@vida-global/core 2.3.2 → 2.3.4

package/test/activeRecord/afterCommitHooks.test.js

@@ -0,0 +1,326 @@
+const afterCommitHooks = require('../../lib/activeRecord/afterCommitHooks');
+const TestHelpers      = require('@vida-global/test-helpers');
+const Helpers          = require('./helpers/afterCommitHooks');
+
+
+afterEach(() => {
+    jest.clearAllMocks();
+});
+
+
+describe('afterCommitHooks', () => {
+    describe('addCallback', () => {
+        it ('registers an unnamed callback', () => {
+            const model    = Helpers.buildModel();
+            const callback = jest.fn();
+
+            afterCommitHooks.addCallback(model, callback);
+
+            expect(afterCommitHooks.callbacksFor(model)).toEqual([callback]);
+        });
+
+        it ('registers a named callback', () => {
+            const model    = Helpers.buildModel();
+            const name     = TestHelpers.Faker.Text.randomString();
+            const callback = jest.fn();
+
+            afterCommitHooks.addCallback(model, name, callback);
+
+            expect(afterCommitHooks.callbacksFor(model)).toEqual([callback]);
+        });
+
+        it ('keeps callbacks in the order they were registered', () => {
+            const model  = Helpers.buildModel();
+            const first  = jest.fn();
+            const second = jest.fn();
+
+            afterCommitHooks.addCallback(model, first);
+            afterCommitHooks.addCallback(model, second);
+
+            expect(afterCommitHooks.callbacksFor(model)).toEqual([first, second]);
+        });
+    });
+
+
+    describe('removeCallback', () => {
+        it ('removes an unnamed callback by reference', () => {
+            const model     = Helpers.buildModel();
+            const removed   = jest.fn();
+            const remaining = jest.fn();
+            afterCommitHooks.addCallback(model, removed);
+            afterCommitHooks.addCallback(model, remaining);
+
+            afterCommitHooks.removeCallback(model, removed);
+
+            expect(afterCommitHooks.callbacksFor(model)).toEqual([remaining]);
+        });
+
+        it ('removes a named callback by name', () => {
+            const model     = Helpers.buildModel();
+            const name      = TestHelpers.Faker.Text.randomString();
+            const removed   = jest.fn();
+            const remaining = jest.fn();
+            afterCommitHooks.addCallback(model, name, removed);
+            afterCommitHooks.addCallback(model, remaining);
+
+            afterCommitHooks.removeCallback(model, name);
+
+            expect(afterCommitHooks.callbacksFor(model)).toEqual([remaining]);
+        });
+
+        it ('leaves unnamed callbacks alone when removing by name', () => {
+            const model    = Helpers.buildModel();
+            const callback = function namedFunction() {};
+            afterCommitHooks.addCallback(model, callback);
+
+            afterCommitHooks.removeCallback(model, 'namedFunction');
+
+            expect(afterCommitHooks.callbacksFor(model)).toEqual([callback]);
+        });
+
+        it ('does not remove callbacks registered on an ancestor', () => {
+            const parent   = Helpers.buildModel();
+            const child    = Helpers.buildModel(parent);
+            const callback = jest.fn();
+            afterCommitHooks.addCallback(parent, callback);
+
+            afterCommitHooks.removeCallback(child, callback);
+
+            expect(afterCommitHooks.callbacksFor(parent)).toEqual([callback]);
+            expect(afterCommitHooks.callbacksFor(child)).toEqual([callback]);
+        });
+    });
+
+
+    describe('callbacksFor', () => {
+        it ('returns an empty list for a model with no callbacks', () => {
+            expect(afterCommitHooks.callbacksFor(Helpers.buildModel())).toEqual([]);
+        });
+
+        it ('includes callbacks registered on an ancestor', () => {
+            const parent         = Helpers.buildModel();
+            const child          = Helpers.buildModel(parent);
+            const parentCallback = jest.fn();
+            const childCallback  = jest.fn();
+            afterCommitHooks.addCallback(parent, parentCallback);
+            afterCommitHooks.addCallback(child, childCallback);
+
+            expect(afterCommitHooks.callbacksFor(child)).toEqual([parentCallback, childCallback]);
+        });
+
+        it ('does not include callbacks registered on a descendant', () => {
+            const parent        = Helpers.buildModel();
+            const child         = Helpers.buildModel(parent);
+            const childCallback = jest.fn();
+            afterCommitHooks.addCallback(child, childCallback);
+
+            expect(afterCommitHooks.callbacksFor(parent)).toEqual([]);
+        });
+
+        it ('does not include callbacks registered on a sibling', () => {
+            const parent           = Helpers.buildModel();
+            const sibling          = Helpers.buildModel(parent);
+            const otherSibling     = Helpers.buildModel(parent);
+            const siblingCallback  = jest.fn();
+            afterCommitHooks.addCallback(sibling, siblingCallback);
+
+            expect(afterCommitHooks.callbacksFor(otherSibling)).toEqual([]);
+        });
+    });
+
+
+    describe('runCallbacks', () => {
+        describe('without a transaction', () => {
+            it ('calls every registered callback with the record and options', async () => {
+                const model    = Helpers.buildModel();
+                const record   = Helpers.buildRecord();
+                const options  = {};
+                const callback = jest.fn();
+                afterCommitHooks.addCallback(model, callback);
+
+                await afterCommitHooks.runCallbacks(model, record, options);
+
+                expect(callback).toHaveBeenCalledTimes(1);
+                expect(callback).toHaveBeenCalledWith(record, options);
+            });
+
+            it ('calls the callback with the model as its context', async () => {
+                const model = Helpers.buildModel();
+                let   context;
+                afterCommitHooks.addCallback(model, function() { context = this; });
+
+                await afterCommitHooks.runCallbacks(model, Helpers.buildRecord(), {});
+
+                expect(context).toBe(model);
+            });
+
+            it ('awaits each callback before running the next', async () => {
+                const model = Helpers.buildModel();
+                const order = [];
+                afterCommitHooks.addCallback(model, async () => {
+                    await Promise.resolve();
+                    order.push('first');
+                });
+                afterCommitHooks.addCallback(model, () => order.push('second'));
+
+                await afterCommitHooks.runCallbacks(model, Helpers.buildRecord(), {});
+
+                expect(order).toEqual(['first', 'second']);
+            });
+
+            it ('lets a callback error propagate', async () => {
+                const model   = Helpers.buildModel();
+                const message = TestHelpers.Faker.Text.randomString();
+                afterCommitHooks.addCallback(model, () => { throw new Error(message); });
+
+                await expect(afterCommitHooks.runCallbacks(model, Helpers.buildRecord(), {}))
+                    .rejects.toThrow(message);
+            });
+        });
+
+
+        describe('with a transaction', () => {
+            it ('defers the callback to the transaction instead of running it', async () => {
+                const model       = Helpers.buildModel();
+                const transaction = Helpers.buildTransaction();
+                const callback    = jest.fn();
+                afterCommitHooks.addCallback(model, callback);
+
+                await afterCommitHooks.runCallbacks(model, Helpers.buildRecord(), { transaction });
+
+                expect(transaction.afterCommit).toHaveBeenCalledTimes(1);
+                expect(callback).toHaveBeenCalledTimes(0);
+            });
+
+            it ('calls the callback with the record and options once the transaction commits', async () => {
+                const model       = Helpers.buildModel();
+                const transaction = Helpers.buildTransaction();
+                const record      = Helpers.buildRecord();
+                const options     = { transaction };
+                const callback    = jest.fn();
+                afterCommitHooks.addCallback(model, callback);
+
+                await afterCommitHooks.runCallbacks(model, record, options);
+                await Helpers.commit(transaction);
+
+                expect(callback).toHaveBeenCalledTimes(1);
+                expect(callback).toHaveBeenCalledWith(record, options);
+            });
+
+            it ('lets a callback error propagate out of the commit', async () => {
+                const model       = Helpers.buildModel();
+                const transaction = Helpers.buildTransaction();
+                const message     = TestHelpers.Faker.Text.randomString();
+                afterCommitHooks.addCallback(model, () => { throw new Error(message); });
+
+                await afterCommitHooks.runCallbacks(model, Helpers.buildRecord(), { transaction });
+
+                await expect(Helpers.commit(transaction)).rejects.toThrow(message);
+            });
+
+            it ('defers to the outermost transaction when the write is in a savepoint', async () => {
+                const model       = Helpers.buildModel();
+                const transaction = Helpers.buildTransaction();
+                const savepoint   = Helpers.buildSavepoint(transaction);
+                afterCommitHooks.addCallback(model, jest.fn());
+
+                await afterCommitHooks.runCallbacks(model, Helpers.buildRecord(), { transaction: savepoint });
+
+                expect(transaction.afterCommit).toHaveBeenCalledTimes(1);
+                expect(savepoint.afterCommit).toHaveBeenCalledTimes(0);
+            });
+
+            it ('defers to the outermost transaction through nested savepoints', async () => {
+                const model       = Helpers.buildModel();
+                const transaction = Helpers.buildTransaction();
+                const outerPoint  = Helpers.buildSavepoint(transaction);
+                const innerPoint  = Helpers.buildSavepoint(outerPoint);
+                afterCommitHooks.addCallback(model, jest.fn());
+
+                await afterCommitHooks.runCallbacks(model, Helpers.buildRecord(), { transaction: innerPoint });
+
+                expect(transaction.afterCommit).toHaveBeenCalledTimes(1);
+                expect(outerPoint.afterCommit).toHaveBeenCalledTimes(0);
+                expect(innerPoint.afterCommit).toHaveBeenCalledTimes(0);
+            });
+        });
+
+
+        describe('deduplication', () => {
+            it ('defers a callback once when the same record is reported twice', async () => {
+                const model       = Helpers.buildModel();
+                const transaction = Helpers.buildTransaction();
+                const record      = Helpers.buildRecord();
+                const callback    = jest.fn();
+                afterCommitHooks.addCallback(model, callback);
+
+                await afterCommitHooks.runCallbacks(model, record, { transaction });
+                await afterCommitHooks.runCallbacks(model, record, { transaction });
+                await Helpers.commit(transaction);
+
+                expect(callback).toHaveBeenCalledTimes(1);
+            });
+
+            it ('defers a callback for each distinct record', async () => {
+                const model       = Helpers.buildModel();
+                const transaction = Helpers.buildTransaction();
+                const first       = Helpers.buildRecord();
+                const second      = Helpers.buildRecord();
+                const callback    = jest.fn();
+                afterCommitHooks.addCallback(model, callback);
+
+                await afterCommitHooks.runCallbacks(model, first, { transaction });
+                await afterCommitHooks.runCallbacks(model, second, { transaction });
+                await Helpers.commit(transaction);
+
+                expect(callback).toHaveBeenCalledTimes(2);
+            });
+
+            it ('defers every registered callback for the same record', async () => {
+                const model       = Helpers.buildModel();
+                const transaction = Helpers.buildTransaction();
+                const first       = jest.fn();
+                const second      = jest.fn();
+                afterCommitHooks.addCallback(model, first);
+                afterCommitHooks.addCallback(model, second);
+
+                await afterCommitHooks.runCallbacks(model, Helpers.buildRecord(), { transaction });
+                await Helpers.commit(transaction);
+
+                expect(first).toHaveBeenCalledTimes(1);
+                expect(second).toHaveBeenCalledTimes(1);
+            });
+
+            it ('treats the same record in a separate transaction as a new registration', async () => {
+                const model    = Helpers.buildModel();
+                const first    = Helpers.buildTransaction();
+                const second   = Helpers.buildTransaction();
+                const record   = Helpers.buildRecord();
+                const callback = jest.fn();
+                afterCommitHooks.addCallback(model, callback);
+
+                await afterCommitHooks.runCallbacks(model, record, { transaction: first });
+                await afterCommitHooks.runCallbacks(model, record, { transaction: second });
+                await Helpers.commit(first);
+                await Helpers.commit(second);
+
+                expect(callback).toHaveBeenCalledTimes(2);
+            });
+
+            it ('deduplicates against the outermost transaction across savepoints', async () => {
+                const model       = Helpers.buildModel();
+                const transaction = Helpers.buildTransaction();
+                const savepoint   = Helpers.buildSavepoint(transaction);
+                const record      = Helpers.buildRecord();
+                const callback    = jest.fn();
+                afterCommitHooks.addCallback(model, callback);
+
+                await afterCommitHooks.runCallbacks(model, record, { transaction });
+                await afterCommitHooks.runCallbacks(model, record, { transaction: savepoint });
+                await Helpers.commit(transaction);
+
+                expect(callback).toHaveBeenCalledTimes(1);
+            });
+        });
+    });
+});

