@uql/core 3.1.0 → 3.1.2

package/src/migrate/introspection/sqliteIntrospector.ts

@@ -1,296 +0,0 @@
-import type {
-  ColumnSchema,
-  ForeignKeySchema,
-  IndexSchema,
-  QuerierPool,
-  SchemaIntrospector,
-  SqlQuerier,
-  TableSchema,
-} from '../../type/index.js';
-import { isSqlQuerier } from '../../type/index.js';
-
-/**
- * SQLite schema introspector
- */
-export class SqliteSchemaIntrospector 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 = /*sql*/ `
-        SELECT name
-        FROM sqlite_master
-        WHERE type = 'table'
-          AND name NOT LIKE 'sqlite_%'
-        ORDER BY name
-      `;
-
-      const results = await querier.all<{ name: string }>(sql);
-      return results.map((r: any) => r.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 = /*sql*/ `
-      SELECT COUNT(*) as count
-      FROM sqlite_master
-      WHERE type = 'table'
-        AND 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('SqliteSchemaIntrospector requires a SQL-based querier');
-    }
-
-    return querier;
-  }
-
-  private async getColumns(querier: SqlQuerier, tableName: string): Promise<ColumnSchema[]> {
-    // SQLite uses PRAGMA for table info
-    const sql = `PRAGMA table_info(${this.escapeId(tableName)})`;
-
-    const results = await querier.all<{
-      cid: number;
-      name: string;
-      type: string;
-      notnull: number;
-      dflt_value: string | null;
-      pk: number;
-    }>(sql);
-
-    // Get unique columns from indexes
-    const uniqueColumns = await this.getUniqueColumns(querier, tableName);
-
-    return results.map((row: any) => ({
-      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
-    }));
-  }
-
-  private async getUniqueColumns(querier: SqlQuerier, tableName: string): Promise<Set<string>> {
-    const sql = `PRAGMA index_list(${this.escapeId(tableName)})`;
-
-    const indexes = await querier.all<{
-      seq: number;
-      name: string;
-      unique: number;
-      origin: string;
-      partial: number;
-    }>(sql);
-
-    const uniqueColumns = new Set<string>();
-
-    for (const index of indexes) {
-      if (index.unique && index.origin === 'u') {
-        const indexInfo = await querier.all<{ name: string }>(`PRAGMA index_info(${this.escapeId(index.name)})`);
-        // Only single-column unique constraints
-        if (indexInfo.length === 1) {
-          uniqueColumns.add(indexInfo[0].name);
-        }
-      }
-    }
-
-    return uniqueColumns;
-  }
-
-  private async getIndexes(querier: SqlQuerier, tableName: string): Promise<IndexSchema[]> {
-    const sql = `PRAGMA index_list(${this.escapeId(tableName)})`;
-
-    const indexes = await querier.all<{
-      seq: number;
-      name: string;
-      unique: number;
-      origin: string;
-      partial: number;
-    }>(sql);
-
-    const result: IndexSchema[] = [];
-
-    for (const index of indexes) {
-      // Skip auto-generated indexes (primary key, unique constraints)
-      if (index.origin !== 'c') {
-        continue;
-      }
-
-      const columns = await querier.all<{ name: string }>(`PRAGMA index_info(${this.escapeId(index.name)})`);
-
-      result.push({
-        name: index.name,
-        columns: columns.map((c: any) => c.name),
-        unique: Boolean(index.unique),
-      });
-    }
-
-    return result;
-  }
-
-  private async getForeignKeys(querier: SqlQuerier, tableName: string): Promise<ForeignKeySchema[]> {
-    const sql = `PRAGMA foreign_key_list(${this.escapeId(tableName)})`;
-
-    const results = await querier.all<{
-      id: number;
-      seq: number;
-      table: string;
-      from: string;
-      to: string;
-      on_update: string;
-      on_delete: string;
-      match: string;
-    }>(sql);
-
-    // Group by id to handle composite foreign keys
-    const grouped = new Map<number, typeof results>();
-    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: any) => r.from),
-        referencedTable: first.table,
-        referencedColumns: rows.map((r: any) => r.to),
-        onDelete: this.normalizeReferentialAction(first.on_delete),
-        onUpdate: this.normalizeReferentialAction(first.on_update),
-      };
-    });
-  }
-
-  private async getPrimaryKey(querier: SqlQuerier, tableName: string): Promise<string[] | undefined> {
-    const sql = `PRAGMA table_info(${this.escapeId(tableName)})`;
-
-    const results = await querier.all<{
-      cid: number;
-      name: string;
-      type: string;
-      notnull: number;
-      dflt_value: string | null;
-      pk: number;
-    }>(sql);
-
-    const pkColumns = results.filter((r: any) => r.pk > 0).sort((a: any, b: any) => a.pk - b.pk);
-
-    if (pkColumns.length === 0) {
-      return undefined;
-    }
-
-    return pkColumns.map((r: any) => r.name);
-  }
-
-  private escapeId(identifier: string): string {
-    return `\`${identifier.replace(/`/g, '``')}\``;
-  }
-
-  private normalizeType(type: string): string {
-    // Extract base type without length/precision
-    const match = type.match(/^([A-Za-z]+)/);
-    return match ? match[1].toUpperCase() : type.toUpperCase();
-  }
-
-  private extractLength(type: string): number | undefined {
-    const match = type.match(/\((\d+)\)/);
-    return match ? Number.parseInt(match[1], 10) : undefined;
-  }
-
-  private parseDefaultValue(defaultValue: string | null): unknown {
-    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;
-  }
-
-  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/migrator-mongo.test.ts

