@uql/core 3.1.1 → 3.1.3

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

@@ -1,75 +0,0 @@
-import { beforeEach, describe, expect, it, jest } from 'bun:test';
-import type { MongoQuerier, QuerierPool } from '../../type/index.js';
-import { MongoSchemaIntrospector } from './mongoIntrospector.js';
-
-describe('MongoSchemaIntrospector', () => {
-  let introspector: MongoSchemaIntrospector;
-  let pool: QuerierPool;
-  let querier: MongoQuerier;
-  let db: any;
-
-  beforeEach(() => {
-    db = {
-      listCollections: jest.fn<any>().mockReturnValue({
-        toArray: jest.fn<any>().mockResolvedValue([]),
-      }),
-      collection: jest.fn<any>().mockReturnValue({
-        indexes: jest.fn<any>().mockResolvedValue([]),
-      }),
-    };
-
-    querier = {
-      db,
-      release: jest.fn<any>().mockResolvedValue(undefined) as any,
-    } as any;
-
-    pool = {
-      getQuerier: jest.fn<any>().mockResolvedValue(querier) as any,
-    } as any;
-
-    introspector = new MongoSchemaIntrospector(pool);
-  });
-
-  it('getTableNames should return collection names', async () => {
-    db.listCollections.mockReturnValueOnce({
-      toArray: jest.fn<any>().mockResolvedValue([{ name: 'users' }, { name: 'posts' }]),
-    });
-
-    const names = await introspector.getTableNames();
-
-    expect(names).toEqual(['users', 'posts']);
-  });
-
-  it('getTableSchema should return collection details', async () => {
-    db.listCollections.mockReturnValueOnce({
-      toArray: jest.fn<any>().mockResolvedValue([{ name: 'users' }]),
-    });
-    db.collection.mockReturnValueOnce({
-      indexes: jest.fn<any>().mockResolvedValue([
-        { name: '_id_', key: { _id: 1 } },
-        { name: 'idx_username', key: { username: 1 }, unique: true },
-      ]),
-    });
-
-    const schema = await introspector.getTableSchema('users');
-
-    expect(schema).toBeDefined();
-    expect(schema?.name).toBe('users');
-    expect(schema?.indexes).toHaveLength(2);
-    expect(schema?.indexes?.[1]).toMatchObject({
-      name: 'idx_username',
-      columns: ['username'],
-      unique: true,
-    });
-  });
-
-  it('getTableSchema should return undefined for non-existent collection', async () => {
-    db.listCollections.mockReturnValueOnce({
-      toArray: jest.fn<any>().mockResolvedValue([]),
-    });
-
-    const schema = await introspector.getTableSchema('non_existent');
-
-    expect(schema).toBeUndefined();
-  });
-});

package/src/migrate/introspection/mongoIntrospector.ts

@@ -1,47 +0,0 @@
-import type { MongoQuerier, QuerierPool, SchemaIntrospector, TableSchema } from '../../type/index.js';
-
-export class MongoSchemaIntrospector implements SchemaIntrospector {
-  constructor(private readonly querierPool: QuerierPool) {}
-
-  async getTableSchema(tableName: string): Promise<TableSchema | undefined> {
-    const querier = await this.querierPool.getQuerier();
-    try {
-      const { db } = querier as MongoQuerier;
-      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: any) => ({
-          name: idx.name,
-          columns: Object.keys(idx.key),
-          unique: !!idx.unique,
-        })),
-      };
-    } finally {
-      await querier.release();
-    }
-  }
-
-  async getTableNames(): Promise<string[]> {
-    const querier = await this.querierPool.getQuerier();
-    try {
-      const { db } = querier as MongoQuerier;
-      const collections = await db.listCollections().toArray();
-      return collections.map((c: any) => c.name);
-    } finally {
-      await querier.release();
-    }
-  }
-
-  async tableExists(tableName: string): Promise<boolean> {
-    const names = await this.getTableNames();
-    return names.includes(tableName);
-  }
-}

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

