@vida-global/core 1.1.0

package/lib/server/systemController.js

@@ -0,0 +1,23 @@
+const { VidaServerController } = require('./serverController');
+
+
+class SystemController extends VidaServerController {
+
+    getHealthCheck() {
+        this.render({});
+    }
+
+
+    getIndex() {
+        this.render('Hello World');
+    }
+
+
+    static get routes() {
+        return {getIndex: '/'};
+    }
+
+}
+
+
+module.exports = { SystemController };

package/package.json

@@ -0,0 +1,37 @@
+{
+    "name": "@vida-global/core",
+    "version": "1.1.0",
+    "description": "Core libraries for supporting Vida development",
+    "author": "",
+    "license": "ISC",
+    "main": "index.js",
+    "scripts": {
+        "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules node_modules/jest/bin/jest.js"
+    },
+    "jest": {
+        "collectCoverage": true,
+        "coveragePathIgnorePatterns": [
+            "/helpers/"
+        ],
+        "setupFilesAfterEnv": ["jest-extended/all"]
+    },
+    "dependencies": {
+        "commander": "^13.1.0",
+        "express": "^4.21.2",
+        "mustache-express": "^1.2.8",
+        "pg": "^8.16.3",
+        "pino": "^9.6.0",
+        "pino-http": "^10.4.0",
+        "pino-pretty": "^13.0.0",
+        "response-time": "^2.3.3",
+        "sequelize": "^6.37.7",
+        "sequelize-cli": "^6.6.3",
+        "socket.io": "^4.4.0"
+    },
+    "devDependencies": {
+        "jest": "^29.6.2",
+        "jest-express": "^1.12.0",
+        "jest-extended": "^7.0.0",
+        "@vida-global/test-helpers": "^1.0.1"
+    }
+}

package/scripts/active_record/migrate.js

@@ -0,0 +1,30 @@
+const   migration = require('../../lib/active_record/db/migration');
+const { Command } = require('commander');
+
+
+const program = new Command();
+program.name('Active Record Migration')
+       .description('A CLI for generating and running Active Record migrations')
+       .version('1.0.0');
+
+
+program.command('create_migration')
+       .argument('<Description>', 'Description of your migration')
+       .option('--databaseId <databaseId>', 'databaseId from db/config.js')
+       .action((migrationDescription, options) => {
+            migration.generateMigrationFile(migrationDescription, options.databaseId);
+       });
+
+
+program.command('migrate')
+       .action(async () => {
+            await migration.runMigrations();
+       });
+
+program.command('rollback')
+       .action(async () => {
+            await migration.rollbackMigration();
+       });
+
+
+program.parse();

package/scripts/release.js

@@ -0,0 +1,62 @@
+const Release   = require('../lib/release');
+const commander = require('commander');
+
+
+function validateIssueNumber(val) {
+    const issueNumber = parseInt(val, 10);
+    if (isNaN(issueNumber)) {
+        throw new commander.InvalidArgumentError('Invalid issue number');
+    }
+
+    return issueNumber;
+}
+
+
+function validateProjectType(val) {
+    const types = ['bugfix', 'chore', 'feature', 'hotfix', 'refactor'];
+    if (!types.includes(val)) {
+        throw new commander.InvalidArgumentError(`must be one of: ${types.join(', ')}`);
+    }
+    return val;
+}
+
+
+function validateVersionType(val) {
+    const types = ['major', 'minor', 'point'];
+    if (!types.includes(val)) {
+        throw new commander.InvalidArgumentError(`must be one of: ${types.join(', ')}`);
+    }
+    return val;
+}
+
+
+const program = new commander.Command();
+program.name('Vida Release')
+       .description('A CLI for generating vida releases')
+       .version('1.0.0');
+
+
+program.command('increment')
+       .argument('<type>', 'version number to increment', validateVersionType)
+       .action(async (type) => {
+          await Release.increment(type);
+       });
+
+
+program.command('production')
+       .argument('[version]', 'optional version release')
+       .action(async (version) => {
+            await Release.release('staging', version);
+       });
+
+
+program.command('develop')
+       .requiredOption('-i, --issue <issueNumber>', 'Must provide an issue number', validateIssueNumber)
+       .option('-t, --type [projectType]', 'Project type', validateProjectType, 'feature')
+       .option('-s, --source [sourceBranch]', 'Branch to copy')
+       .argument('<description...>', 'a description of your project')
+       .action(async (description, { issue, type, source }) => {
+            await Release.develop(type, issue, description.join(' '), source);
+       });
+
+program.parse();

