@vida-global/core 2.0.0 → 2.0.3

package/lib/server/controllerMixins/renderer.js

@@ -0,0 +1,315 @@
+const Errors = require('../errors');
+
+
+class StreamInProgressError extends Error {}
+class NoActiveStreamError   extends Error {}
+
+
+const CONTENT_TYPE_BY_EXTENSION = {
+    html:  'text/html; charset=utf-8',
+    htm:   'text/html; charset=utf-8',
+    css:   'text/css; charset=utf-8',
+    js:    'application/javascript; charset=utf-8',
+    mjs:   'application/javascript; charset=utf-8',
+    json:  'application/json; charset=utf-8',
+    txt:   'text/plain; charset=utf-8',
+    png:   'image/png',
+    jpg:   'image/jpeg',
+    jpeg:  'image/jpeg',
+    gif:   'image/gif',
+    svg:   'image/svg+xml',
+    ico:   'image/x-icon',
+    webp:  'image/webp',
+    woff:  'font/woff',
+    woff2: 'font/woff2',
+    ttf:   'font/ttf',
+    otf:   'font/otf',
+    map:   'application/json; charset=utf-8',
+};
+
+
+function guessContentType(filePath) {
+    const match = /\.([a-z0-9]+)$/i.exec(`${filePath || ''}`);
+    const ext   = match ? match[1].toLowerCase() : '';
+    return CONTENT_TYPE_BY_EXTENSION[ext] || 'application/octet-stream';
+}
+
+
+function setSseHeaders(controller) {
+    controller.statusCode = 200;
+    controller.setHeader('Content-Type',      'text/event-stream; charset=utf-8');
+    controller.setHeader('Cache-Control',     'no-cache');
+    controller.setHeader('Connection',        'keep-alive');
+    controller.setHeader('X-Accel-Buffering', 'no');
+    controller.flushHeaders();
+}
+
+
+const InstanceMethods = {
+    async render(body, options={}) {
+        if (this.rendered)    return;
+        if (this.isStreaming) return;
+
+        if (typeof body == 'string') {
+            this._response.send(body);
+        } else {
+            body = await this.processJSONBody(body, options);
+
+            const  errors = body.errors || null;
+            delete body.errors;
+
+            body = this.formatJSONBody(body, errors, options);
+            this._response.json(body);
+        }
+        this.markRendered();
+    },
+
+
+    async renderErrors(message, fields) {
+        const errors = {message: null, fields: {}};
+
+        if (message && !fields && typeof message == 'object') {
+            fields  = message;
+            message = null;
+        }
+
+        if (fields) {
+          for (const [field, values] of Object.entries(fields)) {
+              if (!Array.isArray(values)) fields[field] = [values];
+          }
+          errors.fields = fields;
+        }
+
+        await this.renderBadRequest(message, { errors });
+    },
+
+
+    formatJSONBody(body, errors, options) {
+        if (options.standardize === false) return body;
+
+        const response = {data: body, status: this.statusText};
+        if (errors) response.errors = errors;
+
+        return response;
+    },
+
+
+    async processJSONBody(body, options) {
+        if (body === undefined)               return null;
+        if (!body || typeof body != 'object') return body;
+
+        let processedBody;
+
+        if (body.toApiResponse) {
+            const formattedBody = await body.toApiResponse(options);
+            return await this.processJSONBody(formattedBody, options);
+
+        } else if (Array.isArray(body)) {
+            const processed = [];
+            for (const idx in body) {
+                processed.push(await this.processJSONBody(body[idx], options));
+            }
+            return processed;
+
+        } else if (body.constructor == Date) {
+            return body.getTime();
+
+        } else {
+            const processed = {};
+            for (let [key, val] of Object.entries(body)) {
+                processed[key] = await this.processJSONBody(val, options);
+            }
+            return processed;
+        }
+    },
+
+
+    _setupStatusRenderers() {
+        const successStatuses = {
+            CreationSuccessful: 201,
+            Accepted:           202,
+            NoConent:           204,
+            MovedPermanently:   301,
+            Found:              302,
+            NotModified:        304,
+            TemporaryRedirect:  307,
+            PermanentRedirect:  308,
+        }
+
+        for (let [type, statusCode] of Object.entries(Errors.Statuses)) {
+            if (type == 'Server') type = 'ServerError';
+            this[`render${type}`] = async function(message=null, body=null) {
+                return await this._renderError(statusCode, message, body);
+            }
+        }
+
+        for (let [type, statusCode] of Object.entries(successStatuses)) {
+            this[`render${type}`] = async function(body=null) {
+                return await this._renderSuccess(statusCode, body);
+            }
+        }
+    },
+
+
+    async _renderError(statusCode, message, body) {
+        this.statusCode     = statusCode;
+        body                = structuredClone(body || {});
+        body.errors         = body.errors          || {};
+        body.errors.message = message              || null;
+        return await this.render(body);
+    },
+
+
+    async _renderSuccess(statusCode, body) {
+      this.statusCode = statusCode;
+      return await this.render(body);
+    },
+
+
+    setHeader(header, value) {
+        this._response.setHeader(header, value);
+    },
+
+
+    flushHeaders() {
+      this._response.flushHeaders();
+    },
+
+
+    /***********************************************************************************************
+    * FILE RENDERING
+    ***********************************************************************************************/
+    renderFile(filePath, { contentType, cacheControl, maxAge } = {}) {
+        if (!filePath) throw new Error('renderFile requires a filePath');
+        const resolvedType = contentType || guessContentType(filePath);
+        this._response.setHeader('Content-Type', resolvedType);
+        if (cacheControl) this._response.setHeader('Cache-Control', cacheControl);
+        this.markRendered();
+        return new Promise((resolve, reject) => {
+            this._response.sendFile(filePath, { maxAge }, (err) => {
+                if (err) reject(err);
+                else     resolve();
+            });
+        });
+    },
+
+
+    /***********************************************************************************************
+    * STREAM
+    ***********************************************************************************************/
+    async streamSseResponse(handler, errorHandler, abortController=null) {
+        if (this._isStreaming) throw new StreamInProgressError();
+        this._isStreaming = true;
+
+        let closeHandler;
+        if (abortController) {
+            this._streamAbortController = abortController;
+            closeHandler = () => abortController.abort();
+            this._request.on('close', closeHandler);
+        }
+
+        setSseHeaders(this);
+        this.markRendered();
+        try {
+            await handler.bind(this)();
+        } catch(err) {
+          await errorHandler(err);
+          throw err;
+        } finally {
+            this.writeStreamEvent(null, '[DONE]');
+            this._response.end();
+
+            this._isStreaming           = false;
+            this._streamAbortController = null;
+
+            if (closeHandler) this._request.off('close', closeHandler);
+        }
+    },
+
+
+    writeStreamEvent(evt, data) {
+        if (!this._isStreaming) throw new NoActiveStreamError();
+        if (this._streamAbortController?.signal?.aborted || this.writableEnded) return;
+
+        if (evt) {
+            this._response.write(`event: ${evt}\n`);
+        }
+
+        const msg = `data: ${data}\n\n`;
+        this._response.write(msg);
+    }
+}
+
+
+const Accessors = {
+    statusText: {
+        get() {
+            switch(this.statusCode) {
+                case 200:
+                    return 'ok';
+                case 201:
+                    return 'created';
+                case 202:
+                    return 'accepted';
+                case 204:
+                    return 'no content';
+                case 301:
+                  return 'moved permanently';
+                case 302:
+                  return 'found';
+                case 304:
+                  return 'not modified';
+                case 307:
+                  return 'temporary redirect';
+                case 308:
+                  return 'permanent redirect';
+                case 400:
+                    return 'bad request'
+                case 401:
+                    return 'unauthorized';
+                case 402:
+                    return 'payment required';
+                case 403:
+                    return 'forbidden';
+                case 404:
+                    return 'not found';
+                case 405:
+                    return 'method not allowed';
+                case 408:
+                    return 'request timeout';
+                case 409:
+                    return 'conflict';
+                case 410:
+                    return 'gone';
+                case 413:
+                    return 'content too large';
+                case 415:
+                    return 'unsupported media type';
+                case 422:
+                    return 'unprocessable content';
+                case 423:
+                    return 'locked';
+                case 429:
+                    return 'too many requests';
+                case 500:
+                    return 'server error';
+                case 501:
+                    return 'not implemented';
+                case 502:
+                    return 'bad gateway';
+                case 503:
+                    return 'service unavailable';
+                case 504:
+                    return 'gateway timeout';
+            }
+        },
+    }
+}
+
+
+module.exports = {
+    Accessors,
+    InstanceMethods,
+    NoActiveStreamError,
+    StreamInProgressError 
+}

