@clioplaylists/clio 0.1.5 → 0.1.7

package/dist/config.js

@@ -0,0 +1,49 @@
+import assert from 'node:assert';
+export class ServerConfig {
+    cfg;
+    assignedPort;
+    constructor(cfg) {
+        this.cfg = cfg;
+    }
+    static readEnv(overrides) {
+        const version = overrides?.version || process.env.CLIO_VERSION || undefined;
+        const debugMode = overrides?.debugMode || process.env.NODE_ENV !== 'production';
+        const serverDid = overrides?.serverDid || process.env.CLIO_SERVER_DID || 'did:example:test';
+        const didPlcUrl = overrides?.didPlcUrl || process.env.DID_PLC_URL || 'http://localhost:2582';
+        // const handleResolverNameservers = process.env.BSKY_HANDLE_RESOLVER_NAMESERVERS
+        //   ? process.env.BSKY_HANDLE_RESOLVER_NAMESERVERS.split(',')
+        //   : []
+        const envPort = overrides?.port || parseInt(process.env.CLIO_PORT || '', 10);
+        const port = isNaN(envPort) ? 2635 : envPort;
+        return new ServerConfig({
+            version,
+            debugMode,
+            port,
+            serverDid,
+            didPlcUrl,
+        });
+    }
+    assignPort(port) {
+        assert(!this.cfg.port || this.cfg.port === port, 'Conflicting port in config');
+        this.assignedPort = port;
+    }
+    get version() {
+        return this.cfg.version;
+    }
+    get debugMode() {
+        return !!this.cfg.debugMode;
+    }
+    get port() {
+        return this.assignedPort || this.cfg.port;
+    }
+    get localUrl() {
+        assert(this.port, 'No port assigned');
+        return `http://localhost:${this.port}`;
+    }
+    get serverDid() {
+        return this.cfg.serverDid;
+    }
+    get didPlcUrl() {
+        return this.cfg.didPlcUrl;
+    }
+}

package/dist/context.d.ts

@@ -0,0 +1,11 @@
+import { DataPlaneClient } from './client';
+import { ServerConfig } from './config';
+export default class AppContext {
+    private opts;
+    constructor(opts: {
+        cfg: ServerConfig;
+        dataplane: DataPlaneClient;
+    });
+    get cfg(): ServerConfig;
+    get dataplane(): DataPlaneClient;
+}

package/dist/context.js

@@ -0,0 +1,12 @@
+export default class AppContext {
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    get cfg() {
+        return this.opts.cfg;
+    }
+    get dataplane() {
+        return this.opts.dataplane;
+    }
+}

package/dist/dataplane/client.d.ts

@@ -0,0 +1,27 @@
+import { Client, Code, ConnectError } from '@connectrpc/connect';
+import { ClioService } from '../rpc/clio_connect';
+export type DataPlaneClient = Client<typeof ClioService>;
+type HttpVersion = '1.1' | '2';
+export declare const createDataPlaneClient: (baseUrls: string[], opts: {
+    httpVersion?: HttpVersion;
+    rejectUnauthorized?: boolean;
+}) => DataPlaneClient;
+export { Code };
+export declare const isDataplaneError: (err: unknown, code?: Code) => err is ConnectError;
+export declare const unpackIdentityServices: (servicesBytes: Uint8Array) => UnpackedServices;
+export declare const unpackIdentityKeys: (keysBytes: Uint8Array) => UnpackedKeys;
+export declare const getServiceEndpoint: (services: UnpackedServices, opts: {
+    id: string;
+    type: string;
+}) => string | undefined;
+export declare const getKeyAsDidKey: (keys: UnpackedKeys, opts: {
+    id: string;
+}) => string | undefined;
+type UnpackedServices = Record<string, {
+    Type: string;
+    URL: string;
+}>;
+type UnpackedKeys = Record<string, {
+    Type: string;
+    PublicKeyMultibase: string;
+}>;

package/dist/dataplane/client.js

