orchid-orm 1.6.39 → 1.7.0

package/dist/index.js

@@ -1,17 +1,13 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var pqb = require('pqb');
 var orchidCore = require('orchid-core');
+var node_async_hooks = require('node:async_hooks');
 var path = require('path');
 var fs = require('fs/promises');
 var typescript = require('typescript');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
+function _interopNamespaceDefault(e) {
   var n = Object.create(null);
   if (e) {
     Object.keys(e).forEach(function (k) {
@@ -24,14 +20,11 @@ function _interopNamespace(e) {
       }
     });
   }
-  n["default"] = e;
+  n.default = e;
   return Object.freeze(n);
 }
 
-var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
-var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
-var typescript__default = /*#__PURE__*/_interopDefaultLegacy(typescript);
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
 
 const createBaseTable = ({
   columnTypes,
@@ -169,11 +162,11 @@ const makeBelongsToMethod = (relation, relationName, query) => {
   };
 };
 const nestedInsert$3 = ({ query, primaryKey }) => {
-  return async (q, data) => {
+  return async (_, data) => {
     const connectOrCreate = data.filter(
       (item) => Boolean(item.connectOrCreate)
     );
-    const t = query.transacting(q);
+    const t = query.clone();
     let connectOrCreated;
     if (connectOrCreate.length) {
       connectOrCreated = await Promise.all(
@@ -237,12 +230,12 @@ const nestedUpdate$3 = ({ query, primaryKey, foreignKey }) => {
         if (primaryKey in params.set) {
           update[foreignKey] = params.set[primaryKey];
         } else {
-          update[foreignKey] = await query.transacting(q2)._findBy(params.set)._get(primaryKey);
+          update[foreignKey] = await query.findBy(params.set)._get(primaryKey);
         }
       } else if (params.create) {
-        update[foreignKey] = await query.transacting(q2)._get(primaryKey)._create(params.create);
+        update[foreignKey] = await query.get(primaryKey)._create(params.create);
       } else if (params.delete) {
-        const selectQuery = q2.transacting(q2);
+        const selectQuery = q2.clone();
         selectQuery.query.type = void 0;
         idForDelete = await selectQuery._getOptional(foreignKey);
         update[foreignKey] = null;
@@ -264,10 +257,10 @@ const nestedUpdate$3 = ({ query, primaryKey, foreignKey }) => {
         const data = await handleResult(q2, queryResult);
         const id = data[0][foreignKey];
         if (id !== null) {
-          await query.transacting(q2)._findBy({ [primaryKey]: id })._update(upsert.update);
+          await query.findBy({ [primaryKey]: id })._update(upsert.update);
         } else {
           state.updateLaterPromises.push(
-            query.transacting(q2)._select(primaryKey)._create(upsert.create).then((result) => {
+            query.select(primaryKey)._create(upsert.create).then((result) => {
               state.updateLater[foreignKey] = result[primaryKey];
             })
           );
@@ -275,12 +268,12 @@ const nestedUpdate$3 = ({ query, primaryKey, foreignKey }) => {
         return data;
       };
     } else if (params.delete || params.update) {
-      q._afterQuery(async (q2, data) => {
+      q._afterQuery(async (_, data) => {
         const id = params.delete ? idForDelete : Array.isArray(data) ? data.length === 0 ? null : {
           in: data.map((item) => item[foreignKey]).filter((id2) => id2 !== null)
         } : data[foreignKey];
         if (id !== void 0 && id !== null) {
-          const t = query.transacting(q2)._findBy({
+          const t = query.findBy({
             [primaryKey]: id
           });
           if (params.delete) {
@@ -472,11 +465,11 @@ const makeHasOneMethod = (table, relation, relationName, query) => {
   };
 };
 const nestedInsert$2 = ({ query, primaryKey, foreignKey }) => {
-  return async (q, data) => {
+  return async (_, data) => {
     const connect = data.filter(
       (item) => Boolean(item[1].connect || item[1].connectOrCreate)
     );
-    const t = query.transacting(q);
+    const t = query.clone();
     let connected;
     if (connect.length) {
       connected = await Promise.all(
@@ -512,7 +505,7 @@ const nestedUpdate$2 = ({ query, primaryKey, foreignKey }) => {
       const key = params.set ? "set" : params.create ? "create" : "upsert";
       throw new Error(`\`${key}\` option is not allowed in a batch update`);
     }
-    const t = query.transacting(q);
+    const t = query.clone();
     const ids = data.map((item) => item[primaryKey]);
     const currentRelationsQuery = t.where({
       [foreignKey]: { in: ids }
@@ -681,11 +674,11 @@ const getWhereForNestedUpdate = (data, params, primaryKey, foreignKey) => {
   return where;
 };
 const nestedInsert$1 = ({ query, primaryKey, foreignKey }) => {
-  return async (q, data) => {
+  return async (_, data) => {
     const connect = data.filter(
       (item) => Boolean(item[1].connect)
     );
-    const t = query.transacting(q);
+    const t = query.clone();
     if (connect.length) {
       await Promise.all(
         connect.flatMap(
@@ -748,7 +741,7 @@ const nestedUpdate$1 = ({ query, primaryKey, foreignKey }) => {
       const key = params.set ? "set" : "create";
       throw new Error(`\`${key}\` option is not allowed in a batch update`);
     }
-    const t = query.transacting(q);
+    const t = query.clone();
     if (params.create) {
       await t._count()._createMany(
         params.create.map((create) => __spreadProps$4(__spreadValues$6({}, create), {
@@ -898,6 +891,8 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
       relationName,
       state
     ),
+    // joinQuery can be a property of RelationQuery and be used by whereExists and other stuff which needs it
+    // and the chained query itself may be a query around this joinQuery
     joinQuery(fromQuery, toQuery) {
       const join = toQuery.whereExists(
         subQuery,
@@ -920,10 +915,11 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
       pqb.pushQueryValue(
         relationQuery,
         "afterCreate",
-        async (q, result) => {
+        async (_, result) => {
           const fromQuery = ref.query.clone();
           fromQuery.query.select = [{ selectAs: { [fk]: pk } }];
-          const createdCount = await subQuery.transacting(q).count()._createFrom(
+          const createdCount = await subQuery.count()._createFrom(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             fromQuery,
             {
               [afk]: result[apk]
@@ -940,8 +936,8 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
     }
   };
 };
-const queryJoinTable = (state, q, data, conditions) => {
-  const t = state.joinTableQuery.transacting(q);
+const queryJoinTable = (state, data, conditions) => {
+  const t = state.joinTableQuery.clone();
   const where = {
     [state.foreignKey]: { in: data.map((item) => item[state.primaryKey]) }
   };
@@ -954,8 +950,10 @@ const queryJoinTable = (state, q, data, conditions) => {
   }
   return t._where(where);
 };
-const queryRelatedTable = (query, q, conditions) => {
-  return query.transacting(q)._where(Array.isArray(conditions) ? { OR: conditions } : conditions);
+const queryRelatedTable = (query, conditions) => {
+  return query.where(
+    Array.isArray(conditions) ? { OR: conditions } : conditions
+  );
 };
 const insertToJoinTable = (state, joinTableTransaction, data, ids) => {
   return joinTableTransaction._count()._createMany(
@@ -975,11 +973,11 @@ const nestedInsert = ({
   associationPrimaryKey,
   associationForeignKey
 }) => {
-  return async (q, data) => {
+  return async (_, data) => {
     const connect = data.filter(
       (item) => Boolean(item[1].connect)
     );
-    const t = relatedTableQuery.transacting(q);
+    const t = relatedTableQuery.clone();
     let connected;
     if (connect.length) {
       connected = await Promise.all(
@@ -1064,7 +1062,7 @@ const nestedInsert = ({
         connectI += len;
       }
     });
-    await joinTableQuery.transacting(q)._count()._createMany(
+    await joinTableQuery.count()._createMany(
       allKeys.flatMap(([selfData, relationKeys]) => {
         const selfKey = selfData[primaryKey];
         return relationKeys.map((relationData) => ({
@@ -1076,10 +1074,10 @@ const nestedInsert = ({
   };
 };
 const nestedUpdate = (state) => {
-  return async (q, data, params) => {
+  return async (_, data, params) => {
     if (params.create) {
-      const ids = await state.relatedTableQuery.transacting(q)._pluck(state.associationPrimaryKey)._createMany(params.create);
-      await state.joinTableQuery.transacting(q)._createMany(
+      const ids = await state.relatedTableQuery.pluck(state.associationPrimaryKey)._createMany(params.create);
+      await state.joinTableQuery.createMany(
         data.flatMap(
           (item) => ids.map((id) => ({
             [state.foreignKey]: item[state.primaryKey],
@@ -1089,38 +1087,40 @@ const nestedUpdate = (state) => {
       );
     }
     if (params.update) {
-      await state.relatedTableQuery.transacting(q)._whereExists(
+      await state.relatedTableQuery.whereExists(
         state.joinTableQuery,
-        (q2) => q2._on(
-          state.associationForeignKeyFull,
-          state.associationPrimaryKeyFull
-        )._where({
-          IN: {
-            columns: [state.foreignKeyFull],
-            values: [data.map((item) => item[state.primaryKey])]
-          }
-        })
+        (q) => (
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          q._on(
+            state.associationForeignKeyFull,
+            state.associationPrimaryKeyFull
+          )._where({
+            IN: {
+              columns: [state.foreignKeyFull],
+              values: [data.map((item) => item[state.primaryKey])]
+            }
+          })
+        )
       )._where(
         Array.isArray(params.update.where) ? { OR: params.update.where } : params.update.where
       )._update(params.update.data);
     }
     if (params.disconnect) {
-      await queryJoinTable(state, q, data, params.disconnect)._delete();
+      await queryJoinTable(state, data, params.disconnect)._delete();
     }
     if (params.delete) {
-      const j = queryJoinTable(state, q, data, params.delete);
+      const j = queryJoinTable(state, data, params.delete);
       const ids = await j._pluck(state.associationForeignKey)._delete();
-      await queryRelatedTable(state.relatedTableQuery, q, {
+      await queryRelatedTable(state.relatedTableQuery, {
         [state.associationPrimaryKey]: { in: ids }
       })._delete();
     }
     if (params.set) {
-      const j = queryJoinTable(state, q, data);
+      const j = queryJoinTable(state, data);
       await j._delete();
       delete j.query[pqb.toSqlCacheKey];
       const ids = await queryRelatedTable(
         state.relatedTableQuery,
-        q,
         params.set
       )._pluck(state.associationPrimaryKey);
       await insertToJoinTable(state, j, data, ids);
@@ -1295,25 +1295,11 @@ const makeRelationQuery = (table, definedAs, relationName, data) => {
   });
 };
 
-function transaction(fn) {
-  if (fn.length === 0) {
-    throw new Error("Argument of $transaction callback should be used");
-  }
-  return this.$queryBuilder.transaction((q) => {
-    const orm = {};
-    for (const key in this) {
-      const value = this[key];
-      if (value instanceof pqb.Db) {
-        const table = value.transacting(q);
-        table.baseQuery = table;
-        table.db = orm;
-        orm[key] = table;
-      } else {
-        orm[key] = value;
-      }
-    }
-    return fn(orm);
-  });
+function transaction(fnOrOptions, fn) {
+  return this.$queryBuilder.transaction(
+    fnOrOptions,
+    fn
+  );
 }
 
 var __defProp$4 = Object.defineProperty;
@@ -1366,12 +1352,14 @@ const orchidORM = (_a, tables) => {
     autoPreparedStatements,
     noPrimaryKey
   };
+  const transactionStorage = new node_async_hooks.AsyncLocalStorage();
   const qb = new pqb.Db(
     adapter,
     void 0,
     void 0,
     pqb.anyShape,
     pqb.columnTypes,
+    transactionStorage,
     commonOptions
   );
   qb.queryBuilder = qb;
@@ -1396,10 +1384,12 @@ const orchidORM = (_a, tables) => {
       options2.noPrimaryKey = "ignore";
     const dbTable = new pqb.Db(
       adapter,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       qb,
       table.table,
       table.columns.shape,
       table.columnTypes,
+      transactionStorage,
       options2
     );
     dbTable.definedAs = key;
@@ -1486,7 +1476,7 @@ class FileChanges {
   }
 }
 
-const { createSourceFile, ScriptTarget, SyntaxKind } = typescript__default["default"];
+const { createSourceFile, ScriptTarget, SyntaxKind } = typescript;
 const iterate = (kind) => {
   return function* (statements) {
     for (const node of statements) {
@@ -1626,7 +1616,7 @@ const ts = {
 };
 
 const getImportPath = (from, to) => {
-  const rel = path__default["default"].relative(path__default["default"].dirname(from), to).split(path__default["default"].sep).join(path__default["default"].posix.sep);
+  const rel = path.relative(path.dirname(from), to).split(path.sep).join(path.posix.sep);
   const importPath = rel.startsWith("./") || rel.startsWith("../") ? rel : `./${rel}`;
   return importPath.replace(/\.[tj]s$/, "");
 };
@@ -1656,7 +1646,7 @@ const optionsToString = (options) => {
   return lines.join("\n    ");
 };
 const updateMainFile = async (filePath, tablePath, ast, options, logger) => {
-  const result = await fs__default["default"].readFile(filePath, "utf-8").then(
+  const result = await fs.readFile(filePath, "utf-8").then(
     (content2) => ({ error: void 0, content: content2 }),
     (error) => {
       return { error, content: void 0 };
@@ -1699,9 +1689,9 @@ const updateMainFile = async (filePath, tablePath, ast, options, logger) => {
   }
   if (write) {
     if (result.error) {
-      await fs__default["default"].mkdir(path__default["default"].dirname(filePath), { recursive: true });
+      await fs.mkdir(path.dirname(filePath), { recursive: true });
     }
-    await fs__default["default"].writeFile(filePath, write);
+    await fs.writeFile(filePath, write);
     logger == null ? void 0 : logger.log(
       `${result.content ? "Updated" : "Created"} ${orchidCore.pathToLog(filePath)}`
     );
@@ -1828,9 +1818,9 @@ const createTable = async (_a) => {
     props,
     "}\n"
   ];
-  await fs__default["default"].mkdir(path__default["default"].dirname(tablePath), { recursive: true });
+  await fs.mkdir(path.dirname(tablePath), { recursive: true });
   try {
-    await fs__default["default"].writeFile(tablePath, orchidCore.codeToString(code, "", "  "), { flag: "wx" });
+    await fs.writeFile(tablePath, orchidCore.codeToString(code, "", "  "), { flag: "wx" });
     logger == null ? void 0 : logger.log(`Created ${orchidCore.pathToLog(tablePath)}`);
   } catch (err) {
     if (err.code !== "EEXIST") {
@@ -1876,7 +1866,7 @@ const changeTable = async (_a) => {
     "logger"
   ]);
   const tablePath = params.tablePath(orchidCore.toCamelCase(ast.name));
-  const content = await fs__default["default"].readFile(tablePath, "utf-8").catch(() => void 0);
+  const content = await fs.readFile(tablePath, "utf-8").catch(() => void 0);
   if (!content)
     return;
   const changes = new FileChanges(content);
@@ -1890,7 +1880,7 @@ const changeTable = async (_a) => {
     addColumns(context);
     addTableData(context);
   }
-  await fs__default["default"].writeFile(tablePath, changes.apply());
+  await fs.writeFile(tablePath, changes.apply());
   logger == null ? void 0 : logger.log(`Updated ${orchidCore.pathToLog(tablePath)}`);
 };
 function* iterateColumnsShapes(statements, className) {
@@ -2151,7 +2141,9 @@ const getColumnMethodArgs = (t, to, key, dataType) => {
   if (!value)
     return;
   if (key === "indexes") {
-    return pqb.columnIndexesToCode(value);
+    return pqb.columnIndexesToCode(
+      value
+    );
   }
   if (key === "foreignKeys") {
     return pqb.columnForeignKeysToCode(value);
@@ -2359,7 +2351,7 @@ const renameTable = async (_a) => {
   ]);
   var _a2;
   const tablePath = params.tablePath(orchidCore.toCamelCase(ast.from));
-  const content = await fs__default["default"].readFile(tablePath, "utf-8").catch(() => void 0);
+  const content = await fs.readFile(tablePath, "utf-8").catch(() => void 0);
   if (!content)
     return;
   const changes = new FileChanges(content);
@@ -2399,7 +2391,7 @@ const renameTable = async (_a) => {
       }
     }
   }
-  await fs__default["default"].writeFile(tablePath, changes.apply());
+  await fs.writeFile(tablePath, changes.apply());
   logger == null ? void 0 : logger.log(`Updated ${orchidCore.pathToLog(tablePath)}`);
 };
 
@@ -2438,8 +2430,8 @@ const createBaseTableFile = async ({
   baseTablePath,
   logger
 }) => {
-  await fs__default["default"].mkdir(path__default["default"].dirname(baseTablePath), { recursive: true });
-  await fs__default["default"].writeFile(
+  await fs.mkdir(path.dirname(baseTablePath), { recursive: true });
+  await fs.writeFile(
     baseTablePath,
     `import { createBaseTable } from 'orchid-orm';