package/test/active_record/baseRecord.test.js

@@ -0,0 +1,179 @@
+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   TestHelpers               = require('@vida-global/test-helpers');
+
+
+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);
+
+
+jest.mock('sequelize', () => {
+    class MockModel {
+        static init     = jest.fn()
+        static findByPk = jest.fn();
+        static findAll  = jest.fn();
+    }
+    const TestHelpers    = require('@vida-global/test-helpers');
+    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 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];
+
+
+jest.mock('../../lib/active_record/db/importSchema', () => jest.fn());
+importSchema.mockImplementation(() => ({created_at: {type: dataTypeValue1}, updated_at: {type: dataTypeValue2}}));
+
+
+afterEach(() => {
+    jest.clearAllMocks();
+});
+
+
+describe('ActiveRecord', () => {
+    describe('ActiveRecord#constructor', () => {
+        it ('will throw an error when creating an instance of BaseRecord', () => {
+            expect(() => new BaseRecord()).toThrow();
+        });
+    });
+
+
+    describe('ActiveRecord.initialize', () => {
+        it ('calls `getActiveRecordSchema` 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]}
+            };
+            expect(importSchema).toHaveBeenCalledTimes(1);
+            expect(Model.init).toHaveBeenCalledTimes(1);
+            expect(Model.init).toHaveBeenCalledWith(tableDetails,
+                                                    {
+                                                      createdAt: 'created_at',
+                                                      deletedAt: 'deleted_at',
+                                                      modelName: 'User',
+                                                      sequelize: mockSequelize,
+                                                      tableName: 'users',
+                                                      updatedAt: 'updated_at'
+                                                    });
+        });
+
+        it ('uses `timestamps: false` when the schema has no timestamps', () => {
+            importSchema.mockImplementation(() => ({}));
+            class User extends BaseRecord {}
+            User.initialize();
+            expect(Model.init).toHaveBeenCalledWith({},
+                                                    {
+                                                      createdAt: 'created_at',
+                                                      deletedAt: 'deleted_at',
+                                                      modelName: 'User',
+                                                      sequelize: mockSequelize,
+                                                      tableName: 'users',
+                                                      timestamps: false,
+                                                      updatedAt: 'updated_at'
+                                                    });
+        });
+
+        it ('does not run twice on the same model', () => {
+            class User extends BaseRecord {}
+            User.initialize();
+            User.initialize();
+            expect(Model.init).toHaveBeenCalledTimes(1);
+        });
+
+        it ('does run once per model', () => {
+            class User extends BaseRecord {}
+            class Team extends BaseRecord {}
+            User.initialize();
+            Team.initialize();
+            expect(Model.init).toHaveBeenCalledTimes(2);
+        });
+
+        it ('will throw an error when run on BaseRecord', () => {
+            expect(() => BaseRecord.initialize()).toThrow();
+        });
+    });
+
+
+    describe('ActiveRecord.tableName', () => {
+        it ('defaults to the puralized version of the class name', () => {
+            class User extends BaseRecord {}
+            expect(User._tableName).toEqual('users');
+        });
+
+        it ('handles atypical pluralizations', () => {
+            class Person extends BaseRecord {}
+            expect(Person._tableName).toEqual('people');
+        });
+
+        it ('converts to snake case', () => {
+            class BigDog extends BaseRecord {}
+            expect(BigDog._tableName).toEqual('big_dogs');
+        });
+
+        it ('can be overridden', () => {
+            class User extends BaseRecord {
+                static _tableName = 'foo';
+            }
+            expect(User._tableName).toEqual('foo');
+        });
+    });
+
+
+    describe('ActiveRecord#find', () => {
+        it ('calls the sequelize `findByPk` method', async () => {
+            class Person extends BaseRecord {}
+            Person.initialize();
+            const id          = Math.random();
+            await Person.find(id);
+            expect(Person.findByPk).toHaveBeenCalledTimes(1);
+            expect(Person.findByPk).toHaveBeenCalledWith(id);
+        });
+    });
+
+
+    describe('ActiveRecord#where', () => {
+        const column    = TestHelpers.Faker.Text.randomString();
+        const value     = TestHelpers.Faker.Text.randomString();
+        const condition = {[column]: value};
+        class Person extends BaseRecord {}
+        Person.initialize();
+
+        it ('calls findAll with the provided condition', async () => {
+            await Person.where(condition);
+            expect(Person.findAll).toHaveBeenCalledWith({where: condition});
+        });
+
+        it ('passes additional options', async () => {
+            const option1 = TestHelpers.Faker.Text.randomString();
+            const option2 = TestHelpers.Faker.Text.randomString();
+            const value1 = TestHelpers.Faker.Text.randomString();
+            const value2 = TestHelpers.Faker.Text.randomString();
+            const options = {[option1]: value1, [option2]: value2};
+
+            await Person.where(condition, options);
+            const expected = {...options, where: condition };
+            expect(Person.findAll).toHaveBeenCalledWith(expected);
+        });
+    });
+});

