@rvoh/dream 0.36.4 → 0.37.4

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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}
+`;
+    }
+}
+exports.default = MissingRequiredPassthroughForAssociationAndClause;

package/dist/cjs/src/helpers/cli/SchemaBuilder.js

@@ -259,7 +259,7 @@ may need to update the table getter in the corresponding Dream.
                     throw new FailedToIdentifyAssociation_js_1.default(model, associationMetaData.type, associationName, associationMetaData.globalAssociationNameOrNames);
                 const optional = associationMetaData.type === 'BelongsTo' ? associationMetaData.optional === true : null;
                 const where = associationMetaData.type === 'HasMany' || associationMetaData.type === 'HasOne'
-                    ? associationMetaData.on || null
+                    ? associationMetaData.and || null
                     : null;
                 // NOTE
                 // this try-catch is here because the SchemaBuilder currently needs to be run twice to generate foreignKey

package/dist/esm/src/Dream.js

@@ -2553,7 +2553,9 @@ export default class Dream {
      *
      * @param associationName - The name of the association to destroy
      * @param options - Options for destroying the association
-     * @param options.on - Optional where statement to apply to query before destroying
+     * @param options.and - Optional and statement to apply to query before destroying
+     * @param options.andNot - Optional andNot statement to apply to query before destroying
+     * @param options.andAny - Optional andAny statement to apply to query before destroying
      * @param options.skipHooks - If true, skips applying model hooks during the destroy operation. Defaults to false
      * @param options.cascade - If false, skips destroying associations marked `dependent: 'destroy'`. Defaults to true
      * @param options.bypassAllDefaultScopes - If true, bypasses all default scopes when destroying the association. Defaults to false
@@ -2565,10 +2567,10 @@ export default class Dream {
             throw new CannotDestroyAssociationOnUnpersistedDream(this, associationName);
         return await destroyAssociation(this, null, associationName, {
             ...destroyOptions(options),
-            joinOnStatements: {
-                on: options?.on,
-                notOn: options?.notOn,
-                onAny: options?.onAny,
+            joinAndStatements: {
+                and: options?.and,
+                andNot: options?.andNot,
+                andAny: options?.andAny,
             },
         });
     }
@@ -2587,7 +2589,9 @@ export default class Dream {
      *
      * @param associationName - The name of the association to destroy
      * @param options - Options for destroying the association
-     * @param options.on - Optional where statement to apply to query before destroying
+     * @param options.and - Optional and statement to apply to query before destroying
+     * @param options.andNot - Optional andNot statement to apply to query before destroying
+     * @param options.andAny - Optional andAny statement to apply to query before destroying
      * @param options.skipHooks - If true, skips applying model hooks during the destroy operation. Defaults to false
      * @param options.cascade - If true, cascades the destroy operation to associations marked with `dependent: 'destroy'`. Defaults to true
      * @param options.bypassAllDefaultScopes - If true, bypasses all default scopes when destroying the association. Defaults to false
@@ -2599,10 +2603,10 @@ export default class Dream {
             throw new CannotDestroyAssociationOnUnpersistedDream(this, associationName);
         return await destroyAssociation(this, null, associationName, {
             ...reallyDestroyOptions(options),
-            joinOnStatements: {
-                on: options?.on,
-                notOn: options?.notOn,
-                onAny: options?.onAny,
+            joinAndStatements: {
+                and: options?.and,
+                andNot: options?.andNot,
+                andAny: options?.andAny,
             },
         });
     }
@@ -2618,7 +2622,9 @@ export default class Dream {
      *
      * @param associationName - The name of the association to undestroy
      * @param options - Options for undestroying the association
-     * @param options.on - Optional where statement to apply to query before undestroying
+     * @param options.and - Optional and statement to apply to query before undestroying
+     * @param options.andNot - Optional andNot statement to apply to query before undestroying
+     * @param options.andAny - Optional andAny statement to apply to query before undestroying
      * @param options.skipHooks - If true, skips applying model hooks during the undestroy operation. Defaults to false
      * @param options.cascade - If false, skips undestroying associations marked `dependent: 'destroy'`. Defaults to true
      * @param options.bypassAllDefaultScopes - If true, bypasses all default scopes when undestroying the association. Defaults to false
@@ -2628,10 +2634,10 @@ export default class Dream {
     async undestroyAssociation(associationName, options) {
         return await undestroyAssociation(this, null, associationName, {
             ...undestroyOptions(options),
-            joinOnStatements: {
-                on: options?.on,
-                notOn: options?.notOn,
-                onAny: options?.onAny,
+            joinAndStatements: {
+                and: options?.and,
+                andNot: options?.andNot,
+                andAny: options?.andAny,
             },
         });
     }
@@ -2647,11 +2653,11 @@ export default class Dream {
      * @returns A Query scoped to the specified association on the current instance
      *
      */
-    associationQuery(associationName, joinOnStatements) {
+    associationQuery(associationName, joinAndStatements) {
         if (this.isNewRecord)
             throw new CannotAssociationQueryOnUnpersistedDream(this, associationName);
         return associationQuery(this, null, associationName, {
-            joinOnStatements: joinOnStatements,
+            joinAndStatements: joinAndStatements,
             bypassAllDefaultScopes: DEFAULT_BYPASS_ALL_DEFAULT_SCOPES,
             defaultScopesToBypass: DEFAULT_DEFAULT_SCOPES_TO_BYPASS,
         });
@@ -2665,14 +2671,14 @@ export default class Dream {
      * ```ts
      * await user.createAssociation('posts', { body: 'hello world' })
      * await user.createAssociation('posts', { body: 'howyadoin' })
