@rvoh/dream 0.45.0 → 0.45.1

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

@@ -2,8 +2,8 @@ import { SelectArg, SelectExpression } from 'kysely';
 import Dream from '../Dream.js';
 import { PassthroughOnClause, WhereStatement } from '../types/associations/shared.js';
 import { AssociationTableNames } from '../types/db.js';
-import { CreateOrFindByExtraOpts, DefaultScopeName, DreamColumnNames, OrderDir, PassthroughColumnNames, PluckEachArgs, PrimaryKeyForFind, TableColumnNames, UpdateableProperties, UpdateablePropertiesForClass, UpdateOrCreateByExtraOpts } from '../types/dream.js';
-import { BaseModelColumnTypes, FindEachOpts, PaginatedDreamQueryOptions, PaginatedDreamQueryResult, QueryWithJoinedAssociationsType, QueryWithJoinedAssociationsTypeAndNoPreload } from '../types/query.js';
+import { CreateOrFindByExtraOpts, DefaultScopeName, DreamColumnNames, DreamSerializerKey, OrderDir, PassthroughColumnNames, PluckEachArgs, PrimaryKeyForFind, TableColumnNames, UpdateableProperties, UpdateablePropertiesForClass, UpdateOrCreateByExtraOpts } from '../types/dream.js';
+import { BaseModelColumnTypes, FindEachOpts, LoadForModifierFn, PaginatedDreamQueryOptions, PaginatedDreamQueryResult, QueryWithJoinedAssociationsType, QueryWithJoinedAssociationsTypeAndNoPreload } from '../types/query.js';
 import { JoinedAssociation, JoinedAssociationsTypeFromAssociations, VariadicJoinsArgs, VariadicLeftJoinLoadArgs, VariadicLoadArgs } from '../types/variadic.js';
 import DreamTransaction from './DreamTransaction.js';
 import Query from './Query.js';
@@ -337,6 +337,59 @@ export default class DreamClassTransactionBuilder<DreamClass extends typeof Drea
         ...Arr,
         LastArg
     ]>, const JoinedAssociations extends readonly JoinedAssociation[] = JoinedAssociationsCandidate extends readonly JoinedAssociation[] ? JoinedAssociationsCandidate : never, RetQuery = QueryWithJoinedAssociationsTypeAndNoPreload<Query<DreamInstance>, JoinedAssociations>>(this: I, ...args: [...Arr, LastArg]): RetQuery;
