Protected$typeProtectedattributesProtecteddataProtectedpassthroughThe attribute name from the data object
Optionaloptions: AutomaticSerializerAttributeOptionsForTypeConfiguration options:
as - Rename the attribute key in the serialized output and OpenAPI shapedefault - Value to use when the attribute is undefined (not available for type columns)openapi - OpenAPI schema definition; required for json/jsonb columns and non-virtual
getters, optional for standard columns (where it can supplement inferred types with a
description), and optional for @deco.Virtual() columns (where the type is inferred
from the decorator)precision - Round decimal values to the specified number of decimal places (0–9)
during rendering; does not affect the OpenAPI shape (not available for type or
virtual columns)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 (not available for type columns)The serializer builder for method chaining
// With type inference (database column)
.attribute('email')
// With explicit OpenAPI type (virtual attribute or json column)
.attribute('fullName', { openapi: { type: 'string' } })
// With default value
.attribute('status', { default: 'pending' })
// Rename output key
.attribute('email', { as: 'userEmail' })
// Round decimal to 2 places
.attribute('price', { precision: 2 })
// Mark as optional in OpenAPI (omitted from response when undefined)
.attribute('deletedAt', { required: false })
Includes an attribute from the data object in the serialized output.
For DreamSerializer, OpenAPI types are automatically inferred from database columns.
For json/jsonb columns and virtual attributes (getters), the openapi option is required.
The attribute name from the data object
Optionaloptions: SerializerAttributeOptionsForVirtualColumnConfiguration options:
as - Rename the attribute key in the serialized output and OpenAPI shapedefault - Value to use when the attribute is undefined (not available for type columns)openapi - OpenAPI schema definition; required for json/jsonb columns and non-virtual
getters, optional for standard columns (where it can supplement inferred types with a
description), and optional for @deco.Virtual() columns (where the type is inferred
from the decorator)precision - Round decimal values to the specified number of decimal places (0–9)
during rendering; does not affect the OpenAPI shape (not available for type or
virtual columns)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 (not available for type columns)The serializer builder for method chaining
// With type inference (database column)
.attribute('email')
// With explicit OpenAPI type (virtual attribute or json column)
.attribute('fullName', { openapi: { type: 'string' } })
// With default value
.attribute('status', { default: 'pending' })
// Rename output key
.attribute('email', { as: 'userEmail' })
// Round decimal to 2 places
.attribute('price', { precision: 2 })
// Mark as optional in OpenAPI (omitted from response when undefined)
.attribute('deletedAt', { required: false })
Includes an attribute from the data object in the serialized output.
For DreamSerializer, OpenAPI types are automatically inferred from database columns.
For json/jsonb columns and virtual attributes (getters), the openapi option is required.
The attribute name from the data object
Configuration options:
as - Rename the attribute key in the serialized output and OpenAPI shapedefault - Value to use when the attribute is undefined (not available for type columns)openapi - OpenAPI schema definition; required for json/jsonb columns and non-virtual
getters, optional for standard columns (where it can supplement inferred types with a
description), and optional for @deco.Virtual() columns (where the type is inferred
from the decorator)precision - Round decimal values to the specified number of decimal places (0–9)
during rendering; does not affect the OpenAPI shape (not available for type or
virtual columns)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 (not available for type columns)The serializer builder for method chaining
// With type inference (database column)
.attribute('email')
// With explicit OpenAPI type (virtual attribute or json column)
.attribute('fullName', { openapi: { type: 'string' } })
// With default value
.attribute('status', { default: 'pending' })
// Rename output key
.attribute('email', { as: 'userEmail' })
// Round decimal to 2 places
.attribute('price', { precision: 2 })
// Mark as optional in OpenAPI (omitted from response when undefined)
.attribute('deletedAt', { required: false })
Includes an attribute from the data object in the serialized output.
For DreamSerializer, OpenAPI types are automatically inferred from database columns.
For json/jsonb columns and virtual attributes (getters), the openapi option is required.
The attribute name from the data object
Optionaloptions: AutomaticSerializerAttributeOptionsConfiguration options:
as - Rename the attribute key in the serialized output and OpenAPI shapedefault - Value to use when the attribute is undefined (not available for type columns)openapi - OpenAPI schema definition; required for json/jsonb columns and non-virtual
getters, optional for standard columns (where it can supplement inferred types with a
description), and optional for @deco.Virtual() columns (where the type is inferred
from the decorator)precision - Round decimal values to the specified number of decimal places (0–9)
during rendering; does not affect the OpenAPI shape (not available for type or
virtual columns)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 (not available for type columns)The serializer builder for method chaining
// With type inference (database column)
.attribute('email')
// With explicit OpenAPI type (virtual attribute or json column)
.attribute('fullName', { openapi: { type: 'string' } })
// With default value
.attribute('status', { default: 'pending' })
// Rename output key
.attribute('email', { as: 'userEmail' })
// Round decimal to 2 places
.attribute('price', { precision: 2 })
// Mark as optional in OpenAPI (omitted from response when undefined)
.attribute('deletedAt', { required: false })
Includes a computed value in the serialized output.
Executes a callback function to generate a custom attribute value.
The openapi option is always required since the return type cannot be inferred.
The attribute name for the computed value
Callback function that returns the computed value
Configuration options:
openapi - (required) OpenAPI schema definition for the computed valueas - Rename the attribute key in the serialized output and OpenAPI shapedefault - Value to use when the callback returns undefinedflatten - 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 individuallyprecision - Round decimal values to the specified number of decimal places (0–9)
during rendering; does not affect the OpenAPI shaperequired - Set to false to mark the attribute as optional in the OpenAPI schema;
when omitted, attributes are required by defaultThe serializer builder for method chaining
// Simple computed value
.customAttribute('initials', () =>
`${user.firstName?.[0]}${user.lastName?.[0]}`.toUpperCase(),
{ openapi: { type: 'string' } }
)
// Flattened object properties
.customAttribute('coordinates', () => ({ lat: 40.7, lng: -74.0 }), {
flatten: true,
openapi: {
lat: { type: 'number' },
lng: { type: 'number' }
}
})
// With decimal precision
.customAttribute('averageRating', () => calculateAverage(ratings), {
openapi: 'decimal',
precision: 2
})
Includes an attribute from a nested object in the serialized output.
Accesses targetName.name on the data object. When the target object or the
delegated attribute is null/undefined, the resolution order is:
default if provided → renders the default valuerequired: false → omits the key entirely from the rendered outputnullWhen 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.
optional and required are not aliases — they encode different things and can
be used together:
optional: true is an OpenAPI-only marker (no runtime effect). It declares
that the rendered value may be null (e.g. when delegating through a HasOne
that may be missing). Use this when you want the key to always be present
but the value to be nullable in the schema.required: false affects both runtime and OpenAPI. At runtime, when the
resolved value is undefined (which includes the case of a missing delegated
association with no default), the key is omitted from the rendered output.
In OpenAPI, the field is marked as not required.The property name containing the target object (e.g., an association name)
The attribute name within the target object
Optionaloptions: AssociatedModelType extends DreamConfiguration 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
(not available when delegating to a 'type' STI discriminator column: substituting
a discriminator string when the association is actually missing produces a response
indistinguishable from "association present with that type," which is misleading)openapi - OpenAPI schema definition; required for non-Dream targets and json/jsonb
columns, optional for standard Dream columns (where types are inferred)optional - Set to true to mark the value as nullable in the OpenAPI schema
(wraps the type in anyOf: [schema, { type: 'null' }]). OpenAPI-only — the
key is still rendered (as null). For Dream models, this is auto-inferred
from optional BelongsTo associations. Use this when delegating through a
HasOne or other nullable association.precision - Round decimal values to the specified number of decimal places (0–9)
during rendering; does not affect the OpenAPI shape (not available when delegating
to a 'type' STI discriminator column, which is always a string enum)required - Set to false to omit the key from the rendered output when the
resolved value is undefined (including a missing delegated association with
no default), and to mark the field as not required in the OpenAPI schemaThe serializer builder for method chaining
// 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'
})
// Rename the output key
.delegatedAttribute('profile', 'avatarUrl', {
openapi: 'string',
as: 'avatar'
})
Executes the serializer and returns the serialized output.
Processes all defined attributes, custom attributes, delegated attributes, and associations to produce the final serialized object.
Additional data to pass through to nested serializers (e.g., locale, current user context)
Rendering options for customizing the serialization process
The serialized object, suitable for JSON responses
Includes an array of associated objects in the serialized output.
When rendering a Dream association, the serializer and OpenAPI shape are automatically inferred from that associated Dream model's registered serializers.
The association property name (should resolve to an array)
Optionaloptions: BaseOptions & SerializerOptionsConfiguration options:
as - Rename the association key in the serialized outputserializerKey - 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 serializersFor ViewModel associations, one of these is required:
viewModelClass + optional serializerKeyserializerFor non-Dream/non-ViewModel associations:
serializer is requiredThe serializer builder for method chaining
// Auto-infer serializer from Dream association
.rendersMany('rooms')
// With specific serializer key
.rendersMany('rooms', { serializerKey: 'summary' })
// Explicit serializer function (for non-Dream objects)
.rendersMany('bedTypes', { serializer: BedTypeSerializer })
// Rename output key
.rendersMany('rooms', { serializerKey: 'forGuests', as: 'guestRooms' })
Includes a single associated object in the serialized output.
When rendering a Dream association, the serializer and OpenAPI shape are automatically inferred from that associated Dream model's registered serializers.
The association property name
Optionaloptions: BaseOptions & SerializerOptionsConfiguration options:
as - Rename the association key in the serialized outputflatten - 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'soptional - 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 nullableserializerKey - 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 serializersFor ViewModel associations, one of these is required:
viewModelClass + optional serializerKeyserializerFor non-Dream/non-ViewModel associations:
serializer is requiredThe serializer builder for method chaining
// Auto-infer serializer from Dream association
.rendersOne('profile')
// With specific serializer key
.rendersOne('user', { serializerKey: 'summary' })
// Allow null association
.rendersOne('approver', { optional: true })
// Flatten into parent object
.rendersOne('candidate', { serializerKey: 'summary', flatten: true })
// Explicit serializer function
.rendersOne('owner', { serializer: CustomOwnerSerializer })
Includes an attribute from the data object in the serialized output.
For DreamSerializer, OpenAPI types are automatically inferred from database columns. For json/jsonb columns and virtual attributes (getters), the
openapioption is required.