@rvoh/psychic 0.36.0-beta.2 → 0.37.0-beta.4

package/dist/cjs/src/bin/index.js

@@ -32,7 +32,7 @@ const path = __importStar(require("node:path"));
 const TypesBuilder_js_1 = __importDefault(require("../cli/helpers/TypesBuilder.js"));
 const controller_js_1 = __importDefault(require("../generate/controller.js"));
 const resource_js_1 = __importDefault(require("../generate/resource.js"));
-const typechecks_js_1 = require("../helpers/typechecks.js");
+const isObject_js_1 = __importDefault(require("../helpers/isObject.js"));
 const app_js_1 = __importDefault(require("../openapi-renderer/app.js"));
 const index_js_1 = __importDefault(require("../psychic-app/index.js"));
 const index_js_2 = __importDefault(require("../server/index.js"));
@@ -75,7 +75,7 @@ class PsychicBin {
         for (const hook of psychicApp.specialHooks.cliSync) {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             const res = await hook();
-            if ((0, typechecks_js_1.isObject)(res)) {
+            if ((0, isObject_js_1.default)(res)) {
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 output = { ...output, ...res };
             }

package/dist/cjs/src/controller/helpers/isPaginatedResult.js

@@ -1,10 +1,13 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = isPaginatedResult;
-const typechecks_js_1 = require("../../helpers/typechecks.js");
+const isObject_js_1 = __importDefault(require("../../helpers/isObject.js"));
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function isPaginatedResult(result) {
-    if (!(0, typechecks_js_1.isObject)(result))
+    if (!(0, isObject_js_1.default)(result))
         return false;
     const paginatedFields = ['currentPage', 'pageCount', 'recordCount', 'results'];
     const keys = Object.keys(result);

package/dist/cjs/src/controller/index.js

@@ -193,12 +193,20 @@ class PsychicController {
     session;
     config;
     action;
+    renderOpts;
     constructor(req, res, { config, action, }) {
         this.req = req;
         this.res = res;
         this.config = config;
         this.session = new index_js_1.default(req, res);
         this.action = action;
+        // TODO: read casing from Dream app config
+        this.renderOpts = {
+            casing: 'camel',
+        };
+    }
+    get headers() {
+        return this.req.headers;
     }
     get params() {
         const params = {
@@ -262,6 +270,10 @@ class PsychicController {
             return data;
         const dreamApp = dream_1.DreamApp.getOrFail();
         const psychicControllerClass = this.constructor;
+        // if we already have a serializer, let's just render it
+        if (data instanceof dream_1.DreamSerializerBuilder || data instanceof dream_1.ObjectSerializerBuilder) {
+            return data.render(this.defaultSerializerPassthrough, this.renderOpts);
+        }
         // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
         const lookup = exports.controllerSerializerIndex.lookupModel(this.constructor, data.constructor);
         if (lookup?.length) {
@@ -276,9 +288,7 @@ class PsychicController {
                 // does not pass it into the call to DreamSerializer/ObjectSerializer,
                 // then it would be lost to serializers rendered via rendersOne/Many, and SerializerRenderer
                 // handles passing its passthrough data into those
-                this.defaultSerializerPassthrough, {
-                    casing: 'camel',
-                });
+                this.defaultSerializerPassthrough, this.renderOpts);
             }
         }
         else {
@@ -299,9 +309,7 @@ class PsychicController {
                     // does not pass it into the call to DreamSerializer/ObjectSerializer,
                     // then it would be lost to serializers rendered via rendersOne/Many, and SerializerRenderer
                     // handles passing its passthrough data into those
-                    this.defaultSerializerPassthrough, {
-                        casing: 'camel',
-                    });
+                    this.defaultSerializerPassthrough, this.renderOpts);
                 }
                 else {
                     throw new Error(`

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_util_1 = require("node:util");
+class AttemptedToDeriveDescendentSerializersFromNonSerializer extends Error {
+    serializer;
+    constructor(serializer) {
+        super();
+        this.serializer = serializer;
+    }
+    get message() {
+        return `
+Attempted to derive descendant serializers from non serializer:
+${(0, node_util_1.inspect)(this.serializer)}`;
+    }
+}
+exports.default = AttemptedToDeriveDescendentSerializersFromNonSerializer;

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ExpectedSerializerForRendersOneOrManyOption extends Error {
+    rendersOneOrMany;
+    referencingSerializerName;
+    attribute;
+    constructor(rendersOneOrMany, referencingSerializerName, attribute) {
+        super();
+        this.rendersOneOrMany = rendersOneOrMany;
+        this.referencingSerializerName = referencingSerializerName;
+        this.attribute = attribute;
+    }
+    get message() {
+        const baseString = `
+The \`serializer\` option on the \`${this.attribute.name}\` \`${this.rendersOneOrMany}\`
+on serializer \`${this.referencingSerializerName}\``;
+        if (this.attribute.options?.serializer) {
+            return `${baseString}
+specifies something other than a serializer.
+It should look something like the following:
+
+\`\`\`
+.${this.rendersOneOrMany}('${this.attribute.name}', {
+  serializer: MySerializer
+})
+\`\`\`
+`;
+        }
+        else {
+            return `${baseString}
+is throwing an error.
+`;
+        }
+    }
+}
+exports.default = ExpectedSerializerForRendersOneOrManyOption;

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class NoSerializerFoundForRendersOneAndMany extends Error {
+    associationName;
+    constructor(associationName) {
+        super();
+        this.associationName = associationName;
+    }
+    get message() {
+        return `
+Attempted to render \`rendersOne\` / \`rendersMany\`
+\`${this.associationName}\`, but could not locate a
+serializer.`;
+    }
+}
+exports.default = NoSerializerFoundForRendersOneAndMany;

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_util_1 = require("node:util");
+class NonSerializerPassedToSerializerOpenapiRenderer extends Error {
+    serializer;
+    constructor(serializer) {
+        super();
+        this.serializer = serializer;
+    }
+    get message() {
+        return `
+Non-serializer passed to SerializerOpenapiRenderer:
+${(0, node_util_1.inspect)(this.serializer)}`;
+    }
+}
+exports.default = NonSerializerPassedToSerializerOpenapiRenderer;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_util_1 = require("node:util");
+class NonSerializerSerializerOverrideProvided extends Error {
+    rendersAssociation;
+    serializer;
+    constructor(rendersAssociation, serializer) {
+        super();
+        this.rendersAssociation = rendersAssociation;
+        this.serializer = serializer;
+    }
+    get message() {
+        return `
+Non-serializer passed to \`serializerOverride\` of a rendersOne/Many declaration:
+
+rendersOne/Many declaration:
+${(0, node_util_1.inspect)(this.rendersAssociation)}
+
+non-serializer passed to serializerOverride:
+${(0, node_util_1.inspect)(this.serializer)}`;
+    }
+}
+exports.default = NonSerializerSerializerOverrideProvided;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ObjectSerializerRendersOneAndManyRequireClassType extends Error {
+    associationName;
+    constructor(associationName) {
+        super();
+        this.associationName = associationName;
+    }
+    get message() {
+        return `
+ObjectSerializer \`rendersOne\` and \`rendersMany\`
+options must include \`dreamClass\`, \`viewModelClass\`, or
+\`serializer\`.
+
+rendersOne/Many name: ${this.associationName}
+`;
+    }
+}
+exports.default = ObjectSerializerRendersOneAndManyRequireClassType;

package/dist/cjs/src/helpers/isObject.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = isObject;
+// also in Dream
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isObject(x) {
+    if (x === null)
+        return false;
+    if (Array.isArray(x))
+        return false;
+    return typeof x === 'object';
+}

package/dist/cjs/src/helpers/pathifyNestedObject.js

@@ -1,11 +1,14 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = pathifyNestedObject;
-const typechecks_js_1 = require("./typechecks.js");
+const isObject_js_1 = __importDefault(require("./isObject.js"));
 function pathifyNestedObject(obj, prefix = '') {
     return Object.keys(obj).reduce((acc, k) => {
         const pre = prefix.length ? prefix + '/' : '';
-        if ((0, typechecks_js_1.isObject)(obj[k]))
+        if ((0, isObject_js_1.default)(obj[k]))
             Object.assign(acc, pathifyNestedObject(obj[k], pre + k));
         else
             acc[pre + k] = obj[k];

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

@@ -0,0 +1,362 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const dream_1 = require("@rvoh/dream");
+const node_util_1 = require("node:util");
+const AttemptedToDeriveDescendentSerializersFromNonSerializer_js_1 = __importDefault(require("../error/openapi/AttemptedToDeriveDescendentSerializersFromNonSerializer.js"));
+const ExpectedSerializerForRendersOneOrManyOption_js_1 = __importDefault(require("../error/openapi/ExpectedSerializerForRendersOneOrManyOption.js"));
+const NonSerializerPassedToSerializerOpenapiRenderer_js_1 = __importDefault(require("../error/openapi/NonSerializerPassedToSerializerOpenapiRenderer.js"));
+const NonSerializerSerializerOverrideProvided_js_1 = __importDefault(require("../error/openapi/NonSerializerSerializerOverrideProvided.js"));
+const NoSerializerFoundForRendersOneAndMany_js_1 = __importDefault(require("../error/openapi/NoSerializerFoundForRendersOneAndMany.js"));
+const ObjectSerializerRendersOneAndManyRequireClassType_js_1 = __importDefault(require("../error/openapi/ObjectSerializerRendersOneAndManyRequireClassType.js"));
+const allSerializersFromHandWrittenOpenapi_js_1 = __importDefault(require("./helpers/allSerializersFromHandWrittenOpenapi.js"));
+const allSerializersToRefsInOpenapi_js_1 = __importDefault(require("./helpers/allSerializersToRefsInOpenapi.js"));
+const dreamAttributeOpenapiShape_js_1 = require("./helpers/dreamAttributeOpenapiShape.js");
+const openapiShorthandToOpenapi_js_1 = __importDefault(require("./helpers/openapiShorthandToOpenapi.js"));
+const NULL_OBJECT_OPENAPI = { type: 'null' };
+class SerializerOpenapiRenderer {
+    serializer;
+    casing;
+    suppressResponseEnums;
+    allOfSiblings = [];
+    constructor(serializer, { casing = 'camel', suppressResponseEnums = false, } = {}) {
+        this.serializer = serializer;
+        if (!(0, dream_1.isDreamSerializer)(this.serializer))
+            throw new NonSerializerPassedToSerializerOpenapiRenderer_js_1.default(this.serializer);
+        this.casing = casing;
+        this.suppressResponseEnums = suppressResponseEnums;
+    }
+    get globalName() {
+        return this.serializer.globalName ?? '--unnamed--';
+    }
+    get openapiName() {
+        return this.serializer.openapiName ?? '--unnamed--';
+    }
+    get serializerRef() {
+        return {
+            $ref: `#/components/schemas/${this.openapiName}`,
+        };
+    }
+    _serializerBuilder;
+    get serializerBuilder() {
+        if (this._serializerBuilder)
+            return this._serializerBuilder;
+        this._serializerBuilder = this.serializer(undefined, undefined);
+        return this._serializerBuilder;
+    }
+    renderedOpenapi(alreadyExtractedDescendantSerializers = {}) {
+        alreadyExtractedDescendantSerializers[this.serializer.globalName] = true;
+        const referencedSerializersAndOpenapiSchemaBodyShorthand = this._renderedOpenapi(alreadyExtractedDescendantSerializers);
+        if (this.allOfSiblings.length) {
+            const openapi = referencedSerializersAndOpenapiSchemaBodyShorthand.openapi;
+            return {
+                ...referencedSerializersAndOpenapiSchemaBodyShorthand,
+                openapi: {
+                    allOf: [openapi, ...this.allOfSiblings],
+                },
+            };
+        }
+        else {
+            return referencedSerializersAndOpenapiSchemaBodyShorthand;
+        }
+    }
+    _renderedOpenapi(alreadyExtractedDescendantSerializers) {
+        const referencedSerializersAndAttributes = this.renderedOpenapiAttributes(alreadyExtractedDescendantSerializers);
+        const requiredProperties = (0, dream_1.compact)(this.serializerBuilder['attributes'].map(attribute => {
+            const attributeType = attribute.type;
+            switch (attributeType) {
+                case 'attribute': {
+                    return attribute.options?.as ?? attribute.name;
+                }
+                case 'delegatedAttribute': {
+                    return attribute.options?.as ?? attribute.name;
+                }
+                case 'customAttribute': {
+                    return attribute.options.flatten ? null : attribute.name;
+                }
+                case 'rendersOne': {
+                    return attribute.options.flatten ? null : (attribute.options?.as ?? attribute.name);
+                }
+                case 'rendersMany': {
+                    return attribute.options?.as ?? attribute.name;
+                }
+                default: {
+                    // protection so that if a new ValidationType is ever added, this will throw a type error at build time
+                    const _never = attributeType;
+                    throw new Error(`Unhandled serializer attribute type: ${_never}`);
+                }
+            }
+        }));
+        return {
+            referencedSerializers: referencedSerializersAndAttributes.referencedSerializers,
+            openapi: {
+                type: 'object',
+                required: (0, dream_1.sort)((0, dream_1.uniq)(requiredProperties.map(property => this.setCase(property)))),
+                properties: (0, dream_1.sortObjectByKey)(referencedSerializersAndAttributes.attributes),
+            },
+        };
+    }
+    renderedOpenapiAttributes(alreadyExtractedDescendantSerializers = {}) {
+        const $typeForOpenapi = this.serializerBuilder['$typeForOpenapi'];
+        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 = [];
+            accumulator = (() => {
+                switch (attributeType) {
+                    ////////////////
+                    // attributes //
+                    ////////////////
+                    case 'attribute': {
+                        const outputAttributeName = this.setCase(attribute.options?.as ?? attribute.name);
+                        const openapi = attribute.options.openapi;
+                        newlyReferencedSerializers = (0, allSerializersFromHandWrittenOpenapi_js_1.default)(openapi);
+                        accumulator[outputAttributeName] = DataTypeForOpenapi?.isDream
+                            ? (0, dreamAttributeOpenapiShape_js_1.dreamColumnOpenapiShape)(DataTypeForOpenapi, attribute.name, openapi, {
+                                suppressResponseEnums: this.suppressResponseEnums,
+                            })
+                            : (0, allSerializersToRefsInOpenapi_js_1.default)((0, openapiShorthandToOpenapi_js_1.default)(openapi));
+                        return accumulator;
+                    }
+                    /////////////////////
+                    // end: attributes //
+                    /////////////////////
+                    ///////////////////////
+                    // custom attributes //
+                    ///////////////////////
+                    case 'customAttribute': {
+                        const outputAttributeName = this.setCase(attribute.name);
+                        const openapi = attribute.options.openapi;
+                        newlyReferencedSerializers = (0, allSerializersFromHandWrittenOpenapi_js_1.default)(openapi);
+                        if (attribute.options.flatten) {
+                            this.allOfSiblings.push((0, allSerializersToRefsInOpenapi_js_1.default)((0, openapiShorthandToOpenapi_js_1.default)(openapi)));
+                        }
+                        else {
+                            accumulator[outputAttributeName] = (0, allSerializersToRefsInOpenapi_js_1.default)((0, openapiShorthandToOpenapi_js_1.default)(openapi));
+                        }
+                        return accumulator;
+                    }
+                    ////////////////////////////
+                    // end: custom attributes //
+                    ////////////////////////////
+                    //////////////////////////
+                    // delegated attributes //
+                    //////////////////////////
+                    case 'delegatedAttribute': {
+                        const outputAttributeName = this.setCase(attribute.options?.as ?? attribute.name);
+                        const openapi = attribute.options.openapi;
+                        newlyReferencedSerializers = (0, allSerializersFromHandWrittenOpenapi_js_1.default)(openapi);
+                        accumulator[outputAttributeName] = (0, allSerializersToRefsInOpenapi_js_1.default)((0, openapiShorthandToOpenapi_js_1.default)(openapi));
+                        return accumulator;
+                    }
+                    ///////////////////////////////
+                    // end: delegated attributes //
+                    ///////////////////////////////
+                    //////////////////
+                    // rendersOnes  //
+                    //////////////////
+                    case 'rendersOne': {
+                        try {
+                            const outputAttributeName = this.setCase(attribute.options.as ?? attribute.name);
+                            const referencedSerializersAndOpenapiSchemaBodyShorthand = associationOpenapi(attribute, DataTypeForOpenapi, alreadyExtractedDescendantSerializers, openapiRenderingOpts);
+                            newlyReferencedSerializers =
+                                referencedSerializersAndOpenapiSchemaBodyShorthand.referencedSerializers;
+                            if (attribute.options.flatten && attribute.options.optional) {
+                                this.allOfSiblings.push({
+                                    anyOf: [referencedSerializersAndOpenapiSchemaBodyShorthand.openapi, NULL_OBJECT_OPENAPI],
+                                });
+                                //
+                            }
+                            else if (attribute.options.flatten) {
+                                this.allOfSiblings.push(referencedSerializersAndOpenapiSchemaBodyShorthand.openapi);
+                                //
+                            }
+                            else if (attribute.options.optional) {
+                                accumulator[outputAttributeName] = {
+                                    anyOf: [referencedSerializersAndOpenapiSchemaBodyShorthand.openapi, NULL_OBJECT_OPENAPI],
+                                };
+                            }
+                            else {
+                                accumulator[outputAttributeName] = referencedSerializersAndOpenapiSchemaBodyShorthand.openapi;
+                            }
+                            return accumulator;
+                        }
+                        catch (error) {
+                            if (error instanceof CallingSerializersThrewError)
+                                return accumulator;
+                            if (error instanceof AttemptedToDeriveDescendentSerializersFromNonSerializer_js_1.default)
+                                throw new ExpectedSerializerForRendersOneOrManyOption_js_1.default('rendersOne', this.globalName, attribute);
+                            throw error;
+                        }
+                    }
+                    ///////////////////////
+                    // end: rendersOnes  //
+                    ///////////////////////
+                    ///////////////////
+                    // rendersManys  //
+                    ///////////////////
+                    case 'rendersMany': {
+                        try {
+                            const outputAttributeName = this.setCase(attribute.options.as ?? attribute.name);
+                            const referencedSerializersAndOpenapiSchemaBodyShorthand = associationOpenapi(attribute, DataTypeForOpenapi, alreadyExtractedDescendantSerializers, openapiRenderingOpts);
+                            newlyReferencedSerializers =
+                                referencedSerializersAndOpenapiSchemaBodyShorthand.referencedSerializers;
+                            accumulator[outputAttributeName] = {
+                                type: 'array',
+                                items: referencedSerializersAndOpenapiSchemaBodyShorthand.openapi,
+                            };
+                            return accumulator;
+                        }
+                        catch (error) {
+                            if (error instanceof CallingSerializersThrewError)
+                                return accumulator;
+                            if (error instanceof AttemptedToDeriveDescendentSerializersFromNonSerializer_js_1.default)
+                                throw new ExpectedSerializerForRendersOneOrManyOption_js_1.default('rendersMany', this.globalName, attribute);
+                            throw error;
+                        }
+                    }
+                    ////////////////////////
+                    // end: rendersManys  //
+                    ////////////////////////
+                    default: {
+                        // protection so that if a new ValidationType is ever added, this will throw a type error at build time
+                        const _never = attributeType;
+                        throw new Error(`Unhandled serializer attribute type: ${_never}`);
+                    }
+                }
+            })();
+            const recursiveNewlyReferencedSerializers = newlyReferencedSerializers.flatMap(serializer => descendantSerializers(serializer, alreadyExtractedDescendantSerializers, openapiRenderingOpts));
+            referencedSerializers = [
+                ...referencedSerializers,
+                ...newlyReferencedSerializers,
+                ...recursiveNewlyReferencedSerializers,
+            ];
+            return accumulator;
+        }, renderedOpenapi);
+        return {
+            referencedSerializers: (0, dream_1.uniq)(referencedSerializers, serializer => serializer.globalName),
+            attributes: renderedOpenapi,
+        };
+    }
+    setCase(attr) {
+        switch (this.casing) {
+            case 'camel':
+                return attr;
+            case 'snake':
+                return (0, dream_1.snakeify)(attr);
+            default: {
+                // protection so that if a new Casing is ever added, this will throw a type error at build time
+                const _never = this.casing;
+                throw new Error(`Unhandled Casing: ${_never}`);
+            }
+        }
+    }
+}
+exports.default = SerializerOpenapiRenderer;
+function associationOpenapi(attribute, DataTypeForOpenapi, alreadyExtractedDescendantSerializers, opts) {
+    const serializerOverride = attribute.options.serializer;
+    if (serializerOverride) {
+        try {
+            return {
+                referencedSerializers: [
+                    serializerOverride,
+                    ...descendantSerializers(serializerOverride, alreadyExtractedDescendantSerializers, opts),
+                ],
+                openapi: new SerializerOpenapiRenderer(serializerOverride, opts).serializerRef,
+            };
+        }
+        catch (error) {
+            if (error instanceof NonSerializerPassedToSerializerOpenapiRenderer_js_1.default)
+                throw new NonSerializerSerializerOverrideProvided_js_1.default(attribute, serializerOverride);
+            throw error;
+        }
+    }
+    let associatedClasses;
+    const association = DataTypeForOpenapi?.isDream &&
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        DataTypeForOpenapi['getAssociationMetadata'](attribute.name);
+    if (association) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        associatedClasses = (0, dream_1.expandStiClasses)(association.modelCB());
+        //
+    }
+    else {
+        const associatedClass = attribute.options.dreamClass ?? attribute.options.viewModelClass;
+        if (associatedClass === undefined) {
+            let serializerCheck;
+            try {
+                ;
+                DataTypeForOpenapi?.prototype?.serializers;
+            }
+            catch {
+                throw new CallingSerializersThrewError();
+            }
+            if (serializerCheck)
+                throw new ObjectSerializerRendersOneAndManyRequireClassType_js_1.default(attribute.name);
+            throw new ObjectSerializerRendersOneAndManyRequireClassType_js_1.default(attribute.name);
+        }
+        if (associatedClass?.isDream) {
+            associatedClasses = (0, dream_1.expandStiClasses)(associatedClass);
+        }
+        else {
+            associatedClasses = [associatedClass];
+        }
+    }
+    const serializersOpenapi = associatedClasses.flatMap(associatedClass => (0, dream_1.inferSerializersFromDreamClassOrViewModelClass)(associatedClass, attribute.options.serializerKey));
+    if (serializersOpenapi.length === 0)
+        throw new NoSerializerFoundForRendersOneAndMany_js_1.default(attribute.name);
+    if (serializersOpenapi.length === 1) {
+        const serializer = serializersOpenapi[0];
+        return {
+            referencedSerializers: [
+                serializer,
+                ...descendantSerializers(serializer, alreadyExtractedDescendantSerializers, opts),
+            ],
+            openapi: new SerializerOpenapiRenderer(serializer, opts).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 }))),
+        },
+    };
+}
+function descendantSerializers(serializer, alreadyExtractedDescendantSerializers, opts) {
+    // 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)
+    if (alreadyExtractedDescendantSerializers[serializer.globalName])
+        return [];
+    if (!(0, dream_1.isDreamSerializer)(serializer))
+        throw new AttemptedToDeriveDescendentSerializersFromNonSerializer_js_1.default(serializer);
+    const immediateDescendantSerializers = new SerializerOpenapiRenderer(serializer, opts).renderedOpenapi(alreadyExtractedDescendantSerializers).referencedSerializers;
+    return [
+        ...immediateDescendantSerializers,
+        ...immediateDescendantSerializers.flatMap(descendantSerializer => descendantSerializers(descendantSerializer, alreadyExtractedDescendantSerializers, opts)),
+    ];
+}
+// When attempting to expand STI children, we might call `.serializers` on
+// an instance that throws an error just by calling `.serializers` (so that
+// they can be sure to define serializers on the STI children, but in this
+// case, there might be STI children that are intermediaries to the intended
+// STI children, so they don't have serializers and calling `.serializers`
+// throws an error)
+class CallingSerializersThrewError extends Error {
+}