+    /**
+     * Recursively left-join-preloads all Dream associations referenced by `rendersOne` and `rendersMany`
+     * in a DreamSerializer. This traverses the entire content tree of serializers to automatically
+     * load all necessary associations, eliminating N+1 query problems and removing the need to
+     * manually remember which associations to preload for serialization.
+     *
+     * This method decouples data loading code from data rendering code by having the serializer
+     * (rendering code) inform the query (loading code) about which associations are needed.
+     * As serializers evolve over time - adding new `rendersOne` and `rendersMany` calls or
+     * modifying existing ones - the loading code automatically adapts without requiring
+     * corresponding modifications to preload statements.
+     *
+     * This method analyzes the serializer (specified by `serializerKey` or 'default') and
+     * automatically preloads all associations that will be needed during serialization.
+     *
+     * ```ts
+     * // Instead of manually specifying all associations:
+     * await User.preload('posts', 'comments', 'replies').all()
+     *
+     * // Automatically preload everything needed for serialization:
+     * await User.preloadFor('summary').all()
+     *
+     * // Add where conditions to specific associations during preloading:
+     * await User.txn(txn).leftJoinPreloadFor('detailed', (dreamClass, associationName) => {
+     *   if (dreamClass.typeof(Post) && associationName === 'comments') {
+     *     return { and: { published: true } }
+     *   }
+     * }).all()
+     *
+     * // Skip preloading specific associations to handle them manually:
+     * await User.txn(txn).leftJoinPreloadFor('summary', (dreamClass, associationName) => {
+     *   if (dreamClass.typeof(User) && associationName === 'posts') {
+     *     return 'omit' // Handle posts preloading separately with custom logic
+     *   }
+     * })
+     * .preload('posts', { and: { featured: true } }) // Custom preloading
+     * .all()
+     * ```
+     *
+     * @param serializerKey - The serializer key to use for determining which associations to preload.
+     * @param modifierFn - Optional callback function to modify or omit specific associations during preloading. Called for each association with the Dream class and association name. Return an object with `and`, `andAny`, or `andNot` properties to add where conditions, return 'omit' to skip preloading that association (useful when you want to handle it manually), or return undefined to use default preloading
+     * @returns A Query with all serialization associations preloaded
+     */
+    leftJoinPreloadFor<T extends DreamClassTransactionBuilder<DreamClass, DreamInstance>, SerializerKey extends DreamSerializerKey<DreamInstance>>(this: T, serializerKey: SerializerKey, modifierFn?: LoadForModifierFn): Query<DreamInstance, Readonly<{
+        joinedAssociations: readonly [];
+        rootTableName: DreamInstance["table"];
+        rootTableAlias: DreamInstance extends Dream ? DreamInstance["table"] : DreamInstance;
+        allowPreload: false;
+        allowLeftJoinPreload: true;
+        allowLimit: false;
+        allowOffset: false;
+        allowPaginate: false;
+    }>>;
     /**
      * Applies preload statement to a Query scoped to this model.
      * Upon instantiating records of this model type,
@@ -368,6 +421,59 @@ export default class DreamClassTransactionBuilder<DreamClass extends typeof Drea
         allowOffset: true;
         allowPaginate: true;
     }>>;
+    /**
+     * Recursively preloads all Dream associations referenced by `rendersOne` and `rendersMany`
+     * in a DreamSerializer. This traverses the entire content tree of serializers to automatically
+     * load all necessary associations, eliminating N+1 query problems and removing the need to
+     * manually remember which associations to preload for serialization.
+     *
+     * This method decouples data loading code from data rendering code by having the serializer
+     * (rendering code) inform the query (loading code) about which associations are needed.
+     * As serializers evolve over time - adding new `rendersOne` and `rendersMany` calls or
+     * modifying existing ones - the loading code automatically adapts without requiring
+     * corresponding modifications to preload statements.
+     *
+     * This method analyzes the serializer (specified by `serializerKey` or 'default') and
+     * automatically preloads all associations that will be needed during serialization.
+     *
+     * ```ts
+     * // Instead of manually specifying all associations:
+     * await User.preload('posts', 'comments', 'replies').all()
+     *
+     * // Automatically preload everything needed for serialization:
+     * await User.preloadFor('summary').all()
+     *
+     * // Add where conditions to specific associations during preloading:
+     * await User.txn(txn).preloadFor('detailed', (dreamClass, associationName) => {
+     *   if (dreamClass.typeof(Post) && associationName === 'comments') {
+     *     return { and: { published: true } }
+     *   }
+     * }).all()
+     *
+     * // Skip preloading specific associations to handle them manually:
+     * await User.txn(txn).preloadFor('summary', (dreamClass, associationName) => {
+     *   if (dreamClass.typeof(User) && associationName === 'posts') {
+     *     return 'omit' // Handle posts preloading separately with custom logic
+     *   }
+     * })
+     * .preload('posts', { and: { featured: true } }) // Custom preloading
+     * .all()
+     * ```
+     *
+     * @param serializerKey - The serializer key to use for determining which associations to preload.
+     * @param modifierFn - Optional callback function to modify or omit specific associations during preloading. Called for each association with the Dream class and association name. Return an object with `and`, `andAny`, or `andNot` properties to add where conditions, return 'omit' to skip preloading that association (useful when you want to handle it manually), or return undefined to use default preloading
+     * @returns A Query with all serialization associations preloaded
+     */
+    preloadFor<T extends DreamClassTransactionBuilder<DreamClass, DreamInstance>, SerializerKey extends DreamSerializerKey<DreamInstance>>(this: T, serializerKey: SerializerKey, modifierFn?: LoadForModifierFn): Query<DreamInstance, Readonly<{
+        joinedAssociations: readonly [];
+        rootTableName: DreamInstance["table"];
+        rootTableAlias: DreamInstance extends Dream ? DreamInstance["table"] : DreamInstance;
+        allowPreload: true;
+        allowLeftJoinPreload: false;
+        allowLimit: true;
+        allowOffset: true;
+        allowPaginate: true;
+    }>>;
     /**
      * Returns a new Query instance with the provided
      * inner join statement attached

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

@@ -1,6 +1,6 @@
 import Dream from '../Dream.js';
-import { AllDefaultScopeNames, AssociationNameToDream, DreamAssociationNames, DreamAssociationNamesWithoutRequiredOnClauses, DreamAttributes, JoinAndStatements, UpdateableAssociationProperties, UpdateableProperties } from '../types/dream.js';
-import { DefaultQueryTypeOptions, QueryWithJoinedAssociationsType } from '../types/query.js';
+import { AllDefaultScopeNames, AssociationNameToDream, DreamAssociationNames, DreamAssociationNamesWithoutRequiredOnClauses, DreamAttributes, DreamSerializerKey, JoinAndStatements, UpdateableAssociationProperties, UpdateableProperties } from '../types/dream.js';
+import { DefaultQueryTypeOptions, LoadForModifierFn, QueryWithJoinedAssociationsType } from '../types/query.js';
 import { JoinedAssociation, JoinedAssociationsTypeFromAssociations, RequiredOnClauseKeys, VariadicJoinsArgs, VariadicLeftJoinLoadArgs, VariadicLoadArgs } from '../types/variadic.js';
 import DreamTransaction from './DreamTransaction.js';
 import { DestroyOptions } from './internal/destroyOptions.js';
@@ -40,6 +40,53 @@ export default class DreamInstanceTransactionBuilder<DreamInstance extends Dream
      * @returns A chainable LoadBuilder instance
      */
     load<I extends DreamInstanceTransactionBuilder<DreamInstance>, DB extends DreamInstance['DB'], TableName extends DreamInstance['table'], Schema extends DreamInstance['schema'], const Arr extends readonly unknown[]>(this: I, ...args: [...Arr, VariadicLoadArgs<DB, Schema, TableName, Arr>]): LoadBuilder<DreamInstance>;
