orchid-orm 1.60.0 → 1.60.1

package/dist/migrations/index.mjs

@@ -0,0 +1,3228 @@
+import { promptSelect, getSchemaAndTableFromName, getDbTableColumnsChecks, dbColumnToAst, instantiateDbColumn, concatSchemaAndName, encodeColumnDefault, getIndexName, getExcludeName, getConstraintName, tableToAst, getDbStructureTableData, makeDomainsMap, astToMigration, createMigrationInterface, introspectDbSchema, makeStructureToAstCtx, makeFileVersion, writeMigrationFile, migrateAndClose, migrate, structureToAst, saveMigratedVersion, rakeDbCommands } from 'rake-db';
+export * from 'rake-db';
+import { colors, EnumColumn, ArrayColumn, toSnakeCase, getColumnBaseType, deepCompare, RawSql, emptyArray, toArray, getFreeSetAlias, VirtualColumn, exhaustive, toCamelCase, addCode, pluralize, codeToString, DomainColumn, UnknownColumn, defaultSchemaConfig, toPascalCase, getImportPath, singleQuote, columnsShapeToCode, pushTableDataCode, quoteObjectKey, pathToLog } from 'pqb';
+import path from 'node:path';
+import { pathToFileURL } from 'url';
+import fs from 'fs/promises';
+import typescript from 'typescript';
+
+const compareSqlExpressions = async (tableExpressions, adapter) => {
+  if (!tableExpressions.length) return;
+  let id = 1;
+  for (const { source, compare, handle } of tableExpressions) {
+    const viewName = `orchidTmpView${id++}`;
+    const values = [];
+    const combinedQueries = [
+      `CREATE TEMPORARY VIEW ${viewName} AS (SELECT ${compare.map(
+        ({ inDb, inCode }, i) => `${inDb} AS "*inDb-${i}*", ${inCode.map(
+          (s, j) => `(${typeof s === "string" ? s : s.toSQL({ values })}) "*inCode-${i}-${j}*"`
+        ).join(", ")}`
+      ).join(", ")} FROM ${source})`,
+      `SELECT pg_get_viewdef('${viewName}') v`,
+      `DROP VIEW ${viewName}`
+    ].join("; ");
+    const result = await adapter.query(combinedQueries, values, viewName).then(
+      (res) => res[1],
+      async (err) => {
+        if (err.code !== "42704") {
+          throw err;
+        }
+      }
+    );
+    if (!result) {
+      handle();
+      return;
+    }
+    const match = compareSqlExpressionResult(
+      result.rows[0].v,
+      compare[0].inCode
+    );
+    handle(match);
+  }
+};
+const compareSqlExpressionResult = (resultSql, inCode) => {
+  let pos = 7;
+  const rgx = /\s+AS\s+"\*(inDb-\d+|inCode-\d+-\d+)\*",?/g;
+  let match;
+  let inDb = "";
+  let codeI = 0;
+  const matches = inCode.map(() => true);
+  while (match = rgx.exec(resultSql)) {
+    const sql = resultSql.slice(pos, rgx.lastIndex - match[0].length).trim();
+    const arr = match[1].split("-");
+    if (arr.length === 2) {
+      inDb = sql;
+      codeI = 0;
+    } else {
+      if (inDb !== sql && // Comparing `(sql) = sql` and `sql = (sql)` below.
+      // Could not reproduce this case in integration tests, but it was reported in #494.
+      !(inDb.startsWith("(") && inDb.endsWith(")") && inDb.slice(1, -1) === sql) && !(sql.startsWith("(") && sql.endsWith(")") && sql.slice(1, -1) === inDb)) {
+        matches[codeI] = false;
+      }
+      codeI++;
+    }
+    pos = rgx.lastIndex;
+  }
+  const firstMatching = matches.indexOf(true);
+  return firstMatching === -1 ? void 0 : firstMatching;
+};
+const promptCreateOrRename = (kind, name, drop, verifying) => {
+  if (verifying) throw new AbortSignal();
+  let hintPos = name.length + 4;
+  for (const from of drop) {
+    const value = from.length + 8 + name.length;
+    if (value > hintPos) hintPos = value;
+  }
+  let max = 0;
+  const add = name.length + 3;
+  for (const name2 of drop) {
+    if (name2.length + add > max) {
+      max = name2.length + add;
+    }
+  }
+  const renameMessage = `rename ${kind}`;
+  return promptSelect({
+    message: `Create or rename ${colors.blueBold(
+      name
+    )} ${kind} from another ${kind}?`,
+    options: [
+      `${colors.greenBold("+")} ${name}  ${colors.pale(
+        `create ${kind}`.padStart(
+          hintPos + renameMessage.length - name.length - 4,
+          " "
+        )
+      )}`,
+      ...drop.map(
+        (d) => `${colors.yellowBold("~")} ${d} ${colors.yellowBold(
+          "=>"
+        )} ${name}  ${colors.pale(
+          renameMessage.padStart(
+            hintPos + renameMessage.length - d.length - name.length - 8,
+            " "
+          )
+        )}`
+      )
+    ]
+  });
+};
+const checkForColumnAddOrDrop = (shape, key) => {
+  const item = shape[key];
+  if (item) {
+    return item && (Array.isArray(item) || item.type === "add" || item.type === "drop");
+  }
+  for (const k in shape) {
+    const item2 = shape[k];
+    if (Array.isArray(item2) ? item2.some(
+      (item3) => (item3.type === "add" || item3.type === "drop") && item3.item.data.name === key
+    ) : (item2.type === "add" || item2.type === "drop") && item2.item.data.name === key) {
+      return true;
+    }
+  }
+  return false;
+};
+
+const processSchemas = async (ast, dbStructure, {
+  codeItems: { schemas },
+  verifying,
+  internal: { generatorIgnore }
+}) => {
+  const createSchemas = [];
+  const dropSchemas = [];
+  for (const schema of schemas) {
+    if (!dbStructure.schemas.includes(schema)) {
+      createSchemas.push(schema);
+    }
+  }
+  for (const schema of dbStructure.schemas) {
+    if (!schemas.has(schema) && schema !== "public" && !generatorIgnore?.schemas?.includes(schema)) {
+      dropSchemas.push(schema);
+    }
+  }
+  for (const schema of createSchemas) {
+    if (dropSchemas.length) {
+      const i = await promptCreateOrRename(
+        "schema",
+        schema,
+        dropSchemas,
+        verifying
+      );
+      if (i) {
+        const from = dropSchemas[i - 1];
+        dropSchemas.splice(i - 1, 1);
+        renameSchemaInStructures(dbStructure.tables, from, schema);
+        renameSchemaInStructures(dbStructure.views, from, schema);
+        renameSchemaInStructures(dbStructure.indexes, from, schema);
+        renameSchemaInStructures(dbStructure.excludes, from, schema);
+        renameSchemaInStructures(dbStructure.constraints, from, schema);
+        renameSchemaInStructures(dbStructure.triggers, from, schema);
+        renameSchemaInStructures(dbStructure.enums, from, schema);
+        renameSchemaInStructures(dbStructure.domains, from, schema);
+        renameSchemaInStructures(dbStructure.collations, from, schema);
+        for (const table of dbStructure.tables) {
+          for (const column of table.columns) {
+            if (column.typeSchema === from) {
+              column.typeSchema = schema;
+            }
+          }
+        }
+        ast.push({
+          type: "renameSchema",
+          from,
+          to: schema
+        });
+        continue;
+      }
+    }
+    ast.push({
+      type: "schema",
+      action: "create",
+      name: schema
+    });
+  }
+  for (const schema of dropSchemas) {
+    ast.push({
+      type: "schema",
+      action: "drop",
+      name: schema
+    });
+  }
+};
+const renameSchemaInStructures = (items, from, to) => {
+  for (const item of items) {
+    if (item.schemaName === from) {
+      item.schemaName = to;
+    }
+  }
+};
+
+const processExtensions = (ast, dbStructure, {
+  currentSchema,
+  internal: { extensions, generatorIgnore }
+}) => {
+  const codeExtensions = extensions?.map((ext) => {
+    const [schema, name] = getSchemaAndTableFromName(ext.name);
+    return { schema, name, version: ext.version };
+  });
+  for (const dbExt of dbStructure.extensions) {
+    if (generatorIgnore?.schemas?.includes(dbExt.schemaName) || generatorIgnore?.extensions?.includes(dbExt.name)) {
+      continue;
+    }
+    if (codeExtensions) {
+      let found = false;
+      for (let i = 0; i < codeExtensions.length; i++) {
+        const codeExt = codeExtensions[i];
+        if (dbExt.name === codeExt.name && dbExt.schemaName === (codeExt.schema ?? currentSchema) && (!codeExt.version || codeExt.version === dbExt.version)) {
+          found = true;
+          codeExtensions.splice(i, 1);
+          break;
+        }
+      }
+      if (found) continue;
+    }
+    ast.push({
+      type: "extension",
+      action: "drop",
+      schema: dbExt.schemaName === currentSchema ? void 0 : dbExt.schemaName,
+      name: dbExt.name,
+      version: dbExt.version
+    });
+  }
+  if (codeExtensions?.length) {
+    ast.push(
+      ...codeExtensions.map((ext) => ({
+        type: "extension",
+        action: "create",
+        ...ext
+      }))
+    );
+  }
+};
+
+const processColumns = async (adapter, config, structureToAstCtx, dbStructure, domainsMap, changeTableData, ast, currentSchema, compareSql, typeCastsCache, verifying) => {
+  const { dbTable } = changeTableData;
+  const dbColumns = Object.fromEntries(
+    dbTable.columns.map((column) => [column.name, column])
+  );
+  const { columnsToAdd, columnsToDrop, columnsToChange } = groupColumns(
+    structureToAstCtx,
+    dbStructure,
+    domainsMap,
+    dbColumns,
+    changeTableData
+  );
+  await addOrRenameColumns(
+    config,
+    dbStructure,
+    changeTableData,
+    columnsToAdd,
+    columnsToDrop,
+    columnsToChange,
+    verifying
+  );
+  await changeColumns(
+    adapter,
+    config,
+    structureToAstCtx,
+    dbStructure,
+    domainsMap,
+    ast,
+    currentSchema,
+    dbColumns,
+    columnsToChange,
+    compareSql,
+    changeTableData,
+    typeCastsCache,
+    verifying
+  );
+  dropColumns(changeTableData, columnsToDrop);
+};
+const groupColumns = (structureToAstCtx, dbStructure, domainsMap, dbColumns, changeTableData) => {
+  const columnsToAdd = [];
+  const columnsToDrop = [];
+  const columnsToChange = /* @__PURE__ */ new Map();
+  const columnsToChangeByDbName = /* @__PURE__ */ new Map();
+  const { codeTable, dbTable, dbTableData } = changeTableData;
+  const checks = getDbTableColumnsChecks(changeTableData.dbTableData);
+  for (const key in codeTable.shape) {
+    const column = codeTable.shape[key];
+    if (!column.dataType) continue;
+    const name = column.data.name ?? key;
+    if (dbColumns[name]) {
+      columnsToChange.set(key, { key, dbName: name, column });
+      columnsToChangeByDbName.set(name, true);
+    } else {
+      columnsToAdd.push({ key, column });
+    }
+  }
+  for (const name in dbColumns) {
+    if (columnsToChangeByDbName.has(name)) continue;
+    const [key, column] = dbColumnToAst(
+      structureToAstCtx,
+      dbStructure,
+      domainsMap,
+      dbTable.name,
+      dbColumns[name],
+      dbTable,
+      dbTableData,
+      checks
+    );
+    columnsToDrop.push({ key, column });
+  }
+  return {
+    columnsToAdd,
+    columnsToDrop,
+    columnsToChange
+  };
+};
+const addOrRenameColumns = async (config, dbStructure, {
+  dbTableData,
+  schema,
+  changeTableAst: { name: tableName, shape }
+}, columnsToAdd, columnsToDrop, columnsToChange, verifying) => {
+  for (const { key, column } of columnsToAdd) {
+    if (columnsToDrop.length) {
+      const codeName = column.data.name ?? key;
+      const i = await promptCreateOrRename(
+        "column",
+        codeName,
+        columnsToDrop.map((x) => x.key),
+        verifying
+      );
+      if (i) {
+        const drop = columnsToDrop[i - 1];
+        columnsToDrop.splice(i - 1, 1);
+        const from = drop.column.data.name ?? drop.key;
+        columnsToChange.set(from, {
+          key,
+          dbName: from,
+          column: column.name(codeName)
+        });
+        const to = config.snakeCase ? toSnakeCase(key) : key;
+        if (dbTableData.primaryKey) {
+          renameColumn(dbTableData.primaryKey.columns, from, to);
+        }
+        for (const index of dbTableData.indexes) {
+          for (const column2 of index.columns) {
+            if ("column" in column2 && column2.column === from) {
+              column2.column = to;
+            }
+          }
+        }
+        for (const exclude of dbTableData.excludes) {
+          for (const column2 of exclude.columns) {
+            if ("column" in column2 && column2.column === from) {
+              column2.column = to;
+            }
+          }
+        }
+        for (const c of dbTableData.constraints) {
+          if (c.check?.columns) {
+            renameColumn(c.check.columns, from, to);
+          }
+          if (c.references) {
+            renameColumn(c.references.columns, from, to);
+          }
+        }
+        for (const c of dbStructure.constraints) {
+          if (c.references && c.references.foreignSchema === schema && c.references.foreignTable === tableName) {
+            renameColumn(c.references.foreignColumns, from, to);
+          }
+        }
+        continue;
+      }
+    }
+    shape[key] = {
+      type: "add",
+      item: column
+    };
+  }
+};
+const dropColumns = ({ changeTableAst: { shape } }, columnsToDrop) => {
+  for (const { key, column } of columnsToDrop) {
+    shape[key] = {
+      type: "drop",
+      item: column
+    };
+  }
+};
+const changeColumns = async (adapter, config, structureToAstCtx, dbStructure, domainsMap, ast, currentSchema, dbColumns, columnsToChange, compareSql, changeTableData, typeCastsCache, verifying) => {
+  for (const [
+    key,
+    { key: codeKey, dbName, column: codeColumn }
+  ] of columnsToChange) {
+    const dbColumnStructure = dbColumns[dbName];
+    const dbColumn = instantiateDbColumn(
+      structureToAstCtx,
+      dbStructure,
+      domainsMap,
+      dbColumnStructure
+    );
+    const action = await compareColumns(
+      adapter,
+      domainsMap,
+      ast,
+      currentSchema,
+      compareSql,
+      changeTableData,
+      typeCastsCache,
+      verifying,
+      key,
+      dbName,
+      dbColumn,
+      codeColumn
+    );
+    if (action === "change") {
+      changeColumn(changeTableData, key, dbName, dbColumn, codeColumn);
+    } else if (action === "recreate") {
+      changeTableData.changeTableAst.shape[key] = [
+        {
+          type: "drop",
+          item: dbColumn
+        },
+        {
+          type: "add",
+          item: codeColumn
+        }
+      ];
+    } else if (action !== "recreate") {
+      const to = codeColumn.data.name ?? codeKey;
+      if (dbName !== to) {
+        changeTableData.changeTableAst.shape[config.snakeCase ? dbName === toSnakeCase(codeKey) ? codeKey : dbName : dbName] = {
+          type: "rename",
+          name: config.snakeCase ? to === toSnakeCase(codeKey) ? codeKey : to : to
+        };
+      }
+    }
+  }
+};
+const compareColumns = async (adapter, domainsMap, ast, currentSchema, compareSql, changeTableData, typeCastsCache, verifying, key, dbName, dbColumn, codeColumn) => {
+  if (dbColumn instanceof ArrayColumn && codeColumn instanceof ArrayColumn) {
+    dbColumn = dbColumn.data.item;
+    codeColumn = codeColumn.data.item;
+  }
+  const dbType = getColumnDbType(dbColumn, currentSchema);
+  const codeType = getColumnDbType(codeColumn, currentSchema);
+  if (dbType !== codeType) {
+    const typeCasts = await getTypeCasts(adapter, typeCastsCache);
+    const dbBaseType = getColumnBaseType(dbColumn, domainsMap, dbType);
+    const codeBaseType = getColumnBaseType(codeColumn, domainsMap, codeType);
+    if (!typeCasts.get(dbBaseType)?.has(codeBaseType)) {
+      if (!(dbColumn instanceof EnumColumn) || !(codeColumn instanceof EnumColumn) || !deepCompare(dbColumn.options, codeColumn.options)) {
+        if (verifying) throw new AbortSignal();
+        const tableName = concatSchemaAndName(changeTableData.changeTableAst);
+        const abort = await promptSelect({
+          message: `Cannot cast type of ${tableName}'s column ${key} from ${dbType} to ${codeType}`,
+          options: [
+            `${colors.yellowBold(
+              `-/+`
+            )} recreate the column, existing data will be ${colors.red(
+              "lost"
+            )}`,
+            `write migration manually`
+          ]
+        });
+        if (abort) {
+          throw new AbortSignal();
+        }
+        dbColumn.data.name = codeColumn.data.name;
+        return "recreate";
+      }
+    }
+    return "change";
+  }
+  const dbData = dbColumn.data;
+  const codeData = codeColumn.data;
+  for (const key2 of ["isNullable", "comment"]) {
+    if (dbData[key2] !== codeData[key2]) {
+      return "change";
+    }
+  }
+  for (const key2 of [
+    "maxChars",
+    "collation",
+    "compression",
+    "numericPrecision",
+    "numericScale",
+    "dateTimePrecision"
+  ]) {
+    if (key2 in codeData && dbData[key2] !== codeData[key2]) {
+      return "change";
+    }
+  }
+  if (dbColumn.data.isOfCustomType) {
+    const { typmod } = dbColumn.data;
+    if (typmod !== void 0 && typmod !== -1) {
+      const i = codeColumn.dataType.indexOf("(");
+      if (i === -1 || codeColumn.dataType.slice(i + 1, -1) !== `${typmod}`) {
+        return "change";
+      }
+    }
+  }
+  if (!deepCompare(
+    dbData.identity,
+    codeData.identity ? {
+      always: false,
+      start: 1,
+      increment: 1,
+      cache: 1,
+      cycle: false,
+      ...codeData.identity ?? {}
+    } : void 0
+  )) {
+    return "change";
+  }
+  if (dbData.default !== void 0 && codeData.default !== void 0) {
+    const valuesBeforeLen = compareSql.values.length;
+    const dbDefault = encodeColumnDefault(
+      dbData.default,
+      compareSql.values,
+      dbColumn
+    );
+    const dbValues = compareSql.values.slice(valuesBeforeLen);
+    const codeDefault = encodeColumnDefault(
+      codeData.default,
+      compareSql.values,
+      codeColumn
+    );
+    const codeValues = compareSql.values.slice(valuesBeforeLen);
+    if (dbValues.length !== codeValues.length || dbValues.length && JSON.stringify(dbValues) !== JSON.stringify(codeValues)) {
+      compareSql.values.length = valuesBeforeLen;
+      return "change";
+    } else if (dbDefault !== codeDefault && dbDefault !== `(${codeDefault})`) {
+      compareSql.expressions.push({
+        inDb: dbDefault,
+        inCode: codeDefault,
+        change: () => {
+          changeColumn(changeTableData, key, dbName, dbColumn, codeColumn);
+          if (!changeTableData.pushedAst) {
+            changeTableData.pushedAst = true;
+            ast.push(changeTableData.changeTableAst);
+          }
+        }
+      });
+    }
+  }
+  return;
+};
+const getTypeCasts = async (adapter, typeCastsCache) => {
+  let typeCasts = typeCastsCache.value;
+  if (!typeCasts) {
+    const { rows } = await adapter.arrays(`SELECT s.typname, t.typname
+FROM pg_cast
+JOIN pg_type AS s ON s.oid = castsource
+JOIN pg_type AS t ON t.oid = casttarget`);
+    const directTypeCasts = /* @__PURE__ */ new Map();
+    for (const [source, target] of rows) {
+      const set = directTypeCasts.get(source);
+      if (set) {
+        set.add(target);
+      } else {
+        directTypeCasts.set(source, /* @__PURE__ */ new Set([target]));
+      }
+    }
+    typeCasts = /* @__PURE__ */ new Map();
+    for (const [type, directSet] of directTypeCasts.entries()) {
+      const set = new Set(directSet);
+      typeCasts.set(type, set);
+      for (const subtype of directSet) {
+        const subset = directTypeCasts.get(subtype);
+        if (subset) {
+          for (const type2 of subset) {
+            set.add(type2);
+          }
+        }
+      }
+    }
+    typeCastsCache.value = typeCasts;
+  }
+  return typeCasts;
+};
+const changeColumn = (changeTableData, key, dbName, dbColumn, codeColumn) => {
+  dbColumn.data.as = codeColumn.data.as = void 0;
+  const simpleCodeColumn = Object.create(codeColumn);
+  simpleCodeColumn.data = {
+    ...codeColumn.data,
+    primaryKey: void 0,
+    indexes: void 0,
+    excludes: void 0,
+    foreignKeys: void 0,
+    check: void 0
+  };
+  changeTableData.changingColumns[dbName] = {
+    from: dbColumn,
+    to: simpleCodeColumn
+  };
+  changeTableData.changeTableAst.shape[key] = {
+    type: "change",
+    from: { column: dbColumn },
+    to: { column: simpleCodeColumn }
+  };
+};
+const getColumnDbType = (column, currentSchema) => {
+  if (column instanceof EnumColumn) {
+    const [schema = currentSchema, name] = getSchemaAndTableFromName(
+      column.enumName
+    );
+    return `${schema}.${name}`;
+  } else if (column instanceof ArrayColumn) {
+    const { item } = column.data;
+    let type = item instanceof EnumColumn ? item.enumName : item.dataType;
+    type = type.startsWith(currentSchema + ".") ? type.slice(currentSchema.length + 1) : type;
+    return type + "[]".repeat(column.data.arrayDims);
+  } else if (column.data.isOfCustomType) {
+    let type = column.dataType;
+    const i = type.indexOf("(");
+    if (i !== -1) {
+      type = type.slice(0, i);
+    }
+    return type.includes(".") ? type : currentSchema + "." + type;
+  } else {
+    return column.dataType;
+  }
+};
+const renameColumn = (columns, from, to) => {
+  for (let i = 0; i < columns.length; i++) {
+    if (columns[i] === from) {
+      columns[i] = to;
+    }
+  }
+};
+
+const processDomains = async (ast, adapter, domainsMap, dbStructure, {
+  codeItems: { domains },
+  structureToAstCtx,
+  currentSchema,
+  internal: { generatorIgnore }
+}, pendingDbTypes) => {
+  const codeDomains = [];
+  if (domains) {
+    for (const { schemaName, name, column } of domains) {
+      codeDomains.push(
+        makeComparableDomain(currentSchema, schemaName, name, column)
+      );
+    }
+  }
+  const tableExpressions = [];
+  const holdCodeDomains = /* @__PURE__ */ new Set();
+  for (const domain of dbStructure.domains) {
+    if (generatorIgnore?.schemas?.includes(domain.schemaName) || generatorIgnore?.domains?.includes(domain.name)) {
+      continue;
+    }
+    const dbColumn = instantiateDbColumn(
+      structureToAstCtx,
+      dbStructure,
+      domainsMap,
+      {
+        // not destructuring `domain` because need to ignore `numericPrecision`, `numericScale`, etc.,
+        // that are loaded from db, but not defined in the code
+        schemaName: domain.typeSchema,
+        tableName: "N/A",
+        name: domain.name,
+        typeSchema: domain.typeSchema,
+        type: domain.type,
+        arrayDims: domain.arrayDims,
+        default: domain.default,
+        isNullable: domain.isNullable,
+        collate: domain.collate,
+        maxChars: domain.maxChars,
+        typmod: -1
+      }
+    );
+    if (domain.checks) {
+      dbColumn.data.checks = domain.checks.map((check) => ({
+        sql: new RawSql([[check]])
+      }));
+    }
+    const dbDomain = makeComparableDomain(
+      currentSchema,
+      domain.schemaName,
+      domain.name,
+      dbColumn
+    );
+    const found = codeDomains.filter(
+      (codeDomain) => deepCompare(dbDomain.compare, codeDomain.compare)
+    );
+    if ((domain.default || domain.checks?.length) && found.length) {
+      for (const codeDomain of found) {
+        holdCodeDomains.add(codeDomain);
+      }
+      const compare = [];
+      pushCompareDefault(compare, domain, found);
+      pushCompareChecks(compare, domain, found);
+      const source = `(VALUES (NULL::${getColumnDbType(
+        dbColumn,
+        currentSchema
+      )})) t(value)`;
+      tableExpressions.push({
+        compare,
+        source,
+        handle(i) {
+          const codeDomain = i === void 0 ? void 0 : found[i];
+          if (!codeDomain) {
+            ast.push(dropAst(dbDomain));
+          } else {
+            holdCodeDomains.delete(codeDomain);
+          }
+        }
+      });
+    } else if (found.length) {
+      let i = codeDomains.findIndex(
+        (codeDomain) => codeDomain.name === dbDomain.name && codeDomain.schemaName === dbDomain.schemaName
+      );
+      if (i === -1) {
+        i = 0;
+        const first = found[0];
+        ast.push({
+          type: "renameType",
+          kind: "DOMAIN",
+          fromSchema: dbDomain.schemaName,
+          from: dbDomain.name,
+          toSchema: first.schemaName,
+          to: first.name
+        });
+        pendingDbTypes.add(first.schemaName, first.name);
+      }
+      codeDomains.splice(i, 1);
+    } else {
+      ast.push(dropAst(dbDomain));
+    }
+  }
+  for (const codeDomain of codeDomains) {
+    if (!holdCodeDomains.has(codeDomain)) {
+      ast.push(createAst(codeDomain));
+      pendingDbTypes.add(codeDomain.schemaName, codeDomain.name);
+    }
+  }
+  if (tableExpressions.length) {
+    await compareSqlExpressions(tableExpressions, adapter);
+    if (holdCodeDomains.size) {
+      for (const codeDomain of holdCodeDomains.keys()) {
+        ast.push(createAst(codeDomain));
+        pendingDbTypes.add(codeDomain.schemaName, codeDomain.name);
+      }
+    }
+  }
+};
+const makeComparableDomain = (currentSchema, schemaName, name, column) => {
+  let arrayDims = 0;
+  const isNullable = column.data.isNullable ?? false;
+  let inner = column;
+  while (inner instanceof ArrayColumn) {
+    inner = inner.data.item;
+    arrayDims++;
+  }
+  const fullType = getColumnDbType(inner, currentSchema);
+  const [typeSchema = "pg_catalog", type] = getSchemaAndTableFromName(fullType);
+  return {
+    schemaName,
+    name,
+    column,
+    compare: {
+      type,
+      typeSchema,
+      arrayDims,
+      isNullable,
+      maxChars: inner.data.maxChars,
+      numericPrecision: inner.data.numericPrecision,
+      numericScale: inner.data.numericScale,
+      dateTimePrecision: inner.data.dateTimePrecision,
+      collate: column.data.collate,
+      hasDefault: column.data.default !== void 0,
+      hasChecks: !!column.data.checks?.length
+    }
+  };
+};
+const pushCompareDefault = (compare, domain, found) => {
+  if (domain.default) {
+    compare.push({
+      inDb: domain.default,
+      inCode: found.map((codeDomain) => {
+        const value = codeDomain.column.data.default;
+        if ("sql" in value) {
+          return value.sql;
+        }
+        return value;
+      })
+    });
+  }
+};
+const pushCompareChecks = (compare, domain, found) => {
+  if (domain.checks?.length) {
+    const inCode = found.flatMap(
+      (codeDomain) => codeDomain.column.data.checks?.map(
+        (check) => typeof check === "string" ? check : check.sql
+      ) || emptyArray
+    );
+    compare.push(
+      ...domain.checks.map((check) => ({
+        inDb: check,
+        inCode
+      }))
+    );
+  }
+};
+const dropAst = (dbDomain) => ({
+  type: "domain",
+  action: "drop",
+  schema: dbDomain.schemaName,
+  name: dbDomain.name,
+  baseType: dbDomain.column
+});
+const createAst = (codeDomain) => ({
+  type: "domain",
+  action: "create",
+  schema: codeDomain.schemaName,
+  name: codeDomain.name,
+  baseType: codeDomain.column
+});
+
+const processEnums = async (ast, dbStructure, {
+  codeItems: { enums },
+  currentSchema,
+  verifying,
+  internal: { generatorIgnore }
+}, pendingDbTypes) => {
+  const createEnums = [];
+  const dropEnums = [];
+  for (const [, codeEnum] of enums) {
+    const { schema = currentSchema, name } = codeEnum;
+    const dbEnum = dbStructure.enums.find(
+      (x) => x.schemaName === schema && x.name === name
+    );
+    if (!dbEnum) {
+      createEnums.push(codeEnum);
+    }
+  }
+  for (const dbEnum of dbStructure.enums) {
+    if (generatorIgnore?.schemas?.includes(dbEnum.schemaName) || generatorIgnore?.enums?.includes(dbEnum.name)) {
+      continue;
+    }
+    const codeEnum = enums.get(`${dbEnum.schemaName}.${dbEnum.name}`);
+    if (codeEnum) {
+      changeEnum(ast, dbEnum, codeEnum, pendingDbTypes);
+      continue;
+    }
+    const i = createEnums.findIndex((x) => x.name === dbEnum.name);
+    if (i !== -1) {
+      const codeEnum2 = createEnums[i];
+      createEnums.splice(i, 1);
+      const fromSchema = dbEnum.schemaName;
+      const toSchema = codeEnum2.schema ?? currentSchema;
+      renameColumnsTypeSchema(dbStructure, fromSchema, toSchema);
+      ast.push({
+        type: "renameType",
+        kind: "TYPE",
+        fromSchema,
+        from: dbEnum.name,
+        toSchema,
+        to: dbEnum.name
+      });
+      pendingDbTypes.add(toSchema, dbEnum.name);
+      changeEnum(ast, dbEnum, codeEnum2, pendingDbTypes);
+      continue;
+    }
+    dropEnums.push(dbEnum);
+  }
+  for (const codeEnum of createEnums) {
+    if (dropEnums.length) {
+      const i = await promptCreateOrRename(
+        "enum",
+        codeEnum.name,
+        dropEnums.map((x) => x.name),
+        verifying
+      );
+      if (i) {
+        const dbEnum = dropEnums[i - 1];
+        dropEnums.splice(i - 1, 1);
+        const fromSchema = dbEnum.schemaName;
+        const from = dbEnum.name;
+        const toSchema = codeEnum.schema ?? currentSchema;
+        const to = codeEnum.name;
+        if (fromSchema !== toSchema) {
+          renameColumnsTypeSchema(dbStructure, fromSchema, toSchema);
+        }
+        for (const table of dbStructure.tables) {
+          for (const column of table.columns) {
+            if (column.type === from) {
+              column.type = to;
+            }
+          }
+        }
+        ast.push({
+          type: "renameType",
+          kind: "TYPE",
+          fromSchema,
+          from,
+          toSchema,
+          to
+        });
+        pendingDbTypes.add(toSchema, to);
+        changeEnum(ast, dbEnum, codeEnum, pendingDbTypes);
+        continue;
+      }
+    }
+    ast.push({
+      type: "enum",
+      action: "create",
+      ...codeEnum
+    });
+    pendingDbTypes.add(codeEnum.schema, codeEnum.name);
+  }
+  for (const dbEnum of dropEnums) {
+    ast.push({
+      type: "enum",
+      action: "drop",
+      schema: dbEnum.schemaName,
+      name: dbEnum.name,
+      values: dbEnum.values
+    });
+  }
+};
+const changeEnum = (ast, dbEnum, codeEnum, pendingDbTypes) => {
+  const { values: dbValues } = dbEnum;
+  const { values: codeValues, schema, name } = codeEnum;
+  if (dbValues.length < codeValues.length) {
+    if (!dbValues.some((value) => !codeValues.includes(value))) {
+      ast.push({
+        type: "enumValues",
+        action: "add",
+        schema,
+        name,
+        values: codeValues.filter((value) => !dbValues.includes(value))
+      });
+      pendingDbTypes.add(schema, name);
+      return;
+    }
+  } else if (dbValues.length > codeValues.length) {
+    if (!codeValues.some((value) => !dbValues.includes(value))) {
+      ast.push({
+        type: "enumValues",
+        action: "drop",
+        schema,
+        name,
+        values: dbValues.filter((value) => !codeValues.includes(value))
+      });
+      pendingDbTypes.add(schema, name);
+      return;
+    }
+  } else if (!dbValues.some((value) => !codeValues.includes(value))) {
+    return;
+  }
+  ast.push({
+    type: "changeEnumValues",
+    schema,
+    name,
+    fromValues: dbValues,
+    toValues: codeValues
+  });
+  pendingDbTypes.add(schema, name);
+};
+const renameColumnsTypeSchema = (dbStructure, from, to) => {
+  for (const table of dbStructure.tables) {
+    for (const column of table.columns) {
+      if (column.typeSchema === from) {
+        column.typeSchema = to;
+      }
+    }
+  }
+};
+
+const processPrimaryKey = (config, changeTableData) => {
+  const { codeTable } = changeTableData;
+  const columnsPrimaryKey = [];
+  for (const key in codeTable.shape) {
+    const column = codeTable.shape[key];
+    if (column.data.primaryKey) {
+      columnsPrimaryKey.push({ key, name: column.data.name ?? key });
+    }
+  }
+  changePrimaryKey(config, columnsPrimaryKey, changeTableData);
+  renamePrimaryKey(changeTableData);
+};
+const changePrimaryKey = (config, columnsPrimaryKey, {
+  codeTable,
+  dbTableData: { primaryKey: dbPrimaryKey },
+  changeTableAst: { shape, add, drop },
+  changingColumns
+}) => {
+  const tablePrimaryKey = codeTable.internal.tableData.primaryKey;
+  const primaryKey = [
+    .../* @__PURE__ */ new Set([
+      ...columnsPrimaryKey,
+      ...(config.snakeCase ? tablePrimaryKey?.columns.map((key) => ({
+        key,
+        name: toSnakeCase(key)
+      })) : tablePrimaryKey?.columns.map((key) => ({ key, name: key }))) ?? []
+    ])
+  ];
+  if (dbPrimaryKey && primaryKey.length === dbPrimaryKey.columns.length && !primaryKey.some(
+    ({ name }) => !dbPrimaryKey.columns.some((dbName) => name === dbName)
+  )) {
+    if (primaryKey.length === 1) {
+      const { key } = primaryKey[0];
+      const changes = shape[key] && toArray(shape[key]);
+      if (changes) {
+        for (const change of changes) {
+          if (change.type !== "change") continue;
+          if (change.from.column) {
+            change.from.column.data.primaryKey = void 0;
+          }
+          if (change.to.column) {
+            const column = Object.create(change.to.column);
+            column.data = { ...column.data, primaryKey: void 0 };
+            change.to.column = column;
+          }
+        }
+      }
+    }
+    return;
+  }
+  const toDrop = dbPrimaryKey?.columns.filter(
+    (key) => !checkForColumnAddOrDrop(shape, key)
+  );
+  if (toDrop?.length) {
+    if (toDrop.length === 1 && changingColumns[toDrop[0]]) {
+      const column = changingColumns[toDrop[0]];
+      column.from.data.primaryKey = dbPrimaryKey?.name ?? true;
+    } else {
+      drop.primaryKey = { columns: toDrop, name: dbPrimaryKey?.name };
+    }
+  }
+  const toAdd = primaryKey.filter(
+    ({ key }) => !checkForColumnAddOrDrop(shape, key)
+  );
+  if (toAdd.length) {
+    if (toAdd.length === 1 && changingColumns[toAdd[0].name]) {
+      const column = changingColumns[toAdd[0].name];
+      column.to.data.primaryKey = tablePrimaryKey?.name ?? true;
+    } else {
+      add.primaryKey = {
+        columns: toAdd.map((c) => c.key),
+        name: tablePrimaryKey?.name
+      };
+    }
+  }
+};
+const renamePrimaryKey = ({
+  codeTable,
+  dbTableData: { primaryKey: dbPrimaryKey },
+  schema,
+  delayedAst
+}) => {
+  const tablePrimaryKey = codeTable.internal.tableData.primaryKey;
+  if (dbPrimaryKey && tablePrimaryKey && dbPrimaryKey?.name !== tablePrimaryKey?.name) {
+    delayedAst.push({
+      type: "renameTableItem",
+      kind: "CONSTRAINT",
+      tableSchema: schema,
+      tableName: codeTable.table,
+      from: dbPrimaryKey.name ?? `${codeTable.table}_pkey`,
+      to: tablePrimaryKey.name ?? `${codeTable}_pkey`
+    });
+  }
+};
+
+const processIndexesAndExcludes = (config, changeTableData, ast, compareExpressions) => {
+  const codeItems = collectCodeIndexes(config, changeTableData);
+  const codeComparableItems = collectCodeComparableItems(config, codeItems);
+  const skipCodeItems = {
+    indexes: /* @__PURE__ */ new Map(),
+    excludes: /* @__PURE__ */ new Map()
+  };
+  const holdCodeItems = {
+    indexes: /* @__PURE__ */ new Map(),
+    excludes: /* @__PURE__ */ new Map()
+  };
+  const processParams = {
+    config,
+    changeTableData,
+    codeComparableItems,
+    codeItems,
+    skipCodeItems,
+    holdCodeItems,
+    // counter for async SQL comparisons that are in progress
+    wait: { indexes: 0, excludes: 0 },
+    ast,
+    compareExpressions
+  };
+  processItems(processParams, "indexes");
+  processItems(processParams, "excludes");
+  addMainItems(
+    changeTableData,
+    codeItems,
+    skipCodeItems,
+    holdCodeItems,
+    "indexes"
+  );
+  addMainItems(
+    changeTableData,
+    codeItems,
+    skipCodeItems,
+    holdCodeItems,
+    "excludes"
+  );
+};
+const processItems = ({
+  config,
+  changeTableData,
+  codeComparableItems,
+  codeItems,
+  skipCodeItems,
+  holdCodeItems,
+  wait,
+  ast,
+  compareExpressions
+}, key) => {
+  const {
+    changeTableAst: { shape }
+  } = changeTableData;
+  const dbItems = changeTableData.dbTableData[key];
+  for (const dbItem of dbItems) {
+    const hasAddedOrDroppedColumn = dbItem.columns.some(
+      (column) => "column" in column && checkForColumnAddOrDrop(shape, column.column)
+    );
+    if (hasAddedOrDroppedColumn) continue;
+    normalizeItem(dbItem);
+    const { found, rename, foundAndHasSql } = findMatchingItem(
+      dbItem,
+      codeComparableItems,
+      codeItems,
+      skipCodeItems,
+      changeTableData.codeTable.table,
+      config,
+      key
+    );
+    const { columns: dbColumns } = dbItem;
+    if (!foundAndHasSql) {
+      handleItemChange(
+        changeTableData,
+        dbItem,
+        dbColumns,
+        found[0],
+        rename[0],
+        key
+      );
+      continue;
+    }
+    for (const codeItem of found) {
+      holdCodeItems[key].set(codeItem, true);
+    }
+    const compare = [];
+    for (let i = 0; i < dbItem.columns.length; i++) {
+      const column = dbItem.columns[i];
+      if (!("expression" in column)) continue;
+      compare.push({
+        inDb: column.expression,
+        inCode: found.map(
+          (x) => x.columns[i].expression
+        )
+      });
+    }
+    if (dbItem.with) {
+      compare.push({
+        inDb: dbItem.with,
+        inCode: found.map((x) => x.options.with)
+      });
+    }
+    if (dbItem.where) {
+      compare.push({
+        inDb: dbItem.where,
+        inCode: found.map((x) => x.options.where)
+      });
+    }
+    wait[key]++;
+    compareExpressions.push({
+      compare,
+      handle(i) {
+        const codeItem = i === void 0 ? void 0 : found[i];
+        handleItemChange(
+          changeTableData,
+          dbItem,
+          dbColumns,
+          codeItem,
+          i === void 0 ? void 0 : rename[i],
+          key
+        );
+        if (codeItem) {
+          holdCodeItems[key].delete(codeItem);
+        }
+        if (!--wait[key] && holdCodeItems[key].size) {
+          addItems(changeTableData, [...holdCodeItems[key].keys()], key);
+          if (!changeTableData.pushedAst) {
+            changeTableData.pushedAst = true;
+            ast.push(changeTableData.changeTableAst);
+          }
+        }
+      }
+    });
+  }
+};
+const collectCodeIndexes = (config, { codeTable, changeTableAst: { shape } }) => {
+  const codeItems = { indexes: [], excludes: [] };
+  for (const key in codeTable.shape) {
+    const column = codeTable.shape[key];
+    if (!column.data.indexes && !column.data.excludes) continue;
+    const name = column.data.name ?? key;
+    if (checkForColumnAddOrDrop(shape, name)) continue;
+    pushCodeColumnItems(config, codeItems, key, name, column, "indexes");
+    pushCodeColumnItems(config, codeItems, key, name, column, "excludes");
+  }
+  pushCodeCompositeItems(config, codeTable, codeItems, "indexes");
+  pushCodeCompositeItems(config, codeTable, codeItems, "excludes");
+  return codeItems;
+};
+const pushCodeColumnItems = (config, codeItems, columnKey, name, column, key) => {
+  const items = column.data[key];
+  if (!items) return;
+  codeItems[key].push(
+    ...items.map(
+      ({
+        options: { collate, opclass, order, weight, ...options },
+        with: wi,
+        ...index
+      }) => {
+        const w = key === "excludes" ? wi : void 0;
+        return {
+          columns: [
+            {
+              collate,
+              opclass,
+              order,
+              weight,
+              column: name,
+              with: w
+            }
+          ],
+          ...index,
+          options: options.include ? config.snakeCase ? {
+            ...options,
+            include: toArray(options.include).map(toSnakeCase)
+          } : options : options,
+          columnKeys: [
+            {
+              collate,
+              opclass,
+              order,
+              weight,
+              column: columnKey,
+              with: w
+            }
+          ],
+          includeKeys: options.include
+        };
+      }
+    )
+  );
+};
+const pushCodeCompositeItems = (config, codeTable, codeItems, key) => {
+  const items = codeTable.internal.tableData[key];
+  if (!items) return;
+  codeItems[key].push(
+    ...items.map((x) => ({
+      ...x,
+      columns: config.snakeCase ? x.columns.map(
+        (c) => "column" in c ? { ...c, column: toSnakeCase(c.column) } : c
+      ) : x.columns,
+      columnKeys: x.columns,
+      options: x.options.include && config.snakeCase ? {
+        ...x.options,
+        include: toArray(x.options.include).map(toSnakeCase)
+      } : x.options,
+      includeKeys: x.options.include
+    }))
+  );
+};
+const collectCodeComparableItems = (config, codeItems) => {
+  return {
+    indexes: collectCodeComparableItemsType(config, codeItems, "indexes"),
+    excludes: collectCodeComparableItemsType(config, codeItems, "excludes")
+  };
+};
+const collectCodeComparableItemsType = (config, codeItems, key) => {
+  return codeItems[key].map((codeItem) => {
+    normalizeItem(codeItem.options);
+    return itemToComparable({
+      ...codeItem.options,
+      include: codeItem.options.include === void 0 ? void 0 : config.snakeCase ? toArray(codeItem.options.include).map(toSnakeCase) : toArray(codeItem.options.include),
+      columns: codeItem.columns,
+      name: codeItem.options.name,
+      columnKeys: codeItem.columnKeys,
+      includeKeys: codeItem.includeKeys
+    });
+  });
+};
+const normalizeItem = (item) => {
+  if (item.using) item.using = item.using.toLowerCase();
+  if (item.using === "btree") item.using = void 0;
+  if (!item.unique) item.unique = void 0;
+  if (item.nullsNotDistinct === false) item.nullsNotDistinct = void 0;
+  if (item.exclude) {
+    for (let i = 0; i < item.columns.length; i++) {
+      item.columns[i].with = item.exclude[i];
+    }
+  }
+};
+const itemToComparable = (index) => {
+  let hasExpression = false;
+  const columns = index.columns.map((column) => {
+    const result = {
+      ...column,
+      expression: void 0,
+      hasExpression: "expression" in column
+    };
+    if (result.hasExpression) hasExpression = true;
+    return result;
+  });
+  return {
+    ...index,
+    schemaName: void 0,
+    tableName: void 0,
+    with: void 0,
+    hasWith: !!index.with,
+    where: void 0,
+    hasWhere: !!index.where,
+    columns,
+    hasExpression
+  };
+};
+const findMatchingItem = (dbItem, codeComparableItems, codeItems, skipCodeItems, tableName, config, key) => {
+  const dbComparableItem = itemToComparable(
+    key === "indexes" ? dbItem : {
+      ...dbItem,
+      exclude: void 0,
+      columns: dbItem.columns.map((column, i) => ({
+        ...column,
+        with: dbItem.exclude[i]
+      }))
+    }
+  );
+  const { found, rename } = findMatchingItemWithoutSql(
+    dbComparableItem,
+    codeComparableItems,
+    codeItems,
+    skipCodeItems,
+    tableName,
+    config,
+    key
+  );
+  const foundAndHasSql = found.length && checkIfItemHasSql(dbComparableItem);
+  return { found, rename, foundAndHasSql };
+};
+const findMatchingItemWithoutSql = (dbItem, codeComparableItems, codeItems, skipCodeItems, tableName, config, key) => {
+  const found = [];
+  const rename = [];
+  const { columns: dbColumns, ...dbItemWithoutColumns } = dbItem;
+  for (let i = 0; i < codeComparableItems[key].length; i++) {
+    if (skipCodeItems[key].has(i)) continue;
+    const { columns: codeColumns, ...codeItem } = codeComparableItems[key][i];
+    if (dbColumns.length === codeColumns.length && !dbColumns.some((dbColumn, i2) => !deepCompare(dbColumn, codeColumns[i2]))) {
+      let a = dbItemWithoutColumns;
+      let b = codeItem;
+      const codeName = b.name ?? (key === "indexes" ? getIndexName : getExcludeName)(
+        tableName,
+        dbColumns
+      );
+      if (a.name !== b.name) {
+        a = { ...a, name: void 0 };
+        b = {
+          ...b,
+          name: void 0,
+          columnKeys: void 0,
+          includeKeys: void 0
+        };
+        if (a.language && !b.language) {
+          b.language = config.language ?? "english";
+        }
+        if (deepCompare(a, b)) {
+          found.push(codeItems[key][i]);
+          rename.push(
+            dbItemWithoutColumns.name !== codeName ? codeName : void 0
+          );
+        }
+      } else {
+        const {
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
+          columnKeys,
+          includeKeys,
+          ...codeItemWithoutKeys
+        } = codeItem;
+        if (deepCompare(dbItemWithoutColumns, codeItemWithoutKeys)) {
+          found.push(codeItems[key][i]);
+          rename.push(void 0);
+        }
+      }
+      if (found.length && !checkIfItemHasSql(codeItem)) {
+        skipCodeItems[key].set(i, true);
+      }
+    }
+  }
+  return { found, rename };
+};
+const checkIfItemHasSql = (x) => x.hasWith || x.hasWhere || x.hasExpression;
+const handleItemChange = ({
+  changeTableAst,
+  schema,
+  codeTable,
+  changingColumns,
+  delayedAst
+}, dbItem, dbColumns, found, rename, key) => {
+  var _a, _b;
+  if (!found) {
+    const name = dbItem.name === (key === "indexes" ? getIndexName : getExcludeName)(
+      changeTableAst.name,
+      dbColumns
+    ) ? void 0 : dbItem.name;
+    if (dbColumns.length === 1 && "column" in dbColumns[0]) {
+      const dbColumn = dbColumns[0];
+      const column = changingColumns[dbColumn.column];
+      if (column) {
+        ((_a = column.from.data)[key] ?? (_a[key] = [])).push({
+          options: { ...dbItem, name },
+          with: key === "indexes" ? void 0 : dbColumn.with
+        });
+        return;
+      }
+    }
+    ((_b = changeTableAst.drop)[key] ?? (_b[key] = [])).push({
+      columns: dbColumns,
+      options: { ...dbItem, name }
+    });
+  } else if (rename) {
+    delayedAst.push({
+      type: "renameTableItem",
+      kind: key === "indexes" ? "INDEX" : "CONSTRAINT",
+      tableSchema: schema,
+      tableName: codeTable.table,
+      from: dbItem.name,
+      to: rename
+    });
+  }
+};
+const addMainItems = (changeTableData, codeItems, skipCodeItems, holdCodeItems, key) => {
+  const itemsToAdd = codeItems[key].filter(
+    (item, i) => !skipCodeItems[key].has(i) && !holdCodeItems[key].has(item)
+  );
+  if (itemsToAdd.length) {
+    addItems(
+      changeTableData,
+      itemsToAdd.map((x) => ({
+        ...x,
+        columns: x.columnKeys,
+        columnNames: x.columns,
+        options: x.options.include ? { ...x.options, include: x.includeKeys } : x.options
+      })),
+      key
+    );
+  }
+};
+const addItems = ({ changeTableAst, changingColumns }, add, key) => {
+  var _a, _b;
+  const items = (_a = changeTableAst.add)[key] ?? (_a[key] = []);
+  for (const item of add) {
+    if (item.columns.length === 1 && "column" in item.columns[0]) {
+      const column = changingColumns[(item.columnNames || item.columns)[0].column];
+      if (column) {
+        ((_b = column.to.data)[key] ?? (_b[key] = [])).push(
+          key === "indexes" ? item : {
+            ...item,
+            with: item.columns[0].with
+          }
+        );
+        continue;
+      }
+    }
+    items.push(item);
+  }
+};
+
+const mapMatchToDb = {
+  FULL: "f",
+  PARTIAL: "p",
+  SIMPLE: "s"
+};
+const mapMatchToCode = {};
+for (const key in mapMatchToDb) {
+  mapMatchToCode[mapMatchToDb[key]] = key;
+}
+const mapActionToDb = {
+  "NO ACTION": "a",
+  RESTRICT: "r",
+  CASCADE: "c",
+  "SET NULL": "n",
+  "SET DEFAULT": "d"
+};
+const mapActionToCode = {};
+for (const key in mapActionToDb) {
+  mapActionToCode[mapActionToDb[key]] = key;
+}
+const processForeignKeys = (config, ast, changeTables, currentSchema, tableShapes) => {
+  var _a, _b;
+  for (const changeTableData of changeTables) {
+    const codeForeignKeys = collectCodeFkeys(
+      config,
+      changeTableData,
+      currentSchema
+    );
+    const { codeTable, dbTableData, changeTableAst, schema, changingColumns } = changeTableData;
+    const { shape, add, drop } = changeTableAst;
+    let changed = false;
+    for (const dbConstraint of dbTableData.constraints) {
+      const { references: dbReferences } = dbConstraint;
+      if (!dbReferences) continue;
+      const hasChangedColumn = dbReferences.columns.some(
+        (column) => checkForColumnAddOrDrop(shape, column)
+      );
+      if (hasChangedColumn) continue;
+      const foreignShape = tableShapes[`${dbReferences.foreignSchema}.${dbReferences.foreignTable}`];
+      const hasForeignChangedColumn = foreignShape && dbReferences.foreignColumns.some((column) => {
+        const res = checkForColumnAddOrDrop(foreignShape, column);
+        return res;
+      });
+      if (hasForeignChangedColumn) continue;
+      let found = false;
+      let rename;
+      for (let i = 0; i < codeForeignKeys.length; i++) {
+        const codeForeignKey = codeForeignKeys[i];
+        const codeReferences = codeForeignKey.references;
+        if (deepCompare(dbReferences, codeReferences)) {
+          found = true;
+          codeForeignKeys.splice(i, 1);
+          const codeName = codeForeignKey.codeConstraint.name ?? getConstraintName(
+            codeTable.table,
+            codeForeignKey,
+            config.snakeCase
+          );
+          if (codeName !== dbConstraint.name) {
+            rename = codeName;
+          }
+        }
+      }
+      if (!found) {
+        const foreignKey = dbForeignKeyToCodeForeignKey(
+          config,
+          dbConstraint,
+          dbReferences
+        );
+        if (dbReferences.columns.length === 1 && changingColumns[dbReferences.columns[0]]) {
+          const column = changingColumns[dbReferences.columns[0]];
+          ((_a = column.from.data).foreignKeys ?? (_a.foreignKeys = [])).push({
+            fnOrTable: foreignKey.references.fnOrTable,
+            foreignColumns: foreignKey.references.foreignColumns,
+            options: foreignKey.references.options
+          });
+        } else {
+          (drop.constraints ?? (drop.constraints = [])).push(foreignKey);
+        }
+        changed = true;
+      } else if (rename) {
+        ast.push({
+          type: "renameTableItem",
+          kind: "CONSTRAINT",
+          tableSchema: schema,
+          tableName: codeTable.table,
+          from: dbConstraint.name,
+          to: rename
+        });
+      }
+    }
+    if (codeForeignKeys.length) {
+      const constraints = add.constraints ?? (add.constraints = []);
+      for (const { codeConstraint, references } of codeForeignKeys) {
+        if (references.columns.length === 1 && changingColumns[references.columns[0]]) {
+          const column = changingColumns[references.columns[0]];
+          ((_b = column.to.data).foreignKeys ?? (_b.foreignKeys = [])).push({
+            fnOrTable: references.foreignTable,
+            foreignColumns: codeConstraint.references.foreignColumns,
+            options: codeConstraint.references.options
+          });
+        } else {
+          constraints.push(codeConstraint);
+        }
+      }
+      changed = true;
+    }
+    if (changed && !changeTableData.pushedAst) {
+      changeTableData.pushedAst = true;
+      ast.push(changeTableData.changeTableAst);
+    }
+  }
+};
+const collectCodeFkeys = (config, { codeTable, changeTableAst: { shape } }, currentSchema) => {
+  const codeForeignKeys = [];
+  for (const key in codeTable.shape) {
+    const column = codeTable.shape[key];
+    if (!column.data.foreignKeys) continue;
+    const name = column.data.name ?? key;
+    if (checkForColumnAddOrDrop(shape, name)) continue;
+    codeForeignKeys.push(
+      ...column.data.foreignKeys.map((x) => {
+        const columns = [name];
+        const fnOrTable = fnOrTableToString(x.fnOrTable);
+        return parseForeignKey(
+          config,
+          {
+            name: x.options?.name,
+            references: {
+              columns: [name],
+              fnOrTable,
+              foreignColumns: x.foreignColumns,
+              options: x.options
+            }
+          },
+          {
+            columns,
+            fnOrTable,
+            foreignColumns: x.foreignColumns,
+            options: x.options
+          },
+          currentSchema
+        );
+      })
+    );
+  }
+  if (codeTable.internal.tableData.constraints) {
+    for (const tableConstraint of codeTable.internal.tableData.constraints) {
+      const { references: refs } = tableConstraint;
+      if (!refs) continue;
+      const fnOrTable = fnOrTableToString(refs.fnOrTable);
+      codeForeignKeys.push(
+        parseForeignKey(
+          config,
+          {
+            ...tableConstraint,
+            references: {
+              ...refs,
+              fnOrTable
+            }
+          },
+          {
+            ...refs,
+            fnOrTable,
+            columns: config.snakeCase ? refs.columns.map(toSnakeCase) : refs.columns,
+            foreignColumns: config.snakeCase ? refs.foreignColumns.map(toSnakeCase) : refs.foreignColumns
+          },
+          currentSchema
+        )
+      );
+    }
+  }
+  return codeForeignKeys;
+};
+const fnOrTableToString = (fnOrTable) => {
+  if (typeof fnOrTable !== "string") {
+    const { schema, table } = new (fnOrTable())();
+    fnOrTable = concatSchemaAndName({ schema, name: table });
+  }
+  return fnOrTable;
+};
+const parseForeignKey = (config, codeConstraint, references, currentSchema) => {
+  const { fnOrTable, columns, foreignColumns, options } = references;
+  const [schema, table] = getSchemaAndTableFromName(fnOrTable);
+  return {
+    references: {
+      foreignSchema: schema ?? currentSchema,
+      foreignTable: table,
+      columns,
+      foreignColumns: config.snakeCase ? foreignColumns.map(toSnakeCase) : foreignColumns,
+      match: mapMatchToDb[options?.match || "SIMPLE"],
+      onUpdate: mapActionToDb[options?.onUpdate || "NO ACTION"],
+      onDelete: mapActionToDb[options?.onDelete || "NO ACTION"]
+    },
+    codeConstraint
+  };
+};
+const dbForeignKeyToCodeForeignKey = (config, dbConstraint, dbReferences) => ({
+  name: dbConstraint.name === getConstraintName(
+    dbConstraint.tableName,
+    { references: dbReferences },
+    config.snakeCase
+  ) ? void 0 : dbConstraint.name,
+  references: {
+    columns: dbReferences.columns,
+    fnOrTable: `${dbReferences.foreignSchema}.${dbReferences.foreignTable}`,
+    foreignColumns: dbReferences.foreignColumns,
+    options: {
+      match: dbReferences.match === "s" ? void 0 : mapMatchToCode[dbReferences.match],
+      onUpdate: dbReferences.onUpdate === "a" ? void 0 : mapActionToCode[dbReferences.onUpdate],
+      onDelete: dbReferences.onDelete === "a" ? void 0 : mapActionToCode[dbReferences.onDelete]
+    }
+  }
+});
+
+const processChecks = (ast, changeTableData, compareExpressions) => {
+  const codeChecks = collectCodeChecks(changeTableData);
+  const {
+    dbTableData,
+    changeTableAst: { add, shape }
+  } = changeTableData;
+  const hasDbChecks = dbTableData.constraints.some((c) => c.check);
+  if (!hasDbChecks) {
+    if (codeChecks.length) {
+      const constraints = add.constraints ?? (add.constraints = []);
+      for (const codeCheck of codeChecks) {
+        if (!codeCheck.column || !changeTableData.changingColumns[codeCheck.column]) {
+          constraints.push({
+            check: codeCheck.check.sql,
+            name: codeCheck.name
+          });
+        }
+      }
+    }
+    return;
+  }
+  let wait = 0;
+  const foundCodeChecks = /* @__PURE__ */ new Set();
+  for (const dbConstraint of dbTableData.constraints) {
+    const { check: dbCheck, name } = dbConstraint;
+    if (!dbCheck) continue;
+    const hasChangedColumn = dbCheck.columns?.some(
+      (column) => checkForColumnAddOrDrop(shape, column)
+    );
+    if (hasChangedColumn) continue;
+    if (codeChecks.length) {
+      wait++;
+      compareExpressions.push({
+        compare: [
+          {
+            inDb: dbCheck.expression,
+            inCode: codeChecks.map(({ check }) => check.sql)
+          }
+        ],
+        handle(i) {
+          if (i !== void 0) {
+            foundCodeChecks.add(i);
+          } else {
+            dropCheck(changeTableData, dbCheck, name);
+          }
+          if (--wait !== 0) return;
+          const checksToAdd = [];
+          codeChecks.forEach((check, i2) => {
+            if (foundCodeChecks.has(i2)) {
+              if (!check.column) return;
+              const change = changeTableData.changingColumns[check.column];
+              if (!change) return;
+              const columnChecks = change.to.data.checks;
+              if (!columnChecks) return;
+              const i3 = columnChecks.indexOf(check.check);
+              if (i3 !== -1) {
+                columnChecks.splice(i3, 1);
+              }
+              return;
+            }
+            checksToAdd.push({
+              name: check.name,
+              check: check.check.sql
+            });
+          });
+          if (checksToAdd.length) {
+            (add.constraints ?? (add.constraints = [])).push(...checksToAdd);
+          }
+          if (!changeTableData.pushedAst && (changeTableData.changeTableAst.drop.constraints?.length || add.constraints?.length)) {
+            changeTableData.pushedAst = true;
+            ast.push(changeTableData.changeTableAst);
+          }
+        }
+      });
+    } else {
+      dropCheck(changeTableData, dbCheck, name);
+    }
+  }
+};
+const collectCodeChecks = ({
+  codeTable,
+  changeTableAst: { shape }
+}) => {
+  const names = /* @__PURE__ */ new Set();
+  const codeChecks = [];
+  for (const key in codeTable.shape) {
+    const column = codeTable.shape[key];
+    if (!column.data.checks) continue;
+    const columnName = column.data.name ?? key;
+    if (checkForColumnAddOrDrop(shape, columnName)) continue;
+    const baseName = `${codeTable.table}_${columnName}_check`;
+    codeChecks.push(
+      ...column.data.checks.map((check) => {
+        const name = check.name || getFreeSetAlias(names, baseName, 1);
+        names.add(name);
+        return {
+          check,
+          name,
+          column: columnName
+        };
+      })
+    );
+  }
+  if (codeTable.internal.tableData.constraints) {
+    for (const constraint of codeTable.internal.tableData.constraints) {
+      const { check } = constraint;
+      if (check) {
+        const baseName = `${codeTable.table}_check`;
+        const name = constraint.name || getFreeSetAlias(names, baseName, 1);
+        names.add(name);
+        codeChecks.push({
+          check: { sql: check, name: constraint.name },
+          name
+        });
+      }
+    }
+  }
+  return codeChecks;
+};
+const dropCheck = ({ changeTableAst: { drop }, changingColumns }, dbCheck, name) => {
+  var _a;
+  const sql = new RawSql([
+    [dbCheck.expression]
+  ]);
+  if (dbCheck.columns?.length === 1 && changingColumns[dbCheck.columns[0]]) {
+    const column = changingColumns[dbCheck.columns[0]];
+    column.from.data.name = "i_d";
+    ((_a = column.from.data).checks ?? (_a.checks = [])).push({
+      name,
+      sql
+    });
+  } else {
+    (drop.constraints ?? (drop.constraints = [])).push({
+      name,
+      check: sql
+    });
+  }
+};
+
+const processTables = async (ast, domainsMap, adapter, dbStructure, config, {
+  structureToAstCtx,
+  codeItems: { tables },
+  currentSchema,
+  internal: { generatorIgnore },
+  verifying
+}, pendingDbTypes) => {
+  const createTables = collectCreateTables(
+    tables,
+    dbStructure,
+    currentSchema
+  );
+  const compareSql = { values: [], expressions: [] };
+  const tableExpressions = [];
+  const { changeTables, changeTableSchemas, dropTables, tableShapes } = collectChangeAndDropTables(
+    config,
+    tables,
+    dbStructure,
+    currentSchema,
+    createTables,
+    generatorIgnore
+  );
+  applyChangeTableSchemas(changeTableSchemas, currentSchema, ast);
+  await applyCreateOrRenameTables(
+    dbStructure,
+    createTables,
+    dropTables,
+    changeTables,
+    tableShapes,
+    currentSchema,
+    ast,
+    verifying
+  );
+  await applyChangeTables(
+    adapter,
+    changeTables,
+    structureToAstCtx,
+    dbStructure,
+    domainsMap,
+    ast,
+    currentSchema,
+    config,
+    compareSql,
+    tableExpressions,
+    verifying,
+    pendingDbTypes
+  );
+  processForeignKeys(config, ast, changeTables, currentSchema, tableShapes);
+  await Promise.all([
+    applyCompareSql(compareSql, adapter),
+    compareSqlExpressions(tableExpressions, adapter)
+  ]);
+  for (const dbTable of dropTables) {
+    ast.push(
+      tableToAst(structureToAstCtx, dbStructure, dbTable, "drop", domainsMap)
+    );
+  }
+};
+const collectCreateTables = (tables, dbStructure, currentSchema) => {
+  return tables.reduce((acc, codeTable) => {
+    const tableSchema = codeTable.q.schema ?? currentSchema;
+    const hasDbTable = dbStructure.tables.some(
+      (t) => t.name === codeTable.table && t.schemaName === tableSchema
+    );
+    if (!hasDbTable) {
+      acc.push(codeTable);
+    }
+    return acc;
+  }, []);
+};
+const collectChangeAndDropTables = (config, tables, dbStructure, currentSchema, createTables, generatorIgnore) => {
+  const changeTables = [];
+  const changeTableSchemas = [];
+  const dropTables = [];
+  const tableShapes = {};
+  const ignoreTables = generatorIgnore?.tables?.map((name) => {
+    const [schema = currentSchema, table] = getSchemaAndTableFromName(name);
+    return { schema, table };
+  });
+  for (const dbTable of dbStructure.tables) {
+    if (dbTable.name === config.migrationsTable || generatorIgnore?.schemas?.includes(dbTable.schemaName) || ignoreTables?.some(
+      ({ schema, table }) => table === dbTable.name && schema === dbTable.schemaName
+    ))
+      continue;
+    const codeTable = tables.find(
+      (t) => t.table === dbTable.name && (t.q.schema ?? currentSchema) === dbTable.schemaName
+    );
+    if (codeTable) {
+      addChangeTable(
+        dbStructure,
+        changeTables,
+        tableShapes,
+        currentSchema,
+        dbTable,
+        codeTable
+      );
+      continue;
+    }
+    const i = createTables.findIndex((t) => t.table === dbTable.name);
+    if (i !== -1) {
+      const codeTable2 = createTables[i];
+      createTables.splice(i, 1);
+      changeTableSchemas.push({ codeTable: codeTable2, dbTable });
+      continue;
+    }
+    dropTables.push(dbTable);
+  }
+  return { changeTables, changeTableSchemas, dropTables, tableShapes };
+};
+const applyChangeTableSchemas = (changeTableSchemas, currentSchema, ast) => {
+  for (const { codeTable, dbTable } of changeTableSchemas) {
+    const fromSchema = dbTable.schemaName;
+    const toSchema = codeTable.q.schema ?? currentSchema;
+    ast.push({
+      type: "renameType",
+      kind: "TABLE",
+      fromSchema,
+      from: dbTable.name,
+      toSchema,
+      to: dbTable.name
+    });
+  }
+};
+const applyChangeTables = async (adapter, changeTables, structureToAstCtx, dbStructure, domainsMap, ast, currentSchema, config, compareSql, tableExpressions, verifying, pendingDbTypes) => {
+  const compareExpressions = [];
+  const typeCastsCache = {};
+  for (const changeTableData of changeTables) {
+    compareExpressions.length = 0;
+    await processTableChange(
+      adapter,
+      structureToAstCtx,
+      dbStructure,
+      domainsMap,
+      ast,
+      currentSchema,
+      config,
+      changeTableData,
+      compareSql,
+      compareExpressions,
+      typeCastsCache,
+      verifying
+    );
+    if (compareExpressions.length) {
+      const { codeTable } = changeTableData;
+      const names = [];
+      const types = [];
+      for (const key in codeTable.shape) {
+        const column = codeTable.shape[key];
+        if (!column.dataType) continue;
+        const name = column.data.name ?? key;
+        const type = getColumnDbTypeForComparison(column, currentSchema);
+        if (!pendingDbTypes.set.has(type)) {
+          names.push(name);
+          types.push(type);
+        }
+      }
+      const tableName = codeTable.table;
+      const source = `(VALUES (${types.map((x) => `NULL::${x}`).join(", ")})) "${tableName}"(${names.map((x) => `"${x}"`).join(", ")})`;
+      tableExpressions.push(
+        ...compareExpressions.map((x) => ({ ...x, source }))
+      );
+    }
+  }
+};
+const getColumnDbTypeForComparison = (column, currentSchema) => {
+  if (column instanceof ArrayColumn) {
+    return getColumnDbTypeForComparison(column.data.item, currentSchema) + "[]".repeat(column.data.arrayDims);
+  }
+  let type = column instanceof EnumColumn ? column.enumName : column.dataType;
+  const i = type.indexOf("(");
+  let append = "";
+  if (i !== -1) {
+    type = type.slice(0, i);
+    append = type.slice(i);
+  }
+  const j = type.indexOf(".");
+  if (j === -1) {
+    let result = `"${type}"${append}`;
+    if (column.data.isOfCustomType || column instanceof EnumColumn) {
+      result = `"${currentSchema}".${result}`;
+    }
+    return result;
+  } else {
+    return `"${type.slice(j)}"."${type.slice(0, j)}"${append}`;
+  }
+};
+const applyCompareSql = async (compareSql, adapter) => {
+  if (compareSql.expressions.length) {
+    const {
+      rows: [results]
+    } = await adapter.arrays(
+      "SELECT " + compareSql.expressions.map((x) => `${x.inDb} = (${x.inCode})`).join(", "),
+      compareSql.values
+    );
+    for (let i = 0; i < results.length; i++) {
+      if (!results[i]) {
+        compareSql.expressions[i].change();
+      }
+    }
+  }
+};
+const applyCreateOrRenameTables = async (dbStructure, createTables, dropTables, changeTables, tableShapes, currentSchema, ast, verifying) => {
+  for (const codeTable of createTables) {
+    if (dropTables.length) {
+      const i = await promptCreateOrRename(
+        "table",
+        codeTable.table,
+        dropTables.map((x) => x.name),
+        verifying
+      );
+      if (i) {
+        const dbTable = dropTables[i - 1];
+        dropTables.splice(i - 1, 1);
+        ast.push({
+          type: "renameType",
+          kind: "TABLE",
+          fromSchema: dbTable.schemaName,
+          from: dbTable.name,
+          toSchema: codeTable.q.schema ?? currentSchema,
+          to: codeTable.table
+        });
+        addChangeTable(
+          dbStructure,
+          changeTables,
+          tableShapes,
+          currentSchema,
+          dbTable,
+          codeTable
+        );
+        continue;
+      }
+    }
+    ast.push(createTableAst(currentSchema, codeTable));
+  }
+};
+const addChangeTable = (dbStructure, changeTables, tableShapes, currentSchema, dbTable, codeTable) => {
+  const shape = {};
+  const schema = codeTable.q.schema ?? currentSchema;
+  changeTables.push({
+    codeTable: cloneCodeTableForChange(codeTable),
+    dbTable,
+    dbTableData: getDbStructureTableData(dbStructure, dbTable),
+    schema,
+    changeTableAst: {
+      type: "changeTable",
+      schema,
+      name: codeTable.table,
+      shape,
+      add: {},
+      drop: {}
+    },
+    pushedAst: false,
+    changingColumns: {},
+    delayedAst: []
+  });
+  tableShapes[`${schema}.${codeTable.table}`] = shape;
+};
+const cloneCodeTableForChange = (codeTable) => ({
+  ...codeTable,
+  // codeTable is a class instance and not all props can be cloned with `...`
+  table: codeTable.table,
+  shape: Object.fromEntries(
+    Object.entries(codeTable.shape).map(([key, column]) => {
+      const cloned = Object.create(column);
+      cloned.data = {
+        ...cloned.data,
+        checks: cloned.data.checks && [...cloned.data.checks]
+      };
+      return [key, cloned];
+    })
+  )
+});
+const createTableAst = (currentSchema, table) => {
+  return {
+    type: "table",
+    action: "create",
+    schema: table.q.schema === currentSchema ? void 0 : table.q.schema,
+    comment: table.internal.comment,
+    name: table.table,
+    shape: makeTableShape(table),
+    noPrimaryKey: table.internal.noPrimaryKey ? "ignore" : "error",
+    ...table.internal.tableData
+  };
+};
+const makeTableShape = (table) => {
+  const shape = {};
+  for (const key in table.shape) {
+    const column = table.shape[key];
+    if (!(column instanceof VirtualColumn)) {
+      shape[key] = column;
+    }
+  }
+  return shape;
+};
+const processTableChange = async (adapter, structureToAstCtx, dbStructure, domainsMap, ast, currentSchema, config, changeTableData, compareSql, compareExpressions, typeCastsCache, verifying) => {
+  await processColumns(
+    adapter,
+    config,
+    structureToAstCtx,
+    dbStructure,
+    domainsMap,
+    changeTableData,
+    ast,
+    currentSchema,
+    compareSql,
+    typeCastsCache,
+    verifying
+  );
+  processPrimaryKey(config, changeTableData);
+  processIndexesAndExcludes(config, changeTableData, ast, compareExpressions);
+  processChecks(ast, changeTableData, compareExpressions);
+  const { changeTableAst } = changeTableData;
+  if (Object.keys(changeTableAst.shape).length || Object.keys(changeTableAst.add).length || Object.keys(changeTableAst.drop).length) {
+    changeTableData.pushedAst = true;
+    ast.push(changeTableAst);
+  }
+  if (changeTableData.delayedAst.length) {
+    ast.push(...changeTableData.delayedAst);
+  }
+};
+
+class PendingDbTypes {
+  constructor() {
+    this.set = /* @__PURE__ */ new Set();
+  }
+  add(schemaName = "public", name) {
+    this.set.add(`"${schemaName}"."${name}"`);
+  }
+}
+const composeMigration = async (adapter, config, ast, dbStructure, params) => {
+  const { structureToAstCtx, currentSchema } = params;
+  const domainsMap = makeDomainsMap(structureToAstCtx, dbStructure);
+  await processSchemas(ast, dbStructure, params);
+  processExtensions(ast, dbStructure, params);
+  const pendingDbTypes = new PendingDbTypes();
+  await processDomains(
+    ast,
+    adapter,
+    domainsMap,
+    dbStructure,
+    params,
+    pendingDbTypes
+  );
+  await processEnums(ast, dbStructure, params, pendingDbTypes);
+  await processTables(
+    ast,
+    domainsMap,
+    adapter,
+    dbStructure,
+    config,
+    params,
+    pendingDbTypes
+  );
+  return astToMigration(currentSchema, config, ast);
+};
+
+const rollbackErr = new Error("Rollback");
+const verifyMigration = async (adapter, config, migrationCode, generateMigrationParams) => {
+  const migrationFn = new Function("change", migrationCode);
+  let code;
+  try {
+    await adapter.transaction(void 0, async (trx) => {
+      const changeFns = [];
+      migrationFn((changeCb) => {
+        changeFns.push(changeCb);
+      });
+      const { log } = config;
+      config.log = false;
+      const db = createMigrationInterface(trx, true, config);
+      config.log = log;
+      for (const changeFn of changeFns) {
+        await changeFn(db, true);
+      }
+      const dbStructure = await introspectDbSchema(trx);
+      generateMigrationParams.verifying = true;
+      try {
+        code = await composeMigration(
+          trx,
+          config,
+          [],
+          dbStructure,
+          generateMigrationParams
+        );
+      } catch (err) {
+        if (err instanceof AbortSignal) {
+          code = false;
+          throw rollbackErr;
+        }
+        throw err;
+      }
+      throw rollbackErr;
+    });
+  } catch (err) {
+    if (err !== rollbackErr) {
+      throw err;
+    }
+  }
+  return code;
+};
+
+const report = (ast, config, currentSchema) => {
+  if (!config.logger) return;
+  const code = [];
+  let green, red, yellow, pale;
+  if (typeof config.log === "object" && config.log.colors === false) {
+    green = red = yellow = pale = (s) => s;
+  } else {
+    ({ green, red, yellow, pale } = colors);
+  }
+  for (const a of ast) {
+    switch (a.type) {
+      case "table": {
+        let hasPrimaryKey = !!a.primaryKey;
+        const counters = {
+          column: 0,
+          index: a.indexes?.length ?? 0,
+          exclude: a.excludes?.length ?? 0,
+          "foreign key": a.constraints?.reduce(
+            (sum, c) => c.references ? sum + 1 : sum,
+            0
+          ) ?? 0,
+          check: a.constraints?.reduce(
+            (sum, c) => c.check ? sum + 1 : sum,
+            0
+          ) ?? 0
+        };
+        for (const key in a.shape) {
+          counters.column++;
+          const column = a.shape[key];
+          if (column.data.primaryKey) {
+            hasPrimaryKey = true;
+          }
+          if (column.data.indexes) {
+            counters.index += column.data.indexes.length;
+          }
+          if (column.data.excludes) {
+            counters.exclude += column.data.excludes.length;
+          }
+          if (column.data.foreignKeys) {
+            counters["foreign key"] += column.data.foreignKeys.length;
+          }
+          if (column.data.checks) {
+            counters.check += column.data.checks.length;
+          }
+        }
+        const summary = [];
+        for (const key in counters) {
+          const value = counters[key];
+          if (value || key === "column") {
+            summary.push(
+              `${value} ${pluralize(key, value, key === "index" ? "es" : "s")}`
+            );
+          }
+        }
+        if (!hasPrimaryKey) {
+          summary.push("no primary key");
+        }
+        code.push(
+          `${a.action === "create" ? green("+ create table") : red("- drop table")} ${dbItemName(a, currentSchema)} (${summary.join(", ")})`
+        );
+        break;
+      }
+      case "changeTable": {
+        const inner = [];
+        const toCodeCtx = {
+          t: "t",
+          table: a.name,
+          currentSchema,
+          migration: true,
+          snakeCase: config.snakeCase
+        };
+        for (const key in a.shape) {
+          const changes = toArray(a.shape[key]);
+          for (const change of changes) {
+            if (change.type === "add" || change.type === "drop") {
+              const column = change.item;
+              const { primaryKey, indexes, excludes, foreignKeys, checks } = column.data;
+              inner.push(
+                `${change.type === "add" ? green("+ add column") : red("- drop column")} ${key} ${column.data.alias ?? getColumnDbType(column, currentSchema)}${column.data.isNullable ? " nullable" : ""}${primaryKey ? " primary key" : ""}${foreignKeys ? ` references ${foreignKeys.map((fk) => {
+                  return `${fnOrTableToString(
+                    fk.fnOrTable
+                  )}(${fk.foreignColumns.join(", ")})`;
+                }).join(", ")}` : ""}${indexes?.length ? indexes.length === 1 ? ", has index" : `, has ${indexes.length} indexes` : ""}${excludes?.length ? excludes.length === 1 ? ", has exclude" : `, has ${excludes.length} excludes` : ""}${checks?.length ? `, checks ${checks.map((check) => check.sql.toSQL({ values: [] })).join(", ")}` : ""}`
+              );
+            } else if (change.type === "change") {
+              let name = change.from.column?.data.name ?? key;
+              if (config.snakeCase) name = toCamelCase(name);
+              const changes2 = [];
+              inner.push(`${yellow("~ change column")} ${name}:`, changes2);
+              changes2.push(`${yellow("from")}: `);
+              const fromCode = change.from.column.toCode(toCodeCtx, key);
+              for (const code2 of fromCode) {
+                addCode(changes2, code2);
+              }
+              changes2.push(`  ${yellow("to")}: `);
+              const toCode = change.to.column.toCode(toCodeCtx, key);
+              for (const code2 of toCode) {
+                addCode(changes2, code2);
+              }
+            } else if (change.type === "rename") {
+              inner.push(
+                `${yellow("~ rename column")} ${config.snakeCase ? toCamelCase(key) : key} ${yellow("=>")} ${change.name}`
+              );
+            } else {
+              exhaustive(change.type);
+            }
+          }
+        }
+        if (a.drop.primaryKey) {
+          inner.push(
+            `${red(`- drop primary key`)} on (${a.drop.primaryKey.columns.join(
+              ", "
+            )})`
+          );
+        }
+        if (a.drop.indexes) {
+          for (const index of a.drop.indexes) {
+            inner.push(
+              `${red(
+                `- drop${index.options.unique ? " unique" : ""} index`
+              )} on (${index.columns.map((c) => "column" in c ? c.column : c.expression).join(", ")})`
+            );
+          }
+        }
+        if (a.drop.excludes) {
+          for (const exclude of a.drop.excludes) {
+            inner.push(
+              `${red(`- drop exclude`)} on (${exclude.columns.map((c) => "column" in c ? c.column : c.expression).join(", ")})`
+            );
+          }
+        }
+        if (a.drop.constraints) {
+          for (const { references } of a.drop.constraints) {
+            if (!references) continue;
+            const [schema, name] = getSchemaAndTableFromName(
+              references.fnOrTable
+            );
+            inner.push(
+              `${red(`- drop foreign key`)} on (${references.columns.join(
+                ", "
+              )}) to ${dbItemName(
+                {
+                  schema,
+                  name
+                },
+                currentSchema
+              )}(${references.foreignColumns.join(", ")})`
+            );
+          }
+          for (const { check } of a.drop.constraints) {
+            if (!check) continue;
+            inner.push(`${red(`- drop check`)} ${check.toSQL({ values: [] })}`);
+          }
+        }
+        if (a.add.primaryKey) {
+          inner.push(
+            `${green(`+ add primary key`)} on (${a.add.primaryKey.columns.join(
+              ", "
+            )})`
+          );
+        }
+        if (a.add.indexes) {
+          for (const index of a.add.indexes) {
+            inner.push(
+              `${green(
+                `+ add${index.options.unique ? " unique" : ""} index`
+              )} on (${index.columns.map((c) => "column" in c ? c.column : c.expression).join(", ")})`
+            );
+          }
+        }
+        if (a.add.excludes) {
+          for (const exclude of a.add.excludes) {
+            inner.push(
+              `${green(`+ add exclude`)} on (${exclude.columns.map((c) => "column" in c ? c.column : c.expression).join(", ")})`
+            );
+          }
+        }
+        if (a.add.constraints) {
+          for (const { references } of a.add.constraints) {
+            if (!references) continue;
+            inner.push(
+              `${green(`+ add foreign key`)} on (${references.columns.join(
+                ", "
+              )}) to ${references.fnOrTable}(${references.foreignColumns.join(", ")})`
+            );
+          }
+          for (const { check } of a.add.constraints) {
+            if (!check) continue;
+            inner.push(
+              `${green(`+ add check`)} ${check.toSQL({ values: [] })}`
+            );
+          }
+        }
+        code.push(
+          `${yellow("~ change table")} ${dbItemName(a, currentSchema)}${inner.length ? ":" : ""}`
+        );
+        if (inner.length) {
+          code.push(inner);
+        }
+        break;
+      }
+      case "schema": {
+        code.push(
+          `${a.action === "create" ? green("+ create schema") : red("- drop schema")} ${a.name}`
+        );
+        break;
+      }
+      case "renameSchema": {
+        code.push(
+          `${yellow("~ rename schema")} ${a.from} ${yellow("=>")} ${a.to}`
+        );
+        break;
+      }
+      case "renameType": {
+        code.push(
+          `${yellow(
+            `~ ${a.fromSchema !== a.toSchema ? a.from !== a.to ? "change schema and rename" : "change schema of" : "rename"} ${a.kind.toLowerCase()}`
+          )} ${dbItemName(
+            {
+              schema: a.fromSchema,
+              name: a.from
+            },
+            currentSchema
+          )} ${yellow("=>")} ${dbItemName(
+            {
+              schema: a.toSchema,
+              name: a.to
+            },
+            currentSchema
+          )}`
+        );
+        break;
+      }
+      case "extension": {
+        code.push(
+          `${a.action === "create" ? green("+ create extension") : red("- drop extension")} ${dbItemName(a, currentSchema)}${a.version ? ` ${pale(a.version)}` : ""}`
+        );
+        break;
+      }
+      case "enum": {
+        code.push(
+          `${a.action === "create" ? green("+ create enum") : red("- drop enum")} ${dbItemName(a, currentSchema)}: (${a.values.join(", ")})`
+        );
+        break;
+      }
+      case "enumValues": {
+        code.push(
+          `${a.action === "add" ? green("+ add values to enum") : red("- remove values from enum")} ${dbItemName(a, currentSchema)}: ${a.values.join(", ")}`
+        );
+        break;
+      }
+      case "changeEnumValues": {
+        if (a.fromValues) {
+          code.push(
+            `${red("- remove values from enum")} ${dbItemName(
+              a,
+              currentSchema
+            )}: ${a.fromValues.join(", ")}`
+          );
+        }
+        if (a.toValues) {
+          code.push(
+            `${green("+ add values to enum")} ${dbItemName(
+              a,
+              currentSchema
+            )}: ${a.toValues.join(", ")}`
+          );
+        }
+        break;
+      }
+      case "domain": {
+        code.push(
+          `${a.action === "create" ? green("+ create domain") : red("- drop domain")} ${dbItemName(a, currentSchema)}`
+        );
+        break;
+      }
+      case "view":
+      case "collation":
+      case "renameEnumValues":
+      case "constraint":
+        break;
+      case "renameTableItem": {
+        code.push(
+          `${yellow(`~ rename ${a.kind.toLowerCase()}`)} on table ${dbItemName(
+            { schema: a.tableSchema, name: a.tableName },
+            currentSchema
+          )}: ${a.from} ${yellow("=>")} ${a.to}`
+        );
+        break;
+      }
+      default:
+        exhaustive(a);
+    }
+  }
+  const result = codeToString(code, "", "  ");
+  config.logger.log(result);
+};
+const dbItemName = ({ schema, name }, currentSchema) => {
+  return schema && schema !== currentSchema ? `${schema}.${name}` : name;
+};
+
+class AbortSignal extends Error {
+}
+const generate = async (adapters, config, args, afterPull) => {
+  let { dbPath } = config;
+  if (!dbPath || !config.baseTable) throw invalidConfig(config);
+  if (!adapters.length) throw new Error(`Database options must not be empty`);
+  if (!dbPath.endsWith(".ts")) dbPath += ".ts";
+  let migrationName = args[0] ?? "generated";
+  let up;
+  if (migrationName === "up") {
+    up = true;
+    migrationName = "generated";
+  } else {
+    up = args[1] === "up";
+  }
+  if (afterPull) {
+    adapters = [afterPull.adapter];
+  }
+  const { dbStructure } = await migrateAndPullStructures(
+    adapters,
+    config,
+    afterPull
+  );
+  const [adapter] = adapters;
+  const currentSchema = adapter.schema ?? "public";
+  const db = await getDbFromConfig(config, dbPath);
+  const { columnTypes, internal } = db.$qb;
+  const codeItems = await getActualItems(
+    db,
+    currentSchema,
+    internal,
+    columnTypes
+  );
+  const structureToAstCtx = makeStructureToAstCtx(config, currentSchema);
+  const generateMigrationParams = {
+    structureToAstCtx,
+    codeItems,
+    currentSchema,
+    internal
+  };
+  const ast = [];
+  let migrationCode;
+  try {
+    migrationCode = await composeMigration(
+      adapter,
+      config,
+      ast,
+      dbStructure,
+      generateMigrationParams
+    );
+  } catch (err) {
+    if (err instanceof AbortSignal) {
+      await closeAdapters(adapters);
+      return;
+    }
+    throw err;
+  }
+  if (migrationCode && !afterPull) {
+    const result = await verifyMigration(
+      adapter,
+      config,
+      migrationCode,
+      generateMigrationParams
+    );
+    if (result !== void 0) {
+      throw new Error(
+        `Failed to verify generated migration: some of database changes were not applied properly. This is a bug, please open an issue, attach the following migration code:
+${migrationCode}${result === false ? "" : `
+After applying:
+${result}`}`
+      );
+    }
+  }
+  const { logger } = config;
+  if ((!up || !migrationCode) && !afterPull) await closeAdapters(adapters);
+  if (!migrationCode) {
+    logger?.log("No changes were detected");
+    return;
+  }
+  const version = afterPull?.version ?? await makeFileVersion({}, config);
+  const delayLog = [];
+  await writeMigrationFile(
+    {
+      ...config,
+      logger: logger ? { ...logger, log: (msg) => delayLog.push(msg) } : logger
+    },
+    version,
+    migrationName,
+    migrationCode
+  );
+  report(ast, config, currentSchema);
+  if (logger) {
+    for (const msg of delayLog) {
+      logger.log(`
+${msg}`);
+    }
+  }
+  if (up) {
+    for (const adapter2 of adapters) {
+      await migrateAndClose({ adapter: adapter2, config });
+    }
+  } else if (!afterPull) {
+    await closeAdapters(adapters);
+  }
+};
+const invalidConfig = (config) => new Error(
+  `\`${config.dbPath ? "baseTable" : "dbPath"}\` setting must be set in the migrations config for the generator to work`
+);
+const getDbFromConfig = async (config, dbPath) => {
+  const module = await config.import(
+    pathToFileURL(path.resolve(config.basePath, dbPath)).toString()
+  );
+  const db = module[config.dbExportedAs ?? "db"];
+  if (!db?.$qb) {
+    throw new Error(
+      `Unable to import OrchidORM instance as ${config.dbExportedAs ?? "db"} from ${config.dbPath}`
+    );
+  }
+  return db;
+};
+const migrateAndPullStructures = async (adapters, config, afterPull) => {
+  if (afterPull) {
+    return {
+      dbStructure: {
+        schemas: [],
+        tables: [],
+        views: [],
+        indexes: [],
+        excludes: [],
+        constraints: [],
+        triggers: [],
+        extensions: [],
+        enums: [],
+        domains: [],
+        collations: []
+      }
+    };
+  }
+  for (const adapter of adapters) {
+    await migrate({ adapter, config });
+  }
+  const dbStructures = await Promise.all(
+    adapters.map((adapter) => introspectDbSchema(adapter))
+  );
+  const dbStructure = dbStructures[0];
+  for (let i = 1; i < dbStructures.length; i++) {
+    compareDbStructures(dbStructure, dbStructures[i], i);
+  }
+  return { dbStructure };
+};
+const compareDbStructures = (a, b, i, path2) => {
+  let err;
+  if (typeof a !== typeof b) {
+    err = true;
+  }
+  if (!a || typeof a !== "object") {
+    if (a !== b) {
+      err = true;
+    }
+  } else {
+    if (Array.isArray(a)) {
+      for (let n = 0, len = a.length; n < len; n++) {
+        compareDbStructures(
+          a[n],
+          b[n],
+          i,
+          path2 ? `${path2}[${n}]` : String(n)
+        );
+      }
+    } else {
+      for (const key in a) {
+        compareDbStructures(
+          a[key],
+          b[key],
+          i,
+          path2 ? `${path2}.${key}` : key
+        );
+      }
+    }
+  }
+  if (err) {
+    throw new Error(`${path2} in the db 0 does not match db ${i}`);
+  }
+};
+const getActualItems = async (db, currentSchema, internal, columnTypes) => {
+  const tableNames = /* @__PURE__ */ new Set();
+  const habtmTables = /* @__PURE__ */ new Map();
+  const codeItems = {
+    schemas: /* @__PURE__ */ new Set(void 0),
+    enums: /* @__PURE__ */ new Map(),
+    tables: [],
+    domains: []
+  };
+  const domains = /* @__PURE__ */ new Map();
+  for (const key in db) {
+    if (key[0] === "$") continue;
+    const table = db[key];
+    if (!table.table) {
+      throw new Error(`Table ${key} is missing table property`);
+    }
+    const { schema } = table.q;
+    const name = concatSchemaAndName({ schema, name: table.table });
+    if (tableNames.has(name)) {
+      throw new Error(`Table ${name} is defined more than once`);
+    }
+    tableNames.add(name);
+    if (schema) codeItems.schemas.add(schema);
+    codeItems.tables.push(table);
+    for (const key2 in table.relations) {
+      const column = table.shape[key2];
+      if (column && "joinTable" in column) {
+        processHasAndBelongsToManyColumn(column, habtmTables, codeItems);
+      }
+    }
+    for (const key2 in table.shape) {
+      const column = table.shape[key2];
+      if (column.data.computed) {
+        delete table.shape[key2];
+      } else if (column instanceof DomainColumn) {
+        const [schemaName = currentSchema, name2] = getSchemaAndTableFromName(
+          column.dataType
+        );
+        domains.set(column.dataType, {
+          schemaName,
+          name: name2,
+          column: column.data.as ?? new UnknownColumn(defaultSchemaConfig)
+        });
+      } else {
+        const en = column.dataType === "enum" ? column : column instanceof ArrayColumn && column.data.item.dataType === "enum" ? column.data.item : void 0;
+        if (en) {
+          processEnumColumn(en, currentSchema, codeItems);
+        }
+      }
+    }
+  }
+  if (internal.extensions) {
+    for (const extension of internal.extensions) {
+      const [schema] = getSchemaAndTableFromName(extension.name);
+      if (schema) codeItems.schemas.add(schema);
+    }
+  }
+  if (internal.domains) {
+    for (const key in internal.domains) {
+      const [schemaName = currentSchema, name] = getSchemaAndTableFromName(key);
+      const column = internal.domains[key](columnTypes);
+      domains.set(key, {
+        schemaName,
+        name,
+        column
+      });
+    }
+  }
+  for (const domain of domains.values()) {
+    codeItems.schemas.add(domain.schemaName);
+    codeItems.domains.push(domain);
+  }
+  return codeItems;
+};
+const processEnumColumn = (column, currentSchema, codeItems) => {
+  const { enumName, options } = column;
+  const [schema, name] = getSchemaAndTableFromName(enumName);
+  const enumSchema = schema ?? currentSchema;
+  codeItems.enums.set(`${enumSchema}.${name}`, {
+    schema: enumSchema,
+    name,
+    values: options
+  });
+  if (schema) codeItems.schemas.add(schema);
+};
+const processHasAndBelongsToManyColumn = (column, habtmTables, codeItems) => {
+  const q = column.joinTable;
+  const prev = habtmTables.get(q.table);
+  if (prev) {
+    for (const key in q.shape) {
+      if (q.shape[key].dataType !== prev.shape[key]?.dataType) {
+        throw new Error(
+          `Column ${key} in ${q.table} in hasAndBelongsToMany relation does not match with the relation on the other side`
+        );
+      }
+    }
+    return;
+  }
+  habtmTables.set(q.table, q);
+  const joinTable = Object.create(q);
+  const shape = {};
+  for (const key in joinTable.shape) {
+    const column2 = Object.create(joinTable.shape[key]);
+    column2.data = {
+      ...column2.data,
+      name: column2.data.name ?? key,
+      identity: void 0,
+      primaryKey: void 0,
+      default: void 0
+    };
+    shape[toCamelCase(key)] = column2;
+  }
+  joinTable.shape = shape;
+  joinTable.internal = {
+    ...joinTable.internal,
+    tableData: {
+      ...joinTable.internal.tableData,
+      primaryKey: {
+        columns: Object.keys(shape)
+      }
+    },
+    noPrimaryKey: false
+  };
+  codeItems.tables.push(joinTable);
+  return;
+};
+const closeAdapters = (adapters) => {
+  return Promise.all(adapters.map((x) => x.close()));
+};
+
+const getTableInfosAndFKeys = (asts, config) => {
+  var _a;
+  const generateTableTo = config.generateTableTo ?? ((name) => `./tables/${name}.table.ts`);
+  const tableInfos = {};
+  const fkeys = {};
+  for (const ast of asts) {
+    if (ast.type === "table") {
+      const tableKey = toCamelCase(ast.name);
+      const dbTableName = ast.schema ? `${ast.schema}.${ast.name}` : ast.name;
+      let tablePath = path.resolve(config.basePath, generateTableTo(tableKey));
+      if (!tablePath.endsWith(".ts")) tablePath += ".ts";
+      const name = toPascalCase(ast.name);
+      const info = {
+        dbTableName,
+        key: tableKey,
+        path: tablePath,
+        name,
+        className: `${name}Table`
+      };
+      tableInfos[dbTableName] = info;
+      if (ast.constraints) {
+        for (const { references } of ast.constraints) {
+          if (!references) continue;
+          (fkeys[_a = references.fnOrTable] ?? (fkeys[_a] = [])).push({
+            table: info,
+            references
+          });
+        }
+      }
+    }
+  }
+  return { tableInfos, fkeys };
+};
+const appCodeGenTable = (tableInfos, fkeys, ast, baseTablePath, baseTableExportedAs, currentSchema) => {
+  const tableInfo = tableInfos[ast.schema ? `${ast.schema}.${ast.name}` : ast.name];
+  const imports = {
+    "orchid-orm": "Selectable, Insertable, Updatable",
+    [getImportPath(tableInfo.path, baseTablePath)]: baseTableExportedAs
+  };
+  const props = [];
+  if (ast.schema) {
+    props.push(`schema = ${singleQuote(ast.schema)};`);
+  }
+  props.push(`readonly table = ${singleQuote(ast.name)};`);
+  if (ast.comment) {
+    props.push(`comment = ${singleQuote(ast.comment)};`);
+  }
+  if (ast.noPrimaryKey === "ignore") {
+    props.push("noPrimaryKey = true;");
+  }
+  const hasTableData = Boolean(
+    ast.primaryKey || ast.indexes?.length || ast.excludes?.length || ast.constraints?.length
+  );
+  const shapeCode = columnsShapeToCode(
+    { t: "t", table: ast.name, currentSchema },
+    ast.shape
+  );
+  props.push(
+    `columns = this.setColumns(${hasTableData ? "\n    " : ""}(t) => ({`,
+    hasTableData ? [shapeCode] : shapeCode,
+    hasTableData ? "  })," : "}));"
+  );
+  if (hasTableData) {
+    props.push(pushTableDataCode([], ast), ");");
+  }
+  const relations = [];
+  const fullTableName = ast.schema ? `${ast.schema}.${ast.name}` : ast.name;
+  const belongsTo = fkeys[fullTableName];
+  if (belongsTo) {
+    for (const { table, references } of belongsTo) {
+      imports[getImportPath(tableInfo.path, table.path)] = table.className;
+      relations.push(
+        `${table.key}: this.belongsTo(() => ${table.className}, {`,
+        [
+          `columns: [${references.foreignColumns.map(singleQuote).join(", ")}],`,
+          `references: [${references.columns.map(singleQuote).join(", ")}],`
+        ],
+        "}),"
+      );
+    }
+  }
+  if (ast.constraints) {
+    for (const { references } of ast.constraints) {
+      if (!references) continue;
+      const table = tableInfos[references.fnOrTable];
+      imports[getImportPath(tableInfo.path, table.path)] = table.className;
+      relations.push(
+        `${table.key}: this.hasMany(() => ${table.className}, {`,
+        [
+          `columns: [${references.columns.map(singleQuote).join(", ")}],`,
+          `references: [${references.foreignColumns.map(singleQuote).join(", ")}],`
+        ],
+        "}),"
+      );
+    }
+  }
+  if (relations.length) {
+    props.push("", "relations = {", relations, "};");
+  }
+  const importsCode = importsToCode(imports);
+  const { name, className } = tableInfo;
+  const code = [
+    `export type ${name} = Selectable<${className}>;
+export type ${name}New = Insertable<${className}>;
+export type ${name}Update = Updatable<${className}>;
+
+export class ${className} extends ${baseTableExportedAs} {`,
+    props,
+    "}\n"
+  ];
+  return {
+    ...tableInfo,
+    content: importsCode + "\n\n" + codeToString(code, "", "  ")
+  };
+};
+function importsToCode(imports) {
+  return Object.entries(imports).map(([from, name]) => `import { ${name} } from '${from}';`).join("\n");
+}
+
+const { createSourceFile, ScriptTarget, SyntaxKind } = typescript;
+const appCodeGenUpdateDbFile = async (dbPath, tables, extensions, domains, currentSchema) => {
+  const content = await fs.readFile(dbPath, "utf-8");
+  const statements = getTsStatements(content);
+  const importName = getOrchidOrmImportName(statements);
+  if (!importName) {
+    throw new Error(`Main file does not contain import of orchid-orm`);
+  }
+  const { config, tablesList } = getOrchidOrmArgs(importName, statements);
+  const changes = [];
+  let replacedConfig;
+  if (extensions.length || domains.length) {
+    let code = content.slice(config.pos, config.end).trim();
+    if (code[0] !== "{") code = `{...${code}}`;
+    code = "{\n  " + code.slice(1, -1).trim();
+    if (!code.endsWith(",")) code += ",";
+    if (extensions.length) {
+      code += `
+  extensions: [${extensions.map(
+        (ext) => ext.version ? `{ ${quoteObjectKey(ext.name, false)}: '${ext.version}' }` : singleQuote(ext.name)
+      ).join(", ")}],`;
+    }
+    if (domains.length) {
+      code += `
+  domains: {
+    ${domains.sort((a, b) => a.name > b.name ? 1 : -1).map(
+        (ast) => `${quoteObjectKey(
+          ast.schema ? `${ast.schema}.${ast.name}` : ast.name,
+          false
+        )}: (t) => ${ast.baseType.toCode(
+          { t: "t", table: ast.name, currentSchema },
+          ast.baseType.data.name ?? ""
+        )},`
+      ).join("\n    ")}
+  },`;
+    }
+    replacedConfig = code + "\n}";
+  }
+  const tablesChanges = makeTablesListChanges(
+    content,
+    statements,
+    tablesList,
+    tables,
+    dbPath
+  );
+  if (tablesChanges) {
+    addChange(
+      content,
+      changes,
+      tablesChanges.imports.pos,
+      tablesChanges.imports.text
+    );
+  }
+  if (replacedConfig) {
+    replaceContent(content, changes, config.pos, config.end, replacedConfig);
+  }
+  if (tablesChanges) {
+    addChange(
+      content,
+      changes,
+      tablesChanges.tablesList.pos,
+      tablesChanges.tablesList.text
+    );
+  }
+  return applyChanges(content, changes);
+};
+const getTsStatements = (content) => {
+  return createSourceFile("file.ts", content, ScriptTarget.Latest, true).statements;
+};
+const getOrchidOrmImportName = (statements) => {
+  for (const node of statements) {
+    if (node.kind !== SyntaxKind.ImportDeclaration) continue;
+    const imp = node;
+    const source = imp.moduleSpecifier.getText().slice(1, -1);
+    if (source !== "orchid-orm") continue;
+    if (!imp.importClause) continue;
+    const elements = imp.importClause.namedBindings?.elements;
+    for (const element of elements) {
+      if (element.propertyName?.escapedText === "orchidORM" || element.name.escapedText === "orchidORM") {
+        return element.name.escapedText.toString();
+      }
+    }
+  }
+  return;
+};
+const makeTablesListChanges = (content, statements, object, tables, dbPath) => {
+  const spaces = getTablesListSpaces(content, object);
+  let imports = "";
+  let tablesList = "";
+  const prependComma = object.properties.length && !object.properties.hasTrailingComma;
+  const tablesListNewLine = content.slice(object.properties.end, object.end).includes("\n");
+  const tablesArr = Object.values(tables);
+  for (let i = 0; i < tablesArr.length; i++) {
+    const { path, className, key } = tablesArr[i];
+    const importPath = getImportPath(dbPath, path);
+    imports += `
+import { ${className} } from '${importPath}';`;
+    tablesList += `${i === 0 && prependComma ? "," : ""}
+${spaces}  ${key}: ${className},`;
+    if (i === tablesArr.length - 1 && !tablesListNewLine) {
+      tablesList += `
+${spaces}`;
+    }
+  }
+  if (!imports.length) return;
+  let importPos = 0;
+  for (const node of statements) {
+    if (node.kind === SyntaxKind.ImportDeclaration) {
+      importPos = node.end;
+    }
+  }
+  return {
+    imports: { pos: importPos, text: imports },
+    tablesList: { pos: object.properties.end, text: tablesList }
+  };
+};
+const getTablesListSpaces = (content, object) => {
+  const lines = content.slice(0, object.end).split("\n");
+  const last = lines[lines.length - 1];
+  return last.match(/^\s+/)?.[0] || "";
+};
+const getOrchidOrmArgs = (importName, statements) => {
+  for (const v of statements) {
+    if (v.kind !== SyntaxKind.VariableStatement) continue;
+    for (const node of v.declarationList.declarations) {
+      const call = node.initializer;
+      if (call?.kind !== SyntaxKind.CallExpression) continue;
+      if (call.expression.getText() !== importName) continue;
+      if (call.arguments.length !== 2) {
+        throw new Error(
+          "Invalid number of arguments when initializing orchid orm"
+        );
+      }
+      const object = call.arguments[1];
+      if (object?.kind !== SyntaxKind.ObjectLiteralExpression) {
+        throw new Error(
+          "Second argument of orchidORM must be an object literal"
+        );
+      }
+      return { config: call.arguments[0], tablesList: object };
+    }
+  }
+  throw new Error("List of tables is not found in main file");
+};
+const addChange = (content, changes, at, text, end = at) => {
+  if (changes.length === 0) {
+    changes.push([0, at], text, [end, content.length]);
+  } else {
+    const last = changes[changes.length - 1];
+    last[1] = at;
+    changes.push(text, [end, content.length]);
+  }
+};
+const replaceContent = (content, changes, from, to, text) => {
+  addChange(content, changes, from, text, to);
+};
+const applyChanges = (content, changes) => {
+  return changes.length ? changes.map(
+    (item) => typeof item === "string" ? item : content.slice(item[0], item[1])
+  ).join("") : content;
+};
+
+const pull = async (adapters, config) => {
+  if (!config.dbPath || !config.baseTable) {
+    throw new Error(
+      `\`${config.dbPath ? "baseTable" : "dbPath"}\` setting must be set in the migrations config for pull command`
+    );
+  }
+  const baseTablePath = config.baseTable.getFilePath();
+  const baseTableExportedAs = config.baseTable.exportAs;
+  const [adapter] = adapters;
+  const currentSchema = adapter.schema || "public";
+  const ctx = makeStructureToAstCtx(config, currentSchema);
+  const asts = await structureToAst(ctx, adapter, config);
+  const { tableInfos, fkeys } = getTableInfosAndFKeys(asts, config);
+  const exclusiveWriteOptions = { flag: "wx" };
+  const pendingFileWrites = [];
+  const tables = {};
+  const extensions = [];
+  const domains = [];
+  let firstTable;
+  for (const ast of asts) {
+    switch (ast.type) {
+      case "table": {
+        const table = appCodeGenTable(
+          tableInfos,
+          fkeys,
+          ast,
+          baseTablePath,
+          baseTableExportedAs,
+          currentSchema
+        );
+        tables[table.key] = table;
+        if (!firstTable) firstTable = table;
+        pendingFileWrites.push([
+          table.path,
+          table.content,
+          exclusiveWriteOptions
+        ]);
+        break;
+      }
+      case "extension": {
+        extensions.push({
+          name: ast.schema ? `${ast.schema}.${ast.name}` : ast.name,
+          version: ast.version
+        });
+        break;
+      }
+      case "domain": {
+        domains.push(ast);
+        break;
+      }
+    }
+  }
+  if (!firstTable && !extensions.length && !domains.length) {
+    await adapter.close();
+    return;
+  }
+  let dbPath = path.resolve(config.basePath, config.dbPath);
+  if (!dbPath.endsWith(".ts")) dbPath += ".ts";
+  const content = await appCodeGenUpdateDbFile(
+    dbPath,
+    tables,
+    extensions,
+    domains,
+    currentSchema
+  );
+  if (content) pendingFileWrites.push([dbPath, content]);
+  if (firstTable) {
+    await fs.mkdir(path.dirname(firstTable.path), { recursive: true });
+  }
+  await Promise.all(
+    pendingFileWrites.map(
+      ([path2, content2, options]) => fs.writeFile(path2, content2, options).then(() => {
+        config.logger?.log(`Created ${pathToLog(path2)}`);
+      })
+    )
+  );
+  const version = await makeFileVersion({}, config);
+  await generate(adapters, config, ["pull"], { adapter, version });
+  await Promise.all(
+    adapters.map(async (adapter2) => {
+      const silentAdapter = adapter2;
+      silentAdapter.silentArrays = adapter2.arrays;
+      await saveMigratedVersion(silentAdapter, version, "pull.ts", config);
+      await adapter2.close();
+    })
+  );
+};
+
+rakeDbCommands.g = rakeDbCommands.generate = {
+  run: generate,
+  help: "gen migration from OrchidORM tables",
+  helpArguments: {
+    "no arguments": '"generated" is a default file name',
+    "migration-name": "set migration file name",
+    up: "auto-apply migration",
+    "migration-name up": "with a custom name and apply it"
+  },
+  helpAfter: "reset"
+};
+rakeDbCommands.pull.run = pull;
+rakeDbCommands.pull.help = "generate ORM tables and a migration for an existing database";
+//# sourceMappingURL=index.mjs.map