@@ -1,54 +0,0 @@
-import { beforeEach, describe, expect, it, jest } from 'bun:test';
-import { Entity, Field, Id } from '../entity/index.js';
-import type { QuerierPool } from '../type/index.js';
-import { Migrator } from './migrator.js';
-
-@Entity()
-class SyncMongoUser {
-  @Id() id?: string;
-  @Field({ index: true }) name?: string;
-}
-
-describe('Migrator autoSync MongoDB Integration', () => {
-  let migrator: Migrator;
-  let pool: QuerierPool;
-  let db: any;
-
-  beforeEach(() => {
-    db = {
-      listCollections: jest.fn<any>().mockReturnValue({
-        toArray: jest.fn<any>().mockResolvedValue([]),
-      }),
-      createCollection: jest.fn<any>().mockResolvedValue({}),
-      collection: jest.fn<any>().mockReturnValue({
-        indexes: jest.fn<any>().mockResolvedValue([]),
-        createIndex: jest.fn<any>().mockResolvedValue({}),
-      }),
-    };
-
-    const querier = {
-      db,
-      release: jest.fn<any>().mockResolvedValue(undefined),
-    };
-
-    pool = {
-      getQuerier: jest.fn<any>().mockResolvedValue(querier),
-      dialect: 'mongodb',
-    } as unknown as QuerierPool;
-
-    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' }),
-    );
-  });
-});

package/src/migrate/migrator.spec.ts