-     * await user.updateAssociation('posts', { body: 'goodbye world' }, { on: { body: 'hello world' }})
+     * await user.updateAssociation('posts', { body: 'goodbye world' }, { and: { body: 'hello world' }})
      * // 1
      * ```
      *
      * @param associationName - The name of the association to update
      * @param attributes - The attributes to update on the association
      * @param options - Options for updating the association
-     * @param options.on - Optional on statement to apply to query before updating
+     * @param options.and - Optional on statement to apply to query before updating
      * @param options.skipHooks - If true, skips applying model hooks during the update operation. Defaults to false
      * @param options.bypassAllDefaultScopes - If true, bypasses all default scopes when updating the association. Defaults to false
      * @param options.defaultScopesToBypass - An array of default scope names to bypass when updating the association. Defaults to an empty array
@@ -2682,10 +2688,10 @@ export default class Dream {
         if (this.isNewRecord)
             throw new CannotUpdateAssociationOnUnpersistedDream(this, associationName);
         return associationUpdateQuery(this, null, associationName, {
-            joinOnStatements: {
-                on: updateAssociationOptions?.on,
-                notOn: updateAssociationOptions?.notOn,
-                onAny: updateAssociationOptions?.onAny,
+            joinAndStatements: {
+                and: updateAssociationOptions?.and,
+                andNot: updateAssociationOptions?.andNot,
+                andAny: updateAssociationOptions?.andAny,
             },
             bypassAllDefaultScopes: updateAssociationOptions?.bypassAllDefaultScopes ?? DEFAULT_BYPASS_ALL_DEFAULT_SCOPES,
             defaultScopesToBypass: updateAssociationOptions?.defaultScopesToBypass ?? DEFAULT_DEFAULT_SCOPES_TO_BYPASS,

package/dist/esm/src/decorators/field/association/HasMany.js

@@ -21,21 +21,21 @@ import { applyGetterAndSetter, associationPrimaryKeyAccessors, blankAssociations
  * @param opts.dependent - Can be either "destroy" or undefined. If "destroy", this record will be cascade deleted if the base model is destroyed.
  * @param opts.distinct - Can be a column name, or else a boolean. If a column name, a distinct clause will be applied to the column. If true, a distinct clause will be applied to the primary key.
  * @param opts.foreignKey - A custom column name to use for the foreign key.
- * @param opts.on - An on clause to be applied when this association is loaded
- * @param opts.notOn - A not on clause to be applied when this association is loaded
- * @param opts.onAny - An onAny clause to be applied when this association is loaded
+ * @param opts.and - An and-clause to be applied when this association is loaded
+ * @param opts.andNot - A not and-clause to be applied when this association is loaded
+ * @param opts.andAny - An andAny clause to be applied when this association is loaded
  * @param opts.order - A custom order statement to apply to this association.
  * @param opts.polymorphic - If true, this association will be treated as a polymorphic association.
  * @param opts.preloadThroughColumns - An array of columns to pluck off the through association attached to this association. Can only be set if `through` is also set.
  * @param opts.primaryKeyOverride - A custom column name to use for the primary key.
- * @param opts.selfOn - Adds an on clause to an association between a column on the associated model and a column on this model.
- * @param opts.selfNotOn - Adds a not on clause to an association between a column on the associated model and a column on this model.
+ * @param opts.selfAnd - Adds an and-clause to an association between a column on the associated model and a column on this model.
+ * @param opts.selfAndNot - Adds a not and-clause to an association between a column on the associated model and a column on this model.
  * @param opts.source - Used in conjunction with 'through' to specify the source association on a child model.
  * @param opts.through - If passed, this association will travel through another association.
  * @param opts.withoutDefaultScopes - A list of default scopes to bypass when loading this association
  */
 export default function HasMany(globalAssociationNameOrNames, opts = {}) {
-    const { dependent, distinct, foreignKey, on, notOn, onAny, order, polymorphic = false, preloadThroughColumns, primaryKeyOverride = null, selfOn, selfNotOn, source, through, withoutDefaultScopes, } = opts;
+    const { dependent, distinct, foreignKey, and, andNot, andAny, order, polymorphic = false, preloadThroughColumns, primaryKeyOverride = null, selfAnd, selfAndNot, source, through, withoutDefaultScopes, } = opts;
     return function (_, context) {
         const key = context.name;
         context.addInitializer(function () {
@@ -57,21 +57,21 @@ export default function HasMany(globalAssociationNameOrNames, opts = {}) {
                 dreamClass,
                 dependent: dependent ?? null,
                 methodName: key,
-                on: on ?? null,
+                and: and ?? null,
             });
             const partialAssociation = associationPrimaryKeyAccessors({
                 modelCB: () => lookupModelByGlobalNameOrNames(globalAssociationNameOrNames),
                 as: key,
                 dependent,
                 globalAssociationNameOrNames,
-                on,
-                notOn,
-                onAny,
+                and,
+                andNot,
+                andAny,
                 polymorphic,
                 preloadThroughColumns,
                 primaryKeyOverride,
-                selfOn,
-                selfNotOn,
+                selfAnd,
+                selfAndNot,
                 source: source || key,
                 type: 'HasMany',
                 withoutDefaultScopes,

package/dist/esm/src/decorators/field/association/HasOne.js

@@ -20,20 +20,20 @@ import { applyGetterAndSetter, associationPrimaryKeyAccessors, blankAssociations
  *
  * @param opts.dependent - Can be either "destroy" or undefined. If "destroy", this record will be cascade deleted if the base model is destroyed.
  * @param opts.foreignKey - A custom column name to use for the foreign key.
- * @param opts.on - An on clause to be applied when this association is loaded
- * @param opts.notOn - A not on clause to be applied when this association is loaded
- * @param opts.onAny - An onAny clause to be applied when this association is loaded
+ * @param opts.and - An and-clause to be applied when this association is loaded
+ * @param opts.andNot - A not and-clause to be applied when this association is loaded
+ * @param opts.andAny - An andAny clause to be applied when this association is loaded
  * @param opts.polymorphic - If true, this association will be treated as a polymorphic association.
  * @param opts.preloadThroughColumns - An array of columns to pluck off the through association attached to this association. Can only be set if `through` is also set.
  * @param opts.primaryKeyOverride - A custom column name to use for the primary key.
- * @param opts.selfOn - Adds an on clause to an association between a column on the associated model and a column on this model.
- * @param opts.selfNotOn - Adds a not on clause to an association between a column on the associated model and a column on this model.
+ * @param opts.selfAnd - Adds an and-clause to an association between a column on the associated model and a column on this model.
+ * @param opts.selfAndNot - Adds a not and-clause to an association between a column on the associated model and a column on this model.
  * @param opts.source - Used in conjunction with 'through' to specify the source association on a child model.
  * @param opts.through - If passed, this association will travel through another association.
  * @param opts.withoutDefaultScopes - A list of default scopes to bypass when loading this association
  */
 export default function HasOne(globalAssociationNameOrNames, opts = {}) {
-    const { dependent, foreignKey, on, notOn, onAny, polymorphic = false, preloadThroughColumns, primaryKeyOverride = null, selfOn, selfNotOn, source, through, withoutDefaultScopes, } = opts;
+    const { dependent, foreignKey, and, andNot, andAny, polymorphic = false, preloadThroughColumns, primaryKeyOverride = null, selfAnd, selfAndNot, source, through, withoutDefaultScopes, } = opts;
     return function (_, context) {
         const key = context.name;
         context.addInitializer(function () {
@@ -55,21 +55,21 @@ export default function HasOne(globalAssociationNameOrNames, opts = {}) {
                 dreamClass,
                 dependent: dependent ?? null,
                 methodName: key,
-                on: on ?? null,
+                and: and ?? null,
             });
             const partialAssociation = associationPrimaryKeyAccessors({
                 modelCB: () => lookupModelByGlobalNameOrNames(globalAssociationNameOrNames),
                 as: key,
                 dependent,
                 globalAssociationNameOrNames,
-                on,
-                notOn,
-                onAny,
+                and,
+                andNot,
+                andAny,
                 polymorphic,
                 preloadThroughColumns,
                 primaryKeyOverride,
-                selfOn,
-                selfNotOn,
+                selfAnd,
+                selfAndNot,
                 source: source || key,
                 through,
                 type: 'HasOne',

package/dist/esm/src/decorators/field/association/shared.js

@@ -3,7 +3,7 @@ import { DreamConst } from '../../../dream/constants.js';
 import { checkForeignKey } from '../../../errors/associations/InvalidComputedForeignKey.js';
 import NonLoadedAssociation from '../../../errors/associations/NonLoadedAssociation.js';
 import CannotDefineAssociationWithBothDependentAndPassthrough from '../../../errors/CannotDefineAssociationWithBothDependentAndPassthrough.js';
-import CannotDefineAssociationWithBothDependentAndRequiredOnClause from '../../../errors/CannotDefineAssociationWithBothDependentAndRequiredOnClause.js';
+import CannotDefineAssociationWithBothDependentAndRequiredAndClause from '../../../errors/CannotDefineAssociationWithBothDependentAndRequiredAndClause.js';
 import camelize from '../../../helpers/camelize.js';
 import freezeBaseClassArrayMap from '../../helpers/freezeBaseClassArrayMap.js';
 import associationToGetterSetterProp from './associationToGetterSetterProp.js';
@@ -113,11 +113,11 @@ association: ${this.as}
         },
     };
 }
-export function validateHasStatementArgs({ dreamClass, dependent, methodName, on, }) {
-    const hasPassthroughOn = Object.values(on || {}).find(val => val === DreamConst.passthrough);
-    const hasRequiredOn = Object.values(on || {}).find(val => val === DreamConst.required);
-    if (dependent && hasPassthroughOn)
+export function validateHasStatementArgs({ dreamClass, dependent, methodName, and, }) {
+    const hasPassthroughAnd = Object.values(and || {}).find(val => val === DreamConst.passthrough);
+    const hasRequiredAnd = Object.values(and || {}).find(val => val === DreamConst.required);
+    if (dependent && hasPassthroughAnd)
         throw new CannotDefineAssociationWithBothDependentAndPassthrough(dreamClass, methodName);
-    if (dependent && hasRequiredOn)
-        throw new CannotDefineAssociationWithBothDependentAndRequiredOnClause(dreamClass, methodName);
+    if (dependent && hasRequiredAnd)
+        throw new CannotDefineAssociationWithBothDependentAndRequiredAndClause(dreamClass, methodName);
 }

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

@@ -311,11 +311,11 @@ export default class DreamInstanceTransactionBuilder {
      *
      * @returns A Query scoped to the specified association on the current instance
      */
-    associationQuery(associationName, joinOnStatements) {
+    associationQuery(associationName, joinAndStatements) {
         if (this.dreamInstance.isNewRecord)
             throw new CannotAssociationQueryOnUnpersistedDream(this.dreamInstance, associationName);
         return associationQuery(this.dreamInstance, this.dreamTransaction, associationName, {
-            joinOnStatements: joinOnStatements,
+            joinAndStatements: joinAndStatements,
             bypassAllDefaultScopes: DEFAULT_BYPASS_ALL_DEFAULT_SCOPES,
             defaultScopesToBypass: DEFAULT_DEFAULT_SCOPES_TO_BYPASS,
         });
@@ -330,7 +330,7 @@ export default class DreamInstanceTransactionBuilder {
      * await ApplicationModel.transaction(async txn => {
      *   await user.txn(txn).createAssociation('posts', { body: 'hello world' })
      *   await user.txn(txn).createAssociation('posts', { body: 'howyadoin' })
-     *   await user.txn(txn).updateAssociation('posts', { body: 'goodbye world' }, { on: { body: 'hello world' }})
+     *   await user.txn(txn).updateAssociation('posts', { body: 'goodbye world' }, { and: { body: 'hello world' }})
      *   // 1
      * })
      * ```
