Merge pull request #79 from Zod-Alkhair/feature/notification-system-fcm-registration

feat: enhance transaction notification logging and error handling

.env.example

@@ -0,0 +1,40 @@
+NODE_ENV=dev
+PORT=5000
+DB_HOST=
+DB_PASS=
+DB_USER=postgres
+DB_PORT=5432
+DB_NAME=
+MIGRATIONS_RUN=true
+SWAGGER_API_DOCS_PATH="/api-docs"
+
+JWT_ACCESS_TOKEN_SECRET=your_access_token_secret
+JWT_ACCESS_TOKEN_EXPIRY=1d
+JWT_REFRESH_TOKEN_SECRET=your_refresh_token_secret
+JWT_REFRESH_TOKEN_EXPIRY=1d
+USE_MOCK=true
+
+
+OCI_TENANCY_ID=
+OCI_USER_ID=
+OCI_FINGERPRINT=
+OCI_PRIVATE_KEY=
+OCI_PASSPHRASE=""
+OCI_NAMESPACE=
+OCI_REGION=
+
+
+MAIL_HOST=smtp.gmail.com
+MAIL_USER=[email protected]
+MAIL_PASSWORD=
+MAIL_PORT=587
+MAIL_FROM=UBA
+
+
+BRANCH_IO_URL=https://api2.branch.io/v1/url
+BRANCH_IO_KEY=
+ZOD_BASE_URL=http://localhost:5001
+ANDROID_PACKAGE_NAME=com.zod
+IOS_PACKAGE_NAME=com.zod
+ANDRIOD_JUNIOR_DEEPLINK_PATH=zodbank://juniors/qr-code/validate
+IOS_JUNIOR_DEEPLINK_PATH=zodbank://juniors/qr-code/validate

.eslintrc.js

@@ -0,0 +1,47 @@
+/** @type {import('eslint').Linter.Config} */
+module.exports = {
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    project: 'tsconfig.json',
+    tsconfigRootDir: __dirname,
+    sourceType: 'module',
+  },
+  plugins: ['@typescript-eslint/eslint-plugin'],
+  extends: ['plugin:@typescript-eslint/recommended', 'plugin:prettier/recommended', 'plugin:security/recommended'],
+  root: true,
+  env: {
+    node: true,
+    jest: true,
+  },
+  ignorePatterns: ['.eslintrc.js', 'node_modules', 'dist', 'coverage', 'jest*\\.ts', 'typeorm*\\.ts'],
+  rules: {
+    '@typescript-eslint/interface-name-prefix': 'off',
+    '@typescript-eslint/explicit-function-return-type': 'off',
+    '@typescript-eslint/explicit-module-boundary-types': 'off',
+    '@typescript-eslint/no-explicit-any': 'off',
+    '@typescript-eslint/no-unused-vars': [
+      'warn',
+      { argsIgnorePattern: '^_', varsIgnorePattern: '^_', caughtErrorsIgnorePattern: '^_' },
+    ],
+    '@typescript-eslint/no-inferrable-types': 'off',
+    'func-names': ['error', 'as-needed'],
+    'no-underscore-dangle': ['error'],
+    'require-await': ['error'],
+    'no-console': ['error'],
+    'no-multi-assign': ['error'],
+    'no-magic-numbers': ['error', { ignoreArrayIndexes: true}],
+    'no-multiple-empty-lines': ['error', { max: 1, maxEOF: 1, maxBOF: 0 }],
+    'max-len': [
+      'error',
+      { code: 120, tabWidth: 2, ignoreUrls: true, ignoreStrings: true, ignoreTemplateLiterals: true },
+    ],
+  },
+  overrides: [
+    {
+      files: ['*spec.ts'],
+      rules: {
+        'no-magic-numbers': ['off'],
+      },
+    },
+  ],
+};

.github/workflows/ci-pipeline.yml

@@ -0,0 +1,85 @@
+name: CI Zod
+
+on:
+  pull_request:
+    branches:
+      - '*'
+  push:
+    branches:
+      - dev
+      - main
+
+env:
+  NODE_ENV: development
+  TAG: dev
+
+jobs:
+  install_dependencies:
+    name: Install Dependencies
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v3
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 22.4.1
+
+      - name: Install Dependencies
+        run: npm install
+
+      - name: Cache Node Modules
+        uses: actions/cache@v3
+        with:
+          path: node_modules
+          key: ${{ runner.os }}-node_modules-${{ hashFiles('**/package-lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-node_modules-
+
+  run_tests:
+    name: Run Tests
+    runs-on: ubuntu-latest
+    needs: install_dependencies
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v3
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 22.4.1
+
+      - name: Install Dependencies
+        run: npm install
+
+      - name: Run Lint
+        run: npm run lint
+
+      - name: Run Tests with Coverage
+        run: npm run test:cov
+
+  build_app:
+    name: Build Application
+    runs-on: ubuntu-latest
+    needs: run_tests
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v3
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 22.4.1
+
+      - name: Install Dependencies
+        run: npm install
+
+      - name: Build Application
+        run: npm run build
+
+      - name: Upload Build Artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: dist
+          path: dist/

.gitignore

@@ -1,24 +1,57 @@
-/static
-/media
-.idea/
-*.pyc
-media/
-*.name
-*.iml
-*.log
-*.xml
-*.pyo
-.DS_Store
-.idea
-venv/*
-static/*
-*.pem
-*.sqlite3
-/migrations/__pycache__/
-/__pycache__/
-/*.pyc
-*/__pycache__/*.pyc
-__pycache__/
-*.env
-ve/*
+# compiled output
+/dist
+/node_modules
+/build
 
+# Logs
+logs
+*.log
+npm-debug.log*
+pnpm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+
+# OS
+.DS_Store
+
+# Tests
+/coverage
+/.nyc_output
+
+# IDEs and editors
+/.idea
+.project
+.classpath
+.c9/
+*.launch
+.settings/
+*.sublime-workspace
+
+# IDE - VSCode
+.vscode/*
+!.vscode/settings.json
+
+
+# dotenv environment variable files
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+
+# temp directory
+.temp
+.tmp
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Diagnostic reports (https://nodejs.org/api/report.html)
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
+
+
+zod-certs

.prettierrc

@@ -0,0 +1,6 @@
+{
+  "singleQuote": true,
+  "trailingComma": "all",
+  "tabWidth": 2,
+  "printWidth": 120
+}

.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+  "editor.formatOnSave": true,
+  "editor.codeActionsOnSave": {
+    "source.organizeImports": "explicit"
+  }
+}

Dockerfile.local

@@ -0,0 +1,33 @@
+# Base image
+FROM node:22.4.1-alpine
+RUN apk update && \
+    apk upgrade && \
+    apk add ca-certificates curl && \
+    update-ca-certificates
+
+#saudi timezone
+ENV TZ=Asia/Riyadh
+
+# Create app directory
+RUN mkdir /app && chown node:node /app
+WORKDIR /app
+
+# finally switch user to node
+USER node
+
+
+# A wildcard is used to ensure both package.json, package-lock.json and package-lock.json are copied
+COPY --chown=node:node package*.json ./
+
+
+
+# Install app dependencies
+RUN npm install --frozen-lockfile
+# Bundle app source
+COPY --chown=node:node . .
+
+# Creates a "dist" folder with the production build
+RUN npm run build
+
+# Start the server using the production build
+CMD [ "node", "dist/main" ]

README.md

@@ -1 +1,99 @@
-# ZODBank-Backend
+<p align="center">
+  <a href="http://nestjs.com/" target="blank"><img src="https://nestjs.com/img/logo-small.svg" width="120" alt="Nest Logo" /></a>
+</p>
+
+[circleci-image]: https://img.shields.io/circleci/build/github/nestjs/nest/master?token=abc123def456
+[circleci-url]: https://circleci.com/gh/nestjs/nest
+
+  <p align="center">A progressive <a href="http://nodejs.org" target="_blank">Node.js</a> framework for building efficient and scalable server-side applications.</p>
+    <p align="center">
+<a href="https://www.npmjs.com/~nestjscore" target="_blank"><img src="https://img.shields.io/npm/v/@nestjs/core.svg" alt="NPM Version" /></a>
+<a href="https://www.npmjs.com/~nestjscore" target="_blank"><img src="https://img.shields.io/npm/l/@nestjs/core.svg" alt="Package License" /></a>
+<a href="https://www.npmjs.com/~nestjscore" target="_blank"><img src="https://img.shields.io/npm/dm/@nestjs/common.svg" alt="NPM Downloads" /></a>
+<a href="https://circleci.com/gh/nestjs/nest" target="_blank"><img src="https://img.shields.io/circleci/build/github/nestjs/nest/master" alt="CircleCI" /></a>
+<a href="https://coveralls.io/github/nestjs/nest?branch=master" target="_blank"><img src="https://coveralls.io/repos/github/nestjs/nest/badge.svg?branch=master#9" alt="Coverage" /></a>
+<a href="https://discord.gg/G7Qnnhy" target="_blank"><img src="https://img.shields.io/badge/discord-online-brightgreen.svg" alt="Discord"/></a>
+<a href="https://opencollective.com/nest#backer" target="_blank"><img src="https://opencollective.com/nest/backers/badge.svg" alt="Backers on Open Collective" /></a>
+<a href="https://opencollective.com/nest#sponsor" target="_blank"><img src="https://opencollective.com/nest/sponsors/badge.svg" alt="Sponsors on Open Collective" /></a>
+  <a href="https://paypal.me/kamilmysliwiec" target="_blank"><img src="https://img.shields.io/badge/Donate-PayPal-ff3f59.svg" alt="Donate us"/></a>
+    <a href="https://opencollective.com/nest#sponsor"  target="_blank"><img src="https://img.shields.io/badge/Support%20us-Open%20Collective-41B883.svg" alt="Support us"></a>
+  <a href="https://twitter.com/nestframework" target="_blank"><img src="https://img.shields.io/twitter/follow/nestframework.svg?style=social&label=Follow" alt="Follow us on Twitter"></a>
+</p>
+  <!--[![Backers on Open Collective](https://opencollective.com/nest/backers/badge.svg)](https://opencollective.com/nest#backer)
+  [![Sponsors on Open Collective](https://opencollective.com/nest/sponsors/badge.svg)](https://opencollective.com/nest#sponsor)-->
+
+## Description
+
+[Nest](https://github.com/nestjs/nest) framework TypeScript starter repository.
+
+## Project setup
+
+```bash
+$ npm install
+```
+
+## Compile and run the project
+
+```bash
+# development
+$ npm run start
+
+# watch mode
+$ npm run start:dev
+
+# production mode
+$ npm run start:prod
+```
+
+## Run tests
+
+```bash
+# unit tests
+$ npm run test
+
+# e2e tests
+$ npm run test:e2e
+
+# test coverage
+$ npm run test:cov
+```
+
+## Deployment
+
+When you're ready to deploy your NestJS application to production, there are some key steps you can take to ensure it runs as efficiently as possible. Check out the [deployment documentation](https://docs.nestjs.com/deployment) for more information.
+
+If you are looking for a cloud-based platform to deploy your NestJS application, check out [Mau](https://mau.nestjs.com), our official platform for deploying NestJS applications on AWS. Mau makes deployment straightforward and fast, requiring just a few simple steps:
+
+```bash
+$ npm install -g mau
+$ mau deploy
+```
+
+With Mau, you can deploy your application in just a few clicks, allowing you to focus on building features rather than managing infrastructure.
+
+## Resources
+
+Check out a few resources that may come in handy when working with NestJS:
+
+- Visit the [NestJS Documentation](https://docs.nestjs.com) to learn more about the framework.
+- For questions and support, please visit our [Discord channel](https://discord.gg/G7Qnnhy).
+- To dive deeper and get more hands-on experience, check out our official video [courses](https://courses.nestjs.com/).
+- Deploy your application to AWS with the help of [NestJS Mau](https://mau.nestjs.com) in just a few clicks.
+- Visualize your application graph and interact with the NestJS application in real-time using [NestJS Devtools](https://devtools.nestjs.com).
+- Need help with your project (part-time to full-time)? Check out our official [enterprise support](https://enterprise.nestjs.com).
+- To stay in the loop and get updates, follow us on [X](https://x.com/nestframework) and [LinkedIn](https://linkedin.com/company/nestjs).
+- Looking for a job, or have a job to offer? Check out our official [Jobs board](https://jobs.nestjs.com).
+
+## Support
+
+Nest is an MIT-licensed open source project. It can grow thanks to the sponsors and support by the amazing backers. If you'd like to join them, please [read more here](https://docs.nestjs.com/support).
+
+## Stay in touch
+
+- Author - [Kamil Myśliwiec](https://twitter.com/kammysliwiec)
+- Website - [https://nestjs.com](https://nestjs.com/)
+- Twitter - [@nestframework](https://twitter.com/nestframework)
+
+## License
+
+Nest is [MIT licensed](https://github.com/nestjs/nest/blob/master/LICENSE).

jest.base.config.ts

@@ -0,0 +1,35 @@
+import type { Config as JestConfig } from 'jest';
+import { pathsToModuleNameMapper } from 'ts-jest';
+import { compilerOptions as tsConfigCompilerOptions } from './tsconfig.json';
+
+type ArrayElement<A> = A extends readonly (infer T)[] ? T : never;
+type JestProjectConfig = Exclude<ArrayElement<JestConfig['projects']>, string>;
+
+const baseJestConfig: JestConfig = {
+  // ...
+};
+const baseJestProjectConfig: JestProjectConfig = {
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.(t|j)s$': 'ts-jest',
+  },
+  moduleNameMapper: pathsToModuleNameMapper(tsConfigCompilerOptions.paths, { prefix: '<rootDir>' }),
+  globalSetup: '<rootDir>/test/global-setup.ts',
+};
+const projects: { name?: string; rootDir: string }[] = [{ rootDir: '.' }];
+
+export function buildJestConfig(config?: {
+  jestConfigs?: JestConfig;
+  jestProjectConfigs?: JestProjectConfig;
+}): JestConfig {
+  return {
+    ...baseJestConfig,
+    ...config?.jestConfigs,
+    projects: projects.map(({ name, rootDir }) => ({
+      ...baseJestProjectConfig,
+      ...config?.jestProjectConfigs,
+      ...(name && { displayName: name }),
+      rootDir,
+    })),
+  };
+}

jest.config.ts

@@ -0,0 +1,16 @@
+import type { Config } from 'jest';
+import { buildJestConfig } from './jest.base.config';
+
+const config: Config = buildJestConfig({
+  jestProjectConfigs: {
+    testRegex: '.*\\.spec\\.ts$',
+    coveragePathIgnorePatterns: ['__testing__', 'entities', '<rootDir>/src/db', 'index.ts'],
+  },
+  jestConfigs: {
+    coverageDirectory: 'coverage',
+    collectCoverageFrom: ['<rootDir>/src/**/*.(t|j)s'],
+    coverageReporters: ['clover', 'json', 'lcov', 'text', 'text-summary', 'cobertura'],
+  },
+});
+
+export default config;

nest-cli.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://json.schemastore.org/nest-cli",
+  "collection": "@nestjs/schematics",
+  "sourceRoot": "src",
+  "compilerOptions": {
+    "deleteOutDir": true,
+    "watchAssets": true,
+    "assets": [
+      {
+        "include": "config",
+        "exclude": "**/*.md"
+      },
+      { "include": "common/modules/**/templates/**/*", "watchAssets": true },
+      { "include": "common/modules/neoleap/zod-certs" },
+      "i18n",
+      "files"
+    ]
+  }
+}

package.json

@@ -0,0 +1,124 @@
+{
+  "name": "test",
+  "version": "0.0.1",
+  "description": "",
+  "author": "",
+  "private": true,
+  "license": "UNLICENSED",
+  "scripts": {
+    "build": "nest build",
+    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+    "start": "nest start",
+    "start:dev": "nest start --watch",
+    "start:debug": "nest start --debug --watch",
+    "start:prod": "node dist/main",
+    "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:cov": "jest --coverage",
+    "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
+    "test:e2e": "jest --config ./test/jest-e2e.json",
+    "typeorm:cli": "./node_modules/.bin/ts-node -r tsconfig-paths/register ./node_modules/.bin/typeorm",
+    "typeorm:cli-d": "ts-node -r tsconfig-paths/register ./node_modules/.bin/typeorm -d typeorm.cli.ts",
+    "migration:generate": "npm run typeorm:cli-d migration:generate",
+    "migration:create": "npm run typeorm:cli migration:create",
+    "migration:up": "npm run typeorm:cli-d migration:run",
+    "migration:down": "npm run typeorm:cli-d migration:revert",
+    "seed": "TS_NODE_PROJECT=tsconfig.json ts-node -r tsconfig-paths/register src/scripts/seed.ts"
+  },
+  "dependencies": {
+    "@abdalhamid/hello": "^2.0.0",
+    "@hamid/hello": "file:../libraries/test-package",
+    "@keyv/redis": "^4.0.2",
+    "@nestjs-modules/mailer": "^2.0.2",
+    "@nestjs/axios": "^3.1.2",
+    "@nestjs/common": "^10.0.0",
+    "@nestjs/config": "^3.3.0",
+    "@nestjs/core": "^10.0.0",
+    "@nestjs/event-emitter": "^2.1.1",
+    "@nestjs/jwt": "^10.2.0",
+    "@nestjs/microservices": "^10.4.7",
+    "@nestjs/passport": "^10.0.3",
+    "@nestjs/platform-express": "^10.4.8",
+    "@nestjs/schedule": "^4.1.2",
+    "@nestjs/swagger": "^8.0.5",
+    "@nestjs/terminus": "^10.2.3",
+    "@nestjs/throttler": "^6.2.1",
+    "@nestjs/typeorm": "^10.0.2",
+    "amqp-connection-manager": "^4.1.14",
+    "amqplib": "^0.10.4",
+    "bcrypt": "^5.1.1",
+    "cacheable": "^1.8.5",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.1",
+    "decimal.js": "^10.6.0",
+    "firebase-admin": "^13.0.2",
+    "google-libphonenumber": "^3.2.39",
+    "handlebars": "^4.7.8",
+    "handlebars-layouts": "^3.1.4",
+    "jwk-to-pem": "^2.0.7",
+    "lodash": "^4.17.21",
+    "moment": "^2.30.1",
+    "nestjs-i18n": "^10.4.9",
+    "nestjs-pino": "^4.1.0",
+    "nestjs-twilio": "^4.4.0",
+    "nodemailer": "^6.9.16",
+    "oci-common": "^2.99.0",
+    "oci-sdk": "^2.99.0",
+    "passport": "^0.7.0",
+    "passport-jwt": "^4.0.1",
+    "pg": "^8.13.1",
+    "pino-http": "^10.3.0",
+    "pino-pretty": "^13.0.0",
+    "qrcode": "^1.5.4",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.1",
+    "typeorm": "^0.3.20",
+    "typeorm-transactional": "^0.5.0"
+  },
+  "devDependencies": {
+    "@golevelup/ts-jest": "^0.6.0",
+    "@nestjs/cli": "^10.0.0",
+    "@nestjs/schematics": "^10.0.0",
+    "@nestjs/testing": "^10.0.0",
+    "@types/bcrypt": "^5.0.2",
+    "@types/express": "^5.0.0",
+    "@types/google-libphonenumber": "^7.4.30",
+    "@types/jest": "^29.5.2",
+    "@types/jwk-to-pem": "^2.0.3",
+    "@types/lodash": "^4.17.13",
+    "@types/multer": "^1.4.12",
+    "@types/node": "^20.3.1",
+    "@types/nodemailer": "^6.4.16",
+    "@types/passport-jwt": "^4.0.1",
+    "@types/qrcode": "^1.5.5",
+    "@types/supertest": "^6.0.0",
+    "@types/uuid": "^10.0.0",
+    "@typescript-eslint/eslint-plugin": "^5.59.2",
+    "@typescript-eslint/parser": "^5.59.2",
+    "eslint": "^8.39.0",
+    "eslint-config-prettier": "^8.8.0",
+    "eslint-plugin-prettier": "^4.0.0",
+    "eslint-plugin-security": "^1.7.1",
+    "i": "^0.3.7",
+    "jest": "^29.5.0",
+    "lint-staged": "^13.2.2",
+    "npm": "^10.9.2",
+    "prettier": "^2.8.8",
+    "source-map-support": "^0.5.21",
+    "supertest": "^7.0.0",
+    "ts-jest": "^29.1.0",
+    "ts-loader": "^9.4.3",
+    "ts-node": "^10.9.1",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.1.3"
+  },
+  "lint-staged": {
+    "*.{js,ts}": [
+      "eslint --fix"
+    ],
+    "*.{js,ts,json,md}": [
+      "prettier --write"
+    ]
+  }
+}

src/app.module.ts

