feat(fingerprint): add fingerprint table and corresponding db interface

Cargo.toml

@@ -65,6 +65,8 @@ moka = { version = "0.12.1", features = ["future"], optional = true }
 
 argh = "0.1.12"
 
+nanoid = "0.4.0"
+
 [dev-dependencies]
 rand = "0.8.5"
 criterion = "0.5.1"

migrations/2024-02-06-064347_add-fingerprint-table/down.sql

@@ -0,0 +1,3 @@
+-- This file should undo anything in `up.sql`
+
+DROP TABLE fingerprint;

migrations/2024-02-06-064347_add-fingerprint-table/up.sql

@@ -0,0 +1,8 @@
+-- Your SQL goes here
+
+CREATE TABLE fingerprint (
+  id SERIAL,
+  card_hash BYTEA UNIQUE NOT NULL,
+  card_fingerprint VARCHAR(255) NOT NULL,
+  PRIMARY KEY (card_hash)
+);

src/error/custom_error.rs

@@ -46,6 +46,20 @@ pub enum HashDBError {
     UnknownError,
 }
 
+#[derive(Debug, thiserror::Error)]
+pub enum FingerprintDBError {
+    #[error("Error while connecting to database")]
+    DBError,
+    #[error("Error while finding element in the database")]
+    DBFilterError,
+    #[error("Error while inserting element in the database")]
+    DBInsertError,
+    #[error("Unpredictable error occurred")]
+    UnknownError,
+    #[error("Error while encoding data: {0}")]
+    EncodingError(&'static str),
+}
+
 pub trait NotFoundError {
     fn is_not_found(&self) -> bool;
 }

src/error/transforms.rs

@@ -80,6 +80,38 @@ impl<'a> From<&'a super::StorageError> for super::HashDBError {
     }
 }
 
+error_transform!(super::StorageError => super::FingerprintDBError);
+impl<'a> From<&'a super::StorageError> for super::FingerprintDBError {
+    fn from(value: &'a super::StorageError) -> Self {
+        match value {
+            super::StorageError::DBPoolError | super::StorageError::PoolClientFailure => {
+                Self::DBError
+            }
+            super::StorageError::FindError => Self::DBFilterError,
+            super::StorageError::DecryptionError
+            | super::StorageError::EncryptionError
+            | super::StorageError::DeleteError => Self::UnknownError,
+            super::StorageError::InsertError => Self::DBInsertError,
+            super::StorageError::NotFoundError => Self::DBFilterError,
+        }
+    }
+}
+
+error_transform!(super::CryptoError => super::FingerprintDBError);
+impl<'a> From<&'a super::CryptoError> for super::FingerprintDBError {
+    fn from(value: &'a super::CryptoError) -> Self {
+        match value {
+            super::CryptoError::SerdeJsonError(_)
+            | super::CryptoError::JWError(_)
+            | super::CryptoError::InvalidData(_)
+            | super::CryptoError::EncodingError(_)
+            | super::CryptoError::NotImplemented
+            | super::CryptoError::EncryptionError
+            | super::CryptoError::DecryptionError => Self::UnknownError,
+        }
+    }
+}
+
 error_transform!(super::CryptoError => super::HashDBError);
 impl<'a> From<&'a super::CryptoError> for super::HashDBError {
     fn from(value: &'a super::CryptoError) -> Self {

src/storage.rs

@@ -19,9 +19,11 @@ use masking::{PeekInterface, Secret};
 #[cfg(feature = "caching")]
 pub mod caching;
 
+pub mod consts;
 pub mod db;
 pub mod schema;
 pub mod types;
+pub mod utils;
 
 pub trait State {}
 
@@ -183,3 +185,23 @@ pub trait HashInterface {
         data_hash: Vec<u8>,
     ) -> Result<types::HashTable, ContainerError<Self::Error>>;
 }
+
+///
+/// Fingerprint:
+///
+/// Interface providing functional to interface with the fingerprint table in database
+#[async_trait::async_trait]
+pub trait FingerprintInterface {
+    type Error;
+
+    async fn find_by_card_hash(
+        &self,
+        card_hash: &[u8],
+    ) -> Result<Option<types::Fingerprint>, ContainerError<Self::Error>>;
+
+    async fn insert_fingerprint(
+        &self,
+        card: types::Card,
+        hash_key: Secret<String>,
+    ) -> Result<types::Fingerprint, ContainerError<Self::Error>>;
+}

src/storage/consts.rs

@@ -0,0 +1,10 @@
+/// Characters to use for generating NanoID
+pub(crate) const ALPHABETS: [char; 62] = [
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
+    'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B',
+    'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U',
+    'V', 'W', 'X', 'Y', 'Z',
+];
+
+/// Number of characters in a generated ID
+pub const ID_LENGTH: usize = 20;

src/storage/db.rs

@@ -5,11 +5,13 @@ use masking::ExposeInterface;
 use masking::Secret;
 
 use crate::crypto::aes::{generate_aes256_key, GcmAes256};
+use crate::crypto::sha::HmacSha512;
+use crate::crypto::Encode;
 use crate::error::{self, ContainerError, ResultContainerExt};
 
 use super::types::StorageDecryption;
 use super::types::StorageEncryption;
-use super::{schema, types, LockerInterface, MerchantInterface, Storage};
+use super::{consts, schema, types, utils, LockerInterface, MerchantInterface, Storage};
 
 #[async_trait::async_trait]
 impl MerchantInterface for Storage {
@@ -259,3 +261,58 @@ impl super::HashInterface for Storage {
         }
     }
 }
