@rvoh/dream 0.36.3 → 0.37.4

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

@@ -257,7 +257,7 @@ may need to update the table getter in the corresponding Dream.
                     throw new FailedToIdentifyAssociation(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/serializer/index.js

@@ -253,18 +253,22 @@ export default class DreamSerializer {
 function unknownTypeToIsoDateString(date) {
     if (date === undefined)
         return undefined;
+    if (date === null)
+        return null;
     if (date instanceof CalendarDate || date instanceof DateTime)
         return date.toISODate();
-    return null;
+    return date;
 }
 function unknownTypeToIsoDatetimeString(dateTime) {
     if (dateTime === undefined)
         return undefined;
+    if (dateTime === null)
+        return null;
     if (dateTime instanceof CalendarDate)
         return DateTime.fromISO(dateTime.toISO()).toISO();
     if (dateTime instanceof DateTime)
         return dateTime.toISO();
-    return null;
+    return dateTime;
 }
 function unknownTypeToDecimal(decimalOrString, precision) {
     if (decimalOrString === undefined)

package/dist/types/src/Dream.d.ts

@@ -11,7 +11,7 @@ import LoadBuilder from './dream/LoadBuilder.js';
 import Query from './dream/Query.js';
 import { AssociationStatementsMap, PassthroughOnClause, WhereStatement } from './types/associations/shared.js';
 import { AssociationTableNames, DbConnectionType } from './types/db.js';
-import { AllDefaultScopeNames, AssociationNameToDream, AttributeKeys, DefaultOrNamedScopeName, DreamAssociationNames, DreamAssociationNamesWithoutRequiredOnClauses, DreamAttributes, DreamColumnNames, DreamParamSafeColumnNames, DreamSerializeOptions, IdType, JoinOnStatements, NextPreloadArgumentType, OrderDir, PassthroughColumnNames, PluckEachArgs, PrimaryKeyForFind, TableColumnNames, UpdateableAssociationProperties, UpdateableProperties, UpdateablePropertiesForClass } from './types/dream.js';
+import { AllDefaultScopeNames, AssociationNameToDream, AttributeKeys, DefaultOrNamedScopeName, DreamAssociationNames, DreamAssociationNamesWithoutRequiredOnClauses, DreamAttributes, DreamColumnNames, DreamParamSafeColumnNames, DreamSerializeOptions, IdType, JoinAndStatements, NextPreloadArgumentType, OrderDir, PassthroughColumnNames, PluckEachArgs, PrimaryKeyForFind, TableColumnNames, UpdateableAssociationProperties, UpdateableProperties, UpdateablePropertiesForClass } from './types/dream.js';
 import { HookStatement, HookStatementMap } from './types/lifecycle.js';
 import { BaseModelColumnTypes, DefaultQueryTypeOptions, FindEachOpts, QueryWithJoinedAssociationsType, QueryWithJoinedAssociationsTypeAndNoPreload } from './types/query.js';
 import { ValidationStatement, ValidationType } from './types/validation.js';
@@ -1925,24 +1925,24 @@ export default class Dream {
      * @returns The created association
      */
     createAssociation<I extends Dream, AssociationName extends DreamAssociationNames<I>, PossibleArrayAssociationType = I[AssociationName & keyof I], AssociationType = PossibleArrayAssociationType extends (infer ElementType)[] ? ElementType : PossibleArrayAssociationType, RestrictedAssociationType extends AssociationType extends Dream ? AssociationType : never = AssociationType extends Dream ? AssociationType : never>(this: I, associationName: AssociationName, attributes?: UpdateableAssociationProperties<I, RestrictedAssociationType>): Promise<NonNullable<AssociationType>>;
-    destroyAssociation<I extends Dream, DB extends I['DB'], TableName extends I['table'], Schema extends I['schema'], AssociationName extends DreamAssociationNames<I>, RequiredOnClauseKeysForThisAssociation extends RequiredOnClauseKeys<Schema, TableName, AssociationName>, AssociationDream extends AssociationNameToDream<I, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options: DestroyOptions<I> & JoinOnStatements<DB, Schema, AssociationTableName, RequiredOnClauseKeysForThisAssociation>): Promise<number>;
-    destroyAssociation<I extends Dream, DB extends I['DB'], Schema extends I['schema'], AssociationName extends DreamAssociationNamesWithoutRequiredOnClauses<I>, AssociationDream extends AssociationNameToDream<I, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options?: DestroyOptions<I> & JoinOnStatements<DB, Schema, AssociationTableName, null>): Promise<number>;
-    reallyDestroyAssociation<I extends Dream, DB extends I['DB'], TableName extends I['table'], Schema extends I['schema'], AssociationName extends DreamAssociationNames<I>, RequiredOnClauseKeysForThisAssociation extends RequiredOnClauseKeys<Schema, TableName, AssociationName>, AssociationDream extends AssociationNameToDream<I, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options: DestroyOptions<I> & JoinOnStatements<DB, Schema, AssociationTableName, RequiredOnClauseKeysForThisAssociation>): Promise<number>;
-    reallyDestroyAssociation<I extends Dream, DB extends I['DB'], Schema extends I['schema'], AssociationName extends DreamAssociationNamesWithoutRequiredOnClauses<I>, AssociationDream extends AssociationNameToDream<I, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options?: DestroyOptions<I> & JoinOnStatements<DB, Schema, AssociationTableName, null>): Promise<number>;
-    undestroyAssociation<I extends Dream, DB extends I['DB'], TableName extends I['table'], Schema extends I['schema'], AssociationName extends DreamAssociationNames<I>, RequiredOnClauseKeysForThisAssociation extends RequiredOnClauseKeys<Schema, TableName, AssociationName>, AssociationDream extends AssociationNameToDream<I, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options: DestroyOptions<I> & JoinOnStatements<DB, Schema, AssociationTableName, RequiredOnClauseKeysForThisAssociation>): Promise<number>;
-    undestroyAssociation<I extends Dream, DB extends I['DB'], Schema extends I['schema'], AssociationName extends DreamAssociationNamesWithoutRequiredOnClauses<I>, AssociationDream extends AssociationNameToDream<I, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options?: DestroyOptions<I> & JoinOnStatements<DB, Schema, AssociationTableName, null>): Promise<number>;
-    associationQuery<I extends Dream, DB extends I['DB'], TableName extends I['table'], Schema extends I['schema'], AssociationName extends DreamAssociationNames<I>, RequiredOnClauseKeysForThisAssociation extends RequiredOnClauseKeys<Schema, TableName, AssociationName>, AssociationDream extends AssociationNameToDream<I, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, joinOnStatements: JoinOnStatements<DB, Schema, AssociationTableName, RequiredOnClauseKeysForThisAssociation>): Query<AssociationDream, DefaultQueryTypeOptions<AssociationDream, AssociationName & string>>;
-    associationQuery<I extends Dream, DB extends I['DB'], Schema extends I['schema'], AssociationName extends DreamAssociationNamesWithoutRequiredOnClauses<I>, AssociationDream extends AssociationNameToDream<I, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, joinOnStatements?: JoinOnStatements<DB, Schema, AssociationTableName, null>): Query<AssociationDream, DefaultQueryTypeOptions<AssociationDream, AssociationName & string>>;
+    destroyAssociation<I extends Dream, DB extends I['DB'], TableName extends I['table'], Schema extends I['schema'], AssociationName extends DreamAssociationNames<I>, RequiredOnClauseKeysForThisAssociation extends RequiredOnClauseKeys<Schema, TableName, AssociationName>, AssociationDream extends AssociationNameToDream<I, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options: DestroyOptions<I> & JoinAndStatements<DB, Schema, AssociationTableName, RequiredOnClauseKeysForThisAssociation>): Promise<number>;
+    destroyAssociation<I extends Dream, DB extends I['DB'], Schema extends I['schema'], AssociationName extends DreamAssociationNamesWithoutRequiredOnClauses<I>, AssociationDream extends AssociationNameToDream<I, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options?: DestroyOptions<I> & JoinAndStatements<DB, Schema, AssociationTableName, null>): Promise<number>;
+    reallyDestroyAssociation<I extends Dream, DB extends I['DB'], TableName extends I['table'], Schema extends I['schema'], AssociationName extends DreamAssociationNames<I>, RequiredOnClauseKeysForThisAssociation extends RequiredOnClauseKeys<Schema, TableName, AssociationName>, AssociationDream extends AssociationNameToDream<I, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options: DestroyOptions<I> & JoinAndStatements<DB, Schema, AssociationTableName, RequiredOnClauseKeysForThisAssociation>): Promise<number>;
+    reallyDestroyAssociation<I extends Dream, DB extends I['DB'], Schema extends I['schema'], AssociationName extends DreamAssociationNamesWithoutRequiredOnClauses<I>, AssociationDream extends AssociationNameToDream<I, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options?: DestroyOptions<I> & JoinAndStatements<DB, Schema, AssociationTableName, null>): Promise<number>;
+    undestroyAssociation<I extends Dream, DB extends I['DB'], TableName extends I['table'], Schema extends I['schema'], AssociationName extends DreamAssociationNames<I>, RequiredOnClauseKeysForThisAssociation extends RequiredOnClauseKeys<Schema, TableName, AssociationName>, AssociationDream extends AssociationNameToDream<I, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options: DestroyOptions<I> & JoinAndStatements<DB, Schema, AssociationTableName, RequiredOnClauseKeysForThisAssociation>): Promise<number>;
+    undestroyAssociation<I extends Dream, DB extends I['DB'], Schema extends I['schema'], AssociationName extends DreamAssociationNamesWithoutRequiredOnClauses<I>, AssociationDream extends AssociationNameToDream<I, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options?: DestroyOptions<I> & JoinAndStatements<DB, Schema, AssociationTableName, null>): Promise<number>;
+    associationQuery<I extends Dream, DB extends I['DB'], TableName extends I['table'], Schema extends I['schema'], AssociationName extends DreamAssociationNames<I>, RequiredOnClauseKeysForThisAssociation extends RequiredOnClauseKeys<Schema, TableName, AssociationName>, AssociationDream extends AssociationNameToDream<I, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, joinAndStatements: JoinAndStatements<DB, Schema, AssociationTableName, RequiredOnClauseKeysForThisAssociation>): Query<AssociationDream, DefaultQueryTypeOptions<AssociationDream, AssociationName & string>>;
+    associationQuery<I extends Dream, DB extends I['DB'], Schema extends I['schema'], AssociationName extends DreamAssociationNamesWithoutRequiredOnClauses<I>, AssociationDream extends AssociationNameToDream<I, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, joinAndStatements?: JoinAndStatements<DB, Schema, AssociationTableName, null>): Query<AssociationDream, DefaultQueryTypeOptions<AssociationDream, AssociationName & string>>;
     updateAssociation<I extends Dream, DB extends I['DB'], TableName extends I['table'], Schema extends I['schema'], AssociationName extends DreamAssociationNames<I>, RequiredOnClauseKeysForThisAssociation extends RequiredOnClauseKeys<Schema, TableName, AssociationName>, AssociationDream extends AssociationNameToDream<I, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, attributes: Partial<DreamAttributes<AssociationNameToDream<I, AssociationName>>>, updateAssociationOptions: {
         bypassAllDefaultScopes?: boolean;
         defaultScopesToBypass?: AllDefaultScopeNames<I>[];
         skipHooks?: boolean;
-    } & JoinOnStatements<DB, Schema, AssociationTableName, RequiredOnClauseKeysForThisAssociation>): Promise<number>;
+    } & JoinAndStatements<DB, Schema, AssociationTableName, RequiredOnClauseKeysForThisAssociation>): Promise<number>;
     updateAssociation<I extends Dream, DB extends I['DB'], Schema extends I['schema'], AssociationName extends DreamAssociationNamesWithoutRequiredOnClauses<I>, AssociationDream extends AssociationNameToDream<I, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, attributes: Partial<DreamAttributes<AssociationNameToDream<I, AssociationName>>>, updateAssociationOptions?: {
         bypassAllDefaultScopes?: boolean;
         defaultScopesToBypass?: AllDefaultScopeNames<I>[];
         skipHooks?: boolean;
-    } & JoinOnStatements<DB, Schema, AssociationTableName, null>): Promise<number>;
+    } & JoinAndStatements<DB, Schema, AssociationTableName, null>): Promise<number>;
     /**
      * Sends data through for use as passthrough data
      * for the associations that require it.

package/dist/types/src/decorators/field/association/shared.d.ts

@@ -11,9 +11,9 @@ export declare function applyGetterAndSetter(target: Dream, partialAssociation:
     isBelongsTo?: boolean;
 }): void;
 export declare function associationPrimaryKeyAccessors(partialAssociation: Exclude<PartialAssociationStatement, 'primaryKey' | 'primaryKeyValue'>, dreamClass: typeof Dream): PartialAssociationStatement;
-export declare function validateHasStatementArgs({ dreamClass, dependent, methodName, on, }: {
+export declare function validateHasStatementArgs({ dreamClass, dependent, methodName, and, }: {
     dreamClass: typeof Dream;
     dependent: DependentOptions | null;
     methodName: string;
-    on: object | null;
+    and: object | null;
 }): void;

package/dist/types/src/dream/DreamInstanceTransactionBuilder.d.ts

@@ -1,5 +1,5 @@
 import Dream from '../Dream.js';
-import { AllDefaultScopeNames, AssociationNameToDream, DreamAssociationNames, DreamAssociationNamesWithoutRequiredOnClauses, DreamAttributes, JoinOnStatements, UpdateableAssociationProperties, UpdateableProperties } from '../types/dream.js';
+import { AllDefaultScopeNames, AssociationNameToDream, DreamAssociationNames, DreamAssociationNamesWithoutRequiredOnClauses, DreamAttributes, JoinAndStatements, UpdateableAssociationProperties, UpdateableProperties } from '../types/dream.js';
 import { DefaultQueryTypeOptions, QueryWithJoinedAssociationsType } from '../types/query.js';
 import { JoinedAssociation, JoinedAssociationsTypeFromAssociations, RequiredOnClauseKeys, VariadicJoinsArgs, VariadicLeftJoinLoadArgs, VariadicLoadArgs } from '../types/variadic.js';
 import DreamTransaction from './DreamTransaction.js';
@@ -273,18 +273,18 @@ export default class DreamInstanceTransactionBuilder<DreamInstance extends Dream
     save<I extends DreamInstanceTransactionBuilder<DreamInstance>>(this: I, { skipHooks }?: {
         skipHooks?: boolean;
     }): Promise<void>;
-    associationQuery<I extends DreamInstanceTransactionBuilder<DreamInstance>, DB extends DreamInstance['DB'], TableName extends DreamInstance['table'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNames<DreamInstance>, RequiredOnClauseKeysForThisAssociation extends RequiredOnClauseKeys<Schema, TableName, AssociationName>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, joinOnStatements: JoinOnStatements<DB, Schema, AssociationTableName, RequiredOnClauseKeysForThisAssociation>): Query<AssociationDream, DefaultQueryTypeOptions<AssociationDream, AssociationName & string>>;
-    associationQuery<I extends DreamInstanceTransactionBuilder<DreamInstance>, DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNamesWithoutRequiredOnClauses<DreamInstance>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, joinOnStatements?: JoinOnStatements<DB, Schema, AssociationTableName, null>): Query<AssociationDream, DefaultQueryTypeOptions<AssociationDream, AssociationName & string>>;
+    associationQuery<I extends DreamInstanceTransactionBuilder<DreamInstance>, DB extends DreamInstance['DB'], TableName extends DreamInstance['table'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNames<DreamInstance>, RequiredOnClauseKeysForThisAssociation extends RequiredOnClauseKeys<Schema, TableName, AssociationName>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, joinAndStatements: JoinAndStatements<DB, Schema, AssociationTableName, RequiredOnClauseKeysForThisAssociation>): Query<AssociationDream, DefaultQueryTypeOptions<AssociationDream, AssociationName & string>>;
+    associationQuery<I extends DreamInstanceTransactionBuilder<DreamInstance>, DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNamesWithoutRequiredOnClauses<DreamInstance>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, joinAndStatements?: JoinAndStatements<DB, Schema, AssociationTableName, null>): Query<AssociationDream, DefaultQueryTypeOptions<AssociationDream, AssociationName & string>>;
     updateAssociation<I extends DreamInstanceTransactionBuilder<DreamInstance>, DB extends DreamInstance['DB'], TableName extends DreamInstance['table'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNames<DreamInstance>, RequiredOnClauseKeysForThisAssociation extends RequiredOnClauseKeys<Schema, TableName, AssociationName>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, attributes: Partial<DreamAttributes<AssociationNameToDream<DreamInstance, AssociationName>>>, updateAssociationOptions: {
         bypassAllDefaultScopes?: boolean;
         defaultScopesToBypass?: AllDefaultScopeNames<DreamInstance>[];
         skipHooks?: boolean;
-    } & JoinOnStatements<DB, Schema, AssociationTableName, RequiredOnClauseKeysForThisAssociation>): Promise<number>;
+    } & JoinAndStatements<DB, Schema, AssociationTableName, RequiredOnClauseKeysForThisAssociation>): Promise<number>;
     updateAssociation<I extends DreamInstanceTransactionBuilder<DreamInstance>, DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNamesWithoutRequiredOnClauses<DreamInstance>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, attributes: Partial<DreamAttributes<AssociationNameToDream<DreamInstance, AssociationName>>>, updateAssociationOptions?: {
         bypassAllDefaultScopes?: boolean;
         defaultScopesToBypass?: AllDefaultScopeNames<DreamInstance>[];
         skipHooks?: boolean;
-    } & JoinOnStatements<DB, Schema, AssociationTableName, null>): Promise<number>;
+    } & JoinAndStatements<DB, Schema, AssociationTableName, null>): Promise<number>;
     /**
      * Creates an association for an instance. Automatically
      * handles setting foreign key and, in the case of polymorphism,
@@ -301,12 +301,12 @@ export default class DreamInstanceTransactionBuilder<DreamInstance extends Dream
      * @returns The created association
      */
     createAssociation<I extends DreamInstanceTransactionBuilder<DreamInstance>, AssociationName extends DreamAssociationNames<DreamInstance>, PossibleArrayAssociationType = DreamInstance[AssociationName & keyof DreamInstance], AssociationType = PossibleArrayAssociationType extends (infer ElementType)[] ? ElementType : PossibleArrayAssociationType, RestrictedAssociationType extends AssociationType extends Dream ? AssociationType : never = AssociationType extends Dream ? AssociationType : never>(this: I, associationName: AssociationName, opts?: UpdateableAssociationProperties<DreamInstance, RestrictedAssociationType>): Promise<NonNullable<AssociationType>>;
