@zintrust/core 0.1.27 → 0.1.28

package/src/migrations/schema/Blueprint.js

@@ -1,191 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,142 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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;AA8UF,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

@@ -1,270 +0,0 @@
-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(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')
-        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(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

@@ -1,5 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

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