+
+#[async_trait::async_trait]
+impl super::FingerprintInterface for Storage {
+    type Error = error::FingerprintDBError;
+
+    async fn find_by_card_hash(
+        &self,
+        card_hash: &[u8],
+    ) -> Result<Option<types::Fingerprint>, ContainerError<Self::Error>> {
+        let mut conn = self.get_conn().await?;
+
+        let output: Result<_, diesel::result::Error> = types::Fingerprint::table()
+            .filter(schema::fingerprint::card_hash.eq(card_hash))
+            .get_result(&mut conn)
+            .await;
+
+        match output {
+            Ok(inner) => Ok(Some(inner)),
+            Err(inner_err) => match inner_err {
+                diesel::result::Error::NotFound => Ok(None),
+                error => Err(error).change_error(error::StorageError::FindError)?,
+            },
+        }
+    }
+    async fn insert_fingerprint(
+        &self,
+        card: types::Card,
+        hash_key: Secret<String>,
+    ) -> Result<types::Fingerprint, ContainerError<Self::Error>> {
+        let algo = HmacSha512::<1>::new(hash_key.expose().into_bytes().into());
+        let card_data = serde_json::to_vec(&card)
+            .change_error(error::FingerprintDBError::EncodingError("byte-vec"))?;
+
+        let card_hash = algo.encode(card_data)?;
+
+        let output = self.find_by_card_hash(&card_hash).await?;
+        match output {
+            Some(inner) => Ok(inner),
+            None => {
+                let mut conn = self.get_conn().await?;
+                let query = diesel::insert_into(types::Fingerprint::table()).values(
+                    types::FingerprintTableNew {
+                        card_hash,
+                        card_fingerprint: utils::generate_id(consts::ID_LENGTH).into(),
+                    },
+                );
+
+                Ok(query
+                    .get_result(&mut conn)
+                    .await
+                    .change_error(error::StorageError::InsertError)?)
+            }
+        }
+    }
+}

src/storage/schema.rs

@@ -1,5 +1,14 @@
 // @generated automatically by Diesel CLI.
 
+diesel::table! {
+    fingerprint (card_hash) {
+        id -> Int4,
+        card_hash -> Bytea,
+        #[max_length = 255]
+        card_fingerprint -> Varchar,
+    }
+}
+
 diesel::table! {
     hash_table (hash_id) {
         id -> Int4,
@@ -40,4 +49,4 @@ diesel::table! {
     }
 }
 
-diesel::allow_tables_to_appear_in_same_query!(hash_table, locker, merchant,);
+diesel::allow_tables_to_appear_in_same_query!(fingerprint, hash_table, locker, merchant,);

src/storage/types.rs

@@ -5,6 +5,7 @@ use diesel::{
     sql_types, AsExpression, Identifiable, Insertable, Queryable,
 };
 use masking::{ExposeInterface, Secret};
+use serde::Serialize;
 
 use crate::crypto::{self, Encryption};
 
@@ -97,6 +98,32 @@ pub struct HashTable {
     pub created_at: time::PrimitiveDateTime,
 }
 
+#[derive(Debug, Clone, Identifiable, Queryable)]
+#[diesel(table_name = schema::fingerprint)]
+pub struct Fingerprint {
+    pub id: i32,
+    pub card_hash: Vec<u8>,
+    pub card_fingerprint: Secret<String>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct Card {
+    pub card_number: masking::StrongSecret<String>,
+    name_on_card: Option<String>,
+    card_exp_month: Option<String>,
+    card_exp_year: Option<String>,
+    card_brand: Option<String>,
+    card_isin: Option<String>,
+    nick_name: Option<String>,
+}
+
+#[derive(Debug, Insertable)]
+#[diesel(table_name = schema::fingerprint)]
+pub(super) struct FingerprintTableNew {
+    pub card_hash: Vec<u8>,
+    pub card_fingerprint: Secret<String>,
+}
+
 #[derive(Debug, Insertable)]
 #[diesel(table_name = schema::hash_table)]
 pub(super) struct HashTableNew {

src/storage/utils.rs

@@ -0,0 +1,5 @@
+use crate::storage::consts;
+
+pub fn generate_id(id_length: usize) -> String {
+    nanoid::nanoid!(id_length, &consts::ALPHABETS)
+}