+    /**
+     * Recursively loads all Dream associations referenced by `rendersOne` and `rendersMany`
+     * in a DreamSerializer. This traverses the entire content tree of serializers to automatically
+     * load all necessary associations, eliminating N+1 query problems and removing the need to
+     * manually remember which associations to preload for serialization.
+     *
+     * This method decouples data loading code from data rendering code by having the serializer
+     * (rendering code) inform the query (loading code) about which associations are needed.
+     * As serializers evolve over time - adding new `rendersOne` and `rendersMany` calls or
+     * modifying existing ones - the loading code automatically adapts without requiring
+     * corresponding modifications to preload statements.
+     *
+     * This method analyzes the serializer (specified by `serializerKey` or 'default') and
+     * automatically preloads all associations that will be needed during serialization.
+     *
+     * ```ts
+     * // Instead of manually specifying all associations:
+     * await User.preload('posts', 'comments', 'replies').all()
+     *
+     * // Automatically preload everything needed for serialization:
+     * await user.loadFor('summary').execute()
+     *
+     * // Add where conditions to specific associations during preloading:
+     * await user.txn(txn).loadFor('detailed', (dreamClass, associationName) => {
+     *   if (dreamClass.typeof(Post) && associationName === 'comments') {
+     *     return { and: { published: true } }
+     *   }
+     * })
+     *    .execute()
+     *
+     * // Skip preloading specific associations to handle them manually:
+     * await user
+     *   .txn(txn)
+     *   .loadFor('summary', (dreamClass, associationName) => {
+     *     if (dreamClass.typeof(User) && associationName === 'posts') {
+     *       return 'omit' // Handle posts preloading separately with custom logic
+     *     }
+     *   })
+     *     .load('posts', { and: { featured: true } }) // Custom preloading
+     *     .execute()
+     * ```
+     *
+     * @param serializerKey - The serializer key to use for determining which associations to preload.
+     * @param modifierFn - Optional callback function to modify or omit specific associations during preloading. Called for each association with the Dream class and association name. Return an object with `and`, `andAny`, or `andNot` properties to add where conditions, return 'omit' to skip preloading that association (useful when you want to handle it manually), or return undefined to use default preloading
+     * @returns A Query with all serialization associations preloaded
+     */
+    loadFor<I extends DreamInstanceTransactionBuilder<DreamInstance>, SerializerKey extends DreamSerializerKey<DreamInstance>>(this: I, serializerKey: SerializerKey, modifierFn?: LoadForModifierFn): LoadBuilder<DreamInstance>;
     /**
      * Load each specified association using a single SQL query.
      * See {@link #load} for loading in separate queries.
@@ -73,6 +120,53 @@ export default class DreamInstanceTransactionBuilder<DreamInstance extends Dream
      * @returns A chainable LeftJoinLoadBuilder instance
      */
     leftJoinLoad<I extends DreamInstanceTransactionBuilder<DreamInstance>, DB extends DreamInstance['DB'], TableName extends DreamInstance['table'], Schema extends DreamInstance['schema'], const Arr extends readonly unknown[]>(this: I, ...args: [...Arr, VariadicLeftJoinLoadArgs<DB, Schema, TableName, Arr>]): LeftJoinLoadBuilder<DreamInstance>;
