@rangka/core 0.0.1

package/src/db/auto-sync.ts

@@ -0,0 +1,133 @@
+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

@@ -0,0 +1,147 @@
+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

@@ -0,0 +1,98 @@
+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

@@ -0,0 +1,305 @@
+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,
+    ];
+  }
+}