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

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

@@ -103,10 +103,6 @@ export default 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 = [];
@@ -166,10 +162,11 @@ export default 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],
                                 });
@@ -179,7 +176,7 @@ export default class SerializerOpenapiRenderer {
                                 this.allOfSiblings.push(referencedSerializersAndOpenapiSchemaBodyShorthand.openapi);
                                 //
                             }
-                            else if (attribute.options.optional) {
+                            else if (optional) {
                                 accumulator[outputAttributeName] = {
                                     anyOf: [referencedSerializersAndOpenapiSchemaBodyShorthand.openapi, NULL_OBJECT_OPENAPI],
                                 };
@@ -206,7 +203,7 @@ export default 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] = {
@@ -233,7 +230,7 @@ export default class SerializerOpenapiRenderer {
                     }
                 }
             })();
-            const recursiveNewlyReferencedSerializers = newlyReferencedSerializers.flatMap(serializer => descendantSerializers(serializer, alreadyExtractedDescendantSerializers, openapiRenderingOpts));
+            const recursiveNewlyReferencedSerializers = newlyReferencedSerializers.flatMap(serializer => descendantSerializers(serializer, alreadyExtractedDescendantSerializers));
             referencedSerializers = [
                 ...referencedSerializers,
                 ...newlyReferencedSerializers,
@@ -260,16 +257,19 @@ export default class 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) {
@@ -282,8 +282,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 = expandStiClasses(association.modelCB());
         //
     }
@@ -309,30 +309,36 @@ function associationOpenapi(attribute, DataTypeForOpenapi, alreadyExtractedDesce
             associatedClasses = [associatedClass];
         }
     }