package/test/activeRecord/baseRecord.test.js

@@ -844,6 +844,98 @@ describe('BaseRecord', () => {
         });
 
 
+        describe('BaseRecord#toCachePayload', () => {
+            it ('returns the record as JSON', async () => {
+                const attrName = TestHelpers.Faker.Text.randomString();
+                const attrVal  = TestHelpers.Faker.Text.randomString();
+                const person   = new Person({[attrName]: attrVal});
+
+                await expect(person.toCachePayload()).resolves.toEqual({[attrName]: attrVal});
+            });
+        });
+
+
+        describe('BaseRecord.fromCachePayload', () => {
+            it ('builds a record that is not new', () => {
+                const attrName = TestHelpers.Faker.Text.randomString();
+                const attrVal  = TestHelpers.Faker.Text.randomString();
+
+                const person = Person.fromCachePayload({[attrName]: attrVal});
+
+                expect(person instanceof Person).toBeTruthy();
+                expect(person[attrName]).toEqual(attrVal);
+                expect(person.options.isNewRecord).toBeFalsy();
+            });
+        });
+
+
+        describe('cache payload overrides', () => {
+            const EXTRA_KEY = 'nicknames';
+
+            class Player extends Person {
+                #nicknames = null;
+
+
+                get nicknames()      { return this.#nicknames; }
+                set nicknames(names) { this.#nicknames = names; }
+
+
+                async toCachePayload() {
+                    const payload      = await super.toCachePayload();
+                    payload[EXTRA_KEY] = await this.fetchNicknames();
+                    return payload;
+                }
+
+
+                static fromCachePayload(data) {
+                    const { [EXTRA_KEY]: nicknames, ...attributes } = data;
+                    const player     = super.fromCachePayload(attributes);
+                    player.nicknames = nicknames;
+                    return player;
+                }
+
+
+                async fetchNicknames() { return []; }
+            }
+
+            const attrName = TestHelpers.Faker.Text.randomString();
+            const attrVal  = TestHelpers.Faker.Text.randomString();
+            const nickname = TestHelpers.Faker.Text.randomString();
+            const payload  = {[attrName]: attrVal, [EXTRA_KEY]: [nickname]};
+            const cached   = `AR:Player:${JSON.stringify(payload)}`;
+
+            it ('writes the associated data into the cached value', async () => {
+                const key    = TestHelpers.Faker.Text.randomString();
+                const player = new Player({[attrName]: attrVal});
+                jest.spyOn(player, 'fetchNicknames').mockResolvedValue([nickname]);
+
+                await Player._cacheFetchedData({[key]: player});
+
+                expect(redisClient.mSet).toHaveBeenCalledTimes(1);
+                expect(redisClient.mSet).toHaveBeenCalledWith({[key]: cached});
+            });
+
+            it ('restores the associated data when decoding, keeping it out of the attributes', () => {
+                const player = Player._decodeCachedValue(cached);
+
+                expect(player.nicknames).toEqual([nickname]);
+                expect(player[attrName]).toEqual(attrVal);
+                expect(player.dataValues[EXTRA_KEY]).toBeUndefined();
+            });
+
+            it ('returns the record and its associated data from a single cache read', async () => {
+                const id = Math.random();
+                redisClient.mGet.mockImplementation(() => [cached]);
+
+                const player = await Player._cachedFind(id);
+
+                expect(redisClient.mGet).toHaveBeenCalledTimes(1);
+                expect(Player.findAll).not.toHaveBeenCalled();
+                expect(player.nicknames).toEqual([nickname]);
+            });
+        });
+
+
         describe('BaseRecord.clearCacheKey', () => {
             it ('deletes the given key from cache', async () => {
                 const key = `Person#find:${Math.random()}`;
@@ -980,34 +1072,42 @@ describe('BaseRecord', () => {
         });
 
 
-        const hooks = ['Save', 'Destroy'];
-        describe.each(hooks)('BaseRecord._after%sCacheHook', (hook) => {
-            class Cacheable extends BaseRecord {
-                static get isCacheable()       { return true; }
-                static get _redisClientFactory() { return mockRedisClientFactory; }
-            }
-            const hookMethod = `_after${hook}CacheHook`;
+        describe('BaseRecord._afterCommitCacheHook', () => {
+            const buildCacheable = () => {
+                class Cacheable extends BaseRecord {
+                    static get isCacheable()         { return true; }
+                    static get _redisClientFactory() { return mockRedisClientFactory; }
+                }
+                return Cacheable;
+            };
+
+
+            it ('is registered as an afterCommit hook for cached models', () => {
+                const Cacheable = buildCacheable();
+                const addSpy    = jest.spyOn(Cacheable, 'addHook');
 
-            it (`is called as an after ${hook.toLowerCase()} hook for cached models`, () => {
-                expect(Cacheable.addHook).toHaveBeenCalledTimes(0);
                 Cacheable.initialize();
-                expect(Cacheable.addHook).toHaveBeenCalledTimes(2);
-                expect(Cacheable.addHook).toHaveBeenCalledWith(`after${hook}`, Cacheable[hookMethod]);
+
+                expect(addSpy).toHaveBeenCalledWith('afterCommit', Cacheable._afterCommitCacheHook);
             });
 
-            it ('is not called as an after save hook for non cached models', () => {
+            it ('is not registered for non cached models', () => {
                 class Foo extends BaseRecord {}
+                const addSpy = jest.spyOn(Foo, 'addHook');
+
                 Foo.initialize();
-                expect(Cacheable.addHook).toHaveBeenCalledTimes(0);
+
+                expect(addSpy).not.toHaveBeenCalledWith('afterCommit', expect.anything());
             });
 
             it ('calls BaseRecord#clearSelfCache and BaseRecord#updateCache', async () => {
+                const Cacheable = buildCacheable();
                 const person    = new Cacheable();
                 const clearSpy  = jest.spyOn(person, 'clearSelfCache');
                 const updateSpy = jest.spyOn(person, 'updateCache');
                 const options   = {};
 
-                await Cacheable[hookMethod](person,options);
+                await Cacheable._afterCommitCacheHook(person, options);
 
                 expect(clearSpy).toHaveBeenCalledTimes(1);
                 expect(updateSpy).toHaveBeenCalledTimes(1);
@@ -1017,6 +1117,204 @@ describe('BaseRecord', () => {
     });
 
 
+    describe('afterCommit hooks', () => {
+        const sourceHooks = ['afterSave', 'afterDestroy', 'afterRestore', 'afterUpsert'];
+
+        describe('BaseRecord.addHook', () => {
+            it ('delegates hook types sequelize supports to the parent implementation', () => {
+                class User extends BaseRecord {}
+                const callback = jest.fn();
+
+                User.addHook('beforeSave', callback);
+
+                expect(Model.addHook).toHaveBeenCalledTimes(1);
+                expect(Model.addHook).toHaveBeenCalledWith('beforeSave', callback, undefined);
+            });
+
+            it ('does not delegate afterCommit to the parent implementation', () => {
+                class User extends BaseRecord {}
+
+                User.addHook('afterCommit', jest.fn());
+
+                expect(Model.addHook).toHaveBeenCalledTimes(0);
+            });
+
+            it ('registers the callback so it runs on commit', async () => {
+                class User extends BaseRecord {}
+                const callback = jest.fn();
+                const record   = new User();
+                const options  = {};
+                User.addHook('afterCommit', callback);
+
+                await User._afterCommitHandler(record, options);
+
+                expect(callback).toHaveBeenCalledTimes(1);
+                expect(callback).toHaveBeenCalledWith(record, options);
+            });
+
+            it ('registers a named callback', async () => {
+                class User extends BaseRecord {}
+                const callback = jest.fn();
+                User.addHook('afterCommit', TestHelpers.Faker.Text.randomString(), callback);
+
+                await User._afterCommitHandler(new User(), {});
+
+                expect(callback).toHaveBeenCalledTimes(1);
+            });
+        });
+
+
+        describe('BaseRecord.removeHook', () => {
+            it ('delegates hook types sequelize supports to the parent implementation', () => {
+                class User extends BaseRecord {}
+                const name = TestHelpers.Faker.Text.randomString();
+
+                User.removeHook('beforeSave', name);
+
+                expect(Model.removeHook).toHaveBeenCalledTimes(1);
+                expect(Model.removeHook).toHaveBeenCalledWith('beforeSave', name);
+            });
+
+            it ('removes a registered afterCommit callback', async () => {
+                class User extends BaseRecord {}
+                const callback = jest.fn();
+                User.addHook('afterCommit', callback);
+
+                User.removeHook('afterCommit', callback);
+                await User._afterCommitHandler(new User(), {});
+
+                expect(Model.removeHook).toHaveBeenCalledTimes(0);
+                expect(callback).toHaveBeenCalledTimes(0);
+            });
+        });
+
+
+        describe('BaseRecord.hasHook', () => {
+            it ('delegates hook types sequelize supports to the parent implementation', () => {
+                class User extends BaseRecord {}
+
+                User.hasHook('beforeSave');
+
+                expect(Model.hasHook).toHaveBeenCalledTimes(1);
+                expect(Model.hasHook).toHaveBeenCalledWith('beforeSave');
+            });
+
+            it ('reports false when no afterCommit callback is registered', () => {
+                class User extends BaseRecord {}
+
+                expect(User.hasHook('afterCommit')).toBe(false);
+            });
+
+            it ('reports true once an afterCommit callback is registered', () => {
+                class User extends BaseRecord {}
+                User.addHook('afterCommit', jest.fn());
+
+                expect(User.hasHook('afterCommit')).toBe(true);
+            });
+        });
+
+
+        describe('BaseRecord.hasHooks', () => {
+            it ('reports on afterCommit the same way hasHook does', () => {
+                class User extends BaseRecord {}
+                User.addHook('afterCommit', jest.fn());
+
+                expect(User.hasHooks('afterCommit')).toBe(true);
+            });
+        });
+
+
+        describe('BaseRecord.afterCommit', () => {
+            it ('registers the callback like addHook does', async () => {
+                class User extends BaseRecord {}
+                const callback = jest.fn();
+
+                User.afterCommit(callback);
+                await User._afterCommitHandler(new User(), {});
+
+                expect(callback).toHaveBeenCalledTimes(1);
+            });
+        });
+
+
+        describe('BaseRecord.initializeHooks', () => {
+            it.each(sourceHooks)('registers the afterCommit handler on %s', (hookType) => {
+                class User extends BaseRecord {}
+
+                User.initialize();
+
+                expect(Model.addHook).toHaveBeenCalledWith(hookType, User._afterCommitHandler, undefined);
+            });
+
+            it ('does not register the handler on afterCreate or afterUpdate', () => {
+                class User extends BaseRecord {}
+
+                User.initialize();
+
+                expect(Model.addHook).not.toHaveBeenCalledWith('afterCreate', expect.anything(), undefined);
+                expect(Model.addHook).not.toHaveBeenCalledWith('afterUpdate', expect.anything(), undefined);
+            });
+        });
+
+
+        describe('BaseRecord._afterCommitHandler', () => {
+            it ('runs callbacks inherited from a parent model', async () => {
+                class User extends BaseRecord {}
+                class Admin extends User {}
+                const callback = jest.fn();
+                User.addHook('afterCommit', callback);
+
+                await Admin._afterCommitHandler(new Admin(), {});
+
+                expect(callback).toHaveBeenCalledTimes(1);
+            });
+
+            it ('does not run callbacks registered on an unrelated model', async () => {
+                class User extends BaseRecord {}
+                class Account extends BaseRecord {}
+                const callback = jest.fn();
+                User.addHook('afterCommit', callback);
+
+                await Account._afterCommitHandler(new Account(), {});
+
+                expect(callback).toHaveBeenCalledTimes(0);
+            });
+
+            it ('unwraps the record from the array afterUpsert reports', async () => {
+                class User extends BaseRecord {}
+                const callback = jest.fn();
+                const record   = new User();
+                const options  = {};
+                User.addHook('afterCommit', callback);
+
+                await User._afterCommitHandler([record, true], options);
+
+                expect(callback).toHaveBeenCalledWith(record, options);
+            });
+
+            it ('defers to the transaction when the write is in one', async () => {
+                class User extends BaseRecord {}
+                const transaction = { afterCommit: jest.fn(), parent: null };
+                const callback    = jest.fn();
+                User.addHook('afterCommit', callback);
+
+                await User._afterCommitHandler(new User(), { transaction });
+
+                expect(transaction.afterCommit).toHaveBeenCalledTimes(1);
+                expect(callback).toHaveBeenCalledTimes(0);
+            });
+
+            it ('lets a callback error propagate', async () => {
+                class User extends BaseRecord {}
+                const message = TestHelpers.Faker.Text.randomString();
+                User.addHook('afterCommit', () => { throw new Error(message); });
+
+                await expect(User._afterCommitHandler(new User(), {})).rejects.toThrow(message);
+            });
+        });
+    });
+
+
     describe('.documentationSchema', () => {
         const buildModel = (attributes) => {
             class Thing extends BaseRecord {}