@@ -0,0 +1,97 @@
+import { MiddlewareConsumer, Module } from '@nestjs/common';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { APP_FILTER, APP_PIPE } from '@nestjs/core';
+import { EventEmitterModule } from '@nestjs/event-emitter';
+import { ScheduleModule } from '@nestjs/schedule';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { I18nMiddleware, I18nModule } from 'nestjs-i18n';
+import { LoggerModule } from 'nestjs-pino';
+import { DataSource } from 'typeorm';
+import { addTransactionalDataSource } from 'typeorm-transactional';
+import { AuthModule } from './auth/auth.module';
+import { CardModule } from './card/card.module';
+import { CacheModule } from './common/modules/cache/cache.module';
+import { LookupModule } from './common/modules/lookup/lookup.module';
+import { NeoLeapModule } from './common/modules/neoleap/neoleap.module';
+import { NotificationModule } from './common/modules/notification/notification.module';
+import { OtpModule } from './common/modules/otp/otp.module';
+import { AllExceptionsFilter, buildI18nValidationExceptionFilter } from './core/filters';
+import { buildConfigOptions, buildLoggerOptions, buildTypeormOptions } from './core/module-options';
+import { buildI18nOptions } from './core/module-options/i18n-options';
+import { buildValidationPipe } from './core/pipes';
+import { CronModule } from './cron/cron.module';
+import { CustomerModule } from './customer/customer.module';
+import { migrations } from './db';
+import { DocumentModule } from './document/document.module';
+import { GuardianModule } from './guardian/guardian.module';
+import { HealthModule } from './health/health.module';
+import { JuniorModule } from './junior/junior.module';
+import { UserModule } from './user/user.module';
+import { WebhookModule } from './webhook/webhook.module';
+import { MoneyRequestModule } from './money-request/money-request.module';
+
+@Module({
+  controllers: [],
+  imports: [
+    ConfigModule.forRoot(buildConfigOptions()),
+    TypeOrmModule.forRootAsync({
+      imports: [],
+      inject: [ConfigService],
+      useFactory: (config: ConfigService) => {
+        return buildTypeormOptions(config, migrations);
+      },
+      async dataSourceFactory(options) {
+        if (!options) {
+          throw new Error('Invalid options passed');
+        }
+
+        return addTransactionalDataSource(new DataSource(options));
+      },
+    }),
+    LoggerModule.forRootAsync({
+      useFactory: (config: ConfigService) => buildLoggerOptions(config),
+      inject: [ConfigService],
+    }),
+    I18nModule.forRoot(buildI18nOptions()),
+    CacheModule,
+    EventEmitterModule.forRoot(),
+    ScheduleModule.forRoot(),
+    // App modules
+    AuthModule,
+    UserModule,
+
+    CustomerModule,
+    JuniorModule,
+    GuardianModule,
+    CardModule,
+
+    NotificationModule,
+    OtpModule,
+    DocumentModule,
+    LookupModule,
+
+    HealthModule,
+
+    CronModule,
+    NeoLeapModule,
+    WebhookModule,
+    MoneyRequestModule,
+  ],
+  providers: [
+    // Global Pipes
+    {
+      inject: [ConfigService],
+      provide: APP_PIPE,
+      useFactory: (config: ConfigService) => buildValidationPipe(config),
+    },
+
+    // Global Filters (order matters)
+    { provide: APP_FILTER, useClass: AllExceptionsFilter },
+    { provide: APP_FILTER, useValue: buildI18nValidationExceptionFilter() },
+  ],
+})
+export class AppModule {
+  configure(consumer: MiddlewareConsumer) {
+    consumer.apply(I18nMiddleware).forRoutes('*');
+  }
+}

src/auth/auth.module.ts

@@ -0,0 +1,16 @@
+import { HttpModule } from '@nestjs/axios';
+import { Module } from '@nestjs/common';
+import { JwtModule } from '@nestjs/jwt';
+import { JuniorModule } from '~/junior/junior.module';
+import { UserModule } from '~/user/user.module';
+import { AuthController } from './controllers';
+import { AuthService } from './services';
+import { AccessTokenStrategy } from './strategies';
+
+@Module({
+  imports: [JwtModule.register({}), UserModule, JuniorModule, HttpModule],
+  providers: [AuthService, AccessTokenStrategy],
+  controllers: [AuthController],
+  exports: [],
+})
+export class AuthModule {}

src/auth/constants/country-code-regex.constant..ts

@@ -0,0 +1 @@
+export const COUNTRY_CODE_REGEX = /^\+\d{1,3}$/;

src/auth/constants/index.ts

@@ -0,0 +1,3 @@
+export * from './country-code-regex.constant.';
+export * from './passcode-regext.constant';
+export * from './password-regex.constant';

src/auth/constants/passcode-regext.constant.ts

@@ -0,0 +1 @@
+export const PASSCODE_REGEX = /^\d{6}$/;

src/auth/constants/password-regex.constant.ts

@@ -0,0 +1 @@
+export const PASSWORD_REGEX = /^(?=.*[A-Z])(?=.*[a-z])(?=.*\d)(?=.*[@$!%*?&#\-_])[A-Za-z\d@$!%*?&#\-_]{8,}$/;

src/auth/controllers/auth.controller.ts

@@ -0,0 +1,107 @@
+import { Body, Controller, HttpCode, HttpStatus, Post, Req, UseGuards } from '@nestjs/common';
+import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
+import { Request } from 'express';
+import { AuthenticatedUser, Public } from '~/common/decorators';
+import { AccessTokenGuard } from '~/common/guards';
+import { ApiDataResponse, ApiLangRequestHeader } from '~/core/decorators';
+import { ResponseFactory } from '~/core/utils';
+import {
+  ChangePasswordRequestDto,
+  CreateUnverifiedUserRequestDto,
+  ForgetPasswordRequestDto,
+  JuniorLoginRequestDto,
+  LoginRequestDto,
+  RefreshTokenRequestDto,
+  SendForgetPasswordOtpRequestDto,
+  setJuniorPasswordRequestDto,
+  VerifyForgetPasswordOtpRequestDto,
+  VerifyUserRequestDto,
+} from '../dtos/request';
+import { SendForgetPasswordOtpResponseDto, SendRegisterOtpResponseDto } from '../dtos/response';
+import { LoginResponseDto } from '../dtos/response/login.response.dto';
+import { VerifyForgetPasswordOtpResponseDto } from '../dtos/response/verify-forget-password-otp.response.dto';
+import { IJwtPayload } from '../interfaces';
+import { AuthService } from '../services';
+
+@Controller('auth')
+@ApiTags('Auth')
+@ApiBearerAuth()
+@ApiLangRequestHeader()
+export class AuthController {
+  constructor(private readonly authService: AuthService) {}
+  @Post('register/otp')
+  async register(@Body() createUnverifiedUserDto: CreateUnverifiedUserRequestDto) {
+    const phoneNumber = await this.authService.sendRegisterOtp(createUnverifiedUserDto);
+    return ResponseFactory.data(new SendRegisterOtpResponseDto(phoneNumber));
+  }
+
+  @Post('register/verify')
+  async verifyUser(@Body() verifyUserDto: VerifyUserRequestDto) {
+    const [res, user] = await this.authService.verifyUser(verifyUserDto);
+    return ResponseFactory.data(new LoginResponseDto(res, user));
+  }
+
+  @Post('login')
+  async login(@Body() verifyUserDto: LoginRequestDto) {
+    const [res, user] = await this.authService.loginWithPassword(verifyUserDto);
+    return ResponseFactory.data(new LoginResponseDto(res, user));
+  }
+
+  @Post('forget-password/otp')
+  async forgetPassword(@Body() sendForgetPasswordOtpDto: SendForgetPasswordOtpRequestDto) {
+    const maskedNumber = await this.authService.sendForgetPasswordOtp(sendForgetPasswordOtpDto);
+    return ResponseFactory.data(new SendForgetPasswordOtpResponseDto(maskedNumber));
+  }
+
+  @Post('forget-password/verify')
+  @HttpCode(HttpStatus.OK)
+  @ApiDataResponse(VerifyForgetPasswordOtpResponseDto)
+  async verifyForgetPasswordOtp(@Body() forgetPasswordDto: VerifyForgetPasswordOtpRequestDto) {
+    const { token, user } = await this.authService.verifyForgetPasswordOtp(forgetPasswordDto);
+
+    return ResponseFactory.data(new VerifyForgetPasswordOtpResponseDto(token, user));
+  }
+
+  @Post('forget-password/reset')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  resetPassword(@Body() forgetPasswordDto: ForgetPasswordRequestDto) {
+    return this.authService.resetPassword(forgetPasswordDto);
+  }
+
+  @Post('change-password')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  @UseGuards(AccessTokenGuard)
+  changePassword(@AuthenticatedUser() { sub }: IJwtPayload, @Body() forgetPasswordDto: ChangePasswordRequestDto) {
+    return this.authService.changePassword(sub, forgetPasswordDto);
+  }
+
+  @Post('junior/set-password')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  @Public()
+  setJuniorPasscode(@Body() setPassworddto: setJuniorPasswordRequestDto) {
+    return this.authService.setJuniorPassword(setPassworddto);
+  }
+
+  @Post('junior/login')
+  @HttpCode(HttpStatus.OK)
+  @ApiDataResponse(LoginResponseDto)
+  async juniorLogin(@Body() juniorLoginDto: JuniorLoginRequestDto) {
+    const [res, user] = await this.authService.juniorLogin(juniorLoginDto);
+
+    return ResponseFactory.data(new LoginResponseDto(res, user));
+  }
+
+  @Post('refresh-token')
+  @Public()
+  async refreshToken(@Body() { refreshToken }: RefreshTokenRequestDto) {
+    const [res, user] = await this.authService.refreshToken(refreshToken);
+    return ResponseFactory.data(new LoginResponseDto(res, user));
+  }
+
+  @Post('logout')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  @UseGuards(AccessTokenGuard)
+  async logout(@Req() request: Request) {
+    await this.authService.logout(request);
+  }
+}

src/auth/controllers/index.ts

@@ -0,0 +1 @@
+export * from './auth.controller';

src/auth/dtos/request/change-password.request.dto.ts

@@ -0,0 +1,23 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsNotEmpty, IsString, Matches } from 'class-validator';
+import { i18nValidationMessage as i18n } from 'nestjs-i18n';
+import { PASSWORD_REGEX } from '~/auth/constants';
+
+export class ChangePasswordRequestDto {
+  @ApiProperty({ example: 'currentPassword@123' })
+  @IsString({ message: i18n('validation.IsString', { path: 'general', property: 'auth.currentPassword' }) })
+  @IsNotEmpty({ message: i18n('validation.IsNotEmpty', { path: 'general', property: 'auth.currentPassword' }) })
+  currentPassword!: string;
+
+  @ApiProperty({ example: 'Abcd1234@' })
+  @Matches(PASSWORD_REGEX, {
+    message: i18n('validation.Matches', { path: 'general', property: 'auth.newPassword' }),
+  })
+  newPassword!: string;
+
+  @ApiProperty({ example: 'Abcd1234@' })
+  @Matches(PASSWORD_REGEX, {
+    message: i18n('validation.Matches', { path: 'general', property: 'auth.confirmNewPassword' }),
+  })
+  confirmNewPassword!: string;
+}

src/auth/dtos/request/create-unverified-user.request.dto.ts

@@ -0,0 +1,4 @@
+import { OmitType } from '@nestjs/swagger';
+import { VerifyUserRequestDto } from './verify-user.request.dto';
+
+export class CreateUnverifiedUserRequestDto extends OmitType(VerifyUserRequestDto, ['otp']) {}

src/auth/dtos/request/forget-password.request.dto.ts

@@ -0,0 +1,34 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsString, Matches } from 'class-validator';
+import { i18nValidationMessage as i18n } from 'nestjs-i18n';
+import { COUNTRY_CODE_REGEX, PASSWORD_REGEX } from '~/auth/constants';
+import { IsValidPhoneNumber } from '~/core/decorators/validations';
+export class ForgetPasswordRequestDto {
+  @ApiProperty({ example: '+962' })
+  @Matches(COUNTRY_CODE_REGEX, {
+    message: i18n('validation.Matches', { path: 'general', property: 'auth.countryCode' }),
+  })
+  countryCode!: string;
+
+  @ApiProperty({ example: '787259134' })
+  @IsValidPhoneNumber({
+    message: i18n('validation.IsValidPhoneNumber', { path: 'general', property: 'auth.phoneNumber' }),
+  })
+  phoneNumber!: string;
+
+  @ApiProperty({ example: 'Abcd1234@' })
+  @Matches(PASSWORD_REGEX, {
+    message: i18n('validation.Matches', { path: 'general', property: 'auth.password' }),
+  })
+  password!: string;
+
+  @ApiProperty({ example: 'Abcd1234@' })
+  @Matches(PASSWORD_REGEX, {
+    message: i18n('validation.Matches', { path: 'general', property: 'auth.confirmPassword' }),
+  })
+  confirmPassword!: string;
+
+  @ApiProperty({ example: 'reset-token-32423123' })
+  @IsString({ message: i18n('validation.IsString', { path: 'general', property: 'auth.resetPasswordToken' }) })
+  resetPasswordToken!: string;
+}

src/auth/dtos/request/index.ts

@@ -0,0 +1,11 @@
+export * from './change-password.request.dto';
+export * from './create-unverified-user.request.dto';
+export * from './forget-password.request.dto';
+export * from './junior-login.request.dto';
+export * from './login.request.dto';
+export * from './refresh-token.request.dto';
+export * from './send-forget-password-otp.request.dto';
+export * from './set-junior-password.request.dto';
+export * from './verify-forget-password-otp.request.dto';
+export * from './verify-otp.request.dto';
+export * from './verify-user.request.dto';

src/auth/dtos/request/junior-login.request.dto.ts

@@ -0,0 +1,26 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsEmail, IsOptional, IsString } from 'class-validator';
+import { i18nValidationMessage as i18n } from 'nestjs-i18n';
+export class JuniorLoginRequestDto {
+  @ApiProperty({ example: '[email protected]' })
+  @IsEmail({}, { message: i18n('validation.IsEmail', { path: 'general', property: 'auth.email' }) })
+  email!: string;
+
+  @ApiProperty({ example: 'Abcd1234@' })
+  @IsString({ message: i18n('validation.IsString', { path: 'general', property: 'auth.password' }) })
+  password!: string;
+
+  @ApiProperty({ example: 'device-123', description: 'Unique device identifier', required: false })
+  @IsOptional()
+  @IsString({ message: i18n('validation.IsString', { path: 'general', property: 'auth.deviceId' }) })
+  deviceId?: string;
+
+  @ApiProperty({
+    example: 'cXYzABC:APA91bHunvwY7rKpn8N7y6vDxS0qmQ5RZx2C8K...',
+    description: 'Firebase Cloud Messaging token for push notifications',
+    required: false,
+  })
+  @IsOptional()
+  @IsString({ message: i18n('validation.IsString', { path: 'general', property: 'auth.fcmToken' }) })
+  fcmToken?: string;
+}

src/auth/dtos/request/login.request.dto.ts

@@ -0,0 +1,38 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsEmail, IsEnum, IsNotEmpty, IsOptional, IsString, Matches, ValidateIf } from 'class-validator';
+import { i18nValidationMessage as i18n } from 'nestjs-i18n';
+import { COUNTRY_CODE_REGEX } from '~/auth/constants';
+import { GrantType } from '~/auth/enums';
+import { IsValidPhoneNumber } from '~/core/decorators/validations';
+export class LoginRequestDto {
+  @ApiProperty({ example: '+962' })
+  @Matches(COUNTRY_CODE_REGEX, {
+    message: i18n('validation.Matches', { path: 'general', property: 'auth.countryCode' }),
+  })
+  countryCode!: string;
+
+  @ApiProperty({ example: '787259134' })
+  @IsValidPhoneNumber({
+    message: i18n('validation.IsValidPhoneNumber', { path: 'general', property: 'auth.phoneNumber' }),
+  })
+  phoneNumber!: string;
+
+  @ApiProperty({ example: 'Abcd1234@' })
+  @IsString({ message: i18n('validation.IsString', { path: 'general', property: 'auth.password' }) })
+  @ValidateIf((o) => o.grantType === GrantType.PASSWORD)
+  password!: string;
+
+  @ApiProperty({ example: 'device-123', description: 'Unique device identifier', required: false })
+  @IsOptional()
+  @IsString({ message: i18n('validation.IsString', { path: 'general', property: 'auth.deviceId' }) })
+  deviceId?: string;
+
+  @ApiProperty({
+    example: 'cXYzABC:APA91bHunvwY7rKpn8N7y6vDxS0qmQ5RZx2C8K...',
+    description: 'Firebase Cloud Messaging token for push notifications',
+    required: false,
+  })
+  @IsOptional()
+  @IsString({ message: i18n('validation.IsString', { path: 'general', property: 'auth.fcmToken' }) })
+  fcmToken?: string;
+}

src/auth/dtos/request/refresh-token.request.dto.ts

@@ -0,0 +1,9 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsNotEmpty, IsString } from 'class-validator';
+import { i18nValidationMessage as i18n } from 'nestjs-i18n';
+export class RefreshTokenRequestDto {
+  @ApiProperty()
+  @IsString({ message: i18n('validation.isString', { path: 'general', property: 'auth.refreshToken' }) })
+  @IsNotEmpty({ message: i18n('validation.required', { path: 'general', property: 'auth.refreshToken' }) })
+  refreshToken!: string;
+}

src/auth/dtos/request/send-forget-password-otp.request.dto.ts

@@ -0,0 +1,4 @@
+import { PickType } from '@nestjs/swagger';
+import { LoginRequestDto } from './login.request.dto';
+
+export class SendForgetPasswordOtpRequestDto extends PickType(LoginRequestDto, ['countryCode', 'phoneNumber']) {}

src/auth/dtos/request/set-junior-password.request.dto.ts

@@ -0,0 +1,13 @@
+import { ApiProperty, PickType } from '@nestjs/swagger';
+import { IsNotEmpty, IsString } from 'class-validator';
+import { i18nValidationMessage as i18n } from 'nestjs-i18n';
+import { ChangePasswordRequestDto } from './change-password.request.dto';
+export class setJuniorPasswordRequestDto extends PickType(ChangePasswordRequestDto, [
+  'newPassword',
+  'confirmNewPassword',
+]) {
+  @ApiProperty()
+  @IsString({ message: i18n('validation.IsNumberString', { path: 'general', property: 'auth.qrToken' }) })
+  @IsNotEmpty({ message: i18n('validation.IsNotEmpty', { path: 'general', property: 'auth.qrToken' }) })
+  qrToken!: string;
+}

src/auth/dtos/request/verify-forget-password-otp.request.dto.ts

@@ -0,0 +1,23 @@
+import { ApiProperty, PickType } from '@nestjs/swagger';
+import { IsNumberString, MaxLength, MinLength } from 'class-validator';
+import { i18nValidationMessage as i18n } from 'nestjs-i18n';
+import { DEFAULT_OTP_LENGTH } from '~/common/modules/otp/constants';
+import { ForgetPasswordRequestDto } from './forget-password.request.dto';
+
+export class VerifyForgetPasswordOtpRequestDto extends PickType(ForgetPasswordRequestDto, [
+  'countryCode',
+  'phoneNumber',
+]) {
+  @ApiProperty({ example: '111111' })
+  @IsNumberString(
+    { no_symbols: true },
+    { message: i18n('validation.IsNumberString', { path: 'general', property: 'auth.otp' }) },
+  )
+  @MaxLength(DEFAULT_OTP_LENGTH, {
+    message: i18n('validation.MaxLength', { path: 'general', property: 'auth.otp', length: DEFAULT_OTP_LENGTH }),
+  })
+  @MinLength(DEFAULT_OTP_LENGTH, {
+    message: i18n('validation.MinLength', { path: 'general', property: 'auth.otp', length: DEFAULT_OTP_LENGTH }),
+  })
+  otp!: string;
+}

src/auth/dtos/request/verify-otp.request.dto.ts

@@ -0,0 +1,19 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsNumberString, MaxLength, MinLength } from 'class-validator';
+import { i18nValidationMessage as i18n } from 'nestjs-i18n';
+import { DEFAULT_OTP_LENGTH } from '~/common/modules/otp/constants';
+
+export class VerifyOtpRequestDto {
+  @ApiProperty({ example: '111111' })
+  @IsNumberString(
+    { no_symbols: true },
+    { message: i18n('validation.IsNumberString', { path: 'general', property: 'auth.otp' }) },
+  )
+  @MaxLength(DEFAULT_OTP_LENGTH, {
+    message: i18n('validation.MaxLength', { path: 'general', property: 'auth.otp', length: DEFAULT_OTP_LENGTH }),
+  })
+  @MinLength(DEFAULT_OTP_LENGTH, {
+    message: i18n('validation.MinLength', { path: 'general', property: 'auth.otp', length: DEFAULT_OTP_LENGTH }),
+  })
+  otp!: string;
+}

src/auth/dtos/request/verify-user.request.dto.ts

