feat(2589): soft delete unused asset

packages/backend/migrations/20240502132505_add_deleted_at_to_assets.js

@@ -0,0 +1,19 @@
+/**
+ * @param { import("knex").Knex } knex
+ * @returns { Promise<void> }
+ */
+exports.up = function (knex) {
+  return knex.schema.alterTable('assets', (table) => {
+    table.timestamp('deletedAt').nullable()
+  })
+}
+
+/**
+ * @param { import("knex").Knex } knex
+ * @returns { Promise<void> }
+ */
+exports.down = function (knex) {
+  return knex.schema.alterTable('assets', (table) => {
+    table.dropColumn('deletedAt')
+  })
+}

packages/backend/src/asset/errors.ts

@@ -1,8 +1,25 @@
 export enum AssetError {
   DuplicateAsset = 'DuplicateAsset',
-  UnknownAsset = 'UnknownAsset'
+  UnknownAsset = 'UnknownAsset',
+  InuseAsset = 'InuseAsset'
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
 export const isAssetError = (o: any): o is AssetError =>
   Object.values(AssetError).includes(o)
+
+export const errorToCode: {
+  [key in AssetError]: number
+} = {
+  [AssetError.UnknownAsset]: 404,
+  [AssetError.DuplicateAsset]: 400,
+  [AssetError.InuseAsset]: 400
+}
+
+export const errorToMessage: {
+  [key in AssetError]: string
+} = {
+  [AssetError.UnknownAsset]: 'unknown asset',
+  [AssetError.DuplicateAsset]: 'Asset already exists',
+  [AssetError.InuseAsset]: 'Asset in use'
+}

packages/backend/src/asset/model.ts

@@ -18,6 +18,8 @@ export class Asset extends BaseModel implements LiquidityAccount {
 
   public readonly liquidityThreshold!: bigint | null
 
+  public readonly deletedAt!: string | null
+
   public get asset(): LiquidityAccount['asset'] {
     return {
       id: this.id,

packages/backend/src/asset/service.ts

@@ -21,10 +21,15 @@ export interface UpdateOptions {
   withdrawalThreshold: bigint | null
   liquidityThreshold: bigint | null
 }
+export interface DeleteOptions {
+  id: string
+  deletedAt: string
+}
 
 export interface AssetService {
   create(options: CreateOptions): Promise<Asset | AssetError>
   update(options: UpdateOptions): Promise<Asset | AssetError>
+  delete(options: DeleteOptions): Promise<Asset | AssetError>
   get(id: string): Promise<void | Asset>
   getPage(pagination?: Pagination, sortOrder?: SortOrder): Promise<Asset[]>
   getAll(): Promise<Asset[]>
@@ -50,6 +55,7 @@ export async function createAssetService({
   return {
     create: (options) => createAsset(deps, options),
     update: (options) => updateAsset(deps, options),
+    delete: (options) => deleteAsset(deps, options),
     get: (id) => getAsset(deps, id),
     getPage: (pagination?, sortOrder?) =>
       getAssetsPage(deps, pagination, sortOrder),
@@ -111,21 +117,43 @@ async function updateAsset(
   }
 }
 
+// soft delete
+async function deleteAsset(
+  deps: ServiceDependencies,
+  { id, deletedAt }: DeleteOptions
+): Promise<Asset | AssetError> {
+  if (!deps.knex) {
+    throw new Error('Knex undefined')
+  }
+  try {
+    return await Asset.query(deps.knex)
+      .patchAndFetchById(id, { deletedAt })
+      .throwIfNotFound()
+  } catch (err) {
+    if (err instanceof NotFoundError) {
+      return AssetError.UnknownAsset
+    }
+    throw err
+  }
+}
+
 async function getAsset(
   deps: ServiceDependencies,
   id: string
 ): Promise<void | Asset> {
-  return await Asset.query(deps.knex).findById(id)
+  return await Asset.query(deps.knex).whereNull('deletedAt').findById(id)
 }
 
 async function getAssetsPage(
   deps: ServiceDependencies,
   pagination?: Pagination,
   sortOrder?: SortOrder
 ): Promise<Asset[]> {
-  return await Asset.query(deps.knex).getPage(pagination, sortOrder)
+  return await Asset.query(deps.knex)
+    .whereNull('deletedAt')
+    .getPage(pagination, sortOrder)
 }
 
 async function getAll(deps: ServiceDependencies): Promise<Asset[]> {
-  return await Asset.query(deps.knex)
+  return await Asset.query(deps.knex).whereNull('deletedAt')
 }