@uql/core 1.0.12 → 3.1.0

package/dist/migrate/introspection/postgresIntrospector.js

@@ -0,0 +1,269 @@
+import { isSqlQuerier } from '../../type/index.js';
+/**
+ * PostgreSQL schema introspector
+ */
+export class PostgresSchemaIntrospector {
+    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
+        FROM information_schema.tables
+        WHERE table_schema = 'public'
+          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 EXISTS (
+        SELECT FROM information_schema.tables
+        WHERE table_schema = 'public'
+          AND table_name = $1
+      ) AS exists
+    `;
+        const results = await querier.all(sql, [tableName]);
+        return results[0]?.exists ?? false;
+    }
+    async getQuerier() {
+        const querier = await this.querierPool.getQuerier();
+        if (!isSqlQuerier(querier)) {
+            await querier.release();
+            throw new Error('PostgresSchemaIntrospector requires a SQL-based querier');
+        }
+        return querier;
+    }
+    async getColumns(querier, tableName) {
+        const sql = /*sql*/ `
+      SELECT
+        c.column_name,
+        c.data_type,
+        c.udt_name,
+        c.is_nullable,
+        c.column_default,
+        c.character_maximum_length,
+        c.numeric_precision,
+        c.numeric_scale,
+        COALESCE(
+          (SELECT TRUE FROM information_schema.table_constraints tc
+           JOIN information_schema.key_column_usage kcu
+             ON tc.constraint_name = kcu.constraint_name
+           WHERE tc.table_name = c.table_name
+             AND tc.constraint_type = 'PRIMARY KEY'
+             AND kcu.column_name = c.column_name
+           LIMIT 1),
+          FALSE
+        ) AS is_primary_key,
+        COALESCE(
+          (SELECT TRUE FROM information_schema.table_constraints tc
+           JOIN information_schema.key_column_usage kcu
+             ON tc.constraint_name = kcu.constraint_name
+           WHERE tc.table_name = c.table_name
+             AND tc.constraint_type = 'UNIQUE'
+             AND kcu.column_name = c.column_name
+           LIMIT 1),
+          FALSE
+        ) AS is_unique,
+        pg_catalog.col_description(
+          (SELECT oid FROM pg_catalog.pg_class WHERE relname = c.table_name),
+          c.ordinal_position
+        ) AS column_comment
+      FROM information_schema.columns c
+      WHERE c.table_schema = 'public'
+        AND c.table_name = $1
+      ORDER BY c.ordinal_position
+    `;
+        const results = await querier.all(sql, [tableName]);
+        return results.map((row) => ({
+            name: row.column_name,
+            type: this.normalizeType(row.data_type, row.udt_name),
+            nullable: row.is_nullable === 'YES',
+            defaultValue: this.parseDefaultValue(row.column_default),
+            isPrimaryKey: row.is_primary_key,
+            isAutoIncrement: this.isAutoIncrement(row.column_default),
+            isUnique: row.is_unique,
+            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 = /*sql*/ `
+      SELECT
+        i.relname AS index_name,
+        array_agg(a.attname ORDER BY k.n) AS columns,
+        ix.indisunique AS is_unique
+      FROM pg_class t
+      JOIN pg_index ix ON t.oid = ix.indrelid
+      JOIN pg_class i ON i.oid = ix.indexrelid
+      JOIN pg_namespace n ON n.oid = t.relnamespace
+      CROSS JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS k(attnum, n)
+      JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum
+      WHERE t.relname = $1
+        AND n.nspname = 'public'
+        AND NOT ix.indisprimary
+      GROUP BY i.relname, ix.indisunique
+      ORDER BY i.relname
+    `;
+        const results = await querier.all(sql, [tableName]);
+        return results.map((row) => ({
+            name: row.index_name,
+            columns: row.columns,
+            unique: row.is_unique,
+        }));
+    }
+    async getForeignKeys(querier, tableName) {
+        const sql = /*sql*/ `
+      SELECT
+        tc.constraint_name,
+        array_agg(kcu.column_name ORDER BY kcu.ordinal_position) AS columns,
+        ccu.table_name AS referenced_table,
+        array_agg(ccu.column_name ORDER BY kcu.ordinal_position) AS referenced_columns,
+        rc.delete_rule,
+        rc.update_rule
+      FROM information_schema.table_constraints tc
+      JOIN information_schema.key_column_usage kcu
+        ON tc.constraint_name = kcu.constraint_name
+        AND tc.table_schema = kcu.table_schema
+      JOIN information_schema.constraint_column_usage ccu
+        ON ccu.constraint_name = tc.constraint_name
+        AND ccu.table_schema = tc.table_schema
+      JOIN information_schema.referential_constraints rc
+        ON rc.constraint_name = tc.constraint_name
+        AND rc.constraint_schema = tc.table_schema
+      WHERE tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_name = $1
+        AND tc.table_schema = 'public'
+      GROUP BY tc.constraint_name, ccu.table_name, rc.delete_rule, rc.update_rule
+      ORDER BY tc.constraint_name
+    `;
+        const results = await querier.all(sql, [tableName]);
+        return results.map((row) => ({
+            name: row.constraint_name,
+            columns: row.columns,
+            referencedTable: row.referenced_table,
+            referencedColumns: row.referenced_columns,
+            onDelete: this.normalizeReferentialAction(row.delete_rule),
+            onUpdate: this.normalizeReferentialAction(row.update_rule),
+        }));
+    }
+    async getPrimaryKey(querier, tableName) {
+        const sql = /*sql*/ `
+      SELECT kcu.column_name
+      FROM information_schema.table_constraints tc
+      JOIN information_schema.key_column_usage kcu
+        ON tc.constraint_name = kcu.constraint_name
+        AND tc.table_schema = kcu.table_schema
+      WHERE tc.constraint_type = 'PRIMARY KEY'
+        AND tc.table_name = $1
+        AND tc.table_schema = 'public'
+      ORDER BY kcu.ordinal_position
+    `;
+        const results = await querier.all(sql, [tableName]);
+        if (results.length === 0) {
+            return undefined;
+        }
+        return results.map((r) => r.column_name);
+    }
+    normalizeType(dataType, udtName) {
+        // Handle user-defined types and arrays
+        if (dataType === 'USER-DEFINED') {
+            return udtName.toUpperCase();
+        }
+        if (dataType === 'ARRAY') {
+            return `${udtName.replace(/^_/, '')}[]`;
+        }
+        return dataType.toUpperCase();
+    }
+    parseDefaultValue(defaultValue) {
+        if (!defaultValue) {
+            return undefined;
+        }
+        // Remove type casting
+        const cleaned = defaultValue.replace(/::[a-z_]+(\[\])?/gi, '').trim();
+        // Check for common patterns
+        if (cleaned.startsWith("'") && cleaned.endsWith("'")) {
+            return cleaned.slice(1, -1);
+        }
+        if (cleaned === 'true' || cleaned === 'false') {
+            return cleaned === 'true';
+        }
+        if (cleaned === 'NULL') {
+            return null;
+        }
+        if (/^-?\d+$/.test(cleaned)) {
+            return Number.parseInt(cleaned, 10);
+        }
+        if (/^-?\d+\.\d+$/.test(cleaned)) {
+            return Number.parseFloat(cleaned);
+        }
+        // Return as-is for functions like CURRENT_TIMESTAMP, nextval(), etc.
+        return defaultValue;
+    }
+    isAutoIncrement(defaultValue) {
+        if (!defaultValue) {
+            return false;
+        }
+        return defaultValue.includes('nextval(');
+    }
+    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;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"postgresIntrospector.js","sourceRoot":"","sources":["../../../src/migrate/introspection/postgresIntrospector.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 * PostgreSQL schema introspector\n */\nexport class PostgresSchemaIntrospector 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\n        FROM information_schema.tables\n        WHERE table_schema = 'public'\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 EXISTS (\n        SELECT FROM information_schema.tables\n        WHERE table_schema = 'public'\n          AND table_name = $1\n      ) AS exists\n    `;\n\n    const results = await querier.all<{ exists: boolean }>(sql, [tableName]);\n    return results[0]?.exists ?? false;\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('PostgresSchemaIntrospector 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 = /*sql*/ `\n      SELECT\n        c.column_name,\n        c.data_type,\n        c.udt_name,\n        c.is_nullable,\n        c.column_default,\n        c.character_maximum_length,\n        c.numeric_precision,\n        c.numeric_scale,\n        COALESCE(\n          (SELECT TRUE FROM information_schema.table_constraints tc\n           JOIN information_schema.key_column_usage kcu\n             ON tc.constraint_name = kcu.constraint_name\n           WHERE tc.table_name = c.table_name\n             AND tc.constraint_type = 'PRIMARY KEY'\n             AND kcu.column_name = c.column_name\n           LIMIT 1),\n          FALSE\n        ) AS is_primary_key,\n        COALESCE(\n          (SELECT TRUE FROM information_schema.table_constraints tc\n           JOIN information_schema.key_column_usage kcu\n             ON tc.constraint_name = kcu.constraint_name\n           WHERE tc.table_name = c.table_name\n             AND tc.constraint_type = 'UNIQUE'\n             AND kcu.column_name = c.column_name\n           LIMIT 1),\n          FALSE\n        ) AS is_unique,\n        pg_catalog.col_description(\n          (SELECT oid FROM pg_catalog.pg_class WHERE relname = c.table_name),\n          c.ordinal_position\n        ) AS column_comment\n      FROM information_schema.columns c\n      WHERE c.table_schema = 'public'\n        AND c.table_name = $1\n      ORDER BY c.ordinal_position\n    `;\n\n    const results = await querier.all<{\n      column_name: string;\n      data_type: string;\n      udt_name: 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      is_primary_key: boolean;\n      is_unique: boolean;\n      column_comment: string | null;\n    }>(sql, [tableName]);\n\n    return results.map((row: any) => ({\n      name: row.column_name,\n      type: this.normalizeType(row.data_type, row.udt_name),\n      nullable: row.is_nullable === 'YES',\n      defaultValue: this.parseDefaultValue(row.column_default),\n      isPrimaryKey: row.is_primary_key,\n      isAutoIncrement: this.isAutoIncrement(row.column_default),\n      isUnique: row.is_unique,\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 = /*sql*/ `\n      SELECT\n        i.relname AS index_name,\n        array_agg(a.attname ORDER BY k.n) AS columns,\n        ix.indisunique AS is_unique\n      FROM pg_class t\n      JOIN pg_index ix ON t.oid = ix.indrelid\n      JOIN pg_class i ON i.oid = ix.indexrelid\n      JOIN pg_namespace n ON n.oid = t.relnamespace\n      CROSS JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS k(attnum, n)\n      JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum\n      WHERE t.relname = $1\n        AND n.nspname = 'public'\n        AND NOT ix.indisprimary\n      GROUP BY i.relname, ix.indisunique\n      ORDER BY i.relname\n    `;\n\n    const results = await querier.all<{\n      index_name: string;\n      columns: string[];\n      is_unique: boolean;\n    }>(sql, [tableName]);\n\n    return results.map((row: any) => ({\n      name: row.index_name,\n      columns: row.columns,\n      unique: row.is_unique,\n    }));\n  }\n\n  private async getForeignKeys(querier: SqlQuerier, tableName: string): Promise<ForeignKeySchema[]> {\n    const sql = /*sql*/ `\n      SELECT\n        tc.constraint_name,\n        array_agg(kcu.column_name ORDER BY kcu.ordinal_position) AS columns,\n        ccu.table_name AS referenced_table,\n        array_agg(ccu.column_name ORDER BY kcu.ordinal_position) AS referenced_columns,\n        rc.delete_rule,\n        rc.update_rule\n      FROM information_schema.table_constraints tc\n      JOIN information_schema.key_column_usage kcu\n        ON tc.constraint_name = kcu.constraint_name\n        AND tc.table_schema = kcu.table_schema\n      JOIN information_schema.constraint_column_usage ccu\n        ON ccu.constraint_name = tc.constraint_name\n        AND ccu.table_schema = tc.table_schema\n      JOIN information_schema.referential_constraints rc\n        ON rc.constraint_name = tc.constraint_name\n        AND rc.constraint_schema = tc.table_schema\n      WHERE tc.constraint_type = 'FOREIGN KEY'\n        AND tc.table_name = $1\n        AND tc.table_schema = 'public'\n      GROUP BY tc.constraint_name, ccu.table_name, rc.delete_rule, rc.update_rule\n      ORDER BY tc.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,\n      referencedTable: row.referenced_table,\n      referencedColumns: row.referenced_columns,\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 = /*sql*/ `\n      SELECT kcu.column_name\n      FROM information_schema.table_constraints tc\n      JOIN information_schema.key_column_usage kcu\n        ON tc.constraint_name = kcu.constraint_name\n        AND tc.table_schema = kcu.table_schema\n      WHERE tc.constraint_type = 'PRIMARY KEY'\n        AND tc.table_name = $1\n        AND tc.table_schema = 'public'\n      ORDER BY kcu.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 normalizeType(dataType: string, udtName: string): string {\n    // Handle user-defined types and arrays\n    if (dataType === 'USER-DEFINED') {\n      return udtName.toUpperCase();\n    }\n    if (dataType === 'ARRAY') {\n      return `${udtName.replace(/^_/, '')}[]`;\n    }\n    return dataType.toUpperCase();\n  }\n\n  private parseDefaultValue(defaultValue: string | null): unknown {\n    if (!defaultValue) {\n      return undefined;\n    }\n\n    // Remove type casting\n    const cleaned = defaultValue.replace(/::[a-z_]+(\\[\\])?/gi, '').trim();\n\n    // Check for common patterns\n    if (cleaned.startsWith(\"'\") && cleaned.endsWith(\"'\")) {\n      return cleaned.slice(1, -1);\n    }\n    if (cleaned === 'true' || cleaned === 'false') {\n      return cleaned === 'true';\n    }\n    if (cleaned === 'NULL') {\n      return null;\n    }\n    if (/^-?\\d+$/.test(cleaned)) {\n      return Number.parseInt(cleaned, 10);\n    }\n    if (/^-?\\d+\\.\\d+$/.test(cleaned)) {\n      return Number.parseFloat(cleaned);\n    }\n\n    // Return as-is for functions like CURRENT_TIMESTAMP, nextval(), etc.\n    return defaultValue;\n  }\n\n  private isAutoIncrement(defaultValue: string | null): boolean {\n    if (!defaultValue) {\n      return false;\n    }\n    return defaultValue.includes('nextval(');\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"]}

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