+    /**
+     * Recursively loads all Dream associations referenced by `rendersOne` and `rendersMany`
+     * in a DreamSerializer. This traverses the entire content tree of serializers to automatically
+     * load all necessary associations, eliminating N+1 query problems and removing the need to
+     * manually remember which associations to preload for serialization.
+     *
+     * This method decouples data loading code from data rendering code by having the serializer
+     * (rendering code) inform the query (loading code) about which associations are needed.
+     * As serializers evolve over time - adding new `rendersOne` and `rendersMany` calls or
+     * modifying existing ones - the loading code automatically adapts without requiring
+     * corresponding modifications to preload statements.
+     *
+     * This method analyzes the serializer (specified by `serializerKey` or 'default') and
+     * automatically preloads all associations that will be needed during serialization.
+     *
+     * ```ts
+     * // Instead of manually specifying all associations:
+     * await User.preload('posts', 'comments', 'replies').all()
+     *
+     * // Automatically preload everything needed for serialization:
+     * await user.leftJoinLoadFor('summary').execute()
+     *
+     * // Add where conditions to specific associations during preloading:
+     * await user.txn(txn).leftJoinLoadFor('detailed', (dreamClass, associationName) => {
+     *   if (dreamClass.typeof(Post) && associationName === 'comments') {
+     *     return { and: { published: true } }
+     *   }
+     * })
+     *    .execute()
+     *
+     * // Skip preloading specific associations to handle them manually:
+     * await user
+     *   .txn(txn)
+     *   .leftJoinLoadFor('summary', (dreamClass, associationName) => {
+     *     if (dreamClass.typeof(User) && associationName === 'posts') {
+     *       return 'omit' // Handle posts preloading separately with custom logic
+     *     }
+     *   })
+     *     .load('posts', { and: { featured: true } }) // Custom preloading
+     *     .execute()
+     * ```
+     *
+     * @param serializerKey - The serializer key to use for determining which associations to preload.
+     * @param modifierFn - Optional callback function to modify or omit specific associations during preloading. Called for each association with the Dream class and association name. Return an object with `and`, `andAny`, or `andNot` properties to add where conditions, return 'omit' to skip preloading that association (useful when you want to handle it manually), or return undefined to use default preloading
+     * @returns A Query with all serialization associations preloaded
+     */
+    leftJoinLoadFor<I extends DreamInstanceTransactionBuilder<DreamInstance>, SerializerKey extends DreamSerializerKey<DreamInstance>>(this: I, serializerKey: SerializerKey, modifierFn?: LoadForModifierFn): LeftJoinLoadBuilder<DreamInstance>;
     /**
      * Returns a new Query instance with the provided
      * inner join statement attached

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

@@ -1,6 +1,7 @@
 import Dream from '../Dream.js';
 import { PassthroughOnClause } from '../types/associations/shared.js';
-import { PassthroughColumnNames } from '../types/dream.js';
+import { DreamSerializerKey, PassthroughColumnNames } from '../types/dream.js';
+import { LoadForModifierFn } from '../types/query.js';
 import { VariadicLeftJoinLoadArgs } from '../types/variadic.js';
 import DreamTransaction from './DreamTransaction.js';
 export default class LeftJoinLoadBuilder<DreamInstance extends Dream> {
@@ -31,6 +32,52 @@ export default class LeftJoinLoadBuilder<DreamInstance extends Dream> {
      * ```
      */
     leftJoinLoad<I extends LeftJoinLoadBuilder<DreamInstance>, DB extends DreamInstance['DB'], TableName extends DreamInstance['table'], Schema extends DreamInstance['schema'], const Arr extends readonly unknown[], const LastArg extends VariadicLeftJoinLoadArgs<DB, Schema, TableName, Arr>>(this: I, ...args: [...Arr, LastArg]): I;