@@ -1,255 +0,0 @@
-import { beforeEach, describe, expect, it, jest, mock } from 'bun:test';
-import { Entity, Id } from '../entity/index.js';
-import type { Migration, MigrationStorage, QuerierPool, SqlQuerier } from '../type/index.js';
-import { MongoSchemaGenerator } from './generator/mongoSchemaGenerator.js';
-import { MysqlSchemaGenerator } from './generator/mysqlSchemaGenerator.js';
-import { PostgresSchemaGenerator } from './generator/postgresSchemaGenerator.js';
-import { SqliteSchemaGenerator } from './generator/sqliteSchemaGenerator.js';
-import { MongoSchemaIntrospector } from './introspection/mongoIntrospector.js';
-import { MysqlSchemaIntrospector } from './introspection/mysqlIntrospector.js';
-import { PostgresSchemaIntrospector } from './introspection/postgresIntrospector.js';
-import { SqliteSchemaIntrospector } from './introspection/sqliteIntrospector.js';
-import { Migrator } from './migrator.js';
-
-mock.module('node:fs/promises', () => ({
-  readdir: jest.fn<any>().mockResolvedValue([]) as any,
-  mkdir: jest.fn<any>().mockResolvedValue(undefined) as any,
-  writeFile: jest.fn<any>().mockResolvedValue(undefined) as any,
-}));
-
-describe('Migrator Core Methods', () => {
-  let migrator: Migrator;
-  let storage: MigrationStorage;
-  let pool: QuerierPool;
-  let querier: SqlQuerier;
-  let mockExecuted: ReturnType<typeof jest.fn>;
-
-  beforeEach(() => {
-    querier = {
-      beginTransaction: jest.fn<any>().mockResolvedValue(undefined),
-      commitTransaction: jest.fn<any>().mockResolvedValue(undefined),
-      rollbackTransaction: jest.fn<any>().mockResolvedValue(undefined),
-      release: jest.fn<any>().mockResolvedValue(undefined),
-      all: jest.fn<any>().mockResolvedValue([]),
-      run: jest.fn<any>().mockResolvedValue({}),
-      dialect: {
-        escapeIdChar: '"',
-      },
-    } as any;
-
-    pool = {
-      getQuerier: jest.fn<any>().mockResolvedValue(querier),
-      dialect: 'postgres',
-    } as any;
-
-    mockExecuted = jest.fn<any>().mockResolvedValue([]);
-    storage = {
-      executed: mockExecuted,
-      logWithQuerier: jest.fn<any>().mockResolvedValue(undefined),
-      unlogWithQuerier: jest.fn<any>().mockResolvedValue(undefined),
-      ensureStorage: jest.fn<any>().mockResolvedValue(undefined),
-    } as any;
-
-    migrator = new Migrator(pool, { storage });
-
-    // Mock getMigrations to return some dummy migrations
-    const mockMigrations: Migration[] = [
-      {
-        name: '20250101000000_m1',
-        up: jest.fn<any>().mockResolvedValue(undefined),
-        down: jest.fn<any>().mockResolvedValue(undefined),
-      },
-      {
-        name: '20250102000000_m2',
-        up: jest.fn<any>().mockResolvedValue(undefined),
-        down: jest.fn<any>().mockResolvedValue(undefined),
-      },
-      {
-        name: '20250103000000_m3',
-        up: jest.fn<any>().mockResolvedValue(undefined),
-        down: jest.fn<any>().mockResolvedValue(undefined),
-      },
-    ];
-    jest.spyOn(migrator, 'getMigrations').mockResolvedValue(mockMigrations);
-  });
-
-  it('pending should return non-executed migrations', async () => {
-    mockExecuted.mockResolvedValue(['20250101000000_m1']);
-
-    const pending = await migrator.pending();
-
-    expect(pending).toHaveLength(2);
-    expect(pending[0].name).toBe('20250102000000_m2');
-    expect(pending[1].name).toBe('20250103000000_m3');
-  });
-
-  it('up should run all pending migrations', async () => {
-    mockExecuted.mockResolvedValue(['20250101000000_m1']);
-
-    const results = await migrator.up();
-
-    expect(results).toHaveLength(2);
-    expect(results[0].name).toBe('20250102000000_m2');
-    expect(results[1].name).toBe('20250103000000_m3');
-
-    const migrations = await migrator.getMigrations();
-    expect(migrations[1].up).toHaveBeenCalled();
-    expect(migrations[2].up).toHaveBeenCalled();
-    expect(storage.logWithQuerier).toHaveBeenCalledTimes(2);
-  });
-
-  it('up to a specific migration', async () => {
-    mockExecuted.mockResolvedValue([]);
-
-    const results = await migrator.up({ to: '20250102000000_m2' });
-
-    expect(results).toHaveLength(2);
-    expect(results[0].name).toBe('20250101000000_m1');
-    expect(results[1].name).toBe('20250102000000_m2');
-  });
-
-  it('down should rollback the last migration', async () => {
-    mockExecuted.mockResolvedValue(['20250101000000_m1', '20250102000000_m2']);
-
-    const results = await migrator.down({ step: 1 });
-
-    expect(results).toHaveLength(1);
-    expect(results[0].name).toBe('20250102000000_m2');
-
-    const migrations = await migrator.getMigrations();
-    expect(migrations[1].down).toHaveBeenCalled();
-    expect(storage.unlogWithQuerier).toHaveBeenCalledTimes(1);
-  });
-
-  it('down to a specific migration', async () => {
-    mockExecuted.mockResolvedValue(['20250101000000_m1', '20250102000000_m2', '20250103000000_m3']);
-
-    // From current state to m1 (inclusive), so roll back m3 and m2
-    const results = await migrator.down({ to: '20250102000000_m2' });
-
-    expect(results).toHaveLength(2);
-    expect(results[0].name).toBe('20250103000000_m3');
-    expect(results[1].name).toBe('20250102000000_m2');
-  });
-
-  it('generateFromEntities should create a migration file', async () => {
-    @Entity()
-    class DummyEntity {
-      @Id() id?: number;
-    }
-
-    migrator = new Migrator(pool, { entities: [DummyEntity] });
-    jest.spyOn(migrator, 'getMigrations').mockResolvedValue([]);
-
-    const generator = {
-      resolveTableName: jest.fn<any>().mockReturnValue('DiffUser'),
-      diffSchema: jest.fn<any>().mockReturnValue({
-        tableName: 'DiffUser',
-        type: 'alter',
-        columnsToAdd: [{ name: 'age', type: 'INTEGER' }],
-      }),
-      generateAlterTable: jest.fn<any>().mockReturnValue(['ALTER TABLE "DiffUser" ADD COLUMN "age" INTEGER;']),
-      generateAlterTableDown: jest.fn<any>().mockReturnValue(['ALTER TABLE "DiffUser" DROP COLUMN "age";']),
-    };
-    migrator.setSchemaGenerator(generator as any);
-
-    const introspector = {
-      getTableSchema: jest.fn<any>().mockResolvedValue({ name: 'DiffUser', columns: [] }),
-      getTableNames: jest.fn<any>().mockResolvedValue([]),
-      tableExists: jest.fn<any>().mockResolvedValue(true),
-    };
-    migrator.schemaIntrospector = introspector as any;
-
-    const { mkdir, writeFile } = await import('node:fs/promises');
-
-    const filePath = await migrator.generateFromEntities('add_age');
-
-    expect(filePath).not.toBe('');
-    expect(filePath).toContain('add_age.ts');
-    expect(mkdir).toHaveBeenCalled();
-    expect(writeFile).toHaveBeenCalledWith(
-      expect.any(String),
-      expect.stringContaining('ALTER TABLE "DiffUser" ADD COLUMN "age" INTEGER;'),
-      'utf-8',
-    );
-  });
-
-  it('status should return pending and executed migrations', async () => {
-    mockExecuted.mockResolvedValue(['20250101000000_m1']);
-
-    const status = await migrator.status();
-
-    expect(status.pending).toEqual(['20250102000000_m2', '20250103000000_m3']);
-    expect(status.executed).toEqual(['20250101000000_m1']);
-  });
-
-  it('sync should call autoSync by default', async () => {
-    const autoSyncSpy = jest.spyOn(migrator, 'autoSync').mockResolvedValue(undefined);
-    await migrator.sync();
-    expect(autoSyncSpy).toHaveBeenCalledWith({ safe: true });
-  });
-
-  it('syncForce should drop and create tables', async () => {
-    @Entity()
-    class SyncEntity {
-      @Id() id?: number;
-    }
-    migrator = new Migrator(pool, { entities: [SyncEntity] });
-
-    const generator = {
-      resolveTableName: jest.fn<any>().mockReturnValue('SyncEntity'),
-      generateDropTable: jest.fn<any>().mockReturnValue('DROP TABLE "SyncEntity"'),
-      generateCreateTable: jest.fn<any>().mockReturnValue('CREATE TABLE "SyncEntity"'),
-      generateAlterTable: jest.fn<any>(),
-      generateAlterTableDown: jest.fn<any>(),
-      diffSchema: jest.fn<any>(),
-    };
-    migrator.setSchemaGenerator(generator as any);
-
-    await migrator.syncForce();
-
-    expect(querier.run).toHaveBeenCalledWith('DROP TABLE "SyncEntity"');
-    expect(querier.run).toHaveBeenCalledWith('CREATE TABLE "SyncEntity"');
-    expect(querier.commitTransaction).toHaveBeenCalled();
-  });
-
-  describe('Dialect Auto-Inference', () => {
-    it('should infer Postgres generator and introspector', () => {
-      const m = new Migrator(pool);
-      expect((m as any).schemaGenerator).toBeInstanceOf(PostgresSchemaGenerator);
-      expect((m as any).schemaIntrospector).toBeInstanceOf(PostgresSchemaIntrospector);
-    });
-
-    it('should infer MySQL generator and introspector', () => {
-      const mysqlPool = { ...pool, dialect: 'mysql' };
-      const m = new Migrator(mysqlPool as any);
-      expect((m as any).schemaGenerator).toBeInstanceOf(MysqlSchemaGenerator);
-      expect((m as any).schemaIntrospector).toBeInstanceOf(MysqlSchemaIntrospector);
-    });
-
-    it('should infer SQLite generator and introspector', () => {
-      const sqlitePool = { ...pool, dialect: 'sqlite' };
-      const m = new Migrator(sqlitePool as any);
-      expect((m as any).schemaGenerator).toBeInstanceOf(SqliteSchemaGenerator);
-      expect((m as any).schemaIntrospector).toBeInstanceOf(SqliteSchemaIntrospector);
-    });
-
-    it('should infer MongoDB generator and introspector', () => {
-      const mongoPool = { ...pool, dialect: 'mongodb' };
-      const m = new Migrator(mongoPool as any);
-      expect((m as any).schemaGenerator).toBeInstanceOf(MongoSchemaGenerator);
-      expect((m as any).schemaIntrospector).toBeInstanceOf(MongoSchemaIntrospector);
-    });
-
-    it('should allow overriding dialect in options', () => {
-      const m = new Migrator(pool, { dialect: 'mysql' });
-      expect((m as any).schemaGenerator).toBeInstanceOf(MysqlSchemaGenerator);
-    });
-
-    it('should allow overriding generator in options', () => {
-      const customGenerator = {} as any;
-      const m = new Migrator(pool, { dialect: 'postgres', schemaGenerator: customGenerator });
-      expect((m as any).schemaGenerator).toBe(customGenerator);
-    });
-  });
-});

