@filoz/repair-cli 0.1.1 → 0.2.0

package/src/commands/replicate.ts

@@ -0,0 +1,183 @@
+import { and, desc, eq, inArray, isNotNull } from 'drizzle-orm'
+import { Cli, z } from 'incur'
+import { repairDelete } from '../db/repair-delete.ts'
+import { replicateCreate } from '../db/replicate-create.ts'
+import { contextMiddleware, contextSchema } from '../middleware.ts'
+import { runAddPieces } from '../pipeline/add-pieces.ts'
+import { ensureReplicateDataset } from '../pipeline/create-datasets.ts'
+import { globalOptions } from '../utils.ts'
+
+export const replicate = Cli.create('replicate', {
+  description: 'Replicate dataset commands',
+  vars: contextSchema,
+})
+
+replicate.command('create', {
+  description: 'Create a new dataset replication',
+  options: globalOptions.extend({
+    dataSetId: z.coerce.bigint().describe('Dataset ID to replicate'),
+    targetProviderId: z.coerce.bigint().describe('Target provider ID for replication'),
+  }),
+  middleware: [contextMiddleware],
+  run: async (c) => {
+    try {
+      const { dataSetId, targetProviderId } = c.options
+
+      const replicateId = await replicateCreate({
+        ...c.var,
+        dataSetId,
+        targetProviderId,
+      })
+
+      return c.ok({
+        replicateId,
+      })
+    } catch (error) {
+      console.error(error)
+      return c.error({
+        code: 'REPLICATE_FAILED',
+        message: error instanceof Error ? error.message : 'Failed to replicate the dataset',
+        retryable: true,
+      })
+    }
+  },
+})
+
+replicate.command('list', {
+  description: 'List all replications',
+  options: globalOptions,
+  middleware: [contextMiddleware],
+  run: async (c) => {
+    try {
+      const localSchema = c.var.localDb._.fullSchema
+      const replications = await c.var.localDb.query.repairs.findMany({
+        where: isNotNull(localSchema.repairs.repairDataSetId),
+        orderBy: [desc(localSchema.repairs.createdAt)],
+        with: {
+          operations: true,
+        },
+      })
+
+      const replicationsFlattened = replications.map((repair) => {
+        const { operations, ...replicationWithoutOperations } = repair
+        return {
+          id: replicationWithoutOperations.id,
+          status: replicationWithoutOperations.status,
+          sourceProviderId: replicationWithoutOperations.repairProviderId,
+          sourceDataSetId: replicationWithoutOperations.repairDataSetId,
+          targetProviderId: replicationWithoutOperations.targetProviderId,
+          targetProviderUrl: replicationWithoutOperations.targetProviderUrl,
+          targetDataSetId: replicationWithoutOperations.targetDataSetId,
+          blockNumber: replicationWithoutOperations.blockNumber,
+          operations: operations.length,
+          pending: operations.filter((operation) => operation.status === 'pending').length,
+          failed: operations.filter((operation) => operation.status === 'failed').length,
+          completed: operations.filter((operation) => operation.status === 'completed').length,
+          skipped: operations.filter((operation) => operation.status === 'skipped').length,
+        }
+      })
+
+      return c.ok({
+        replications: replicationsFlattened,
+      })
+    } catch (error) {
+      console.error(error)
+      return c.error({
+        code: 'REPLICATE_FAILED',
+        message: error instanceof Error ? error.message : 'Failed to list replications',
+        retryable: true,
+      })
+    }
+  },
+})
+
+replicate.command('delete', {
+  description: 'Delete a replication',
+  args: z.object({
+    replicateId: z.coerce.number().describe('Replication ID to delete'),
+  }),
+  options: globalOptions,
+  middleware: [contextMiddleware],
+  run: async (c) => {
+    try {
+      const { deleted, operationsDeleted } = await repairDelete({
+        localDb: c.var.localDb,
+        repairId: c.args.replicateId,
+      })
+
+      if (!deleted) {
+        return c.error({
+          code: 'REPLICATE_NOT_FOUND',
+          message: 'Replication not found',
+          retryable: false,
+        })
+      }
+
+      return c.ok({
+        replicateId: c.args.replicateId,
+        operationsDeleted,
+      })
+    } catch (error) {
+      console.error(error)
+      return c.error({
+        code: 'REPLICATE_FAILED',
+        message: error instanceof Error ? error.message : 'Failed to delete the replication',
+        retryable: true,
+      })
+    }
+  },
+})
+
+replicate.command('run', {
+  description: 'Run a replication',
+  args: z.object({
+    replicateId: z.coerce.number().describe('Replication ID to run'),
+  }),
+  options: globalOptions.extend({
+    concurrency: z.coerce.number().min(1).max(10).default(4).describe('Concurrency level'),
+    batchSize: z.coerce.number().min(1).max(40).default(40).describe('Max pieces per batch'),
+  }),
+  middleware: [contextMiddleware],
+  run: async (c) => {
+    try {
+      const schema = c.var.localDb._.fullSchema
+      const repair = await c.var.localDb.query.repairs.findFirst({
+        where: and(
+          eq(schema.repairs.id, c.args.replicateId),
+          inArray(schema.repairs.status, ['pending', 'failed']),
+          isNotNull(schema.repairs.repairDataSetId)
+        ),
+      })
+      if (!repair) {
+        return c.error({
+          code: 'REPLICATE_NOT_FOUND',
+          message: 'Replication not found, it may have already been run or completed',
+          retryable: false,
+        })
+      }
+
+      await ensureReplicateDataset({
+        ...c.var,
+        repair,
+        source: c.var.source,
+      })
+
+      await runAddPieces({
+        ...c.var,
+        repair,
+        concurrency: c.options.concurrency,
+        batchSize: c.options.batchSize,
+      })
+      return c.ok({
+        replicateId: repair.id,
+      })
+    } catch (error) {
+      console.error(error)
+      return c.error({
+        code: 'REPLICATE_FAILED',
+        message: error instanceof Error ? error.message : 'Failed to replicate the dataset',
+        retryable: true,
+      })
+    }
+  },
+})

