@rvoh/dream 0.36.4 → 0.38.0

package/dist/esm/src/dream/Query.js

@@ -7,8 +7,8 @@ import AssociationDeclaredWithoutAssociatedDreamClass from '../errors/associatio
 import CannotAssociateThroughPolymorphic from '../errors/associations/CannotAssociateThroughPolymorphic.js';
 import CannotJoinPolymorphicBelongsToError from '../errors/associations/CannotJoinPolymorphicBelongsToError.js';
 import JoinAttemptedOnMissingAssociation from '../errors/associations/JoinAttemptedOnMissingAssociation.js';
-import MissingRequiredAssociationOnClause from '../errors/associations/MissingRequiredAssociationOnClause.js';
-import MissingRequiredPassthroughForAssociationOnClause from '../errors/associations/MissingRequiredPassthroughForAssociationOnClause.js';
+import MissingRequiredAssociationAndClause from '../errors/associations/MissingRequiredAssociationAndClause.js';
+import MissingRequiredPassthroughForAssociationAndClause from '../errors/associations/MissingRequiredPassthroughForAssociationAndClause.js';
 import MissingThroughAssociation from '../errors/associations/MissingThroughAssociation.js';
 import MissingThroughAssociationSource from '../errors/associations/MissingThroughAssociationSource.js';
 import CannotCallUndestroyOnANonSoftDeleteModel from '../errors/CannotCallUndestroyOnANonSoftDeleteModel.js';
