text stringlengths 70 351k | source stringclasses 4
values |
|---|---|
<|fim_prefix|>
// file: hyperswitch/crates/drainer/src/health_check.rs | crate: drainer
fn from(error: diesel::result::Error) -> Self {
{
diesel::result::Error::DatabaseError(_, _) => Self::DbError,<|fim_suffix|>
<|fim_middle|>
_ => Self::UnknownError,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/drainer/src/health_check.rs | crate: drainer
use actix_web::{web, Scope};
use router_env::{instrument, logger, tracing};
pub async fn health() -> impl actix_web::Responder {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/drainer/src/health_check.rs | crate: drainer
use std::{collections::HashMap, sync::Arc};
use actix_web::{web, Scope};
use common_utils::{errors::CustomResult, id_type};
use crate::{
connection::pg_connection,
errors::HealthCheckError,
services::{self, log_and_return_error_response, Store},
Settings,
};
pub fn server(conf: Settings, stores: HashMap<id_type::TenantId, Arc<Store>>) -> Scope {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/drainer/src/utils.rs | crate: drainer
use serde::de::Deserialize;
use crate::{
errors, kv, metrics,
stream::{StreamEntries, StreamReadResult},
};
pub(crate) fn deserialize_db_op<'de, D>(deserializer: D) -> Result<kv::DBOperation, D::Error>
where
D: serde::Deserializer<'de>,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/drainer/src/utils.rs | crate: drainer
use std::sync::{atomic, Arc};
use crate::{
errors, kv, metrics,
stream::{StreamEntries, StreamReadResult},
};
pub async fn increment_stream_index(
(index, jobs_picked): (u8, Arc<atomic::AtomicU8>),
total_streams: u8,
) -> u8 {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/drainer/src/utils.rs | crate: drainer
use serde::de::Deserialize;
use crate::{
errors, kv, metrics,
stream::{StreamEntries, StreamReadResult},
};
pub(crate) fn deserialize_db_op<'de, D>(deserializer: D) -> Result<kv::DBOperation, D::Error>
where
D: serde::Deserializer<'de>,
{
{
serde_json::Value::String(str_val) => {
serde_json::from_str(&str_val).map_err(serde::de::Error::custom)
}<|fim_suffix|>
<|fim_middle|>
other => Err(serde::de::Error::custom(format!(
"unexpected data format - expected string got: {other:?}"
))),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/drainer/src/utils.rs | crate: drainer
use serde::de::Deserialize;
use crate::{
errors, kv, metrics,
stream::{StreamEntries, StreamReadResult},
};
pub(crate) fn deserialize_i64<'de, D>(deserializer: D) -> Result<i64, D::Error>
where
D: serde::Deserializer<'de>,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/drainer/src/utils.rs | crate: drainer
use error_stack::report;
use redis_interface as redis;
use crate::{
errors, kv, metrics,
stream::{StreamEntries, StreamReadResult},
};
pub fn parse_stream_entries<'a>(
read_result: &'a StreamReadResult,
stream_name: &str,
) -> errors::DrainerResult<&'a StreamEntries> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/lib.rs | crate: router_derive
use syn::parse_macro_input;
use crate::macros::diesel::DieselEnumMeta;
pub fn flat_struct_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/lib.rs | crate: router_derive
use syn::parse_macro_input;
use crate::macros::diesel::DieselEnumMeta;
pub fn setter(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/lib.rs | crate: router_derive
use syn::parse_macro_input;
use crate::macros::diesel::DieselEnumMeta;
pub fn try_get_enum_variant(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/lib.rs | crate: router_derive
use syn::parse_macro_input;
use crate::macros::diesel::DieselEnumMeta;
pub fn derive_to_encryption_attr(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/lib.rs | crate: router_derive
use crate::macros::diesel::DieselEnumMeta;
pub fn generate_permissions(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router_derive/src/lib.rs | crate: router_derive
use syn::parse_macro_input;
use crate::macros::diesel::DieselEnumMeta;
pub fn try_get_enum_variant(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let input = syn::parse_macro_input!(input as syn::DeriveInput);
macros::try_get_enum::try_get_enum_variant(input)
.unwrap_or_else(|error| error.into_compile_error())
.into()
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/lib.rs | crate: router_derive
use syn::parse_macro_input;
use crate::macros::diesel::DieselEnumMeta;
pub fn validate_config(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/lib.rs | crate: router_derive
use syn::parse_macro_input;
use crate::macros::diesel::DieselEnumMeta;
pub fn polymorphic_schema(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/lib.rs | crate: router_derive
use syn::parse_macro_input;
use crate::macros::diesel::DieselEnumMeta;
pub fn operation_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/lib.rs | crate: router_derive
use syn::parse_macro_input;
use crate::macros::diesel::DieselEnumMeta;
pub fn api_error_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/lib.rs | crate: router_derive
use syn::parse_macro_input;
fn check_if_auth_based_attr_is_present(f: &syn::Field, ident: &str) -> bool {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/lib.rs | crate: router_derive
use syn::parse_macro_input;
use crate::macros::diesel::DieselEnumMeta;
pub fn diesel_enum(
args: proc_macro::TokenStream,
item: proc_macro::TokenStream,
) -> proc_macro::TokenStream {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/lib.rs | crate: router_derive
use syn::parse_macro_input;
use crate::macros::diesel::DieselEnumMeta;
pub fn diesel_enum_derive_string(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/lib.rs | crate: router_derive
use syn::parse_macro_input;
use crate::macros::diesel::DieselEnumMeta;
pub fn diesel_enum_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/lib.rs | crate: router_derive
use syn::parse_macro_input;
use crate::macros::diesel::DieselEnumMeta;
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/operation.rs | crate: router_derive
use std::str::FromStr;
use proc_macro2::{Span, TokenStream};
use quote::{quote, ToTokens};
use strum::IntoEnumIterator;
use syn::{self, parse::Parse, DeriveInput};
use crate::macros::helpers;
pub fn operation_derive_inner(input: DeriveInput) -> syn::Result<proc_macro::TokenStream> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router_derive/src/macros/operation.rs | crate: router_derive
use proc_macro2::{Span, TokenStream};
use syn::{self, parse::Parse, DeriveInput};
fn get_operation_properties(
operation_enums: Vec<OperationsEnumMeta>,
) -> syn::Result<OperationProperties> {
let mut operations = vec![];
let mut flows = vec![];
for operation in operation_enums {
match operation {
OperationsEnumMeta::Operations { value, .. } => {
operations = value;
}
OperationsEnumMeta::Flow { value, .. } => {
flows = value;
}
}
}
if operations.is_empty() {
Err(syn::Error::new(
Span::call_site(),
"atleast one operation must be specitied",
))?;
}
if flows.is_empty() {
Err(syn::Error::new(
Span::call_site(),
"atleast one flow must be specitied",
))?;
}
Ok(OperationProperties { operations, flows })
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/operation.rs | crate: router_derive
use proc_macro2::{Span, TokenStream};
use quote::{quote, ToTokens};
use syn::{self, parse::Parse, DeriveInput};
use crate::macros::helpers;
fn to_ref_function(&self, ident: Derives) -> TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/operation.rs | crate: router_derive
use proc_macro2::{Span, TokenStream};
use quote::{quote, ToTokens};
use syn::{self, parse::Parse, DeriveInput};
use crate::macros::helpers;
fn to_function(&self, ident: Derives) -> TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/operation.rs | crate: router_derive
use proc_macro2::{Span, TokenStream};
use syn::{self, parse::Parse, DeriveInput};
fn get_req_type(ident: Derives) -> syn::Ident {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/operation.rs | crate: router_derive
use syn::{self, parse::Parse, DeriveInput};
fn get_derives(input: syn::parse::ParseStream<'_>) -> syn::Result<Vec<Derives>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/operation.rs | crate: router_derive
use proc_macro2::{Span, TokenStream};
use syn::{self, parse::Parse, DeriveInput};
fn get_operation_properties(
operation_enums: Vec<OperationsEnumMeta>,
) -> syn::Result<OperationProperties> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/operation.rs | crate: router_derive
use syn::{self, parse::Parse, DeriveInput};
use crate::macros::helpers;
fn get_metadata(&self) -> syn::Result<Vec<OperationsEnumMeta>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router_derive/src/macros/operation.rs | crate: router_derive
use syn::{self, parse::Parse, DeriveInput};
fn get_derives(input: syn::parse::ParseStream<'_>) -> syn::Result<Vec<Derives>> {
let lit_str_list = input.parse::<syn::LitStr>()?;
parse_list_string(lit_str_list.value(), "flow")
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/operation.rs | crate: router_derive
use syn::{self, parse::Parse, DeriveInput};
fn get_conversions(input: syn::parse::ParseStream<'_>) -> syn::Result<Vec<Conversion>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/operation.rs | crate: router_derive
use std::str::FromStr;
use proc_macro2::{Span, TokenStream};
use strum::IntoEnumIterator;
use syn::{self, parse::Parse, DeriveInput};
use crate::macros::helpers;
fn parse_list_string<T>(list_string: String, keyword: &str) -> syn::Result<Vec<T>>
where
T: FromStr + IntoEnumIterator + ToString,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/operation.rs | crate: router_derive
use proc_macro2::{Span, TokenStream};
use quote::{quote, ToTokens};
use syn::{self, parse::Parse, DeriveInput};
fn to_ref_operation(
self,
ref_fns: impl Iterator<Item = TokenStream> + Clone,
struct_name: &syn::Ident,
) -> TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/operation.rs | crate: router_derive
use proc_macro2::{Span, TokenStream};
use quote::{quote, ToTokens};
use syn::{self, parse::Parse, DeriveInput};
fn to_operation(
self,
fns: impl Iterator<Item = TokenStream> + Clone,
struct_name: &syn::Ident,
) -> TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router_derive/src/macros/diesel.rs | crate: router_derive
use proc_macro2::{Span, TokenStream};
use quote::{format_ident, quote, ToTokens};
use syn::{parse::Parse, Data, DeriveInput, ItemEnum};
use crate::macros::helpers;
/// Based on the storage type, derive appropriate diesel traits
/// This will add the appropriate #[diesel(sql_type)]
/// Since the `FromSql` and `ToSql` have to be derived for all the enums, this will add the
/// `DieselEnum` derive trait.
pub(crate) fn diesel_enum_attribute_macro(
diesel_enum_meta: DieselEnumMeta,
item: &ItemEnum,
) -> syn::Result<TokenStream> {
let diesel_derives =
quote!(#[derive(diesel::AsExpression, diesel::FromSqlRow, router_derive::DieselEnum) ]);
match diesel_enum_meta {
DieselEnumMeta::StorageTypeEnum {
value: storage_type,
..
} => match storage_type {
StorageType::Text => Ok(quote! {
#diesel_derives
#[diesel(sql_type = ::diesel::sql_types::Text)]
#[storage_type(storage_type = "text")]
#item
}),
StorageType::DbEnum => {
let name = &item.ident;
let type_name = format_ident!("Db{name}");
Ok(quote! {
#diesel_derives
#[diesel(sql_type = #type_name)]
#[storage_type(storage_type= "db_enum")]
#item
})
}
},
}
} | ast_fragments |
// file: hyperswitch/crates/router_derive/src/macros/diesel.rs | crate: router_derive
use proc_macro2::{Span, TokenStream};
use quote::{format_ident, quote, ToTokens};
use syn::{parse::Parse, Data, DeriveInput, ItemEnum};
use crate::macros::helpers;
pub(crate) fn diesel_enum_db_enum_derive_inner(ast: &DeriveInput) -> syn::Result<TokenStream> {
let name = &ast.ident;
let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
match &ast.data {
Data::Enum(_) => (),
_ => return Err(helpers::non_enum_error()),
};
let struct_name = format_ident!("Db{name}");
let type_name = format!("{name}");
Ok(quote! {
#[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::diesel::QueryId, ::diesel::SqlType)]
#[diesel(postgres_type(name = #type_name))]
pub struct #struct_name;
#[automatically_derived]
impl #impl_generics ::diesel::serialize::ToSql<#struct_name, ::diesel::pg::Pg> for #name #ty_generics
#where_clause
{
fn to_sql<'b>(&'b self, out: &mut ::diesel::serialize::Output<'b, '_, ::diesel::pg::Pg>) -> ::diesel::serialize::Result {
use ::std::io::Write;
out.write_all(self.to_string().as_bytes())?;
Ok(::diesel::serialize::IsNull::No)
}
}
#[automatically_derived]
impl #impl_generics ::diesel::deserialize::FromSql<#struct_name, ::diesel::pg::Pg> for #name #ty_generics
#where_clause
{
fn from_sql(value: ::diesel::pg::PgValue) -> diesel::deserialize::Result<Self> {
use ::core::str::FromStr;
Self::from_str(::core::str::from_utf8(value.as_bytes())?)
.map_err(|_| "Unrecognized enum variant".into())
}
}
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/diesel.rs | crate: router_derive
use proc_macro2::{Span, TokenStream};
use quote::{format_ident, quote, ToTokens};
use syn::{parse::Parse, Data, DeriveInput, ItemEnum};
use crate::macros::helpers;
pub(crate) fn diesel_enum_text_derive_inner(ast: &DeriveInput) -> syn::Result<TokenStream> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/diesel.rs | crate: router_derive
use proc_macro2::{Span, TokenStream};
use syn::{parse::Parse, Data, DeriveInput, ItemEnum};
use crate::macros::helpers;
pub(crate) fn diesel_enum_derive_inner(ast: &DeriveInput) -> syn::Result<TokenStream> {
{
StorageType::Text => diesel_enum_text_derive_inner(ast),<|fim_suffix|>
<|fim_middle|>
StorageType::DbEnum => diesel_enum_db_enum_derive_inner(ast),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/diesel.rs | crate: router_derive
use proc_macro2::{Span, TokenStream};
use quote::{format_ident, quote, ToTokens};
use syn::{parse::Parse, Data, DeriveInput, ItemEnum};
use crate::macros::helpers;
pub(crate) fn diesel_enum_db_enum_derive_inner(ast: &DeriveInput) -> syn::Result<TokenStream> {
{
Data::Enum(_) => (),<|fim_suffix|>
<|fim_middle|>
_ => return Err(helpers::non_enum_error()),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/diesel.rs | crate: router_derive
use proc_macro2::{Span, TokenStream};
use syn::{parse::Parse, Data, DeriveInput, ItemEnum};
use crate::macros::helpers;
pub(crate) fn diesel_enum_derive_inner(ast: &DeriveInput) -> syn::Result<TokenStream> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/diesel.rs | crate: router_derive
use syn::{parse::Parse, Data, DeriveInput, ItemEnum};
use crate::macros::helpers;
fn get_metadata(&self) -> syn::Result<Vec<DieselEnumMeta>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/diesel.rs | crate: router_derive
use proc_macro2::{Span, TokenStream};
fn to_tokens(&self, tokens: &mut TokenStream) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/diesel.rs | crate: router_derive
use syn::{parse::Parse, Data, DeriveInput, ItemEnum};
fn parse(input: syn::parse::ParseStream<'_>) -> syn::Result<Self> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/diesel.rs | crate: router_derive
pub fn get_storage_type(&self) -> &StorageType {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/helpers.rs | crate: router_derive
use proc_macro2::Span;
use syn::{parse::Parse, punctuated::Punctuated, spanned::Spanned, Attribute, Token};
pub(super) fn syn_error(span: Span, message: &str) -> syn::Error {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/helpers.rs | crate: router_derive
use proc_macro2::Span;
use syn::{parse::Parse, punctuated::Punctuated, spanned::Spanned, Attribute, Token};
pub(super) fn get_struct_fields(
data: syn::Data,
) -> syn::Result<Punctuated<syn::Field, syn::token::Comma>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/helpers.rs | crate: router_derive
use syn::{parse::Parse, punctuated::Punctuated, spanned::Spanned, Attribute, Token};
pub(super) fn get_metadata_inner<'a, T: Parse + Spanned>(
ident: &str,
attrs: impl IntoIterator<Item = &'a Attribute>,
) -> syn::Result<Vec<T>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/helpers.rs | crate: router_derive
/// Get all the variants of a enum in the form of a string
pub fn get_possible_values_for_enum<T>() -> String
where
T: strum::IntoEnumIterator + ToString,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router_derive/src/macros/helpers.rs | crate: router_derive
use proc_macro2::Span;
use syn::{parse::Parse, punctuated::Punctuated, spanned::Spanned, Attribute, Token};
pub(super) fn syn_error(span: Span, message: &str) -> syn::Error {
syn::Error::new(span, message)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/helpers.rs | crate: router_derive
use quote::ToTokens;
use syn::{parse::Parse, punctuated::Punctuated, spanned::Spanned, Attribute, Token};
pub(super) fn occurrence_error<T: ToTokens>(
first_keyword: T,
second_keyword: T,
attr: &str,
) -> syn::Error {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/helpers.rs | crate: router_derive
use proc_macro2::Span;
use syn::{parse::Parse, punctuated::Punctuated, spanned::Spanned, Attribute, Token};
pub fn non_enum_error() -> syn::Error {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/to_encryptable.rs | crate: router_derive
use std::iter::Iterator;
use quote::{format_ident, quote};
use syn::{parse::Parse, punctuated::Punctuated, token::Comma, Field, Ident, Type as SynType};
use crate::macros::{helpers::get_struct_fields, misc::get_field_type};
/// Generates the ToEncryptable trait implementation
fn generate_impls(
self,
gen1: proc_macro2::TokenStream,
gen2: proc_macro2::TokenStream,
gen3: proc_macro2::TokenStream,
impl_st: proc_macro2::TokenStream,
inner: &[Field],
) -> proc_macro2::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/to_encryptable.rs | crate: router_derive
use std::iter::Iterator;
use quote::{format_ident, quote};
use syn::{parse::Parse, punctuated::Punctuated, token::Comma, Field, Ident, Type as SynType};
use crate::macros::{helpers::get_struct_fields, misc::get_field_type};
/// Generates the fields for temporary structs which consists of the fields that should be
/// encrypted/decrypted
fn generate_struct_fields(self, fields: &[(Field, Ident)]) -> Vec<proc_macro2::TokenStream> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/to_encryptable.rs | crate: router_derive
use syn::{parse::Parse, punctuated::Punctuated, token::Comma, Field, Ident, Type as SynType};
/// This function returns the inner most type recursively
/// For example:
///
/// In the case of `Encryptable<Secret<String>>> this returns String
fn get_inner_most_type(ty: SynType) -> syn::Result<Ident> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/to_encryptable.rs | crate: router_derive
use std::iter::Iterator;
use quote::{format_ident, quote};
use syn::{parse::Parse, punctuated::Punctuated, token::Comma, Field, Ident, Type as SynType};
use crate::macros::{helpers::get_struct_fields, misc::get_field_type};
/// This function generates the temporary struct and ToEncryptable impls for the temporary structs
fn generate_to_encryptable(
struct_name: Ident,
fields: Vec<Field>,
) -> syn::Result<proc_macro2::TokenStream> {
{
StructType::FromRequest => {
let decrypted_name = format_ident!("Decrypted{}", struct_name);
(
quote! { #decrypted_name },
quote! { Secret<#provided_ty> },
quote! { Secret<#provided_ty> },
)
}<|fim_suffix|>
<|fim_middle|>
_ => (quote! {}, quote! {}, quote! {}),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/to_encryptable.rs | crate: router_derive
use std::iter::Iterator;
use quote::{format_ident, quote};
use syn::{parse::Parse, punctuated::Punctuated, token::Comma, Field, Ident, Type as SynType};
use crate::macros::{helpers::get_struct_fields, misc::get_field_type};
/// Generates the fields for temporary structs which consists of the fields that should be
/// encrypted/decrypted
fn generate_struct_fields(self, fields: &[(Field, Ident)]) -> Vec<proc_macro2::TokenStream> {
{
(Self::Encrypted, true) => quote! { pub #ident: Option<Encryption> },<|fim_suffix|>
<|fim_middle|>
(Self::Updated, _) => quote! { pub #ident: Option<Secret<#inner_ty>> },
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/to_encryptable.rs | crate: router_derive
use syn::{parse::Parse, punctuated::Punctuated, token::Comma, Field, Ident, Type as SynType};
use crate::macros::{helpers::get_struct_fields, misc::get_field_type};
pub fn derive_to_encryption(
input: syn::DeriveInput,
) -> Result<proc_macro2::TokenStream, syn::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/to_encryptable.rs | crate: router_derive
use std::iter::Iterator;
use syn::{parse::Parse, punctuated::Punctuated, token::Comma, Field, Ident, Type as SynType};
/// This function returns the inner most type of a field
fn get_field_and_inner_types(fields: &[Field]) -> Vec<(Field, Ident)> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/to_encryptable.rs | crate: router_derive
use std::iter::Iterator;
use syn::{parse::Parse, punctuated::Punctuated, token::Comma, Field, Ident, Type as SynType};
/// This returns the field which implement #[encrypt] attribute
fn get_encryptable_fields(fields: Punctuated<Field, Comma>) -> Vec<Field> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/to_encryptable.rs | crate: router_derive
use syn::{parse::Parse, punctuated::Punctuated, token::Comma, Field, Ident, Type as SynType};
fn get_inner_type_recursive(path: syn::TypePath) -> syn::Result<syn::TypePath> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/to_encryptable.rs | crate: router_derive
use syn::{parse::Parse, punctuated::Punctuated, token::Comma, Field, Ident, Type as SynType};
fn get_inner_type(path: &syn::TypePath) -> syn::Result<syn::TypePath> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router_derive/src/macros/to_encryptable.rs | crate: router_derive
use std::iter::Iterator;
use syn::{parse::Parse, punctuated::Punctuated, token::Comma, Field, Ident, Type as SynType};
fn get_encryption_ty_meta(field: &Field) -> Option<FieldMeta> {
let attrs = &field.attrs;
attrs
.iter()
.flat_map(|s| s.parse_args::<FieldMeta>())
.find(|s| s._meta_type.eq("ty"))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/to_encryptable.rs | crate: router_derive
fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/to_encryptable.rs | crate: router_derive
use std::iter::Iterator;
use quote::{format_ident, quote};
use syn::{parse::Parse, punctuated::Punctuated, token::Comma, Field, Ident, Type as SynType};
use crate::macros::{helpers::get_struct_fields, misc::get_field_type};
/// This function generates the temporary struct and ToEncryptable impls for the temporary structs
fn generate_to_encryptable(
struct_name: Ident,
fields: Vec<Field>,
) -> syn::Result<proc_macro2::TokenStream> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/api_error/helpers.rs | crate: router_derive
use syn::{
parse::Parse, spanned::Spanned, DeriveInput, Field, Fields, LitStr, Token, TypePath, Variant,
};
use crate::macros::helpers::{get_metadata_inner, occurrence_error};
fn get_variant_properties(&self) -> syn::Result<ErrorVariantProperties> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/api_error/helpers.rs | crate: router_derive
use syn::{
parse::Parse, spanned::Spanned, DeriveInput, Field, Fields, LitStr, Token, TypePath, Variant,
};
use crate::macros::helpers::{get_metadata_inner, occurrence_error};
fn get_type_properties(&self) -> syn::Result<ErrorTypeProperties> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/api_error/helpers.rs | crate: router_derive
use syn::{
parse::Parse, spanned::Spanned, DeriveInput, Field, Fields, LitStr, Token, TypePath, Variant,
};
fn missing_attribute_error(variant: &Variant, attr: &str) -> syn::Error {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/api_error/helpers.rs | crate: router_derive
use proc_macro2::TokenStream;
fn to_tokens(&self, tokens: &mut TokenStream) {
{
Self::ErrorType { keyword, .. } => keyword.to_tokens(tokens),<|fim_suffix|>
<|fim_middle|>
Self::Ignore { keyword, .. } => keyword.to_tokens(tokens),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/api_error/helpers.rs | crate: router_derive
use syn::{
parse::Parse, spanned::Spanned, DeriveInput, Field, Fields, LitStr, Token, TypePath, Variant,
};
/// Get all the fields not used in the error message.
pub(super) fn get_unused_fields(
fields: &Fields,
message: &str,
ignore: &std::collections::HashSet<String>,
) -> Vec<Field> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/api_error/helpers.rs | crate: router_derive
use syn::{
parse::Parse, spanned::Spanned, DeriveInput, Field, Fields, LitStr, Token, TypePath, Variant,
};
pub(super) fn check_missing_attributes(
variant: &Variant,
variant_properties: &ErrorVariantProperties,
) -> syn::Result<()> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router_derive/src/macros/api_error/helpers.rs | crate: router_derive
use syn::{
parse::Parse, spanned::Spanned, DeriveInput, Field, Fields, LitStr, Token, TypePath, Variant,
};
fn missing_attribute_error(variant: &Variant, attr: &str) -> syn::Error {
syn::Error::new_spanned(variant, format!("{attr} must be specified"))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router_derive/src/macros/api_error/helpers.rs | crate: router_derive
use syn::{
parse::Parse, spanned::Spanned, DeriveInput, Field, Fields, LitStr, Token, TypePath, Variant,
};
use crate::macros::helpers::{get_metadata_inner, occurrence_error};
fn get_metadata(&self) -> syn::Result<Vec<VariantMeta>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router_derive/src/macros/api_error/helpers.rs | crate: router_derive
use syn::{
parse::Parse, spanned::Spanned, DeriveInput, Field, Fields, LitStr, Token, TypePath, Variant,
};
use crate::macros::helpers::{get_metadata_inner, occurrence_error};
fn get_metadata(&self) -> syn::Result<Vec<EnumMeta>> {
get_metadata_inner("error", &self.attrs)
} | ast_fragments |
// file: hyperswitch/crates/hsdev/src/main.rs | crate: hsdev
use diesel::{pg::PgConnection, Connection};
use diesel_migrations::{FileBasedMigrations, HarnessWithOutput, MigrationHarness};
use toml::Value;
fn main() {
let args = Args::parse();
let toml_file = &args.toml_file;
let table_name = &args.toml_table;
let toml_contents = match std::fs::read_to_string(toml_file) {
Ok(contents) => contents,
Err(e) => {
eprintln!("Error reading TOML file: {}", e);
return;
}
};
let toml_data: Value = match toml_contents.parse() {
Ok(data) => data,
Err(e) => {
eprintln!("Error parsing TOML file: {}", e);
return;
}
};
let table = get_toml_table(table_name, &toml_data);
let input = match input_file::InputData::read(table) {
Ok(data) => data,
Err(e) => {
eprintln!("Error loading TOML file: {}", e);
return;
}
};
let db_url = input.postgres_url();
println!("Attempting to connect to {}", db_url);
let mut conn = match PgConnection::establish(&db_url) {
Ok(value) => value,
Err(_) => {
eprintln!("Unable to establish database connection");
return;
}
};
let migrations = match FileBasedMigrations::find_migrations_directory() {
Ok(value) => value,
Err(_) => {
eprintln!("Could not find migrations directory");
return;
}
};
let mut harness = HarnessWithOutput::write_to_stdout(&mut conn);
match harness.run_pending_migrations(migrations) {
Ok(_) => println!("Successfully ran migrations"),
Err(_) => eprintln!("Couldn't run migrations"),
};
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hsdev/src/main.rs | crate: hsdev
use toml::Value;
fn test_input_file() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hsdev/src/main.rs | crate: hsdev
use toml::Value;
fn test_given_toml() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hsdev/src/main.rs | crate: hsdev
use toml::Value;
fn test_input_file() {
let toml_str = r#"username = "db_user"
password = "db_pass"
dbname = "db_name"
host = "localhost"
port = 5432"#;
let toml_value = Value::from_str(toml_str);
assert!(toml_value.is_ok());
let toml_value = toml_value.unwrap();
let toml_table = InputData::read(&toml_value);
assert!(toml_table.is_ok());
let toml_table = toml_table.unwrap();
let db_url = toml_table.postgres_url();
assert_eq!("postgres://db_user:db_pass@localhost:5432/db_name", db_url);
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hsdev/src/main.rs | crate: hsdev
use toml::Value;
pub fn get_toml_table<'a>(table_name: &'a str, toml_data: &'a Value) -> &'a Value {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/benches/backends.rs | crate: euclid
use common_utils::types::MinorUnit;
use euclid::{
backend::{inputs, EuclidBackend, InterpreterBackend, VirInterpreterBackend},
enums,
frontend::ast::{self, parser},
types::DummyOutput,
};
fn get_program_data() -> (ast::Program<DummyOutput>, inputs::BackendInput) {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/benches/backends.rs | crate: euclid
use criterion::{black_box, criterion_group, criterion_main, Criterion};
use euclid::{
backend::{inputs, EuclidBackend, InterpreterBackend, VirInterpreterBackend},
enums,
frontend::ast::{self, parser},
types::DummyOutput,
};
fn interpreter_vs_jit_vs_vir_interpreter(c: &mut Criterion) {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/euclid/benches/backends.rs | crate: euclid
use criterion::{black_box, criterion_group, criterion_main, Criterion};
use euclid::{
backend::{inputs, EuclidBackend, InterpreterBackend, VirInterpreterBackend},
enums,
frontend::ast::{self, parser},
types::DummyOutput,
};
fn interpreter_vs_jit_vs_vir_interpreter(c: &mut Criterion) {
let (program, binputs) = get_program_data();
let interp_b = InterpreterBackend::with_program(program.clone()).expect("Interpreter backend");
let vir_interp_b =
VirInterpreterBackend::with_program(program).expect("Vir Interpreter Backend");
c.bench_function("Raw Interpreter Backend", |b| {
b.iter(|| {
interp_b
.execute(binputs.clone())
.expect("Interpreter EXECUTION");
});
});
c.bench_function("Valued Interpreter Backend", |b| {
b.iter(|| {
vir_interp_b
.execute(binputs.clone())
.expect("Vir Interpreter execution");
})
});
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/types.rs | crate: euclid
pub type Metadata = std::collections::HashMap<String, serde_json::Value>;
pub fn fits(&self, other: &Self) -> bool {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/types.rs | crate: euclid
use common_utils::types::MinorUnit;
fn test_num_value_fits_less_than() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/types.rs | crate: euclid
use common_utils::types::MinorUnit;
fn test_num_value_fits_greater_than() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/euclid/src/types.rs | crate: euclid
use common_utils::types::MinorUnit;
fn test_num_value_fits_less_than() {
let val1 = NumValue {
number: MinorUnit::new(30),
refinement: Some(NumValueRefinement::LessThan),
};
let val2 = NumValue {
number: MinorUnit::new(10),
refinement: Some(NumValueRefinement::LessThan),
};
assert!(val1.fits(&val2));
} | ast_fragments |
// file: hyperswitch/crates/euclid/src/types.rs | crate: euclid
use common_utils::types::MinorUnit;
fn test_num_value_fits_greater_than() {
let val1 = NumValue {
number: MinorUnit::new(10),
refinement: Some(NumValueRefinement::GreaterThan),
};
let val2 = NumValue {
number: MinorUnit::new(30),
refinement: Some(NumValueRefinement::GreaterThan),
};
assert!(val1.fits(&val2))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/types.rs | crate: euclid
pub type Metadata = std::collections::HashMap<String, serde_json::Value>;
pub fn get_key(&self) -> EuclidKey {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/types.rs | crate: euclid
pub type Metadata = std::collections::HashMap<String, serde_json::Value>;
pub fn get_num_value(&self) -> Option<NumValue> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/types.rs | crate: euclid
fn from(value: NumValueRefinement) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/types.rs | crate: euclid
use crate::{
dssa::types::EuclidAnalysable,
enums,
frontend::{
ast,
dir::{DirKeyKind, DirValue, EuclidDirFilter},
},
};
fn from(comp_type: ast::ComparisonType) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/euclid/src/types.rs | crate: euclid
pub type Metadata = std::collections::HashMap<String, serde_json::Value>;
pub fn key_type(&self) -> DataType {
match self {
Self::PaymentMethod => DataType::EnumVariant,
Self::CardBin => DataType::StrValue,
Self::Metadata => DataType::MetadataValue,
Self::PaymentMethodType => DataType::EnumVariant,
Self::CardNetwork => DataType::EnumVariant,
Self::AuthenticationType => DataType::EnumVariant,
Self::CaptureMethod => DataType::EnumVariant,
Self::PaymentAmount => DataType::Number,
Self::PaymentCurrency => DataType::EnumVariant,
Self::BusinessCountry => DataType::EnumVariant,
Self::BillingCountry => DataType::EnumVariant,
Self::MandateType => DataType::EnumVariant,
Self::MandateAcceptanceType => DataType::EnumVariant,
Self::PaymentType => DataType::EnumVariant,
Self::BusinessLabel => DataType::StrValue,
Self::SetupFutureUsage => DataType::EnumVariant,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/types.rs | crate: euclid
use crate::{
dssa::types::EuclidAnalysable,
enums,
frontend::{
ast,
dir::{DirKeyKind, DirValue, EuclidDirFilter},
},
};
pub type Metadata = std::collections::HashMap<String, serde_json::Value>;
fn get_dir_value_for_analysis(&self, rule_name: String) -> Vec<(DirValue, Metadata)> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/frontend/dir.rs | crate: euclid
fn test_consistent_dir_key_naming() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/frontend/dir.rs | crate: euclid
pub type DirIfCondition = Vec<DirComparison>;
pub fn check_equality(v1: &Self, v2: &Self) -> bool {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/frontend/dir.rs | crate: euclid
use crate::{enums as euclid_enums, frontend::ast, types};
pub type DirIfCondition = Vec<DirComparison>;
pub fn get_metadata_val(&self) -> Option<types::MetadataValue> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/euclid/src/frontend/dir.rs | crate: euclid
pub type DirIfCondition = Vec<DirComparison>;
pub fn get_key(&self) -> DirKey {
let (kind, data) = match self {
Self::PaymentMethod(_) => (DirKeyKind::PaymentMethod, None),
Self::CardBin(_) => (DirKeyKind::CardBin, None),
Self::RewardType(_) => (DirKeyKind::RewardType, None),
Self::BusinessCountry(_) => (DirKeyKind::BusinessCountry, None),
Self::BillingCountry(_) => (DirKeyKind::BillingCountry, None),
Self::BankTransferType(_) => (DirKeyKind::BankTransferType, None),
Self::UpiType(_) => (DirKeyKind::UpiType, None),
Self::CardType(_) => (DirKeyKind::CardType, None),
Self::CardNetwork(_) => (DirKeyKind::CardNetwork, None),
Self::MetaData(met) => (DirKeyKind::MetaData, Some(met.key.clone())),
Self::PayLaterType(_) => (DirKeyKind::PayLaterType, None),
Self::WalletType(_) => (DirKeyKind::WalletType, None),
Self::BankRedirectType(_) => (DirKeyKind::BankRedirectType, None),
Self::CryptoType(_) => (DirKeyKind::CryptoType, None),
Self::AuthenticationType(_) => (DirKeyKind::AuthenticationType, None),
Self::CaptureMethod(_) => (DirKeyKind::CaptureMethod, None),
Self::PaymentAmount(_) => (DirKeyKind::PaymentAmount, None),
Self::PaymentCurrency(_) => (DirKeyKind::PaymentCurrency, None),
Self::Connector(_) => (DirKeyKind::Connector, None),
Self::BankDebitType(_) => (DirKeyKind::BankDebitType, None),
Self::MandateAcceptanceType(_) => (DirKeyKind::MandateAcceptanceType, None),
Self::MandateType(_) => (DirKeyKind::MandateType, None),
Self::PaymentType(_) => (DirKeyKind::PaymentType, None),
Self::BusinessLabel(_) => (DirKeyKind::BusinessLabel, None),
Self::SetupFutureUsage(_) => (DirKeyKind::SetupFutureUsage, None),
Self::CardRedirectType(_) => (DirKeyKind::CardRedirectType, None),
Self::VoucherType(_) => (DirKeyKind::VoucherType, None),
Self::GiftCardType(_) => (DirKeyKind::GiftCardType, None),
Self::RealTimePaymentType(_) => (DirKeyKind::RealTimePaymentType, None),
Self::OpenBankingType(_) => (DirKeyKind::OpenBankingType, None),
Self::MobilePaymentType(_) => (DirKeyKind::MobilePaymentType, None),
};
DirKey::new(kind, data)
} | ast_fragments |
// file: hyperswitch/crates/euclid/src/frontend/dir.rs | crate: euclid
use crate::{enums as euclid_enums, frontend::ast, types};
pub type DirIfCondition = Vec<DirComparison>;
pub fn get_type(&self) -> types::DataType {
match self {
Self::PaymentMethod => types::DataType::EnumVariant,
Self::CardBin => types::DataType::StrValue,
Self::CardType => types::DataType::EnumVariant,
Self::CardNetwork => types::DataType::EnumVariant,
Self::MetaData => types::DataType::MetadataValue,
Self::MandateType => types::DataType::EnumVariant,
Self::PaymentType => types::DataType::EnumVariant,
Self::MandateAcceptanceType => types::DataType::EnumVariant,
Self::PayLaterType => types::DataType::EnumVariant,
Self::WalletType => types::DataType::EnumVariant,
Self::UpiType => types::DataType::EnumVariant,
Self::VoucherType => types::DataType::EnumVariant,
Self::BankTransferType => types::DataType::EnumVariant,
Self::GiftCardType => types::DataType::EnumVariant,
Self::BankRedirectType => types::DataType::EnumVariant,
Self::CryptoType => types::DataType::EnumVariant,
Self::RewardType => types::DataType::EnumVariant,
Self::PaymentAmount => types::DataType::Number,
Self::PaymentCurrency => types::DataType::EnumVariant,
Self::AuthenticationType => types::DataType::EnumVariant,
Self::CaptureMethod => types::DataType::EnumVariant,
Self::BusinessCountry => types::DataType::EnumVariant,
Self::BillingCountry => types::DataType::EnumVariant,
Self::Connector => types::DataType::EnumVariant,
Self::BankDebitType => types::DataType::EnumVariant,
Self::BusinessLabel => types::DataType::StrValue,
Self::SetupFutureUsage => types::DataType::EnumVariant,
Self::CardRedirectType => types::DataType::EnumVariant,
Self::RealTimePaymentType => types::DataType::EnumVariant,
Self::OpenBankingType => types::DataType::EnumVariant,
Self::MobilePaymentType => types::DataType::EnumVariant,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/frontend/dir.rs | crate: euclid
use strum::IntoEnumIterator;
use crate::{enums as euclid_enums, frontend::ast, types};
fn test_not_allowed_dir_keys() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.