@vida-global/core 1.1.13 → 1.2.1

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,28 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
+
+name: Node.js Package
+
+on:
+  push:
+    branches:
+      - release/production
+
+permissions:
+  id-token: write
+  contents: read
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '24'
+          registry-url: 'https://registry.npmjs.org'
+      - run: npm ci
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_READ_TOKEN }}
+      - run: npm test
+      - run: npm publish

package/README.md

@@ -7,4 +7,3 @@ This package is intended to contain core elements used across all Vida Apps. Kee
 - [HttpClient](lib/http)
 - [Logger](lib/logger)
 - [VidaServer](lib/server)
-- [Release Scripts](lib/release)

package/index.js

@@ -4,6 +4,7 @@ const { AuthorizationError,
         VidaServerController }  = require('./lib/server');
 const { logger }                = require('./lib/logger');
 const   ActiveRecord            = require('./lib/active_record');
+const { redisClientFactory }    = require('./lib/redis');
 
 
 module.exports = {
@@ -12,6 +13,7 @@ module.exports = {
     HttpClient,
     HttpError,
     logger,
+    redisClientFactory,
     VidaServer,
     VidaServerController,
 };

package/lib/active_record/baseRecord.js

@@ -1,10 +1,11 @@
 const { Connection, DEFAULT_DATABASE_ID } = require('./db/connection');
 const { getActiveRecordSchema }           = require('./db/schema');
+const { logger }                          = require('../logger');
 const { Model, Op }                       = require('sequelize');
+const   nodeUtil                          = require('util');
+const { redisClientFactory }              = require('../redis');
 const { tableize }                        = require('inflection');
 const   utils                             = require('./utils');
-const   nodeUtil                          = require('util');
-
 
 
 class BaseRecord extends Model {
@@ -26,8 +27,15 @@ class BaseRecord extends Model {
     /***********************************************************************************************
     * QUERIES
     ***********************************************************************************************/
-    static async find(id) {
-        return await this.findByPk(id);
+    static async find(ids) {
+        if (this.isCacheable) {
+            return await this._cachedFind(...arguments);
+        } else if (Array.isArray(ids)) {
+            const pk = this.primaryKeyAttribute
+            return await this.where({[pk]: ids});
+        } else {
+            return await this.findByPk(ids);
+        }
     }
 
 
@@ -61,10 +69,19 @@ class BaseRecord extends Model {
 
         this.init(schema, options);
 
+        this.initializeHooks();
+
         this._initialized = true;
     }
 
 
+    static initializeHooks() {
+        if (this.isCacheable) {
+            this.addHook('afterSave', this._afterSaveCacheHook);
+        }
+    }
+
+
     /***********************************************************************************************
     * DB CONNECTION
     ***********************************************************************************************/
@@ -96,13 +113,158 @@ class BaseRecord extends Model {
     }
 
 
+    /***********************************************************************************************
+    * CACHING
+    ***********************************************************************************************/
+    static async _cachedFind(ids, { clear=false }={}) {
+        const multiFind = Array.isArray(ids)
+        const idsToFind = multiFind ? ids : [ids];
+        const keyPairs  = idsToFind.map(id => [this._recordCacheKey(id), id]);
+        const keysToIds = Object.fromEntries(keyPairs);
+        const idsToKeys = Object.fromEntries(keyPairs.map(p => p.reverse()));
+        const keys      = Object.keys(keysToIds);
+
+        let records = await this.cachedFetch(keys, { clear }, async (missedKeys) => {
+            const idsToFind = missedKeys.map(key => keysToIds[key]);
+            const pk        = this.primaryKeyAttribute
+            const records   = await this.where({[pk]: idsToFind});
+            const keysToRecords = records.map(r => [idsToKeys[r[pk]], r])
+            return Object.fromEntries(keysToRecords);
+        });
+
+        records = Object.values(records);
+        if (!multiFind) return records[0] || null;
+        return records.filter(r => Boolean(r));
+    }
+
+
+    static async cachedIds(key, where, { clear=false }={}) {
+        const pk = this.primaryKeyAttribute;
+        const result = await this.cachedFetch([key], { clear }, async () => {
+            const rows = await this.findAll({ where, attributes: [pk], raw: true});
+            return {[key]: rows.map(row => row[pk])};
+        });
+
+        return result[key];
+    }
+
+
+    static async cachedFetch(keys, { clear=false }, fetcher) {
+        const client       = await this._getRedisClient();
+        const cachedValues = clear ? [] : await client.mGet(keys);
+        const kvPairs      = keys.map((key,idx) => {
+            const val = this._unmarshallCachedData(cachedValues[idx]);
+            return [key, val]
+        });
+        const cachedData   = Object.fromEntries(kvPairs);
+        const missedKeys   = keys.filter((key, idx) => cachedValues[idx] == null);
+        const hitKeys      = keys.filter(key => !missedKeys.includes(key));
+
+        this.debugLog('Cache Hit', hitKeys.join(', ') || '-');
+
+        let fetchedData = {};
+        if (missedKeys.length) {
+            this.debugLog('Cache Miss', missedKeys.join(', '));
+            fetchedData = await fetcher(missedKeys);
+            await this._cacheFetchedData(fetchedData)
+        }
+
+        return {...cachedData, ...fetchedData};
+    }
+
+
+    static async _cacheFetchedData(fetchedData) {
+        const toCache = {};
+
+        for (const [key, value] of Object.entries(fetchedData)) {
+            toCache[key] = this._marshallDataForCaching(value);
+        }
+
+        const client = await this._getRedisClient();
+        await client.mSet(toCache);
+        this.debugLog('Cache Set', Object.keys(fetchedData).join(', '));
+    }
+
+
+    static _marshallDataForCaching(value) {
+      let marshalledValue;
+      if (value instanceof this) {
+          marshalledValue = JSON.stringify(value.toJSON());
+          marshalledValue = `${this.recordCachingPrefix}:${marshalledValue}`;
+      } else {
+          marshalledValue = JSON.stringify(value);
+      }
+      return marshalledValue;
+    }
+
+
+    static _unmarshallCachedData(value) {
+        if (value == null)            return null;
+        if (typeof value != 'string') return value;
+
+        if (value.startsWith(this.recordCachingPrefix)) {
+            const regExp = new RegExp(`^${this.recordCachingPrefix}:`);
+            value        = value.replace(regExp, '');
+            const data   = JSON.parse(value);
+            return new this(data, {isNewRecord: false});
+        } else {
+            return JSON.parse(value);
+        }
+    }
+
+
+    async clearSelfCache() {
+        if (!this.constructor.isCacheable) return;
+
+        const pk     = this.constructor.primaryKeyAttribute;
+        const key    = this.constructor._recordCacheKey(this[pk]);
+        const client = await this.constructor._getRedisClient();
+
+        await client.del(key);
+        this.constructor.debugLog('Cache Del', key);
+    }
+
+
+    async updateCache() {}
+
+
+    static get recordCachingPrefix() {
+        return `AR:${this.name}`;
+    }
+
+
+    static _recordCacheKey(id) {
+        return `${this.name}#find:${id}`;
+    }
+
+
+    static async _getRedisClient() {
+      return await redisClientFactory();
+    }
+
+
+    static get isCacheable() { return false; }
+
+
+    static async _afterSaveCacheHook(record, options) {
+        await record.clearSelfCache();
+        await record.updateCache(options);
+    }
+
+
     /***********************************************************************************************
     * MISC
     ***********************************************************************************************/
     [nodeUtil.inspect.custom](opts) {
         const args = Array.from(arguments);
         args.shift();
-        return nodeUtil.inspect(this.dataValues, ...args);
+        const str = `${this.constructor.name} ${nodeUtil.inspect(this.dataValues)}`;
+        return nodeUtil.inspect(str, ...args);
+    }
+
+
+    static debugLog(tag, log) {
+        logger.debug(`[AR:${this.name}][${tag}] ${log}`);
     }
 }
 

package/lib/redis/index.js

@@ -0,0 +1,5 @@
+const { redisClientFactory } = require('./redisClient');
+
+module.exports = {
+  redisClientFactory
+}

package/lib/redis/redisClient.js

@@ -0,0 +1,45 @@
+const   fs       = require('fs');
+const { logger } = require('../logger');
+const   redis    = require('redis');
+
+
+let redisSingleton;
+
+
+async function initRedisClientSingleton() {
+    if (redisSingleton) return;
+
+    const certLocation = process.env.REDIS_CERT_LOCATION || `${process.cwd()}/redis_ca.pem`;
+    const cert         = fs.readFileSync(certLocation)
+
+    redisSingleton = redis.createClient({
+        socket: {
+            host: process.env.REDIS_HOST,
+            port: parseInt(process.env.REDIS_PORT),
+            tls:  true,
+            ca:   [cert]
+        },
+        password: process.env.REDIS_PASSWORD
+    });
+
+    redisSingleton.on('ready', (err) => {
+        logger.info('Redis Client Connected');
+    });
+    redisSingleton .on('error', (err) => {
+        const errno = err.errno ? ` (${err.errno})` : '';
+        logger.error(`Redis: ${err.message}${errno}`);
+    });
+
+    await redisSingleton.connect();
+}
+
+
+async function redisClientFactory() {
+    await initRedisClientSingleton();
+    return redisSingleton;
+}
+
+
+module.exports = {
+    redisClientFactory
+};

package/package.json

@@ -1,14 +1,14 @@
 {
     "name": "@vida-global/core",
-    "version": "1.1.13",
+    "version": "1.2.1",
     "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",
-        "release": "node ./scripts/release.js",
-        "develop": "node ./scripts/release.js develop"
+        "release": "node node_modules/@vida-global/release/scripts/release.js",
+        "develop": "node node_modules/@vida-global/release/scripts/release.js develop"
     },
     "jest": {
         "collectCoverage": true,
@@ -25,10 +25,12 @@
         "pino": "^9.6.0",
         "pino-http": "^10.4.0",
         "pino-pretty": "^13.0.0",
+        "redis": "^5.0.0",
         "response-time": "^2.3.3",
         "sequelize": "^6.37.7",
         "sequelize-cli": "^6.6.3",
-        "socket.io": "^4.4.0"
+        "socket.io": "^4.4.0",
+        "@vida-global/release": "^1.0.0"
     },
     "devDependencies": {
         "jest": "^29.6.2",