@vida-global/core 1.1.13 → 1.2.0

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/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,6 +1,6 @@
 {
     "name": "@vida-global/core",
-    "version": "1.1.13",
+    "version": "1.2.0",
     "description": "Core libraries for supporting Vida development",
     "author": "",
     "license": "ISC",
@@ -25,6 +25,7 @@
         "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",

package/test/active_record/baseRecord.test.js

@@ -4,6 +4,7 @@ const { ConnectionConfiguration } = require('../../lib/active_record/db/connecti
 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');
 
 
@@ -17,12 +18,25 @@ connectionSpy.mockImplementation(() => mockSequelize);
 
 
 jest.mock('sequelize', () => {
+    const TestHelpers    = require('@vida-global/test-helpers');
     class MockModel {
-        static init     = jest.fn()
-        static findByPk = jest.fn();
-        static findAll  = jest.fn();
+        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 }
     }
-    const TestHelpers    = require('@vida-global/test-helpers');
+
+    MockModel.findAll.mockImplementation(() => []);
+
     const dataTypeKey1   = TestHelpers.Faker.Text.randomString();
     const dataTypeValue1 = TestHelpers.Faker.Text.randomString();
     const dataTypeKey2   = TestHelpers.Faker.Text.randomString();
@@ -41,6 +55,17 @@ const dataTypeValue1 = Sequelize.DataTypes[dataTypeKey1].types.postgres[0];
 const dataTypeValue2 = Sequelize.DataTypes[dataTypeKey2].types.postgres[0];
 
 
+jest.mock('../../lib/redis', () => {
+    const client = {
+        del:  jest.fn(),
+        mGet: jest.fn(),
+        mSet: jest.fn(),
+    }
+    const redisClientFactory = () => client;
+
+    return { redisClientFactory };
+});
+
 jest.mock('../../lib/active_record/db/importSchema', () => jest.fn());
 importSchema.mockImplementation(() => ({created_at: {type: dataTypeValue1}, updated_at: {type: dataTypeValue2}}));
 
@@ -50,16 +75,16 @@ afterEach(() => {
 });
 
 
-describe('ActiveRecord', () => {
-    describe('ActiveRecord#constructor', () => {
+describe('BaseRecord', () => {
+    describe('BaseRecord.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', () => {
+    describe('BaseRecord.initialize', () => {
+        it ('calls `getBaseRecordSchema` and passes the response to init', () => {
             class User extends BaseRecord {}
             User.initialize();
             const tableDetails = {created_at: {type: Sequelize.DataTypes[dataTypeKey1]},
@@ -115,7 +140,7 @@ describe('ActiveRecord', () => {
     });
 
 
-    describe('ActiveRecord.tableName', () => {
+    describe('BaseRecord.tableName', () => {
         it ('defaults to the puralized version of the class name', () => {
             class User extends BaseRecord {}
             expect(User._tableName).toEqual('users');
@@ -140,19 +165,30 @@ describe('ActiveRecord', () => {
     });
 
 
-    describe('ActiveRecord#find', () => {
-        it ('calls the sequelize `findByPk` method', async () => {
-            class Person extends BaseRecord {}
-            Person.initialize();
-            const id          = Math.random();
+    describe('BaseRecord.find', () => {
+        const pk = TestHelpers.Faker.Text.randomString();
+        class Person extends BaseRecord {}
+        Person.initialize();
+        Person.primaryKeyAttribute = pk;
+
+        it ('calls the sequelize `findByPk` method when passed one value', async () => {
+            const id = Math.random();
             await Person.find(id);
             expect(Person.findByPk).toHaveBeenCalledTimes(1);
             expect(Person.findByPk).toHaveBeenCalledWith(id);
         });
+
+        it ('calls the sequelize `findAll` method when passed multiple value', async () => {
+            const id1 = Math.random();
+            const id2 = Math.random();
+            await Person.find([id1, id2]);
+            expect(Person.findAll).toHaveBeenCalledTimes(1);
+            expect(Person.findAll).toHaveBeenCalledWith({where: {[pk]: [id1, id2]}});
+        });
     });
 
 
-    describe('ActiveRecord#where', () => {
+    describe('BaseRecord.where', () => {
         const column    = TestHelpers.Faker.Text.randomString();
         const value     = TestHelpers.Faker.Text.randomString();
         const condition = {[column]: value};
@@ -176,4 +212,319 @@ describe('ActiveRecord', () => {
             expect(Person.findAll).toHaveBeenCalledWith(expected);
         });
     });
+
+
+    describe('Caching', () => {
+        class Person extends BaseRecord {
+            static get isCacheable() { return true; }
+        }
+        let redisClient
+        beforeEach(async () => {
+            redisClient = await redisClientFactory();
+            redisClient.mGet.mockImplementation(keys => new Array(keys.length));
+        });
+
+        describe('BaseRecord.find', () => {
+            const findSpy = jest.spyOn(Person, '_cachedFind');
+            it ('calls _cachedFindByPk when one id is passed', async () => {
+                const id = Math.random();
+                await Person.find(id);
+                expect(Person.findByPk).toHaveBeenCalledTimes(0);
+                expect(findSpy).toHaveBeenCalledTimes(1);
+                expect(findSpy).toHaveBeenCalledWith(id);
+            });
+
+            it ('calls _cachedFind when multiple ids are passed', async () => {
+                const id1 = Math.random();
+                const id2 = Math.random();
+                await Person.find([id1, id2]);
+                expect(Person.findByPk).toHaveBeenCalledTimes(0);
+                expect(findSpy).toHaveBeenCalledTimes(1);
+                expect(findSpy).toHaveBeenCalledWith([id1, id2]);
+            });
+        });
+
+
+        describe('BaseRecord._cachedFind', () => {
+            const pk  = Person.primaryKeyAttribute;
+            const id1 = Math.random();
+            const id2 = Math.random();
+            const id3 = Math.random();
+            const id4 = Math.random();
+            
+            it ('converts ids to cache keys and fetches from cache', async () => {
+                await Person._cachedFind([id1, id2]);
+                expect(redisClient.mGet).toHaveBeenCalledTimes(1);
+                expect(redisClient.mGet).toHaveBeenCalledWith([
+                  `Person#find:${id1}`,
+                  `Person#find:${id2}`,
+                ]);
+            });
+
+            it ('fetches misseds id from the database and caches them', async () => {
+                const key1 = `Person#find:${id1}`;
+                const key2 = `Person#find:${id2}`;
+                const key3 = `Person#find:${id3}`;
+                Person.findAll.mockImplementation(() => [new Person({[pk]:id1}), new Person({[pk]:id3})]);
+                redisClient.mGet.mockImplementation(keys => [null, '{}', null]);
+                await Person._cachedFind([id1, id2, id3]);
+
+                expect(redisClient.mGet).toHaveBeenCalledTimes(1);
+                expect(redisClient.mGet).toHaveBeenCalledWith([key1, key2, key3]);
+                expect(Person.findAll).toHaveBeenCalledTimes(1);
+                expect(Person.findAll).toHaveBeenCalledWith({where: {[pk]: [id1, id3]}});
+                expect(redisClient.mSet).toHaveBeenCalledTimes(1);
+                expect(redisClient.mSet).toHaveBeenCalledWith({
+                  [key1]: `AR:Person:{"${pk}":${id1}}`,
+                  [key3]: `AR:Person:{"${pk}":${id3}}`,
+                });
+            });
+
+            it ('does not hit the database for cache hits', async () => {
+                redisClient.mGet.mockImplementation(keys => [`AR:Person:{}`, `AR:Person:{}`]);
+                await Person._cachedFind([id1, id2]);
+                expect(redisClient.mGet).toHaveBeenCalledTimes(1);
+                expect(redisClient.mGet).toHaveBeenCalledWith([`Person#find:${id1}`, `Person#find:${id2}`]);
+                expect(Person.findAll).not.toHaveBeenCalled();
+            });
+
+            it ('does hit the database when `clear` is true', async () => {
+                redisClient.mGet.mockImplementation(keys => [`AR:Person:{}`, `AR:Person:{}`]);
+                await Person._cachedFind([id1, id2], {clear: true});
+                expect(redisClient.mGet).not.toHaveBeenCalled();
+                expect(Person.findAll).toHaveBeenCalledTimes(1);
+                expect(Person.findAll).toHaveBeenCalledWith({where: {[pk]: [id1, id2]}});
+            });
+
+            it ('returns an array of active record objects if an array was passed', async () => {
+                const p1 = new Person({[pk]: id1});
+                const p2 = new Person({[pk]: id2});
+                const p3 = new Person({[pk]: id3});
+                Person.findAll.mockImplementation(() => [p1, p3]);
+                redisClient.mGet.mockImplementation(keys => [null, `AR:Person:${JSON.stringify(p2.toJSON())}`, null]);
+
+                const results = await Person._cachedFind([id1, id2, id3, id4]);
+                expect(results.length).toEqual(3);
+                expect(results).toContain(p1);
+                expect(results).toContain(p3);
+                expect(results.filter(r => r[pk] == id2).length).toEqual(1);
+            });
+
+            it ('returns a single active record object if an array was not passed', async () => {
+                const p1 = new Person({[pk]: id1});
+                Person.findAll.mockImplementation(() => [p1]);
+                const results = await Person._cachedFind(id1);
+                expect(results).toEqual(p1);
+            });
+
+            it ('sets `isNewRecord` to false for records from cache', async () => {
+                redisClient.mGet.mockImplementation(keys => [`AR:Person:{}`]);
+                const person = await Person._cachedFind(id1);
+                expect(person.options.isNewRecord).toBeFalsy();
+            });
+        });
+
+
+        describe('BaseRecord.cachedIds', () => {
+            const key     = TestHelpers.Faker.Text.randomString();
+            const colName = TestHelpers.Faker.Text.randomString();
+            const val     = TestHelpers.Faker.Text.randomString();
+            const where   = {[colName]: val};
+            const ids     = [Math.random(), Math.random(), Math.random()];
+            const pk      = Person.primaryKeyAttribute;
+            const rows    = ids.map(id => ({[pk]: id}));
+
+            it ('fetches ids from the database and sets them in cache', async () => {
+                Person.findAll.mockImplementation(() => rows);
+                await Person.cachedIds(key, where)
+                expect(redisClient.mGet).toHaveBeenCalledTimes(1);
+                expect(redisClient.mGet).toHaveBeenCalledWith([key]);
+                expect(Person.findAll).toHaveBeenCalledTimes(1);
+                expect(Person.findAll).toHaveBeenCalledWith({ where, attributes: [pk], raw: true });
+                expect(redisClient.mSet).toHaveBeenCalledTimes(1);
+                expect(redisClient.mSet).toHaveBeenCalledWith({
+                  [key]: JSON.stringify(ids)
+                });
+            });
+
+            it ('does not hit the database for cache hits', async () => {
+                redisClient.mGet.mockImplementation(keys => [JSON.stringify(ids)]);
+                await Person.cachedIds(key, where)
+                expect(redisClient.mGet).toHaveBeenCalledTimes(1);
+                expect(redisClient.mGet).toHaveBeenCalledWith([key]);
+                expect(Person.findAll).not.toHaveBeenCalled();
+            });
+
+
+            it ('does hit the database when `clear` is true', async () => {
+                redisClient.mGet.mockImplementation(keys => [JSON.stringify(ids)]);
+                await Person.cachedIds(key, where, {clear: true})
+                expect(redisClient.mGet).not.toHaveBeenCalled();
+                expect(Person.findAll).toHaveBeenCalledTimes(1);
+                expect(Person.findAll).toHaveBeenCalledWith({ where, attributes: [pk], raw: true });
+            });
+
+            it ('does hit the database when `clear` is true', async () => {
+                redisClient.mGet.mockImplementation(keys => [JSON.stringify(ids)]);
+                await Person.cachedIds(key, where, {clear: true})
+                expect(redisClient.mGet).not.toHaveBeenCalled();
+                expect(Person.findAll).toHaveBeenCalledTimes(1);
+                expect(Person.findAll).toHaveBeenCalledWith({ where, attributes: [pk], raw: true });
+            });
+        });
+
+
+        describe('BaseRecord.cachedFetch', () => {
+            const key1    = Math.random();
+            const key2    = Math.random();
+            const key3    = Math.random();
+            const fetcher = jest.fn();
+
+            fetcher.mockImplementation(() => ({}));
+
+            it ('does a redis multi get with all keys', async () => {
+                await Person.cachedFetch([key1, key2, key3], {}, fetcher);
+                expect(redisClient.mGet).toHaveBeenCalledTimes(1);
+                expect(redisClient.mGet).toHaveBeenCalledWith([key1, key2, key3]);
+            });
+
+            it ('calls the fetcher for any cache misses', async () => {
+                redisClient.mGet.mockImplementation(() => [null, '{}', null]);
+                await Person.cachedFetch([key1, key2, key3], {}, fetcher);
+                expect(fetcher).toHaveBeenCalledTimes(1);
+                expect(fetcher).toHaveBeenCalledWith([key1, key3]);
+            });
+
+            it ('does not call the fetcher if there are no cache misses', async () => {
+                redisClient.mGet.mockImplementation(() => ['{}', '{}', '{}']);
+                await Person.cachedFetch([key1, key2, key3], {}, fetcher);
+                expect(fetcher).toHaveBeenCalledTimes(0);
+            });
+
+            it ('ignores the cache if `clear` is true', async () => {
+                redisClient.mGet.mockImplementation(() => ['{}', '{}', '{}']);
+                await Person.cachedFetch([key1, key2, key3], {clear: true}, fetcher);
+                expect(redisClient.mGet).not.toHaveBeenCalled();
+                expect(fetcher).toHaveBeenCalledTimes(1);
+                expect(fetcher).toHaveBeenCalledWith([key1, key2, key3]);
+            });
+
+            it ('calls BaseRecord._cacheFetchedData with data returned by the fetcher', async () => {
+                const cacheSpy = jest.spyOn(Person, '_cacheFetchedData');
+                const obj1     = {};
+                const obj2     = {};
+                const data     = {[key1]: obj1, [key2]: obj2};
+                redisClient.mGet.mockImplementation(() => [null, null]);
+                fetcher.mockImplementation(() => data);
+
+                await Person.cachedFetch([key1, key2], {}, fetcher);
+
+                expect(cacheSpy).toHaveBeenCalledTimes(1);
+                expect(cacheSpy).toHaveBeenCalledWith(data);
+            });
+
+            it ('returns data from cache hits and misses', async () => {
+                const pk   = Person.primaryKeyAttribute;
+                const id1  = Math.random();
+                const id2  = Math.random();
+                const id3  = Math.random();
+                const obj1 = {[pk]: id1};
+                const obj2 = {[pk]: id2};
+                const obj3 = {[pk]: id3};
+                const data = {[key1]: obj1};
+                redisClient.mGet.mockImplementation(() => [null, JSON.stringify(obj2), JSON.stringify(obj3)]);
+                fetcher.mockImplementation(() => data);
+
+                const results = await Person.cachedFetch([key1, key2, key3], {}, fetcher);
+
+                expect(Object.keys(results).length).toEqual(3);
+                expect(results[key1]).toBe(obj1);
+
+                expect(results[key2]).not.toBe(obj2);
+                expect(results[key2]).toEqual(obj2);
+
+                expect(results[key3]).not.toBe(obj3);
+                expect(results[key3]).toEqual(obj3);
+            });
+        });
+
+
+        describe('BaseRecord._cacheFetchedData', () => {
+            const key1    = TestHelpers.Faker.Text.randomString();
+            const key2    = TestHelpers.Faker.Text.randomString();
+            const key3    = TestHelpers.Faker.Text.randomString();
+            const key4    = TestHelpers.Faker.Text.randomString();
+
+            it ('marshalls data and does a redis multi set', async () => {
+                const obj1Key = TestHelpers.Faker.Text.randomString();
+                const obj1Val = TestHelpers.Faker.Text.randomString();
+                const obj1 = {[obj1Key]: obj1Val};
+                const obj2Key = TestHelpers.Faker.Text.randomString();
+                const obj2Val = TestHelpers.Faker.Text.randomString();
+                const obj2 = {[obj2Key]: obj2Val};
+
+                const person1 = new Person(obj1)
+                const person2 = new Person(obj2)
+
+                await Person._cacheFetchedData({
+                    [key1]: obj1,
+                    [key2]: obj2,
+                    [key3]: person1,
+                    [key4]: person2,
+                });
+                const cachedData = {
+                    [key1]: JSON.stringify(obj1),
+                    [key2]: JSON.stringify(obj2),
+                    [key3]: `AR:Person:${JSON.stringify(obj1)}`,
+                    [key4]: `AR:Person:${JSON.stringify(obj2)}`,
+                }
+
+                expect(redisClient.mSet).toHaveBeenCalledTimes(1);
+                expect(redisClient.mSet).toHaveBeenCalledWith(cachedData);
+            });
+        });
+
+
+        describe('BaseRecord.#clearSelfCache', () => {
+            it ('deletes the key from cache', async () => {
+                const pk     = Person.primaryKeyAttribute;
+                const id     = Math.random();
+                const key    = Person._recordCacheKey(id);
+                const person = new Person({[pk]: id});
+
+                await person.clearSelfCache();
+                expect(redisClient.del).toHaveBeenCalledTimes(1);
+                expect(redisClient.del).toHaveBeenCalledWith(key);
+            });
+        });
+
+
+        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);
+            });
+
+            it ('is not called as an after save hook for non cached models', () => {
+                class Foo extends BaseRecord {}
+                Foo.initialize();
+                expect(Person.addHook).toHaveBeenCalledTimes(0);
+            });
+
+            it ('calls BaseRecord#clearSelfCache and BaseRecord#updateCache', async () => {
+                const person    = new Person();
+                const clearSpy  = jest.spyOn(person, 'clearSelfCache');
+                const updateSpy = jest.spyOn(person, 'updateCache');
+                const options   = {};
+
+                await Person._afterSaveCacheHook(person,options);
+
+                expect(clearSpy).toHaveBeenCalledTimes(1);
+                expect(updateSpy).toHaveBeenCalledTimes(1);
+                expect(updateSpy).toHaveBeenCalledWith(options);
+            });
+        });
+    });
 });