@vida-global/core 1.1.0

package/lib/active_record/db/migration.js

@@ -0,0 +1,132 @@
+const { Connection }                      = require('./connection');
+const   fs                                = require('node:fs');
+const { generateActiveRecordSchemaFiles } = require('./schema');
+const { logger }                          = require('../../logger');
+const { Migrator }                        = require('./migrator');
+const   utils                             = require('../utils');
+const versioning                          = require('./migrationVersion');
+
+
+/***********************************************************************************************
+* MIGRATION UP
+***********************************************************************************************/
+async function runMigrations() {
+    const migrations = await migrationsToRun();
+    for (const migration of migrations) {
+        await runMigration(migration);
+    }
+
+    await generateActiveRecordSchemaFiles();
+
+    Connection.closeAll();
+}
+
+
+async function runMigration(migration) {
+    const migrationStr = migration.fileName.replace(/\.js$/, '');
+    logger.info(`Running migration ${migrationStr}`);
+
+    await Migrator.runMigration(migration);
+
+    await versioning.markVersionAsPerformed(migration);
+    logger.info(`Completed migration ${migrationStr}`);
+}
+
+
+async function migrationsToRun() {
+    const allMigrations   = getMigrations();
+    const migrationsToRun = [];
+
+    for (const migration of allMigrations) {
+        if (await versioning.migrationHasRun(migration)) continue;
+        migrationsToRun.push(migration);
+    }
+
+    return migrationsToRun;
+}
+
+
+/***********************************************************************************************
+* MIGRATION DOWN
+***********************************************************************************************/
+async function rollbackMigration() {
+    const migration = await migrationToRollback();
+    if (!migration) {
+        logger.info(`No migration to rollback`);
+    } else {
+        const migrationStr = migration.fileName.replace(/\.js$/, '');
+        logger.info(`Rolling back migration ${migrationStr}`);
+
+        await Migrator.rollbackMigration(migration);
+
+        await versioning.markVersionAsNotPerformed(migration);
+        logger.info(`Rolled back migration ${migrationStr}`);
+    }
+
+    await generateActiveRecordSchemaFiles();
+
+    Connection.closeAll();
+}
+
+
+async function migrationToRollback() {
+    const allMigrations   = getMigrations().reverse();
+
+    for (const migration of allMigrations) {
+        if (await versioning.migrationHasRun(migration)) return migration;
+    }
+
+    return null;
+}
+
+
+/***********************************************************************************************
+* MIGRATION CREATION
+***********************************************************************************************/
+function generateMigrationFile(description, databaseId) {
+    utils.ensureMigrationsDirectory();
+
+    description    = utils.toCamelCase(description);
+    const fileName = fileNameForMigration(description, databaseId);
+    const filePath = `${utils.migrationsDirectory}/${fileName}`;   
+    const template = require('./migrationTemplate');
+    fs.writeFile(filePath, template, err => {
+        if (err) {
+            logger.error(`Unable to write new migration file to ${filePath}`);
+        } else {
+            logger.info(`New migration file written to ${filePath}`); 
+        }
+    });
+}
+
+
+function fileNameForMigration(description, databaseId) {
+    const name     = `${description}_${new Date().getTime()}`;
+    const dbSuffix = databaseId ? `.${databaseId}` : '';
+    return `${name}${dbSuffix}.js`;
+}
+
+
+/***********************************************************************************************
+* UTILS
+***********************************************************************************************/
+function getMigrations() {
+    const files = fs.readdirSync(utils.migrationsDirectory);
+    const migrations = files.map(f => {
+        const m = f.match(/_(?<version>\d+)(\.(?<databaseId>\w+))?\.js$/);
+        if (!m) return;
+        return {fileName: f, databaseId: m.groups.databaseId, version: m.groups.version};
+    });
+
+    return migrations.filter(item => item)
+                      .sort((m1, m2) => {
+                          return parseInt(m1.version) - parseInt(m2.version);
+                      });
+}
+
+
+module.exports = {
+    generateMigrationFile,
+    rollbackMigration,
+    runMigrations
+}

package/lib/active_record/db/migrationTemplate.js

@@ -0,0 +1,8 @@
+module.exports = `module.exports = {
+    up: async function() {
+    },
+
+    down: async function () {
+    }
+}`;
+

package/lib/active_record/db/migrationVersion.js