-    destroyAssociation<I extends DreamInstanceTransactionBuilder<DreamInstance>, DB extends DreamInstance['DB'], TableName extends DreamInstance['table'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNames<DreamInstance>, RequiredOnClauseKeysForThisAssociation extends RequiredOnClauseKeys<Schema, TableName, AssociationName>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options: DestroyOptions<DreamInstance> & JoinOnStatements<DB, Schema, AssociationTableName, RequiredOnClauseKeysForThisAssociation>): Promise<number>;
-    destroyAssociation<I extends DreamInstanceTransactionBuilder<DreamInstance>, DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNamesWithoutRequiredOnClauses<DreamInstance>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options?: DestroyOptions<DreamInstance> & JoinOnStatements<DB, Schema, AssociationTableName, null>): Promise<number>;
-    reallyDestroyAssociation<I extends DreamInstanceTransactionBuilder<DreamInstance>, DB extends DreamInstance['DB'], TableName extends DreamInstance['table'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNames<DreamInstance>, RequiredOnClauseKeysForThisAssociation extends RequiredOnClauseKeys<Schema, TableName, AssociationName>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options: DestroyOptions<DreamInstance> & JoinOnStatements<DB, Schema, AssociationTableName, RequiredOnClauseKeysForThisAssociation>): Promise<number>;
-    reallyDestroyAssociation<I extends DreamInstanceTransactionBuilder<DreamInstance>, DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNamesWithoutRequiredOnClauses<DreamInstance>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options?: DestroyOptions<DreamInstance> & JoinOnStatements<DB, Schema, AssociationTableName, null>): Promise<number>;
-    undestroyAssociation<I extends DreamInstanceTransactionBuilder<DreamInstance>, DB extends DreamInstance['DB'], TableName extends DreamInstance['table'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNames<DreamInstance>, RequiredOnClauseKeysForThisAssociation extends RequiredOnClauseKeys<Schema, TableName, AssociationName>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options: DestroyOptions<DreamInstance> & JoinOnStatements<DB, Schema, AssociationTableName, RequiredOnClauseKeysForThisAssociation>): Promise<number>;
-    undestroyAssociation<I extends DreamInstanceTransactionBuilder<DreamInstance>, DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNamesWithoutRequiredOnClauses<DreamInstance>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options?: DestroyOptions<DreamInstance> & JoinOnStatements<DB, Schema, AssociationTableName, null>): Promise<number>;
+    destroyAssociation<I extends DreamInstanceTransactionBuilder<DreamInstance>, DB extends DreamInstance['DB'], TableName extends DreamInstance['table'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNames<DreamInstance>, RequiredOnClauseKeysForThisAssociation extends RequiredOnClauseKeys<Schema, TableName, AssociationName>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options: DestroyOptions<DreamInstance> & JoinAndStatements<DB, Schema, AssociationTableName, RequiredOnClauseKeysForThisAssociation>): Promise<number>;
+    destroyAssociation<I extends DreamInstanceTransactionBuilder<DreamInstance>, DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNamesWithoutRequiredOnClauses<DreamInstance>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options?: DestroyOptions<DreamInstance> & JoinAndStatements<DB, Schema, AssociationTableName, null>): Promise<number>;
+    reallyDestroyAssociation<I extends DreamInstanceTransactionBuilder<DreamInstance>, DB extends DreamInstance['DB'], TableName extends DreamInstance['table'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNames<DreamInstance>, RequiredOnClauseKeysForThisAssociation extends RequiredOnClauseKeys<Schema, TableName, AssociationName>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options: DestroyOptions<DreamInstance> & JoinAndStatements<DB, Schema, AssociationTableName, RequiredOnClauseKeysForThisAssociation>): Promise<number>;
+    reallyDestroyAssociation<I extends DreamInstanceTransactionBuilder<DreamInstance>, DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNamesWithoutRequiredOnClauses<DreamInstance>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options?: DestroyOptions<DreamInstance> & JoinAndStatements<DB, Schema, AssociationTableName, null>): Promise<number>;
+    undestroyAssociation<I extends DreamInstanceTransactionBuilder<DreamInstance>, DB extends DreamInstance['DB'], TableName extends DreamInstance['table'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNames<DreamInstance>, RequiredOnClauseKeysForThisAssociation extends RequiredOnClauseKeys<Schema, TableName, AssociationName>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options: DestroyOptions<DreamInstance> & JoinAndStatements<DB, Schema, AssociationTableName, RequiredOnClauseKeysForThisAssociation>): Promise<number>;
+    undestroyAssociation<I extends DreamInstanceTransactionBuilder<DreamInstance>, DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNamesWithoutRequiredOnClauses<DreamInstance>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options?: DestroyOptions<DreamInstance> & JoinAndStatements<DB, Schema, AssociationTableName, null>): Promise<number>;
     /**
      * @internal
      *

package/dist/types/src/dream/Query.d.ts

@@ -3,7 +3,7 @@ import ConnectedToDB from '../db/ConnectedToDB.js';
 import Dream from '../Dream.js';
 import { ColumnNamesAccountingForJoinedAssociations, LimitStatement, OffsetStatement, OrderQueryStatement, PassthroughOnClause, WhereStatement, WhereStatementForJoinedAssociation } from '../types/associations/shared.js';
 import { DbConnectionType } from '../types/db.js';
-import { AllDefaultScopeNames, DefaultScopeName, DreamColumnNames, DreamTableSchema, OrderDir, PassthroughColumnNames, PluckEachArgs, PrimaryKeyForFind, RelaxedJoinOnStatement, RelaxedJoinStatement, RelaxedPreloadOnStatement, RelaxedPreloadStatement, TableColumnNames, TableOrAssociationName } from '../types/dream.js';
+import { AllDefaultScopeNames, DefaultScopeName, DreamColumnNames, DreamTableSchema, OrderDir, PassthroughColumnNames, PluckEachArgs, PrimaryKeyForFind, RelaxedJoinAndStatement, RelaxedJoinStatement, RelaxedPreloadOnStatement, RelaxedPreloadStatement, TableColumnNames, TableOrAssociationName } from '../types/dream.js';
 import { DefaultQueryTypeOptions, ExtendQueryType, NamespacedOrBaseModelColumnTypes, QueryToKyselyDBType, QueryToKyselyTableNamesType } from '../types/query.js';
 import { JoinedAssociation, JoinedAssociationsTypeFromAssociations, QueryTypeOptions, VariadicJoinsArgs, VariadicLeftJoinLoadArgs, VariadicLoadArgs } from '../types/variadic.js';
 import DreamTransaction from './DreamTransaction.js';
@@ -113,7 +113,7 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
      * stores the joins on statements applied to the
      * current Query instance
      */
