@rvoh/psychic 0.24.1

package/dist/cjs/src/openapi-renderer/helpers/isBlankDescription.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = isBlankDescription;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isBlankDescription(obj) {
+    if (typeof obj !== 'object')
+        return false;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    if (Object.keys(obj).length > 1)
+        return false;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    return Object.keys(obj)[0] === 'description';
+}

package/dist/cjs/src/openapi-renderer/helpers/openapiRoute.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = openapiRoute;
+function openapiRoute(route) {
+    const sanitizedRoute = route.replace(/^\//, '').replace(/:([^/]*)(\/|$)/g, '{$1}$2');
+    return `/${sanitizedRoute}`;
+}

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

@@ -0,0 +1,321 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dream_1 = require("@rvoh/dream");
+const CannotFlattenMultiplePolymorphicRendersOneAssociations_js_1 = require("../error/openapi/CannotFlattenMultiplePolymorphicRendersOneAssociations.js");
+const EnvInternal_js_1 = require("../helpers/EnvInternal.js");
+const index_js_1 = require("../psychic-application/index.js");
+const body_segment_js_1 = require("./body-segment.js");
+class OpenapiSerializerRenderer {
+    openapiName;
+    controllerClass;
+    serializerClass;
+    serializers;
+    schemaDelimeter;
+    processedSchemas;
+    target;
+    /**
+     * @internal
+     *
+     * Used to recursively parse nested object structures
+     * within nested openapi objects
+     */
+    constructor({ openapiName, controllerClass, serializerClass, serializers, schemaDelimeter, processedSchemas, target, }) {
+        this.openapiName = openapiName;
+        this.controllerClass = controllerClass;
+        this.serializerClass = serializerClass;
+        this.serializers = serializers;
+        this.schemaDelimeter = schemaDelimeter;
+        this.processedSchemas = processedSchemas;
+        this.target = target;
+    }
+    /**
+     * converts the serializer to an openapi schema
+     */
+    parse() {
+        if (this.processedSchemas[this.serializerClass.globalName])
+            return {};
+        this.processedSchemas[this.serializerClass.globalName] = true;
+        const attributes = this.serializerClass['attributeStatements'];
+        const serializerKey = this.serializerClass.openapiName;
+        const serializerObject = {
+            type: 'object',
+            required: [],
+            properties: {},
+        };
+        let componentsSchema = {};
+        attributes.forEach(attr => {
+            serializerObject.required.push(attr.field);
+            const { results, extraComponents } = this.recursivelyParseBody({ openApiShape: attr.openApiShape });
+            componentsSchema = { ...componentsSchema, ...extraComponents };
+            serializerObject.properties[attr.field] = results;
+        });
+        serializerObject.required = (0, dream_1.uniq)(serializerObject.required);
+        const serializerPayload = this.attachAssociationsToSerializerPayload({
+            serializerPayload: { [serializerKey]: serializerObject, ...componentsSchema },
+            serializerKey,
+        });
+        return { ...serializerPayload, ...componentsSchema };
+    }
+    recursivelyParseBody({ openApiShape, }) {
+        return new body_segment_js_1.default({
+            openapiName: this.openapiName,
+            controllerClass: this.controllerClass,
+            bodySegment: openApiShape,
+            serializers: this.serializers,
+            schemaDelimeter: this.schemaDelimeter,
+            processedSchemas: this.processedSchemas,
+            target: this.target,
+        }).parse();
+    }
+    /**
+     * @internal
+     *
+     * for each association existing on a given serializer,
+     * attach the association's schema to the component schema
+     * output, and also generate a $ref between the base
+     * serializer and the new one.
+     */
+    attachAssociationsToSerializerPayload({ serializerPayload, serializerKey, }) {
+        const associations = this.serializerClass['associationStatements'];
+        let finalOutput = { ...serializerPayload };
+        let flattenedPolymorphicSchemas = [];
+        let flattenedPolymorphicAssociation;
+        associations.forEach(association => {
+            const associatedSerializers = dream_1.DreamSerializer.getAssociatedSerializersForOpenapi(association);
+            if (!associatedSerializers)
+                throw new Error(`
+Error: ${this.serializerClass.name} missing explicit serializer definition for ${association.type} ${association.field}, using type: 'object'
+`);
+            if (associatedSerializers.length === 1) {
+                // point the association directly to the schema
+                finalOutput = this.addSingleSerializerAssociationToOutput({
+                    association,
+                    serializerKey,
+                    finalOutput,
+                    associatedSerializers,
+                });
+            }
+            else {
+                // leverage anyOf to handle an array of serializers
+                const data = this.addMultiSerializerAssociationToOutput({
+                    association,
+                    serializerKey,
+                    finalOutput,
+                    associatedSerializers,
+                    flattenedPolymorphicSchemas,
+                    flattenedPolymorphicAssociation,
+                });
+                finalOutput = data.finalOutput;
+                flattenedPolymorphicSchemas = data.flattenedPolymorphicSchemas;
+                if (data.flattenedPolymorphicAssociation) {
+                    flattenedPolymorphicAssociation = data.flattenedPolymorphicAssociation;
+                }
+            }
+        });
+        if (flattenedPolymorphicSchemas.length && flattenedPolymorphicAssociation) {
+            if (flattenedPolymorphicAssociation.optional) {
+                return {
+                    ...finalOutput,
+                    [serializerKey]: {
+                        anyOf: [
+                            { ...finalOutput[serializerKey] },
+                            {
+                                allOf: [
+                                    { ...finalOutput[serializerKey] },
+                                    { anyOf: flattenedPolymorphicSchemas.map(schema => ({ $schema: schema })) },
+                                ],
+                            },
+                        ],
+                    },
+                };
+            }
+            else {
+                return {
+                    ...finalOutput,
+                    [serializerKey]: {
+                        allOf: [
+                            { ...finalOutput[serializerKey] },
+                            { anyOf: flattenedPolymorphicSchemas.map(schema => ({ $schema: schema })) },
+                        ],
+                    },
+                };
+            }
+        }
+        else {
+            return finalOutput;
+        }
+    }
+    /**
+     * @internal
+     *
+     * points an association directly to the $ref associated
+     * with the target serializer, and add target serializer
+     * to the schema
+     */
+    addSingleSerializerAssociationToOutput({ associatedSerializers, finalOutput, serializerKey, association, }) {
+        const associatedSerializer = associatedSerializers[0];
+        const associatedSerializerKey = associatedSerializer.openapiName;
+        if (EnvInternal_js_1.default.isDebug)
+            index_js_1.default.log(`Processing serializer ${associatedSerializerKey}`);
+        let flattenedData;
+        switch (association.type) {
+            case 'RendersMany':
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
+                ;
+                finalOutput[serializerKey].properties[association.field] = {
+                    type: 'array',
+                    items: {
+                        $ref: `#/components/schemas/${associatedSerializerKey}`,
+                    },
+                };
+                finalOutput[serializerKey].required = (0, dream_1.uniq)([
+                    ...(finalOutput[serializerKey].required || []),
+                    association.field,
+                ]);
+                break;
+            case 'RendersOne':
+                if (association.flatten) {
+                    flattenedData = this.flattenRendersOneAssociation(associatedSerializer, {
+                        finalOutput,
+                        serializerKey,
+                    });
+                    finalOutput[serializerKey].properties = flattenedData;
+                    if (!association.optional) {
+                        finalOutput[serializerKey].required = (0, dream_1.uniq)([
+                            ...(finalOutput[serializerKey].required || []),
+                            ...Object.keys(flattenedData),
+                        ]);
+                    }
+                }
+                else {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
+                    ;
+                    finalOutput[serializerKey].properties[association.field] = this.accountForNullableOption({
+                        $ref: `#/components/schemas/${associatedSerializerKey}`,
+                    }, association.optional);
+                    finalOutput[serializerKey].required = (0, dream_1.uniq)([
+                        ...(finalOutput[serializerKey].required || []),
+                        association.field,
+                    ]);
+                }
+                break;
+        }
+        const associatedSchema = new OpenapiSerializerRenderer({
+            openapiName: this.openapiName,
+            controllerClass: this.controllerClass,
+            serializerClass: associatedSerializer,
+            serializers: this.serializers,
+            schemaDelimeter: this.schemaDelimeter,
+            processedSchemas: this.processedSchemas,
+            target: this.target,
+        }).parse();
+        finalOutput = { ...finalOutput, ...associatedSchema };
+        return finalOutput;
+    }
+    /**
+     * @internal
+     *
+     * Takes an association and flattens each of it's child
+     * attributes into a new object. This is done whenever
+     * a serializer's @RendersOne options include `flatten: true`
+     */
+    flattenRendersOneAssociation(associatedSerializer, { finalOutput, serializerKey, }) {
+        const serialized = new OpenapiSerializerRenderer({
+            openapiName: this.openapiName,
+            controllerClass: this.controllerClass,
+            serializerClass: associatedSerializer,
+            serializers: this.serializers,
+            schemaDelimeter: this.schemaDelimeter,
+            processedSchemas: {},
+            target: this.target,
+        }).parse();
+        const associatedProperties = serialized[associatedSerializer.openapiName]
+            .properties;
+        return {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
+            ...finalOutput[serializerKey].properties,
+            ...associatedProperties,
+        };
+    }
+    /**
+     * @internal
+     *
+     * leverages anyOf to cast multiple possible $ref values,
+     * each pointing to its respective target serializer.
+     */
+    addMultiSerializerAssociationToOutput({ associatedSerializers, finalOutput, serializerKey, association, flattenedPolymorphicSchemas, flattenedPolymorphicAssociation, }) {
+        if (association.flatten) {
+            if (flattenedPolymorphicSchemas.length)
+                throw new CannotFlattenMultiplePolymorphicRendersOneAssociations_js_1.default(this.serializerClass, association.field);
+            associatedSerializers.forEach(associatedSerializer => {
+                const associatedSchema = new OpenapiSerializerRenderer({
+                    openapiName: this.openapiName,
+                    controllerClass: this.controllerClass,
+                    serializerClass: associatedSerializer,
+                    serializers: this.serializers,
+                    schemaDelimeter: this.schemaDelimeter,
+                    processedSchemas: this.processedSchemas,
+                    target: this.target,
+                }).parse();
+                finalOutput = { ...finalOutput, ...associatedSchema };
+            });
+            return {
+                finalOutput,
+                flattenedPolymorphicSchemas: associatedSerializers.map(ser => ser.openapiName),
+                flattenedPolymorphicAssociation: association,
+            };
+        }
+        else {
+            const anyOf = [];
+            associatedSerializers.forEach(associatedSerializer => {
+                const associatedSerializerKey = associatedSerializer.openapiName;
+                if (EnvInternal_js_1.default.isDebug)
+                    index_js_1.default.log(`Processing serializer ${associatedSerializerKey}`);
+                finalOutput[serializerKey].required = (0, dream_1.uniq)([
+                    ...(finalOutput[serializerKey].required || []),
+                    association.field,
+                ]);
+                switch (association.type) {
+                    case 'RendersMany':
+                        anyOf.push({
+                            type: 'array',
+                            items: {
+                                $ref: `#/components/schemas/${associatedSerializerKey}`,
+                            },
+                        });
+                        break;
+                    case 'RendersOne':
+                        anyOf.push({
+                            $ref: `#/components/schemas/${associatedSerializerKey}`,
+                        });
+                        break;
+                }
+                const associatedSchema = new OpenapiSerializerRenderer({
+                    openapiName: this.openapiName,
+                    controllerClass: this.controllerClass,
+                    serializerClass: associatedSerializer,
+                    serializers: this.serializers,
+                    schemaDelimeter: this.schemaDelimeter,
+                    processedSchemas: this.processedSchemas,
+                    target: this.target,
+                }).parse();
+                finalOutput = { ...finalOutput, ...associatedSchema };
+            });
+            finalOutput[serializerKey].properties[association.field] = {
+                anyOf,
+            };
+        }
+        return { finalOutput, flattenedPolymorphicSchemas, flattenedPolymorphicAssociation };
+    }
+    accountForNullableOption(bodySegment, nullable) {
+        if (nullable) {
+            return {
+                anyOf: [bodySegment, { type: 'null' }],
+            };
+        }
+        else {
+            return bodySegment;
+        }
+    }
+}
+exports.default = OpenapiSerializerRenderer;

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cachePsychicApplication = cachePsychicApplication;
+exports.getCachedPsychicApplication = getCachedPsychicApplication;
+exports.getCachedPsychicApplicationOrFail = getCachedPsychicApplicationOrFail;
+let _psychicApp = undefined;
+function cachePsychicApplication(psychicApp) {
+    _psychicApp = psychicApp;
+}
+function getCachedPsychicApplication() {
+    return _psychicApp;
+}
+function getCachedPsychicApplicationOrFail() {
+    if (!_psychicApp)
+        throw new Error('must call `cachePsychicApplication` before loading cached psychic app');
+    return _psychicApp;
+}

package/dist/cjs/src/psychic-application/helpers/PsychicImporter.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dream_1 = require("@rvoh/dream");
+class PsychicImporter {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static async importControllers(controllersPath, importCb) {
+        const controllerPaths = await dream_1.DreamImporter.ls(controllersPath);
+        const controllerClasses = [];
+        for (const controllerPath of controllerPaths) {
+            controllerClasses.push([controllerPath, (await importCb(controllerPath))]);
+        }
+        return controllerClasses;
+    }
+}
+exports.default = PsychicImporter;

package/dist/cjs/src/psychic-application/helpers/globalControllerKeyFromPath.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+function default_1(filepath, dirPath) {
+    const prefixPath = dirPath;
+    return ('controllers/' +
+        filepath
+            .replace(prefixPath, '')
+            .replace(/\.[jt]s$/, '')
+            .replace(/^\//, ''));
+}

package/dist/cjs/src/psychic-application/helpers/import/importControllers.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = importControllers;
+exports.getControllersOrFail = getControllersOrFail;
+exports.getControllersOrBlank = getControllersOrBlank;
+const index_js_1 = require("../../../controller/index.js");
+const globalControllerKeyFromPath_js_1 = require("../globalControllerKeyFromPath.js");
+const PsychicImporter_js_1 = require("../PsychicImporter.js");
+let _controllers;
+async function importControllers(psychicApp, controllersPath, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+importCb) {
+    if (_controllers)
+        return _controllers;
+    /**
+     * Certain features (e.g. passing a Dream instance to `create` so that it automatically destructures polymorphic type and primary key)
+     * need static access to things set up by decorators (e.g. associations). Stage 3 Decorators change the context that is available
+     * at decoration time such that the class of a property being decorated is only avilable during instance instantiation. In order
+     * to only apply static values once, on boot, `globallyInitializingDecorators` is set to true on Dream, and all Dream models are instantiated.
+     */
+    index_js_1.default['globallyInitializingDecorators'] = true;
+    _controllers = {};
+    const controllerClasses = await PsychicImporter_js_1.default.importControllers(controllersPath, importCb);
+    for (const [controllerPath, potentialControllerClass] of controllerClasses) {
+        if (potentialControllerClass?.isPsychicController) {
+            const controllerClass = potentialControllerClass;
+            const controllerKey = (0, globalControllerKeyFromPath_js_1.default)(controllerPath, controllersPath);
+            controllerClass['setGlobalName'](controllerKey);
+            _controllers[controllerKey] = controllerClass;
+        }
+    }
+    for (const [, controllerClass] of controllerClasses) {
+        if (controllerClass?.isPsychicController) {
+            /**
+             * Certain features (e.g. passing a Dream instance to `create` so that it automatically destructures polymorphic type and primary key)
+             * need static access to things set up by decorators (e.g. associations). Stage 3 Decorators change the context that is available
+             * at decoration time such that the class of a property being decorated is only avilable during instance instantiation. In order
+             * to only apply static values once, on boot, `globallyInitializingDecorators` is set to true on Dream, and all Dream models are instantiated.
+             */
+            new controllerClass({}, {}, {
+                action: 'a',
+                config: psychicApp,
+            });
+        }
+    }
+    index_js_1.default['globallyInitializingDecorators'] = false;
+    return _controllers;
+}
+function getControllersOrFail() {
+    if (!_controllers)
+        throw new Error('Must call loadModels before calling getModelsOrFail');
+    return _controllers;
+}
+function getControllersOrBlank() {
+    return _controllers || {};
+}

package/dist/cjs/src/psychic-application/helpers/loadAppEnv.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dotenv = require("dotenv");
+const EnvInternal_js_1 = require("../../helpers/EnvInternal.js");
+dotenv.config({ path: EnvInternal_js_1.default.isTest ? '../../.env.test' : '../../.env' });

package/dist/cjs/src/psychic-application/helpers/lookupClassByGlobalName.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = lookupClassByGlobalName;
+const dream_1 = require("@rvoh/dream");
+const importControllers_js_1 = require("./import/importControllers.js");
+function lookupClassByGlobalName(name) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const lookup = (0, dream_1.lookupClassByGlobalName)(name);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    if (lookup)
+        return lookup;
+    const combinedObj = {
+        ...(0, importControllers_js_1.getControllersOrFail)(),
+    };
+    return combinedObj[name] || null;
+}