@vida-global/core 2.1.1 → 2.2.0

package/test/activeRecord/baseRecord.test.js

@@ -3,7 +3,7 @@ const { Connection }            = require('../../lib/activeRecord/db/connection'
 const { getActiveRecordSchema } = require('../../lib/activeRecord/db/schema');
 const   importSchema            = require('../../lib/activeRecord/db/importSchema');
 const { Model, Sequelize }      = require('sequelize');
-const { mockRedisClientFactory } = require('./helpers/baseRecordMocks');
+const { mockRedisClientFactory, mockScannedKeys, randomCacheKeys } = require('./helpers/baseRecordMocks');
 const   TestHelpers             = require('@vida-global/test-helpers');
 const { camelize }              = require('inflection');
 const   Helpers                 = require('./helpers/baseRecord');
@@ -165,8 +165,58 @@ describe('BaseRecord', () => {
                                                       sequelize: new Helpers.MockSequelize(),
                                                       tableName: 'users',
                                                       timestamps: false,
-                                                      updatedAt: 'updated_at'
-                                                    });
+                                                       updatedAt: 'updated_at'
+                                                     });
+        });
+
+        it ('uses `paranoid: true` when the schema has timestamps and deleted_at', () => {
+            importSchema.mockImplementation(() => ({
+                created_at: {type: Helpers.dataTypeValue1},
+                deleted_at: {type: Helpers.dataTypeValue2},
+                updated_at: {type: Helpers.dataTypeValue2},
+            }));
+            class User extends BaseRecord {}
+            User.initialize();
+
+            expect(Model.init).toHaveBeenCalledWith(
+                {
+                    created_at: {type: Sequelize.DataTypes[Helpers.dataTypeKey1]},
+                    deleted_at: {type: Sequelize.DataTypes[Helpers.dataTypeKey2]},
+                    updated_at: {type: Sequelize.DataTypes[Helpers.dataTypeKey2]},
+                },
+                {
+                    createdAt: 'created_at',
+                    deletedAt: 'deleted_at',
+                    modelName: 'User',
+                    paranoid: true,
+                    sequelize: new Helpers.MockSequelize(),
+                    tableName: 'users',
+                    updatedAt: 'updated_at'
+                }
+            );
+        });
+
+        it ('does not use `paranoid: true` when the schema has deleted_at but no timestamps', () => {
+            importSchema.mockImplementation(() => ({
+                deleted_at: {type: Helpers.dataTypeValue2},
+            }));
+            class User extends BaseRecord {}
+            User.initialize();
+
+            expect(Model.init).toHaveBeenCalledWith(
+                {
+                    deleted_at: {type: Sequelize.DataTypes[Helpers.dataTypeKey2]},
+                },
+                {
+                    createdAt: 'created_at',
+                    deletedAt: 'deleted_at',
+                    modelName: 'User',
+                    sequelize: new Helpers.MockSequelize(),
+                    tableName: 'users',
+                    timestamps: false,
+                    updatedAt: 'updated_at'
+                }
+            );
         });
 
         it ('does not run twice on the same model', () => {
@@ -382,7 +432,7 @@ describe('BaseRecord', () => {
             const id = Math.random();
             await Person.find(id);
             expect(Person.findByPk).toHaveBeenCalledTimes(1);
-            expect(Person.findByPk).toHaveBeenCalledWith(id);
+            expect(Person.findByPk).toHaveBeenCalledWith(id, {useMaster: false});
         });
 
         it ('calls the sequelize `findAll` method when passed multiple value', async () => {
@@ -390,7 +440,13 @@ describe('BaseRecord', () => {
             const id2 = Math.random();
             await Person.find([id1, id2]);
             expect(Person.findAll).toHaveBeenCalledTimes(1);
-            expect(Person.findAll).toHaveBeenCalledWith({where: {[pk]: [id1, id2]}});
+            expect(Person.findAll).toHaveBeenCalledWith({useMaster: false, where: {[pk]: [id1, id2]}});
+        });
+
+        it ('forwards useWriteDB to findByPk as useMaster', async () => {
+            const id = Math.random();
+            await Person.find(id, {useWriteDB: true});
+            expect(Person.findByPk).toHaveBeenCalledWith(id, {useMaster: true});
         });
     });
 
@@ -421,10 +477,33 @@ describe('BaseRecord', () => {
     });
 
 
+    describe('BaseRecord.transaction', () => {
+        it ('delegates to the query interface and returns the result', async () => {
+            const expected = {};
+            const callback = jest.fn(() => expected);
+            const queryInterface = {
+                transaction: jest.fn(cb => cb())
+            };
+            class FakeConnection {
+                get queryInterface() { return queryInterface; }
+            }
+            class User extends BaseRecord {
+                static get connectionClass() { return FakeConnection; }
+            }
+
+            const result = await User.transaction(callback);
+
+            expect(queryInterface.transaction).toHaveBeenCalledTimes(1);
+            expect(queryInterface.transaction).toHaveBeenCalledWith(callback);
+            expect(result).toBe(expected);
+        });
+    });
+
+
     describe('Caching', () => {
         class Person extends BaseRecord {
             static get isCacheable()       { return true; }
-            static get redisClientFactory() { return mockRedisClientFactory; }
+            static get _redisClientFactory() { return mockRedisClientFactory; }
         }
         let redisClient
         beforeEach(() => {
@@ -439,7 +518,7 @@ describe('BaseRecord', () => {
                 await Person.find(id);
                 expect(Person.findByPk).toHaveBeenCalledTimes(0);
                 expect(findSpy).toHaveBeenCalledTimes(1);
-                expect(findSpy).toHaveBeenCalledWith(id);
+                expect(findSpy).toHaveBeenCalledWith(id, {});
             });
 
             it ('calls _cachedFind when multiple ids are passed', async () => {
@@ -448,7 +527,7 @@ describe('BaseRecord', () => {
                 await Person.find([id1, id2]);
                 expect(Person.findByPk).toHaveBeenCalledTimes(0);
                 expect(findSpy).toHaveBeenCalledTimes(1);
-                expect(findSpy).toHaveBeenCalledWith([id1, id2]);
+                expect(findSpy).toHaveBeenCalledWith([id1, id2], {});
             });
         });
 
@@ -693,6 +772,116 @@ describe('BaseRecord', () => {
         });
 
 
+        describe('BaseRecord.clearCacheKey', () => {
+            it ('deletes the given key from cache', async () => {
+                const key = `Person#find:${Math.random()}`;
+
+                await Person.clearCacheKey(key);
+                expect(redisClient.del).toHaveBeenCalledTimes(1);
+                expect(redisClient.del).toHaveBeenCalledWith(key);
+            });
+        });
+
+
+        describe('BaseRecord.forEachCacheKeyByPattern', () => {
+            const pattern = `Person#find:*`;
+
+            it ('scans with the given pattern and a default count of 100', async () => {
+                mockScannedKeys([]);
+
+                await Person.forEachCacheKeyByPattern(pattern, jest.fn());
+
+                expect(redisClient.scanIterator).toHaveBeenCalledTimes(1);
+                expect(redisClient.scanIterator).toHaveBeenCalledWith({ MATCH: pattern, COUNT: 100 });
+            });
+
+            it ('passes a custom count to the scan', async () => {
+                const count = TestHelpers.Faker.Math.randomNumber();
+                mockScannedKeys([]);
+
+                await Person.forEachCacheKeyByPattern(pattern, jest.fn(), count);
+
+                expect(redisClient.scanIterator).toHaveBeenCalledWith({ MATCH: pattern, COUNT: count });
+            });
+
+            it ('buffers the individually yielded keys into one batch per count', async () => {
+                const keys     = randomCacheKeys(5);
+                const callback = jest.fn();
+                mockScannedKeys(keys);
+
+                await Person.forEachCacheKeyByPattern(pattern, callback, 2);
+
+                expect(callback).toHaveBeenCalledTimes(3);
+                expect(callback).toHaveBeenNthCalledWith(1, keys.slice(0, 2), redisClient);
+                expect(callback).toHaveBeenNthCalledWith(2, keys.slice(2, 4), redisClient);
+                expect(callback).toHaveBeenNthCalledWith(3, keys.slice(4), redisClient);
+            });
+
+            it ('invokes the callback once when fewer keys than the count are scanned', async () => {
+                const keys     = randomCacheKeys(2);
+                const callback = jest.fn();
+                mockScannedKeys(keys);
+
+                await Person.forEachCacheKeyByPattern(pattern, callback);
+
+                expect(callback).toHaveBeenCalledTimes(1);
+                expect(callback).toHaveBeenCalledWith(keys, redisClient);
+            });
+
+            it ('flattens keys yielded as arrays', async () => {
+                const keys     = randomCacheKeys(3);
+                const callback = jest.fn();
+                mockScannedKeys([keys.slice(0, 2), keys.slice(2)]);
+
+                await Person.forEachCacheKeyByPattern(pattern, callback);
+
+                expect(callback).toHaveBeenCalledTimes(1);
+                expect(callback).toHaveBeenCalledWith(keys, redisClient);
+            });
+
+            it ('does not invoke the callback when the scan yields nothing', async () => {
+                const callback = jest.fn();
+                mockScannedKeys([]);
+
+                await Person.forEachCacheKeyByPattern(pattern, callback);
+
+                expect(callback).not.toHaveBeenCalled();
+            });
+        });
+
+
+        describe('BaseRecord.clearCacheKeysByPattern', () => {
+            const pattern = `Person#find:*`;
+
+            it ('scans for matching keys with the given pattern', async () => {
+                mockScannedKeys([]);
+
+                await Person.clearCacheKeysByPattern(pattern);
+
+                expect(redisClient.scanIterator).toHaveBeenCalledTimes(1);
+                expect(redisClient.scanIterator).toHaveBeenCalledWith({ MATCH: pattern, COUNT: 100 });
+            });
+
+            it ('deletes all scanned keys in a single batched call', async () => {
+                const keys = randomCacheKeys(3);
+                mockScannedKeys(keys);
+
+                await Person.clearCacheKeysByPattern(pattern);
+
+                expect(redisClient.del).toHaveBeenCalledTimes(1);
+                expect(redisClient.del).toHaveBeenCalledWith(keys);
+            });
+
+            it ('does not delete when the scan yields nothing', async () => {
+                mockScannedKeys([]);
+
+                await Person.clearCacheKeysByPattern(pattern);
+
+                expect(redisClient.del).not.toHaveBeenCalled();
+            });
+        });
+
+
         describe('BaseRecord.#clearSelfCache', () => {
             it ('deletes the key from cache', async () => {
                 const pk     = Person.primaryKeyAttribute;
@@ -704,6 +893,18 @@ describe('BaseRecord', () => {
                 expect(redisClient.del).toHaveBeenCalledTimes(1);
                 expect(redisClient.del).toHaveBeenCalledWith(key);
             });
+
+            it ('delegates deletion to clearCacheKey', async () => {
+                const pk       = Person.primaryKeyAttribute;
+                const id       = Math.random();
+                const key      = Person._recordCacheKey(id);
+                const person   = new Person({[pk]: id});
+                const clearSpy = jest.spyOn(Person, 'clearCacheKey');
+
+                await person.clearSelfCache();
+                expect(clearSpy).toHaveBeenCalledTimes(1);
+                expect(clearSpy).toHaveBeenCalledWith(key);
+            });
         });
 
 
@@ -711,7 +912,7 @@ describe('BaseRecord', () => {
         describe.each(hooks)('BaseRecord._after%sCacheHook', (hook) => {
             class Cacheable extends BaseRecord {
                 static get isCacheable()       { return true; }
-                static get redisClientFactory() { return mockRedisClientFactory; }
+                static get _redisClientFactory() { return mockRedisClientFactory; }
             }
             const hookMethod = `_after${hook}CacheHook`;
 
@@ -842,5 +1043,45 @@ describe('BaseRecord', () => {
 
             expect(record.toApiResponse()).toEqual({ name: 'OVERRIDDEN' });
         });
+
+
+        it ('leaves column keys unchanged when camelizeFieldsForApiResponse is disabled', () => {
+            const record = buildRecord(
+                { org_id: { type: 'integer' }, external_task_id: { type: 'string' } },
+                { org_id: 7, external_task_id: 'abc' },
+            );
+
+            expect(record.toApiResponse()).toEqual({ org_id: 7, external_task_id: 'abc' });
+        });
+
+
+        it ('camelizes column keys when camelizeFieldsForApiResponse is enabled', () => {
+            const record = buildRecord(
+                { org_id: { type: 'integer' }, external_task_id: { type: 'string' } },
+                { org_id: 7, external_task_id: 'abc' },
+            );
+            Object.defineProperty(record, 'camelizeFieldsForApiResponse', { get: () => true, configurable: true });
+
+            expect(record.toApiResponse()).toEqual({ orgId: 7, externalTaskId: 'abc' });
+        });
+    });
+
+
+    describe('#apiResponseKey', () => {
+        it ('returns the column unchanged by default', () => {
+            class Thing extends BaseRecord {}
+            const record = Object.create(Thing.prototype);
+
+            expect(record.apiResponseKey('external_task_id')).toEqual('external_task_id');
+        });
+
+
+        it ('camelizes the column when camelizeFieldsForApiResponse is enabled', () => {
+            class Thing extends BaseRecord {}
+            const record = Object.create(Thing.prototype);
+            Object.defineProperty(record, 'camelizeFieldsForApiResponse', { get: () => true, configurable: true });
+
+            expect(record.apiResponseKey('external_task_id')).toEqual('externalTaskId');
+        });
     });
 });

package/test/activeRecord/db/migrator.test.js

@@ -61,6 +61,27 @@ describe('Migrator', () => {
             expect(Helpers.mockQueryInterface.createTable).toHaveBeenCalledWith(tableName, details);
         });
 
+        it ('adds a deleted_at column for paranoid tables', async () => {
+            const tableName = Helpers.randomString();
+            const details = { ...defaultColumns };
+
+            await Helpers.migrator.createTable(tableName, details, { paranoid: true });
+
+            expect(Helpers.mockQueryInterface.createTable).toHaveBeenCalledWith(tableName, {
+                ...defaultColumns,
+                deleted_at: { allowNull: true, type: 'DATE' },
+            });
+        });
+
+        it ('leaves deleted_at off tables that are not paranoid', async () => {
+            const tableName = Helpers.randomString();
+            const details = { ...defaultColumns };
+
+            await Helpers.migrator.createTable(tableName, details);
+
+            expect(Helpers.mockQueryInterface.createTable).toHaveBeenCalledWith(tableName, defaultColumns);
+        });
+
         it ('snake_cases created table columns', async () => {
             const tableName = Helpers.randomString();
             const details = { ...defaultColumns, myColumn: 1 };

package/test/activeRecord/db/queryInterface.test.js

@@ -29,10 +29,12 @@ describe('QueryInterface', () => {
 
     describe('QueryInterface#transaction', () => {
         it('delegates transaction callback to sequelize', async () => {
-            const callback = jest.fn();
+            const expected = {};
+            const callback =  jest.fn(() => expected);
 
-            await queryInterface.transaction(callback);
+            const result = await queryInterface.transaction(callback);
 
+            expect(result).toBe(expected);
             expect(connection._sequelize.transaction).toHaveBeenCalledTimes(1);
             expect(connection._sequelize.transaction).toHaveBeenCalledWith(callback);
         });

package/test/activeRecord/helpers/baseRecordMocks.js

@@ -10,6 +10,11 @@ const dataTypeKey2   = TestHelpers.Faker.Text.randomString();
 const dataTypeValue2 = TestHelpers.Faker.Text.randomString();
 
 
+function randomCacheKeys(count) {
+    return Array.from({ length: count }, () => `Person#find:${TestHelpers.Faker.Text.randomString()}`);
+}
+
+
 /***************************************************************************************************
 * MOCKS
 ***************************************************************************************************/
@@ -42,14 +47,26 @@ class MockSequelize {
 
 
 const redisClient = {
-    del:     jest.fn(),
-    mGet:    jest.fn(),
-    mSet:    jest.fn(),
-    connect: jest.fn(),
+    del:          jest.fn(),
+    mGet:         jest.fn(),
+    mSet:         jest.fn(),
+    connect:      jest.fn(),
+    scanIterator: jest.fn(),
 }
 const mockRedisClientFactory = () => redisClient;
 
 
+// redis 4's scanIterator yields one key string at a time. Pass an array element to model the
+// batches redis 5 yields instead.
+function mockScannedKeys(scanned) {
+    redisClient.scanIterator.mockImplementation(async function* () {
+        for (const item of scanned) {
+            yield item;
+        }
+    });
+}
+
+
 module.exports = {
     dataTypeKey1,
     dataTypeValue1,
@@ -57,5 +74,7 @@ module.exports = {
     dataTypeValue2,
     MockModel,
     mockRedisClientFactory,
+    mockScannedKeys,
     MockSequelize,
+    randomCacheKeys,
 }

package/test/cache/memoryCache.test.js

@@ -16,6 +16,82 @@ describe('MemoryCache', () => {
     });
 
 
+    describe('#delete', () => {
+        const options = {
+            namespace: 'squire:shop-data',
+            key: { shopId: 'shop-1' },
+            ttlSeconds: 300,
+        };
+
+
+        it('deletes a cached value', async () => {
+            await cache.fetch(options, async () => ({ version: 1 }));
+
+            await expect(cache.delete(options)).resolves.toBe(true);
+            await expect(cache.fetch(options, async () => ({ version: 2 }))).resolves.toEqual({
+                value: { version: 2 },
+                cacheHit: false,
+            });
+        });
+
+
+        it('deletes values using an equivalent object key', async () => {
+            await cache.fetch({
+                ...options,
+                key: { agentId: 'agent-1', shopId: 'shop-1' },
+            }, async () => ({ version: 1 }));
+
+            await expect(cache.delete({
+                namespace: options.namespace,
+                key: { shopId: 'shop-1', agentId: 'agent-1' },
+            })).resolves.toBe(true);
+        });
+
+
+        it('returns false when the value is not cached', async () => {
+            await expect(cache.delete(options)).resolves.toBe(false);
+        });
+
+
+        it('invalidates an in-flight fetch without interfering with its replacement', async () => {
+            let resolveOldFetch;
+            let resolveNewFetch;
+            const oldFetcher = jest.fn(() => new Promise((resolve) => {
+                resolveOldFetch = resolve;
+            }));
+            const newFetcher = jest.fn(() => new Promise((resolve) => {
+                resolveNewFetch = resolve;
+            }));
+            const oldFetch = cache.fetch(options, oldFetcher);
+            await expect(cache.delete(options)).resolves.toBe(true);
+            const newFetch = cache.fetch(options, newFetcher);
+
+            resolveOldFetch({ version: 1 });
+            await expect(oldFetch).resolves.toEqual({ value: { version: 1 }, cacheHit: false });
+            const joinedFetcher = jest.fn();
+            const joinedFetch   = cache.fetch(options, joinedFetcher);
+            resolveNewFetch({ version: 2 });
+
+            await expect(Promise.all([newFetch, joinedFetch])).resolves.toEqual([
+                { value: { version: 2 }, cacheHit: false },
+                { value: { version: 2 }, cacheHit: false },
+            ]);
+            expect(oldFetcher).toHaveBeenCalledTimes(1);
+            expect(newFetcher).toHaveBeenCalledTimes(1);
+            expect(joinedFetcher).not.toHaveBeenCalled();
+            await expect(cache.fetch(options, joinedFetcher)).resolves.toEqual({
+                value: { version: 2 },
+                cacheHit: true,
+            });
+        });
+
+
+        it('requires a namespace', async () => {
+            await expect(cache.delete()).rejects.toThrow('MemoryCache namespace is required.');
+        });
+    });
+
+
     describe('#fetch', () => {
         const options = {
             namespace: 'squire:shop-data',

package/test/server/controllerMixins/callbacks.test.js

@@ -1,4 +1,5 @@
 const { VidaServerController } = require('../../../lib/server/serverController');
+const { buildResponseMock }    = require('../helpers/response');
 
 
 describe('VidaServerController', () => {
@@ -75,7 +76,7 @@ describe('VidaServerController', () => {
                 namedBefore() { order.push('before2') }
                 testAction()  { order.push('action');  return {} }
             }
-            const response   = { json: jest.fn(), send: jest.fn(), setHeader: jest.fn(), end: jest.fn(), statusCode: 200 };
+            const response   = buildResponseMock({ end: jest.fn() });
             const controller = new C({}, response);
 
             await controller.performRequest('testAction');
@@ -92,7 +93,7 @@ describe('VidaServerController', () => {
                 namedAfter() { order.push('after2') }
                 testAction() { order.push('action'); return {} }
             }
-            const response   = { json: jest.fn(), send: jest.fn(), setHeader: jest.fn(), end: jest.fn(), statusCode: 200 };
+            const response   = buildResponseMock({ end: jest.fn() });
             const controller = new C({}, response);
 
             await controller.performRequest('testAction');
@@ -105,7 +106,7 @@ describe('VidaServerController', () => {
                 setupCallbacks() { this.beforeCallback(() => false) }
             }
             C.prototype.testAction = testAction;
-            const response   = { json: jest.fn(), send: jest.fn(), setHeader: jest.fn(), end: jest.fn(), statusCode: 200 };
+            const response   = buildResponseMock({ end: jest.fn() });
             const controller = new C({}, response);
 
             await controller.performRequest('testAction');
@@ -121,7 +122,7 @@ describe('VidaServerController', () => {
                 }
                 testAction() { return {} }
             }
-            const response   = { json: jest.fn(), send: jest.fn(), setHeader: jest.fn(), end: jest.fn(), statusCode: 200 };
+            const response   = buildResponseMock({ end: jest.fn() });
             const controller = new C({}, response);
 
             await controller.performRequest('testAction');
@@ -137,7 +138,7 @@ describe('VidaServerController', () => {
                 }
                 testAction() { return {} }
             }
-            const response   = { json: jest.fn(), send: jest.fn(), setHeader: jest.fn(), end: jest.fn(), statusCode: 200 };
+            const response   = buildResponseMock({ end: jest.fn() });
             const controller = new C({}, response);
 
             await controller.performRequest('testAction');