@rvoh/psychic 0.24.1

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

@@ -0,0 +1,89 @@
+const SUPPORTED_LOCALES = ['en-US'];
+export function supportedLocales() {
+    return SUPPORTED_LOCALES;
+}
+class TranslationMissing extends Error {
+}
+export default class I18nProvider {
+    /**
+     * Leverages the arguments provided to return to you an
+     * i18n function, which will provide type completion based
+     * on the locales set up in your application.
+     *
+     * @param allLocales - the list of all locales in your app. something like `{ en: { ... }, ['en-UK']: { ... }, es: { ... }, ... }`
+     * @param singleLocaleKey - the key from the allLocales object that you want to use as your type base. i.e. 'en'
+     * */
+    static provide(allLocales, singleLocaleKey) {
+        return function i18n(locale, i18nPathString, interpolations) {
+            const language = locale?.split('-')?.[0];
+            const i18nPath = i18nPathString.split('.');
+            const localeI18nObject = (allLocales[language] ||
+                allLocales['en']);
+            try {
+                return applyInterpolations(i18nPathString, _i18n(localeI18nObject, i18nPath), interpolations);
+            }
+            catch (err) {
+                const error = err;
+                if (error.constructor === TranslationMissing)
+                    return i18nPathString;
+                throw error;
+            }
+        };
+    }
+}
+function applyInterpolations(i18nPathString, str, interpolations) {
+    if (!interpolations)
+        return str;
+    Object.keys(interpolations).forEach(key => {
+        const interpolationValue = interpolations[key];
+        if (interpolationValue === undefined)
+            throw new I18nInterpolationReceivedUndefined(i18nPathString, key);
+        if (interpolationValue === null)
+            throw new I18nInterpolationReceivedNull(i18nPathString, key);
+        const replacement = interpolationValue.toString();
+        str = str.replace(`%{${key}}`, replacement);
+    });
+    return str;
+}
+function _i18n(i18nHash, i18nPath) {
+    const translation = i18nHash[i18nPath[0]];
+    if (translation === undefined)
+        throw new TranslationMissing();
+    if (typeof translation === 'string')
+        return translation;
+    return _i18n(translation, i18nPath.slice(1));
+}
+export class I18nInterpolationReceivedUndefined extends Error {
+    i18nPathString;
+    interpolationKey;
+    constructor(i18nPathString, interpolationKey) {
+        super();
+        Object.setPrototypeOf(this, I18nInterpolationReceivedUndefined.prototype);
+        this.i18nPathString = i18nPathString;
+        this.interpolationKey = interpolationKey;
+    }
+    get message() {
+        return `
+undefined interpolation value received:
+i18n path string: ${this.i18nPathString}
+interpolationKey: ${this.interpolationKey}
+    `;
+    }
+}
+export class I18nInterpolationReceivedNull extends Error {
+    i18nPathString;
+    interpolationKey;
+    constructor(i18nPathString, interpolationKey) {
+        super();
+        Object.setPrototypeOf(this, I18nInterpolationReceivedNull.prototype);
+        this.i18nPathString = i18nPathString;
+        this.interpolationKey = interpolationKey;
+    }
+    get message() {
+        return `
+null interpolation value received:
+i18n path string: ${this.i18nPathString}
+interpolationKey: ${this.interpolationKey}
+    `;
+    }
+}

package/dist/esm/src/index.js

