@rvoh/psychic 0.24.1

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

@@ -0,0 +1,282 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsychicNestedRouter = void 0;
+const dream_1 = require("@rvoh/dream");
+const express_1 = require("express");
+const pluralize_esm_1 = require("pluralize-esm");
+const EnvInternal_js_1 = require("../helpers/EnvInternal.js");
+const errorIsRescuableHttpError_js_1 = require("../helpers/error/errorIsRescuableHttpError.js");
+const index_js_1 = require("../psychic-application/index.js");
+const helpers_js_1 = require("../router/helpers.js");
+const params_js_1 = require("../server/params.js");
+const route_manager_js_1 = require("./route-manager.js");
+const types_js_1 = require("./types.js");
+class PsychicRouter {
+    app;
+    config;
+    currentNamespaces = [];
+    routeManager = new route_manager_js_1.default();
+    constructor(app, config) {
+        this.app = app;
+        this.config = config;
+    }
+    get routingMechanism() {
+        return this.app;
+    }
+    get routes() {
+        return this.routeManager.routes;
+    }
+    get currentNamespacePaths() {
+        return this.currentNamespaces.map(n => n.namespace);
+    }
+    // this is called after all routes have been processed.
+    commit() {
+        this.routes.forEach(route => {
+            this.app[route.httpMethod]((0, helpers_js_1.routePath)(route.path), (req, res) => {
+                this.handle(route.controller, route.action, { req, res }).catch(() => { });
+            });
+        });
+    }
+    get(path, controller, action) {
+        this.crud('get', path, controller, action);
+    }
+    post(path, controller, action) {
+        this.crud('post', path, controller, action);
+    }
+    put(path, controller, action) {
+        this.crud('put', path, controller, action);
+    }
+    patch(path, controller, action) {
+        this.crud('patch', path, controller, action);
+    }
+    delete(path, controller, action) {
+        this.crud('delete', path, controller, action);
+    }
+    options(path, controller, action) {
+        this.crud('options', path, controller, action);
+    }
+    prefixPathWithNamespaces(str) {
+        if (!this.currentNamespaces.length)
+            return str;
+        return '/' + this.currentNamespacePaths.join('/') + '/' + str;
+    }
+    crud(httpMethod, path, controller, action) {
+        controller ||= (0, helpers_js_1.lookupControllerOrFail)(this, { path, httpMethod });
+        action ||= path.replace(/^\//, '');
+        if (action.match(/\//))
+            throw new Error('action cant have a slash in it - action was inferred from path');
+        this.routeManager.addRoute({
+            httpMethod,
+            path: this.prefixPathWithNamespaces(path),
+            controller,
+            action,
+        });
+    }
+    namespace(namespace, cb) {
+        const nestedRouter = new PsychicNestedRouter(this.app, this.config, this.routeManager, {
+            namespaces: this.currentNamespaces,
+        });
+        this.runNestedCallbacks(namespace, nestedRouter, cb);
+    }
+    scope(scope, cb) {
+        const nestedRouter = new PsychicNestedRouter(this.app, this.config, this.routeManager, {
+            namespaces: this.currentNamespaces,
+        });
+        this.runNestedCallbacks(scope, nestedRouter, cb, { treatNamespaceAsScope: true });
+    }
+    resources(path, optionsOrCb, cb) {
+        return this.makeResource(path, optionsOrCb, cb, true);
+    }
+    resource(path, optionsOrCb, cb) {
+        return this.makeResource(path, optionsOrCb, cb, false);
+    }
+    collection(cb) {
+        const replacedNamespaces = this.currentNamespaces.slice(0, this.currentNamespaces.length - 1);
+        const nestedRouter = new PsychicNestedRouter(this.app, this.config, this.routeManager, {
+            namespaces: replacedNamespaces,
+        });
+        const currentNamespace = replacedNamespaces[replacedNamespaces.length - 1];
+        if (!currentNamespace)
+            throw new Error('Must be within a resource to call the collection method');
+        cb(nestedRouter);
+    }
+    makeResource(path, optionsOrCb, cb, plural) {
+        if (cb) {
+            if (typeof optionsOrCb === 'function')
+                throw new Error('cannot pass a function as a second arg when passing 3 args');
+            this._makeResource(path, optionsOrCb, cb, plural);
+        }
+        else {
+            if (typeof optionsOrCb === 'function')
+                this._makeResource(path, undefined, optionsOrCb, plural);
+            else
+                this._makeResource(path, optionsOrCb, undefined, plural);
+        }
+    }
+    _makeResource(path, options, cb, plural) {
+        const nestedRouter = new PsychicNestedRouter(this.app, this.config, this.routeManager, {
+            namespaces: this.currentNamespaces,
+        });
+        const { only, except } = options || {};
+        let resourceMethods = plural ? types_js_1.ResourcesMethods : types_js_1.ResourceMethods;
+        if (only) {
+            resourceMethods = only;
+        }
+        else if (except) {
+            resourceMethods = resourceMethods.filter(m => !except.includes(m));
+        }
+        const originalCurrentNamespaces = this.currentNamespaces;
+        this.makeRoomForNewIdParam(nestedRouter);
+        this.runNestedCallbacks(path, nestedRouter, cb, { asMember: plural, resourceful: true });
+        this.currentNamespaces = originalCurrentNamespaces;
+        resourceMethods.forEach(action => {
+            if (plural) {
+                (0, helpers_js_1.applyResourcesAction)(path, action, nestedRouter, options);
+            }
+            else {
+                (0, helpers_js_1.applyResourceAction)(path, action, nestedRouter, options);
+            }
+        });
+    }
+    runNestedCallbacks(namespace, nestedRouter, cb, { asMember = false, resourceful = false, treatNamespaceAsScope = false, } = {}) {
+        this.addNamespace(namespace, resourceful, { nestedRouter, treatNamespaceAsScope });
+        if (asMember) {
+            this.addNamespace(':id', resourceful, { nestedRouter, treatNamespaceAsScope: true });
+        }
+        if (cb)
+            cb(nestedRouter);
+        this.removeLastNamespace(nestedRouter);
+        if (asMember)
+            this.removeLastNamespace(nestedRouter);
+    }
+    addNamespace(namespace, resourceful, { nestedRouter, treatNamespaceAsScope, } = {}) {
+        this.currentNamespaces = [
+            ...this.currentNamespaces,
+            {
+                namespace,
+                resourceful,
+                isScope: treatNamespaceAsScope || false,
+            },
+        ];
+        if (nestedRouter)
+            nestedRouter.currentNamespaces = this.currentNamespaces;
+    }
+    removeLastNamespace(nestedRouter) {
+        this.currentNamespaces.pop();
+        if (nestedRouter)
+            nestedRouter.currentNamespaces = this.currentNamespaces;
+    }
+    makeRoomForNewIdParam(nestedRouter) {
+        this.currentNamespaces = [
+            ...this.currentNamespaces.map((namespace, index) => {
+                const previousNamespace = this.currentNamespaces[index - 1];
+                if (namespace.namespace === ':id' && previousNamespace) {
+                    return {
+                        ...namespace,
+                        namespace: `:${(0, dream_1.camelize)(pluralize_esm_1.default.singular(previousNamespace.namespace))}Id`,
+                    };
+                }
+                else
+                    return namespace;
+            }),
+        ];
+        if (nestedRouter)
+            nestedRouter.currentNamespaces = this.currentNamespaces;
+    }
+    async handle(controller, action, { req, res, }) {
+        const controllerInstance = this._initializeController(controller, req, res, action);
+        try {
+            await controllerInstance.runAction(action);
+        }
+        catch (error) {
+            const err = error;
+            const psychicApp = index_js_1.default.getOrFail();
+            if (!EnvInternal_js_1.default.isTest)
+                psychicApp.logger.error(err.message);
+            if ((0, errorIsRescuableHttpError_js_1.default)(err)) {
+                const httpErr = err;
+                if (httpErr.data) {
+                    res.status(httpErr.status).json(httpErr.data);
+                }
+                else {
+                    res.sendStatus(httpErr.status);
+                }
+            }
+            else if (err instanceof dream_1.RecordNotFound) {
+                res.sendStatus(404);
+            }
+            else if (err instanceof dream_1.ValidationError) {
+                res.status(422).json({ errors: err.errors || {} });
+            }
+            else if (err instanceof params_js_1.ParamValidationError) {
+                let errorsJson = {};
+                try {
+                    errorsJson = JSON.parse(err.message);
+                }
+                catch {
+                    // noop
+                }
+                res.status(400).json({
+                    errors: errorsJson,
+                });
+            }
+            else {
+                // by default, ts-node will mask these errors for no good reason, causing us
+                // to have to apply an ugly and annoying try-catch pattern to our controllers
+                // and manually console log the error to determine what the actual error was.
+                // this block enables us to not have to do that anymore.
+                if (EnvInternal_js_1.default.isTest && !EnvInternal_js_1.default.boolean('PSYCHIC_EXPECTING_INTERNAL_SERVER_ERROR')) {
+                    index_js_1.default.log('ATTENTION: a server error was detected:');
+                    index_js_1.default.logWithLevel('error', err);
+                }
+                if (this.config.specialHooks.serverError.length) {
+                    try {
+                        for (const hook of this.config.specialHooks.serverError) {
+                            await hook(err, req, res);
+                        }
+                    }
+                    catch (error) {
+                        if (EnvInternal_js_1.default.isDevelopmentOrTest) {
+                            // In development and test, we want to throw so that, for example, double-setting of
+                            // status headers throws an error in specs. We couldn't figure out how to write
+                            // a spec for ensuring that such errors made it through because Supertest would
+                            // respond with the first header sent, which was successful, and the exception only
+                            // happened when Jest ended the spec.
+                            throw error;
+                        }
+                        else {
+                            index_js_1.default.logWithLevel('error', `
+                  Something went wrong while attempting to call your custom server:error hooks.
+                  Psychic will rescue errors thrown here to prevent the server from crashing.
+                  The error thrown is:
+                `);
+                            index_js_1.default.logWithLevel('error', error);
+                        }
+                    }
+                }
+                else
+                    throw err;
+            }
+        }
+    }
+    _initializeController(ControllerClass, req, res, action) {
+        return new ControllerClass(req, res, {
+            config: this.config,
+            action,
+        });
+    }
+}
+exports.default = PsychicRouter;
+class PsychicNestedRouter extends PsychicRouter {
+    router;
+    constructor(app, config, routeManager, { namespaces = [], } = {}) {
+        super(app, config);
+        this.router = (0, express_1.Router)();
+        this.currentNamespaces = namespaces;
+        this.routeManager = routeManager;
+    }
+    get routingMechanism() {
+        return this.router;
+    }
+}
+exports.PsychicNestedRouter = PsychicNestedRouter;

package/dist/cjs/src/router/route-manager.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class RouteManager {
+    routes = [];
+    addRoute({ httpMethod, path, controller, action, }) {
+        this.routes.push({
+            httpMethod,
+            path,
+            controller,
+            action,
+        });
+    }
+}
+exports.default = RouteManager;

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpMethods = exports.ResourceMethods = exports.ResourcesMethods = void 0;
+exports.ResourcesMethods = ['index', 'create', 'update', 'show', 'destroy'];
+exports.ResourceMethods = ['create', 'update', 'show', 'destroy'];
+exports.HttpMethods = ['get', 'post', 'put', 'patch', 'delete', 'options'];

package/dist/cjs/src/server/front-end-client.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sspawn_js_1 = require("../helpers/sspawn.js");
+class FrontEndClientServer {
+    child;
+    start(port = 3000) {
+        this.child = (0, sspawn_js_1.ssspawn)(`PORT=${port} yarn client`, { stdio: 'ignore' });
+    }
+    stop() {
+        if (!this.child)
+            return;
+        this.child.kill();
+    }
+}
+exports.default = FrontEndClientServer;

package/dist/cjs/src/server/helpers/startPsychicServer.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = startPsychicServer;
+exports.createPsychicHttpInstance = createPsychicHttpInstance;
+const fs = require("fs");
+const http = require("http");
+const https = require("https");
+const EnvInternal_js_1 = require("../../helpers/EnvInternal.js");
+const index_js_1 = require("../../psychic-application/index.js");
+const index_js_2 = require("../../server/index.js");
+async function startPsychicServer({ app, port, withFrontEndClient, frontEndPort, sslCredentials, }) {
+    return await new Promise(accept => {
+        const httpOrHttps = createPsychicHttpInstance(app, sslCredentials);
+        const server = httpOrHttps.listen(port, () => {
+            welcomeMessage({ port, withFrontEndClient, frontEndPort });
+            accept(server);
+        });
+    });
+}
+function createPsychicHttpInstance(app, sslCredentials) {
+    if (sslCredentials?.key && sslCredentials?.cert) {
+        return https.createServer({
+            key: fs.readFileSync(sslCredentials.key),
+            cert: fs.readFileSync(sslCredentials.cert),
+        }, app);
+    }
+    else {
+        return http.createServer(app);
+    }
+}
+function welcomeMessage({ port, withFrontEndClient, frontEndPort, }) {
+    if (!EnvInternal_js_1.default.isTest) {
+        const psychicApp = index_js_1.default.getOrFail();
+        psychicApp.logger.info(index_js_2.default.asciiLogo());
+        psychicApp.logger.info(`psychic dev server started at port ${port}`);
+        if (withFrontEndClient)
+            psychicApp.logger.info(`client dev server on port ${frontEndPort}`);
+    }
+}

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

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dream_1 = require("@rvoh/dream");
+const cookieParser = require("cookie-parser");
+const cors = require("cors");
+const express = require("express");
+const OpenApiValidator = require("express-openapi-validator");
+const path = require("path");
+const EnvInternal_js_1 = require("../helpers/EnvInternal.js");
+const isOpenapiError_js_1 = require("../helpers/isOpenapiError.js");
+const index_js_1 = require("../psychic-application/index.js");
+const logo_js_1 = require("../psychic-application/logo.js");
+const index_js_2 = require("../router/index.js");
+const front_end_client_js_1 = require("./front-end-client.js");
+const startPsychicServer_js_1 = require("./helpers/startPsychicServer.js");
+class PsychicServer {
+    static async startPsychicServer(opts) {
+        return await (0, startPsychicServer_js_1.default)(opts);
+    }
+    static createPsychicHttpInstance(app, sslCredentials) {
+        return (0, startPsychicServer_js_1.createPsychicHttpInstance)(app, sslCredentials);
+    }
+    static asciiLogo() {
+        return (0, logo_js_1.default)();
+    }
+    expressApp;
+    frontEndClient;
+    httpServer;
+    booted = false;
+    constructor() {
+        this.buildApp();
+    }
+    get config() {
+        return index_js_1.default.getOrFail();
+    }
+    async routes() {
+        const r = new index_js_2.default(this.expressApp, this.config);
+        const psychicApp = index_js_1.default.getOrFail();
+        await psychicApp.routesCb(r);
+        return r.routes;
+    }
+    async boot() {
+        if (this.booted)
+            return;
+        const psychicApp = index_js_1.default.getOrFail();
+        this.expressApp.use((_, res, next) => {
+            Object.keys(psychicApp.defaultResponseHeaders).forEach(key => {
+                res.setHeader(key, psychicApp.defaultResponseHeaders[key]);
+            });
+            next();
+        });
+        await this.config['runHooksFor']('boot');
+        this.initializeCors();
+        this.initializeJSON();
+        try {
+            await this.config.boot();
+        }
+        catch (err) {
+            const error = err;
+            index_js_1.default.logWithLevel('error', error);
+            throw new Error(`
+        Failed to boot psychic config. the error thrown was:
+          ${error.message}
+      `);
+        }
+        for (const expressInitHook of this.config.specialHooks.serverInit) {
+            await expressInitHook(this);
+        }
+        this.initializeOpenapiValidation();
+        await this.buildRoutes();
+        for (const afterRoutesHook of this.config.specialHooks.serverInitAfterRoutes) {
+            await afterRoutesHook(this);
+        }
+        this.booted = true;
+        return true;
+    }
+    // TODO: use config helper for fetching default port
+    async start(port, { withFrontEndClient = EnvInternal_js_1.default.boolean('CLIENT'), frontEndPort = 3000, } = {}) {
+        await this.boot();
+        if (withFrontEndClient) {
+            this.frontEndClient = new front_end_client_js_1.default();
+            this.frontEndClient.start(frontEndPort);
+        }
+        const psychicApp = index_js_1.default.getOrFail();
+        const startOverride = psychicApp['overrides']['server:start'];
+        if (startOverride) {
+            this.httpServer = await startOverride(this, { port, withFrontEndClient, frontEndPort });
+        }
+        else {
+            const httpServer = await (0, startPsychicServer_js_1.default)({
+                app: this.expressApp,
+                port: port || psychicApp.port,
+                withFrontEndClient,
+                frontEndPort,
+                sslCredentials: this.config.sslCredentials,
+            });
+            this.httpServer = httpServer;
+        }
+        for (const hook of psychicApp.specialHooks.serverStart) {
+            await hook(this);
+        }
+        process.on('SIGINT', () => {
+            void this.shutdownAndExit();
+        });
+        process.on('SIGTERM', () => {
+            void this.shutdownAndExit();
+        });
+        return true;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    attach(id, obj) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        this.$attached[id] = obj;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    $attached = {};
+    async shutdownAndExit() {
+        await this.stop();
+        process.exit();
+    }
+    async stop({ bypassClosingDbConnections = false } = {}) {
+        const psychicApp = index_js_1.default.getOrFail();
+        for (const hook of psychicApp.specialHooks.serverShutdown) {
+            await hook(this);
+        }
+        this.frontEndClient?.stop();
+        this.httpServer?.close();
+        if (!bypassClosingDbConnections) {
+            await (0, dream_1.closeAllDbConnections)();
+        }
+    }
+    async serveForRequestSpecs(block) {
+        const psychicApp = index_js_1.default.getOrFail();
+        const port = psychicApp.port;
+        await this.boot();
+        let server;
+        await new Promise(accept => {
+            server = this.expressApp.listen(port, () => accept({}));
+        });
+        await block();
+        server.close();
+        return true;
+    }
+    buildApp() {
+        this.expressApp = express.default();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.expressApp.use(cookieParser.default());
+    }
+    initializeCors() {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.expressApp.use(cors.default(this.config.corsOptions));
+    }
+    initializeJSON() {
+        this.expressApp.use(express.json(this.config.jsonOptions));
+    }
+    initializeOpenapiValidation() {
+        const psychicApp = index_js_1.default.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 ((0, isOpenapiError_js_1.default)(err)) {
+                        if (EnvInternal_js_1.default.isDebug) {
+                            index_js_1.default.log(JSON.stringify(err));
+                            console.trace();
+                        }
+                        res.status(err.status).json({
+                            message: err.message,
+                            errors: err.errors,
+                        });
+                    }
+                    else {
+                        if (EnvInternal_js_1.default.isDebug) {
+                            index_js_1.default.logWithLevel('error', err);
+                        }
+                        next();
+                    }
+                });
+            }
+        }
+    }
+    async buildRoutes() {
+        const r = new index_js_2.default(this.expressApp, this.config);
+        const psychicApp = index_js_1.default.getOrFail();
+        await psychicApp.routesCb(r);
+        r.commit();
+    }
+}
+exports.default = PsychicServer;