@@ -0,0 +1,118 @@
+import { ApiProperty } from '@nestjs/swagger';
+import {
+  IsEnum,
+  IsNotEmpty,
+  IsNumberString,
+  IsOptional,
+  IsString,
+  Matches,
+  MaxLength,
+  MinLength,
+} from 'class-validator';
+import { i18nValidationMessage as i18n } from 'nestjs-i18n';
+import { COUNTRY_CODE_REGEX, PASSWORD_REGEX } from '~/auth/constants';
+import { CountryIso } from '~/common/enums';
+import { DEFAULT_OTP_LENGTH } from '~/common/modules/otp/constants';
+import { IsValidPhoneNumber } from '~/core/decorators/validations';
+
+export class VerifyUserRequestDto {
+  @ApiProperty({ example: '+962' })
+  @Matches(COUNTRY_CODE_REGEX, {
+    message: i18n('validation.Matches', { path: 'general', property: 'auth.countryCode' }),
+  })
+  countryCode!: string;
+
+  @ApiProperty({ example: '787259134' })
+  @IsValidPhoneNumber({
+    message: i18n('validation.IsValidPhoneNumber', { path: 'general', property: 'auth.phoneNumber' }),
+  })
+  phoneNumber!: string;
+  @ApiProperty({ example: 'John' })
+  @IsString({ message: i18n('validation.IsString', { path: 'general', property: 'customer.firstName' }) })
+  @IsNotEmpty({ message: i18n('validation.IsNotEmpty', { path: 'general', property: 'customer.firstName' }) })
+  firstName!: string;
+
+  @ApiProperty({ example: 'Doe' })
+  @IsString({ message: i18n('validation.IsString', { path: 'general', property: 'customer.lastName' }) })
+  @IsNotEmpty({ message: i18n('validation.IsNotEmpty', { path: 'general', property: 'customer.lastName' }) })
+  lastName!: string;
+
+  @ApiProperty({ example: 'JO' })
+  @IsEnum(CountryIso, {
+    message: i18n('validation.IsEnum', { path: 'general', property: 'customer.countryOfResidence' }),
+  })
+  @IsOptional()
+  countryOfResidence: CountryIso = CountryIso.SAUDI_ARABIA;
+
+  // Address fields (optional during registration, required for card creation)
+  @ApiProperty({ example: 'SA', description: 'Country code', required: false })
+  @IsEnum(CountryIso, {
+    message: i18n('validation.IsEnum', { path: 'general', property: 'customer.country' }),
+  })
+  @IsOptional()
+  country?: CountryIso;
+
+  @ApiProperty({ example: 'Riyadh', description: 'Region/Province', required: false })
+  @IsString({ message: i18n('validation.IsString', { path: 'general', property: 'customer.region' }) })
+  @IsOptional()
+  region?: string;
+
+  @ApiProperty({ example: 'Riyadh', description: 'City', required: false })
+  @IsString({ message: i18n('validation.IsString', { path: 'general', property: 'customer.city' }) })
+  @IsOptional()
+  city?: string;
+
+  @ApiProperty({ example: 'Al Olaya', description: 'Neighborhood/District', required: false })
+  @IsString({ message: i18n('validation.IsString', { path: 'general', property: 'customer.neighborhood' }) })
+  @IsOptional()
+  neighborhood?: string;
+
+  @ApiProperty({ example: 'King Fahd Road', description: 'Street name', required: false })
+  @IsString({ message: i18n('validation.IsString', { path: 'general', property: 'customer.street' }) })
+  @IsOptional()
+  street?: string;
+
+  @ApiProperty({ example: '123', description: 'Building number', required: false })
+  @IsString({ message: i18n('validation.IsString', { path: 'general', property: 'customer.building' }) })
+  @IsOptional()
+  building?: string;
+
+  @ApiProperty({ example: 'Abcd1234@' })
+  @Matches(PASSWORD_REGEX, {
+    message: i18n('validation.Matches', { path: 'general', property: 'auth.password' }),
+  })
+  password!: string;
+
+  @ApiProperty({ example: 'Abcd1234@' })
+  @Matches(PASSWORD_REGEX, {
+    message: i18n('validation.Matches', { path: 'general', property: 'auth.confirmPassword' }),
+  })
+  confirmPassword!: string;
+
+  @ApiProperty({ example: '111111' })
+  @IsNumberString(
+    { no_symbols: true },
+    { message: i18n('validation.IsNumberString', { path: 'general', property: 'auth.otp' }) },
+  )
+  @MaxLength(DEFAULT_OTP_LENGTH, {
+    message: i18n('validation.MaxLength', { path: 'general', property: 'auth.otp', length: DEFAULT_OTP_LENGTH }),
+  })
+  @MinLength(DEFAULT_OTP_LENGTH, {
+    message: i18n('validation.MinLength', { path: 'general', property: 'auth.otp', length: DEFAULT_OTP_LENGTH }),
+  })
+  otp!: string;
+
+  @ApiProperty({ example: 'device-123', description: 'Unique device identifier', required: false })
+  @IsOptional()
+  @IsString({ message: i18n('validation.IsString', { path: 'general', property: 'auth.deviceId' }) })
+  deviceId?: string;
+
+  @ApiProperty({
+    example: 'cXYzABC:APA91bHunvwY7rKpn8N7y6vDxS0qmQ5RZx2C8K...',
+    description: 'Firebase Cloud Messaging token for push notifications',
+    required: false,
+  })
+  @IsOptional()
+  @IsString({ message: i18n('validation.IsString', { path: 'general', property: 'auth.fcmToken' }) })
+  fcmToken?: string;
+}

src/auth/dtos/response/index.ts

@@ -0,0 +1,4 @@
+export * from './send-forget-password.response.dto';
+export * from './send-register-otp.response.dto';
+export * from './user.response.dto';
+export * from './verify-user.response.dto';

src/auth/dtos/response/login.response.dto.ts

@@ -0,0 +1,30 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { ILoginResponse } from '~/auth/interfaces';
+import { CustomerResponseDto } from '~/customer/dtos/response';
+import { User } from '~/user/entities';
+import { UserResponseDto } from './user.response.dto';
+
+export class LoginResponseDto {
+  @ApiProperty()
+  accessToken!: string;
+
+  @ApiProperty()
+  refreshToken!: string;
+
+  @ApiProperty()
+  expiresAt!: Date;
+
+  @ApiProperty({ example: UserResponseDto })
+  user!: UserResponseDto;
+
+  @ApiProperty({ type: CustomerResponseDto })
+  customer!: CustomerResponseDto | null;
+
+  constructor(IVerifyUserResponse: ILoginResponse, user: User) {
+    this.user = new UserResponseDto(user);
+    this.customer = user.customer ? new CustomerResponseDto(user.customer) : null;
+    this.accessToken = IVerifyUserResponse.accessToken;
+    this.refreshToken = IVerifyUserResponse.refreshToken;
+    this.expiresAt = IVerifyUserResponse.expiresAt;
+  }
+}

src/auth/dtos/response/send-forget-password.response.dto.ts

@@ -0,0 +1,7 @@
+export class SendForgetPasswordOtpResponseDto {
+  maskedNumber!: string;
+
+  constructor(maskedNumber: string) {
+    this.maskedNumber = maskedNumber;
+  }
+}

src/auth/dtos/response/send-register-otp.response.dto.ts

@@ -0,0 +1,10 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+export class SendRegisterOtpResponseDto {
+  @ApiProperty()
+  maskedNumber!: string;
+
+  constructor(maskedNumber: string) {
+    this.maskedNumber = maskedNumber;
+  }
+}

src/auth/dtos/response/send-register-otp.v2.response.dto.ts

@@ -0,0 +1,10 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+export class SendRegisterOtpV2ResponseDto {
+  @ApiProperty()
+  maskedNumber!: string;
+
+  constructor(maskedNumber: string) {
+    this.maskedNumber = maskedNumber;
+  }
+}

src/auth/dtos/response/user.response.dto.ts

@@ -0,0 +1,54 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Gender } from '~/customer/enums';
+import { DocumentMetaResponseDto } from '~/document/dtos/response';
+import { User } from '~/user/entities';
+
+export class UserResponseDto {
+  @ApiProperty()
+  id!: string;
+
+  @ApiProperty()
+  countryCode!: string;
+
+  @ApiProperty()
+  phoneNumber!: string;
+
+  @ApiProperty()
+  email!: string;
+
+  @ApiProperty()
+  firstName!: string;
+
+  @ApiProperty()
+  lastName!: string;
+
+  @ApiProperty()
+  dateOfBirth!: Date;
+
+  @ApiPropertyOptional({ type: DocumentMetaResponseDto, nullable: true })
+  profilePicture!: DocumentMetaResponseDto | null;
+
+  @ApiProperty()
+  isPhoneVerified!: boolean;
+
+  @ApiProperty()
+  isEmailVerified!: boolean;
+
+  @ApiPropertyOptional({ enum: Gender, nullable: true })
+  gender!: Gender | null;
+
+
+  constructor(user: User) {
+    this.id = user.id;
+    this.countryCode = user.countryCode;
+    this.phoneNumber = user.phoneNumber;
+    this.dateOfBirth = user.customer?.dateOfBirth;
+    this.email = user.email;
+    this.firstName = user.firstName;
+    this.lastName = user.lastName;
+    this.profilePicture = user.profilePicture ? new DocumentMetaResponseDto(user.profilePicture) : null;
+    this.isEmailVerified = user.isEmailVerified;
+    this.isPhoneVerified = user.isPhoneVerified;
+    this.gender = (user.customer?.gender as Gender) || null;
+  }
+}

src/auth/dtos/response/verify-forget-password-otp.response.dto.ts

@@ -0,0 +1,19 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { User } from '~/user/entities';
+
+export class VerifyForgetPasswordOtpResponseDto {
+  @ApiProperty()
+  phoneNumber!: string;
+
+  @ApiProperty()
+  countryCode!: string;
+
+  @ApiProperty()
+  resetPasswordToken!: string;
+
+  constructor(token: string, user: User) {
+    this.phoneNumber = user.phoneNumber;
+    this.countryCode = user.countryCode;
+    this.resetPasswordToken = token;
+  }
+}

src/auth/dtos/response/verify-user.response.dto.ts

@@ -0,0 +1,24 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { ILoginResponse } from '~/auth/interfaces';
+import { User } from '~/user/entities';
+
+export class VerifyUserResponseDto {
+  @ApiProperty()
+  accessToken!: string;
+
+  @ApiProperty()
+  refreshToken!: string;
+
+  @ApiProperty()
+  expiresAt!: Date;
+
+  @ApiProperty()
+  user!: User;
+
+  constructor(data: ILoginResponse, user: User) {
+    this.accessToken = data.accessToken;
+    this.refreshToken = data.refreshToken;
+    this.expiresAt = data.expiresAt;
+    this.user = user;
+  }
+}

src/auth/enums/grant-type.enum.ts

@@ -0,0 +1,4 @@
+export enum GrantType {
+  PASSWORD = 'PASSWORD',
+  BIOMETRIC = 'BIOMETRIC',
+}

src/auth/enums/index.ts

@@ -0,0 +1,2 @@
+export * from './grant-type.enum';
+export * from './roles.enum';

src/auth/enums/roles.enum.ts

@@ -0,0 +1,6 @@
+export enum Roles {
+  JUNIOR = 'JUNIOR',
+  GUARDIAN = 'GUARDIAN',
+  CHECKER = 'CHECKER',
+  SUPER_ADMIN = 'SUPER_ADMIN',
+}

src/auth/interfaces/index.ts

@@ -0,0 +1,2 @@
+export * from './jwt-payload.interface';
+export * from './login-response.interface';

src/auth/interfaces/jwt-payload.interface.ts

@@ -0,0 +1,6 @@
+import { Roles } from '../enums';
+
+export interface IJwtPayload {
+  sub: string;
+  roles: Roles[];
+}

src/auth/interfaces/login-response.interface.ts

@@ -0,0 +1,5 @@
+export interface ILoginResponse {
+  accessToken: string;
+  refreshToken: string;
+  expiresAt: Date;
+}

src/auth/services/auth.service.ts

@@ -0,0 +1,395 @@
+import { BadRequestException, Injectable, Logger, UnauthorizedException } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { JwtService } from '@nestjs/jwt';
+import * as bcrypt from 'bcrypt';
+import { Request } from 'express';
+import moment from 'moment';
+import { CacheService } from '~/common/modules/cache/services';
+import { OtpScope, OtpType } from '~/common/modules/otp/enums';
+import { OtpService } from '~/common/modules/otp/services';
+import { UserType } from '~/user/enums';
+import { DeviceService, UserService, UserTokenService } from '~/user/services';
+import { User } from '../../user/entities';
+import {
+  ChangePasswordRequestDto,
+  CreateUnverifiedUserRequestDto,
+  ForgetPasswordRequestDto,
+  JuniorLoginRequestDto,
+  LoginRequestDto,
+  SendForgetPasswordOtpRequestDto,
+  setJuniorPasswordRequestDto,
+  VerifyForgetPasswordOtpRequestDto,
+  VerifyUserRequestDto,
+} from '../dtos/request';
+import { Roles } from '../enums';
+import { IJwtPayload, ILoginResponse } from '../interfaces';
+
+const ONE_THOUSAND = 1000;
+const SALT_ROUNDS = 10;
+@Injectable()
+export class AuthService {
+  private readonly logger = new Logger(AuthService.name);
+
+  constructor(
+    private readonly otpService: OtpService,
+    private readonly jwtService: JwtService,
+    private readonly configService: ConfigService,
+    private readonly userService: UserService,
+    private readonly deviceService: DeviceService,
+    private readonly userTokenService: UserTokenService,
+    private readonly cacheService: CacheService,
+  ) {}
+
+  async sendRegisterOtp(body: CreateUnverifiedUserRequestDto) {
+    if (body.password !== body.confirmPassword) {
+      this.logger.error('Password and confirm password do not match');
+      throw new BadRequestException('AUTH.PASSWORD_MISMATCH');
+    }
+
+    this.logger.log(`Sending OTP to ${body.countryCode + body.phoneNumber}`);
+    const user = await this.userService.findOrCreateUser(body);
+    return this.otpService.generateAndSendOtp({
+      userId: user.id,
+      recipient: user.fullPhoneNumber,
+      scope: OtpScope.VERIFY_PHONE,
+      otpType: OtpType.SMS,
+    });
+  }
+
+  async verifyUser(verifyUserDto: VerifyUserRequestDto): Promise<[ILoginResponse, User]> {
+    this.logger.log(`Verifying user with phone number ${verifyUserDto.countryCode + verifyUserDto.phoneNumber}`);
+    const user = await this.userService.findUserOrThrow({
+      phoneNumber: verifyUserDto.phoneNumber,
+      countryCode: verifyUserDto.countryCode,
+    });
+
+    if (user.isPhoneVerified) {
+      this.logger.error(`User with phone number ${user.fullPhoneNumber} already verified`);
+      throw new BadRequestException('USER.PHONE_NUMBER_ALREADY_VERIFIED');
+    }
+
+    const isOtpValid = await this.otpService.verifyOtp({
+      userId: user.id,
+      scope: OtpScope.VERIFY_PHONE,
+      otpType: OtpType.SMS,
+      value: verifyUserDto.otp,
+    });
+
+    if (!isOtpValid) {
+      this.logger.error(`Invalid OTP for user with phone number ${user.fullPhoneNumber}`);
+      throw new BadRequestException('OTP.INVALID_OTP');
+    }
+
+    await this.userService.verifyUser(user.id, verifyUserDto);
+
+    await user.reload();
+
+    const tokens = await this.generateAuthToken(user);
+    this.logger.log(`User with phone number ${user.fullPhoneNumber} verified successfully`);
+
+    // Register/update device with FCM token if provided
+    if (verifyUserDto.fcmToken && verifyUserDto.deviceId) {
+      await this.registerDeviceToken(user.id, verifyUserDto.deviceId, verifyUserDto.fcmToken);
+    }
+
+    return [tokens, user];
+  }
+
+  async sendForgetPasswordOtp({ countryCode, phoneNumber }: SendForgetPasswordOtpRequestDto) {
+    this.logger.log(`Sending forget password OTP to ${countryCode + phoneNumber}`);
+    const user = await this.userService.findUserOrThrow({ countryCode, phoneNumber });
+
+    return this.otpService.generateAndSendOtp({
+      userId: user.id,
+      recipient: user.fullPhoneNumber,
+      scope: OtpScope.FORGET_PASSWORD,
+      otpType: OtpType.SMS,
+    });
+  }
+
+  async verifyForgetPasswordOtp({ countryCode, phoneNumber, otp }: VerifyForgetPasswordOtpRequestDto) {
+    const user = await this.userService.findUserOrThrow({ countryCode, phoneNumber });
+
+    const isOtpValid = await this.otpService.verifyOtp({
+      userId: user.id,
+      scope: OtpScope.FORGET_PASSWORD,
+      otpType: OtpType.SMS,
+      value: otp,
+    });
+
+    if (!isOtpValid) {
+      this.logger.error(`Invalid OTP for user with phone number ${user.fullPhoneNumber}`);
+      throw new BadRequestException('OTP.INVALID_OTP');
+    }
+
+    // generate a token for the user to reset password
+    const token = await this.userTokenService.generateToken(user.id, moment().add(5, 'minutes').toDate());
+
+    return { token, user };
+  }
+
+  async resetPassword({
+    countryCode,
+    phoneNumber,
+    resetPasswordToken,
+    password,
+    confirmPassword,
+  }: ForgetPasswordRequestDto) {
+    this.logger.log(`Verifying forget password OTP for ${countryCode + phoneNumber}`);
+    const user = await this.userService.findUserOrThrow({ countryCode, phoneNumber });
+    await this.userTokenService.validateToken(
+      resetPasswordToken,
+      user.roles.includes(Roles.GUARDIAN) ? UserType.GUARDIAN : UserType.JUNIOR,
+    );
+
+    if (password !== confirmPassword) {
+      this.logger.error('Password and confirm password do not match');
+      throw new BadRequestException('AUTH.PASSWORD_MISMATCH');
+    }
+
+    const isOldPassword = bcrypt.compareSync(password, user.password);
+
+    if (isOldPassword) {
+      this.logger.error(
+        `New password cannot be the same as the current password for user with phone number ${user.fullPhoneNumber}`,
+      );
+      throw new BadRequestException('AUTH.PASSWORD_SAME_AS_CURRENT');
+    }
+
+    const hashedPassword = bcrypt.hashSync(password, user.salt);
+
+    await this.userService.setPassword(user.id, hashedPassword, user.salt);
+    await this.userTokenService.invalidateToken(resetPasswordToken);
+    this.logger.log(`Passcode updated successfully for user with phone number ${user.fullPhoneNumber}`);
+  }
+
+  async changePassword(userId: string, { currentPassword, newPassword, confirmNewPassword }: ChangePasswordRequestDto) {
+    const user = await this.userService.findUserOrThrow({ id: userId });
+
+    if (!user.isPasswordSet) {
+      this.logger.error(`Password not set for user with id ${userId}`);
+      throw new BadRequestException('AUTH.PASSWORD_NOT_SET');
+    }
+
+    if (currentPassword === newPassword) {
+      this.logger.error('New password cannot be the same as current password');
+      throw new BadRequestException('AUTH.PASSWORD_SAME_AS_CURRENT');
+    }
+
+    if (newPassword !== confirmNewPassword) {
+      this.logger.error('New password and confirm new password do not match');
+      throw new BadRequestException('AUTH.PASSWORD_MISMATCH');
+    }
+
+    this.logger.log(`Validating current password for user with id ${userId}`);
+    const isCurrentPasswordValid = bcrypt.compareSync(currentPassword, user.password);
+
+    if (!isCurrentPasswordValid) {
+      this.logger.error(`Invalid current password for user with id ${userId}`);
+      throw new UnauthorizedException('AUTH.INVALID_CURRENT_PASSWORD');
+    }
+
+    const salt = bcrypt.genSaltSync(SALT_ROUNDS);
+    const hashedNewPassword = bcrypt.hashSync(newPassword, salt);
+    await this.userService.setPassword(user.id, hashedNewPassword, salt);
+    this.logger.log(`Password changed successfully for user with id ${userId}`);
+  }
+
+  async setJuniorPassword(body: setJuniorPasswordRequestDto) {
+    this.logger.log(`Setting passcode for junior with qrToken ${body.qrToken}`);
+    if (body.newPassword != body.confirmNewPassword) {
+      throw new BadRequestException('AUTH.PASSWORD_MISMATCH');
+    }
+    const juniorId = await this.userTokenService.validateToken(body.qrToken, UserType.JUNIOR);
+    const salt = bcrypt.genSaltSync(SALT_ROUNDS);
+    const hashedPasscode = bcrypt.hashSync(body.newPassword, salt);
+    await this.userService.setPassword(juniorId!, hashedPasscode, salt);
+    await this.userTokenService.invalidateToken(body.qrToken);
+    this.logger.log(`Passcode set successfully for junior with id ${juniorId}`);
+  }
+
+  async refreshToken(refreshToken: string): Promise<[ILoginResponse, User]> {
+    this.logger.log('Refreshing token');
+
+    const isBlackListed = await this.cacheService.get(refreshToken);
+
+    if (isBlackListed) {
+      this.logger.error('Refresh token is blacklisted');
+      throw new BadRequestException('AUTH.INVALID_REFRESH_TOKEN');
+    }
+
+    try {
+      const isValid = await this.jwtService.verifyAsync<IJwtPayload>(refreshToken, {
+        secret: this.configService.getOrThrow('JWT_REFRESH_TOKEN_SECRET'),
+      });
+
+      this.logger.log(`Refreshing token for user with id ${isValid.sub}`);
+
+      const user = await this.userService.findUserOrThrow({ id: isValid.sub });
+
+      const tokens = await this.generateAuthToken(user);
+
+      this.logger.log(`Blacklisting old tokens for user with id ${isValid.sub}`);
+
+      const refreshTokenExpiry = this.jwtService.decode(refreshToken).exp - Date.now() / ONE_THOUSAND;
+
+      await this.cacheService.set(refreshToken, 'BLACKLISTED', refreshTokenExpiry);
+
+      this.logger.log(`Token refreshed successfully for user with id ${isValid.sub}`);
+
+      return [tokens, user];
+    } catch (error) {
+      this.logger.error('Invalid refresh token');
+      throw new BadRequestException('AUTH.INVALID_REFRESH_TOKEN');
+    }
+  }
+
+  logout(req: Request) {
+    this.logger.log('Logging out');
+    const accessToken = req.headers.authorization?.split(' ')[1] as string;
+    const expiryInTtl = this.jwtService.decode(accessToken).exp - Date.now() / ONE_THOUSAND;
+    return this.cacheService.set(accessToken, 'BLACKLISTED', expiryInTtl);
+  }
+
+  async loginWithPassword(loginDto: LoginRequestDto): Promise<[ILoginResponse, User]> {
+    const user = await this.userService.findUser({
+      countryCode: loginDto.countryCode,
+      phoneNumber: loginDto.phoneNumber,
+    });
+
+    if (!user) {
+      this.logger.error(`User not found with phone number ${loginDto.countryCode + loginDto.phoneNumber}`);
+      throw new UnauthorizedException('AUTH.INVALID_CREDENTIALS');
+    }
+
+    if (!user.password) {
+      this.logger.error(`Password not set for user with phone number ${loginDto.countryCode + loginDto.phoneNumber}`);
+      throw new UnauthorizedException('AUTH.PHONE_NUMBER_NOT_VERIFIED');
+    }
+
+    this.logger.log(`validating password for user with phone ${loginDto.countryCode + loginDto.phoneNumber}`);
+    const isPasswordValid = bcrypt.compareSync(loginDto.password, user.password);
+
+    if (!isPasswordValid) {
+      this.logger.error(`Invalid password for user with phone ${loginDto.countryCode + loginDto.phoneNumber}`);
+      throw new UnauthorizedException('AUTH.INVALID_CREDENTIALS');
+    }
+
+    const tokens = await this.generateAuthToken(user);
+    this.logger.log(`Password validated successfully for user`);
+
+    // Register/update device with FCM token if provided
+    if (loginDto.fcmToken && loginDto.deviceId) {
+      await this.registerDeviceToken(user.id, loginDto.deviceId, loginDto.fcmToken);
+    }
+
+    return [tokens, user];
+  }
+
+  async juniorLogin(juniorLoginDto: JuniorLoginRequestDto): Promise<[ILoginResponse, User]> {
+    const user = await this.userService.findUser({ email: juniorLoginDto.email });
+
+    if (!user || !user.roles.includes(Roles.JUNIOR)) {
+      throw new UnauthorizedException('AUTH.INVALID_CREDENTIALS');
+    }
+
+    this.logger.log(`validating password for user with email ${juniorLoginDto.email}`);
+    const isPasswordValid = bcrypt.compareSync(juniorLoginDto.password, user.password);
+
+    if (!isPasswordValid) {
+      this.logger.error(`Invalid password for user with email ${juniorLoginDto.email}`);
+      throw new UnauthorizedException('AUTH.INVALID_CREDENTIALS');
+    }
+
+    const tokens = await this.generateAuthToken(user);
+    this.logger.log(`Password validated successfully for user`);
+
+    // Register/update device with FCM token if provided
+    if (juniorLoginDto.fcmToken && juniorLoginDto.deviceId) {
+      await this.registerDeviceToken(user.id, juniorLoginDto.deviceId, juniorLoginDto.fcmToken);
+    }
+
+    return [tokens, user];
+  }
+
+  /**
+   * Register or update device with FCM token
+   * This method handles:
+   * 1. Device already exists for this user → Update FCM token
+   * 2. Device exists for different user → Transfer device to new user
+   * 3. Device doesn't exist → Create new device
+   */
+  private async registerDeviceToken(userId: string, deviceId: string, fcmToken: string): Promise<void> {
+    try {
+      this.logger.log(`Registering/updating device ${deviceId} with FCM token for user ${userId}`);
+
+      // Step 1: Check if device already exists for this user
+      const existingDeviceForUser = await this.deviceService.findUserDeviceById(deviceId, userId);
+
+      if (existingDeviceForUser) {
+        // Device exists for this user → Update FCM token and last access time
+        await this.deviceService.updateDevice(deviceId, {
+          fcmToken,
+          userId,
+          lastAccessOn: new Date(),
+        });
+        this.logger.log(`Device ${deviceId} updated with new FCM token for user ${userId}`);
+        return;
+      }
+
+      // Step 2: Check if device exists for any user (different user scenario)
+      const existingDevice = await this.deviceService.findByDeviceId(deviceId);
+
+      if (existingDevice) {
+        // Device exists for different user → Transfer device to new user
+        this.logger.log(
+          `Device ${deviceId} exists for user ${existingDevice.userId}, transferring to user ${userId}`
+        );
+        await this.deviceService.updateDevice(deviceId, {
+          userId,
+          fcmToken,
+          lastAccessOn: new Date(),
+        });
+        this.logger.log(`Device ${deviceId} transferred from user ${existingDevice.userId} to user ${userId}`);
+        return;
+      }
+
+      // Step 3: Device doesn't exist → Create new device
+      await this.deviceService.createDevice({
+        deviceId,
+        userId,
+        fcmToken,
+        lastAccessOn: new Date(),
+      });
+      this.logger.log(`New device ${deviceId} registered with FCM token for user ${userId}`);
+    } catch (error) {
+      // Log error but don't fail the login/signup process
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const errorStack = error instanceof Error ? error.stack : undefined;
+      this.logger.error(`Failed to register device token for user ${userId}: ${errorMessage}`, errorStack);
+    }
+  }
+
+  private async generateAuthToken(user: User) {
+    this.logger.log(`Generating auth token for user with id ${user.id}`);
+    const [accessToken, refreshToken] = await Promise.all([
+      this.jwtService.sign(
+        { sub: user.id, roles: user.roles },
+        {
+          expiresIn: this.configService.getOrThrow('JWT_ACCESS_TOKEN_EXPIRY'),
+          secret: this.configService.getOrThrow('JWT_ACCESS_TOKEN_SECRET'),
+        },
+      ),
+      this.jwtService.sign(
+        { sub: user.id, roles: user.roles },
+        {
+          expiresIn: this.configService.getOrThrow('JWT_REFRESH_TOKEN_EXPIRY'),
+          secret: this.configService.getOrThrow('JWT_REFRESH_TOKEN_SECRET'),
+        },
+      ),
+    ]);
+
+    this.logger.log(`Auth token generated successfully for user with id ${user.id}`);
+    return { accessToken, refreshToken, expiresAt: new Date(this.jwtService.decode(accessToken).exp * ONE_THOUSAND) };
+  }
+}