@@ -0,0 +1,50 @@
+import _pluralize from 'pluralize-esm';
+export const pluralize = _pluralize;
+export { default as PsychicBin } from './bin/index.js';
+export { default as PsychicCLI } from './cli/index.js';
+export { default as PsychicController, } from './controller/index.js';
+export { BeforeAction, OpenAPI } from './controller/decorators.js';
+export { default as envLoader } from './env/Loader.js';
+export { default as I18nProvider } from './i18n/provider.js';
+export { default as HttpStatusBadGateway } from './error/http/BadGateway.js';
+export { default as HttpStatusBadRequest } from './error/http/BadRequest.js';
+export { default as HttpStatusConflict } from './error/http/Conflict.js';
+export { default as HttpStatusContentTooLarge } from './error/http/ContentTooLarge.js';
+export { default as HttpStatusExpectationFailed } from './error/http/ExpectationFailed.js';
+export { default as HttpStatusFailedDependency } from './error/http/FailedDependency.js';
+export { default as HttpStatusForbidden } from './error/http/Forbidden.js';
+export { default as HttpStatusGatewayTimeout } from './error/http/GatewayTimeout.js';
+export { default as HttpStatusGone } from './error/http/Gone.js';
+export { default as HttpStatusImATeapot } from './error/http/ImATeapot.js';
+export { default as HttpStatusInsufficientStorage } from './error/http/InsufficientStorage.js';
+export { default as HttpStatusInternalServerError } from './error/http/InternalServerError.js';
+export { default as HttpStatusLocked } from './error/http/Locked.js';
+export { default as HttpStatusMethodNotAllowed } from './error/http/MethodNotAllowed.js';
+export { default as HttpStatusMisdirectedRequest } from './error/http/MisdirectedRequest.js';
+export { default as HttpStatusNotAcceptable } from './error/http/NotAcceptable.js';
+export { default as HttpStatusNotExtended } from './error/http/NotExtended.js';
+export { default as HttpStatusNotFound } from './error/http/NotFound.js';
+export { default as HttpStatusNotImplemented } from './error/http/NotImplemented.js';
+export { default as HttpStatusPaymentRequired } from './error/http/PaymentRequired.js';
+export { default as HttpStatusPreconditionFailed } from './error/http/PreconditionFailed.js';
+export { default as HttpStatusPreconditionRequired } from './error/http/PreconditionRequired.js';
+export { default as HttpStatusProxyAuthenticationRequired } from './error/http/ProxyAuthenticationRequired.js';
+export { default as HttpStatusRequestHeaderFieldsTooLarge } from './error/http/RequestHeaderFieldsTooLarge.js';
+export { default as HttpStatusServiceUnavailable } from './error/http/ServiceUnavailable.js';
+export { default as HttpStatusTooManyRequests } from './error/http/TooManyRequests.js';
+export { default as HttpStatusUnauthorized } from './error/http/Unauthorized.js';
+export { default as HttpStatusUnavailableForLegalReasons } from './error/http/UnavailableForLegalReasons.js';
+export { default as HttpStatusUnprocessableContent } from './error/http/UnprocessableContent.js';
+export { default as HttpStatusUnsupportedMediaType } from './error/http/UnsupportedMediaType.js';
+export { default as generateController } from './generate/controller.js';
+export { default as generateResource } from './generate/resource.js';
+export { default as cookieMaxAgeFromCookieOpts } from './helpers/cookieMaxAgeFromCookieOpts.js';
+export { default as pathifyNestedObject } from './helpers/pathifyNestedObject.js';
+export { MissingControllerActionPairingInRoutes, } from './openapi-renderer/endpoint.js';
+export { default as PsychicApplication, } from './psychic-application/index.js';
+export { default as PsychicImporter } from './psychic-application/helpers/PsychicImporter.js';
+export { default as PsychicRouter } from './router/index.js';
+export { default as PsychicServer } from './server/index.js';
+export { createPsychicHttpInstance as getPsychicHttpInstance } from './server/helpers/startPsychicServer.js';
+export { default as Params, ParamValidationError } from './server/params.js';
+export { default as PsychicSession } from './session/index.js';

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

