@zintrust/core 0.1.19 → 0.1.21

package/src/migrations/MigratorFactory.js

@@ -0,0 +1,339 @@
+import { Env } from '../config/env.js';
+import { Logger } from '../config/logger.js';
+import { ErrorFactory } from '../exceptions/ZintrustError.js';
+import * as path from '../node-singletons/path.js';
+import { MigrationDiscovery } from '../migrations/MigrationDiscovery.js';
+import { MigrationLoader } from '../migrations/MigrationLoader.js';
+import { MigrationLock } from '../migrations/MigrationLock.js';
+import { SqliteMaintenance } from '../orm/maintenance/SqliteMaintenance.js';
+import { MigrationStore } from '../orm/migrations/MigrationStore.js';
+function nowIso() {
+    // MySQL/MariaDB DATETIME does not accept ISO8601 with timezone (e.g. trailing 'Z').
+    // Use a portable UTC datetime string.
+    return new Date().toISOString().slice(0, 19).replace('T', ' ');
+}
+function createCtx(options) {
+    const projectRoot = options.projectRoot;
+    const globalDir = MigrationDiscovery.resolveDir(projectRoot, options.globalDir);
+    const extension = options.extension;
+    const service = typeof options.service === 'string' && options.service.length > 0 ? options.service : null;
+    const separateTracking = options.separateTracking === true;
+    const includeGlobal = options.includeGlobal !== false;
+    const lockFile = options.lockFile ?? path.join(projectRoot, '.zintrust', 'migrate.lock');
+    const serviceDir = service === null
+        ? null
+        : MigrationDiscovery.resolveDir(projectRoot, path.join('services', service, Env.get('MIGRATIONS_SERVICE_DIR', 'database/migrations')));
+    return {
+        options,
+        projectRoot,
+        globalDir,
+        extension,
+        lockFile,
+        separateTracking,
+        includeGlobal,
+        service,
+        serviceDir,
+    };
+}
+function keyForTarget(t) {
+    return `${t.scope}:${t.service}`;
+}
+function getTargets(ctx) {
+    if (!ctx.separateTracking)
+        return [{ scope: 'global', service: '' }];
+    if (ctx.service === null) {
+        return [{ scope: 'global', service: '' }];
+    }
+    const targets = [];
+    // Prefer rolling back service migrations before global ones.
+    targets.push({ scope: 'service', service: ctx.service });
+    if (ctx.includeGlobal)
+        targets.push({ scope: 'global', service: '' });
+    return targets;
+}
+function getTargetForMigration(ctx, migration) {
+    if (!ctx.separateTracking)
+        return { scope: 'global', service: '' };
+    if (ctx.service === null)
+        return { scope: 'global', service: '' };
+    const serviceDir = ctx.serviceDir;
+    if (serviceDir !== null) {
+        const prefix = serviceDir.endsWith(path.sep) ? serviceDir : `${serviceDir}${path.sep}`;
+        if (migration.filePath.startsWith(prefix)) {
+            return { scope: 'service', service: ctx.service };
+        }
+    }
+    return { scope: 'global', service: '' };
+}
+function getMigrationDirs(ctx) {
+    const dirs = [];
+    if (ctx.includeGlobal) {
+        dirs.push(ctx.globalDir);
+    }
+    if (ctx.serviceDir !== null) {
+        dirs.push(ctx.serviceDir);
+    }
+    return dirs;
+}
+async function discover(ctx) {
+    const files = getMigrationDirs(ctx).flatMap((dir) => MigrationDiscovery.listMigrationFiles(dir, ctx.extension));
+    const loaded = [];
+    // Build a serial chain to keep ordering without `await` inside a loop.
+    let chain = Promise.resolve();
+    for (const file of files) {
+        chain = chain.then(async () => {
+            loaded.push(await MigrationLoader.load(file));
+        });
+    }
+    await chain;
+    return loaded.sort((a, b) => a.name.localeCompare(b.name));
+}
+async function runSerial(items, fn) {
+    let chain = Promise.resolve();
+    for (const item of items) {
+        chain = chain.then(async () => fn(item));
+    }
+    await chain;
+}
+async function withLock(ctx, fn) {
+    const release = MigrationLock.acquire(ctx.lockFile);
+    try {
+        return await fn();
+    }
+    finally {
+        release();
+    }
+}
+async function applyOneMigration(params) {
+    const { db, migration, scope, service, batch } = params;
+    await MigrationStore.insertRunning(db, {
+        name: migration.name,
+        scope,
+        service,
+        batch,
+    });
+    try {
+        await db.transaction(async () => {
+            await migration.up(db);
+            await MigrationStore.markStatus(db, {
+                name: migration.name,
+                scope,
+                service,
+                status: 'completed',
+                appliedAt: nowIso(),
+            });
+        });
+    }
+    catch (error) {
+        await MigrationStore.markStatus(db, {
+            name: migration.name,
+            scope,
+            service,
+            status: 'failed',
+        });
+        Logger.error('Migration failed', { migration: migration.name, error });
+        throw error;
+    }
+}
+async function rollbackOneMigration(params) {
+    const { db, name, migrationMap, scope, service, errorLabel } = params;
+    const m = migrationMap.get(name);
+    if (m === undefined) {
+        const label = errorLabel === 'rollback' ? 'rollback' : 'reset';
+        throw ErrorFactory.createCliError(`Cannot ${label} '${name}' because its migration file is missing.`);
+    }
+    await db.transaction(async () => {
+        await m.down(db);
+        await MigrationStore.deleteRecord(db, { name, scope, service });
+    });
+}
+async function rollbackTargetBatch(params) {
+    const { db, target, migrationMap, count } = params;
+    const last = await MigrationStore.getLastCompletedBatch(db, target.scope, target.service);
+    if (last <= 0)
+        return 0;
+    const targetMinBatch = Math.max(1, last - count + 1);
+    const rows = await MigrationStore.listCompletedInBatchesGte(db, {
+        scope: target.scope,
+        service: target.service,
+        minBatch: targetMinBatch,
+    });
+    const appliedNames = rows.map((r) => r.name);
+    if (appliedNames.length === 0)
+        return 0;
+    let rolledBack = 0;
+    await runSerial(appliedNames, async (name) => {
+        await rollbackOneMigration({
+            db,
+            name,
+            migrationMap,
+            scope: target.scope,
+            service: target.service,
+            errorLabel: 'rollback',
+        });
+        rolledBack++;
+    });
+    return rolledBack;
+}
+async function resetTarget(params) {
+    const { db, target, migrationMap } = params;
+    const names = await MigrationStore.listAllCompletedNames(db, {
+        scope: target.scope,
+        service: target.service,
+    });
+    if (names.length === 0)
+        return 0;
+    let rolledBack = 0;
+    await runSerial(names, async (name) => {
+        await rollbackOneMigration({
+            db,
+            name,
+            migrationMap,
+            scope: target.scope,
+            service: target.service,
+            errorLabel: 'reset',
+        });
+        rolledBack++;
+    });
+    return rolledBack;
+}
+async function applyPendingMigrations(ctx, db, migrations) {
+    const targets = getTargets(ctx);
+    const appliedByTarget = new Map();
+    const batchByTarget = new Map();
+    await Promise.all(targets.map(async (t) => {
+        const key = keyForTarget(t);
+        appliedByTarget.set(key, await MigrationStore.getAppliedMap(db, t.scope, t.service));
+        batchByTarget.set(key, (await MigrationStore.getLastCompletedBatch(db, t.scope, t.service)) + 1);
+    }));
+    const pending = migrations.filter((m) => {
+        const target = getTargetForMigration(ctx, m);
+        const appliedMap = appliedByTarget.get(keyForTarget(target));
+        const row = appliedMap?.get(m.name);
+        if (row?.status === 'completed')
+            return false;
+        // Check for collision with existing migrations (same identifying suffix)
+        // This allows multiple projects to share a DB without re-running shared migrations
+        // Use \d+ to support variable timestamp length (default 14, but robust to 15+)
+        const match = new RegExp(/^(\d{14,})(_.+)$/).exec(m.name);
+        if (match && appliedMap) {
+            const suffix = match[2];
+            for (const appliedName of appliedMap.keys()) {
+                if (appliedName !== m.name && appliedName.endsWith(suffix)) {
+                    Logger.info(`Skipping migration '${m.name}' — migration '${appliedName}' with the same suffix ('${suffix}') has already been applied`);
+                    return false;
+                }
+            }
+        }
+        return true;
+    });
+    if (pending.length === 0)
+        return { applied: 0, pending: 0, appliedNames: [] };
+    let appliedCount = 0;
+    const appliedNames = [];
+    await runSerial(pending, async (m) => {
+        const target = getTargetForMigration(ctx, m);
+        const batch = batchByTarget.get(keyForTarget(target)) ?? 1;
+        await applyOneMigration({
+            db,
+            migration: m,
+            scope: target.scope,
+            service: target.service,
+            batch,
+        });
+        appliedCount++;
+        appliedNames.push(m.name);
+    });
+    return { applied: appliedCount, pending: pending.length - appliedCount, appliedNames };
+}
+function buildStatus(ctx) {
+    return async () => {
+        const db = ctx.options.db;
+        await MigrationStore.ensureTable(db);
+        const migrations = await discover(ctx);
+        const targets = getTargets(ctx);
+        const appliedByTarget = new Map();
+        await Promise.all(targets.map(async (t) => {
+            appliedByTarget.set(keyForTarget(t), await MigrationStore.getAppliedMap(db, t.scope, t.service));
+        }));
+        return migrations.map((m) => {
+            const target = getTargetForMigration(ctx, m);
+            const row = appliedByTarget.get(keyForTarget(target))?.get(m.name);
+            return {
+                name: m.name,
+                applied: row?.status === 'completed',
+                batch: typeof row?.batch === 'number' ? row.batch : null,
+                status: typeof row?.status === 'string' ? row.status : null,
+                appliedAt: typeof row?.appliedAt === 'string' ? row.appliedAt : null,
+            };
+        });
+    };
+}
+function buildMigrate(ctx) {
+    return async () => {
+        const db = ctx.options.db;
+        return withLock(ctx, async () => {
+            await MigrationStore.ensureTable(db);
+            const migrations = await discover(ctx);
+            return applyPendingMigrations(ctx, db, migrations);
+        });
+    };
+}
+function buildRollback(ctx) {
+    return async (steps) => {
+        const db = ctx.options.db;
+        return withLock(ctx, async () => {
+            await MigrationStore.ensureTable(db);
+            const targets = getTargets(ctx);
+            const count = Math.max(1, steps);
+            const discovered = await discover(ctx);
+            const migrationMap = new Map(discovered.map((m) => [m.name, m]));
+            let rolledBack = 0;
+            await runSerial(targets, async (target) => {
+                rolledBack += await rollbackTargetBatch({ db, target, migrationMap, count });
+            });
+            return { rolledBack };
+        });
+    };
+}
+function buildReset(ctx) {
+    return async () => {
+        const db = ctx.options.db;
+        return withLock(ctx, async () => {
+            await MigrationStore.ensureTable(db);
+            const targets = getTargets(ctx);
+            const discovered = await discover(ctx);
+            const migrationMap = new Map(discovered.map((m) => [m.name, m]));
+            let rolledBack = 0;
+            await runSerial(targets, async (target) => {
+                rolledBack += await resetTarget({ db, target, migrationMap });
+            });
+            return { rolledBack };
+        });
+    };
+}
+function buildFresh(ctx) {
+    return async () => {
+        const db = ctx.options.db;
+        return withLock(ctx, async () => {
+            if (db.getType() === 'sqlite') {
+                await SqliteMaintenance.dropAllTables(db);
+            }
+            await MigrationStore.ensureTable(db);
+            const migrations = await discover(ctx);
+            return applyPendingMigrations(ctx, db, migrations);
+        });
+    };
+}
+export const MigratorFactory = Object.freeze({
+    create(options) {
+        const ctx = createCtx(options);
+        return {
+            status: buildStatus(ctx),
+            migrate: buildMigrate(ctx),
+            rollbackLastBatch: buildRollback(ctx),
+            resetAll: buildReset(ctx),
+            fresh: buildFresh(ctx),
+        };
+    },
+});