@@ -0,0 +1,68 @@
+const { Connection } = require('./connection');
+const { DataTypes }  = require('sequelize');
+
+
+const performedVersions = {};
+const models      = {};
+
+
+async function migrationHasRun({ version, databaseId }) {
+    const performedVersions = await performedVersionsForDatabase(databaseId);
+    return performedVersions.has(version)
+}
+
+
+async function markVersionAsPerformed({ version, databaseId }) {
+    const model = await versionModelForDatabase(databaseId);
+    await model.create({ version });
+}
+
+
+async function markVersionAsNotPerformed({ version, databaseId }) {
+    const model = await versionModelForDatabase(databaseId);
+    await model.destroy({where: { version }});
+}
+
+
+async function performedVersionsForDatabase(databaseId) {
+    if (performedVersions[databaseId]) return performedVersions[databaseId];
+
+    const model                   = await versionModelForDatabase(databaseId);
+    const records                 = await model.findAll()
+    const versions                = new Set(records.map(({ version }) => version));
+    performedVersions[databaseId] = versions;
+
+    return performedVersions[databaseId];
+}
+
+
+async function versionModelForDatabase(databaseId) {
+    if (models[databaseId]) return models[databaseId];
+
+    const model        = createVersionModelForDatabase(databaseId);
+    models[databaseId] = model;
+    await model.sync();
+
+    return model;
+};
+
+
+function createVersionModelForDatabase(databaseId) {
+    const connection = new Connection(databaseId);
+    return connection._sequelize.define('MigrationVersion', {
+        version: {
+            type:       DataTypes.STRING,
+            primaryKey: true
+        }
+
+    }, {
+        tableName: 'migration_versions'
+    });
+}
+
+
+module.exports = {
+    markVersionAsNotPerformed,
+    markVersionAsPerformed,
+    migrationHasRun
+};

package/lib/active_record/db/migrator.js

@@ -0,0 +1,169 @@
+const { Connection }    = require('./connection');
+const   utils           = require('../utils');
+const { Sequelize, Op } = require('sequelize');
+const { underscore }    = require('inflection');
+
+
+class Migrator {
+    #connection;
+    #fileName;
+    #migrationModule;
+
+    DataTypes = Sequelize.DataTypes;
+    Operators = Op;
+
+
+    constructor(fileName, databaseId) {
+        this.#connection = new Connection(databaseId);
+        this.#fileName   = fileName;
+    }
+
+
+    async run() {
+        if (!this.migrationModule.up) throw new Error('Missing migration `up`');
+
+        const migrator = this;
+        await this.#connection.queryInterface.transaction(async () => {
+            await migrator.migrationModule.up.call(migrator);
+        });
+    }
+
+
+    async rollback() {
+        if (!this.migrationModule.down) return;
+
+        const migrator = this;
+        await this.#connection.queryInterface.transaction(async () => {
+            await migrator.migrationModule.down.call(migrator);
+        });
+    }
+
+
+    static async runMigration({ fileName, databaseId }) {
+        await (new Migrator(fileName, databaseId).run());
+    }
+
+
+    static async rollbackMigration({ fileName, databaseId }) {
+        await (new Migrator(fileName, databaseId).rollback());
+    }
+
+
+    get migrationModule() {
+        if (!this.#migrationModule) {
+            this.#migrationModule = this.importMigrationModule();
+        }
+
+        return {...this.#migrationModule};
+    }
+
+
+    importMigrationModule() {
+        const filePath = `${utils.migrationsDirectory}/${this.#fileName}`;
+        return require(filePath);
+    }
+
+
+    /***********************************************************************************************
+    * MIGRATION ACTIONS
+    ***********************************************************************************************/
+    async createTable(tableName, details, options={}) {
+        details = {...this.defaultIdColumn, ...details};
+        if (options.timestamps !== false) {
+            details = {...details, ...this.defaultTimestampColumns};
+        }
+
+        details = this.normalizeTableDetails(details);
+        await this.#sequelizeQueryInterface.createTable(tableName, details);
+    }
+
+
+    normalizeTableDetails(details) {
+        const normalized = {};
+
+        for (const [colName, colDetails] of Object.entries(details)) {
+            const snakedColName = underscore(colName);
+            normalized[snakedColName] = colDetails;
+        }
+
+        return normalized;
+    }
+
+
+    get defaultIdColumn() {
+        return {
+          id: {
+            allowNull:     false,
+            autoIncrement: true,
+            primaryKey:    true,
+            type:          this.DataTypes.INTEGER, }
+        };
+    }
+
+
+    get defaultTimestampColumns() {
+        return {
+            created_at: {
+                allowNull: false,
+                type: this.DataTypes.DATE },
+            updated_at: {
+                allowNull: false,
+                type: this.DataTypes.DATE }
+        };
+    }
+
+
+    async dropTable(tableName) {
+        await this.#sequelizeQueryInterface.dropTable(tableName);
+    }
+
+
+    async addColumn(tableName, columnName, columnDetails) {
+        await this.#sequelizeQueryInterface.addColumn(tableName, columnName, columnDetails);
+    }
+
+
+    async removeColumn(tableName, columnName) {
+        await this.#sequelizeQueryInterface.removeColumn(tableName, columnName);
+    }
+
+
+    async addIndex(tableName, fields, { concurrently, unique, name, where }) {
+        const options = {fields: fields};
+        if (concurrently) options.concurrently = true;
+        if (unique)       options.unique       = true;
+        if (name)         options.name         = name;
+        if (where)        options.where        = where;
+
+        await this.#sequelizeQueryInterface.addIndex(tableName, options);
+    }
+
+
+    async removeIndex(tableName, indexNameOrAttributes, concurrently=false) {
+        const options = {};
+        if (concurrently) options.concurrently = true;
+        await this.#sequelizeQueryInterface.removeIndex(tableName, indexNameOrAttributes, options);
+    }
+
+
+    async renameColumn(tableName, oldName, newName) {
+        newName = underscore(newName);
+        await this.#sequelizeQueryInterface.renameColumn(tableName, oldName, newName);
+    }
+
+
+    async changeColumn(tableName, columnName, dataTypeOrOptions) {
+        await this.#sequelizeQueryInterface.changeColumn(tableName, columnName, dataTypeOrOptions);
+    }
+
+
+    get #sequelizeQueryInterface() {
+        return this.#connection._sequelize.getQueryInterface();
+    }
+}
+
+
+
+module.exports = {
+    Migrator
+};

