@uql/core 1.0.12 → 3.1.0

package/src/migrate/introspection/postgresIntrospector.ts

@@ -0,0 +1,329 @@
+import type {
+  ColumnSchema,
+  ForeignKeySchema,
+  IndexSchema,
+  QuerierPool,
+  SchemaIntrospector,
+  SqlQuerier,
+  TableSchema,
+} from '../../type/index.js';
+import { isSqlQuerier } from '../../type/index.js';
+
+/**
+ * PostgreSQL schema introspector
+ */
+export class PostgresSchemaIntrospector implements SchemaIntrospector {
+  constructor(private readonly querierPool: QuerierPool) {}
+
+  async getTableSchema(tableName: string): Promise<TableSchema | undefined> {
+    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(): Promise<string[]> {
+    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<{ table_name: string }>(sql);
+      return results.map((r: any) => r.table_name);
+    } finally {
+      await querier.release();
+    }
+  }
+
+  async tableExists(tableName: string): Promise<boolean> {
+    const querier = await this.getQuerier();
+
+    try {
+      return this.tableExistsInternal(querier, tableName);
+    } finally {
+      await querier.release();
+    }
+  }
+
+  private async tableExistsInternal(querier: SqlQuerier, tableName: string): Promise<boolean> {
+    const sql = `
+      SELECT EXISTS (
+        SELECT FROM information_schema.tables
+        WHERE table_schema = 'public'
+          AND table_name = $1
+      ) AS exists
+    `;
+
+    const results = await querier.all<{ exists: boolean }>(sql, [tableName]);
+    return results[0]?.exists ?? false;
+  }
+
+  private async getQuerier(): Promise<SqlQuerier> {
+    const querier = await this.querierPool.getQuerier();
+
+    if (!isSqlQuerier(querier)) {
+      await querier.release();
+      throw new Error('PostgresSchemaIntrospector requires a SQL-based querier');
+    }
+
+    return querier;
+  }
+
+  private async getColumns(querier: SqlQuerier, tableName: string): Promise<ColumnSchema[]> {
+    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<{
+      column_name: string;
+      data_type: string;
+      udt_name: string;
+      is_nullable: string;
+      column_default: string | null;
+      character_maximum_length: number | null;
+      numeric_precision: number | null;
+      numeric_scale: number | null;
+      is_primary_key: boolean;
+      is_unique: boolean;
+      column_comment: string | null;
+    }>(sql, [tableName]);
+
+    return results.map((row: any) => ({
+      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,
+    }));
+  }
+
+  private async getIndexes(querier: SqlQuerier, tableName: string): Promise<IndexSchema[]> {
+    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<{
+      index_name: string;
+      columns: string[];
+      is_unique: boolean;
+    }>(sql, [tableName]);
+
+    return results.map((row: any) => ({
+      name: row.index_name,
+      columns: row.columns,
+      unique: row.is_unique,
+    }));
+  }
+
+  private async getForeignKeys(querier: SqlQuerier, tableName: string): Promise<ForeignKeySchema[]> {
+    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<{
+      constraint_name: string;
+      columns: string[];
+      referenced_table: string;
+      referenced_columns: string[];
+      delete_rule: string;
+      update_rule: string;
+    }>(sql, [tableName]);
+
+    return results.map((row: any) => ({
+      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),
+    }));
+  }
+
+  private async getPrimaryKey(querier: SqlQuerier, tableName: string): Promise<string[] | undefined> {
+    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<{ column_name: string }>(sql, [tableName]);
+
+    if (results.length === 0) {
+      return undefined;
+    }
+
+    return results.map((r: any) => r.column_name);
+  }
+
+  private normalizeType(dataType: string, udtName: string): string {
+    // Handle user-defined types and arrays
+    if (dataType === 'USER-DEFINED') {
+      return udtName.toUpperCase();
+    }
+    if (dataType === 'ARRAY') {
+      return `${udtName.replace(/^_/, '')}[]`;
+    }
+    return dataType.toUpperCase();
+  }
+
+  private parseDefaultValue(defaultValue: string | null): unknown {
+    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;
+  }
+
+  private isAutoIncrement(defaultValue: string | null): boolean {
+    if (!defaultValue) {
+      return false;
+    }
+    return defaultValue.includes('nextval(');
+  }
+
+  private normalizeReferentialAction(action: string): 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION' | undefined {
+    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;
+    }
+  }
+}