@@ -150,7 +150,7 @@ export default class Query extends ConnectedToDB {
      * stores the joins on statements applied to the
      * current Query instance
      */
-    innerJoinOnStatements = Object.freeze({});
+    innerJoinAndStatements = Object.freeze({});
     /**
      * @internal
      *
@@ -164,7 +164,7 @@ export default class Query extends ConnectedToDB {
      * stores the joins on statements applied to the
      * current Query instance
      */
-    leftJoinOnStatements = Object.freeze({});
+    leftJoinAndStatements = Object.freeze({});
     /**
      * @internal
      *
@@ -234,9 +234,9 @@ export default class Query extends ConnectedToDB {
         this.preloadStatements = Object.freeze(opts.preloadStatements || {});
         this.preloadOnStatements = Object.freeze(opts.preloadOnStatements || {});
         this.innerJoinStatements = Object.freeze(opts.innerJoinStatements || {});
-        this.innerJoinOnStatements = Object.freeze(opts.innerJoinOnStatements || {});
+        this.innerJoinAndStatements = Object.freeze(opts.innerJoinAndStatements || {});
         this.leftJoinStatements = Object.freeze(opts.leftJoinStatements || {});
-        this.leftJoinOnStatements = Object.freeze(opts.leftJoinOnStatements || {});
+        this.leftJoinAndStatements = Object.freeze(opts.leftJoinAndStatements || {});
         this.baseSqlAlias = opts.baseSqlAlias || this.tableName;
         this.baseSelectQuery = opts.baseSelectQuery || null;
         this.limitStatement = opts.limit || null;
@@ -308,16 +308,16 @@ export default class Query extends ConnectedToDB {
             order: opts.order === null ? [] : [...this.orderStatements, ...(opts.order || [])],
             distinctColumn: opts.distinctColumn !== undefined ? opts.distinctColumn : this.distinctColumn,
             loadFromJoins: opts.loadFromJoins !== undefined ? opts.loadFromJoins : this.joinLoadActivated,
-            // when passed, preloadStatements, preloadOnStatements, innerJoinStatements, and innerJoinOnStatements are already
+            // when passed, preloadStatements, preloadOnStatements, innerJoinStatements, and innerJoinAndStatements are already
             // cloned versions of the `this.` versions, handled in the `preload` and `joins` methods
             preloadStatements: opts.preloadStatements || this.preloadStatements,
             preloadOnStatements: opts.preloadOnStatements || this.preloadOnStatements,
             innerJoinDreamClasses: opts.innerJoinDreamClasses || this.innerJoinDreamClasses,
             innerJoinStatements: opts.innerJoinStatements || this.innerJoinStatements,
-            innerJoinOnStatements: opts.innerJoinOnStatements || this.innerJoinOnStatements,
+            innerJoinAndStatements: opts.innerJoinAndStatements || this.innerJoinAndStatements,
             leftJoinStatements: opts.leftJoinStatements || this.leftJoinStatements,
-            leftJoinOnStatements: opts.leftJoinOnStatements || this.leftJoinOnStatements,
-            // end:when passed, preloadStatements, preloadOnStatements, innerJoinStatements, and innerJoinOnStatements are already...
+            leftJoinAndStatements: opts.leftJoinAndStatements || this.leftJoinAndStatements,
+            // end:when passed, preloadStatements, preloadOnStatements, innerJoinStatements, and innerJoinAndStatements are already...
             bypassAllDefaultScopes: opts.bypassAllDefaultScopes !== undefined ? opts.bypassAllDefaultScopes : this.bypassAllDefaultScopes,
             bypassAllDefaultScopesExceptOnAssociations: opts.bypassAllDefaultScopesExceptOnAssociations !== undefined
                 ? opts.bypassAllDefaultScopesExceptOnAssociations
@@ -463,7 +463,7 @@ export default class Query extends ConnectedToDB {
      * // [Reply{id: 1}, Reply{id: 2}]
      * ```
      *
-     * @param args - A chain of association names and on/notOn/onAny clauses
+     * @param args - A chain of association names and and/andNot/andAny clauses
      * @returns A cloned Query with the joinLoad statement applied
      */
     leftJoinPreload(...args) {
@@ -485,7 +485,7 @@ export default class Query extends ConnectedToDB {
      * // [Reply{id: 1}, Reply{id: 2}]
      * ```
      *
-     * @param args - A chain of association names and on/notOn/onAny clauses
+     * @param args - A chain of association names and and/andNot/andAny clauses
      * @returns A cloned Query with the preload statement applied
      */
     preload(...args) {
@@ -502,36 +502,44 @@ export default class Query extends ConnectedToDB {
      * await User.query().innerJoin('posts').first()
      * ```
      *
-     * @param args - A chain of association names and on/notOn/onAny clauses
+     * @param args - A chain of association names and and/andNot/andAny clauses
      * @returns A cloned Query with the joins clause applied
      */
     innerJoin(...args) {
         const innerJoinDreamClasses = [...this.innerJoinDreamClasses];
         const innerJoinStatements = cloneDeepSafe(this.innerJoinStatements);
-        const innerJoinOnStatements = cloneDeepSafe(this.innerJoinOnStatements);
-        this.fleshOutJoinStatements(innerJoinDreamClasses, innerJoinStatements, innerJoinOnStatements, null, [...args]);
-        return this.clone({ innerJoinDreamClasses, innerJoinStatements, innerJoinOnStatements });
+        const innerJoinAndStatements = cloneDeepSafe(this.innerJoinAndStatements);
+        this.fleshOutJoinStatements(innerJoinDreamClasses, innerJoinStatements, innerJoinAndStatements, null, [...args]);
+        return this.clone({
+            innerJoinDreamClasses,
+            innerJoinStatements,
+            innerJoinAndStatements,
+        });
     }
     /**
      * @internal
      *
-     * @param args - A chain of association names and on/notOn/onAny clauses
+     * @param args - A chain of association names and and/andNot/andAny clauses
      * @returns A cloned Query with the joins clause applied
      */
     leftJoin(...args) {
         const innerJoinDreamClasses = [...this.innerJoinDreamClasses];
         const leftJoinStatements = cloneDeepSafe(this.leftJoinStatements);
-        const leftJoinOnStatements = cloneDeepSafe(this.leftJoinOnStatements);
-        this.fleshOutJoinStatements(innerJoinDreamClasses, leftJoinStatements, leftJoinOnStatements, null, [
+        const leftJoinAndStatements = cloneDeepSafe(this.leftJoinAndStatements);
+        this.fleshOutJoinStatements(innerJoinDreamClasses, leftJoinStatements, leftJoinAndStatements, null, [
             ...args,
         ]);
-        return this.clone({ innerJoinDreamClasses, leftJoinStatements, leftJoinOnStatements });
+        return this.clone({
+            innerJoinDreamClasses,
+            leftJoinStatements,
+            leftJoinAndStatements,
+        });
     }
     /**
      * @internal
      *
      */
-    fleshOutJoinStatements(innerJoinDreamClasses, joinStatements, joinOnStatements, previousAssociationName, associationStatements, previousDreamClass = this.dreamClass) {
+    fleshOutJoinStatements(innerJoinDreamClasses, joinStatements, joinAndStatements, previousAssociationName, associationStatements, previousDreamClass = this.dreamClass) {
         const nextAssociationStatement = associationStatements.shift();
         if (nextAssociationStatement === undefined) {
             // just satisfying typing
@@ -540,11 +548,11 @@ export default class Query extends ConnectedToDB {
             const nextStatement = nextAssociationStatement;
             if (!joinStatements[nextStatement])
                 joinStatements[protectAgainstPollutingAssignment(nextStatement)] = {};
-            if (!joinOnStatements[nextStatement])
-                joinOnStatements[protectAgainstPollutingAssignment(nextStatement)] = {};
+            if (!joinAndStatements[nextStatement])
+                joinAndStatements[protectAgainstPollutingAssignment(nextStatement)] = {};
             const nextDreamClass = this.addAssociatedDreamClassToInnerJoinDreamClasses(previousDreamClass, nextStatement, innerJoinDreamClasses);
             const nextJoinsStatements = joinStatements[nextStatement];
-            const nextJoinsOnStatements = joinOnStatements[nextStatement];
+            const nextJoinsOnStatements = joinAndStatements[nextStatement];
             this.fleshOutJoinStatements(innerJoinDreamClasses, nextJoinsStatements, nextJoinsOnStatements, nextStatement, associationStatements, nextDreamClass);
             //
         }
@@ -562,9 +570,9 @@ export default class Query extends ConnectedToDB {
             const clonedNextAssociationStatement = cloneDeepSafe(nextAssociationStatement);
             const keys = Object.keys(clonedNextAssociationStatement);
             keys.forEach((key) => {
-                joinOnStatements[protectAgainstPollutingAssignment(key)] = clonedNextAssociationStatement[key];
+                joinAndStatements[protectAgainstPollutingAssignment(key)] = clonedNextAssociationStatement[key];
             });
-            this.fleshOutJoinStatements(innerJoinDreamClasses, joinStatements, joinOnStatements, previousAssociationName, associationStatements, previousDreamClass);
+            this.fleshOutJoinStatements(innerJoinDreamClasses, joinStatements, joinAndStatements, previousAssociationName, associationStatements, previousDreamClass);
         }
     }
     /**
@@ -784,7 +792,7 @@ export default class Query extends ConnectedToDB {
      *   public localizedTexts: LocalizedText[]
      *
      *   @deco.HasOne('LocalizedText', {
-     *     on: { locale: DreamConst.passthrough },
+     *     and: { locale: DreamConst.passthrough },
      *   })
      *   public currentLocalizedText: LocalizedText
      * }
@@ -1953,11 +1961,11 @@ export default class Query extends ConnectedToDB {
             const value = preloadOnStatements[key];
             if (value === undefined)
                 throw new UnexpectedUndefined();
-            // filter out plain objects, but not ops and not on/notOn/onAny statements
+            // filter out plain objects, but not ops and not and/andNot/andAny statements
             // because plain objects are just the next level of nested preload
-            if (key === 'on' ||
-                key === 'notOn' ||
-                key === 'onAny' ||
+            if (key === 'and' ||
+                key === 'andNot' ||
+                key === 'andAny' ||
                 value === null ||
                 value.constructor !== Object) {
                 agg[key] = value;
@@ -2046,9 +2054,9 @@ export default class Query extends ConnectedToDB {
             }
         }
     }
-    applyOneJoin({ query, dreamClass, previousAssociationTableOrAlias, currentAssociationTableOrAlias, joinOnStatements = {}, throughAssociations = [], joinType, }) {
+    applyOneJoin({ query, dreamClass, previousAssociationTableOrAlias, currentAssociationTableOrAlias, joinAndStatements = {}, throughAssociations = [], joinType, }) {
         const { name, alias } = extractAssociationMetadataFromAssociationName(currentAssociationTableOrAlias);
-        const joinOnStatement = joinOnStatements[currentAssociationTableOrAlias];
+        const joinAndStatement = joinAndStatements[currentAssociationTableOrAlias];
         previousAssociationTableOrAlias = extractAssociationMetadataFromAssociationName(previousAssociationTableOrAlias).alias;
         currentAssociationTableOrAlias = alias;
         let association = dreamClass['getAssociationMetadata'](name);
@@ -2122,12 +2130,12 @@ export default class Query extends ConnectedToDB {
                 join = join.onRef(this.namespaceColumn(association.foreignKey(), previousAssociationTableOrAlias), '=', this.namespaceColumn(association.primaryKey(), currentAssociationTableOrAlias));
                 if (timeToApplyThroughAssociations) {
                     throughAssociations.forEach((throughAssociation) => {
-                        join = this.applyAssociationOnStatementsToJoinStatement({
+                        join = this.applyAssociationAndStatementsToJoinStatement({
                             join,
                             association: throughAssociation,
                             currentAssociationTableOrAlias,
                             previousAssociationTableOrAlias: originalPreviousAssociationTableOrAlias,
-                            joinOnStatements,
+                            joinAndStatements,
                         });
                     });
                 }
@@ -2136,7 +2144,7 @@ export default class Query extends ConnectedToDB {
                     tableNameOrAlias: currentAssociationTableOrAlias,
                     association,
                 });
-                join = this.applyJoinOnStatement(join, joinOnStatement, currentAssociationTableOrAlias);
+                join = this.applyJoinAndStatement(join, joinAndStatement, currentAssociationTableOrAlias);
                 return join;
             });
         }
@@ -2156,28 +2164,28 @@ export default class Query extends ConnectedToDB {
                 }
                 if (timeToApplyThroughAssociations) {
                     throughAssociations.forEach((throughAssociation) => {
-                        join = this.applyAssociationOnStatementsToJoinStatement({
+                        join = this.applyAssociationAndStatementsToJoinStatement({
                             join,
                             association: throughAssociation,
                             currentAssociationTableOrAlias,
                             previousAssociationTableOrAlias: originalPreviousAssociationTableOrAlias,
-                            joinOnStatements,
+                            joinAndStatements,
                         });
                     });
                 }
-                join = this.applyAssociationOnStatementsToJoinStatement({
+                join = this.applyAssociationAndStatementsToJoinStatement({
                     join,
                     association,
                     currentAssociationTableOrAlias,
                     previousAssociationTableOrAlias,
-                    joinOnStatements,
+                    joinAndStatements,
                 });
                 join = this.conditionallyApplyDefaultScopesDependentOnAssociation({
                     join,
                     tableNameOrAlias: currentAssociationTableOrAlias,
                     association,
                 });
-                join = this.applyJoinOnStatement(join, joinOnStatement, currentAssociationTableOrAlias);
+                join = this.applyJoinAndStatement(join, joinAndStatement, currentAssociationTableOrAlias);
                 return join;
             });
             if (association.type === 'HasMany') {
@@ -2204,29 +2212,29 @@ export default class Query extends ConnectedToDB {
             currentAssociationTableOrAlias,
         };
     }
-    applyAssociationOnStatementsToJoinStatement({ join, currentAssociationTableOrAlias, previousAssociationTableOrAlias, association, joinOnStatements, }) {
-        if (association.on) {
-            this.throwUnlessAllRequiredWhereClausesProvided(association, currentAssociationTableOrAlias, joinOnStatements);
-            join = join.on((eb) => this.whereStatementToExpressionWrapper(eb, this.aliasWhereStatement(association.on, currentAssociationTableOrAlias), { disallowSimilarityOperator: false }));
+    applyAssociationAndStatementsToJoinStatement({ join, currentAssociationTableOrAlias, previousAssociationTableOrAlias, association, joinAndStatements, }) {
+        if (association.and) {
+            this.throwUnlessAllRequiredWhereClausesProvided(association, currentAssociationTableOrAlias, joinAndStatements);
+            join = join.on((eb) => this.whereStatementToExpressionWrapper(eb, this.aliasWhereStatement(association.and, currentAssociationTableOrAlias), { disallowSimilarityOperator: false }));
         }
-        if (association.notOn) {
-            join = join.on((eb) => this.whereStatementToExpressionWrapper(eb, this.aliasWhereStatement(association.notOn, currentAssociationTableOrAlias), { negate: true }));
+        if (association.andNot) {
+            join = join.on((eb) => this.whereStatementToExpressionWrapper(eb, this.aliasWhereStatement(association.andNot, currentAssociationTableOrAlias), { negate: true }));
         }
-        if (association.onAny) {
-            join = join.on((eb) => eb.or(association.onAny.map(whereAnyStatement => this.whereStatementToExpressionWrapper(eb, this.aliasWhereStatement(whereAnyStatement, currentAssociationTableOrAlias), { disallowSimilarityOperator: false }))));
+        if (association.andAny) {
+            join = join.on((eb) => eb.or(association.andAny.map(whereAnyStatement => this.whereStatementToExpressionWrapper(eb, this.aliasWhereStatement(whereAnyStatement, currentAssociationTableOrAlias), { disallowSimilarityOperator: false }))));
         }
-        if (association.selfOn) {
+        if (association.selfAnd) {
             join = join.on((eb) => this.whereStatementToExpressionWrapper(eb, this.rawifiedSelfOnClause({
                 associationAlias: association.as,
                 selfAlias: previousAssociationTableOrAlias,
-                selfOnClause: association.selfOn,
+                selfAndClause: association.selfAnd,
             })));
         }
-        if (association.selfNotOn) {
+        if (association.selfAndNot) {
             join = join.on((eb) => this.whereStatementToExpressionWrapper(eb, this.rawifiedSelfOnClause({
                 associationAlias: association.as,
                 selfAlias: previousAssociationTableOrAlias,
-                selfOnClause: association.selfNotOn,
+                selfAndClause: association.selfAndNot,
             }), { negate: true }));
         }
         return join;
@@ -2261,22 +2269,22 @@ export default class Query extends ConnectedToDB {
             return this.namespaceColumn(foreignKey, tableNameOrAlias);
         return this.namespaceColumn(association.distinct, tableNameOrAlias);
     }
-    recursivelyJoin({ query, joinsStatement, joinOnStatements, dreamClass, previousAssociationTableOrAlias, joinType, }) {
-        for (const currentAssociationTableOrAlias of Object.keys(joinsStatement)) {
+    recursivelyJoin({ query, joinStatement, joinAndStatements, dreamClass, previousAssociationTableOrAlias, joinType, }) {
+        for (const currentAssociationTableOrAlias of Object.keys(joinStatement)) {
             const results = this.applyOneJoin({
                 query,
                 dreamClass,
                 previousAssociationTableOrAlias,
                 currentAssociationTableOrAlias,
-                joinOnStatements,
+                joinAndStatements,
                 joinType,
             });
             query = results.query;
             const association = results.association;
             query = this.recursivelyJoin({
                 query,
-                joinsStatement: joinsStatement[currentAssociationTableOrAlias],
-                joinOnStatements: joinOnStatements[currentAssociationTableOrAlias],
+                joinStatement: joinStatement[currentAssociationTableOrAlias],
+                joinAndStatements: joinAndStatements[currentAssociationTableOrAlias],
                 dreamClass: association.modelCB(),
                 previousAssociationTableOrAlias: currentAssociationTableOrAlias,
                 joinType,
@@ -2284,16 +2292,16 @@ export default class Query extends ConnectedToDB {
         }
         return query;
     }
-    throwUnlessAllRequiredWhereClausesProvided(association, namespace, joinOnStatements) {
-        const whereStatement = association.on;
-        const columnsRequiringWhereStatements = Object.keys(whereStatement).reduce((agg, column) => {
-            if (whereStatement[column] === DreamConst.required)
+    throwUnlessAllRequiredWhereClausesProvided(association, namespace, joinAndStatements) {
+        const andClause = association.and;
+        const columnsRequiringAndStatements = Object.keys(andClause).reduce((agg, column) => {
+            if (andClause[column] === DreamConst.required)
                 agg.push(column);
             return agg;
         }, []);
-        const missingRequiredWhereStatements = columnsRequiringWhereStatements.filter(column => joinOnStatements[namespace]?.on?.[column] === undefined);
+        const missingRequiredWhereStatements = columnsRequiringAndStatements.filter(column => joinAndStatements[namespace]?.and?.[column] === undefined);
         if (missingRequiredWhereStatements.length)
-            throw new MissingRequiredAssociationOnClause(association, missingRequiredWhereStatements[0]);
+            throw new MissingRequiredAssociationAndClause(association, missingRequiredWhereStatements[0]);
     }
     applyOrderStatementForAssociation({ query, tableNameOrAlias, association, }) {
         if (!query.orderBy)
@@ -2421,7 +2429,7 @@ export default class Query extends ConnectedToDB {
         else if (val === DreamConst.passthrough) {
             const column = attr.split('.').pop();
             if (this.passthroughOnStatement[column] === undefined)
-                throw new MissingRequiredPassthroughForAssociationOnClause(column);
+                throw new MissingRequiredPassthroughForAssociationAndClause(column);
             val = this.passthroughOnStatement[column];
         }
         if (val === null) {
@@ -2488,36 +2496,36 @@ export default class Query extends ConnectedToDB {
             throw new CannotPassUndefinedAsAValueToAWhereClause(this.dreamClass, a2);
         return { a, b, c, a2, b2, c2 };
     }
-    applyJoinOnStatement(join, joinOnStatement, rootTableOrAssociationAlias) {
-        if (!joinOnStatement)
+    applyJoinAndStatement(join, joinAndStatement, rootTableOrAssociationAlias) {
+        if (!joinAndStatement)
             return join;
-        join = this._applyJoinOnStatements(join, joinOnStatement.on, rootTableOrAssociationAlias);
-        join = this._applyJoinOnStatements(join, joinOnStatement.notOn, rootTableOrAssociationAlias, {
+        join = this._applyJoinAndStatements(join, joinAndStatement.and, rootTableOrAssociationAlias);
+        join = this._applyJoinAndStatements(join, joinAndStatement.andNot, rootTableOrAssociationAlias, {
             negate: true,
         });
-        join = this._applyJoinOnAnyStatements(join, joinOnStatement.onAny, rootTableOrAssociationAlias);
+        join = this._applyJoinAndAnyStatements(join, joinAndStatement.andAny, rootTableOrAssociationAlias);
         return join;
     }
-    _applyJoinOnStatements(join, joinOnStatement, rootTableOrAssociationAlias, { negate = false, } = {}) {
-        if (!joinOnStatement)
+    _applyJoinAndStatements(join, joinAndStatement, rootTableOrAssociationAlias, { negate = false, } = {}) {
+        if (!joinAndStatement)
             return join;
-        return join.on((eb) => this.joinOnStatementToExpressionWrapper(joinOnStatement, rootTableOrAssociationAlias, eb, {
+        return join.on((eb) => this.joinAndStatementToExpressionWrapper(joinAndStatement, rootTableOrAssociationAlias, eb, {
             negate,
             disallowSimilarityOperator: negate,
         }));
     }
-    _applyJoinOnAnyStatements(join, joinOnAnyStatement, rootTableOrAssociationAlias) {
-        if (!joinOnAnyStatement)
+    _applyJoinAndAnyStatements(join, joinAndAnyStatement, rootTableOrAssociationAlias) {
+        if (!joinAndAnyStatement)
             return join;
-        if (!joinOnAnyStatement.length)
+        if (!joinAndAnyStatement.length)
             return join;
         return join.on((eb) => {
-            return eb.or(joinOnAnyStatement.map(joinOnStatement => this.joinOnStatementToExpressionWrapper(joinOnStatement, rootTableOrAssociationAlias, eb)));
+            return eb.or(joinAndAnyStatement.map(joinAndStatement => this.joinAndStatementToExpressionWrapper(joinAndStatement, rootTableOrAssociationAlias, eb)));
         });
     }
-    joinOnStatementToExpressionWrapper(joinOnStatement, rootTableOrAssociationAlias, eb, { negate = false, disallowSimilarityOperator = true, } = {}) {
-        return this.whereStatementToExpressionWrapper(eb, Object.keys(joinOnStatement).reduce((agg, key) => {
-            agg[this.namespaceColumn(key.toString(), rootTableOrAssociationAlias)] = joinOnStatement[key];
+    joinAndStatementToExpressionWrapper(joinAndStatement, rootTableOrAssociationAlias, eb, { negate = false, disallowSimilarityOperator = true, } = {}) {
+        return this.whereStatementToExpressionWrapper(eb, Object.keys(joinAndStatement).reduce((agg, key) => {
+            agg[this.namespaceColumn(key.toString(), rootTableOrAssociationAlias)] = joinAndStatement[key];
             return agg;
         }, {}), {
             negate,
@@ -2530,8 +2538,8 @@ export default class Query extends ConnectedToDB {
         if (!isEmpty(query.innerJoinStatements)) {
             kyselyQuery = query.recursivelyJoin({
                 query: kyselyQuery,
-                joinsStatement: query.innerJoinStatements,
-                joinOnStatements: query.innerJoinOnStatements,
+                joinStatement: query.innerJoinStatements,
+                joinAndStatements: query.innerJoinAndStatements,
                 dreamClass: query.dreamClass,
                 previousAssociationTableOrAlias: this.baseSqlAlias,
                 joinType: 'inner',
@@ -2540,8 +2548,8 @@ export default class Query extends ConnectedToDB {
         if (!isEmpty(query.leftJoinStatements)) {
             kyselyQuery = query.recursivelyJoin({
                 query: kyselyQuery,
-                joinsStatement: query.leftJoinStatements,
-                joinOnStatements: query.leftJoinOnStatements,
+                joinStatement: query.leftJoinStatements,
+                joinAndStatements: query.leftJoinAndStatements,
                 dreamClass: query.dreamClass,
                 previousAssociationTableOrAlias: this.baseSqlAlias,
                 joinType: 'left',
@@ -2577,11 +2585,11 @@ export default class Query extends ConnectedToDB {
             return aliasedWhere;
         }, {});
     }
-    rawifiedSelfOnClause({ associationAlias, selfAlias, selfOnClause, }) {
+    rawifiedSelfOnClause({ associationAlias, selfAlias, selfAndClause, }) {
         const alphanumericUnderscoreRegexp = /[^a-zA-Z0-9_]/g;
         selfAlias = selfAlias.replace(alphanumericUnderscoreRegexp, '');
-        return Object.keys(selfOnClause).reduce((acc, key) => {
-            const selfColumn = selfOnClause[key]?.replace(alphanumericUnderscoreRegexp, '');
+        return Object.keys(selfAndClause).reduce((acc, key) => {
+            const selfColumn = selfAndClause[key]?.replace(alphanumericUnderscoreRegexp, '');
             if (!selfColumn)
                 return acc;
             acc[this.namespaceColumn(key, associationAlias)] = sql.raw(`"${snakeify(selfAlias)}"."${snakeify(selfColumn)}"`);
@@ -2659,7 +2667,7 @@ export default class Query extends ConnectedToDB {
         return new SimilarityBuilder(this.dreamInstance, {
             where: [...this.whereStatements],
             whereNot: [...this.whereNotStatements],
-            joinOnStatements: this.innerJoinOnStatements,
+            joinAndStatements: this.innerJoinAndStatements,
             transaction: this.dreamTransaction,
             connection: this.connectionOverride,
         });

package/dist/esm/src/dream/internal/associations/associationQuery.js

@@ -1,5 +1,5 @@
 import applyScopeBypassingSettingsToQuery from '../applyScopeBypassingSettingsToQuery.js';
-export default function associationQuery(dream, txn = null, associationName, { joinOnStatements, bypassAllDefaultScopes, defaultScopesToBypass, }) {
+export default function associationQuery(dream, txn = null, associationName, { joinAndStatements, bypassAllDefaultScopes, defaultScopesToBypass, }) {
     const association = dream['associationMetadataMap']()[associationName];
     const associationClass = association.modelCB();
     const dreamClass = dream.constructor;
@@ -7,8 +7,8 @@ export default function associationQuery(dream, txn = null, associationName, { j
     let baseSelectQuery = dreamClassOrTransaction.where({
         [dream.primaryKey]: dream.primaryKeyValue,
     });
-    if (joinOnStatements && (joinOnStatements.on || joinOnStatements.notOn || joinOnStatements.onAny))
-        baseSelectQuery = baseSelectQuery.innerJoin(association.as, joinOnStatements);
+    if (joinAndStatements && (joinAndStatements.and || joinAndStatements.andNot || joinAndStatements.andAny))
+        baseSelectQuery = baseSelectQuery.innerJoin(association.as, joinAndStatements);
     else
         baseSelectQuery = baseSelectQuery.innerJoin(association.as);
     let query = txn ? associationClass.txn(txn).queryInstance() : associationClass.query();

package/dist/esm/src/dream/internal/associations/associationUpdateQuery.js

@@ -1,7 +1,7 @@
 import UnexpectedUndefined from '../../../errors/UnexpectedUndefined.js';
 import namespaceColumn from '../../../helpers/namespaceColumn.js';
 import applyScopeBypassingSettingsToQuery from '../applyScopeBypassingSettingsToQuery.js';
-export default function associationUpdateQuery(dream, txn = null, associationName, { joinOnStatements, bypassAllDefaultScopes, defaultScopesToBypass, }) {
+export default function associationUpdateQuery(dream, txn = null, associationName, { joinAndStatements, bypassAllDefaultScopes, defaultScopesToBypass, }) {
     const association = dream['associationMetadataMap']()[associationName];
     if (association === undefined)
         throw new UnexpectedUndefined();
@@ -17,8 +17,8 @@ export default function associationUpdateQuery(dream, txn = null, associationNam
         bypassAllDefaultScopes,
         defaultScopesToBypass,
     });
-    if (joinOnStatements && (joinOnStatements.on || joinOnStatements.notOn || joinOnStatements.onAny))
-        nestedScope = nestedScope.innerJoin(association.as, joinOnStatements);
+    if (joinAndStatements && (joinAndStatements.and || joinAndStatements.andNot || joinAndStatements.andAny))
+        nestedScope = nestedScope.innerJoin(association.as, joinAndStatements);
     else
         nestedScope = nestedScope.innerJoin(association.as);
     const nestedSelect = nestedScope

package/dist/esm/src/dream/internal/associations/destroyAssociation.js

@@ -1,7 +1,7 @@
 import associationUpdateQuery from './associationUpdateQuery.js';
-export default async function destroyAssociation(dream, txn = null, associationName, { joinOnStatements, bypassAllDefaultScopes, defaultScopesToBypass, cascade, reallyDestroy, skipHooks, }) {
+export default async function destroyAssociation(dream, txn = null, associationName, { joinAndStatements, bypassAllDefaultScopes, defaultScopesToBypass, cascade, reallyDestroy, skipHooks, }) {
     const query = associationUpdateQuery(dream, txn, associationName, {
-        joinOnStatements,
+        joinAndStatements,
         bypassAllDefaultScopes,
         defaultScopesToBypass,
     });

package/dist/esm/src/dream/internal/associations/undestroyAssociation.js

@@ -1,7 +1,7 @@
 import associationUpdateQuery from './associationUpdateQuery.js';
-export default async function undestroyAssociation(dream, txn = null, associationName, { joinOnStatements, bypassAllDefaultScopes, defaultScopesToBypass, cascade, skipHooks, }) {
+export default async function undestroyAssociation(dream, txn = null, associationName, { joinAndStatements, bypassAllDefaultScopes, defaultScopesToBypass, cascade, skipHooks, }) {
     const query = associationUpdateQuery(dream, txn, associationName, {
-        joinOnStatements,
+        joinAndStatements,
         bypassAllDefaultScopes,
         defaultScopesToBypass,
     });

package/dist/esm/src/dream/internal/similarity/SimilarityBuilder.js

@@ -11,12 +11,12 @@ import similarityWhereSql from './similarityWhereSql.js';
 export default class SimilarityBuilder extends ConnectedToDB {
     whereStatement;
     whereNotStatement;
-    joinOnStatements = Object.freeze({});
+    joinAndStatements = Object.freeze({});
     constructor(dreamInstance, opts = {}) {
         super(dreamInstance, opts);
         this.whereStatement = Object.freeze(opts.where || []);
         this.whereNotStatement = Object.freeze(opts.whereNot || []);
-        this.joinOnStatements = Object.freeze(opts.joinOnStatements || {});
+        this.joinAndStatements = Object.freeze(opts.joinAndStatements || {});
     }
     /*
     #select
@@ -70,11 +70,11 @@ export default class SimilarityBuilder extends ConnectedToDB {
                 bypassOrder,
             });
         });
-        this.joinOnStatementsWithSimilarityClauses().forEach((similarityStatement, index) => {
+        this.joinAndStatementsWithSimilarityClauses().forEach((similarityStatement, index) => {
             kyselyQuery = this.addStatementToSelectQuery({
                 kyselyQuery,
                 similarityStatement,
-                statementType: 'on',
+                statementType: 'join_and',
                 index,
                 bypassOrder,
             });
@@ -145,11 +145,11 @@ export default class SimilarityBuilder extends ConnectedToDB {
                 index,
             });
         });
-        this.joinOnStatementsWithSimilarityClauses().forEach((similarityStatement, index) => {
+        this.joinAndStatementsWithSimilarityClauses().forEach((similarityStatement, index) => {
             kyselyQuery = this.addStatementToUpdateQuery({
                 kyselyQuery,
                 similarityStatement,
-                statementType: 'on',
+                statementType: 'join_and',
                 index,
             });
         });
@@ -164,8 +164,8 @@ export default class SimilarityBuilder extends ConnectedToDB {
     whereNotStatementsWithSimilarityClauses() {
         return this.similarityStatementFilter(this.whereNotStatement);
     }
-    joinOnStatementsWithSimilarityClauses() {
-        return this.recursiveJoinsOnFinder(removeOnFromObjectHierarchy(this.joinOnStatements), this.dreamClass);
+    joinAndStatementsWithSimilarityClauses() {
+        return this.recursiveJoinsOnFinder(removeJoinAndFromObjectHierarchy(this.joinAndStatements), this.dreamClass);
     }
     recursiveJoinsOnFinder(obj, dreamClass) {
         const similar = [];
@@ -207,7 +207,7 @@ export default class SimilarityBuilder extends ConnectedToDB {
         return [
             ...this.whereStatementsWithSimilarityClauses(),
             ...this.whereNotStatementsWithSimilarityClauses(),
-            ...this.joinOnStatementsWithSimilarityClauses(),
+            ...this.joinAndStatementsWithSimilarityClauses(),
         ];
     }
     addStatementToSelectQuery({ kyselyQuery, similarityStatement, index, statementType, bypassOrder, }) {
@@ -308,15 +308,15 @@ export default class SimilarityBuilder extends ConnectedToDB {
         return `${statementType}_rank_${statementIndex + 1}`;
     }
 }
-export const SIMILARITY_TYPES = ['where', 'on'];
-function removeOnFromObjectHierarchy(obj) {
+export const SIMILARITY_TYPES = ['where', 'join_and'];
+function removeJoinAndFromObjectHierarchy(obj) {
     if (obj?.isOpsStatement)
         return obj;
     const result = {};
     for (const key in obj) {
         if (Object.prototype.hasOwnProperty.call(obj, key)) {
             if (isObject(obj[key])) {
-                result[key] = removeOnFromObjectHierarchy(obj[key].on || obj[key]);
+                result[key] = removeJoinAndFromObjectHierarchy(obj[key].and || obj[key]);
             }
             else {
                 result[key] = obj[key];

package/dist/esm/src/errors/{CannotDefineAssociationWithBothDependentAndRequiredOnClause.js → CannotDefineAssociationWithBothDependentAndRequiredAndClause.js}

@@ -1,4 +1,4 @@
-export default class CannotDefineAssociationWithBothDependentAndRequiredOnClause extends Error {
+export default class CannotDefineAssociationWithBothDependentAndRequiredAndClause extends Error {
     dreamClass;
     associationName;
     constructor(dreamClass, associationName) {

package/dist/esm/src/errors/associations/{MissingRequiredAssociationOnClause.js → MissingRequiredAssociationAndClause.js}

@@ -1,4 +1,4 @@
-export default class MissingRequiredAssociationOnClause extends Error {
+export default class MissingRequiredAssociationAndClause extends Error {
     association;
     column;
     constructor(association, column) {
@@ -8,9 +8,9 @@ export default class MissingRequiredAssociationOnClause extends Error {
     }
     get message() {
         return `
-Missing required association on clause:
+Missing required association and-clause:
 Association: ${this.association.as}
-Missing on clause for column: ${this.column}
+Missing and-clause for column: ${this.column}
 `;
     }
 }

package/dist/esm/src/errors/associations/MissingRequiredPassthroughForAssociationAndClause.js

@@ -0,0 +1,13 @@
+export default class MissingRequiredPassthroughForAssociationAndClause extends Error {
+    column;
+    constructor(column) {
+        super();
+        this.column = column;
+    }
+    get message() {
+        return `
+Missing passthrough for association and-clause:
+Missing passthrough and-clause for column: ${this.column}
+`;
+    }
+}