orchid-orm 1.6.39 → 1.7.0

package/dist/index.mjs

@@ -1,6 +1,7 @@
-import { columnTypes, getColumnTypes, addQueryOn, VirtualColumn, pushQueryValue, isQueryReturnsAll, getQueryAs, toSqlCacheKey, NotFoundError, relationQueryKey, Db, Adapter, anyShape, getClonedQueryData, columnsShapeToCode, primaryKeyToCode, indexToCode, constraintToCode, columnIndexesToCode, columnForeignKeysToCode, columnCheckToCode, identityToCode } from 'pqb';
+import { columnTypes, getColumnTypes, addQueryOn, VirtualColumn, pushQueryValue, isQueryReturnsAll, getQueryAs, toSqlCacheKey, NotFoundError, relationQueryKey, Adapter, Db, anyShape, getClonedQueryData, columnsShapeToCode, primaryKeyToCode, indexToCode, constraintToCode, columnIndexesToCode, columnForeignKeysToCode, columnCheckToCode, identityToCode } from 'pqb';
 export { OrchidOrmError, OrchidOrmInternalError, columnTypes } from 'pqb';
 import { snakeCaseKey, toSnakeCase, emptyObject, pathToLog, toCamelCase, toPascalCase, singleQuote, codeToString, quoteObjectKey, addCode, columnDefaultArgumentToCode, deepCompare } from 'orchid-core';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import * as path from 'path';
 import path__default from 'path';
 import fs from 'fs/promises';
@@ -142,11 +143,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(
@@ -210,12 +211,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;
@@ -237,10 +238,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];
             })
           );
@@ -248,12 +249,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) {
@@ -445,11 +446,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(
@@ -485,7 +486,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 }
@@ -654,11 +655,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(
@@ -721,7 +722,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), {
@@ -871,6 +872,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,
@@ -893,10 +896,11 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
       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]
@@ -913,8 +917,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]) }
   };
@@ -927,8 +931,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(
@@ -948,11 +954,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(
@@ -1037,7 +1043,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) => ({
@@ -1049,10 +1055,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],
@@ -1062,38 +1068,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[toSqlCacheKey];
       const ids = await queryRelatedTable(
         state.relatedTableQuery,
-        q,
         params.set
       )._pluck(state.associationPrimaryKey);
       await insertToJoinTable(state, j, data, ids);
@@ -1268,25 +1276,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 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;
@@ -1339,12 +1333,14 @@ const orchidORM = (_a, tables) => {
     autoPreparedStatements,
     noPrimaryKey
   };
+  const transactionStorage = new AsyncLocalStorage();
   const qb = new Db(
     adapter,
     void 0,
     void 0,
     anyShape,
     columnTypes,
+    transactionStorage,
     commonOptions
   );
   qb.queryBuilder = qb;
@@ -1369,10 +1365,12 @@ const orchidORM = (_a, tables) => {
       options2.noPrimaryKey = "ignore";
     const dbTable = new Db(
       adapter,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       qb,
       table.table,
       table.columns.shape,
       table.columnTypes,
+      transactionStorage,
       options2
     );
     dbTable.definedAs = key;
@@ -2124,7 +2122,9 @@ const getColumnMethodArgs = (t, to, key, dataType) => {
   if (!value)
     return;
   if (key === "indexes") {
-    return columnIndexesToCode(value);
+    return columnIndexesToCode(
+      value
+    );
   }
   if (key === "foreignKeys") {
     return columnForeignKeysToCode(value);