orchid-orm 1.67.0 → 1.68.0

package/dist/migrations/node-postgres.js

@@ -1,3795 +1,12 @@
-'use strict';
-
-var rakeDb = require('rake-db');
-var internal = require('pqb/internal');
-var path = require('node:path');
-var url = require('url');
-var fs = require('fs/promises');
-var typescript = require('typescript');
-var nodePostgres = require('rake-db/node-postgres');
-
-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 rakeDb.promptSelect({
-    message: `Create or rename ${internal.colors.blueBold(
-      name
-    )} ${kind} from another ${kind}?`,
-    options: [
-      `${internal.colors.greenBold("+")} ${name}  ${internal.colors.pale(
-        `create ${kind}`.padStart(
-          hintPos + renameMessage.length - name.length - 4,
-          " "
-        )
-      )}`,
-      ...drop.map(
-        (d) => `${internal.colors.yellowBold("~")} ${d} ${internal.colors.yellowBold(
-          "=>"
-        )} ${name}  ${internal.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 },
-  currentSchema
-}) => {
-  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" && schema !== currentSchema && !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] = rakeDb.getSchemaAndTableFromName(currentSchema, 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 = rakeDb.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] = rakeDb.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 ? internal.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 = rakeDb.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 === internal.toSnakeCase(codeKey) ? codeKey : dbName : dbName] = {
-          type: "rename",
-          name: config.snakeCase ? to === internal.toSnakeCase(codeKey) ? codeKey : to : to
-        };
-      }
-    }
-  }
-};
-const compareColumns = async (adapter, domainsMap, ast, currentSchema, compareSql, changeTableData, typeCastsCache, verifying, key, dbName, dbColumn, codeColumn) => {
-  if (dbColumn instanceof internal.ArrayColumn && codeColumn instanceof internal.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 = internal.getColumnBaseType(dbColumn, domainsMap, dbType);
-    const codeBaseType = internal.getColumnBaseType(codeColumn, domainsMap, codeType);
-    if (!typeCasts.get(dbBaseType)?.has(codeBaseType)) {
-      if (!(dbColumn instanceof internal.EnumColumn) || !(codeColumn instanceof internal.EnumColumn) || !internal.deepCompare(dbColumn.options, codeColumn.options)) {
-        if (verifying) throw new AbortSignal();
-        const tableName = rakeDb.concatSchemaAndName(changeTableData.changeTableAst);
-        const abort = await rakeDb.promptSelect({
-          message: `Cannot cast type of ${tableName}'s column ${key} from ${dbType} to ${codeType}`,
-          options: [
-            `${internal.colors.yellowBold(
-              `-/+`
-            )} recreate the column, existing data will be ${internal.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 (!internal.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 = rakeDb.encodeColumnDefault(
-      dbData.default,
-      compareSql.values,
-      dbColumn
-    );
-    const dbValues = compareSql.values.slice(valuesBeforeLen);
-    const codeDefault = rakeDb.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})`) {
-      const change = () => {
-        changeColumn(changeTableData, key, dbName, dbColumn, codeColumn);
-        if (!changeTableData.pushedAst) {
-          changeTableData.pushedAst = true;
-          ast.push(changeTableData.changeTableAst);
-        }
-      };
-      compareSql.expressions.push({
-        inDb: dbDefault,
-        inCode: codeDefault,
-        change
-      });
-    }
-  }
-  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 internal.EnumColumn) {
-    const [schema = currentSchema, name] = rakeDb.getSchemaAndTableFromName(
-      currentSchema,
-      column.enumName
-    );
-    return `${schema}.${name}`;
-  } else if (column instanceof internal.ArrayColumn) {
-    const { item } = column.data;
-    let type = item instanceof internal.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 = rakeDb.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 internal.RawSql([[check]])
-      }));
-    }
-    const dbDomain = makeComparableDomain(
-      currentSchema,
-      domain.schemaName,
-      domain.name,
-      dbColumn
-    );
-    const found = codeDomains.filter(
-      (codeDomain) => internal.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 internal.ArrayColumn) {
-    inner = inner.data.item;
-    arrayDims++;
-  }
-  const fullType = getColumnDbType(inner, currentSchema);
-  const [typeSchema = "pg_catalog", type] = rakeDb.getSchemaAndTableFromName(
-    currentSchema,
-    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
-      ) || internal.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: internal.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] && internal.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: internal.toArray(options.include).map(internal.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: internal.toSnakeCase(c.column) } : c
-      ) : x.columns,
-      columnKeys: x.columns,
-      options: x.options.include && config.snakeCase ? {
-        ...x.options,
-        include: internal.toArray(x.options.include).map(internal.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 ? internal.toArray(codeItem.options.include).map(internal.toSnakeCase) : internal.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) => !internal.deepCompare(dbColumn, codeColumns[i2]))) {
-      let a = dbItemWithoutColumns;
-      let b = codeItem;
-      const codeName = b.name ?? (key === "indexes" ? rakeDb.getIndexName : rakeDb.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 (internal.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,
-          // eslint-disable-next-line @typescript-eslint/no-unused-vars
-          includeKeys,
-          ...codeItemWithoutKeys
-        } = codeItem;
-        if (internal.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" ? rakeDb.getIndexName : rakeDb.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) => {
-        return checkForColumnAddOrDrop(foreignShape, column);
-      });
-      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 (internal.deepCompare(dbReferences, codeReferences)) {
-          found = true;
-          codeForeignKeys.splice(i, 1);
-          const codeName = codeForeignKey.codeConstraint.name ?? rakeDb.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(internal.toSnakeCase) : refs.columns,
-            foreignColumns: config.snakeCase ? refs.foreignColumns.map(internal.toSnakeCase) : refs.foreignColumns
-          },
-          currentSchema
-        )
-      );
-    }
-  }
-  return codeForeignKeys;
-};
-const fnOrTableToString = (fnOrTable) => {
-  if (typeof fnOrTable !== "string") {
-    const { schema, table } = new (fnOrTable())();
-    fnOrTable = rakeDb.concatSchemaAndName({ schema, name: table });
-  }
-  return fnOrTable;
-};
-const parseForeignKey = (config, codeConstraint, references, currentSchema) => {
-  const { fnOrTable, columns, foreignColumns, options } = references;
-  const [schema, table] = rakeDb.getSchemaAndTableFromName(currentSchema, fnOrTable);
-  return {
-    references: {
-      foreignSchema: schema ?? currentSchema,
-      foreignTable: table,
-      columns,
-      foreignColumns: config.snakeCase ? foreignColumns.map(internal.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 === rakeDb.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 || internal.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 || internal.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 internal.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(
-    adapter,
-    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(
-      rakeDb.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 = (adapter, config, tables, dbStructure, currentSchema, createTables, generatorIgnore) => {
-  const changeTables = [];
-  const changeTableSchemas = [];
-  const dropTables = [];
-  const tableShapes = {};
-  const ignoreTables = generatorIgnore?.tables?.map((name) => {
-    const [schema = currentSchema, table] = rakeDb.getSchemaAndTableFromName(
-      currentSchema,
-      name
-    );
-    return { schema, table };
-  });
-  const { schema: migrationsSchema = "public", table: migrationsTable } = rakeDb.getMigrationsSchemaAndTable(adapter, config);
-  for (const dbTable of dbStructure.tables) {
-    if (dbTable.name === migrationsTable && dbTable.schemaName === migrationsSchema || 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 internal.ArrayColumn) {
-    return getColumnDbTypeForComparison(column.data.item, currentSchema) + "[]".repeat(column.data.arrayDims);
-  }
-  let type = column instanceof internal.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 internal.EnumColumn) {
-      result = `"${currentSchema}".${result}`;
-    }
-    return result;
-  } else {
-    return `"${type.slice(j)}"."${type.slice(0, j)}"${append}`;
-  }
-};
-const freezeSqlClock = (sql) => sql.replaceAll("clock_timestamp()", `'0.1ms'::interval + now()`);
-const applyCompareSql = async (compareSql, adapter) => {
-  if (compareSql.expressions.length) {
-    const {
-      rows: [results]
-    } = await adapter.arrays(
-      "SELECT " + compareSql.expressions.map(
-        (x) => `${freezeSqlClock(x.inDb)} = (${x.inCode && freezeSqlClock(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: rakeDb.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 internal.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);
-  }
-};
-
-const defaults = {
-  super: false,
-  inherit: false,
-  createRole: false,
-  createDb: false,
-  canLogin: false,
-  replication: false,
-  connLimit: -1,
-  bypassRls: false
-};
-const processRoles = async (ast, dbStructure, { verifying, internal: { roles } }) => {
-  if (!dbStructure.roles || !roles) return;
-  const codeRoles = roles.map((role) => {
-    const { defaultPrivileges: _, ...roleWithoutPrivileges } = role;
-    return {
-      ...defaults,
-      ...roleWithoutPrivileges
-    };
-  });
-  const found = /* @__PURE__ */ new Set();
-  const dropRoles = [];
-  for (const dbRole of dbStructure.roles) {
-    const {
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      defaultPrivileges: _,
-      ...dbRoleWithoutPrivileges
-    } = dbRole;
-    const codeRole = codeRoles.find(
-      (codeRole2) => dbRole.name === codeRole2.name
-    );
-    if (codeRole) {
-      found.add(dbRole.name);
-      if (!internal.deepCompare(dbRoleWithoutPrivileges, codeRole)) {
-        ast.push({
-          type: "changeRole",
-          name: dbRole.name,
-          from: dbRoleWithoutPrivileges,
-          to: codeRole
-        });
-      }
-      continue;
-    }
-    dropRoles.push(dbRole);
-  }
-  for (const codeRole of codeRoles) {
-    if (found.has(codeRole.name)) continue;
-    if (dropRoles.length) {
-      const i = await promptCreateOrRename(
-        "table",
-        codeRole.name,
-        dropRoles.map((x) => x.name),
-        verifying
-      );
-      if (i) {
-        const dbRole = dropRoles[i - 1];
-        dropRoles.splice(i - 1, 1);
-        ast.push(makeRenameOrChangeAst(dbRole, codeRole));
-        continue;
-      }
-    }
-    ast.push({
-      type: "role",
-      action: "create",
-      ...codeRole
-    });
-  }
-  for (const dbRole of dropRoles) {
-    ast.push({
-      type: "role",
-      action: "drop",
-      ...dbRole
-    });
-  }
-};
-const makeRenameOrChangeAst = (dbRole, codeRole) => {
-  const { name: dbRoleName, ...dbRoleRest } = dbRole;
-  const { name: codeRoleName, ...codeRoleRest } = codeRole;
-  if (internal.deepCompare(dbRoleRest, codeRoleRest) && dbRoleName !== codeRoleName) {
-    return {
-      type: "renameRole",
-      from: dbRoleName,
-      to: codeRoleName
-    };
-  } else {
-    return {
-      type: "changeRole",
-      name: dbRole.name,
-      from: dbRole,
-      to: codeRole
-    };
-  }
-};
-
-const ALL_OBJECT_TYPES = [
-  "TABLES",
-  "SEQUENCES",
-  "FUNCTIONS",
-  "TYPES",
-  "SCHEMAS",
-  "LARGE_OBJECTS"
-];
-const createAllObjectConfigs = (isGrantable, schema, supportedPrivileges) => {
-  let types;
-  if (schema) {
-    types = ALL_OBJECT_TYPES.filter(
-      (t) => t !== "SCHEMAS" && t !== "LARGE_OBJECTS"
-    );
-  } else {
-    types = ALL_OBJECT_TYPES.filter((t) => {
-      if (t === "LARGE_OBJECTS") {
-        return supportedPrivileges.PRIVILEGES.LARGE_OBJECT !== void 0;
-      }
-      return true;
-    });
-  }
-  return types.map((object) => ({
-    object,
-    privilegeConfigs: [{ privilege: "ALL", isGrantable }]
-  }));
-};
-const objectTypeToKey = {
-  TABLES: "tables",
-  SEQUENCES: "sequences",
-  FUNCTIONS: "functions",
-  TYPES: "types",
-  SCHEMAS: "schemas",
-  LARGE_OBJECTS: "largeObjects"
-};
-const splitPrivilegeConfigs = (configs) => {
-  const regular = [];
-  const grantable = [];
-  for (const p of configs) {
-    if (p.isGrantable) {
-      grantable.push(p.privilege);
-    } else {
-      regular.push(p.privilege);
-    }
-  }
-  return { regular, grantable };
-};
-const createPrivilegeSetting = (regular, grantable) => {
-  const setting = {};
-  if (regular.length) setting.privileges = regular;
-  if (grantable.length) setting.grantablePrivileges = grantable;
-  return setting;
-};
-const collapsePrivileges = (privs, newPrivilegeConfigs, expectedPrivs, isGrantable) => {
-  const hasAll = privs.some((p) => p.privilege === "ALL");
-  const allPresent = hasAll || privs.length > 0 && privs.length === expectedPrivs.length && expectedPrivs.every((priv) => privs.some((p) => p.privilege === priv));
-  if (allPresent) {
-    newPrivilegeConfigs.push({ privilege: "ALL", isGrantable });
-  } else if (privs.length > 0) {
-    newPrivilegeConfigs.push(...privs);
-  }
-};
-const collapsePrivilegesToAll = (privilege, objectTypeToAllPrivileges) => {
-  const collapsedObjectConfigs = privilege.objectConfigs.map(
-    (objConfig) => {
-      const allPrivileges = objectTypeToAllPrivileges[objConfig.object];
-      const expectedPrivs = allPrivileges.filter((p) => p !== "ALL");
-      const regularPrivs = [];
-      const grantablePrivs = [];
-      for (const p of objConfig.privilegeConfigs) {
-        if (p.isGrantable) {
-          grantablePrivs.push(p);
-        } else {
-          regularPrivs.push(p);
-        }
-      }
-      const newPrivilegeConfigs = [];
-      collapsePrivileges(
-        regularPrivs,
-        newPrivilegeConfigs,
-        expectedPrivs,
-        false
-      );
-      collapsePrivileges(
-        grantablePrivs,
-        newPrivilegeConfigs,
-        expectedPrivs,
-        true
-      );
-      return {
-        object: objConfig.object,
-        privilegeConfigs: newPrivilegeConfigs
-      };
-    }
-  );
-  return {
-    owner: privilege.owner,
-    grantee: privilege.grantee,
-    schema: privilege.schema,
-    objectConfigs: collapsedObjectConfigs
-  };
-};
-const privilegeConfigsMatch = (a, b, objectType, objectTypeToAllPrivileges) => {
-  if (a.privilege === b.privilege && a.isGrantable === b.isGrantable) {
-    return true;
-  }
-  const allPrivileges = objectTypeToAllPrivileges[objectType];
-  const expectedPrivs = allPrivileges.filter((p) => p !== "ALL");
-  if (a.privilege === "ALL" && a.isGrantable === b.isGrantable) {
-    return expectedPrivs.includes(b.privilege);
-  }
-  if (b.privilege === "ALL" && a.isGrantable === b.isGrantable) {
-    return expectedPrivs.includes(a.privilege);
-  }
-  return false;
-};
-const normalizeRoleName = (name) => {
-  if (name.startsWith('"') && name.endsWith('"')) {
-    return name.slice(1, -1);
-  }
-  return name;
-};
-const processPrivilegeConfig = (config, objectType) => {
-  if (!config) return;
-  const privilegeConfigs = [];
-  if (config.privileges) {
-    for (const p of config.privileges) {
-      privilegeConfigs.push({ privilege: p, isGrantable: false });
-    }
-  }
-  if (config.grantablePrivileges) {
-    for (const p of config.grantablePrivileges) {
-      privilegeConfigs.push({ privilege: p, isGrantable: true });
-    }
-  }
-  if (privilegeConfigs.length) {
-    return { object: objectType, privilegeConfigs };
-  }
-  return;
-};
-const hasAnyPrivilege = (obj) => {
-  if (!obj) return false;
-  for (const key of ALL_OBJECT_TYPES) {
-    const setting = obj[objectTypeToKey[key]];
-    if (setting?.privileges?.length || setting?.grantablePrivileges?.length) {
-      return true;
-    }
-  }
-  return false;
-};
-const processDefaultPrivileges = (ast, dbStructure, { internal: { roles } }) => {
-  if (!dbStructure.defaultPrivileges || !roles) return;
-  const supportedPrivileges = internal.getSupportedDefaultPrivileges(
-    dbStructure.version
-  );
-  const objectTypeToAllPrivileges = {};
-  objectTypeToAllPrivileges.TABLES = supportedPrivileges.PRIVILEGES.TABLE;
-  objectTypeToAllPrivileges.SEQUENCES = supportedPrivileges.PRIVILEGES.SEQUENCE;
-  objectTypeToAllPrivileges.FUNCTIONS = supportedPrivileges.PRIVILEGES.FUNCTION;
-  objectTypeToAllPrivileges.TYPES = supportedPrivileges.PRIVILEGES.TYPE;
-  objectTypeToAllPrivileges.SCHEMAS = supportedPrivileges.PRIVILEGES.SCHEMA;
-  if (supportedPrivileges.PRIVILEGES.LARGE_OBJECT) {
-    objectTypeToAllPrivileges.LARGE_OBJECTS = supportedPrivileges.PRIVILEGES.LARGE_OBJECT;
-  }
-  const codePrivileges = /* @__PURE__ */ new Map();
-  for (const role of roles) {
-    if (!role.defaultPrivileges) continue;
-    for (const privilege of role.defaultPrivileges) {
-      const key = `${role.name}.${privilege.schema}`;
-      const objectConfigs = [];
-      if (privilege.allGrantable) {
-        objectConfigs.push(
-          ...createAllObjectConfigs(
-            true,
-            privilege.schema,
-            supportedPrivileges
-          )
-        );
-      } else if (privilege.all) {
-        objectConfigs.push(
-          ...createAllObjectConfigs(
-            false,
-            privilege.schema,
-            supportedPrivileges
-          )
-        );
-      }
-      for (const objectType of ALL_OBJECT_TYPES) {
-        if (privilege.schema && (objectType === "SCHEMAS" || objectType === "LARGE_OBJECTS")) {
-          continue;
-        }
-        if (objectType === "LARGE_OBJECTS" && !supportedPrivileges.PRIVILEGES.LARGE_OBJECT) {
-          continue;
-        }
-        const key2 = objectTypeToKey[objectType];
-        if (key2 in privilege) {
-          const config = privilege[key2];
-          const processed = processPrivilegeConfig(config, objectType);
-          if (processed) {
-            const existingIndex = objectConfigs.findIndex(
-              (o) => o.object === objectType
-            );
-            if (existingIndex >= 0) {
-              objectConfigs[existingIndex] = processed;
-            } else {
-              objectConfigs.push(processed);
-            }
-          }
-        }
-      }
-      if (objectConfigs.length) {
-        codePrivileges.set(key, {
-          owner: void 0,
-          grantee: role.name,
-          schema: privilege.schema,
-          objectConfigs
-        });
-      }
-    }
-  }
-  const found = /* @__PURE__ */ new Set();
-  for (const dbPrivilege of dbStructure.defaultPrivileges) {
-    const grantee = normalizeRoleName(dbPrivilege.grantee);
-    if (grantee === "postgres") continue;
-    const key = `${grantee}.${dbPrivilege.schema}`;
-    const codePrivilege = codePrivileges.get(key);
-    if (codePrivilege) {
-      found.add(key);
-      const grant = {};
-      const revoke = {};
-      for (const objectType of ALL_OBJECT_TYPES) {
-        if (objectType === "LARGE_OBJECTS" && !supportedPrivileges.PRIVILEGES.LARGE_OBJECT) {
-          continue;
-        }
-        const dbObj = dbPrivilege.objectConfigs.find(
-          (o) => o.object === objectType
-        );
-        const codeObj = codePrivilege.objectConfigs.find(
-          (o) => o.object === objectType
-        );
-        const dbPrivs = dbObj?.privilegeConfigs ?? [];
-        const codePrivs = codeObj?.privilegeConfigs ?? [];
-        const collapsedDbPrivilege = {
-          owner: dbPrivilege.owner,
-          grantee: dbPrivilege.grantee,
-          schema: dbPrivilege.schema,
-          objectConfigs: [{ object: objectType, privilegeConfigs: dbPrivs }]
-        };
-        const collapsedDbObj = collapsePrivilegesToAll(
-          collapsedDbPrivilege,
-          objectTypeToAllPrivileges
-        ).objectConfigs[0];
-        const collapsedDbPrivs = collapsedDbObj?.privilegeConfigs ?? [];
-        const toGrant = codePrivs.filter(
-          (cp) => !collapsedDbPrivs.some(
-            (dp) => privilegeConfigsMatch(
-              cp,
-              dp,
-              objectType,
-              objectTypeToAllPrivileges
-            )
-          )
-        );
-        const toRevoke = dbPrivs.filter(
-          (dp) => !codePrivs.some(
-            (cp) => privilegeConfigsMatch(
-              cp,
-              dp,
-              objectType,
-              objectTypeToAllPrivileges
-            )
-          )
-        );
-        if (toGrant.length) {
-          const { regular, grantable } = splitPrivilegeConfigs(toGrant);
-          const setting = createPrivilegeSetting(regular, grantable);
-          if (setting.privileges || setting.grantablePrivileges) {
-            grant[objectTypeToKey[objectType]] = setting;
-          }
-        }
-        if (toRevoke.length) {
-          const { regular, grantable } = splitPrivilegeConfigs(toRevoke);
-          const setting = createPrivilegeSetting(regular, grantable);
-          if (setting.privileges || setting.grantablePrivileges) {
-            revoke[objectTypeToKey[objectType]] = setting;
-          }
-        }
-      }
-      const hasGrant = hasAnyPrivilege(grant);
-      const hasRevoke = hasAnyPrivilege(revoke);
-      if (hasGrant || hasRevoke) {
-        ast.push({
-          type: "defaultPrivilege",
-          grantee,
-          schema: dbPrivilege.schema,
-          grant: hasGrant ? grant : void 0,
-          revoke: hasRevoke ? revoke : void 0
-        });
-      }
-    } else {
-      const revoke = {};
-      for (const obj of dbPrivilege.objectConfigs) {
-        const { regular, grantable } = splitPrivilegeConfigs(
-          obj.privilegeConfigs
-        );
-        const setting = createPrivilegeSetting(regular, grantable);
-        if (setting.privileges || setting.grantablePrivileges) {
-          revoke[objectTypeToKey[obj.object]] = setting;
-        }
-      }
-      if (hasAnyPrivilege(revoke)) {
-        ast.push({
-          type: "defaultPrivilege",
-          grantee,
-          schema: dbPrivilege.schema,
-          revoke
-        });
-      }
-    }
-  }
-  for (const [key, codePrivilege] of codePrivileges) {
-    if (found.has(key)) continue;
-    const grant = {};
-    for (const obj of codePrivilege.objectConfigs) {
-      const { regular, grantable } = splitPrivilegeConfigs(
-        obj.privilegeConfigs
-      );
-      const setting = createPrivilegeSetting(regular, grantable);
-      if (setting.privileges || setting.grantablePrivileges) {
-        grant[objectTypeToKey[obj.object]] = setting;
-      }
-    }
-    if (hasAnyPrivilege(grant)) {
-      ast.push({
-        type: "defaultPrivilege",
-        grantee: codePrivilege.grantee,
-        schema: codePrivilege.schema,
-        grant
-      });
-    }
-  }
-};
-
-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;
-  await processRoles(ast, dbStructure, params);
-  processDefaultPrivileges(ast, dbStructure, params);
-  const domainsMap = rakeDb.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 rakeDb.astToMigration(currentSchema, config, ast);
-};
-
-const rollbackErr = new Error("Rollback");
-const verifyMigration = async (adapter, config, migrationCode, generateMigrationParams, roles, defaultPrivileges) => {
-  const migrationFn = new Function("change", migrationCode);
-  let code;
-  try {
-    await adapter.transaction(async (trx) => {
-      const changeFns = [];
-      migrationFn((changeCb) => {
-        changeFns.push(changeCb);
-      });
-      const { log } = config;
-      config.log = false;
-      const db = rakeDb.createMigrationInterface(trx, true, config).getDb(
-        config.columnTypes
-      );
-      config.log = log;
-      for (const changeFn of changeFns) {
-        await changeFn(db, true);
-      }
-      const dbStructure = await rakeDb.introspectDbSchema(trx, {
-        roles,
-        loadDefaultPrivileges: defaultPrivileges?.loadDefaultPrivileges
-      });
-      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 } = internal.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} ${internal.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 = internal.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 = internal.toCamelCase(name);
-              const changes2 = [];
-              inner.push(`${yellow("~ change column")} ${name}:`, changes2);
-              changes2.push(`${yellow("from")}: `);
-              const fromCode = change.from.column?.toCode(toCodeCtx, key);
-              if (fromCode) {
-                for (const code2 of fromCode) {
-                  internal.addCode(changes2, code2);
-                }
-              }
-              changes2.push(`  ${yellow("to")}: `);
-              const toCode = change.to.column?.toCode(toCodeCtx, key);
-              if (toCode) {
-                for (const code2 of toCode) {
-                  internal.addCode(changes2, code2);
-                }
-              }
-            } else if (change.type === "rename") {
-              inner.push(
-                `${yellow("~ rename column")} ${config.snakeCase ? internal.toCamelCase(key) : key} ${yellow("=>")} ${change.name}`
-              );
-            } else {
-              internal.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] = rakeDb.getSchemaAndTableFromName(
-              currentSchema,
-              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;
-      }
-      case "role":
-        code.push(
-          `${a.action === "create" ? green("+ create role") : red("- drop role")} ${a.name}`
-        );
-        break;
-      case "renameRole":
-      case "changeRole": {
-        if (a.type === "renameRole") {
-          code.push(
-            `${yellow("~ rename role")} ${a.from} ${yellow("=>")} ${a.to}`
-          );
-        } else {
-          code.push(`${yellow("~ change role")} ${a.name}`);
-        }
-        break;
-      }
-      case "defaultPrivilege": {
-        const mapPrivilege = (p) => p === "ALL" ? "ALL PRIVILEGES" : p;
-        const schema = a.schema ? ` in schema ${internal.colors.pale(a.schema)}` : ` ${internal.colors.pale("in all schemas")}`;
-        const parts = [];
-        if (a.grant) {
-          for (const [objType, config2] of Object.entries(a.grant)) {
-            if (!config2) continue;
-            const type = objType.replace(/([A-Z])/g, " $1").toLowerCase();
-            if (config2.privileges?.length) {
-              parts.push(
-                `${green("+ grant default privileges")} ${config2.privileges.map(mapPrivilege).join(", ")} on ${type} to ${a.grantee}${schema}`
-              );
-            }
-            if (config2.grantablePrivileges?.length) {
-              parts.push(
-                `${green(
-                  "+ grant default privileges"
-                )} ${config2.grantablePrivileges.map(mapPrivilege).join(", ")} on ${type} with grant option to ${a.grantee}${schema}`
-              );
-            }
-          }
-        }
-        if (a.revoke) {
-          for (const [objType, config2] of Object.entries(a.revoke)) {
-            if (!config2) continue;
-            const type = objType.replace(/([A-Z])/g, " $1").toLowerCase();
-            if (config2.privileges?.length) {
-              parts.push(
-                `${red("- revoke default privileges")} ${config2.privileges.map(mapPrivilege).join(", ")} on ${type} from ${a.grantee}${schema}`
-              );
-            }
-            if (config2.grantablePrivileges?.length) {
-              parts.push(
-                `${red(
-                  "- revoke default privileges"
-                )} ${config2.grantablePrivileges.map(mapPrivilege).join(", ")} on ${type} with grant option from ${a.grantee}${schema}`
-              );
-            }
-          }
-        }
-        if (parts.length) {
-          code.push(parts.join("\n"));
-        }
-        break;
-      }
-      default:
-        internal.exhaustive(a);
-    }
-  }
-  const result = internal.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 db = await getDbFromConfig(config, dbPath);
-  const { columnTypes, internal: internal$1 } = db.$qb;
-  const rolesDbStructureParam = internal$1.roles ? internal$1.managedRolesSql ? { whereSql: internal$1.managedRolesSql } : internal.emptyObject : void 0;
-  const { dbStructure } = await migrateAndPullStructures(
-    adapters,
-    config,
-    rolesDbStructureParam,
-    internal$1.roles ? { loadDefaultPrivileges: true } : void 0,
-    afterPull
-  );
-  const [adapter] = adapters;
-  const adapterSchema = adapter.getSchema();
-  const currentSchema = (typeof adapterSchema === "function" ? adapterSchema() : adapterSchema) ?? "public";
-  const codeItems = await getActualItems(
-    db,
-    currentSchema,
-    internal$1,
-    columnTypes
-  );
-  const structureToAstCtx = rakeDb.makeStructureToAstCtx(config, currentSchema);
-  const generateMigrationParams = {
-    structureToAstCtx,
-    codeItems,
-    currentSchema,
-    internal: internal$1
-  };
-  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,
-      rolesDbStructureParam,
-      internal$1.roles ? { loadDefaultPrivileges: true } : void 0
-    );
-    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 rakeDb.makeFileVersion({}, config);
-  const delayLog = [];
-  await rakeDb.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 rakeDb.migrateAndClose(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(
-    url.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, roles, defaultPrivileges, afterPull) => {
-  if (afterPull) {
-    const version = await rakeDb.getDbVersion(adapters[0]);
-    return {
-      dbStructure: {
-        version,
-        schemas: [],
-        tables: [],
-        views: [],
-        indexes: [],
-        excludes: [],
-        constraints: [],
-        triggers: [],
-        extensions: [],
-        enums: [],
-        domains: [],
-        collations: []
-      }
-    };
-  }
-  for (const adapter of adapters) {
-    await rakeDb.migrate(adapter, config);
-  }
-  const dbStructures = await Promise.all(
-    adapters.map(
-      (adapter) => rakeDb.introspectDbSchema(adapter, {
-        roles,
-        loadDefaultPrivileges: defaultPrivileges?.loadDefaultPrivileges
-      })
-    )
-  );
-  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$1, 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: []
-  };
-  codeItems.schemas.add(currentSchema);
-  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 = internal.getQuerySchema(table);
-    const name = rakeDb.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: table.table,
-      shape: table.shape,
-      internal: table.internal,
-      q: {
-        schema: internal.getQuerySchema(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 internal.DomainColumn) {
-        const [schemaName = currentSchema, name2] = rakeDb.getSchemaAndTableFromName(
-          currentSchema,
-          column.dataType
-        );
-        domains.set(column.dataType, {
-          schemaName,
-          name: name2,
-          column: column.data.as ?? new internal.UnknownColumn(internal.defaultSchemaConfig)
-        });
-      } else {
-        const en = column.dataType === "enum" ? column : column instanceof internal.ArrayColumn && column.data.item.dataType === "enum" ? column.data.item : void 0;
-        if (en) {
-          processEnumColumn(en, currentSchema, codeItems);
-        }
-      }
-    }
-  }
-  if (internal$1.extensions) {
-    for (const extension of internal$1.extensions) {
-      const [schema] = rakeDb.getSchemaAndTableFromName(currentSchema, extension.name);
-      if (schema) codeItems.schemas.add(schema);
-    }
-  }
-  if (internal$1.domains) {
-    for (const key in internal$1.domains) {
-      const [schemaName = currentSchema, name] = rakeDb.getSchemaAndTableFromName(
-        currentSchema,
-        key
-      );
-      const column = internal$1.domains[key](columnTypes);
-      domains.set(key, {
-        schemaName,
-        name,
-        column
-      });
-    }
-  }
-  for (const domain of domains.values()) {
-    codeItems.schemas.add(domain.schemaName);
-    codeItems.domains.push(domain);
-  }
-  if (internal$1.roles) {
-    for (const role of internal$1.roles) {
-      if (role.defaultPrivileges) {
-        for (const privilege of role.defaultPrivileges) {
-          if (privilege.schema) codeItems.schemas.add(privilege.schema);
-        }
-      }
-    }
-  }
-  return codeItems;
-};
-const processEnumColumn = (column, currentSchema, codeItems) => {
-  const { enumName, options } = column;
-  const [schema, name] = rakeDb.getSchemaAndTableFromName(currentSchema, 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[internal.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 = internal.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 = internal.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",
-    [internal.getImportPath(tableInfo.path, baseTablePath)]: baseTableExportedAs
-  };
-  const props = [];
-  if (ast.schema) {
-    props.push(`schema = ${internal.singleQuote(ast.schema)};`);
-  }
-  props.push(`readonly table = ${internal.singleQuote(ast.name)};`);
-  if (ast.comment) {
-    props.push(`comment = ${internal.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 = internal.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(internal.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[internal.getImportPath(tableInfo.path, table.path)] = table.className;
-      relations.push(
-        `${table.key}: this.belongsTo(() => ${table.className}, {`,
-        [
-          `columns: [${references.foreignColumns.map(internal.singleQuote).join(", ")}],`,
-          `references: [${references.columns.map(internal.singleQuote).join(", ")}],`
-        ],
-        "}),"
-      );
-    }
-  }
-  if (ast.constraints) {
-    for (const { references } of ast.constraints) {
-      if (!references) continue;
-      const table = tableInfos[references.fnOrTable];
-      imports[internal.getImportPath(tableInfo.path, table.path)] = table.className;
-      relations.push(
-        `${table.key}: this.hasMany(() => ${table.className}, {`,
-        [
-          `columns: [${references.columns.map(internal.singleQuote).join(", ")}],`,
-          `references: [${references.foreignColumns.map(internal.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" + internal.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 ? `{ ${internal.quoteObjectKey(ext.name, false)}: '${ext.version}' }` : internal.singleQuote(ext.name)
-      ).join(", ")}],`;
-    }
-    if (domains.length) {
-      code += `
-  domains: {
-    ${domains.sort((a, b) => a.name > b.name ? 1 : -1).map(
-        (ast) => `${internal.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.name.escapedText === "orchidORM" || element.propertyName && "escapedText" in element.propertyName && element.propertyName.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 = internal.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 adapterSchema = adapter.getSchema();
-  const currentSchema = (typeof adapterSchema === "function" ? adapterSchema() : adapterSchema) ?? "public";
-  const ctx = rakeDb.makeStructureToAstCtx(config, currentSchema);
-  const asts = await rakeDb.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 ${internal.pathToLog(path2)}`);
-      })
-    )
-  );
-  const version = await rakeDb.makeFileVersion({}, config);
-  await generate(adapters, config, ["pull"], { adapter, version });
-  await Promise.all(
-    adapters.map(async (adapter2) => {
-      const silentAdapter = adapter2;
-      silentAdapter.silentArrays = adapter2.arrays;
-      await rakeDb.saveMigratedVersion(silentAdapter, version, "pull.ts", config);
-      await adapter2.close();
-    })
-  );
-};
-
-rakeDb.rakeDbCommands.g = rakeDb.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"
-};
-rakeDb.rakeDbCommands.pull.run = pull;
-rakeDb.rakeDbCommands.pull.help = "generate ORM tables and a migration for an existing database";
-
-Object.keys(nodePostgres).forEach(function (k) {
-  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () { return nodePostgres[k]; }
-  });
-});
-//# sourceMappingURL=node-postgres.js.map
+(0, require("orchid-orm/migrations").patchRakeDb)();
+var rake_db_node_postgres = require("rake-db/node-postgres");
+Object.keys(rake_db_node_postgres).forEach(function(k) {
+	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function() {
+			return rake_db_node_postgres[k];
+		}
+	});
+});
+
+//# sourceMappingURL=node-postgres.js.map