@rvoh/dream 2.0.0-alpha.3 → 2.0.0-alpha.5

package/dist/cjs/src/Dream.js

@@ -1403,56 +1403,6 @@ export default class Dream {
     static preloadFor(serializerKey, modifierFn) {
         return this.query().preloadFor(serializerKey, modifierFn);
     }
-    /**
-     * Recursively preloads all Dream associations referenced by `rendersOne` and `rendersMany`
-     * in a DreamSerializer using left join preloading. This traverses the entire content tree
-     * of serializers to automatically load all necessary associations in a single query,
-     * 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 left join preload statements.
-     *
-     * This method analyzes the serializer (specified by `serializerKey` or 'default') and
-     * automatically left join preloads all associations that will be needed during serialization.
-     *
-     * Note: Left join preloading loads all data in a single SQL query but has trade-offs compared
-     * to regular preloading. See {@link Dream.leftJoinPreload} for details about limitations.
-     *
-     * ```ts
-     * // Instead of manually specifying all associations:
-     * await User.leftJoinPreload('posts', 'comments', 'replies').all()
-     *
-     * // Automatically left join preload everything needed for serialization:
-     * await User.leftJoinPreloadFor('summary').all()
-     *
-     * // Add where conditions to specific associations during left join preloading:
-     * await User.leftJoinPreloadFor('detailed', (associationName, dreamClass) => {
-     *   if (dreamClass.typeof(Post) && associationName === 'comments') {
-     *     return { and: { published: true } }
-     *   }
-     * }).all()
-     *
-     * // Skip left join preloading specific associations to handle them manually:
-     * await User.leftJoinPreloadFor('summary', (associationName, dreamClass) => {
-     *   if (dreamClass.typeof(User) && associationName === 'posts') {
-     *     return 'omit' // Handle posts preloading separately with custom logic
-     *   }
-     * })
-     * .preload('posts', { and: { featured: true } }) // Custom preloading instead
-     * .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 left join preloaded
-     */
-    static leftJoinPreloadFor(serializerKey, modifierFn) {
-        return this.query().leftJoinPreloadFor(serializerKey, modifierFn);
-    }
     /**
      * Returns a new Query instance with the provided
      * inner join statement attached
@@ -3375,57 +3325,6 @@ export default class Dream {
     leftJoinLoad(...args) {
         return new LeftJoinLoadBuilder(this).leftJoinLoad(...args);
     }
-    /**
-     * 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.
-     *
-     * Note: Left join loading loads all data in a single SQL query but has trade-offs compared
-     * to regular preloading. See {@link Dream.leftJoinPreload} for details about limitations.
-     *
-     * ```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', (associationName, dreamClass) => {
-     *   if (dreamClass.typeof(Post) && associationName === 'comments') {
-     *     return { and: { published: true } }
-     *   }
-     * })
-     *    .execute()
-     *
-     * // Skip preloading specific associations to handle them manually:
-     * await user
-     *   .loadFor('summary', (associationName, dreamClass) => {
-     *     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(serializerKey, modifierFn) {
-        return new LeftJoinLoadBuilder(this)['leftJoinLoadFor'](serializerKey, modifierFn);
-    }
     /**
      * Returns true if the association specified has
      * been loaded on this instance

package/dist/cjs/src/db/migration-helpers/DreamMigrationHelpers.js

@@ -17,7 +17,10 @@ export default class DreamMigrationHelpers {
      */
     static async renameTable(db, from, to) {
         await db.schema.alterTable(from).renameTo(to).execute();
-        await sql `ALTER SEQUENCE ${from}_id_seq RENAME TO ${to}_id_seq`.execute(db);
+        const fromSequenceName = `${from}_id_seq`;
+        const toSequenceName = `${to}_id_seq`;
+        const sqlStatement = `ALTER SEQUENCE ${fromSequenceName} RENAME TO ${toSequenceName}`;
+        await sql.raw(sqlStatement).execute(db);
     }
     /**
      * Unique indexes cannot be populated by the same value even within a transaction,

package/dist/cjs/src/dream/DreamClassTransactionBuilder.js

@@ -362,54 +362,6 @@ export default class DreamClassTransactionBuilder {
     leftJoinPreload(...args) {
         return this.queryInstance().leftJoinPreload(...args);
     }
-    /**
-     * 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
-     * await ApplicationModel.transaction(async txn => {
-     *   // Instead of manually specifying all associations:
-     *   await User.txn(txn).preload('posts', 'comments', 'replies').all()
-     *
-     *   // Automatically preload everything needed for serialization:
-     *   await User.txn(txn).preloadFor('summary').all()
-     *
-     *   // Add where conditions to specific associations during preloading:
-     *   await User.txn(txn).leftJoinPreloadFor('detailed', (associationName, dreamClass) => {
-     *     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', (associationName, dreamClass) => {
-     *     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(serializerKey, modifierFn) {
-        return this.queryInstance().leftJoinPreloadFor(serializerKey, modifierFn);
-    }
     /**
      * Applies preload statement to a Query scoped to this model.
      * Upon instantiating records of this model type,

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

@@ -143,56 +143,6 @@ export default class DreamInstanceTransactionBuilder {
     leftJoinLoad(...args) {
         return new LeftJoinLoadBuilder(this.dreamInstance, this.dreamTransaction).leftJoinLoad(...args);
     }
-    /**
-     * 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
-     * await ApplicationModel.transaction(async txn => {
-     *   // Instead of manually specifying all associations:
-     *   await User.txn(txn).preload('posts', 'comments', 'replies').all()
-     *
-     *   // Automatically preload everything needed for serialization:
-     *   await user.txn(txn).leftJoinLoadFor('summary').execute()
-     *
-     *   // Add where conditions to specific associations during preloading:
-     *   await user.txn(txn).leftJoinLoadFor('detailed', (associationName, dreamClass) => {
-     *     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', (associationName, dreamClass) => {
-     *       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(serializerKey, modifierFn) {
-        return new LeftJoinLoadBuilder(this.dreamInstance, this.dreamTransaction)['leftJoinLoadFor'](serializerKey, modifierFn);
-    }
     /**
      * Returns a new Query instance with the provided
      * inner join statement attached

package/dist/cjs/src/dream/LeftJoinLoadBuilder.js

@@ -38,55 +38,6 @@ export default class LeftJoinLoadBuilder {
         this.query = this.query.leftJoinPreload(...args);
         return this;
     }
-    /**
-     * 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', (associationName, dreamClass) => {
-     *   if (dreamClass.typeof(Post) && associationName === 'comments') {
-     *     return { and: { published: true } }
-     *   }
-     * })
-     *    .execute()
-     *
-     * // Skip preloading specific associations to handle them manually:
-     * await user
-     *   .leftJoinLoadFor('summary', (associationName, dreamClass) => {
-     *     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(serializerKey, modifierFn) {
-        this.query = this.query.leftJoinPreloadFor(serializerKey, modifierFn);
-        return this;
-    }
     /**
      * executes a load builder query, binding
      * all associations to their respective model

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

@@ -530,63 +530,6 @@ export default class Query {
         });
         return query;
     }
-    /**
-     * Recursively preloads all Dream associations referenced by `rendersOne` and `rendersMany`
-     * in a DreamSerializer using left join preloading. This traverses the entire content tree
-     * of serializers to automatically load all necessary associations in a single query,
-     * 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 left join preload statements.
-     *
-     * This method analyzes the serializer (specified by `serializerKey` or 'default') and
-     * automatically left join preloads all associations that will be needed during serialization.
-     *
-     * Note: Left join preloading loads all data in a single SQL query but has trade-offs compared
-     * to regular preloading. See {@link Dream.leftJoinPreload} for details about limitations.
-     *
-     * ```ts
-     * // Instead of manually specifying all associations:
-     * await User.leftJoinPreload('posts', 'comments', 'replies').all()
-     *
-     * // Automatically left join preload everything needed for serialization:
-     * await User.leftJoinPreloadFor('summary').all()
-     *
-     * // Add where conditions to specific associations during left join preloading:
-     * await User.leftJoinPreloadFor('detailed', (associationName, dreamClass) => {
-     *   if (dreamClass.typeof(Post) && associationName === 'comments') {
-     *     return { and: { published: true } }
-     *   }
-     * })
-     *   .all()
-     *
-     * // Skip left join preloading specific associations to handle them manually:
-     * await User.leftJoinPreloadFor('summary', (associationName, dreamClass) => {
-     *   if (dreamClass.typeof(User) && associationName === 'posts') {
-     *     return 'omit' // Handle posts preloading separately with custom logic
-     *   }
-     * })
-     *   .preload('posts', { and: { featured: true } }) // Custom preloading instead
-     *   .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 left join preloaded
-     */
-    leftJoinPreloadFor(serializerKey, modifierFn) {
-        const preloadArgs = extractNestedPaths(this.dreamClass['serializationMap'](serializerKey));
-        let query = this;
-        const counter = { count: 0 };
-        preloadArgs.forEach(dreamClassAndAssociationNameTupleArray => {
-            query = query.leftJoinPreload(...convertDreamClassAndAssociationNameTupleArrayToPreloadArgs(dreamClassAndAssociationNameTupleArray, modifierFn, counter));
-        });
-        return query;
-    }
     /**
      * Returns a new Query instance, with the provided
      * joins statement attached

package/dist/esm/src/Dream.js

@@ -1403,56 +1403,6 @@ export default class Dream {
     static preloadFor(serializerKey, modifierFn) {
         return this.query().preloadFor(serializerKey, modifierFn);
     }
-    /**
-     * Recursively preloads all Dream associations referenced by `rendersOne` and `rendersMany`
-     * in a DreamSerializer using left join preloading. This traverses the entire content tree
-     * of serializers to automatically load all necessary associations in a single query,
-     * 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 left join preload statements.
-     *
-     * This method analyzes the serializer (specified by `serializerKey` or 'default') and
-     * automatically left join preloads all associations that will be needed during serialization.
-     *
-     * Note: Left join preloading loads all data in a single SQL query but has trade-offs compared
-     * to regular preloading. See {@link Dream.leftJoinPreload} for details about limitations.
-     *
-     * ```ts
-     * // Instead of manually specifying all associations:
-     * await User.leftJoinPreload('posts', 'comments', 'replies').all()
-     *
-     * // Automatically left join preload everything needed for serialization:
-     * await User.leftJoinPreloadFor('summary').all()
-     *
-     * // Add where conditions to specific associations during left join preloading:
-     * await User.leftJoinPreloadFor('detailed', (associationName, dreamClass) => {
-     *   if (dreamClass.typeof(Post) && associationName === 'comments') {
-     *     return { and: { published: true } }
-     *   }
-     * }).all()
-     *
-     * // Skip left join preloading specific associations to handle them manually:
-     * await User.leftJoinPreloadFor('summary', (associationName, dreamClass) => {
-     *   if (dreamClass.typeof(User) && associationName === 'posts') {
-     *     return 'omit' // Handle posts preloading separately with custom logic
-     *   }
-     * })
-     * .preload('posts', { and: { featured: true } }) // Custom preloading instead
-     * .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 left join preloaded
-     */
-    static leftJoinPreloadFor(serializerKey, modifierFn) {
-        return this.query().leftJoinPreloadFor(serializerKey, modifierFn);
-    }
     /**
      * Returns a new Query instance with the provided
      * inner join statement attached
@@ -3375,57 +3325,6 @@ export default class Dream {
     leftJoinLoad(...args) {
         return new LeftJoinLoadBuilder(this).leftJoinLoad(...args);
     }
-    /**
-     * 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.
-     *
-     * Note: Left join loading loads all data in a single SQL query but has trade-offs compared
-     * to regular preloading. See {@link Dream.leftJoinPreload} for details about limitations.
-     *
-     * ```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', (associationName, dreamClass) => {
-     *   if (dreamClass.typeof(Post) && associationName === 'comments') {
-     *     return { and: { published: true } }
-     *   }
-     * })
-     *    .execute()
-     *
-     * // Skip preloading specific associations to handle them manually:
-     * await user
-     *   .loadFor('summary', (associationName, dreamClass) => {
-     *     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(serializerKey, modifierFn) {
-        return new LeftJoinLoadBuilder(this)['leftJoinLoadFor'](serializerKey, modifierFn);
-    }
     /**
      * Returns true if the association specified has
      * been loaded on this instance

package/dist/esm/src/db/migration-helpers/DreamMigrationHelpers.js

@@ -17,7 +17,10 @@ export default class DreamMigrationHelpers {
      */
     static async renameTable(db, from, to) {
         await db.schema.alterTable(from).renameTo(to).execute();
-        await sql `ALTER SEQUENCE ${from}_id_seq RENAME TO ${to}_id_seq`.execute(db);
+        const fromSequenceName = `${from}_id_seq`;
+        const toSequenceName = `${to}_id_seq`;
+        const sqlStatement = `ALTER SEQUENCE ${fromSequenceName} RENAME TO ${toSequenceName}`;
+        await sql.raw(sqlStatement).execute(db);
     }
     /**
      * Unique indexes cannot be populated by the same value even within a transaction,

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

@@ -362,54 +362,6 @@ export default class DreamClassTransactionBuilder {
     leftJoinPreload(...args) {
         return this.queryInstance().leftJoinPreload(...args);
     }
-    /**
-     * 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
-     * await ApplicationModel.transaction(async txn => {
-     *   // Instead of manually specifying all associations:
-     *   await User.txn(txn).preload('posts', 'comments', 'replies').all()
-     *
-     *   // Automatically preload everything needed for serialization:
-     *   await User.txn(txn).preloadFor('summary').all()
-     *
-     *   // Add where conditions to specific associations during preloading:
-     *   await User.txn(txn).leftJoinPreloadFor('detailed', (associationName, dreamClass) => {
-     *     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', (associationName, dreamClass) => {
-     *     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(serializerKey, modifierFn) {
-        return this.queryInstance().leftJoinPreloadFor(serializerKey, modifierFn);
-    }
     /**
      * Applies preload statement to a Query scoped to this model.
      * Upon instantiating records of this model type,

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

@@ -143,56 +143,6 @@ export default class DreamInstanceTransactionBuilder {
     leftJoinLoad(...args) {
         return new LeftJoinLoadBuilder(this.dreamInstance, this.dreamTransaction).leftJoinLoad(...args);
     }
-    /**
-     * 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
-     * await ApplicationModel.transaction(async txn => {
-     *   // Instead of manually specifying all associations:
-     *   await User.txn(txn).preload('posts', 'comments', 'replies').all()
-     *
-     *   // Automatically preload everything needed for serialization:
-     *   await user.txn(txn).leftJoinLoadFor('summary').execute()
-     *
-     *   // Add where conditions to specific associations during preloading:
-     *   await user.txn(txn).leftJoinLoadFor('detailed', (associationName, dreamClass) => {
-     *     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', (associationName, dreamClass) => {
-     *       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(serializerKey, modifierFn) {
-        return new LeftJoinLoadBuilder(this.dreamInstance, this.dreamTransaction)['leftJoinLoadFor'](serializerKey, modifierFn);
-    }
     /**
      * Returns a new Query instance with the provided
      * inner join statement attached