@devxcrew/framework 0.1.10 → 0.1.12

package/README.md

@@ -30,7 +30,7 @@ const statusToken = createModuleToken<{ routes: ApiRoute[] }>("status");
 const status = defineModuleProvider({
   token: statusToken,
   dependencies: [],
-  create: () => ({
+  create: (): { routes: ApiRoute[] } => ({
     routes: [
       {
         method: "GET",
@@ -74,6 +74,8 @@ server.listen(3000);
 
 ## Operations
 
+- `readApplicationConfig` validates `APP_NAME`, `APP_PORT`, `APP_MODE`, and the public `APP_URL`. In development, the URL port must match `APP_PORT`. In production, a reverse proxy can expose a different HTTPS port. Set `APP_HOST` to the listen address when it differs from the public host.
+- Apps load `.env` with their own startup tool and validate their extra settings. Pass those values to `readApplicationConfig`. The Framework does not read files or secrets on import.
 - `createApplicationServer` sets basic security headers. Configure exact CORS origins, trusted proxy addresses, and rate limits for each app.
 - The built-in rate limiter is local to one process. Set `rateLimit.store` to an app-owned atomic shared store when deployment uses multiple instances. Store failures return 503.
 - Set `logger` for request logs. Set `onRequestComplete` to pass request data to a metrics or tracing adapter. Neither receives URL query values.
@@ -90,3 +92,9 @@ npm run release:check
 ```
 
 Keep secrets in ignored environment files. Commit and publish through the repository release workflow only when authorized.
+
+## Database and environment settings
+
+Framework now owns createDatabaseProvider, DatabaseExecution, ResumableTransfer and createSettingsProvider.
+See agent/DATABASE.md for ownership and development use.
+These contracts are local source changes. Publish a new package version before using registry pins in other apps.

package/dist/index.d.ts

@@ -6,3 +6,5 @@ export { createValidationProvider, parseWithSchema, type ValidationProvider, } f
 export { createLogger, type Logger, type LoggerOptions, type LogFields, type LogLevel, type LogRecord, } from "./modules/logger/logger.provider.js";
 export { createHttpSecurityProvider, type HttpSecurityOptions, type HttpSecurityProvider, type RateLimitOptions, type RateLimitStore, } from "./modules/http/http-security.provider.js";
 export { createHealthProvider, createAsyncHealthProvider, type HealthCheck, type HealthProvider, type HealthSnapshot, type AsyncHealthCheck, type AsyncHealthProvider, } from "./modules/health/health.provider.js";
+export * from "./modules/database/index.js";
+export * from "./modules/settings/index.js";

package/dist/index.js

@@ -6,3 +6,5 @@ export { createValidationProvider, parseWithSchema, } from "./modules/validation
 export { createLogger, } from "./modules/logger/logger.provider.js";
 export { createHttpSecurityProvider, } from "./modules/http/http-security.provider.js";
 export { createHealthProvider, createAsyncHealthProvider, } from "./modules/health/health.provider.js";
+export * from "./modules/database/index.js";
+export * from "./modules/settings/index.js";

package/dist/modules/database/common/database.schema.d.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+export declare function readDatabaseConfiguration(environment?: NodeJS.ProcessEnv): {
+    readonly driver: "mariadb";
+    readonly options: {
+        host: string;
+        port: number;
+        user: string;
+        password: string;
+        database: string;
+        connectionLimit: number;
+        connectTimeout: number;
+        charset: string;
+        supportBigNumbers: boolean;
+        bigNumberStrings: boolean;
+        multipleStatements: boolean;
+        timezone: string;
+    };
+} | {
+    readonly path: string;
+    readonly driver: "sqlite";
+    readonly options?: undefined;
+};
+export declare const databaseCommandSchema: z.ZodEnum<{
+    check: "check";
+    connections: "connections";
+    migrate: "migrate";
+    seed: "seed";
+    "seed:tenancy": "seed:tenancy";
+    smoke: "smoke";
+    backup: "backup";
+    "verify-backup": "verify-backup";
+    "verify-restore": "verify-restore";
+    "import-sqlite": "import-sqlite";
+}>;
+export declare const connectionTargetSchema: z.ZodObject<{
+    key: z.ZodString;
+    driver: z.ZodEnum<{
+        mariadb: "mariadb";
+        sqlite: "sqlite";
+    }>;
+    databaseName: z.ZodNullable<z.ZodString>;
+    sqlitePath: z.ZodNullable<z.ZodString>;
+    version: z.ZodNumber;
+}, z.core.$strict>;

package/dist/modules/database/common/database.schema.js

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import { mariaDbConfig } from "../drivers/mariadb/index.js";
+import { sqliteConfig } from "../drivers/sqlite/index.js";
+export function readDatabaseConfiguration(environment = process.env) {
+    const normalized = { ...environment };
+    const driver = normalized.DB_DRIVER;
+    if (driver === "mariadb")
+        return { driver, options: mariaDbConfig(normalized) };
+    if (driver !== "sqlite")
+        throw new Error("DB_DRIVER must be mariadb or sqlite.");
+    return { driver, ...sqliteConfig(normalized) };
+}
+export const databaseCommandSchema = z.enum([
+    "connections",
+    "migrate",
+    "seed",
+    "seed:tenancy",
+    "check",
+    "smoke",
+    "backup",
+    "verify-backup",
+    "verify-restore",
+    "import-sqlite",
+]);
+export const connectionTargetSchema = z
+    .strictObject({
+    key: z.string().min(1).max(255),
+    driver: z.enum(["sqlite", "mariadb"]),
+    databaseName: z
+        .string()
+        .regex(/^[a-zA-Z][a-zA-Z0-9_]{0,63}$/)
+        .nullable(),
+    sqlitePath: z.string().trim().min(1).nullable(),
+    version: z.number().int().min(1),
+})
+    .superRefine((target, context) => {
+    if (target.driver === "mariadb" && !target.databaseName)
+        context.addIssue({
+            code: "custom",
+            path: ["databaseName"],
+            message: "Database name is required.",
+        });
+    if (target.driver === "sqlite" && !target.sqlitePath)
+        context.addIssue({
+            code: "custom",
+            path: ["sqlitePath"],
+            message: "Database path is required.",
+        });
+});

package/dist/modules/database/common/database.types.d.ts

@@ -0,0 +1,26 @@
+import type { Generated, Kysely } from "kysely";
+import type { Migration } from "kysely/migration";
+export interface DatabaseInfrastructureSchema {
+    transfer_checkpoints: {
+        job_id: string;
+        source_sha256: string;
+        cursor: number;
+        version: Generated<number>;
+    };
+    application_metadata: {
+        key: string;
+        value: string;
+    };
+}
+export type DatabaseSchema = DatabaseInfrastructureSchema;
+export interface ConnectionTarget {
+    key: string;
+    driver: "sqlite" | "mariadb";
+    databaseName: string | null;
+    sqlitePath: string | null;
+    version: number;
+}
+export interface DatabaseProviderOptions<Schema> {
+    migrations?: Readonly<Record<string, Migration>>;
+    seed?: (database: Kysely<Schema>, environment: NodeJS.ProcessEnv) => Promise<void>;
+}

package/dist/modules/database/common/database.types.js

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

package/dist/modules/database/common/index.d.ts

@@ -0,0 +1,2 @@
+export { readDatabaseConfiguration, databaseCommandSchema, connectionTargetSchema, } from "./database.schema.js";
+export type { DatabaseSchema, ConnectionTarget } from "./database.types.js";

package/dist/modules/database/common/index.js

@@ -0,0 +1 @@
+export { readDatabaseConfiguration, databaseCommandSchema, connectionTargetSchema, } from "./database.schema.js";

package/dist/modules/database/database.connections.d.ts

@@ -0,0 +1,45 @@
+import { Kysely } from "kysely";
+import { type ConnectionTarget, type DatabaseSchema } from "./common/index.js";
+export declare class DatabaseCapacityError extends Error {
+    constructor();
+}
+export declare class DatabaseConnections {
+    private readonly environment;
+    private readonly configuration;
+    private readonly limit;
+    private readonly idleMs;
+    private master?;
+    private readonly pools;
+    private verified;
+    private closed;
+    private closing?;
+    private mutation;
+    constructor(environment?: NodeJS.ProcessEnv);
+    get driver(): "mariadb" | "sqlite";
+    getMaster(): Kysely<import("./index.js").DatabaseInfrastructureSchema>;
+    withConnection<T>(input: ConnectionTarget, work: (database: Kysely<DatabaseSchema>) => Promise<T>): Promise<T>;
+    provision(input: ConnectionTarget): Promise<import("kysely/migration").MigrationResult[]>;
+    verify(): Promise<void>;
+    list(): ({
+        state: string;
+        host: string;
+        port: number;
+        database: string;
+        name: string;
+        driver: "mariadb" | "sqlite";
+    } | {
+        state: string;
+        path: string;
+        name: string;
+        driver: "mariadb" | "sqlite";
+    })[];
+    poolStats(): {
+        capacity: number;
+        pools: number;
+        leased: number;
+    };
+    close(): Promise<void>;
+    private exclusive;
+    private acquire;
+    private remove;
+}

package/dist/modules/database/database.connections.js

@@ -0,0 +1,196 @@
+import { ensureMariaDbDatabase } from "./drivers/mariadb/index.js";
+import { createStorageMigrator } from "./database.migration.js";
+import { Kysely, sql } from "kysely";
+import { z } from "zod";
+import { readDatabaseConfiguration, connectionTargetSchema, } from "./common/index.js";
+import { createSqliteDialect } from "./drivers/sqlite/index.js";
+import { createMariaDbDialect, MariaDbCompatibilityPlugin, } from "./drivers/mariadb/index.js";
+export class DatabaseCapacityError extends Error {
+    constructor() {
+        super("Database connection capacity reached; retry later.");
+    }
+}
+export class DatabaseConnections {
+    environment;
+    configuration;
+    limit;
+    idleMs;
+    master;
+    pools = new Set();
+    verified = false;
+    closed = false;
+    closing;
+    // Serialize acquisition/retirement so concurrent requests cannot exceed the pool bound.
+    mutation = Promise.resolve();
+    constructor(environment = process.env) {
+        this.environment = { ...environment };
+        this.configuration = readDatabaseConfiguration(this.environment);
+        this.limit = z.coerce
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .parse(environment.DB_POOL_CACHE_LIMIT ?? 16);
+        this.idleMs = z.coerce
+            .number()
+            .int()
+            .min(0)
+            .max(86_400_000)
+            .parse(environment.DB_POOL_IDLE_MS ?? 300_000);
+    }
+    get driver() {
+        return this.configuration.driver;
+    }
+    getMaster() {
+        if (this.closed)
+            throw new Error("Database connections are closed.");
+        if (!this.master) {
+            const config = this.configuration;
+            this.master = new Kysely({
+                dialect: config.driver === "mariadb"
+                    ? createMariaDbDialect(this.environment)
+                    : createSqliteDialect(config.path),
+                plugins: config.driver === "mariadb" ? [new MariaDbCompatibilityPlugin()] : [],
+            });
+        }
+        return this.master;
+    }
+    async withConnection(input, work) {
+        const target = connectionTargetSchema.parse(input);
+        const entry = await this.exclusive(() => this.acquire(target));
+        try {
+            return await work(entry.database);
+        }
+        finally {
+            await this.exclusive(async () => {
+                entry.leases--;
+                entry.touched = Date.now();
+                if (entry.leases === 0) {
+                    entry.drained?.();
+                    if (entry.retired && !this.closed)
+                        await this.remove(entry);
+                }
+            });
+        }
+    }
+    async provision(input) {
+        const target = connectionTargetSchema.parse(input);
+        if (target.driver === "mariadb")
+            await ensureMariaDbDatabase(this.environment, target.databaseName);
+        return this.withConnection(target, async (database) => {
+            const result = await createStorageMigrator(database).migrateToLatest();
+            if (result.error)
+                throw result.error;
+            return result.results ?? [];
+        });
+    }
+    async verify() {
+        this.verified = false;
+        await sql `SELECT 1`.execute(this.getMaster());
+        this.verified = true;
+    }
+    list() {
+        const config = this.configuration;
+        return [
+            {
+                name: "master",
+                driver: config.driver,
+                ...(config.driver === "mariadb"
+                    ? {
+                        host: config.options.host,
+                        port: config.options.port,
+                        database: config.options.database,
+                    }
+                    : { path: config.path }),
+                state: this.closed
+                    ? "closed"
+                    : this.verified
+                        ? "verified"
+                        : this.master
+                            ? "initialized"
+                            : "configured",
+            },
+        ];
+    }
+    poolStats() {
+        return {
+            capacity: this.limit,
+            pools: this.pools.size,
+            leased: [...this.pools].reduce((sum, pool) => sum + pool.leases, 0),
+        };
+    }
+    async close() {
+        if (!this.closing) {
+            this.closed = true;
+            this.verified = false;
+            this.closing = this.exclusive(async () => {
+                // Capture entries without waiting inside the mutation lock: releases must still run.
+                return [...this.pools];
+            }).then(async (entries) => {
+                await Promise.all(entries.map(async (entry) => {
+                    if (entry.leases)
+                        await new Promise((resolve) => {
+                            entry.drained = resolve;
+                        });
+                    await entry.database.destroy();
+                }));
+                this.pools.clear();
+                await this.master?.destroy();
+            });
+        }
+        await this.closing;
+    }
+    exclusive(work) {
+        const result = this.mutation.then(work);
+        this.mutation = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    async acquire(target) {
+        if (this.closed)
+            throw new Error("Database connections are closed.");
+        const now = Date.now();
+        for (const pool of [...this.pools]) {
+            if (pool.target.key === target.key &&
+                JSON.stringify(pool.target) !== JSON.stringify(target))
+                pool.retired = true;
+            if (pool.leases === 0 &&
+                (pool.retired || now - pool.touched >= this.idleMs))
+                await this.remove(pool);
+        }
+        const existing = [...this.pools].find((pool) => !pool.retired && JSON.stringify(pool.target) === JSON.stringify(target));
+        if (existing) {
+            existing.leases++;
+            return existing;
+        }
+        if (this.pools.size >= this.limit) {
+            const idle = [...this.pools]
+                .filter((pool) => pool.leases === 0)
+                .sort((a, b) => a.touched - b.touched)[0];
+            if (!idle)
+                throw new DatabaseCapacityError();
+            await this.remove(idle);
+        }
+        const database = new Kysely({
+            dialect: target.driver === "mariadb"
+                ? createMariaDbDialect({
+                    ...this.environment,
+                    DB_MASTER_NAME: target.databaseName,
+                })
+                : createSqliteDialect(target.sqlitePath),
+            plugins: target.driver === "mariadb" ? [new MariaDbCompatibilityPlugin()] : [],
+        });
+        const entry = {
+            target,
+            database,
+            leases: 1,
+            touched: now,
+            retired: false,
+        };
+        this.pools.add(entry);
+        return entry;
+    }
+    async remove(pool) {
+        await pool.database.destroy();
+        this.pools.delete(pool);
+    }
+}

package/dist/modules/database/database.controller.d.ts

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

package/dist/modules/database/database.controller.js

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

package/dist/modules/database/database.execution.d.ts

@@ -0,0 +1,30 @@
+import type { Kysely, Transaction } from "kysely";
+import { z } from "zod";
+import type { DatabaseSchema } from "./common/index.js";
+export declare class DatabaseValidationError extends Error {
+    readonly fields: Record<string, string[]>;
+    constructor(error: z.ZodError);
+}
+/** Transport and domain schemas remain owned by the calling module. */
+export declare class DatabaseExecution<Schema = DatabaseSchema> {
+    private readonly database;
+    constructor(database: Kysely<Schema>);
+    persist<Input, Output>(schema: z.ZodType<Input>, input: unknown, write: (transaction: Transaction<Schema>, value: Input) => Promise<Output>): Promise<Output>;
+    fetch<Row>(input: unknown, read: (database: Kysely<Schema>, page: {
+        limit: number;
+        offset: number;
+    }) => Promise<Row[]>, outputSchema: z.ZodType<Row>): Promise<{
+        data: Row[];
+        meta: {
+            page: number;
+            pageSize: number;
+        };
+    }>;
+    /** One transaction: a late invalid row or failed write rolls back every batch. */
+    transfer<Row>(schema: z.ZodType<Row>, source: AsyncIterable<unknown> | Iterable<unknown>, write: (transaction: Transaction<Schema>, rows: readonly Row[], signal: AbortSignal) => Promise<void>, batchSize?: number, options?: {
+        signal?: AbortSignal;
+        timeoutMs?: number;
+        maxRows?: number;
+    }): Promise<number>;
+}
+export declare function iterateTransfer(source: AsyncIterable<unknown> | Iterable<unknown>, signal: AbortSignal): AsyncGenerator<unknown, void, unknown>;

package/dist/modules/database/database.execution.js

@@ -0,0 +1,109 @@
+import { z } from "zod";
+const pageSchema = z.strictObject({
+    page: z.number().int().min(1).max(1_000_000),
+    pageSize: z.number().int().min(1).max(500),
+});
+const batchSchema = z.number().int().min(1).max(500);
+export class DatabaseValidationError extends Error {
+    fields;
+    constructor(error) {
+        super("Database input validation failed.");
+        this.name = "DatabaseValidationError";
+        this.fields = Object.create(null);
+        for (const issue of error.issues) {
+            const key = issue.path.join(".") || "input";
+            (this.fields[key] ??= []).push("Invalid value.");
+        }
+    }
+}
+/** Transport and domain schemas remain owned by the calling module. */
+export class DatabaseExecution {
+    database;
+    constructor(database) {
+        this.database = database;
+    }
+    async persist(schema, input, write) {
+        const value = validate(schema, input);
+        return this.database
+            .transaction()
+            .execute((transaction) => write(transaction, value));
+    }
+    async fetch(input, read, outputSchema) {
+        const { page, pageSize } = validate(pageSchema, input);
+        const rows = await read(this.database, {
+            limit: pageSize,
+            offset: (page - 1) * pageSize,
+        });
+        if (!Array.isArray(rows) || rows.length > pageSize)
+            throw new Error("Repository exceeded the requested page size.");
+        return {
+            data: rows.map((row) => validate(outputSchema, row)),
+            meta: { page, pageSize },
+        };
+    }
+    /** One transaction: a late invalid row or failed write rolls back every batch. */
+    async transfer(schema, source, write, batchSize = 100, options = {}) {
+        validate(batchSchema, batchSize);
+        const limits = validate(z.strictObject({
+            timeoutMs: z.number().int().min(1).max(3_600_000).default(30_000),
+            maxRows: z.number().int().min(1).max(100_000_000).default(1_000_000),
+        }), { timeoutMs: options.timeoutMs, maxRows: options.maxRows });
+        const timeout = AbortSignal.timeout(limits.timeoutMs);
+        const signal = options.signal
+            ? AbortSignal.any([options.signal, timeout])
+            : timeout;
+        signal.throwIfAborted();
+        return this.database.transaction().execute(async (transaction) => {
+            let count = 0;
+            let batch = [];
+            for await (const input of iterateTransfer(source, signal)) {
+                if (count + batch.length >= limits.maxRows)
+                    throw new Error("Transfer row limit exceeded.");
+                batch.push(validate(schema, input));
+                if (batch.length === batchSize) {
+                    await write(transaction, batch, signal);
+                    signal.throwIfAborted();
+                    count += batch.length;
+                    batch = [];
+                }
+            }
+            if (batch.length) {
+                await write(transaction, batch, signal);
+                signal.throwIfAborted();
+                count += batch.length;
+            }
+            return count;
+        });
+    }
+}
+function validate(schema, input) {
+    const result = schema.safeParse(input);
+    if (!result.success)
+        throw new DatabaseValidationError(result.error);
+    return result.data;
+}
+export async function* iterateTransfer(source, signal) {
+    const iterator = Symbol.asyncIterator in source
+        ? source[Symbol.asyncIterator]()
+        : source[Symbol.iterator]();
+    try {
+        while (true) {
+            signal.throwIfAborted();
+            const next = await new Promise((resolve, reject) => {
+                const abort = () => reject(signal.reason);
+                signal.addEventListener("abort", abort, { once: true });
+                Promise.resolve()
+                    .then(() => iterator.next())
+                    .then(resolve, reject)
+                    .finally(() => signal.removeEventListener("abort", abort));
+            });
+            if (next.done)
+                return;
+            yield next.value;
+        }
+    }
+    finally {
+        // A stalled producer must not hold the transaction while its cleanup waits.
+        Promise.resolve(iterator.return?.()).catch(() => undefined);
+    }
+}

package/dist/modules/database/database.migration.d.ts

@@ -0,0 +1,11 @@
+import { type Kysely } from "kysely";
+import { type Migration, Migrator } from "kysely/migration";
+export declare const transferCheckpointsMigration: Migration;
+export declare const databaseMetadataMigration: Migration;
+export declare function createDatabaseMigrator<Schema>(database: Kysely<Schema>, migrations?: Readonly<Record<string, Migration>>): Migrator;
+export declare function prepareMigrationStorage<Schema>(database: Kysely<Schema>, driver: string): Promise<void>;
+export declare const storageMigrations: {
+    "001_database_metadata": Migration;
+    "002_transfer_checkpoints": Migration;
+};
+export declare function createStorageMigrator<Schema>(database: Kysely<Schema>): Migrator;

package/dist/modules/database/database.migration.js

@@ -0,0 +1,80 @@
+import { sql } from "kysely";
+import { Migrator } from "kysely/migration";
+export const transferCheckpointsMigration = {
+    async up(database) {
+        await database.schema
+            .createTable("transfer_checkpoints")
+            .addColumn("job_id", "text", (column) => column.primaryKey())
+            .addColumn("source_sha256", "text", (column) => column.notNull())
+            .addColumn("cursor", "integer", (column) => column.notNull().defaultTo(0))
+            .addColumn("version", "integer", (column) => column.notNull().defaultTo(1))
+            .execute();
+    },
+    async down(database) {
+        await database.schema.dropTable("transfer_checkpoints").execute();
+    },
+};
+export const databaseMetadataMigration = {
+    async up(database) {
+        await database.schema
+            .createTable("application_metadata")
+            .addColumn("key", "text", (column) => column.primaryKey())
+            .addColumn("value", "text", (column) => column.notNull())
+            .execute();
+    },
+    async down(database) {
+        await database.schema.dropTable("application_metadata").execute();
+    },
+};
+export function createDatabaseMigrator(database, migrations = storageMigrations) {
+    return new Migrator({
+        db: database,
+        migrationTableName: "migrations",
+        migrationLockTableName: "migration_locks",
+        provider: {
+            async getMigrations() {
+                return { ...migrations };
+            },
+        },
+    });
+}
+export async function prepareMigrationStorage(database, driver) {
+    const tables = new Set((await database.introspection.getTables({ withInternalKyselyTables: true })).map((table) => table.name));
+    for (const [previous, current] of [
+        ["kysely_migration", "migrations"],
+        ["kysely_migration_lock", "migration_locks"],
+    ]) {
+        if (!tables.has(previous))
+            continue;
+        if (tables.has(current)) {
+            const rows = await sql `SELECT * FROM ${sql.table(current)}`.execute(database);
+            if (current === "migrations"
+                ? rows.rows.length > 0
+                : rows.rows.some((row) => Number(row.is_locked) !== 0)) {
+                throw new Error(`Both ${previous} and ${current} exist; migration history needs reconciliation.`);
+            }
+            await database.schema.dropTable(current).execute();
+        }
+        await database.schema.alterTable(previous).renameTo(current).execute();
+        tables.add(current);
+    }
+    if (driver !== "mariadb" || !tables.has("migrations"))
+        return;
+    const column = await sql `SELECT DATA_TYPE FROM information_schema.COLUMNS
+    WHERE TABLE_SCHEMA=DATABASE() AND TABLE_NAME='migrations' AND COLUMN_NAME='timestamp'`.execute(database);
+    if (column.rows[0]?.DATA_TYPE === "datetime")
+        return;
+    const invalid = await sql `SELECT COUNT(*) total FROM migrations
+    WHERE timestamp NOT REGEXP '^[0-9]{4}-[0-9]{2}-[0-9]{2}[T ][0-9]{2}:[0-9]{2}:[0-9]{2}(\\.[0-9]{1,6})?Z?$'`.execute(database);
+    if (Number(invalid.rows[0]?.total))
+        throw new Error("Migration timestamps contain unsupported values.");
+    await sql `UPDATE migrations SET timestamp=REPLACE(REPLACE(timestamp,'T',' '),'Z','')`.execute(database);
+    await sql `ALTER TABLE migrations MODIFY COLUMN timestamp DATETIME(3) NOT NULL`.execute(database);
+}
+export const storageMigrations = {
+    "001_database_metadata": databaseMetadataMigration,
+    "002_transfer_checkpoints": transferCheckpointsMigration,
+};
+export function createStorageMigrator(database) {
+    return createDatabaseMigrator(database, storageMigrations);
+}