feat(card): add model and card endpoints (#2144)

* feat(card): add model and card endpoints

* fix: remove check

* fix: fetch wallet address

Author: dragosp1011

packages/wallet/backend/migrations/20251009143023_create_cards.js

@@ -0,0 +1,34 @@
+/**
+ * @param { import("knex").Knex } knex
+ * @returns { Promise<void> }
+ */
+exports.up = function (knex) {
+  return knex.schema.createTable('cards', (table) => {
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid()'))
+
+    table.uuid('userId').notNullable()
+    table.foreign('userId').references('users.id')
+
+    table.uuid('accountId').notNullable()
+    table.foreign('accountId').references('accounts.id')
+
+    table.uuid('walletAddressId').notNullable()
+    table.foreign('walletAddressId').references('walletAddresses.id')
+
+    table.string('publicKey')
+    table
+      .enum('status', ['ORDERED', 'INACTIVE', 'ACTIVE', 'FROZEN', 'TERMINATED'])
+      .notNullable()
+
+    table.timestamp('createdAt').notNullable()
+    table.timestamp('updatedAt').notNullable()
+  })
+}
+
+/**
+ * @param { import("knex").Knex } knex
+ * @returns { Promise<void> }
+ */
+exports.down = function (knex) {
+  return knex.schema.dropTableIfExists('cards')
+}

packages/wallet/backend/src/app.ts

@@ -161,6 +161,9 @@ export class App {
       : undefined
     const gateHubController = this.container.resolve('gateHubController')
     const cardController = this.container.resolve('cardController')
+    const interledgerCardController = this.container.resolve(
+      'interledgerCardController'
+    )
 
     app.use(
       cors({
@@ -414,6 +417,29 @@ export class App {
       cardController.closeCard
     )
 
+    // Interledger cards
+    router.get('/cards', isAuth, interledgerCardController.list)
+
+    router.get('/cards/:cardId', isAuth, interledgerCardController.getById)
+
+    router.post('/cards', isAuth, interledgerCardController.create)
+
+    router.put(
+      '/cards/:cardId/freeze',
+      isAuth,
+      interledgerCardController.freeze
+    )
+    router.put(
+      '/cards/:cardId/unfreeze',
+      isAuth,
+      interledgerCardController.unfreeze
+    )
+    router.delete(
+      '/cards/:cardId/terminate',
+      isAuth,
+      interledgerCardController.terminate
+    )
+
     // Return an error for invalid routes
     router.use('*', (req: Request, res: CustomResponse) => {
       const e = Error(`Requested path ${req.path} was not found`)

packages/wallet/backend/src/createContainer.ts

@@ -55,6 +55,8 @@ import { CardController } from './card/controller'
 import { CardService } from './card/service'
 import { StripeController } from './stripe-integration/controller'
 import { StripeService } from './stripe-integration/service'
+import { InterledgerCardController } from '@/interledgerCard/controller'
+import { InterledgerCardService } from '@/interledgerCard/service'
 
 export interface Cradle {
   env: Env
@@ -100,6 +102,8 @@ export interface Cradle {
   gateHubService: GateHubService
   cardService: CardService
   cardController: CardController
+  interledgerCardService: InterledgerCardService
+  interledgerCardController: InterledgerCardController
 }
 
 export async function createContainer(
@@ -160,7 +164,9 @@ export async function createContainer(
     gateHubClient: asClass(GateHubClient).singleton(),
     gateHubController: asClass(GateHubController).singleton(),
     gateHubService: asClass(GateHubService).singleton(),
-    cardController: asClass(CardController).singleton()
+    cardController: asClass(CardController).singleton(),
+    interledgerCardService: asClass(InterledgerCardService).singleton(),
+    interledgerCardController: asClass(InterledgerCardController).singleton()
   })
 
   return container

packages/wallet/backend/src/interledgerCard/controller.ts

@@ -0,0 +1,125 @@
+import type { NextFunction, Request } from 'express'
+import { validate } from '@/shared/validate'
+import { CreateCardResponse, InterledgerCardService } from './service'
+import { cardIdSchema, cardSchema } from './validation'
+import { Controller, toSuccessResponse } from '@shared/backend'
+import { Card } from '@/interledgerCard/model'
+
+interface IInterledgerCardController {
+  create: Controller<CreateCardResponse>
+  list: Controller<Card[]>
+  getById: Controller<Card>
+  freeze: Controller
+  unfreeze: Controller
+  terminate: Controller
+}
+
+export class InterledgerCardController implements IInterledgerCardController {
+  constructor(private interledgerCardService: InterledgerCardService) {}
+
+  create = async (
+    req: Request,
+    res: CustomResponse<Card>,
+    next: NextFunction
+  ) => {
+    try {
+      const userId = req.session.user.id
+      const {
+        body: { accountId, walletAddressId }
+      } = await validate(cardSchema, req)
+
+      const createAccountResult = await this.interledgerCardService.create({
+        userId,
+        accountId,
+        walletAddressId
+      })
+
+      res.status(200).json(toSuccessResponse(createAccountResult))
+    } catch (e) {
+      next(e)
+    }
+  }
+
+  list = async (
+    req: Request,
+    res: CustomResponse<Card[]>,
+    next: NextFunction
+  ) => {
+    const userId = req.session.user.id
+
+    try {
+      const accounts = await this.interledgerCardService.list(userId)
+
+      res.status(200).json(toSuccessResponse(accounts))
+    } catch (e) {
+      next(e)
+    }
+  }
+
+  getById = async (
+    req: Request,
+    res: CustomResponse<Card>,
+    next: NextFunction
+  ) => {
+    const userId = req.session.user.id
+    const {
+      params: { cardId }
+    } = await validate(cardIdSchema, req)
+
+    try {
+      const getAccountsResult = await this.interledgerCardService.getById(
+        userId,
+        cardId
+      )
+
+      res.status(200).json(toSuccessResponse(getAccountsResult))
+    } catch (e) {
+      next(e)
+    }
+  }
+
+  freeze = async (req: Request, res: CustomResponse, next: NextFunction) => {
+    try {
+      const userId = req.session.user.id
+      const {
+        params: { cardId }
+      } = await validate(cardIdSchema, req)
+
+      await this.interledgerCardService.freeze(userId, cardId)
+
+      res.status(200).json(toSuccessResponse())
+    } catch (e) {
+      next(e)
+    }
+  }
+
+  unfreeze = async (req: Request, res: CustomResponse, next: NextFunction) => {
+    try {
+      const userId = req.session.user.id
+      const {
+        params: { cardId }
+      } = await validate(cardIdSchema, req)
+
+      await this.interledgerCardService.unfreeze(userId, cardId)
+
+      res.status(200).json(toSuccessResponse())
+    } catch (e) {
+      next(e)
+    }
+  }
+
+  terminate = async (req: Request, res: CustomResponse, next: NextFunction) => {
+    try {
+      const userId = req.session.user.id
+      const {
+        params: { cardId }
+      } = await validate(cardIdSchema, req)
+
+      await this.interledgerCardService.terminate(userId, cardId)
+
+      res.status(200).json(toSuccessResponse())
+    } catch (e) {
+      next(e)
+    }
+  }
+}

packages/wallet/backend/src/interledgerCard/model.ts

@@ -0,0 +1,53 @@
+import { WalletAddress } from '@/walletAddress/model'
+import { User } from '@/user/model'
+import { Model } from 'objection'
+import { BaseModel } from '@shared/backend'
+import { Account } from '@/account/model'
+
+export type CardStatusType =
+  | 'ORDERED'
+  | 'INACTIVE'
+  | 'ACTIVE'
+  | 'FROZEN'
+  | 'TERMINATED'
+
+export class Card extends BaseModel {
+  static tableName = 'cards'
+
+  public readonly accountId!: string
+  public readonly userId!: string
+  public readonly walletAddressId!: string
+  public readonly publicKey?: string | null
+  public readonly status!: CardStatusType
+
+  public user!: User
+  public account!: Account
+  public walletAddress!: WalletAddress
+
+  static relationMappings = () => ({
+    user: {
+      relation: Model.BelongsToOneRelation,
+      modelClass: User,
+      join: {
+        from: 'cards.userId',
+        to: 'users.id'
+      }
+    },
+    walletAddress: {
+      relation: Model.BelongsToOneRelation,
+      modelClass: WalletAddress,
+      join: {
+        from: 'cards.walletAddressId',
+        to: 'walletAddresses.id'
+      }
+    },
+    account: {
+      relation: Model.BelongsToOneRelation,
+      modelClass: Account,
+      join: {
+        from: 'cards.accountId',
+        to: 'account.id'
+      }
+    }
+  })
+}