@rvoh/psychic 0.24.1

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

@@ -0,0 +1,346 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+const init_missing_routes_callback_js_1 = require("../error/psychic-application/init-missing-routes-callback.js");
+const cookieMaxAgeFromCookieOpts_js_1 = require("../helpers/cookieMaxAgeFromCookieOpts.js");
+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");
+class PsychicApplication {
+    static async init(cb, dreamCb, opts = {}) {
+        let psychicApp;
+        await dream_1.DreamApplication.init(dreamCb, { bypassModelIntegrityCheck: opts.bypassModelIntegrityCheck }, async (dreamApp) => {
+            psychicApp = new PsychicApplication();
+            await cb(psychicApp);
+            if (!psychicApp.loadedControllers)
+                throw new init_missing_call_to_load_controllers_js_1.default();
+            if (!psychicApp.apiRoot)
+                throw new init_missing_api_root_js_1.default();
+            if (!psychicApp.routesCb)
+                throw new init_missing_routes_callback_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);
+            (0, cache_js_1.cachePsychicApplication)(psychicApp);
+        });
+        return psychicApp;
+    }
+    static lookupClassByGlobalName(name) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return (0, lookupClassByGlobalName_js_1.default)(name);
+    }
+    static checkKey(encryptionIdentifier, key, algorithm) {
+        if (!dream_1.Encrypt.validateKey(key, algorithm))
+            console.warn(`
+Your current key value for ${encryptionIdentifier} encryption is invalid.
+Try setting it to something valid, like:
+  ${dream_1.Encrypt.generateKey(algorithm)}
+
+(This was done by calling:
+  Encrypt.generateKey('${algorithm}')
+`);
+    }
+    /**
+     * Returns the cached psychic application if it has been set.
+     * If it has not been set, an exception is raised.
+     *
+     * The psychic application can be set by calling PsychicApplication#init
+     */
+    static getOrFail() {
+        return (0, cache_js_1.getCachedPsychicApplicationOrFail)();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static log(...args) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        this.getOrFail().logger.info(...args);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static logWithLevel(level, ...args) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        this.getOrFail().logger[level](...args);
+    }
+    _apiOnly = false;
+    get apiOnly() {
+        return this._apiOnly;
+    }
+    _apiRoot;
+    get apiRoot() {
+        return this._apiRoot;
+    }
+    _sessionCookieName = 'session';
+    get sessionCookieName() {
+        return this._sessionCookieName;
+    }
+    _clientRoot;
+    get clientRoot() {
+        return this._clientRoot;
+    }
+    _encryption;
+    get encryption() {
+        return this._encryption;
+    }
+    _appName = 'untitled app';
+    get appName() {
+        return this._appName;
+    }
+    _port = EnvInternal_js_1.default.integer('PORT', { optional: true }) || 7777;
+    get port() {
+        return this._port;
+    }
+    _corsOptions = {};
+    get corsOptions() {
+        return this._corsOptions;
+    }
+    _jsonOptions;
+    get jsonOptions() {
+        return this._jsonOptions;
+    }
+    _cookieOptions;
+    get cookieOptions() {
+        return this._cookieOptions;
+    }
+    _logger = console;
+    get logger() {
+        return this._logger;
+    }
+    _sslCredentials;
+    get sslCredentials() {
+        return this._sslCredentials;
+    }
+    _saltRounds;
+    get saltRounds() {
+        return this._saltRounds;
+    }
+    _routesCb;
+    get routesCb() {
+        return this._routesCb;
+    }
+    _openapi = {
+        default: {
+            outputFilename: 'openapi.json',
+            schemaDelimeter: '',
+            info: {
+                title: 'untitled openapi spec',
+                version: 'unknown version',
+                description: '',
+            },
+        },
+    };
+    get openapi() {
+        return this._openapi;
+    }
+    _client = {
+        apiPath: 'src/api',
+    };
+    get client() {
+        return this._client;
+    }
+    _paths = {
+        apiRoutes: 'src/conf/routes.ts',
+        controllers: 'src/app/controllers',
+        controllerSpecs: 'spec/unit/controllers',
+    };
+    get paths() {
+        return this._paths;
+    }
+    _inflections;
+    get inflections() {
+        return this._inflections;
+    }
+    _bootHooks = {
+        boot: [],
+        load: [],
+        'load:dev': [],
+        'load:test': [],
+        'load:prod': [],
+    };
+    get bootHooks() {
+        return this._bootHooks;
+    }
+    _specialHooks = {
+        sync: [],
+        serverInit: [],
+        serverInitAfterRoutes: [],
+        serverStart: [],
+        serverError: [],
+        serverShutdown: [],
+    };
+    get specialHooks() {
+        return this._specialHooks;
+    }
+    _overrides = {
+        ['server:start']: null,
+    };
+    get overrides() {
+        return this._overrides;
+    }
+    _loadedControllers = false;
+    get loadedControllers() {
+        return this._loadedControllers;
+    }
+    _baseDefaultResponseHeaders = {
+        ['cache-control']: 'max-age=0, private, must-revalidate',
+    };
+    _defaultResponseHeaders = {};
+    get defaultResponseHeaders() {
+        return {
+            ...this._baseDefaultResponseHeaders,
+            ...this._defaultResponseHeaders,
+        };
+    }
+    get controllers() {
+        return (0, importControllers_js_1.getControllersOrFail)();
+    }
+    async load(resourceType, resourcePath, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    importCb) {
+        switch (resourceType) {
+            case 'controllers':
+                await (0, importControllers_js_1.default)(this, resourcePath, importCb);
+                this._loadedControllers = true;
+                break;
+        }
+    }
+    booted = false;
+    async boot(force = false) {
+        if (this.booted && !force)
+            return;
+        // await new IntegrityChecker().check()
+        await this.runHooksFor('load');
+        switch (EnvInternal_js_1.default.nodeEnv) {
+            case 'development':
+                await this.runHooksFor('load:dev');
+                break;
+            case 'production':
+                await this.runHooksFor('load:prod');
+                break;
+            case 'test':
+                await this.runHooksFor('load:test');
+                break;
+        }
+        await this.inflections?.();
+        this.booted = true;
+    }
+    on(hookEventType, cb) {
+        switch (hookEventType) {
+            case 'server:error':
+                this._specialHooks.serverError.push(cb);
+                break;
+            case 'server:init':
+                this._specialHooks.serverInit.push(cb);
+                break;
+            case 'server:start':
+                this._specialHooks.serverStart.push(cb);
+                break;
+            case 'server:shutdown':
+                this._specialHooks.serverShutdown.push(cb);
+                break;
+            case 'server:init:after-routes':
+                this._specialHooks.serverInitAfterRoutes.push(cb);
+                break;
+            case 'sync':
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                this._specialHooks['sync'].push(cb);
+                break;
+            default:
+                this.bootHooks[hookEventType].push(cb);
+        }
+    }
+    set(option, unknown1, unknown2) {
+        const value = unknown2 || unknown1;
+        switch (option) {
+            case 'appName':
+                this._appName = value;
+                break;
+            case 'apiOnly':
+                this._apiOnly = value;
+                break;
+            case 'apiRoot':
+                this._apiRoot = value;
+                break;
+            case 'clientRoot':
+                this._clientRoot = value;
+                break;
+            case 'defaultResponseHeaders':
+                this._defaultResponseHeaders = Object.keys(value).reduce((agg, key) => {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+                    agg[key.toLowerCase()] = value[key];
+                    return agg;
+                }, {});
+                break;
+            case 'sessionCookieName':
+                this._sessionCookieName = value;
+                break;
+            case 'encryption':
+                this._encryption = value;
+                break;
+            case 'cors':
+                this._corsOptions = { ...this.corsOptions, ...value };
+                break;
+            case 'cookie':
+                this._cookieOptions = {
+                    ...this.cookieOptions,
+                    maxAge: (0, cookieMaxAgeFromCookieOpts_js_1.default)(value.maxAge),
+                };
+                break;
+            case 'client':
+                this._client = { ...this.client, ...value };
+                break;
+            case 'routes':
+                this._routesCb = value;
+                break;
+            case 'json':
+                this._jsonOptions = { ...this.jsonOptions, ...value };
+                break;
+            case 'logger':
+                this._logger = value;
+                break;
+            case 'ssl':
+                this._sslCredentials = { ...this.sslCredentials, ...value };
+                break;
+            case 'port':
+                this._port = value;
+                break;
+            case 'saltRounds':
+                this._saltRounds = value;
+                break;
+            case 'openapi':
+                this._openapi = {
+                    ...this.openapi,
+                    [unknown2 ? unknown1 : 'default']: {
+                        outputFilename: 'openapi.json',
+                        ...value,
+                    },
+                };
+                break;
+            case 'paths':
+                this._paths = {
+                    ...this.paths,
+                    ...value,
+                };
+                break;
+            case 'inflections':
+                this._inflections = value;
+                break;
+            default:
+                throw new Error(`Unhandled option type passed to PsychicApplication#set: ${option}`);
+        }
+    }
+    override(override, value) {
+        switch (override) {
+            case 'server:start':
+                this.overrides['server:start'] = value;
+        }
+    }
+    async runHooksFor(hookEventType) {
+        for (const hook of this.bootHooks[hookEventType]) {
+            await hook(this);
+        }
+    }
+}
+exports.default = PsychicApplication;

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = logo;
+exports.basicLogo = basicLogo;
+const colors = require("colorette");
+function logo() {
+    return (colors.bgMagentaBright(colors.black(`
+      ,▄█▄                                               
+    ]█▄▄                         ╓█████▌                 
+    ▐██████▄                   ▄█████▓╣█                 
+     ║████████▄,  ,  ,,▄,▄▄▄▓██████╬╬╣╣▌                 
+      ╚███╣██████████▓▓▓▓██████████╩╠╬▓                  
+       ╙█╬╬╬▓███████████████████████▒▓▌                  `)) +
+        colors.bgMagentaBright(colors.black(`
+        ╙▓█▓██████████████████████████                   
+         ╚██████▀███████████`) + colors.greenBright(`╩█▓▌`) + colors.black(`▐▓████▄                  
+         '║█████`) + colors.greenBright(`\`╣█Γ║`) + colors.black(`████████▄▄φ▓█████▌                  
+          ║█████████████████████▓█████▌                  
+           █████████████▓▓████████████                   `)) +
+        colors.bgMagentaBright(colors.black(`
+           ║█████████████████████████                    
+          ]█████████████████████████                     
+         ,▓██████████████████████████                    
+        ▓█████████████████████████████µ                  `)) +
+        colors.bgMagentaBright(colors.black(`
+       ▐███████████████████████████████▄▄                
+       ║█████████████████████████████████╬╬╣▓            
+   ,╔╦║███████████████████████████████████▓╬╬╣           
+,≥≥⌠░░░╠▓████████████████████████████████████▓▓          
+,;=-',▄█████████████████████████████████████████▓        `)) +
+        colors.bgGreen(colors.magenta(`
+                                                         
+                                                         
+                                                         
+  ██████╗ ███████╗██╗   ██╗ ██████╗██╗  ██╗██╗ ██████╗   
+  ██╔══██╗██╔════╝╚██╗ ██╔╝██╔════╝██║  ██║██║██╔════╝   
+  ██████╔╝███████╗ ╚████╔╝ ██║     ███████║██║██║        
+  ██╔═══╝ ╚════██║  ╚██╔╝  ██║     ██╔══██║██║██║        
+  ██║     ███████║   ██║   ╚██████╗██║  ██║██║╚██████╗   
+  ╚═╝     ╚══════╝   ╚═╝    ╚═════╝╚═╝  ╚═╝╚═╝ ╚═════╝   
+                                                         
+                                                         `)));
+}
+function basicLogo() {
+    return (`
+      ,▄█▄                                               
+    ]█▄▄                         ╓█████▌                 
+    ▐██████▄                   ▄█████▓╣█                 
+     ║████████▄,  ,  ,,▄,▄▄▄▓██████╬╬╣╣▌                 
+      ╚███╣██████████▓▓▓▓██████████╩╠╬▓                  
+       ╙█╬╬╬▓███████████████████████▒▓▌                  
+        ╙▓█▓██████████████████████████                   
+         ╚██████▀███████████╩█▓▌▐▓████▄                  
+         '║█████\`╣█Γ║████████▄▄φ▓█████▌                  
+          ║█████████████████████▓█████▌                  
+           █████████████▓▓████████████                   
+           ║█████████████████████████                    
+          ]█████████████████████████                     
+         ,▓██████████████████████████                    
+        ▓█████████████████████████████µ                  
+       ▐███████████████████████████████▄▄                
+       ║█████████████████████████████████╬╬╣▓            
+   ,╔╦║███████████████████████████████████▓╬╬╣           
+,≥≥⌠░░░╠▓████████████████████████████████████▓▓          
+,;=-',▄█████████████████████████████████████████▓        
+                                                         
+                                                         
+                                                         
+  ██████╗ ███████╗██╗   ██╗ ██████╗██╗  ██╗██╗ ██████╗   
+  ██╔══██╗██╔════╝╚██╗ ██╔╝██╔════╝██║  ██║██║██╔════╝   
+  ██████╔╝███████╗ ╚████╔╝ ██║     ███████║██║██║        
+  ██╔═══╝ ╚════██║  ╚██╔╝  ██║     ██╔══██║██║██║        
+  ██║     ███████║   ██║   ╚██████╗██║  ██║██║╚██████╗   
+  ╚═╝     ╚══════╝   ╚═╝    ╚═════╝╚═╝  ╚═╝╚═╝ ╚═════╝   
+                                                         
+                                                         `);
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/src/router/helpers.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routePath = routePath;
+exports.resourcePath = resourcePath;
+exports.sanitizedControllerPath = sanitizedControllerPath;
+exports.controllerGlobalNameFromControllerPath = controllerGlobalNameFromControllerPath;
+exports.namespacedRoute = namespacedRoute;
+exports.namespacedControllerActionString = namespacedControllerActionString;
+exports.lookupControllerOrFail = lookupControllerOrFail;
+exports.applyResourcesAction = applyResourcesAction;
+exports.applyResourceAction = applyResourceAction;
+const dream_1 = require("@rvoh/dream");
+const cannot_find_inferred_controller_from_provided_namespace_js_1 = require("../error/router/cannot-find-inferred-controller-from-provided-namespace.js");
+const cannot_infer_controller_from_top_level_route_js_1 = require("../error/router/cannot-infer-controller-from-top-level-route.js");
+const pascalizeFileName_js_1 = require("../helpers/pascalizeFileName.js");
+const index_js_1 = require("../psychic-application/index.js");
+function routePath(routePath) {
+    return `/${routePath.replace(/^\//, '')}`;
+}
+function resourcePath(routePath) {
+    return `/${routePath}/:id`;
+}
+function sanitizedControllerPath(controllerName) {
+    return controllerName.replace(/Controller$/, '') + 'Controller';
+}
+function controllerGlobalNameFromControllerPath(controllerName) {
+    return `controllers/${sanitizedControllerPath(controllerName)}`;
+}
+function namespacedRoute(namespace, route) {
+    const compactedRoutes = (0, dream_1.compact)([namespace || null, route]);
+    return '/' + compactedRoutes.join('/').replace(/^\//, '');
+}
+function namespacedControllerActionString(namespace, controllerActionString) {
+    return [
+        namespace
+            .split('/')
+            .filter(part => !/^:/.test(part))
+            .map(part => (0, dream_1.pascalize)(part))
+            .join('/'),
+        controllerActionString,
+    ]
+        .join('/')
+        .replace(/^\//, '');
+}
+function lookupControllerOrFail(routingMechanism, opts) {
+    const namespaces = opts.resourceName
+        ? routingMechanism.currentNamespaces.concat({
+            namespace: opts.resourceName,
+            resourceful: false,
+            isScope: false,
+        })
+        : routingMechanism.currentNamespaces;
+    const filteredNamespaces = namespaces.filter(n => !n.isScope);
+    if (!filteredNamespaces.length)
+        throw new cannot_infer_controller_from_top_level_route_js_1.default(opts.httpMethod, opts.path, (0, pascalizeFileName_js_1.default)(opts.path) + 'Controller', (0, dream_1.camelize)((0, pascalizeFileName_js_1.default)(opts.path)));
+    return inferControllerOrFail(filteredNamespaces, opts);
+}
+function inferControllerOrFail(filteredNamespaces, opts) {
+    const filename = filteredNamespaces.map(str => (0, dream_1.pascalize)(str.namespace)).join('/') + 'Controller';
+    const expectedPath = `controllers/${filename}`;
+    const controller = index_js_1.default.getOrFail().controllers[expectedPath];
+    if (!controller)
+        throw new cannot_find_inferred_controller_from_provided_namespace_js_1.default({
+            expectedPath,
+            controllerName: filename.replace(/\//g, ''),
+            action: (0, dream_1.camelize)((0, pascalizeFileName_js_1.default)(opts.path)),
+            httpMethod: opts.httpMethod,
+            path: opts.path,
+        });
+    return controller;
+}
+function applyResourcesAction(path, action, routingMechanism, options) {
+    const controller = options?.controller ||
+        lookupControllerOrFail(routingMechanism, {
+            path: action,
+            httpMethod: httpMethodFromResourcefulAction(action),
+            resourceName: path,
+        });
+    switch (action) {
+        case 'index':
+            routingMechanism.get(path, controller, 'index');
+            break;
+        case 'create':
+            routingMechanism.post(path, controller, 'create');
+            break;
+        case 'update':
+            routingMechanism.put(`${path}/:id`, controller, 'update');
+            routingMechanism.patch(`${path}/:id`, controller, 'update');
+            break;
+        case 'show':
+            routingMechanism.get(`${path}/:id`, controller, 'show');
+            break;
+        case 'destroy':
+            routingMechanism.delete(`${path}/:id`, controller, 'destroy');
+            break;
+    }
+}
+function applyResourceAction(path, action, routingMechanism, options) {
+    const controller = options?.controller ||
+        lookupControllerOrFail(routingMechanism, {
+            path: action,
+            httpMethod: httpMethodFromResourcefulAction(action),
+            resourceName: path,
+        });
+    switch (action) {
+        case 'create':
+            routingMechanism.post(path, controller, 'create');
+            break;
+        case 'update':
+            routingMechanism.put(path, controller, 'update');
+            routingMechanism.patch(path, controller, 'update');
+            break;
+        case 'show':
+            routingMechanism.get(path, controller, 'show');
+            break;
+        case 'destroy':
+            routingMechanism.delete(path, controller, 'destroy');
+            break;
+        default:
+            throw new Error(`unsupported resource method type: ${action}`);
+    }
+}
+function httpMethodFromResourcefulAction(action) {
+    switch (action) {
+        case 'index':
+            return 'get';
+        case 'show':
+            return 'get';
+        case 'create':
+            return 'post';
+        case 'update':
+            return 'patch';
+        case 'destroy':
+            return 'delete';
+        default:
+            throw new Error(`unexpected resourceful action: ${action}`);
+    }
+}