-    private readonly innerJoinOnStatements;
+    private readonly innerJoinAndStatements;
     /**
      * @internal
      *
@@ -127,7 +127,7 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
      * stores the joins on statements applied to the
      * current Query instance
      */
-    private readonly leftJoinOnStatements;
+    private readonly leftJoinAndStatements;
     /**
      * @internal
      *
@@ -309,7 +309,7 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
      * // [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<Q extends Query<DreamInstance, any>, DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], TableName extends DreamInstance['table'], const Arr extends readonly unknown[], const LastArg extends VariadicLeftJoinLoadArgs<DB, Schema, TableName, Arr>, Incompatible extends Q['queryTypeOpts'] extends Readonly<{
@@ -328,7 +328,7 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
      * // [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<Q extends Query<DreamInstance, any>, DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], TableName extends DreamInstance['table'], const Arr extends readonly unknown[], Incompatible extends Q['queryTypeOpts'] extends Readonly<{
@@ -344,7 +344,7 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
      * 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<DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], TableName extends DreamInstance['table'], const Arr extends readonly unknown[], const LastArg extends VariadicJoinsArgs<DB, Schema, TableName, Arr>, const JoinedAssociationsCandidate = JoinedAssociationsTypeFromAssociations<DB, Schema, TableName, [
@@ -356,7 +356,7 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
     /**
      * @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<DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], TableName extends DreamInstance['table'], const Arr extends readonly unknown[], const LastArg extends VariadicJoinsArgs<DB, Schema, TableName, Arr>, const JoinedAssociationsCandidate = JoinedAssociationsTypeFromAssociations<DB, Schema, TableName, [
@@ -477,7 +477,7 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
      *   public localizedTexts: LocalizedText[]
      *
      *   @deco.HasOne('LocalizedText', {
-     *     on: { locale: DreamConst.passthrough },
+     *     and: { locale: DreamConst.passthrough },
      *   })
      *   public currentLocalizedText: LocalizedText
      * }
@@ -1041,7 +1041,7 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
      */
     private joinsBridgeThroughAssociations;
     private applyOneJoin;