src/auth/services/index.ts

@@ -0,0 +1 @@
+export * from './auth.service';

src/auth/strategies/access-token.strategy.ts

@@ -0,0 +1,27 @@
+import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { PassportStrategy } from '@nestjs/passport';
+import { ExtractJwt, Strategy } from 'passport-jwt';
+import { UserService } from '~/user/services';
+import { IJwtPayload } from '../interfaces';
+
+@Injectable()
+export class AccessTokenStrategy extends PassportStrategy(Strategy, 'access-token') {
+  constructor(configService: ConfigService, private userService: UserService) {
+    super({
+      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+      ignoreExpiration: false,
+      secretOrKey: configService.get<string>('JWT_ACCESS_TOKEN_SECRET'),
+    });
+  }
+
+  async validate(payload: IJwtPayload) {
+    const user = await this.userService.findUser({ id: payload.sub });
+
+    if (!user) {
+      throw new UnauthorizedException();
+    }
+
+    return payload;
+  }
+}

src/auth/strategies/index.ts

@@ -0,0 +1 @@
+export * from './access-token.strategy';

src/auth/utils/crypt.ts

@@ -0,0 +1,26 @@
+import * as crypto from 'crypto';
+
+export function verifySignature(
+  publicKeyBase64: string,
+  signatureBase64: string,
+  message: string,
+  algorithm: 'SHA1' | 'SHA384',
+) {
+  const signatureBuffer = Buffer.from(signatureBase64, 'base64');
+
+  const publicKeyPEM = '-----BEGIN PUBLIC KEY-----\n' + publicKeyBase64 + '\n-----END PUBLIC KEY-----';
+  const verifier = crypto.createVerify(algorithm);
+  verifier.update(message, 'utf8');
+  return verifier.verify(
+    {
+      key: publicKeyPEM,
+      padding: crypto.constants.RSA_PKCS1_PADDING,
+    },
+    signatureBuffer,
+  );
+}
+
+export function removePadding(originalSignature: string) {
+  const buffer = Buffer.from(originalSignature, 'base64');
+  return buffer.toString('base64');
+}

src/auth/utils/index.ts

@@ -0,0 +1 @@
+export * from './crypt';

src/card/card.module.ts

@@ -0,0 +1,33 @@
+import { forwardRef, Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { NeoLeapModule } from '~/common/modules/neoleap/neoleap.module';
+import { CustomerModule } from '~/customer/customer.module';
+import { CardsController } from './controllers';
+import { Card } from './entities';
+import { Account } from './entities/account.entity';
+import { Transaction } from './entities/transaction.entity';
+import { CardRepository } from './repositories';
+import { AccountRepository } from './repositories/account.repository';
+import { TransactionRepository } from './repositories/transaction.repository';
+import { CardService } from './services';
+import { AccountService } from './services/account.service';
+import { TransactionService } from './services/transaction.service';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([Card, Account, Transaction]),
+    forwardRef(() => NeoLeapModule),
+    forwardRef(() => CustomerModule), // <-- add forwardRef here
+  ],
+  providers: [
+    CardService,
+    CardRepository,
+    TransactionService,
+    TransactionRepository,
+    AccountService,
+    AccountRepository,
+  ],
+  exports: [CardService, TransactionService],
+  controllers: [CardsController],
+})
+export class CardModule {}

src/card/controllers/cards.controller.ts

@@ -0,0 +1,86 @@
+import { Body, Controller, Get, HttpCode, HttpStatus, Param, Post, UseGuards } from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+import { Roles } from '~/auth/enums';
+import { IJwtPayload } from '~/auth/interfaces';
+import { AllowedRoles, AuthenticatedUser } from '~/common/decorators';
+import { AccessTokenGuard, RolesGuard } from '~/common/guards';
+import { CardEmbossingDetailsResponseDto } from '~/common/modules/neoleap/dtos/response';
+import { ApiDataResponse } from '~/core/decorators';
+import { ResponseFactory } from '~/core/utils';
+import { FundIbanRequestDto } from '../dtos/requests';
+import { AccountIbanResponseDto, CardResponseDto, ChildCardResponseDto } from '../dtos/responses';
+import { CardService } from '../services';
+
+@Controller('cards')
+@ApiBearerAuth()
+@ApiTags('Cards')
+@UseGuards(AccessTokenGuard)
+export class CardsController {
+  constructor(private readonly cardService: CardService) {}
+
+  @Post()
+  @ApiDataResponse(CardResponseDto)
+  async createCard(@AuthenticatedUser() { sub }: IJwtPayload) {
+    const card = await this.cardService.createCard(sub);
+    return ResponseFactory.data(new CardResponseDto(card));
+  }
+
+  @Get('child-cards')
+  @UseGuards(RolesGuard)
+  @AllowedRoles(Roles.GUARDIAN)
+  @ApiDataResponse(ChildCardResponseDto)
+  async getChildCards(@AuthenticatedUser() { sub }: IJwtPayload) {
+    const cards = await this.cardService.getChildCards(sub);
+    return ResponseFactory.data(cards.map((card) => new ChildCardResponseDto(card)));
+  }
+
+  @Get('child-cards/:childid')
+  @UseGuards(RolesGuard)
+  @AllowedRoles(Roles.GUARDIAN)
+  @ApiDataResponse(ChildCardResponseDto)
+  async getChildCardById(@Param('childid') childId: string, @AuthenticatedUser() { sub }: IJwtPayload) {
+    const card = await this.cardService.getCardByChildId(sub, childId);
+    return ResponseFactory.data(new ChildCardResponseDto(card));
+  }
+
+  @Get('child-cards/:cardid/embossing-details')
+  @UseGuards(RolesGuard)
+  @AllowedRoles(Roles.GUARDIAN)
+  @ApiDataResponse(CardEmbossingDetailsResponseDto)
+  async getChildCardEmbossingDetails(@Param('cardid') cardId: string, @AuthenticatedUser() { sub }: IJwtPayload) {
+    const res = await this.cardService.getChildCardEmbossingInformation(cardId, sub);
+    return ResponseFactory.data(res);
+  }
+
+  @Get('current')
+  @ApiDataResponse(CardResponseDto)
+  async getCurrentCard(@AuthenticatedUser() { sub }: IJwtPayload) {
+    const card = await this.cardService.getCardByCustomerId(sub);
+    return ResponseFactory.data(new CardResponseDto(card));
+  }
+
+  @Get('embossing-details')
+  @ApiDataResponse(CardEmbossingDetailsResponseDto)
+  async getCardById(@AuthenticatedUser() { sub }: IJwtPayload) {
+    const res = await this.cardService.getEmbossingInformation(sub);
+    return ResponseFactory.data(res);
+  }
+
+  @Get('iban')
+  @UseGuards(RolesGuard)
+  @AllowedRoles(Roles.GUARDIAN)
+  @ApiDataResponse(AccountIbanResponseDto)
+  async getCardIban(@AuthenticatedUser() { sub }: IJwtPayload) {
+    const iban = await this.cardService.getIbanInformation(sub);
+    return ResponseFactory.data(new AccountIbanResponseDto(iban));
+  }
+
+  @Post('mock/fund-iban')
+  @ApiOperation({ summary: 'Mock endpoint to fund the IBAN - For testing purposes only' })
+  @UseGuards(RolesGuard)
+  @AllowedRoles(Roles.GUARDIAN)
+  @HttpCode(HttpStatus.NO_CONTENT)
+  fundIban(@Body() { amount, iban }: FundIbanRequestDto) {
+    return this.cardService.fundIban(iban, amount);
+  }
+}

src/card/controllers/index.ts

@@ -0,0 +1 @@
+export * from './cards.controller';

src/card/dtos/requests/fund-iban.request.dto.ts

@@ -0,0 +1,9 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsString } from 'class-validator';
+import { TransferToJuniorRequestDto } from '~/junior/dtos/request';
+
+export class FundIbanRequestDto extends TransferToJuniorRequestDto {
+  @ApiProperty({ example: 'DE89370400440532013000' })
+  @IsString()
+  iban!: string;
+}

src/card/dtos/requests/index.ts

@@ -0,0 +1 @@
+export * from './fund-iban.request.dto';

src/card/dtos/responses/account-iban.response.dto.ts

@@ -0,0 +1,10 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+export class AccountIbanResponseDto {
+  @ApiProperty({ example: 'DE89370400440532013000' })
+  iban!: string;
+
+  constructor(iban: string) {
+    this.iban = iban;
+  }
+}

src/card/dtos/responses/card.response.dto.ts

@@ -0,0 +1,66 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Card } from '~/card/entities';
+import { CardScheme, CardStatus, CustomerType } from '~/card/enums';
+import { CardStatusDescriptionMapper } from '~/card/mappers/card-status-description.mapper';
+import { UserLocale } from '~/core/enums';
+
+export class CardResponseDto {
+  @ApiProperty({
+    example: 'b34df8c2-5d3e-4b1a-9c2f-7e3b1a2d3f4e',
+  })
+  id!: string;
+
+  @ApiProperty({
+    example: '123456',
+    description: 'The first six digits of the card number.',
+  })
+  firstSixDigits!: string;
+
+  @ApiProperty({ example: '7890', description: 'The last four digits of the card number.' })
+  lastFourDigits!: string;
+
+  @ApiProperty({
+    enum: CardScheme,
+    description: 'The card scheme (e.g., VISA, MASTERCARD).',
+  })
+  scheme!: CardScheme;
+
+  @ApiProperty({
+    enum: CardStatus,
+    description: 'The current status of the card (e.g., ACTIVE, PENDING).',
+  })
+  status!: CardStatus;
+
+  @ApiProperty({
+    example: 'The card is active',
+    description: 'A description of the card status.',
+  })
+  statusDescription!: string;
+
+  @ApiProperty({
+    example: 2000.0,
+    description: 'The credit limit of the card.',
+  })
+  balance!: number;
+
+  @ApiProperty({
+    example: 100.0,
+    nullable: true,
+    description: 'The reserved balance of the card (applicable for child accounts).',
+  })
+  reservedBalance!: number | null;
+
+  constructor(card: Card) {
+    this.id = card.id;
+    this.firstSixDigits = card.firstSixDigits;
+    this.lastFourDigits = card.lastFourDigits;
+    this.scheme = card.scheme;
+    this.status = card.status;
+    this.statusDescription = CardStatusDescriptionMapper[card.statusDescription][UserLocale.ENGLISH].description;
+    this.balance =
+      card.customerType === CustomerType.CHILD
+        ? Math.min(card.limit, card.account.balance)
+        : card.account.balance - card.account.reservedBalance;
+    this.reservedBalance = card.customerType === CustomerType.PARENT ? card.account.reservedBalance : null;
+  }
+}

src/card/dtos/responses/child-card.response.dto.ts

@@ -0,0 +1,48 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Card } from '~/card/entities';
+import { Gender } from '~/customer/enums';
+import { DocumentMetaResponseDto } from '~/document/dtos/response';
+import { CardResponseDto } from './card.response.dto';
+
+class JuniorInfo {
+  @ApiProperty({ example: 'id' })
+  id!: string;
+
+  @ApiProperty({ example: 'FirstName' })
+  firstName!: string;
+
+  @ApiProperty({ example: 'LastName' })
+  lastName!: string;
+
+  @ApiProperty({ example: '[email protected]' })
+  email!: string;
+
+  @ApiProperty({ enum: Gender, example: Gender.MALE })
+  gender!: Gender;
+
+  @ApiProperty({ example: '2000-01-01' })
+  dateOfBirth!: Date;
+
+  @ApiProperty({ example: DocumentMetaResponseDto, nullable: true })
+  profilePicture!: DocumentMetaResponseDto | null;
+
+  constructor(card: Card) {
+    this.id = card.customer?.junior?.id;
+    this.firstName = card.customer?.firstName;
+    this.lastName = card.customer?.lastName;
+    this.email = card.customer?.user?.email;
+    this.gender = card.customer.gender;
+    this.profilePicture = card.customer?.user?.profilePicture
+      ? new DocumentMetaResponseDto(card.customer.user.profilePicture)
+      : null;
+  }
+}
+export class ChildCardResponseDto extends CardResponseDto {
+  @ApiProperty({ type: JuniorInfo })
+  junior!: JuniorInfo | null;
+
+  constructor(card: Card) {
+    super(card);
+    this.junior = card.customer?.junior ? new JuniorInfo(card) : null;
+  }
+}

src/card/dtos/responses/child-transfer-item.response.dto.ts

@@ -0,0 +1,16 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+export class ChildTransferItemDto {
+  @ApiProperty({ example: '2025-10-14T09:53:40.000Z' })
+  date!: Date;
+
+  @ApiProperty({ example: 50.0 })
+  amount!: number;
+
+  @ApiProperty({ example: 'SAR' })
+  currency!: string;
+
+  @ApiProperty({ example: 'You received {{amount}} {{currency}} from your parent.' })
+  message!: string;
+}
+

src/card/dtos/responses/guardian-home.response.dto.ts

@@ -0,0 +1,17 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { TransactionItemResponseDto } from './transaction-item.response.dto';
+
+export class GuardianHomeResponseDto {
+  @ApiProperty({ example: 2000.0 })
+  availableBalance!: number;
+
+  @ApiProperty({ type: [TransactionItemResponseDto] })
+  recentTransactions!: TransactionItemResponseDto[];
+
+  constructor(availableBalance: number, recentTransactions: TransactionItemResponseDto[]) {
+    this.availableBalance = availableBalance;
+    this.recentTransactions = recentTransactions;
+  }
+}
+
+

src/card/dtos/responses/index.ts

@@ -0,0 +1,15 @@
+export * from './account-iban.response.dto';
+export * from './card.response.dto';
+export * from './child-card.response.dto';
+export * from './transaction-item.response.dto';
+export * from './guardian-home.response.dto';
+export * from './paged-transactions.response.dto';
+export * from './parent-transfer-item.response.dto';
+export * from './parent-home.response.dto';
+export * from './paged-parent-transfers.response.dto';
+export * from './child-transfer-item.response.dto';
+export * from './junior-home.response.dto';
+export * from './paged-child-transfers.response.dto';
+export * from './spending-history-item.response.dto';
+export * from './spending-history.response.dto';
+export * from './transaction-detail.response.dto';

src/card/dtos/responses/junior-home.response.dto.ts

@@ -0,0 +1,16 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { ChildTransferItemDto } from './child-transfer-item.response.dto';
+
+export class JuniorHomeResponseDto {
+  @ApiProperty({ example: 500.0 })
+  availableBalance!: number;
+
+  @ApiProperty({ type: [ChildTransferItemDto] })
+  recentTransfers!: ChildTransferItemDto[];
+
+  constructor(availableBalance: number, recentTransfers: ChildTransferItemDto[]) {
+    this.availableBalance = availableBalance;
+    this.recentTransfers = recentTransfers;
+  }
+}
+

src/card/dtos/responses/paged-child-transfers.response.dto.ts

@@ -0,0 +1,33 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { ChildTransferItemDto } from './child-transfer-item.response.dto';
+
+export class PagedChildTransfersResponseDto {
+  @ApiProperty({ type: [ChildTransferItemDto] })
+  items!: ChildTransferItemDto[];
+
+  @ApiProperty({ example: 1 })
+  page!: number;
+
+  @ApiProperty({ example: 10 })
+  size!: number;
+
+  @ApiProperty({ example: 20 })
+  total!: number;
+
+  @ApiProperty({ example: true })
+  hasMore!: boolean;
+
+  constructor(
+    items: ChildTransferItemDto[],
+    page: number,
+    size: number,
+    total: number,
+  ) {
+    this.items = items;
+    this.page = page;
+    this.size = size;
+    this.total = total;
+    this.hasMore = page * size < total;
+  }
+}
+

src/card/dtos/responses/paged-parent-transfers.response.dto.ts

@@ -0,0 +1,33 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { ParentTransferItemDto } from './parent-transfer-item.response.dto';
+
+export class PagedParentTransfersResponseDto {
+  @ApiProperty({ type: [ParentTransferItemDto] })
+  items!: ParentTransferItemDto[];
+
+  @ApiProperty({ example: 1 })
+  page!: number;
+
+  @ApiProperty({ example: 10 })
+  size!: number;
+
+  @ApiProperty({ example: 45 })
+  total!: number;
+
+  @ApiProperty({ example: true })
+  hasMore!: boolean;
+
+  constructor(
+    items: ParentTransferItemDto[],
+    page: number,
+    size: number,
+    total: number,
+  ) {
+    this.items = items;
+    this.page = page;
+    this.size = size;
+    this.total = total;
+    this.hasMore = page * size < total;
+  }
+}
+

src/card/dtos/responses/paged-transactions.response.dto.ts

@@ -0,0 +1,33 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { TransactionItemResponseDto } from './transaction-item.response.dto';
+
+export class PagedTransactionsResponseDto {
+  @ApiProperty({ type: [TransactionItemResponseDto] })
+  items!: TransactionItemResponseDto[];
+
+  @ApiProperty({ example: 1 })
+  page!: number;
+
+  @ApiProperty({ example: 10 })
+  size!: number;
+
+  @ApiProperty({ example: 45 })
+  total!: number;
+
+  @ApiProperty({ example: true })
+  hasMore!: boolean;
+
+  constructor(
+    items: TransactionItemResponseDto[],
+    page: number,
+    size: number,
+    total: number,
+  ) {
+    this.items = items;
+    this.page = page;
+    this.size = size;
+    this.total = total;
+    this.hasMore = page * size < total;
+  }
+}
+

src/card/dtos/responses/parent-home.response.dto.ts

