@rvoh/psychic 0.36.0-beta.1 → 0.37.0-beta.3

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,24 +270,25 @@ 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) {
             const serializer = lookup?.[1];
             if ((0, dream_1.isDreamSerializer)(serializer)) {
-                return new dream_1.SerializerRenderer(
                 // passthrough data going into the serializer is the argument that gets
                 // used in the custom attribute callback function
-                serializer(data, this.defaultSerializerPassthrough), 
-                // passthrough data must be passed both into the serializer and the SerializerRenderer
+                return serializer(data, this.defaultSerializerPassthrough).render(
+                // passthrough data must be passed both into the serializer and render
                 // because, if the serializer does accept passthrough data, then passing it in is how
                 // it gets into the serializer, but if it does not accept passthrough data, and therefore
                 // 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',
-                }).render();
+                this.defaultSerializerPassthrough, this.renderOpts);
             }
         }
         else {
@@ -291,19 +300,16 @@ class PsychicController {
             if (serializerKey && Object.prototype.hasOwnProperty.call(dreamApp.serializers, serializerKey)) {
                 const serializer = dreamApp.serializers[serializerKey];
                 if (serializer && (0, dream_1.isDreamSerializer)(serializer)) {
-                    return new dream_1.SerializerRenderer(
                     // passthrough data going into the serializer is the argument that gets
                     // used in the custom attribute callback function
-                    serializer(data, this.defaultSerializerPassthrough), 
-                    // passthrough data must be passed both into the serializer and the SerializerRenderer
+                    return serializer(data, this.defaultSerializerPassthrough).render(
+                    // passthrough data must be passed both into the serializer and render
                     // because, if the serializer does accept passthrough data, then passing it in is how
                     // it gets into the serializer, but if it does not accept passthrough data, and therefore
                     // 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',
-                    }).render();
+                    this.defaultSerializerPassthrough, this.renderOpts);
                 }
                 else {
                     throw new Error(`

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

@@ -27,7 +27,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const dream_1 = require("@rvoh/dream");
-const lodash_es_1 = require("lodash-es");
 const fs = __importStar(require("node:fs/promises"));
 const node_util_1 = require("node:util");
 const UnexpectedUndefined_js_1 = __importDefault(require("../error/UnexpectedUndefined.js"));
@@ -36,8 +35,7 @@ const index_js_1 = __importDefault(require("../psychic-app/index.js"));
 const types_js_1 = require("../router/types.js");
 const index_js_2 = __importDefault(require("../server/index.js"));
 const defaults_js_1 = require("./defaults.js");
-const schemaDelimiter_js_1 = __importDefault(require("./helpers/schemaDelimiter.js"));
-const suppressResponseEnums_js_1 = __importDefault(require("./helpers/suppressResponseEnums.js"));
+const suppressResponseEnumsConfig_js_1 = __importDefault(require("./helpers/suppressResponseEnumsConfig.js"));
 const debugEnabled = (0, node_util_1.debuglog)('psychic').enabled;
 class OpenapiAppRenderer {
     /**
@@ -76,13 +74,12 @@ class OpenapiAppRenderer {
         return output;
     }
     static _toObject(routes, openapiName) {
-        const opts = {
-            openapiName,
+        const renderOpts = {
             casing: 'camel',
-            schemaDelimiter: (0, schemaDelimiter_js_1.default)(openapiName),
-            suppressResponseEnums: (0, suppressResponseEnums_js_1.default)(openapiName),
+            suppressResponseEnums: (0, suppressResponseEnumsConfig_js_1.default)(openapiName),
         };
-        let processedSchemas = {};
+        const alreadyExtractedDescendantSerializers = {};
+        const renderedSchemasOpenapi = {};
         const psychicApp = index_js_1.default.getOrFail();
         const controllers = psychicApp.controllers;
         const openapiConfig = psychicApp.openapi?.[openapiName];
@@ -127,7 +124,10 @@ class OpenapiAppRenderer {
                 const renderer = controller.openapi[key];
                 if (renderer === undefined)
                     throw new UnexpectedUndefined_js_1.default();
-                const endpointPayloadAndReferencedSerializers = renderer.toPathObject(routes, opts);
+                const endpointPayloadAndReferencedSerializers = renderer.toPathObject(routes, {
+                    openapiName,
+                    renderOpts,
+                });
                 const serializersAppearingInHandWrittenOpenapi = endpointPayloadAndReferencedSerializers.referencedSerializers;
                 const endpointPayload = endpointPayloadAndReferencedSerializers.openapi;
                 if (endpointPayload === undefined)
@@ -148,15 +148,16 @@ class OpenapiAppRenderer {
                     ...finalPathObject.parameters,
                     ...endpointPayloadPath.parameters,
                 ]);
-                const schemaRenderingResults = renderer.toSchemaObject({
-                    ...opts,
-                    processedSchemas,
+                renderer.toSchemaObject({
+                    openapiName,
+                    renderOpts,
+                    renderedSchemasOpenapi,
+                    alreadyExtractedDescendantSerializers,
                     serializersAppearingInHandWrittenOpenapi,
                 });
-                processedSchemas = { ...processedSchemas, ...schemaRenderingResults.processedSchemas };
                 finalOutput.components.schemas = {
                     ...finalOutput.components.schemas,
-                    ...schemaRenderingResults.renderedSchemas,
+                    ...renderedSchemasOpenapi,
                 };
             }
         }
@@ -168,7 +169,7 @@ class OpenapiAppRenderer {
         return finalOutput;
     }
     static combineParameters(parameters) {
-        const groupedParams = (0, lodash_es_1.groupBy)(parameters, 'name');
+        const groupedParams = (0, dream_1.groupBy)(parameters, obj => obj.name);
         return (0, dream_1.compact)(Object.keys(groupedParams).map(paramName => {
             const identicalParams = groupedParams[paramName] || [];
             return identicalParams.reduce((compositeParam, param) => {

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

@@ -12,7 +12,6 @@ const primitiveOpenapiStatementToOpenapi_js_1 = __importDefault(require("./helpe
 const schemaToRef_js_1 = __importDefault(require("./helpers/schemaToRef.js"));
 class OpenapiBodySegmentRenderer {
     bodySegment;
-    schemaDelimiter;
     casing;
     suppressResponseEnums;
     target;
@@ -23,12 +22,11 @@ class OpenapiBodySegmentRenderer {
      * Used to recursively parse nested object structures
      * within nested openapi objects
      */
-    constructor(bodySegment, { openapiName, schemaDelimiter, casing, suppressResponseEnums, target }) {
+    constructor(bodySegment, { openapiName, renderOpts, target }) {
         this.openapiName = openapiName;
         this.bodySegment = bodySegment;
-        this.schemaDelimiter = schemaDelimiter;
-        this.casing = casing;
-        this.suppressResponseEnums = suppressResponseEnums;
+        this.casing = renderOpts.casing;
+        this.suppressResponseEnums = renderOpts.suppressResponseEnums;
         this.target = target;
     }
     /**
@@ -390,7 +388,6 @@ The following values will be allowed:
             throw new NonSerializerSuppliedToSerializerBodySegment_js_1.default(this.bodySegment, serializer);
         const serializerRef = new dream_1.SerializerOpenapiRenderer(serializer, {
             casing: this.casing,
-            schemaDelimiter: this.schemaDelimiter,
             suppressResponseEnums: this.suppressResponseEnums,
         }).serializerRef;
         if (serializerRefBodySegment.many) {

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

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MissingControllerActionPairingInRoutes = void 0;
 const dream_1 = require("@rvoh/dream");
-const lodash_es_1 = require("lodash-es");
 const FailedToLookupSerializerForEndpoint_js_1 = __importDefault(require("../error/openapi/FailedToLookupSerializerForEndpoint.js"));
 const NonSerializerDerivedInOpenapiEndpointRenderer_js_1 = __importDefault(require("../error/openapi/NonSerializerDerivedInOpenapiEndpointRenderer.js"));
 const NonSerializerDerivedInToSchemaObjects_js_1 = __importDefault(require("../error/openapi/NonSerializerDerivedInToSchemaObjects.js"));
@@ -21,10 +20,6 @@ class OpenapiEndpointRenderer {
     dreamsOrSerializers;
     controllerClass;
     action;
-    openapiName;
-    casing;
-    schemaDelimiter;
-    suppressResponseEnums;
     many;
     paginate;
     responses;
@@ -96,18 +91,18 @@ class OpenapiEndpointRenderer {
      * `#toPathObject` specifically builds the `paths` portion of the
      * final openapi.json output
      */
-    toPathObject(routes, { openapiName, casing, schemaDelimiter, suppressResponseEnums, }) {
-        this.openapiName = openapiName;
-        this.casing = casing;
-        this.schemaDelimiter = schemaDelimiter;
-        this.suppressResponseEnums = suppressResponseEnums;
+    toPathObject(routes, { openapiName, renderOpts }) {
         const path = this.computedPath(routes);
         const method = this.computedMethod(routes);
-        const requestBody = this.computedRequestBody(routes);
-        const responsesAndReferencedSerializers = this.parseResponses();
+        const requestBody = this.computedRequestBody(routes, { openapiName, renderOpts });
+        const responsesAndReferencedSerializers = this.parseResponses({ openapiName, renderOpts });
         const output = {
             [path]: {
-                parameters: [...this.headersArray(), ...this.pathParamsArray(routes), ...this.queryArray()],
+                parameters: [
+                    ...this.headersArray({ openapiName }),
+                    ...this.pathParamsArray(routes),
+                    ...this.queryArray({ openapiName, renderOpts }),
+                ],
                 [method]: {
                     tags: this.tags || [],
                 },
@@ -149,18 +144,13 @@ class OpenapiEndpointRenderer {
      * final openapi.json output, adding any relevant entries that were uncovered
      * while parsing the responses and provided callback function.
      */
-    toSchemaObject({ openapiName, casing, schemaDelimiter, suppressResponseEnums, processedSchemas, serializersAppearingInHandWrittenOpenapi, }) {
-        this.openapiName = openapiName;
-        this.casing = casing;
-        this.schemaDelimiter = schemaDelimiter;
-        this.suppressResponseEnums = suppressResponseEnums;
+    toSchemaObject({ openapiName, renderOpts, alreadyExtractedDescendantSerializers, renderedSchemasOpenapi, serializersAppearingInHandWrittenOpenapi, }) {
         const serializers = this.getSerializerClasses() ?? [];
-        return serializersToSchemaObjects(this.controllerClass, this.action, [...serializers, ...serializersAppearingInHandWrittenOpenapi], {
-            openapiName: this.openapiName,
-            casing: this.casing,
-            schemaDelimiter: this.schemaDelimiter,
-            suppressResponseEnums: this.suppressResponseEnums,
-            processedSchemas,
+        serializersToSchemaObjects(this.controllerClass, this.action, [...serializers, ...serializersAppearingInHandWrittenOpenapi], {
+            openapiName,
+            renderOpts,
+            alreadyExtractedDescendantSerializers,
+            renderedSchemasOpenapi,
         });
     }
     /**
@@ -264,10 +254,8 @@ class OpenapiEndpointRenderer {
      * Generates the header portion of the openapi payload's
      * "parameters" field for a single endpoint.
      */
-    headersArray() {
-        const defaultHeaders = this.omitDefaultHeaders
-            ? {}
-            : (0, openapiOpts_js_1.default)(this.openapiName)?.defaults?.headers || {};
+    headersArray({ openapiName }) {
+        const defaultHeaders = this.omitDefaultHeaders ? {} : (0, openapiOpts_js_1.default)(openapiName)?.defaults?.headers || {};
         const headers = { ...defaultHeaders, ...(this.headers || []) };
         return ((0, dream_1.compact)(Object.keys(headers).map((headerName) => {
             const header = headers[headerName];
@@ -294,7 +282,7 @@ class OpenapiEndpointRenderer {
      * Generates the header portion of the openapi payload's
      * "parameters" field for a single endpoint.
      */
-    queryArray() {
+    queryArray({ openapiName, renderOpts, }) {
         const queryParams = Object.keys(this.query || {}).map((queryName) => {
             const queryParam = this.query[queryName];
             let output = {
@@ -318,10 +306,8 @@ class OpenapiEndpointRenderer {
                     ...output,
                     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                     schema: new body_segment_js_1.default(queryParam.schema, {
-                        openapiName: this.openapiName,
-                        schemaDelimiter: this.schemaDelimiter,
-                        casing: this.casing,
-                        suppressResponseEnums: this.suppressResponseEnums,
+                        openapiName,
+                        renderOpts,
                         target: 'request',
                         // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     }).render().openapi,
@@ -349,7 +335,7 @@ class OpenapiEndpointRenderer {
      *
      * Generates the requestBody portion of the endpoint
      */
-    computedRequestBody(routes) {
+    computedRequestBody(routes, { openapiName, renderOpts, }) {
         const method = this.computedMethod(routes);
         if (this.requestBody === null)
             return this.defaultRequestBody();
@@ -357,13 +343,11 @@ class OpenapiEndpointRenderer {
         if (!httpMethodsThatAllowBody.includes(method))
             return this.defaultRequestBody();
         if (this.shouldAutogenerateBody()) {
-            return this.generateRequestBodyForModel();
+            return this.generateRequestBodyForModel({ openapiName, renderOpts });
         }
         let schema = new body_segment_js_1.default(this.requestBody, {
-            openapiName: this.openapiName,
-            schemaDelimiter: this.schemaDelimiter,
-            casing: this.casing,
-            suppressResponseEnums: this.suppressResponseEnums,
+            openapiName,
+            renderOpts,
             target: 'request',
         }).render().openapi;
         const bodyPageParam = this.paginate?.body;
@@ -427,7 +411,7 @@ class OpenapiEndpointRenderer {
      * that model that are safe to ingest will be automatically added to
      * the request body.
      */
-    generateRequestBodyForModel() {
+    generateRequestBodyForModel({ openapiName, renderOpts, }) {
         const forDreamClass = this.requestBody?.for;
         const dreamClass = forDreamClass || this.getSingleDreamModelClass();
         if (!dreamClass)
@@ -540,10 +524,8 @@ class OpenapiEndpointRenderer {
                             paramsShape.properties = {
                                 ...paramsShape.properties,
                                 [columnName]: new body_segment_js_1.default(metadata.type, {
-                                    openapiName: this.openapiName,
-                                    schemaDelimiter: this.schemaDelimiter,
-                                    casing: this.casing,
-                                    suppressResponseEnums: this.suppressResponseEnums,
+                                    openapiName,
+                                    renderOpts,
                                     target: 'request',
                                 }).render().openapi,
                             };
@@ -587,10 +569,8 @@ class OpenapiEndpointRenderer {
             }
         }
         let processedSchema = new body_segment_js_1.default(paramsShape, {
-            openapiName: this.openapiName,
-            schemaDelimiter: this.schemaDelimiter,
-            casing: this.casing,
-            suppressResponseEnums: this.suppressResponseEnums,
+            openapiName,
+            renderOpts,
             target: 'request',
         }).render().openapi;
         const bodyPageParam = this.paginate?.body;
@@ -610,13 +590,11 @@ class OpenapiEndpointRenderer {
      *
      * Generates the responses portion of the endpoint
      */
-    parseResponses() {
+    parseResponses({ openapiName, renderOpts, }) {
         let responseData = {};
         const rendererOpts = {
-            openapiName: this.openapiName,
-            schemaDelimiter: this.schemaDelimiter,
-            casing: this.casing,
-            suppressResponseEnums: this.suppressResponseEnums,
+            openapiName,
+            renderOpts,
             target: 'response',
         };
         const computedStatus = this.status || this.defaultStatus;
@@ -632,7 +610,7 @@ class OpenapiEndpointRenderer {
                 };
             }
             else {
-                const parsingResults = this.parseSerializerResponseShape();
+                const parsingResults = this.parseSerializerResponseShape({ renderOpts });
                 serializersAppearingInHandWrittenOpenapi = [
                     ...serializersAppearingInHandWrittenOpenapi,
                     ...parsingResults.referencedSerializers,
@@ -647,7 +625,7 @@ class OpenapiEndpointRenderer {
         }
         Object.keys(this.responses || {}).forEach(statusCode => {
             const statusCodeInt = parseInt(statusCode);
-            const response = (0, lodash_es_1.cloneDeep)(this.responses[statusCodeInt]);
+            const response = (0, dream_1.cloneDeepSafe)(this.responses[statusCodeInt], obj => obj);
             responseData[statusCodeInt] ||= { description: statusDescription(statusCodeInt) };
             const statusResponse = responseData[statusCodeInt];
             const results = new body_segment_js_1.default(response, rendererOpts).render();
@@ -663,13 +641,13 @@ class OpenapiEndpointRenderer {
         });
         const defaultResponses = this.omitDefaultResponses
             ? {}
-            : (0, openapiOpts_js_1.default)(this.openapiName)?.defaults?.responses || {};
+            : (0, openapiOpts_js_1.default)(openapiName)?.defaults?.responses || {};
         const psychicAndConfigLevelDefaults = this.omitDefaultResponses
             ? {}
-            : (0, lodash_es_1.cloneDeep)({
+            : (0, dream_1.cloneDeepSafe)({
                 ...defaults_js_1.DEFAULT_OPENAPI_RESPONSES,
                 ...defaultResponses,
-            });
+            }, obj => obj);
         Object.keys(psychicAndConfigLevelDefaults).forEach(key => {
             if (!responseData[key]) {
                 const data = psychicAndConfigLevelDefaults[key];
@@ -708,7 +686,7 @@ class OpenapiEndpointRenderer {
      * returns a ref object for the callback passed to the
      * Openapi decorator.
      */
-    parseSerializerResponseShape() {
+    parseSerializerResponseShape({ renderOpts, }) {
         const serializerClasses = this.getSerializerClasses();
         if (!serializerClasses)
             return {
@@ -716,9 +694,9 @@ class OpenapiEndpointRenderer {
                 openapi: { description: 'no content' },
             };
         if (serializerClasses.length > 1) {
-            return this.parseMultiEntitySerializerResponseShape(serializerClasses);
+            return this.parseMultiEntitySerializerResponseShape(serializerClasses, { renderOpts });
         }
-        return this.parseSingleEntitySerializerResponseShape(serializerClasses[0]);
+        return this.parseSingleEntitySerializerResponseShape(serializerClasses[0], { renderOpts });
     }
     /**
      * @internal
@@ -731,16 +709,14 @@ class OpenapiEndpointRenderer {
      * public show() {...}
      * ```
      */
-    parseSingleEntitySerializerResponseShape(serializer) {
+    parseSingleEntitySerializerResponseShape(serializer, { renderOpts, }) {
         if (serializer === undefined) {
             throw new FailedToLookupSerializerForEndpoint_js_1.default(this.controllerClass, this.action);
         }
         if (!(0, dream_1.isDreamSerializer)(serializer)) {
             throw new SerializerForEndpointNotAFunction_js_1.default(this.controllerClass, this.action, serializer);
         }
-        const serializerOpenapiRenderer = new dream_1.SerializerOpenapiRenderer(serializer, {
-            schemaDelimiter: this.schemaDelimiter,
-        });
+        const serializerOpenapiRenderer = new dream_1.SerializerOpenapiRenderer(serializer, renderOpts);
         const finalOutput = {
             content: {
                 'application/json': {
@@ -807,18 +783,16 @@ class OpenapiEndpointRenderer {
      * public responses() {...}
      * ```
      */
-    parseMultiEntitySerializerResponseShape(serializers) {
+    parseMultiEntitySerializerResponseShape(serializers, { renderOpts, }) {
         const anyOf = { anyOf: [] };
         serializers.forEach(serializer => {
             if (!(0, dream_1.isDreamSerializer)(serializer))
                 throw new NonSerializerDerivedInOpenapiEndpointRenderer_js_1.default(this.controllerClass, this.action, serializer);
         });
-        const sortedSerializerClasses = (0, dream_1.sortBy)(serializers, serializer => new dream_1.SerializerOpenapiRenderer(serializer, { schemaDelimiter: this.schemaDelimiter }).openapiName);
+        const sortedSerializerClasses = (0, dream_1.sortBy)(serializers, serializer => new dream_1.SerializerOpenapiRenderer(serializer, renderOpts).openapiName);
         let referencedSerializers = [];
         sortedSerializerClasses.forEach(serializer => {
-            const serializerOpenapiRenderer = new dream_1.SerializerOpenapiRenderer(serializer, {
-                schemaDelimiter: this.schemaDelimiter,
-            });
+            const serializerOpenapiRenderer = new dream_1.SerializerOpenapiRenderer(serializer, renderOpts);
             anyOf.anyOf.push(serializerOpenapiRenderer.serializerRef);
             referencedSerializers = [
                 ...referencedSerializers,
@@ -998,55 +972,34 @@ function statusDescription(status) {
             return `Status ${status}`;
     }
 }
-function serializersToSchemaObjects(controllerClass, actionName, serializers, { casing, schemaDelimiter, suppressResponseEnums, openapiName, processedSchemas, }) {
+function serializersToSchemaObjects(controllerClass, actionName, serializers, { renderOpts, openapiName, alreadyExtractedDescendantSerializers, renderedSchemasOpenapi, }) {
     serializers.forEach(serializer => {
         if (!(0, dream_1.isDreamSerializer)(serializer))
             throw new NonSerializerDerivedInToSchemaObjects_js_1.default(controllerClass, actionName, serializer);
     });
-    serializers = serializers.filter(serializer => {
-        const serializerOpenapiRenderer = new dream_1.SerializerOpenapiRenderer(serializer, {
-            casing,
-            schemaDelimiter,
-            suppressResponseEnums,
-        });
-        return !processedSchemas[serializerOpenapiRenderer.globalName];
-    });
+    serializers = serializers.filter(serializer => !renderedSchemasOpenapi[new dream_1.SerializerOpenapiRenderer(serializer, renderOpts).openapiName]);
     if (!serializers.length)
-        return { processedSchemas, renderedSchemas: {} };
-    const renderedSchemas = {};
+        return;
     let dependentOnSerializers = [];
     serializers.forEach(serializer => {
-        const renderer = new dream_1.SerializerOpenapiRenderer(serializer, {
-            casing,
-            schemaDelimiter,
-            suppressResponseEnums,
-        });
-        const globalName = renderer.globalName;
-        processedSchemas = { ...processedSchemas, [globalName]: true };
-        const results = renderer.renderedOpenapi(processedSchemas);
+        const renderer = new dream_1.SerializerOpenapiRenderer(serializer, renderOpts);
+        const results = renderer.renderedOpenapi(alreadyExtractedDescendantSerializers);
         const segmentRendererResults = new body_segment_js_1.default(results.openapi, {
             openapiName,
-            casing,
-            schemaDelimiter,
-            suppressResponseEnums,
+            renderOpts,
             target: 'response',
         }).render();
-        renderedSchemas[renderer.openapiName] = segmentRendererResults.openapi;
+        renderedSchemasOpenapi[renderer.openapiName] = segmentRendererResults.openapi;
         dependentOnSerializers = [
             ...dependentOnSerializers,
             ...results.referencedSerializers,
-            ...segmentRendererResults.referencedSerializers,
+            ...segmentRendererResults.referencedSerializers, // should always be empty
         ];
     });
-    const recursiveResults = serializersToSchemaObjects(controllerClass, actionName, dependentOnSerializers, {
-        casing,
-        suppressResponseEnums,
-        schemaDelimiter,
+    serializersToSchemaObjects(controllerClass, actionName, dependentOnSerializers, {
+        renderOpts,
         openapiName,
-        processedSchemas,
+        alreadyExtractedDescendantSerializers,
+        renderedSchemasOpenapi,
     });
-    return {
-        processedSchemas: { ...processedSchemas, ...recursiveResults.processedSchemas },
-        renderedSchemas: { ...renderedSchemas, ...recursiveResults.renderedSchemas },
-    };
 }

package/dist/cjs/src/openapi-renderer/helpers/{suppressResponseEnums.js → suppressResponseEnumsConfig.js}

@@ -3,11 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = suppressResponseEnums;
+exports.default = suppressResponseEnumsConfig;
 const openapiOpts_js_1 = __importDefault(require("./openapiOpts.js"));
 /**
  * returns either the delimiter set in the app config, or else a blank string
  */
-function suppressResponseEnums(openapiName) {
+function suppressResponseEnumsConfig(openapiName) {
     return !!(0, openapiOpts_js_1.default)(openapiName)?.suppressResponseEnums;
 }

package/dist/cjs/src/psychic-app/index.js

@@ -190,7 +190,6 @@ Try setting it to something valid, like:
     _openapi = {
         default: {
             outputFilename: 'openapi.json',
-            schemaDelimiter: '',
             info: {
                 title: 'untitled openapi spec',
                 version: 'unknown version',

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

@@ -30,14 +30,10 @@ const dream_1 = require("@rvoh/dream");
 const cookieParser = __importStar(require("cookie-parser"));
 const cors = __importStar(require("cors"));
 const express = __importStar(require("express"));
-const OpenApiValidator = __importStar(require("express-openapi-validator"));
-const path = __importStar(require("node:path"));
-const node_util_1 = require("node:util");
-const isOpenapiError_js_1 = __importDefault(require("../helpers/isOpenapiError.js"));
 const index_js_1 = __importDefault(require("../psychic-app/index.js"));
 const index_js_2 = __importDefault(require("../router/index.js"));
 const startPsychicServer_js_1 = __importStar(require("./helpers/startPsychicServer.js"));
-const debugEnabled = (0, node_util_1.debuglog)('psychic').enabled;
+// const debugEnabled = debuglog('psychic').enabled
 class PsychicServer {
     static async startPsychicServer(opts) {
         return await (0, startPsychicServer_js_1.default)(opts);
@@ -92,7 +88,6 @@ class PsychicServer {
         for (const serverInitAfterMiddlewareHook of this.config.specialHooks.serverInitAfterMiddleware) {
             await serverInitAfterMiddlewareHook(this);
         }
-        this.initializeOpenapiValidation();
         await this.buildRoutes();
         for (const afterRoutesHook of this.config.specialHooks.serverInitAfterRoutes) {
             await afterRoutesHook(this);
@@ -171,35 +166,6 @@ class PsychicServer {
     initializeJSON() {
         this.expressApp.use(express.json(this.config.jsonOptions));
     }
-    initializeOpenapiValidation() {
-        const psychicApp = index_js_1.default.getOrFail();
-        for (const openapiName in psychicApp.openapi) {
-            const openapiOpts = psychicApp.openapi[openapiName];
-            if (openapiOpts?.validation) {
-                const opts = openapiOpts.validation;
-                opts.apiSpec ||= path.join(psychicApp.apiRoot, 'openapi.json');
-                this.expressApp.use(OpenApiValidator.middleware(opts));
-                this.expressApp.use((err, req, res, next) => {
-                    if ((0, isOpenapiError_js_1.default)(err)) {
-                        if (debugEnabled) {
-                            index_js_1.default.log((0, node_util_1.inspect)(err));
-                            console.trace();
-                        }
-                        res.status(err.status).json({
-                            message: err.message,
-                            errors: err.errors,
-                        });
-                    }
-                    else {
-                        if (debugEnabled) {
-                            index_js_1.default.logWithLevel('error', err);
-                        }
-                        next();
-                    }
-                });
-            }
-        }
-    }
     async buildRoutes() {
         const r = new index_js_2.default(this.expressApp, this.config);
         const psychicApp = index_js_1.default.getOrFail();