feat(core): diesel models and db interface changes for authentication table (#3859)

Author: hrithikesh026

crates/common_enums/src/enums.rs

@@ -2172,6 +2172,91 @@ pub enum ApplePayFlow {
     Manual,
 }
 
+#[derive(
+    Clone,
+    Debug,
+    Eq,
+    Default,
+    Hash,
+    PartialEq,
+    serde::Deserialize,
+    serde::Serialize,
+    strum::Display,
+    strum::EnumString,
+    utoipa::ToSchema,
+    Copy,
+)]
+#[router_derive::diesel_enum(storage_type = "text")]
+#[serde(rename_all = "snake_case")]
+#[strum(serialize_all = "snake_case")]
+pub enum AuthenticationStatus {
+    #[default]
+    Started,
+    Pending,
+    Success,
+    Failed,
+}
+
+impl AuthenticationStatus {
+    pub fn is_terminal_status(&self) -> bool {
+        match self {
+            Self::Started | Self::Pending => false,
+            Self::Success | Self::Failed => true,
+        }
+    }
+
+    pub fn is_failed(&self) -> bool {
+        self == &Self::Failed
+    }
+}
+
+#[derive(
+    Clone,
+    Debug,
+    Eq,
+    Default,
+    Hash,
+    PartialEq,
+    serde::Deserialize,
+    serde::Serialize,
+    strum::Display,
+    strum::EnumString,
+    utoipa::ToSchema,
+    Copy,
+)]
+#[router_derive::diesel_enum(storage_type = "text")]
+#[serde(rename_all = "snake_case")]
+#[strum(serialize_all = "snake_case")]
+pub enum DecoupledAuthenticationType {
+    #[default]
+    Challenge,
+    Frictionless,
+}
+
+#[derive(
+    Clone,
+    Debug,
+    Eq,
+    Default,
+    Hash,
+    PartialEq,
+    serde::Deserialize,
+    serde::Serialize,
+    strum::Display,
+    strum::EnumString,
+    utoipa::ToSchema,
+    Copy,
+)]
+#[router_derive::diesel_enum(storage_type = "text")]
+#[serde(rename_all = "snake_case")]
+#[strum(serialize_all = "snake_case")]
+pub enum AuthenticationLifecycleStatus {
+    Used,
+    #[default]
+    Unused,
+    Expired,
+}
+
 #[derive(
     Clone,
     Copy,

crates/diesel_models/src/authentication.rs

