orchid-orm 1.38.0 → 1.38.2

package/dist/migrations.mjs

@@ -1,6 +1,6 @@
 import { promptSelect, colors, getSchemaAndTableFromName, getDbTableColumnsChecks, dbColumnToAst, instantiateDbColumn, concatSchemaAndName, encodeColumnDefault, getIndexName, getExcludeName, getConstraintName, tableToAst, getDbStructureTableData, makeDomainsMap, astToMigration, createMigrationInterface, introspectDbSchema, exhaustive, pluralize, makeStructureToAstCtx, makeFileVersion, writeMigrationFile, migrate, structureToAst, saveMigratedVersion, rakeDbCommands } from 'rake-db';
 export * from 'rake-db';
-import { toSnakeCase, deepCompare, toArray, addCode, codeToString, toCamelCase, toPascalCase, getImportPath, singleQuote, quoteObjectKey, pathToLog } from 'orchid-core';
+import { toSnakeCase, deepCompare, emptyArray, toArray, addCode, codeToString, toCamelCase, toPascalCase, getImportPath, singleQuote, quoteObjectKey, pathToLog } from 'orchid-core';
 import { EnumColumn, ArrayColumn, DomainColumn, RawSQL, VirtualColumn, UnknownColumn, defaultSchemaConfig, columnsShapeToCode, pushTableDataCode, Adapter } from 'pqb';
 import path from 'node:path';
 import { pathToFileURL } from 'url';
