orchid-orm 1.17.38 → 1.18.1

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-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, DbTableOptionScopes, DefaultColumnTypes, QueryBeforeHook, QueryAfterHook, AfterHook, WhereResult, MergeQuery, SetQueryReturns, QueryReturnType } from 'pqb';
 export * from 'pqb';
-import { EmptyObject, MaybeArray, StringKey, ColumnsShapeBase, ColumnShapeQueryType, ColumnShapeOutput, ColumnShapeInput } from 'orchid-core';
+import { ColumnsShapeBase, EmptyObject, MaybeArray, StringKey, CoreQueryScopes, ColumnShapeQueryType, ColumnShapeOutput, ColumnShapeInput } from 'orchid-core';
 
 type RelationCommonOptions<Related extends TableClass = TableClass, Scope extends Query = Query> = {
     scope?: ScopeFn<Related, Scope>;
@@ -25,14 +25,14 @@ type BelongsTo = RelationThunkBase & {
     type: 'belongsTo';
     options: BelongsToOptions;
 };
-type BelongsToOptions<Self extends Table = Table, Related extends TableClass = TableClass, Scope extends Query = Query> = RelationCommonOptions<Related, Scope> & RelationRefsOrKeysOptions<keyof Self['columns'], keyof InstanceType<Related>['columns'], keyof InstanceType<Related>['columns'], keyof Self['columns']>;
+type BelongsToOptions<Columns extends ColumnsShapeBase = ColumnsShapeBase, Related extends TableClass = TableClass, Scope extends Query = Query> = RelationCommonOptions<Related, Scope> & RelationRefsOrKeysOptions<keyof Columns, keyof InstanceType<Related>['columns'], keyof InstanceType<Related>['columns'], keyof Columns>;
 type BelongsToInfo<T extends Table, Relation extends BelongsTo, K extends string, FK extends string = Relation['options'] extends RelationRefsOptions ? Relation['options']['columns'][number] : Relation['options'] extends RelationKeysOptions ? Relation['options']['foreignKey'] : never, Q extends QueryWithTable = SetQueryTableAlias<DbTable<ReturnType<Relation['fn']>>, K>, DataForCreate = RelationToOneDataForCreate<{
     nestedCreateQuery: Q;
     table: Q;
 }>, 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;
@@ -76,11 +76,11 @@ type HasMany = RelationThunkBase & {
     type: 'hasMany';
     options: HasManyOptions;
 };
-type HasManyOptions<Self extends Table = Table, Related extends TableClass = TableClass, Scope extends Query = Query, Through extends string = string, Source extends string = string> = HasOneOptions<Self, Related, Scope, Through, Source>;
+type HasManyOptions<Columns extends ColumnsShapeBase = ColumnsShapeBase, Related extends TableClass = TableClass, Scope extends Query = Query, Through extends string = string, Source extends string = string> = HasOneOptions<Columns, Related, Scope, Through, Source>;
 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;
@@ -114,11 +114,11 @@ type HasOne = RelationThunkBase & {
     type: 'hasOne';
     options: HasOneOptions;
 };
-type HasOneOptions<Self extends Table = Table, Related extends TableClass = TableClass, Scope extends Query = Query, Through extends string = string, Source extends string = string> = RelationCommonOptions<Related, Scope> & (RelationHasOptions<keyof Self['columns'], keyof InstanceType<Related>['columns']> | RelationThroughOptions<Through, Source>);
+type HasOneOptions<Columns extends ColumnsShapeBase = ColumnsShapeBase, Related extends TableClass = TableClass, Scope extends Query = Query, Through extends string = string, Source extends string = string> = RelationCommonOptions<Related, Scope> & (RelationHasOptions<keyof Columns, keyof InstanceType<Related>['columns']> | RelationThroughOptions<Through, Source>);
 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;
@@ -239,8 +239,8 @@ type HasAndBelongsToMany = RelationThunkBase & {
     type: 'hasAndBelongsToMany';
     options: HasAndBelongsToManyOptions;
 };
-type HasAndBelongsToManyOptions<Self extends Table = Table, Related extends TableClass = TableClass, Scope extends Query = Query> = RelationCommonOptions<Related, Scope> & ({
-    columns: (keyof Self['columns'])[];
+type HasAndBelongsToManyOptions<Columns extends ColumnsShapeBase = ColumnsShapeBase, Related extends TableClass = TableClass, Scope extends Query = Query> = RelationCommonOptions<Related, Scope> & ({
+    columns: (keyof Columns)[];
     references: string[];
     through: {
         table: string;
@@ -248,7 +248,7 @@ type HasAndBelongsToManyOptions<Self extends Table = Table, Related extends Tabl
         references: (keyof InstanceType<Related>['columns'])[];
     };
 } | {
-    primaryKey: keyof Self['columns'];
+    primaryKey: keyof Columns;
     foreignKey: string;
     joinTable: string;
     associationPrimaryKey: string;
@@ -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;
@@ -344,7 +344,7 @@ type TableClass<T extends Table = Table> = {
 type TableClasses = Record<string, TableClass>;
 type TableToDb<T extends Table, RelationQueries extends Record<string, RelationQueryBase>> = Db<T['table'], T['columns'], RelationQueries, T['types'], T['computed'] extends ComputedColumnsBase<never> ? T['columns'] & {
     [K in keyof T['computed']]: ReturnType<T['computed'][K]>['_type'];
-} : T['columns']> & {
+} : T['columns'], T['scopes']> & {
     definedAs: string;
     db: OrchidORM;
     getFilePath(): string;
@@ -364,6 +364,7 @@ type Table = {
      * collect computed columns returned by {@link BaseTable.setColumns}
      */
     computed?: ComputedColumnsBase<never>;
+    scopes?: CoreQueryScopes;
 };
 type Queryable<T extends Table> = Partial<ColumnShapeQueryType<T['columns']>>;
 type Selectable<T extends Table> = ColumnShapeOutput<T['columns']>;
@@ -478,22 +479,37 @@ interface BaseTableInstance<ColumnTypes> {
      * @param computed - object where keys are column names and values are functions returning raw SQL
      */
     setComputed<Table extends string, Shape extends ColumnsShapeBase, Computed extends ComputedColumnsBase<Db<Table, Shape, EmptyObject, ColumnTypes>>>(computed: Computed): Computed;
-    belongsTo<Self extends Table, Related extends TableClass, Scope extends Query, Options extends BelongsToOptions<Self, Related, Scope>>(this: Self, fn: () => Related, options: Options): {
+    /**
+     * See {@link ScopeMethods}
+     */
+    setScopes<Table extends string, Columns extends ColumnsShapeBase, Keys extends string>(this: {
+        table: Table;
+        columns: Columns;
+    }, scopes: DbTableOptionScopes<Table, Columns, Keys>): CoreQueryScopes<Keys>;
+    belongsTo<Columns extends ColumnsShapeBase, Related extends TableClass, Scope extends Query, Options extends BelongsToOptions<Columns, Related, Scope>>(this: {
+        columns: Columns;
+    }, fn: () => Related, options: Options): {
         type: 'belongsTo';
         fn: () => Related;
         options: Options;
     };
-    hasOne<Self extends Table, Related extends TableClass, Scope extends Query, Through extends string, Source extends string, Options extends HasOneOptions<Self, Related, Scope, Through, Source>>(this: Self, fn: () => Related, options: Options): {
+    hasOne<Columns extends ColumnsShapeBase, Related extends TableClass, Scope extends Query, Through extends string, Source extends string, Options extends HasOneOptions<Columns, Related, Scope, Through, Source>>(this: {
+        columns: Columns;
+    }, fn: () => Related, options: Options): {
         type: 'hasOne';
         fn: () => Related;
         options: Options;
     };
-    hasMany<Self extends Table, Related extends TableClass, Scope extends Query, Through extends string, Source extends string, Options extends HasManyOptions<Self, Related, Scope, Through, Source>>(this: Self, fn: () => Related, options: Options): {
+    hasMany<Columns extends ColumnsShapeBase, Related extends TableClass, Scope extends Query, Through extends string, Source extends string, Options extends HasManyOptions<Columns, Related, Scope, Through, Source>>(this: {
+        columns: Columns;
+    }, fn: () => Related, options: Options): {
         type: 'hasMany';
         fn: () => Related;
         options: Options;
     };
-    hasAndBelongsToMany<Self extends Table, Related extends TableClass, Scope extends Query, Options extends HasAndBelongsToManyOptions<Self, Related, Scope>>(this: Self, fn: () => Related, options: Options): {
+    hasAndBelongsToMany<Columns extends ColumnsShapeBase, Related extends TableClass, Scope extends Query, Options extends HasAndBelongsToManyOptions<Columns, Related, Scope>>(this: {
+        columns: Columns;
+    }, fn: () => Related, options: Options): {
         type: 'hasAndBelongsToMany';
         fn: () => Related;
         options: Options;

package/dist/index.js

@@ -82,6 +82,9 @@ function createBaseTable({
     setComputed(computed) {
       return computed;
     }
+    setScopes(scopes) {
+      return scopes;
+    }
     belongsTo(fn, options) {
       return {
         type: "belongsTo",
@@ -182,31 +185,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 +283,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 +543,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 +563,17 @@ const makeHasOneMethod = (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];
@@ -564,6 +585,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 +604,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 +789,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 +811,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 +833,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 +852,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 +1135,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 +1154,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 +1177,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 +1198,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 +1628,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);
@@ -1704,7 +1759,8 @@ const orchidORM = (_a, tables) => {
     tableInstances[key] = table;
     const options2 = __spreadProps(__spreadValues$1({}, commonOptions), {
       schema: table.schema,
-      language: table.language
+      language: table.language,
+      scopes: table.scopes
     });
     if (table.noPrimaryKey)
       options2.noPrimaryKey = "ignore";