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

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

@@ -1,4 +1,4 @@
-import { DreamApp, GlobalNameNotSet, isDreamSerializer, SerializerRenderer, } from '@rvoh/dream';
+import { DreamApp, DreamSerializerBuilder, GlobalNameNotSet, isDreamSerializer, ObjectSerializerBuilder, } from '@rvoh/dream';
 import ParamValidationError from '../error/controller/ParamValidationError.js';
 import HttpStatusBadGateway from '../error/http/BadGateway.js';
 import HttpStatusBadRequest from '../error/http/BadRequest.js';
@@ -187,12 +187,20 @@ export default class PsychicController {
     session;
     config;
     action;
+    renderOpts;
     constructor(req, res, { config, action, }) {
         this.req = req;
         this.res = res;
         this.config = config;
         this.session = new Session(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 = {
@@ -256,24 +264,25 @@ export default class PsychicController {
             return data;
         const dreamApp = DreamApp.getOrFail();
         const psychicControllerClass = this.constructor;
+        // if we already have a serializer, let's just render it
+        if (data instanceof DreamSerializerBuilder || data instanceof 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 = controllerSerializerIndex.lookupModel(this.constructor, data.constructor);
         if (lookup?.length) {
             const serializer = lookup?.[1];
             if (isDreamSerializer(serializer)) {
-                return new 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 {
@@ -285,19 +294,16 @@ export default class PsychicController {
             if (serializerKey && Object.prototype.hasOwnProperty.call(dreamApp.serializers, serializerKey)) {
                 const serializer = dreamApp.serializers[serializerKey];
                 if (serializer && isDreamSerializer(serializer)) {
-                    return new 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/esm/src/openapi-renderer/app.js

@@ -1,5 +1,4 @@
-import { compact, sortObjectByKey } from '@rvoh/dream';
-import { groupBy } from 'lodash-es';
+import { compact, groupBy, sortObjectByKey } from '@rvoh/dream';
 import * as fs from 'node:fs/promises';
 import { debuglog } from 'node:util';
 import UnexpectedUndefined from '../error/UnexpectedUndefined.js';
@@ -8,8 +7,7 @@ import PsychicApp from '../psychic-app/index.js';
 import { HttpMethods } from '../router/types.js';
 import PsychicServer from '../server/index.js';
 import { DEFAULT_OPENAPI_COMPONENT_RESPONSES, DEFAULT_OPENAPI_COMPONENT_SCHEMAS } from './defaults.js';
-import schemaDelimiter from './helpers/schemaDelimiter.js';
-import suppressResponseEnums from './helpers/suppressResponseEnums.js';
+import suppressResponseEnumsConfig from './helpers/suppressResponseEnumsConfig.js';
 const debugEnabled = debuglog('psychic').enabled;
 export default class OpenapiAppRenderer {
     /**
@@ -48,13 +46,12 @@ export default class OpenapiAppRenderer {
         return output;
     }
     static _toObject(routes, openapiName) {
-        const opts = {
-            openapiName,
+        const renderOpts = {
             casing: 'camel',
-            schemaDelimiter: schemaDelimiter(openapiName),
-            suppressResponseEnums: suppressResponseEnums(openapiName),
+            suppressResponseEnums: suppressResponseEnumsConfig(openapiName),
         };
-        let processedSchemas = {};
+        const alreadyExtractedDescendantSerializers = {};
+        const renderedSchemasOpenapi = {};
         const psychicApp = PsychicApp.getOrFail();
         const controllers = psychicApp.controllers;
         const openapiConfig = psychicApp.openapi?.[openapiName];
@@ -99,7 +96,10 @@ export default class OpenapiAppRenderer {
                 const renderer = controller.openapi[key];
                 if (renderer === undefined)
                     throw new UnexpectedUndefined();
-                const endpointPayloadAndReferencedSerializers = renderer.toPathObject(routes, opts);
+                const endpointPayloadAndReferencedSerializers = renderer.toPathObject(routes, {
+                    openapiName,
+                    renderOpts,
+                });
                 const serializersAppearingInHandWrittenOpenapi = endpointPayloadAndReferencedSerializers.referencedSerializers;
                 const endpointPayload = endpointPayloadAndReferencedSerializers.openapi;
                 if (endpointPayload === undefined)
@@ -120,15 +120,16 @@ export default 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,
                 };
             }
         }
@@ -140,7 +141,7 @@ export default class OpenapiAppRenderer {
         return finalOutput;
     }
     static combineParameters(parameters) {
-        const groupedParams = groupBy(parameters, 'name');
+        const groupedParams = groupBy(parameters, obj => obj.name);
         return compact(Object.keys(groupedParams).map(paramName => {
             const identicalParams = groupedParams[paramName] || [];
             return identicalParams.reduce((compositeParam, param) => {

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

@@ -7,7 +7,6 @@ import primitiveOpenapiStatementToOpenapi from './helpers/primitiveOpenapiStatem
 import schemaToRef from './helpers/schemaToRef.js';
 export default class OpenapiBodySegmentRenderer {
     bodySegment;
-    schemaDelimiter;
     casing;
     suppressResponseEnums;
     target;
@@ -18,12 +17,11 @@ export default 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;
     }
     /**
@@ -385,7 +383,6 @@ The following values will be allowed:
             throw new NonSerializerSuppliedToSerializerBodySegment(this.bodySegment, serializer);
         const serializerRef = new SerializerOpenapiRenderer(serializer, {
             casing: this.casing,
-            schemaDelimiter: this.schemaDelimiter,
             suppressResponseEnums: this.suppressResponseEnums,
         }).serializerRef;
         if (serializerRefBodySegment.many) {

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

@@ -1,5 +1,4 @@
-import { SerializerOpenapiRenderer, compact, inferSerializersFromDreamClassOrViewModelClass, isDreamSerializer, sortBy, } from '@rvoh/dream';
-import { cloneDeep } from 'lodash-es';
+import { SerializerOpenapiRenderer, cloneDeepSafe, compact, inferSerializersFromDreamClassOrViewModelClass, isDreamSerializer, sortBy, } from '@rvoh/dream';
 import OpenApiFailedToLookupSerializerForEndpoint from '../error/openapi/FailedToLookupSerializerForEndpoint.js';
 import NonSerializerDerivedInOpenapiEndpointRenderer from '../error/openapi/NonSerializerDerivedInOpenapiEndpointRenderer.js';
 import NonSerializerDerivedInToSchemaObjects from '../error/openapi/NonSerializerDerivedInToSchemaObjects.js';
@@ -15,10 +14,6 @@ export default class OpenapiEndpointRenderer {
     dreamsOrSerializers;
     controllerClass;
     action;
-    openapiName;
-    casing;
-    schemaDelimiter;
-    suppressResponseEnums;
     many;
     paginate;
     responses;
@@ -90,18 +85,18 @@ export default 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 || [],
                 },
@@ -143,18 +138,13 @@ export default 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,
         });
     }
     /**
@@ -258,10 +248,8 @@ export default class OpenapiEndpointRenderer {
      * Generates the header portion of the openapi payload's
      * "parameters" field for a single endpoint.
      */
-    headersArray() {
-        const defaultHeaders = this.omitDefaultHeaders
-            ? {}
-            : openapiOpts(this.openapiName)?.defaults?.headers || {};
+    headersArray({ openapiName }) {
+        const defaultHeaders = this.omitDefaultHeaders ? {} : openapiOpts(openapiName)?.defaults?.headers || {};
         const headers = { ...defaultHeaders, ...(this.headers || []) };
         return (compact(Object.keys(headers).map((headerName) => {
             const header = headers[headerName];
@@ -288,7 +276,7 @@ export default 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 = {
@@ -312,10 +300,8 @@ export default class OpenapiEndpointRenderer {
                     ...output,
                     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                     schema: new OpenapiBodySegmentRenderer(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,
@@ -343,7 +329,7 @@ export default 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();
@@ -351,13 +337,11 @@ export default class OpenapiEndpointRenderer {
         if (!httpMethodsThatAllowBody.includes(method))
             return this.defaultRequestBody();
         if (this.shouldAutogenerateBody()) {
-            return this.generateRequestBodyForModel();
+            return this.generateRequestBodyForModel({ openapiName, renderOpts });
         }
         let schema = new OpenapiBodySegmentRenderer(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;
@@ -421,7 +405,7 @@ export default 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)
@@ -534,10 +518,8 @@ export default class OpenapiEndpointRenderer {
                             paramsShape.properties = {
                                 ...paramsShape.properties,
                                 [columnName]: new OpenapiBodySegmentRenderer(metadata.type, {
-                                    openapiName: this.openapiName,
-                                    schemaDelimiter: this.schemaDelimiter,
-                                    casing: this.casing,
-                                    suppressResponseEnums: this.suppressResponseEnums,
+                                    openapiName,
+                                    renderOpts,
                                     target: 'request',
                                 }).render().openapi,
                             };
@@ -581,10 +563,8 @@ export default class OpenapiEndpointRenderer {
             }
         }
         let processedSchema = new OpenapiBodySegmentRenderer(paramsShape, {
-            openapiName: this.openapiName,
-            schemaDelimiter: this.schemaDelimiter,
-            casing: this.casing,
-            suppressResponseEnums: this.suppressResponseEnums,
+            openapiName,
+            renderOpts,
             target: 'request',
         }).render().openapi;
         const bodyPageParam = this.paginate?.body;
@@ -604,13 +584,11 @@ export default 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;
@@ -626,7 +604,7 @@ export default class OpenapiEndpointRenderer {
                 };
             }
             else {
-                const parsingResults = this.parseSerializerResponseShape();
+                const parsingResults = this.parseSerializerResponseShape({ renderOpts });
                 serializersAppearingInHandWrittenOpenapi = [
                     ...serializersAppearingInHandWrittenOpenapi,
                     ...parsingResults.referencedSerializers,
@@ -641,7 +619,7 @@ export default class OpenapiEndpointRenderer {
         }
         Object.keys(this.responses || {}).forEach(statusCode => {
             const statusCodeInt = parseInt(statusCode);
-            const response = cloneDeep(this.responses[statusCodeInt]);
+            const response = cloneDeepSafe(this.responses[statusCodeInt], obj => obj);
             responseData[statusCodeInt] ||= { description: statusDescription(statusCodeInt) };
             const statusResponse = responseData[statusCodeInt];
             const results = new OpenapiBodySegmentRenderer(response, rendererOpts).render();
@@ -657,13 +635,13 @@ export default class OpenapiEndpointRenderer {
         });
         const defaultResponses = this.omitDefaultResponses
             ? {}
-            : openapiOpts(this.openapiName)?.defaults?.responses || {};
+            : openapiOpts(openapiName)?.defaults?.responses || {};
         const psychicAndConfigLevelDefaults = this.omitDefaultResponses
             ? {}
-            : cloneDeep({
+            : cloneDeepSafe({
                 ...DEFAULT_OPENAPI_RESPONSES,
                 ...defaultResponses,
-            });
+            }, obj => obj);
         Object.keys(psychicAndConfigLevelDefaults).forEach(key => {
             if (!responseData[key]) {
                 const data = psychicAndConfigLevelDefaults[key];
@@ -702,7 +680,7 @@ export default class OpenapiEndpointRenderer {
      * returns a ref object for the callback passed to the
      * Openapi decorator.
      */
-    parseSerializerResponseShape() {
+    parseSerializerResponseShape({ renderOpts, }) {
         const serializerClasses = this.getSerializerClasses();
         if (!serializerClasses)
             return {
@@ -710,9 +688,9 @@ export default 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
@@ -725,16 +703,14 @@ export default class OpenapiEndpointRenderer {
      * public show() {...}
      * ```
      */
-    parseSingleEntitySerializerResponseShape(serializer) {
+    parseSingleEntitySerializerResponseShape(serializer, { renderOpts, }) {
         if (serializer === undefined) {
             throw new OpenApiFailedToLookupSerializerForEndpoint(this.controllerClass, this.action);
         }
         if (!isDreamSerializer(serializer)) {
             throw new OpenApiSerializerForEndpointNotAFunction(this.controllerClass, this.action, serializer);
         }
-        const serializerOpenapiRenderer = new SerializerOpenapiRenderer(serializer, {
-            schemaDelimiter: this.schemaDelimiter,
-        });
+        const serializerOpenapiRenderer = new SerializerOpenapiRenderer(serializer, renderOpts);
         const finalOutput = {
             content: {
                 'application/json': {
@@ -801,18 +777,16 @@ export default class OpenapiEndpointRenderer {
      * public responses() {...}
      * ```
      */
-    parseMultiEntitySerializerResponseShape(serializers) {
+    parseMultiEntitySerializerResponseShape(serializers, { renderOpts, }) {
         const anyOf = { anyOf: [] };
         serializers.forEach(serializer => {
             if (!isDreamSerializer(serializer))
                 throw new NonSerializerDerivedInOpenapiEndpointRenderer(this.controllerClass, this.action, serializer);
         });
-        const sortedSerializerClasses = sortBy(serializers, serializer => new SerializerOpenapiRenderer(serializer, { schemaDelimiter: this.schemaDelimiter }).openapiName);
+        const sortedSerializerClasses = sortBy(serializers, serializer => new SerializerOpenapiRenderer(serializer, renderOpts).openapiName);
         let referencedSerializers = [];
         sortedSerializerClasses.forEach(serializer => {
-            const serializerOpenapiRenderer = new SerializerOpenapiRenderer(serializer, {
-                schemaDelimiter: this.schemaDelimiter,
-            });
+            const serializerOpenapiRenderer = new SerializerOpenapiRenderer(serializer, renderOpts);
             anyOf.anyOf.push(serializerOpenapiRenderer.serializerRef);
             referencedSerializers = [
                 ...referencedSerializers,
@@ -990,55 +964,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 (!isDreamSerializer(serializer))
             throw new NonSerializerDerivedInToSchemaObjects(controllerClass, actionName, serializer);
     });
-    serializers = serializers.filter(serializer => {
-        const serializerOpenapiRenderer = new SerializerOpenapiRenderer(serializer, {
-            casing,
-            schemaDelimiter,
-            suppressResponseEnums,
-        });
-        return !processedSchemas[serializerOpenapiRenderer.globalName];
-    });
+    serializers = serializers.filter(serializer => !renderedSchemasOpenapi[new SerializerOpenapiRenderer(serializer, renderOpts).openapiName]);
     if (!serializers.length)
-        return { processedSchemas, renderedSchemas: {} };
-    const renderedSchemas = {};
+        return;
     let dependentOnSerializers = [];
     serializers.forEach(serializer => {
-        const renderer = new SerializerOpenapiRenderer(serializer, {
-            casing,
-            schemaDelimiter,
-            suppressResponseEnums,
-        });
-        const globalName = renderer.globalName;
-        processedSchemas = { ...processedSchemas, [globalName]: true };
-        const results = renderer.renderedOpenapi(processedSchemas);
+        const renderer = new SerializerOpenapiRenderer(serializer, renderOpts);
+        const results = renderer.renderedOpenapi(alreadyExtractedDescendantSerializers);
         const segmentRendererResults = new OpenapiBodySegmentRenderer(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/esm/src/openapi-renderer/helpers/{suppressResponseEnums.js → suppressResponseEnumsConfig.js}

@@ -2,6 +2,6 @@ import openapiOpts from './openapiOpts.js';
 /**
  * returns either the delimiter set in the app config, or else a blank string
  */
-export default function suppressResponseEnums(openapiName) {
+export default function suppressResponseEnumsConfig(openapiName) {
     return !!openapiOpts(openapiName)?.suppressResponseEnums;
 }

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

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

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

@@ -2,14 +2,10 @@ import { closeAllDbConnections, DreamLogos } from '@rvoh/dream';
 import * as cookieParser from 'cookie-parser';
 import * as cors from 'cors';
 import * as express from 'express';
-import * as OpenApiValidator from 'express-openapi-validator';
-import * as path from 'node:path';
-import { debuglog, inspect } from 'node:util';
-import isOpenapiError from '../helpers/isOpenapiError.js';
 import PsychicApp from '../psychic-app/index.js';
 import PsychicRouter from '../router/index.js';
 import startPsychicServer, { createPsychicHttpInstance, } from './helpers/startPsychicServer.js';
-const debugEnabled = debuglog('psychic').enabled;
+// const debugEnabled = debuglog('psychic').enabled
 export default class PsychicServer {
     static async startPsychicServer(opts) {
         return await startPsychicServer(opts);
@@ -64,7 +60,6 @@ export default 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);
@@ -143,35 +138,6 @@ export default class PsychicServer {
     initializeJSON() {
         this.expressApp.use(express.json(this.config.jsonOptions));
     }
-    initializeOpenapiValidation() {
-        const psychicApp = PsychicApp.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 (isOpenapiError(err)) {
-                        if (debugEnabled) {
-                            PsychicApp.log(inspect(err));
-                            console.trace();
-                        }
-                        res.status(err.status).json({
-                            message: err.message,
-                            errors: err.errors,
-                        });
-                    }
-                    else {
-                        if (debugEnabled) {
-                            PsychicApp.logWithLevel('error', err);
-                        }
-                        next();
-                    }
-                });
-            }
-        }
-    }
     async buildRoutes() {
         const r = new PsychicRouter(this.expressApp, this.config);
         const psychicApp = PsychicApp.getOrFail();

package/dist/types/src/controller/index.d.ts

@@ -1,4 +1,4 @@
-import { Dream, DreamModelSerializerType, DreamParamSafeAttributes, SimpleObjectSerializerType } from '@rvoh/dream';
+import { Dream, DreamModelSerializerType, DreamParamSafeAttributes, SerializerRendererOpts, SimpleObjectSerializerType } from '@rvoh/dream';
 import { Request, Response } from 'express';
 import { ControllerHook } from '../controller/hooks.js';
 import { HttpStatusCodeInt, HttpStatusSymbol } from '../error/http/status-codes.js';
@@ -119,10 +119,12 @@ export default class PsychicController {
     session: Session;
     config: PsychicApp;
     action: string;
+    renderOpts: SerializerRendererOpts;
     constructor(req: Request, res: Response, { config, action, }: {
         config: PsychicApp;
         action: string;
     });
+    get headers(): import("http").IncomingHttpHeaders;
     get params(): PsychicParamsDictionary;
     param<ReturnType = string>(key: string): ReturnType;
     castParam<const EnumType extends readonly string[], OptsType extends ParamsCastOptions<EnumType>, ExpectedType extends (typeof PsychicParamsPrimitiveLiterals)[number] | RegExp>(key: string, expectedType: ExpectedType, opts?: OptsType): ValidatedAllowsNull<ExpectedType, OptsType> extends infer T ? T extends ValidatedAllowsNull<ExpectedType, OptsType> ? T extends true ? ValidatedReturnType<ExpectedType, OptsType> | null | undefined : ValidatedReturnType<ExpectedType, OptsType> : never : never;

package/dist/types/src/openapi-renderer/body-segment.d.ts

@@ -1,15 +1,12 @@
-import { DreamModelSerializerType, OpenapiSchemaBody, OpenapiSchemaBodyShorthand, OpenapiShorthandPrimitiveTypes, SerializerCasing, SimpleObjectSerializerType } from '@rvoh/dream';
-import { OpenapiEndpointResponse, OpenapiResponses } from './endpoint.js';
+import { DreamModelSerializerType, OpenapiSchemaBody, OpenapiSchemaBodyShorthand, OpenapiShorthandPrimitiveTypes, SimpleObjectSerializerType } from '@rvoh/dream';
+import { OpenapiEndpointResponse, OpenapiRenderOpts, OpenapiResponses } from './endpoint.js';
 export interface OpenapiBodySegmentRendererOpts {
     openapiName: string;
-    schemaDelimiter: string;
-    casing: SerializerCasing;
-    suppressResponseEnums: boolean;
+    renderOpts: OpenapiRenderOpts;
     target: OpenapiBodyTarget;
 }
 export default class OpenapiBodySegmentRenderer {
     private bodySegment;
-    private schemaDelimiter;
     private casing;
     private suppressResponseEnums;
     private target;
@@ -20,7 +17,7 @@ export default class OpenapiBodySegmentRenderer {
      * Used to recursively parse nested object structures
      * within nested openapi objects
      */
-    constructor(bodySegment: OpenapiBodySegment, { openapiName, schemaDelimiter, casing, suppressResponseEnums, target }: OpenapiBodySegmentRendererOpts);
+    constructor(bodySegment: OpenapiBodySegment, { openapiName, renderOpts, target }: OpenapiBodySegmentRendererOpts);
     /**
      * returns the shorthanded body segment, rendered
      * to the appropriate openapi shape