@@ -0,0 +1,170 @@
+use diesel::{AsChangeset, Identifiable, Insertable, Queryable};
+use serde::{self, Deserialize, Serialize};
+use serde_json;
+
+use crate::schema::authentication;
+
+#[derive(Clone, Debug, Eq, PartialEq, Identifiable, Queryable, Serialize, Deserialize)]
+#[diesel(table_name = authentication,  primary_key(authentication_id))]
+pub struct Authentication {
+    pub authentication_id: String,
+    pub merchant_id: String,
+    pub authentication_connector: String,
+    pub connector_authentication_id: Option<String>,
+    pub authentication_data: Option<serde_json::Value>,
+    pub payment_method_id: String,
+    pub authentication_type: Option<common_enums::DecoupledAuthenticationType>,
+    pub authentication_status: common_enums::AuthenticationStatus,
+    pub authentication_lifecycle_status: common_enums::AuthenticationLifecycleStatus,
+    #[serde(with = "common_utils::custom_serde::iso8601")]
+    pub created_at: time::PrimitiveDateTime,
+    #[serde(with = "common_utils::custom_serde::iso8601")]
+    pub modified_at: time::PrimitiveDateTime,
+    pub error_message: Option<String>,
+    pub error_code: Option<String>,
+    pub connector_metadata: Option<serde_json::Value>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Insertable)]
+#[diesel(table_name = authentication)]
+pub struct AuthenticationNew {
+    pub authentication_id: String,
+    pub merchant_id: String,
+    pub authentication_connector: String,
+    pub connector_authentication_id: Option<String>,
+    pub authentication_data: Option<serde_json::Value>,
+    pub payment_method_id: String,
+    pub authentication_type: Option<common_enums::DecoupledAuthenticationType>,
+    pub authentication_status: common_enums::AuthenticationStatus,
+    pub authentication_lifecycle_status: common_enums::AuthenticationLifecycleStatus,
+    pub error_message: Option<String>,
+    pub error_code: Option<String>,
+    pub connector_metadata: Option<serde_json::Value>,
+}
+
+#[derive(Debug)]
+pub enum AuthenticationUpdate {
+    AuthenticationDataUpdate {
+        authentication_data: Option<serde_json::Value>,
+        connector_authentication_id: Option<String>,
+        payment_method_id: Option<String>,
+        authentication_type: Option<common_enums::DecoupledAuthenticationType>,
+        authentication_status: Option<common_enums::AuthenticationStatus>,
+        authentication_lifecycle_status: Option<common_enums::AuthenticationLifecycleStatus>,
+        connector_metadata: Option<serde_json::Value>,
+    },
+    PostAuthorizationUpdate {
+        authentication_lifecycle_status: common_enums::AuthenticationLifecycleStatus,
+    },
+    ErrorUpdate {
+        error_message: Option<String>,
+        error_code: Option<String>,
+        authentication_status: common_enums::AuthenticationStatus,
+        connector_authentication_id: Option<String>,
+    },
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, AsChangeset, Serialize, Deserialize)]
+#[diesel(table_name = authentication)]
+pub struct AuthenticationUpdateInternal {
+    pub connector_authentication_id: Option<String>,
+    pub authentication_data: Option<serde_json::Value>,
+    pub payment_method_id: Option<String>,
+    pub authentication_type: Option<common_enums::DecoupledAuthenticationType>,
+    pub authentication_status: Option<common_enums::AuthenticationStatus>,
+    pub authentication_lifecycle_status: Option<common_enums::AuthenticationLifecycleStatus>,
+    pub modified_at: time::PrimitiveDateTime,
+    pub error_message: Option<String>,
+    pub error_code: Option<String>,
+    pub connector_metadata: Option<serde_json::Value>,
+}
+
+impl AuthenticationUpdateInternal {
+    pub fn apply_changeset(self, source: Authentication) -> Authentication {
+        let Self {
+            connector_authentication_id,
+            authentication_data,
+            payment_method_id,
+            authentication_type,
+            authentication_status,
+            authentication_lifecycle_status,
+            modified_at: _,
+            error_code,
+            error_message,
+            connector_metadata,
+        } = self;
+        Authentication {
+            connector_authentication_id: connector_authentication_id
+                .or(source.connector_authentication_id),
+            authentication_data: authentication_data.or(source.authentication_data),
+            payment_method_id: payment_method_id.unwrap_or(source.payment_method_id),
+            authentication_type: authentication_type.or(source.authentication_type),
+            authentication_status: authentication_status.unwrap_or(source.authentication_status),
+            authentication_lifecycle_status: authentication_lifecycle_status
+                .unwrap_or(source.authentication_lifecycle_status),
+            modified_at: common_utils::date_time::now(),
+            error_code: error_code.or(source.error_code),
+            error_message: error_message.or(source.error_message),
+            connector_metadata: connector_metadata.or(source.connector_metadata),
+            ..source
+        }
+    }
+}
+
+impl From<AuthenticationUpdate> for AuthenticationUpdateInternal {
+    fn from(auth_update: AuthenticationUpdate) -> Self {
+        match auth_update {
+            AuthenticationUpdate::AuthenticationDataUpdate {
+                authentication_data,
+                connector_authentication_id,
+                authentication_type,
+                authentication_status,
+                payment_method_id,
+                authentication_lifecycle_status,
+                connector_metadata,
+            } => Self {
+                authentication_data,
+                connector_authentication_id,
+                authentication_type,
+                authentication_status,
+                authentication_lifecycle_status,
+                modified_at: common_utils::date_time::now(),
+                payment_method_id,
+                error_message: None,
+                error_code: None,
+                connector_metadata,
+            },
+            AuthenticationUpdate::ErrorUpdate {
+                error_message,
+                error_code,
+                authentication_status,
+                connector_authentication_id,
+            } => Self {
+                error_code,
+                error_message,
+                authentication_status: Some(authentication_status),
+                authentication_data: None,
+                connector_authentication_id,
+                authentication_type: None,
+                authentication_lifecycle_status: None,
+                modified_at: common_utils::date_time::now(),
+                payment_method_id: None,
+                connector_metadata: None,
+            },
+            AuthenticationUpdate::PostAuthorizationUpdate {
+                authentication_lifecycle_status,
+            } => Self {
+                connector_authentication_id: None,
+                authentication_data: None,
+                payment_method_id: None,
+                authentication_type: None,
+                authentication_status: None,
+                authentication_lifecycle_status: Some(authentication_lifecycle_status),
+                modified_at: common_utils::date_time::now(),
+                error_message: None,
+                error_code: None,
+                connector_metadata: None,
+            },
+        }
+    }
+}

