orchid-orm 1.14.4 → 1.15.1

package/dist/index.mjs

@@ -1,6 +1,6 @@
-import { columnTypes, QueryHooks, getColumnTypes, addQueryOn, VirtualColumn, pushQueryValue, isQueryReturnsAll, getQueryAs, toSQLCacheKey, OrchidOrmInternalError, NotFoundError, Adapter, Db, anyShape, getClonedQueryData } from 'pqb';
+import { columnTypes, QueryHooks, getColumnTypes, getQueryAs, setQueryObjectValue, pushQueryOn, VirtualColumn, pushQueryValue, isQueryReturnsAll, toSQLCacheKey, OrchidOrmInternalError, NotFoundError, Adapter, Db, anyShape, getClonedQueryData } from 'pqb';
 export { OrchidOrmError, OrchidOrmInternalError, columnTypes, raw, testTransaction } from 'pqb';
-import { getStackTrace, applyMixins, getCallerFilePath, snakeCaseKey, toSnakeCase } from 'orchid-core';
+import { getStackTrace, applyMixins, getCallerFilePath, snakeCaseKey, toSnakeCase, emptyArray, toArray } from 'orchid-core';
 import { AsyncLocalStorage } from 'node:async_hooks';
 
 const createBaseTable = ({
@@ -81,7 +81,6 @@ const create = (columnTypes, filePathOrStack, snakeCase, nowSQL, exportAs = "Bas
     belongsTo(fn, options) {
       return {
         type: "belongsTo",
-        returns: "one",
         fn,
         options
       };
@@ -89,7 +88,6 @@ const create = (columnTypes, filePathOrStack, snakeCase, nowSQL, exportAs = "Bas
     hasOne(fn, options) {
       return {
         type: "hasOne",
-        returns: "one",
         fn,
         options
       };
@@ -97,7 +95,6 @@ const create = (columnTypes, filePathOrStack, snakeCase, nowSQL, exportAs = "Bas
     hasMany(fn, options) {
       return {
         type: "hasMany",
-        returns: "many",
         fn,
         options
       };
@@ -105,7 +102,6 @@ const create = (columnTypes, filePathOrStack, snakeCase, nowSQL, exportAs = "Bas
     hasAndBelongsToMany(fn, options) {
       return {
         type: "hasAndBelongsToMany",
-        returns: "many",
         fn,
         options
       };
@@ -116,6 +112,98 @@ const create = (columnTypes, filePathOrStack, snakeCase, nowSQL, exportAs = "Bas
   return base;
 };
 
+const getThroughRelation = (table, through) => {
+  var _a;
+  return (_a = table.relations[through]) == null ? void 0 : _a.relationConfig;
+};
+const getSourceRelation = (throughRelation, source) => {
+  var _a;
+  return (_a = throughRelation.table.relations[source]) == null ? void 0 : _a.relationConfig;
+};
+const hasRelationHandleCreate = (q, ctx, item, rowIndex, key, primaryKeys, nestedInsert) => {
+  const value = item[key];
+  if ((!value.create || Array.isArray(value.create) && value.create.length === 0) && (!value.connect || Array.isArray(value.connect) && value.connect.length === 0) && (!value.connectOrCreate || Array.isArray(value.connectOrCreate) && value.connectOrCreate.length === 0))
+    return;
+  const store = ctx;
+  if (!store.hasRelation)
+    store.hasRelation = {};
+  const values = [rowIndex, value];
+  if (store.hasRelation[key]) {
+    store.hasRelation[key].push(values);
+    return;
+  }
+  q.q.wrapInTransaction = true;
+  const relationData = [values];
+  store.hasRelation[key] = relationData;
+  q._afterCreate(
+    primaryKeys,
+    (rows, q2) => nestedInsert(
+      q2,
+      relationData.map(([rowIndex2, data]) => [
+        rows[rowIndex2],
+        data
+      ])
+    )
+  );
+};
+const hasRelationHandleUpdate = (q, set, key, primaryKeys, nestedUpdate) => {
+  const value = set[key];
+  if (!value.set && !("upsert" in value) && (!value.disconnect || Array.isArray(value.disconnect) && value.disconnect.length === 0) && (!value.delete || Array.isArray(value.delete) && value.delete.length === 0) && (!value.update || Array.isArray(value.update.where) && value.update.where.length === 0) && (!value.create || Array.isArray(value.create) && value.create.length === 0))
+    return;
+  selectIfNotSelected(q, primaryKeys);
+  q.q.wrapInTransaction = true;
+  q._afterUpdate(q.primaryKeys, (rows, q2) => {
+    return nestedUpdate(
+      q2,
+      rows,
+      value
+    );
+  });
+};
+const selectIfNotSelected = (q, columns) => {
+  const select = q.q.select || [];
+  if (!select.includes("*")) {
+    for (const column of columns) {
+      if (!select.includes(column)) {
+        select.push(column);
+      }
+    }
+    q.q.select = select;
+  }
+};
+const relationWhere = (len, keys, valueKeys) => (params) => {
+  const obj = {};
+  for (let i = 0; i < len; i++) {
+    obj[keys[i]] = params[valueKeys[i]];
+  }
+  return obj;
+};
+function joinHasThrough(q, fromQuery, toQuery, throughRelation, sourceRelation) {
+  return q.whereExists(
+    throughRelation.joinQuery(fromQuery, throughRelation.query),
+    () => {
+      const as = getQueryAs(toQuery);
+      return sourceRelation.joinQuery(
+        throughRelation.query,
+        sourceRelation.query.as(as)
+      );
+    }
+  );
+}
+function joinHasRelation(fromQuery, toQuery, primaryKeys, foreignKeys, len) {
+  const q = toQuery.clone();
+  setQueryObjectValue(
+    q,
+    "joinedShapes",
+    fromQuery.q.as || fromQuery.table,
+    fromQuery.q.shape
+  );
+  for (let i = 0; i < len; i++) {
+    pushQueryOn(q, fromQuery, toQuery, foreignKeys[i], primaryKeys[i]);
+  }
+  return q;
+}
+
 class BelongsToVirtualColumn extends VirtualColumn {
   constructor(key, state) {
     super();
@@ -127,16 +215,19 @@ class BelongsToVirtualColumn extends VirtualColumn {
   create(q, ctx, item, rowIndex) {
     const {
       key,
-      state: { foreignKey, primaryKey }
+      state: { primaryKeys, foreignKeys }
     } = this;
-    let columnIndex = ctx.columns.get(foreignKey);
-    if (columnIndex === void 0) {
-      ctx.columns.set(foreignKey, columnIndex = ctx.columns.size);
-    }
+    const columnIndexes = foreignKeys.map((key2) => {
+      let index = ctx.columns.get(key2);
+      if (index === void 0) {
+        ctx.columns.set(key2, index = ctx.columns.size);
+      }
+      return index;
+    });
     const store = ctx;
     if (!store.belongsTo)
       store.belongsTo = {};
-    const values = [rowIndex, columnIndex, item[key]];
+    const values = [rowIndex, columnIndexes, item[key]];
     if (store.belongsTo[key]) {
       store.belongsTo[key].push(values);
       return;
@@ -150,9 +241,13 @@ class BelongsToVirtualColumn extends VirtualColumn {
         relationData.map(([, , data]) => data)
       );
       const { values: values2 } = q2.q;
-      relationData.forEach(([rowIndex2, columnIndex2], index) => {
-        values2[rowIndex2][columnIndex2] = inserted[index][primaryKey];
-      });
+      for (let i = 0, len = relationData.length; i < len; i++) {
+        const [rowIndex2, columnIndexes2] = relationData[i];
+        const row = values2[rowIndex2];
+        for (let c = 0, len2 = columnIndexes2.length; c < len2; c++) {
+          row[columnIndexes2[c]] = inserted[i][primaryKeys[c]];
+        }
+      }
     });
   }
   update(q, ctx, set) {
@@ -164,68 +259,91 @@ class BelongsToVirtualColumn extends VirtualColumn {
   }
 }
 const makeBelongsToMethod = (relation, relationName, query) => {
-  const { primaryKey, foreignKey } = relation.options;
-  const state = { query, primaryKey, foreignKey };
+  const primaryKeys = "columns" in relation.options ? relation.options.references : [relation.options.primaryKey];
+  const foreignKeys = "columns" in relation.options ? relation.options.columns : [relation.options.foreignKey];
+  const len = primaryKeys.length;
+  const state = { query, primaryKeys, foreignKeys, len };
+  const makeWhere = relationWhere(len, primaryKeys, foreignKeys);
+  const join = (fromQuery, toQuery, primaryKeys2, foreignKeys2) => {
+    const q = toQuery.clone();
+    setQueryObjectValue(
+      q,
+      "joinedShapes",
+      fromQuery.q.as || fromQuery.table,
+      fromQuery.q.shape
+    );
+    for (let i = 0; i < len; i++) {
+      pushQueryOn(q, fromQuery, toQuery, primaryKeys2[i], foreignKeys2[i]);
+    }
+    return q;
+  };
   return {
     returns: "one",
-    method: (params) => {
-      return query.where({ [primaryKey]: params[foreignKey] });
+    method(params) {
+      return query.where(makeWhere(params));
     },
     virtualColumn: new BelongsToVirtualColumn(relationName, state),
     joinQuery(fromQuery, toQuery) {
-      return addQueryOn(toQuery, fromQuery, toQuery, primaryKey, foreignKey);
+      return join(fromQuery, toQuery, primaryKeys, foreignKeys);
     },
     reverseJoin(fromQuery, toQuery) {
-      return addQueryOn(fromQuery, toQuery, fromQuery, foreignKey, primaryKey);
+      return join(toQuery, fromQuery, foreignKeys, primaryKeys);
     }
   };
 };
-const nestedInsert$3 = ({ query, primaryKey }) => {
+const nestedInsert$3 = ({ query, primaryKeys }) => {
   return async (_, data) => {
-    const connectOrCreate = data.filter(
-      (item) => Boolean(item.connectOrCreate)
-    );
     const t = query.clone();
+    const items = [];
+    for (const item of data) {
+      if (item.connectOrCreate) {
+        items.push(item);
+      }
+    }
     let connectOrCreated;
-    if (connectOrCreate.length) {
-      connectOrCreated = await Promise.all(
-        connectOrCreate.map(
-          (item) => t.findBy(item.connectOrCreate.where)._takeOptional()
-        )
-      );
+    if (items.length) {
+      for (let i = 0, len = items.length; i < len; i++) {
+        items[i] = t.findByOptional(
+          items[i].connectOrCreate.where
+        );
+      }
+      connectOrCreated = await Promise.all(items);
     } else {
-      connectOrCreated = [];
+      connectOrCreated = emptyArray;
     }
     let connectOrCreatedI = 0;
-    const create = data.filter(
-      (item) => {
-        if (item.connectOrCreate) {
-          return !connectOrCreated[connectOrCreatedI++];
-        } else {
-          return Boolean(item.create);
-        }
+    items.length = 0;
+    for (const item of data) {
+      if (item.connectOrCreate) {
+        if (!connectOrCreated[connectOrCreatedI++])
+          items.push(item);
+      } else if (item.create) {
+        items.push(item);
       }
-    );
+    }
     let created;
-    if (create.length) {
-      created = await t.select(primaryKey)._createMany(
-        create.map(
-          (item) => "create" in item ? item.create : item.connectOrCreate.create
-        )
-      );
+    if (items.length) {
+      for (let i = 0, len = items.length; i < len; i++) {
+        items[i] = "create" in items[i] ? items[i].create : items[i].connectOrCreate.create;
+      }
+      created = await t.select(...primaryKeys)._createMany(items);
     } else {
-      created = [];
+      created = emptyArray;
+    }
+    items.length = 0;
+    for (const item of data) {
+      if (item.connect) {
+        items.push(item);
+      }
     }
-    const connect = data.filter(
-      (item) => Boolean(item.connect)
-    );
     let connected;
-    if (connect.length) {
-      connected = await Promise.all(
-        connect.map((item) => t.findBy(item.connect)._take())
-      );
+    if (items.length) {
+      for (let i = 0, len = items.length; i < len; i++) {
+        items[i] = t.findBy(items[i].connect);
+      }
+      connected = await Promise.all(items);
     } else {
-      connected = [];
+      connected = emptyArray;
     }
     let createdI = 0;
     let connectedI = 0;
@@ -235,125 +353,122 @@ const nestedInsert$3 = ({ query, primaryKey }) => {
     });
   };
 };
-const nestedUpdate$3 = ({ query, primaryKey, foreignKey }) => {
+const nestedUpdate$3 = ({ query, primaryKeys, foreignKeys, len }) => {
   return (q, update, params, state) => {
-    var _a, _b, _c;
+    var _a;
     if (params.upsert && isQueryReturnsAll(q)) {
       throw new Error("`upsert` option is not allowed in a batch update");
     }
     let idsForDelete;
     q._beforeUpdate(async (q2) => {
       if (params.disconnect) {
-        update[foreignKey] = null;
+        for (const key of foreignKeys) {
+          update[key] = null;
+        }
       } else if (params.set) {
-        if (primaryKey in params.set) {
-          update[foreignKey] = params.set[primaryKey];
-        } else {
-          update[foreignKey] = await query.findBy(params.set)._get(primaryKey);
+        let loadPrimaryKeys;
+        let loadForeignKeys;
+        for (let i = 0; i < len; i++) {
+          const primaryKey = primaryKeys[i];
+          if (primaryKey in params.set) {
+            update[foreignKeys[i]] = params.set[primaryKey];
+          } else {
+            (loadPrimaryKeys != null ? loadPrimaryKeys : loadPrimaryKeys = []).push(primaryKey);
+            (loadForeignKeys != null ? loadForeignKeys : loadForeignKeys = []).push(foreignKeys[i]);
+          }
+        }
+        if (loadPrimaryKeys) {
+          const record = await query.select(...loadPrimaryKeys)._findBy(params.set);
+          for (let i = 0, len2 = loadPrimaryKeys.length; i < len2; i++) {
+            update[loadForeignKeys[i]] = record[loadPrimaryKeys[i]];
+          }
         }
       } else if (params.create) {
-        update[foreignKey] = await query.get(primaryKey)._create(params.create);
+        const q3 = query.clone();
+        q3.q.select = primaryKeys;
+        const record = await q3._create(params.create);
+        for (let i = 0; i < len; i++) {
+          update[foreignKeys[i]] = record[primaryKeys[i]];
+        }
       } else if (params.delete) {
         const selectQuery = q2.clone();
         selectQuery.q.type = void 0;
-        idsForDelete = await selectQuery._pluck(foreignKey);
-        update[foreignKey] = null;
+        selectQuery.q.distinct = emptyArray;
+        idsForDelete = await selectQuery._rows();
+        for (const foreignKey of foreignKeys) {
+          update[foreignKey] = null;
+        }
       }
     });
     const { upsert } = params;
     if (upsert || params.update || params.delete) {
-      if (!((_a = q.q.select) == null ? void 0 : _a.includes("*")) && !((_b = q.q.select) == null ? void 0 : _b.includes(foreignKey))) {
-        q._select(foreignKey);
-      }
+      selectIfNotSelected(q, foreignKeys);
     }
     if (upsert) {
-      ((_c = state.queries) != null ? _c : state.queries = []).push(async (queryResult) => {
+      ((_a = state.queries) != null ? _a : state.queries = []).push(async (queryResult) => {
         var _a2;
-        const id = queryResult.rows[0][foreignKey];
-        if (id !== null) {
-          await query.findBy({ [primaryKey]: id })._update(upsert.update);
+        const row = queryResult.rows[0];
+        let obj = {};
+        for (let i = 0; i < len; i++) {
+          const id = row[foreignKeys[i]];
+          if (id === null) {
+            obj = void 0;
+            break;
+          }
+          obj[primaryKeys[i]] = id;
+        }
+        if (obj) {
+          await query.findBy(obj)._update(upsert.update);
         } else {
           const data = typeof upsert.create === "function" ? upsert.create() : upsert.create;
-          const result = await query.select(primaryKey)._create(data);
-          ((_a2 = state.updateData) != null ? _a2 : state.updateData = {})[foreignKey] = result[primaryKey];
+          const result = await query.select(...primaryKeys)._create(data);
+          for (let i = 0; i < len; i++) {
+            ((_a2 = state.updateData) != null ? _a2 : state.updateData = {})[foreignKeys[i]] = result[primaryKeys[i]];
+          }
         }
       });
     } else if (params.delete || params.update) {
       q._afterUpdate([], async (data) => {
-        const id = params.delete ? { in: idsForDelete } : 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.where({
-            [primaryKey]: id
-          });
-          if (params.delete) {
-            await t._delete();
-          } else if (params.update) {
-            await t._update(params.update);
+        let ids;
+        if (params.delete) {
+          ids = idsForDelete;
+        } else {
+          ids = [];
+          for (const item of data) {
+            let row;
+            for (const foreignKey of foreignKeys) {
+              const id = item[foreignKey];
+              if (id === null) {
+                row = void 0;
+                break;
+              } else {
+                (row != null ? row : row = []).push(id);
+              }
+            }
+            if (row)
+              ids.push(row);
           }
         }
+        if (!(ids == null ? void 0 : ids.length))
+          return;
+        const t = query.whereIn(
+          primaryKeys,
+          ids
+        );
+        if (params.delete) {
+          await t._delete();
+        } else {
+          await t._update(
+            params.update
+          );
+        }
       });
     }
     return !params.update && !params.upsert;
   };
 };
 
-const getThroughRelation = (table, through) => {
-  var _a;
-  return (_a = table.relations[through]) == null ? void 0 : _a.relationConfig;
-};
-const getSourceRelation = (throughRelation, source) => {
-  var _a;
-  return (_a = throughRelation.table.relations[source]) == null ? void 0 : _a.relationConfig;
-};
-const hasRelationHandleCreate = (q, ctx, item, rowIndex, key, primaryKey, nestedInsert) => {
-  const value = item[key];
-  if ((!value.create || Array.isArray(value.create) && value.create.length === 0) && (!value.connect || Array.isArray(value.connect) && value.connect.length === 0) && (!value.connectOrCreate || Array.isArray(value.connectOrCreate) && value.connectOrCreate.length === 0))
-    return;
-  const store = ctx;
-  if (!store.hasRelation)
-    store.hasRelation = {};
-  const values = [rowIndex, value];
-  if (store.hasRelation[key]) {
-    store.hasRelation[key].push(values);
-    return;
-  }
-  q.q.wrapInTransaction = true;
-  const relationData = [values];
-  store.hasRelation[key] = relationData;
-  q._afterCreate(
-    [primaryKey],
-    (rows, q2) => nestedInsert(
-      q2,
-      relationData.map(([rowIndex2, data]) => [
-        rows[rowIndex2],
-        data
-      ])
-    )
-  );
-};
-const hasRelationHandleUpdate = (q, set, key, primaryKey, nestedUpdate) => {
-  var _a, _b;
-  const value = set[key];
-  if (!value.set && !("upsert" in value) && (!value.disconnect || Array.isArray(value.disconnect) && value.disconnect.length === 0) && (!value.delete || Array.isArray(value.delete) && value.delete.length === 0) && (!value.update || Array.isArray(value.update.where) && value.update.where.length === 0) && (!value.create || Array.isArray(value.create) && value.create.length === 0))
-    return;
-  if (!((_a = q.q.select) == null ? void 0 : _a.includes("*")) && !((_b = q.q.select) == null ? void 0 : _b.includes(primaryKey))) {
-    q._select(primaryKey);
-  }
-  q.q.wrapInTransaction = true;
-  q._afterUpdate(q.primaryKeys, (rows, q2) => {
-    return nestedUpdate(
-      q2,
-      rows,
-      value
-    );
-  });
-};
-
 var __defProp$5 = Object.defineProperty;
-var __defProps$3 = Object.defineProperties;
-var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;
 var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
 var __propIsEnum$5 = Object.prototype.propertyIsEnumerable;
@@ -369,7 +484,6 @@ var __spreadValues$5 = (a, b) => {
     }
   return a;
 };
-var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
 class HasOneVirtualColumn extends VirtualColumn {
   constructor(key, state) {
     super();
@@ -385,7 +499,7 @@ class HasOneVirtualColumn extends VirtualColumn {
       item,
       rowIndex,
       this.key,
-      this.state.primaryKey,
+      this.state.primaryKeys,
       this.nestedInsert
     );
   }
@@ -399,7 +513,7 @@ class HasOneVirtualColumn extends VirtualColumn {
       q,
       set,
       this.key,
-      this.state.primaryKey,
+      this.state.primaryKeys,
       this.nestedUpdate
     );
   }
@@ -421,46 +535,49 @@ const makeHasOneMethod = (table, relation, relationName, query) => {
         );
       },
       joinQuery(fromQuery, toQuery) {
-        return toQuery.whereExists(
-          throughRelation.joinQuery(fromQuery, throughRelation.query),
-          () => {
-            const as = getQueryAs(toQuery);
-            return sourceRelation.joinQuery(
-              throughRelation.query,
-              sourceRelation.query.as(as)
-            );
-          }
+        return joinHasThrough(
+          toQuery,
+          fromQuery,
+          toQuery,
+          throughRelation,
+          sourceRelation
         );
       },
       reverseJoin(fromQuery, toQuery) {
-        return fromQuery.whereExists(
-          throughRelation.joinQuery(fromQuery, throughRelation.query),
-          () => {
-            const as = getQueryAs(toQuery);
-            return sourceRelation.joinQuery(
-              throughRelation.query,
-              sourceRelation.query.as(as)
-            );
-          }
+        return joinHasThrough(
+          fromQuery,
+          fromQuery,
+          toQuery,
+          throughRelation,
+          sourceRelation
         );
       }
     };
   }
-  const { primaryKey, foreignKey } = relation.options;
-  const state = { query, primaryKey, foreignKey };
-  const fromQuerySelect = [{ selectAs: { [foreignKey]: primaryKey } }];
+  const primaryKeys = "columns" in relation.options ? relation.options.columns : [relation.options.primaryKey];
+  const foreignKeys = "columns" in relation.options ? relation.options.references : [relation.options.foreignKey];
+  const state = { query, primaryKeys, foreignKeys };
+  const len = primaryKeys.length;
+  const reversedOn = {};
+  for (let i = 0; i < len; i++) {
+    reversedOn[foreignKeys[i]] = primaryKeys[i];
+  }
+  const fromQuerySelect = [{ selectAs: reversedOn }];
   return {
     returns: "one",
     method: (params) => {
-      const values = { [foreignKey]: params[primaryKey] };
+      const values = {};
+      for (let i = 0; i < len; i++) {
+        values[foreignKeys[i]] = params[primaryKeys[i]];
+      }
       return query.where(values)._defaults(values);
     },
     virtualColumn: new HasOneVirtualColumn(relationName, state),
     joinQuery(fromQuery, toQuery) {
-      return addQueryOn(toQuery, fromQuery, toQuery, foreignKey, primaryKey);
+      return joinHasRelation(fromQuery, toQuery, primaryKeys, foreignKeys, len);
     },
     reverseJoin(fromQuery, toQuery) {
-      return addQueryOn(fromQuery, toQuery, fromQuery, primaryKey, foreignKey);
+      return joinHasRelation(toQuery, fromQuery, foreignKeys, primaryKeys, len);
     },
     modifyRelatedQuery(relationQuery) {
       return (query2) => {
@@ -473,57 +590,88 @@ const makeHasOneMethod = (table, relation, relationName, query) => {
     }
   };
 };
-const nestedInsert$2 = ({ query, primaryKey, foreignKey }) => {
+const nestedInsert$2 = ({ query, primaryKeys, foreignKeys }) => {
   return async (_, data) => {
-    const connect = data.filter(
-      (item) => Boolean(item[1].connect || item[1].connectOrCreate)
-    );
     const t = query.clone();
+    const items = [];
+    for (const item of data) {
+      if (item[1].connect || item[1].connectOrCreate) {
+        items.push(item);
+      }
+    }
     let connected;
-    if (connect.length) {
-      connected = await Promise.all(
-        connect.map(([selfData, item]) => {
-          const data2 = { [foreignKey]: selfData[primaryKey] };
-          return "connect" in item ? t.where(item.connect)._updateOrThrow(data2) : t.where(item.connectOrCreate.where)._update(data2);
-        })
-      );
+    if (items.length) {
+      for (let i = 0, len = items.length; i < len; i++) {
+        const [selfData, item] = items[i];
+        const data2 = {};
+        for (let i2 = 0; i2 < len; i2++) {
+          data2[foreignKeys[i2]] = selfData[primaryKeys[i2]];
+        }
+        items[i] = "connect" in item ? t.where(item.connect)._updateOrThrow(data2) : t.where(
+          item.connectOrCreate.where
+        )._update(data2);
+      }
+      connected = await Promise.all(items);
     } else {
       connected = [];
     }
     let connectedI = 0;
-    const create = data.filter(
-      (item) => {
-        if (item[1].connectOrCreate) {
-          return !connected[connectedI++];
+    items.length = 0;
+    for (const item of data) {
+      if (item[1].connectOrCreate) {
+        if (!connected[connectedI++]) {
+          items.push(item);
         }
-        return Boolean(item[1].create);
+      } else if (item[1].create) {
+        items.push(item);
       }
-    );
-    if (create.length) {
-      await t._count()._createMany(
-        create.map(([selfData, item]) => __spreadValues$5({
-          [foreignKey]: selfData[primaryKey]
-        }, "create" in item ? item.create : item.connectOrCreate.create))
-      );
+    }
+    if (items.length) {
+      for (let i = 0, len = items.length; i < len; i++) {
+        const [selfData, item] = items[i];
+        const data2 = __spreadValues$5({}, "create" in item ? item.create : item.connectOrCreate.create);
+        for (let i2 = 0; i2 < primaryKeys.length; i2++) {
+          data2[foreignKeys[i2]] = selfData[primaryKeys[i2]];
+        }
+        items[i] = data2;
+      }
+      await t._count()._createMany(items);
     }
   };
 };
-const nestedUpdate$2 = ({ query, primaryKey, foreignKey }) => {
+const nestedUpdate$2 = ({ query, primaryKeys, foreignKeys }) => {
+  const len = primaryKeys.length;
+  const setNulls = {};
+  for (const foreignKey of foreignKeys) {
+    setNulls[foreignKey] = null;
+  }
   return async (_, data, params) => {
     const t = query.clone();
-    const ids = data.map((item) => item[primaryKey]);
-    const currentRelationsQuery = t.where({
-      [foreignKey]: { in: ids }
-    });
+    const ids = data.map(
+      (item) => primaryKeys.map((primaryKey) => item[primaryKey])
+    );
+    const currentRelationsQuery = t.whereIn(
+      foreignKeys,
+      ids
+    );
     if (params.create || params.disconnect || params.set) {
-      await currentRelationsQuery._update({ [foreignKey]: null });
+      await currentRelationsQuery._update(
+        setNulls
+      );
+      const record = data[0];
       if (params.create) {
-        await t._count()._create(__spreadProps$3(__spreadValues$5({}, params.create), {
-          [foreignKey]: data[0][primaryKey]
-        }));
+        const obj = __spreadValues$5({}, params.create);
+        for (let i = 0; i < len; i++) {
+          obj[foreignKeys[i]] = record[primaryKeys[i]];
+        }
+        await t._count()._create(obj);
       }
       if (params.set) {
-        await t._where(params.set)._update({ [foreignKey]: data[0][primaryKey] });
+        const obj = {};
+        for (let i = 0; i < len; i++) {
+          obj[foreignKeys[i]] = record[primaryKeys[i]];
+        }
+        await t._where(params.set)._update(obj);
       }
     } else if (params.update) {
       await currentRelationsQuery._update(params.update);
@@ -531,13 +679,23 @@ const nestedUpdate$2 = ({ query, primaryKey, foreignKey }) => {
       await currentRelationsQuery._delete();
     } else if (params.upsert) {
       const { update, create } = params.upsert;
-      const updatedIds = await currentRelationsQuery._pluck(foreignKey)._update(update);
+      currentRelationsQuery.q.select = foreignKeys;
+      const updatedIds = await currentRelationsQuery._rows()._update(update);
       if (updatedIds.length < ids.length) {
         const data2 = typeof create === "function" ? create() : create;
         await t.createMany(
-          ids.filter((id) => !updatedIds.includes(id)).map((id) => __spreadProps$3(__spreadValues$5({}, data2), {
-            [foreignKey]: id
-          }))
+          ids.reduce((rows, ids2) => {
+            if (!updatedIds.some(
+              (updated) => updated.every((value, i) => value === ids2[i])
+            )) {
+              const obj = __spreadValues$5({}, data2);
+              for (let i = 0; i < len; i++) {
+                obj[foreignKeys[i]] = ids2[i];
+              }
+              rows.push(obj);
+            }
+            return rows;
+          }, [])
         );
       }
     }
@@ -545,8 +703,6 @@ const nestedUpdate$2 = ({ query, primaryKey, foreignKey }) => {
 };
 
 var __defProp$4 = Object.defineProperty;
-var __defProps$2 = Object.defineProperties;
-var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
 var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
 var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
@@ -562,7 +718,6 @@ var __spreadValues$4 = (a, b) => {
     }
   return a;
 };
-var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
 class HasManyVirtualColumn extends VirtualColumn {
   constructor(key, state) {
     super();
@@ -578,7 +733,7 @@ class HasManyVirtualColumn extends VirtualColumn {
       item,
       rowIndex,
       this.key,
-      this.state.primaryKey,
+      this.state.primaryKeys,
       this.nestedInsert
     );
   }
@@ -592,7 +747,7 @@ class HasManyVirtualColumn extends VirtualColumn {
       q,
       set,
       this.key,
-      this.state.primaryKey,
+      this.state.primaryKeys,
       this.nestedUpdate
     );
   }
@@ -618,46 +773,49 @@ const makeHasManyMethod = (table, relation, relationName, query) => {
         );
       },
       joinQuery(fromQuery, toQuery) {
-        return toQuery.whereExists(
-          throughRelation.joinQuery(fromQuery, throughRelation.query),
-          () => {
-            const as = getQueryAs(toQuery);
-            return sourceRelation.joinQuery(
-              throughRelation.query,
-              sourceRelation.query.as(as)
-            );
-          }
+        return joinHasThrough(
+          toQuery,
+          fromQuery,
+          toQuery,
+          throughRelation,
+          sourceRelation
         );
       },
       reverseJoin(fromQuery, toQuery) {
-        return fromQuery.whereExists(
-          throughRelation.joinQuery(fromQuery, throughRelation.query),
-          () => {
-            const as = getQueryAs(toQuery);
-            return sourceRelation.joinQuery(
-              throughRelation.query,
-              sourceRelation.query.as(as)
-            );
-          }
+        return joinHasThrough(
+          fromQuery,
+          fromQuery,
+          toQuery,
+          throughRelation,
+          sourceRelation
         );
       }
     };
   }
-  const { primaryKey, foreignKey } = relation.options;
-  const state = { query, primaryKey, foreignKey };
-  const fromQuerySelect = [{ selectAs: { [foreignKey]: primaryKey } }];
+  const primaryKeys = "columns" in relation.options ? relation.options.columns : [relation.options.primaryKey];
+  const foreignKeys = "columns" in relation.options ? relation.options.references : [relation.options.foreignKey];
+  const state = { query, primaryKeys, foreignKeys };
+  const len = primaryKeys.length;
+  const reversedOn = {};
+  for (let i = 0; i < len; i++) {
+    reversedOn[foreignKeys[i]] = primaryKeys[i];
+  }
+  const fromQuerySelect = [{ selectAs: reversedOn }];
   return {
     returns: "many",
     method: (params) => {
-      const values = { [foreignKey]: params[primaryKey] };
+      const values = {};
+      for (let i = 0; i < len; i++) {
+        values[foreignKeys[i]] = params[primaryKeys[i]];
+      }
       return query.where(values)._defaults(values);
     },
     virtualColumn: new HasManyVirtualColumn(relationName, state),
     joinQuery(fromQuery, toQuery) {
-      return addQueryOn(toQuery, fromQuery, toQuery, foreignKey, primaryKey);
+      return joinHasRelation(fromQuery, toQuery, primaryKeys, foreignKeys, len);
     },
     reverseJoin(fromQuery, toQuery) {
-      return addQueryOn(fromQuery, toQuery, fromQuery, primaryKey, foreignKey);
+      return joinHasRelation(toQuery, fromQuery, foreignKeys, primaryKeys, len);
     },
     modifyRelatedQuery(relationQuery) {
       return (query2) => {
@@ -670,121 +828,150 @@ const makeHasManyMethod = (table, relation, relationName, query) => {
     }
   };
 };
-const getWhereForNestedUpdate = (data, params, primaryKey, foreignKey) => {
-  const where = {
-    [foreignKey]: { in: data.map((item) => item[primaryKey]) }
-  };
-  if (params) {
-    if (Array.isArray(params)) {
-      where.OR = params;
-    } else {
-      Object.assign(where, params);
-    }
-  }
-  return where;
+const getWhereForNestedUpdate = (t, data, params, primaryKeys, foreignKeys) => {
+  return t.where({
+    IN: {
+      columns: foreignKeys,
+      values: data.map((item) => primaryKeys.map((key) => item[key]))
+    },
+    OR: params ? toArray(params) : void 0
+  });
 };
-const nestedInsert$1 = ({ query, primaryKey, foreignKey }) => {
+const nestedInsert$1 = ({ query, primaryKeys, foreignKeys }) => {
+  const len = primaryKeys.length;
   return async (_, data) => {
-    const connect = data.filter(
-      (item) => Boolean(item[1].connect)
-    );
     const t = query.clone();
-    if (connect.length) {
-      await Promise.all(
-        connect.flatMap(
-          ([selfData, { connect: connect2 }]) => t.or(...connect2)._updateOrThrow({
-            [foreignKey]: selfData[primaryKey]
-          })
-        )
-      );
+    const items = [];
+    for (const item of data) {
+      if (item[1].connect) {
+        items.push(item);
+      }
+    }
+    if (items.length) {
+      for (let i = 0, len2 = items.length; i < len2; i++) {
+        const [selfData, { connect }] = items[i];
+        const obj = {};
+        for (let i2 = 0; i2 < len2; i2++) {
+          obj[foreignKeys[i2]] = selfData[primaryKeys[i2]];
+        }
+        items[i] = t.or(...connect)._updateOrThrow(obj);
+      }
+      await Promise.all(items);
+    }
+    items.length = 0;
+    for (const item of data) {
+      if (item[1].connectOrCreate) {
+        items.push(item);
+      }
     }
-    const connectOrCreate = data.filter(
-      (item) => Boolean(item[1].connectOrCreate)
-    );
     let connected;
-    if (connectOrCreate.length) {
-      connected = await Promise.all(
-        connectOrCreate.flatMap(
-          ([selfData, { connectOrCreate: connectOrCreate2 }]) => connectOrCreate2.map(
-            (item) => t.where(item.where)._update({
-              [foreignKey]: selfData[primaryKey]
-            })
-          )
-        )
-      );
+    if (items.length) {
+      const queries = [];
+      for (let i = 0, len2 = items.length; i < len2; i++) {
+        const [selfData, { connectOrCreate }] = items[i];
+        for (const item of connectOrCreate) {
+          const obj = {};
+          for (let i2 = 0; i2 < len2; i2++) {
+            obj[foreignKeys[i2]] = selfData[primaryKeys[i2]];
+          }
+          queries.push(
+            t.where(item.where)._update(obj)
+          );
+        }
+      }
+      connected = await Promise.all(queries);
     } else {
       connected = [];
     }
     let connectedI = 0;
-    const create = data.filter(
-      (item) => {
-        if (item[1].connectOrCreate) {
-          const length = item[1].connectOrCreate.length;
-          connectedI += length;
-          for (let i = length; i > 0; i--) {
-            if (connected[connectedI - i] === 0)
-              return true;
+    items.length = 0;
+    for (const item of data) {
+      if (item[1].connectOrCreate) {
+        const length = item[1].connectOrCreate.length;
+        connectedI += length;
+        for (let i = length; i > 0; i--) {
+          if (connected[connectedI - i] === 0) {
+            items.push(item);
+            break;
           }
         }
-        return Boolean(item[1].create);
+      } else if (item[1].create) {
+        items.push(item);
       }
-    );
+    }
     connectedI = 0;
-    if (create.length) {
-      await t._createMany(
-        create.flatMap(([selfData, { create: create2 = [], connectOrCreate: connectOrCreate2 = [] }]) => {
-          return [
-            ...create2.map((item) => __spreadValues$4({
-              [foreignKey]: selfData[primaryKey]
-            }, item)),
-            ...connectOrCreate2.filter(() => connected[connectedI++] === 0).map((item) => __spreadValues$4({
-              [foreignKey]: selfData[primaryKey]
-            }, item.create))
-          ];
-        })
-      );
+    if (items.length) {
+      const records = [];
+      for (const [selfData, { create, connectOrCreate }] of items) {
+        const obj = {};
+        for (let i = 0; i < len; i++) {
+          obj[foreignKeys[i]] = selfData[primaryKeys[i]];
+        }
+        if (create) {
+          for (const item of create) {
+            records.push(__spreadValues$4(__spreadValues$4({}, item), obj));
+          }
+        }
+        if (connectOrCreate) {
+          for (const item of connectOrCreate) {
+            if (connected[connectedI++] === 0) {
+              records.push(__spreadValues$4(__spreadValues$4({}, item.create), obj));
+            }
+          }
+        }
+      }
+      await t._createMany(records);
     }
   };
 };
-const nestedUpdate$1 = ({ query, primaryKey, foreignKey }) => {
+const nestedUpdate$1 = ({ query, primaryKeys, foreignKeys }) => {
+  const len = primaryKeys.length;
   return async (_, data, params) => {
     var _a;
     const t = query.clone();
     if (params.create) {
+      const obj = {};
+      for (let i = 0; i < len; i++) {
+        obj[foreignKeys[i]] = data[0][primaryKeys[i]];
+      }
       await t._count()._createMany(
-        params.create.map((create) => __spreadProps$2(__spreadValues$4({}, create), {
-          [foreignKey]: data[0][primaryKey]
-        }))
+        params.create.map((create) => __spreadValues$4(__spreadValues$4({}, create), obj))
       );
       delete t.q[toSQLCacheKey];
     }
     if (params.disconnect || params.set) {
-      await t.where(
-        getWhereForNestedUpdate(
-          data,
-          params.disconnect,
-          primaryKey,
-          foreignKey
-        )
-      )._update({ [foreignKey]: null });
+      const obj = {};
+      for (const foreignKey of foreignKeys) {
+        obj[foreignKey] = null;
+      }
+      await getWhereForNestedUpdate(
+        t,
+        data,
+        params.disconnect,
+        primaryKeys,
+        foreignKeys
+      )._update(obj);
       if (params.set) {
         delete t.q[toSQLCacheKey];
+        const obj2 = {};
+        for (let i = 0; i < len; i++) {
+          obj2[foreignKeys[i]] = data[0][primaryKeys[i]];
+        }
         await t.where(
           Array.isArray(params.set) ? {
             OR: params.set
           } : params.set
-        )._update({ [foreignKey]: data[0][primaryKey] });
+        )._update(obj2);
       }
     }
     if (params.delete || params.update) {
       delete t.q[toSQLCacheKey];
-      const q = t._where(
-        getWhereForNestedUpdate(
-          data,
-          params.delete || ((_a = params.update) == null ? void 0 : _a.where),
-          primaryKey,
-          foreignKey
-        )
+      const q = getWhereForNestedUpdate(
+        t,
+        data,
+        params.delete || ((_a = params.update) == null ? void 0 : _a.where),
+        primaryKeys,
+        foreignKeys
       );
       if (params.delete) {
         await q._delete();
@@ -829,7 +1016,7 @@ class HasAndBelongsToManyVirtualColumn extends VirtualColumn {
       item,
       rowIndex,
       this.key,
-      this.state.primaryKey,
+      this.state.primaryKeys,
       this.nestedInsert
     );
   }
@@ -838,7 +1025,7 @@ class HasAndBelongsToManyVirtualColumn extends VirtualColumn {
       q,
       set,
       this.key,
-      this.state.primaryKey,
+      this.state.primaryKeys,
       this.nestedUpdate
     );
   }
@@ -851,23 +1038,48 @@ const removeColumnName = (column) => {
   return cloned;
 };
 const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query) => {
-  const {
-    primaryKey: pk,
-    foreignKey: fk,
-    associationPrimaryKey: apk,
-    associationForeignKey: afk,
-    joinTable
-  } = relation.options;
-  const foreignKeyFull = `${joinTable}.${fk}`;
-  const associationForeignKeyFull = `${joinTable}.${afk}`;
-  const associationPrimaryKeyFull = `${getQueryAs(query)}.${apk}`;
+  let primaryKeys;
+  let foreignKeys;
+  let joinTable;
+  let throughForeignKeys;
+  let throughPrimaryKeys;
+  const { options } = relation;
+  if ("columns" in options) {
+    primaryKeys = options.columns;
+    foreignKeys = options.references;
+    joinTable = options.through.table;
+    throughForeignKeys = options.through.columns;
+    throughPrimaryKeys = options.through.references;
+  } else {
+    primaryKeys = [options.primaryKey];
+    foreignKeys = [options.foreignKey];
+    joinTable = options.joinTable;
+    throughForeignKeys = [options.associationForeignKey];
+    throughPrimaryKeys = [options.associationPrimaryKey];
+  }
+  const foreignKeysFull = foreignKeys.map((key) => `${joinTable}.${key}`);
+  const throughForeignKeysFull = throughForeignKeys.map(
+    (key) => `${joinTable}.${key}`
+  );
+  const foreignTable = getQueryAs(query);
+  const throughPrimaryKeysFull = throughPrimaryKeys.map(
+    (key) => `${foreignTable}.${key}`
+  );
+  const len = primaryKeys.length;
+  const throughLen = throughPrimaryKeys.length;
   const baseQuery = Object.create(qb.baseQuery);
   baseQuery.baseQuery = baseQuery;
   baseQuery.table = joinTable;
-  baseQuery.shape = {
-    [fk]: removeColumnName(table.shape[pk]),
-    [afk]: removeColumnName(query.shape[apk])
-  };
+  const shape = {};
+  for (let i = 0; i < len; i++) {
+    shape[foreignKeys[i]] = removeColumnName(table.shape[primaryKeys[i]]);
+  }
+  for (let i = 0; i < throughLen; i++) {
+    shape[throughForeignKeys[i]] = removeColumnName(
+      query.shape[throughPrimaryKeys[i]]
+    );
+  }
+  baseQuery.shape = shape;
   baseQuery.q = __spreadProps$1(__spreadValues$3({}, baseQuery.q), {
     shape: baseQuery.shape
   });
@@ -875,31 +1087,56 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
   const state = {
     relatedTableQuery: query,
     joinTableQuery: subQuery,
-    primaryKey: pk,
-    foreignKey: fk,
-    associationPrimaryKey: apk,
-    associationForeignKey: afk,
-    foreignKeyFull,
-    associationForeignKeyFull,
-    associationPrimaryKeyFull
+    primaryKeys,
+    foreignKeys,
+    throughForeignKeys,
+    throughPrimaryKeys,
+    foreignKeysFull,
+    throughForeignKeysFull,
+    throughPrimaryKeysFull
   };
+  const joinQuery = (toQuery, tableAs, foreignAs) => {
+    return toQuery.whereExists(subQuery, (q) => {
+      for (let i = 0; i < throughLen; i++) {
+        q._on(
+          throughForeignKeysFull[i],
+          `${foreignAs}.${throughPrimaryKeys[i]}`
+        );
+      }
+      for (let i = 0; i < len; i++) {
+        q._on(foreignKeysFull[i], `${tableAs}.${primaryKeys[i]}`);
+      }
+      return q;
+    });
+  };
+  const obj = {};
+  for (let i = 0; i < len; i++) {
+    obj[foreignKeys[i]] = primaryKeys[i];
+  }
+  const selectPrimaryKeysAsForeignKeys = [{ selectAs: obj }];
   return {
     returns: "many",
     method(params) {
-      return query.whereExists(
-        subQuery,
-        (q) => q.on(associationForeignKeyFull, associationPrimaryKeyFull).where({
-          [foreignKeyFull]: params[pk]
-        })
-      );
+      return query.whereExists(subQuery, (q) => {
+        q = q.clone();
+        const where = {};
+        for (let i = 0; i < len; i++) {
+          where[foreignKeysFull[i]] = params[primaryKeys[i]];
+        }
+        for (let i = 0; i < throughLen; i++) {
+          q._on(throughForeignKeysFull[i], throughPrimaryKeysFull[i]);
+        }
+        return q._where(where);
+      });
     },
     virtualColumn: new HasAndBelongsToManyVirtualColumn(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,
-        (q) => q._on(associationForeignKeyFull, `${getQueryAs(toQuery)}.${apk}`)._on(foreignKeyFull, `${getQueryAs(fromQuery)}.${pk}`)
+      const join = joinQuery(
+        toQuery,
+        getQueryAs(fromQuery),
+        getQueryAs(toQuery)
       );
       join.q.joinedShapes = __spreadProps$1(__spreadValues$3({}, join.q.joinedShapes), {
         [fromQuery.q.as || fromQuery.table]: fromQuery.q.shape
@@ -907,10 +1144,7 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
       return join;
     },
     reverseJoin(fromQuery, toQuery) {
-      return fromQuery.whereExists(
-        subQuery,
-        (q) => q._on(associationForeignKeyFull, `${getQueryAs(toQuery)}.${apk}`)._on(foreignKeyFull, `${getQueryAs(fromQuery)}.${pk}`)
-      );
+      return joinQuery(fromQuery, getQueryAs(fromQuery), getQueryAs(toQuery));
     },
     modifyRelatedQuery(relationQuery) {
       const ref = {};
@@ -922,14 +1156,12 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
           );
         }
         const fromQuery = ref.q.clone();
-        fromQuery.q.select = [{ selectAs: { [fk]: pk } }];
-        const createdCount = await subQuery.count()._createFrom(
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          fromQuery,
-          {
-            [afk]: result[0][apk]
-          }
-        );
+        fromQuery.q.select = selectPrimaryKeysAsForeignKeys;
+        const data = {};
+        for (let i = 0; i < throughLen; i++) {
+          data[throughForeignKeys[i]] = result[0][throughPrimaryKeys[i]];
+        }
+        const createdCount = await subQuery.count()._createFrom(fromQuery, data);
         if (createdCount === 0) {
           throw new NotFoundError(fromQuery);
         }
@@ -941,97 +1173,127 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
   };
 };
 const queryJoinTable = (state, data, conditions) => {
-  const t = state.joinTableQuery.clone();
-  const where = {
-    [state.foreignKey]: { in: data.map((item) => item[state.primaryKey]) }
-  };
+  const t = state.joinTableQuery.where({
+    IN: {
+      columns: state.foreignKeys,
+      values: data.map((item) => state.primaryKeys.map((key) => item[key]))
+    }
+  });
   if (conditions) {
-    where[state.associationForeignKey] = {
-      in: state.relatedTableQuery.where(
-        Array.isArray(conditions) ? { OR: conditions } : conditions
-      )._select(state.associationPrimaryKey)
-    };
+    t._where({
+      IN: {
+        columns: state.throughForeignKeys,
+        values: state.relatedTableQuery.where(conditionsToWhereArg(conditions))._select(...state.throughPrimaryKeys)
+      }
+    });
   }
-  return t._where(where);
-};
-const queryRelatedTable = (query, conditions) => {
-  return query.where(
-    Array.isArray(conditions) ? { OR: conditions } : conditions
-  );
+  return t;
 };
-const insertToJoinTable = (state, joinTableTransaction, data, ids) => {
-  return joinTableTransaction._count()._createMany(
-    data.flatMap(
-      (item) => ids.map((id) => ({
-        [state.foreignKey]: item[state.primaryKey],
-        [state.associationForeignKey]: id
-      }))
-    )
-  );
+const conditionsToWhereArg = (conditions) => Array.isArray(conditions) ? { OR: conditions } : conditions;
+const insertToJoinTable = (state, joinTableTransaction, data, idsRows) => {
+  const len = state.primaryKeys.length;
+  const throughLen = state.throughPrimaryKeys.length;
+  const records = [];
+  for (const item of data) {
+    const obj = {};
+    for (let i = 0; i < len; i++) {
+      obj[state.foreignKeys[i]] = item[state.primaryKeys[i]];
+    }
+    for (const ids of idsRows) {
+      const record = __spreadValues$3({}, obj);
+      for (let i = 0; i < throughLen; i++) {
+        record[state.throughForeignKeys[i]] = ids[i];
+      }
+      records.push(record);
+    }
+  }
+  return joinTableTransaction._count()._createMany(records);
 };
 const nestedInsert = ({
   relatedTableQuery,
   joinTableQuery,
-  primaryKey,
-  foreignKey,
-  associationPrimaryKey,
-  associationForeignKey
+  primaryKeys,
+  foreignKeys,
+  throughPrimaryKeys,
+  throughForeignKeys
 }) => {
+  const len = primaryKeys.length;
+  const throughLen = primaryKeys.length;
   return async (_, data) => {
-    const connect = data.filter(
-      (item) => Boolean(item[1].connect)
-    );
     const t = relatedTableQuery.clone();
+    const items = [];
+    for (const item of data) {
+      if (item[1].connect) {
+        items.push(item);
+      }
+    }
     let connected;
-    if (connect.length) {
-      connected = await Promise.all(
-        connect.flatMap(
-          ([, { connect: connect2 }]) => connect2.map(
-            (item) => t.select(associationPrimaryKey)._findBy(item)._take()
-          )
-        )
-      );
+    if (items.length) {
+      const queries = [];
+      for (const [, { connect }] of items) {
+        for (const item of connect) {
+          queries.push(
+            t.select(...throughPrimaryKeys)._findBy(item)._take()
+          );
+        }
+      }
+      connected = await Promise.all(queries);
     } else {
       connected = [];
     }
-    const connectOrCreate = data.filter(
-      (item) => Boolean(item[1].connectOrCreate)
-    );
+    items.length = 0;
+    for (const item of data) {
+      if (item[1].connectOrCreate) {
+        items.push(item);
+      }
+    }
     let connectOrCreated;
-    if (connectOrCreate.length) {
-      connectOrCreated = await Promise.all(
-        connectOrCreate.flatMap(
-          ([, { connectOrCreate: connectOrCreate2 }]) => connectOrCreate2.map(
-            (item) => t.select(associationPrimaryKey)._findBy(item.where)._takeOptional()
-          )
-        )
-      );
+    if (items.length) {
+      const queries = [];
+      for (const [, { connectOrCreate }] of items) {
+        for (const item of connectOrCreate) {
+          queries.push(
+            t.select(...throughPrimaryKeys)._findBy(item.where)._takeOptional()
+          );
+        }
+      }
+      connectOrCreated = await Promise.all(queries);
     } else {
       connectOrCreated = [];
     }
     let connectOrCreateI = 0;
-    const create = data.filter(
-      (item) => {
-        if (item[1].connectOrCreate) {
-          const length = item[1].connectOrCreate.length;
-          connectOrCreateI += length;
-          for (let i = length; i > 0; i--) {
-            if (!connectOrCreated[connectOrCreateI - i])
-              return true;
+    items.length = 0;
+    for (const item of data) {
+      if (item[1].connectOrCreate) {
+        const length = item[1].connectOrCreate.length;
+        connectOrCreateI += length;
+        for (let i = length; i > 0; i--) {
+          if (!connectOrCreated[connectOrCreateI - i]) {
+            items.push(item);
+            break;
           }
         }
-        return Boolean(item[1].create);
+      } else if (item[1].create) {
+        items.push(item);
       }
-    );
+    }
     connectOrCreateI = 0;
     let created;
-    if (create.length) {
-      created = await t.select(associationPrimaryKey)._createMany(
-        create.flatMap(([, { create: create2 = [], connectOrCreate: connectOrCreate2 = [] }]) => [
-          ...create2,
-          ...connectOrCreate2.filter(() => !connectOrCreated[connectOrCreateI++]).map((item) => item.create)
-        ])
-      );
+    if (items.length) {
+      const records2 = [];
+      for (const [, { create, connectOrCreate }] of items) {
+        if (create) {
+          records2.push(...create);
+        }
+        if (connectOrCreate) {
+          for (const item of connectOrCreate) {
+            if (!connectOrCreated[connectOrCreateI++]) {
+              records2.push(item.create);
+            }
+          }
+        }
+      }
+      created = await t.select(...throughPrimaryKeys)._createMany(records2);
     } else {
       created = [];
     }
@@ -1039,95 +1301,110 @@ const nestedInsert = ({
     let createI = 0;
     let connectI = 0;
     connectOrCreateI = 0;
-    data.forEach(([, data2], index) => {
-      if (data2.create || data2.connectOrCreate) {
-        if (data2.create) {
-          const len = data2.create.length;
-          allKeys[index][1] = created.slice(createI, createI + len);
-          createI += len;
+    for (let index = 0, len2 = data.length; index < len2; index++) {
+      const item = data[index][1];
+      if (item.create || item.connectOrCreate) {
+        if (item.create) {
+          const len3 = item.create.length;
+          allKeys[index][1] = created.slice(createI, createI + len3);
+          createI += len3;
         }
-        if (data2.connectOrCreate) {
+        if (item.connectOrCreate) {
           const arr = [];
           allKeys[index][1] = arr;
-          const len = data2.connectOrCreate.length;
-          for (let i = 0; i < len; i++) {
-            const item = connectOrCreated[connectOrCreateI++];
-            if (item) {
-              arr.push(item);
+          const len3 = item.connectOrCreate.length;
+          for (let i = 0; i < len3; i++) {
+            const item2 = connectOrCreated[connectOrCreateI++];
+            if (item2) {
+              arr.push(item2);
             } else {
               arr.push(created[createI++]);
             }
           }
         }
       }
-      if (data2.connect) {
-        const len = data2.connect.length;
-        allKeys[index][1] = connected.slice(connectI, connectI + len);
-        connectI += len;
+      if (item.connect) {
+        const len3 = item.connect.length;
+        allKeys[index][1] = connected.slice(connectI, connectI + len3);
+        connectI += len3;
       }
-    });
-    await joinTableQuery.count()._createMany(
-      allKeys.flatMap(([selfData, relationKeys]) => {
-        const selfKey = selfData[primaryKey];
-        return relationKeys.map((relationData) => ({
-          [foreignKey]: selfKey,
-          [associationForeignKey]: relationData[associationPrimaryKey]
-        }));
-      })
-    );
+    }
+    const records = [];
+    for (const [selfData, relationKeys] of allKeys) {
+      const obj = {};
+      for (let i = 0; i < len; i++) {
+        obj[foreignKeys[i]] = selfData[primaryKeys[i]];
+      }
+      for (const relationData of relationKeys) {
+        const record = __spreadValues$3({}, obj);
+        for (let i = 0; i < throughLen; i++) {
+          record[throughForeignKeys[i]] = relationData[throughPrimaryKeys[i]];
+        }
+        records.push(record);
+      }
+    }
+    await joinTableQuery.count()._createMany(records);
   };
 };
 const nestedUpdate = (state) => {
+  const len = state.primaryKeys.length;
+  const throughLen = state.throughPrimaryKeys.length;
   return async (_, data, params) => {
     if (params.create) {
-      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],
-            [state.associationForeignKey]: id
-          }))
-        )
-      );
+      const idsRows = await state.relatedTableQuery.select(...state.throughPrimaryKeys)._rows()._createMany(params.create);
+      const records = [];
+      for (const item of data) {
+        const obj = {};
+        for (let i = 0; i < len; i++) {
+          obj[state.foreignKeys[i]] = item[state.primaryKeys[i]];
+        }
+        for (const ids of idsRows) {
+          const record = __spreadValues$3({}, obj);
+          for (let i = 0; i < throughLen; i++) {
+            record[state.throughForeignKeys[i]] = ids[i];
+          }
+          records.push(record);
+        }
+      }
+      await state.joinTableQuery.createMany(records);
     }
     if (params.update) {
-      await state.relatedTableQuery.whereExists(
-        state.joinTableQuery,
-        (q) => (
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      await state.relatedTableQuery.whereExists(state.joinTableQuery, (q) => {
+        for (let i = 0; i < throughLen; i++) {
           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);
+            state.throughForeignKeysFull[i],
+            state.throughPrimaryKeysFull[i]
+          );
+        }
+        return q._where({
+          IN: {
+            columns: state.foreignKeysFull,
+            values: data.map(
+              (item) => state.primaryKeys.map((key) => item[key])
+            )
+          }
+        });
+      })._where(conditionsToWhereArg(params.update.where))._update(params.update.data);
     }
     if (params.disconnect) {
       await queryJoinTable(state, data, params.disconnect)._delete();
     }
     if (params.delete) {
       const j = queryJoinTable(state, data, params.delete);
-      const ids = await j._pluck(state.associationForeignKey)._delete();
-      await queryRelatedTable(state.relatedTableQuery, {
-        [state.associationPrimaryKey]: { in: ids }
+      const idsRows = await j._select(...state.throughForeignKeys)._rows()._delete();
+      await state.relatedTableQuery.where({
+        IN: {
+          columns: state.throughPrimaryKeys,
+          values: idsRows
+        }
       })._delete();
     }
     if (params.set) {
       const j = queryJoinTable(state, data);
       await j._delete();
       delete j.q[toSQLCacheKey];
-      const ids = await queryRelatedTable(
-        state.relatedTableQuery,
-        params.set
-      )._pluck(state.associationPrimaryKey);
-      await insertToJoinTable(state, j, data, ids);
+      const idsRows = await state.relatedTableQuery.where(conditionsToWhereArg(params.set))._select(...state.throughPrimaryKeys)._rows();
+      await insertToJoinTable(state, j, data, idsRows);
     }
   };
 };