+    /**
+     * Recursively loads all Dream associations referenced by `rendersOne` and `rendersMany`
+     * in a DreamSerializer. This traverses the entire content tree of serializers to automatically
+     * load all necessary associations, eliminating N+1 query problems and removing the need to
+     * manually remember which associations to preload for serialization.
+     *
+     * This method decouples data loading code from data rendering code by having the serializer
+     * (rendering code) inform the query (loading code) about which associations are needed.
+     * As serializers evolve over time - adding new `rendersOne` and `rendersMany` calls or
+     * modifying existing ones - the loading code automatically adapts without requiring
+     * corresponding modifications to preload statements.
+     *
+     * This method analyzes the serializer (specified by `serializerKey` or 'default') and
+     * automatically preloads all associations that will be needed during serialization.
+     *
+     * ```ts
+     * // Instead of manually specifying all associations:
+     * await User.preload('posts', 'comments', 'replies').all()
+     *
+     * // Automatically preload everything needed for serialization:
+     * await user.leftJoinLoadFor('summary').execute()
+     *
+     * // Add where conditions to specific associations during preloading:
+     * await user.leftJoinLoadFor('detailed', (dreamClass, associationName) => {
+     *   if (dreamClass.typeof(Post) && associationName === 'comments') {
+     *     return { and: { published: true } }
+     *   }
+     * })
+     *    .execute()
+     *
+     * // Skip preloading specific associations to handle them manually:
+     * await user
+     *   .leftJoinLoadFor('summary', (dreamClass, associationName) => {
+     *     if (dreamClass.typeof(User) && associationName === 'posts') {
+     *       return 'omit' // Handle posts preloading separately with custom logic
+     *     }
+     *   })
+     *     .load('posts', { and: { featured: true } }) // Custom preloading
+     *     .execute()
+     * ```
+     *
+     * @param serializerKey - The serializer key to use for determining which associations to preload.
+     * @param modifierFn - Optional callback function to modify or omit specific associations during preloading. Called for each association with the Dream class and association name. Return an object with `and`, `andAny`, or `andNot` properties to add where conditions, return 'omit' to skip preloading that association (useful when you want to handle it manually), or return undefined to use default preloading
+     * @returns A Query with all serialization associations preloaded
+     */
+    leftJoinLoadFor<I extends LeftJoinLoadBuilder<DreamInstance>, SerializerKey extends DreamSerializerKey<DreamInstance>>(this: I, serializerKey: SerializerKey, modifierFn?: LoadForModifierFn): I;
     /**
      * executes a load builder query, binding
      * all associations to their respective model

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

@@ -1,6 +1,7 @@
 import Dream from '../Dream.js';
 import { PassthroughOnClause } from '../types/associations/shared.js';
-import { PassthroughColumnNames } from '../types/dream.js';
+import { DreamSerializerKey, PassthroughColumnNames } from '../types/dream.js';
+import { LoadForModifierFn } from '../types/query.js';
 import { VariadicLoadArgs } from '../types/variadic.js';
 import DreamTransaction from './DreamTransaction.js';
 export default class LoadBuilder<DreamInstance extends Dream> {
@@ -31,6 +32,52 @@ export default class LoadBuilder<DreamInstance extends Dream> {
      * ```
      */
     load<I extends LoadBuilder<DreamInstance>, DB extends DreamInstance['DB'], TableName extends DreamInstance['table'], Schema extends DreamInstance['schema'], const Arr extends readonly unknown[]>(this: I, ...args: [...Arr, VariadicLoadArgs<DB, Schema, TableName, Arr>]): I;
