@zintrust/core 0.4.17 → 0.4.18

package/src/migrations/schema/Blueprint.js

@@ -0,0 +1,191 @@
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { ColumnType as ColumnTypeName, SchOther } from '../enum/index.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(SchOther.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(SchOther.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, ColumnTypeName.STRING, length),
+        integer: (name) => addColumn(state, name, ColumnTypeName.INTEGER),
+        bigInteger: (name) => addColumn(state, name, ColumnTypeName.BIGINT).unsigned(),
+        uuid: (name) => addColumn(state, name, ColumnTypeName.UUID),
+        real: (name) => addColumn(state, name, ColumnTypeName.REAL),
+        boolean: (name) => addColumn(state, name, ColumnTypeName.BOOLEAN),
+        text: (name) => addColumn(state, name, ColumnTypeName.TEXT),
+        json: (name) => addColumn(state, name, ColumnTypeName.JSON),
+        timestamp: (name) => addColumn(state, name, ColumnTypeName.TIMESTAMP),
+        blob: (name) => addColumn(state, name, ColumnTypeName.BLOB),
+        id: (name = SchOther.ID) => addColumn(state, name, ColumnTypeName.INTEGER).primary().autoIncrement(),
+        timestamps: (createdAt = SchOther.CREATED_AT, updatedAt = SchOther.UPDATED_AT) => {
+            api.timestamp(createdAt).notNullable().default(ColumnTypeName.CURRENT_TIMESTAMP);
+            api.timestamp(updatedAt).notNullable().default(ColumnTypeName.CURRENT_TIMESTAMP);
+        },
+        index: (cols, name) => {
+            const arr = Array.isArray(cols) ? cols : [cols];
+            for (const c of arr)
+                assertIdentifier(SchOther.COLUMN, c);
+            const indexName = name ?? `idx_${state.tableName}_${arr.join('_')}`;
+            assertIdentifier(SchOther.INDEX, indexName);
+            state.indexes.push({ name: indexName, columns: arr, type: ColumnTypeName.INDEX });
+        },
+        unique: (cols, name) => {
+            const arr = Array.isArray(cols) ? cols : [cols];
+            for (const c of arr)
+                assertIdentifier(SchOther.COLUMN, c);
+            const indexName = name ?? `uniq_${state.tableName}_${arr.join('_')}`;
+            assertIdentifier(SchOther.INDEX, indexName);
+            state.indexes.push({ name: indexName, columns: arr, type: ColumnTypeName.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(SchOther.COLUMN, name);
+            state.dropColumns.push(name);
+        },
+        dropIndex: (name) => {
+            assertIdentifier(SchOther.INDEX, name);
+            state.dropIndexes.push(name);
+        },
+        dropForeign: (name) => {
+            assertIdentifier(SchOther.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(SchOther.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 '../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;AAM/C,OAAO,KAAK,EAAgC,aAAa,EAAE,MAAM,0BAA0B,CAAC;AA6M5F,iBAAS,mBAAmB,CAAC,EAAE,EAAE,SAAS,GAAG,aAAa,CAWzD;AAED,eAAO,MAAM,MAAM;;EAEjB,CAAC"}

package/src/migrations/schema/Schema.js

@@ -0,0 +1,142 @@
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { BaseAdapter } from '../../orm/DatabaseAdapter.js';
+import { isSqliteFamily } from '../enum/index.js';
+import { MigrationBlueprint } from '../schema/Blueprint.js';
+import { MigrationSchemaCompiler } from '../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 (isSqliteFamily(t)) {
+        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,
+});

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

@@ -0,0 +1,20 @@
+import type { ColumnDefinition, ForeignKeyDefinition, IndexDefinition, TableDefinition } from '../schema/types';
+type AlterTablePlan = {
+    addColumns: ColumnDefinition[];
+    dropColumns: string[];
+    createIndexes: IndexDefinition[];
+    dropIndexes: string[];
+    addForeignKeys: ForeignKeyDefinition[];
+    dropForeignKeys: string[];
+};
+export declare const MigrationSchemaCompiler: Readonly<{
+    compileCreateTable(driver: string, def: TableDefinition, opts?: {
+        ifNotExists?: boolean;
+    }): string[];
+    compileDropTable(driver: string, table: string, opts?: {
+        ifExists?: boolean;
+    }): string;
+    compileAlterTable(driver: string, table: string, plan: AlterTablePlan): string[];
+}>;
+export {};
+//# sourceMappingURL=SchemaCompiler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SchemaCompiler.d.ts","sourceRoot":"","sources":["../../../../src/migrations/schema/SchemaCompiler.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,gBAAgB,EAEhB,oBAAoB,EACpB,eAAe,EACf,eAAe,EAChB,MAAM,0BAA0B,CAAC;AAIlC,KAAK,cAAc,GAAG;IACpB,UAAU,EAAE,gBAAgB,EAAE,CAAC;IAC/B,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,aAAa,EAAE,eAAe,EAAE,CAAC;IACjC,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,cAAc,EAAE,oBAAoB,EAAE,CAAC;IACvC,eAAe,EAAE,MAAM,EAAE,CAAC;CAC3B,CAAC;AAqVF,eAAO,MAAM,uBAAuB;+BAExB,MAAM,OACT,eAAe,SACb;QAAE,WAAW,CAAC,EAAE,OAAO,CAAA;KAAE,GAC/B,MAAM,EAAE;6BAKc,MAAM,SAAS,MAAM,SAAS;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,MAAM;8BAK5D,MAAM,SAAS,MAAM,QAAQ,cAAc,GAAG,MAAM,EAAE;EAIhF,CAAC"}

package/src/migrations/schema/SchemaCompiler.js

@@ -0,0 +1,273 @@
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { AdaptersEnum, ColumnType, isSqliteFamily, SchOther } from '../enum/index.js';
+const IDENT_RE = /^[A-Za-z_]\w*$/;
+function isSupportedDriver(driver) {
+    return (driver === AdaptersEnum.sqlite ||
+        driver === AdaptersEnum.d1 ||
+        driver === AdaptersEnum.d1Remote ||
+        driver === AdaptersEnum.postgresql ||
+        driver === AdaptersEnum.mysql ||
+        driver === AdaptersEnum.sqlserver);
+}
+function assertIdentifier(label, value) {
+    if (!IDENT_RE.test(value)) {
+        throw ErrorFactory.createValidationError(`Invalid ${label} identifier: ${value}`);
+    }
+}
+function requireSupportedDriver(driver) {
+    if (!isSupportedDriver(driver)) {
+        throw ErrorFactory.createValidationError(`Unsupported DB driver: ${driver}`);
+    }
+    return driver;
+}
+function quoteIdent(driver, ident) {
+    assertIdentifier(ColumnType.SQL, ident);
+    if (driver === AdaptersEnum.mysql)
+        return `\`${ident}\``;
+    return `"${ident}"`;
+}
+function normalizeForeignKeyAction(action) {
+    switch (action) {
+        case ColumnType.CASCADE:
+        case ColumnType.SETNULL:
+        case ColumnType.RESTRICT:
+        case ColumnType.NOACTION:
+        case ColumnType.SETDEFAULT:
+            return action;
+        default:
+            throw ErrorFactory.createValidationError(`Unsupported foreign key action: ${String(action)}`);
+    }
+}
+const TYPE_SQL = Object.freeze({
+    STRING: (driver, def) => {
+        const len = typeof def.length === SchOther.NUMBER && Number.isFinite(def.length) ? def.length : 255;
+        return isSqliteFamily(driver) ? ColumnType.TEXT : `${ColumnType.VARCHAR}(${len})`;
+    },
+    INTEGER: (driver) => (driver === AdaptersEnum.mysql ? ColumnType.INT : ColumnType.INTEGER),
+    BIGINT: () => ColumnType.BIGINT,
+    UUID: (driver) => {
+        if (driver === AdaptersEnum.postgresql)
+            return ColumnType.UUID;
+        return isSqliteFamily(driver) ? ColumnType.TEXT : `${ColumnType.VARCHAR}(36)`;
+    },
+    REAL: (driver) => (driver === AdaptersEnum.sqlserver ? ColumnType.FLOAT : ColumnType.REAL),
+    BOOLEAN: (driver) => (driver === AdaptersEnum.mysql ? ColumnType.TINYINT_1 : ColumnType.BOOLEAN),
+    TEXT: () => ColumnType.TEXT,
+    JSON: (driver) => {
+        if (driver === AdaptersEnum.postgresql)
+            return ColumnType.JSONB;
+        if (driver === AdaptersEnum.mysql)
+            return ColumnType.JSON;
+        return ColumnType.TEXT;
+    },
+    TIMESTAMP: (driver) => {
+        if (driver === AdaptersEnum.mysql)
+            return ColumnType.DATETIME;
+        if (driver === AdaptersEnum.postgresql)
+            return ColumnType.TIMESTAMP;
+        return ColumnType.TEXT;
+    },
+    BLOB: (driver) => (driver === AdaptersEnum.postgresql ? ColumnType.BYTEA : ColumnType.BLOB),
+});
+function getColumnTypeSql(driver, def) {
+    return TYPE_SQL[def.type](driver, def);
+}
+function getAutoIncrementColumnSql(driver, colName, type) {
+    const sqliteFamily = isSqliteFamily(driver);
+    if (sqliteFamily) {
+        return `${colName} ${ColumnType.INTEGER} ${ColumnType.PRIMARY_KEY} ${ColumnType.AUTOINCREMENT}`;
+    }
+    if (driver === AdaptersEnum.postgresql) {
+        return `${colName} ${type === ColumnType.BIGINT ? ColumnType.BIGSERIAL : ColumnType.SERIAL} ${ColumnType.PRIMARY_KEY}`;
+    }
+    if (driver === AdaptersEnum.mysql) {
+        const typeSql = type === ColumnType.BIGINT ? ColumnType.BIGINT : ColumnType.INT;
+        return `${colName} ${typeSql} ${ColumnType.AUTO_INCREMENT} ${ColumnType.PRIMARY_KEY}`;
+    }
+    if (driver === AdaptersEnum.sqlserver) {
+        const typeSql = type === ColumnType.BIGINT ? ColumnType.BIGINT : ColumnType.INT;
+        return `${colName} ${typeSql} ${ColumnType.IDENTITY_1_1} ${ColumnType.PRIMARY_KEY}`;
+    }
+    throw ErrorFactory.createValidationError(`Auto-increment not supported for driver: ${driver}`);
+}
+function formatDefaultValueSql(driver, table, def) {
+    if (def.defaultValue === undefined)
+        return null;
+    const dv = def.defaultValue;
+    if (dv === null)
+        return ColumnType.DEFAULT_NULL;
+    if (typeof dv === 'number' && Number.isFinite(dv))
+        return `DEFAULT ${dv}`;
+    if (typeof dv === 'boolean') {
+        if (driver === AdaptersEnum.postgresql)
+            return `DEFAULT ${dv ? 'true' : 'false'}`;
+        return `DEFAULT ${dv ? 1 : 0}`;
+    }
+    if (typeof dv === 'string') {
+        if (dv === ColumnType.CURRENT_TIMESTAMP)
+            return `DEFAULT ${ColumnType.CURRENT_TIMESTAMP}`;
+        const escaped = dv.replaceAll("'", "''");
+        return `DEFAULT '${escaped}'`;
+    }
+    throw ErrorFactory.createValidationError(`Unsupported default type for ${table}.${def.name}`);
+}
+function buildColumnSql(driver, table, def) {
+    assertIdentifier(SchOther.TABLE, table);
+    assertIdentifier(SchOther.COLUMN, def.name);
+    const col = quoteIdent(driver, def.name);
+    if (def.autoIncrement === true) {
+        if (def.type !== ColumnType.INTEGER && def.type !== ColumnType.BIGINT) {
+            throw ErrorFactory.createValidationError(`Auto-increment column must be INTEGER or BIGINT: ${table}.${def.name}`);
+        }
+        return getAutoIncrementColumnSql(driver, col, def.type);
+    }
+    const parts = [`${col} ${getColumnTypeSql(driver, def)}`];
+    if (driver === AdaptersEnum.mysql &&
+        def.unsigned === true &&
+        (def.type === ColumnType.INTEGER ||
+            def.type === ColumnType.BIGINT ||
+            def.type === ColumnType.REAL)) {
+        parts.push(ColumnType.UNSIGNED);
+    }
+    if (def.nullable !== true)
+        parts.push(ColumnType.NOT_NULL);
+    if (def.unique === true)
+        parts.push(ColumnType.UNIQUE);
+    if (def.primary === true)
+        parts.push(ColumnType.PRIMARY_KEY);
+    const defaultSql = formatDefaultValueSql(driver, table, def);
+    if (defaultSql !== null)
+        parts.push(defaultSql);
+    return parts.join(' ');
+}
+function buildPrimaryKeyConstraintSql(driver, columns) {
+    const cols = columns.map((c) => {
+        assertIdentifier(SchOther.COLUMN, c);
+        return quoteIdent(driver, c);
+    });
+    return `${ColumnType.PRIMARY_KEY} (${cols.join(', ')})`;
+}
+function buildForeignKeyConstraintSql(driver, table, fk) {
+    assertIdentifier(SchOther.TABLE, table);
+    assertIdentifier(SchOther.FOREIGN_KEY, fk.name);
+    assertIdentifier(SchOther.REFERENCED_TABLE, fk.referencedTable);
+    for (const c of fk.columns)
+        assertIdentifier(SchOther.COLUMN, c);
+    for (const c of fk.referencedColumns)
+        assertIdentifier(SchOther.REFERENCED_COLUMN, c);
+    const constraint = `${ColumnType.CONSTRAINT} ${quoteIdent(driver, fk.name)}`;
+    const localCols = fk.columns.map((c) => quoteIdent(driver, c)).join(', ');
+    const refCols = fk.referencedColumns.map((c) => quoteIdent(driver, c)).join(', ');
+    const parts = [
+        `${constraint} ${ColumnType.FOREIGN_KEY_S} (${localCols}) ${ColumnType.REFERENCES} ${quoteIdent(driver, fk.referencedTable)} (${refCols})`,
+    ];
+    if (fk.onDelete)
+        parts.push(`${ColumnType.ON_DELETE} ${normalizeForeignKeyAction(fk.onDelete)}`);
+    if (fk.onUpdate)
+        parts.push(`${ColumnType.ON_UPDATE} ${normalizeForeignKeyAction(fk.onUpdate)}`);
+    return parts.join(' ');
+}
+function buildCreateIndexSql(driver, table, idx) {
+    assertIdentifier(SchOther.TABLE, table);
+    assertIdentifier(SchOther.INDEX, idx.name);
+    for (const c of idx.columns)
+        assertIdentifier(SchOther.COLUMN, c);
+    const unique = idx.type === ColumnType.UNIQUE ? `${ColumnType.UNIQUE} ` : '';
+    const cols = idx.columns.map((c) => quoteIdent(driver, c)).join(', ');
+    return `${ColumnType.CREATE_INDEX_S} ${unique}${quoteIdent(driver, idx.name)} ${ColumnType.ON} ${quoteIdent(driver, table)} (${cols})`;
+}
+function buildDropIndexSql(driver, table, indexName) {
+    assertIdentifier(SchOther.TABLE, table);
+    assertIdentifier(SchOther.INDEX, indexName);
+    if (driver === AdaptersEnum.mysql) {
+        return `${ColumnType.DROP_INDEX_S} ${quoteIdent(driver, indexName)} ${ColumnType.ON} ${quoteIdent(driver, table)}`;
+    }
+    return `${ColumnType.DROP_INDEX_S} ${ColumnType.IF_EXISTS} ${quoteIdent(driver, indexName)}`;
+}
+function buildDropTableSql(driver, table, ifExists) {
+    assertIdentifier(SchOther.TABLE, table);
+    const ine = ifExists ? `${ColumnType.IF_EXISTS} ` : '';
+    return `${ColumnType.DROP_TABLE_S} ${ine}${quoteIdent(driver, table)}`;
+}
+function buildCreateTableStatements(driver, def, ifNotExists) {
+    assertIdentifier(SchOther.TABLE, def.name);
+    if (def.columns.length === 0) {
+        throw ErrorFactory.createValidationError(`Schema for table '${def.name}' has no columns`);
+    }
+    const primaryCols = def.columns.filter((c) => c.primary === true).map((c) => c.name);
+    const colLines = def.columns.map((c) => buildColumnSql(driver, def.name, c));
+    const constraints = [];
+    if (primaryCols.length > 1)
+        constraints.push(buildPrimaryKeyConstraintSql(driver, primaryCols));
+    for (const fk of def.foreignKeys) {
+        constraints.push(buildForeignKeyConstraintSql(driver, def.name, fk));
+    }
+    const allLines = [...colLines, ...constraints].map((l) => `  ${l}`);
+    const ine = ifNotExists ? `${ColumnType.IF_NOT_EXISTS} ` : '';
+    const createSql = `${ColumnType.CREATE_TABLE_S} ${ine}${quoteIdent(driver, def.name)} (\n${allLines.join(',\n')}\n)`;
+    const statements = [createSql];
+    for (const idx of def.indexes) {
+        statements.push(buildCreateIndexSql(driver, def.name, idx));
+    }
+    return statements;
+}
+function compileAddColumns(driver, table, cols) {
+    return cols.map((col) => {
+        const colSql = buildColumnSql(driver, table, col);
+        return `${ColumnType.ALTER_TABLE_S} ${quoteIdent(driver, table)} ${ColumnType.ADD_COLUMN_S} ${colSql}`;
+    });
+}
+function compileIndexOps(driver, table, plan) {
+    const create = plan.createIndexes.map((idx) => buildCreateIndexSql(driver, table, idx));
+    const drop = plan.dropIndexes.map((idx) => buildDropIndexSql(driver, table, idx));
+    return [...create, ...drop];
+}
+function compileAdvancedAlterOps(driver, table, plan) {
+    const needs = plan.dropColumns.length > 0 ||
+        plan.addForeignKeys.length > 0 ||
+        plan.dropForeignKeys.length > 0;
+    if (!needs)
+        return [];
+    if (isSqliteFamily(driver)) {
+        throw ErrorFactory.createValidationError('SQLite/D1 does not support dropping columns or altering foreign keys safely (table rebuild required)');
+    }
+    const statements = [];
+    for (const col of plan.dropColumns) {
+        assertIdentifier(SchOther.COLUMN, col);
+        statements.push(`${ColumnType.ALTER_TABLE_S} ${quoteIdent(driver, table)} ${ColumnType.DROP_COLUMN_S} ${quoteIdent(driver, col)}`);
+    }
+    for (const fk of plan.addForeignKeys) {
+        statements.push(`${ColumnType.ALTER_TABLE_S} ${quoteIdent(driver, table)} ${ColumnType.ADD} ${buildForeignKeyConstraintSql(driver, table, fk)}`);
+    }
+    for (const fkName of plan.dropForeignKeys) {
+        assertIdentifier(SchOther.FOREIGN_KEY, fkName);
+        if (driver === AdaptersEnum.mysql) {
+            statements.push(`${ColumnType.ALTER_TABLE_S} ${quoteIdent(driver, table)} ${ColumnType.DROP} ${ColumnType.FOREIGN_KEY_S} ${quoteIdent(driver, fkName)}`);
+            continue;
+        }
+        statements.push(`${ColumnType.ALTER_TABLE_S} ${quoteIdent(driver, table)} ${ColumnType.DROP} ${ColumnType.CONSTRAINT} ${quoteIdent(driver, fkName)}`);
+    }
+    return statements;
+}
+function buildAlterTableStatements(driver, table, plan) {
+    assertIdentifier(SchOther.TABLE, table);
+    return [
+        ...compileAddColumns(driver, table, plan.addColumns),
+        ...compileIndexOps(driver, table, plan),
+        ...compileAdvancedAlterOps(driver, table, plan),
+    ];
+}
+export const MigrationSchemaCompiler = Object.freeze({
+    compileCreateTable(driver, def, opts) {
+        const d = requireSupportedDriver(driver);
+        return buildCreateTableStatements(d, def, opts?.ifNotExists !== false);
+    },
+    compileDropTable(driver, table, opts) {
+        const d = requireSupportedDriver(driver);
+        return buildDropTableSql(d, table, opts?.ifExists !== false);
+    },
+    compileAlterTable(driver, table, plan) {
+        const d = requireSupportedDriver(driver);
+        return buildAlterTableStatements(d, table, plan);
+    },
+});

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

@@ -0,0 +1,5 @@
+export { MigrationBlueprint } from '../schema/Blueprint';
+export { Schema } from '../schema/Schema';
+export { MigrationSchemaCompiler } from '../schema/SchemaCompiler';
+export type { Blueprint, BlueprintCallback, ColumnBuilder, ColumnDefinition, ColumnType, ForeignKeyAction, ForeignKeyBuilder, ForeignKeyDefinition, IndexDefinition, IndexType, SchemaBuilder, TableDefinition, } from '../schema/types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/migrations/schema/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AACnD,OAAO,EAAE,uBAAuB,EAAE,MAAM,mCAAmC,CAAC;AAC5E,YAAY,EACV,SAAS,EACT,iBAAiB,EACjB,aAAa,EACb,gBAAgB,EAChB,UAAU,EACV,gBAAgB,EAChB,iBAAiB,EACjB,oBAAoB,EACpB,eAAe,EACf,SAAS,EACT,aAAa,EACb,eAAe,GAChB,MAAM,0BAA0B,CAAC"}

package/src/migrations/schema/index.js

@@ -0,0 +1,3 @@
+export { MigrationBlueprint } from '../schema/Blueprint.js';
+export { Schema } from '../schema/Schema.js';
+export { MigrationSchemaCompiler } from '../schema/SchemaCompiler.js';