-    private applyAssociationOnStatementsToJoinStatement;
+    private applyAssociationAndStatementsToJoinStatement;
     private conditionallyApplyDefaultScopesDependentOnAssociation;
     private distinctColumnNameForAssociation;
     private recursivelyJoin;
@@ -1052,10 +1052,10 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
     private notInArrayWithNullExpressionBuilder;
     private whereStatementToExpressionWrapper;
     private dreamWhereStatementToExpressionBuilderParts;
-    private applyJoinOnStatement;
-    private _applyJoinOnStatements;
-    private _applyJoinOnAnyStatements;
-    private joinOnStatementToExpressionWrapper;
+    private applyJoinAndStatement;
+    private _applyJoinAndStatements;
+    private _applyJoinAndAnyStatements;
+    private joinAndStatementToExpressionWrapper;
     private buildCommon;
     private checkForQueryViolations;
     private aliasWhereStatements;
@@ -1088,9 +1088,9 @@ export interface QueryOpts<DreamInstance extends Dream, ColumnType extends Dream
     distinctColumn?: ColumnType | null | undefined;
     innerJoinDreamClasses?: readonly (typeof Dream)[] | undefined;
     innerJoinStatements?: RelaxedJoinStatement | undefined;
-    innerJoinOnStatements?: RelaxedJoinOnStatement<DB, Schema> | undefined;
+    innerJoinAndStatements?: RelaxedJoinAndStatement<DB, Schema> | undefined;
     leftJoinStatements?: RelaxedJoinStatement | undefined;