@@ -1,113 +0,0 @@
-import { beforeEach, describe, expect, it, jest } from 'bun:test';
-import type { QuerierPool, SqlQuerier } from '../../type/index.js';
-import { MysqlSchemaIntrospector } from './mysqlIntrospector.js';
-
-describe('MysqlSchemaIntrospector', () => {
-  let introspector: MysqlSchemaIntrospector;
-  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 MysqlSchemaIntrospector(pool);
-  });
-
-  it('getTableNames should return a list of tables', async () => {
-    mockAll.mockResolvedValueOnce([{ table_name: 'users' }, { table_name: 'posts' }]);
-
-    const names = await introspector.getTableNames();
-
-    expect(names).toEqual(['users', 'posts']);
-    expect(querier.all).toHaveBeenCalledWith(expect.stringContaining('information_schema.TABLES'));
-  });
-
-  it('getTableSchema should return table details', async () => {
-    // 1. tableExists check
-    mockAll.mockResolvedValueOnce([{ count: 1 }]);
-    // 2. getColumns
-    mockAll.mockResolvedValueOnce([
-      {
-        column_name: 'id',
-        data_type: 'int',
-        column_type: 'int(11)',
-        is_nullable: 'NO',
-        column_default: null,
-        character_maximum_length: null,
-        numeric_precision: 10,
-        numeric_scale: 0,
-        column_key: 'PRI',
-        extra: 'auto_increment',
-        column_comment: 'User ID',
-      },
-      {
-        column_name: 'email',
-        data_type: 'varchar',
-        column_type: 'varchar(255)',
-        is_nullable: 'YES',
-        column_default: null,
-        character_maximum_length: 255,
-        numeric_precision: null,
-        numeric_scale: null,
-        column_key: 'UNI',
-        extra: '',
-        column_comment: null,
-      },
-    ]);
-    // 3. getIndexes
-    mockAll.mockResolvedValueOnce([
-      {
-        index_name: 'email_unique',
-        columns: 'email',
-        is_unique: 1,
-      },
-    ]);
-    // 4. getForeignKeys
-    mockAll.mockResolvedValueOnce([]);
-    // 5. getPrimaryKey
-    mockAll.mockResolvedValueOnce([{ column_name: 'id' }]);
-
-    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: 'INT',
-      nullable: false,
-      isAutoIncrement: true,
-      isPrimaryKey: true,
-    });
-    expect(schema?.indexes).toHaveLength(1);
-    expect(schema?.indexes?.[0].name).toBe('email_unique');
-    expect(schema?.indexes?.[0].unique).toBe(true);
-  });
-
-  it('getTableSchema should return undefined for non-existent table', async () => {
-    mockAll.mockResolvedValueOnce([{ count: 0 }]);
-
-    const schema = await introspector.getTableSchema('non_existent');
-
-    expect(schema).toBeUndefined();
-  });
-});

package/src/migrate/introspection/mysqlIntrospector.ts

