orchid-orm 1.55.0 → 1.56.2

package/dist/{migrations.js → migrations/postgres-js.js}

@@ -7,6 +7,7 @@ var path = require('node:path');
 var url = require('url');
 var fs = require('fs/promises');
 var typescript = require('typescript');
+var postgresJs = require('rake-db/postgres-js');
 
 const compareSqlExpressions = async (tableExpressions, adapter) => {
   if (tableExpressions.length) {
@@ -17,10 +18,10 @@ const compareSqlExpressions = async (tableExpressions, adapter) => {
         const values = [];
         let result;
         try {
-          const results = await adapter.query({
+          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, inCode }, i) => `${inDb} AS "*inDb-${i}*", ${inCode.map(
                   (s, j) => `(${typeof s === "string" ? s : s.toSQL({ values })}) "*inCode-${i}-${j}*"`
@@ -30,7 +31,7 @@ const compareSqlExpressions = async (tableExpressions, adapter) => {
               `DROP VIEW ${viewName}`
             ].join("; "),
             values
-          });
+          );
           result = results[1];
         } catch {
         }
@@ -89,20 +90,20 @@ const promptCreateOrRename = (kind, name, drop, verifying) => {
   }
   const renameMessage = `rename ${kind}`;
   return rakeDb.promptSelect({
-    message: `Create or rename ${rakeDb.colors.blueBold(
+    message: `Create or rename ${orchidCore.colors.blueBold(
       name
     )} ${kind} from another ${kind}?`,
     options: [
-      `${rakeDb.colors.greenBold("+")} ${name}  ${rakeDb.colors.pale(
+      `${orchidCore.colors.greenBold("+")} ${name}  ${orchidCore.colors.pale(
         `create ${kind}`.padStart(
           hintPos + renameMessage.length - name.length - 4,
           " "
         )
       )}`,
       ...drop.map(
-        (d) => `${rakeDb.colors.yellowBold("~")} ${d} ${rakeDb.colors.yellowBold(
+        (d) => `${orchidCore.colors.yellowBold("~")} ${d} ${orchidCore.colors.yellowBold(
           "=>"
-        )} ${name}  ${rakeDb.colors.pale(
+        )} ${name}  ${orchidCore.colors.pale(
           renameMessage.padStart(
             hintPos + renameMessage.length - d.length - name.length - 8,
             " "
@@ -460,9 +461,9 @@ const compareColumns = async (adapter, domainsMap, ast, currentSchema, compareSq
         const abort = await rakeDb.promptSelect({
           message: `Cannot cast type of ${tableName}'s column ${key} from ${dbType} to ${codeType}`,
           options: [
-            `${rakeDb.colors.yellowBold(
+            `${orchidCore.colors.yellowBold(
               `-/+`
-            )} recreate the column, existing data will be ${rakeDb.colors.red(
+            )} recreate the column, existing data will be ${orchidCore.colors.red(
               "lost"
             )}`,
             `write migration manually`
@@ -2006,10 +2007,10 @@ 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
-    });
+    } = await adapter.arrays(
+      "SELECT " + compareSql.expressions.map((x) => `${x.inDb} = (${x.inCode})`).join(", "),
+      compareSql.values
+    );
     for (let i = 0; i < results.length; i++) {
       if (!results[i]) {
         compareSql.expressions[i].change();
@@ -2148,29 +2149,25 @@ const composeMigration = async (adapter, config, ast, dbStructure, params) => {
   return rakeDb.astToMigration(currentSchema, config, ast);
 };
 
+const rollbackErr = new Error("Rollback");
 const verifyMigration = async (adapter, config, migrationCode, generateMigrationParams) => {
   const migrationFn = new Function("change", migrationCode);
-  return adapter.transaction(
-    { text: "BEGIN" },
-    async (trx) => {
+  let code;
+  try {
+    await adapter.transaction(void 0, async (trx) => {
       const changeFns = [];
       migrationFn((changeCb) => {
         changeFns.push(changeCb);
       });
       const { log } = config;
       config.log = false;
-      const db = rakeDb.createMigrationInterface(
-        trx,
-        true,
-        config
-      );
+      const db = rakeDb.createMigrationInterface(trx, true, config);
       config.log = log;
       for (const changeFn of changeFns) {
         await changeFn(db, true);
       }
       const dbStructure = await rakeDb.introspectDbSchema(trx);
       generateMigrationParams.verifying = true;
-      let code;
       try {
         code = await composeMigration(
           trx,
@@ -2181,14 +2178,19 @@ const verifyMigration = async (adapter, config, migrationCode, generateMigration
         );
       } catch (err) {
         if (err instanceof AbortSignal) {
-          return false;
+          code = false;
+          throw rollbackErr;
         }
         throw err;
       }
-      return code;
-    },
-    { text: "ROLLBACK" }
-  );
+      throw rollbackErr;
+    });
+  } catch (err) {
+    if (err !== rollbackErr) {
+      throw err;
+    }
+  }
+  return code;
 };
 
 const report = (ast, config, currentSchema) => {
@@ -2198,7 +2200,7 @@ const report = (ast, config, currentSchema) => {
   if (typeof config.log === "object" && config.log.colors === false) {
     green = red = yellow = pale = (s) => s;
   } else {
-    ({ green, red, yellow, pale } = rakeDb.colors);
+    ({ green, red, yellow, pale } = orchidCore.colors);
   }
   for (const a of ast) {
     switch (a.type) {
@@ -2241,7 +2243,7 @@ const report = (ast, config, currentSchema) => {
           const value = counters[key];
           if (value || key === "column") {
             summary.push(
-              `${value} ${rakeDb.pluralize(key, value, key === "index" ? "es" : "s")}`
+              `${value} ${orchidCore.pluralize(key, value, key === "index" ? "es" : "s")}`
             );
           }
         }
@@ -2295,7 +2297,7 @@ const report = (ast, config, currentSchema) => {
                 `${yellow("~ rename column")} ${config.snakeCase ? orchidCore.toCamelCase(key) : key} ${yellow("=>")} ${change.name}`
               );
             } else {
-              rakeDb.exhaustive(change.type);
+              orchidCore.exhaustive(change.type);
             }
           }
         }
@@ -2482,7 +2484,7 @@ const report = (ast, config, currentSchema) => {
         break;
       }
       default:
-        rakeDb.exhaustive(a);
+        orchidCore.exhaustive(a);
     }
   }
   const result = orchidCore.codeToString(code, "", "  ");
@@ -2494,10 +2496,10 @@ const dbItemName = ({ schema, name }, currentSchema) => {
 
 class AbortSignal extends Error {
 }
-const generate = async (options, config, args, afterPull) => {
+const generate = async (adapters, config, args, afterPull) => {
   let { dbPath } = config;
   if (!dbPath || !config.baseTable) throw invalidConfig(config);
-  if (!options.length) throw new Error(`Database options must not be empty`);
+  if (!adapters.length) throw new Error(`Database options must not be empty`);
   if (!dbPath.endsWith(".ts")) dbPath += ".ts";
   let migrationName = args[0] ?? "generated";
   let up;
@@ -2507,8 +2509,11 @@ const generate = async (options, config, args, afterPull) => {
   } else {
     up = args[1] === "up";
   }
-  const { dbStructure, adapters } = await migrateAndPullStructures(
-    options,
+  if (afterPull) {
+    adapters = [afterPull.adapter];
+  }
+  const { dbStructure } = await migrateAndPullStructures(
+    adapters,
     config,
     afterPull
   );
@@ -2587,7 +2592,9 @@ ${msg}`);
     }
   }
   if (up) {
-    await rakeDb.migrate({}, options, config, void 0, adapters);
+    for (const adapter2 of adapters) {
+      await rakeDb.migrateAndClose({ adapter: adapter2, config });
+    }
   } else if (!afterPull) {
     await closeAdapters(adapters);
   }
@@ -2607,7 +2614,7 @@ const getDbFromConfig = async (config, dbPath) => {
   }
   return db;
 };
-const migrateAndPullStructures = async (options, config, afterPull) => {
+const migrateAndPullStructures = async (adapters, config, afterPull) => {
   if (afterPull) {
     return {
       dbStructure: {
@@ -2622,18 +2629,12 @@ const migrateAndPullStructures = async (options, config, afterPull) => {
         enums: [],
         domains: [],
         collations: []
-      },
-      adapters: [afterPull.adapter]
+      }
     };
   }
-  const adapters = await rakeDb.migrate(
-    {},
-    options,
-    config,
-    void 0,
-    void 0,
-    true
-  );
+  for (const adapter of adapters) {
+    await rakeDb.migrate({ adapter, config });
+  }
   const dbStructures = await Promise.all(
     adapters.map((adapter) => rakeDb.introspectDbSchema(adapter))
   );
@@ -2641,7 +2642,7 @@ const migrateAndPullStructures = async (options, config, afterPull) => {
   for (let i = 1; i < dbStructures.length; i++) {
     compareDbStructures(dbStructure, dbStructures[i], i);
   }
-  return { dbStructure, adapters };
+  return { dbStructure };
 };
 const compareDbStructures = (a, b, i, path2) => {
   let err;
@@ -3088,7 +3089,7 @@ const applyChanges = (content, changes) => {
   ).join("") : content;
 };
 
-const pull = async (options, config) => {
+const pull = async (adapters, config) => {
   if (!config.dbPath || !config.baseTable) {
     throw new Error(
       `\`${config.dbPath ? "baseTable" : "dbPath"}\` setting must be set in the migrations config for pull command`
@@ -3096,7 +3097,6 @@ const pull = async (options, config) => {
   }
   const baseTablePath = config.baseTable.getFilePath();
   const baseTableExportedAs = config.baseTable.exportAs;
-  const adapters = options.map((opts) => new pqb.Adapter(opts));
   const [adapter] = adapters;
   const currentSchema = adapter.schema || "public";
   const ctx = rakeDb.makeStructureToAstCtx(config, currentSchema);
@@ -3160,13 +3160,13 @@ const pull = async (options, config) => {
   }
   await Promise.all(
     pendingFileWrites.map(
-      ([path2, content2, options2]) => fs.writeFile(path2, content2, options2).then(() => {
+      ([path2, content2, options]) => fs.writeFile(path2, content2, options).then(() => {
         config.logger?.log(`Created ${orchidCore.pathToLog(path2)}`);
       })
     )
   );
   const version = await rakeDb.makeFileVersion({}, config);
-  await generate(options, config, ["pull"], { adapter, version });
+  await generate(adapters, config, ["pull"], { adapter, version });
   await Promise.all(
     adapters.map(async (adapter2) => {
       const silentAdapter = adapter2;
@@ -3191,10 +3191,10 @@ rakeDb.rakeDbCommands.g = rakeDb.rakeDbCommands.generate = {
 rakeDb.rakeDbCommands.pull.run = pull;
 rakeDb.rakeDbCommands.pull.help = "generate ORM tables and a migration for an existing database";
 
-Object.keys(rakeDb).forEach(function (k) {
+Object.keys(postgresJs).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
     enumerable: true,
-    get: function () { return rakeDb[k]; }
+    get: function () { return postgresJs[k]; }
   });
 });
-//# sourceMappingURL=migrations.js.map
+//# sourceMappingURL=postgres-js.js.map