@vida-global/core 1.2.4 → 1.3.0

package/lib/server/serverController.js

@@ -1,5 +1,10 @@
-const { logger }    = require('../logger');
-const { camelize }  = require('inflection');
+const { logger }                 = require('../logger');
+const { camelize, singularize }  = require('inflection');
+const{ AuthorizationError,
+       ForbiddenError,
+       NotFoundError,
+       ServerError,
+       ValidationError }         = require('./errors');
 
 
 class VidaServerController {
@@ -70,6 +75,71 @@ class VidaServerController {
     }
 
 
+    /***********************************************************************************************
+    * PERFORM ACTION
+    ***********************************************************************************************/
+    async performRequest(action) {
+        try {
+            await this.#performRequest(action)
+        } catch(err) {
+            await this.#handleError(err);
+        }
+    }
+
+
+    async #performRequest(action) {
+        await this.setupRequestState();
+
+        if (this.rendered) {
+            this.#response.end();
+            return;
+        }
+
+        this.setupCallbacks();
+
+        const responseBody = await this.#performAction(action);
+
+        if (!this.rendered) {
+            await this.render(responseBody || {});
+        }
+
+        this.#response.end();
+    }
+
+
+    async #performAction(action) {
+        if (await this.runBeforeCallbacks(action) === false) return false;
+        const responseBody = await this[action]();
+        if (await this.runAfterCallbacks(action) === false)  return false;
+
+        return responseBody;
+    }
+
+
+    async #handleError(err) {
+        if (err instanceof AuthorizationError) {
+            await this.renderUnauthorizedResponse(err.message);
+
+        } else if (err instanceof ForbiddenError) {
+            await this.renderForbiddenResponse(err.message);
+
+        } else if (err instanceof NotFoundError) {
+            await this.renderNotFoundResponse(err.message);
+
+        } else if (err instanceof ValidationError) {
+            await this.renderErrors(err.message, err.errors);
+
+        } else {
+            this.statusCode = 500;
+            await this.render({error: err.message});
+            if (process.env.NODE_ENV == 'development') console.log(err);
+        }
+    }
+
+
+    /***********************************************************************************************
+    * RESPONSE RENDERING
+    ***********************************************************************************************/
     async render(body, options={}) {
         if (typeof body == 'string') {
             this._response.send(body);
@@ -81,6 +151,46 @@ class VidaServerController {
     }
 
 
+    async renderErrors(message, fields) {
+        this.statusCode = 400;
+
+        const errors = {message: null, fields: {}};
+
+        if (message && !fields && typeof message == 'object') {
+            fields  = message;
+            message = null;
+        }
+
+        if (message) errors.message = message;
+        if (fields) {
+          for (const [field, values] of Object.entries(fields)) {
+              if (!Array.isArray(values)) fields[field] = [values];
+          }
+          errors.fields = fields;
+        }
+
+        await this.render({ errors });
+    }
+
+
+    async renderNotFoundResponse(message=null) {
+        this.statusCode = 404;
+        await this.render({ message });
+    }
+
+
+    async renderUnauthorizedResponse(message=null) {
+        this.statusCode = 401;
+        await this.render({ message });
+    }
+
+
+    async renderForbiddenResponse(message=null) {
+        this.statusCode = 403;
+        await this.render({ message });
+    }
+
+
     async formatJSONBody(body, options) {
         body = await this._formatJSONBody(body, options);
         if (options.standardize === false) return body;
@@ -122,6 +232,8 @@ class VidaServerController {
                 return 'bad request'
             case 401:
                 return 'unauthorized';
+            case 403:
+                return 'forbidden';
             case 404:
                 return 'not found';
             case 500:
@@ -130,21 +242,34 @@ class VidaServerController {
     }
 
 
-    async renderErrors(errors) {
-        this.statusCode = 400;
-        await this.render({ errors });
+    /***********************************************************************************************
+    * HELPERS
+    ***********************************************************************************************/
+    static autoLoadHelpers() {
+        try {
+            this._autoLoadHelpers()
+        } catch(err) {
+            if (err.message.includes(`Cannot find module '${this.autoLoadHelperPath}'`)) return;
+            throw err;
+        }
     }
 
 
-    async renderNotFoundResponse() {
-        this.statusCode = 404;
-        await this.render();
+    static _autoLoadHelpers() {
+        const { InstanceMethods, Accessors } = require(this.autoLoadHelperPath);
+
+        if (InstanceMethods) Object.assign(this.prototype, InstanceMethods);
+
+        if (Accessors) {
+            for (const [attrName, attrAccessors] of Object.entries(Accessors)) {
+                Object.defineProperty(this.prototype, attrName, attrAccessors);
+            }
+        }
     }
 
 
-    async renderUnauthorizedResponse() {
-        this.statusCode = 401;
-        await this.render();
+    static get autoLoadHelperPath() {
+        return `${process.cwd()}/lib/controllers${this.routePrefix}Controller.js`;
     }
 
 
@@ -222,7 +347,7 @@ class VidaServerController {
             if (parameterErrors.length) errors[parameterName] = parameterErrors;
         }
 
-        if (Object.keys(errors).length) throw new ValidationError(errors);
+        if (Object.keys(errors).length) throw new ValidationError('', errors);
     }
 
 
@@ -264,6 +389,11 @@ class VidaServerController {
     }
 
 
+    validateRegex(value, regex) {
+        if (!regex.test(value)) return `must match the pattern ${regex}`;
+    }
+
+
     validateFunction(value, fnc) {
         const error = fnc(value);
         if (error) return error;
@@ -272,6 +402,7 @@ class VidaServerController {
 
     /***********************************************************************************************
     * 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
@@ -304,7 +435,26 @@ class VidaServerController {
 
     static _routeForAction(method, path, routePrefix, actionName) {
         if (this.routes[actionName]) return this.routes[actionName];
-        if (path == 'Index')         return routePrefix;
+
+        // 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}`;
@@ -337,19 +487,15 @@ class VidaServerController {
 }
 
 
-class AuthorizationError extends Error {}
-class ValidationError    extends Error {
-    #errors;
-    constructor(errors) {
-        super();
-        this.#errors = errors;
-    }
-    get errors() { return structuredClone(this.#errors) }; 
+VidaServerController.prototype.Errors = {
+    Authorization: AuthorizationError,
+    Forbidden:     ForbiddenError,
+    NotFound:      NotFoundError,
+    Server:        ServerError,
+    Validation:    ValidationError
 }
 
 
 module.exports = { 
-    AuthorizationError,
-    ValidationError,
     VidaServerController
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vida-global/core",
-    "version": "1.2.4",
+    "version": "1.3.0",
     "description": "Core libraries for supporting Vida development",
     "author": "",
     "license": "ISC",

package/scripts/{active_record → activeRecord}/migrate.js

@@ -1,4 +1,4 @@
-const   migration = require('../../lib/active_record/db/migration');
+const   migration = require('../../lib/activeRecord/db/migration');
 const { Command } = require('commander');
 
 

package/test/{active_record → activeRecord}/baseRecord.test.js

@@ -1,80 +1,30 @@
-const { BaseRecord }              = require('../../lib/active_record/baseRecord');
-const { Connection}               = require('../../lib/active_record/db/connection');
-const { ConnectionConfiguration } = require('../../lib/active_record/db/connectionConfiguration');
-const { getActiveRecordSchema }   = require('../../lib/active_record/db/schema');
-const   importSchema              = require('../../lib/active_record/db/importSchema');
-const { Model, Sequelize }        = require('sequelize');
-const { redisClientFactory }      = require('../../lib/redis');
-const   TestHelpers               = require('@vida-global/test-helpers');
-const { camelize }                = require('inflection');
-
-
-const connectionConfig = {database: ' ', host: ' ', password: ' ', username: ' '};
-const configSpy        = jest.spyOn(ConnectionConfiguration, '_fetchAllConfigs');
-configSpy.mockImplementation(() => ({default: {test: connectionConfig}}));
-
-const mockSequelize = new (class MockSequelize {})();
-const connectionSpy = jest.spyOn(Connection.prototype, '_sequelize', 'get');
-connectionSpy.mockImplementation(() => mockSequelize);
+const { BaseRecord }            = require('../../lib/activeRecord/baseRecord');
+const { getActiveRecordSchema } = require('../../lib/activeRecord/db/schema');
+const   importSchema            = require('../../lib/activeRecord/db/importSchema');
+const { Model, Sequelize }      = require('sequelize');
+const { redisClientFactory }    = require('../../lib/redis');
+const   TestHelpers             = require('@vida-global/test-helpers');
+const { camelize }              = require('inflection');
+const   Helpers                 = require('./helpers/baseRecord');
 
 
 jest.mock('sequelize', () => {
-    const TestHelpers    = require('@vida-global/test-helpers');
-    class MockModel {
-        constructor(data, opts={}) {
-            this.dataValues = data || {}
-            this.options    = opts;
-            for (const [k,v] of Object.entries(this.dataValues)) {
-                this[k] = v;
-            }
-        };
-        static addHook             = jest.fn()
-        static init                = jest.fn()
-        static findByPk            = jest.fn();
-        static findAll             = jest.fn();
-        static primaryKeyAttribute = TestHelpers.Faker.Text.randomString();
-        toJSON()                   { return this.dataValues }
-    }
-
-    MockModel.findAll.mockImplementation(() => []);
-
-    const dataTypeKey1   = TestHelpers.Faker.Text.randomString();
-    const dataTypeValue1 = TestHelpers.Faker.Text.randomString();
-    const dataTypeKey2   = TestHelpers.Faker.Text.randomString();
-    const dataTypeValue2 = TestHelpers.Faker.Text.randomString();
-    const Sequelize = {DataTypes: {
-        [dataTypeKey1]: {types: {postgres: [dataTypeValue1]}, key: dataTypeKey1},
-        [dataTypeKey2]: {types: {postgres: [dataTypeValue2]}, key: dataTypeKey2},
-        postgres:       {}
-    }};
-    return { Model: MockModel, Sequelize } ;
+    const  { MockModel, MockSequelize } = require('./helpers/baseRecordMocks');
+    return { Model: MockModel, Sequelize: MockSequelize } ;
 });
 
-const dataTypeKey1   = Object.keys(Sequelize.DataTypes)[0];
-const dataTypeKey2   = Object.keys(Sequelize.DataTypes)[1];
-const dataTypeValue1 = Sequelize.DataTypes[dataTypeKey1].types.postgres[0];
-const dataTypeValue2 = Sequelize.DataTypes[dataTypeKey2].types.postgres[0];
-const col1Name       = `${TestHelpers.Faker.Text.randomString()}_${TestHelpers.Faker.Text.randomString()}_${TestHelpers.Faker.Text.randomString()}`;
-
-
 jest.mock('../../lib/redis', () => {
-    const client = {
-        del:  jest.fn(),
-        mGet: jest.fn(),
-        mSet: jest.fn(),
-    }
-    const redisClientFactory = () => client;
-
-    return { redisClientFactory };
+    const { mockRedisClientFactory } = require('./helpers/baseRecordMocks');
+    return { redisClientFactory: mockRedisClientFactory };
 });
 
-jest.mock('../../lib/active_record/db/importSchema', () => jest.fn());
-const schema = {created_at: {type: dataTypeValue1},
-                updated_at: {type: dataTypeValue2},
-                [col1Name]: {type: dataTypeValue2}
-};
-importSchema.mockImplementation(() => structuredClone(schema));
-beforeEach(() => importSchema.mockImplementation(() => structuredClone(schema)));
+jest.mock('../../lib/activeRecord/db/importSchema', () => jest.fn());
+importSchema.mockImplementation(() => structuredClone(Helpers.schema));
+
+
+beforeEach(() => {
+    importSchema.mockImplementation(() => structuredClone(Helpers.schema));
+})
 
 
 afterEach(() => {
@@ -94,9 +44,9 @@ describe('BaseRecord', () => {
         it ('calls `getBaseRecordSchema` and passes the response to init', () => {
             class User extends BaseRecord {}
             User.initialize();
-            const tableDetails = {created_at: {type: Sequelize.DataTypes[dataTypeKey1]},
-                                  updated_at: {type: Sequelize.DataTypes[dataTypeKey2]},
-                                  [col1Name]: {type: Sequelize.DataTypes[dataTypeKey2]}
+            const tableDetails = {created_at: {type: Sequelize.DataTypes[Helpers.dataTypeKey1]},
+                                  updated_at: {type: Sequelize.DataTypes[Helpers.dataTypeKey2]},
+                                  [Helpers.colName]: {type: Sequelize.DataTypes[Helpers.dataTypeKey2]}
             };
             expect(importSchema).toHaveBeenCalledTimes(1);
             expect(Model.init).toHaveBeenCalledTimes(1);
@@ -105,7 +55,7 @@ describe('BaseRecord', () => {
                                                       createdAt: 'created_at',
                                                       deletedAt: 'deleted_at',
                                                       modelName: 'User',
-                                                      sequelize: mockSequelize,
+                                                      sequelize: new Helpers.MockSequelize(),
                                                       tableName: 'users',
                                                       updatedAt: 'updated_at'
                                                     });
@@ -120,7 +70,7 @@ describe('BaseRecord', () => {
                                                       createdAt: 'created_at',
                                                       deletedAt: 'deleted_at',
                                                       modelName: 'User',
-                                                      sequelize: mockSequelize,
+                                                      sequelize: new Helpers.MockSequelize(),
                                                       tableName: 'users',
                                                       timestamps: false,
                                                       updatedAt: 'updated_at'
@@ -148,17 +98,17 @@ describe('BaseRecord', () => {
 
         it ('allows for overriding getters and setters', () => {
             class User extends BaseRecord {}
-            const getterMethodName = `_get${camelize(col1Name)}`;
-            const setterMethodName = `_set${camelize(col1Name)}`;
+            const getterMethodName = `_get${camelize(Helpers.colName)}`;
+            const setterMethodName = `_set${camelize(Helpers.colName)}`;
             const getter = jest.fn();
             const setter = jest.fn();
             User.prototype[getterMethodName] = getter;
             User.prototype[setterMethodName] = setter;
             User.initialize();
-            const tableDetails = {created_at: {type: Sequelize.DataTypes[dataTypeKey1]},
-                                  updated_at: {type: Sequelize.DataTypes[dataTypeKey2]},
-                                  [col1Name]: {
-                                      type: Sequelize.DataTypes[dataTypeKey2],
+            const tableDetails = {created_at: {type: Sequelize.DataTypes[Helpers.dataTypeKey1]},
+                                  updated_at: {type: Sequelize.DataTypes[Helpers.dataTypeKey2]},
+                                  [Helpers.colName]: {
+                                      type: Sequelize.DataTypes[Helpers.dataTypeKey2],
                                       get: getter,
                                       set: setter,
                                   }};
@@ -167,7 +117,7 @@ describe('BaseRecord', () => {
                                                       createdAt: 'created_at',
                                                       deletedAt: 'deleted_at',
                                                       modelName: 'User',
-                                                      sequelize: mockSequelize,
+                                                      sequelize: new Helpers.MockSequelize(),
                                                       tableName: 'users',
                                                       updatedAt: 'updated_at'
                                                     });
@@ -535,27 +485,33 @@ describe('BaseRecord', () => {
         });
 
 
-        describe('BaseRecord._afterSaveCacheHook', () => {
-            it ('is called as an after save hook for cached models', () => {
-                expect(Person.addHook).toHaveBeenCalledTimes(0);
-                Person.initialize();
-                expect(Person.addHook).toHaveBeenCalledTimes(1);
-                expect(Person.addHook).toHaveBeenCalledWith('afterSave', Person._afterSaveCacheHook);
+        const hooks = ['Save', 'Destroy'];
+        describe.each(hooks)('BaseRecord._after%sCacheHook', (hook) => {
+            class Cacheable extends BaseRecord {
+                static get isCacheable() { return true; }
+            }
+            const hookMethod = `_after${hook}CacheHook`;
+
+            it (`is called as an after ${hook.toLowerCase()} hook for cached models`, () => {
+                expect(Cacheable.addHook).toHaveBeenCalledTimes(0);
+                Cacheable.initialize();
+                expect(Cacheable.addHook).toHaveBeenCalledTimes(2);
+                expect(Cacheable.addHook).toHaveBeenCalledWith(`after${hook}`, Cacheable[hookMethod]);
             });
 
             it ('is not called as an after save hook for non cached models', () => {
                 class Foo extends BaseRecord {}
                 Foo.initialize();
-                expect(Person.addHook).toHaveBeenCalledTimes(0);
+                expect(Cacheable.addHook).toHaveBeenCalledTimes(0);
             });
 
             it ('calls BaseRecord#clearSelfCache and BaseRecord#updateCache', async () => {
-                const person    = new Person();
+                const person    = new Cacheable();
                 const clearSpy  = jest.spyOn(person, 'clearSelfCache');
                 const updateSpy = jest.spyOn(person, 'updateCache');
                 const options   = {};
 
-                await Person._afterSaveCacheHook(person,options);
+                await Cacheable[hookMethod](person,options);
 
                 expect(clearSpy).toHaveBeenCalledTimes(1);
                 expect(updateSpy).toHaveBeenCalledTimes(1);

package/test/activeRecord/db/connection.test.js

@@ -0,0 +1,149 @@
+const { Connection }              = require('../../../lib/activeRecord/db/connection');
+const { ConnectionConfiguration } = require('../../../lib/activeRecord/db/connectionConfiguration');
+const   Helpers                   = require('../helpers/connection');
+
+
+let fetchConfigsSpy;
+
+jest.mock('sequelize', () => {
+    const { MockSequelize } = require('../helpers/fixtures');
+    return { Sequelize: MockSequelize };
+});
+
+beforeEach(() => {
+    fetchConfigsSpy = jest.spyOn(ConnectionConfiguration, '_fetchAllConfigs');
+    fetchConfigsSpy.mockImplementation(Helpers.buildConfigs);
+});
+
+afterEach(() => {
+    fetchConfigsSpy.mockRestore();
+    Connection.clearConnectionsCache();
+    process.env.NODE_ENV = Helpers.originalNodeEnv;
+});
+
+
+describe('Connection', () => {
+    describe('Connection#_sequelize', () => {
+        it ('caches connections per database id', () => {
+            const conn1 = new Connection();
+            const conn2 = new Connection();
+            const conn3 = new Connection(Helpers.databaseId1);
+
+            expect(conn1._sequelize).toBe(conn2._sequelize);
+            expect(conn1._sequelize).not.toBe(conn3._sequelize);
+        });
+
+
+        describe('settings (postgres)', () => {
+            it.each([
+                ['default',   () => new Connection(), Helpers.defaultConfig],
+                ['secondary', () => new Connection(Helpers.databaseId1), Helpers.secondaryConfig],
+            ])('maps %s postgres config into sequelize options', (_label, connectionFactory, expectedConfig) => {
+                const connection = connectionFactory();
+                const options = connection._sequelize.options;
+
+                expect(options.database).toEqual(expectedConfig.database);
+                expect(options.dialect).toEqual('postgres');
+                expect(options.host).toEqual(expectedConfig.host);
+                expect(options.password).toEqual(expectedConfig.password);
+                expect(options.port).toEqual(expectedConfig.port);
+                expect(options.username).toEqual(expectedConfig.username);
+            });
+
+            it ('requires ssl when configured', () => {
+                const conn = new Connection(Helpers.databaseId2);
+
+                expect(conn._sequelize.options.dialectOptions).toEqual({ ssl: { require: true } });
+            });
+
+            it.each([
+                ['development', undefined],
+                ['production', false],
+            ])('sets logging for %s', (environment, expectedLogging) => {
+                process.env.NODE_ENV = environment;
+                const conn = new Connection();
+
+                expect(conn._sequelize.options.logging).toBe(expectedLogging);
+            });
+
+            it ('sets the configured pool or defaults', () => {
+                const conn1 = new Connection();
+                const conn2 = new Connection(Helpers.databaseId1);
+
+                expect(conn1._sequelize.options.pool).toEqual(Helpers.defaultConfig.pool);
+                expect(conn2._sequelize.options.pool).toEqual({ min: 0, max: 5 });
+            });
+
+            it ('configures underscored naming', () => {
+                const conn = new Connection();
+
+                expect(conn._sequelize.options.define.underscored).toBeTruthy();
+            });
+
+            it ('configures replication when readers are present', () => {
+                const replicatedConfig = Helpers.buildPostgresConfig({
+                    readers: [Helpers.buildPostgresConfig(), Helpers.buildPostgresConfig()],
+                });
+                fetchConfigsSpy.mockImplementation(() => ({ default: { test: replicatedConfig } }));
+
+                const conn = new Connection();
+                const options = conn._sequelize.options;
+
+                expect(options.database).toBe(undefined);
+                expect(options.host).toBe(undefined);
+                expect(options.port).toBe(undefined);
+                expect(options.username).toBe(undefined);
+                expect(options.password).toBe(undefined);
+                expect(options.replication).toEqual({
+                    write: {
+                        database: replicatedConfig.database,
+                        host:     replicatedConfig.host,
+                        password: replicatedConfig.password,
+                        port:     replicatedConfig.port,
+                        username: replicatedConfig.username,
+                    },
+                    read: replicatedConfig.readers,
+                });
+            });
+        });
+
+
+        describe('settings (sqlite)', () => {
+            it ('maps sqlite options', () => {
+                const conn = new Connection('sqlite');
+
+                expect(conn._sequelize.options.dialect).toEqual('sqlite');
+                expect(conn._sequelize.options.storage).toEqual(
+                    `${process.cwd()}/config/db/database.test.sqlite`,
+                );
+            });
+        });
+    });
+
+
+    describe('Connection#close', () => {
+        it ('closes a single connection', () => {
+            const conn = new Connection();
+            conn._sequelize; // reference it to initiate the connection
+
+            conn.close();
+
+            expect(conn._sequelize.close).toHaveBeenCalledTimes(1);
+        });
+    });
+
+
+    describe('Connection.closeAll', () => {
+        it ('closes all cached connections', () => {
+            const defaultConnection   = new Connection();
+            const secondaryConnection = new Connection(Helpers.databaseId1);
+            defaultConnection._sequelize;   // reference it to initiate the connection
+            secondaryConnection._sequelize; // reference it to initiate the connection
+
+            Connection.closeAll();
+
+            expect(defaultConnection._sequelize.close).toHaveBeenCalledTimes(1);
+            expect(secondaryConnection._sequelize.close).toHaveBeenCalledTimes(1);
+        });
+    });
+});