@vida-global/core 2.0.6 → 2.0.8

package/lib/activeRecord/baseRecord.js

@@ -142,9 +142,19 @@ class BaseRecord extends Model {
     /***********************************************************************************************
     * DB CONNECTION
     ***********************************************************************************************/
+    static get connectionClass() {
+        return Connection;
+    }
+
+
+    static buildConnection() {
+        return new this.connectionClass(this.databaseId);
+    }
+
+
     static get connection() {
         if (!this._connection) {
-            this._connection = new Connection(this.constructor.databaseId);
+            this._connection = this.buildConnection();
         }
         return this._connection;
     }
@@ -297,8 +307,13 @@ class BaseRecord extends Model {
     }
 
 
+    static get redisClientFactory() {
+        return redisClientFactory;
+    }
+
+
     static async _getRedisClient() {
-      const client = redisClientFactory();
+      const client = this.redisClientFactory();
       await client.connect();
       return client;
     }

package/lib/activeRecord/db/connection.js

@@ -13,9 +13,34 @@ class Connection {
     #options;
 
     constructor(databaseId, options={}) {
-        this.#databaseId    = databaseId || DEFAULT_DATABASE_ID;
-        this.#configuration = new ConnectionConfiguration(this.#databaseId);
-        this.#options       = options;
+        this.#databaseId = databaseId || DEFAULT_DATABASE_ID;
+        this.#options    = options;
+    }
+
+
+    /***********************************************************************************************
+    * COLLABORATOR SEAMS
+    ***********************************************************************************************/
+    get ormEngineClass() {
+        return Sequelize;
+    }
+
+
+    get configurationClass() {
+        return ConnectionConfiguration;
+    }
+
+
+    get queryInterfaceClass() {
+        return QueryInterface;
+    }
+
+
+    get configuration() {
+        if (!this.#configuration) {
+            this.#configuration = new this.configurationClass(this.#databaseId);
+        }
+        return this.#configuration;
     }
 
 
@@ -38,14 +63,14 @@ class Connection {
 
 
     get queryInterface() {
-        return new QueryInterface(this);
+        return new this.queryInterfaceClass(this);
     }
 
 
     get _sequelize() {
         if (sequelizeConnectionsCache[this.#databaseId]) return sequelizeConnectionsCache[this.#databaseId];
 
-        const connection = new Sequelize(null, null, null, this.sequelizeOptions);
+        const connection = new this.ormEngineClass(null, null, null, this.sequelizeOptions);
         sequelizeConnectionsCache[this.#databaseId] = connection;
 
         return connection;
@@ -76,34 +101,34 @@ class Connection {
 
     get postgresSequelizeOptions() {
         const options = {
-            pool: this.#configuration.pool,
+            pool: this.configuration.pool,
         };
 
         const primaryConfig = {
-            database: this.#configuration.database,
-            host:     this.#configuration.host,
-            password: this.#configuration.password,
-            port:     this.#configuration.port,
-            username: this.#configuration.username
+            database: this.configuration.database,
+            host:     this.configuration.host,
+            password: this.configuration.password,
+            port:     this.configuration.port,
+            username: this.configuration.username
         };
 
-        if (this.#configuration.readers.length) {
+        if (this.configuration.readers.length) {
             options.replication = {
                 write: primaryConfig,
-                read: this.#configuration.readers
+                read: this.configuration.readers
             }
         } else {
             Object.assign(options, primaryConfig);
         }
 
-        if (this.#configuration.ssl) options.dialectOptions = {ssl: {require: true}};
+        if (this.configuration.ssl) options.dialectOptions = {ssl: {require: true}};
         return options;
     }
 
 
     get sqliteSequelizeOptions() {
         return {
-            storage: this.#configuration.storage
+            storage: this.configuration.storage
         };
     }
 
@@ -112,12 +137,12 @@ class Connection {
         if (this.#options.hasOwnProperty('loggingEnabled')) {
             return this.#options.loggingEnabled;
         }
-        return this.#configuration.loggingEnabled;
+        return this.configuration.loggingEnabled;
     }
 
 
     get dialect() {
-        return this.#configuration.dialect;
+        return this.configuration.dialect;
     }
 }
 

package/lib/activeRecord/db/schema.js

@@ -6,35 +6,65 @@ const { logger }                  = require('../../logger');
 const { Sequelize }               = require('sequelize');
 const   utils                     = require('../utils');
 
-async function generateActiveRecordSchemaFiles() {
-    utils.ensureSchemasDirectory();
+class SchemaFileGenerator {
+    get connectionClass() {
+        return Connection;
+    }
+
 
-    const databaseIds = ConnectionConfiguration.configuredDatabaseIds();
-    for (const databaseId of databaseIds) {
-        await generateSchemaFilesForDatabase(databaseId);
+    get databaseIds() {
+        return ConnectionConfiguration.configuredDatabaseIds();
     }
-};
 
 
-async function generateSchemaFilesForDatabase(databaseId) {
-    Connection.clearConnectionsCache();
-    const connection     = new Connection(databaseId, {loggingEnabled: false});
-    const queryInterface = connection.queryInterface;
-    const tables         = await queryInterface.allTables();
+    async run() {
+        utils.ensureSchemasDirectory();
+        for (const databaseId of this.databaseIds) {
+            await this.generateForDatabase(databaseId);
+        }
+    }
+
+
+    buildConnection(databaseId) {
+        return new this.connectionClass(databaseId, {loggingEnabled: false});
+    }
+
 
-    const filePath = filePathForSchemaFile(databaseId);
-    const schemas  = `module.exports = ${JSON.stringify(tables, null, 4)};`;
+    async generateForDatabase(databaseId) {
+        this.connectionClass.clearConnectionsCache();
+        const tables = await this.fetchTables(databaseId);
+        this.writeSchemaFile(databaseId, tables);
+    }
 
-    fs.writeFile(filePath, schemas, err => {
+
+    async fetchTables(databaseId) {
+        const connection = this.buildConnection(databaseId);
+        return await connection.queryInterface.allTables();
+    }
+
+
+    writeSchemaFile(databaseId, tables) {
+        const filePath = filePathForSchemaFile(databaseId);
+        const schemas  = `module.exports = ${JSON.stringify(tables, null, 4)};`;
+        fs.writeFile(filePath, schemas, err => this.handleWriteResult(err, filePath));
+    }
+
+
+    handleWriteResult(err, filePath) {
         if (err) {
             logger.error(`Unable to write new schema file to ${filePath}`);
         } else {
-            logger.info(`New schemas file written to ${filePath}`); 
+            logger.info(`New schemas file written to ${filePath}`);
         }
-    });
+    }
 }
 
 
+async function generateActiveRecordSchemaFiles() {
+    await new SchemaFileGenerator().run();
+};
+
+
 function getActiveRecordSchema(tableName, databaseId, dialect) {
     const filePath = filePathForSchemaFile(databaseId);
     const schema   = importSchema(filePath, tableName);
@@ -108,6 +138,7 @@ function filePathForSchemaFile(databaseId) {
 
 
 module.exports = {
+    SchemaFileGenerator,
     generateActiveRecordSchemaFiles,
     getActiveRecordSchema
 };

package/lib/jobQueue/abstractJob.js

@@ -20,8 +20,13 @@ class AbstractJob {
     }
 
 
+    static get queueResolver() {
+        return getQueue;
+    }
+
+
     static queue(...jobArgs) {
-        return getQueue(this.queueName(...jobArgs));
+        return this.queueResolver(this.queueName(...jobArgs));
     }
 
 
@@ -43,8 +48,18 @@ class AbstractJob {
     }
 
 
+    get loggerLibrary() {
+        return logger;
+    }
+
+
+    get apm() {
+        return APM;
+    }
+
+
     get logger() {
-        return logger[this.constructor.name].child(this.id);
+        return this.loggerLibrary[this.constructor.name].child(this.id);
     }
 
 
@@ -57,12 +72,12 @@ class AbstractJob {
     * APM
     ***********************************************************************************************/
     addApmAttribute(key, value) {
-        APM.addCustomAttribute(key, value);
+        this.apm.addCustomAttribute(key, value);
     }
 
 
     startApmSegment(name, record, handler) {
-        return APM.startSegment(name, record, handler);
+        return this.apm.startSegment(name, record, handler);
     }
 
 

package/lib/jobQueue/queue.js

@@ -18,12 +18,15 @@ class Queue extends AbstractJobComponent {
     }
 
 
-    get queueName() { return this.#queueName   }
-    get logger()    { return logger.queue.child(this.fullQueueName) }
+    get queueName()     { return this.#queueName   }
+    get loggerLibrary() { return logger }
+    get logger()        { return this.loggerLibrary.queue.child(this.fullQueueName) }
+    get queueClass()    { return BullMQ.Queue }
+    get idGenerator()   { return randomUUID }
 
 
     async queueJob(job, args, settings) {
-        const id = randomUUID();
+        const id = this.idGenerator();
         await this.#queue.add(job.name, { id, args }, settings);
     }
 
@@ -34,7 +37,7 @@ class Queue extends AbstractJobComponent {
     get #queue() {
         if (this.#_queue) return this.#_queue;
 
-        this.#_queue            = new BullMQ.Queue(this.fullQueueName, this.queueOptions);
+        this.#_queue            = new this.queueClass(this.fullQueueName, this.queueOptions);
         this.#_queue.on('error', this.#handleError.bind(this));
 
         return this.#_queue
@@ -157,5 +160,6 @@ function getQueue(name) {
 
 
 module.exports = {
+    Queue,
     getQueue
 }

package/lib/jobQueue/worker.js

@@ -54,8 +54,18 @@ class Worker extends AbstractJobComponent {
     }
 
 
+    get loggerLibrary() {
+        return logger;
+    }
+
+
+    get apm() {
+        return APM;
+    }
+
+
     get logger() {
-        return logger.worker;
+        return this.loggerLibrary.worker;
     }
 
 
@@ -67,12 +77,17 @@ class Worker extends AbstractJobComponent {
     /***********************************************************************************************
     * WORKER SETUP
     ***********************************************************************************************/
+    get workerClass() {
+        return BullMQ.Worker;
+    }
+
+
     get #worker() {
         if (this.#_worker) return this.#_worker;
 
-        this.#_worker = new BullMQ.Worker(this.fullQueueName,
-                                          this.processJob.bind(this),
-                                          this.workerOptions);
+        this.#_worker = new this.workerClass(this.fullQueueName,
+                                             this.processJob.bind(this),
+                                             this.workerOptions);
         this.#setupEventHandling();
 
         return this.#_worker;
@@ -108,9 +123,9 @@ class Worker extends AbstractJobComponent {
         if (!jobClass) throw `Unknown Job: ${bullJob.name}`;
 
         const context = this.#buildJobContext(bullJob, jobClass);
-        return await APM.startBackgroundTransaction(context.jobName,
-                                                    this.fullQueueName,
-                                                    () => this.#runJob(context));
+        return await this.apm.startBackgroundTransaction(context.jobName,
+                                                         this.fullQueueName,
+                                                         () => this.#runJob(context));
     }
 
 
@@ -149,25 +164,25 @@ class Worker extends AbstractJobComponent {
     async #executeJob(context) {
         const { bullJob, jobClass, id, args, jobName } = context;
         const job = new jobClass();
-        await APM.startSegment(`job:${jobName}`,
-                               true,
-                               () => job._run(id, args, bullJob.updateProgress.bind(bullJob)));
+        await this.apm.startSegment(`job:${jobName}`,
+                                    true,
+                                    () => job._run(id, args, bullJob.updateProgress.bind(bullJob)));
     }
 
 
     #addJobAttributes(context) {
-        APM.addCustomAttribute('jobId',       context.id);
-        APM.addCustomAttribute('jobName',     context.jobName);
-        APM.addCustomAttribute('queueName',   context.queueName);
-        APM.addCustomAttribute('attempt',     context.attempt);
-        APM.addCustomAttribute('maxAttempts', context.maxAttempts);
+        this.apm.addCustomAttribute('jobId',       context.id);
+        this.apm.addCustomAttribute('jobName',     context.jobName);
+        this.apm.addCustomAttribute('queueName',   context.queueName);
+        this.apm.addCustomAttribute('attempt',     context.attempt);
+        this.apm.addCustomAttribute('maxAttempts', context.maxAttempts);
     }
 
 
     #reportJobError(err, context) {
         const isFinalRetry = context.attempt >= context.maxAttempts;
 
-        APM.reportError(err, {
+        this.apm.reportError(err, {
             jobId:       context.id,
             jobName:     context.jobName,
             queueName:   context.queueName,
@@ -181,7 +196,7 @@ class Worker extends AbstractJobComponent {
 
 
     #recordJobFailedEvent(context, err) {
-        APM.recordCustomEvent(JOB_FAILED_EVENT, {
+        this.apm.recordCustomEvent(JOB_FAILED_EVENT, {
             jobName:   context.jobName,
             queueName: context.queueName,
             attempts:  context.attempt,
@@ -191,13 +206,13 @@ class Worker extends AbstractJobComponent {
 
 
     #recordJobSuccess(context, duration) {
-        APM.recordCustomEvent(JOB_COMPLETED_EVENT, {
+        this.apm.recordCustomEvent(JOB_COMPLETED_EVENT, {
             jobName:    context.jobName,
             queueName:  context.queueName,
             durationMs: duration,
             attempts:   context.attempt,
         });
-        APM.recordMetric(durationMetricName(context.queueName, context.jobName), duration);
+        this.apm.recordMetric(durationMetricName(context.queueName, context.jobName), duration);
     }
 
 
@@ -247,7 +262,7 @@ class Worker extends AbstractJobComponent {
 
     #loggerForJob(bullJob) {
         const { id } = this.#dataForJob(bullJob);
-        return logger.worker.child(id);
+        return this.logger.child(id);
     }
 
 

package/lib/logger/index.js

@@ -92,13 +92,17 @@ class Logger {
 
 
     #createLogger(scopes, id) {
-        scopes    = Array.isArray(scopes) ? scopes : [scopes];
-        scopes    = scopes.map(scope => scope.toLowerCase());
-        const key = `${scopes.join('|')}:${id}`;
-        if (loggers[key]) return loggers[key];
+        scopes         = Array.isArray(scopes) ? scopes : [scopes];
+        scopes         = scopes.map(scope => scope.toLowerCase());
+        const cacheKey = scopes.join('|');
 
-        loggers[key] = new Logger(scopes, id);
-        return loggers[key];
+        if (!id && loggers[cacheKey]) return loggers[cacheKey];
+
+        const logger = new Logger(scopes, id);
+
+        if (!id) loggers[cacheKey] = logger;
+
+        return logger;
     }
 
 

package/lib/logger/serverMiddleware.js

@@ -1,41 +1,56 @@
 const expressWinston = require('express-winston');
 
 
-const msgFormatter = (req, res) => {
-    let msg;
-    if (req.controller) {
-        msg = `${req.controller.constructor.name}#${req.action}`;
-    } else {
-        msg = res.statusCode >= 500 ? 'request errored' : 'request completed';
+class LoggingMiddleware {
+    #logger;
+    #middleware;
+
+
+    constructor(logger) {
+        this.#logger = logger;
+    }
+
+
+    get loggerMiddlewareClass() {
+        return expressWinston;
     }
 
-    const responseTime    = res.responseTime || '-';
-    const requestDetails  = `req: ${req.method} ${req.url.split('?')[0]} for ${req.ip}`;
-    const responseDetails = `res: statusCode=${res.statusCode} responseTime=${responseTime}ms`;
 
-    msg = `${msg}\n    ${requestDetails}\n    ${responseDetails}`;
-    if (res.error) {
-        msg = `${msg}\n${res.error.stack}`;
+    get middleware() {
+        if (!this.#middleware) {
+            this.#middleware = this.loggerMiddlewareClass.logger({
+                dynamicMeta:     (req, res) => ({ id: req.id }),
+                level:           'debug',
+                msg:             this.msgFormatter.bind(this),
+                winstonInstance: this.#logger._winstonLogger,
+            });
+        }
+
+        return this.#middleware;
     }
 
-    return msg;
-};
 
+    msgFormatter(req, res) {
+        const baseMessage     = this.requestMessage(req, res);
+        const requestDetails  = `req: ${req.method} ${req.url.split('?')[0]} for ${req.ip}`;
+        const responseTime    = res.responseTime || '-';
+        const responseDetails = `res: statusCode=${res.statusCode} responseTime=${responseTime}ms`;
 
-let _middleware;
+        let msg = `${baseMessage}\n    ${requestDetails}\n    ${responseDetails}`;
+        if (res.error) msg = `${msg}\n${res.error.stack}`;
 
-function middleware(logger) {
-    if (_middleware) return _middleware;
-    _middleware = expressWinston.logger({
-        dynamicMeta:     (req, res) => ({id: req.id}),
-        level:           'debug',
-        msg:             msgFormatter,
-        winstonInstance: logger._winstonLogger,
-    });
-    return _middleware;
-};
+        return msg;
+    }
+
+
+    requestMessage(req, res) {
+        if (req.controller)        return `${req.controller.constructor.name}#${req.action}`;
+        if (res.statusCode >= 500) return 'request errored';
+        return 'request completed';
+    }
+}
 
 
 module.exports = {
-  middleware
+    LoggingMiddleware
 }

package/lib/server/controllerMixins/renderer.js

@@ -231,11 +231,13 @@ const InstanceMethods = {
         if (!this._isStreaming) throw new NoActiveStreamError();
         if (this._streamAbortController?.signal?.aborted || this.writableEnded) return;
 
+        let msg;
         if (evt) {
-            this._response.write(`event: ${evt}\n`);
+            msg = `event: ${evt}\ndata: ${data}\n\n`;
+        } else {
+            msg = `data: ${data}\n\n`;
         }
 
-        const msg = `data: ${data}\n\n`;
         this._response.write(msg);
     }
 }

package/lib/server/server.js

@@ -3,10 +3,10 @@ const   cookieParser           = require('cookie-parser');
 const { ControllerImporter }   = require('./controllerImporter');
 const   express                = require('express');
 const { logger }               = require('../logger');
-const   loggingMiddleware      = require('../logger/serverMiddleware');
+const { LoggingMiddleware }    = require('../logger/serverMiddleware');
 const   mustacheExpress        = require('mustache-express');
 const   responseTime           = require('response-time');
-const   IoServer               = require("socket.io")
+const   IoServer               = require("socket.io");
 const { Server }               = require('http');
 const { SystemController }     = require('./systemController');
 const   requestID              = require( 'express-request-id');
@@ -50,9 +50,14 @@ class VidaServer {
     /***********************************************************************************************
     * WEB SOCKETS
     ***********************************************************************************************/
+    get socketServerFactory() {
+        return IoServer;
+    }
+
+
     get #ioServer() {
         if (!this.#_ioServer) {
-            this.#_ioServer = IoServer(this.#httpServer, {
+            this.#_ioServer = this.socketServerFactory(this.#httpServer, {
                 cors: { origin: this.corsOrigins, credentials: true }
             });
         }
@@ -79,9 +84,9 @@ class VidaServer {
         this.use(this.octetStreamParsingMiddleware);
         this.use(responseTime({suffix: true}))
         this.use(cookieParser());
-        this.use(express.static('public'))
+        this.use(this.serverEngineFactory.static('public'))
         this.use(this.loggingMiddleware);
-        this.use('/static', express.static(this.staticFilesDirectory));
+        this.use('/static', this.serverEngineFactory.static(this.staticFilesDirectory));
         this.use(this.connectionAbortedMiddleware);
         this.use(requestID());
 
@@ -90,7 +95,7 @@ class VidaServer {
 
 
     get jsonParsingMiddleware() {
-        return express.json({
+        return this.serverEngineFactory.json({
             limit:          '50Mb', // Increase JSON limit
             parameterLimit: 50000,  // Increase parameter limit
             type:           [
@@ -102,7 +107,7 @@ class VidaServer {
 
 
     get octetStreamParsingMiddleware() {
-        return express.raw({ type: 'application/octet-stream', limit: this.octetStreamLimit });
+        return this.serverEngineFactory.raw({ type: 'application/octet-stream', limit: this.octetStreamLimit });
     }
 
 
@@ -112,7 +117,7 @@ class VidaServer {
 
 
     get loggingMiddleware() {
-        return loggingMiddleware.middleware(this.logger);
+        return new LoggingMiddleware(this.logger).middleware;
     }
 
 
@@ -235,14 +240,24 @@ class VidaServer {
     }
 
 
+    get serverEngineFactory() {
+        return express;
+    }
+
+
+    get httpServerFactory() {
+        return Server;
+    }
+
+
     get #expressServer() {
-        if (!this.#_expressServer) this.#_expressServer = express();
+        if (!this.#_expressServer) this.#_expressServer = this.serverEngineFactory();
         return this.#_expressServer;
     }
 
 
     get #httpServer() { // Needed for io socket to work
-        if (!this.#_httpServer) this.#_httpServer = Server(this.#expressServer);
+        if (!this.#_httpServer) this.#_httpServer = this.httpServerFactory(this.#expressServer);
         return this.#_httpServer;
     }
 

package/package.json

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