@uql/core 1.0.12 → 3.0.0

package/dist/migrate/generator/postgresSchemaGenerator.js

@@ -0,0 +1,111 @@
+import { AbstractSchemaGenerator } from '../schemaGenerator.js';
+/**
+ * PostgreSQL-specific schema generator
+ */
+export class PostgresSchemaGenerator extends AbstractSchemaGenerator {
+    serialPrimaryKeyType = 'SERIAL PRIMARY KEY';
+    constructor(namingStrategy) {
+        super(namingStrategy, '"');
+    }
+    mapColumnType(columnType, field) {
+        switch (columnType) {
+            case 'int':
+                return 'INTEGER';
+            case 'smallint':
+                return 'SMALLINT';
+            case 'bigint':
+                return 'BIGINT';
+            case 'float':
+            case 'double':
+            case 'real':
+                return 'DOUBLE PRECISION';
+            case 'decimal':
+            case 'numeric':
+                if (field.precision !== undefined) {
+                    if (field.scale !== undefined) {
+                        return `NUMERIC(${field.precision}, ${field.scale})`;
+                    }
+                    return `NUMERIC(${field.precision})`;
+                }
+                return 'NUMERIC';
+            case 'boolean':
+                return 'BOOLEAN';
+            case 'char':
+                return `CHAR(${field.length ?? 1})`;
+            case 'varchar':
+                return `VARCHAR(${field.length ?? 255})`;
+            case 'text':
+                return 'TEXT';
+            case 'uuid':
+                return 'UUID';
+            case 'date':
+                return 'DATE';
+            case 'time':
+                return 'TIME';
+            case 'timestamp':
+                return 'TIMESTAMP';
+            case 'timestamptz':
+                return 'TIMESTAMPTZ';
+            case 'json':
+                return 'JSON';
+            case 'jsonb':
+                return 'JSONB';
+            case 'blob':
+            case 'bytea':
+                return 'BYTEA';
+            case 'vector':
+                if (field.length) {
+                    return `VECTOR(${field.length})`;
+                }
+                return 'VECTOR';
+            case 'serial':
+                return 'SERIAL';
+            case 'bigserial':
+                return 'BIGSERIAL';
+            default:
+                return 'TEXT';
+        }
+    }
+    getBooleanType() {
+        return 'BOOLEAN';
+    }
+    generateAlterColumnStatements(tableName, column, newDefinition) {
+        const statements = [];
+        const escapedTableName = this.escapeId(tableName);
+        const escapedColumnName = this.escapeId(column.name);
+        // PostgreSQL uses separate ALTER COLUMN clauses for different changes
+        // 1. Change type
+        statements.push(`ALTER TABLE ${escapedTableName} ALTER COLUMN ${escapedColumnName} TYPE ${column.type};`);
+        // 2. Change nullability
+        if (column.nullable) {
+            statements.push(`ALTER TABLE ${escapedTableName} ALTER COLUMN ${escapedColumnName} DROP NOT NULL;`);
+        }
+        else {
+            statements.push(`ALTER TABLE ${escapedTableName} ALTER COLUMN ${escapedColumnName} SET NOT NULL;`);
+        }
+        // 3. Change default value
+        if (column.defaultValue !== undefined) {
+            statements.push(`ALTER TABLE ${escapedTableName} ALTER COLUMN ${escapedColumnName} SET DEFAULT ${this.formatDefaultValue(column.defaultValue)};`);
+        }
+        else {
+            statements.push(`ALTER TABLE ${escapedTableName} ALTER COLUMN ${escapedColumnName} DROP DEFAULT;`);
+        }
+        return statements;
+    }
+    generateColumnComment(tableName, columnName, comment) {
+        // PostgreSQL handles comments separately via COMMENT ON COLUMN
+        return '';
+    }
+    /**
+     * Generate COMMENT ON COLUMN statement for PostgreSQL
+     */
+    generateColumnCommentStatement(tableName, columnName, comment) {
+        const escapedComment = comment.replace(/'/g, "''");
+        return `COMMENT ON COLUMN ${this.escapeId(tableName)}.${this.escapeId(columnName)} IS '${escapedComment}';`;
+    }
+    generateDropIndex(tableName, indexName) {
+        // PostgreSQL doesn't require table name in DROP INDEX
+        return `DROP INDEX IF EXISTS ${this.escapeId(indexName)};`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"postgresSchemaGenerator.js","sourceRoot":"","sources":["../../../src/migrate/generator/postgresSchemaGenerator.ts"],"names":[],"mappings":"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","sourcesContent":["import type { ColumnSchema, ColumnType, FieldOptions, NamingStrategy } from '../../type/index.js';\nimport { AbstractSchemaGenerator } from '../schemaGenerator.js';\n\n/**\n * PostgreSQL-specific schema generator\n */\nexport class PostgresSchemaGenerator extends AbstractSchemaGenerator {\n  protected readonly serialPrimaryKeyType = 'SERIAL PRIMARY KEY';\n\n  constructor(namingStrategy?: NamingStrategy) {\n    super(namingStrategy, '\"');\n  }\n\n  public override mapColumnType(columnType: ColumnType, field: FieldOptions): string {\n    switch (columnType) {\n      case 'int':\n        return 'INTEGER';\n      case 'smallint':\n        return 'SMALLINT';\n      case 'bigint':\n        return 'BIGINT';\n      case 'float':\n      case 'double':\n      case 'real':\n        return 'DOUBLE PRECISION';\n      case 'decimal':\n      case 'numeric':\n        if (field.precision !== undefined) {\n          if (field.scale !== undefined) {\n            return `NUMERIC(${field.precision}, ${field.scale})`;\n          }\n          return `NUMERIC(${field.precision})`;\n        }\n        return 'NUMERIC';\n      case 'boolean':\n        return 'BOOLEAN';\n      case 'char':\n        return `CHAR(${field.length ?? 1})`;\n      case 'varchar':\n        return `VARCHAR(${field.length ?? 255})`;\n      case 'text':\n        return 'TEXT';\n      case 'uuid':\n        return 'UUID';\n      case 'date':\n        return 'DATE';\n      case 'time':\n        return 'TIME';\n      case 'timestamp':\n        return 'TIMESTAMP';\n      case 'timestamptz':\n        return 'TIMESTAMPTZ';\n      case 'json':\n        return 'JSON';\n      case 'jsonb':\n        return 'JSONB';\n      case 'blob':\n      case 'bytea':\n        return 'BYTEA';\n      case 'vector':\n        if (field.length) {\n          return `VECTOR(${field.length})`;\n        }\n        return 'VECTOR';\n      case 'serial':\n        return 'SERIAL';\n      case 'bigserial':\n        return 'BIGSERIAL';\n      default:\n        return 'TEXT';\n    }\n  }\n\n  public override getBooleanType(): string {\n    return 'BOOLEAN';\n  }\n\n  public override generateAlterColumnStatements(\n    tableName: string,\n    column: ColumnSchema,\n    newDefinition: string,\n  ): string[] {\n    const statements: string[] = [];\n    const escapedTableName = this.escapeId(tableName);\n    const escapedColumnName = this.escapeId(column.name);\n\n    // PostgreSQL uses separate ALTER COLUMN clauses for different changes\n    // 1. Change type\n    statements.push(`ALTER TABLE ${escapedTableName} ALTER COLUMN ${escapedColumnName} TYPE ${column.type};`);\n\n    // 2. Change nullability\n    if (column.nullable) {\n      statements.push(`ALTER TABLE ${escapedTableName} ALTER COLUMN ${escapedColumnName} DROP NOT NULL;`);\n    } else {\n      statements.push(`ALTER TABLE ${escapedTableName} ALTER COLUMN ${escapedColumnName} SET NOT NULL;`);\n    }\n\n    // 3. Change default value\n    if (column.defaultValue !== undefined) {\n      statements.push(\n        `ALTER TABLE ${escapedTableName} ALTER COLUMN ${escapedColumnName} SET DEFAULT ${this.formatDefaultValue(column.defaultValue)};`,\n      );\n    } else {\n      statements.push(`ALTER TABLE ${escapedTableName} ALTER COLUMN ${escapedColumnName} DROP DEFAULT;`);\n    }\n\n    return statements;\n  }\n\n  public override generateColumnComment(tableName: string, columnName: string, comment: string): string {\n    // PostgreSQL handles comments separately via COMMENT ON COLUMN\n    return '';\n  }\n\n  /**\n   * Generate COMMENT ON COLUMN statement for PostgreSQL\n   */\n  generateColumnCommentStatement(tableName: string, columnName: string, comment: string): string {\n    const escapedComment = comment.replace(/'/g, \"''\");\n    return `COMMENT ON COLUMN ${this.escapeId(tableName)}.${this.escapeId(columnName)} IS '${escapedComment}';`;\n  }\n\n  override generateDropIndex(tableName: string, indexName: string): string {\n    // PostgreSQL doesn't require table name in DROP INDEX\n    return `DROP INDEX IF EXISTS ${this.escapeId(indexName)};`;\n  }\n}\n"]}

package/dist/migrate/generator/sqliteSchemaGenerator.d.ts

@@ -0,0 +1,14 @@
+import type { ColumnSchema, ColumnType, FieldOptions } from '../../type/index.js';
+import { AbstractSchemaGenerator } from '../schemaGenerator.js';
+/**
+ * SQLite-specific schema generator
+ */
+export declare class SqliteSchemaGenerator extends AbstractSchemaGenerator {
+    protected readonly serialPrimaryKeyType = "INTEGER PRIMARY KEY AUTOINCREMENT";
+    mapColumnType(columnType: ColumnType, field: FieldOptions): string;
+    getBooleanType(): string;
+    generateAlterColumnStatements(tableName: string, column: ColumnSchema, newDefinition: string): string[];
+    generateColumnComment(tableName: string, columnName: string, comment: string): string;
+    generateDropIndex(tableName: string, indexName: string): string;
+    formatDefaultValue(value: unknown): string;
+}

package/dist/migrate/generator/sqliteSchemaGenerator.js

@@ -0,0 +1,68 @@
+import { AbstractSchemaGenerator } from '../schemaGenerator.js';
+/**
+ * SQLite-specific schema generator
+ */
+export class SqliteSchemaGenerator extends AbstractSchemaGenerator {
+    serialPrimaryKeyType = 'INTEGER PRIMARY KEY AUTOINCREMENT';
+    mapColumnType(columnType, field) {
+        // SQLite has dynamic typing, but we use type affinity
+        switch (columnType) {
+            case 'int':
+            case 'smallint':
+            case 'bigint':
+            case 'serial':
+            case 'bigserial':
+                return 'INTEGER';
+            case 'float':
+            case 'double':
+            case 'real':
+            case 'decimal':
+            case 'numeric':
+                return 'REAL';
+            case 'boolean':
+                return 'INTEGER'; // SQLite uses 0/1 for booleans
+            case 'char':
+            case 'varchar':
+            case 'text':
+            case 'uuid':
+                return 'TEXT';
+            case 'date':
+            case 'time':
+            case 'timestamp':
+            case 'timestamptz':
+                return 'TEXT'; // SQLite stores dates as TEXT or INTEGER
+            case 'json':
+            case 'jsonb':
+                return 'TEXT'; // SQLite stores JSON as TEXT
+            case 'blob':
+            case 'bytea':
+                return 'BLOB';
+            case 'vector':
+                return 'TEXT'; // Store as JSON array
+            default:
+                return 'TEXT';
+        }
+    }
+    getBooleanType() {
+        return 'INTEGER';
+    }
+    generateAlterColumnStatements(tableName, column, newDefinition) {
+        // SQLite has very limited ALTER TABLE support
+        // Column type changes require recreating the table
+        throw new Error(`SQLite does not support altering column '${column.name}' in table '${tableName}'. ` +
+            'You need to recreate the table to change column types.');
+    }
+    generateColumnComment(tableName, columnName, comment) {
+        return '';
+    }
+    generateDropIndex(tableName, indexName) {
+        return `DROP INDEX IF EXISTS ${this.escapeId(indexName)};`;
+    }
+    formatDefaultValue(value) {
+        if (typeof value === 'boolean') {
+            return value ? '1' : '0';
+        }
+        return super.formatDefaultValue(value);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/migrate/index.d.ts

@@ -0,0 +1,12 @@
+export type { ColumnSchema, Dialect, ForeignKeySchema, IndexSchema, Migration, MigrationDefinition, MigrationResult, MigrationStorage, MigratorOptions, MongoQuerier, SchemaDiff, SchemaGenerator, SchemaIntrospector, SqlDialect, SqlQuerier, SqlQueryDialect, TableSchema, } from '../type/index.js';
+export { isSqlQuerier } from '../type/index.js';
+export { MysqlSchemaGenerator, MysqlSchemaGenerator as MariadbSchemaGenerator, } from './generator/mysqlSchemaGenerator.js';
+export { PostgresSchemaGenerator } from './generator/postgresSchemaGenerator.js';
+export { SqliteSchemaGenerator } from './generator/sqliteSchemaGenerator.js';
+export { MariadbSchemaIntrospector, MysqlSchemaIntrospector } from './introspection/mysqlIntrospector.js';
+export { PostgresSchemaIntrospector } from './introspection/postgresIntrospector.js';
+export { SqliteSchemaIntrospector } from './introspection/sqliteIntrospector.js';
+export { defineMigration, Migrator } from './migrator.js';
+export { AbstractSchemaGenerator } from './schemaGenerator.js';
+export { DatabaseMigrationStorage } from './storage/databaseStorage.js';
+export { JsonMigrationStorage } from './storage/jsonStorage.js';

package/dist/migrate/index.js

@@ -0,0 +1,17 @@
+// Core types
+export { isSqlQuerier } from '../type/index.js';
+export { MysqlSchemaGenerator, MysqlSchemaGenerator as MariadbSchemaGenerator, } from './generator/mysqlSchemaGenerator.js';
+export { PostgresSchemaGenerator } from './generator/postgresSchemaGenerator.js';
+export { SqliteSchemaGenerator } from './generator/sqliteSchemaGenerator.js';
+// Schema introspection
+export { MariadbSchemaIntrospector, MysqlSchemaIntrospector } from './introspection/mysqlIntrospector.js';
+export { PostgresSchemaIntrospector } from './introspection/postgresIntrospector.js';
+export { SqliteSchemaIntrospector } from './introspection/sqliteIntrospector.js';
+// Main migrator
+export { defineMigration, Migrator } from './migrator.js';
+// Schema generators
+export { AbstractSchemaGenerator } from './schemaGenerator.js';
+// Storage implementations
+export { DatabaseMigrationStorage } from './storage/databaseStorage.js';
+export { JsonMigrationStorage } from './storage/jsonStorage.js';
+//# sourceMappingURL=data:application/json;base64,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

package/dist/migrate/introspection/index.d.ts

@@ -0,0 +1,4 @@
+export * from './mongoIntrospector.js';
+export { MariadbSchemaIntrospector, MysqlSchemaIntrospector } from './mysqlIntrospector.js';
+export * from './postgresIntrospector.js';
+export * from './sqliteIntrospector.js';

package/dist/migrate/introspection/index.js

@@ -0,0 +1,5 @@
+export * from './mongoIntrospector.js';
+export { MariadbSchemaIntrospector, MysqlSchemaIntrospector } from './mysqlIntrospector.js';
+export * from './postgresIntrospector.js';
+export * from './sqliteIntrospector.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbWlncmF0ZS9pbnRyb3NwZWN0aW9uL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsT0FBTyxFQUFFLHlCQUF5QixFQUFFLHVCQUF1QixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDNUYsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLHlCQUF5QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9tb25nb0ludHJvc3BlY3Rvci5qcyc7XG5leHBvcnQgeyBNYXJpYWRiU2NoZW1hSW50cm9zcGVjdG9yLCBNeXNxbFNjaGVtYUludHJvc3BlY3RvciB9IGZyb20gJy4vbXlzcWxJbnRyb3NwZWN0b3IuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9wb3N0Z3Jlc0ludHJvc3BlY3Rvci5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3NxbGl0ZUludHJvc3BlY3Rvci5qcyc7XG4iXX0=

package/dist/migrate/introspection/mongoIntrospector.d.ts

@@ -0,0 +1,8 @@
+import type { QuerierPool, SchemaIntrospector, TableSchema } from '../../type/index.js';
+export declare class MongoSchemaIntrospector implements SchemaIntrospector {
+    private readonly querierPool;
+    constructor(querierPool: QuerierPool);
+    getTableSchema(tableName: string): Promise<TableSchema | undefined>;
+    getTableNames(): Promise<string[]>;
+    tableExists(tableName: string): Promise<boolean>;
+}

package/dist/migrate/introspection/mongoIntrospector.js

@@ -0,0 +1,46 @@
+export class MongoSchemaIntrospector {
+    querierPool;
+    constructor(querierPool) {
+        this.querierPool = querierPool;
+    }
+    async getTableSchema(tableName) {
+        const querier = await this.querierPool.getQuerier();
+        try {
+            const { db } = querier;
+            const collections = await db.listCollections({ name: tableName }).toArray();
+            if (collections.length === 0) {
+                return undefined;
+            }
+            // MongoDB doesn't have a fixed schema, but we can look at the indexes
+            const indexes = await db.collection(tableName).indexes();
+            return {
+                name: tableName,
+                columns: [], // We don't have columns in Mongo
+                indexes: indexes.map((idx) => ({
+                    name: idx.name,
+                    columns: Object.keys(idx.key),
+                    unique: !!idx.unique,
+                })),
+            };
+        }
+        finally {
+            await querier.release();
+        }
+    }
+    async getTableNames() {
+        const querier = await this.querierPool.getQuerier();
+        try {
+            const { db } = querier;
+            const collections = await db.listCollections().toArray();
+            return collections.map((c) => c.name);
+        }
+        finally {
+            await querier.release();
+        }
+    }
+    async tableExists(tableName) {
+        const names = await this.getTableNames();
+        return names.includes(tableName);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/migrate/introspection/mysqlIntrospector.d.ts

@@ -0,0 +1,25 @@
+import type { QuerierPool, SchemaIntrospector, TableSchema } from '../../type/index.js';
+/**
+ * MySQL/MariaDB schema introspector.
+ * Works with both MySQL and MariaDB as they share the same information_schema structure.
+ */
+export declare class MysqlSchemaIntrospector implements SchemaIntrospector {
+    private readonly querierPool;
+    constructor(querierPool: QuerierPool);
+    getTableSchema(tableName: string): Promise<TableSchema | undefined>;
+    getTableNames(): Promise<string[]>;
+    tableExists(tableName: string): Promise<boolean>;
+    private tableExistsInternal;
+    private getQuerier;
+    private getColumns;
+    private getIndexes;
+    private getForeignKeys;
+    private getPrimaryKey;
+    private parseDefaultValue;
+    private normalizeReferentialAction;
+}
+/**
+ * Alias for MysqlSchemaIntrospector.
+ * MariaDB uses the same information_schema structure as MySQL.
+ */
+export declare const MariadbSchemaIntrospector: typeof MysqlSchemaIntrospector;

package/dist/migrate/introspection/mysqlIntrospector.js

@@ -0,0 +1,220 @@
+import { isSqlQuerier } from '../../type/index.js';
+/**
+ * MySQL/MariaDB schema introspector.
+ * Works with both MySQL and MariaDB as they share the same information_schema structure.
+ */
+export class MysqlSchemaIntrospector {
+    querierPool;
+    constructor(querierPool) {
+        this.querierPool = querierPool;
+    }
+    async getTableSchema(tableName) {
+        const querier = await this.getQuerier();
+        try {
+            const exists = await this.tableExistsInternal(querier, tableName);
+            if (!exists) {
+                return undefined;
+            }
+            const [columns, indexes, foreignKeys, primaryKey] = await Promise.all([
+                this.getColumns(querier, tableName),
+                this.getIndexes(querier, tableName),
+                this.getForeignKeys(querier, tableName),
+                this.getPrimaryKey(querier, tableName),
+            ]);
+            return {
+                name: tableName,
+                columns,
+                primaryKey,
+                indexes,
+                foreignKeys,
+            };
+        }
+        finally {
+            await querier.release();
+        }
+    }
+    async getTableNames() {
+        const querier = await this.getQuerier();
+        try {
+            const sql = `
+        SELECT TABLE_NAME as table_name
+        FROM information_schema.TABLES
+        WHERE TABLE_SCHEMA = DATABASE()
+          AND TABLE_TYPE = 'BASE TABLE'
+        ORDER BY TABLE_NAME
+      `;
+            const results = await querier.all(sql);
+            return results.map((r) => r.table_name);
+        }
+        finally {
+            await querier.release();
+        }
+    }
+    async tableExists(tableName) {
+        const querier = await this.getQuerier();
+        try {
+            return this.tableExistsInternal(querier, tableName);
+        }
+        finally {
+            await querier.release();
+        }
+    }
+    async tableExistsInternal(querier, tableName) {
+        const sql = `
+      SELECT COUNT(*) as count
+      FROM information_schema.TABLES
+      WHERE TABLE_SCHEMA = DATABASE()
+        AND TABLE_NAME = ?
+    `;
+        const results = await querier.all(sql, [tableName]);
+        return (results[0]?.count ?? 0) > 0;
+    }
+    async getQuerier() {
+        const querier = await this.querierPool.getQuerier();
+        if (!isSqlQuerier(querier)) {
+            await querier.release();
+            throw new Error('MysqlSchemaIntrospector requires a SQL-based querier');
+        }
+        return querier;
+    }
+    async getColumns(querier, tableName) {
+        const sql = `
+      SELECT
+        COLUMN_NAME as column_name,
+        DATA_TYPE as data_type,
+        COLUMN_TYPE as column_type,
+        IS_NULLABLE as is_nullable,
+        COLUMN_DEFAULT as column_default,
+        CHARACTER_MAXIMUM_LENGTH as character_maximum_length,
+        NUMERIC_PRECISION as numeric_precision,
+        NUMERIC_SCALE as numeric_scale,
+        COLUMN_KEY as column_key,
+        EXTRA as extra,
+        COLUMN_COMMENT as column_comment
+      FROM information_schema.COLUMNS
+      WHERE TABLE_SCHEMA = DATABASE()
+        AND TABLE_NAME = ?
+      ORDER BY ORDINAL_POSITION
+    `;
+        const results = await querier.all(sql, [tableName]);
+        return results.map((row) => ({
+            name: row.column_name,
+            type: row.data_type.toUpperCase(),
+            nullable: row.is_nullable === 'YES',
+            defaultValue: this.parseDefaultValue(row.column_default),
+            isPrimaryKey: row.column_key === 'PRI',
+            isAutoIncrement: row.extra.toLowerCase().includes('auto_increment'),
+            isUnique: row.column_key === 'UNI',
+            length: row.character_maximum_length ?? undefined,
+            precision: row.numeric_precision ?? undefined,
+            scale: row.numeric_scale ?? undefined,
+            comment: row.column_comment || undefined,
+        }));
+    }
+    async getIndexes(querier, tableName) {
+        const sql = `
+      SELECT
+        INDEX_NAME as index_name,
+        GROUP_CONCAT(COLUMN_NAME ORDER BY SEQ_IN_INDEX) as columns,
+        NOT NON_UNIQUE as is_unique
+      FROM information_schema.STATISTICS
+      WHERE TABLE_SCHEMA = DATABASE()
+        AND TABLE_NAME = ?
+        AND INDEX_NAME != 'PRIMARY'
+      GROUP BY INDEX_NAME, NON_UNIQUE
+      ORDER BY INDEX_NAME
+    `;
+        const results = await querier.all(sql, [tableName]);
+        return results.map((row) => ({
+            name: row.index_name,
+            columns: row.columns.split(','),
+            unique: Boolean(row.is_unique),
+        }));
+    }
+    async getForeignKeys(querier, tableName) {
+        const sql = `
+      SELECT
+        kcu.CONSTRAINT_NAME as constraint_name,
+        GROUP_CONCAT(kcu.COLUMN_NAME ORDER BY kcu.ORDINAL_POSITION) as columns,
+        kcu.REFERENCED_TABLE_NAME as referenced_table,
+        GROUP_CONCAT(kcu.REFERENCED_COLUMN_NAME ORDER BY kcu.ORDINAL_POSITION) as referenced_columns,
+        rc.DELETE_RULE as delete_rule,
+        rc.UPDATE_RULE as update_rule
+      FROM information_schema.KEY_COLUMN_USAGE kcu
+      JOIN information_schema.REFERENTIAL_CONSTRAINTS rc
+        ON kcu.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
+        AND kcu.TABLE_SCHEMA = rc.CONSTRAINT_SCHEMA
+      WHERE kcu.TABLE_SCHEMA = DATABASE()
+        AND kcu.TABLE_NAME = ?
+        AND kcu.REFERENCED_TABLE_NAME IS NOT NULL
+      GROUP BY kcu.CONSTRAINT_NAME, kcu.REFERENCED_TABLE_NAME, rc.DELETE_RULE, rc.UPDATE_RULE
+      ORDER BY kcu.CONSTRAINT_NAME
+    `;
+        const results = await querier.all(sql, [tableName]);
+        return results.map((row) => ({
+            name: row.constraint_name,
+            columns: row.columns.split(','),
+            referencedTable: row.referenced_table,
+            referencedColumns: row.referenced_columns.split(','),
+            onDelete: this.normalizeReferentialAction(row.delete_rule),
+            onUpdate: this.normalizeReferentialAction(row.update_rule),
+        }));
+    }
+    async getPrimaryKey(querier, tableName) {
+        const sql = `
+      SELECT COLUMN_NAME as column_name
+      FROM information_schema.KEY_COLUMN_USAGE
+      WHERE TABLE_SCHEMA = DATABASE()
+        AND TABLE_NAME = ?
+        AND CONSTRAINT_NAME = 'PRIMARY'
+      ORDER BY ORDINAL_POSITION
+    `;
+        const results = await querier.all(sql, [tableName]);
+        if (results.length === 0) {
+            return undefined;
+        }
+        return results.map((r) => r.column_name);
+    }
+    parseDefaultValue(defaultValue) {
+        if (defaultValue === null) {
+            return undefined;
+        }
+        // Check for common patterns
+        if (defaultValue === 'NULL') {
+            return null;
+        }
+        if (defaultValue === 'CURRENT_TIMESTAMP') {
+            return defaultValue;
+        }
+        if (/^'.*'$/.test(defaultValue)) {
+            return defaultValue.slice(1, -1);
+        }
+        if (/^-?\d+$/.test(defaultValue)) {
+            return Number.parseInt(defaultValue, 10);
+        }
+        if (/^-?\d+\.\d+$/.test(defaultValue)) {
+            return Number.parseFloat(defaultValue);
+        }
+        return defaultValue;
+    }
+    normalizeReferentialAction(action) {
+        switch (action.toUpperCase()) {
+            case 'CASCADE':
+                return 'CASCADE';
+            case 'SET NULL':
+                return 'SET NULL';
+            case 'RESTRICT':
+                return 'RESTRICT';
+            case 'NO ACTION':
+                return 'NO ACTION';
+            default:
+                return undefined;
+        }
+    }
+}
+/**
+ * Alias for MysqlSchemaIntrospector.
+ * MariaDB uses the same information_schema structure as MySQL.
+ */
+export const MariadbSchemaIntrospector = MysqlSchemaIntrospector;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mysqlIntrospector.js","sourceRoot":"","sources":["../../../src/migrate/introspection/mysqlIntrospector.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  ColumnSchema,\n  ForeignKeySchema,\n  IndexSchema,\n  QuerierPool,\n  SchemaIntrospector,\n  SqlQuerier,\n  TableSchema,\n} from '../../type/index.js';\nimport { isSqlQuerier } from '../../type/index.js';\n\n/**\n * MySQL/MariaDB schema introspector.\n * Works with both MySQL and MariaDB as they share the same information_schema structure.\n */\nexport class MysqlSchemaIntrospector implements SchemaIntrospector {\n  constructor(private readonly querierPool: QuerierPool) {}\n\n  async getTableSchema(tableName: string): Promise<TableSchema | undefined> {\n    const querier = await this.getQuerier();\n\n    try {\n      const exists = await this.tableExistsInternal(querier, tableName);\n      if (!exists) {\n        return undefined;\n      }\n\n      const [columns, indexes, foreignKeys, primaryKey] = await Promise.all([\n        this.getColumns(querier, tableName),\n        this.getIndexes(querier, tableName),\n        this.getForeignKeys(querier, tableName),\n        this.getPrimaryKey(querier, tableName),\n      ]);\n\n      return {\n        name: tableName,\n        columns,\n        primaryKey,\n        indexes,\n        foreignKeys,\n      };\n    } finally {\n      await querier.release();\n    }\n  }\n\n  async getTableNames(): Promise<string[]> {\n    const querier = await this.getQuerier();\n\n    try {\n      const sql = `\n        SELECT TABLE_NAME as table_name\n        FROM information_schema.TABLES\n        WHERE TABLE_SCHEMA = DATABASE()\n          AND TABLE_TYPE = 'BASE TABLE'\n        ORDER BY TABLE_NAME\n      `;\n\n      const results = await querier.all<{ table_name: string }>(sql);\n      return results.map((r: any) => r.table_name);\n    } finally {\n      await querier.release();\n    }\n  }\n\n  async tableExists(tableName: string): Promise<boolean> {\n    const querier = await this.getQuerier();\n\n    try {\n      return this.tableExistsInternal(querier, tableName);\n    } finally {\n      await querier.release();\n    }\n  }\n\n  private async tableExistsInternal(querier: SqlQuerier, tableName: string): Promise<boolean> {\n    const sql = `\n      SELECT COUNT(*) as count\n      FROM information_schema.TABLES\n      WHERE TABLE_SCHEMA = DATABASE()\n        AND TABLE_NAME = ?\n    `;\n\n    const results = await querier.all<{ count: number }>(sql, [tableName]);\n    return (results[0]?.count ?? 0) > 0;\n  }\n\n  private async getQuerier(): Promise<SqlQuerier> {\n    const querier = await this.querierPool.getQuerier();\n\n    if (!isSqlQuerier(querier)) {\n      await querier.release();\n      throw new Error('MysqlSchemaIntrospector requires a SQL-based querier');\n    }\n\n    return querier;\n  }\n\n  private async getColumns(querier: SqlQuerier, tableName: string): Promise<ColumnSchema[]> {\n    const sql = `\n      SELECT\n        COLUMN_NAME as column_name,\n        DATA_TYPE as data_type,\n        COLUMN_TYPE as column_type,\n        IS_NULLABLE as is_nullable,\n        COLUMN_DEFAULT as column_default,\n        CHARACTER_MAXIMUM_LENGTH as character_maximum_length,\n        NUMERIC_PRECISION as numeric_precision,\n        NUMERIC_SCALE as numeric_scale,\n        COLUMN_KEY as column_key,\n        EXTRA as extra,\n        COLUMN_COMMENT as column_comment\n      FROM information_schema.COLUMNS\n      WHERE TABLE_SCHEMA = DATABASE()\n        AND TABLE_NAME = ?\n      ORDER BY ORDINAL_POSITION\n    `;\n\n    const results = await querier.all<{\n      column_name: string;\n      data_type: string;\n      column_type: string;\n      is_nullable: string;\n      column_default: string | null;\n      character_maximum_length: number | null;\n      numeric_precision: number | null;\n      numeric_scale: number | null;\n      column_key: string;\n      extra: string;\n      column_comment: string | null;\n    }>(sql, [tableName]);\n\n    return results.map((row: any) => ({\n      name: row.column_name,\n      type: row.data_type.toUpperCase(),\n      nullable: row.is_nullable === 'YES',\n      defaultValue: this.parseDefaultValue(row.column_default),\n      isPrimaryKey: row.column_key === 'PRI',\n      isAutoIncrement: row.extra.toLowerCase().includes('auto_increment'),\n      isUnique: row.column_key === 'UNI',\n      length: row.character_maximum_length ?? undefined,\n      precision: row.numeric_precision ?? undefined,\n      scale: row.numeric_scale ?? undefined,\n      comment: row.column_comment || undefined,\n    }));\n  }\n\n  private async getIndexes(querier: SqlQuerier, tableName: string): Promise<IndexSchema[]> {\n    const sql = `\n      SELECT\n        INDEX_NAME as index_name,\n        GROUP_CONCAT(COLUMN_NAME ORDER BY SEQ_IN_INDEX) as columns,\n        NOT NON_UNIQUE as is_unique\n      FROM information_schema.STATISTICS\n      WHERE TABLE_SCHEMA = DATABASE()\n        AND TABLE_NAME = ?\n        AND INDEX_NAME != 'PRIMARY'\n      GROUP BY INDEX_NAME, NON_UNIQUE\n      ORDER BY INDEX_NAME\n    `;\n\n    const results = await querier.all<{\n      index_name: string;\n      columns: string;\n      is_unique: number;\n    }>(sql, [tableName]);\n\n    return results.map((row: any) => ({\n      name: row.index_name,\n      columns: row.columns.split(','),\n      unique: Boolean(row.is_unique),\n    }));\n  }\n\n  private async getForeignKeys(querier: SqlQuerier, tableName: string): Promise<ForeignKeySchema[]> {\n    const sql = `\n      SELECT\n        kcu.CONSTRAINT_NAME as constraint_name,\n        GROUP_CONCAT(kcu.COLUMN_NAME ORDER BY kcu.ORDINAL_POSITION) as columns,\n        kcu.REFERENCED_TABLE_NAME as referenced_table,\n        GROUP_CONCAT(kcu.REFERENCED_COLUMN_NAME ORDER BY kcu.ORDINAL_POSITION) as referenced_columns,\n        rc.DELETE_RULE as delete_rule,\n        rc.UPDATE_RULE as update_rule\n      FROM information_schema.KEY_COLUMN_USAGE kcu\n      JOIN information_schema.REFERENTIAL_CONSTRAINTS rc\n        ON kcu.CONSTRAINT_NAME = rc.CONSTRAINT_NAME\n        AND kcu.TABLE_SCHEMA = rc.CONSTRAINT_SCHEMA\n      WHERE kcu.TABLE_SCHEMA = DATABASE()\n        AND kcu.TABLE_NAME = ?\n        AND kcu.REFERENCED_TABLE_NAME IS NOT NULL\n      GROUP BY kcu.CONSTRAINT_NAME, kcu.REFERENCED_TABLE_NAME, rc.DELETE_RULE, rc.UPDATE_RULE\n      ORDER BY kcu.CONSTRAINT_NAME\n    `;\n\n    const results = await querier.all<{\n      constraint_name: string;\n      columns: string;\n      referenced_table: string;\n      referenced_columns: string;\n      delete_rule: string;\n      update_rule: string;\n    }>(sql, [tableName]);\n\n    return results.map((row: any) => ({\n      name: row.constraint_name,\n      columns: row.columns.split(','),\n      referencedTable: row.referenced_table,\n      referencedColumns: row.referenced_columns.split(','),\n      onDelete: this.normalizeReferentialAction(row.delete_rule),\n      onUpdate: this.normalizeReferentialAction(row.update_rule),\n    }));\n  }\n\n  private async getPrimaryKey(querier: SqlQuerier, tableName: string): Promise<string[] | undefined> {\n    const sql = `\n      SELECT COLUMN_NAME as column_name\n      FROM information_schema.KEY_COLUMN_USAGE\n      WHERE TABLE_SCHEMA = DATABASE()\n        AND TABLE_NAME = ?\n        AND CONSTRAINT_NAME = 'PRIMARY'\n      ORDER BY ORDINAL_POSITION\n    `;\n\n    const results = await querier.all<{ column_name: string }>(sql, [tableName]);\n\n    if (results.length === 0) {\n      return undefined;\n    }\n\n    return results.map((r: any) => r.column_name);\n  }\n\n  private parseDefaultValue(defaultValue: string | null): unknown {\n    if (defaultValue === null) {\n      return undefined;\n    }\n\n    // Check for common patterns\n    if (defaultValue === 'NULL') {\n      return null;\n    }\n    if (defaultValue === 'CURRENT_TIMESTAMP') {\n      return defaultValue;\n    }\n    if (/^'.*'$/.test(defaultValue)) {\n      return defaultValue.slice(1, -1);\n    }\n    if (/^-?\\d+$/.test(defaultValue)) {\n      return Number.parseInt(defaultValue, 10);\n    }\n    if (/^-?\\d+\\.\\d+$/.test(defaultValue)) {\n      return Number.parseFloat(defaultValue);\n    }\n\n    return defaultValue;\n  }\n\n  private normalizeReferentialAction(action: string): 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION' | undefined {\n    switch (action.toUpperCase()) {\n      case 'CASCADE':\n        return 'CASCADE';\n      case 'SET NULL':\n        return 'SET NULL';\n      case 'RESTRICT':\n        return 'RESTRICT';\n      case 'NO ACTION':\n        return 'NO ACTION';\n      default:\n        return undefined;\n    }\n  }\n}\n\n/**\n * Alias for MysqlSchemaIntrospector.\n * MariaDB uses the same information_schema structure as MySQL.\n */\nexport const MariadbSchemaIntrospector = MysqlSchemaIntrospector;\n"]}

package/dist/migrate/introspection/postgresIntrospector.d.ts

@@ -0,0 +1,21 @@
+import type { QuerierPool, SchemaIntrospector, TableSchema } from '../../type/index.js';
+/**
+ * PostgreSQL schema introspector
+ */
+export declare class PostgresSchemaIntrospector implements SchemaIntrospector {
+    private readonly querierPool;
+    constructor(querierPool: QuerierPool);
+    getTableSchema(tableName: string): Promise<TableSchema | undefined>;
+    getTableNames(): Promise<string[]>;
+    tableExists(tableName: string): Promise<boolean>;
+    private tableExistsInternal;
+    private getQuerier;
+    private getColumns;
+    private getIndexes;
+    private getForeignKeys;
+    private getPrimaryKey;
+    private normalizeType;
+    private parseDefaultValue;
+    private isAutoIncrement;
+    private normalizeReferentialAction;
+}