@@ -0,0 +1,23 @@
+import type { QuerierPool, SchemaIntrospector, TableSchema } from '../../type/index.js';
+/**
+ * SQLite schema introspector
+ */
+export declare class SqliteSchemaIntrospector 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 getUniqueColumns;
+    private getIndexes;
+    private getForeignKeys;
+    private getPrimaryKey;
+    private escapeId;
+    private normalizeType;
+    private extractLength;
+    private parseDefaultValue;
+    private normalizeReferentialAction;
+}

package/dist/migrate/introspection/sqliteIntrospector.js

@@ -0,0 +1,212 @@
+import { isSqlQuerier } from '../../type/index.js';
+/**
+ * SQLite schema introspector
+ */
+export class SqliteSchemaIntrospector {
+    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 = /*sql*/ `
+        SELECT name
+        FROM sqlite_master
+        WHERE type = 'table'
+          AND name NOT LIKE 'sqlite_%'
+        ORDER BY name
+      `;
+            const results = await querier.all(sql);
+            return results.map((r) => r.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 = /*sql*/ `
+      SELECT COUNT(*) as count
+      FROM sqlite_master
+      WHERE type = 'table'
+        AND 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('SqliteSchemaIntrospector requires a SQL-based querier');
+        }
+        return querier;
+    }
+    async getColumns(querier, tableName) {
+        // SQLite uses PRAGMA for table info
+        const sql = `PRAGMA table_info(${this.escapeId(tableName)})`;
+        const results = await querier.all(sql);
+        // Get unique columns from indexes
+        const uniqueColumns = await this.getUniqueColumns(querier, tableName);
+        return results.map((row) => ({
+            name: row.name,
+            type: this.normalizeType(row.type),
+            nullable: row.notnull === 0,
+            defaultValue: this.parseDefaultValue(row.dflt_value),
+            isPrimaryKey: row.pk > 0,
+            isAutoIncrement: row.pk > 0 && row.type.toUpperCase() === 'INTEGER',
+            isUnique: uniqueColumns.has(row.name),
+            length: this.extractLength(row.type),
+            precision: undefined,
+            scale: undefined,
+            comment: undefined, // SQLite doesn't support column comments
+        }));
+    }
+    async getUniqueColumns(querier, tableName) {
+        const sql = `PRAGMA index_list(${this.escapeId(tableName)})`;
+        const indexes = await querier.all(sql);
+        const uniqueColumns = new Set();
+        for (const index of indexes) {
+            if (index.unique && index.origin === 'u') {
+                const indexInfo = await querier.all(`PRAGMA index_info(${this.escapeId(index.name)})`);
+                // Only single-column unique constraints
+                if (indexInfo.length === 1) {
+                    uniqueColumns.add(indexInfo[0].name);
+                }
+            }
+        }
+        return uniqueColumns;
+    }
+    async getIndexes(querier, tableName) {
+        const sql = `PRAGMA index_list(${this.escapeId(tableName)})`;
+        const indexes = await querier.all(sql);
+        const result = [];
+        for (const index of indexes) {
+            // Skip auto-generated indexes (primary key, unique constraints)
+            if (index.origin !== 'c') {
+                continue;
+            }
+            const columns = await querier.all(`PRAGMA index_info(${this.escapeId(index.name)})`);
+            result.push({
+                name: index.name,
+                columns: columns.map((c) => c.name),
+                unique: Boolean(index.unique),
+            });
+        }
+        return result;
+    }
+    async getForeignKeys(querier, tableName) {
+        const sql = `PRAGMA foreign_key_list(${this.escapeId(tableName)})`;
+        const results = await querier.all(sql);
+        // Group by id to handle composite foreign keys
+        const grouped = new Map();
+        for (const row of results) {
+            const existing = grouped.get(row.id) ?? [];
+            existing.push(row);
+            grouped.set(row.id, existing);
+        }
+        return Array.from(grouped.entries()).map(([id, rows]) => {
+            const first = rows[0];
+            return {
+                name: `fk_${tableName}_${id}`,
+                columns: rows.map((r) => r.from),
+                referencedTable: first.table,
+                referencedColumns: rows.map((r) => r.to),
+                onDelete: this.normalizeReferentialAction(first.on_delete),
+                onUpdate: this.normalizeReferentialAction(first.on_update),
+            };
+        });
+    }
+    async getPrimaryKey(querier, tableName) {
+        const sql = `PRAGMA table_info(${this.escapeId(tableName)})`;
+        const results = await querier.all(sql);
+        const pkColumns = results.filter((r) => r.pk > 0).sort((a, b) => a.pk - b.pk);
+        if (pkColumns.length === 0) {
+            return undefined;
+        }
+        return pkColumns.map((r) => r.name);
+    }
+    escapeId(identifier) {
+        return `\`${identifier.replace(/`/g, '``')}\``;
+    }
+    normalizeType(type) {
+        // Extract base type without length/precision
+        const match = type.match(/^([A-Za-z]+)/);
+        return match ? match[1].toUpperCase() : type.toUpperCase();
+    }
+    extractLength(type) {
+        const match = type.match(/\((\d+)\)/);
+        return match ? Number.parseInt(match[1], 10) : undefined;
+    }
+    parseDefaultValue(defaultValue) {
+        if (defaultValue === null) {
+            return undefined;
+        }
+        // Check for common patterns
+        if (defaultValue === 'NULL') {
+            return null;
+        }
+        if (defaultValue === 'CURRENT_TIMESTAMP' || defaultValue === 'CURRENT_DATE' || defaultValue === 'CURRENT_TIME') {
+            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;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sqliteIntrospector.js","sourceRoot":"","sources":["../../../src/migrate/introspection/sqliteIntrospector.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 * SQLite schema introspector\n */\nexport class SqliteSchemaIntrospector 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 = /*sql*/ `\n        SELECT name\n        FROM sqlite_master\n        WHERE type = 'table'\n          AND name NOT LIKE 'sqlite_%'\n        ORDER BY name\n      `;\n\n      const results = await querier.all<{ name: string }>(sql);\n      return results.map((r: any) => r.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 = /*sql*/ `\n      SELECT COUNT(*) as count\n      FROM sqlite_master\n      WHERE type = 'table'\n        AND 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('SqliteSchemaIntrospector requires a SQL-based querier');\n    }\n\n    return querier;\n  }\n\n  private async getColumns(querier: SqlQuerier, tableName: string): Promise<ColumnSchema[]> {\n    // SQLite uses PRAGMA for table info\n    const sql = `PRAGMA table_info(${this.escapeId(tableName)})`;\n\n    const results = await querier.all<{\n      cid: number;\n      name: string;\n      type: string;\n      notnull: number;\n      dflt_value: string | null;\n      pk: number;\n    }>(sql);\n\n    // Get unique columns from indexes\n    const uniqueColumns = await this.getUniqueColumns(querier, tableName);\n\n    return results.map((row: any) => ({\n      name: row.name,\n      type: this.normalizeType(row.type),\n      nullable: row.notnull === 0,\n      defaultValue: this.parseDefaultValue(row.dflt_value),\n      isPrimaryKey: row.pk > 0,\n      isAutoIncrement: row.pk > 0 && row.type.toUpperCase() === 'INTEGER',\n      isUnique: uniqueColumns.has(row.name),\n      length: this.extractLength(row.type),\n      precision: undefined,\n      scale: undefined,\n      comment: undefined, // SQLite doesn't support column comments\n    }));\n  }\n\n  private async getUniqueColumns(querier: SqlQuerier, tableName: string): Promise<Set<string>> {\n    const sql = `PRAGMA index_list(${this.escapeId(tableName)})`;\n\n    const indexes = await querier.all<{\n      seq: number;\n      name: string;\n      unique: number;\n      origin: string;\n      partial: number;\n    }>(sql);\n\n    const uniqueColumns = new Set<string>();\n\n    for (const index of indexes) {\n      if (index.unique && index.origin === 'u') {\n        const indexInfo = await querier.all<{ name: string }>(`PRAGMA index_info(${this.escapeId(index.name)})`);\n        // Only single-column unique constraints\n        if (indexInfo.length === 1) {\n          uniqueColumns.add(indexInfo[0].name);\n        }\n      }\n    }\n\n    return uniqueColumns;\n  }\n\n  private async getIndexes(querier: SqlQuerier, tableName: string): Promise<IndexSchema[]> {\n    const sql = `PRAGMA index_list(${this.escapeId(tableName)})`;\n\n    const indexes = await querier.all<{\n      seq: number;\n      name: string;\n      unique: number;\n      origin: string;\n      partial: number;\n    }>(sql);\n\n    const result: IndexSchema[] = [];\n\n    for (const index of indexes) {\n      // Skip auto-generated indexes (primary key, unique constraints)\n      if (index.origin !== 'c') {\n        continue;\n      }\n\n      const columns = await querier.all<{ name: string }>(`PRAGMA index_info(${this.escapeId(index.name)})`);\n\n      result.push({\n        name: index.name,\n        columns: columns.map((c: any) => c.name),\n        unique: Boolean(index.unique),\n      });\n    }\n\n    return result;\n  }\n\n  private async getForeignKeys(querier: SqlQuerier, tableName: string): Promise<ForeignKeySchema[]> {\n    const sql = `PRAGMA foreign_key_list(${this.escapeId(tableName)})`;\n\n    const results = await querier.all<{\n      id: number;\n      seq: number;\n      table: string;\n      from: string;\n      to: string;\n      on_update: string;\n      on_delete: string;\n      match: string;\n    }>(sql);\n\n    // Group by id to handle composite foreign keys\n    const grouped = new Map<number, typeof results>();\n    for (const row of results) {\n      const existing = grouped.get(row.id) ?? [];\n      existing.push(row);\n      grouped.set(row.id, existing);\n    }\n\n    return Array.from(grouped.entries()).map(([id, rows]) => {\n      const first = rows[0];\n      return {\n        name: `fk_${tableName}_${id}`,\n        columns: rows.map((r: any) => r.from),\n        referencedTable: first.table,\n        referencedColumns: rows.map((r: any) => r.to),\n        onDelete: this.normalizeReferentialAction(first.on_delete),\n        onUpdate: this.normalizeReferentialAction(first.on_update),\n      };\n    });\n  }\n\n  private async getPrimaryKey(querier: SqlQuerier, tableName: string): Promise<string[] | undefined> {\n    const sql = `PRAGMA table_info(${this.escapeId(tableName)})`;\n\n    const results = await querier.all<{\n      cid: number;\n      name: string;\n      type: string;\n      notnull: number;\n      dflt_value: string | null;\n      pk: number;\n    }>(sql);\n\n    const pkColumns = results.filter((r: any) => r.pk > 0).sort((a: any, b: any) => a.pk - b.pk);\n\n    if (pkColumns.length === 0) {\n      return undefined;\n    }\n\n    return pkColumns.map((r: any) => r.name);\n  }\n\n  private escapeId(identifier: string): string {\n    return `\\`${identifier.replace(/`/g, '``')}\\``;\n  }\n\n  private normalizeType(type: string): string {\n    // Extract base type without length/precision\n    const match = type.match(/^([A-Za-z]+)/);\n    return match ? match[1].toUpperCase() : type.toUpperCase();\n  }\n\n  private extractLength(type: string): number | undefined {\n    const match = type.match(/\\((\\d+)\\)/);\n    return match ? Number.parseInt(match[1], 10) : undefined;\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' || defaultValue === 'CURRENT_DATE' || defaultValue === 'CURRENT_TIME') {\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"]}

package/dist/migrate/migrator-mongo.test.d.ts

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

package/dist/migrate/migrator-mongo.test.js

@@ -0,0 +1,54 @@
+import { __decorate, __metadata } from "tslib";
+import { beforeEach, describe, expect, it, jest } from 'bun:test';
+import { Entity, Field, Id } from '../entity/index.js';
+import { Migrator } from './migrator.js';
+let SyncMongoUser = class SyncMongoUser {
+    id;
+    name;
+};
+__decorate([
+    Id(),
+    __metadata("design:type", String)
+], SyncMongoUser.prototype, "id", void 0);
+__decorate([
+    Field({ index: true }),
+    __metadata("design:type", String)
+], SyncMongoUser.prototype, "name", void 0);
+SyncMongoUser = __decorate([
+    Entity()
+], SyncMongoUser);
+describe('Migrator autoSync MongoDB Integration', () => {
+    let migrator;
+    let pool;
+    let db;
+    beforeEach(() => {
+        db = {
+            listCollections: jest.fn().mockReturnValue({
+                toArray: jest.fn().mockResolvedValue([]),
+            }),
+            createCollection: jest.fn().mockResolvedValue({}),
+            collection: jest.fn().mockReturnValue({
+                indexes: jest.fn().mockResolvedValue([]),
+                createIndex: jest.fn().mockResolvedValue({}),
+            }),
+        };
+        const querier = {
+            db,
+            release: jest.fn().mockResolvedValue(undefined),
+        };
+        pool = {
+            getQuerier: jest.fn().mockResolvedValue(querier),
+            dialect: 'mongodb',
+        };
+        migrator = new Migrator(pool, {
+            entities: [SyncMongoUser],
+        });
+    });
+    it('should generate createCollection and createIndex for MongoDB', async () => {
+        await migrator.autoSync({ logging: true });
+        expect(db.createCollection).toHaveBeenCalledWith('SyncMongoUser');
+        expect(db.collection).toHaveBeenCalledWith('SyncMongoUser');
+        expect(db.collection('SyncMongoUser').createIndex).toHaveBeenCalledWith({ name: 1 }, expect.objectContaining({ name: 'idx_SyncMongoUser_name' }));
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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