@rangka/core 0.1.1 → 0.1.3

package/src/db/auto-sync.ts

@@ -1,133 +0,0 @@
-import type { Kysely } from 'kysely';
-import { sql } from 'kysely';
-import type { SchemaRegistry } from '../schema/registry.js';
-import type { DdlOperation } from './types.js';
-import { SchemaToDesired } from './desired-state.js';
-import { DiffEngine } from './diff-engine.js';
-import { introspect } from './introspect.js';
-
-export interface AutoSyncOptions {
-  allowDestructive?: boolean;
-}
-
-export interface AutoSyncResult {
-  applied: DdlOperation[];
-  warnings: DdlOperation[];
-}
-
-/**
- * Compares the desired schema (from the registry) against the actual database state
- * and applies any DDL operations needed to bring the database in sync.
- */
-export async function autoSync(
-  registry: SchemaRegistry,
-  db: Kysely<unknown>,
-  options: AutoSyncOptions = {},
-): Promise<AutoSyncResult> {
-  const desired = new SchemaToDesired().convert(registry);
-  const actual = await introspect(db);
-  const operations = new DiffEngine().diff(desired, actual);
-
-  if (operations.length === 0) {
-    console.log(`[rangka:sync] Schema is up to date`);
-    return { applied: [], warnings: [] };
-  }
-
-  const applied: DdlOperation[] = [];
-  const warnings: DdlOperation[] = [];
-
-  for (const op of operations) {
-    if (op.destructive) {
-      await handleDestructiveOp(op, options, applied, warnings, db);
-    } else {
-      await applyOperation(op, db);
-      applied.push(op);
-    }
-  }
-
-  if (applied.length > 0) {
-    console.log(`[rangka:sync] Applied ${applied.length} operation(s):`);
-    for (const op of applied) {
-      console.log(`  ${formatOperation(op)}`);
-    }
-  }
-
-  if (warnings.length > 0) {
-    console.warn(`[rangka:sync] ${warnings.length} skipped (destructive):`);
-    for (const op of warnings) {
-      console.warn(`  ${formatOperation(op)}`);
-    }
-  }
-
-  return { applied, warnings };
-}
-
-/** Apply a non-destructive DDL operation. */
-async function applyOperation(op: DdlOperation, db: Kysely<unknown>): Promise<void> {
-  await sql.raw(op.sql).execute(db);
-}
-
-/**
- * Handle a destructive operation: apply it if allowed, otherwise log a warning.
- */
-async function handleDestructiveOp(
-  op: DdlOperation,
-  options: AutoSyncOptions,
-  applied: DdlOperation[],
-  warnings: DdlOperation[],
-  db: Kysely<unknown>,
-): Promise<void> {
-  if (options.allowDestructive) {
-    const ddlSql = generateDestructiveSql(op);
-    await sql.raw(ddlSql).execute(db);
-    applied.push(op);
-  } else {
-    warnings.push(op);
-  }
-}
-
-function formatOperation(op: DdlOperation): string {
-  switch (op.type) {
-    case 'CREATE_TABLE':
-      return `+ table ${op.table}`;
-    case 'ADD_COLUMN':
-      return `+ column ${op.table}.${extractColumnFromSql(op.sql)}`;
-    case 'ALTER_COLUMN_TYPE':
-      return `~ column type ${op.table}.${extractColumnFromSql(op.sql)}`;
-    case 'CREATE_INDEX':
-      return `+ index on ${op.table}`;
-    case 'ADD_FOREIGN_KEY':
-      return `+ foreign key on ${op.table}`;
-    case 'ADD_CHECK_CONSTRAINT':
-      return `+ check constraint on ${op.table}`;
-    case 'DROP_TABLE':
-      return `- table ${op.table} (orphaned)`;
-    case 'DROP_COLUMN':
-      return `- column ${op.detail ?? op.table} (orphaned)`;
-    default:
-      return `${op.type} on ${op.table}`;
-  }
-}
-
-function extractColumnFromSql(s: string): string {
-  const match = s.match(/COLUMN "([^"]+)"/i) ?? s.match(/COLUMN\s+(\S+)/i);
-  return match ? match[1] : 'unknown';
-}
-
-/** Generate the raw SQL for a destructive operation (DROP COLUMN / DROP TABLE). */
-function generateDestructiveSql(op: DdlOperation): string {
-  switch (op.type) {
-    case 'DROP_COLUMN': {
-      const match = op.detail?.match(/Orphaned column: (.+)\.(.+)/);
-      if (match) return `ALTER TABLE "${match[1]}" DROP COLUMN "${match[2]}"`;
-      return op.sql;
-    }
-    case 'DROP_TABLE': {
-      const match = op.detail?.match(/Orphaned table: (.+)/);
-      if (match) return `DROP TABLE "${match[1]}"`;
-      return op.sql;
-    }
-    default:
-      return op.sql;
-  }
-}