@@ -0,0 +1,150 @@
+import * as fs from 'fs/promises';
+import { groupBy } from 'lodash-es';
+import EnvInternal from '../helpers/EnvInternal.js';
+import openapiJsonPath from '../helpers/openapiJsonPath.js';
+import PsychicApplication from '../psychic-application/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';
+export default class OpenapiAppRenderer {
+    /**
+     * @internal
+     *
+     * reads the lates openapi builds using buildOpenapiObject, and syncs
+     * the contents to the openapi.json file at the project root.
+     */
+    static async sync() {
+        const openapiContents = await OpenapiAppRenderer.toObject();
+        const psychicApp = PsychicApplication.getOrFail();
+        const asyncWriteOpenapiFile = async (key) => {
+            const jsonPath = openapiJsonPath(key);
+            await fs.writeFile(jsonPath, JSON.stringify(openapiContents[key], null, 2), {
+                flag: 'w+',
+            });
+        };
+        await Promise.all(Object.keys(psychicApp.openapi).map(key => asyncWriteOpenapiFile(key)));
+    }
+    /**
+     * @internal
+     *
+     * builds a new typescript object which contains the combined
+     * payloads of all `@Openapi` decorator calls used throughout
+     * the controller layer.
+     */
+    static async toObject() {
+        const psychicApp = PsychicApplication.getOrFail();
+        const convertToObjectAndStoreInOutput = async (output, key) => {
+            output[key] = await this._toObject(key);
+        };
+        const output = {};
+        await Promise.all(Object.keys(psychicApp.openapi).map(key => convertToObjectAndStoreInOutput(output, key)));
+        return output;
+    }
+    static async _toObject(openapiName) {
+        const processedSchemas = {};
+        const psychicApp = PsychicApplication.getOrFail();
+        const controllers = psychicApp.controllers;
+        const server = new PsychicServer();
+        await server.boot();
+        const routes = await server.routes();
+        const openapiConfig = psychicApp.openapi?.[openapiName];
+        const finalOutput = {
+            openapi: '3.1.0',
+            info: {
+                version: openapiConfig?.info?.version || 'unknown version',
+                title: openapiConfig?.info?.title || 'unknown title',
+                description: openapiConfig?.info?.description || 'The autogenerated openapi spec for your app',
+            },
+            paths: {},
+            components: {
+                ...(psychicApp.openapi?.[openapiName]?.defaults?.components || {}),
+                schemas: {
+                    ...DEFAULT_OPENAPI_COMPONENT_SCHEMAS,
+                    ...(psychicApp.openapi?.[openapiName]?.defaults?.components?.schemas ||
+                        {}),
+                },
+                responses: {
+                    ...DEFAULT_OPENAPI_COMPONENT_RESPONSES,
+                    ...(psychicApp.openapi?.[openapiName]?.defaults?.components?.responses || {}),
+                },
+            },
+        };
+        if (psychicApp.openapi?.[openapiName]?.servers) {
+            finalOutput.servers = psychicApp.openapi?.[openapiName]?.servers;
+        }
+        if (psychicApp.openapi?.[openapiName]?.defaults?.securitySchemes) {
+            finalOutput.components = {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
+                securitySchemes: psychicApp.openapi?.[openapiName].defaults.securitySchemes,
+                ...finalOutput.components,
+            };
+        }
+        if (psychicApp.openapi?.[openapiName]?.defaults?.security) {
+            finalOutput.security = psychicApp.openapi?.[openapiName].defaults.security;
+        }
+        for (const [controllerName, controller] of Object.entries(controllers).filter(([, controller]) => controller.openapiNames.includes(openapiName))) {
+            for (const key of Object.keys(controller.openapi || {})) {
+                if (EnvInternal.isDebug)
+                    console.log(`Processing OpenAPI key ${key} for controller ${controllerName}`);
+                const renderer = controller.openapi[key];
+                finalOutput.components.schemas = {
+                    ...finalOutput.components.schemas,
+                    ...renderer.toSchemaObject(openapiName, processedSchemas),
+                };
+                const endpointPayload = renderer.toPathObject(openapiName, processedSchemas, routes);
+                const path = Object.keys(endpointPayload)[0];
+                const method = Object.keys(endpointPayload[path]).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,
+                ]);
+            }
+        }
+        return this.sortedSchemaPayload(finalOutput);
+    }
+    static combineParameters(parameters) {
+        const groupedParams = groupBy(parameters, 'name');
+        const result = Object.keys(groupedParams).map(paramName => {
+            const identicalParams = groupedParams[paramName];
+            return identicalParams.reduce((compositeParam, param) => {
+                compositeParam.description ||= param.description;
+                if (compositeParam.allowEmptyValue !== undefined)
+                    compositeParam.allowEmptyValue = param.allowEmptyValue;
+                if (compositeParam.allowReserved !== undefined)
+                    compositeParam.allowReserved = param.allowReserved;
+                if (compositeParam.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 sortedSchema = { ...schema };
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        sortedSchema.paths = sortedPaths.reduce((agg, path) => {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            agg[path] = schema.paths[path];
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return agg;
+            // 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) => {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            agg[key] = schema.components.schemas[key];
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return agg;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }, {});
+        return sortedSchema;
+    }
+}