@rvoh/psychic 0.26.3 → 0.27.2

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsychicApplicationAllowedPackageManagersEnumValues = void 0;
 const dream_1 = require("@rvoh/dream");
 const init_missing_api_root_js_1 = require("../error/psychic-application/init-missing-api-root.js");
 const init_missing_call_to_load_controllers_js_1 = require("../error/psychic-application/init-missing-call-to-load-controllers.js");
@@ -9,6 +10,7 @@ const EnvInternal_js_1 = require("../helpers/EnvInternal.js");
 const cache_js_1 = require("./cache.js");
 const importControllers_js_1 = require("./helpers/import/importControllers.js");
 const lookupClassByGlobalName_js_1 = require("./helpers/lookupClassByGlobalName.js");
+const init_missing_package_manager_js_1 = require("../error/psychic-application/init-missing-package-manager.js");
 class PsychicApplication {
     static async init(cb, dreamCb, opts = {}) {
         let psychicApp;
@@ -21,11 +23,16 @@ class PsychicApplication {
                 throw new init_missing_api_root_js_1.default();
             if (!psychicApp.routesCb)
                 throw new init_missing_routes_callback_js_1.default();
+            if (!exports.PsychicApplicationAllowedPackageManagersEnumValues.includes(psychicApp.packageManager))
+                throw new init_missing_package_manager_js_1.default();
             if (psychicApp.encryption?.cookies?.current)
                 this.checkKey('cookies', psychicApp.encryption.cookies.current.key, psychicApp.encryption.cookies.current.algorithm);
             await psychicApp.inflections?.();
             dreamApp.set('projectRoot', psychicApp.apiRoot);
             dreamApp.set('logger', psychicApp.logger);
+            for (const plugin of psychicApp.plugins) {
+                await plugin(psychicApp);
+            }
             (0, cache_js_1.cachePsychicApplication)(psychicApp);
         });
         return psychicApp;
@@ -34,6 +41,29 @@ class PsychicApplication {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return (0, lookupClassByGlobalName_js_1.default)(name);
     }
+    /**
+     * @internal
+     *
+     * used to provide the correct package manager syntax for running a script
+     * inside of the package.json "scripts" section.
+     */
+    packageManagerRunCmd(cmd) {
+        switch (this.packageManager) {
+            case 'npm':
+                return `npm run ${cmd}`;
+            default:
+                return `${this.packageManager} ${cmd}`;
+        }
+    }
+    /**
+     * @internal
+     *
+     * adds the necessary package manager prefix to the psy command provided
+     * i.e. `psyCmd('sync')`
+     */
+    psyCmd(cmd) {
+        return this.packageManagerRunCmd(`psy ${cmd}`);
+    }
     static checkKey(encryptionIdentifier, key, algorithm) {
         if (!dream_1.Encrypt.validateKey(key, algorithm))
             console.warn(`
@@ -108,14 +138,18 @@ Try setting it to something valid, like:
     get logger() {
         return this._logger;
     }
-    _sslCredentials;
+    _sslCredentials = undefined;
     get sslCredentials() {
         return this._sslCredentials;
     }
-    _saltRounds;
+    _saltRounds = undefined;
     get saltRounds() {
         return this._saltRounds;
     }
+    _packageManager;
+    get packageManager() {
+        return this._packageManager;
+    }
     _routesCb;
     get routesCb() {
         return this._routesCb;
@@ -196,6 +230,10 @@ Try setting it to something valid, like:
     get controllers() {
         return (0, importControllers_js_1.getControllersOrFail)();
     }
+    _plugins = [];
+    get plugins() {
+        return this._plugins;
+    }
     async load(resourceType, resourcePath, 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     importCb) {
@@ -226,6 +264,9 @@ Try setting it to something valid, like:
         await this.inflections?.();
         this.booted = true;
     }
+    plugin(cb) {
+        this._plugins.push(cb);
+    }
     on(hookEventType, cb) {
         switch (hookEventType) {
             case 'server:error':
@@ -306,6 +347,9 @@ Try setting it to something valid, like:
             case 'port':
                 this._port = value;
                 break;
+            case 'packageManager':
+                this._packageManager = value;
+                break;
             case 'saltRounds':
                 this._saltRounds = value;
                 break;
@@ -344,3 +388,4 @@ Try setting it to something valid, like:
     }
 }
 exports.default = PsychicApplication;
+exports.PsychicApplicationAllowedPackageManagersEnumValues = ['yarn', 'npm', 'pnpm'];

package/dist/esm/src/bin/helpers/enumsAndTheirValues.js

@@ -7,8 +7,9 @@ SELECT pg_type.typname AS enum_type, pg_enum.enumlabel AS enum_label FROM pg_typ
 `.execute(db('primary'));
     const rowData = {};
     rows.forEach(row => {
-        rowData[row.enumType] ||= [];
-        rowData[row.enumType].push(row.enumLabel);
+        const enumType = row.enumType;
+        rowData[enumType] ||= [];
+        rowData[enumType].push(row.enumLabel);
     });
     return rowData;
 }

package/dist/esm/src/bin/helpers/enumsFileStr.js

@@ -6,7 +6,7 @@ export default async function enumsFileStr() {
     let enumsFileStr = autogeneratedFileDisclaimer();
     Object.keys(enums).forEach(enumName => {
         const exportedTypeName = pascalizeFileName(enumName) + 'Values';
-        const values = enums[enumName];
+        const values = enums[enumName] || [];
         enumsFileStr += `\
 export const ${exportedTypeName} = [
   ${values.map(val => `'${val}'`).join(',\n  ')}

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

@@ -25,6 +25,20 @@ export default class PsychicBin {
         if (!bypassDreamSync)
             await DreamBin.sync(() => { });
         await PsychicBin.syncTypes();
+        const psychicApp = PsychicApplication.getOrFail();
+        DreamCLI.logger.logStartProgress('running post-sync operations...');
+        // call post-sync command in a separate process, so that newly-generated
+        // types can be reloaded and brought into all classes.
+        await DreamCLI.spawn(psychicApp.psyCmd('post-sync'), {
+            onStdout: message => {
+                DreamCLI.logger.logContinueProgress(`[post-sync]` + ' ' + message, {
+                    logPrefixColor: 'cyan',
+                });
+            },
+        });
+        DreamCLI.logger.logEndProgress();
+    }
+    static async postSync() {
         const psychicApp = PsychicApplication.getOrFail();
         await PsychicBin.syncOpenapiJson();
         if (psychicApp.openapi?.syncEnumsToClient) {

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

@@ -48,6 +48,14 @@ export default class PsychicCLI {
             await PsychicBin.sync();
             process.exit();
         });
+        program
+            .command('post-sync')
+            .description('an internal command that runs as the second stage of the `sync` command, since after types are rebuit, the application needs to be reloaded before autogenerating certain files, since those files will need to leverage the updated types')
+            .action(async () => {
+            await initializePsychicApplication();
+            await PsychicBin.postSync();
+            process.exit();
+        });
         program
             .command('sync:routes')
             .description('reads the routes generated by your app and generates a cache file, which is then used to give autocomplete support to the route helper, amoongst other things.')

package/dist/esm/src/devtools/helpers/launchDevServer.js

@@ -1,6 +1,7 @@
 import { spawn } from 'child_process';
 import { createServer } from 'net';
 import sleep from '../../../spec/helpers/sleep.js';
+import UnexpectedUndefined from '../../error/UnexpectedUndefined.js';
 const devServerProcesses = {};
 export async function launchDevServer(key, { port = 3000, cmd = 'yarn client', timeout = 5000 } = {}) {
     if (devServerProcesses[key])
@@ -8,6 +9,8 @@ export async function launchDevServer(key, { port = 3000, cmd = 'yarn client', t
     if (process.env.DEBUG === '1')
         console.log('Starting server...');
     const [_cmd, ...args] = cmd.split(' ');
+    if (_cmd === undefined)
+        throw new UnexpectedUndefined();
     const proc = spawn(_cmd, args, {
         detached: true,
         env: {

package/dist/esm/src/error/UnexpectedUndefined.js

@@ -0,0 +1,11 @@
+export default class UnexpectedUndefined extends Error {
+    constructor() {
+        super();
+    }
+    get message() {
+        return `Undefined detected where it should never happen since we are iterating 
+over keys of an internal object that should not have undefined values.
+
+This was added as part of activating noUncheckedIndexedAccess in tsconfig.`;
+    }
+}

package/dist/esm/src/error/psychic-application/init-missing-package-manager.js

@@ -0,0 +1,17 @@
+export default class PsychicApplicationInitMissingPackageManager extends Error {
+    constructor() {
+        super();
+    }
+    get message() {
+        return `
+must set packageManager when initializing a new PsychicApplication.
+
+within conf/app.ts, you must have a call to "#set('packageManager', '<YOUR_CHOSEN_PACKAGE_MANAGER>')", i.e.
+
+  // conf/app.ts
+  export default async (app: PsychicApplication) => {
+    await app.set('packageManager', 'yarn')
+  }
+    `;
+    }
+}

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

@@ -1,6 +1,7 @@
 import { hyphenize, standardizeFullyQualifiedModelName } from '@rvoh/dream';
 import * as fs from 'fs/promises';
 import { existsSync } from 'node:fs';
+import UnexpectedUndefined from '../error/UnexpectedUndefined.js';
 import EnvInternal from '../helpers/EnvInternal.js';
 import psychicFileAndDirPaths from '../helpers/path/psychicFileAndDirPaths.js';
 import psychicPath from '../helpers/path/psychicPath.js';
@@ -20,6 +21,10 @@ export default async function generateController({ fullyQualifiedControllerName,
         if (controllerNameParts.length > (isAdmin ? 1 : 0)) {
             // Write the ancestor controller
             const [baseAncestorName, baseAncestorImportStatement] = baseAncestorNameAndImport(controllerNameParts, isAdmin, { forBaseController: true });
+            if (baseAncestorName === undefined)
+                throw new UnexpectedUndefined();
+            if (baseAncestorImportStatement === undefined)
+                throw new UnexpectedUndefined();
             const baseControllerName = [...controllerNameParts, 'BaseController'].join('/');
             const { absDirPath, absFilePath } = psychicFileAndDirPaths(psychicPath('controllers'), baseControllerName + `.ts`);
             await fs.mkdir(absDirPath, { recursive: true });
@@ -32,12 +37,18 @@ export default async function generateController({ fullyQualifiedControllerName,
                 }));
             }
         }
-        controllerNameParts.push(allControllerNameParts[index]);
+        const namedPart = allControllerNameParts[index];
+        if (namedPart)
+            controllerNameParts.push(namedPart);
     }
     // Write the controller
     const [ancestorName, ancestorImportStatement] = baseAncestorNameAndImport(controllerNameParts, isAdmin, {
         forBaseController: false,
     });
+    if (ancestorName === undefined)
+        throw new UnexpectedUndefined();
+    if (ancestorImportStatement === undefined)
+        throw new UnexpectedUndefined();
     const { relFilePath, absDirPath, absFilePath } = psychicFileAndDirPaths(psychicPath('controllers'), fullyQualifiedControllerName + `.ts`);
     await fs.mkdir(absDirPath, { recursive: true });
     try {

package/dist/esm/src/generate/helpers/addResourceToRoutes.js

@@ -1,5 +1,6 @@
 import * as fs from 'fs/promises';
 import * as path from 'path';
+import UnexpectedUndefined from '../../error/UnexpectedUndefined.js';
 import psychicPath from '../../helpers/path/psychicPath.js';
 import PsychicApplication from '../../psychic-application/index.js';
 export default async function addResourceToRoutes(route) {
@@ -9,6 +10,8 @@ export default async function addResourceToRoutes(route) {
     const matchesAndReplacements = addResourceToRoutes_routeToRegexAndReplacements(route);
     for (let index = 0; index < matchesAndReplacements.length; index++) {
         const matchAndReplacement = matchesAndReplacements[index];
+        if (matchAndReplacement === undefined)
+            throw new UnexpectedUndefined();
         if (matchAndReplacement.regex.test(routes)) {
             routes = routes.replace(matchAndReplacement.regex, matchAndReplacement.replacement +
                 closeBrackets(index, indent(matchesAndReplacements.length - index - 1)) +

package/dist/esm/src/helpers/openapiJsonPath.js

@@ -1,6 +1,10 @@
 import * as path from 'path';
+import UnexpectedUndefined from '../error/UnexpectedUndefined.js';
 import PsychicApplication from '../psychic-application/index.js';
 export default function openapiJsonPath(openapiName = 'default') {
     const psychicApp = PsychicApplication.getOrFail();
-    return path.join(psychicApp.apiRoot, psychicApp.openapi[openapiName].outputFilename);
+    const namedOpenapi = psychicApp.openapi[openapiName];
+    if (namedOpenapi === undefined)
+        throw new UnexpectedUndefined();
+    return path.join(psychicApp.apiRoot, namedOpenapi.outputFilename);
 }

package/dist/esm/src/i18n/provider.js

@@ -46,7 +46,10 @@ function applyInterpolations(i18nPathString, str, interpolations) {
     return str;
 }
 function _i18n(i18nHash, i18nPath) {
-    const translation = i18nHash[i18nPath[0]];
+    const index = i18nPath[0];
+    if (index === undefined)
+        throw new TranslationMissing();
+    const translation = i18nHash[index];
     if (translation === undefined)
         throw new TranslationMissing();
     if (typeof translation === 'string')

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

@@ -1,5 +1,7 @@
+import { compact } from '@rvoh/dream';
 import * as fs from 'fs/promises';
 import { groupBy } from 'lodash-es';
+import UnexpectedUndefined from '../error/UnexpectedUndefined.js';
 import EnvInternal from '../helpers/EnvInternal.js';
 import openapiJsonPath from '../helpers/openapiJsonPath.js';
 import PsychicApplication from '../psychic-application/index.js';
@@ -87,22 +89,30 @@ export default class OpenapiAppRenderer {
                 if (EnvInternal.isDebug)
                     console.log(`Processing OpenAPI key ${key} for controller ${controllerName}`);
                 const renderer = controller.openapi[key];
+                if (renderer === undefined)
+                    throw new UnexpectedUndefined();
                 finalOutput.components.schemas = {
                     ...finalOutput.components.schemas,
                     ...renderer.toSchemaObject(openapiName, processedSchemas),
                 };
                 const endpointPayload = renderer.toPathObject(openapiName, processedSchemas, routes);
+                if (endpointPayload === undefined)
+                    throw new UnexpectedUndefined();
                 const path = Object.keys(endpointPayload)[0];
-                const method = Object.keys(endpointPayload[path]).find(key => HttpMethods.includes(key));
+                if (path === undefined)
+                    throw new UnexpectedUndefined();
+                const endpointPayloadPath = endpointPayload[path];
+                if (endpointPayloadPath === undefined)
+                    throw new UnexpectedUndefined();
+                const method = Object.keys(endpointPayloadPath).find(key => HttpMethods.includes(key));
                 if (!finalOutput.paths[path]) {
                     finalOutput.paths[path] = { parameters: [] };
                 }
-                const pathObj = finalOutput.paths[path];
-                const otherPathObj = endpointPayload[path];
-                pathObj[method] = otherPathObj[method];
-                pathObj.parameters = this.combineParameters([
-                    ...pathObj.parameters,
-                    ...endpointPayload[path].parameters,
+                const finalPathObject = finalOutput.paths[path];
+                finalPathObject[method] = endpointPayloadPath[method];
+                finalPathObject.parameters = this.combineParameters([
+                    ...finalPathObject.parameters,
+                    ...endpointPayloadPath.parameters,
                 ]);
             }
         }
@@ -110,24 +120,26 @@ export default class OpenapiAppRenderer {
     }
     static combineParameters(parameters) {
         const groupedParams = groupBy(parameters, 'name');
-        const result = Object.keys(groupedParams).map(paramName => {
-            const identicalParams = groupedParams[paramName];
+        return compact(Object.keys(groupedParams).map(paramName => {
+            const identicalParams = groupedParams[paramName] || [];
             return identicalParams.reduce((compositeParam, param) => {
+                if (compositeParam === undefined)
+                    throw new UnexpectedUndefined();
                 compositeParam.description ||= param.description;
-                if (compositeParam.allowEmptyValue !== undefined)
+                if (param.allowEmptyValue !== undefined)
                     compositeParam.allowEmptyValue = param.allowEmptyValue;
-                if (compositeParam.allowReserved !== undefined)
+                if (param.allowReserved !== undefined)
                     compositeParam.allowReserved = param.allowReserved;
-                if (compositeParam.required !== undefined)
+                if (param.required !== undefined)
                     compositeParam.required = param.required;
                 return compositeParam;
             }, identicalParams[0]);
-        });
-        return result;
+        }));
     }
     static sortedSchemaPayload(schema) {
         const sortedPaths = Object.keys(schema.paths).sort();
-        const sortedSchemas = Object.keys(schema.components.schemas).sort();
+        const schemas = schema.components.schemas || {};
+        const sortedSchemaNames = Object.keys(schemas).sort();
         const sortedSchema = { ...schema };
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         sortedSchema.paths = sortedPaths.reduce((agg, path) => {
@@ -138,9 +150,9 @@ export default class OpenapiAppRenderer {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
         }, {});
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        sortedSchema.components.schemas = sortedSchemas.reduce((agg, key) => {
+        sortedSchema.components.schemas = sortedSchemaNames.reduce((agg, key) => {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-            agg[key] = schema.components.schemas[key];
+            agg[key] = schemas[key];
             // eslint-disable-next-line @typescript-eslint/no-unsafe-return
             return agg;
             // eslint-disable-next-line @typescript-eslint/no-explicit-any

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

@@ -172,8 +172,9 @@ export default class OpenapiBodySegmentRenderer {
         if (bodySegment.nullable) {
             data.nullable = true;
         }
-        if (bodySegment.description) {
-            data.description = bodySegment.description;
+        const description = bodySegment.description;
+        if (description) {
+            data.description = description;
         }
         return data;
     }

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

@@ -100,19 +100,22 @@ export default class OpenapiEndpointRenderer {
                 },
             },
         };
+        const outputPath = output[path];
+        if (outputPath === undefined)
+            throw new Error(`no output for path ${path}`);
         if (this.summary) {
-            output[path][method].summary = this.summary;
+            outputPath[method].summary = this.summary;
         }
         if (this.description) {
-            output[path][method].description = this.description;
+            outputPath[method].description = this.description;
         }
         if (this.security) {
-            output[path][method].security = this.security;
+            outputPath[method].security = this.security;
         }
         if (requestBody) {
-            output[path][method]['requestBody'] = requestBody;
+            outputPath[method]['requestBody'] = requestBody;
         }
-        output[path][method].responses = responses;
+        outputPath[method].responses = responses;
         return output;
     }
     /**
@@ -260,8 +263,10 @@ export default class OpenapiEndpointRenderer {
             ? {}
             : this.openapiOpts(openapiName)?.defaults?.headers || {};
         const headers = { ...defaultHeaders, ...(this.headers || []) };
-        return (Object.keys(headers).map((headerName) => {
+        return (compact(Object.keys(headers).map((headerName) => {
             const header = headers[headerName];
+            if (header === undefined)
+                return null;
             const data = {
                 in: 'header',
                 name: headerName,
@@ -275,7 +280,7 @@ export default class OpenapiEndpointRenderer {
                 data.schema.format = header.format;
             }
             return data;
-        }) || []);
+        })) || []);
     }
     /**
      * @internal
@@ -289,20 +294,20 @@ export default class OpenapiEndpointRenderer {
             let output = {
                 in: 'query',
                 name: queryName,
-                description: queryParam.description || queryName,
+                description: queryParam?.description || queryName,
                 allowReserved: true,
                 ...queryParam,
                 schema: {
                     type: 'string',
                 },
             };
-            if (typeof queryParam.allowEmptyValue === 'boolean') {
+            if (typeof queryParam?.allowEmptyValue === 'boolean') {
                 output.allowEmptyValue = queryParam.allowEmptyValue;
             }
-            if (typeof queryParam.allowReserved === 'boolean') {
+            if (typeof queryParam?.allowReserved === 'boolean') {
                 output.allowReserved = queryParam.allowReserved;
             }
-            if (queryParam.schema) {
+            if (queryParam?.schema) {
                 output = {
                     ...output,
                     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
@@ -614,10 +619,16 @@ export default class OpenapiEndpointRenderer {
                 ...defaultResponses,
             });
         Object.keys(psychicAndConfigLevelDefaults).forEach(key => {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
             if (!responseData[key]) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
-                responseData[key] = psychicAndConfigLevelDefaults[key];
+                const data = psychicAndConfigLevelDefaults[key];
+                switch (key) {
+                    case 'summary':
+                    case 'description':
+                        responseData[key] = data;
+                        break;
+                    default:
+                        responseData[key] = data;
+                }
             }
         });
         return responseData;
@@ -674,6 +685,8 @@ export default class OpenapiEndpointRenderer {
      */
     parseSingleEntitySerializerResponseShape() {
         const serializerClass = this.getSerializerClasses()[0];
+        if (serializerClass === undefined)
+            throw new Error('getSerializerClasses returned no serializer classes');
         const serializerKey = serializerClass.openapiName;
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const serializerObject = this.accountForNullableOption({
@@ -815,7 +828,9 @@ export default class OpenapiEndpointRenderer {
             const modelClass = dreamOrSerializerOrViewModel;
             const modelPrototype = modelClass.prototype;
             const serializerKey = modelPrototype.serializers[this.serializerKey || 'default'];
-            return dreamApp.serializers[serializerKey] || null;
+            if (serializerKey === undefined)
+                throw new Error(`no serializerKey for ${this.serializerKey || 'default'}`);
+            return dreamApp.serializers[serializerKey] ?? null;
         }
     }
 }

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

@@ -1,5 +1,6 @@
 import { DreamSerializer, uniq, } from '@rvoh/dream';
 import CannotFlattenMultiplePolymorphicRendersOneAssociations from '../error/openapi/CannotFlattenMultiplePolymorphicRendersOneAssociations.js';
+import UnexpectedUndefined from '../error/UnexpectedUndefined.js';
 import EnvInternal from '../helpers/EnvInternal.js';
 import PsychicApplication from '../psychic-application/index.js';
 import OpenapiBodySegmentRenderer from './body-segment.js';
@@ -78,6 +79,9 @@ export default class OpenapiSerializerRenderer {
         let finalOutput = { ...serializerPayload };
         let flattenedPolymorphicSchemas = [];
         let flattenedPolymorphicAssociation;
+        const finalOutputForSerializerKey = finalOutput[serializerKey];
+        if (finalOutputForSerializerKey === undefined)
+            throw new UnexpectedUndefined();
         associations.forEach(association => {
             const associatedSerializers = DreamSerializer.getAssociatedSerializersForOpenapi(association);
             if (!associatedSerializers)
@@ -116,10 +120,10 @@ Error: ${this.serializerClass.name} missing explicit serializer definition for $
                     ...finalOutput,
                     [serializerKey]: {
                         anyOf: [
-                            { ...finalOutput[serializerKey] },
+                            { ...finalOutputForSerializerKey },
                             {
                                 allOf: [
-                                    { ...finalOutput[serializerKey] },
+                                    { ...finalOutputForSerializerKey },
                                     { anyOf: flattenedPolymorphicSchemas.map(schema => ({ $schema: schema })) },
                                 ],
                             },
@@ -132,7 +136,7 @@ Error: ${this.serializerClass.name} missing explicit serializer definition for $
                     ...finalOutput,
                     [serializerKey]: {
                         allOf: [
-                            { ...finalOutput[serializerKey] },
+                            { ...finalOutputForSerializerKey },
                             { anyOf: flattenedPolymorphicSchemas.map(schema => ({ $schema: schema })) },
                         ],
                     },
@@ -152,22 +156,27 @@ Error: ${this.serializerClass.name} missing explicit serializer definition for $
      */
     addSingleSerializerAssociationToOutput({ associatedSerializers, finalOutput, serializerKey, association, }) {
         const associatedSerializer = associatedSerializers[0];
+        if (associatedSerializer === undefined)
+            throw new UnexpectedUndefined();
         const associatedSerializerKey = associatedSerializer.openapiName;
         if (EnvInternal.isDebug)
             PsychicApplication.log(`Processing serializer ${associatedSerializerKey}`);
         let flattenedData;
+        const finalOutputForSerializerKey = finalOutput[serializerKey];
+        if (finalOutputForSerializerKey === undefined)
+            throw new UnexpectedUndefined();
         switch (association.type) {
             case 'RendersMany':
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
                 ;
-                finalOutput[serializerKey].properties[association.field] = {
+                finalOutputForSerializerKey.properties[association.field] = {
                     type: 'array',
                     items: {
                         $ref: `#/components/schemas/${associatedSerializerKey}`,
                     },
                 };
-                finalOutput[serializerKey].required = uniq([
-                    ...(finalOutput[serializerKey].required || []),
+                finalOutputForSerializerKey.required = uniq([
+                    ...(finalOutputForSerializerKey.required || []),
                     association.field,
                 ]);
                 break;
@@ -179,8 +188,8 @@ Error: ${this.serializerClass.name} missing explicit serializer definition for $
                     });
                     finalOutput[serializerKey].properties = flattenedData;
                     if (!association.optional) {
-                        finalOutput[serializerKey].required = uniq([
-                            ...(finalOutput[serializerKey].required || []),
+                        finalOutputForSerializerKey.required = uniq([
+                            ...(finalOutputForSerializerKey.required || []),
                             ...Object.keys(flattenedData),
                         ]);
                     }
@@ -191,8 +200,8 @@ Error: ${this.serializerClass.name} missing explicit serializer definition for $
                     finalOutput[serializerKey].properties[association.field] = this.accountForNullableOption({
                         $ref: `#/components/schemas/${associatedSerializerKey}`,
                     }, association.optional);
-                    finalOutput[serializerKey].required = uniq([
-                        ...(finalOutput[serializerKey].required || []),
+                    finalOutputForSerializerKey.required = uniq([
+                        ...(finalOutputForSerializerKey.required || []),
                         association.field,
                     ]);
                 }
@@ -242,6 +251,9 @@ Error: ${this.serializerClass.name} missing explicit serializer definition for $
      * each pointing to its respective target serializer.
      */
     addMultiSerializerAssociationToOutput({ associatedSerializers, finalOutput, serializerKey, association, flattenedPolymorphicSchemas, flattenedPolymorphicAssociation, }) {
+        const finalOutputForSerializerKey = finalOutput[serializerKey];
+        if (finalOutputForSerializerKey === undefined)
+            throw new UnexpectedUndefined();
         if (association.flatten) {
             if (flattenedPolymorphicSchemas.length)
                 throw new CannotFlattenMultiplePolymorphicRendersOneAssociations(this.serializerClass, association.field);
@@ -269,8 +281,8 @@ Error: ${this.serializerClass.name} missing explicit serializer definition for $
                 const associatedSerializerKey = associatedSerializer.openapiName;
                 if (EnvInternal.isDebug)
                     PsychicApplication.log(`Processing serializer ${associatedSerializerKey}`);
-                finalOutput[serializerKey].required = uniq([
-                    ...(finalOutput[serializerKey].required || []),
+                finalOutputForSerializerKey.required = uniq([
+                    ...(finalOutputForSerializerKey.required || []),
                     association.field,
                 ]);
                 switch (association.type) {