crates/diesel_models/src/query/authentication.rs

@@ -0,0 +1,72 @@
+use diesel::{associations::HasTable, BoolExpressionMethods, ExpressionMethods};
+
+use super::generics;
+use crate::{
+    authentication::{
+        Authentication, AuthenticationNew, AuthenticationUpdate, AuthenticationUpdateInternal,
+    },
+    errors,
+    schema::authentication::dsl,
+    PgPooledConn, StorageResult,
+};
+
+impl AuthenticationNew {
+    pub async fn insert(self, conn: &PgPooledConn) -> StorageResult<Authentication> {
+        generics::generic_insert(conn, self).await
+    }
+}
+
+impl Authentication {
+    pub async fn update_by_merchant_id_authentication_id(
+        conn: &PgPooledConn,
+        merchant_id: String,
+        authentication_id: String,
+        authorization_update: AuthenticationUpdate,
+    ) -> StorageResult<Self> {
+        match generics::generic_update_with_unique_predicate_get_result::<
+            <Self as HasTable>::Table,
+            _,
+            _,
+            _,
+        >(
+            conn,
+            dsl::merchant_id
+                .eq(merchant_id.to_owned())
+                .and(dsl::authentication_id.eq(authentication_id.to_owned())),
+            AuthenticationUpdateInternal::from(authorization_update),
+        )
+        .await
+        {
+            Err(error) => match error.current_context() {
+                errors::DatabaseError::NotFound => Err(error.attach_printable(
+                    "Authentication with the given Authentication ID does not exist",
+                )),
+                errors::DatabaseError::NoFieldsToUpdate => {
+                    generics::generic_find_one::<<Self as HasTable>::Table, _, _>(
+                        conn,
+                        dsl::merchant_id
+                            .eq(merchant_id.to_owned())
+                            .and(dsl::authentication_id.eq(authentication_id.to_owned())),
+                    )
+                    .await
+                }
+                _ => Err(error),
+            },
+            result => result,
+        }
+    }
+
+    pub async fn find_by_merchant_id_authentication_id(
+        conn: &PgPooledConn,
+        merchant_id: &str,
+        authentication_id: &str,
+    ) -> StorageResult<Self> {
+        generics::generic_find_one::<<Self as HasTable>::Table, _, _>(
+            conn,
+            dsl::merchant_id
+                .eq(merchant_id.to_owned())
+                .and(dsl::authentication_id.eq(authentication_id.to_owned())),
+        )
+        .await
+    }
+}

crates/diesel_models/src/schema.rs

@@ -58,6 +58,38 @@ diesel::table! {
     }
 }
 
+diesel::table! {
+    use diesel::sql_types::*;
+    use crate::enums::diesel_exports::*;
+
+    authentication (authentication_id) {
+        #[max_length = 64]
+        authentication_id -> Varchar,
+        #[max_length = 64]
+        merchant_id -> Varchar,
+        #[max_length = 64]
+        authentication_connector -> Varchar,
+        #[max_length = 64]
+        connector_authentication_id -> Nullable<Varchar>,
+        authentication_data -> Nullable<Jsonb>,
+        #[max_length = 64]
+        payment_method_id -> Varchar,
+        #[max_length = 64]
+        authentication_type -> Nullable<Varchar>,
+        #[max_length = 64]
+        authentication_status -> Varchar,
+        #[max_length = 64]
+        authentication_lifecycle_status -> Varchar,
+        created_at -> Timestamp,
+        modified_at -> Timestamp,
+        #[max_length = 64]
+        error_message -> Nullable<Varchar>,
+        #[max_length = 64]
+        error_code -> Nullable<Varchar>,
+        connector_metadata -> Nullable<Jsonb>,
+    }
+}
+
 diesel::table! {
     use diesel::sql_types::*;
     use crate::enums::diesel_exports::*;
@@ -1108,6 +1140,7 @@ diesel::table! {
 diesel::allow_tables_to_appear_in_same_query!(
     address,
     api_keys,
+    authentication,
     blocklist,
     blocklist_fingerprint,
     blocklist_lookup,