@@ -0,0 +1,16 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { ParentTransferItemDto } from './parent-transfer-item.response.dto';
+
+export class ParentHomeResponseDto {
+  @ApiProperty({ example: 2000.0 })
+  availableBalance!: number;
+
+  @ApiProperty({ type: [ParentTransferItemDto] })
+  recentTransfers!: ParentTransferItemDto[];
+
+  constructor(availableBalance: number, recentTransfers: ParentTransferItemDto[]) {
+    this.availableBalance = availableBalance;
+    this.recentTransfers = recentTransfers;
+  }
+}
+

src/card/dtos/responses/parent-transfer-item.response.dto.ts

@@ -0,0 +1,16 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+export class ParentTransferItemDto {
+  @ApiProperty({ example: '2025-10-14T09:53:40.000Z' })
+  date!: Date;
+
+  @ApiProperty({ example: 50.0 })
+  amount!: number;
+
+  @ApiProperty({ example: 'SAR' })
+  currency!: string;
+
+  @ApiProperty({ example: 'Ahmed Ali' })
+  childName!: string;
+}
+

src/card/dtos/responses/spending-history-item.response.dto.ts

@@ -0,0 +1,58 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Transaction } from '~/card/entities/transaction.entity';
+
+export class SpendingHistoryItemDto {
+  @ApiProperty({ example: '2025-10-14T09:53:40.000Z' })
+  date!: Date;
+
+  @ApiProperty({ example: 50.5 })
+  amount!: number;
+
+  @ApiProperty({ example: 'SAR' })
+  currency!: string;
+
+  @ApiPropertyOptional({ example: 'Shopping' })
+  category!: string | null;
+
+  @ApiPropertyOptional({ example: 'Target Store' })
+  merchantName!: string | null;
+
+  @ApiPropertyOptional({ example: 'Riyadh' })
+  merchantCity!: string | null;
+
+  @ApiProperty({ example: '277012*****3456' })
+  cardMasked!: string;
+
+  @ApiProperty()
+  transactionId!: string;
+
+  constructor(transaction: Transaction) {
+    this.date = transaction.transactionDate;
+    this.amount = transaction.transactionAmount;
+    this.currency = transaction.transactionCurrency === '682' ? 'SAR' : transaction.transactionCurrency;
+    this.category = this.mapMccToCategory(transaction.merchantCategoryCode);
+    this.merchantName = transaction.merchantName;
+    this.merchantCity = transaction.merchantCity;
+    this.cardMasked = transaction.cardMaskedNumber;
+    this.transactionId = transaction.id;
+  }
+
+  private mapMccToCategory(mcc: string | null): string {
+    if (!mcc) return 'Other';
+    
+    const mccCode = mcc;
+    
+    // Map MCC codes to categories
+    if (mccCode >= '5200' && mccCode <= '5599') return 'Shopping';
+    if (mccCode >= '5800' && mccCode <= '5899') return 'Food & Dining';
+    if (mccCode >= '3000' && mccCode <= '3999') return 'Travel';
+    if (mccCode >= '4000' && mccCode <= '4799') return 'Transportation';
+    if (mccCode >= '7200' && mccCode <= '7999') return 'Entertainment';
+    if (mccCode >= '5900' && mccCode <= '5999') return 'Services';
+    if (mccCode >= '4800' && mccCode <= '4899') return 'Utilities';
+    if (mccCode >= '8000' && mccCode <= '8999') return 'Health & Wellness';
+    
+    return 'Other';
+  }
+}
+

src/card/dtos/responses/spending-history.response.dto.ts

@@ -0,0 +1,24 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { SpendingHistoryItemDto } from './spending-history-item.response.dto';
+
+export class SpendingHistoryResponseDto {
+  @ApiProperty({ type: [SpendingHistoryItemDto] })
+  transactions!: SpendingHistoryItemDto[];
+
+  @ApiProperty({ example: 150.75 })
+  totalSpent!: number;
+
+  @ApiProperty({ example: 'SAR' })
+  currency!: string;
+
+  @ApiProperty({ example: 10 })
+  count!: number;
+
+  constructor(transactions: SpendingHistoryItemDto[], currency: string = 'SAR') {
+    this.transactions = transactions;
+    this.totalSpent = transactions.reduce((sum, tx) => sum + tx.amount, 0);
+    this.currency = currency;
+    this.count = transactions.length;
+  }
+}
+

src/card/dtos/responses/transaction-detail.response.dto.ts

@@ -0,0 +1,74 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Transaction } from '~/card/entities/transaction.entity';
+
+export class TransactionDetailResponseDto {
+  @ApiProperty()
+  id!: string;
+
+  @ApiProperty({ example: '2025-10-14T09:53:40.000Z' })
+  date!: Date;
+
+  @ApiProperty({ example: 50.5 })
+  amount!: number;
+
+  @ApiProperty({ example: 'SAR' })
+  currency!: string;
+
+  @ApiProperty({ example: 2.5 })
+  fees!: number;
+
+  @ApiProperty({ example: 0.5 })
+  vatOnFees!: number;
+
+  @ApiPropertyOptional({ example: 'Target Store' })
+  merchantName!: string | null;
+
+  @ApiPropertyOptional({ example: 'Shopping' })
+  category!: string | null;
+
+  @ApiPropertyOptional({ example: 'Riyadh' })
+  merchantCity!: string | null;
+
+  @ApiProperty({ example: '277012*****3456' })
+  cardMasked!: string;
+
+  @ApiProperty()
+  rrn!: string;
+
+  @ApiProperty()
+  transactionId!: string;
+
+  constructor(transaction: Transaction) {
+    this.id = transaction.id;
+    this.date = transaction.transactionDate;
+    this.amount = transaction.transactionAmount;
+    this.currency = transaction.transactionCurrency === '682' ? 'SAR' : transaction.transactionCurrency;
+    this.fees = transaction.fees;
+    this.vatOnFees = transaction.vatOnFees;
+    this.merchantName = transaction.merchantName;
+    this.category = this.mapMccToCategory(transaction.merchantCategoryCode);
+    this.merchantCity = transaction.merchantCity;
+    this.cardMasked = transaction.cardMaskedNumber;
+    this.rrn = transaction.rrn;
+    this.transactionId = transaction.transactionId;
+  }
+
+  private mapMccToCategory(mcc: string | null): string {
+    if (!mcc) return 'Other';
+    
+    const mccCode = mcc;
+    
+    // Map MCC codes to categories
+    if (mccCode >= '5200' && mccCode <= '5599') return 'Shopping';
+    if (mccCode >= '5800' && mccCode <= '5899') return 'Food & Dining';
+    if (mccCode >= '3000' && mccCode <= '3999') return 'Travel';
+    if (mccCode >= '4000' && mccCode <= '4799') return 'Transportation';
+    if (mccCode >= '7200' && mccCode <= '7999') return 'Entertainment';
+    if (mccCode >= '5900' && mccCode <= '5999') return 'Services';
+    if (mccCode >= '4800' && mccCode <= '4899') return 'Utilities';
+    if (mccCode >= '8000' && mccCode <= '8999') return 'Health & Wellness';
+    
+    return 'Other';
+  }
+}
+

src/card/dtos/responses/transaction-item.response.dto.ts

@@ -0,0 +1,24 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { ParentTransactionType } from '~/card/enums';
+
+export class TransactionItemResponseDto {
+  @ApiProperty()
+  date!: Date;
+
+  @ApiProperty({ example: -50.0 })
+  amountSigned!: number;
+
+  @ApiProperty({ enum: ParentTransactionType })
+  type!: ParentTransactionType;
+
+  @ApiProperty({ description: 'Counterparty display name (child for transfer, source label for top-up)' })
+  counterpartyName!: string;
+
+  @ApiProperty({ nullable: true })
+  counterpartyAccountMasked!: string | null;
+
+  @ApiProperty({ required: false })
+  childName?: string;
+}
+
+

src/card/entities/account.entity.ts

@@ -0,0 +1,60 @@
+import { Column, CreateDateColumn, Entity, Index, OneToMany, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm';
+import { Card } from './card.entity';
+import { Transaction } from './transaction.entity';
+
+@Entity('accounts')
+export class Account {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string;
+
+  @Column('varchar', { length: 255, nullable: false, unique: true, name: 'account_reference' })
+  @Index({ unique: true })
+  accountReference!: string;
+
+  @Index({ unique: true })
+  @Column('varchar', { length: 255, nullable: false, name: 'account_number' })
+  accountNumber!: string;
+
+  @Index({ unique: true })
+  @Column('varchar', { length: 255, nullable: false, name: 'iban' })
+  iban!: string;
+
+  @Column('varchar', { length: 255, nullable: false, name: 'currency' })
+  currency!: string;
+
+  @Column('decimal', {
+    precision: 10,
+    scale: 2,
+    default: 0.0,
+    name: 'balance',
+    transformer: {
+      to: (value: number) => value,
+      from: (value: string) => parseFloat(value),
+    },
+  })
+  balance!: number;
+
+  @Column('decimal', {
+    precision: 10,
+    scale: 2,
+    default: 0.0,
+    name: 'reserved_balance',
+    transformer: {
+      to: (value: number) => value,
+      from: (value: string) => parseFloat(value),
+    },
+  })
+  reservedBalance!: number;
+
+  @OneToMany(() => Card, (card) => card.account, { cascade: true })
+  cards!: Card[];
+
+  @OneToMany(() => Transaction, (transaction) => transaction.account, { cascade: true })
+  transactions!: Transaction[];
+
+  @CreateDateColumn({ name: 'created_at', type: 'timestamp with time zone' })
+  createdAt!: Date;
+
+  @UpdateDateColumn({ name: 'updated_at', type: 'timestamp with time zone' })
+  updatedAt!: Date;
+}

src/card/entities/card.entity.ts

@@ -0,0 +1,89 @@
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  JoinColumn,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+} from 'typeorm';
+import { Customer } from '~/customer/entities';
+import { CardColors, CardIssuers, CardScheme, CardStatus, CardStatusDescription, CustomerType } from '../enums';
+import { Account } from './account.entity';
+import { Transaction } from './transaction.entity';
+
+@Entity('cards')
+export class Card {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string;
+
+  @Index({ unique: true })
+  @Column({ name: 'card_reference', nullable: false, type: 'varchar' })
+  cardReference!: string;
+
+  @Index({ unique: true })
+  @Column({ name: 'vpan', nullable: false, type: 'varchar' })
+  vpan!: string;
+
+  @Column({ length: 6, name: 'first_six_digits', nullable: false, type: 'varchar' })
+  firstSixDigits!: string;
+
+  @Column({ length: 4, name: 'last_four_digits', nullable: false, type: 'varchar' })
+  lastFourDigits!: string;
+
+  @Column({ type: 'varchar', nullable: false })
+  expiry!: string;
+
+  @Column({ type: 'varchar', nullable: false, name: 'customer_type' })
+  customerType!: CustomerType;
+
+  @Column({ type: 'varchar', nullable: false, default: CardColors.DEEP_MAGENTA })
+  color!: CardColors;
+
+  @Column({ type: 'varchar', nullable: false, default: CardStatus.PENDING })
+  status!: CardStatus;
+
+  @Column({ type: 'varchar', nullable: false, default: CardStatusDescription.PENDING_ACTIVATION })
+  statusDescription!: CardStatusDescription;
+
+  @Column({ type: 'decimal', precision: 10, scale: 2, default: 0.0, name: 'limit' })
+  limit!: number;
+
+  @Column({ type: 'varchar', nullable: false, default: CardScheme.VISA })
+  scheme!: CardScheme;
+
+  @Column({ type: 'varchar', nullable: false })
+  issuer!: CardIssuers;
+
+  @Column({ type: 'uuid', name: 'customer_id', nullable: false })
+  customerId!: string;
+
+  @Column({ type: 'uuid', name: 'parent_id', nullable: true })
+  parentId?: string;
+
+  @Column({ type: 'uuid', name: 'account_id', nullable: false })
+  accountId!: string;
+
+  @ManyToOne(() => Customer, (customer) => customer.childCards)
+  @JoinColumn({ name: 'parent_id' })
+  parentCustomer?: Customer;
+
+  @ManyToOne(() => Customer, (customer) => customer.cards, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'customer_id' })
+  customer!: Customer;
+
+  @ManyToOne(() => Account, (account) => account.cards, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'account_id' })
+  account!: Account;
+
+  @OneToMany(() => Transaction, (transaction) => transaction.card, { cascade: true })
+  transactions!: Transaction[];
+
+  @CreateDateColumn({ name: 'created_at', type: 'timestamp with time zone' })
+  createdAt!: Date;
+
+  @UpdateDateColumn({ type: 'timestamp with time zone', name: 'updated_at' })
+  updatedAt!: Date;
+}

src/card/entities/index.ts

@@ -0,0 +1 @@
+export * from './card.entity';

src/card/entities/transaction.entity.ts

@@ -0,0 +1,87 @@
+import { Column, CreateDateColumn, Entity, JoinColumn, ManyToOne, PrimaryGeneratedColumn } from 'typeorm';
+import { TransactionScope, TransactionType } from '../enums';
+import { Account } from './account.entity';
+import { Card } from './card.entity';
+
+@Entity('transactions')
+export class Transaction {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string;
+
+  @Column({ name: 'transaction_scope', type: 'varchar', nullable: false })
+  transactionScope!: TransactionScope;
+
+  @Column({ name: 'transaction_type', type: 'varchar', default: TransactionType.EXTERNAL })
+  transactionType!: TransactionType;
+
+  @Column({ name: 'card_reference', nullable: true, type: 'varchar' })
+  cardReference!: string;
+
+  @Column({ name: 'account_reference', nullable: true, type: 'varchar' })
+  accountReference!: string;
+
+  @Column({ name: 'transaction_id', unique: true, nullable: true, type: 'varchar' })
+  transactionId!: string;
+
+  @Column({ name: 'card_masked_number', nullable: true, type: 'varchar' })
+  cardMaskedNumber!: string;
+
+  @Column({ type: 'timestamp with time zone', name: 'transaction_date', nullable: true })
+  transactionDate!: Date;
+
+  @Column({ name: 'rrn', nullable: true, type: 'varchar' })
+  rrn!: string;
+
+  @Column({
+    type: 'decimal',
+    precision: 12,
+    scale: 2,
+    name: 'transaction_amount',
+    transformer: {
+      to: (value: number) => value,
+      from: (value: string) => parseFloat(value),
+    },
+  })
+  transactionAmount!: number;
+
+  @Column({ type: 'varchar', name: 'transaction_currency' })
+  transactionCurrency!: string;
+
+  @Column({ type: 'decimal', name: 'billing_amount', precision: 12, scale: 2 })
+  billingAmount!: number;
+
+  @Column({ type: 'decimal', name: 'settlement_amount', precision: 12, scale: 2 })
+  settlementAmount!: number;
+
+  @Column({ type: 'decimal', name: 'fees', precision: 12, scale: 2 })
+  fees!: number;
+
+  @Column({ type: 'decimal', name: 'vat_on_fees', precision: 12, scale: 2, default: 0.0 })
+  vatOnFees!: number;
+
+  @Column({ name: 'merchant_name', type: 'varchar', nullable: true })
+  merchantName!: string | null;
+
+  @Column({ name: 'merchant_category_code', type: 'varchar', nullable: true })
+  merchantCategoryCode!: string | null;
+
+  @Column({ name: 'merchant_city', type: 'varchar', nullable: true })
+  merchantCity!: string | null;
+
+  @Column({ name: 'card_id', type: 'uuid', nullable: true })
+  cardId!: string;
+
+  @Column({ name: 'account_id', type: 'uuid', nullable: true })
+  accountId!: string;
+
+  @ManyToOne(() => Card, (card) => card.transactions, { onDelete: 'CASCADE', nullable: true })
+  @JoinColumn({ name: 'card_id' })
+  card!: Card;
+
+  @ManyToOne(() => Account, (account) => account.transactions, { onDelete: 'CASCADE', nullable: true })
+  @JoinColumn({ name: 'account_id' })
+  account!: Account;
+
+  @CreateDateColumn({ name: 'created_at', type: 'timestamp with time zone' })
+  createdAt!: Date;
+}

src/card/enums/card-colors.enum.ts

@@ -0,0 +1,13 @@
+export enum CardColors {
+  RAINBOW_PASTEL = 'RAINBOW_PASTEL',
+  DEEP_MAGENTA = 'DEEP_MAGENTA',
+  GREEN_TEAL = 'GREEN_TEAL',
+
+  BLUE_GREEN = 'BLUE_GREEN',
+  TEAL_NAVY = 'TEAL_NAVY',
+  PURPLE_PINK = 'PURPLE_PINK',
+
+  GOLD_BLUE = 'GOLD_BLUE',
+  OCEAN_BLUE = 'OCEAN_BLUE',
+  BROWN_RUST = 'BROWN_RUST',
+}

src/card/enums/card-issuers.enum.ts

@@ -0,0 +1,3 @@
+export enum CardIssuers {
+  NEOLEAP = 'NEOLEAP',
+}

src/card/enums/card-scheme.enum.ts

@@ -0,0 +1,4 @@
+export enum CardScheme {
+  VISA = 'VISA',
+  MASTERCARD = 'MASTERCARD',
+}

src/card/enums/card-status-description.enum.ts

@@ -0,0 +1,68 @@
+/**
+ * import { CardStatus, CardStatusDescription } from '../enums';
+ 
+ export const CardStatusMapper: Record<string, { description: CardStatusDescription; status: CardStatus }> = {
+   //ACTIVE
+   '00': { description: 'NORMAL', status: CardStatus.ACTIVE },
+ 
+   //PENDING
+   '02': { description: 'NOT_YET_ISSUED', status: CardStatus.PENDING },
+   '20': { description: 'PENDING_ISSUANCE', status: CardStatus.PENDING },
+   '21': { description: 'CARD_EXTRACTED', status: CardStatus.PENDING },
+   '22': { description: 'EXTRACTION_FAILED', status: CardStatus.PENDING },
+   '23': { description: 'FAILED_PRINTING_BULK', status: CardStatus.PENDING },
+   '24': { description: 'FAILED_PRINTING_INST', status: CardStatus.PENDING },
+   '30': { description: 'PENDING_ACTIVATION', status: CardStatus.PENDING },
+   '27': { description: 'PENDING_PIN', status: CardStatus.PENDING },
+   '16': { description: 'PREPARE_TO_CLOSE', status: CardStatus.PENDING },
+ 
+   //BLOCKED
+   '01': { description: 'PIN_TRIES_EXCEEDED', status: CardStatus.BLOCKED },
+   '03': { description: 'CARD_EXPIRED', status: CardStatus.BLOCKED },
+   '04': { description: 'LOST', status: CardStatus.BLOCKED },
+   '05': { description: 'STOLEN', status: CardStatus.BLOCKED },
+   '06': { description: 'CUSTOMER_CLOSE', status: CardStatus.BLOCKED },
+   '07': { description: 'BANK_CANCELLED', status: CardStatus.BLOCKED },
+   '08': { description: 'FRAUD', status: CardStatus.BLOCKED },
+   '09': { description: 'DAMAGED', status: CardStatus.BLOCKED },
+   '50': { description: 'SAFE_BLOCK', status: CardStatus.BLOCKED },
+   '51': { description: 'TEMPORARY_BLOCK', status: CardStatus.BLOCKED },
+   '52': { description: 'RISK_BLOCK', status: CardStatus.BLOCKED },
+   '53': { description: 'OVERDRAFT', status: CardStatus.BLOCKED },
+   '54': { description: 'BLOCKED_FOR_FEES', status: CardStatus.BLOCKED },
+   '67': { description: 'CLOSED_CUSTOMER_DEAD', status: CardStatus.BLOCKED },
+   '75': { description: 'RETURN_CARD', status: CardStatus.BLOCKED },
+ 
+   //Fallback
+   '99': { description: 'UNKNOWN', status: CardStatus.PENDING },
+ };
+ 
+ */
+export enum CardStatusDescription {
+  NORMAL = 'NORMAL',
+  NOT_YET_ISSUED = 'NOT_YET_ISSUED',
+  PENDING_ISSUANCE = 'PENDING_ISSUANCE',
+  CARD_EXTRACTED = 'CARD_EXTRACTED',
+  EXTRACTION_FAILED = 'EXTRACTION_FAILED',
+  FAILED_PRINTING_BULK = 'FAILED_PRINTING_BULK',
+  FAILED_PRINTING_INST = 'FAILED_PRINTING_INST',
+  PENDING_ACTIVATION = 'PENDING_ACTIVATION',
+  PENDING_PIN = 'PENDING_PIN',
+  PREPARE_TO_CLOSE = 'PREPARE_TO_CLOSE',
+  PIN_TRIES_EXCEEDED = 'PIN_TRIES_EXCEEDED',
+  CARD_EXPIRED = 'CARD_EXPIRED',
+  LOST = 'LOST',
+  STOLEN = 'STOLEN',
+  CUSTOMER_CLOSE = 'CUSTOMER_CLOSE',
+  BANK_CANCELLED = 'BANK_CANCELLED',
+  FRAUD = 'FRAUD',
+  DAMAGED = 'DAMAGED',
+  SAFE_BLOCK = 'SAFE_BLOCK',
+  TEMPORARY_BLOCK = 'TEMPORARY_BLOCK',
+  RISK_BLOCK = 'RISK_BLOCK',
+  OVERDRAFT = 'OVERDRAFT',
+  BLOCKED_FOR_FEES = 'BLOCKED_FOR_FEES',
+  CLOSED_CUSTOMER_DEAD = 'CLOSED_CUSTOMER_DEAD',
+  RETURN_CARD = 'RETURN_CARD',
+  UNKNOWN = 'UNKNOWN',
+}

src/card/enums/card-status.enum.ts

@@ -0,0 +1,6 @@
+export enum CardStatus {
+  ACTIVE = 'ACTIVE',
+  CANCELED = 'CANCELED',
+  BLOCKED = 'BLOCKED',
+  PENDING = 'PENDING',
+}