@@ -0,0 +1,120 @@
+import { getDidKeyFromMultibase } from '@atproto/identity';
+import { Code, ConnectError, createClient, makeAnyClient, } from '@connectrpc/connect';
+import { createGrpcTransport } from '@connectrpc/connect-node';
+import assert from 'node:assert';
+import { randomInt } from 'node:crypto';
+import * as ui8 from 'uint8arrays';
+import { ClioService } from '../rpc/clio_connect';
+const MAX_RETRIES = 3;
+export const createDataPlaneClient = (baseUrls, opts) => {
+    const clients = baseUrls.map((baseUrl) => createBaseClient(baseUrl, opts));
+    assert(clients.length > 0, 'no clients available');
+    return makeAnyClient(ClioService, (method) => {
+        return async (...args) => {
+            let tries = 0;
+            let error;
+            let remainingClients = clients;
+            while (tries < MAX_RETRIES) {
+                const client = randomElement(remainingClients);
+                assert(client, 'no clients available');
+                try {
+                    return await client.lib[method.localName](...args);
+                }
+                catch (err) {
+                    if (err instanceof ConnectError &&
+                        (err.code === Code.Unavailable || err.code === Code.Aborted)) {
+                        tries++;
+                        error = err;
+                        remainingClients = getRemainingClients(remainingClients, client);
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+            }
+            assert(error);
+            throw error;
+        };
+    });
+};
+export { Code };
+export const isDataplaneError = (err, code) => {
+    if (err instanceof ConnectError) {
+        return !code || err.code === code;
+    }
+    return false;
+};
+const createBaseClient = (baseUrl, opts) => {
+    const { httpVersion = '2', rejectUnauthorized = true } = opts;
+    const transport = createGrpcTransport({
+        baseUrl,
+        httpVersion,
+        acceptCompression: [],
+        nodeOptions: { rejectUnauthorized },
+    });
+    return {
+        lib: createClient(ClioService, transport),
+        url: new URL(baseUrl),
+    };
+};
+const getRemainingClients = (clients, lastClient) => {
+    if (clients.length < 2)
+        return clients; // no clients to choose from
+    if (lastClient.url.port) {
+        // if the last client had a port, we attempt to exclude its whole host.
+        const maybeRemaining = clients.filter((c) => c.url.hostname !== lastClient.url.hostname);
+        if (maybeRemaining.length) {
+            return maybeRemaining;
+        }
+    }
+    return clients.filter((c) => c !== lastClient);
+};
+const randomElement = (arr) => {
+    if (arr.length === 0)
+        return;
+    return arr[randomInt(arr.length)];
+};
+export const unpackIdentityServices = (servicesBytes) => {
+    const servicesStr = ui8.toString(servicesBytes, 'utf8');
+    if (!servicesStr)
+        return {};
+    return JSON.parse(servicesStr);
+};
+export const unpackIdentityKeys = (keysBytes) => {
+    const keysStr = ui8.toString(keysBytes, 'utf8');
+    if (!keysStr)
+        return {};
+    return JSON.parse(keysStr);
+};
+export const getServiceEndpoint = (services, opts) => {
+    const endpoint = services[opts.id] &&
+        services[opts.id].Type === opts.type &&
+        validateUrl(services[opts.id].URL);
+    return endpoint || undefined;
+};
+export const getKeyAsDidKey = (keys, opts) => {
+    const key = keys[opts.id] &&
+        getDidKeyFromMultibase({
+            type: keys[opts.id].Type,
+            publicKeyMultibase: keys[opts.id].PublicKeyMultibase,
+        });
+    return key || undefined;
+};
+const validateUrl = (urlStr) => {
+    let url;
+    try {
+        url = new URL(urlStr);
+    }
+    catch {
+        return undefined;
+    }
+    if (!['http:', 'https:'].includes(url.protocol)) {
+        return undefined;
+    }
+    else if (!url.hostname) {
+        return undefined;
+    }
+    else {
+        return urlStr;
+    }
+};

package/dist/dataplane/index.d.ts

@@ -0,0 +1,2 @@
+export * from './client';
+export * from './server';

package/dist/dataplane/index.js

@@ -0,0 +1,2 @@
+export * from './client';
+export * from './server';

package/dist/dataplane/server/background.d.ts

@@ -0,0 +1,13 @@
+import PQueue from 'p-queue';
+import { Database } from './db';
+export declare class BackgroundQueue {
+    db: Database;
+    queue: PQueue<import("p-queue/dist/priority-queue").default, import("p-queue").DefaultAddOptions>;
+    destroyed: boolean;
+    constructor(db: Database);
+    add(task: Task): void;
+    processAll(): Promise<void>;
+    destroy(): Promise<void>;
+}
+type Task = (db: Database) => Promise<void>;
+export {};

package/dist/dataplane/server/background.js

@@ -0,0 +1,30 @@
+import PQueue from 'p-queue';
+import { dbLogger } from '../../logger';
+// A simple queue for in-process, out-of-band/backgrounded work
+export class BackgroundQueue {
+    db;
+    queue = new PQueue();
+    destroyed = false;
+    constructor(db) {
+        this.db = db;
+    }
+    add(task) {
+        if (this.destroyed) {
+            return;
+        }
+        this.queue
+            .add(() => task(this.db))
+            .catch((err) => {
+            dbLogger.error(err, 'background queue task failed');
+        });
+    }
+    async processAll() {
+        await this.queue.onIdle();
+    }
+    // On destroy we stop accepting new tasks, but complete all pending/in-progress tasks.
+    // The application calls this only once http connections have drained (tasks no longer being added).
+    async destroy() {
+        this.destroyed = true;
+        await this.queue.onIdle();
+    }
+}

package/dist/dataplane/server/db/database-schema.d.ts

@@ -0,0 +1,13 @@
+import { Kysely } from 'kysely';
+import * as actorTable from './tables/actor';
+import * as actorSyncTable from './tables/actor-sync';
+import * as artistTable from './tables/artist';
+import * as artistListItemTable from './tables/artist-list-item';
+import * as playlistTable from './tables/playlist';
+import * as playlistIdeaTable from './tables/playlist-idea';
+import * as playlistItemTable from './tables/playlist-item';
+import * as profileTable from './tables/profile';
+import * as recordTable from './tables/record';
+import * as songTable from './tables/song';
+export type DatabaseSchemaType = actorTable.PartialDB & actorSyncTable.PartialDB & artistTable.PartialDB & artistListItemTable.PartialDB & playlistTable.PartialDB & playlistIdeaTable.PartialDB & playlistItemTable.PartialDB & profileTable.PartialDB & recordTable.PartialDB & songTable.PartialDB;
+export type DatabaseSchema = Kysely<DatabaseSchemaType>;

package/dist/dataplane/server/db/database-schema.js

@@ -0,0 +1 @@
+export {};

package/dist/dataplane/server/db/db.d.ts

@@ -0,0 +1,32 @@
+import { Migrator } from 'kysely';
+import { Pool as PgPool } from 'pg';
+import TypedEmitter from 'typed-emitter';
+import { DatabaseSchema } from './database-schema';
+import { PgOptions } from './types';
+export declare class Database {
+    opts: PgOptions;
+    pool: PgPool;
+    db: DatabaseSchema;
+    migrator: Migrator;
+    txEvt: TxnEmitter;
+    destroyed: boolean;
+    constructor(opts: PgOptions, instances?: {
+        db: DatabaseSchema;
+        pool: PgPool;
+        migrator: Migrator;
+    });
+    get schema(): string | undefined;
+    transaction<T>(fn: (db: Database) => Promise<T>): Promise<T>;
+    get isTransaction(): boolean;
+    assertTransaction(): void;
+    assertNotTransaction(): void;
+    onCommit(fn: () => void): void;
+    migrateToOrThrow(migration: string): Promise<import("kysely").MigrationResult[]>;
+    migrateToLatestOrThrow(): Promise<import("kysely").MigrationResult[]>;
+    close(): Promise<void>;
+}
+export default Database;
+type TxnEmitter = TypedEmitter<TxnEvents>;
+type TxnEvents = {
+    commit: () => void;
+};

package/dist/dataplane/server/db/db.js

@@ -0,0 +1,152 @@
+import { Kysely, Migrator, PostgresDialect, } from 'kysely';
+import assert from 'node:assert';
+import EventEmitter from 'node:events';
+import { Pool as PgPool, types as pgTypes } from 'pg';
+import { dbLogger } from '../../../logger';
+import * as migrations from './migrations';
+import { CtxMigrationProvider } from './migrations/provider';
+export class Database {
+    opts;
+    pool;
+    db;
+    migrator;
+    txEvt = new EventEmitter();
+    destroyed = false;
+    constructor(opts, instances) {
+        this.opts = opts;
+        // if instances are provided, use those
+        if (instances) {
+            this.db = instances.db;
+            this.pool = instances.pool;
+            this.migrator = instances.migrator;
+            return;
+        }
+        // else create a pool & connect
+        const { schema, url } = opts;
+        const pool = opts.pool ??
+            new PgPool({
+                connectionString: url,
+                max: opts.poolSize,
+                maxUses: opts.poolMaxUses,
+                idleTimeoutMillis: opts.poolIdleTimeoutMs,
+            });
+        // Select count(*) and other pg bigints as js integer
+        pgTypes.setTypeParser(pgTypes.builtins.INT8, (n) => parseInt(n, 10));
+        // Setup schema usage, primarily for test parallelism (each test suite runs in its own pg schema)
+        if (schema && !/^[a-z_]+$/i.test(schema)) {
+            throw new Error(`Postgres schema must only contain [A-Za-z_]: ${schema}`);
+        }
+        pool.on('error', onPoolError);
+        pool.on('connect', (client) => {
+            client.on('error', onClientError);
+            // Used for trigram indexes, e.g. on actor search
+            client.query('SET pg_trgm.word_similarity_threshold TO .4;');
+            if (schema) {
+                // Shared objects such as extensions will go in the public schema
+                client.query(`SET search_path TO "${schema}",public;`);
+            }
+        });
+        this.pool = pool;
+        this.db = new Kysely({
+            dialect: new PostgresDialect({ pool }),
+        });
+        this.migrator = new Migrator({
+            db: this.db,
+            migrationTableSchema: opts.schema,
+            provider: new CtxMigrationProvider(migrations, 'pg'),
+        });
+    }
+    get schema() {
+        return this.opts.schema;
+    }
+    async transaction(fn) {
+        const leakyTxPlugin = new LeakyTxPlugin();
+        const { dbTxn, txRes } = await this.db
+            .withPlugin(leakyTxPlugin)
+            .transaction()
+            .execute(async (txn) => {
+            const dbTxn = new Database(this.opts, {
+                db: txn,
+                pool: this.pool,
+                migrator: this.migrator,
+            });
+            const txRes = await fn(dbTxn)
+                .catch(async (err) => {
+                leakyTxPlugin.endTx();
+                // ensure that all in-flight queries are flushed & the connection is open
+                await dbTxn.db.getExecutor().provideConnection(noopAsync);
+                throw err;
+            })
+                .finally(() => leakyTxPlugin.endTx());
+            return { dbTxn, txRes };
+        });
+        dbTxn?.txEvt.emit('commit');
+        return txRes;
+    }
+    get isTransaction() {
+        return this.db.isTransaction;
+    }
+    assertTransaction() {
+        assert(this.isTransaction, 'Transaction required');
+    }
+    assertNotTransaction() {
+        assert(!this.isTransaction, 'Cannot be in a transaction');
+    }
+    onCommit(fn) {
+        this.assertTransaction();
+        this.txEvt.once('commit', fn);
+    }
+    async migrateToOrThrow(migration) {
+        if (this.schema) {
+            await this.db.schema.createSchema(this.schema).ifNotExists().execute();
+        }
+        const { error, results } = await this.migrator.migrateTo(migration);
+        if (error) {
+            throw error;
+        }
+        if (!results) {
+            throw new Error('An unknown failure occurred while migrating');
+        }
+        return results;
+    }
+    async migrateToLatestOrThrow() {
+        if (this.schema) {
+            await this.db.schema.createSchema(this.schema).ifNotExists().execute();
+        }
+        const { error, results } = await this.migrator.migrateToLatest();
+        if (error) {
+            throw error;
+        }
+        if (!results) {
+            throw new Error('An unknown failure occurred while migrating');
+        }
+        return results;
+    }
+    async close() {
+        if (this.destroyed)
+            return;
+        await this.db.destroy();
+        this.destroyed = true;
+    }
+}
+export default Database;
+const onPoolError = (err) => dbLogger.error({ err }, 'db pool error');
+const onClientError = (err) => dbLogger.error({ err }, 'db client error');
+// utils
+// -------
+class LeakyTxPlugin {
+    txOver = false;
+    endTx() {
+        this.txOver = true;
+    }
+    transformQuery(args) {
+        if (this.txOver) {
+            throw new Error('tx already failed');
+        }
+        return args.node;
+    }
+    async transformResult(args) {
+        return args.result;
+    }
+}
+const noopAsync = async () => { };

package/dist/dataplane/server/db/index.d.ts

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

package/dist/dataplane/server/db/index.js

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

package/dist/dataplane/server/db/migrations/20230309T045948368Z-init.d.ts

@@ -0,0 +1,3 @@
+import { Kysely } from 'kysely';
+export declare function up(db: Kysely<unknown>): Promise<void>;
+export declare function down(db: Kysely<unknown>): Promise<void>;

package/dist/dataplane/server/db/migrations/20230309T045948368Z-init.js

@@ -0,0 +1,113 @@
+import { sql } from 'kysely';
+// @TODO subject indexes, naming?
+// @TODO drop indexes in down()?
+export async function up(db) {
+    try {
+        // Add trigram support, supporting user search.
+        // Explicitly add to public schema, so the extension can be seen in all schemas.
+        await sql `create extension if not exists pg_trgm with schema public`.execute(db);
+    }
+    catch (err) {
+        // The "if not exists" isn't bulletproof against races, and we see test suites racing to
+        // create the extension. So we can just ignore errors indicating the extension already exists.
+        if (!err?.['detail']?.includes?.('(pg_trgm) already exists'))
+            throw err;
+    }
+    // profile
+    await db.schema
+        .createTable('profile')
+        .addColumn('uri', 'varchar', (col) => col.primaryKey())
+        .addColumn('cid', 'varchar', (col) => col.notNull())
+        .addColumn('creator_did', 'varchar', (col) => col.notNull())
+        .addColumn('display_name', 'varchar')
+        .addColumn('description', 'varchar')
+        .addColumn('avatar_cid', 'varchar')
+        .addColumn('banner_cid', 'varchar')
+        .addColumn('indexed_at', 'varchar', (col) => col.notNull())
+        .execute();
+    // follow
+    await db.schema
+        .createTable('follow')
+        .addColumn('uri', 'varchar', (col) => col.primaryKey())
+        .addColumn('cid', 'varchar', (col) => col.notNull())
+        .addColumn('creator', 'varchar', (col) => col.notNull())
+        .addColumn('subjectDid', 'varchar', (col) => col.notNull())
+        .addColumn('createdAt', 'varchar', (col) => col.notNull())
+        .addColumn('indexedAt', 'varchar', (col) => col.notNull())
+        .addColumn('sortAt', 'varchar', (col) => col
+        .generatedAlwaysAs(sql `least("createdAt", "indexedAt")`)
+        .stored()
+        .notNull())
+        .addUniqueConstraint('follow_unique_subject', ['creator', 'subjectDid'])
+        .execute();
+    // for, eg, "followersCount" on profile views
+    await db.schema
+        .createIndex('follow_subjectdid_idx')
+        .on('follow')
+        .column('subjectDid')
+        .execute();
+    // like
+    await db.schema
+        .createTable('like')
+        .addColumn('uri', 'varchar', (col) => col.primaryKey())
+        .addColumn('cid', 'varchar', (col) => col.notNull())
+        .addColumn('creator', 'varchar', (col) => col.notNull())
+        .addColumn('subject', 'varchar', (col) => col.notNull())
+        .addColumn('subjectCid', 'varchar', (col) => col.notNull())
+        .addColumn('createdAt', 'varchar', (col) => col.notNull())
+        .addColumn('indexedAt', 'varchar', (col) => col.notNull())
+        .addColumn('sortAt', 'varchar', (col) => col
+        .generatedAlwaysAs(sql `least("createdAt", "indexedAt")`)
+        .stored()
+        .notNull())
+        // Aids in index uniqueness plus post like counts
+        .addUniqueConstraint('like_unique_subject', ['subject', 'creator'])
+        .execute();
+    // subscription
+    await db.schema
+        .createTable('subscription')
+        .addColumn('service', 'varchar', (col) => col.notNull())
+        .addColumn('method', 'varchar', (col) => col.notNull())
+        .addColumn('state', 'varchar', (col) => col.notNull())
+        .addPrimaryKeyConstraint('subscription_pkey', ['service', 'method'])
+        .execute();
+    // actor
+    await db.schema
+        .createTable('actor')
+        .addColumn('did', 'varchar', (col) => col.primaryKey())
+        .addColumn('handle', 'varchar', (col) => col.unique())
+        .addColumn('indexedAt', 'varchar', (col) => col.notNull())
+        .execute();
+    await db.schema // Supports user search
+        .createIndex(`actor_handle_tgrm_idx`)
+        .on('actor')
+        .using('gist')
+        .expression(sql `"handle" gist_trgm_ops`)
+        .execute();
+    //record
+    await db.schema
+        .createTable('record')
+        .addColumn('uri', 'varchar', (col) => col.primaryKey())
+        .addColumn('cid', 'varchar', (col) => col.notNull())
+        .addColumn('did', 'varchar', (col) => col.notNull())
+        .addColumn('json', 'text', (col) => col.notNull())
+        .addColumn('indexedAt', 'varchar', (col) => col.notNull())
+        .addColumn('takedownId', 'integer') // foreign key created in moderation-init migration
+        .execute();
+}
+export async function down(db) {
+    // record
+    await db.schema.dropTable('record').execute();
+    // actor
+    await db.schema.dropTable('actor').execute();
+    // subscription
+    await db.schema.dropTable('subscription').execute();
+    // like
+    await db.schema.dropTable('like').execute();
+    // follow
+    await db.schema.dropTable('follow').execute();
+    // post
+    await db.schema.dropTable('post').execute();
+    // profile
+    await db.schema.dropTable('profile').execute();
+}

package/dist/dataplane/server/db/migrations/20230420T211446071Z-did-cache.d.ts

@@ -0,0 +1,3 @@
+import { Kysely } from 'kysely';
+export declare function up(db: Kysely<unknown>): Promise<void>;
+export declare function down(db: Kysely<unknown>): Promise<void>;

package/dist/dataplane/server/db/migrations/20230420T211446071Z-did-cache.js

@@ -0,0 +1,11 @@
+export async function up(db) {
+    await db.schema
+        .createTable('did_cache')
+        .addColumn('did', 'varchar', (col) => col.primaryKey())
+        .addColumn('doc', 'jsonb', (col) => col.notNull())
+        .addColumn('updatedAt', 'bigint', (col) => col.notNull())
+        .execute();
+}
+export async function down(db) {
+    await db.schema.dropTable('did_cache').execute();
+}

package/dist/dataplane/server/db/migrations/index.d.ts

@@ -0,0 +1,2 @@
+export * as _20230309T045948368Z from './20230309T045948368Z-init';
+export * as _20230420T211446071Z from './20230420T211446071Z-did-cache';

package/dist/dataplane/server/db/migrations/index.js

@@ -0,0 +1,5 @@
+// NOTE this file can be edited by hand, but it is also appended to by the migration:create command.
+// It's important that every migration is exported from here with the proper name. We'd simplify
+// this with kysely's FileMigrationProvider, but it doesn't play nicely with the build process.
+export * as _20230309T045948368Z from './20230309T045948368Z-init';
+export * as _20230420T211446071Z from './20230420T211446071Z-did-cache';

package/dist/dataplane/server/db/migrations/provider.d.ts

@@ -0,0 +1,11 @@
+import { Kysely, Migration, MigrationProvider } from 'kysely';
+export declare class CtxMigrationProvider<T> implements MigrationProvider {
+    private migrations;
+    private ctx;
+    constructor(migrations: Record<string, CtxMigration<T>>, ctx: T);
+    getMigrations(): Promise<Record<string, Migration>>;
+}
+export interface CtxMigration<T> {
+    up(db: Kysely<unknown>, ctx: T): Promise<void>;
+    down?(db: Kysely<unknown>, ctx: T): Promise<void>;
+}

package/dist/dataplane/server/db/migrations/provider.js

@@ -0,0 +1,19 @@
+// Passes a context argument to migrations. We use this to thread the dialect into migrations
+export class CtxMigrationProvider {
+    migrations;
+    ctx;
+    constructor(migrations, ctx) {
+        this.migrations = migrations;
+        this.ctx = ctx;
+    }
+    async getMigrations() {
+        const ctxMigrations = {};
+        Object.entries(this.migrations).forEach(([name, migration]) => {
+            ctxMigrations[name] = {
+                up: async (db) => await migration.up(db, this.ctx),
+                down: async (db) => await migration.down?.(db, this.ctx),
+            };
+        });
+        return ctxMigrations;
+    }
+}