-    leftJoinOnStatements?: RelaxedJoinOnStatement<DB, Schema> | undefined;
+    leftJoinAndStatements?: RelaxedJoinAndStatement<DB, Schema> | undefined;
     bypassAllDefaultScopes?: boolean | undefined;
     bypassAllDefaultScopesExceptOnAssociations?: boolean | undefined;
     defaultScopesToBypass?: AllDefaultScopeNames<DreamInstance>[] | undefined;

package/dist/types/src/dream/internal/associations/associationQuery.d.ts

@@ -1,9 +1,9 @@
 import Dream from '../../../Dream.js';
-import { AssociationNameToDream, DreamAssociationNames, JoinOnStatements } from '../../../types/dream.js';
+import { AssociationNameToDream, DreamAssociationNames, JoinAndStatements } from '../../../types/dream.js';
 import DreamTransaction from '../../DreamTransaction.js';
 import Query from '../../Query.js';
-export default function associationQuery<DreamInstance extends Dream, DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNames<DreamInstance>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table'], AssociationQuery = Query<AssociationNameToDream<DreamInstance, AssociationName>>>(dream: DreamInstance, txn: (DreamTransaction<Dream> | null) | undefined, associationName: AssociationName, { joinOnStatements, bypassAllDefaultScopes, defaultScopesToBypass, }: {
-    joinOnStatements: JoinOnStatements<DB, Schema, AssociationTableName, null>;
+export default function associationQuery<DreamInstance extends Dream, DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNames<DreamInstance>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table'], AssociationQuery = Query<AssociationNameToDream<DreamInstance, AssociationName>>>(dream: DreamInstance, txn: (DreamTransaction<Dream> | null) | undefined, associationName: AssociationName, { joinAndStatements, bypassAllDefaultScopes, defaultScopesToBypass, }: {
+    joinAndStatements: JoinAndStatements<DB, Schema, AssociationTableName, null>;
     bypassAllDefaultScopes: boolean;
     defaultScopesToBypass: string[];
 }): AssociationQuery;

