orchid-orm 1.24.7 → 1.25.1

package/dist/migrations.mjs

@@ -0,0 +1,2839 @@
+import { promptSelect, colors, getSchemaAndTableFromName, getDbTableColumnsChecks, dbColumnToAst, instantiateDbColumn, concatSchemaAndName, encodeColumnDefault, getIndexName, getConstraintName, tableToAst, getDbStructureTableData, makeDomainsMap, astToMigration, createMigrationInterface, introspectDbSchema, exhaustive, pluralize, makeStructureToAstCtx, makeFileVersion, writeMigrationFile, migrate, structureToAst, saveMigratedVersion, rakeDbCommands } from 'rake-db';
+export * from 'rake-db';
+import { EnumColumn, DomainColumn, RawSQL, ArrayColumn, VirtualColumn, UnknownColumn, defaultSchemaConfig, columnsShapeToCode, Adapter } from 'pqb';
+import { deepCompare, toArray, addCode, codeToString, toCamelCase, toPascalCase, getImportPath, singleQuote, quoteObjectKey, pathToLog } from 'orchid-core';
+import fs from 'fs/promises';
+import path from 'node:path';
+import typescript from 'typescript';
+
+const compareSqlExpressions = async (tableExpressions, adapter) => {
+  if (tableExpressions.length) {
+    let id = 1;
+    await Promise.all(
+      tableExpressions.map(async ({ source, compare, handle }) => {
+        const viewName = `orchidTmpView${id++}`;
+        const values = [];
+        try {
+          const sql = `CREATE TEMPORARY VIEW ${viewName} AS (SELECT ${compare.map(
+            ({ inDb: inDb2, inCode }, i) => `${inDb2} AS "*inDb-${i}*", ${inCode.map(
+              (s, j) => `(${typeof s === "string" ? s : s.toSQL({ values })}) "*inCode-${i}-${j}*"`
+            ).join(", ")}`
+          ).join(", ")} FROM ${source})`;
+          await adapter.query({ text: sql, values });
+        } catch (err) {
+          handle();
+          return;
+        }
+        const {
+          rows: [{ v }]
+        } = await adapter.query(
+          `SELECT pg_get_viewdef('${viewName}') v`
+        );
+        await adapter.query(`DROP VIEW ${viewName}`);
+        let pos = 7;
+        const rgx = /\s+AS\s+"\*(inDb-\d+|inCode-\d+-\d+)\*",?/g;
+        let match;
+        let inDb = "";
+        let codeI = 0;
+        const matches = compare[0].inCode.map(() => true);
+        while (match = rgx.exec(v)) {
+          const sql = v.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) {
+              matches[codeI] = false;
+            }
+            codeI++;
+          }
+          pos = rgx.lastIndex;
+        }
+        const firstMatching = matches.indexOf(true);
+        handle(firstMatching === -1 ? void 0 : firstMatching);
+      })
+    );
+  }
+};
+const promptCreateOrRename = (kind, name, drop, verifying) => {
+  if (verifying)
+    throw new AbortSignal();
+  let hintPos = name.length + 4;
+  for (const from of drop) {
+    const value = from.length + 8 + name.length;
+    if (value > hintPos)
+      hintPos = value;
+  }
+  let max = 0;
+  const add = name.length + 3;
+  for (const name2 of drop) {
+    if (name2.length + add > max) {
+      max = name2.length + add;
+    }
+  }
+  const renameMessage = `rename ${kind}`;
+  return promptSelect({
+    message: `Create or rename ${colors.blueBold(
+      name
+    )} ${kind} from another ${kind}?`,
+    options: [
+      `${colors.greenBold("+")} ${name}  ${colors.pale(
+        `create ${kind}`.padStart(
+          hintPos + renameMessage.length - name.length - 4,
+          " "
+        )
+      )}`,
+      ...drop.map(
+        (d) => `${colors.yellowBold("~")} ${d} ${colors.yellowBold(
+          "=>"
+        )} ${name}  ${colors.pale(
+          renameMessage.padStart(
+            hintPos + renameMessage.length - d.length - name.length - 8,
+            " "
+          )
+        )}`
+      )
+    ]
+  });
+};
+const checkForColumnChange = (shape, key) => {
+  const item = shape[key];
+  return item && (Array.isArray(item) || item.type !== "rename");
+};
+
+const processSchemas = async (ast, schemas, dbStructure, verifying) => {
+  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") {
+      dropSchemas.push(schema);
+    }
+  }
+  for (const schema of createSchemas) {
+    if (dropSchemas.length) {
+      const index = await promptCreateOrRename(
+        "schema",
+        schema,
+        dropSchemas,
+        verifying
+      );
+      if (index) {
+        const from = dropSchemas[index - 1];
+        dropSchemas.splice(index - 1, 1);
+        renameSchemaInStructures(dbStructure.tables, from, schema);
+        renameSchemaInStructures(dbStructure.views, from, schema);
+        renameSchemaInStructures(dbStructure.indexes, 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;
+    }
+  }
+};
+
+var __defProp$6 = Object.defineProperty;
+var __getOwnPropSymbols$6 = Object.getOwnPropertySymbols;
+var __hasOwnProp$6 = Object.prototype.hasOwnProperty;
+var __propIsEnum$6 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$6 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$6.call(b, prop))
+      __defNormalProp$6(a, prop, b[prop]);
+  if (__getOwnPropSymbols$6)
+    for (var prop of __getOwnPropSymbols$6(b)) {
+      if (__propIsEnum$6.call(b, prop))
+        __defNormalProp$6(a, prop, b[prop]);
+    }
+  return a;
+};
+const processExtensions = (ast, dbStructure, currentSchema, extensions) => {
+  var _a;
+  const codeExtensions = extensions == null ? void 0 : extensions.map((ext) => {
+    const [schema, name] = getSchemaAndTableFromName(ext.name);
+    return { schema, name, version: ext.version };
+  });
+  for (const dbExt of dbStructure.extensions) {
+    if (codeExtensions) {
+      let found = false;
+      for (let i = 0; i < codeExtensions.length; i++) {
+        const codeExt = codeExtensions[i];
+        if (dbExt.name === codeExt.name && dbExt.schemaName === ((_a = codeExt.schema) != null ? _a : 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 == null ? void 0 : codeExtensions.length) {
+    ast.push(
+      ...codeExtensions.map((ext) => __spreadValues$6({
+        type: "extension",
+        action: "create"
+      }, ext))
+    );
+  }
+};
+
+var __defProp$5 = Object.defineProperty;
+var __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;
+var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
+var __propIsEnum$5 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$5 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$5.call(b, prop))
+      __defNormalProp$5(a, prop, b[prop]);
+  if (__getOwnPropSymbols$5)
+    for (var prop of __getOwnPropSymbols$5(b)) {
+      if (__propIsEnum$5.call(b, prop))
+        __defNormalProp$5(a, prop, b[prop]);
+    }
+  return a;
+};
+const processColumns = async (adapter, 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(
+    dbStructure,
+    changeTableData,
+    columnsToAdd,
+    columnsToDrop,
+    columnsToChange,
+    verifying
+  );
+  await changeColumns(
+    adapter,
+    structureToAstCtx,
+    dbStructure,
+    domainsMap,
+    ast,
+    currentSchema,
+    dbColumns,
+    columnsToChange,
+    compareSql,
+    changeTableData,
+    typeCastsCache,
+    verifying
+  );
+  dropColumns(changeTableData, columnsToDrop);
+};
+const groupColumns = (structureToAstCtx, dbStructure, domainsMap, dbColumns, changeTableData) => {
+  var _a;
+  const columnsToAdd = [];
+  const columnsToDrop = [];
+  const columnsToChange = /* @__PURE__ */ new Map();
+  const { codeTable, dbTable, dbTableData } = changeTableData;
+  const checks = getDbTableColumnsChecks(changeTableData.dbTableData);
+  for (const key in codeTable.shape) {
+    const column = codeTable.shape[key];
+    if (!column.dataType)
+      continue;
+    const name = (_a = column.data.name) != null ? _a : key;
+    if (dbColumns[name]) {
+      columnsToChange.set(name, column);
+    } else {
+      columnsToAdd.push({ key: name, column });
+    }
+  }
+  for (const name in dbColumns) {
+    if (columnsToChange.has(name))
+      continue;
+    const [key, column] = dbColumnToAst(
+      structureToAstCtx,
+      dbStructure,
+      domainsMap,
+      dbTable.name,
+      dbColumns[name],
+      dbTable,
+      dbTableData,
+      checks
+    );
+    columnsToDrop.push({ key, column });
+  }
+  return {
+    columnsToAdd,
+    columnsToDrop,
+    columnsToChange
+  };
+};
+const addOrRenameColumns = async (dbStructure, {
+  dbTableData,
+  schema,
+  changeTableAst: { name: tableName, shape }
+}, columnsToAdd, columnsToDrop, columnsToChange, verifying) => {
+  var _a, _b;
+  for (const { key, column } of columnsToAdd) {
+    if (columnsToDrop.length) {
+      const index = await promptCreateOrRename(
+        "column",
+        (_a = column.data.name) != null ? _a : key,
+        columnsToDrop.map((x) => x.key),
+        verifying
+      );
+      if (index) {
+        const drop = columnsToDrop[index - 1];
+        columnsToDrop.splice(index - 1, 1);
+        const from = drop.key;
+        columnsToChange.set(from, column.name(key));
+        if (dbTableData.primaryKey) {
+          renameColumn(dbTableData.primaryKey.columns, from, key);
+        }
+        for (const index2 of dbTableData.indexes) {
+          for (const column2 of index2.columns) {
+            if ("column" in column2 && column2.column === from) {
+              column2.column = key;
+            }
+          }
+        }
+        for (const c of dbTableData.constraints) {
+          if ((_b = c.check) == null ? void 0 : _b.columns) {
+            renameColumn(c.check.columns, from, key);
+          }
+          if (c.references) {
+            renameColumn(c.references.columns, from, key);
+          }
+        }
+        for (const c of dbStructure.constraints) {
+          if (c.references && c.references.foreignSchema === schema && c.references.foreignTable === tableName) {
+            renameColumn(c.references.foreignColumns, from, key);
+          }
+        }
+        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, structureToAstCtx, dbStructure, domainsMap, ast, currentSchema, dbColumns, columnsToChange, compareSql, changeTableData, typeCastsCache, verifying) => {
+  var _a, _b, _c, _d, _e, _f;
+  const { shape } = changeTableData.changeTableAst;
+  for (const [name, codeColumn] of columnsToChange) {
+    const dbColumnStructure = dbColumns[name];
+    let changed = false;
+    const dbColumn = instantiateDbColumn(
+      structureToAstCtx,
+      dbStructure,
+      domainsMap,
+      dbColumnStructure
+    );
+    const dbType = getColumnDbType(dbColumn, currentSchema);
+    const codeType = getColumnDbType(codeColumn, currentSchema);
+    if (dbType !== codeType) {
+      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;
+      }
+      const dbBaseType = dbColumn instanceof DomainColumn ? (_a = domainsMap[dbColumn.dataType]) == null ? void 0 : _a.dataType : dbType;
+      const codeBaseType = codeColumn instanceof DomainColumn ? (_b = domainsMap[codeColumn.dataType]) == null ? void 0 : _b.dataType : codeType;
+      if (!((_c = typeCasts.get(dbBaseType)) == null ? void 0 : _c.has(codeBaseType))) {
+        if (!(dbColumn instanceof EnumColumn) || !(codeColumn instanceof EnumColumn) || !deepCompare(dbColumn.options, codeColumn.options)) {
+          if (verifying)
+            throw new AbortSignal();
+          const tableName = concatSchemaAndName(changeTableData.changeTableAst);
+          const abort = await promptSelect({
+            message: `Cannot cast type of ${tableName}'s column ${name} from ${dbType} to ${codeType}`,
+            options: [
+              `${colors.yellowBold(
+                `-/+`
+              )} recreate the column, existing data will be ${colors.red(
+                "lost"
+              )}`,
+              `write migration manually`
+            ]
+          });
+          if (abort) {
+            throw new AbortSignal();
+          }
+          shape[name] = [
+            {
+              type: "drop",
+              item: dbColumn
+            },
+            {
+              type: "add",
+              item: codeColumn
+            }
+          ];
+          continue;
+        }
+      }
+      changed = true;
+    }
+    const dbData = dbColumn.data;
+    const codeData = codeColumn.data;
+    if (!changed) {
+      if (!dbData.isNullable)
+        dbData.isNullable = void 0;
+      for (const key of ["isNullable", "comment"]) {
+        if (dbData[key] !== codeData[key]) {
+          changed = true;
+          break;
+        }
+      }
+    }
+    if (!changed) {
+      for (const key of [
+        "maxChars",
+        "collation",
+        "compression",
+        "numericPrecision",
+        "numericScale",
+        "dateTimePrecision"
+      ]) {
+        if (key in codeData && dbData[key] !== codeData[key]) {
+          changed = true;
+          break;
+        }
+      }
+    }
+    if (!changed && !deepCompare(
+      dbData.identity,
+      codeData.identity ? __spreadValues$5({
+        always: false,
+        start: 1,
+        increment: 1,
+        cache: 1,
+        cycle: false
+      }, (_d = codeData.identity) != null ? _d : {}) : void 0
+    )) {
+      changed = true;
+    }
+    if (!changed && dbData.default !== void 0 && dbData.default !== null && codeData.default !== void 0 && codeData.default !== null) {
+      const valuesBeforeLen = compareSql.values.length;
+      const dbDefault = encodeColumnDefault(
+        dbData.default,
+        compareSql.values,
+        dbColumn
+      );
+      const dbValues = compareSql.values.slice(valuesBeforeLen);
+      const codeDefault = encodeColumnDefault(
+        codeData.default,
+        compareSql.values,
+        codeColumn
+      );
+      const codeValues = compareSql.values.slice(valuesBeforeLen);
+      if (dbValues.length !== codeValues.length || dbValues.length && JSON.stringify(dbValues) !== JSON.stringify(codeValues)) {
+        changed = true;
+        compareSql.values.length = valuesBeforeLen;
+      } else if (dbDefault !== codeDefault && dbDefault !== `(${codeDefault})`) {
+        compareSql.expressions.push({
+          inDb: dbDefault,
+          inCode: codeDefault,
+          change: () => {
+            changeColumn(shape, name, dbColumn, codeColumn);
+            if (!changeTableData.pushedAst) {
+              changeTableData.pushedAst = true;
+              ast.push(changeTableData.changeTableAst);
+            }
+          }
+        });
+      }
+    }
+    if (changed) {
+      changeColumn(shape, name, dbColumn, codeColumn);
+    } else {
+      const from = (_e = dbColumn.data.name) != null ? _e : name;
+      const to = (_f = codeColumn.data.name) != null ? _f : name;
+      if (from !== to) {
+        shape[from] = {
+          type: "rename",
+          name: to
+        };
+      }
+    }
+  }
+};
+const changeColumn = (shape, name, dbColumn, codeColumn) => {
+  dbColumn.data.as = codeColumn.data.as = void 0;
+  shape[name] = {
+    type: "change",
+    from: { column: dbColumn },
+    to: { column: codeColumn }
+  };
+};
+const getColumnDbType = (column, currentSchema) => {
+  if (column instanceof EnumColumn) {
+    const [schema = currentSchema, name] = getSchemaAndTableFromName(
+      column.enumName
+    );
+    return column.enumName = `${schema}.${name}`;
+  } 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, structureToAstCtx, domainsMap, dbStructure, currentSchema, domains) => {
+  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) {
+    const dbColumn = instantiateDbColumn(
+      structureToAstCtx,
+      dbStructure,
+      domainsMap,
+      {
+        schemaName: domain.typeSchema,
+        tableName: "N/A",
+        name: domain.name,
+        typeSchema: domain.typeSchema,
+        type: domain.type,
+        isArray: domain.isArray,
+        default: domain.default,
+        isNullable: domain.isNullable,
+        collate: domain.collate
+      }
+    );
+    if (domain.check) {
+      dbColumn.data.check = {
+        sql: new RawSQL([[domain.check]])
+      };
+    }
+    const dbDomain = makeComparableDomain(
+      currentSchema,
+      domain.schemaName,
+      domain.name,
+      dbColumn
+    );
+    const found = codeDomains.filter(
+      (codeDomain) => deepCompare(dbDomain.compare, codeDomain.compare)
+    );
+    if ((domain.default || domain.check) && found.length) {
+      for (const codeDomain of found) {
+        holdCodeDomains.add(codeDomain);
+      }
+      const compare = [];
+      pushCompare(compare, domain, found, "default");
+      pushCompare(compare, domain, found, "check");
+      const source = `(VALUES (NULL::${getColumnDbType(
+        dbColumn,
+        currentSchema
+      )})) t(value)`;
+      tableExpressions.push({
+        compare,
+        source,
+        handle(index) {
+          const codeDomain = index === void 0 ? void 0 : found[index];
+          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
+        });
+      }
+      codeDomains.splice(i, 1);
+    } else {
+      ast.push(dropAst(dbDomain));
+    }
+  }
+  for (const codeDomain of codeDomains) {
+    if (!holdCodeDomains.has(codeDomain)) {
+      ast.push(createAst(codeDomain));
+    }
+  }
+  if (tableExpressions.length) {
+    await compareSqlExpressions(tableExpressions, adapter);
+    if (holdCodeDomains.size) {
+      for (const codeDomain of holdCodeDomains.keys()) {
+        ast.push(createAst(codeDomain));
+      }
+    }
+  }
+};
+const makeComparableDomain = (currentSchema, schemaName, name, column) => {
+  var _a;
+  let isArray = false;
+  const isNullable = (_a = column.data.isNullable) != null ? _a : false;
+  let inner = column;
+  if (column instanceof ArrayColumn) {
+    inner = column.data.item;
+    isArray = true;
+  }
+  const fullType = getColumnDbType(inner, currentSchema);
+  const [typeSchema = "pg_catalog", type] = getSchemaAndTableFromName(fullType);
+  return {
+    schemaName,
+    name,
+    column,
+    compare: {
+      type,
+      typeSchema,
+      isArray,
+      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,
+      hasCheck: column.data.check !== void 0
+    }
+  };
+};
+const pushCompare = (compare, domain, found, key) => {
+  const inDb = domain[key];
+  if (inDb) {
+    compare.push({
+      inDb,
+      inCode: found.map((codeDomain) => {
+        const value = codeDomain.column.data[key];
+        if ("sql" in value) {
+          return value.sql;
+        }
+        return value;
+      })
+    });
+  }
+};
+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
+});
+
+var __defProp$4 = Object.defineProperty;
+var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
+var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
+var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$4 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$4.call(b, prop))
+      __defNormalProp$4(a, prop, b[prop]);
+  if (__getOwnPropSymbols$4)
+    for (var prop of __getOwnPropSymbols$4(b)) {
+      if (__propIsEnum$4.call(b, prop))
+        __defNormalProp$4(a, prop, b[prop]);
+    }
+  return a;
+};
+const processEnums = async (ast, enums, dbStructure, currentSchema, verifying) => {
+  var _a, _b;
+  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) {
+    const codeEnum = enums.get(`${dbEnum.schemaName}.${dbEnum.name}`);
+    if (codeEnum) {
+      changeEnum(ast, dbEnum, codeEnum);
+      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 = (_a = codeEnum2.schema) != null ? _a : currentSchema;
+      renameColumnsTypeSchema(dbStructure, fromSchema, toSchema);
+      ast.push({
+        type: "renameType",
+        kind: "TYPE",
+        fromSchema,
+        from: dbEnum.name,
+        toSchema,
+        to: dbEnum.name
+      });
+      changeEnum(ast, dbEnum, codeEnum2);
+      continue;
+    }
+    dropEnums.push(dbEnum);
+  }
+  for (const codeEnum of createEnums) {
+    if (dropEnums.length) {
+      const index = await promptCreateOrRename(
+        "enum",
+        codeEnum.name,
+        dropEnums.map((x) => x.name),
+        verifying
+      );
+      if (index) {
+        const dbEnum = dropEnums[index - 1];
+        dropEnums.splice(index - 1, 1);
+        const fromSchema = dbEnum.schemaName;
+        const from = dbEnum.name;
+        const toSchema = (_b = codeEnum.schema) != null ? _b : 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
+        });
+        changeEnum(ast, dbEnum, codeEnum);
+        continue;
+      }
+    }
+    ast.push(__spreadValues$4({
+      type: "enum",
+      action: "create"
+    }, codeEnum));
+  }
+  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) => {
+  const { values: dbValues } = dbEnum;
+  const { values: codeValues, schema, name } = codeEnum;
+  if (dbValues.length < codeValues.length) {
+    if (!dbValues.some((value, i) => value !== codeValues[i])) {
+      ast.push({
+        type: "enumValues",
+        action: "add",
+        schema,
+        name,
+        values: codeValues.slice(-(codeValues.length - dbValues.length))
+      });
+      return;
+    }
+  } else if (dbValues.length > codeValues.length) {
+    if (!codeValues.some((value, i) => value !== dbValues[i])) {
+      ast.push({
+        type: "enumValues",
+        action: "drop",
+        schema,
+        name,
+        values: dbValues.slice(-(dbValues.length - codeValues.length))
+      });
+      return;
+    }
+  } else if (!dbValues.some((value, i) => value !== codeValues[i])) {
+    return;
+  }
+  ast.push({
+    type: "changeEnumValues",
+    schema,
+    name,
+    fromValues: dbValues,
+    toValues: codeValues
+  });
+};
+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 = (ast, changeTableData) => {
+  var _a;
+  const { codeTable } = changeTableData;
+  const columnsPrimaryKey = [];
+  for (const key in codeTable.shape) {
+    const column = codeTable.shape[key];
+    if (column.data.primaryKey) {
+      columnsPrimaryKey.push((_a = column.data.name) != null ? _a : key);
+    }
+  }
+  changePrimaryKey(columnsPrimaryKey, changeTableData);
+  renamePrimaryKey(ast, changeTableData);
+};
+const changePrimaryKey = (columnsPrimaryKey, {
+  codeTable,
+  dbTableData: { primaryKey: dbPrimaryKey },
+  changeTableAst: { shape, add, drop }
+}) => {
+  var _a;
+  const tablePrimaryKey = codeTable.internal.primaryKey;
+  const primaryKey = [
+    .../* @__PURE__ */ new Set([...columnsPrimaryKey, ...(_a = tablePrimaryKey == null ? void 0 : tablePrimaryKey.columns) != null ? _a : []])
+  ];
+  if (!dbPrimaryKey || primaryKey.length !== dbPrimaryKey.columns.length || primaryKey.some((a) => !dbPrimaryKey.columns.some((b) => a === b))) {
+    const toDrop = dbPrimaryKey == null ? void 0 : dbPrimaryKey.columns.filter(
+      (key) => !checkForColumnChange(shape, key)
+    );
+    if (toDrop == null ? void 0 : toDrop.length) {
+      drop.primaryKey = { columns: toDrop, options: dbPrimaryKey == null ? void 0 : dbPrimaryKey.options };
+    }
+    const toAdd = primaryKey.filter((key) => !checkForColumnChange(shape, key));
+    if (toAdd.length) {
+      add.primaryKey = {
+        columns: toAdd,
+        options: tablePrimaryKey == null ? void 0 : tablePrimaryKey.options
+      };
+    }
+  }
+};
+const renamePrimaryKey = (ast, {
+  codeTable,
+  dbTableData: { primaryKey: dbPrimaryKey },
+  schema
+}) => {
+  var _a, _b, _c, _d, _e, _f;
+  const tablePrimaryKey = codeTable.internal.primaryKey;
+  if (dbPrimaryKey && tablePrimaryKey && ((_a = dbPrimaryKey == null ? void 0 : dbPrimaryKey.options) == null ? void 0 : _a.name) !== ((_b = tablePrimaryKey == null ? void 0 : tablePrimaryKey.options) == null ? void 0 : _b.name)) {
+    ast.push({
+      type: "renameTableItem",
+      kind: "CONSTRAINT",
+      tableSchema: schema,
+      tableName: codeTable.table,
+      from: (_d = (_c = dbPrimaryKey.options) == null ? void 0 : _c.name) != null ? _d : `${codeTable.table}_pkey`,
+      to: (_f = (_e = tablePrimaryKey.options) == null ? void 0 : _e.name) != null ? _f : `${codeTable}_pkey`
+    });
+  }
+};
+
+var __defProp$3 = Object.defineProperty;
+var __defProps$3 = Object.defineProperties;
+var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
+var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
+var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$3 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$3.call(b, prop))
+      __defNormalProp$3(a, prop, b[prop]);
+  if (__getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(b)) {
+      if (__propIsEnum$3.call(b, prop))
+        __defNormalProp$3(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$3.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$3.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+const processIndexes = (config, changeTableData, delayedAst, ast, compareExpressions) => {
+  const codeIndexes = collectCodeIndexes(changeTableData);
+  const codeComparableIndexes = collectCodeComparableIndexes(codeIndexes);
+  const skipCodeIndexes = /* @__PURE__ */ new Map();
+  const holdCodeIndexes = /* @__PURE__ */ new Map();
+  let wait = 0;
+  const {
+    changeTableAst: { shape }
+  } = changeTableData;
+  for (const dbIndex of changeTableData.dbTableData.indexes) {
+    const hasChangedColumn = dbIndex.columns.some(
+      (column) => "column" in column && checkForColumnChange(shape, column.column)
+    );
+    if (hasChangedColumn)
+      continue;
+    normalizeIndex(dbIndex);
+    const dbComparableIndex = indexToComparable(dbIndex);
+    const { columns: dbColumns } = dbIndex;
+    const { found, rename } = findMatchingIndexWithoutSql(
+      dbComparableIndex,
+      codeComparableIndexes,
+      codeIndexes,
+      skipCodeIndexes,
+      changeTableData.codeTable.table,
+      config
+    );
+    if (found.length && checkIfIndexHasSql(dbComparableIndex)) {
+      for (const codeIndex of found) {
+        holdCodeIndexes.set(codeIndex, true);
+      }
+      const compare = [];
+      for (let i = 0; i < dbIndex.columns.length; i++) {
+        const column = dbIndex.columns[i];
+        if (!("expression" in column))
+          continue;
+        compare.push({
+          inDb: column.expression,
+          inCode: found.map(
+            (index) => index.columns[i].expression
+          )
+        });
+      }
+      if (dbIndex.with) {
+        compare.push({
+          inDb: dbIndex.with,
+          inCode: found.map((index) => index.options.with)
+        });
+      }
+      if (dbIndex.where) {
+        compare.push({
+          inDb: dbIndex.where,
+          inCode: found.map((index) => index.options.where)
+        });
+      }
+      wait++;
+      compareExpressions.push({
+        compare,
+        handle(index) {
+          var _a, _b;
+          const codeIndex = index === void 0 ? void 0 : found[index];
+          handleIndexChange(
+            ast,
+            changeTableData,
+            dbIndex,
+            dbColumns,
+            codeIndex,
+            index === void 0 ? void 0 : rename[index]
+          );
+          if (codeIndex) {
+            holdCodeIndexes.delete(codeIndex);
+          }
+          if (!--wait && holdCodeIndexes.size) {
+            ((_b = (_a = changeTableData.changeTableAst.add).indexes) != null ? _b : _a.indexes = []).push(
+              ...holdCodeIndexes.keys()
+            );
+            if (!changeTableData.pushedAst) {
+              changeTableData.pushedAst = true;
+              ast.push(changeTableData.changeTableAst);
+            }
+          }
+        }
+      });
+    } else {
+      handleIndexChange(
+        delayedAst,
+        changeTableData,
+        dbIndex,
+        dbColumns,
+        found[0],
+        rename[0]
+      );
+    }
+  }
+  const addIndexes = codeIndexes.filter(
+    (index, i) => !skipCodeIndexes.has(i) && !holdCodeIndexes.has(index)
+  );
+  if (addIndexes.length) {
+    changeTableData.changeTableAst.add.indexes = addIndexes;
+  }
+};
+const collectCodeIndexes = ({
+  codeTable,
+  changeTableAst: { shape }
+}) => {
+  var _a;
+  const codeIndexes = [];
+  for (const key in codeTable.shape) {
+    const column = codeTable.shape[key];
+    if (!column.data.indexes)
+      continue;
+    const name = (_a = column.data.name) != null ? _a : key;
+    if (checkForColumnChange(shape, name))
+      continue;
+    codeIndexes.push(
+      ...column.data.indexes.map(
+        (_b) => {
+          var _c = _b, { collate, opclass, order, weight } = _c, options = __objRest(_c, ["collate", "opclass", "order", "weight"]);
+          return {
+            columns: [{ collate, opclass, order, weight, column: name }],
+            options
+          };
+        }
+      )
+    );
+  }
+  if (codeTable.internal.indexes) {
+    codeIndexes.push(...codeTable.internal.indexes);
+  }
+  return codeIndexes;
+};
+const collectCodeComparableIndexes = (codeIndexes) => {
+  return codeIndexes.map((codeIndex) => {
+    normalizeIndex(codeIndex.options);
+    return indexToComparable(__spreadProps$3(__spreadValues$3({}, codeIndex.options), {
+      include: codeIndex.options.include === void 0 ? void 0 : toArray(codeIndex.options.include),
+      columns: codeIndex.columns
+    }));
+  });
+};
+const normalizeIndex = (index) => {
+  if (index.using === "btree")
+    index.using = void 0;
+  if (index.unique === false)
+    index.unique = void 0;
+  if (index.nullsNotDistinct === false)
+    index.nullsNotDistinct = void 0;
+};
+const indexToComparable = (index) => {
+  let hasExpression = false;
+  const columns = index.columns.map((column) => {
+    const result = __spreadProps$3(__spreadValues$3({}, column), {
+      expression: void 0,
+      hasExpression: "expression" in column
+    });
+    if (result.hasExpression)
+      hasExpression = true;
+    return result;
+  });
+  return __spreadProps$3(__spreadValues$3({}, index), {
+    schemaName: void 0,
+    tableName: void 0,
+    with: void 0,
+    hasWith: !!index.with,
+    where: void 0,
+    hasWhere: !!index.where,
+    columns,
+    hasExpression
+  });
+};
+const findMatchingIndexWithoutSql = (dbIndex, codeComparableIndexes, codeIndexes, skipCodeIndexes, tableName, config) => {
+  var _c, _d;
+  const found = [];
+  const rename = [];
+  const _a = dbIndex, { columns: dbColumns } = _a, dbIndexWithoutColumns = __objRest(_a, ["columns"]);
+  for (let i = 0; i < codeComparableIndexes.length; i++) {
+    if (skipCodeIndexes.has(i))
+      continue;
+    const _b = codeComparableIndexes[i], { columns: codeColumns } = _b, codeIndex = __objRest(_b, ["columns"]);
+    if (dbColumns.length === codeColumns.length && !dbColumns.some((dbColumn, i2) => !deepCompare(dbColumn, codeColumns[i2]))) {
+      let a = dbIndexWithoutColumns;
+      let b = codeIndex;
+      const codeName = (_c = b.name) != null ? _c : getIndexName(tableName, dbColumns);
+      if (a.name !== b.name) {
+        a = __spreadProps$3(__spreadValues$3({}, a), { name: void 0 });
+        b = __spreadProps$3(__spreadValues$3({}, b), { name: void 0 });
+        if (a.language && !b.language) {
+          b.language = (_d = config.language) != null ? _d : "english";
+        }
+        if (deepCompare(a, b)) {
+          found.push(codeIndexes[i]);
+          rename.push(
+            dbIndexWithoutColumns.name !== codeName ? codeName : void 0
+          );
+        }
+      } else if (deepCompare(dbIndexWithoutColumns, codeIndex)) {
+        found.push(codeIndexes[i]);
+        rename.push(void 0);
+      }
+      if (found.length && !checkIfIndexHasSql(codeIndex)) {
+        skipCodeIndexes.set(i, true);
+      }
+    }
+  }
+  return { found, rename };
+};
+const checkIfIndexHasSql = (index) => index.hasWith || index.hasWhere || index.hasExpression;
+const handleIndexChange = (ast, { changeTableAst, schema, codeTable }, dbIndex, dbColumns, found, rename) => {
+  var _a, _b;
+  if (!found) {
+    ((_b = (_a = changeTableAst.drop).indexes) != null ? _b : _a.indexes = []).push({
+      columns: dbColumns,
+      options: dbIndex
+    });
+  } else if (rename) {
+    ast.push({
+      type: "renameTableItem",
+      kind: "INDEX",
+      tableSchema: schema,
+      tableName: codeTable.table,
+      from: dbIndex.name,
+      to: rename
+    });
+  }
+};
+
+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 = (ast, changeTables, currentSchema, tableShapes) => {
+  var _a, _b, _c;
+  for (const changeTableData of changeTables) {
+    const codeForeignKeys = collectCodeFkeys(changeTableData, currentSchema);
+    const { codeTable, dbTableData, changeTableAst, schema } = 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) => checkForColumnChange(shape, column)
+      );
+      if (hasChangedColumn)
+        continue;
+      const foreignShape = tableShapes[`${dbReferences.foreignSchema}.${dbReferences.foreignTable}`];
+      const hasForeignChangedColumn = foreignShape && dbReferences.foreignColumns.some(
+        (column) => checkForColumnChange(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 (deepCompare(dbReferences, codeReferences)) {
+          found = true;
+          codeForeignKeys.splice(i, 1);
+          const codeName = (_a = codeForeignKey.codeConstraint.name) != null ? _a : getConstraintName(codeTable.table, codeForeignKey);
+          if (codeName !== dbConstraint.name) {
+            rename = codeName;
+          }
+        }
+      }
+      if (!found) {
+        ((_b = drop.constraints) != null ? _b : drop.constraints = []).push(
+          dbForeignKeyToCodeForeignKey(dbConstraint, dbReferences)
+        );
+        changed = true;
+      } else if (rename) {
+        ast.push({
+          type: "renameTableItem",
+          kind: "CONSTRAINT",
+          tableSchema: schema,
+          tableName: codeTable.table,
+          from: dbConstraint.name,
+          to: rename
+        });
+      }
+    }
+    if (codeForeignKeys.length) {
+      ((_c = add.constraints) != null ? _c : add.constraints = []).push(
+        ...codeForeignKeys.map((x) => x.codeConstraint)
+      );
+      changed = true;
+    }
+    if (changed && !changeTableData.pushedAst) {
+      changeTableData.pushedAst = true;
+      ast.push(changeTableData.changeTableAst);
+    }
+  }
+};
+const collectCodeFkeys = ({ codeTable, changeTableAst: { shape } }, currentSchema) => {
+  var _a;
+  const codeForeignKeys = [];
+  for (const key in codeTable.shape) {
+    const column = codeTable.shape[key];
+    if (!column.data.foreignKeys)
+      continue;
+    const name = (_a = column.data.name) != null ? _a : key;
+    if (checkForColumnChange(shape, name))
+      continue;
+    codeForeignKeys.push(
+      ...column.data.foreignKeys.map((x) => {
+        const columns = [name];
+        const references = {
+          columns,
+          fnOrTable: fnOrTableToString("fn" in x ? x.fn : x.table),
+          foreignColumns: x.columns,
+          options: {
+            name: x.name,
+            match: x.match,
+            onUpdate: x.onUpdate,
+            onDelete: x.onDelete
+          }
+        };
+        return parseForeignKey(
+          {
+            name: x.name,
+            references
+          },
+          references,
+          currentSchema
+        );
+      })
+    );
+  }
+  if (codeTable.internal.constraints) {
+    for (const constraint of codeTable.internal.constraints) {
+      const { references } = constraint;
+      if (!references)
+        continue;
+      references.fnOrTable = fnOrTableToString(references.fnOrTable);
+      codeForeignKeys.push(
+        parseForeignKey(
+          constraint,
+          references,
+          currentSchema
+        )
+      );
+    }
+  }
+  return codeForeignKeys;
+};
+const fnOrTableToString = (fnOrTable) => {
+  if (typeof fnOrTable !== "string") {
+    const { schema, table } = new (fnOrTable())();
+    fnOrTable = concatSchemaAndName({ schema, name: table });
+  }
+  return fnOrTable;
+};
+const parseForeignKey = (codeConstraint, references, currentSchema) => {
+  const { fnOrTable, columns, foreignColumns, options } = references;
+  const [schema, table] = getSchemaAndTableFromName(fnOrTable);
+  return {
+    references: {
+      foreignSchema: schema != null ? schema : currentSchema,
+      foreignTable: table,
+      columns,
+      foreignColumns,
+      match: mapMatchToDb[(options == null ? void 0 : options.match) || "SIMPLE"],
+      onUpdate: mapActionToDb[(options == null ? void 0 : options.onUpdate) || "NO ACTION"],
+      onDelete: mapActionToDb[(options == null ? void 0 : options.onDelete) || "NO ACTION"]
+    },
+    codeConstraint
+  };
+};
+const dbForeignKeyToCodeForeignKey = (dbConstraint, dbReferences) => ({
+  name: dbConstraint.name === getConstraintName(dbConstraint.tableName, { references: dbReferences }) ? 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) => {
+  var _a, _b;
+  const codeChecks = collectCodeChecks(changeTableData);
+  const {
+    dbTableData,
+    changeTableAst: { add, drop, shape }
+  } = changeTableData;
+  const hasDbChecks = dbTableData.constraints.some((c) => c.check);
+  if (!hasDbChecks) {
+    if (codeChecks.length) {
+      ((_a = add.constraints) != null ? _a : add.constraints = []).push(
+        ...codeChecks.map((check) => {
+          var _a2;
+          return {
+            name: (_a2 = check.options) == null ? void 0 : _a2.name,
+            check: check.sql
+          };
+        })
+      );
+    }
+    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 = (_b = dbCheck.columns) == null ? void 0 : _b.some(
+      (column) => checkForColumnChange(shape, column)
+    );
+    if (hasChangedColumn)
+      continue;
+    if (codeChecks.length) {
+      wait++;
+      compareExpressions.push({
+        compare: [
+          {
+            inDb: dbCheck.expression,
+            inCode: codeChecks.map((check) => check.sql)
+          }
+        ],
+        handle(index) {
+          var _a2;
+          if (index !== void 0)
+            return;
+          dropCheck(drop, dbCheck, name);
+          if (--wait === 0 && !changeTableData.pushedAst) {
+            changeTableData.pushedAst = true;
+            ((_a2 = add.constraints) != null ? _a2 : add.constraints = []).push(
+              ...codeChecks.filter((_, i) => !foundCodeChecks.has(i)).map((check) => {
+                var _a3;
+                return {
+                  name: (_a3 = check.options) == null ? void 0 : _a3.name,
+                  check: check.sql
+                };
+              })
+            );
+            ast.push(changeTableData.changeTableAst);
+          }
+        }
+      });
+    } else {
+      dropCheck(drop, dbCheck, name);
+    }
+  }
+};
+const collectCodeChecks = ({
+  codeTable,
+  changeTableAst: { shape }
+}) => {
+  var _a;
+  const codeChecks = [];
+  for (const key in codeTable.shape) {
+    const column = codeTable.shape[key];
+    if (!column.data.check)
+      continue;
+    const name = (_a = column.data.name) != null ? _a : key;
+    if (checkForColumnChange(shape, name))
+      continue;
+    codeChecks.push(column.data.check);
+  }
+  if (codeTable.internal.constraints) {
+    for (const constraint of codeTable.internal.constraints) {
+      const { check } = constraint;
+      if (check) {
+        codeChecks.push({ sql: check, options: { name: constraint.name } });
+      }
+    }
+  }
+  return codeChecks;
+};
+const dropCheck = (drop, dbCheck, name) => {
+  var _a;
+  ((_a = drop.constraints) != null ? _a : drop.constraints = []).push({
+    name,
+    check: new RawSQL([[dbCheck.expression]])
+  });
+};
+
+var __defProp$2 = Object.defineProperty;
+var __defProps$2 = Object.defineProperties;
+var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
+var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$2.call(b, prop))
+      __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b)) {
+      if (__propIsEnum$2.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
+const processTables = async (ast, structureToAstCtx, domainsMap, adapter, tables, dbStructure, currentSchema, config, verifying) => {
+  const createTables = collectCreateTables(
+    tables,
+    dbStructure,
+    currentSchema
+  );
+  const compareSql = { values: [], expressions: [] };
+  const tableExpressions = [];
+  const { changeTables, changeTableSchemas, dropTables, tableShapes } = collectChangeAndDropTables(
+    tables,
+    dbStructure,
+    currentSchema,
+    createTables
+  );
+  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
+  );
+  processForeignKeys(ast, changeTables, currentSchema, tableShapes);
+  await Promise.all([
+    applyCompareSql(compareSql, adapter),
+    compareSqlExpressions(tableExpressions, adapter)
+  ]);
+  for (const dbTable of dropTables) {
+    ast.push(
+      tableToAst(structureToAstCtx, dbStructure, dbTable, "drop", domainsMap)
+    );
+  }
+};
+const collectCreateTables = (tables, dbStructure, currentSchema) => {
+  return tables.reduce((acc, codeTable) => {
+    var _a;
+    const tableSchema = (_a = codeTable.q.schema) != null ? _a : currentSchema;
+    const hasDbTable = dbStructure.tables.some(
+      (t) => t.name === codeTable.table && t.schemaName === tableSchema
+    );
+    if (!hasDbTable) {
+      acc.push(codeTable);
+    }
+    return acc;
+  }, []);
+};
+const collectChangeAndDropTables = (tables, dbStructure, currentSchema, createTables) => {
+  const changeTables = [];
+  const changeTableSchemas = [];
+  const dropTables = [];
+  const tableShapes = {};
+  for (const dbTable of dbStructure.tables) {
+    if (dbTable.name === "schemaMigrations")
+      continue;
+    const codeTable = tables.find(
+      (t) => {
+        var _a;
+        return t.table === dbTable.name && ((_a = t.q.schema) != null ? _a : 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) => {
+  var _a;
+  for (const { codeTable, dbTable } of changeTableSchemas) {
+    const fromSchema = dbTable.schemaName;
+    const toSchema = (_a = codeTable.q.schema) != null ? _a : 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) => {
+  var _a;
+  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 = (_a = column.data.name) != null ? _a : key;
+        names.push(name);
+        types.push(getColumnDbType(column, currentSchema));
+      }
+      const tableName = codeTable.table;
+      const source = `(VALUES (${types.map((x) => `NULL::${x}`).join(", ")})) "${tableName}"(${names.map((x) => `"${x}"`).join(", ")})`;
+      tableExpressions.push(
+        ...compareExpressions.map((x) => __spreadProps$2(__spreadValues$2({}, x), { source }))
+      );
+    }
+  }
+};
+const applyCompareSql = async (compareSql, adapter) => {
+  if (compareSql.expressions.length) {
+    const {
+      rows: [results]
+    } = await adapter.arrays({
+      text: "SELECT " + compareSql.expressions.map((x) => `${x.inDb} = (${x.inCode})`).join(", "),
+      values: 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) => {
+  var _a;
+  for (const codeTable of createTables) {
+    if (dropTables.length) {
+      const index = await promptCreateOrRename(
+        "table",
+        codeTable.table,
+        dropTables.map((x) => x.name),
+        verifying
+      );
+      if (index) {
+        const dbTable = dropTables[index - 1];
+        dropTables.splice(index - 1, 1);
+        ast.push({
+          type: "renameType",
+          kind: "TABLE",
+          fromSchema: dbTable.schemaName,
+          from: dbTable.name,
+          toSchema: (_a = codeTable.q.schema) != null ? _a : 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) => {
+  var _a;
+  const shape = {};
+  const schema = (_a = codeTable.q.schema) != null ? _a : currentSchema;
+  changeTables.push({
+    codeTable,
+    dbTable,
+    dbTableData: getDbStructureTableData(dbStructure, dbTable),
+    schema,
+    changeTableAst: {
+      type: "changeTable",
+      schema,
+      name: codeTable.table,
+      shape,
+      add: {},
+      drop: {}
+    },
+    pushedAst: false
+  });
+  tableShapes[`${schema}.${codeTable.table}`] = shape;
+};
+const createTableAst = (currentSchema, table) => {
+  return __spreadProps$2(__spreadValues$2({
+    type: "table",
+    action: "create",
+    schema: table.q.schema === currentSchema ? void 0 : table.q.schema,
+    comment: table.internal.comment,
+    name: table.table,
+    shape: makeTableShape(table)
+  }, table.internal), {
+    noPrimaryKey: table.internal.noPrimaryKey ? "ignore" : "error"
+  });
+};
+const makeTableShape = (table) => {
+  const shape = {};
+  for (const key in table.shape) {
+    const column = table.shape[key];
+    if (!(column instanceof VirtualColumn)) {
+      shape[key] = column;
+    }
+  }
+  return shape;
+};
+const processTableChange = async (adapter, structureToAstCtx, dbStructure, domainsMap, ast, currentSchema, config, changeTableData, compareSql, compareExpressions, typeCastsCache, verifying) => {
+  await processColumns(
+    adapter,
+    structureToAstCtx,
+    dbStructure,
+    domainsMap,
+    changeTableData,
+    ast,
+    currentSchema,
+    compareSql,
+    typeCastsCache,
+    verifying
+  );
+  const delayedAst = [];
+  processPrimaryKey(delayedAst, changeTableData);
+  processIndexes(config, changeTableData, delayedAst, 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 (delayedAst.length)
+    ast.push(...delayedAst);
+};
+
+const composeMigration = async (adapter, config, ast, dbStructure, {
+  structureToAstCtx,
+  codeItems: { schemas, enums, tables, domains },
+  currentSchema,
+  internal,
+  verifying
+}) => {
+  const domainsMap = makeDomainsMap(structureToAstCtx, dbStructure);
+  await processSchemas(ast, schemas, dbStructure, verifying);
+  processExtensions(ast, dbStructure, currentSchema, internal.extensions);
+  await processDomains(
+    ast,
+    adapter,
+    structureToAstCtx,
+    domainsMap,
+    dbStructure,
+    currentSchema,
+    domains
+  );
+  await processEnums(ast, enums, dbStructure, currentSchema, verifying);
+  await processTables(
+    ast,
+    structureToAstCtx,
+    domainsMap,
+    adapter,
+    tables,
+    dbStructure,
+    currentSchema,
+    config,
+    verifying
+  );
+  return astToMigration(currentSchema, config, ast);
+};
+
+const verifyMigration = async (adapter, config, migrationCode, generateMigrationParams) => {
+  const migrationFn = new Function("change", migrationCode);
+  return adapter.transaction(
+    { text: "BEGIN" },
+    async (trx) => {
+      const changeFns = [];
+      migrationFn((changeCb) => {
+        changeFns.push(changeCb);
+      });
+      const { log } = config;
+      config.log = false;
+      const db = createMigrationInterface(trx, true, config);
+      config.log = log;
+      for (const changeFn of changeFns) {
+        await changeFn(db, true);
+      }
+      const dbStructure = await introspectDbSchema(trx);
+      generateMigrationParams.verifying = true;
+      let code;
+      try {
+        code = await composeMigration(
+          adapter,
+          config,
+          [],
+          dbStructure,
+          generateMigrationParams
+        );
+      } catch (err) {
+        if (err instanceof AbortSignal) {
+          return false;
+        }
+        throw err;
+      }
+      return code;
+    },
+    { text: "ROLLBACK" }
+  );
+};
+
+const report = (ast, config, currentSchema) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  if (!config.logger)
+    return;
+  const code = [];
+  let green, red, yellow, pale;
+  if (typeof config.log === "object" && config.log.colors === false) {
+    green = red = yellow = pale = (s) => s;
+  } else {
+    ({ green, red, yellow, pale } = colors);
+  }
+  for (const a of ast) {
+    switch (a.type) {
+      case "table": {
+        let hasPrimaryKey = !!a.primaryKey;
+        const counters = {
+          column: 0,
+          index: (_b = (_a = a.indexes) == null ? void 0 : _a.length) != null ? _b : 0,
+          "foreign key": (_d = (_c = a.constraints) == null ? void 0 : _c.reduce(
+            (sum, c) => c.references ? sum + 1 : sum,
+            0
+          )) != null ? _d : 0,
+          check: (_f = (_e = a.constraints) == null ? void 0 : _e.reduce(
+            (sum, c) => c.check ? sum + 1 : sum,
+            0
+          )) != null ? _f : 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.foreignKeys) {
+            counters["foreign key"] += column.data.foreignKeys.length;
+          }
+          if (column.data.check) {
+            counters.check++;
+          }
+        }
+        const summary = [];
+        for (const key in counters) {
+          const value = counters[key];
+          if (value || key === "column") {
+            summary.push(
+              `${value} ${pluralize(key, value, key === "index" ? "es" : "s")}`
+            );
+          }
+        }
+        if (!hasPrimaryKey) {
+          summary.push("no primary key");
+        }
+        code.push(
+          `${a.action === "create" ? green("+ create table") : red("- drop table")} ${dbItemName(a, currentSchema)} (${summary.join(", ")})`
+        );
+        break;
+      }
+      case "changeTable": {
+        const inner = [];
+        for (const key in a.shape) {
+          const changes = toArray(a.shape[key]);
+          for (const change of changes) {
+            if (change.type === "add" || change.type === "drop") {
+              const column = change.item;
+              const name = (_g = column.data.name) != null ? _g : key;
+              const { primaryKey, indexes, foreignKeys, check } = column.data;
+              inner.push(
+                `${change.type === "add" ? green("+ add column") : red("- drop column")} ${name} ${(_h = column.data.alias) != null ? _h : getColumnDbType(column, currentSchema)}${column.data.isNullable ? " nullable" : ""}${primaryKey ? " primary key" : ""}${foreignKeys ? ` references ${foreignKeys.map((fk) => {
+                  return `${fnOrTableToString(
+                    "fn" in fk ? fk.fn : fk.table
+                  )}(${fk.columns.join(", ")})`;
+                }).join(", ")}` : ""}${(indexes == null ? void 0 : indexes.length) ? indexes.length === 1 ? ", has index" : `, has ${indexes.length} indexes` : ""}${check ? `, checks ${check.sql.toSQL({ values: [] })}` : ""}`
+              );
+            } else if (change.type === "change") {
+              const name = (_j = (_i = change.from.column) == null ? void 0 : _i.data.name) != null ? _j : key;
+              const changes2 = [];
+              inner.push(`${yellow("~ change column")} ${name}:`, changes2);
+              changes2.push(`${yellow("from")}: `);
+              for (const code2 of change.from.column.toCode("t", true)) {
+                addCode(changes2, code2);
+              }
+              changes2.push(`  ${yellow("to")}: `);
+              for (const code2 of change.to.column.toCode("t", true)) {
+                addCode(changes2, code2);
+              }
+            } else if (change.type === "rename") {
+              inner.push(
+                `${yellow("~ rename column")} ${key} ${yellow("=>")} ${change.name}`
+              );
+            } else {
+              exhaustive(change.type);
+            }
+          }
+        }
+        if (a.drop.primaryKey) {
+          inner.push(
+            `${red(`- drop primary key`)} on (${a.drop.primaryKey.columns.join(
+              ", "
+            )})`
+          );
+        }
+        if (a.drop.indexes) {
+          for (const index of a.drop.indexes) {
+            inner.push(
+              `${red(
+                `- drop${index.options.unique ? " unique" : ""} index`
+              )} on (${index.columns.map((c) => "column" in c ? c.column : c.expression).join(", ")})`
+            );
+          }
+        }
+        if (a.drop.constraints) {
+          for (const { references } of a.drop.constraints) {
+            if (!references)
+              continue;
+            const [schema, name] = getSchemaAndTableFromName(
+              references.fnOrTable
+            );
+            inner.push(
+              `${red(`- drop foreign key`)} on (${references.columns.join(
+                ", "
+              )}) to ${dbItemName(
+                {
+                  schema,
+                  name
+                },
+                currentSchema
+              )}(${references.foreignColumns.join(", ")})`
+            );
+          }
+          for (const { check } of a.drop.constraints) {
+            if (!check)
+              continue;
+            inner.push(`${red(`- drop check`)} ${check.toSQL({ values: [] })}`);
+          }
+        }
+        if (a.add.primaryKey) {
+          inner.push(
+            `${green(`+ add primary key`)} on (${a.add.primaryKey.columns.join(
+              ", "
+            )})`
+          );
+        }
+        if (a.add.indexes) {
+          for (const index of a.add.indexes) {
+            inner.push(
+              `${green(
+                `+ add${index.options.unique ? " unique" : ""} index`
+              )} on (${index.columns.map((c) => "column" in c ? c.column : c.expression).join(", ")})`
+            );
+          }
+        }
+        if (a.add.constraints) {
+          for (const { references } of a.add.constraints) {
+            if (!references)
+              continue;
+            inner.push(
+              `${green(`+ add foreign key`)} on (${references.columns.join(
+                ", "
+              )}) to ${references.fnOrTable}(${references.foreignColumns.join(", ")})`
+            );
+          }
+          for (const { check } of a.add.constraints) {
+            if (!check)
+              continue;
+            inner.push(
+              `${green(`+ add check`)} ${check.toSQL({ values: [] })}`
+            );
+          }
+        }
+        code.push(
+          `${yellow("~ change table")} ${dbItemName(a, currentSchema)}${inner.length ? ":" : ""}`
+        );
+        if (inner.length) {
+          code.push(inner);
+        }
+        break;
+      }
+      case "schema": {
+        code.push(
+          `${a.action === "create" ? green("+ create schema") : red("- drop schema")} ${a.name}`
+        );
+        break;
+      }
+      case "renameSchema": {
+        code.push(
+          `${yellow("~ rename schema")} ${a.from} ${yellow("=>")} ${a.to}`
+        );
+        break;
+      }
+      case "renameType": {
+        code.push(
+          `${yellow(
+            `~ ${a.fromSchema !== a.toSchema ? a.from !== a.to ? "change schema and rename" : "change schema of" : "rename"} ${a.kind.toLowerCase()}`
+          )} ${dbItemName(
+            {
+              schema: a.fromSchema,
+              name: a.from
+            },
+            currentSchema
+          )} ${yellow("=>")} ${dbItemName(
+            {
+              schema: a.toSchema,
+              name: a.to
+            },
+            currentSchema
+          )}`
+        );
+        break;
+      }
+      case "extension": {
+        code.push(
+          `${a.action === "create" ? green("+ create extension") : red("- drop extension")} ${dbItemName(a, currentSchema)}${a.version ? ` ${pale(a.version)}` : ""}`
+        );
+        break;
+      }
+      case "enum": {
+        code.push(
+          `${a.action === "create" ? green("+ create enum") : red("- drop enum")} ${dbItemName(a, currentSchema)}: (${a.values.join(", ")})`
+        );
+        break;
+      }
+      case "enumValues": {
+        code.push(
+          `${a.action === "add" ? green("+ add values to enum") : red("- remove values from enum")} ${dbItemName(a, currentSchema)}: ${a.values.join(", ")}`
+        );
+        break;
+      }
+      case "changeEnumValues": {
+        if (a.fromValues) {
+          code.push(
+            `${red("- remove values from enum")} ${dbItemName(
+              a,
+              currentSchema
+            )}: ${a.fromValues.join(", ")}`
+          );
+        }
+        if (a.toValues) {
+          code.push(
+            `${green("+ add values to enum")} ${dbItemName(
+              a,
+              currentSchema
+            )}: ${a.toValues.join(", ")}`
+          );
+        }
+        break;
+      }
+      case "domain": {
+        code.push(
+          `${a.action === "create" ? green("+ create domain") : red("- drop domain")} ${dbItemName(a, currentSchema)}`
+        );
+        break;
+      }
+      case "view":
+      case "collation":
+      case "renameEnumValues":
+      case "constraint":
+        break;
+      case "renameTableItem": {
+        code.push(
+          `${yellow(`~ rename ${a.kind.toLowerCase()}`)} on table ${dbItemName(
+            { schema: a.tableSchema, name: a.tableName },
+            currentSchema
+          )}: ${a.from} ${yellow("=>")} ${a.to}`
+        );
+        break;
+      }
+      default:
+        exhaustive(a);
+    }
+  }
+  const result = codeToString(code, "", "  ");
+  config.logger.log(result);
+};
+const dbItemName = ({ schema, name }, currentSchema) => {
+  return schema && schema !== currentSchema ? `${schema}.${name}` : name;
+};
+
+var __defProp$1 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+class AbortSignal extends Error {
+}
+const generate = async (options, config, args, afterPull) => {
+  var _a, _b, _c;
+  let { dbPath } = config;
+  if (!dbPath || !config.baseTable)
+    throw invalidConfig(config);
+  if (!options.length)
+    throw new Error(`Database options must not be empty`);
+  if (!dbPath.endsWith(".ts"))
+    dbPath += ".ts";
+  let migrationName = (_a = args[0]) != null ? _a : "generated";
+  let up;
+  if (migrationName === "up") {
+    up = true;
+    migrationName = "generated";
+  } else {
+    up = args[1] === "up";
+  }
+  const { dbStructure, adapters } = await migrateAndPullStructures(
+    options,
+    config,
+    afterPull
+  );
+  const [adapter] = adapters;
+  const currentSchema = (_b = adapter.schema) != null ? _b : "public";
+  const db = await getDbFromConfig(config, dbPath);
+  const { columnTypes, internal } = db.$queryBuilder;
+  const codeItems = await getActualItems(
+    db,
+    currentSchema,
+    internal,
+    columnTypes
+  );
+  const structureToAstCtx = makeStructureToAstCtx(config, currentSchema);
+  const generateMigrationParams = {
+    structureToAstCtx,
+    codeItems,
+    currentSchema,
+    internal
+  };
+  const ast = [];
+  let migrationCode;
+  try {
+    migrationCode = await composeMigration(
+      adapter,
+      config,
+      ast,
+      dbStructure,
+      generateMigrationParams
+    );
+  } catch (err) {
+    if (err instanceof AbortSignal) {
+      await closeAdapters(adapters);
+      return;
+    }
+    throw err;
+  }
+  if (migrationCode && !afterPull) {
+    const result = await verifyMigration(
+      adapter,
+      config,
+      migrationCode,
+      generateMigrationParams
+    );
+    if (result !== void 0) {
+      throw new Error(
+        `Failed to verify generated migration: some of database changes were not applied properly. This is a bug, please open an issue, attach the following migration code:
+${migrationCode}${result === false ? "" : `
+After applying:
+${result}`}`
+      );
+    }
+  }
+  const { logger } = config;
+  if ((!up || !migrationCode) && !afterPull)
+    await closeAdapters(adapters);
+  if (!migrationCode) {
+    logger == null ? void 0 : logger.log("No changes were detected");
+    return;
+  }
+  const version = (_c = afterPull == null ? void 0 : afterPull.version) != null ? _c : await makeFileVersion({}, config);
+  const delayLog = [];
+  await writeMigrationFile(
+    __spreadProps$1(__spreadValues$1({}, config), {
+      logger: logger ? __spreadProps$1(__spreadValues$1({}, 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) {
+    await migrate({}, options, config, void 0, adapters);
+  } 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) => {
+  var _a, _b;
+  const module = await config.import(dbPath);
+  const db = module[(_a = config.dbExportedAs) != null ? _a : "db"];
+  if (!(db == null ? void 0 : db.$queryBuilder)) {
+    throw new Error(
+      `Unable to import OrchidORM instance as ${(_b = config.dbExportedAs) != null ? _b : "db"} from ${config.dbPath}`
+    );
+  }
+  return db;
+};
+const migrateAndPullStructures = async (options, config, afterPull) => {
+  if (afterPull) {
+    return {
+      dbStructure: {
+        schemas: [],
+        tables: [],
+        views: [],
+        indexes: [],
+        constraints: [],
+        triggers: [],
+        extensions: [],
+        enums: [],
+        domains: [],
+        collations: []
+      },
+      adapters: [afterPull.adapter]
+    };
+  }
+  const adapters = await migrate(
+    {},
+    options,
+    config,
+    void 0,
+    void 0,
+    true
+  );
+  const dbStructures = await Promise.all(
+    adapters.map((adapter) => introspectDbSchema(adapter))
+  );
+  const dbStructure = dbStructures[0];
+  for (let i = 1; i < dbStructures.length; i++) {
+    compareDbStructures(dbStructure, dbStructures[i], i);
+  }
+  return { dbStructure, adapters };
+};
+const compareDbStructures = (a, b, i, path) => {
+  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,
+          path ? `${path}[${n}]` : String(n)
+        );
+      }
+    } else {
+      for (const key in a) {
+        compareDbStructures(
+          a[key],
+          b[key],
+          i,
+          path ? `${path}.${key}` : key
+        );
+      }
+    }
+  }
+  if (err) {
+    throw new Error(`${path} in the db 0 does not match db ${i}`);
+  }
+};
+const getActualItems = async (db, currentSchema, internal, columnTypes) => {
+  var _a;
+  const tableNames = /* @__PURE__ */ new Set();
+  const habtmTables = /* @__PURE__ */ new Map();
+  const codeItems = {
+    schemas: /* @__PURE__ */ new Set(void 0),
+    enums: /* @__PURE__ */ new Map(),
+    tables: [],
+    domains: []
+  };
+  const domains = /* @__PURE__ */ new Map();
+  for (const key in db) {
+    if (key[0] === "$")
+      continue;
+    const table = db[key];
+    if (!table.table) {
+      throw new Error(`Table ${key} is missing table property`);
+    }
+    const { schema } = table.q;
+    const name = concatSchemaAndName({ schema, name: table.table });
+    if (tableNames.has(name)) {
+      throw new Error(`Table ${name} is defined more than once`);
+    }
+    tableNames.add(name);
+    if (schema)
+      codeItems.schemas.add(schema);
+    codeItems.tables.push(table);
+    for (const key2 in table.relations) {
+      const column = table.shape[key2];
+      if (column && "joinTable" in column) {
+        processHasAndBelongsToManyColumn(column, habtmTables, codeItems);
+      }
+    }
+    for (const key2 in table.shape) {
+      const column = table.shape[key2];
+      if (column instanceof DomainColumn) {
+        const [schemaName = currentSchema, name2] = getSchemaAndTableFromName(
+          column.dataType
+        );
+        domains.set(column.dataType, {
+          schemaName,
+          name: name2,
+          column: (_a = column.data.as) != null ? _a : new UnknownColumn(defaultSchemaConfig)
+        });
+      } else if (column.dataType === "enum") {
+        processEnumColumn(column, currentSchema, codeItems);
+      }
+    }
+  }
+  if (internal.extensions) {
+    for (const extension of internal.extensions) {
+      const [schema] = getSchemaAndTableFromName(extension.name);
+      if (schema)
+        codeItems.schemas.add(schema);
+    }
+  }
+  if (internal.domains) {
+    for (const key in internal.domains) {
+      const [schemaName = currentSchema, name] = getSchemaAndTableFromName(key);
+      const column = internal.domains[key](columnTypes);
+      domains.set(key, {
+        schemaName,
+        name,
+        column
+      });
+    }
+  }
+  for (const domain of domains.values()) {
+    codeItems.schemas.add(domain.schemaName);
+    codeItems.domains.push(domain);
+  }
+  return codeItems;
+};
+const processEnumColumn = (column, currentSchema, codeItems) => {
+  const { enumName, options } = column;
+  const [schema, name] = getSchemaAndTableFromName(enumName);
+  const enumSchema = schema != null ? 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] !== prev.shape[key]) {
+        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 = __spreadProps$1(__spreadValues$1({}, column2.data), {
+      identity: void 0,
+      isPrimaryKey: void 0,
+      default: void 0
+    });
+    shape[key] = column2;
+  }
+  joinTable.shape = shape;
+  joinTable.internal.primaryKey = {
+    columns: Object.keys(shape)
+  };
+  joinTable.internal.noPrimaryKey = false;
+  codeItems.tables.push(joinTable);
+  return;
+};
+const closeAdapters = (adapters) => {
+  return Promise.all(adapters.map((x) => x.close()));
+};
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const getTableInfosAndFKeys = (asts, config) => {
+  var _a, _b, _c;
+  const generateTableTo = (_a = config.generateTableTo) != null ? _a : (name) => `./tables/${name}.table.ts`;
+  const tableInfos = {};
+  const fkeys = {};
+  for (const ast of asts) {
+    if (ast.type === "table") {
+      const tableKey = toCamelCase(ast.name);
+      const dbTableName = ast.schema ? `${ast.schema}.${ast.name}` : ast.name;
+      let tablePath = path.resolve(config.basePath, generateTableTo(tableKey));
+      if (!tablePath.endsWith(".ts"))
+        tablePath += ".ts";
+      const name = toPascalCase(ast.name);
+      const info = {
+        dbTableName,
+        key: tableKey,
+        path: tablePath,
+        name,
+        className: `${name}Table`
+      };
+      tableInfos[dbTableName] = info;
+      if (ast.constraints) {
+        for (const { references } of ast.constraints) {
+          if (!references)
+            continue;
+          ((_c = fkeys[_b = references.fnOrTable]) != null ? _c : fkeys[_b] = []).push({
+            table: info,
+            references
+          });
+        }
+      }
+    }
+  }
+  return { tableInfos, fkeys };
+};
+const appCodeGenTable = (tableInfos, fkeys, ast, baseTablePath, baseTableExportedAs) => {
+  const tableInfo = tableInfos[ast.schema ? `${ast.schema}.${ast.name}` : ast.name];
+  const imports = {
+    "orchid-orm": "Selectable, Insertable, Updatable",
+    [getImportPath(tableInfo.path, baseTablePath)]: baseTableExportedAs
+  };
+  const props = [];
+  if (ast.schema) {
+    props.push(`schema = ${singleQuote(ast.schema)};`);
+  }
+  props.push(`readonly table = ${singleQuote(ast.name)};`);
+  if (ast.comment) {
+    props.push(`comment = ${singleQuote(ast.comment)};`);
+  }
+  if (ast.noPrimaryKey === "ignore") {
+    props.push("noPrimaryKey = true;");
+  }
+  props.push(
+    "columns = this.setColumns((t) => ({",
+    columnsShapeToCode(ast.shape, ast, "t"),
+    "}));"
+  );
+  const relations = [];
+  const fullTableName = ast.schema ? `${ast.schema}.${ast.name}` : ast.name;
+  const belongsTo = fkeys[fullTableName];
+  if (belongsTo) {
+    for (const { table, references } of belongsTo) {
+      imports[getImportPath(tableInfo.path, table.path)] = table.className;
+      relations.push(
+        `${table.key}: this.belongsTo(() => ${table.className}, {`,
+        [
+          `columns: [${references.foreignColumns.map(singleQuote).join(", ")}],`,
+          `references: [${references.columns.map(singleQuote).join(", ")}],`
+        ],
+        "}),"
+      );
+    }
+  }
+  if (ast.constraints) {
+    for (const { references } of ast.constraints) {
+      if (!references)
+        continue;
+      const table = tableInfos[references.fnOrTable];
+      imports[getImportPath(tableInfo.path, table.path)] = table.className;
+      relations.push(
+        `${table.key}: this.hasMany(() => ${table.className}, {`,
+        [
+          `columns: [${references.columns.map(singleQuote).join(", ")}],`,
+          `references: [${references.foreignColumns.map(singleQuote).join(", ")}],`
+        ],
+        "}),"
+      );
+    }
+  }
+  if (relations.length) {
+    props.push("", "relations = {", relations, "};");
+  }
+  const importsCode = importsToCode(imports);
+  const { name, className } = tableInfo;
+  const code = [
+    `export type ${name} = Selectable<${className}>;
+export type ${name}New = Insertable<${className}>;
+export type ${name}Update = Updatable<${className}>;
+
+export class ${className} extends ${baseTableExportedAs} {`,
+    props,
+    "}\n"
+  ];
+  return __spreadProps(__spreadValues({}, tableInfo), {
+    content: importsCode + "\n\n" + codeToString(code, "", "  ")
+  });
+};
+function importsToCode(imports) {
+  return Object.entries(imports).map(([from, name]) => `import { ${name} } from '${from}';`).join("\n");
+}
+
+const { createSourceFile, ScriptTarget, SyntaxKind } = typescript;
+const appCodeGenUpdateDbFile = async (dbPath, tables, extensions, domains) => {
+  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 ? `{ ${ext.name}: '${ext.version}' }` : `'${ext.name}'`
+      ).join(", ")}],`;
+    }
+    if (domains.length) {
+      code += `
+  domains: {
+    ${domains.sort((a, b) => a.name > b.name ? 1 : -1).map(
+        (ast) => `${quoteObjectKey(
+          ast.schema ? `${ast.schema}.${ast.name}` : ast.name
+        )}: (t) => ${ast.baseType.toCode("t")},`
+      ).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) => {
+  var _a, _b;
+  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 = (_a = imp.importClause.namedBindings) == null ? void 0 : _a.elements;
+    for (const element of elements) {
+      if (((_b = element.propertyName) == null ? void 0 : _b.escapedText) === "orchidORM" || element.name.escapedText === "orchidORM") {
+        return element.name.escapedText.toString();
+      }
+    }
+  }
+  return;
+};
+const makeTablesListChanges = (content, statements, object, tables, dbPath) => {
+  const spaces = getTablesListSpaces(content, object);
+  let imports = "";
+  let tablesList = "";
+  const prependComma = object.properties.length && !object.properties.hasTrailingComma;
+  const tablesListNewLine = content.slice(object.properties.end, object.end).includes("\n");
+  const tablesArr = Object.values(tables);
+  for (let i = 0; i < tablesArr.length; i++) {
+    const { path, className, key } = tablesArr[i];
+    const importPath = getImportPath(dbPath, path);
+    imports += `
+import { ${className} } from '${importPath}';`;
+    tablesList += `${i === 0 && prependComma ? "," : ""}
+${spaces}  ${key}: ${className},`;
+    if (i === tablesArr.length - 1 && !tablesListNewLine) {
+      tablesList += `
+${spaces}`;
+    }
+  }
+  if (!imports.length)
+    return;
+  let importPos = 0;
+  for (const node of statements) {
+    if (node.kind === SyntaxKind.ImportDeclaration) {
+      importPos = node.end;
+    }
+  }
+  return {
+    imports: { pos: importPos, text: imports },
+    tablesList: { pos: object.properties.end, text: tablesList }
+  };
+};
+const getTablesListSpaces = (content, object) => {
+  var _a;
+  const lines = content.slice(0, object.end).split("\n");
+  const last = lines[lines.length - 1];
+  return ((_a = last.match(/^\s+/)) == null ? void 0 : _a[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 == null ? void 0 : 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 == null ? void 0 : 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 (options, 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 = new Adapter(options[0]);
+  const currentSchema = adapter.schema || "public";
+  const ctx = makeStructureToAstCtx(config, currentSchema);
+  const asts = await structureToAst(ctx, adapter);
+  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
+        );
+        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
+  );
+  if (content)
+    pendingFileWrites.push([dbPath, content]);
+  if (firstTable) {
+    await fs.mkdir(path.dirname(firstTable.path), { recursive: true });
+  }
+  await Promise.all(
+    pendingFileWrites.map(
+      ([path2, content2, options2]) => fs.writeFile(path2, content2, options2).then(() => {
+        var _a;
+        (_a = config.logger) == null ? void 0 : _a.log(`Created ${pathToLog(path2)}`);
+      })
+    )
+  );
+  const version = await makeFileVersion({}, config);
+  await generate(options, config, ["pull"], { adapter, version });
+  const silentAdapter = adapter;
+  silentAdapter.silentArrays = adapter.arrays;
+  await saveMigratedVersion(silentAdapter, version, "pull.ts", config);
+  await adapter.close();
+};
+
+rakeDbCommands.g = rakeDbCommands.generate = {
+  run: generate,
+  help: "gen migration from OrchidORM tables",
+  helpArguments: {
+    "no arguments": '"generated" is a default file name',
+    "migration-name": "set migration file name",
+    up: "auto-apply migration",
+    "migration-name up": "with a custom name and apply it"
+  },
+  helpAfter: "reset"
+};
+rakeDbCommands.pull.run = pull;
+rakeDbCommands.pull.help = "generate ORM tables and a migration for an existing database";
+//# sourceMappingURL=migrations.mjs.map