+    /**
+     * Recursively loads all Dream associations referenced by `rendersOne` and `rendersMany`
+     * in a DreamSerializer. This traverses the entire content tree of serializers to automatically
+     * load all necessary associations, eliminating N+1 query problems and removing the need to
+     * manually remember which associations to preload for serialization.
+     *
+     * This method decouples data loading code from data rendering code by having the serializer
+     * (rendering code) inform the query (loading code) about which associations are needed.
+     * As serializers evolve over time - adding new `rendersOne` and `rendersMany` calls or
+     * modifying existing ones - the loading code automatically adapts without requiring
+     * corresponding modifications to preload statements.
+     *
+     * This method analyzes the serializer (specified by `serializerKey` or 'default') and
+     * automatically preloads all associations that will be needed during serialization.
+     *
+     * ```ts
+     * // Instead of manually specifying all associations:
+     * await User.preload('posts', 'comments', 'replies').all()
+     *
+     * // Automatically preload everything needed for serialization:
+     * await user.loadFor('summary').execute()
+     *
+     * // Add where conditions to specific associations during preloading:
+     * await user.loadFor('detailed', (dreamClass, associationName) => {
+     *   if (dreamClass.typeof(Post) && associationName === 'comments') {
+     *     return { and: { published: true } }
+     *   }
+     * })
+     *    .execute()
+     *
+     * // Skip preloading specific associations to handle them manually:
+     * await user
+     *   .loadFor('summary', (dreamClass, associationName) => {
+     *     if (dreamClass.typeof(User) && associationName === 'posts') {
+     *       return 'omit' // Handle posts preloading separately with custom logic
+     *     }
+     *   })
+     *     .load('posts', { and: { featured: true } }) // Custom preloading
+     *     .execute()
+     * ```
+     *
+     * @param serializerKey - The serializer key to use for determining which associations to preload.
+     * @param modifierFn - Optional callback function to modify or omit specific associations during preloading. Called for each association with the Dream class and association name. Return an object with `and`, `andAny`, or `andNot` properties to add where conditions, return 'omit' to skip preloading that association (useful when you want to handle it manually), or return undefined to use default preloading
+     * @returns A Query with all serialization associations preloaded
+     */
+    loadFor<I extends LoadBuilder<DreamInstance>, SerializerKey extends DreamSerializerKey<DreamInstance>>(this: I, serializerKey: SerializerKey, modifierFn?: LoadForModifierFn): I;
     /**
      * executes a load builder query, binding
      * all associations to their respective model

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

@@ -2,8 +2,8 @@ import { DeleteQueryBuilder, SelectQueryBuilder, UpdateQueryBuilder } from 'kyse
 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, DreamAssociationNames, DreamColumnNames, DreamConstructorType, DreamSerializerKey, DreamTableSchema, OrderDir, PassthroughColumnNames, PluckEachArgs, PrimaryKeyForFind, RelaxedJoinAndStatement, RelaxedJoinStatement, RelaxedPreloadOnStatement, RelaxedPreloadStatement, TableColumnNames, TableOrAssociationName } from '../types/dream.js';
-import { DefaultQueryTypeOptions, ExtendQueryType, NamespacedOrBaseModelColumnTypes, PaginatedDreamQueryOptions, PaginatedDreamQueryResult, QueryToKyselyDBType, QueryToKyselyTableNamesType } from '../types/query.js';
+import { AllDefaultScopeNames, DefaultScopeName, DreamColumnNames, DreamConstructorType, DreamSerializerKey, DreamTableSchema, OrderDir, PassthroughColumnNames, PluckEachArgs, PrimaryKeyForFind, RelaxedJoinAndStatement, RelaxedJoinStatement, RelaxedPreloadOnStatement, RelaxedPreloadStatement, TableColumnNames, TableOrAssociationName } from '../types/dream.js';
+import { DefaultQueryTypeOptions, ExtendQueryType, LoadForModifierFn, NamespacedOrBaseModelColumnTypes, PaginatedDreamQueryOptions, PaginatedDreamQueryResult, QueryToKyselyDBType, QueryToKyselyTableNamesType } from '../types/query.js';
 import { JoinedAssociation, JoinedAssociationsTypeFromAssociations, QueryTypeOptions, VariadicJoinsArgs, VariadicLeftJoinLoadArgs, VariadicLoadArgs } from '../types/variadic.js';
 import DreamTransaction from './DreamTransaction.js';
 import PostgresQueryDriver from './QueryDriver/Postgres.js';
@@ -361,46 +361,33 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
      * await User.preload('posts', 'comments', 'replies').all()
      *
      * // Automatically preload everything needed for serialization:
-     * await User.preloadForSerialization({ serializerKey: 'summary' }).all()
+     * await User.preloadFor('summary').all()
      *
      * // Add where conditions to specific associations during preloading:
-     * await User.preloadForSerialization({
-     *   serializerKey: 'detailed',
-     *   modifierFn: (dreamClass, associationName) => {
-     *     if (dreamClass.typeof(Post) && associationName === 'comments') {
-     *       return { and: { published: true } }
-     *     }
+     * await User.preloadFor('detailed', (dreamClass, associationName) => {
+     *   if (dreamClass.typeof(Post) && associationName === 'comments') {
+     *     return { and: { published: true } }
      *   }
-     * }).all()
+     * })
+     *   .all()
      *
      * // Skip preloading specific associations to handle them manually:
-     * await User.preloadForSerialization({
-     *   serializerKey: 'summary',
-     *   modifierFn: (dreamClass, associationName) => {
-     *     if (dreamClass.typeof(User) && associationName === 'posts') {
-     *       return 'omit' // Handle posts preloading separately with custom logic
-     *     }
+     * await User.preloadFor('summary', (dreamClass, associationName) => {
+     *   if (dreamClass.typeof(User) && associationName === 'posts') {
+     *     return 'omit' // Handle posts preloading separately with custom logic
      *   }
      * })
-     * .preload('posts', { and: { featured: true } }) // Custom preloading
-     * .all()
+     *   .preload('posts', { and: { featured: true } }) // Custom preloading
+     *   .all()
      * ```
      *
-     * @param opts - Configuration options for serialization preloading
-     * @param opts.serializerKey - The serializer key to use for determining which associations to preload. Defaults to 'default'
-     * @param opts.modifierFn - Optional callback function to modify or omit specific associations during preloading. Called for each association with the Dream class and association name. Return an object with `and`, `andAny`, or `andNot` properties to add where conditions, return 'omit' to skip preloading that association (useful when you want to handle it manually), or return undefined to use default preloading
+     * @param serializerKey - The serializer key to use for determining which associations to preload.
+     * @param modifierFn - Optional callback function to modify or omit specific associations during preloading. Called for each association with the Dream class and association name. Return an object with `and`, `andAny`, or `andNot` properties to add where conditions, return 'omit' to skip preloading that association (useful when you want to handle it manually), or return undefined to use default preloading
      * @returns A Query with all serialization associations preloaded
      */