src/card/enums/customer-type.enum.ts

@@ -0,0 +1,4 @@
+export enum CustomerType {
+  PARENT = 'PARENT',
+  CHILD = 'CHILD',
+}

src/card/enums/index.ts

@@ -0,0 +1,9 @@
+export * from './card-colors.enum';
+export * from './card-issuers.enum';
+export * from './card-scheme.enum';
+export * from './card-status-description.enum';
+export * from './card-status.enum';
+export * from './customer-type.enum';
+export * from './transaction-scope.enum';
+export * from './transaction-type.enum';
+export * from './parent-transaction-type.enum';

src/card/enums/parent-transaction-type.enum.ts

@@ -0,0 +1,6 @@
+export enum ParentTransactionType {
+  PARENT_TRANSFER = 'PARENT_TRANSFER',
+  PARENT_TOPUP = 'PARENT_TOPUP',
+}
+
+

src/card/enums/transaction-scope.enum.ts

@@ -0,0 +1,4 @@
+export enum TransactionScope {
+  CARD = 'CARD',
+  ACCOUNT = 'ACCOUNT',
+}

src/card/enums/transaction-type.enum.ts

@@ -0,0 +1,4 @@
+export enum TransactionType {
+  INTERNAL = 'INTERNAL',
+  EXTERNAL = 'EXTERNAL',
+}

src/card/mappers/card-status-description.mapper.ts

@@ -0,0 +1,112 @@
+import { UserLocale } from '~/core/enums';
+import { CardStatusDescription } from '../enums';
+
+export const CardStatusDescriptionMapper: Record<
+  CardStatusDescription,
+  { [key in UserLocale]: { description: string } }
+> = {
+  [CardStatusDescription.NORMAL]: {
+    [UserLocale.ENGLISH]: { description: 'The card is active' },
+    [UserLocale.ARABIC]: { description: 'البطاقة نشطة' },
+  },
+  [CardStatusDescription.NOT_YET_ISSUED]: {
+    [UserLocale.ENGLISH]: { description: 'The card is not yet issued' },
+    [UserLocale.ARABIC]: { description: 'البطاقة لم تصدر بعد' },
+  },
+  [CardStatusDescription.PENDING_ISSUANCE]: {
+    [UserLocale.ENGLISH]: { description: 'The card is pending issuance' },
+    [UserLocale.ARABIC]: { description: 'البطاقة قيد الإصدار' },
+  },
+  [CardStatusDescription.CARD_EXTRACTED]: {
+    [UserLocale.ENGLISH]: { description: 'The card has been extracted' },
+    [UserLocale.ARABIC]: { description: 'تم استخراج البطاقة' },
+  },
+  [CardStatusDescription.EXTRACTION_FAILED]: {
+    [UserLocale.ENGLISH]: { description: 'The card extraction has failed' },
+    [UserLocale.ARABIC]: { description: 'فشل استخراج البطاقة' },
+  },
+  [CardStatusDescription.FAILED_PRINTING_BULK]: {
+    [UserLocale.ENGLISH]: { description: 'The card printing in bulk has failed' },
+    [UserLocale.ARABIC]: { description: 'فشل الطباعة بالجملة للبطاقة' },
+  },
+  [CardStatusDescription.FAILED_PRINTING_INST]: {
+    [UserLocale.ENGLISH]: { description: 'The card printing in institution has failed' },
+    [UserLocale.ARABIC]: { description: 'فشل الطباعة في المؤسسة للبطاقة' },
+  },
+  [CardStatusDescription.PENDING_ACTIVATION]: {
+    [UserLocale.ENGLISH]: { description: 'The card is pending activation' },
+    [UserLocale.ARABIC]: { description: 'البطاقة قيد التفعيل' },
+  },
+  [CardStatusDescription.PENDING_PIN]: {
+    [UserLocale.ENGLISH]: { description: 'The card is pending PIN' },
+    [UserLocale.ARABIC]: { description: 'البطاقة قيد الانتظار لرقم التعريف الشخصي' },
+  },
+  [CardStatusDescription.PREPARE_TO_CLOSE]: {
+    [UserLocale.ENGLISH]: { description: 'The card is being prepared for closure' },
+    [UserLocale.ARABIC]: { description: 'البطاقة قيد التحضير للإغلاق' },
+  },
+  [CardStatusDescription.PIN_TRIES_EXCEEDED]: {
+    [UserLocale.ENGLISH]: { description: 'The card PIN tries have been exceeded' },
+    [UserLocale.ARABIC]: { description: 'تم تجاوز محاولات رقم التعريف الشخصي للبطاقة' },
+  },
+  [CardStatusDescription.CARD_EXPIRED]: {
+    [UserLocale.ENGLISH]: { description: 'The card has expired' },
+    [UserLocale.ARABIC]: { description: 'انتهت صلاحية البطاقة' },
+  },
+  [CardStatusDescription.LOST]: {
+    [UserLocale.ENGLISH]: { description: 'The card is lost' },
+    [UserLocale.ARABIC]: { description: 'البطاقة ضائعة' },
+  },
+  [CardStatusDescription.STOLEN]: {
+    [UserLocale.ENGLISH]: { description: 'The card is stolen' },
+    [UserLocale.ARABIC]: { description: 'البطاقة مسروقة' },
+  },
+  [CardStatusDescription.CUSTOMER_CLOSE]: {
+    [UserLocale.ENGLISH]: { description: 'The card is being closed by the customer' },
+    [UserLocale.ARABIC]: { description: 'البطاقة قيد الإغلاق من قبل العميل' },
+  },
+  [CardStatusDescription.BANK_CANCELLED]: {
+    [UserLocale.ENGLISH]: { description: 'The card has been cancelled by the bank' },
+    [UserLocale.ARABIC]: { description: 'البطاقة ألغيت من قبل البنك' },
+  },
+  [CardStatusDescription.FRAUD]: {
+    [UserLocale.ENGLISH]: { description: 'Fraud' },
+    [UserLocale.ARABIC]: { description: 'احتيال' },
+  },
+  [CardStatusDescription.DAMAGED]: {
+    [UserLocale.ENGLISH]: { description: 'The card is damaged' },
+    [UserLocale.ARABIC]: { description: 'البطاقة تالفة' },
+  },
+  [CardStatusDescription.SAFE_BLOCK]: {
+    [UserLocale.ENGLISH]: { description: 'The card is in a safe block' },
+    [UserLocale.ARABIC]: { description: 'البطاقة في حظر آمن' },
+  },
+  [CardStatusDescription.TEMPORARY_BLOCK]: {
+    [UserLocale.ENGLISH]: { description: 'The card is in a temporary block' },
+    [UserLocale.ARABIC]: { description: 'البطاقة في حظر مؤقت' },
+  },
+  [CardStatusDescription.RISK_BLOCK]: {
+    [UserLocale.ENGLISH]: { description: 'The card is in a risk block' },
+    [UserLocale.ARABIC]: { description: 'البطاقة في حظر المخاطر' },
+  },
+  [CardStatusDescription.OVERDRAFT]: {
+    [UserLocale.ENGLISH]: { description: 'The card is in overdraft' },
+    [UserLocale.ARABIC]: { description: 'البطاقة في السحب على المكشوف' },
+  },
+  [CardStatusDescription.BLOCKED_FOR_FEES]: {
+    [UserLocale.ENGLISH]: { description: 'The card is blocked for fees' },
+    [UserLocale.ARABIC]: { description: 'البطاقة محظورة للرسوم' },
+  },
+  [CardStatusDescription.CLOSED_CUSTOMER_DEAD]: {
+    [UserLocale.ENGLISH]: { description: 'The card is closed because the customer is dead' },
+    [UserLocale.ARABIC]: { description: 'البطاقة مغلقة لأن العميل متوفى' },
+  },
+  [CardStatusDescription.RETURN_CARD]: {
+    [UserLocale.ENGLISH]: { description: 'The card is being returned' },
+    [UserLocale.ARABIC]: { description: 'البطاقة قيد الإرجاع' },
+  },
+  [CardStatusDescription.UNKNOWN]: {
+    [UserLocale.ENGLISH]: { description: 'The card status is unknown' },
+    [UserLocale.ARABIC]: { description: 'حالة البطاقة غير معروفة' },
+  },
+};

src/card/mappers/card-status.mapper.ts

@@ -0,0 +1,37 @@
+import { CardStatus, CardStatusDescription } from '../enums';
+
+export const CardStatusMapper: Record<string, { description: CardStatusDescription; status: CardStatus }> = {
+  //ACTIVE
+  '00': { description: CardStatusDescription.NORMAL, status: CardStatus.ACTIVE },
+
+  //PENDING
+  '02': { description: CardStatusDescription.NOT_YET_ISSUED, status: CardStatus.PENDING },
+  '20': { description: CardStatusDescription.PENDING_ISSUANCE, status: CardStatus.PENDING },
+  '21': { description: CardStatusDescription.CARD_EXTRACTED, status: CardStatus.PENDING },
+  '22': { description: CardStatusDescription.EXTRACTION_FAILED, status: CardStatus.PENDING },
+  '23': { description: CardStatusDescription.FAILED_PRINTING_BULK, status: CardStatus.PENDING },
+  '24': { description: CardStatusDescription.FAILED_PRINTING_INST, status: CardStatus.PENDING },
+  '30': { description: CardStatusDescription.PENDING_ACTIVATION, status: CardStatus.PENDING },
+  '27': { description: CardStatusDescription.PENDING_PIN, status: CardStatus.PENDING },
+  '16': { description: CardStatusDescription.PREPARE_TO_CLOSE, status: CardStatus.PENDING },
+
+  //BLOCKED
+  '01': { description: CardStatusDescription.PIN_TRIES_EXCEEDED, status: CardStatus.BLOCKED },
+  '03': { description: CardStatusDescription.CARD_EXPIRED, status: CardStatus.BLOCKED },
+  '04': { description: CardStatusDescription.LOST, status: CardStatus.BLOCKED },
+  '05': { description: CardStatusDescription.STOLEN, status: CardStatus.BLOCKED },
+  '06': { description: CardStatusDescription.CUSTOMER_CLOSE, status: CardStatus.BLOCKED },
+  '07': { description: CardStatusDescription.BANK_CANCELLED, status: CardStatus.BLOCKED },
+  '08': { description: CardStatusDescription.FRAUD, status: CardStatus.BLOCKED },
+  '09': { description: CardStatusDescription.DAMAGED, status: CardStatus.BLOCKED },
+  '50': { description: CardStatusDescription.SAFE_BLOCK, status: CardStatus.BLOCKED },
+  '51': { description: CardStatusDescription.TEMPORARY_BLOCK, status: CardStatus.BLOCKED },
+  '52': { description: CardStatusDescription.RISK_BLOCK, status: CardStatus.BLOCKED },
+  '53': { description: CardStatusDescription.OVERDRAFT, status: CardStatus.BLOCKED },
+  '54': { description: CardStatusDescription.BLOCKED_FOR_FEES, status: CardStatus.BLOCKED },
+  '67': { description: CardStatusDescription.CLOSED_CUSTOMER_DEAD, status: CardStatus.BLOCKED },
+  '75': { description: CardStatusDescription.RETURN_CARD, status: CardStatus.BLOCKED },
+
+  //Fallback
+  '99': { description: CardStatusDescription.UNKNOWN, status: CardStatus.PENDING },
+};

src/card/repositories/account.repository.ts

@@ -0,0 +1,66 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { CreateApplicationResponse } from '~/common/modules/neoleap/dtos/response';
+import { Account } from '../entities/account.entity';
+
+@Injectable()
+export class AccountRepository {
+  constructor(@InjectRepository(Account) private readonly accountRepository: Repository<Account>) {}
+
+  createAccount(data: CreateApplicationResponse): Promise<Account> {
+    return this.accountRepository.save(
+      this.accountRepository.create({
+        accountReference: data.accountId,
+        accountNumber: data.accountNumber,
+        iban: data.iBan,
+        balance: 0,
+        currency: '682',
+      }),
+    );
+  }
+
+  getAccountByReferenceNumber(accountReference: string): Promise<Account | null> {
+    return this.accountRepository.findOne({
+      where: { accountReference },
+      relations: ['cards'],
+    });
+  }
+
+  getAccountByIban(iban: string): Promise<Account | null> {
+    return this.accountRepository.findOne({
+      where: { iban },
+      relations: ['cards'],
+    });
+  }
+
+  getAccountByAccountNumber(accountNumber: string): Promise<Account | null> {
+    return this.accountRepository.findOne({
+      where: { accountNumber },
+      relations: ['cards'],
+    });
+  }
+
+  getAccountByCustomerId(customerId: string): Promise<Account | null> {
+    return this.accountRepository.findOne({
+      where: { cards: { customerId } },
+      relations: ['cards'],
+    });
+  }
+
+  topUpAccountBalance(accountReference: string, amount: number) {
+    return this.accountRepository.increment({ accountReference }, 'balance', amount);
+  }
+
+  decreaseAccountBalance(accountReference: string, amount: number) {
+    return this.accountRepository.decrement({ accountReference }, 'balance', amount);
+  }
+
+  increaseReservedBalance(accountId: string, amount: number) {
+    return this.accountRepository.increment({ id: accountId }, 'reservedBalance', amount);
+  }
+
+  decreaseReservedBalance(accountId: string, amount: number) {
+    return this.accountRepository.decrement({ id: accountId }, 'reservedBalance', amount);
+  }
+}

src/card/repositories/card.repository.ts

@@ -0,0 +1,112 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { CreateApplicationResponse } from '~/common/modules/neoleap/dtos/response';
+import { Card } from '../entities';
+import { CardColors, CardIssuers, CardScheme, CardStatus, CardStatusDescription, CustomerType } from '../enums';
+
+@Injectable()
+export class CardRepository {
+  constructor(@InjectRepository(Card) private readonly cardRepository: Repository<Card>) {}
+
+  createCard(
+    customerId: string,
+    accountId: string,
+    card: CreateApplicationResponse,
+    cardColor?: CardColors,
+    parentId?: string,
+  ): Promise<Card> {
+    return this.cardRepository.save(
+      this.cardRepository.create({
+        customerId: customerId,
+        expiry: card.expiryDate,
+        cardReference: card.cardId,
+        customerType: parentId ? CustomerType.CHILD : CustomerType.PARENT,
+        firstSixDigits: card.firstSixDigits,
+        lastFourDigits: card.lastFourDigits,
+        color: cardColor ? cardColor : CardColors.DEEP_MAGENTA,
+        scheme: CardScheme.VISA,
+        issuer: CardIssuers.NEOLEAP,
+        accountId: accountId,
+        vpan: card.vpan,
+        parentId,
+      }),
+    );
+  }
+
+  findChildCardsForGuardian(guardianId: string): Promise<Card[]> {
+    return this.cardRepository.find({
+      where: { parentId: guardianId, customerType: CustomerType.CHILD },
+      relations: ['account', 'customer', 'customer.user', 'customer.user.profilePicture', 'customer.junior'],
+    });
+  }
+
+  getCardById(id: string): Promise<Card | null> {
+    return this.cardRepository.findOne({
+      where: { id },
+      relations: [
+        'account',
+        'customer',
+        'customer.user',
+        'customer.junior',
+        'customer.junior.guardian',
+        'customer.junior.guardian.customer',
+        'customer.junior.guardian.customer.user',
+      ],
+    });
+  }
+
+  findCardByChildId(guardianId: string, childId: string): Promise<Card | null> {
+    return this.cardRepository.findOne({
+      where: { parentId: guardianId, customerId: childId, customerType: CustomerType.CHILD },
+      relations: ['account', 'customer', 'customer.user', 'customer.user.profilePicture', 'customer.junior'],
+    });
+  }
+
+  getCardByReferenceNumber(referenceNumber: string): Promise<Card | null> {
+    return this.cardRepository.findOne({ where: { cardReference: referenceNumber }, relations: ['account'] });
+  }
+
+  getCardByVpan(vpan: string): Promise<Card | null> {
+    return this.cardRepository.findOne({
+      where: { vpan },
+      relations: [
+        'account',
+        'customer',
+        'customer.user',
+        'customer.junior',
+        'customer.junior.guardian',
+        'customer.junior.guardian.customer',
+        'customer.junior.guardian.customer.user',
+      ],
+    });
+  }
+
+  getCardByCustomerId(customerId: string): Promise<Card | null> {
+    return this.cardRepository.findOne({
+      where: { customerId },
+      relations: [
+        'account',
+        'customer',
+        'customer.user',
+        'customer.junior',
+        'customer.junior.guardian',
+        'customer.junior.guardian.customer',
+        'customer.junior.guardian.customer.user',
+      ],
+    });
+  }
+
+  updateCardStatus(id: string, status: CardStatus, statusDescription: CardStatusDescription) {
+    return this.cardRepository.update(id, {
+      status: status,
+      statusDescription: statusDescription,
+    });
+  }
+
+  updateCardLimit(cardId: string, newLimit: number) {
+    return this.cardRepository.update(cardId, {
+      limit: newLimit,
+    });
+  }
+}

src/card/repositories/index.ts

@@ -0,0 +1,3 @@
+export * from './card.repository';
+export * from './transaction.repository';
+export * from './account.repository';

src/card/repositories/transaction.repository.ts

@@ -0,0 +1,183 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import moment from 'moment';
+import { Repository } from 'typeorm';
+import {
+  AccountTransactionWebhookRequest,
+  CardTransactionWebhookRequest,
+} from '~/common/modules/neoleap/dtos/requests';
+import { Card } from '../entities';
+import { Account } from '../entities/account.entity';
+import { Transaction } from '../entities/transaction.entity';
+import { TransactionScope, TransactionType } from '../enums';
+
+@Injectable()
+export class TransactionRepository {
+  constructor(@InjectRepository(Transaction) private transactionRepository: Repository<Transaction>) {}
+
+  createCardTransaction(card: Card, transactionData: CardTransactionWebhookRequest): Promise<Transaction> {
+    return this.transactionRepository.save(
+      this.transactionRepository.create({
+        transactionId: transactionData.transactionId,
+        cardReference: transactionData.cardId,
+        transactionAmount: transactionData.transactionAmount,
+        transactionCurrency: transactionData.transactionCurrency,
+        billingAmount: transactionData.billingAmount,
+        settlementAmount: transactionData.settlementAmount,
+        transactionDate: moment(transactionData.date + transactionData.time, 'YYYYMMDDHHmmss').toDate(),
+        rrn: transactionData.rrn,
+        cardMaskedNumber: transactionData.cardMaskedNumber,
+        fees: transactionData.fees,
+        cardId: card.id,
+        accountId: card.account!.id,
+        transactionType: TransactionType.EXTERNAL,
+        accountReference: card.account!.accountReference,
+        transactionScope: TransactionScope.CARD,
+        vatOnFees: transactionData.vatOnFees,
+        merchantName: transactionData.cardAcceptorLocation?.merchantName || null,
+        merchantCategoryCode: transactionData.cardAcceptorLocation?.mcc || null,
+        merchantCity: transactionData.cardAcceptorLocation?.merchantCity || null,
+      }),
+    );
+  }
+
+  createAccountTransaction(account: Account, transactionData: AccountTransactionWebhookRequest): Promise<Transaction> {
+    return this.transactionRepository.save(
+      this.transactionRepository.create({
+        transactionId: transactionData.transactionId,
+        transactionAmount: transactionData.amount,
+        transactionCurrency: transactionData.currency,
+        billingAmount: 0,
+        settlementAmount: 0,
+        transactionDate: moment(transactionData.date + transactionData.time, 'YYYYMMDDHHmmss').toDate(),
+        fees: 0,
+        accountReference: account.accountReference,
+        accountId: account.id,
+        transactionType: TransactionType.EXTERNAL,
+        transactionScope: TransactionScope.ACCOUNT,
+        vatOnFees: 0,
+      }),
+    );
+  }
+
+  createInternalChildTransaction(card: Card, amount: number): Promise<Transaction> {
+    return this.transactionRepository.save(
+      this.transactionRepository.create({
+        transactionId: `CHILD-${card.id}-${Date.now()}`,
+        transactionAmount: amount,
+        transactionCurrency: '682',
+        billingAmount: 0,
+        settlementAmount: 0,
+        transactionDate: new Date(),
+        fees: 0,
+        cardId: card.id,
+        cardReference: card.cardReference,
+        cardMaskedNumber: card.firstSixDigits + '******' + card.lastFourDigits,
+        accountId: card.account!.id,
+        transactionType: TransactionType.INTERNAL,
+        accountReference: card.account!.accountReference,
+        transactionScope: TransactionScope.CARD,
+        vatOnFees: 0,
+      }),
+    );
+  }
+
+  findTransactionByReference(transactionId: string, accountReference: string): Promise<Transaction | null> {
+    return this.transactionRepository.findOne({
+      where: { transactionId, accountReference },
+    });
+  }
+
+  getTransactionsForCardWithinDateRange(juniorId: string, startDate: Date, endDate: Date): Promise<Transaction[]> {
+    return this.transactionRepository
+      .createQueryBuilder('transaction')
+      .innerJoinAndSelect('transaction.card', 'card')
+      .where('card.customerId = :juniorId', { juniorId })
+      .andWhere('transaction.transactionScope = :scope', { scope: TransactionScope.CARD })
+      .andWhere('transaction.transactionType = :type', { type: TransactionType.EXTERNAL })
+      .andWhere('transaction.transactionDate BETWEEN :startDate AND :endDate', { startDate, endDate })
+      .orderBy('transaction.transactionDate', 'DESC')
+      .getMany();
+  }
+
+  findParentTransfers(guardianCustomerId: string, skip: number, take: number): Promise<Transaction[]> {
+    return this.transactionRepository
+      .createQueryBuilder('tx')
+      .innerJoinAndSelect('tx.card', 'card')
+      .innerJoinAndSelect('card.customer', 'childCustomer')
+      .innerJoinAndSelect('card.account', 'account')
+      .where('card.parentId = :guardianCustomerId', { guardianCustomerId })
+      .andWhere('tx.transactionScope = :scope', { scope: TransactionScope.CARD })
+      .andWhere('tx.transactionType = :type', { type: TransactionType.INTERNAL })
+      .orderBy('tx.transactionDate', 'DESC')
+      .skip(skip)
+      .take(take)
+      .getMany();
+  }
+
+  findParentTopups(guardianCustomerId: string, skip: number, take: number): Promise<Transaction[]> {
+    return this.transactionRepository
+      .createQueryBuilder('tx')
+      .innerJoinAndSelect('tx.account', 'account')
+      .leftJoinAndSelect('account.cards', 'parentCards')
+      .where('tx.transactionScope = :scope', { scope: TransactionScope.ACCOUNT })
+      .andWhere('parentCards.customerId = :guardianCustomerId', { guardianCustomerId })
+      .orderBy('tx.transactionDate', 'DESC')
+      .skip(skip)
+      .take(take)
+      .getMany();
+  }
+
+  countParentTransfers(guardianCustomerId: string): Promise<number> {
+    return this.transactionRepository
+      .createQueryBuilder('tx')
+      .innerJoin('tx.card', 'card')
+      .where('card.parentId = :guardianCustomerId', { guardianCustomerId })
+      .andWhere('tx.transactionScope = :scope', { scope: TransactionScope.CARD })
+      .andWhere('tx.transactionType = :type', { type: TransactionType.INTERNAL })
+      .getCount();
+  }
+
+  countParentTopups(guardianCustomerId: string): Promise<number> {
+    return this.transactionRepository
+      .createQueryBuilder('tx')
+      .innerJoin('tx.account', 'account')
+      .leftJoin('account.cards', 'parentCards')
+      .where('tx.transactionScope = :scope', { scope: TransactionScope.ACCOUNT })
+      .andWhere('parentCards.customerId = :guardianCustomerId', { guardianCustomerId })
+      .getCount();
+  }
+
+  findTransfersToJunior(juniorId: string, skip: number, take: number): Promise<Transaction[]> {
+    return this.transactionRepository
+      .createQueryBuilder('tx')
+      .innerJoinAndSelect('tx.card', 'card')
+      .innerJoinAndSelect('card.account', 'account')
+      .where('card.customerId = :juniorId', { juniorId })
+      .andWhere('tx.transactionScope = :scope', { scope: TransactionScope.CARD })
+      .andWhere('tx.transactionType = :type', { type: TransactionType.INTERNAL })
+      .orderBy('tx.transactionDate', 'DESC')
+      .skip(skip)
+      .take(take)
+      .getMany();
+  }
+
+  countTransfersToJunior(juniorId: string): Promise<number> {
+    return this.transactionRepository
+      .createQueryBuilder('tx')
+      .innerJoin('tx.card', 'card')
+      .where('card.customerId = :juniorId', { juniorId })
+      .andWhere('tx.transactionScope = :scope', { scope: TransactionScope.CARD })
+      .andWhere('tx.transactionType = :type', { type: TransactionType.INTERNAL })
+      .getCount();
+  }
+
+  findTransactionById(transactionId: string, juniorId: string): Promise<Transaction | null> {
+    return this.transactionRepository
+      .createQueryBuilder('tx')
+      .innerJoinAndSelect('tx.card', 'card')
+      .where('tx.id = :transactionId', { transactionId })
+      .andWhere('card.customerId = :juniorId', { juniorId })
+      .getOne();
+  }
+}