@@ -348,10 +348,10 @@ export default class DreamInstanceTransactionBuilder {
         if (this.dreamInstance.isNewRecord)
             throw new CannotUpdateAssociationOnUnpersistedDream(this.dreamInstance, associationName);
         return await associationUpdateQuery(this.dreamInstance, this.dreamTransaction, associationName, {
-            joinOnStatements: {
-                on: updateAssociationOptions?.on,
-                notOn: updateAssociationOptions?.notOn,
-                onAny: updateAssociationOptions?.onAny,
+            joinAndStatements: {
+                and: updateAssociationOptions?.and,
+                andNot: updateAssociationOptions?.andNot,
+                andAny: updateAssociationOptions?.andAny,
             },
             bypassAllDefaultScopes: updateAssociationOptions?.bypassAllDefaultScopes ?? DEFAULT_BYPASS_ALL_DEFAULT_SCOPES,
             defaultScopesToBypass: updateAssociationOptions?.defaultScopesToBypass ?? DEFAULT_DEFAULT_SCOPES_TO_BYPASS,
@@ -383,13 +383,15 @@ export default class DreamInstanceTransactionBuilder {
      *
      * ```ts
      * await ApplicationModel.transaction(async txn => {
-     *   await user.txn(txn).destroyAssociation('posts', { on: { body: 'hello world' } })
+     *   await user.txn(txn).destroyAssociation('posts', { and: { body: 'hello world' } })
      * })
      * ```
      *
      * @param associationName - The name of the association to destroy
      * @param options - Options for destroying the association
-     * @param options.on - Optional where statement to apply to query before destroying
+     * @param options.and - Optional and statement to apply to query before destroying
+     * @param options.andNot - Optional andNot statement to apply to query before destroying
+     * @param options.andAny - Optional andAny statement to apply to query before destroying
      * @param options.skipHooks - If true, skips applying model hooks during the destroy operation. Defaults to false
      * @param options.cascade - If false, skips destroying associations marked `dependent: 'destroy'`. Defaults to true
      * @param options.bypassAllDefaultScopes - If true, bypasses all default scopes when destroying the association. Defaults to false
@@ -401,10 +403,10 @@ export default class DreamInstanceTransactionBuilder {
             throw new CannotDestroyAssociationOnUnpersistedDream(this.dreamInstance, associationName);
         return await destroyAssociation(this.dreamInstance, this.dreamTransaction, associationName, {
             ...destroyOptions(options),
-            joinOnStatements: {
-                on: options?.on,
-                notOn: options?.notOn,
-                onAny: options?.onAny,
+            joinAndStatements: {
+                and: options?.and,
+                andNot: options?.andNot,
+                andAny: options?.andAny,
             },
         });
     }
@@ -419,13 +421,15 @@ export default class DreamInstanceTransactionBuilder {
      *
      * ```ts
      * await ApplicationModel.transaction(async txn => {
-     *   await user.txn(txn).reallyDestroyAssociation('posts', { on: { body: 'hello world' } })
+     *   await user.txn(txn).reallyDestroyAssociation('posts', { and: { body: 'hello world' } })
      * })
      * ```
      *
      * @param associationName - The name of the association to destroy
      * @param options - Options for destroying the association
-     * @param options.on - Optional where statement to apply to query before destroying
+     * @param options.and - Optional and statement to apply to query before destroying
+     * @param options.andNot - Optional andNot statement to apply to query before destroying
+     * @param options.andAny - Optional andAny statement to apply to query before destroying
      * @param options.skipHooks - If true, skips applying model hooks during the destroy operation. Defaults to false
      * @param options.cascade - If true, cascades the destroy operation to associations marked with `dependent: 'destroy'`. Defaults to true
      * @param options.bypassAllDefaultScopes - If true, bypasses all default scopes when destroying the association. Defaults to false
@@ -437,10 +441,10 @@ export default class DreamInstanceTransactionBuilder {
             throw new CannotDestroyAssociationOnUnpersistedDream(this.dreamInstance, associationName);
         return await destroyAssociation(this.dreamInstance, this.dreamTransaction, associationName, {
             ...reallyDestroyOptions(options),
-            joinOnStatements: {
-                on: options?.on,
-                notOn: options?.notOn,
-                onAny: options?.onAny,
+            joinAndStatements: {
+                and: options?.and,
+                andNot: options?.andNot,
+                andAny: options?.andAny,
             },
         });
     }
@@ -451,12 +455,14 @@ export default class DreamInstanceTransactionBuilder {
      * will also be undeleted.
      *
      * ```ts
-     * await user.undestroyAssociation('posts', { on: { body: 'hello world' } })
+     * await user.undestroyAssociation('posts', { and: { body: 'hello world' } })
      * ```
      *
      * @param associationName - The name of the association to undestroy
      * @param options - Options for undestroying the association
-     * @param options.on - Optional where statement to apply to query before undestroying
+     * @param options.and - Optional and statement to apply to query before undestroying
+     * @param options.andNot - Optional andNot statement to apply to query before undestroying
+     * @param options.andAny - Optional andAny statement to apply to query before undestroying
      * @param options.skipHooks - If true, skips applying model hooks during the undestroy operation. Defaults to false
      * @param options.cascade - If false, skips undestroying associations marked `dependent: 'destroy'`. Defaults to true
      * @param options.bypassAllDefaultScopes - If true, bypasses all default scopes when undestroying the association. Defaults to false
@@ -466,10 +472,10 @@ export default class DreamInstanceTransactionBuilder {
     async undestroyAssociation(associationName, options) {
         return await undestroyAssociation(this.dreamInstance, this.dreamTransaction, associationName, {
             ...undestroyOptions(options),
-            joinOnStatements: {
-                on: options?.on,
-                notOn: options?.notOn,
-                onAny: options?.onAny,
+            joinAndStatements: {
+                and: options?.and,
+                andNot: options?.andNot,
+                andAny: options?.andAny,
             },
         });
     }