@@ -14,23 +14,30 @@ const compareSqlExpressions = async (tableExpressions, adapter) => {
       tableExpressions.map(async ({ source, compare, handle }) => {
         const viewName = `orchidTmpView${id++}`;
         const values = [];
+        let result;
         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) {
+          const results = await adapter.query({
+            // It is important to run `CREATE TEMPORARY VIEW` and `DROP VIEW` on the same db connection,
+            // that's why SQLs are combined into a single query.
+            text: [
+              `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})`,
+              `SELECT pg_get_viewdef('${viewName}') v`,
+              `DROP VIEW ${viewName}`
+            ].join("; "),
+            values
+          });
+          result = results[1];
+        } catch {
+        }
+        if (!result) {
           handle();
           return;
         }
-        const {
-          rows: [{ v }]
-        } = await adapter.query(
-          `SELECT pg_get_viewdef('${viewName}') v`
-        );
-        await adapter.query(`DROP VIEW ${viewName}`);
+        const v = result.rows[0].v;
         let pos = 7;
         const rgx = /\s+AS\s+"\*(inDb-\d+|inCode-\d+-\d+)\*",?/g;
         let match;
@@ -618,10 +625,10 @@ const processDomains = async (ast, adapter, structureToAstCtx, domainsMap, dbStr
         typmod: -1
       }
     );
-    if (domain.check) {
-      dbColumn.data.check = {
-        sql: new RawSQL([[domain.check]])
-      };
+    if (domain.checks) {
+      dbColumn.data.checks = domain.checks.map((check) => ({
+        sql: new RawSQL([[check]])
+      }));
     }
     const dbDomain = makeComparableDomain(
       currentSchema,
@@ -632,13 +639,13 @@ const processDomains = async (ast, adapter, structureToAstCtx, domainsMap, dbStr
     const found = codeDomains.filter(
       (codeDomain) => deepCompare(dbDomain.compare, codeDomain.compare)
     );
-    if ((domain.default || domain.check) && found.length) {
+    if ((domain.default || domain.checks?.length) && found.length) {
       for (const codeDomain of found) {
         holdCodeDomains.add(codeDomain);
       }
       const compare = [];
-      pushCompare(compare, domain, found, "default");
-      pushCompare(compare, domain, found, "check");
+      pushCompareDefault(compare, domain, found);
+      pushCompareChecks(compare, domain, found);
       const source = `(VALUES (NULL::${getColumnDbType(
         dbColumn,
         currentSchema
@@ -715,17 +722,16 @@ const makeComparableDomain = (currentSchema, schemaName, name, column) => {
       dateTimePrecision: inner.data.dateTimePrecision,
       collate: column.data.collate,
       hasDefault: column.data.default !== void 0,
-      hasCheck: column.data.check !== void 0
+      hasChecks: !!column.data.checks?.length
     }
   };
 };
-const pushCompare = (compare, domain, found, key) => {
-  const inDb = domain[key];
-  if (inDb) {
+const pushCompareDefault = (compare, domain, found) => {
+  if (domain.default) {
     compare.push({
-      inDb,
+      inDb: domain.default,
       inCode: found.map((codeDomain) => {
-        const value = codeDomain.column.data[key];
+        const value = codeDomain.column.data.default;
         if ("sql" in value) {
           return value.sql;
         }
@@ -734,6 +740,21 @@ const pushCompare = (compare, domain, found, key) => {
     });
   }
 };
+const pushCompareChecks = (compare, domain, found) => {
+  if (domain.checks?.length) {
+    const inCode = found.flatMap(
+      (codeDomain) => codeDomain.column.data.checks?.map(
+        (check) => typeof check === "string" ? check : check.sql
+      ) || emptyArray
+    );
+    compare.push(
+      ...domain.checks.map((check) => ({
+        inDb: check,
+        inCode
+      }))
+    );
+  }
+};
 const dropAst = (dbDomain) => ({
   type: "domain",
   action: "drop",
@@ -1211,6 +1232,7 @@ const collectCodeComparableItemsType = (config, codeItems, key) => {
   });
 };
 const normalizeItem = (item) => {
+  if (item.using) item.using = item.using.toLowerCase();
   if (item.using === "btree") item.using = void 0;
   if (!item.unique) item.unique = void 0;
   if (item.nullsNotDistinct === false) item.nullsNotDistinct = void 0;
@@ -1619,12 +1641,12 @@ const processChecks = (ast, changeTableData, compareExpressions) => {
   if (!hasDbChecks) {
     if (codeChecks.length) {
       const constraints = add.constraints ?? (add.constraints = []);
-      for (const check of codeChecks) {
-        if (check.column && changeTableData.changingColumns[check.column]) {
-          const column = changeTableData.changingColumns[check.column];
-          column.to.data.check = check;
-        } else {
-          constraints.push({ check: check.sql, name: check.name });
+      for (const codeCheck of codeChecks) {
+        if (!codeCheck.column || !changeTableData.changingColumns[codeCheck.column]) {
+          constraints.push({
+            check: codeCheck.check.sql,
+            name: codeCheck.name
+          });
         }
       }
     }
@@ -1645,20 +1667,40 @@ const processChecks = (ast, changeTableData, compareExpressions) => {
         compare: [
           {
             inDb: dbCheck.expression,
-            inCode: codeChecks.map((check) => check.sql)
+            inCode: codeChecks.map(({ check }) => check.sql)
           }
         ],
         handle(i) {
-          if (i !== void 0) return;
-          dropCheck(changeTableData, dbCheck, name);
-          if (--wait === 0 && !changeTableData.pushedAst) {
+          if (i !== void 0) {
+            foundCodeChecks.add(i);
+          } else {
+            dropCheck(changeTableData, dbCheck, name);
+          }
+          if (--wait !== 0) return;
+          const checksToAdd = [];
+          codeChecks.forEach((check, i2) => {
+            if (foundCodeChecks.has(i2)) {
+              if (!check.column) return;
+              const change = changeTableData.changingColumns[check.column];
+              if (!change) return;
+              const columnChecks = change.to.data.checks;
+              if (!columnChecks) return;
+              const i3 = columnChecks.indexOf(check.check);
+              if (i3 !== -1) {
+                columnChecks.splice(i3, 1);
+              }
+              return;
+            }
+            checksToAdd.push({
+              name: check.name,
+              check: check.check.sql
+            });
+          });
+          if (checksToAdd.length) {
+            (add.constraints ?? (add.constraints = [])).push(...checksToAdd);
+          }
+          if (!changeTableData.pushedAst && (changeTableData.changeTableAst.drop.constraints?.length || add.constraints?.length)) {
             changeTableData.pushedAst = true;
-            (add.constraints ?? (add.constraints = [])).push(
-              ...codeChecks.filter((_, i2) => !foundCodeChecks.has(i2)).map((check) => ({
-                name: check.name,
-                check: check.sql
-              }))
-            );
             ast.push(changeTableData.changeTableAst);
           }
         }
@@ -1672,41 +1714,70 @@ const collectCodeChecks = ({
   codeTable,
   changeTableAst: { shape }
 }) => {
+  const names = /* @__PURE__ */ new Set();
   const codeChecks = [];
   for (const key in codeTable.shape) {
     const column = codeTable.shape[key];
-    if (!column.data.check) continue;
-    const name = column.data.name ?? key;
-    if (checkForColumnAddOrDrop(shape, name)) continue;
-    codeChecks.push({
-      ...column.data.check,
-      column: name
-    });
+    if (!column.data.checks) continue;
+    const columnName = column.data.name ?? key;
+    if (checkForColumnAddOrDrop(shape, columnName)) continue;
+    const baseName = `${codeTable.table}_${columnName}_check`;
+    codeChecks.push(
+      ...column.data.checks.map((check) => {
+        let name = check.name;
+        if (!name) {
+          name = baseName;
+          let n = 0;
+          while (names.has(name)) {
+            name = baseName + ++n;
+          }
+        }
+        names.add(name);
+        return {
+          check,
+          name,
+          column: columnName
+        };
+      })
+    );
   }
   if (codeTable.internal.tableData.constraints) {
     for (const constraint of codeTable.internal.tableData.constraints) {
       const { check } = constraint;
       if (check) {
-        codeChecks.push({ sql: check, name: constraint.name });
+        const baseName = `${codeTable.table}_check`;
+        let name = constraint.name;
+        if (!name) {
+          name = baseName;
+          let n = 0;
+          while (names.has(name)) {
+            name = baseName + ++n;
+          }
+        }
+        names.add(name);
+        codeChecks.push({
+          check: { sql: check, name: constraint.name },
+          name
+        });
       }
     }
   }
   return codeChecks;
 };
 const dropCheck = ({ changeTableAst: { drop }, changingColumns }, dbCheck, name) => {
-  const constraints = drop.constraints ?? (drop.constraints = []);
+  var _a;
   const sql = new RawSQL([
     [dbCheck.expression]
   ]);
   if (dbCheck.columns?.length === 1 && changingColumns[dbCheck.columns[0]]) {
     const column = changingColumns[dbCheck.columns[0]];
     column.from.data.name = "i_d";
-    column.from.data.check = {
+    ((_a = column.from.data).checks ?? (_a.checks = [])).push({
       name,
       sql
-    };
+    });
   } else {
-    constraints.push({
+    (drop.constraints ?? (drop.constraints = [])).push({
       name,
       check: sql
     });
@@ -1920,7 +1991,7 @@ const addChangeTable = (dbStructure, changeTables, tableShapes, currentSchema, d
   const shape = {};
   const schema = codeTable.q.schema ?? currentSchema;
   changeTables.push({
-    codeTable,
+    codeTable: cloneCodeTableForChange(codeTable),
     dbTable,
     dbTableData: getDbStructureTableData(dbStructure, dbTable),
     schema,
@@ -1938,6 +2009,19 @@ const addChangeTable = (dbStructure, changeTables, tableShapes, currentSchema, d
   });
   tableShapes[`${schema}.${codeTable.table}`] = shape;
 };
+const cloneCodeTableForChange = (codeTable) => ({
+  ...codeTable,
+  shape: Object.fromEntries(
+    Object.entries(codeTable.shape).map(([key, column]) => {
+      const cloned = Object.create(column);
+      cloned.data = {
+        ...cloned.data,
+        checks: cloned.data.checks && [...cloned.data.checks]
+      };
+      return [key, cloned];
+    })
+  )
+});
 const createTableAst = (currentSchema, table) => {
   return {
     type: "table",
@@ -2106,8 +2190,8 @@ const report = (ast, config, currentSchema) => {
           if (column.data.foreignKeys) {
             counters["foreign key"] += column.data.foreignKeys.length;
           }
-          if (column.data.check) {
-            counters.check++;
+          if (column.data.checks) {
+            counters.check += column.data.checks.length;
           }
         }
         const summary = [];
@@ -2140,13 +2224,13 @@ const report = (ast, config, currentSchema) => {
           for (const change of changes) {
             if (change.type === "add" || change.type === "drop") {
               const column = change.item;
-              const { primaryKey, indexes, excludes, foreignKeys, check } = column.data;
+              const { primaryKey, indexes, excludes, foreignKeys, checks } = column.data;
               inner.push(
                 `${change.type === "add" ? green("+ add column") : red("- drop column")} ${key} ${column.data.alias ?? getColumnDbType(column, currentSchema)}${column.data.isNullable ? " nullable" : ""}${primaryKey ? " primary key" : ""}${foreignKeys ? ` references ${foreignKeys.map((fk) => {
                   return `${fnOrTableToString(
                     fk.fnOrTable
                   )}(${fk.foreignColumns.join(", ")})`;
-                }).join(", ")}` : ""}${indexes?.length ? indexes.length === 1 ? ", has index" : `, has ${indexes.length} indexes` : ""}${excludes?.length ? excludes.length === 1 ? ", has exclude" : `, has ${excludes.length} excludes` : ""}${check ? `, checks ${check.sql.toSQL({ values: [] })}` : ""}`
+                }).join(", ")}` : ""}${indexes?.length ? indexes.length === 1 ? ", has index" : `, has ${indexes.length} indexes` : ""}${excludes?.length ? excludes.length === 1 ? ", has exclude" : `, has ${excludes.length} excludes` : ""}${checks?.length ? `, checks ${checks.map((check) => check.sql.toSQL({ values: [] })).join(", ")}` : ""}`
               );
             } else if (change.type === "change") {
               const name = change.from.column?.data.name ?? key;