@rvoh/dream 2.5.7 → 2.5.8

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

@@ -14,7 +14,15 @@ export default class ObjectSerializerBuilder {
      * inference is not available for plain objects or ViewModels.
      *
      * @param name - The attribute name from the data object
-     * @param options - Configuration options including required OpenAPI schema, default value, and output customization
+     * @param options - Configuration options:
+     *   - `openapi` - (required) OpenAPI schema definition for the attribute
+     *   - `as` - Rename the attribute key in the serialized output and OpenAPI shape
+     *   - `default` - Value to use when the attribute is undefined
+     *   - `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, meaning `undefined` values will
+     *     serialize as `null`
      * @returns The serializer builder for method chaining
      *
      * @example
@@ -35,9 +43,19 @@ export default class ObjectSerializerBuilder {
      *   openapi: { type: 'string' },
      *   as: 'userEmail'
      * })
-     * ```
      *
-     * See: {@link https://your-docs-url.com/docs/serializers/attributes | Serializer Attributes Documentation}
+     * // Round decimal to 2 places
+     * .attribute('price', {
+     *   openapi: 'decimal',
+     *   precision: 2
+     * })
+     *
+     * // Mark as optional in OpenAPI (omitted from response when undefined)
+     * .attribute('nickname', {
+     *   openapi: 'string',
+     *   required: false
+     * })
+     * ```
      */
     attribute(name, options) {
         this.attributes.push({
@@ -50,13 +68,22 @@ export default class ObjectSerializerBuilder {
     /**
      * Includes an attribute from a nested object in the serialized output.
      *
-     * Pulls up an attribute from a target object property. The `openapi` option
-     * is always required. If the target object or the delegated attribute
-     * is null/undefined, the `default` option value will be used if provided.
+     * Accesses `targetName.name` on the data object. The `openapi` option is always
+     * required. 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
      * @param name - The attribute name within the target object
-     * @param options - Configuration options including required OpenAPI schema, default value, and output customization
+     * @param options - Configuration options:
+     *   - `openapi` - (required) OpenAPI schema definition for the attribute
+     *   - `as` - Rename the attribute key in the serialized output and OpenAPI shape
+     *     (e.g., delegating `'profile', 'avatarUrl'` with `as: 'avatar'` outputs the value
+     *     under `avatar`)
+     *   - `default` - Value to use when the target object or its attribute is null/undefined
+     *   - `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
@@ -71,9 +98,13 @@ export default class ObjectSerializerBuilder {
      *   openapi: { type: 'string' },
      *   default: 'Anonymous 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({
@@ -90,9 +121,19 @@ export default class ObjectSerializerBuilder {
      * Executes a callback function to generate a custom attribute value.
      * The `openapi` option is always required since the return type cannot be inferred.
      *
+     * Unlike DreamSerializerBuilder's `customAttribute`, this version does not support `as`
+     * or `precision`.
+     *
      * @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
+     *   - `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
+     *   - `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
@@ -112,8 +153,6 @@ export default class ObjectSerializerBuilder {
      *   }
      * })
      * ```
-     *
-     * See: {@link https://your-docs-url.com/docs/serializers/attributes | Serializer Attributes Documentation}
      */
     customAttribute(name, fn, options) {
         this.attributes.push({
@@ -131,25 +170,47 @@ export default class ObjectSerializerBuilder {
      * since association schemas cannot be inferred from plain objects.
      *
      * @param name - The association property name
-     * @param options - Configuration options including required serializer and OpenAPI schema
+     * @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
+     *
+     *   For Dream associations:
+     *   - `dreamClass` - The Dream model class, enabling serializer inference; when specified,
+     *     `serializerKey` may also be provided to select a specific registered serializer
+     *   - `serializer` - Provide an explicit serializer function
+     *
+     *   For ViewModel associations:
+     *   - `viewModelClass` + optional `serializerKey`
+     *   - `serializer`
+     *
+     *   For non-Dream/non-ViewModel associations:
+     *   - `serializer` is required
      * @returns The serializer builder for method chaining
      *
      * @example
      * ```typescript
      * // With explicit serializer function
-     * .rendersOne('owner', UserSerializer, {
-     *   openapi: { $ref: '#/components/schemas/User' }
-     * })
+     * .rendersOne('owner', { serializer: CustomOwnerSerializer })
      *
-     * // With Dream class reference
+     * // With Dream class reference and serializer key
      * .rendersOne('creator', {
      *   dreamClass: User,
-     *   serializerKey: 'summary',
-     *   openapi: { $ref: '#/components/schemas/UserSummary' }
+     *   serializerKey: 'summary'
      * })
-     * ```
      *
-     * See: {@link https://your-docs-url.com/docs/serializers/associations | Serializer Associations Documentation}
+     * // Allow null association
+     * .rendersOne('approver', { serializer: UserSerializer, optional: true })
+     *
+     * // Flatten into parent object
+     * .rendersOne('profile', { serializer: ProfileSerializer, flatten: true })
+     * ```
      */
     rendersOne(name, options) {
         this.attributes.push({
@@ -165,32 +226,43 @@ export default class ObjectSerializerBuilder {
      * For ObjectSerializer, explicit serializer configuration is always required
      * since association schemas cannot be inferred from plain objects.
      *
-     * @param name - The association property name (should be an array)
-     * @param options - Configuration options including required serializer and OpenAPI schema
+     * @param name - The association property name (should resolve to an array)
+     * @param options - Configuration options:
+     *   - `as` - Rename the association key in the serialized output
+     *
+     *   For Dream associations:
+     *   - `dreamClass` - The Dream model class, enabling serializer inference; when specified,
+     *     `serializerKey` may also be provided to select a specific registered serializer
+     *   - `serializer` - Provide an explicit serializer function
+     *
+     *   For ViewModel associations:
+     *   - `viewModelClass` + optional `serializerKey`
+     *   - `serializer`
+     *
+     *   For non-Dream/non-ViewModel associations:
+     *   - `serializer` is required
      * @returns The serializer builder for method chaining
      *
      * @example
      * ```typescript
      * // With explicit serializer function
-     * .rendersMany('articles', ArticleSerializer, {
-     *   openapi: {
-     *     type: 'array',
-     *     items: { $ref: '#/components/schemas/Article' }
-     *   }
+     * .rendersMany('articles', { serializer: ArticleSerializer })
+     *
+     * // With Dream class reference and serializer key
+     * .rendersMany('posts', {
+     *   dreamClass: Post,
+     *   serializerKey: 'summary'
      * })
      *
      * // With ViewModel class reference
      * .rendersMany('comments', {
      *   viewModelClass: CommentViewModel,
-     *   serializer: CommentViewModelSerializer,
-     *   openapi: {
-     *     type: 'array',
-     *     items: { $ref: '#/components/schemas/Comment' }
-     *   }
+     *   serializer: CommentViewModelSerializer
      * })
-     * ```
      *
-     * See: {@link https://your-docs-url.com/docs/serializers/associations | Serializer Associations Documentation}
+     * // Rename output key
+     * .rendersMany('articles', { serializer: ArticleSerializer, as: 'posts' })
+     * ```
      */
     rendersMany(name, options) {
         this.attributes.push({
@@ -203,13 +275,13 @@ export default class ObjectSerializerBuilder {
     /**
      * 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
@@ -219,8 +291,6 @@ export default class ObjectSerializerBuilder {
      * // With passthrough data for nested serializers
      * const result = UserViewModelSerializer(userVm).render({ currentUserId: '456' })
      * ```
-     *
-     * See: {@link https://your-docs-url.com/docs/serializers/render | Serializer Rendering Documentation}
      */
     render(passthrough = {}, opts = {}) {
         return new SerializerRenderer(this, passthrough, opts).render();

package/dist/esm/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/esm/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/esm/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/esm/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/esm/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