package/lib/active_record/db/queryInterface.js

@@ -0,0 +1,47 @@
+const { Op }  = require('sequelize');
+
+class QueryInterface {
+    #connection;
+
+    Operators = Op;
+
+    constructor(connection) {
+        this.#connection = connection;
+    }
+
+
+    async allTables() {
+        const queryInterface = this.#sequelizeQueryInterface;
+        const tableNames     = await queryInterface.showAllTables()
+        const tables         = {};
+
+        for (const tableName of tableNames) {
+            const table      = await (queryInterface.describeTable(tableName));
+            tables[tableName] = table;
+        }
+
+        return tables;
+    }
+
+
+    async transaction(callback) {
+        await this.#sequelize.transaction(callback); 
+    }
+
+
+
+    get #sequelizeQueryInterface() {
+        return this.#sequelize.getQueryInterface();
+    }
+
+
+    get #sequelize() {
+        return this.#connection._sequelize;
+    }
+
+}
+
+
+module.exports = {
+    QueryInterface
+}

package/lib/active_record/db/schema.js

@@ -0,0 +1,113 @@
+const { Connection }              = require('./connection');
+const { ConnectionConfiguration } = require('./connectionConfiguration');
+const   fs                        = require('node:fs');
+const   importSchema              = require('./importSchema');
+const { logger }                  = require('../../logger');
+const { Sequelize }               = require('sequelize');
+const   utils                     = require('../utils');
+
+async function generateActiveRecordSchemaFiles() {
+    utils.ensureSchemasDirectory();
+
+    const databaseIds = ConnectionConfiguration.configuredDatabaseIds();
+    for (const databaseId of databaseIds) {
+        await generateSchemaFilesForDatabase(databaseId);
+    }
+};
+
+
+async function generateSchemaFilesForDatabase(databaseId) {
+    Connection.clearConnectionsCache();
+    const connection     = new Connection(databaseId, {loggingEnabled: false});
+    const queryInterface = connection.queryInterface;
+    const tables         = await queryInterface.allTables();
+
+    const filePath = filePathForSchemaFile(databaseId);
+    const schemas  = `module.exports = ${JSON.stringify(tables, null, 4)};`;
+
+    fs.writeFile(filePath, schemas, err => {
+        if (err) {
+            logger.error(`Unable to write new schema file to ${filePath}`);
+        } else {
+            logger.info(`New schemas file written to ${filePath}`); 
+        }
+    });
+}
+
+
+function getActiveRecordSchema(tableName, databaseId, dialect) {
+    const filePath = filePathForSchemaFile(databaseId);
+    const schema   = importSchema(filePath, tableName);
+    if (!schema) throw new Error(`No schema found for table ${databaseId}.${tableName}`);
+
+    cleanSchema(schema, dialect);
+
+    return schema;
+}
+
+
+function cleanSchema(schema, dialect) {
+    for (const [col, details] of Object.entries(schema)) {
+        const dataType = dataTypeForColumn(details, dialect);
+        if (dataType) details.type = dataType;
+        resolveAutoIncrementColumns(details);
+        resolveUUIDColumns(details);
+    }
+}
+
+function resolveAutoIncrementColumns(details) {
+    if (!details.defaultValue) return;
+
+    const regExp = /^nextval\(\w+_seq::regclass\)$/;
+    if (details.defaultValue.match(regExp)) {
+        delete details.defaultValue;
+        delete details.allowNull;
+        details.autoIncrement = true;
+    }
+}
+
+
+function dataTypeForColumn(details, dialect) {
+    const typeStr         = details.type.replace(/\(.*\)/, '').toUpperCase();
+
+    const typesForDialect = Object.values(Sequelize.DataTypes).filter(val => val.types && val.types[dialect]);
+    for (const dataType of typesForDialect) {
+        if (dataType.key == typeStr) return dataType;
+        let typeStrs            = dataType.types[dialect];
+        if (!typeStrs) typeStrs = [];
+        if (!Array.isArray(typeStrs)) {
+            typeStrs = Object.values(typeStrs).map(map => Object.values(map)).flat();
+        }
+        typeStrs = typeStrs.filter(Boolean);
+        typeStrs = typeStrs.map(aTypeStr => aTypeStr.toUpperCase());
+        if (typeStrs.includes(typeStr)) return Sequelize.DataTypes[dataType.key];
+    }
+
+    const typesByDialect  = Object.values(Sequelize.DataTypes[dialect]);
+    for (const dataType of typesByDialect) {
+        if (dataType.key == typeStr) return dataType;
+        try {
+            const aTypeStr = dataType.prototype.toSql().replace(/\(.*\)/, '').toUpperCase();
+            if (aTypeStr == typeStr) return Sequelize.DataTypes[dataType.key];
+        } catch(err) {}
+    }
+
+    if (typeStr.includes('CHAR')) return Sequelize.DataTypes.STRING;
+}
+
+
+function resolveUUIDColumns(details) {
+    if (details.type != 'UUID' || !details.primaryKey) return;
+    details.defaultValue = Sequelize.UUIDV4;
+}
+
+
+function filePathForSchemaFile(databaseId) {
+    return `${utils.schemasDirectory}/${databaseId}.js`;
+}
+
+
+module.exports = {
+    generateActiveRecordSchemaFiles,
+    getActiveRecordSchema
+};