-    preloadForSerialization<Q extends Query<DreamInstance, any>, SerializerKey extends DreamSerializerKey<DreamInstance>, RetQuery = Query<DreamInstance, ExtendQueryType<QueryTypeOpts, Readonly<{
+    preloadFor<Q extends Query<DreamInstance, any>, SerializerKey extends DreamSerializerKey<DreamInstance>, RetQuery = Query<DreamInstance, ExtendQueryType<QueryTypeOpts, Readonly<{
         allowLeftJoinPreload: false;
-    }>>>>(this: Q, { serializerKey, modifierFn, }?: {
-        serializerKey?: SerializerKey;
-        modifierFn?: <DreamClass extends typeof Dream, const AssociationName extends DreamAssociationNames<InstanceType<DreamClass>>>(dreamClass: DreamClass, associationName: AssociationName) => {
-            and?: object;
-            andAny?: object;
-            andNot?: object;
-        } | 'omit' | undefined;
-    }): RetQuery;
+    }>>>>(this: Q, serializerKey: SerializerKey, modifierFn?: LoadForModifierFn): RetQuery;
     /**
      * Recursively preloads all Dream associations referenced by `rendersOne` and `rendersMany`
      * in a DreamSerializer using left join preloading. This traverses the entire content tree
@@ -425,50 +412,36 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
      * await User.leftJoinPreload('posts', 'comments', 'replies').all()
      *
      * // Automatically left join preload everything needed for serialization:
-     * await User.leftJoinPreloadForSerialization({ serializerKey: 'summary' }).all()
+     * await User.leftJoinPreloadFor('summary').all()
      *
      * // Add where conditions to specific associations during left join preloading:
-     * await User.leftJoinPreloadForSerialization({
-     *   serializerKey: 'detailed',
-     *   modifierFn: (dreamClass, associationName) => {
-     *     if (dreamClass.typeof(Post) && associationName === 'comments') {
-     *       return { and: { published: true } }
-     *     }
+     * await User.leftJoinPreloadFor('detailed', (dreamClass, associationName) => {
+     *   if (dreamClass.typeof(Post) && associationName === 'comments') {
+     *     return { and: { published: true } }
      *   }
-     * }).all()
+     * })
+     *   .all()
      *
      * // Skip left join preloading specific associations to handle them manually:
-     * await User.leftJoinPreloadForSerialization({
-     *   serializerKey: 'summary',
-     *   modifierFn: (dreamClass, associationName) => {
-     *     if (dreamClass.typeof(User) && associationName === 'posts') {
-     *       return 'omit' // Handle posts preloading separately with custom logic
-     *     }
+     * await User.leftJoinPreloadFor('summary', (dreamClass, associationName) => {
+     *   if (dreamClass.typeof(User) && associationName === 'posts') {
+     *     return 'omit' // Handle posts preloading separately with custom logic
      *   }
      * })
-     * .preload('posts', { and: { featured: true } }) // Custom preloading instead
-     * .all()
+     *   .preload('posts', { and: { featured: true } }) // Custom preloading instead
+     *   .all()
      * ```
      *
-     * @param opts - Configuration options for serialization preloading
-     * @param opts.serializerKey - The serializer key to use for determining which associations to preload. Defaults to 'default'
-     * @param opts.modifierFn - Optional callback function to modify or omit specific associations during preloading. Called for each association with the Dream class and association name. Return an object with `and`, `andAny`, or `andNot` properties to add where conditions, return 'omit' to skip preloading that association (useful when you want to handle it manually), or return undefined to use default preloading
+     * @param serializerKey - The serializer key to use for determining which associations to preload.
+     * @param modifierFn - Optional callback function to modify or omit specific associations during preloading. Called for each association with the Dream class and association name. Return an object with `and`, `andAny`, or `andNot` properties to add where conditions, return 'omit' to skip preloading that association (useful when you want to handle it manually), or return undefined to use default preloading
      * @returns A Query with all serialization associations left join preloaded
      */