package/dist/types/src/dream/internal/associations/associationUpdateQuery.d.ts

@@ -1,9 +1,9 @@
 import Dream from '../../../Dream.js';
-import { AssociationNameToDream, DreamAssociationNames, JoinOnStatements } from '../../../types/dream.js';
+import { AssociationNameToDream, DreamAssociationNames, JoinAndStatements } from '../../../types/dream.js';
 import DreamTransaction from '../../DreamTransaction.js';
 import Query from '../../Query.js';
-export default function associationUpdateQuery<DreamInstance extends Dream, DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNames<DreamInstance>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table'], AssociationQuery = Query<AssociationNameToDream<DreamInstance, AssociationName>>>(dream: DreamInstance, txn: (DreamTransaction<Dream> | null) | undefined, associationName: AssociationName, { joinOnStatements, bypassAllDefaultScopes, defaultScopesToBypass, }: {
-    joinOnStatements: JoinOnStatements<DB, Schema, AssociationTableName, null>;
+export default function associationUpdateQuery<DreamInstance extends Dream, DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNames<DreamInstance>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table'], AssociationQuery = Query<AssociationNameToDream<DreamInstance, AssociationName>>>(dream: DreamInstance, txn: (DreamTransaction<Dream> | null) | undefined, associationName: AssociationName, { joinAndStatements, bypassAllDefaultScopes, defaultScopesToBypass, }: {
+    joinAndStatements: JoinAndStatements<DB, Schema, AssociationTableName, null>;
     bypassAllDefaultScopes: boolean;
     defaultScopesToBypass: string[];
 }): AssociationQuery;

package/dist/types/src/dream/internal/associations/destroyAssociation.d.ts

@@ -1,8 +1,8 @@
 import Dream from '../../../Dream.js';
-import { AssociationNameToDream, DreamAssociationNames, JoinOnStatements } from '../../../types/dream.js';
+import { AssociationNameToDream, DreamAssociationNames, JoinAndStatements } from '../../../types/dream.js';
 import DreamTransaction from '../../DreamTransaction.js';
-export default function destroyAssociation<DreamInstance extends Dream, DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNames<DreamInstance>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table']>(dream: DreamInstance, txn: (DreamTransaction<Dream> | null) | undefined, associationName: AssociationName, { joinOnStatements, bypassAllDefaultScopes, defaultScopesToBypass, cascade, reallyDestroy, skipHooks, }: {
-    joinOnStatements: JoinOnStatements<DB, Schema, AssociationTableName, null>;
+export default function destroyAssociation<DreamInstance extends Dream, DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNames<DreamInstance>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table']>(dream: DreamInstance, txn: (DreamTransaction<Dream> | null) | undefined, associationName: AssociationName, { joinAndStatements, bypassAllDefaultScopes, defaultScopesToBypass, cascade, reallyDestroy, skipHooks, }: {
+    joinAndStatements: JoinAndStatements<DB, Schema, AssociationTableName, null>;
     bypassAllDefaultScopes: boolean;
     defaultScopesToBypass: string[];
     cascade: boolean;

package/dist/types/src/dream/internal/associations/undestroyAssociation.d.ts

@@ -1,8 +1,8 @@
 import Dream from '../../../Dream.js';
-import { AssociationNameToDream, DreamAssociationNames, JoinOnStatements } from '../../../types/dream.js';
+import { AssociationNameToDream, DreamAssociationNames, JoinAndStatements } from '../../../types/dream.js';
 import DreamTransaction from '../../DreamTransaction.js';
-export default function undestroyAssociation<DreamInstance extends Dream, DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNames<DreamInstance>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table']>(dream: DreamInstance, txn: (DreamTransaction<Dream> | null) | undefined, associationName: AssociationName, { joinOnStatements, bypassAllDefaultScopes, defaultScopesToBypass, cascade, skipHooks, }: {
-    joinOnStatements: JoinOnStatements<DB, Schema, AssociationTableName, null>;
+export default function undestroyAssociation<DreamInstance extends Dream, DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNames<DreamInstance>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table']>(dream: DreamInstance, txn: (DreamTransaction<Dream> | null) | undefined, associationName: AssociationName, { joinAndStatements, bypassAllDefaultScopes, defaultScopesToBypass, cascade, skipHooks, }: {
+    joinAndStatements: JoinAndStatements<DB, Schema, AssociationTableName, null>;
     bypassAllDefaultScopes: boolean;
     defaultScopesToBypass: string[];
     cascade: boolean;

package/dist/types/src/dream/internal/similarity/SimilarityBuilder.d.ts

@@ -3,12 +3,12 @@ import ConnectedToDB from '../../../db/ConnectedToDB.js';
 import Dream from '../../../Dream.js';
 import { WhereStatement } from '../../../types/associations/shared.js';
 import { DbConnectionType } from '../../../types/db.js';