package/lib/active_record/index.js

@@ -0,0 +1,6 @@
+const { BaseRecord } = require('./baseRecord');
+
+
+module.exports = {
+    BaseRecord,
+}

package/lib/active_record/utils.js

@@ -0,0 +1,43 @@
+const fs = require('node:fs');
+
+
+const configDirectory     = `${process.cwd()}/config/db`;
+const migrationsDirectory = `${configDirectory}/migrations`;
+const schemasDirectory    = `${configDirectory}/schemas`;
+
+
+function ensureConfigDirectory() {
+    fs.mkdirSync(configDirectory, { recursive: true });
+}
+
+
+function ensureMigrationsDirectory() {
+    fs.mkdirSync(migrationsDirectory, { recursive: true });
+}
+
+
+function ensureSchemasDirectory() {
+    fs.mkdirSync(schemasDirectory, { recursive: true });
+}
+
+
+function toCamelCase(str) {
+    return str.split(/[-_\s]/).map((word, index) => {
+        if (index === 0) return word.toLowerCase();
+        return (
+            word.charAt(0).toUpperCase() +
+            word.slice(1).toLowerCase()
+        );
+    }).join("");
+}
+
+
+module.exports = {
+    configDirectory,
+    ensureConfigDirectory,
+    ensureMigrationsDirectory,
+    ensureSchemasDirectory,
+    migrationsDirectory,
+    schemasDirectory,
+    toCamelCase
+}

package/lib/http/README.md

@@ -0,0 +1,32 @@
+# HttpClient
+The `HttpClient` is a generic client for making HTTP requests. It can be used on its own, but is best suited for creating subclasses intended for specific APIs. By overriding the `urlRoot` and `defaultHeaders` methods, an API client can be made that reduces duplicated code.
+```
+class MyApiClient extends HttpClient {
+    constructor({dev, token}) {
+        this.#token = token;
+        this.#dev   = dev;
+    }
+
+    get defaultHeaders() {
+        const headers = super.defaultHeaders;
+        headers.Authorization = `Bearer ${this.#token}`;
+        return headers;
+    }
+
+    get urlRoot() {
+        if (this.#dev) {
+            return "https://staging.foo.com";
+        } else {
+            return "https://foo.com";
+        }
+    }
+}
+
+const client = new MyApiClient(true, '123abctoken');
+const requestParameters = {baz: 1, ban: 2};
+const response = await client.get("/foo/bar", {requestParameters});
+
+const requestBody = {baz: 1, ban: 2};
+const response = await client.post("/foo/bar", {requestBody});
+```
+