package/src/migrations/schema/Blueprint.d.ts

@@ -0,0 +1,5 @@
+import type { Blueprint } from '../../migrations/schema/types';
+export declare const MigrationBlueprint: Readonly<{
+    create(tableName: string): Blueprint;
+}>;
+//# sourceMappingURL=Blueprint.d.ts.map

package/src/migrations/schema/Blueprint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Blueprint.d.ts","sourceRoot":"","sources":["../../../../src/migrations/schema/Blueprint.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,SAAS,EASV,MAAM,2BAA2B,CAAC;AA0NnC,eAAO,MAAM,kBAAkB;sBACX,MAAM,GAAG,SAAS;EAMpC,CAAC"}

package/src/migrations/schema/Blueprint.js

@@ -0,0 +1,189 @@
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+const IDENT_RE = /^[A-Za-z_]\w*$/;
+function assertIdentifier(label, value) {
+    if (!IDENT_RE.test(value)) {
+        throw ErrorFactory.createValidationError(`Invalid ${label} identifier: ${value}`);
+    }
+}
+function createColumnBuilder(def) {
+    const builder = {
+        nullable() {
+            def.nullable = true;
+            return builder;
+        },
+        notNullable() {
+            def.nullable = false;
+            return builder;
+        },
+        default(value) {
+            def.defaultValue = value;
+            return builder;
+        },
+        unique() {
+            def.unique = true;
+            return builder;
+        },
+        primary() {
+            def.primary = true;
+            def.nullable = false;
+            return builder;
+        },
+        autoIncrement() {
+            def.autoIncrement = true;
+            def.primary = true;
+            def.nullable = false;
+            return builder;
+        },
+        unsigned() {
+            def.unsigned = true;
+            return builder;
+        },
+        getDefinition() {
+            return { ...def };
+        },
+    };
+    return builder;
+}
+function createForeignKeyBuilder(columns, name) {
+    for (const c of columns)
+        assertIdentifier('column', c);
+    const fk = {
+        name: name ?? `fk_${columns.join('_')}`,
+        columns,
+    };
+    const builder = {
+        references(cols) {
+            const arr = Array.isArray(cols) ? cols : [cols];
+            for (const c of arr)
+                assertIdentifier('referenced column', c);
+            fk.referencedColumns = arr;
+            return builder;
+        },
+        on(table) {
+            assertIdentifier('referenced table', table);
+            fk.referencedTable = table;
+            return builder;
+        },
+        onDelete(action) {
+            fk.onDelete = action;
+            return builder;
+        },
+        onUpdate(action) {
+            fk.onUpdate = action;
+            return builder;
+        },
+        getDefinition() {
+            if (typeof fk.referencedTable !== 'string' || fk.referencedTable.length === 0) {
+                throw ErrorFactory.createValidationError('Foreign key missing referenced table');
+            }
+            if (!Array.isArray(fk.referencedColumns) || fk.referencedColumns.length === 0) {
+                throw ErrorFactory.createValidationError('Foreign key missing referenced columns');
+            }
+            return fk;
+        },
+    };
+    return builder;
+}
+function createState(tableName) {
+    return {
+        tableName,
+        columns: [],
+        indexes: [],
+        foreignKeys: [],
+        dropColumns: [],
+        dropIndexes: [],
+        dropForeignKeys: [],
+        pendingForeignKeys: [],
+    };
+}
+function addColumn(state, name, type, length) {
+    assertIdentifier('column', name);
+    const def = {
+        name,
+        type,
+        length,
+        nullable: false,
+        defaultValue: undefined,
+        primary: false,
+        unique: false,
+        autoIncrement: false,
+        unsigned: false,
+    };
+    const builder = createColumnBuilder(def);
+    state.columns.push(def);
+    return builder;
+}
+function buildDefinition(state) {
+    for (const fk of state.pendingForeignKeys)
+        state.foreignKeys.push(fk.getDefinition());
+    return {
+        name: state.tableName,
+        columns: [...state.columns],
+        indexes: [...state.indexes],
+        foreignKeys: [...state.foreignKeys],
+    };
+}
+function createBlueprintApi(state) {
+    const api = {
+        string: (name, length = 255) => addColumn(state, name, 'STRING', length),
+        integer: (name) => addColumn(state, name, 'INTEGER'),
+        bigInteger: (name) => addColumn(state, name, 'INTEGER').unsigned(),
+        real: (name) => addColumn(state, name, 'REAL'),
+        boolean: (name) => addColumn(state, name, 'BOOLEAN'),
+        text: (name) => addColumn(state, name, 'TEXT'),
+        json: (name) => addColumn(state, name, 'JSON'),
+        timestamp: (name) => addColumn(state, name, 'TIMESTAMP'),
+        blob: (name) => addColumn(state, name, 'BLOB'),
+        id: (name = 'id') => addColumn(state, name, 'INTEGER').primary().autoIncrement(),
+        timestamps: (createdAt = 'created_at', updatedAt = 'updated_at') => {
+            api.timestamp(createdAt).notNullable().default('CURRENT_TIMESTAMP');
+            api.timestamp(updatedAt).notNullable().default('CURRENT_TIMESTAMP');
+        },
+        index: (cols, name) => {
+            const arr = Array.isArray(cols) ? cols : [cols];
+            for (const c of arr)
+                assertIdentifier('column', c);
+            const indexName = name ?? `idx_${state.tableName}_${arr.join('_')}`;
+            assertIdentifier('index', indexName);
+            state.indexes.push({ name: indexName, columns: arr, type: 'INDEX' });
+        },
+        unique: (cols, name) => {
+            const arr = Array.isArray(cols) ? cols : [cols];
+            for (const c of arr)
+                assertIdentifier('column', c);
+            const indexName = name ?? `uniq_${state.tableName}_${arr.join('_')}`;
+            assertIdentifier('index', indexName);
+            state.indexes.push({ name: indexName, columns: arr, type: 'UNIQUE' });
+        },
+        foreign: (cols, name) => {
+            const arr = Array.isArray(cols) ? cols : [cols];
+            const builder = createForeignKeyBuilder(arr, name);
+            state.pendingForeignKeys.push(builder);
+            return builder;
+        },
+        dropColumn: (name) => {
+            assertIdentifier('column', name);
+            state.dropColumns.push(name);
+        },
+        dropIndex: (name) => {
+            assertIdentifier('index', name);
+            state.dropIndexes.push(name);
+        },
+        dropForeign: (name) => {
+            assertIdentifier('foreign key', name);
+            state.dropForeignKeys.push(name);
+        },
+        getDefinition: () => buildDefinition(state),
+        getDropColumns: () => [...state.dropColumns],
+        getDropIndexes: () => [...state.dropIndexes],
+        getDropForeignKeys: () => [...state.dropForeignKeys],
+    };
+    return api;
+}
+export const MigrationBlueprint = Object.freeze({
+    create(tableName) {
+        assertIdentifier('table', tableName);
+        const state = createState(tableName);
+        return createBlueprintApi(state);
+    },
+});

