orchid-orm 1.17.38 → 1.18.0

package/dist/index.mjs

@@ -181,31 +181,45 @@ const relationWhere = (len, keys, valueKeys) => (params) => {
   }
   return obj;
 };
-function joinHasThrough(q, fromQuery, toQuery, throughRelation, sourceRelation) {
+function joinHasThrough(q, baseQuery, joiningQuery, throughRelation, sourceRelation) {
   return q.whereExists(
-    throughRelation.joinQuery(fromQuery, throughRelation.query),
+    throughRelation.joinQuery(throughRelation.query, baseQuery),
     () => {
-      const as = getQueryAs(toQuery);
+      const as = getQueryAs(joiningQuery);
       return sourceRelation.joinQuery(
-        throughRelation.query,
-        sourceRelation.query.as(as)
+        sourceRelation.query.as(as),
+        throughRelation.query
       );
     }
   );
 }
-function joinHasRelation(fromQuery, toQuery, primaryKeys, foreignKeys, len) {
-  const q = toQuery.clone();
+function joinHasRelation(baseQuery, joiningQuery, primaryKeys, foreignKeys, len) {
+  const q = joiningQuery.clone();
   setQueryObjectValue(
     q,
     "joinedShapes",
-    fromQuery.q.as || fromQuery.table,
-    fromQuery.q.shape
+    baseQuery.q.as || baseQuery.table,
+    baseQuery.q.shape
   );
   for (let i = 0; i < len; i++) {
-    pushQueryOn(q, fromQuery, toQuery, foreignKeys[i], primaryKeys[i]);
+    pushQueryOn(q, baseQuery, joiningQuery, foreignKeys[i], primaryKeys[i]);
   }
   return q;
 }
+const joinQueryChainingHOF = (reverseJoin, joinQuery) => (joiningQuery, baseQuery) => {
+  const chain = joiningQuery.q.relChain;
+  if (!chain || chain.length === 1) {
+    return joinQuery(joiningQuery, baseQuery);
+  }
+  const last = chain[chain.length - 1];
+  const query = "relationConfig" in last ? last.relationConfig.joinQuery(last, baseQuery) : last;
+  const inner = reverseJoin(query, joiningQuery);
+  return joiningQuery.where({
+    EXISTS: {
+      args: [inner]
+    }
+  });
+};
 
 class BelongsToVirtualColumn extends VirtualColumn {
   constructor(key, state) {
@@ -265,31 +279,33 @@ const makeBelongsToMethod = (relation, relationName, query) => {
   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();
+  const join = (baseQuery, joiningQuery, primaryKeys2, foreignKeys2) => {
+    const q = joiningQuery.clone();
     setQueryObjectValue(
       q,
       "joinedShapes",
-      fromQuery.q.as || fromQuery.table,
-      fromQuery.q.shape
+      baseQuery.q.as || baseQuery.table,
+      baseQuery.q.shape
     );
     for (let i = 0; i < len; i++) {
-      pushQueryOn(q, fromQuery, toQuery, primaryKeys2[i], foreignKeys2[i]);
+      pushQueryOn(q, baseQuery, joiningQuery, primaryKeys2[i], foreignKeys2[i]);
     }
     return q;
   };
+  const reverseJoin = (baseQuery, joiningQuery) => {
+    return join(joiningQuery, baseQuery, foreignKeys, primaryKeys);
+  };
   return {
     returns: "one",
     method(params) {
       return query.where(makeWhere(params));
     },
     virtualColumn: new BelongsToVirtualColumn(relationName, state),
-    joinQuery(fromQuery, toQuery) {
-      return join(fromQuery, toQuery, primaryKeys, foreignKeys);
-    },
-    reverseJoin(fromQuery, toQuery) {
-      return join(toQuery, fromQuery, foreignKeys, primaryKeys);
-    }
+    joinQuery: joinQueryChainingHOF(
+      reverseJoin,
+      (joiningQuery, baseQuery) => join(baseQuery, joiningQuery, primaryKeys, foreignKeys)
+    ),
+    reverseJoin
   };
 };
 const nestedInsert$3 = ({ query, primaryKeys }) => {
@@ -523,8 +539,17 @@ const makeHasOneMethod = (table, relation, relationName, query) => {
     const { through, source } = relation.options;
     const throughRelation = getThroughRelation(table, through);
     const sourceRelation = getSourceRelation(throughRelation, source);
-    const sourceQuery = sourceRelation.joinQuery(throughRelation.query, sourceRelation.query).as(relationName);
+    const sourceQuery = sourceRelation.joinQuery(sourceRelation.query, throughRelation.query).as(relationName);
     const whereExistsCallback = () => sourceQuery;
+    const reverseJoin2 = (baseQuery, joiningQuery) => {
+      return joinHasThrough(
+        baseQuery,
+        baseQuery,
+        joiningQuery,
+        throughRelation,
+        sourceRelation
+      );
+    };
     return {
       returns: "one",
       method: (params) => {
@@ -534,24 +559,17 @@ const makeHasOneMethod = (table, relation, relationName, query) => {
           whereExistsCallback
         );
       },
-      joinQuery(fromQuery, toQuery) {
-        return joinHasThrough(
-          toQuery,
-          fromQuery,
-          toQuery,
+      joinQuery: joinQueryChainingHOF(
+        reverseJoin2,
+        (joiningQuery, baseQuery) => joinHasThrough(
+          joiningQuery,
+          baseQuery,
+          joiningQuery,
           throughRelation,
           sourceRelation
-        );
-      },
-      reverseJoin(fromQuery, toQuery) {
-        return joinHasThrough(
-          fromQuery,
-          fromQuery,
-          toQuery,
-          throughRelation,
-          sourceRelation
-        );
-      }
+        )
+      ),
+      reverseJoin: reverseJoin2
     };
   }
   const primaryKeys = "columns" in relation.options ? relation.options.columns : [relation.options.primaryKey];
@@ -563,6 +581,15 @@ const makeHasOneMethod = (table, relation, relationName, query) => {
     reversedOn[foreignKeys[i]] = primaryKeys[i];
   }
   const fromQuerySelect = [{ selectAs: reversedOn }];
+  const reverseJoin = (baseQuery, joiningQuery) => {
+    return joinHasRelation(
+      joiningQuery,
+      baseQuery,
+      foreignKeys,
+      primaryKeys,
+      len
+    );
+  };
   return {
     returns: "one",
     method: (params) => {
@@ -573,19 +600,18 @@ const makeHasOneMethod = (table, relation, relationName, query) => {
       return query.where(values)._defaults(values);
     },
     virtualColumn: new HasOneVirtualColumn(relationName, state),
-    joinQuery(fromQuery, toQuery) {
-      return joinHasRelation(fromQuery, toQuery, primaryKeys, foreignKeys, len);
-    },
-    reverseJoin(fromQuery, toQuery) {
-      return joinHasRelation(toQuery, fromQuery, foreignKeys, primaryKeys, len);
-    },
+    joinQuery: joinQueryChainingHOF(
+      reverseJoin,
+      (joiningQuery, baseQuery) => joinHasRelation(baseQuery, joiningQuery, primaryKeys, foreignKeys, len)
+    ),
+    reverseJoin,
     modifyRelatedQuery(relationQuery) {
       return (query2) => {
-        const fromQuery = query2.clone();
-        fromQuery.q.select = fromQuerySelect;
+        const baseQuery = query2.clone();
+        baseQuery.q.select = fromQuerySelect;
         const q = relationQuery.q;
         q.kind = "from";
-        q.values = { from: fromQuery };
+        q.values = { from: baseQuery };
       };
     }
   };
@@ -759,10 +785,19 @@ const makeHasManyMethod = (table, relation, relationName, query) => {
     const sourceRelation = getSourceRelation(throughRelation, source);
     const sourceRelationQuery = sourceRelation.query.as(relationName);
     const sourceQuery = sourceRelation.joinQuery(
-      throughRelation.query,
-      sourceRelationQuery
+      sourceRelationQuery,
+      throughRelation.query
     );
     const whereExistsCallback = () => sourceQuery;
+    const reverseJoin2 = (baseQuery, joiningQuery) => {
+      return joinHasThrough(
+        baseQuery,
+        baseQuery,
+        joiningQuery,
+        throughRelation,
+        sourceRelation
+      );
+    };
     return {
       returns: "many",
       method: (params) => {
@@ -772,24 +807,17 @@ const makeHasManyMethod = (table, relation, relationName, query) => {
           whereExistsCallback
         );
       },
-      joinQuery(fromQuery, toQuery) {
-        return joinHasThrough(
-          toQuery,
-          fromQuery,
-          toQuery,
-          throughRelation,
-          sourceRelation
-        );
-      },
-      reverseJoin(fromQuery, toQuery) {
-        return joinHasThrough(
-          fromQuery,
-          fromQuery,
-          toQuery,
+      joinQuery: joinQueryChainingHOF(
+        reverseJoin2,
+        (joiningQuery, baseQuery) => joinHasThrough(
+          joiningQuery,
+          baseQuery,
+          joiningQuery,
           throughRelation,
           sourceRelation
-        );
-      }
+        )
+      ),
+      reverseJoin: reverseJoin2
     };
   }
   const primaryKeys = "columns" in relation.options ? relation.options.columns : [relation.options.primaryKey];
@@ -801,6 +829,15 @@ const makeHasManyMethod = (table, relation, relationName, query) => {
     reversedOn[foreignKeys[i]] = primaryKeys[i];
   }
   const fromQuerySelect = [{ selectAs: reversedOn }];
+  const reverseJoin = (baseQuery, joiningQuery) => {
+    return joinHasRelation(
+      joiningQuery,
+      baseQuery,
+      foreignKeys,
+      primaryKeys,
+      len
+    );
+  };
   return {
     returns: "many",
     method: (params) => {
@@ -811,19 +848,18 @@ const makeHasManyMethod = (table, relation, relationName, query) => {
       return query.where(values)._defaults(values);
     },
     virtualColumn: new HasManyVirtualColumn(relationName, state),
-    joinQuery(fromQuery, toQuery) {
-      return joinHasRelation(fromQuery, toQuery, primaryKeys, foreignKeys, len);
-    },
-    reverseJoin(fromQuery, toQuery) {
-      return joinHasRelation(toQuery, fromQuery, foreignKeys, primaryKeys, len);
-    },
+    joinQuery: joinQueryChainingHOF(
+      reverseJoin,
+      (joiningQuery, baseQuery) => joinHasRelation(baseQuery, joiningQuery, primaryKeys, foreignKeys, len)
+    ),
+    reverseJoin,
     modifyRelatedQuery(relationQuery) {
       return (query2) => {
-        const fromQuery = query2.clone();
-        fromQuery.q.select = fromQuerySelect;
+        const baseQuery = query2.clone();
+        baseQuery.q.select = fromQuerySelect;
         const q = relationQuery.q;
         q.kind = "from";
-        q.values = { from: fromQuery };
+        q.values = { from: baseQuery };
       };
     }
   };
@@ -1095,8 +1131,8 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
     throughForeignKeysFull,
     throughPrimaryKeysFull
   };
-  const joinQuery = (toQuery, tableAs, foreignAs) => {
-    return toQuery.whereExists(subQuery, (q) => {
+  const joinQuery = (joiningQuery, tableAs, foreignAs) => {
+    return joiningQuery.whereExists(subQuery, (q) => {
       for (let i = 0; i < throughLen; i++) {
         q._on(
           throughForeignKeysFull[i],
@@ -1114,6 +1150,13 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
     obj[foreignKeys[i]] = primaryKeys[i];
   }
   const selectPrimaryKeysAsForeignKeys = [{ selectAs: obj }];
+  const reverseJoin = (baseQuery2, joiningQuery) => {
+    return joinQuery(
+      baseQuery2,
+      getQueryAs(baseQuery2),
+      getQueryAs(joiningQuery)
+    );
+  };
   return {
     returns: "many",
     method(params) {
@@ -1130,22 +1173,18 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
       });
     },
     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 = joinQuery(
-        toQuery,
-        getQueryAs(fromQuery),
-        getQueryAs(toQuery)
+    joinQuery: joinQueryChainingHOF(reverseJoin, (joiningQuery, baseQuery2) => {
+      const joined = joinQuery(
+        joiningQuery,
+        getQueryAs(baseQuery2),
+        getQueryAs(joiningQuery)
       );
-      join.q.joinedShapes = __spreadProps$1(__spreadValues$3({}, join.q.joinedShapes), {
-        [fromQuery.q.as || fromQuery.table]: fromQuery.q.shape
+      joined.q.joinedShapes = __spreadProps$1(__spreadValues$3({}, joined.q.joinedShapes), {
+        [baseQuery2.q.as || baseQuery2.table]: baseQuery2.q.shape
       });
-      return join;
-    },
-    reverseJoin(fromQuery, toQuery) {
-      return joinQuery(fromQuery, getQueryAs(fromQuery), getQueryAs(toQuery));
-    },
+      return joined;
+    }),
+    reverseJoin,
     modifyRelatedQuery(relationQuery) {
       const ref = {};
       relationQuery._afterCreate([], async (result) => {
@@ -1155,15 +1194,15 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
             "Creating multiple `hasAndBelongsToMany` records is not yet supported"
           );
         }
-        const fromQuery = ref.q.clone();
-        fromQuery.q.select = selectPrimaryKeysAsForeignKeys;
+        const baseQuery2 = ref.q.clone();
+        baseQuery2.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);
+        const createdCount = await subQuery.count()._createFrom(baseQuery2, data);
         if (createdCount === 0) {
-          throw new NotFoundError(fromQuery);
+          throw new NotFoundError(baseQuery2);
         }
       });
       return (q) => {
@@ -1585,10 +1624,23 @@ const makeRelationQuery = (table, relationName, data, q) => {
     get() {
       var _a;
       const toTable = q.clone();
-      const query = this.q.isSubQuery ? toTable : toTable._all()._whereExists(
-        this.baseQuery,
-        (q2) => data.reverseJoin(this, toTable)
-      );
+      let query;
+      if (this.q.isSubQuery) {
+        query = toTable;
+        query.q.isSubQuery = true;
+      } else {
+        query = toTable._all()._where({
+          EXISTS: {
+            args: [data.reverseJoin(this, toTable)]
+          }
+        });
+      }
+      if (this.q.relChain) {
+        query.q.relChain = [...this.q.relChain, this];
+        query.q.returnType = "all";
+      } else {
+        query.q.relChain = [this];
+      }
       query.q.joinedShapes = __spreadValues$2({
         [getQueryAs(this)]: this.q.shape
       }, this.q.joinedShapes);