-    const serializersOpenapi = associatedClasses.flatMap(associatedClass => inferSerializersFromDreamClassOrViewModelClass(associatedClass, attribute.options.serializerKey));
-    if (serializersOpenapi.length === 0)
+    const serializers = associatedClasses.flatMap(associatedClass => inferSerializersFromDreamClassOrViewModelClass(associatedClass, attribute.options.serializerKey));
+    if (serializers.length === 0)
         throw new NoSerializerFoundForRendersOneAndMany(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: sortBy(uniq(serializersOpenapi.map(serializer => new SerializerOpenapiRenderer(serializer, opts).serializerRef), ref => ref['$ref']), ref => (ref['$ref'] ? ref['$ref'] : inspect(ref, { depth: 2 }))),
+        associationOpts: { optional },
+        referencedSerializersAndOpenapiSchemaBodyShorthand: {
+            referencedSerializers: [
+                ...serializers,
+                ...serializers.flatMap(serializer => descendantSerializers(serializer, alreadyExtractedDescendantSerializers)),
+            ],
+            openapi: {
+                anyOf: sortBy(uniq(serializers.map(serializer => new SerializerOpenapiRenderer(serializer).serializerRef), ref => ref['$ref']), ref => (ref['$ref'] ? ref['$ref'] : 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)
@@ -340,10 +346,10 @@ function descendantSerializers(serializer, alreadyExtractedDescendantSerializers
         return [];
     if (!isDreamSerializer(serializer))
         throw new AttemptedToDeriveDescendentSerializersFromNonSerializer(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/esm/src/openapi-renderer/body-segment.js

@@ -7,20 +7,57 @@ import maybeNullOpenapiShorthandToOpenapiShorthand from './helpers/maybeNullOpen
 import primitiveOpenapiStatementToOpenapi from './helpers/primitiveOpenapiStatementToOpenapi.js';
 import schemaToRef from './helpers/schemaToRef.js';
 import SerializerOpenapiRenderer from './SerializerOpenapiRenderer.js';
-export default 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' }
+ *   }
+ * }
+ * ```
+ */
+export default 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;
@@ -36,7 +73,7 @@ export default class OpenapiBodySegmentRenderer {
     /**
      * @internal
      *
-     * Recursively parses nested objects and arrays,
+     * Recursively expand nested objects and arrays,
      * as well as primitive types
      */
     recursivelyParseBody(bodySegment) {
@@ -162,7 +199,7 @@ export default class OpenapiBodySegmentRenderer {
     /**
      * @internal
      *
-     * recursively parses a oneOf statement
+     * recursively expands a oneOf statement
      */
     oneOfStatement(bodySegment) {
         const oneOfBodySegment = bodySegment;
@@ -186,7 +223,7 @@ export default class OpenapiBodySegmentRenderer {
     /**
      * @internal
      *
-     * recursively parses an anyOf statement
+     * recursively expand an anyOf statement
      */
     anyOfStatement(bodySegment) {
         const anyOfBodySegment = bodySegment;
@@ -210,7 +247,7 @@ export default class OpenapiBodySegmentRenderer {
     /**
      * @internal
      *
-     * recursively parses an allOf statement
+     * recursively expand an allOf statement
      */
     allOfStatement(bodySegment) {
         const allOfBodySegment = bodySegment;
@@ -234,7 +271,7 @@ export default class OpenapiBodySegmentRenderer {
     /**
      * @internal
      *
-     * recursively parses an array statement
+     * recursively expand an array statement
      */
     arrayStatement(bodySegment) {
         const results = this.recursivelyParseBody(bodySegment.items);
@@ -251,7 +288,7 @@ export default class OpenapiBodySegmentRenderer {
     /**
      * @internal
      *
-     * recursively parses an object statement
+     * recursively expand an object statement
      */
     objectStatement(bodySegment) {
         const objectBodySegment = bodySegment;
@@ -288,7 +325,7 @@ export default class OpenapiBodySegmentRenderer {
     /**
      * @internal
      *
-     * parses either the `properties` or `additionalProperties` values
+     * expand either the `properties` or `additionalProperties` values
      * on an object
      */
     parseObjectPropertyStatement(propertySegment) {
@@ -311,7 +348,7 @@ export default 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 primitiveOpenapiStatementToOpenapi(bodySegment);
@@ -319,7 +356,7 @@ export default 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;

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

@@ -3,7 +3,7 @@ import OpenApiFailedToLookupSerializerForEndpoint from '../error/openapi/FailedT
 import NonSerializerDerivedInOpenapiEndpointRenderer from '../error/openapi/NonSerializerDerivedInOpenapiEndpointRenderer.js';
 import NonSerializerDerivedInToSchemaObjects from '../error/openapi/NonSerializerDerivedInToSchemaObjects.js';
 import OpenApiSerializerForEndpointNotAFunction from '../error/openapi/SerializerForEndpointNotAFunction.js';
-import OpenapiBodySegmentRenderer from './body-segment.js';
+import OpenapiSegmentExpander from './body-segment.js';
 import { DEFAULT_OPENAPI_RESPONSES } from './defaults.js';
 import openapiOpts from './helpers/openapiOpts.js';
 import openapiRoute from './helpers/openapiRoute.js';
@@ -277,7 +277,7 @@ export default 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 = {
@@ -300,8 +300,7 @@ export default class OpenapiEndpointRenderer {
                 output = {
                     ...output,
                     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                    schema: new OpenapiBodySegmentRenderer(queryParam.schema, {
-                        openapiName,
+                    schema: new OpenapiSegmentExpander(queryParam.schema, {
                         renderOpts,
                         target: 'request',
                         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -340,8 +339,7 @@ export default class OpenapiEndpointRenderer {
         if (this.shouldAutogenerateBody()) {
             return this.generateRequestBodyForModel({ openapiName, renderOpts });
         }
-        let schema = new OpenapiBodySegmentRenderer(this.requestBody, {
-            openapiName,
+        let schema = new OpenapiSegmentExpander(this.requestBody, {
             renderOpts,
             target: 'request',
         }).render().openapi;
@@ -406,7 +404,7 @@ export default 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)
@@ -518,8 +516,7 @@ export default class OpenapiEndpointRenderer {
                         if (metadata?.type) {
                             paramsShape.properties = {
                                 ...paramsShape.properties,
-                                [columnName]: new OpenapiBodySegmentRenderer(metadata.type, {
-                                    openapiName,
+                                [columnName]: new OpenapiSegmentExpander(metadata.type, {
                                     renderOpts,
                                     target: 'request',
                                 }).render().openapi,
@@ -563,8 +560,7 @@ export default class OpenapiEndpointRenderer {
                     }
             }
         }
-        let processedSchema = new OpenapiBodySegmentRenderer(paramsShape, {
-            openapiName,
+        let processedSchema = new OpenapiSegmentExpander(paramsShape, {
             renderOpts,
             target: 'request',
         }).render().openapi;
@@ -588,7 +584,6 @@ export default class OpenapiEndpointRenderer {
     parseResponses({ openapiName, renderOpts, }) {
         let responseData = {};
         const rendererOpts = {
-            openapiName,
             renderOpts,
             target: 'response',
         };
@@ -623,7 +618,7 @@ export default class OpenapiEndpointRenderer {
             const response = cloneDeepSafe(this.responses[statusCodeInt], obj => obj);
             responseData[statusCodeInt] ||= { description: statusDescription(statusCodeInt) };
             const statusResponse = responseData[statusCodeInt];
-            const results = new OpenapiBodySegmentRenderer(response, rendererOpts).render();
+            const results = new OpenapiSegmentExpander(response, rendererOpts).render();
             serializersAppearingInHandWrittenOpenapi = [
                 ...serializersAppearingInHandWrittenOpenapi,
                 ...results.referencedSerializers,
@@ -977,8 +972,7 @@ function serializersToSchemaObjects(controllerClass, actionName, serializers, {
     serializers.forEach(serializer => {
         const renderer = new SerializerOpenapiRenderer(serializer, renderOpts);
         const results = renderer.renderedOpenapi(alreadyExtractedDescendantSerializers);
-        const segmentRendererResults = new OpenapiBodySegmentRenderer(results.openapi, {
-            openapiName,
+        const segmentRendererResults = new OpenapiSegmentExpander(results.openapi, {
             renderOpts,
             target: 'response',
         }).render();

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

@@ -1,4 +1,46 @@
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+import { inferSerializersFromDreamClassOrViewModelClass, } from '@rvoh/dream';
 import isObject from '../../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]
+ * ```
+ */
 export default function allSerializersFromHandWrittenOpenapi(openapi) {
     const serializers = new Set();
     extractSerializers(openapi, serializers);
@@ -9,15 +51,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 = inferSerializersFromDreamClassOrViewModelClass(value.$serializable, value.$serializableSerializerKey);
+        foundSerializers.forEach(serializer => serializers.add(serializer));
+        //
+    }
     else if (isObject(value)) {
         // Recurse into objects
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         Object.values(value).forEach(val => extractSerializers(val, serializers));
         //
     }

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

@@ -1,5 +1,54 @@
+/* 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 */
+import { inferSerializersFromDreamClassOrViewModelClass, } from '@rvoh/dream';
 import isObject from '../../helpers/isObject.js';
 import SerializerOpenapiRenderer from '../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' }
+ * //     }
+ * //   }
+ * // }
+ * ```
+ */
 export default function allSerializersToRefsInOpenapi(openapi) {
     if (!openapi)
         return {};
@@ -10,24 +59,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($serializer).serializerRef;
         return {
             ...rest,
             ...openapiRenderer,
         };
+        //
+    }
+    else if (value.$serializable) {
+        const { $serializable, $serializableSerializerKey, ...rest } = value;
+        const foundSerializers = inferSerializersFromDreamClassOrViewModelClass($serializable, $serializableSerializerKey);
+        const refs = foundSerializers.map(serializer => new SerializerOpenapiRenderer(serializer).serializerRef);
+        if (refs.length === 0)
+            return rest;
+        if (refs.length === 1) {
+            return {
+                ...rest,
+                ...refs[0],
+            };
+        }
+        return {
+            ...rest,
+            anyOf: refs,
+        };
+        //
     }
     else if (isObject(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;
@@ -35,7 +98,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/types/src/helpers/typeHelpers.d.ts

@@ -1,5 +1,7 @@
+import { Dream, DreamOrViewModelClassSerializerKey, DreamSerializableArray, ViewModelClass } from '@rvoh/dream';
 export type FunctionProperties<T> = {
     [K in keyof T as T[K] extends (...args: any[]) => any ? K : never]: T[K];
 };
 export type FunctionPropertyNames<T> = keyof FunctionProperties<T> & string;
 export type StringToInt<T extends string> = T extends `${infer N extends number}` ? N : never;
+export type DreamOrViewModelClassSerializerArrayKeys<T extends DreamSerializableArray> = T['length'] extends 0 ? string : T[0] extends typeof Dream | ViewModelClass ? DreamOrViewModelClassSerializerKey<T[0]> & DreamOrViewModelClassSerializerArrayKeys<T extends [any, ...infer Rest] ? Rest : never> : DreamOrViewModelClassSerializerArrayKeys<T extends [any, ...infer Rest] ? Rest : never>;