@rvoh/psychic 0.37.0-beta.4 → 0.37.0-beta.6

package/dist/cjs/src/error/openapi/AttemptedToDeriveDescendentSerializersFromNonSerializer.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const node_util_1 = require("node:util");
 class AttemptedToDeriveDescendentSerializersFromNonSerializer extends Error {
     serializer;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     constructor(serializer) {
         super();
         this.serializer = serializer;

package/dist/cjs/src/error/openapi/NonSerializerPassedToSerializerOpenapiRenderer.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const node_util_1 = require("node:util");
 class NonSerializerPassedToSerializerOpenapiRenderer extends Error {
     serializer;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     constructor(serializer) {
         super();
         this.serializer = serializer;

package/dist/cjs/src/error/openapi/NonSerializerSerializerOverrideProvided.js

@@ -4,7 +4,11 @@ const node_util_1 = require("node:util");
 class NonSerializerSerializerOverrideProvided extends Error {
     rendersAssociation;
     serializer;
-    constructor(rendersAssociation, serializer) {
+    constructor(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    rendersAssociation, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    serializer) {
         super();
         this.rendersAssociation = rendersAssociation;
         this.serializer = serializer;

package/dist/cjs/src/openapi-renderer/SerializerOpenapiRenderer.js

@@ -108,10 +108,6 @@ class SerializerOpenapiRenderer {
         const DataTypeForOpenapi = $typeForOpenapi;
         let referencedSerializers = [];
         let renderedOpenapi = {};
-        const openapiRenderingOpts = {
-            casing: this.casing,
-            suppressResponseEnums: this.suppressResponseEnums,
-        };
         renderedOpenapi = this.serializerBuilder['attributes'].reduce((accumulator, attribute) => {
             const attributeType = attribute.type;
             let newlyReferencedSerializers = [];
@@ -171,10 +167,11 @@ class SerializerOpenapiRenderer {
                     case 'rendersOne': {
                         try {
                             const outputAttributeName = this.setCase(attribute.options.as ?? attribute.name);
-                            const referencedSerializersAndOpenapiSchemaBodyShorthand = associationOpenapi(attribute, DataTypeForOpenapi, alreadyExtractedDescendantSerializers, openapiRenderingOpts);
+                            const { associationOpts, referencedSerializersAndOpenapiSchemaBodyShorthand } = associationOpenapi(attribute, DataTypeForOpenapi, alreadyExtractedDescendantSerializers);
+                            const optional = attribute.options.optional ?? associationOpts.optional;
                             newlyReferencedSerializers =
                                 referencedSerializersAndOpenapiSchemaBodyShorthand.referencedSerializers;
-                            if (attribute.options.flatten && attribute.options.optional) {
+                            if (attribute.options.flatten && optional) {
                                 this.allOfSiblings.push({
                                     anyOf: [referencedSerializersAndOpenapiSchemaBodyShorthand.openapi, NULL_OBJECT_OPENAPI],
                                 });
@@ -184,7 +181,7 @@ class SerializerOpenapiRenderer {
                                 this.allOfSiblings.push(referencedSerializersAndOpenapiSchemaBodyShorthand.openapi);
                                 //
                             }
-                            else if (attribute.options.optional) {
+                            else if (optional) {
                                 accumulator[outputAttributeName] = {
                                     anyOf: [referencedSerializersAndOpenapiSchemaBodyShorthand.openapi, NULL_OBJECT_OPENAPI],
                                 };
@@ -211,7 +208,7 @@ class SerializerOpenapiRenderer {
                     case 'rendersMany': {
                         try {
                             const outputAttributeName = this.setCase(attribute.options.as ?? attribute.name);
-                            const referencedSerializersAndOpenapiSchemaBodyShorthand = associationOpenapi(attribute, DataTypeForOpenapi, alreadyExtractedDescendantSerializers, openapiRenderingOpts);
+                            const { referencedSerializersAndOpenapiSchemaBodyShorthand } = associationOpenapi(attribute, DataTypeForOpenapi, alreadyExtractedDescendantSerializers);
                             newlyReferencedSerializers =
                                 referencedSerializersAndOpenapiSchemaBodyShorthand.referencedSerializers;
                             accumulator[outputAttributeName] = {
@@ -238,7 +235,7 @@ class SerializerOpenapiRenderer {
                     }
                 }
             })();
-            const recursiveNewlyReferencedSerializers = newlyReferencedSerializers.flatMap(serializer => descendantSerializers(serializer, alreadyExtractedDescendantSerializers, openapiRenderingOpts));
+            const recursiveNewlyReferencedSerializers = newlyReferencedSerializers.flatMap(serializer => descendantSerializers(serializer, alreadyExtractedDescendantSerializers));
             referencedSerializers = [
                 ...referencedSerializers,
                 ...newlyReferencedSerializers,
@@ -266,16 +263,19 @@ class SerializerOpenapiRenderer {
     }
 }
 exports.default = SerializerOpenapiRenderer;
-function associationOpenapi(attribute, DataTypeForOpenapi, alreadyExtractedDescendantSerializers, opts) {
+function associationOpenapi(attribute, DataTypeForOpenapi, alreadyExtractedDescendantSerializers) {
     const serializerOverride = attribute.options.serializer;
     if (serializerOverride) {
         try {
             return {
-                referencedSerializers: [
-                    serializerOverride,
-                    ...descendantSerializers(serializerOverride, alreadyExtractedDescendantSerializers, opts),
-                ],
-                openapi: new SerializerOpenapiRenderer(serializerOverride, opts).serializerRef,
+                associationOpts: { optional: false },
+                referencedSerializersAndOpenapiSchemaBodyShorthand: {
+                    referencedSerializers: [
+                        serializerOverride,
+                        ...descendantSerializers(serializerOverride, alreadyExtractedDescendantSerializers),
+                    ],
+                    openapi: new SerializerOpenapiRenderer(serializerOverride).serializerRef,
+                },
             };
         }
         catch (error) {
@@ -288,8 +288,8 @@ function associationOpenapi(attribute, DataTypeForOpenapi, alreadyExtractedDesce
     const association = DataTypeForOpenapi?.isDream &&
         // eslint-disable-next-line @typescript-eslint/no-unsafe-call
         DataTypeForOpenapi['getAssociationMetadata'](attribute.name);
+    const optional = !!association?.optional;
     if (association) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
         associatedClasses = (0, dream_1.expandStiClasses)(association.modelCB());
         //
     }
@@ -315,30 +315,36 @@ function associationOpenapi(attribute, DataTypeForOpenapi, alreadyExtractedDesce
             associatedClasses = [associatedClass];
         }
     }
-    const serializersOpenapi = associatedClasses.flatMap(associatedClass => (0, dream_1.inferSerializersFromDreamClassOrViewModelClass)(associatedClass, attribute.options.serializerKey));
-    if (serializersOpenapi.length === 0)
+    const serializers = associatedClasses.flatMap(associatedClass => (0, dream_1.inferSerializersFromDreamClassOrViewModelClass)(associatedClass, attribute.options.serializerKey));
+    if (serializers.length === 0)
         throw new NoSerializerFoundForRendersOneAndMany_js_1.default(attribute.name);
-    if (serializersOpenapi.length === 1) {
-        const serializer = serializersOpenapi[0];
+    if (serializers.length === 1) {
+        const serializer = serializers[0];
         return {
-            referencedSerializers: [
-                serializer,
-                ...descendantSerializers(serializer, alreadyExtractedDescendantSerializers, opts),
-            ],
-            openapi: new SerializerOpenapiRenderer(serializer, opts).serializerRef,
+            associationOpts: { optional },
+            referencedSerializersAndOpenapiSchemaBodyShorthand: {
+                referencedSerializers: [
+                    serializer,
+                    ...descendantSerializers(serializer, alreadyExtractedDescendantSerializers),
+                ],
+                openapi: new SerializerOpenapiRenderer(serializer).serializerRef,
+            },
         };
     }
     return {
-        referencedSerializers: [
-            ...serializersOpenapi,
-            ...serializersOpenapi.flatMap(serializer => descendantSerializers(serializer, alreadyExtractedDescendantSerializers, opts)),
-        ],
-        openapi: {
-            anyOf: (0, dream_1.sortBy)((0, dream_1.uniq)(serializersOpenapi.map(serializer => new SerializerOpenapiRenderer(serializer, opts).serializerRef), ref => ref['$ref']), ref => (ref['$ref'] ? ref['$ref'] : (0, node_util_1.inspect)(ref, { depth: 2 }))),
+        associationOpts: { optional },
+        referencedSerializersAndOpenapiSchemaBodyShorthand: {
+            referencedSerializers: [
+                ...serializers,
+                ...serializers.flatMap(serializer => descendantSerializers(serializer, alreadyExtractedDescendantSerializers)),
+            ],
+            openapi: {
+                anyOf: (0, dream_1.sortBy)((0, dream_1.uniq)(serializers.map(serializer => new SerializerOpenapiRenderer(serializer).serializerRef), ref => ref['$ref']), ref => (ref['$ref'] ? ref['$ref'] : (0, node_util_1.inspect)(ref, { depth: 2 }))),
+            },
         },
     };
 }
-function descendantSerializers(serializer, alreadyExtractedDescendantSerializers, opts) {
+function descendantSerializers(serializer, alreadyExtractedDescendantSerializers) {
     // alreadyExtractedDescendantSerializers is used not only to avoid duplicate
     // work (and thereby speed up OpenAPI spec generation), but also to avoid
     // infinite loops (a recursive OpenAPI structure is valid)
@@ -346,10 +352,10 @@ function descendantSerializers(serializer, alreadyExtractedDescendantSerializers
         return [];
     if (!(0, dream_1.isDreamSerializer)(serializer))
         throw new AttemptedToDeriveDescendentSerializersFromNonSerializer_js_1.default(serializer);
-    const immediateDescendantSerializers = new SerializerOpenapiRenderer(serializer, opts).renderedOpenapi(alreadyExtractedDescendantSerializers).referencedSerializers;
+    const immediateDescendantSerializers = new SerializerOpenapiRenderer(serializer).renderedOpenapi(alreadyExtractedDescendantSerializers).referencedSerializers;
     return [
         ...immediateDescendantSerializers,
-        ...immediateDescendantSerializers.flatMap(descendantSerializer => descendantSerializers(descendantSerializer, alreadyExtractedDescendantSerializers, opts)),
+        ...immediateDescendantSerializers.flatMap(descendantSerializer => descendantSerializers(descendantSerializer, alreadyExtractedDescendantSerializers)),
     ];
 }
 // When attempting to expand STI children, we might call `.serializers` on

package/dist/cjs/src/openapi-renderer/body-segment.js

@@ -12,20 +12,57 @@ const maybeNullOpenapiShorthandToOpenapiShorthand_js_1 = __importDefault(require
 const primitiveOpenapiStatementToOpenapi_js_1 = __importDefault(require("./helpers/primitiveOpenapiStatementToOpenapi.js"));
 const schemaToRef_js_1 = __importDefault(require("./helpers/schemaToRef.js"));
 const SerializerOpenapiRenderer_js_1 = __importDefault(require("./SerializerOpenapiRenderer.js"));
-class OpenapiBodySegmentRenderer {
+/**
+ * @internal
+ *
+ * Internal class used to recursively expand OpenAPI shorthand notation into full OpenAPI schema objects.
+ *
+ * This class handles the transformation of various shorthand formats:
+ * - Primitive shorthands like `'string'` → `{ type: 'string' }`
+ * - Nullable shorthands like `['string', 'null']` → `{ type: ['string', 'null'] }`
+ * - Array shorthands like `'string[]'` → `{ type: 'array', items: { type: 'string' } }`
+ * - Nullable array shorthands like `['string[]', 'null']` → `{ type: ['array', 'null'], items: { type: 'string' } }`
+ * - Serializer references like `{ $serializer: SomeSerializer }` → `{ $ref: '#/components/schemas/SerializerOpenapiName' }`
+ * - Serializable references like `{ $serializable: SomeModel, key: 'summary' }` → resolved serializer reference
+ *
+ * The class recursively processes nested structures (objects, arrays, unions) and maintains
+ * a collection of referenced serializers that need to be included in the final OpenAPI document.
+ *
+ * @example
+ * ```typescript
+ * // Input shorthand
+ * {
+ *   type: 'object',
+ *   properties: {
+ *     name: 'string',
+ *     tags: 'string[]',
+ *     user: { $serializer: UserSerializer }
+ *   }
+ * }
+ *
+ * // Output expanded
+ * {
+ *   type: 'object',
+ *   properties: {
+ *     name: { type: 'string' },
+ *     tags: { type: 'array', items: { type: 'string' } },
+ *     user: { $ref: '#/components/schemas/UserSerializer' }
+ *   }
+ * }
+ * ```
+ */
+class OpenapiSegmentExpander {
     bodySegment;
     casing;
     suppressResponseEnums;
     target;
-    openapiName;
     /**
      * @internal
      *
-     * Used to recursively parse nested object structures
+     * Used to recursively expand nested object structures
      * within nested openapi objects
      */
-    constructor(bodySegment, { openapiName, renderOpts, target }) {
-        this.openapiName = openapiName;
+    constructor(bodySegment, { renderOpts, target }) {
         this.bodySegment = bodySegment;
         this.casing = renderOpts.casing;
         this.suppressResponseEnums = renderOpts.suppressResponseEnums;
@@ -41,7 +78,7 @@ class OpenapiBodySegmentRenderer {
     /**
      * @internal
      *
-     * Recursively parses nested objects and arrays,
+     * Recursively expand nested objects and arrays,
      * as well as primitive types
      */
     recursivelyParseBody(bodySegment) {
@@ -167,7 +204,7 @@ class OpenapiBodySegmentRenderer {
     /**
      * @internal
      *
-     * recursively parses a oneOf statement
+     * recursively expands a oneOf statement
      */
     oneOfStatement(bodySegment) {
         const oneOfBodySegment = bodySegment;
@@ -191,7 +228,7 @@ class OpenapiBodySegmentRenderer {
     /**
      * @internal
      *
-     * recursively parses an anyOf statement
+     * recursively expand an anyOf statement
      */
     anyOfStatement(bodySegment) {
         const anyOfBodySegment = bodySegment;
@@ -215,7 +252,7 @@ class OpenapiBodySegmentRenderer {
     /**
      * @internal
      *
-     * recursively parses an allOf statement
+     * recursively expand an allOf statement
      */
     allOfStatement(bodySegment) {
         const allOfBodySegment = bodySegment;
@@ -239,7 +276,7 @@ class OpenapiBodySegmentRenderer {
     /**
      * @internal
      *
-     * recursively parses an array statement
+     * recursively expand an array statement
      */
     arrayStatement(bodySegment) {
         const results = this.recursivelyParseBody(bodySegment.items);
@@ -256,7 +293,7 @@ class OpenapiBodySegmentRenderer {
     /**
      * @internal
      *
-     * recursively parses an object statement
+     * recursively expand an object statement
      */
     objectStatement(bodySegment) {
         const objectBodySegment = bodySegment;
@@ -293,7 +330,7 @@ class OpenapiBodySegmentRenderer {
     /**
      * @internal
      *
-     * parses either the `properties` or `additionalProperties` values
+     * expand either the `properties` or `additionalProperties` values
      * on an object
      */
     parseObjectPropertyStatement(propertySegment) {
@@ -316,7 +353,7 @@ class OpenapiBodySegmentRenderer {
     /**
      * @internal
      *
-     * recursively parses a primitive literal type (i.e. string or boolean[])
+     * recursively expand a primitive literal type (i.e. string or boolean[])
      */
     primitiveLiteralStatement(bodySegment) {
         return (0, primitiveOpenapiStatementToOpenapi_js_1.default)(bodySegment);
@@ -324,7 +361,7 @@ class OpenapiBodySegmentRenderer {
     /**
      * @internal
      *
-     * recursively parses a primitive object type (i.e. { type: 'string[]' })
+     * recursively expand a primitive object type (i.e. { type: 'string[]' })
      */
     primitiveObjectStatement(bodySegment) {
         const safeBodySegment = bodySegment;
@@ -454,4 +491,4 @@ The following values will be allowed:
         return returnObj;
     }
 }
-exports.default = OpenapiBodySegmentRenderer;
+exports.default = OpenapiSegmentExpander;

package/dist/cjs/src/openapi-renderer/endpoint.js

@@ -283,7 +283,7 @@ class OpenapiEndpointRenderer {
      * Generates the header portion of the openapi payload's
      * "parameters" field for a single endpoint.
      */
-    queryArray({ openapiName, renderOpts, }) {
+    queryArray({ renderOpts, }) {
         const queryParams = Object.keys(this.query || {}).map((queryName) => {
             const queryParam = this.query[queryName];
             let output = {
@@ -307,7 +307,6 @@ class OpenapiEndpointRenderer {
                     ...output,
                     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                     schema: new body_segment_js_1.default(queryParam.schema, {
-                        openapiName,
                         renderOpts,
                         target: 'request',
                         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -347,7 +346,6 @@ class OpenapiEndpointRenderer {
             return this.generateRequestBodyForModel({ openapiName, renderOpts });
         }
         let schema = new body_segment_js_1.default(this.requestBody, {
-            openapiName,
             renderOpts,
             target: 'request',
         }).render().openapi;
@@ -412,7 +410,7 @@ class OpenapiEndpointRenderer {
      * that model that are safe to ingest will be automatically added to
      * the request body.
      */
-    generateRequestBodyForModel({ openapiName, renderOpts, }) {
+    generateRequestBodyForModel({ renderOpts, }) {
         const forDreamClass = this.requestBody?.for;
         const dreamClass = forDreamClass || this.getSingleDreamModelClass();
         if (!dreamClass)
@@ -525,7 +523,6 @@ class OpenapiEndpointRenderer {
                             paramsShape.properties = {
                                 ...paramsShape.properties,
                                 [columnName]: new body_segment_js_1.default(metadata.type, {
-                                    openapiName,
                                     renderOpts,
                                     target: 'request',
                                 }).render().openapi,
@@ -570,7 +567,6 @@ class OpenapiEndpointRenderer {
             }
         }
         let processedSchema = new body_segment_js_1.default(paramsShape, {
-            openapiName,
             renderOpts,
             target: 'request',
         }).render().openapi;
@@ -594,7 +590,6 @@ class OpenapiEndpointRenderer {
     parseResponses({ openapiName, renderOpts, }) {
         let responseData = {};
         const rendererOpts = {
-            openapiName,
             renderOpts,
             target: 'response',
         };
@@ -986,7 +981,6 @@ function serializersToSchemaObjects(controllerClass, actionName, serializers, {
         const renderer = new SerializerOpenapiRenderer_js_1.default(serializer, renderOpts);
         const results = renderer.renderedOpenapi(alreadyExtractedDescendantSerializers);
         const segmentRendererResults = new body_segment_js_1.default(results.openapi, {
-            openapiName,
             renderOpts,
             target: 'response',
         }).render();

package/dist/cjs/src/openapi-renderer/helpers/allSerializersFromHandWrittenOpenapi.js

@@ -4,7 +4,49 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = allSerializersFromHandWrittenOpenapi;
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+const dream_1 = require("@rvoh/dream");
 const isObject_js_1 = __importDefault(require("../../helpers/isObject.js"));
+/**
+ * @internal
+ *
+ * Recursively scans an OpenAPI schema structure and returns an array of all Serializers referenced within it.
+ *
+ * This function traverses the provided OpenAPI schema definition looking for `$serializer` properties
+ * and collects all unique serializer references found. It performs a deep scan of nested objects and
+ * arrays to find all serializer references at any level of nesting.
+ *
+ * **Important**: This function does _not_ recurse into the OpenAPI schemas generated by the discovered
+ * Serializers themselves. It only extracts serializers from the hand-written OpenAPI structure provided
+ * as input.
+ *
+ * @param openapi - The OpenAPI schema definition to scan for serializer references
+ * @returns An array of unique serializers found in the schema structure
+ *
+ * @example
+ * ```typescript
+ * const schema = {
+ *   type: 'object',
+ *   properties: {
+ *     user: { $serializer: UserSerializer },
+ *     posts: {
+ *       type: 'array',
+ *       items: { $serializer: PostSerializer }
+ *     },
+ *     metadata: {
+ *       type: 'object',
+ *       properties: {
+ *         author: { $serializer: UserSerializer } // Duplicate, will be deduplicated
+ *       }
+ *     }
+ *   }
+ * }
+ *
+ * const serializers = allSerializersFromHandWrittenOpenapi(schema)
+ * // Returns: [UserSerializer, PostSerializer]
+ * ```
+ */
 function allSerializersFromHandWrittenOpenapi(openapi) {
     const serializers = new Set();
     extractSerializers(openapi, serializers);
@@ -15,15 +57,17 @@ function extractSerializers(
 value, serializers) {
     if (!value)
         return;
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     if (value.$serializer) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument
         serializers.add(value.$serializer);
         //
     }
+    else if (value.$serializable) {
+        const foundSerializers = (0, dream_1.inferSerializersFromDreamClassOrViewModelClass)(value.$serializable, value.$serializableSerializerKey);
+        foundSerializers.forEach(serializer => serializers.add(serializer));
+        //
+    }
     else if ((0, isObject_js_1.default)(value)) {
         // Recurse into objects
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         Object.values(value).forEach(val => extractSerializers(val, serializers));
         //
     }

package/dist/cjs/src/openapi-renderer/helpers/allSerializersToRefsInOpenapi.js

@@ -4,8 +4,57 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = allSerializersToRefsInOpenapi;
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+const dream_1 = require("@rvoh/dream");
 const isObject_js_1 = __importDefault(require("../../helpers/isObject.js"));
 const SerializerOpenapiRenderer_js_1 = __importDefault(require("../SerializerOpenapiRenderer.js"));
+/**
+ * @internal
+ *
+ * Transforms OpenAPI schema definitions by replacing serializer shorthand references with proper `$ref` statements.
+ *
+ * This function is used by the SerializerOpenapiRenderer to ensure that the schemas it generates from
+ * Serializers contain `$ref` statements instead of `$serializer` or `$serializable` statements. This
+ * transformation enables consistent ordering of `anyOf` statements since `anyOf` arrays are sorted by
+ * the `$ref` value, which follows the pattern `'#/components/schemas/TheSerializerOpenapiName'`.
+ *
+ * The function recursively traverses the schema and transforms:
+ * - `{ $serializer: SomeSerializer }` → `{ $ref: '#/components/schemas/SerializerOpenapiName' }`
+ * - `{ $serializable: SomeModel, key: 'summary' }` → `{ $ref: '#/components/schemas/ModelSummarySerializer' }`
+ *
+ * @param openapi - The OpenAPI schema definition that may contain serializer shorthand references
+ * @returns The transformed schema with `$ref` statements replacing serializer shorthands
+ *
+ * @example
+ * ```typescript
+ * const input = {
+ *   type: 'object',
+ *   properties: {
+ *     user: { $serializer: UserSerializer },
+ *     posts: {
+ *       type: 'array',
+ *       items: { $serializer: PostSerializer }
+ *     }
+ *   }
+ * }
+ *
+ * const output = allSerializersToRefsInOpenapi(input)
+ * // Returns:
+ * // {
+ * //   type: 'object',
+ * //   properties: {
+ * //     user: { $ref: '#/components/schemas/UserSerializer' },
+ * //     posts: {
+ * //       type: 'array',
+ * //       items: { $ref: '#/components/schemas/PostSerializer' }
+ * //     }
+ * //   }
+ * // }
+ * ```
+ */
 function allSerializersToRefsInOpenapi(openapi) {
     if (!openapi)
         return {};
@@ -16,24 +65,38 @@ function transformValue(value) {
     if (!value)
         return value;
     // If this is an object with a $serializer property, replace it with $ref
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     if (value.$serializer) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const { $serializer, ...rest } = value;
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         const openapiRenderer = new SerializerOpenapiRenderer_js_1.default($serializer).serializerRef;
         return {
             ...rest,
             ...openapiRenderer,
         };
+        //
+    }
+    else if (value.$serializable) {
+        const { $serializable, $serializableSerializerKey, ...rest } = value;
+        const foundSerializers = (0, dream_1.inferSerializersFromDreamClassOrViewModelClass)($serializable, $serializableSerializerKey);
+        const refs = foundSerializers.map(serializer => new SerializerOpenapiRenderer_js_1.default(serializer).serializerRef);
+        if (refs.length === 0)
+            return rest;
+        if (refs.length === 1) {
+            return {
+                ...rest,
+                ...refs[0],
+            };
+        }
+        return {
+            ...rest,
+            anyOf: refs,
+        };
+        //
     }
     else if ((0, isObject_js_1.default)(value)) {
         // Recurse into objects
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const transformed = {};
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         for (const [key, val] of Object.entries(value)) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
             transformed[key] = transformValue(val);
         }
         return transformed;
@@ -41,7 +104,6 @@ function transformValue(value) {
     }
     else if (Array.isArray(value)) {
         // Recurse into arrays
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return value.map(val => transformValue(val));
         //
     }

package/dist/esm/src/error/openapi/AttemptedToDeriveDescendentSerializersFromNonSerializer.js

@@ -1,6 +1,7 @@
 import { inspect } from 'node:util';
 export default class AttemptedToDeriveDescendentSerializersFromNonSerializer extends Error {
     serializer;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     constructor(serializer) {
         super();
         this.serializer = serializer;

package/dist/esm/src/error/openapi/NonSerializerPassedToSerializerOpenapiRenderer.js

@@ -1,6 +1,7 @@
 import { inspect } from 'node:util';
 export default class NonSerializerPassedToSerializerOpenapiRenderer extends Error {
     serializer;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     constructor(serializer) {
         super();
         this.serializer = serializer;

package/dist/esm/src/error/openapi/NonSerializerSerializerOverrideProvided.js

@@ -2,7 +2,11 @@ import { inspect } from 'node:util';
 export default class NonSerializerSerializerOverrideProvided extends Error {
     rendersAssociation;
     serializer;
-    constructor(rendersAssociation, serializer) {
+    constructor(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    rendersAssociation, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    serializer) {
         super();
         this.rendersAssociation = rendersAssociation;
         this.serializer = serializer;