package/test/active_record/db/connection.test.js

@@ -0,0 +1,221 @@
+const { Connection }              = require('../../../lib/active_record/db/connection');
+const { ConnectionConfiguration } = require('../../../lib/active_record/db/connectionConfiguration');
+const   TestHelpers               = require('@vida-global/test-helpers');
+
+
+jest.mock('sequelize', () => {
+    class MockSequelize {
+        constructor(_1, _2, _3, options) {
+            this.options = options;
+        }
+
+        transaction = jest.fn(callback => callback())
+        close       = jest.fn();
+    }
+    return {Sequelize: MockSequelize};
+});
+
+
+let spy;
+const origEnv = process.env.NODE_ENV;
+afterEach(() => {
+    if (spy) spy.mockRestore();
+    spy = null;
+    Connection.clearConnectionsCache();
+    process.env.NODE_ENV = origEnv;
+});
+
+
+const config1 = {
+    database: TestHelpers.Faker.Text.randomString(),
+    host:     TestHelpers.Faker.Text.randomString(),
+    password: TestHelpers.Faker.Text.randomString(),
+    port:     Math.random(),
+    username: TestHelpers.Faker.Text.randomString(),
+    pool:     {
+        min: Math.random(),
+        max: Math.random(),
+    }
+}
+
+const config2 = {
+    database: TestHelpers.Faker.Text.randomString(),
+    host:     TestHelpers.Faker.Text.randomString(),
+    password: TestHelpers.Faker.Text.randomString(),
+    port:     Math.random(),
+    username: TestHelpers.Faker.Text.randomString()
+}
+
+const config3 = {
+    database: TestHelpers.Faker.Text.randomString(),
+    host:     TestHelpers.Faker.Text.randomString(),
+    password: TestHelpers.Faker.Text.randomString(),
+    port:     Math.random(),
+    ssl:      true,
+    username: TestHelpers.Faker.Text.randomString()
+}
+
+const sqliteConfig = {
+    dialect: 'sqlite'
+};
+
+const databaseId1 = TestHelpers.Faker.Text.randomString();
+const databaseId2 = TestHelpers.Faker.Text.randomString();
+
+
+describe('Connection', () => {
+    beforeEach(() => {
+        spy = jest.spyOn(ConnectionConfiguration, '_fetchAllConfigs');
+        spy.mockImplementation(() => ({
+            default:       {test: config1, development: config1, production: config1},
+            [databaseId1]: {test: config2, production: {}},
+            [databaseId2]: {test: config3, production: {}},
+            sqlite:        {test: sqliteConfig}
+        }));
+    });
+
+    describe('Connection#_sequelize', () => {
+        it ('caches the connection to the same database', () => {
+            const conn1 = new Connection();
+            const conn2 = new Connection();
+            expect(conn1._sequelize).toBe(conn2._sequelize);
+        });
+
+        it ('does not cache connections to different databases', () => {
+            const conn1 = new Connection();
+            const conn2 = new Connection(databaseId1);
+            expect(conn1._sequelize).not.toBe(conn2._sequelize);
+        });
+
+        describe('settings (postgres)', () => {
+            it ('sets the connection settings to the correct values', () => {
+                const conn1 = new Connection();
+                expect(conn1._sequelize.options.database).toEqual(config1.database);
+                expect(conn1._sequelize.options.dialect).toEqual('postgres');
+                expect(conn1._sequelize.options.host).toEqual(config1.host);
+                expect(conn1._sequelize.options.password).toEqual(config1.password);
+                expect(conn1._sequelize.options.port).toEqual(config1.port);
+                expect(conn1._sequelize.options.username).toEqual(config1.username);
+
+                const conn2 = new Connection(databaseId1);
+                expect(conn2._sequelize.options.database).toEqual(config2.database);
+                expect(conn2._sequelize.options.dialect).toEqual('postgres');
+                expect(conn2._sequelize.options.host).toEqual(config2.host);
+                expect(conn2._sequelize.options.password).toEqual(config2.password);
+                expect(conn2._sequelize.options.port).toEqual(config2.port);
+                expect(conn2._sequelize.options.username).toEqual(config2.username);
+            });
+
+            it ('requires ssl when the configuration says to', () => {
+                const conn = new Connection(databaseId2);
+                expect(conn._sequelize.options.dialectOptions).toEqual({ssl: {require: true}});
+            });
+
+            it ('enables logging in development', () => {
+                process.env.NODE_ENV = 'development';
+                const conn = new Connection();
+                expect(conn._sequelize.options.logging).toBe(undefined); // undefined defaults to true
+            });
+
+            it ('does not enable logging in production', () => {
+                process.env.NODE_ENV = 'production';
+                const conn = new Connection();
+                expect(conn._sequelize.options.logging).toBeFalsy();
+            });
+
+            it ('sets the connection pool to the configured values', () => {
+                const conn1 = new Connection();
+                expect(conn1._sequelize.options.pool).toEqual(config1.pool);
+
+                const conn2 = new Connection(databaseId1);
+                expect(conn2._sequelize.options.pool).toEqual({min: 0, max: 5})
+            });
+
+            it ('configures the connection to use underscores for columns', () => {
+                const conn = new Connection();
+                expect(conn._sequelize.options.define.underscored).toBeTruthy();
+            });
+
+
+            describe('replication', () => {
+                it ('configures a read and writer when replicas are configured', () => {
+                    const config = {
+                        database: TestHelpers.Faker.Text.randomString(),
+                        host:     TestHelpers.Faker.Text.randomString(),
+                        password: TestHelpers.Faker.Text.randomString(),
+                        port:     Math.random(),
+                        username: TestHelpers.Faker.Text.randomString(),
+                        readers: [
+                            {
+                                database: TestHelpers.Faker.Text.randomString(),
+                                host:     TestHelpers.Faker.Text.randomString(),
+                                password: TestHelpers.Faker.Text.randomString(),
+                                port:     Math.random(),
+                                username: TestHelpers.Faker.Text.randomString(),
+                            },
+                            {
+                                database: TestHelpers.Faker.Text.randomString(),
+                                host:     TestHelpers.Faker.Text.randomString(),
+                                password: TestHelpers.Faker.Text.randomString(),
+                                port:     Math.random(),
+                                username: TestHelpers.Faker.Text.randomString(),
+                            },
+                        ]
+                    }
+                    spy.mockImplementation(() => ({default: {test: config }}));
+                    const conn    = new Connection();
+                    const options = conn._sequelize.options;
+                    expect(options.database).toBe(undefined);
+                    expect(options.dialect).toBe('postgres');
+                    expect(options.host).toBe(undefined);
+                    expect(options.password).toBe(undefined);
+                    expect(options.port).toBe(undefined);
+                    expect(options.username).toBe(undefined);
+
+                    expect(options.replication).toEqual({
+                        write: {
+                            database: config.database,
+                            host:     config.host,
+                            password: config.password,
+                            port:     config.port,
+                            username: config.username,
+                        },
+                        read: config.readers
+                    });
+                });
+            });
+        });
+
+
+        describe('settings (sqlite)', () => {
+            it ('sets the connection settings to the correct values for sqlite', () => {
+                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 ('calls close on the underlying sequelize 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 ('calls close on all cached connections', () => {
+            const conn1 = new Connection();
+            const conn2 = new Connection(databaseId1);
+            conn1._sequelize // reference it to initiate the connection
+            conn2._sequelize // reference it to initiate the connection
+            Connection.closeAll();
+            expect(conn1._sequelize.close).toHaveBeenCalledTimes(1);
+            expect(conn2._sequelize.close).toHaveBeenCalledTimes(1);
+        });
+    });
+});