package/src/migrations/schema/Schema.d.ts

@@ -0,0 +1,8 @@
+import type { IDatabase } from '../../orm/Database';
+import type { SchemaBuilder } from '../../migrations/schema/types';
+declare function createSchemaBuilder(db: IDatabase): SchemaBuilder;
+export declare const Schema: Readonly<{
+    create: typeof createSchemaBuilder;
+}>;
+export {};
+//# sourceMappingURL=Schema.d.ts.map

package/src/migrations/schema/Schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Schema.d.ts","sourceRoot":"","sources":["../../../../src/migrations/schema/Schema.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAK/C,OAAO,KAAK,EAAgC,aAAa,EAAE,MAAM,2BAA2B,CAAC;AA6M7F,iBAAS,mBAAmB,CAAC,EAAE,EAAE,SAAS,GAAG,aAAa,CAWzD;AAED,eAAO,MAAM,MAAM;;EAEjB,CAAC"}

package/src/migrations/schema/Schema.js

@@ -0,0 +1,141 @@
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { BaseAdapter } from '../../orm/DatabaseAdapter.js';
+import { MigrationBlueprint } from '../../migrations/schema/Blueprint.js';
+import { MigrationSchemaCompiler } from '../../migrations/schema/SchemaCompiler.js';
+const IDENT_RE = /^[A-Za-z_]\w*$/;
+function assertIdentifier(label, value) {
+    if (!IDENT_RE.test(value)) {
+        throw ErrorFactory.createValidationError(`Invalid ${label} identifier: ${value}`);
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function getStringProp(value, key) {
+    if (!isRecord(value))
+        return null;
+    const v = value[key];
+    return typeof v === 'string' ? v : null;
+}
+function mapNames(rows) {
+    return rows.map((r) => getStringProp(r, 'name') ?? '').filter((name) => name.length > 0);
+}
+function buildParameterized(db, sql, parameters) {
+    const adapter = db.getAdapterInstance(false);
+    return BaseAdapter.buildParameterizedQuery(sql, parameters, (i) => adapter.getPlaceholder(i));
+}
+async function queryExists(db, sql, parameters) {
+    const built = buildParameterized(db, sql, parameters);
+    const rows = await db.query(built.sql, built.parameters, true);
+    return rows.length > 0;
+}
+async function runStatements(db, statements) {
+    await statements
+        .filter((sql) => sql.trim() !== '')
+        .reduce(async (p, sql) => {
+        await p;
+        await db.query(sql, []);
+    }, Promise.resolve());
+}
+async function schemaCreate(db, tableName, callback) {
+    const blueprint = MigrationBlueprint.create(tableName);
+    await callback(blueprint);
+    const statements = MigrationSchemaCompiler.compileCreateTable(db.getType(), blueprint.getDefinition(), {
+        ifNotExists: true,
+    });
+    await runStatements(db, statements);
+}
+async function schemaTable(db, tableName, callback) {
+    const blueprint = MigrationBlueprint.create(tableName);
+    await callback(blueprint);
+    const def = blueprint.getDefinition();
+    const plan = {
+        addColumns: def.columns,
+        dropColumns: blueprint.getDropColumns(),
+        createIndexes: def.indexes,
+        dropIndexes: blueprint.getDropIndexes(),
+        addForeignKeys: def.foreignKeys,
+        dropForeignKeys: blueprint.getDropForeignKeys(),
+    };
+    const statements = MigrationSchemaCompiler.compileAlterTable(db.getType(), tableName, plan);
+    await runStatements(db, statements);
+}
+async function schemaDrop(db, tableName, ifExists) {
+    const sql = MigrationSchemaCompiler.compileDropTable(db.getType(), tableName, { ifExists });
+    await db.query(sql, []);
+}
+async function schemaHasTable(db, tableName) {
+    const t = db.getType();
+    if (t === 'sqlite' || t === 'd1' || t === 'd1-remote') {
+        return queryExists(db, "SELECT 1 FROM sqlite_master WHERE type='table' AND name=? LIMIT 1", [
+            tableName,
+        ]);
+    }
+    if (t === 'postgresql') {
+        return queryExists(db, "SELECT 1 FROM information_schema.tables WHERE table_schema='public' AND table_name=? LIMIT 1", [tableName]);
+    }
+    if (t === 'mysql') {
+        return queryExists(db, 'SELECT 1 FROM information_schema.tables WHERE table_schema = DATABASE() AND table_name=? LIMIT 1', [tableName]);
+    }
+    if (t === 'sqlserver') {
+        return queryExists(db, 'SELECT 1 FROM sys.tables WHERE name=?', [tableName]);
+    }
+    throw ErrorFactory.createCliError(`Unsupported DB driver: ${t}`);
+}
+async function schemaHasColumn(db, tableName, columnName) {
+    const t = db.getType();
+    if (t === 'sqlite' || t === 'd1' || t === 'd1-remote') {
+        assertIdentifier('table', tableName);
+        assertIdentifier('column', columnName);
+        const rows = await db.query(`PRAGMA table_info("${tableName}")`, [], true);
+        return rows.some((r) => getStringProp(r, 'name') === columnName);
+    }
+    if (t === 'postgresql') {
+        return queryExists(db, "SELECT 1 FROM information_schema.columns WHERE table_schema='public' AND table_name=? AND column_name=? LIMIT 1", [tableName, columnName]);
+    }
+    if (t === 'mysql') {
+        return queryExists(db, 'SELECT 1 FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name=? AND column_name=? LIMIT 1', [tableName, columnName]);
+    }
+    if (t === 'sqlserver') {
+        return queryExists(db, 'SELECT 1 FROM sys.columns WHERE object_id = OBJECT_ID(?) AND name=?', [
+            tableName,
+            columnName,
+        ]);
+    }
+    throw ErrorFactory.createCliError(`Unsupported DB driver: ${t}`);
+}
+async function schemaGetAllTables(db) {
+    const t = db.getType();
+    if (t === 'sqlite' || t === 'd1' || t === 'd1-remote') {
+        const rows = await db.query("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'", [], true);
+        return mapNames(rows);
+    }
+    if (t === 'postgresql') {
+        const rows = await db.query("SELECT table_name AS name FROM information_schema.tables WHERE table_schema='public'", [], true);
+        return mapNames(rows);
+    }
+    if (t === 'mysql') {
+        const rows = await db.query('SELECT table_name AS name FROM information_schema.tables WHERE table_schema = DATABASE()', [], true);
+        return mapNames(rows);
+    }
+    if (t === 'sqlserver') {
+        const rows = await db.query('SELECT name FROM sys.tables', [], true);
+        return mapNames(rows);
+    }
+    throw ErrorFactory.createCliError(`Unsupported DB driver: ${t}`);
+}
+function createSchemaBuilder(db) {
+    return {
+        create: async (tableName, callback) => schemaCreate(db, tableName, callback),
+        table: async (tableName, callback) => schemaTable(db, tableName, callback),
+        drop: async (tableName) => schemaDrop(db, tableName, false),
+        dropIfExists: async (tableName) => schemaDrop(db, tableName, true),
+        hasTable: async (tableName) => schemaHasTable(db, tableName),
+        hasColumn: async (tableName, columnName) => schemaHasColumn(db, tableName, columnName),
+        getAllTables: async () => schemaGetAllTables(db),
+        getDb: () => db,
+    };
+}
+export const Schema = Object.freeze({
+    create: createSchemaBuilder,
+});