@rvoh/dream 2.5.7 → 2.5.8

package/dist/cjs/src/Dream.js

@@ -3238,13 +3238,28 @@ export default class Dream {
         return new LoadBuilder(this).passthrough(passthroughWhereStatement);
     }
     /**
-     * Loads the requested associations upon execution
+     * Loads the requested associations upon execution.
+     *
+     * **IMPORTANT:** `load().execute()` returns a **new clone** of the model with the
+     * associations loaded. It does NOT modify the original instance. You must use the
+     * returned value:
+     *
+     * ```ts
+     * // CORRECT — use the returned clone:
+     * const loaded = await user.load('posts').execute()
+     * loaded.posts // works
+     *
+     * // WRONG — original is not modified:
+     * await user.load('posts').execute()
+     * user.posts // association not loaded!
+     * ```
      *
      * NOTE: {@link Dream.preload} is often a preferrable way of achieving the
-     * same goal.
+     * same goal. Alternatively, `await model.association('posts')` loads only
+     * if the association is not already loaded.
      *
      * ```ts
-     * await user
+     * const user = await user
      *  .load('posts', { body: ops.ilike('%hello world%') }, 'comments', 'replies')
      *  .load('images')
      *  .execute()
@@ -3257,7 +3272,7 @@ export default class Dream {
      * ```
      *
      * @param args - A list of associations (and optional where clauses) to load
-     * @returns A chainable LoadBuilder instance
+     * @returns A chainable LoadBuilder instance. Call `.execute()` to get the cloned model with associations loaded.
      */
     load(...args) {
         return new LoadBuilder(this).load(...args);
@@ -3326,19 +3341,19 @@ export default class Dream {
      * Load each specified association using a single SQL query.
      * See {@link Dream.load} for loading in separate queries.
      *
+     * **IMPORTANT:** Like `load()`, `leftJoinLoad().execute()` returns a **new clone** of the
+     * model with associations loaded. It does NOT modify the original instance.
+     *
      * Note: since leftJoinLoad loads via single query, it has
-     * some downsides and that may be avoided using {@link Dream.load}:
+     * some downsides that may be avoided using {@link Dream.load}:
      * 1. `limit` and `offset` will be automatically removed
      * 2. `through` associations will bring additional namespaces into the query that can conflict with through associations from other associations, creating an invalid query
      * 3. each nested association will result in an additional record which duplicates data from the outer record. E.g., given `.leftJoinLoad('a', 'b', 'c')`, if each `a` has 10 `b` and each `b` has 10 `c`, then for one `a`, 100 records will be returned, each of which has all of the columns of `a`. `.load('a', 'b', 'c')` would perform three separate SQL queries, but the data for a single `a` would only be returned once.
      * 4. the individual query becomes more complex the more associations are included
      * 5. associations loading associations loading associations could result in exponential amounts of data; in those cases, `.load(...).findEach(...)` avoids instantiating massive amounts of data at once
      *
-     * 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
-     * await user
+     * const user = await user
      *  .leftJoinLoad('posts', { body: ops.ilike('%hello world%') }, 'comments', 'replies')
      *  .leftJoinLoad('images')
      *  .execute()
@@ -3351,7 +3366,7 @@ export default class Dream {
      * ```
      *
      * @param args - A list of associations (and optional where clauses) to load
-     * @returns A chainable LeftJoinLoadBuilder instance
+     * @returns A chainable LeftJoinLoadBuilder instance. Call `.execute()` to get the cloned model with associations loaded.
      */
     leftJoinLoad(...args) {
         return new LeftJoinLoadBuilder(this).leftJoinLoad(...args);

package/dist/cjs/src/decorators/class/STI.js

@@ -3,7 +3,7 @@ import StiChildIncompatibleWithReplicaSafeDecorator from '../../errors/sti/StiCh
 import StiChildIncompatibleWithSoftDeleteDecorator from '../../errors/sti/StiChildIncompatibleWithSoftDeleteDecorator.js';
 import { scopeImplementation } from '../static-method/Scope.js';
 export const STI_SCOPE_NAME = 'dream:STI';
-export default function STI(dreamClass, { value } = {}) {
+export default function STI(dreamClass) {
     return function (target) {
         const stiChildClass = target;
         const baseClass = dreamClass['sti'].baseClass || dreamClass;
@@ -21,7 +21,7 @@ export default function STI(dreamClass, { value } = {}) {
         stiChildClass['sti'] = {
             active: true,
             baseClass,
-            value: value || stiChildClass.sanitizedName,
+            value: stiChildClass.sanitizedName,
         };
         stiChildClass[STI_SCOPE_NAME] = function (query) {
             return query.where({ type: stiChildClass['sti'].value });

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

@@ -5,13 +5,16 @@ export default class LeftJoinLoadBuilder {
     dream;
     query;
     /**
-     * An intermediate class on the way to executing a load
-     * query. this can be accessed on an instance of a dream
-     * model by using the `#load` method:
+     * An intermediate builder for loading associations onto a Dream model
+     * via a single left-join SQL query. Accessed via `#leftJoinLoad`.
+     *
+     * **Note:** The LeftJoinLoadBuilder works on a clone of the original model.
+     * Call `.execute()` to get the clone with associations loaded.
      *
      * ```ts
      * const user = await User.firstOrFail()
-     * await user.load('settings').execute()
+     * const loaded = await user.leftJoinLoad('settings').execute()
+     * loaded.settings // association is loaded on the returned clone
      * ```
      */
     constructor(dream, dreamTransaction) {
@@ -39,17 +42,20 @@ export default class LeftJoinLoadBuilder {
         return this;
     }
     /**
-     * executes a load builder query, binding
-     * all associations to their respective model
-     * instances.
+     * Executes the left-join load query, returning a **clone** of the original model
+     * with all requested associations loaded. The original instance is not modified.
      *
      * ```ts
      * const user = await User.firstOrFail()
-     * await user
-     *   .load('settings')
-     *   .load('posts', 'comments', 'replies', ['image', 'localizedText'])
+     * const loaded = await user
+     *   .leftJoinLoad('settings')
+     *   .leftJoinLoad('posts', 'comments', 'replies')
      *   .execute()
+     *
+     * loaded.settings // works — associations are on the returned clone
      * ```
+     *
+     * @returns A clone of the Dream instance with all requested associations loaded
      */
     async execute() {
         if (this.dreamTransaction) {

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

@@ -3,13 +3,16 @@ export default class LoadBuilder {
     dream;
     query;
     /**
-     * An intermediate class on the way to executing a load
-     * query. this can be accessed on an instance of a dream
-     * model by using the `#load` method:
+     * An intermediate builder for loading associations onto a Dream model.
+     * Accessed via the `#load` method on a Dream instance.
+     *
+     * **Note:** The LoadBuilder works on a clone of the original model.
+     * Call `.execute()` to get the clone with associations loaded.
      *
      * ```ts
      * const user = await User.firstOrFail()
-     * await user.load('settings').execute()
+     * const loaded = await user.load('settings').execute()
+     * loaded.settings // association is loaded on the returned clone
      * ```
      */
     constructor(dream, dreamTransaction) {
@@ -89,19 +92,22 @@ export default class LoadBuilder {
         return this;
     }
     /**
-     * Executes a load builder query, binding
-     * all associations to their respective model
-     * instances.
+     * Executes the load query, binding all associations to a **clone** of the
+     * original model instance. The original instance is not modified.
+     *
+     * You must use the returned value to access the loaded associations:
      *
      * ```ts
      * const user = await User.firstOrFail()
-     * await user
+     * const loaded = await user
      *   .load('settings')
      *   .load('posts', 'comments', 'replies', ['image', 'localizedText'])
      *   .execute()
+     *
+     * loaded.settings // works — associations are on the returned clone
      * ```
      *
-     * @returns The Dream instance with all associations loaded
+     * @returns A clone of the Dream instance with all requested associations loaded
      */
     async execute() {
         if (this.dreamTransaction) {

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

@@ -1698,7 +1698,7 @@ export default class Query {
      * Updates all records matching the Query
      *
      * ```ts
-     * await User.where({ email: ops.ilike('%burpcollaborator%') }).updateAll({ email: null })
+     * await User.where({ email: ops.ilike('%burpcollaborator%') }).update({ email: null })
      * // 12
      * ```
      * @param attributes - The attributes used to update the records

package/dist/cjs/src/serializer/builders/DreamSerializerBuilder.js

@@ -20,30 +20,46 @@ export default class DreamSerializerBuilder {
     /**
      * Includes an attribute from a nested object in the serialized output.
      *
-     * Serializes an attribute from a target object. If the target object or
-     * the delegated attribute is null/undefined, the `default` option value
+     * Accesses `targetName.name` on the data object. If the target object
+     * or the delegated attribute is null/undefined, the `default` option value
      * will be used if provided.
      *
-     * @param targetName - The property name containing the target object
+     * When the target is a Dream model, OpenAPI types may be automatically inferred
+     * for standard database columns. For json/jsonb columns or non-Dream targets,
+     * the `openapi` option is required.
+     *
+     * @param targetName - The property name containing the target object (e.g., an association name)
      * @param name - The attribute name within the target object
-     * @param options - Configuration options including OpenAPI schema, default value, and output customization
+     * @param options - Configuration options:
+     *   - `as` - Rename the attribute key in the serialized output and OpenAPI shape
+     *     (e.g., delegating `'user', 'email'` with `as: 'userEmail'` outputs the value
+     *     under `userEmail`)
+     *   - `default` - Value to use when the target object or its attribute is null/undefined
+     *   - `openapi` - OpenAPI schema definition; required for non-Dream targets and json/jsonb
+     *     columns, optional for standard Dream columns (where types are inferred)
+     *   - `precision` - Round decimal values to the specified number of decimal places (0–9)
+     *     during rendering; does not affect the OpenAPI shape
+     *   - `required` - Set to `false` to mark the attribute as optional in the OpenAPI schema;
+     *     when omitted, attributes are required by default
      * @returns The serializer builder for method chaining
      *
      * @example
      * ```typescript
-     * // Delegate to user.email
-     * .delegatedAttribute('user', 'email', {
-     *   openapi: { type: 'string', format: 'email' }
-     * })
+     * // Delegate to a Dream association's column (type inferred)
+     * .delegatedAttribute('currentLocalizedText', 'title', { openapi: 'string' })
      *
      * // With default value for null target or attribute
      * .delegatedAttribute('user', 'displayName', {
      *   openapi: { type: 'string' },
      *   default: 'Unknown User'
      * })
-     * ```
      *
-     * See: {@link https://your-docs-url.com/docs/serializers/attributes | Serializer Attributes Documentation}
+     * // Rename the output key
+     * .delegatedAttribute('profile', 'avatarUrl', {
+     *   openapi: 'string',
+     *   as: 'avatar'
+     * })
+     * ```
      */
     delegatedAttribute(targetName, name, options) {
         this.attributes.push({
@@ -62,7 +78,17 @@ export default class DreamSerializerBuilder {
      *
      * @param name - The attribute name for the computed value
      * @param fn - Callback function that returns the computed value
-     * @param options - Configuration options including required OpenAPI schema and optional flattening
+     * @param options - Configuration options:
+     *   - `openapi` - (required) OpenAPI schema definition for the computed value
+     *   - `as` - Rename the attribute key in the serialized output and OpenAPI shape
+     *   - `default` - Value to use when the callback returns undefined
+     *   - `flatten` - When `true`, spreads the returned object's properties directly into the
+     *     parent serialized output instead of nesting them under `name`; the `openapi` option
+     *     should then define each flattened property individually
+     *   - `precision` - Round decimal values to the specified number of decimal places (0–9)
+     *     during rendering; does not affect the OpenAPI shape
+     *   - `required` - Set to `false` to mark the attribute as optional in the OpenAPI schema;
+     *     when omitted, attributes are required by default
      * @returns The serializer builder for method chaining
      *
      * @example
@@ -74,16 +100,20 @@ export default class DreamSerializerBuilder {
      * )
      *
      * // Flattened object properties
-     * .customAttribute('metadata', () => ({ age: 30, city: 'NYC' }), {
+     * .customAttribute('coordinates', () => ({ lat: 40.7, lng: -74.0 }), {
      *   flatten: true,
      *   openapi: {
-     *     age: { type: 'integer' },
-     *     city: { type: 'string' }
+     *     lat: { type: 'number' },
+     *     lng: { type: 'number' }
      *   }
      * })
-     * ```
      *
-     * See: {@link https://your-docs-url.com/docs/serializers/attributes | Serializer Attributes Documentation}
+     * // With decimal precision
+     * .customAttribute('averageRating', () => calculateAverage(ratings), {
+     *   openapi: 'decimal',
+     *   precision: 2
+     * })
+     * ```
      */
     customAttribute(name, fn, options) {
         this.attributes.push({
@@ -97,28 +127,50 @@ export default class DreamSerializerBuilder {
     /**
      * Includes a single associated object in the serialized output.
      *
-     * When rendering a Dream association, the OpenAPI shape is automatically
-     * inferred from that associated Dream's serializer.
+     * When rendering a Dream association, the serializer and OpenAPI shape are automatically
+     * inferred from that associated Dream model's registered serializers.
      *
      * @param name - The association property name
-     * @param options - Configuration options for serialization and schema definition
+     * @param options - Configuration options:
+     *   - `as` - Rename the association key in the serialized output
+     *   - `flatten` - When `true`, spreads the rendered association's attributes directly into
+     *     the parent serialized output instead of nesting them under `name`. Be aware of
+     *     attribute shadowing: if the parent and flattened association share attribute names
+     *     (e.g., `id`), the flattened association's values overwrite the parent's
+     *   - `optional` - When `true`, allows the association to be null/missing without causing
+     *     an `OpenapiResponseValidationFailure` during Psychic controller unit specs. By default,
+     *     `rendersOne` expects the association to be present (mirroring the `optional` option on
+     *     `@deco.BelongsTo`). Set this to `true` when the association is genuinely nullable
+     *   - `serializerKey` - Use a specific serializer key from the associated Dream model's
+     *     registered serializers (e.g., `'summary'`)
+     *   - `serializer` - Provide an explicit serializer function instead of using the
+     *     associated model's registered serializers
+     *
+     *   For ViewModel associations, one of these is required:
+     *   - `viewModelClass` + optional `serializerKey`
+     *   - `serializer`
+     *
+     *   For non-Dream/non-ViewModel associations:
+     *   - `serializer` is required
      * @returns The serializer builder for method chaining
      *
      * @example
      * ```typescript
-     * // DreamSerializer with inference
-     * .rendersOne('user') // Infers from Dream association
+     * // Auto-infer serializer from Dream association
+     * .rendersOne('profile')
      *
-     * // With specific serializer
+     * // With specific serializer key
      * .rendersOne('user', { serializerKey: 'summary' })
      *
-     * // ObjectSerializer (explicit configuration required)
-     * .rendersOne('owner', UserSerializer, {
-     *   openapi: { $ref: '#/components/schemas/User' }
-     * })
-     * ```
+     * // Allow null association
+     * .rendersOne('approver', { optional: true })
      *
-     * See: {@link https://your-docs-url.com/docs/serializers/associations | Serializer Associations Documentation}
+     * // Flatten into parent object
+     * .rendersOne('candidate', { serializerKey: 'summary', flatten: true })
+     *
+     * // Explicit serializer function
+     * .rendersOne('owner', { serializer: CustomOwnerSerializer })
+     * ```
      */
     rendersOne(name, options) {
         this.attributes.push({
@@ -131,31 +183,39 @@ export default class DreamSerializerBuilder {
     /**
      * Includes an array of associated objects in the serialized output.
      *
-     * When rendering a Dream association, the OpenAPI shape is automatically
-     * inferred from that associated Dream's serializer.
+     * When rendering a Dream association, the serializer and OpenAPI shape are automatically
+     * inferred from that associated Dream model's registered serializers.
+     *
+     * @param name - The association property name (should resolve to an array)
+     * @param options - Configuration options:
+     *   - `as` - Rename the association key in the serialized output
+     *   - `serializerKey` - Use a specific serializer key from the associated Dream model's
+     *     registered serializers (e.g., `'summary'`)
+     *   - `serializer` - Provide an explicit serializer function instead of using the
+     *     associated model's registered serializers
      *
-     * @param name - The association property name (should be an array)
-     * @param options - Configuration options for serialization and schema definition
+     *   For ViewModel associations, one of these is required:
+     *   - `viewModelClass` + optional `serializerKey`
+     *   - `serializer`
+     *
+     *   For non-Dream/non-ViewModel associations:
+     *   - `serializer` is required
      * @returns The serializer builder for method chaining
      *
      * @example
      * ```typescript
-     * // DreamSerializer with inference
-     * .rendersMany('posts') // Infers from Dream association
+     * // Auto-infer serializer from Dream association
+     * .rendersMany('rooms')
      *
-     * // With specific serializer
-     * .rendersMany('posts', { serializerKey: 'summary' })
+     * // With specific serializer key
+     * .rendersMany('rooms', { serializerKey: 'summary' })
      *
-     * // ObjectSerializer (explicit configuration required)
-     * .rendersMany('articles', ArticleSerializer, {
-     *   openapi: {
-     *     type: 'array',
-     *     items: { $ref: '#/components/schemas/Article' }
-     *   }
-     * })
-     * ```
+     * // Explicit serializer function (for non-Dream objects)
+     * .rendersMany('bedTypes', { serializer: BedTypeSerializer })
      *
-     * See: {@link https://your-docs-url.com/docs/serializers/associations | Serializer Associations Documentation}
+     * // Rename output key
+     * .rendersMany('rooms', { serializerKey: 'forGuests', as: 'guestRooms' })
+     * ```
      */
     rendersMany(name, options) {
         this.attributes.push({
@@ -168,24 +228,22 @@ export default class DreamSerializerBuilder {
     /**
      * Executes the serializer and returns the serialized output.
      *
-     * This method processes all defined attributes, custom attributes, delegated attributes,
-     * and associations to produce the final serialized object. The result is suitable for
-     * JSON.stringify() and API responses.
+     * Processes all defined attributes, custom attributes, delegated attributes,
+     * and associations to produce the final serialized object.
      *
      * @param passthrough - Additional data to pass through to nested serializers
+     *   (e.g., locale, current user context)
      * @param opts - Rendering options for customizing the serialization process
-     * @returns The serialized object
+     * @returns The serialized object, suitable for JSON responses
      *
      * @example
      * ```typescript
      * const result = UserSerializer(user).render()
      * // Returns: { id: 1, email: 'user@example.com', ... }
      *
-     * // With passthrough data
+     * // With passthrough data for nested serializers
      * const result = UserSerializer(user).render({ currentUserId: 123 })
      * ```
-     *
-     * See: {@link https://your-docs-url.com/docs/serializers/render | Serializer Rendering Documentation}
      */
     render(passthrough = {}, opts = {}) {
         return new SerializerRenderer(this, passthrough, opts).render();