-    leftJoinPreloadForSerialization<Q extends Query<DreamInstance, any>, SerializerKey extends DreamSerializerKey<DreamInstance>, RetQuery = Query<DreamInstance, ExtendQueryType<QueryTypeOpts, Readonly<{
+    leftJoinPreloadFor<Q extends Query<DreamInstance, any>, SerializerKey extends DreamSerializerKey<DreamInstance>, RetQuery = Query<DreamInstance, ExtendQueryType<QueryTypeOpts, Readonly<{
         allowPreload: false;
         allowLimit: false;
         allowOffset: false;
         allowPaginate: false;
-    }>>>>(this: Q, { serializerKey, modifierFn, }?: {
-        serializerKey?: SerializerKey;
-        modifierFn?: <DreamClass extends typeof Dream, const AssociationName extends DreamAssociationNames<InstanceType<DreamClass>>>(dreamClass: DreamClass, associationName: AssociationName) => {
-            and?: object;
-            andAny?: object;
-            andNot?: object;
-        } | 'omit' | undefined;
-    }): RetQuery;
-    private convertDreamClassAndAssociationNameTupleArrayToPreloadArgs;
+    }>>>>(this: Q, serializerKey: SerializerKey, modifierFn?: LoadForModifierFn): RetQuery;
     /**
      * Returns a new Query instance, with the provided
      * joins statement attached

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

@@ -0,0 +1,9 @@
+import { LoadForModifierFn } from '../../types/query.js';
+import { DreamClassAndAssociationNameTuple } from './extractNestedPaths.js';
+export default function convertDreamClassAndAssociationNameTupleArrayToPreloadArgs(dreamClassAndAssociationNameTupleArray: DreamClassAndAssociationNameTuple[], modifierFn?: LoadForModifierFn, counter?: {
+    count: number;
+}): (string | {
+    and?: object;
+    andAny?: object;
+    andNot?: object;
+})[];

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

@@ -0,0 +1 @@
+export default function unaliasTableName(tableName: string): string;

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

@@ -88,4 +88,9 @@ export interface PaginatedDreamQueryResult<T extends Dream> {
      */
     results: T[];
 }
+export type LoadForModifierFn = (dreamClass: typeof Dream, associationName: string) => {
+    and?: object;
+    andAny?: object;
+    andNot?: object;
+} | 'omit' | undefined;
 export {};

package/dist/types/src/types/query.ts

@@ -203,3 +203,8 @@ export interface PaginatedDreamQueryResult<T extends Dream> {
    */
   results: T[]
 }
+
+export type LoadForModifierFn = (
+  dreamClass: typeof Dream,
+  associationName: string
+) => { and?: object; andAny?: object; andNot?: object } | 'omit' | undefined