@@ -1,278 +0,0 @@
-import type {
-  ColumnSchema,
-  ForeignKeySchema,
-  IndexSchema,
-  QuerierPool,
-  SchemaIntrospector,
-  SqlQuerier,
-  TableSchema,
-} from '../../type/index.js';
-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 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 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<{ 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 COUNT(*) as count
-      FROM information_schema.TABLES
-      WHERE TABLE_SCHEMA = DATABASE()
-        AND TABLE_NAME = ?
-    `;
-
-    const results = await querier.all<{ count: number }>(sql, [tableName]);
-    return (results[0]?.count ?? 0) > 0;
-  }
-
-  private async getQuerier(): Promise<SqlQuerier> {
-    const querier = await this.querierPool.getQuerier();
-
-    if (!isSqlQuerier(querier)) {
-      await querier.release();
-      throw new Error('MysqlSchemaIntrospector requires a SQL-based querier');
-    }
-
-    return querier;
-  }
-
-  private async getColumns(querier: SqlQuerier, tableName: string): Promise<ColumnSchema[]> {
-    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<{
-      column_name: string;
-      data_type: string;
-      column_type: string;
-      is_nullable: string;
-      column_default: string | null;
-      character_maximum_length: number | null;
-      numeric_precision: number | null;
-      numeric_scale: number | null;
-      column_key: string;
-      extra: string;
-      column_comment: string | null;
-    }>(sql, [tableName]);
-
-    return results.map((row: any) => ({
-      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,
-    }));
-  }
-
-  private async getIndexes(querier: SqlQuerier, tableName: string): Promise<IndexSchema[]> {
-    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<{
-      index_name: string;
-      columns: string;
-      is_unique: number;
-    }>(sql, [tableName]);
-
-    return results.map((row: any) => ({
-      name: row.index_name,
-      columns: row.columns.split(','),
-      unique: Boolean(row.is_unique),
-    }));
-  }
-
-  private async getForeignKeys(querier: SqlQuerier, tableName: string): Promise<ForeignKeySchema[]> {
-    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<{
-      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.split(','),
-      referencedTable: row.referenced_table,
-      referencedColumns: row.referenced_columns.split(','),
-      onDelete: this.normalizeReferentialAction(row.delete_rule),
-      onUpdate: this.normalizeReferentialAction(row.update_rule),
-    }));
-  }
-
-  private async getPrimaryKey(querier: SqlQuerier, tableName: string): Promise<string[] | undefined> {
-    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<{ column_name: string }>(sql, [tableName]);
-
-    if (results.length === 0) {
-      return undefined;
-    }
-
-    return results.map((r: any) => r.column_name);
-  }
-
-  private parseDefaultValue(defaultValue: string | null): unknown {
-    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;
-  }
-
-  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;
-    }
-  }
-}
-
-/**
- * Alias for MysqlSchemaIntrospector.
- * MariaDB uses the same information_schema structure as MySQL.
- */
-export const MariadbSchemaIntrospector = MysqlSchemaIntrospector;

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

@@ -1,112 +0,0 @@
-import { beforeEach, describe, expect, it, jest } from 'bun:test';
-import type { QuerierPool, SqlQuerier } from '../../type/index.js';
-import { PostgresSchemaIntrospector } from './postgresIntrospector.js';
-
-describe('PostgresSchemaIntrospector', () => {
-  let introspector: PostgresSchemaIntrospector;
-  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 PostgresSchemaIntrospector(pool);
-  });
-
-  it('getTableNames should return a list of tables', async () => {
-    mockAll.mockResolvedValueOnce([{ table_name: 'users' }, { table_name: 'posts' }]);
-
-    const names = await introspector.getTableNames();
-
-    expect(names).toEqual(['users', 'posts']);
-    expect(querier.all).toHaveBeenCalledWith(expect.stringContaining('information_schema.tables'));
-  });
-
-  it('getTableSchema should return table details', async () => {
-    // 1. tableExists check
-    mockAll.mockResolvedValueOnce([{ exists: true }]);
-    // 2. getColumns
-    mockAll.mockResolvedValueOnce([
-      {
-        column_name: 'id',
-        data_type: 'integer',
-        udt_name: 'int4',
-        is_nullable: 'NO',
-        column_default: "nextval('users_id_seq'::regclass)",
-        character_maximum_length: null,
-        numeric_precision: 32,
-        numeric_scale: 0,
-        is_primary_key: true,
-        is_unique: false,
-        column_comment: 'User ID',
-      },
-      {
-        column_name: 'name',
-        data_type: 'character varying',
-        udt_name: 'varchar',
-        is_nullable: 'YES',
-        column_default: null,
-        character_maximum_length: 255,
-        numeric_precision: null,
-        numeric_scale: null,
-        is_primary_key: false,
-        is_unique: false,
-        column_comment: null,
-      },
-    ]);
-    // 3. getIndexes
-    mockAll.mockResolvedValueOnce([
-      {
-        index_name: 'idx_users_name',
-        columns: ['name'],
-        is_unique: false,
-      },
-    ]);
-    // 4. getForeignKeys
-    mockAll.mockResolvedValueOnce([]);
-    // 5. getPrimaryKey
-    mockAll.mockResolvedValueOnce([{ column_name: 'id' }]);
-
-    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?.indexes).toHaveLength(1);
-    expect(schema?.indexes?.[0].name).toBe('idx_users_name');
-  });
-
-  it('getTableSchema should return undefined for non-existent table', async () => {
-    mockAll.mockResolvedValueOnce([{ exists: false }]);
-
-    const schema = await introspector.getTableSchema('non_existent');
-
-    expect(schema).toBeUndefined();
-  });
-});