src/card/services/account.service.ts

@@ -0,0 +1,81 @@
+import { Injectable, UnprocessableEntityException } from '@nestjs/common';
+import { CreateApplicationResponse } from '~/common/modules/neoleap/dtos/response';
+import { Account } from '../entities/account.entity';
+import { AccountRepository } from '../repositories/account.repository';
+
+@Injectable()
+export class AccountService {
+  constructor(private readonly accountRepository: AccountRepository) {}
+
+  createAccount(data: CreateApplicationResponse): Promise<Account> {
+    return this.accountRepository.createAccount(data);
+  }
+
+  async getAccountByReferenceNumber(accountReference: string): Promise<Account> {
+    const account = await this.accountRepository.getAccountByReferenceNumber(accountReference);
+    if (!account) {
+      throw new UnprocessableEntityException('ACCOUNT.NOT_FOUND');
+    }
+    return account;
+  }
+
+  async getAccountByAccountNumber(accountNumber: string): Promise<Account> {
+    const account = await this.accountRepository.getAccountByAccountNumber(accountNumber);
+    if (!account) {
+      throw new UnprocessableEntityException('ACCOUNT.NOT_FOUND');
+    }
+    return account;
+  }
+
+  async getAccountByIban(iban: string): Promise<Account> {
+    const account = await this.accountRepository.getAccountByIban(iban);
+    if (!account) {
+      throw new UnprocessableEntityException('ACCOUNT.NOT_FOUND');
+    }
+    return account;
+  }
+
+  creditAccountBalance(accountReference: string, amount: number) {
+    return this.accountRepository.topUpAccountBalance(accountReference, amount);
+  }
+
+  async getAccountByCustomerId(customerId: string): Promise<Account> {
+    const account = await this.accountRepository.getAccountByCustomerId(customerId);
+    if (!account) {
+      throw new UnprocessableEntityException('ACCOUNT.NOT_FOUND');
+    }
+    return account;
+  }
+
+  async decreaseAccountBalance(accountReference: string, amount: number) {
+    const account = await this.getAccountByReferenceNumber(accountReference);
+
+    /**
+     *
+     * While there is no need to check for insufficient balance  because this is a webhook handler,
+     * I just added this check to ensure we don't have corruption in our data.
+     */
+
+    if (account.balance < amount) {
+      throw new UnprocessableEntityException('ACCOUNT.INSUFFICIENT_BALANCE');
+    }
+
+    return this.accountRepository.decreaseAccountBalance(accountReference, amount);
+  }
+
+  increaseReservedBalance(account: Account, amount: number) {
+    // Balance check is performed by the caller (e.g., transferToChild)
+    // to ensure correct account (guardian vs child) is validated
+    return this.accountRepository.increaseReservedBalance(account.id, amount);
+  }
+
+  decrementReservedBalance(account: Account, amount: number) {
+    return this.accountRepository.decreaseReservedBalance(account.id, amount);
+  }
+
+  //THIS IS A MOCK FUNCTION FOR TESTING PURPOSES ONLY
+  async fundIban(iban: string, amount: number) {
+    const account = await this.getAccountByIban(iban);
+    return this.accountRepository.topUpAccountBalance(account.accountReference, amount);
+  }
+}

src/card/services/card.service.ts