package/src/commands/setup.ts

@@ -114,12 +114,28 @@ export const setup = Cli.create('setup', {
         })
       }
 
+      const source = await p.text({
+        message: 'Enter your source',
+        placeholder: 'Dataset source',
+        defaultValue: 'early-repair',
+        initialValue: config.get('source'),
+        withGuide: false,
+      })
+      if (p.isCancel(source)) {
+        return c.error({
+          code: 'SETUP_CANCELLED',
+          message: 'Setup cancelled',
+          retryable: false,
+        })
+      }
+
       // Set config
       config.set('privateKey', pk)
       config.set('indexerMainnetUrl', indexerMainnetUrl)
       config.set('indexerCalibrationUrl', indexerCalibrationUrl)
       config.set('chainId', chainId)
       config.set('dbPath', dbPath)
+      config.set('source', source)
 
       // setup database
       const db = await createLocalDatabase(dbPath)

package/src/db/dedupe-cids.ts

@@ -0,0 +1,49 @@
+import { and, eq, inArray } from 'drizzle-orm'
+import type { OperationSelect } from '../local-schema.ts'
+import type { IndexerDatabase, LocalDatabase } from '../types.ts'
+import { upsertOperations } from './upsert-operations.ts'
+
+export type SyncPiecesOnchainOptions = {
+  indexerDb: IndexerDatabase
+  localDb: LocalDatabase
+  dataSetId: bigint
+  operations: OperationSelect[]
+}
+
+/**
+ * Dedupe operations by CID on the target repair dataset.
+ * Returns operations that are not onchain.
+ */
+export async function dedupeCids({ indexerDb, localDb, dataSetId, operations }: SyncPiecesOnchainOptions) {
+  const cids = operations.map((operation) => operation.cid)
+  const schema = indexerDb._.fullSchema
+
+  const rows = await indexerDb
+    .select({ cid: schema.pieces.cid })
+    .from(schema.pieces)
+    .where(
+      and(eq(schema.pieces.dataSetId, dataSetId), eq(schema.pieces.removed, false), inArray(schema.pieces.cid, cids))
+    )
+
+  const existingCids = new Set<string>()
+  const completedOperations: OperationSelect[] = []
+
+  for (const row of rows) {
+    completedOperations.push(...operations.filter((operation) => operation.cid === row.cid))
+    existingCids.add(row.cid)
+  }
+
+  if (completedOperations.length > 0) {
+    await upsertOperations({
+      localDb,
+      operations: completedOperations.map((operation) => ({
+        ...operation,
+        status: 'completed',
+        error: null,
+      })),
+    })
+  }
+
+  // return operations that are not onchain
+  return operations.filter((operation) => !existingCids.has(operation.cid))
+}