package/src/migrate/migrator.test.ts

@@ -1,94 +0,0 @@
-import { beforeEach, describe, expect, it, jest } from 'bun:test';
-import { Entity, Field, Id } from '../entity/index.js';
-import type { QuerierPool, SqlQuerier, TableSchema } from '../type/index.js';
-import { Migrator } from './migrator.js';
-
-@Entity()
-class SyncUser {
-  @Id() id?: number;
-  @Field() name?: string;
-}
-
-@Entity()
-class SyncProfile {
-  @Id() id?: number;
-  @Field() bio?: string;
-  @Field({ reference: () => SyncUser }) userId?: number;
-}
-
-describe('Migrator autoSync Integration', () => {
-  let migrator: Migrator;
-  let pool: QuerierPool;
-
-  beforeEach(() => {
-    // Mock pool and querier for testing
-    const querier = {
-      run: jest.fn<any>().mockResolvedValue({}),
-      all: jest.fn<any>().mockResolvedValue([]),
-      beginTransaction: jest.fn<any>().mockResolvedValue(undefined),
-      commitTransaction: jest.fn<any>().mockResolvedValue(undefined),
-      rollbackTransaction: jest.fn<any>().mockResolvedValue(undefined),
-      release: jest.fn<any>().mockResolvedValue(undefined),
-      dialect: {
-        escapeIdChar: '"',
-        placeholder: jest.fn<any>().mockReturnValue('?'),
-      },
-    };
-    pool = {
-      getQuerier: jest.fn<any>().mockResolvedValue(querier),
-      dialect: 'postgres',
-    } as unknown as QuerierPool;
-
-    migrator = new Migrator(pool, {
-      entities: [SyncUser, SyncProfile],
-    });
-  });
-
-  it('should generate create statements for new tables', async () => {
-    // Mock introspector to return nothing
-    const introspector = {
-      getTableSchema: jest.fn<any>().mockResolvedValue(undefined),
-      getTableNames: jest.fn<any>().mockResolvedValue([]),
-      tableExists: jest.fn<any>().mockResolvedValue(false),
-    };
-    migrator.schemaIntrospector = introspector as any;
-
-    await migrator.autoSync({ logging: true });
-
-    const querier = (await pool.getQuerier()) as SqlQuerier;
-    expect(querier.run).toHaveBeenCalledWith(expect.stringContaining('CREATE TABLE "SyncUser"'));
-    expect(querier.run).toHaveBeenCalledWith(expect.stringContaining('CREATE TABLE "SyncProfile"'));
-  });
-
-  it('should generate alter statements for missing columns', async () => {
-    // Mock introspector to return existing table with one column missing
-    const introspector = {
-      getTableSchema: jest.fn<any>().mockImplementation((name: any) => {
-        if (name === 'SyncUser') {
-          return Promise.resolve({
-            name: 'SyncUser',
-            columns: [
-              {
-                name: 'id',
-                type: 'INTEGER',
-                nullable: false,
-                isPrimaryKey: true,
-                isAutoIncrement: true,
-                isUnique: false,
-              },
-            ],
-          } as TableSchema);
-        }
-        return Promise.resolve(undefined);
-      }),
-    };
-    migrator.schemaIntrospector = introspector as any;
-
-    await migrator.autoSync({ logging: true });
-
-    const querier = (await pool.getQuerier()) as SqlQuerier;
-    expect(querier.run).toHaveBeenCalledWith(
-      expect.stringContaining('ALTER TABLE "SyncUser" ADD COLUMN "name" VARCHAR(255)'),
-    );
-  });
-});