package/src/migrate/introspection/sqliteIntrospector.spec.ts

@@ -0,0 +1,112 @@
+import { beforeEach, describe, expect, it, jest } from 'bun:test';
+import type { QuerierPool, SqlQuerier } from '../../type/index.js';
+import { SqliteSchemaIntrospector } from './sqliteIntrospector.js';
+
+describe('SqliteSchemaIntrospector', () => {
+  let introspector: SqliteSchemaIntrospector;
+  let pool: QuerierPool;
+  let querier: SqlQuerier;
+
+  let mockAll: ReturnType<typeof jest.fn>;
+  let mockRun: ReturnType<typeof jest.fn>;
+  let mockRelease: ReturnType<typeof jest.fn>;
+  let mockGetQuerier: ReturnType<typeof jest.fn>;
+
+  beforeEach(() => {
+    mockAll = jest.fn<any>().mockResolvedValue([]);
+    mockRun = jest.fn<any>().mockResolvedValue({});
+    mockRelease = jest.fn<any>().mockResolvedValue(undefined);
+
+    querier = {
+      all: mockAll,
+      run: mockRun,
+      release: mockRelease,
+      dialect: { escapeIdChar: '`' },
+    } as any;
+
+    mockGetQuerier = jest.fn<any>().mockResolvedValue(querier);
+    pool = {
+      getQuerier: mockGetQuerier,
+    } as any;
+
+    introspector = new SqliteSchemaIntrospector(pool);
+  });
+
+  it('getTableNames should return a list of tables', async () => {
+    mockAll.mockResolvedValueOnce([{ name: 'users' }, { name: 'posts' }]);
+
+    const names = await introspector.getTableNames();
+
+    expect(names).toEqual(['users', 'posts']);
+    expect(querier.all).toHaveBeenCalledWith(expect.stringContaining('sqlite_master'));
+  });
+
+  it('getTableSchema should return table details', async () => {
+    mockAll.mockImplementation((async (sql: string, _values?: unknown[]) => {
+      const normalizedSql = sql.replace(/\s+/g, ' ').trim();
+      if (normalizedSql.includes('SELECT COUNT(*) as count FROM sqlite_master')) {
+        return [{ count: 1 }];
+      }
+      if (normalizedSql.includes('PRAGMA table_info')) {
+        return [
+          { cid: 0, name: 'id', type: 'INTEGER', notnull: 1, dflt_value: null as any, pk: 1 },
+          { cid: 1, name: 'username', type: 'VARCHAR(255)', notnull: 0, dflt_value: null as any, pk: 0 },
+        ];
+      }
+      if (normalizedSql.includes('PRAGMA index_list')) {
+        return [
+          { seq: 0, name: 'sqlite_autoindex_users_1', unique: 1, origin: 'u', partial: 0 },
+          { seq: 1, name: 'idx_users_username', unique: 0, origin: 'c', partial: 0 },
+        ];
+      }
+      if (normalizedSql.includes('PRAGMA index_info')) {
+        return [{ name: 'username' }];
+      }
+      if (normalizedSql.includes('PRAGMA foreign_key_list')) {
+        return [
+          {
+            id: 0,
+            seq: 0,
+            table: 'users',
+            from: 'author_id',
+            to: 'id',
+            on_update: 'CASCADE',
+            on_delete: 'RESTRICT',
+            match: 'NONE',
+          },
+        ];
+      }
+      return [];
+    }) as any);
+
+    const schema = await introspector.getTableSchema('users');
+
+    expect(schema).toBeDefined();
+    expect(schema?.name).toBe('users');
+    expect(schema?.columns).toHaveLength(2);
+    expect(schema?.columns[0]).toMatchObject({
+      name: 'id',
+      type: 'INTEGER',
+      nullable: false,
+      isAutoIncrement: true,
+      isPrimaryKey: true,
+    });
+    expect(schema?.columns[1]).toMatchObject({
+      name: 'username',
+      type: 'VARCHAR',
+      nullable: true,
+      isUnique: true,
+      length: 255,
+    });
+    expect(schema?.indexes).toHaveLength(1);
+    expect(schema?.indexes?.[0].name).toBe('idx_users_username');
+  });
+
+  it('getTableSchema should return undefined for non-existent table', async () => {
+    mockAll.mockResolvedValueOnce([{ count: 0 }]);
+
+    const schema = await introspector.getTableSchema('non_existent');
+
+    expect(schema).toBeUndefined();
+  });
+});