package/src/db/{get-providers-by-cid.ts → find-providers-by-cid.ts}

@@ -1,10 +1,9 @@
-import { and, asc, eq, inArray, isNull, lte, notInArray, or } from 'drizzle-orm'
+import { and, asc, eq, inArray, isNull, lte, or } from 'drizzle-orm'
 import type { IndexerDatabase, RepairProvider } from '../types.ts'
 
-export type GetProvidersByCidOptions = {
+export type FindProvidersByCidOptions = {
   indexerDb: IndexerDatabase
   cids: readonly string[]
-  excludedProviderIds: readonly bigint[]
   blockNumber: bigint
 }
 
@@ -20,12 +19,11 @@ export type ProvidersByCid = Record<string, RepairProvider[]>
  * included. Every requested CID is present in the result; CIDs with no alternate providers
  * map to an empty array.
  */
-export async function getProvidersByCid({
+export async function findProvidersByCid({
   indexerDb,
   cids,
-  excludedProviderIds,
   blockNumber,
-}: GetProvidersByCidOptions): Promise<ProvidersByCid> {
+}: FindProvidersByCidOptions): Promise<ProvidersByCid> {
   const schema = indexerDb._.fullSchema
   const providersByCid = Object.fromEntries(cids.map((cid) => [cid, []])) as ProvidersByCid
   if (cids.length === 0) return providersByCid
@@ -35,11 +33,8 @@ export async function getProvidersByCid({
     eq(schema.dataSets.deleted, false),
     or(isNull(schema.dataSets.pdpEndEpoch), lte(schema.dataSets.pdpEndEpoch, blockNumber)),
     eq(schema.pieces.removed, false),
-    // or(eq(schema.providers.approved, true), eq(schema.providers.endorsed, true)),
+    or(eq(schema.providers.approved, true), eq(schema.providers.endorsed, true)),
   ]
-  if (excludedProviderIds.length > 0) {
-    filters.push(notInArray(schema.dataSets.providerId, [...excludedProviderIds]))
-  }
 
   // Join through datasets because providers own datasets, while pieces only reference dataset IDs.
   const rows = await indexerDb

package/src/db/{get-repair-dataset.ts → find-repair-dataset.ts}

@@ -1,12 +1,12 @@
 import { and, asc, eq, isNull } from 'drizzle-orm'
 import type { Address } from 'viem'
 import type { IndexerDatabase } from '../types.ts'
-import { EARLY_REPAIR_SOURCE } from '../utils.ts'
 
-export type GetRepairDatasetOptions = {
+export type FindRepairDatasetOptions = {
   indexerDb: IndexerDatabase
   providerId: bigint
   payer: Address
+  source: string
 }
 
 /**
@@ -14,14 +14,15 @@ export type GetRepairDatasetOptions = {
  *
  * When multiple datasets match, the lowest `dataSetId` is returned.
  */
-export async function getRepairDataset({
+export async function findRepairDataset({
   indexerDb,
   providerId,
   payer,
-}: GetRepairDatasetOptions): Promise<bigint | null> {
+  source,
+}: FindRepairDatasetOptions): Promise<bigint | null> {
   const schema = indexerDb._.fullSchema
 
-  const [row] = await indexerDb
+  const result = await indexerDb
     .select({
       dataSetId: schema.dataSets.dataSetId,
     })
@@ -32,7 +33,7 @@ export async function getRepairDataset({
         eq(schema.dataSets.deleted, false),
         isNull(schema.dataSets.pdpEndEpoch),
         eq(schema.dataSets.payer, payer.toLowerCase()),
-        eq(schema.dataSets.source, EARLY_REPAIR_SOURCE),
+        eq(schema.dataSets.source, source),
         eq(schema.dataSets.withCdn, false),
         eq(schema.dataSets.withIpfsIndexing, true)
       )
@@ -40,5 +41,9 @@ export async function getRepairDataset({
     .orderBy(asc(schema.dataSets.dataSetId))
     .limit(1)
 
-  return row.dataSetId ?? null
+  if (result.length === 0) {
+    return null
+  }
+
+  return result[0].dataSetId
 }

package/src/db/get-pieces.ts

@@ -3,7 +3,7 @@ import { and, asc, eq, isNull, lte, or } from 'drizzle-orm'
 import pMap from 'p-map'
 import type { OperationInsert } from '../local-schema.ts'
 import type { IndexerDatabase } from '../types.ts'
-import { getProvidersByCid } from './get-providers-by-cid.ts'
+import { findProvidersByCid } from './find-providers-by-cid.ts'
 
 /** Default page size when paginating pieces from the indexer. */
 export const DEFAULT_PIECES_PAGE_SIZE = 3000
@@ -43,6 +43,34 @@ export type GetPiecesPageResult = {
 /** Options for {@link forEachPiecesPage}; pagination state is managed internally. */
 export type ForEachPiecesPageOptions = Omit<GetPiecesPageOptions, 'offset' | 'seenCids'>
 
+/** Options for fetching one page of source-dataset pieces for replication. */
+export type GetDataSetPiecesPageOptions = {
+  indexerDb: IndexerDatabase
+  /** Source dataset whose pieces are being replicated. */
+  dataSetId: bigint
+  /** Local job row to attach operations to. */
+  repairId: number
+  /** Provider URL that serves the source dataset pieces. */
+  sourceProviderUrl: string
+  /** Max indexer rows per page. Defaults to {@link DEFAULT_PIECES_PAGE_SIZE}. */
+  limit?: number
+  /** SQL offset for the indexer query. */
+  offset?: number
+}
+
+/** Result of a single {@link getDataSetPiecesPage} call. */
+export type GetDataSetPiecesPageResult = {
+  /** `add_piece` operations ready to insert for this page. */
+  operations: OperationInsert[]
+  /** Whether another indexer page may exist after this one. */
+  hasMore: boolean
+  /** Offset to pass as `offset` on the next page. */
+  nextOffset: number
+}
+
+/** Options for {@link forEachDataSetPiecesPage}; pagination state is managed internally. */
+export type ForEachDataSetPiecesPageOptions = Omit<GetDataSetPiecesPageOptions, 'offset'>
+
 type PieceForOperation = {
   cid: string
   metadata: Record<string, string> | null
@@ -107,10 +135,9 @@ export async function getPiecesPage({
   }
 
   // Resolve pull sources in one query per page; exclude the provider being repaired from alternates.
-  const providersByCid = await getProvidersByCid({
+  const providersByCid = await findProvidersByCid({
     indexerDb,
     cids: pieces.map((piece) => piece.cid),
-    excludedProviderIds: [],
     blockNumber,
   })
 
@@ -157,6 +184,53 @@ export async function getPiecesPage({
   }
 }
 
+/**
+ * Fetch one page of pieces for a specific dataset and map them to replication operations.
+ *
+ * Unlike repairs, replication preserves source dataset ordering and does not dedupe repeated CIDs.
+ *
+ * @param options - Indexer connection, dataset context, and optional pagination state.
+ * @returns Operations for this page plus pagination cursors.
+ */
+export async function getDataSetPiecesPage({
+  indexerDb,
+  dataSetId,
+  repairId,
+  sourceProviderUrl,
+  limit = DEFAULT_PIECES_PAGE_SIZE,
+  offset = 0,
+}: GetDataSetPiecesPageOptions): Promise<GetDataSetPiecesPageResult> {
+  const schema = indexerDb._.fullSchema
+  const rows = await indexerDb
+    .select({
+      cid: schema.pieces.cid,
+      metadata: schema.pieces.metadata,
+    })
+    .from(schema.pieces)
+    .where(and(eq(schema.pieces.dataSetId, dataSetId), eq(schema.pieces.removed, false)))
+    .orderBy(asc(schema.pieces.pieceId))
+    .limit(limit)
+    .offset(offset)
+
+  const now = Date.now()
+  const operations: OperationInsert[] = rows.map(({ cid, metadata }) => ({
+    repairId,
+    type: 'add_piece',
+    status: 'pending',
+    cid,
+    metadata: metadata ?? {},
+    alternateProvider: sourceProviderUrl,
+    createdAt: now,
+    updatedAt: now,
+  }))
+
+  return {
+    operations,
+    hasMore: rows.length === limit,
+    nextOffset: offset + rows.length,
+  }
+}
+
 /**
  * Walk every page of `add_piece` operations for a provider, invoking `onPage` per batch.
  *
@@ -187,3 +261,31 @@ export async function forEachPiecesPage(
     hasMore = page.hasMore
   }
 }
+
+/**
+ * Walk every page of `add_piece` operations for a source dataset, invoking `onPage` per batch.
+ *
+ * Replication pagination intentionally has no CID dedupe state so duplicate pieces are preserved.
+ *
+ * @param options - Same inputs as {@link getDataSetPiecesPage} except pagination cursor.
+ * @param onPage - Async handler for each page result (e.g. batch insert into local DB).
+ */
+export async function forEachDataSetPiecesPage(
+  options: ForEachDataSetPiecesPageOptions,
+  onPage: (page: GetDataSetPiecesPageResult) => Promise<void>
+): Promise<void> {
+  let offset = 0
+  let hasMore = true
+
+  while (hasMore) {
+    const page = await getDataSetPiecesPage({
+      ...options,
+      offset,
+    })
+
+    await onPage(page)
+
+    offset = page.nextOffset
+    hasMore = page.hasMore
+  }
+}

package/src/db/get-target-dataset.ts

@@ -6,7 +6,7 @@ import type { LocalDatabase, WalletClient } from '../types.ts'
 const targetDatasetCache = new Map<number, getDataSet.OutputType>()
 
 /**
- * Get the single IPFS-enabled target dataset for a repair.
+ * Get a targetdataset for a repair.
  *
  * @param options - The options for getting the target dataset.
  */

package/src/db/repair-create.ts

@@ -47,6 +47,7 @@ export async function repairCreate(options: RepairCreateOptions): Promise<number
     .insert(localSchema.repairs)
     .values({
       repairProviderId,
+      repairDataSetId: null,
       targetProviderId: targetProvider.providerId,
       targetProviderUrl: targetProvider.serviceUrl,
       targetDataSetId: null,

package/src/db/repair-delete.ts

@@ -19,11 +19,6 @@ export async function repairDelete({ localDb, repairId }: RepairDeleteOptions):
   const repair = await localDb.query.repairs.findFirst({
     where: eq(localSchema.repairs.id, repairId),
     columns: { id: true },
-    with: {
-      operations: {
-        columns: { id: true },
-      },
-    },
   })
 
   if (!repair) {

package/src/db/replicate-create.ts

@@ -0,0 +1,106 @@
+import { taskLog } from '@clack/prompts'
+import { eq } from 'drizzle-orm'
+import { getBlockNumber } from 'viem/actions'
+import { NoAlternateProviderError, RepairCreationError } from '../error.ts'
+import type { Context } from '../types.ts'
+import { forEachDataSetPiecesPage } from './get-pieces.ts'
+import { getRepairProvider } from './get-repair-provider.ts'
+
+export interface ReplicateCreateOptions extends Context {
+  dataSetId: bigint
+  targetProviderId: bigint
+}
+
+/**
+ * Prepare a replication job by creating a local row and inserting every source dataset piece.
+ *
+ * @param options - The options for creating a replication job.
+ * @returns The ID of the created local job.
+ */
+export async function replicateCreate(options: ReplicateCreateOptions): Promise<number> {
+  const { indexerDb, localDb, dataSetId, targetProviderId, client } = options
+  const indexerSchema = indexerDb._.fullSchema
+  const localSchema = localDb._.fullSchema
+  const now = Date.now()
+  const blockNumber = await getBlockNumber(client)
+
+  const log = taskLog({
+    title: 'Creating replication',
+    limit: 10,
+    retainLog: true,
+  })
+
+  const [sourceDataSet] = await indexerDb
+    .select({
+      dataSetId: indexerSchema.dataSets.dataSetId,
+      providerId: indexerSchema.dataSets.providerId,
+      deleted: indexerSchema.dataSets.deleted,
+    })
+    .from(indexerSchema.dataSets)
+    .where(eq(indexerSchema.dataSets.dataSetId, dataSetId))
+    .limit(1)
+
+  if (!sourceDataSet || sourceDataSet.deleted) {
+    throw new RepairCreationError(`Source dataset ${dataSetId} not found or deleted`)
+  }
+
+  if (targetProviderId === sourceDataSet.providerId) {
+    throw new RepairCreationError('Target provider must differ from the source dataset provider')
+  }
+
+  const sourceProvider = await getRepairProvider({
+    indexerDb,
+    providerId: sourceDataSet.providerId,
+  })
+
+  if (!sourceProvider) {
+    throw new RepairCreationError(`Source provider ${sourceDataSet.providerId} not found or inactive`)
+  }
+
+  const targetProvider = await getRepairProvider({
+    indexerDb,
+    providerId: targetProviderId,
+  })
+
+  if (!targetProvider) {
+    throw new NoAlternateProviderError(targetProviderId)
+  }
+
+  const [repair] = await localDb
+    .insert(localSchema.repairs)
+    .values({
+      repairProviderId: sourceProvider.providerId,
+      repairDataSetId: sourceDataSet.dataSetId,
+      targetProviderId: targetProvider.providerId,
+      targetProviderUrl: targetProvider.serviceUrl,
+      targetDataSetId: null,
+      blockNumber,
+      createdAt: now,
+      updatedAt: now,
+    })
+    .returning({ id: localSchema.repairs.id })
+
+  if (!repair) throw new RepairCreationError('Failed to create replication row')
+
+  let totalOperations = 0
+  await forEachDataSetPiecesPage(
+    {
+      indexerDb,
+      dataSetId: sourceDataSet.dataSetId,
+      repairId: repair.id,
+      sourceProviderUrl: sourceProvider.serviceUrl,
+    },
+    async (page) => {
+      totalOperations += page.operations.length
+
+      if (page.operations.length > 0) {
+        await localDb.insert(localSchema.operations).values(page.operations)
+      }
+
+      log.message(`Inserted ${page.operations.length} operations`)
+    }
+  )
+
+  log.success(`Created replication ${repair.id} with ${totalOperations} operations`, { showLog: true })
+  return repair.id
+}

package/src/db/upsert-operations.ts

@@ -18,6 +18,6 @@ export async function upsertOperations({ localDb, operations }: UpsertOperations
     .values(operations.map((operation) => ({ ...operation, updatedAt: now })))
     .onConflictDoUpdate({
       target: localDb._.fullSchema.operations.id,
-      set: buildConflictUpdateColumns(localSchema.operations, ['status', 'error', 'updatedAt']),
+      set: buildConflictUpdateColumns(localSchema.operations, ['status', 'error', 'updatedAt', 'result']),
     })
 }

package/src/local-schema.ts

@@ -51,6 +51,7 @@ export const repairs = table('repairs', {
   id: t.int().primaryKey({ autoIncrement: true }),
   status: t.text().$type<RepairStatus>().notNull().default('pending'),
   repairProviderId: bigintType('repair_provider_id').notNull(),
+  repairDataSetId: bigintType('repair_data_set_id'),
   targetProviderId: bigintType('target_provider_id').notNull(),
   targetProviderUrl: t.text('target_provider_url').notNull(),
   targetDataSetId: bigintType('target_data_set_id'),

package/src/middleware.ts

@@ -12,10 +12,20 @@ export const contextSchema = z.object({
   config: z.custom<typeof config>(),
   client: z.custom<Client<Transport, Chain, Account>>(),
   chain: z.custom<Chain>(),
+  source: z.string(),
 })
 
 export const contextMiddleware = middleware<typeof contextSchema>(async (c, next) => {
-  const { dbPath, chainId, indexerMainnetUrl, indexerCalibrationUrl } = config.store
+  const { dbPath, chainId, indexerMainnetUrl, indexerCalibrationUrl, source } = config.store
+
+  if (!dbPath || !chainId || !indexerMainnetUrl || !indexerCalibrationUrl || !source) {
+    return c.error({
+      code: 'CONFIG_NOT_SET',
+      message: 'Config not set. Please run `repair setup` first.',
+      retryable: false,
+    })
+  }
+
   const localDb = await createLocalDatabase(dbPath)
   const indexerDb = drizzlePostgres(chainId === 314 ? indexerMainnetUrl : indexerCalibrationUrl, {
     schema: indexerSchema,
@@ -27,6 +37,7 @@ export const contextMiddleware = middleware<typeof contextSchema>(async (c, next
   c.set('config', config)
   c.set('client', client)
   c.set('chain', chain)
+  c.set('source', source)
   await next()
 
   localDb.$client.close()