@@ -0,0 +1,213 @@
+import { BadRequestException, forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
+import Decimal from 'decimal.js';
+import { Transactional } from 'typeorm-transactional';
+import { AccountCardStatusChangedWebhookRequest } from '~/common/modules/neoleap/dtos/requests';
+import { NeoLeapService } from '~/common/modules/neoleap/services';
+import { Customer } from '~/customer/entities';
+import { KycStatus } from '~/customer/enums';
+import { CustomerService } from '~/customer/services';
+import { OciService } from '~/document/services';
+import { Card } from '../entities';
+import { CardColors } from '../enums';
+import { CardStatusMapper } from '../mappers/card-status.mapper';
+import { CardRepository } from '../repositories';
+import { AccountService } from './account.service';
+import { TransactionService } from './transaction.service';
+
+@Injectable()
+export class CardService {
+  private readonly logger = new Logger(CardService.name);
+  constructor(
+    private readonly cardRepository: CardRepository,
+    private readonly accountService: AccountService,
+    private readonly ociService: OciService,
+    @Inject(forwardRef(() => TransactionService)) private readonly transactionService: TransactionService,
+    @Inject(forwardRef(() => NeoLeapService)) private readonly neoleapService: NeoLeapService,
+    @Inject(forwardRef(() => CustomerService)) private readonly customerService: CustomerService,
+  ) {}
+
+  @Transactional()
+  async createCard(customerId: string): Promise<Card> {
+    const customer = await this.customerService.findCustomerById(customerId);
+
+    if (customer.kycStatus !== KycStatus.APPROVED) {
+      throw new BadRequestException('CUSTOMER.KYC_NOT_APPROVED');
+    }
+
+    if (!customer.neoleapExternalCustomerId) {
+      throw new BadRequestException('CUSTOMER.KYC_NOT_COMPLETED');
+    }
+
+    if (customer.cards.length > 0) {
+      throw new BadRequestException('CUSTOMER.ALREADY_HAS_CARD');
+    }
+
+    // Validate required fields for card creation
+    const missingFields = [];
+    if (!customer.nationalId) missingFields.push('nationalId');
+    if (!customer.dateOfBirth) missingFields.push('dateOfBirth');
+    if (!customer.nationalIdExpiry) missingFields.push('nationalIdExpiry');
+
+    if (missingFields.length > 0) {
+      throw new BadRequestException(
+        `CUSTOMER.MISSING_REQUIRED_FIELDS: ${missingFields.join(', ')}. Please complete your profile.`
+      );
+    }
+
+    const data = await this.neoleapService.createApplication(customer);
+    const account = await this.accountService.createAccount(data);
+    const createdCard = await this.cardRepository.createCard(customerId, account.id, data);
+
+    return this.getCardById(createdCard.id);
+  }
+
+  async getChildCards(guardianId: string): Promise<Card[]> {
+    const cards = await this.cardRepository.findChildCardsForGuardian(guardianId);
+    await this.prepareJuniorImages(cards);
+    return cards;
+  }
+
+  async createCardForChild(parentCustomer: Customer, childCustomer: Customer, cardColor: CardColors, cardPin: string) {
+    const data = await this.neoleapService.createChildCard(parentCustomer, childCustomer, cardPin);
+    const createdCard = await this.cardRepository.createCard(
+      childCustomer.id,
+      parentCustomer.cards[0].account.id,
+      data,
+      cardColor,
+      parentCustomer.id,
+    );
+
+    return this.getCardById(createdCard.id);
+  }
+
+  async getCardByChildId(guardianId: string, childId: string): Promise<Card> {
+    const card = await this.cardRepository.findCardByChildId(guardianId, childId);
+    if (!card) {
+      throw new BadRequestException('CARD.NOT_FOUND');
+    }
+    await this.prepareJuniorImages([card]);
+    return card;
+  }
+  async getCardById(id: string): Promise<Card> {
+    const card = await this.cardRepository.getCardById(id);
+
+    if (!card) {
+      throw new BadRequestException('CARD.NOT_FOUND');
+    }
+
+    return card;
+  }
+
+  async getCardByReferenceNumber(referenceNumber: string): Promise<Card> {
+    const card = await this.cardRepository.getCardByReferenceNumber(referenceNumber);
+
+    if (!card) {
+      throw new BadRequestException('CARD.NOT_FOUND');
+    }
+
+    return card;
+  }
+
+  async getCardByVpan(vpan: string): Promise<Card> {
+    const card = await this.cardRepository.getCardByVpan(vpan);
+
+    if (!card) {
+      throw new BadRequestException('CARD.NOT_FOUND');
+    }
+    return card;
+  }
+
+  async getCardByCustomerId(customerId: string): Promise<Card> {
+    const card = await this.cardRepository.getCardByCustomerId(customerId);
+    if (!card) {
+      throw new BadRequestException('CARD.NOT_FOUND');
+    }
+
+    return card;
+  }
+
+  async updateCardStatus(body: AccountCardStatusChangedWebhookRequest) {
+    const card = await this.getCardByVpan(body.cardId);
+    const { description, status } = CardStatusMapper[body.newStatus] || CardStatusMapper['99'];
+
+    return this.cardRepository.updateCardStatus(card.id, status, description);
+  }
+
+  async getEmbossingInformation(customerId: string) {
+    const card = await this.getCardByCustomerId(customerId);
+
+    return this.neoleapService.getEmbossingInformation(card);
+  }
+
+  async getChildCardEmbossingInformation(cardId: string, guardianId: string) {
+    const card = await this.getCardById(cardId);
+    if (card.parentId !== guardianId) {
+      throw new BadRequestException('CARD.DOES_NOT_BELONG_TO_GUARDIAN');
+    }
+    return this.neoleapService.getEmbossingInformation(card);
+  }
+
+  async updateCardLimit(cardId: string, newLimit: number) {
+    const { affected } = await this.cardRepository.updateCardLimit(cardId, newLimit);
+
+    if (affected === 0) {
+      throw new BadRequestException('CARD.NOT_FOUND');
+    }
+  }
+
+  async getIbanInformation(customerId: string) {
+    const account = await this.accountService.getAccountByCustomerId(customerId);
+    return account.iban;
+  }
+
+  @Transactional()
+  async transferToChild(juniorId: string, amount: number) {
+    const card = await this.getCardByCustomerId(juniorId);
+
+    this.logger.debug(`Transfer to child - juniorId: ${juniorId}, parentId: ${card.parentId}, cardId: ${card.id}`);
+    this.logger.debug(`Card account - balance: ${card.account.balance}, reserved: ${card.account.reservedBalance}`);
+
+    const fundingAccount = card.parentId
+      ? await this.accountService.getAccountByCustomerId(card.parentId)
+      : card.account;
+
+    this.logger.debug(`Funding account - balance: ${fundingAccount.balance}, reserved: ${fundingAccount.reservedBalance}, available: ${fundingAccount.balance - fundingAccount.reservedBalance}`);
+    this.logger.debug(`Amount requested: ${amount}`);
+
+    if (amount > fundingAccount.balance - fundingAccount.reservedBalance) {
+      this.logger.error(`Insufficient balance - requested: ${amount}, available: ${fundingAccount.balance - fundingAccount.reservedBalance}`);
+      throw new BadRequestException('CARD.INSUFFICIENT_BALANCE');
+    }
+
+    const finalAmount = Decimal(amount).plus(card.limit);
+    await Promise.all([
+      this.neoleapService.updateCardControl(card.cardReference, finalAmount.toNumber()),
+      this.updateCardLimit(card.id, finalAmount.toNumber()),
+      this.accountService.increaseReservedBalance(fundingAccount, amount),
+      this.transactionService.createInternalChildTransaction(card.id, amount),
+    ]);
+
+    return finalAmount.toNumber();
+  }
+
+  getWeeklySummary(juniorId: string, startDate?: Date, endDate?: Date) {
+    return this.transactionService.getWeeklySummary(juniorId, startDate, endDate);
+  }
+
+  fundIban(iban: string, amount: number) {
+    return this.accountService.fundIban(iban, amount);
+  }
+
+  private async prepareJuniorImages(cards: Card[]) {
+    this.logger.log(`Preparing junior images`);
+    await Promise.all(
+      cards.map(async (card) => {
+        const profilePicture = card.customer?.user?.profilePicture;
+
+        if (profilePicture) {
+          profilePicture.url = await this.ociService.generatePreSignedUrl(profilePicture);
+        }
+      }),
+    );
+  }
+}

src/card/services/index.ts

@@ -0,0 +1,3 @@
+export * from './card.service';
+export * from './transaction.service';
+export * from './account.service';

src/card/services/transaction.service.ts

@@ -0,0 +1,365 @@
+import { forwardRef, Inject, Injectable, UnprocessableEntityException } from '@nestjs/common';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import Decimal from 'decimal.js';
+import moment from 'moment';
+import { Transactional } from 'typeorm-transactional';
+import {
+  AccountTransactionWebhookRequest,
+  CardTransactionWebhookRequest,
+} from '~/common/modules/neoleap/dtos/requests';
+import { NOTIFICATION_EVENTS } from '~/common/modules/notification/constants/event-names.constant';
+import { ITransactionCreatedEvent } from '~/common/modules/notification/interfaces/notification-events.interface';
+import { Transaction } from '../entities/transaction.entity';
+import { CustomerType, TransactionType } from '../enums';
+import { TransactionRepository } from '../repositories/transaction.repository';
+import { AccountService } from './account.service';
+import { CardService } from './card.service';
+import {
+  TransactionItemResponseDto,
+  PagedTransactionsResponseDto,
+  ParentTransferItemDto,
+  PagedParentTransfersResponseDto,
+  ChildTransferItemDto,
+  PagedChildTransfersResponseDto,
+} from '../dtos/responses';
+import { ParentTransactionType } from '../enums';
+
+@Injectable()
+export class TransactionService {
+  constructor(
+    private readonly transactionRepository: TransactionRepository,
+    private readonly accountService: AccountService,
+    @Inject(forwardRef(() => CardService)) private readonly cardService: CardService,
+    private readonly eventEmitter: EventEmitter2,
+  ) {}
+
+  @Transactional()
+  async createCardTransaction(body: CardTransactionWebhookRequest) {
+    const card = await this.cardService.getCardByVpan(body.cardId);
+    const existingTransaction = await this.findExistingTransaction(body.transactionId, card.account.accountReference);
+
+    if (existingTransaction) {
+      throw new UnprocessableEntityException('TRANSACTION.ALREADY_EXISTS');
+    }
+
+    const transaction = await this.transactionRepository.createCardTransaction(card, body);
+    const total = new Decimal(body.transactionAmount).plus(body.billingAmount).plus(body.fees).plus(body.vatOnFees);
+
+    if (card.customerType === CustomerType.CHILD) {
+      if (card.parentId) {
+        const parentAccount = await this.accountService.getAccountByCustomerId(card.parentId);
+        await Promise.all([
+          this.accountService.decreaseAccountBalance(parentAccount.accountReference, total.toNumber()),
+          this.accountService.decrementReservedBalance(parentAccount, total.toNumber()),
+        ]);
+      } else {
+        await Promise.all([
+          this.accountService.decreaseAccountBalance(card.account.accountReference, total.toNumber()),
+          this.accountService.decrementReservedBalance(card.account, total.toNumber()),
+        ]);
+      }
+    } else {
+      await this.accountService.decreaseAccountBalance(card.account.accountReference, total.toNumber());
+    }
+
+    const event: ITransactionCreatedEvent = {
+      transaction,
+      card,
+      isTopUp: false,
+      isChildSpending: card.customerType === CustomerType.CHILD,
+      timestamp: new Date(),
+    };
+    this.eventEmitter.emit(NOTIFICATION_EVENTS.TRANSACTION_CREATED, event);
+
+    return transaction;
+  }
+
+  @Transactional()
+  async createAccountTransaction(body: AccountTransactionWebhookRequest) {
+    const account = await this.accountService.getAccountByAccountNumber(body.accountId);
+
+    const existingTransaction = await this.findExistingTransaction(body.transactionId, account.accountReference);
+
+    if (existingTransaction) {
+      throw new UnprocessableEntityException('TRANSACTION.ALREADY_EXISTS');
+    }
+
+    const transaction = await this.transactionRepository.createAccountTransaction(account, body);
+    await this.accountService.creditAccountBalance(account.accountReference, body.amount);
+
+    const accountWithCards = await this.accountService.getAccountByAccountNumber(body.accountId);
+    const card = accountWithCards.cards?.[0] 
+      ? await this.cardService.getCardById(accountWithCards.cards[0].id)
+      : null;
+
+    if (card) {
+      const event: ITransactionCreatedEvent = {
+        transaction,
+        card,
+        isTopUp: true,
+        isChildSpending: false,
+        timestamp: new Date(),
+      };
+      this.eventEmitter.emit(NOTIFICATION_EVENTS.TRANSACTION_CREATED, event);
+    }
+
+    return transaction;
+  }
+
+  async createInternalChildTransaction(cardId: string, amount: number) {
+    const card = await this.cardService.getCardById(cardId);
+    const transaction = await this.transactionRepository.createInternalChildTransaction(card, amount);
+    
+    const event: ITransactionCreatedEvent = {
+      transaction,
+      card,
+      isTopUp: true,
+      isChildSpending: true,
+      timestamp: new Date(),
+    };
+    
+    console.log(`[TransactionService] Emitting TRANSACTION_CREATED event for transaction ${transaction.id}`);
+    this.eventEmitter.emit(NOTIFICATION_EVENTS.TRANSACTION_CREATED, event);
+    console.log(`[TransactionService] Event emitted successfully`);
+    
+    return transaction;
+  }
+
+  private async findExistingTransaction(transactionId: string, accountReference: string): Promise<Transaction | null> {
+    const existingTransaction = await this.transactionRepository.findTransactionByReference(
+      transactionId,
+      accountReference,
+    );
+
+    return existingTransaction;
+  }
+
+  async getWeeklySummary(juniorId: string, startDate?: Date, endDate?: Date) {
+    let startOfWeek: Date;
+    let endOfWeek: Date;
+
+    if (startDate && endDate) {
+      startOfWeek = startDate;
+      endOfWeek = endDate;
+    } else {
+      const now = moment();
+      const dayOfWeek = now.day();
+      
+      startOfWeek = moment().subtract(dayOfWeek, 'days').startOf('day').toDate();
+      
+      endOfWeek = moment().add(6 - dayOfWeek, 'days').endOf('day').toDate();
+    }
+
+    const transactions = await this.transactionRepository.getTransactionsForCardWithinDateRange(
+      juniorId,
+      startOfWeek,
+      endOfWeek,
+    );
+    
+    const summary = {
+      startOfWeek: startOfWeek,
+      endOfWeek: endOfWeek,
+      total: 0,
+      monday: 0,
+      tuesday: 0,
+      wednesday: 0,
+      thursday: 0,
+      friday: 0,
+      saturday: 0,
+      sunday: 0,
+    };
+
+    transactions.forEach((transaction) => {
+      const day = moment(transaction.transactionDate).format('dddd').toLowerCase() as
+        | 'monday'
+        | 'tuesday'
+        | 'wednesday'
+        | 'thursday'
+        | 'friday'
+        | 'saturday'
+        | 'sunday';
+      summary[day] += transaction.transactionAmount;
+    });
+
+    summary.total = transactions.reduce((acc, curr) => acc + curr.transactionAmount, 0);
+
+    return summary;
+  }
+
+  async getParentConsolidated(
+    guardianCustomerId: string,
+    page: number,
+    size: number,
+  ): Promise<TransactionItemResponseDto[]> {
+    const skip = (page - 1) * size;
+
+    const [transfers, topups] = await Promise.all([
+      this.transactionRepository.findParentTransfers(guardianCustomerId, skip, size),
+      this.transactionRepository.findParentTopups(guardianCustomerId, skip, size),
+    ]);
+
+    const merged = [...transfers, ...topups].sort(
+      (a, b) => new Date(b.transactionDate).getTime() - new Date(a.transactionDate).getTime(),
+    );
+
+    const trimmed = merged.slice(0, size);
+
+    return trimmed.map((t) => this.mapParentItem(t));
+  }
+
+  async getParentTransactionsPaginated(
+    guardianCustomerId: string,
+    page: number,
+    size: number,
+    type?: ParentTransactionType,
+  ): Promise<PagedTransactionsResponseDto> {
+    const skip = (page - 1) * size;
+
+    let transfers: Transaction[] = [];
+    let topups: Transaction[] = [];
+    let transferCount = 0;
+    let topupCount = 0;
+
+    if (!type || type === ParentTransactionType.PARENT_TRANSFER) {
+      [transfers, transferCount] = await Promise.all([
+        this.transactionRepository.findParentTransfers(guardianCustomerId, skip, size),
+        this.transactionRepository.countParentTransfers(guardianCustomerId),
+      ]);
+    }
+
+    if (!type || type === ParentTransactionType.PARENT_TOPUP) {
+      [topups, topupCount] = await Promise.all([
+        this.transactionRepository.findParentTopups(guardianCustomerId, skip, size),
+        this.transactionRepository.countParentTopups(guardianCustomerId),
+      ]);
+    }
+
+    const total = transferCount + topupCount;
+
+    if (type) {
+      const items = type === ParentTransactionType.PARENT_TRANSFER ? transfers : topups;
+      const mapped = items.map((t) => this.mapParentItem(t));
+      return new PagedTransactionsResponseDto(mapped, page, size, total);
+    }
+
+    const merged = [...transfers, ...topups].sort(
+      (a, b) => new Date(b.transactionDate).getTime() - new Date(a.transactionDate).getTime(),
+    );
+
+    const paginated = merged.slice(0, size);
+    const mapped = paginated.map((t) => this.mapParentItem(t));
+
+    return new PagedTransactionsResponseDto(mapped, page, size, total);
+  }
+
+  async getParentTransfersOnly(guardianCustomerId: string, page: number, size: number): Promise<ParentTransferItemDto[]> {
+    const skip = (page - 1) * size;
+    const transfers = await this.transactionRepository.findParentTransfers(guardianCustomerId, skip, size);
+    return transfers.map((t) => this.mapToParentTransferItem(t));
+  }
+
+  async getParentTransfersPaginated(
+    guardianCustomerId: string,
+    page: number,
+    size: number,
+  ): Promise<PagedParentTransfersResponseDto> {
+    const skip = (page - 1) * size;
+    const [transfers, total] = await Promise.all([
+      this.transactionRepository.findParentTransfers(guardianCustomerId, skip, size),
+      this.transactionRepository.countParentTransfers(guardianCustomerId),
+    ]);
+    const items = transfers.map((t) => this.mapToParentTransferItem(t));
+    return new PagedParentTransfersResponseDto(items, page, size, total);
+  }
+
+  async getChildTransfers(juniorId: string, page: number, size: number): Promise<ChildTransferItemDto[]> {
+    const skip = (page - 1) * size;
+    const transfers = await this.transactionRepository.findTransfersToJunior(juniorId, skip, size);
+    return transfers.map((t) => this.mapToChildTransferItem(t));
+  }
+
+  async getChildTransfersPaginated(
+    juniorId: string,
+    page: number,
+    size: number,
+  ): Promise<PagedChildTransfersResponseDto> {
+    const skip = (page - 1) * size;
+    const [transfers, total] = await Promise.all([
+      this.transactionRepository.findTransfersToJunior(juniorId, skip, size),
+      this.transactionRepository.countTransfersToJunior(juniorId),
+    ]);
+    const items = transfers.map((t) => this.mapToChildTransferItem(t));
+    return new PagedChildTransfersResponseDto(items, page, size, total);
+  }
+
+  private mapToParentTransferItem(t: Transaction): ParentTransferItemDto {
+    const child = t.card?.customer;
+    const currency = t.transactionCurrency === '682' ? 'SAR' : t.transactionCurrency;
+    return {
+      date: t.transactionDate,
+      amount: Math.abs(t.transactionAmount),
+      currency,
+      childName: child ? `${child.firstName} ${child.lastName}` : 'Child',
+    };
+  }
+
+  private mapToChildTransferItem(t: Transaction): ChildTransferItemDto {
+    const amount = Math.abs(t.transactionAmount);
+    const currency = t.transactionCurrency === '682' ? 'SAR' : t.transactionCurrency;
+    return {
+      date: t.transactionDate,
+      amount,
+      currency,
+      message: `You received {{amount}} {{currency}} from your parent.`,
+    };
+  }
+
+  async getChildSpendingHistory(juniorId: string, startUtc: Date, endUtc: Date) {
+    const transactions = await this.transactionRepository.getTransactionsForCardWithinDateRange(
+      juniorId,
+      startUtc,
+      endUtc,
+    );
+
+    const { SpendingHistoryItemDto, SpendingHistoryResponseDto } = await import('../dtos/responses');
+    const items = transactions.map((t) => new SpendingHistoryItemDto(t));
+    return new SpendingHistoryResponseDto(items);
+  }
+
+  async getTransactionDetail(transactionId: string, juniorId: string) {
+    const transaction = await this.transactionRepository.findTransactionById(transactionId, juniorId);
+
+    if (!transaction) {
+      throw new UnprocessableEntityException('TRANSACTION.NOT_FOUND');
+    }
+
+    const { TransactionDetailResponseDto } = await import('../dtos/responses');
+    return new TransactionDetailResponseDto(transaction);
+  }
+
+  private mapParentItem(t: Transaction): TransactionItemResponseDto {
+    const dto = new TransactionItemResponseDto();
+    dto.date = t.transactionDate;
+
+    if (t.transactionType === TransactionType.INTERNAL) {
+      dto.type = ParentTransactionType.PARENT_TRANSFER;
+      dto.amountSigned = -Math.abs(t.transactionAmount);
+      const child = t.card?.customer;
+      dto.counterpartyName = child ? `${child.firstName} ${child.lastName}` : 'Child';
+      dto.childName = dto.counterpartyName;
+      dto.counterpartyAccountMasked = t.card?.account?.accountReference
+        ? `****${t.card.account.accountReference.slice(-4)}`
+        : null;
+      return dto;
+    }
+
+    dto.type = ParentTransactionType.PARENT_TOPUP;
+    const settlement = Number(t.settlementAmount ?? 0);
+    const txn = Number(t.transactionAmount ?? 0);
+    const creditAmount = settlement > 0 ? settlement : txn;
+    dto.amountSigned = Math.abs(Number.isFinite(creditAmount) ? creditAmount : 0);
+    dto.counterpartyName = 'Top-up';
+    dto.counterpartyAccountMasked = t.accountReference ? `****${t.accountReference.slice(-4)}` : null;
+    return dto;
+  }
+}

src/common/constants/countries-numeric-iso.constant.ts

@@ -0,0 +1,253 @@
+import { CountryIso } from '../enums';
+
+export const CountriesNumericISO: Record<CountryIso, string> = {
+  [CountryIso.ARUBA]: '533',
+  [CountryIso.AFGHANISTAN]: '004',
+  [CountryIso.ANGOLA]: '024',
+  [CountryIso.ANGUILLA]: '660',
+  [CountryIso.ALAND_ISLANDS]: '248',
+  [CountryIso.ALBANIA]: '008',
+  [CountryIso.ANDORRA]: '020',
+  [CountryIso.UNITED_ARAB_EMIRATES]: '784',
+  [CountryIso.ARGENTINA]: '032',
+  [CountryIso.ARMENIA]: '051',
+  [CountryIso.AMERICAN_SAMOA]: '016',
+  [CountryIso.ANTARCTICA]: '010',
+  [CountryIso.FRENCH_SOUTHERN_TERRITORIES]: '260',
+  [CountryIso.ANTIGUA_AND_BARBUDA]: '028',
+  [CountryIso.AUSTRALIA]: '036',
+  [CountryIso.AUSTRIA]: '040',
+  [CountryIso.AZERBAIJAN]: '031',
+  [CountryIso.BURUNDI]: '108',
+  [CountryIso.BELGIUM]: '056',
+  [CountryIso.BENIN]: '204',
+  [CountryIso.BONAIRE_SINT_EUSTATIUS_AND_SABA]: '535',
+  [CountryIso.BURKINA_FASO]: '854',
+  [CountryIso.BANGLADESH]: '050',
+  [CountryIso.BULGARIA]: '100',
+  [CountryIso.BAHRAIN]: '048',
+  [CountryIso.BAHAMAS]: '044',
+  [CountryIso.BOSNIA_AND_HERZEGOVINA]: '070',
+  [CountryIso.SAINT_BARTHÉLEMY]: '652',
+  [CountryIso.BELARUS]: '112',
+  [CountryIso.BELIZE]: '084',
+  [CountryIso.BERMUDA]: '060',
+  [CountryIso.BOLIVIA_PLURINATIONAL_STATE_OF]: '068',
+  [CountryIso.BRAZIL]: '076',
+  [CountryIso.BARBADOS]: '052',
+  [CountryIso.BRUNEI_DARUSSALAM]: '096',
+  [CountryIso.BHUTAN]: '064',
+  [CountryIso.BOUVET_ISLAND]: '074',
+  [CountryIso.BOTSWANA]: '072',
+  [CountryIso.CENTRAL_AFRICAN_REPUBLIC]: '140',
+  [CountryIso.CANADA]: '124',
+  [CountryIso.COCOS_KEELING_ISLANDS]: '166',
+  [CountryIso.SWITZERLAND]: '756',
+  [CountryIso.CHILE]: '152',
+  [CountryIso.CHINA]: '156',
+  [CountryIso.COTE_DIVOIRE]: '384',
+  [CountryIso.CAMEROON]: '120',
+  [CountryIso.CONGO_THE_DEMOCRATIC_REPUBLIC_OF_THE]: '180',
+  [CountryIso.CONGO]: '178',
+  [CountryIso.COOK_ISLANDS]: '184',
+  [CountryIso.COLOMBIA]: '170',
+  [CountryIso.COMOROS]: '174',
+  [CountryIso.CABO_VERDE]: '132',
+  [CountryIso.COSTA_RICA]: '188',
+  [CountryIso.CUBA]: '192',
+  [CountryIso.CURAÇAO]: '531',
+  [CountryIso.CHRISTMAS_ISLAND]: '162',
+  [CountryIso.CAYMAN_ISLANDS]: '136',
+  [CountryIso.CYPRUS]: '196',
+  [CountryIso.CZECHIA]: '203',
+  [CountryIso.GERMANY]: '276',
+  [CountryIso.DJIBOUTI]: '262',
+  [CountryIso.DOMINICA]: '212',
+  [CountryIso.DENMARK]: '208',
+  [CountryIso.DOMINICAN_REPUBLIC]: '214',
+  [CountryIso.ALGERIA]: '012',
+  [CountryIso.ECUADOR]: '218',
+  [CountryIso.EGYPT]: '818',
+  [CountryIso.ERITREA]: '232',
+  [CountryIso.WESTERN_SAHARA]: '732',
+  [CountryIso.SPAIN]: '724',
+  [CountryIso.ESTONIA]: '233',
+  [CountryIso.ETHIOPIA]: '231',
+  [CountryIso.FINLAND]: '246',
+  [CountryIso.FIJI]: '242',
+  [CountryIso.FALKLAND_ISLANDS_MALVINAS]: '238',
+  [CountryIso.FRANCE]: '250',
+  [CountryIso.FAROE_ISLANDS]: '234',
+  [CountryIso.MICRONESIA_FEDERATED_STATES_OF]: '583',
+  [CountryIso.GABON]: '266',
+  [CountryIso.UNITED_KINGDOM]: '826',
+  [CountryIso.GEORGIA]: '268',
+  [CountryIso.GUERNSEY]: '831',
+  [CountryIso.GHANA]: '288',
+  [CountryIso.GIBRALTAR]: '292',
+  [CountryIso.GUINEA]: '324',
+  [CountryIso.GUADELOUPE]: '312',
+  [CountryIso.GAMBIA]: '270',
+  [CountryIso.GUINEA_BISSAU]: '624',
+  [CountryIso.EQUATORIAL_GUINEA]: '226',
+  [CountryIso.GREECE]: '300',
+  [CountryIso.GRENADA]: '308',
+  [CountryIso.GREENLAND]: '304',
+  [CountryIso.GUATEMALA]: '320',
+  [CountryIso.FRENCH_GUIANA]: '254',
+  [CountryIso.GUAM]: '316',
+  [CountryIso.GUYANA]: '328',
+  [CountryIso.HONG_KONG]: '344',
+  [CountryIso.HEARD_ISLAND_AND_MCDONALD_ISLANDS]: '334',
+  [CountryIso.HONDURAS]: '340',
+  [CountryIso.CROATIA]: '191',
+  [CountryIso.HAITI]: '332',
+  [CountryIso.HUNGARY]: '348',
+  [CountryIso.INDONESIA]: '360',
+  [CountryIso.ISLE_OF_MAN]: '833',
+  [CountryIso.INDIA]: '356',
+  [CountryIso.BRITISH_INDIAN_OCEAN_TERRITORY]: '086',
+  [CountryIso.IRELAND]: '372',
+  [CountryIso.IRAN_ISLAMIC_REPUBLIC_OF]: '364',
+  [CountryIso.IRAQ]: '368',
+  [CountryIso.ICELAND]: '352',
+  [CountryIso.ISRAEL]: '376',
+  [CountryIso.ITALY]: '380',
+  [CountryIso.JAMAICA]: '388',
+  [CountryIso.JERSEY]: '832',
+  [CountryIso.JORDAN]: '400',
+  [CountryIso.JAPAN]: '392',
+  [CountryIso.KAZAKHSTAN]: '398',
+  [CountryIso.KENYA]: '404',
+  [CountryIso.KYRGYZSTAN]: '417',
+  [CountryIso.CAMBODIA]: '116',
+  [CountryIso.KIRIBATI]: '296',
+  [CountryIso.SAINT_KITTS_AND_NEVIS]: '659',
+  [CountryIso.KOREA_REPUBLIC_OF]: '410',
+  [CountryIso.KUWAIT]: '414',
+  [CountryIso.LAO_PEOPLES_DEMOCRATIC_REPUBLIC]: '418',
+  [CountryIso.LEBANON]: '422',
+  [CountryIso.LIBERIA]: '430',
+  [CountryIso.LIBYA]: '434',
+  [CountryIso.SAINT_LUCIA]: '662',
+  [CountryIso.LIECHTENSTEIN]: '438',
+  [CountryIso.SRI_LANKA]: '144',
+  [CountryIso.LESOTHO]: '426',
+  [CountryIso.LITHUANIA]: '440',
+  [CountryIso.LUXEMBOURG]: '442',
+  [CountryIso.LATVIA]: '428',
+  [CountryIso.MACAO]: '446',
+  [CountryIso.SAINT_MARTIN_FRENCH_PART]: '663',
+  [CountryIso.MOROCCO]: '504',
+  [CountryIso.MONACO]: '492',
+  [CountryIso.MOLDOVA_REPUBLIC_OF]: '498',
+  [CountryIso.MADAGASCAR]: '450',
+  [CountryIso.MALDIVES]: '462',
+  [CountryIso.MEXICO]: '484',
+  [CountryIso.MARSHALL_ISLANDS]: '584',
+  [CountryIso.NORTH_MACEDONIA]: '807',
+  [CountryIso.MALI]: '466',
+  [CountryIso.MALTA]: '470',
+  [CountryIso.MYANMAR]: '104',
+  [CountryIso.MONTENEGRO]: '499',
+  [CountryIso.MONGOLIA]: '496',
+  [CountryIso.NORTHERN_MARIANA_ISLANDS]: '580',
+  [CountryIso.MOZAMBIQUE]: '508',
+  [CountryIso.MAURITANIA]: '478',
+  [CountryIso.MONTSERRAT]: '500',
+  [CountryIso.MARTINIQUE]: '474',
+  [CountryIso.MAURITIUS]: '480',
+  [CountryIso.MALAWI]: '454',
+  [CountryIso.MALAYSIA]: '458',
+  [CountryIso.MAYOTTE]: '175',
+  [CountryIso.NAMIBIA]: '516',
+  [CountryIso.NEW_CALEDONIA]: '540',
+  [CountryIso.NIGER]: '562',
+  [CountryIso.NORFOLK_ISLAND]: '574',
+  [CountryIso.NIGERIA]: '566',
+  [CountryIso.NICARAGUA]: '558',
+  [CountryIso.NIUE]: '570',
+  [CountryIso.NETHERLANDS]: '528',
+  [CountryIso.NORWAY]: '578',
+  [CountryIso.NEPAL]: '524',
+  [CountryIso.NAURU]: '520',
+  [CountryIso.NEW_ZEALAND]: '554',
+  [CountryIso.OMAN]: '512',
+  [CountryIso.PAKISTAN]: '586',
+  [CountryIso.PANAMA]: '591',
+  [CountryIso.PITCAIRN]: '612',
+  [CountryIso.PERU]: '604',
+  [CountryIso.PHILIPPINES]: '608',
+  [CountryIso.PALAU]: '585',
+  [CountryIso.PAPUA_NEW_GUINEA]: '598',
+  [CountryIso.POLAND]: '616',
+  [CountryIso.PUERTO_RICO]: '630',
+  [CountryIso.KOREA_DEMOCRATIC_PEOPLES_REPUBLIC_OF]: '408',
+  [CountryIso.PORTUGAL]: '620',
+  [CountryIso.PARAGUAY]: '600',
+  [CountryIso.PALESTINE_STATE_OF]: '275',
+  [CountryIso.FRENCH_POLYNESIA]: '258',
+  [CountryIso.QATAR]: '634',
+  [CountryIso.REUNION]: '638',
+  [CountryIso.ROMANIA]: '642',
+  [CountryIso.RUSSIAN_FEDERATION]: '643',
+  [CountryIso.RWANDA]: '646',
+  [CountryIso.SAUDI_ARABIA]: '682',
+  [CountryIso.SUDAN]: '729',
+  [CountryIso.SENEGAL]: '686',
+  [CountryIso.SINGAPORE]: '702',
+  [CountryIso.SOUTH_GEORGIA_AND_THE_SOUTH_SANDWICH_ISLANDS]: '239',
+  [CountryIso.SAINT_HELENA_ASCENSION_AND_TRISTAN_DA_CUNHA]: '654',
+  [CountryIso.SVALBARD_AND_JAN_MAYEN]: '744',
+  [CountryIso.SOLOMON_ISLANDS]: '090',
+  [CountryIso.SIERRA_LEONE]: '694',
+  [CountryIso.EL_SALVADOR]: '222',
+  [CountryIso.SAN_MARINO]: '674',
+  [CountryIso.SOMALIA]: '706',
+  [CountryIso.SAINT_PIERRE_AND_MIQUELON]: '666',
+  [CountryIso.SERBIA]: '688',
+  [CountryIso.SOUTH_SUDAN]: '728',
+  [CountryIso.SAO_TOME_AND_PRINCIPE]: '678',
+  [CountryIso.SURINAME]: '740',
+  [CountryIso.SLOVAKIA]: '703',
+  [CountryIso.SLOVENIA]: '705',
+  [CountryIso.SWEDEN]: '752',
+  [CountryIso.ESWATINI]: '748',
+  [CountryIso.SINT_MAARTEN_DUTCH_PART]: '534',
+  [CountryIso.SEYCHELLES]: '690',
+  [CountryIso.SYRIAN_ARAB_REPUBLIC]: '760',
+  [CountryIso.TURKS_AND_CAICOS_ISLANDS]: '796',
+  [CountryIso.CHAD]: '148',
+  [CountryIso.TOGO]: '768',
+  [CountryIso.THAILAND]: '764',
+  [CountryIso.TAJIKISTAN]: '762',
+  [CountryIso.TOKELAU]: '772',
+  [CountryIso.TURKMENISTAN]: '795',
+  [CountryIso.TIMOR_LESTE]: '626',
+  [CountryIso.TONGA]: '776',
+  [CountryIso.TRINIDAD_AND_TOBAGO]: '780',
+  [CountryIso.TUNISIA]: '788',
+  [CountryIso.TURKEY]: '792',
+  [CountryIso.TUVALU]: '798',
+  [CountryIso.TAIWAN_PROVINCE_OF_CHINA]: '158',
+  [CountryIso.TANZANIA_UNITED_REPUBLIC_OF]: '834',
+  [CountryIso.UGANDA]: '800',
+  [CountryIso.UKRAINE]: '804',
+  [CountryIso.UNITED_STATES_MINOR_OUTLYING_ISLANDS]: '581',
+  [CountryIso.URUGUAY]: '858',
+  [CountryIso.UNITED_STATES]: '840',
+  [CountryIso.UZBEKISTAN]: '860',
+  [CountryIso.HOLY_SEE_VATICAN_CITY_STATE]: '336',
+  [CountryIso.SAINT_VINCENT_AND_THE_GRENADINES]: '670',
+  [CountryIso.VENEZUELA_BOLIVARIAN_REPUBLIC_OF]: '862',
+  [CountryIso.VIRGIN_ISLANDS_BRITISH]: '092',
+  [CountryIso.VIRGIN_ISLANDS_US]: '850',
+  [CountryIso.VIET_NAM]: '704',
+  [CountryIso.VANUATU]: '548',
+  [CountryIso.WALLIS_AND_FUTUNA]: '876',
+  [CountryIso.SAMOA]: '882',
+  [CountryIso.YEMEN]: '887',
+  [CountryIso.SOUTH_AFRICA]: '710',
+  [CountryIso.ZAMBIA]: '894',
+  [CountryIso.ZIMBABWE]: '716',
+};