package/src/db/client.ts

@@ -1,147 +0,0 @@
-import { Kysely, PostgresDialect } from 'kysely';
-import pg from 'pg';
-import type { SchemaRegistry } from '../schema/registry.js';
-import { modelToTableName } from './field-mapper.js';
-
-export interface DatabaseClientConfig {
-  host: string;
-  port?: number;
-  database: string;
-  user: string;
-  password: string;
-  pool?: {
-    min?: number;
-    max?: number;
-  };
-}
-
-/**
- * Thin wrapper around Kysely that resolves qualified model names
- * (e.g. "sales.Invoice") to their underlying table names automatically.
- */
-export class DatabaseClient {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private readonly db: Kysely<any>;
-  private readonly pool: pg.Pool;
-  private readonly qualifiedNameToTable: Map<string, string>;
-
-  constructor(config: DatabaseClientConfig, registry?: SchemaRegistry) {
-    this.pool = this.createPool(config);
-    this.db = new Kysely({ dialect: new PostgresDialect({ pool: this.pool }) });
-    this.qualifiedNameToTable = this.buildTableNameMap(registry);
-  }
-
-  /**
-   * Verify the database connection is reachable.
-   * Throws with actionable diagnostics if it cannot connect.
-   */
-  async verifyConnection(): Promise<void> {
-    let client: pg.PoolClient | undefined;
-    try {
-      client = await this.pool.connect();
-      await client.query('SELECT 1');
-    } catch (err: unknown) {
-      const pgErr = err as { code?: string; message?: string };
-      const detail = formatConnectionError(pgErr, this.pool);
-      throw new Error(`Database connection failed: ${detail}`, { cause: err });
-    } finally {
-      client?.release();
-    }
-  }
-
-  // --- Query builders (resolve model name to table name automatically) ---
-
-  selectFrom(model: string) {
-    return this.db.selectFrom(this.resolveTable(model));
-  }
-
-  insertInto(model: string) {
-    return this.db.insertInto(this.resolveTable(model));
-  }
-
-  updateTable(model: string) {
-    return this.db.updateTable(this.resolveTable(model));
-  }
-
-  deleteFrom(model: string) {
-    return this.db.deleteFrom(this.resolveTable(model));
-  }
-
-  /** Execute a callback within a database transaction. */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  async transaction<T>(callback: (trx: Kysely<any>) => Promise<T>): Promise<T> {
-    return this.db.transaction().execute(callback);
-  }
-
-  /** Direct access to the underlying Kysely instance. */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  get kysely(): Kysely<any> {
-    return this.db;
-  }
-
-  /** Close the connection pool and release resources. */
-  async destroy(): Promise<void> {
-    await this.db.destroy();
-  }
-
-  // --- Private helpers ---
-
-  /** Maps a qualified model name to its table name, falling back to the raw input. */
-  private resolveTable(nameOrQualified: string): string {
-    return this.qualifiedNameToTable.get(nameOrQualified) ?? nameOrQualified;
-  }
-
-  /** Create the underlying pg connection pool. */
-  private createPool(config: DatabaseClientConfig): pg.Pool {
-    return new pg.Pool({
-      host: config.host,
-      port: config.port ?? 5432,
-      database: config.database,
-      user: config.user,
-      password: config.password,
-      min: config.pool?.min ?? 2,
-      max: config.pool?.max ?? 10,
-    });
-  }
-
-  /** Pre-compute the mapping from qualified model names to SQL table names. */
-  private buildTableNameMap(registry?: SchemaRegistry): Map<string, string> {
-    const map = new Map<string, string>();
-    if (registry) {
-      for (const model of registry.getAllModels()) {
-        map.set(model.qualifiedName, modelToTableName(model.qualifiedName));
-      }
-    }
-    return map;
-  }
-}
-
-function formatConnectionError(err: { code?: string; message?: string }, pool: pg.Pool): string {
-  const opts = (pool as unknown as { options: pg.PoolConfig }).options;
-  const host = opts.host ?? 'localhost';
-  const port = opts.port ?? 5432;
-  const database = opts.database ?? '(unknown)';
-
-  switch (err.code) {
-    case 'ECONNREFUSED':
-      return (
-        `Could not connect to PostgreSQL at ${host}:${port}. ` +
-        `Is the server running and accepting connections?`
-      );
-    case 'ENOTFOUND':
-      return `Host "${host}" not found. Check the database host configuration.`;
-    case 'ETIMEDOUT':
-      return (
-        `Connection to ${host}:${port} timed out. ` +
-        `Check network connectivity and firewall rules.`
-      );
-    case '3D000':
-      return `Database "${database}" does not exist on ${host}:${port}.`;
-    case '28P01':
-      return `Authentication failed for user "${opts.user ?? '(unknown)'}". Check credentials.`;
-    case '28000':
-      return `Authorization failed for user "${opts.user ?? '(unknown)'}". Check pg_hba.conf or user permissions.`;
-    default:
-      return err.message ?? 'Unknown error';
-  }
-}

