text stringlengths 70 351k | source stringclasses 4
values |
|---|---|
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/bamboraapac/transformers.rs | crate: hyperswitch_connectors | connector: bamboraapac
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_request_types::{
PaymentsAuthorizeData, PaymentsCaptureData, PaymentsSyncData, RefundsData, ResponseId,
SetupMandateRequestData,
},
router_response_types::{MandateReference, PaymentsResponseData, RefundsResponseData},
types,
};
use hyperswitch_interfaces::{
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
errors,
};
use crate::{
types::ResponseRouterData,
utils::{self, CardData as _, PaymentsAuthorizeRequestData, RouterData as _},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
BamboraapacCaptureResponse,
PaymentsCaptureData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/bamboraapac/transformers.rs | crate: hyperswitch_connectors | connector: bamboraapac
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_request_types::{
PaymentsAuthorizeData, PaymentsCaptureData, PaymentsSyncData, RefundsData, ResponseId,
SetupMandateRequestData,
},
router_response_types::{MandateReference, PaymentsResponseData, RefundsResponseData},
types,
};
use hyperswitch_interfaces::{
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
errors,
};
use crate::{
types::ResponseRouterData,
utils::{self, CardData as _, PaymentsAuthorizeRequestData, RouterData as _},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
BamboraapacPaymentsResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/amazonpay/transformers.rs | crate: hyperswitch_connectors | connector: amazonpay
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
fn try_from(
item: &AmazonpayRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
{
PaymentMethodData::Card(req_card) => {
let card = AmazonpayCard {
number: req_card.card_number,
expiry_month: req_card.card_exp_month,
expiry_year: req_card.card_exp_year,
cvc: req_card.card_cvc,
complete: item.router_data.request.is_auto_capture()?,
};
Ok(Self {
amount: item.amount.clone(),
card,
})
}<|fim_suffix|>
<|fim_middle|>
_ => Err(errors::ConnectorError::NotImplemented("Payment method".to_string()).into()),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/amazonpay/transformers.rs | crate: hyperswitch_connectors | connector: amazonpay
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
fn try_from(item: &AmazonpayRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/amazonpay/transformers.rs | crate: hyperswitch_connectors | connector: amazonpay
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::PaymentsAuthorizeRequestData,
};
fn try_from(
item: ResponseRouterData<F, AmazonpayPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/amazonpay/transformers.rs | crate: hyperswitch_connectors | connector: amazonpay
fn from(item: AmazonpayPaymentStatus) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/amazonpay/transformers.rs | crate: hyperswitch_connectors | connector: amazonpay
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
fn try_from(
item: &AmazonpayRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/benches/encryption_bench.rs | crate: benches
use cripta::{
app::AppState,
config,
core::{crypto::custodian::Custodian, datakey::create::generate_and_create_data_key},
multitenancy::TenantId,
types::{
core::{DecryptedData, DecryptedDataGroup, Identifier},
method::EncryptionType,
requests::CreateDataKeyRequest,
},
};
use criterion::{black_box, criterion_group, criterion_main, Criterion};
use tokio::runtime::Runtime;
pub fn criterion_batch_data_encryption_decryption(c: &mut Criterion) {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/benches/encryption_bench.rs | crate: benches
use cripta::{
app::AppState,
config,
core::{crypto::custodian::Custodian, datakey::create::generate_and_create_data_key},
multitenancy::TenantId,
types::{
core::{DecryptedData, DecryptedDataGroup, Identifier},
method::EncryptionType,
requests::CreateDataKeyRequest,
},
};
use rustc_hash::FxHashMap;
fn generate_batch_data(size: u64) -> DecryptedDataGroup {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch-encryption-service/benches/encryption_bench.rs | crate: benches
use cripta::{
app::AppState,
config,
core::{crypto::custodian::Custodian, datakey::create::generate_and_create_data_key},
multitenancy::TenantId,
types::{
core::{DecryptedData, DecryptedDataGroup, Identifier},
method::EncryptionType,
requests::CreateDataKeyRequest,
},
};
use rustc_hash::FxHashMap;
fn generate_batch_data(size: u64) -> DecryptedDataGroup {
let mut batch_map = FxHashMap::default();
for i in 0..size {
let key = format!("key_{}", i);
let value = DecryptedData::from_data(
(0..1024)
.map(|_| rand::random::<u8>())
.collect::<Vec<_>>()
.into(),
);
batch_map.insert(key, value);
}
DecryptedDataGroup(batch_map)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/benches/encryption_bench.rs | crate: benches
use cripta::{
app::AppState,
config,
core::{crypto::custodian::Custodian, datakey::create::generate_and_create_data_key},
multitenancy::TenantId,
types::{
core::{DecryptedData, DecryptedDataGroup, Identifier},
method::EncryptionType,
requests::CreateDataKeyRequest,
},
};
use criterion::{black_box, criterion_group, criterion_main, Criterion};
use tokio::runtime::Runtime;
pub fn criterion_data_encryption_decryption(c: &mut Criterion) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/types/method.rs | crate: src
use crate::{
core::{custodian::Custodian, DataDecrypter, DataEncrypter},
errors,
multitenancy::TenantState,
types::Identifier,
};
pub async fn encrypt(
self,
state: &TenantState,
identifier: &Identifier,
custodian: Custodian,
) -> errors::CustomResult<DecryptionType, errors::CryptoError> {
{
Self::Single(data) => {
DecryptionType::Single(data.encrypt(state, identifier, custodian).await?)
}<|fim_suffix|>
<|fim_middle|>
Self::Batch(data) => {
DecryptionType::Batch(data.encrypt(state, identifier, custodian).await?)
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/types/method.rs | crate: src
use crate::{
core::{custodian::Custodian, DataDecrypter, DataEncrypter},
errors,
multitenancy::TenantState,
types::Identifier,
};
pub async fn encrypt(
self,
state: &TenantState,
identifier: &Identifier,
custodian: Custodian,
) -> errors::CustomResult<DecryptionType, errors::CryptoError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/types/method.rs | crate: src
use crate::{
core::{custodian::Custodian, DataDecrypter, DataEncrypter},
errors,
multitenancy::TenantState,
types::Identifier,
};
pub async fn decrypt(
self,
state: &TenantState,
identifier: &Identifier,
custodian: Custodian,
) -> errors::CustomResult<EncryptionType, errors::CryptoError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/types/core/key.rs | crate: src
use crate::{
core::KeyDecrypter,
crypto::Source,
env::observability as logger,
errors::{self, SwitchError},
multitenancy::TenantState,
storage::{cache, dek::DataKeyStorageInterface},
types::Identifier,
};
use rustc_hash::{FxHashMap, FxHashSet};
pub async fn get_multiple_keys(
state: &TenantState,
identifier: &Identifier,
version: FxHashSet<Version>,
) -> errors::CustomResult<FxHashMap<Version, Self>, errors::DatabaseError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/types/core/key.rs | crate: src
{
type Row = i32;
fn build(row: Self::Row) -> deserialize::Result<Self> {
Ok(Self::from(row))
}
}
impl<'frame, 'metadata> DeserializeValue<'frame, 'metadata> for Version {
fn type_check(typ: &ColumnType<'_>) -> Result<(), scylla::deserialize::TypeCheckError> {
i32::type_check(typ)
}
fn deserialize(
typ: &'metadata ColumnType<'metadata>,
cql_val: Option<FrameSlice<'frame>>,
) -> Result<Self, scylla::deserialize::DeserializationError> {
let int = <i32 as DeserializeValue<'frame, 'metadata>>::deserialize(typ, cql_val)?;
Ok(Self::from(int))
}
}
#[cfg(test)]
mod tests {
use super::*;
fn deserialize(
typ: &'metadata ColumnType<'metadata>,
cql_val: Option<FrameSlice<'frame>>,
) -> Result<Self, scylla::deserialize::DeserializationError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/types/core/key.rs | crate: src
#[derive(AsExpression, Eq, PartialEq, Debug, Clone, Copy, Hash)]
#[diesel(sql_type = diesel::sql_types::Integer)]
pub struct Version(i32);
impl Display for Version {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(&format!("v{}", self.0))
}
}
impl SerializeValue for Version {
fn serialize<'b>(
&self,
_typ: &ColumnType<'_>,
writer: scylla::serialize::writers::CellWriter<'b>,
) -> Result<
scylla::serialize::writers::WrittenCellProof<'b>,
scylla::serialize::SerializationError,
> {
// Skipping type check here since `Version` is a domain type and the type checking would be
// done during the construction of `Version` type.
let proof = writer
.set_value(self.0.to_be_bytes().as_slice())
.map_err(|err| {
fn serialize<'b>(
&self,
_typ: &ColumnType<'_>,
writer: scylla::serialize::writers::CellWriter<'b>,
) -> Result<
scylla::serialize::writers::WrittenCellProof<'b>,
scylla::serialize::SerializationError,
> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/types/core/key.rs | crate: src
use diesel::{
backend::Backend,
deserialize::{self, FromSql},
expression::AsExpression,
serialize::ToSql,
sql_types, Queryable,
};
use masking::{Deserialize, Serialize};
use scylla::{
deserialize::{DeserializeValue, FrameSlice},
frame::response::result::ColumnType,
};
use serde::de::{self, Deserializer, Unexpected, Visitor};
fn test_version_deserialize() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch-encryption-service/src/types/core/key.rs | crate: src
use crate::{
core::KeyDecrypter,
crypto::Source,
env::observability as logger,
errors::{self, SwitchError},
multitenancy::TenantState,
storage::{cache, dek::DataKeyStorageInterface},
types::Identifier,
};
use diesel::{
backend::Backend,
deserialize::{self, FromSql},
expression::AsExpression,
serialize::ToSql,
sql_types, Queryable,
};
use charybdis::scylla::SerializeValue;
use scylla::{
deserialize::{DeserializeValue, FrameSlice},
frame::response::result::ColumnType,
};
fn deserialize(
typ: &'metadata ColumnType<'metadata>,
cql_val: Option<FrameSlice<'frame>>,
) -> Result<Self, scylla::deserialize::DeserializationError> {
let int = <i32 as DeserializeValue<'frame, 'metadata>>::deserialize(typ, cql_val)?;
Ok(Self::from(int))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/types/core/key.rs | crate: src
use diesel::{
backend::Backend,
deserialize::{self, FromSql},
expression::AsExpression,
serialize::ToSql,
sql_types, Queryable,
};
use charybdis::scylla::SerializeValue;
use scylla::{
deserialize::{DeserializeValue, FrameSlice},
frame::response::result::ColumnType,
};
fn type_check(typ: &ColumnType<'_>) -> Result<(), scylla::deserialize::TypeCheckError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/types/core/key.rs | crate: src
fn from(v: i32) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/types/core/key.rs | crate: src
use crate::{
core::KeyDecrypter,
crypto::Source,
env::observability as logger,
errors::{self, SwitchError},
multitenancy::TenantState,
storage::{cache, dek::DataKeyStorageInterface},
types::Identifier,
};
use diesel::{
backend::Backend,
deserialize::{self, FromSql},
expression::AsExpression,
serialize::ToSql,
sql_types, Queryable,
};
use serde::de::{self, Deserializer, Unexpected, Visitor};
pub fn inner(self) -> i32 {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/types/core/key.rs | crate: src
use crate::{
core::KeyDecrypter,
crypto::Source,
env::observability as logger,
errors::{self, SwitchError},
multitenancy::TenantState,
storage::{cache, dek::DataKeyStorageInterface},
types::Identifier,
};
use diesel::{
backend::Backend,
deserialize::{self, FromSql},
expression::AsExpression,
serialize::ToSql,
sql_types, Queryable,
};
use serde::de::{self, Deserializer, Unexpected, Visitor};
pub fn increment(self) -> errors::CustomResult<Self, errors::ParsingError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/types/core/key.rs | crate: src
use crate::{
core::KeyDecrypter,
crypto::Source,
env::observability as logger,
errors::{self, SwitchError},
multitenancy::TenantState,
storage::{cache, dek::DataKeyStorageInterface},
types::Identifier,
};
pub async fn get_latest(identifier: &Identifier, state: &TenantState) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/types/core/key.rs | crate: src
use crate::{
core::KeyDecrypter,
crypto::Source,
env::observability as logger,
errors::{self, SwitchError},
multitenancy::TenantState,
storage::{cache, dek::DataKeyStorageInterface},
types::Identifier,
};
use diesel::{
backend::Backend,
deserialize::{self, FromSql},
expression::AsExpression,
serialize::ToSql,
sql_types, Queryable,
};
use serde::de::{self, Deserializer, Unexpected, Visitor};
fn visit_str<E>(self, value: &str) -> Result<Version, E>
where
E: de::Error,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch-encryption-service/src/types/core/key.rs | crate: src
use crate::{
core::KeyDecrypter,
crypto::Source,
env::observability as logger,
errors::{self, SwitchError},
multitenancy::TenantState,
storage::{cache, dek::DataKeyStorageInterface},
types::Identifier,
};
use diesel::{
backend::Backend,
deserialize::{self, FromSql},
expression::AsExpression,
serialize::ToSql,
sql_types, Queryable,
};
use charybdis::scylla::SerializeValue;
use scylla::{
deserialize::{DeserializeValue, FrameSlice},
frame::response::result::ColumnType,
};
use serde::de::{self, Deserializer, Unexpected, Visitor};
fn serialize<'b>(
&self,
_typ: &ColumnType<'_>,
writer: scylla::serialize::writers::CellWriter<'b>,
) -> Result<
scylla::serialize::writers::WrittenCellProof<'b>,
scylla::serialize::SerializationError,
> {
// Skipping type check here since `Version` is a domain type and the type checking would be
// done during the construction of `Version` type.
let proof = writer
.set_value(self.0.to_be_bytes().as_slice())
.map_err(|err| {
logger::error!(version_serialize_err=?err);
scylla::serialize::SerializationError::new(errors::DatabaseError::Others)
})?;
Ok(proof)
} | ast_fragments |
// file: hyperswitch-encryption-service/src/types/core/key.rs | crate: src
use crate::{
core::KeyDecrypter,
crypto::Source,
env::observability as logger,
errors::{self, SwitchError},
multitenancy::TenantState,
storage::{cache, dek::DataKeyStorageInterface},
types::Identifier,
};
use core::fmt::Display;
use diesel::{
backend::Backend,
deserialize::{self, FromSql},
expression::AsExpression,
serialize::ToSql,
sql_types, Queryable,
};
use core::fmt;
use serde::de::{self, Deserializer, Unexpected, Visitor};
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(&format!("v{}", self.0))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/types/core/key.rs | crate: src
use crate::{
core::KeyDecrypter,
crypto::Source,
env::observability as logger,
errors::{self, SwitchError},
multitenancy::TenantState,
storage::{cache, dek::DataKeyStorageInterface},
types::Identifier,
};
pub async fn get_key(
state: &TenantState,
identifier: &Identifier,
version: Version,
) -> errors::CustomResult<Self, errors::DatabaseError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch-encryption-service/src/types/core/data.rs | crate: src
use crate::{consts::base64::BASE64_ENGINE, types::key::Version};
use masking::PeekInterface;
use serde::{
de::{self, Deserialize, Deserializer, Unexpected, Visitor},
Serialize,
};
use std::fmt;
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
struct EncryptedDataVisitor;
impl Visitor<'_> for EncryptedDataVisitor {
type Value = EncryptedData;
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str("string of the format {version}:{base64_encoded_data}'")
}
fn visit_str<E>(self, value: &str) -> Result<EncryptedData, E>
where
E: de::Error,
{
let (version, data) = value.split_once(':').ok_or_else(|| {
E::invalid_value(
Unexpected::Str(value),
&"String should of the format {version}:{base64_encoded_data}",
)
})?;
let dec_data = BASE64_ENGINE.decode(data).map_err(|err| {
let err = err.to_string();
E::invalid_value(Unexpected::Str(data), &err.as_str())
})?;
let (_, version) = version.split_once('v').ok_or_else(|| {
E::invalid_value(
Unexpected::Str(version),
&"Version should be in the format of v{version_num}",
)
})?;
let version = version.parse::<i32>().map_err(|_| {
E::invalid_value(Unexpected::Str(version), &"Unexpted version number")
})?;
Ok(EncryptedData {
version: Version::from(version),
data: masking::StrongSecret::new(dec_data),
})
}
}
deserializer.deserialize_str(EncryptedDataVisitor)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/types/core/data.rs | crate: src
use crate::{consts::base64::BASE64_ENGINE, types::key::Version};
use masking::PeekInterface;
use serde::{
de::{self, Deserialize, Deserializer, Unexpected, Visitor},
Serialize,
};
fn visit_str<E>(self, value: &str) -> Result<EncryptedData, E>
where
E: de::Error,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/types/core/data.rs | crate: src
use crate::{consts::base64::BASE64_ENGINE, types::key::Version};
use masking::PeekInterface;
use serde::{
de::{self, Deserialize, Deserializer, Unexpected, Visitor},
Serialize,
};
fn test_data_deserialize() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch-encryption-service/src/types/core/data.rs | crate: src
use crate::{consts::base64::BASE64_ENGINE, types::key::Version};
use masking::PeekInterface;
use serde::{
de::{self, Deserialize, Deserializer, Unexpected, Visitor},
Serialize,
};
fn test_data_deserialize() {
#[derive(PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
struct ExtractedEncryptedData {
data: EncryptedData,
}
let data = serde_json::json!({
"data": "v1:T21naXQnc3dvcmtpbmc=",
});
let actual_data: ExtractedEncryptedData = serde_json::from_value(data).unwrap();
let expected_data = EncryptedData {
version: Version::from(1),
data: masking::StrongSecret::new(String::from("Omgit'sworking").as_bytes().to_vec()),
};
let expected_data = ExtractedEncryptedData {
data: expected_data,
};
assert_eq!(actual_data, expected_data);
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/types/core/data.rs | crate: src
use crate::{consts::base64::BASE64_ENGINE, types::key::Version};
use serde::{
de::{self, Deserialize, Deserializer, Unexpected, Visitor},
Serialize,
};
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch-encryption-service/src/types/core/data.rs | crate: src
use masking::PeekInterface;
use serde::{
de::{self, Deserialize, Deserializer, Unexpected, Visitor},
Serialize,
};
pub fn inner(self) -> masking::StrongSecret<Vec<u8>> {
self.data
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/types/core/data.rs | crate: src
use masking::PeekInterface;
use serde::{
de::{self, Deserialize, Deserializer, Unexpected, Visitor},
Serialize,
};
pub fn inner(self) -> masking::StrongSecret<Vec<u8>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/types/core/data.rs | crate: src
use masking::PeekInterface;
pub fn from_data(data: masking::StrongSecret<Vec<u8>>) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/types/core/identifier.rs | crate: src
use crate::errors;
fn try_from(value: (String, String)) -> Result<Self, Self::Error> {
{
("User", kid) => Ok(Self::User(kid)),<|fim_suffix|>
<|fim_middle|>
(_, _) => Err(error_stack::Report::from(
errors::ParsingError::ParsingFailed(String::from("Failed to parse Identifier")),
)),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/types/core/identifier.rs | crate: src
pub fn get_identifier(&self) -> (String, String) {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/types/core/identifier.rs | crate: src
use crate::errors;
fn try_from(value: (String, String)) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/types/core/identifier.rs | crate: src
pub fn is_entity(&self) -> bool {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch-encryption-service/src/types/core/identifier.rs | crate: src
pub fn get_identifier(&self) -> (String, String) {
match self {
Self::User(id) => (String::from("User"), id.clone()),
Self::Merchant(id) => (String::from("Merchant"), id.clone()),
Self::UserAuth(id) => (String::from("UserAuth"), id.clone()),
Self::Entity(id) => (String::from("Entity"), id.clone()),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/core/datakey.rs | crate: src
use crate::{
core::custodian::Custodian,
env::observability as logger,
errors::{self, ToContainerError},
metrics,
multitenancy::TenantState,
types::{
requests::{CreateDataKeyRequest, RotateDataKeyRequest, TransferKeyRequest},
response::DataKeyCreateResponse,
},
};
use axum::Json;
use opentelemetry::KeyValue;
pub async fn rotate_data_key(
state: TenantState,
custodian: Custodian,
Json(req): Json<RotateDataKeyRequest>,
) -> errors::ApiResponseResult<Json<DataKeyCreateResponse>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/core/datakey.rs | crate: src
use crate::{
core::custodian::Custodian,
env::observability as logger,
errors::{self, ToContainerError},
metrics,
multitenancy::TenantState,
types::{
requests::{CreateDataKeyRequest, RotateDataKeyRequest, TransferKeyRequest},
response::DataKeyCreateResponse,
},
};
use axum::Json;
pub async fn transfer_data_key(
state: TenantState,
custodian: Custodian,
Json(req): Json<TransferKeyRequest>,
) -> errors::ApiResponseResult<Json<DataKeyCreateResponse>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch-encryption-service/src/core/datakey.rs | crate: src
use crate::{
core::custodian::Custodian,
env::observability as logger,
errors::{self, ToContainerError},
metrics,
multitenancy::TenantState,
types::{
requests::{CreateDataKeyRequest, RotateDataKeyRequest, TransferKeyRequest},
response::DataKeyCreateResponse,
},
};
use axum::Json;
use opentelemetry::KeyValue;
pub async fn rotate_data_key(
state: TenantState,
custodian: Custodian,
Json(req): Json<RotateDataKeyRequest>,
) -> errors::ApiResponseResult<Json<DataKeyCreateResponse>> {
let identifier = req.identifier.clone();
generate_and_rotate_data_key(state, custodian, req)
.await
.map(Json)
.map_err(|err| {
logger::error!(key_create_failure=?err);
let (data_identifier, key_identifier) = identifier.get_identifier();
metrics::KEY_ROTATE_FAILURE.add(
1,
&[
KeyValue::new("key_identifier", key_identifier),
KeyValue::new("data_identifier", data_identifier),
],
);
err
})
.to_container_error()
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/core/datakey.rs | crate: src
use crate::{
core::custodian::Custodian,
env::observability as logger,
errors::{self, ToContainerError},
metrics,
multitenancy::TenantState,
types::{
requests::{CreateDataKeyRequest, RotateDataKeyRequest, TransferKeyRequest},
response::DataKeyCreateResponse,
},
};
use axum::Json;
use opentelemetry::KeyValue;
pub async fn create_data_key(
state: TenantState,
custodian: Custodian,
Json(req): Json<CreateDataKeyRequest>,
) -> errors::ApiResponseResult<Json<DataKeyCreateResponse>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/core/metrics.rs | crate: src
use crate::{
app::AppState,
errors::{self, ToContainerError},
};
use axum::extract::State;
use prometheus::{default_registry, Encoder, TextEncoder};
use std::{io::BufWriter, sync::Arc};
pub async fn gather(State(_): State<Arc<AppState>>) -> errors::ApiResponseResult<Vec<u8>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch-encryption-service/src/core/metrics.rs | crate: src
use crate::{
app::AppState,
errors::{self, ToContainerError},
};
use axum::extract::State;
use prometheus::{default_registry, Encoder, TextEncoder};
use std::{io::BufWriter, sync::Arc};
pub async fn gather(State(_): State<Arc<AppState>>) -> errors::ApiResponseResult<Vec<u8>> {
let registry = default_registry();
let metrics_families = registry.gather();
let encoder = TextEncoder::new();
let mut buffer = BufWriter::new(Vec::new());
encoder
.encode(&metrics_families, &mut buffer)
.change_context(errors::ApplicationErrorResponse::ParsingFailed(
"Failed to flush the metrics buffer".to_string(),
))
.to_container_error()?;
buffer
.into_inner()
.change_context(errors::ApplicationErrorResponse::ParsingFailed(
"Failed to flush the metrics buffer".to_string(),
))
.to_container_error()
} | ast_fragments |
// file: hyperswitch-encryption-service/src/core/datakey/create.rs | crate: src
use crate::{
core::{crypto::KeyEncrypter, custodian::Custodian},
env::observability as logger,
errors::{self, SwitchError},
multitenancy::TenantState,
storage::dek::DataKeyStorageInterface,
types::{key::Version, requests::CreateDataKeyRequest, response::DataKeyCreateResponse, Key},
};
pub async fn generate_and_create_data_key(
state: TenantState,
custodian: Custodian,
req: CreateDataKeyRequest,
) -> errors::CustomResult<DataKeyCreateResponse, errors::ApplicationErrorResponse> {
let db = state.get_db_pool();
let version = Version::get_latest(&req.identifier, &state).await;
let (source, aes_key) = state.keymanager_client.generate_key().await.switch()?;
let key = Key {
version,
identifier: req.identifier.clone(),
key: aes_key,
source,
token: custodian.into_access_token(&state),
}
.encrypt(&state)
.await
.switch()
.map_err(|err| {
logger::error!(?err);
err
})?;
let data_key = db.get_or_insert_data_key(key).await.switch()?;
Ok(DataKeyCreateResponse {
key_version: data_key.version,
identifier: req.identifier,
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/core/datakey/create.rs | crate: src
use crate::{
core::{crypto::KeyEncrypter, custodian::Custodian},
env::observability as logger,
errors::{self, SwitchError},
multitenancy::TenantState,
storage::dek::DataKeyStorageInterface,
types::{key::Version, requests::CreateDataKeyRequest, response::DataKeyCreateResponse, Key},
};
pub async fn generate_and_create_data_key(
state: TenantState,
custodian: Custodian,
req: CreateDataKeyRequest,
) -> errors::CustomResult<DataKeyCreateResponse, errors::ApplicationErrorResponse> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch-encryption-service/src/core/datakey/transfer.rs | crate: src
use error_stack::ResultExt;
use crate::{
consts::base64::BASE64_ENGINE,
core::{crypto::KeyEncrypter, custodian::Custodian},
crypto::Source,
env::observability as logger,
errors::{self, SwitchError},
multitenancy::TenantState,
storage::dek::DataKeyStorageInterface,
types::{key::Version, requests::TransferKeyRequest, response::DataKeyCreateResponse, Key},
};
use base64::Engine;
pub async fn transfer_data_key(
state: TenantState,
custodian: Custodian,
req: TransferKeyRequest,
) -> errors::CustomResult<DataKeyCreateResponse, errors::ApplicationErrorResponse> {
let db = &state.get_db_pool();
let key = BASE64_ENGINE.decode(req.key).change_context(
errors::ApplicationErrorResponse::InternalServerError("Failed to decode the base64 key"),
)?;
let key = <[u8; 32]>::try_from(key).map_err(|_| {
error_stack::report!(errors::ApplicationErrorResponse::InternalServerError(
"Invalid key found"
))
})?;
let key = Key {
version: Version::default(),
identifier: req.identifier.clone(),
key: key.into(),
source: Source::KMS,
token: custodian.into_access_token(&state),
}
.encrypt(&state)
.await
.switch()
.map_err(|err| {
logger::error!(?err);
err
})?;
let data_key = db.get_or_insert_data_key(key).await.switch()?;
Ok(DataKeyCreateResponse {
identifier: req.identifier,
key_version: data_key.version,
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/core/datakey/transfer.rs | crate: src
use error_stack::ResultExt;
use crate::{
consts::base64::BASE64_ENGINE,
core::{crypto::KeyEncrypter, custodian::Custodian},
crypto::Source,
env::observability as logger,
errors::{self, SwitchError},
multitenancy::TenantState,
storage::dek::DataKeyStorageInterface,
types::{key::Version, requests::TransferKeyRequest, response::DataKeyCreateResponse, Key},
};
use base64::Engine;
pub async fn transfer_data_key(
state: TenantState,
custodian: Custodian,
req: TransferKeyRequest,
) -> errors::CustomResult<DataKeyCreateResponse, errors::ApplicationErrorResponse> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/storage/cache.rs | crate: src
pub use core::*;
pub use statics::*;
use crate::multitenancy::TenantState;
pub fn from_state(tenant: &TenantState, key: String) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/storage/cache.rs | crate: src
pub use core::*;
pub use statics::*;
pub async fn get(&self, key: &Key) -> Option<V> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/storage/cache.rs | crate: src
pub use core::*;
pub use statics::*;
pub async fn push(&self, key: Key, val: V) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/storage/cache.rs | crate: src
use moka::future::Cache as MokCache;
fn new(time_to_live: u64, time_to_idle: u64, max_capacity: Option<u64>) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch-encryption-service/src/storage/cache.rs | crate: src
pub use core::*;
pub use statics::*;
use crate::multitenancy::TenantState;
pub fn from_state(tenant: &TenantState, key: String) -> Self {
Self {
prefix: tenant.cache_prefix.clone(),
key,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/storage/cache/core.rs | crate: src
use crate::{
errors,
multitenancy::TenantState,
storage::cache::{Cache, Key},
};
pub async fn get_or_populate_cache<T, Fut>(
tenant: &TenantState,
key: String,
cache: &Cache<T>,
f: Fut,
) -> errors::CustomResult<T, errors::DatabaseError>
where
T: Clone + Sync + Send + 'static,
Fut: futures::Future<Output = errors::CustomResult<T, errors::DatabaseError>> + Send,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch-encryption-service/src/storage/cache/core.rs | crate: src
use crate::{
errors,
multitenancy::TenantState,
storage::cache::{Cache, Key},
};
pub async fn get_or_populate_cache<T, Fut>(
tenant: &TenantState,
key: String,
cache: &Cache<T>,
f: Fut,
) -> errors::CustomResult<T, errors::DatabaseError>
where
T: Clone + Sync + Send + 'static,
Fut: futures::Future<Output = errors::CustomResult<T, errors::DatabaseError>> + Send,
{
let key = Key::from_state(tenant, key);
if let Some(val) = cache.get(&key).await {
Ok(val)
} else {
let val = f.await?;
cache.push(key, val.clone()).await;
Ok(val)
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/env/observability.rs | crate: src
use super::{
logger::{self, LogGuard},
metrics::{self, MetricsGuard},
};
pub use super::logger::{LogConfig, LogLevel, OnRequest, OnResponse};
pub use tracing::{debug, error, info, trace, warn};
pub fn setup(log_config: &LogConfig, crates_to_filter: impl AsRef<[&'static str]>) -> Guards {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch-encryption-service/src/env/observability.rs | crate: src
use super::{
logger::{self, LogGuard},
metrics::{self, MetricsGuard},
};
pub use super::logger::{LogConfig, LogLevel, OnRequest, OnResponse};
pub use tracing::{debug, error, info, trace, warn};
pub fn setup(log_config: &LogConfig, crates_to_filter: impl AsRef<[&'static str]>) -> Guards {
let log_guard = logger::setup_logging_pipeline(log_config, crates_to_filter);
let metrics_guard = metrics::setup_metrics_pipeline();
Guards {
_log_guard: log_guard,
_metrics_guard: metrics_guard,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/env/logger.rs | crate: src
use tracing::level_filters::LevelFilter;
use tracing_subscriber::{fmt, EnvFilter, Layer};
fn get_envfilter<'a>(
filtering_directive: Option<&String>,
default_log_level: impl Into<LevelFilter> + Copy,
filter_log_level: impl Into<LevelFilter> + Copy,
crates_to_filter: impl AsRef<[&'a str]>,
) -> EnvFilter {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/env/logger.rs | crate: src
use tracing_appender::non_blocking::WorkerGuard;
use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::util::SubscriberInitExt;
use tracing_subscriber::{fmt, EnvFilter, Layer};
pub(super) fn setup_logging_pipeline(
log_config: &LogConfig,
crates_to_filter: impl AsRef<[&'static str]>,
) -> LogGuard {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/env/logger.rs | crate: src
use tracing::level_filters::LevelFilter;
fn on_response(
self,
response: &hyper::Response<B>,
latency: std::time::Duration,
_: &tracing::Span,
) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/env/logger.rs | crate: src
use tracing::level_filters::LevelFilter;
fn on_response(
self,
response: &hyper::Response<B>,
latency: std::time::Duration,
_: &tracing::Span,
) {
{
LogLevel::Debug => {
tracing::event!(
tracing::Level::DEBUG,
status,
latency,
"Finished processing request"
);
}<|fim_suffix|>
<|fim_middle|>
_ => {}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/env/logger.rs | crate: src
use tracing::level_filters::LevelFilter;
fn on_request(&mut self, _: &hyper::Request<B>, _: &tracing::Span) {
{
LogLevel::Debug => {
tracing::event!(tracing::Level::DEBUG, "Started processing request");
}<|fim_suffix|>
<|fim_middle|>
_ => {}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/env/logger.rs | crate: src
pub fn with_level(level: LogLevel) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/env/logger.rs | crate: src
use tracing::level_filters::LevelFilter;
fn on_request(&mut self, _: &hyper::Request<B>, _: &tracing::Span) {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/env/logger.rs | crate: src
fn from(value: LogLevel) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/errors/db.rs | crate: src
fn switch(self) -> super::CustomResult<T, super::DatabaseError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch-encryption-service/src/errors/db.rs | crate: src
fn switch(self) -> super::CustomResult<T, super::DatabaseError> {
self.change_context(DatabaseError::InvalidValue)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/errors/db.rs | crate: src
use crate::env::observability as logger;
use error_stack::{report, ResultExt};
fn switch(self) -> super::CustomResult<T, DatabaseError> {
{
charybdis::errors::CharybdisError::NotFoundError(err) => {
(DatabaseError::NotFound, err)
}<|fim_suffix|>
<|fim_middle|>
err => {
logger::error!(err=?err);
(DatabaseError::Others, "An unknown error occurred")
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/errors/db.rs | crate: src
use diesel::result::{DatabaseErrorKind, Error as diesel_error};
use error_stack::{report, ResultExt};
fn switch(self) -> super::CustomResult<T, DatabaseError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/errors/app.rs | crate: src
use axum::response::{IntoResponse, Response};
use hyper::StatusCode;
fn into_response(self) -> Response {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/errors/app.rs | crate: src
use axum::response::{IntoResponse, Response};
use hyper::StatusCode;
fn into_response(self) -> Response {
{
err @ ApplicationErrorResponse::InternalServerError(_) => (
StatusCode::INTERNAL_SERVER_ERROR,
axum::Json(ApiErrorResponse {
error_message: err.to_string(),
error_code: error_codes::IE_00,
}),
),<|fim_suffix|>
<|fim_middle|>
err @ ApplicationErrorResponse::InvalidTenantId => (
StatusCode::BAD_REQUEST,
axum::Json(ApiErrorResponse {
error_message: err.to_string(),
error_code: error_codes::BR_00,
}),
),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/errors/app.rs | crate: src
use super::SwitchError;
pub type ApiResponseResult<T> = Result<T, ApiErrorContainer>;
fn switch(self) -> super::CustomResult<T, ApplicationErrorResponse> {
{
super::DatabaseError::NotFound => ApplicationErrorResponse::NotFound("Database"),<|fim_suffix|>
<|fim_middle|>
super::DatabaseError::UniqueViolation => ApplicationErrorResponse::UniqueViolation,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/errors/app.rs | crate: src
pub type ApiResponseResult<T> = Result<T, ApiErrorContainer>;
fn to_container_error(self) -> Result<T, ApiErrorContainer> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/errors/app.rs | crate: src
use super::SwitchError;
pub type ApiResponseResult<T> = Result<T, ApiErrorContainer>;
fn switch(self) -> super::CustomResult<T, ApplicationErrorResponse> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/errors/app.rs | crate: src
use super::SwitchError;
pub type ApiResponseResult<T> = Result<T, ApiErrorContainer>;
fn switch(self) -> super::CustomResult<T, ParsingError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/services/aws/config.rs | crate: src
use aws_config::{meta::region::RegionProviderChain, BehaviorVersion};
use aws_sdk_kms::{config::Region, Client};
pub async fn new(config: &AwsKmsConfig) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/services/aws/config.rs | crate: src
pub fn key_id(&self) -> &str {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-encryption-service/src/services/aws/config.rs | crate: src
use aws_sdk_kms::{config::Region, Client};
pub fn inner_client(&self) -> &Client {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch-encryption-service/src/services/aws/config.rs | crate: src
use aws_config::{meta::region::RegionProviderChain, BehaviorVersion};
use aws_sdk_kms::{config::Region, Client};
pub async fn new(config: &AwsKmsConfig) -> Self {
let region_provider = RegionProviderChain::first_try(Region::new(config.region.clone()));
let sdk_config = aws_config::defaults(BehaviorVersion::v2024_03_28())
.region(region_provider)
.load()
.await;
Self {
inner_client: Client::new(&sdk_config),
key_id: config.key_id.clone(),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/storage_impl/src/lookup.rs | crate: storage_impl
use common_utils::errors::CustomResult;
use diesel_models::{
enums as storage_enums, kv,
reverse_lookup::{
ReverseLookup as DieselReverseLookup, ReverseLookupNew as DieselReverseLookupNew,
},
};
use crate::{
diesel_error_to_data_error,
errors::{self, RedisErrorExt},
kv_router_store::KVRouterStore,
redis::kv_store::{decide_storage_scheme, kv_wrapper, KvOperation, Op, PartitionKey},
utils::{self, try_redis_get_else_try_database_get},
DatabaseStore, RouterStore,
};
async fn get_lookup_by_lookup_id(
&self,
id: &str,
storage_scheme: storage_enums::MerchantStorageScheme,
) -> CustomResult<DieselReverseLookup, errors::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/storage_impl/src/lookup.rs | crate: storage_impl
use common_utils::errors::CustomResult;
use diesel_models::{
enums as storage_enums, kv,
reverse_lookup::{
ReverseLookup as DieselReverseLookup, ReverseLookupNew as DieselReverseLookupNew,
},
};
use redis_interface::SetnxReply;
use crate::{
diesel_error_to_data_error,
errors::{self, RedisErrorExt},
kv_router_store::KVRouterStore,
redis::kv_store::{decide_storage_scheme, kv_wrapper, KvOperation, Op, PartitionKey},
utils::{self, try_redis_get_else_try_database_get},
DatabaseStore, RouterStore,
};
async fn insert_reverse_lookup(
&self,
new: DieselReverseLookupNew,
storage_scheme: storage_enums::MerchantStorageScheme,
) -> CustomResult<DieselReverseLookup, errors::StorageError> {
let storage_scheme = Box::pin(decide_storage_scheme::<_, DieselReverseLookup>(
self,
storage_scheme,
Op::Insert,
))
.await;
match storage_scheme {
storage_enums::MerchantStorageScheme::PostgresOnly => {
self.router_store
.insert_reverse_lookup(new, storage_scheme)
.await
}
storage_enums::MerchantStorageScheme::RedisKv => {
let created_rev_lookup = DieselReverseLookup {
lookup_id: new.lookup_id.clone(),
sk_id: new.sk_id.clone(),
pk_id: new.pk_id.clone(),
source: new.source.clone(),
updated_by: storage_scheme.to_string(),
};
let redis_entry = kv::TypedSql {
op: kv::DBOperation::Insert {
insertable: Box::new(kv::Insertable::ReverseLookUp(new)),
},
};
match Box::pin(kv_wrapper::<DieselReverseLookup, _, _>(
self,
KvOperation::SetNx(&created_rev_lookup, redis_entry),
PartitionKey::CombinationKey {
combination: &format!("reverse_lookup_{}", &created_rev_lookup.lookup_id),
},
))
.await
.map_err(|err| err.to_redis_failed_response(&created_rev_lookup.lookup_id))?
.try_into_setnx()
{
Ok(SetnxReply::KeySet) => Ok(created_rev_lookup),
Ok(SetnxReply::KeyNotSet) => Err(errors::StorageError::DuplicateValue {
entity: "reverse_lookup",
key: Some(created_rev_lookup.lookup_id.clone()),
}
.into()),
Err(er) => Err(er).change_context(errors::StorageError::KVError),
}
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/storage_impl/src/lookup.rs | crate: storage_impl
use common_utils::errors::CustomResult;
use diesel_models::{
enums as storage_enums, kv,
reverse_lookup::{
ReverseLookup as DieselReverseLookup, ReverseLookupNew as DieselReverseLookupNew,
},
};
use redis_interface::SetnxReply;
use crate::{
diesel_error_to_data_error,
errors::{self, RedisErrorExt},
kv_router_store::KVRouterStore,
redis::kv_store::{decide_storage_scheme, kv_wrapper, KvOperation, Op, PartitionKey},
utils::{self, try_redis_get_else_try_database_get},
DatabaseStore, RouterStore,
};
async fn insert_reverse_lookup(
&self,
new: DieselReverseLookupNew,
storage_scheme: storage_enums::MerchantStorageScheme,
) -> CustomResult<DieselReverseLookup, errors::StorageError> {
{
Ok(SetnxReply::KeySet) => Ok(created_rev_lookup),<|fim_suffix|>
<|fim_middle|>
Err(er) => Err(er).change_context(errors::StorageError::KVError),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/storage_impl/src/lookup.rs | crate: storage_impl
use common_utils::errors::CustomResult;
use diesel_models::{
enums as storage_enums, kv,
reverse_lookup::{
ReverseLookup as DieselReverseLookup, ReverseLookupNew as DieselReverseLookupNew,
},
};
use crate::{
diesel_error_to_data_error,
errors::{self, RedisErrorExt},
kv_router_store::KVRouterStore,
redis::kv_store::{decide_storage_scheme, kv_wrapper, KvOperation, Op, PartitionKey},
utils::{self, try_redis_get_else_try_database_get},
DatabaseStore, RouterStore,
};
async fn get_lookup_by_lookup_id(
&self,
id: &str,
_storage_scheme: storage_enums::MerchantStorageScheme,
) -> CustomResult<DieselReverseLookup, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/storage_impl/src/lookup.rs | crate: storage_impl
use common_utils::errors::CustomResult;
use diesel_models::{
enums as storage_enums, kv,
reverse_lookup::{
ReverseLookup as DieselReverseLookup, ReverseLookupNew as DieselReverseLookupNew,
},
};
use crate::{
diesel_error_to_data_error,
errors::{self, RedisErrorExt},
kv_router_store::KVRouterStore,
redis::kv_store::{decide_storage_scheme, kv_wrapper, KvOperation, Op, PartitionKey},
utils::{self, try_redis_get_else_try_database_get},
DatabaseStore, RouterStore,
};
async fn insert_reverse_lookup(
&self,
new: DieselReverseLookupNew,
_storage_scheme: storage_enums::MerchantStorageScheme,
) -> CustomResult<DieselReverseLookup, errors::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/storage_impl/src/lib.rs | crate: storage_impl
use std::{fmt::Debug, sync::Arc};
use diesel_models as store;
use error_stack::ResultExt;
use hyperswitch_domain_models::{
behaviour::{Conversion, ReverseConversion},
merchant_key_store::MerchantKeyStore,
};
use common_utils::{errors::CustomResult, types::keymanager::KeyManagerState};
pub use mock_db::MockDb;
use redis_interface::{errors::RedisError, RedisConnectionPool, SaddReply};
pub use crate::database::store::Store;
pub use crate::{database::store::DatabaseStore, errors::StorageError};
pub async fn find_resources<D, R, M>(
&self,
state: &KeyManagerState,
key_store: &MerchantKeyStore,
execute_query: R,
) -> error_stack::Result<Vec<D>, StorageError>
where
D: Debug + Sync + Conversion,
R: futures::Future<
Output = error_stack::Result<Vec<M>, diesel_models::errors::DatabaseError>,
> + Send,
M: ReverseConversion<D>,
{
let resource_futures = execute_query
.await
.map_err(|error| {
let new_err = diesel_error_to_data_error(*error.current_context());
error.change_context(new_err)
})?
.into_iter()
.map(|resource| async {
resource
.convert(
state,
key_store.key.get_inner(),
key_store.merchant_id.clone().into(),
)
.await
.change_context(StorageError::DecryptionError)
})
.collect::<Vec<_>>();
let resources = futures::future::try_join_all(resource_futures).await?;
Ok(resources)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/storage_impl/src/lib.rs | crate: storage_impl
use std::{fmt::Debug, sync::Arc};
use diesel_models as store;
use error_stack::ResultExt;
use hyperswitch_domain_models::{
behaviour::{Conversion, ReverseConversion},
merchant_key_store::MerchantKeyStore,
};
use common_utils::{errors::CustomResult, types::keymanager::KeyManagerState};
pub use mock_db::MockDb;
use redis_interface::{errors::RedisError, RedisConnectionPool, SaddReply};
pub use crate::database::store::Store;
pub use crate::{database::store::DatabaseStore, errors::StorageError};
pub async fn call_database<D, R, M>(
&self,
state: &KeyManagerState,
key_store: &MerchantKeyStore,
execute_query: R,
) -> error_stack::Result<D, StorageError>
where
D: Debug + Sync + Conversion,
R: futures::Future<Output = error_stack::Result<M, diesel_models::errors::DatabaseError>>
+ Send,
M: ReverseConversion<D>,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/storage_impl/src/lib.rs | crate: storage_impl
use std::{fmt::Debug, sync::Arc};
use error_stack::ResultExt;
use masking::StrongSecret;
use redis::{kv_store::RedisConnInterface, pub_sub::PubSubInterface, RedisStore};
pub use mock_db::MockDb;
use redis_interface::{errors::RedisError, RedisConnectionPool, SaddReply};
pub use crate::database::store::Store;
pub use crate::{database::store::DatabaseStore, errors::StorageError};
pub async fn from_config(
db_conf: T::Config,
tenant_config: &dyn config::TenantConfig,
encryption_key: StrongSecret<Vec<u8>>,
cache_store: Arc<RedisStore>,
inmemory_cache_stream: &str,
) -> error_stack::Result<Self, StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/storage_impl/src/lib.rs | crate: storage_impl
use std::{fmt::Debug, sync::Arc};
use error_stack::ResultExt;
use common_utils::{errors::CustomResult, types::keymanager::KeyManagerState};
use redis_interface::{errors::RedisError, RedisConnectionPool, SaddReply};
async fn check_for_constraints(
&self,
redis_conn: &Arc<RedisConnectionPool>,
) -> CustomResult<(), RedisError> {
{
SaddReply::KeyNotSet => Err(error_stack::report!(RedisError::SetAddMembersFailed)),<|fim_suffix|>
<|fim_middle|>
SaddReply::KeySet => Ok(()),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/storage_impl/src/lib.rs | crate: storage_impl
use diesel_models as store;
use error_stack::ResultExt;
use common_utils::{errors::CustomResult, types::keymanager::KeyManagerState};
pub use mock_db::MockDb;
use redis_interface::{errors::RedisError, RedisConnectionPool, SaddReply};
pub use crate::database::store::Store;
pub use crate::{database::store::DatabaseStore, errors::StorageError};
pub(crate) fn diesel_error_to_data_error(
diesel_error: diesel_models::errors::DatabaseError,
) -> StorageError {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/storage_impl/src/lib.rs | crate: storage_impl
fn unique_constraints(&self) -> Vec<String> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/storage_impl/src/lib.rs | crate: storage_impl
fn table_name(&self) -> &str {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/storage_impl/src/lib.rs | crate: storage_impl
fn unique_constraints(&self) -> Vec<String> {
vec![format!(
"refund_{}_{}",
self.merchant_id.get_string_repr(),
self.refund_id
)]
} | ast_fragments |
// file: hyperswitch/crates/storage_impl/src/lib.rs | crate: storage_impl
fn unique_constraints(&self) -> Vec<String> {
vec![format!(
"pa_{}_{}_{}",
self.merchant_id.get_string_repr(),
self.payment_id.get_string_repr(),
self.attempt_id
)]
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/storage_impl/src/lib.rs | crate: storage_impl
use std::{fmt::Debug, sync::Arc};
use error_stack::ResultExt;
use common_utils::{errors::CustomResult, types::keymanager::KeyManagerState};
use redis_interface::{errors::RedisError, RedisConnectionPool, SaddReply};
async fn check_for_constraints(
&self,
redis_conn: &Arc<RedisConnectionPool>,
) -> CustomResult<(), RedisError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/storage_impl/src/lib.rs | crate: storage_impl
use diesel_models as store;
use error_stack::ResultExt;
use common_utils::{errors::CustomResult, types::keymanager::KeyManagerState};
pub use mock_db::MockDb;
use redis_interface::{errors::RedisError, RedisConnectionPool, SaddReply};
pub use crate::database::store::Store;
pub use crate::{database::store::DatabaseStore, errors::StorageError};
pub(crate) fn diesel_error_to_data_error(
diesel_error: diesel_models::errors::DatabaseError,
) -> StorageError {
match diesel_error {
diesel_models::errors::DatabaseError::DatabaseConnectionError => {
StorageError::DatabaseConnectionError
}
diesel_models::errors::DatabaseError::NotFound => {
StorageError::ValueNotFound("Value not found".to_string())
}
diesel_models::errors::DatabaseError::UniqueViolation => StorageError::DuplicateValue {
entity: "entity ",
key: None,
},
_ => StorageError::DatabaseError(error_stack::report!(diesel_error)),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/storage_impl/src/lib.rs | crate: storage_impl
use std::{fmt::Debug, sync::Arc};
use error_stack::ResultExt;
use masking::StrongSecret;
use redis::{kv_store::RedisConnInterface, pub_sub::PubSubInterface, RedisStore};
pub use mock_db::MockDb;
use redis_interface::{errors::RedisError, RedisConnectionPool, SaddReply};
pub use crate::database::store::Store;
pub use crate::{database::store::DatabaseStore, errors::StorageError};
/// # Panics
///
/// Will panic if `CONNECTOR_AUTH_FILE_PATH` is not set
pub async fn test_store(
db_conf: T::Config,
tenant_config: &dyn config::TenantConfig,
cache_conf: &redis_interface::RedisSettings,
encryption_key: StrongSecret<Vec<u8>>,
) -> error_stack::Result<Self, StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/storage_impl/src/lib.rs | crate: storage_impl
use masking::StrongSecret;
pub use mock_db::MockDb;
pub use crate::database::store::Store;
pub use crate::{database::store::DatabaseStore, errors::StorageError};
pub fn master_key(&self) -> &StrongSecret<Vec<u8>> {
{<|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.