orchid-orm 1.17.38 → 1.18.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Query, QueryWithTable, SetQueryTableAlias, WhereArg, UpdateData, CreateData, AddQueryDefaults, Db, IsolationLevel, TransactionOptions, Adapter, FromArgs, FromResult, AdapterOptions, QueryLogOptions, NoPrimaryKeyOption, RelationQuery, RelationConfigBase, RelationQueryBase, ComputedColumnsBase, QueryData, QueryBase, DefaultColumnTypes, QueryBeforeHook, QueryAfterHook, AfterHook, WhereResult, MergeQuery, SetQueryReturns, QueryReturnType } from 'pqb';
+import { Query, QueryWithTable, SetQueryTableAlias, RelationJoinQuery, WhereArg, UpdateData, CreateData, AddQueryDefaults, Db, IsolationLevel, TransactionOptions, Adapter, FromArgs, FromResult, AdapterOptions, QueryLogOptions, NoPrimaryKeyOption, RelationQuery, RelationConfigBase, RelationQueryBase, ComputedColumnsBase, QueryData, QueryBase, DefaultColumnTypes, QueryBeforeHook, QueryAfterHook, AfterHook, WhereResult, MergeQuery, SetQueryReturns, QueryReturnType } from 'pqb';
 export * from 'pqb';
 import { EmptyObject, MaybeArray, StringKey, ColumnsShapeBase, ColumnShapeQueryType, ColumnShapeOutput, ColumnShapeInput } from 'orchid-core';
 
@@ -32,7 +32,7 @@ type BelongsToInfo<T extends Table, Relation extends BelongsTo, K extends string
 }>, Required = Relation['options']['required'] extends true ? true : false> = {
     table: Q;
     query: Q;
-    joinQuery(fromQuery: Query, toQuery: Query): Query;
+    joinQuery: RelationJoinQuery;
     one: true;
     required: Required;
     omitForeignKeyInCreate: FK;
@@ -80,7 +80,7 @@ type HasManyOptions<Self extends Table = Table, Related extends TableClass = Tab
 type HasManyInfo<T extends Table, Relations extends RelationThunks, Relation extends HasMany, K extends string, Populate extends Record<string, true> = Relation['options'] extends RelationRefsOptions ? Record<Relation['options']['references'][number], true> : Relation['options'] extends RelationKeysOptions ? Record<Relation['options']['foreignKey'], true> : never, TC extends TableClass = ReturnType<Relation['fn']>, Q extends QueryWithTable = SetQueryTableAlias<DbTable<TC>, K>, NestedCreateQuery extends Query = Relation['options'] extends RelationThroughOptions ? Q : AddQueryDefaults<Q, Populate>> = {
     table: Q;
     query: Q;
-    joinQuery(fromQuery: Query, toQuery: Query): Query;
+    joinQuery: RelationJoinQuery;
     one: false;
     required: Relation['options']['required'] extends true ? true : false;
     omitForeignKeyInCreate: never;
@@ -118,7 +118,7 @@ type HasOneOptions<Self extends Table = Table, Related extends TableClass = Tabl
 type HasOneInfo<T extends Table, Relations extends RelationThunks, Relation extends HasOne, K extends string, Populate extends Record<string, true> = Relation['options'] extends RelationRefsOptions ? Record<Relation['options']['references'][number], true> : Relation['options'] extends RelationKeysOptions ? Record<Relation['options']['foreignKey'], true> : never, TC extends TableClass = ReturnType<Relation['fn']>, Q extends QueryWithTable = SetQueryTableAlias<DbTable<TC>, K>, NestedCreateQuery extends Query = Relation['options'] extends RelationThroughOptions ? Q : AddQueryDefaults<Q, Populate>> = {
     table: Q;
     query: Q;
-    joinQuery(fromQuery: Query, toQuery: Query): Query;
+    joinQuery: RelationJoinQuery;
     one: true;
     required: Relation['options']['required'] extends true ? true : false;
     omitForeignKeyInCreate: never;
@@ -257,7 +257,7 @@ type HasAndBelongsToManyOptions<Self extends Table = Table, Related extends Tabl
 type HasAndBelongsToManyInfo<T extends Table, Relation extends HasAndBelongsToMany, K extends string, TC extends TableClass = ReturnType<Relation['fn']>, Q extends QueryWithTable = SetQueryTableAlias<DbTable<TC>, K>> = {
     table: Q;
     query: Q;
-    joinQuery(fromQuery: Query, toQuery: Query): Query;
+    joinQuery: RelationJoinQuery;
     one: false;
     required: Relation['options']['required'] extends true ? true : false;
     omitForeignKeyInCreate: never;

package/dist/index.js

@@ -182,31 +182,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 = pqb.getQueryAs(toQuery);
+      const as = pqb.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();
   pqb.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++) {
-    pqb.pushQueryOn(q, fromQuery, toQuery, foreignKeys[i], primaryKeys[i]);
+    pqb.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 pqb.VirtualColumn {
   constructor(key, state) {
@@ -266,31 +280,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();
     pqb.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++) {
-      pqb.pushQueryOn(q, fromQuery, toQuery, primaryKeys2[i], foreignKeys2[i]);
+      pqb.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 }) => {
@@ -524,8 +540,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) => {
@@ -535,24 +560,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];
@@ -564,6 +582,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) => {
@@ -574,19 +601,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 };
       };
     }
   };
@@ -760,10 +786,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) => {
@@ -773,24 +808,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];
@@ -802,6 +830,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) => {
@@ -812,19 +849,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 };
       };
     }
   };
@@ -1096,8 +1132,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],
@@ -1115,6 +1151,13 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
     obj[foreignKeys[i]] = primaryKeys[i];
   }
   const selectPrimaryKeysAsForeignKeys = [{ selectAs: obj }];
+  const reverseJoin = (baseQuery2, joiningQuery) => {
+    return joinQuery(
+      baseQuery2,
+      pqb.getQueryAs(baseQuery2),
+      pqb.getQueryAs(joiningQuery)
+    );
+  };
   return {
     returns: "many",
     method(params) {
@@ -1131,22 +1174,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,
-        pqb.getQueryAs(fromQuery),
-        pqb.getQueryAs(toQuery)
+    joinQuery: joinQueryChainingHOF(reverseJoin, (joiningQuery, baseQuery2) => {
+      const joined = joinQuery(
+        joiningQuery,
+        pqb.getQueryAs(baseQuery2),
+        pqb.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, pqb.getQueryAs(fromQuery), pqb.getQueryAs(toQuery));
-    },
+      return joined;
+    }),
+    reverseJoin,
     modifyRelatedQuery(relationQuery) {
       const ref = {};
       relationQuery._afterCreate([], async (result) => {
@@ -1156,15 +1195,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 pqb.NotFoundError(fromQuery);
+          throw new pqb.NotFoundError(baseQuery2);
         }
       });
       return (q) => {
@@ -1586,10 +1625,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({
         [pqb.getQueryAs(this)]: this.q.shape
       }, this.q.joinedShapes);