-import { JoinOnStatements, RelaxedJoinOnStatement, SimilarityStatement } from '../../../types/dream.js';
+import { JoinAndStatements, RelaxedJoinAndStatement, SimilarityStatement } from '../../../types/dream.js';
 import DreamTransaction from '../../DreamTransaction.js';
 export default class SimilarityBuilder<DreamInstance extends Dream, DB extends DreamInstance['DB'] = DreamInstance['DB'], Schema extends DreamInstance['schema'] = DreamInstance['schema']> extends ConnectedToDB<DreamInstance> {
     readonly whereStatement: readonly WhereStatement<DB, Schema, any>[];
     readonly whereNotStatement: readonly WhereStatement<DB, Schema, any>[];
-    readonly joinOnStatements: JoinOnStatements<DB, Schema, any, any>;
+    readonly joinAndStatements: JoinAndStatements<DB, Schema, any, any>;
     constructor(dreamInstance: DreamInstance, opts?: SimilarityBuilderOpts<DreamInstance>);
     select<T extends SimilarityBuilder<DreamInstance>>(this: T, kyselyQuery: SelectQueryBuilder<DB, any, object>, { bypassOrder }?: {
         bypassOrder?: boolean;
@@ -17,7 +17,7 @@ export default class SimilarityBuilder<DreamInstance extends Dream, DB extends D
     get hasSimilarityClauses(): boolean;
     whereStatementsWithSimilarityClauses(): SimilarityStatement[];
     whereNotStatementsWithSimilarityClauses(): SimilarityStatement[];
-    joinOnStatementsWithSimilarityClauses(): SimilarityStatement[];
+    joinAndStatementsWithSimilarityClauses(): SimilarityStatement[];
     private recursiveJoinsOnFinder;
     statementsWithSimilarityClauses(): SimilarityStatement[];
     private addStatementToSelectQuery;
@@ -30,9 +30,9 @@ export default class SimilarityBuilder<DreamInstance extends Dream, DB extends D
 export interface SimilarityBuilderOpts<DreamInstance extends Dream, DB extends DreamInstance['DB'] = DreamInstance['DB'], Schema extends DreamInstance['schema'] = DreamInstance['schema']> {
     where?: WhereStatement<DB, Schema, any>[] | undefined;
     whereNot?: WhereStatement<DB, Schema, any>[] | undefined;
-    joinOnStatements?: RelaxedJoinOnStatement<DB, Schema> | undefined;
+    joinAndStatements?: RelaxedJoinAndStatement<DB, Schema> | undefined;
     transaction?: DreamTransaction<Dream> | null | undefined;
     connection?: DbConnectionType | undefined;
 }
-export declare const SIMILARITY_TYPES: readonly ["where", "on"];
+export declare const SIMILARITY_TYPES: readonly ["where", "join_and"];
 export type SimilarityStatementType = (typeof SIMILARITY_TYPES)[number];

package/dist/types/src/errors/{CannotDefineAssociationWithBothDependentAndRequiredOnClause.d.ts → CannotDefineAssociationWithBothDependentAndRequiredAndClause.d.ts}

@@ -1,5 +1,5 @@
 import Dream from '../Dream.js';
-export default class CannotDefineAssociationWithBothDependentAndRequiredOnClause extends Error {
+export default class CannotDefineAssociationWithBothDependentAndRequiredAndClause extends Error {
     private dreamClass;
     private associationName;
     constructor(dreamClass: typeof Dream, associationName: string);

package/dist/types/src/errors/associations/{MissingRequiredAssociationOnClause.d.ts → MissingRequiredAssociationAndClause.d.ts}

@@ -1,6 +1,6 @@
 import { HasManyStatement } from '../../types/associations/hasMany.js';
 import { HasOneStatement } from '../../types/associations/hasOne.js';
-export default class MissingRequiredAssociationOnClause extends Error {
+export default class MissingRequiredAssociationAndClause extends Error {
     private association;
     private column;
     constructor(association: HasManyStatement<any, any, any, any> | HasOneStatement<any, any, any, any>, column: string | undefined);

package/dist/types/src/errors/associations/MissingRequiredPassthroughForAssociationAndClause.d.ts

@@ -0,0 +1,5 @@
+export default class MissingRequiredPassthroughForAssociationAndClause extends Error {
+    private column;
+    constructor(column: string);
+    get message(): string;
+}

package/dist/types/src/types/associations/shared.d.ts

@@ -295,9 +295,9 @@ export interface HasStatement<
   foreignKey: () => keyof DB[ForeignTableName] & string
   foreignKeyTypeField: () => keyof DB[ForeignTableName] & string
   globalAssociationNameOrNames: string[]
-  on?: OnStatementForAssociationDefinition<DB, Schema, ForeignTableName>
-  notOn?: WhereStatement<DB, Schema, ForeignTableName>
-  onAny?: WhereStatement<DB, Schema, ForeignTableName>[]
+  and?: OnStatementForAssociationDefinition<DB, Schema, ForeignTableName>
+  andNot?: WhereStatement<DB, Schema, ForeignTableName>
+  andAny?: WhereStatement<DB, Schema, ForeignTableName>[]
   // ATTENTION
   //
   // Using `order` with HasOne is tempting as an elegant API
@@ -313,13 +313,14 @@ export interface HasStatement<
   primaryKey: (associationInstance?: Dream) => DreamColumnNames<BaseInstance>
   primaryKeyOverride?: DreamColumnNames<BaseInstance> | null
   primaryKeyValue: (associationInstance: Dream) => any
-  selfOn?: SelfOnStatement<BaseInstance, DB, Schema, ForeignTableName>
-  selfNotOn?: SelfOnStatement<BaseInstance, DB, Schema, ForeignTableName>
+  selfAnd?: SelfOnStatement<BaseInstance, DB, Schema, ForeignTableName>
+  selfAndNot?: SelfOnStatement<BaseInstance, DB, Schema, ForeignTableName>
   source: string
   through?: string
   type: HasType
   withoutDefaultScopes?: DefaultScopeName<BaseInstance>[]
 }
+
 interface HasOptionsBase<
   BaseInstance extends Dream,
   AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>,
@@ -331,7 +332,7 @@ interface HasOptionsBase<
   dependent?: DependentOptions
   foreignKey?: TableColumnNames<BaseInstance['DB'], AssociationTableName & keyof BaseInstance['DB']>
 
-  on?: OnStatementForAssociationDefinition<
+  and?: OnStatementForAssociationDefinition<
     BaseInstance['DB'],
     BaseInstance['schema'],
     AssociationTableName &
@@ -339,7 +340,7 @@ interface HasOptionsBase<
       keyof BaseInstance['DB']
   >
 
-  notOn?: WhereStatement<
+  andNot?: WhereStatement<
     BaseInstance['DB'],
     BaseInstance['schema'],
     AssociationTableName &
@@ -347,7 +348,7 @@ interface HasOptionsBase<
       keyof BaseInstance['DB']
   >
 
-  onAny?: WhereStatement<
+  andAny?: WhereStatement<
     BaseInstance['DB'],
     BaseInstance['schema'],
     AssociationTableName &
@@ -359,7 +360,7 @@ interface HasOptionsBase<
   preloadThroughColumns?: string[] | Record<string, string>
   primaryKeyOverride?: DreamColumnNames<BaseInstance> | null
 
-  selfOn?: SelfOnStatement<
+  selfAnd?: SelfOnStatement<
     BaseInstance,
     BaseInstance['DB'],
     BaseInstance['schema'],
@@ -368,7 +369,7 @@ interface HasOptionsBase<
       keyof BaseInstance['DB']
   >
 
-  selfNotOn?: SelfOnStatement<
+  selfAndNot?: SelfOnStatement<
     BaseInstance,
     BaseInstance['DB'],
     BaseInstance['schema'],
@@ -431,10 +432,11 @@ type hasOneManySpecificFields =
   | 'source'
   | 'through'
   | 'preloadThroughColumns'
-  | 'on'
-  | 'notOn'
-  | 'selfOn'
-  | 'selfNotOn'
+  | 'and'
+  | 'andNot'
+  | 'andAny'
+  | 'selfAnd'
+  | 'selfAndNot'
 type belongsToSpecificFields = 'optional'
 
 export type PartialAssociationStatement =

package/dist/types/src/types/dream.d.ts

@@ -237,26 +237,26 @@ export type AssociationTableName<
   AssociationData = MetadataForAssociation<Schema, TableName, AssociationName>,
 > = (AssociationData['tables' & keyof AssociationData] & any[])[0] & keyof Schema
 
-export type JoinOnStatements<
+export type JoinAndStatements<
   DB,
   Schema,
   TableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB,
   RequiredOnClauseKeysForThisAssociation,
 > = RequiredOnClauseKeysForThisAssociation extends null
   ? {
-      on?: WhereStatement<DB, Schema, TableName>
-      notOn?: WhereStatement<DB, Schema, TableName>
-      // notOn?: WhereStatementWithoutSimilarityClauses<DB, Schema, TableName>
-      onAny?: WhereStatement<DB, Schema, TableName>[]
-      // onAny?: WhereStatementWithoutSimilarityClauses<DB, Schema, TableName>[]
+      and?: WhereStatement<DB, Schema, TableName>
+      andNot?: WhereStatement<DB, Schema, TableName>
+      // andNot?: WhereStatementWithoutSimilarityClauses<DB, Schema, TableName>
+      andAny?: WhereStatement<DB, Schema, TableName>[]
+      // andAny?: WhereStatementWithoutSimilarityClauses<DB, Schema, TableName>[]
     }
   : RequiredOnClauseKeysForThisAssociation extends string[]
     ? {
-        on: OnStatementForAssociation<DB, Schema, TableName, RequiredOnClauseKeysForThisAssociation>
-        notOn?: WhereStatement<DB, Schema, TableName>
-        // notOn?: WhereStatementWithoutSimilarityClauses<DB, Schema, TableName>
-        onAny?: WhereStatement<DB, Schema, TableName>[]
-        // onAny?: WhereStatementWithoutSimilarityClauses<DB, Schema, TableName>[]
+        and: OnStatementForAssociation<DB, Schema, TableName, RequiredOnClauseKeysForThisAssociation>
+        andNot?: WhereStatement<DB, Schema, TableName>
+        // andNot?: WhereStatementWithoutSimilarityClauses<DB, Schema, TableName>
+        andAny?: WhereStatement<DB, Schema, TableName>[]
+        // andAny?: WhereStatementWithoutSimilarityClauses<DB, Schema, TableName>[]
       }
     : never
 ////////////////////////////////
@@ -406,17 +406,17 @@ export type RelaxedPreloadOnStatement<DB, Schema, Depth extends number = 0> = De
   : {
       [key: string]:
         | RelaxedPreloadOnStatement<DB, Schema, Inc<Depth>>
-        | JoinOnStatements<any, any, any, any>
+        | JoinAndStatements<any, any, any, any>
         | FakeOnClauseValue
         | object
     }
 
-export type RelaxedJoinOnStatement<DB, Schema, Depth extends number = 0> = Depth extends 7
+export type RelaxedJoinAndStatement<DB, Schema, Depth extends number = 0> = Depth extends 7
   ? object
   : {
       [key: string]:
-        | RelaxedJoinOnStatement<DB, Schema, Inc<Depth>>
-        | JoinOnStatements<any, any, any, any>
+        | RelaxedJoinAndStatement<DB, Schema, Inc<Depth>>
+        | JoinAndStatements<any, any, any, any>
         | FakeOnClauseValue
         | object
     }

package/dist/types/src/types/variadic.d.ts

@@ -3,7 +3,7 @@ import { AssociationTableNames } from './db.js'
 import {
   AssociationNamesForTable,
   AssociationTableName,
-  JoinOnStatements,
+  JoinAndStatements,
   MAX_VARIADIC_DEPTH,
 } from './dream.js'
 import { Inc, ReadonlyTail } from './utils.ts'
@@ -149,7 +149,7 @@ type VariadicCheckThenRecurse<
       ? VALID
       : ConcreteArgs[0] extends AliasedSchemaAssociation<Schema, ConcreteTableName>
         ? VALID
-        : ConcreteArgs[0] extends JoinOnStatements<
+        : ConcreteArgs[0] extends JoinAndStatements<
               DB,
               Schema,
               ConcreteTableName,
@@ -298,7 +298,7 @@ type AllowedNextArgValuesForLoad<
 > =
   | AssociationNamesForTable<Schema, TableName>
   | AssociationNamesForTable<Schema, TableName>[]
-  | JoinOnStatements<DB, Schema, TableName, RequiredOnClauseKeysForThisAssociation>
+  | JoinAndStatements<DB, Schema, TableName, RequiredOnClauseKeysForThisAssociation>
 type AllowedNextArgValuesForLeftJoinLoad<
   DB,
   Schema,
@@ -308,7 +308,7 @@ type AllowedNextArgValuesForLeftJoinLoad<
 > =
   | Exclude<AssociationNamesForTable<Schema, TableName>, UsedNamespaces>
   | Exclude<AssociationNamesForTable<Schema, TableName>, UsedNamespaces>[]
-  | JoinOnStatements<DB, Schema, TableName, RequiredOnClauseKeysForThisAssociation>
+  | JoinAndStatements<DB, Schema, TableName, RequiredOnClauseKeysForThisAssociation>
 type AllowedNextArgValuesForJoin<
   DB,
   Schema,
@@ -317,7 +317,7 @@ type AllowedNextArgValuesForJoin<
   UsedNamespaces,
 > =
   | Exclude<AssociationNamesForTable<Schema, TableName>, UsedNamespaces>
-  | JoinOnStatements<DB, Schema, TableName, RequiredOnClauseKeysForThisAssociation>
+  | JoinAndStatements<DB, Schema, TableName, RequiredOnClauseKeysForThisAssociation>
 
 export interface JoinedAssociation {
   table: string