package/src/db/desired-state.ts

@@ -1,98 +0,0 @@
-import type { SchemaRegistry } from '../schema/registry.js';
-import type { ResolvedModel } from '../schema/types.js';
-import type { DesiredState, TableDefinition, IndexDefinition } from './types.js';
-import { mapFieldsToColumns, modelToTableName } from './field-mapper.js';
-import { getJobTables } from '../jobs/tables.js';
-
-/**
- * Converts the in-memory schema registry into the desired database state
- * (list of table definitions) used by the diff engine for migrations.
- */
-export class SchemaToDesired {
-  convert(registry: SchemaRegistry): DesiredState {
-    const tables: TableDefinition[] = [];
-    const models = registry.getAllModels();
-    let hasSequenceField = false;
-
-    for (const model of models) {
-      const { primaryTable, joinTables } = this.modelToTables(model);
-      tables.push(primaryTable);
-      tables.push(...joinTables);
-
-      if (model.fields.some((f) => f.config.type === 'sequence')) {
-        hasSequenceField = true;
-      }
-    }
-
-    // Add the naming_sequence helper table if any model uses sequence fields
-    if (hasSequenceField) {
-      tables.push(this.buildNamingSequenceTable());
-    }
-
-    // Always include the internal job queue tables
-    tables.push(...getJobTables());
-
-    return { tables };
-  }
-
-  /**
-   * Converts a single model into its primary table definition plus any
-   * extra join/pivot tables required by its fields.
-   */
-  private modelToTables(model: ResolvedModel): {
-    primaryTable: TableDefinition;
-    joinTables: TableDefinition[];
-  } {
-    const tableName = modelToTableName(model.qualifiedName);
-    const mapping = mapFieldsToColumns(model);
-    const indexes = this.buildIndexes(model, tableName);
-
-    const primaryTable: TableDefinition = {
-      name: tableName,
-      columns: mapping.columns,
-      foreignKeys: mapping.foreignKeys,
-      checkConstraints: mapping.checkConstraints,
-      indexes,
-    };
-
-    return { primaryTable, joinTables: mapping.extraTables };
-  }
-
-  /** Generates index definitions from a model's declared indexes. */
-  private buildIndexes(model: ResolvedModel, tableName: string): IndexDefinition[] {
-    if (!model.indexes || model.indexes.length === 0) return [];
-
-    return model.indexes.map((idx) => {
-      const prefix = idx.unique ? 'uidx' : 'idx';
-      const indexName = `${prefix}_${tableName}_${idx.fields.join('_')}`;
-      return {
-        name: indexName,
-        table: tableName,
-        columns: idx.fields,
-        unique: idx.unique ?? false,
-      };
-    });
-  }
-
-  /** Table definition for the naming_sequence counter table. */
-  private buildNamingSequenceTable(): TableDefinition {
-    return {
-      name: 'naming_sequence',
-      columns: [
-        { name: 'model', type: 'VARCHAR(255)', nullable: false },
-        { name: 'field', type: 'VARCHAR(255)', nullable: false },
-        { name: 'next_val', type: 'BIGINT', nullable: false, defaultValue: '1' },
-      ],
-      foreignKeys: [],
-      checkConstraints: [],
-      indexes: [
-        {
-          name: 'uidx_naming_sequence_key',
-          table: 'naming_sequence',
-          columns: ['model', 'field'],
-          unique: true,
-        },
-      ],
-    };
-  }
-}