package/lib/server/controllerMixins/requestDetails.js

@@ -0,0 +1,82 @@
+function processRequestData(data) {
+    const processedData = {};
+    for (let [paramName, paramValue] of Object.entries(data)) {
+        processedData[paramName] = processedRequestDataValue(paramValue)
+    }
+
+    return processedData;
+}
+
+
+function processedRequestDataValue(value) {
+    try {
+        if (!/^\[|{/.test(value)) return value;
+        return JSON.parse(value);
+    } catch(err) {
+        return value;
+    }
+}
+
+
+const InstanceMethods = {
+    getCookie(name) {
+        if (!name) return null;
+        const value = this.cookies[name];
+        return value === undefined ? null : value;
+    },
+
+
+    setCookie(name, value, options = {}) {
+        if (!name) return;
+        this._response.cookie(name, value ?? '', options);
+    }
+}
+
+
+const Accessors = {
+    params: {
+        get() { 
+            if (!this._params) {
+                const body   = Buffer.isBuffer(this._request.body) ? {} : processRequestData(this._request.body || {});
+                this._params = {...this._request.params, ...this._request.query, ...body};
+            }
+            return structuredClone(this._params);
+        }
+    },
+
+
+    contentType:     { get() { return this.requestHeaders['content-type']          }},
+    cookies:         { get() { return this._request.cookies || {}                  }},
+    requestBody:     { get() { return this._request.body                           }},
+    requestHeaders:  { get() { return structuredClone(this._request.headers || {}) }},
+    requestId:       { get() { return this._request.id                             }},
+    requestIp:       { get() { return this._request.ip                             }},
+    requestMethod:   { get() { return this._request.method                         }},
+    responseHeaders: { get() { return this._response.headers                       }},
+    url:             { get() { return this._request.originalUrl                    }},
+    userAgent:       { get() { return this.requestHeaders['user-agent']            }},
+
+
+    statusCode: {
+        get()        { return this._response.statusCode    },
+        set(_status) { this._response.statusCode = _status }
+    },
+
+
+    bearerToken: {
+        get() {
+            const auth = this.requestHeaders.authorization;
+            if (!auth) return null;
+
+            const match = /^\s*bearer\s+(.+)$/i.exec(auth);
+            if (!match) return null;
+            return match[1].trim();
+        }
+    },
+}
+
+
+module.exports = {
+    Accessors,
+    InstanceMethods
+};

package/lib/server/controllerMixins/routing.js

@@ -0,0 +1,108 @@
+const { singularize }  = require('inflection');
+
+
+const actionStore = new WeakMap();
+
+
+/***********************************************************************************************
+* ACTION SETUP
+************************************************************************************************
+* The controller looks for any methods that fit the pattern of `{httpMethod}ActionName`
+* (e.g. getFooBar) and prepares server routes for them. By default, a method `getFooBar` on a
+* `BazController` would have an endpoint of  `GET /baz/fooBar`. The server will also prepend
+* directory names, so if `bazController.js` is nested within the `ban` directory
+* (e.g. `ban/bazController.js`), the endpoint will be `GET /ban/baz/fooBar`.
+*
+* Default routing logic can be overriden by defining custom routes in the `routes` getter. To
+* provider a custom route for `getFooBar`, `routes` should return an object like:
+* {getFooBar: '/ban/:accountIdd/foo/:userId/bar'}`
+***********************************************************************************************/
+const StaticMethods = {
+    _constructAction(actionName) {
+        const routePrefix = this.routePrefix
+        const action      = {};
+        const match       = actionName.match(this.actionRegExp);
+
+        action.method = match.groups.method.toUpperCase();
+        action.action = actionName;
+        action.path   = this._routeForAction(action.method, match.groups.path, routePrefix, actionName);
+        return action;
+    },
+
+
+    _routeForAction(method, path, routePrefix, actionName) {
+        if (this.routes?.[actionName]) return this.routes[actionName];
+
+        // If the path starts with Record, use :id as a path parameter
+        /*
+          class UsersController {
+              // Get /users
+              async getIndex() {}
+
+              // Get /user/:id
+              async getRecord() {}
+
+              // Get /user/:id/status
+              async getRecordStatus() {}
+          }
+        */
+        if (/^Record($|[A-Z])/.test(path)) {
+          routePrefix = `${singularize(routePrefix)}/:id`;
+          path = path == 'Record' ? 'Index' : path.replace(/^Record/, '');
+        }
+
+        if (path == 'Index') return routePrefix;
+
+        path = path.charAt(0).toLowerCase() + path.slice(1);
+        return `${routePrefix}/${path}`;
+    }
+}
+
+
+const StaticAccessors = {
+    actions: {
+        get() {
+            if (actionStore.has(this)) return actionStore.get(this);
+            const actionNames = this.actionNames;
+            const actions = actionNames.map((actionName => {
+                return this._constructAction(actionName);
+            }).bind(this));
+
+            actionStore.set(this, actions);
+            return actions;
+        }
+    },
+
+
+    routePrefix: {
+        get() {
+            const controllerName   = this.name.replace(/Controller$/, '');
+            const controllerPrefix = controllerName.charAt(0).toLowerCase() + controllerName.slice(1);
+            
+            return `${this.directoryPrefix || ''}/${controllerPrefix}`;
+        }
+    },
+
+
+    actionNames: {
+        get() {
+            const methodNames = Object.getOwnPropertyNames(this.prototype);
+            const nameRegExp  = this.actionRegExp;
+            return methodNames.filter(name => nameRegExp.test(name));
+        }
+    },
+
+
+    actionRegExp: {
+        get() {
+            return new RegExp(/^(?<method>get|post|put|delete|patch|head)(?<path>[A-Z][a-zA-Z]+)$/);
+        }
+    }
+
+}
+
+
+module.exports = {
+    StaticAccessors,
+    StaticMethods,
+}

package/lib/server/controllerMixins/validations.js

@@ -0,0 +1,114 @@
+const { camelize }  = require('inflection');
+const   Errors      = require('../errors');
+
+
+const StaticMethods = {
+    parametersForAction(actionName) {
+        const methodName = this.parametersMethodForAction(actionName);
+        if (this[methodName]) return this[methodName]();
+        return null;
+    },
+
+
+    parametersMethodForAction(actionName) {
+        return `parametersFor${camelize(actionName)}`;
+    },
+}
+
+
+const InstanceMethods = {
+    async validateAction(actionName) {
+        const parameters = this.constructor.parametersForAction(actionName);
+        if (parameters) await this.validateParameters(parameters);
+    },
+
+
+    async validateParameters(validations) {
+        const errors = {};
+        for (const [parameterName, parameterValidations] of Object.entries(validations)) {
+            const parameterErrors = await this.validateParameter(this.params[parameterName], parameterValidations);
+            if (parameterErrors.length) errors[parameterName] = parameterErrors;
+        }
+
+        if (Object.keys(errors).length) throw new Errors.ValidationError('', errors);
+    },
+
+
+    async validateParameter(value, parameterValidations) {
+        const errors = [];
+
+        if (parameterValidations?.optional && value === undefined) return errors;
+
+        for (const [validationType, validationOptions] of Object.entries(parameterValidations)) {
+            const validationMethod = `validate${camelize(validationType)}`;
+            if (!this[validationMethod]) continue;
+            const error = await this[validationMethod](value, validationOptions);
+            if (error) errors.push(error);
+        }
+
+        return errors;
+    },
+
+
+    validatePresence(value) {
+        if (!value) return 'required';
+    },
+
+
+    validateIsInteger(value, options) {
+        const num = parseFloat(value);
+        if (!/^-?\d+$/.test(value) || isNaN(num) || !Number.isInteger(num)) return 'must be an integer';
+
+        if (options?.gte !== undefined) {
+            if (num < options.gte) return `must be greater than or equal to ${options.gte}`;
+        }
+        if (options?.lte !== undefined) {
+            if (num > options.lte) return `must be less than or equal to ${options.lte}`;
+        }
+    },
+
+
+    validateIsString(value, options) {
+        if (typeof value !== 'string') return 'must be a string';
+
+        if (options?.length?.gte !== undefined) {
+            if (value.length < options.length.gte) return `must be greater than or equal to ${options.length.gte} characters`;
+        }
+        if (options?.length?.lte !== undefined) {
+            if (value.length > options.length.lte) return `must be fewer than or equal to ${options.length.lte} characters`;
+        }
+        if (options?.regex !== undefined) {
+            if (!options.regex.test(value)) return `must match ${options.regex}`;
+        }
+    },
+
+
+    validateIsDateTime(value) {
+        if (new Date(value) == 'Invalid Date') return 'invalid date';
+    },
+
+
+    validateIsEnum(value, options) {
+        if (!options.enums.includes(value)) {
+            return options.error || `must be one of [${options.enums.filter(Boolean).join(', ')}]`;
+        }
+    },
+
+
+    validateIsBoolean(value, bool) {
+      if (typeof value == 'boolean' && value === bool) return;
+      return `must be ${bool}`;
+    },
+
+
+    async validateFunction(value, fnc) {
+        const error = await fnc.call(this, value);
+        if (error) return error;
+    },
+}
+
+
+module.exports = {
+    InstanceMethods,
+    StaticMethods
+};

package/lib/server/server.js

@@ -1,4 +1,5 @@
 const   APM                    = require('../apm');
+const   cookieParser           = require('cookie-parser');
 const { ControllerImporter }   = require('./controllerImporter');
 const   express                = require('express');
 const { logger }               = require('../logger');
@@ -77,6 +78,7 @@ class VidaServer {
         this.use(this.jsonParsingMiddleware);
         this.use(this.octetStreamParsingMiddleware);
         this.use(responseTime({suffix: true}))
+        this.use(cookieParser());
         this.use(express.static('public'))
         this.use(this.loggingMiddleware);
         this.use('/static', express.static(this.staticFilesDirectory));