package/src/db/diff-engine.ts

@@ -1,305 +0,0 @@
-import type {
-  DesiredState,
-  ActualState,
-  DdlOperation,
-  TableDefinition,
-  ActualTable,
-  ColumnDefinition,
-  ActualColumn,
-  IndexDefinition,
-  ActualIndex,
-  ForeignKeyDefinition,
-  ActualForeignKey,
-  CheckConstraintDefinition,
-  ActualCheckConstraint,
-} from './types.js';
-
-/**
- * Compares a desired schema state against the actual database state and
- * produces a sorted list of DDL operations needed to reconcile the two.
- */
-export class DiffEngine {
-  // --- Public API ---
-
-  /** Compute the full set of DDL operations to bring `actual` in line with `desired`. */
-  diff(desired: DesiredState, actual: ActualState): DdlOperation[] {
-    const operations: DdlOperation[] = [];
-    const actualTablesByName = new Map(actual.tables.map((t) => [t.name, t]));
-
-    // Generate operations for each desired table (create or update)
-    for (const desiredTable of desired.tables) {
-      const existingTable = actualTablesByName.get(desiredTable.name);
-      if (!existingTable) {
-        operations.push(...this.buildNewTableOperations(desiredTable));
-      } else {
-        operations.push(...this.diffTable(desiredTable, existingTable));
-      }
-    }
-
-    // Flag tables that exist in the database but not in the schema
-    for (const existingTable of actual.tables) {
-      const stillDesired = desired.tables.find((t) => t.name === existingTable.name);
-      if (!stillDesired) {
-        operations.push(this.warnOrphanedTable(existingTable.name));
-      }
-    }
-
-    return this.sortByDependencyOrder(operations);
-  }
-
-  // --- Table creation ---
-
-  /** Build all operations needed to create a brand new table (table + indexes + foreign keys + check constraints). */
-  private buildNewTableOperations(table: TableDefinition): DdlOperation[] {
-    return [
-      this.buildCreateTableOp(table),
-      ...table.indexes.map((idx) => this.buildCreateIndexOp(idx)),
-      ...table.foreignKeys.map((fk) => this.buildAddForeignKeyOp(table.name, fk)),
-    ];
-  }
-
-  /** Generate the CREATE TABLE DDL for a table definition. */
-  private buildCreateTableOp(table: TableDefinition): DdlOperation {
-    const columnClauses = table.columns.map((col) => this.columnToSql(col));
-
-    const primaryKeyColumn = table.columns.find((c) => c.primaryKey);
-    if (primaryKeyColumn) {
-      columnClauses.push(`PRIMARY KEY (${primaryKeyColumn.name})`);
-    }
-
-    for (const chk of table.checkConstraints) {
-      columnClauses.push(`CONSTRAINT "${chk.name}" CHECK (${chk.expression})`);
-    }
-
-    const sql = `CREATE TABLE "${table.name}" (\n  ${columnClauses.join(',\n  ')}\n)`;
-    return {
-      type: 'CREATE_TABLE',
-      table: table.name,
-      sql,
-      destructive: false,
-    };
-  }
-
-  // --- Table diffing (existing table vs desired) ---
-
-  /** Compare an existing table against its desired definition and produce update operations. */
-  private diffTable(desired: TableDefinition, actual: ActualTable): DdlOperation[] {
-    const operations: DdlOperation[] = [];
-
-    operations.push(...this.diffColumns(desired.name, desired.columns, actual.columns));
-    operations.push(...this.diffIndexes(desired.name, desired.indexes, actual.indexes));
-    operations.push(...this.diffForeignKeys(desired.name, desired.foreignKeys, actual.foreignKeys));
-    operations.push(
-      ...this.diffCheckConstraints(desired.name, desired.checkConstraints, actual.checkConstraints),
-    );
-
-    return operations;
-  }
-
-  /** Detect added columns, type changes, and orphaned columns. */
-  private diffColumns(
-    tableName: string,
-    desiredColumns: ColumnDefinition[],
-    actualColumns: ActualColumn[],
-  ): DdlOperation[] {
-    const operations: DdlOperation[] = [];
-    const actualColumnsByName = new Map(actualColumns.map((c) => [c.name, c]));
-    const desiredColumnNames = new Set(desiredColumns.map((c) => c.name));
-
-    for (const desiredCol of desiredColumns) {
-      const existingCol = actualColumnsByName.get(desiredCol.name);
-      if (!existingCol) {
-        operations.push(this.buildAddColumnOp(tableName, desiredCol));
-      } else if (this.hasColumnTypeChanged(desiredCol, existingCol)) {
-        operations.push(this.buildAlterColumnTypeOp(tableName, desiredCol));
-      }
-    }
-
-    // Flag columns that exist in the DB but are no longer in the schema
-    for (const existingCol of actualColumns) {
-      if (!desiredColumnNames.has(existingCol.name)) {
-        operations.push(this.warnOrphanedColumn(tableName, existingCol.name));
-      }
-    }
-
-    return operations;
-  }
-
-  /** Detect indexes that need to be created. */
-  private diffIndexes(
-    tableName: string,
-    desiredIndexes: IndexDefinition[],
-    actualIndexes: ActualIndex[],
-  ): DdlOperation[] {
-    const existingIndexNames = new Set(actualIndexes.map((i) => i.name));
-
-    return desiredIndexes
-      .filter((idx) => !existingIndexNames.has(idx.name))
-      .map((idx) => this.buildCreateIndexOp(idx));
-  }
-
-  /** Detect foreign keys that need to be added. */
-  private diffForeignKeys(
-    tableName: string,
-    desiredForeignKeys: ForeignKeyDefinition[],
-    actualForeignKeys: ActualForeignKey[],
-  ): DdlOperation[] {
-    const existingFkNames = new Set(actualForeignKeys.map((fk) => fk.name));
-
-    return desiredForeignKeys
-      .filter((fk) => !existingFkNames.has(fk.name))
-      .map((fk) => this.buildAddForeignKeyOp(tableName, fk));
-  }
-
-  /** Detect CHECK constraints that need to be added. */
-  private diffCheckConstraints(
-    tableName: string,
-    desiredConstraints: CheckConstraintDefinition[],
-    actualConstraints: ActualCheckConstraint[],
-  ): DdlOperation[] {
-    const existingNames = new Set(actualConstraints.map((c) => c.name));
-
-    return desiredConstraints
-      .filter((chk) => !existingNames.has(chk.name))
-      .map((chk) => this.buildAddCheckConstraintOp(tableName, chk));
-  }
-
-  // --- DDL operation builders ---
-
-  /** Generate an ADD COLUMN operation. */
-  private buildAddColumnOp(tableName: string, col: ColumnDefinition): DdlOperation {
-    const colSql = this.columnToSql(col);
-    const sql = `ALTER TABLE "${tableName}" ADD COLUMN ${colSql}`;
-    return { type: 'ADD_COLUMN', table: tableName, sql, destructive: false };
-  }
-
-  /** Generate an ALTER COLUMN TYPE operation. */
-  private buildAlterColumnTypeOp(tableName: string, col: ColumnDefinition): DdlOperation {
-    const sql = `ALTER TABLE "${tableName}" ALTER COLUMN "${col.name}" TYPE ${col.type}`;
-    return { type: 'ALTER_COLUMN_TYPE', table: tableName, sql, destructive: false };
-  }
-
-  /** Generate a CREATE INDEX operation. */
-  private buildCreateIndexOp(idx: IndexDefinition): DdlOperation {
-    const uniquePrefix = idx.unique ? 'UNIQUE ' : '';
-    const quotedColumns = idx.columns.map((c) => `"${c}"`).join(', ');
-    const whereClause = idx.where ? ` WHERE ${idx.where}` : '';
-    const sql = `CREATE ${uniquePrefix}INDEX "${idx.name}" ON "${idx.table}" (${quotedColumns})${whereClause}`;
-    return { type: 'CREATE_INDEX', table: idx.table, sql, destructive: false };
-  }
-
-  /** Generate an ADD FOREIGN KEY constraint operation. */
-  private buildAddForeignKeyOp(tableName: string, fk: ForeignKeyDefinition): DdlOperation {
-    const sql = `ALTER TABLE "${tableName}" ADD CONSTRAINT "${fk.name}" FOREIGN KEY ("${fk.column}") REFERENCES "${fk.referencedTable}" ("${fk.referencedColumn}")`;
-    return { type: 'ADD_FOREIGN_KEY', table: tableName, sql, destructive: false };
-  }
-
-  /** Generate an ADD CHECK CONSTRAINT operation. */
-  private buildAddCheckConstraintOp(
-    tableName: string,
-    chk: CheckConstraintDefinition,
-  ): DdlOperation {
-    const sql = `ALTER TABLE "${tableName}" ADD CONSTRAINT "${chk.name}" CHECK (${chk.expression})`;
-    return { type: 'ADD_CHECK_CONSTRAINT', table: tableName, sql, destructive: false };
-  }
-
-  // --- Orphan warnings (destructive markers) ---
-
-  /** Produce a warning operation for a table that exists in the DB but not in the schema. */
-  private warnOrphanedTable(tableName: string): DdlOperation {
-    return {
-      type: 'DROP_TABLE',
-      table: tableName,
-      sql: `-- WARNING: Table "${tableName}" exists in database but not in schema (not dropped without --allow-destructive)`,
-      destructive: true,
-      detail: `Orphaned table: ${tableName}`,
-    };
-  }
-
-  /** Produce a warning operation for a column that exists in the DB but not in the schema. */
-  private warnOrphanedColumn(tableName: string, columnName: string): DdlOperation {
-    return {
-      type: 'DROP_COLUMN',
-      table: tableName,
-      sql: `-- WARNING: Column "${tableName}"."${columnName}" exists in database but not in schema (not dropped without --allow-destructive)`,
-      destructive: true,
-      detail: `Orphaned column: ${tableName}.${columnName}`,
-    };
-  }
-
-  // --- SQL helpers ---
-
-  /** Convert a column definition to its SQL fragment (e.g. `"name" TEXT NOT NULL DEFAULT 'x'`). */
-  private columnToSql(col: ColumnDefinition): string {
-    let sql = `"${col.name}" ${col.type}`;
-    if (!col.nullable && !col.primaryKey) sql += ' NOT NULL';
-    if (col.defaultValue !== undefined) sql += ` DEFAULT ${col.defaultValue}`;
-    return sql;
-  }
-
-  /** Check whether the column type has changed (case-insensitive comparison). */
-  private hasColumnTypeChanged(desired: ColumnDefinition, actual: ActualColumn): boolean {
-    return desired.type.toUpperCase() !== actual.type.toUpperCase();
-  }
-
-  // --- Operation ordering ---
-
-  /**
-   * Sort operations so they execute in a safe dependency order:
-   * 1. CREATE TABLE (tables must exist before columns/indexes reference them)
-   * 2. ADD COLUMN
-   * 3. ALTER COLUMN TYPE
-   * 4. CREATE INDEX (columns must exist first)
-   * 5. ADD FOREIGN KEY (referenced tables must exist first)
-   * 6. ADD CHECK CONSTRAINT (columns must exist first)
-   * 7. Destructive operations (always last, require explicit opt-in)
-   */
-  private sortByDependencyOrder(operations: DdlOperation[]): DdlOperation[] {
-    const createTables: DdlOperation[] = [];
-    const addColumns: DdlOperation[] = [];
-    const alterColumns: DdlOperation[] = [];
-    const createIndexes: DdlOperation[] = [];
-    const addForeignKeys: DdlOperation[] = [];
-    const addCheckConstraints: DdlOperation[] = [];
-    const destructive: DdlOperation[] = [];
-
-    for (const op of operations) {
-      if (op.destructive) {
-        destructive.push(op);
-      } else {
-        switch (op.type) {
-          case 'CREATE_TABLE':
-            createTables.push(op);
-            break;
-          case 'ADD_COLUMN':
-            addColumns.push(op);
-            break;
-          case 'ALTER_COLUMN_TYPE':
-            alterColumns.push(op);
-            break;
-          case 'CREATE_INDEX':
-            createIndexes.push(op);
-            break;
-          case 'ADD_FOREIGN_KEY':
-            addForeignKeys.push(op);
-            break;
-          case 'ADD_CHECK_CONSTRAINT':
-            addCheckConstraints.push(op);
-            break;
-          default:
-            addColumns.push(op);
-        }
-      }
-    }
-
-    return [
-      ...createTables,
-      ...addColumns,
-      ...alterColumns,
-      ...createIndexes,
-      ...addForeignKeys,
-      ...addCheckConstraints,
-      ...destructive,
-    ];
-  }
-}