@storyous/mongodb 1.0.0

package/__tests__/mongoLocker.test.ts

@@ -0,0 +1,191 @@
+import assert from 'assert';
+import { noop, pick, times } from 'lodash';
+import { beforeEach, describe, it } from 'mocha';
+import { Collection, MongoClient } from 'mongodb';
+import sinon from 'sinon';
+import {
+    getMongoLocker, LockCallback, LockerOptions, mongoLocker,
+} from '../lib';
+import { Key } from '../lib/mongoClient';
+import connectAndGetMongoClient from './getMongoClient';
+
+describe('packages/mongodb/mongoLocker', () => {
+
+    let mongoClient: MongoClient;
+    let collection: Collection;
+    const collectionName = 'customLocks';
+
+    beforeEach(async () => {
+        mongoClient = await connectAndGetMongoClient();
+        collection = mongoClient.db().collection(collectionName);
+        await collection.drop().catch(noop);
+    });
+
+    [
+        { description: 'default mongoLocker instance', locker: () => mongoLocker },
+        { description: 'custom getMongoLocker', locker: () => getMongoLocker(collection) },
+    ]
+        .forEach((suite) => {
+
+            describe(suite.description, () => {
+
+                let locker: (key: Key, callback: LockCallback<any>, options?: LockerOptions) => Promise<any>;
+
+                beforeEach(async () => {
+                    locker = await suite.locker();
+                });
+
+                it('should acquire and release a lock', async () => {
+
+                    let i = 0;
+                    const callback: any = sinon.spy(() => ++i);
+
+                    const result1 = await locker('AAA', callback);
+                    assert.strictEqual(result1, 1);
+
+                    const result2 = await locker('AAA', callback);
+                    assert.strictEqual(result2, 2);
+
+                    assert.deepStrictEqual(callback.callCount, 2);
+                });
+
+                it('should not be possible to acquire the lock twice at once', async () => {
+
+                    const callback = sinon.spy(() => new Promise((resolve) => { setTimeout(resolve, 50); }));
+                    const callLocker = () => locker('AAA', callback, { noLaterThan: 0 });
+
+                    const concurrency = 10;
+                    const promises = times(concurrency, callLocker);
+
+                    // Node 10 or less does not support allSettled. Going through good old cycle in such case
+                    if (Promise.allSettled) {
+                        await Promise.allSettled(promises); // just to get rid of UnhandledRejectionErrors
+                    } else {
+                    // just to get rid of UnhandledRejectionErrors
+                        promises.forEach((promise) => promise.catch(() => {}));
+
+                        for (let i = 0; i < promises.length; i++) {
+                            try {
+                            await promises[i]; // eslint-disable-line
+                            } catch (err) {
+                            // That's ok, we expect there can be errors
+                            }
+                        }
+                    }
+
+                    const stats = {
+                        resolved: 0,
+                        failed: 0,
+                    };
+
+                    for (const promise of promises) {
+                        try {
+                            await promise; // eslint-disable-line no-await-in-loop
+                            stats.resolved++;
+                        } catch (err: any) {
+                            assert(/The lock is already acquired./.test(err?.message));
+                            stats.failed++;
+                        }
+                    }
+
+                    assert.deepStrictEqual(callback.callCount, 1, 'The callback should be called only once');
+                    assert.deepStrictEqual(stats, {
+                        resolved: 1,
+                        failed: concurrency - 1,
+                    });
+                });
+
+                it('should propagate an error and release the lock if the callback fails', async () => {
+
+                    await assert.rejects(() => locker('AAA', async () => {
+                        throw new Error('Some error occurred');
+                    }), /Some error occurred/);
+
+                    const callback = sinon.spy();
+                    await locker('AAA', callback);
+
+                    assert.strictEqual(callback.callCount, 1);
+                });
+
+                it(
+                    'should be able to handle few concurrent tasks by waiting some time and acquire retries',
+                    async () => {
+                        const callTimes: Date[] = [];
+                        const callback = sinon.spy(async () => {
+                            callTimes.push(new Date());
+                            await new Promise((resolve) => { setTimeout(resolve, 150); });
+                            callTimes.push(new Date());
+                        }); // default retryDelay is 200
+
+                        const callLocker = () => locker('AAA', callback);
+
+                        await Promise.all(times(3, callLocker));
+
+                        assert.strictEqual(callback.callCount, 3);
+                        callTimes.forEach((time, i) => {
+                            if (i > 0) {
+                                assert(time > callTimes[i - 1], 'There was a parallel callback execution!');
+                            }
+                        });
+                    });
+
+                it('should be possible to override a lock which expired yet', async () => {
+                    const expireIn = 500;
+                    const array: number[] = [];
+                    const key = 'AAA';
+
+                    const firstCallPromise = locker(key, async () => {
+                        array.push(1);
+                        // the method last too long
+                        await new Promise((resolve) => { setTimeout(resolve, 2 * expireIn); });
+                        array.push(3);
+                    }, { expireIn });
+
+                    await new Promise((resolve) => { setTimeout(resolve, expireIn); });
+
+                    const secondCallPromise = locker('AAA', async () => {
+                        array.push(2);
+                    }, { expireIn });
+
+                    await Promise.all([firstCallPromise, secondCallPromise]);
+                    assert.deepStrictEqual(array, [1, 2, 3]);
+                });
+            });
+        });
+
+    describe('getMongoLocker', () => {
+        it('should create and TTL index on the right field', async () => {
+            await mongoClient.db()
+                .createCollection(collectionName);
+
+            let indexes = await collection.indexes();
+            assert.deepStrictEqual(indexes.length, 1); // ensure there is only mandatory _id index
+
+            const locker = await getMongoLocker(collection);
+            indexes = await collection.indexes();
+            assert.deepStrictEqual(indexes.length, 2, 'No or wrong indexes has been created!');
+            assert.deepStrictEqual(pick(indexes[1], 'key', 'expireAfterSeconds'), {
+                expireAfterSeconds: 0,
+                key: {
+                    expiresAt: 1,
+                },
+            }, 'No or wrong indexes has been created!');
+
+            const startedAt = new Date();
+            const someKey = 'someKey';
+            const expireIn = 55000;
+            await locker(someKey, async () => {
+                const document = await collection.findOne({});
+                assert.strictEqual(document?._id, someKey);
+                assert(
+                    document.expiresAt >= new Date(startedAt.getTime() + expireIn),
+                    'The expiresAt property has to be greater then startedAt + expiresIn',
+                );
+                assert(
+                    document.expiresAt < new Date(Date.now() + expireIn),
+                    'The acquiredAt property has to be younger then present + expiresIn',
+                );
+            }, { expireIn });
+        });
+    });
+});

package/__tests__/runMigration.test.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const mocha_1 = require("mocha");
+const winston_1 = require("winston");
+const lib_1 = require("../lib");
+(0, mocha_1.describe)('packages/mongodb/migrations', () => {
+    (0, mocha_1.before)(async () => {
+        lib_1.mongoClient.init('mongodb://127.0.0.1');
+        await lib_1.mongoClient.getClient().connect();
+        await lib_1.appData._collection.deleteOne({ _id: 'migrations' });
+    });
+    (0, mocha_1.it)('should runMigrations works', async () => {
+        await (0, lib_1.runMigrations)((0, winston_1.createLogger)(), `${__dirname}/migrations`, { safeMigration: false });
+        const migration = await lib_1.appData.getDocument('migrations');
+        assert_1.default.deepStrictEqual(migration?.lastRun, '1642152064249-test.js');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVuTWlncmF0aW9uLnRlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJydW5NaWdyYXRpb24udGVzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLG9EQUE0QjtBQUM1QixpQ0FBNkM7QUFDN0MscUNBQXVDO0FBQ3ZDLGdDQUE2RDtBQUU3RCxJQUFBLGdCQUFRLEVBQUMsNkJBQTZCLEVBQUUsR0FBRyxFQUFFO0lBQ3pDLElBQUEsY0FBTSxFQUFDLEtBQUssSUFBSSxFQUFFO1FBQ2QsaUJBQVcsQ0FBQyxJQUFJLENBQUMscUJBQXFCLENBQUMsQ0FBQztRQUN4QyxNQUFNLGlCQUFXLENBQUMsU0FBUyxFQUFFLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDeEMsTUFBTSxhQUFPLENBQUMsV0FBVyxDQUFDLFNBQVMsQ0FBQyxFQUFFLEdBQUcsRUFBRSxZQUFZLEVBQUUsQ0FBQyxDQUFDO0lBQy9ELENBQUMsQ0FBQyxDQUFDO0lBRUgsSUFBQSxVQUFFLEVBQUMsNEJBQTRCLEVBQUUsS0FBSyxJQUFJLEVBQUU7UUFDeEMsTUFBTSxJQUFBLG1CQUFhLEVBQ2YsSUFBQSxzQkFBWSxHQUFFLEVBQ2QsR0FBRyxTQUFTLGFBQWEsRUFDekIsRUFBRSxhQUFhLEVBQUUsS0FBSyxFQUFFLENBQzNCLENBQUM7UUFFRixNQUFNLFNBQVMsR0FBRyxNQUFNLGFBQU8sQ0FBQyxXQUFXLENBQUMsWUFBWSxDQUFDLENBQUM7UUFDMUQsZ0JBQU0sQ0FBQyxlQUFlLENBQUMsU0FBUyxFQUFFLE9BQU8sRUFBRSx1QkFBdUIsQ0FBQyxDQUFDO0lBQ3hFLENBQUMsQ0FBQyxDQUFDO0FBQ1AsQ0FBQyxDQUFDLENBQUMifQ==

package/__tests__/runMigration.test.ts

@@ -0,0 +1,23 @@
+import assert from 'assert';
+import { before, describe, it } from 'mocha';
+import { createLogger } from 'winston';
+import { appData, mongoClient, runMigrations } from '../lib';
+
+describe('packages/mongodb/migrations', () => {
+    before(async () => {
+        mongoClient.init('mongodb://127.0.0.1');
+        await mongoClient.getClient().connect();
+        await appData._collection.deleteOne({ _id: 'migrations' });
+    });
+
+    it('should runMigrations works', async () => {
+        await runMigrations(
+            createLogger(),
+            `${__dirname}/migrations`,
+            { safeMigration: false },
+        );
+
+        const migration = await appData.getDocument('migrations');
+        assert.deepStrictEqual(migration?.lastRun, '1642152064249-test.js');
+    });
+});

package/__tests__/withTransaction.test.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const lodash_1 = require("lodash");
+const mocha_1 = require("mocha");
+const lib_1 = require("../lib");
+require('./getMongoClient');
+(0, mocha_1.describe)('packages/mongodb/withTransaction', () => {
+    let testCollection;
+    (0, mocha_1.beforeEach)(async () => {
+        testCollection = (0, lib_1.getCollection)('withTransactionTests');
+        await testCollection.drop().catch(lodash_1.noop);
+        await testCollection.insertOne({}); // ensure the collection is created before tests
+    });
+    (0, mocha_1.it)('should commit the transaction', async () => {
+        const expectedReturnValue = { some: 'value' };
+        const returnValue = await (0, lib_1.withTransaction)(async (session) => {
+            await testCollection.insertOne({}, { session });
+            await testCollection.insertOne({}, { session });
+            assert_1.default.equal(await testCollection.countDocuments({}, { session }), 3);
+            return expectedReturnValue;
+        });
+        assert_1.default.equal(await testCollection.countDocuments({}), 3, 'there should available documents after a commit');
+        assert_1.default.equal(returnValue, expectedReturnValue);
+    });
+    (0, mocha_1.it)('should rollback the transaction', async () => {
+        const error = new Error('some error');
+        await assert_1.default.rejects(() => (0, lib_1.withTransaction)(async (session) => {
+            await testCollection.insertOne({}, { session });
+            await testCollection.insertOne({}, { session });
+            assert_1.default.equal(await testCollection.countDocuments({}, { session }), 3);
+            throw error;
+        }), error);
+        assert_1.default.equal(await testCollection.countDocuments({}), 1, 'there should be no document after a rollback');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2l0aFRyYW5zYWN0aW9uLnRlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJ3aXRoVHJhbnNhY3Rpb24udGVzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLG9EQUE0QjtBQUM1QixtQ0FBOEI7QUFDOUIsaUNBQWlEO0FBRWpELGdDQUF3RDtBQUV4RCxPQUFPLENBQUMsa0JBQWtCLENBQUMsQ0FBQztBQUU1QixJQUFBLGdCQUFRLEVBQUMsa0NBQWtDLEVBQUUsR0FBRyxFQUFFO0lBRTlDLElBQUksY0FBMEIsQ0FBQztJQUMvQixJQUFBLGtCQUFVLEVBQUMsS0FBSyxJQUFJLEVBQUU7UUFDbEIsY0FBYyxHQUFHLElBQUEsbUJBQWEsRUFBQyxzQkFBc0IsQ0FBQyxDQUFDO1FBQ3ZELE1BQU0sY0FBYyxDQUFDLElBQUksRUFBRSxDQUFDLEtBQUssQ0FBQyxhQUFJLENBQUMsQ0FBQztRQUN4QyxNQUFNLGNBQWMsQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFRLENBQUMsQ0FBQyxnREFBZ0Q7SUFDL0YsQ0FBQyxDQUFDLENBQUM7SUFFSCxJQUFBLFVBQUUsRUFBQywrQkFBK0IsRUFBRSxLQUFLLElBQUksRUFBRTtRQUUzQyxNQUFNLG1CQUFtQixHQUFHLEVBQUUsSUFBSSxFQUFFLE9BQU8sRUFBRSxDQUFDO1FBRTlDLE1BQU0sV0FBVyxHQUFHLE1BQU0sSUFBQSxxQkFBZSxFQUFDLEtBQUssRUFBRSxPQUFPLEVBQUUsRUFBRTtZQUV4RCxNQUFNLGNBQWMsQ0FBQyxTQUFTLENBQUMsRUFBRSxFQUFFLEVBQUUsT0FBTyxFQUFFLENBQUMsQ0FBQztZQUNoRCxNQUFNLGNBQWMsQ0FBQyxTQUFTLENBQUMsRUFBRSxFQUFFLEVBQUUsT0FBTyxFQUFFLENBQUMsQ0FBQztZQUVoRCxnQkFBTSxDQUFDLEtBQUssQ0FDUixNQUFNLGNBQWMsQ0FBQyxjQUFjLENBQUMsRUFBRSxFQUFFLEVBQUUsT0FBTyxFQUFFLENBQUMsRUFDcEQsQ0FBQyxDQUNKLENBQUM7WUFFRixPQUFPLG1CQUFtQixDQUFDO1FBQy9CLENBQUMsQ0FBQyxDQUFDO1FBRUgsZ0JBQU0sQ0FBQyxLQUFLLENBQ1IsTUFBTSxjQUFjLENBQUMsY0FBYyxDQUFDLEVBQUUsQ0FBQyxFQUN2QyxDQUFDLEVBQ0QsaURBQWlELENBQ3BELENBQUM7UUFFRixnQkFBTSxDQUFDLEtBQUssQ0FBQyxXQUFXLEVBQUUsbUJBQW1CLENBQUMsQ0FBQztJQUNuRCxDQUFDLENBQUMsQ0FBQztJQUVILElBQUEsVUFBRSxFQUFDLGlDQUFpQyxFQUFFLEtBQUssSUFBSSxFQUFFO1FBQzdDLE1BQU0sS0FBSyxHQUFHLElBQUksS0FBSyxDQUFDLFlBQVksQ0FBQyxDQUFDO1FBRXRDLE1BQU0sZ0JBQU0sQ0FBQyxPQUFPLENBQUMsR0FBRyxFQUFFLENBQUMsSUFBQSxxQkFBZSxFQUFDLEtBQUssRUFBRSxPQUFPLEVBQUUsRUFBRTtZQUV6RCxNQUFNLGNBQWMsQ0FBQyxTQUFTLENBQUMsRUFBRSxFQUFFLEVBQUUsT0FBTyxFQUFFLENBQUMsQ0FBQztZQUNoRCxNQUFNLGNBQWMsQ0FBQyxTQUFTLENBQUMsRUFBRSxFQUFFLEVBQUUsT0FBTyxFQUFFLENBQUMsQ0FBQztZQUVoRCxnQkFBTSxDQUFDLEtBQUssQ0FDUixNQUFNLGNBQWMsQ0FBQyxjQUFjLENBQUMsRUFBRSxFQUFFLEVBQUUsT0FBTyxFQUFFLENBQUMsRUFDcEQsQ0FBQyxDQUNKLENBQUM7WUFFRixNQUFNLEtBQUssQ0FBQztRQUVoQixDQUFDLENBQUMsRUFBRSxLQUFLLENBQUMsQ0FBQztRQUVYLGdCQUFNLENBQUMsS0FBSyxDQUNSLE1BQU0sY0FBYyxDQUFDLGNBQWMsQ0FBQyxFQUFFLENBQUMsRUFDdkMsQ0FBQyxFQUNELDhDQUE4QyxDQUNqRCxDQUFDO0lBQ04sQ0FBQyxDQUFDLENBQUM7QUFDUCxDQUFDLENBQUMsQ0FBQyJ9

package/__tests__/withTransaction.test.ts

@@ -0,0 +1,67 @@
+import assert from 'assert';
+import { noop } from 'lodash';
+import { beforeEach, describe, it } from 'mocha';
+import { Collection } from 'mongodb';
+import { getCollection, withTransaction } from '../lib';
+
+require('./getMongoClient');
+
+describe('packages/mongodb/withTransaction', () => {
+
+    let testCollection: Collection;
+    beforeEach(async () => {
+        testCollection = getCollection('withTransactionTests');
+        await testCollection.drop().catch(noop);
+        await testCollection.insertOne({}) as any; // ensure the collection is created before tests
+    });
+
+    it('should commit the transaction', async () => {
+
+        const expectedReturnValue = { some: 'value' };
+
+        const returnValue = await withTransaction(async (session) => {
+
+            await testCollection.insertOne({}, { session });
+            await testCollection.insertOne({}, { session });
+
+            assert.equal(
+                await testCollection.countDocuments({}, { session }),
+                3,
+            );
+
+            return expectedReturnValue;
+        });
+
+        assert.equal(
+            await testCollection.countDocuments({}),
+            3,
+            'there should available documents after a commit',
+        );
+
+        assert.equal(returnValue, expectedReturnValue);
+    });
+
+    it('should rollback the transaction', async () => {
+        const error = new Error('some error');
+
+        await assert.rejects(() => withTransaction(async (session) => {
+
+            await testCollection.insertOne({}, { session });
+            await testCollection.insertOne({}, { session });
+
+            assert.equal(
+                await testCollection.countDocuments({}, { session }),
+                3,
+            );
+
+            throw error;
+
+        }), error);
+
+        assert.equal(
+            await testCollection.countDocuments({}),
+            1,
+            'there should be no document after a rollback',
+        );
+    });
+});

package/lib/appData/index.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getCollection_1 = __importDefault(require("../getCollection"));
+const mongoDuplicateKeyErrorCodes = [11000, 11001];
+const appData = {
+    get _collection() {
+        return (0, getCollection_1.default)('appData');
+    },
+    _failReads: 0,
+    ensureDocumentExists(document) {
+        return this._collection
+            .insertOne(document)
+            .catch((err) => (new Promise((resolve, reject) => {
+            if (!mongoDuplicateKeyErrorCodes.includes(err.code)) {
+                reject(err);
+                return;
+            }
+            resolve(null);
+        })));
+    },
+    updateDocument(_id, update, upsert = false) {
+        const query = { _id };
+        const options = {
+            returnOriginal: false,
+            upsert,
+        };
+        return this._collection
+            .findOneAndUpdate(query, update, options)
+            .then((result) => result.value);
+    },
+    getDocument(_id) {
+        const query = { _id };
+        return this._collection.findOne(query);
+    },
+};
+exports.default = appData;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUNBLHFFQUE2QztBQUc3QyxNQUFNLDJCQUEyQixHQUFHLENBQUMsS0FBSyxFQUFFLEtBQUssQ0FBQyxDQUFDO0FBRW5ELE1BQU0sT0FBTyxHQUFHO0lBRVosSUFBSSxXQUFXO1FBQ1gsT0FBTyxJQUFBLHVCQUFhLEVBQUMsU0FBUyxDQUFDLENBQUM7SUFDcEMsQ0FBQztJQUVELFVBQVUsRUFBRSxDQUFDO0lBRWIsb0JBQW9CLENBQUUsUUFBc0I7UUFDeEMsT0FBTyxJQUFJLENBQUMsV0FBVzthQUNsQixTQUFTLENBQUMsUUFBZSxDQUFDO2FBQzFCLEtBQUssQ0FBQyxDQUFDLEdBQVEsRUFBRSxFQUFFLENBQUMsQ0FDakIsSUFBSSxPQUFPLENBQUMsQ0FBQyxPQUFPLEVBQUUsTUFBTSxFQUFFLEVBQUU7WUFDNUIsSUFBSSxDQUFDLDJCQUEyQixDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLEVBQUU7Z0JBQ2pELE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQztnQkFFWixPQUFPO2FBQ1Y7WUFDRCxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDbEIsQ0FBQyxDQUFDLENBQ0wsQ0FBQyxDQUFDO0lBQ1gsQ0FBQztJQUVELGNBQWMsQ0FBRSxHQUFRLEVBQUUsTUFBYyxFQUFFLFNBQWtCLEtBQUs7UUFDN0QsTUFBTSxLQUFLLEdBQUcsRUFBRSxHQUFHLEVBQUUsQ0FBQztRQUN0QixNQUFNLE9BQU8sR0FBRztZQUNaLGNBQWMsRUFBRSxLQUFLO1lBQ3JCLE1BQU07U0FDVCxDQUFDO1FBQ0YsT0FBTyxJQUFJLENBQUMsV0FBVzthQUNsQixnQkFBZ0IsQ0FBQyxLQUFLLEVBQUUsTUFBTSxFQUFFLE9BQU8sQ0FBQzthQUN4QyxJQUFJLENBQUMsQ0FBQyxNQUFNLEVBQUUsRUFBRSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUN4QyxDQUFDO0lBRUQsV0FBVyxDQUFFLEdBQVE7UUFDakIsTUFBTSxLQUFLLEdBQUcsRUFBRSxHQUFHLEVBQUUsQ0FBQztRQUN0QixPQUFPLElBQUksQ0FBQyxXQUFXLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQzNDLENBQUM7Q0FFSixDQUFDO0FBRUYsa0JBQWUsT0FBTyxDQUFDIn0=

package/lib/appData/index.ts

@@ -0,0 +1,48 @@
+import { InsertOneResult, WithId } from 'mongodb';
+import getCollection from '../getCollection';
+import { Key } from '../mongoClient';
+
+const mongoDuplicateKeyErrorCodes = [11000, 11001];
+
+const appData = {
+
+    get _collection () {
+        return getCollection('appData');
+    },
+
+    _failReads: 0,
+
+    ensureDocumentExists (document: { _id: Key }): Promise<Document | InsertOneResult | null> {
+        return this._collection
+            .insertOne(document as any)
+            .catch((err: any) => (
+                new Promise((resolve, reject) => {
+                    if (!mongoDuplicateKeyErrorCodes.includes(err.code)) {
+                        reject(err);
+
+                        return;
+                    }
+                    resolve(null);
+                })
+            ));
+    },
+
+    updateDocument (_id: Key, update: Object, upsert: boolean = false): Promise<WithId<any| null>> {
+        const query = { _id };
+        const options = {
+            returnOriginal: false,
+            upsert,
+        };
+        return this._collection
+            .findOneAndUpdate(query, update, options)
+            .then((result) => result.value);
+    },
+
+    getDocument (_id: Key): Promise<WithId<any| null>> {
+        const query = { _id };
+        return this._collection.findOne(query);
+    },
+
+};
+
+export default appData;

package/lib/concurrentTask.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("@storyous/errors");
+const attemptRecursive = async (task, startAttemptsDelay, latestTime, callNumber) => (task().catch(async (err) => {
+    if (errors_1.AppError.isConcurrentRequestError(err)) {
+        const nextCallDelay = startAttemptsDelay * (callNumber ** 2);
+        if ((Date.now() + nextCallDelay) < latestTime) {
+            await new Promise((resolve) => { setTimeout(resolve, nextCallDelay); });
+            return attemptRecursive(task, startAttemptsDelay, latestTime, ++callNumber);
+        }
+    }
+    throw err;
+}));
+/**
+ * noLaterThan = In what time by now should be the latest attempt executed
+ * startAttemptsDelay = Starting attempts delay
+ */
+const concurrentTask = async (task, { noLaterThan = 2000, startAttemptsDelay = 50 } = {}) => (attemptRecursive(task, startAttemptsDelay, Date.now() + noLaterThan, 1));
+exports.default = concurrentTask;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uY3VycmVudFRhc2suanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJjb25jdXJyZW50VGFzay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLDZDQUE0QztBQUU1QyxNQUFNLGdCQUFnQixHQUFHLEtBQUssRUFDMUIsSUFBc0IsRUFDdEIsa0JBQTBCLEVBQzFCLFVBQWtCLEVBQ2xCLFVBQWtCLEVBQ04sRUFBRSxDQUFDLENBQ2YsSUFBSSxFQUFFLENBQUMsS0FBSyxDQUFDLEtBQUssRUFBRSxHQUFVLEVBQUUsRUFBRTtJQUM5QixJQUFJLGlCQUFRLENBQUMsd0JBQXdCLENBQUMsR0FBRyxDQUFDLEVBQUU7UUFDeEMsTUFBTSxhQUFhLEdBQUcsa0JBQWtCLEdBQUcsQ0FBQyxVQUFVLElBQUksQ0FBQyxDQUFDLENBQUM7UUFDN0QsSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUsR0FBRyxhQUFhLENBQUMsR0FBRyxVQUFVLEVBQUU7WUFDM0MsTUFBTSxJQUFJLE9BQU8sQ0FBQyxDQUFDLE9BQU8sRUFBRSxFQUFFLEdBQUcsVUFBVSxDQUFDLE9BQU8sRUFBRSxhQUFhLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO1lBQ3hFLE9BQU8sZ0JBQWdCLENBQUMsSUFBSSxFQUFFLGtCQUFrQixFQUFFLFVBQVUsRUFBRSxFQUFFLFVBQVUsQ0FBQyxDQUFDO1NBQy9FO0tBQ0o7SUFFRCxNQUFNLEdBQUcsQ0FBQztBQUNkLENBQUMsQ0FBQyxDQUNMLENBQUM7QUFFRjs7O0dBR0c7QUFDSCxNQUFNLGNBQWMsR0FBRyxLQUFLLEVBQU0sSUFBc0IsRUFBRSxFQUFFLFdBQVcsR0FBRyxJQUFJLEVBQUUsa0JBQWtCLEdBQUcsRUFBRSxFQUFFLEdBQUcsRUFBRSxFQUFFLEVBQUUsQ0FBQyxDQUMvRyxnQkFBZ0IsQ0FBQyxJQUFJLEVBQUUsa0JBQWtCLEVBQUUsSUFBSSxDQUFDLEdBQUcsRUFBRSxHQUFHLFdBQVcsRUFBRSxDQUFDLENBQUMsQ0FDMUUsQ0FBQztBQUVGLGtCQUFlLGNBQWMsQ0FBQyJ9

package/lib/concurrentTask.ts

@@ -0,0 +1,30 @@
+import { AppError } from '@storyous/errors';
+
+const attemptRecursive = async <T> (
+    task: () => Promise<T>,
+    startAttemptsDelay: number,
+    latestTime: number,
+    callNumber: number,
+): Promise<any> => (
+    task().catch(async (err: Error) => {
+        if (AppError.isConcurrentRequestError(err)) {
+            const nextCallDelay = startAttemptsDelay * (callNumber ** 2);
+            if ((Date.now() + nextCallDelay) < latestTime) {
+                await new Promise((resolve) => { setTimeout(resolve, nextCallDelay); });
+                return attemptRecursive(task, startAttemptsDelay, latestTime, ++callNumber);
+            }
+        }
+
+        throw err;
+    })
+);
+
+/**
+ * noLaterThan = In what time by now should be the latest attempt executed
+ * startAttemptsDelay = Starting attempts delay
+ */
+const concurrentTask = async <T> (task: () => Promise<T>, { noLaterThan = 2000, startAttemptsDelay = 50 } = {}) => (
+    attemptRecursive(task, startAttemptsDelay, Date.now() + noLaterThan, 1)
+);
+
+export default concurrentTask;

package/lib/fixtures.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = require("lodash");
+const fixtures = {
+    ensureInCollection(_fixtures, collection) {
+        const fixtureIds = [];
+        const objectMap = {};
+        _fixtures.forEach((object) => {
+            fixtureIds.push(object._id);
+            objectMap[object._id.toString()] = object;
+        });
+        return collection.find({ _id: { $in: fixtureIds } })
+            .toArray()
+            .then((existing) => {
+            existing.forEach((object) => {
+                const stringId = object._id.toString();
+                delete objectMap[stringId];
+            });
+            const filteredObjects = (0, lodash_1.toArray)(objectMap);
+            if (filteredObjects.length) {
+                return collection.insertMany(filteredObjects);
+            }
+            return Promise.resolve(null);
+        });
+    },
+};
+exports.default = fixtures;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZml4dHVyZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJmaXh0dXJlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLG1DQUFpQztBQUdqQyxNQUFNLFFBQVEsR0FBRztJQUNiLGtCQUFrQixDQUFFLFNBQXFCLEVBQUUsVUFBc0I7UUFDN0QsTUFBTSxVQUFVLEdBQWUsRUFBRSxDQUFDO1FBQ2xDLE1BQU0sU0FBUyxHQUE2QixFQUFFLENBQUM7UUFFL0MsU0FBUyxDQUFDLE9BQU8sQ0FBQyxDQUFDLE1BQU0sRUFBRSxFQUFFO1lBQ3pCLFVBQVUsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDO1lBQzVCLFNBQVMsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLFFBQVEsRUFBRSxDQUFDLEdBQUcsTUFBTSxDQUFDO1FBQzlDLENBQUMsQ0FBQyxDQUFDO1FBRUgsT0FBTyxVQUFVLENBQUMsSUFBSSxDQUNsQixFQUFFLEdBQUcsRUFBRSxFQUFFLEdBQUcsRUFBRSxVQUFVLEVBQUUsRUFBRSxDQUMvQjthQUNJLE9BQU8sRUFBRTthQUNULElBQUksQ0FDRCxDQUFDLFFBQVEsRUFBRSxFQUFFO1lBQ1QsUUFBUSxDQUFDLE9BQU8sQ0FBQyxDQUFDLE1BQU0sRUFBRSxFQUFFO2dCQUN4QixNQUFNLFFBQVEsR0FBRyxNQUFNLENBQUMsR0FBRyxDQUFDLFFBQVEsRUFBRSxDQUFDO2dCQUN2QyxPQUFPLFNBQVMsQ0FBQyxRQUFRLENBQUMsQ0FBQztZQUMvQixDQUFDLENBQUMsQ0FBQztZQUVILE1BQU0sZUFBZSxHQUFlLElBQUEsZ0JBQU8sRUFBQyxTQUFTLENBQUMsQ0FBQztZQUV2RCxJQUFJLGVBQWUsQ0FBQyxNQUFNLEVBQUU7Z0JBQ3hCLE9BQU8sVUFBVSxDQUFDLFVBQVUsQ0FBQyxlQUFlLENBQUMsQ0FBQzthQUNqRDtZQUVELE9BQU8sT0FBTyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUNqQyxDQUFDLENBQUMsQ0FBQztJQUNmLENBQUM7Q0FDSixDQUFDO0FBRUYsa0JBQWUsUUFBUSxDQUFDIn0=

package/lib/fixtures.ts

@@ -0,0 +1,36 @@
+import { toArray } from 'lodash';
+import { Collection, Document, ObjectId } from 'mongodb';
+
+const fixtures = {
+    ensureInCollection (_fixtures: Document[], collection: Collection): Promise<any> {
+        const fixtureIds: ObjectId[] = [];
+        const objectMap: Record<string, Document> = {};
+
+        _fixtures.forEach((object) => {
+            fixtureIds.push(object._id);
+            objectMap[object._id.toString()] = object;
+        });
+
+        return collection.find(
+            { _id: { $in: fixtureIds } },
+        )
+            .toArray()
+            .then(
+                (existing) => {
+                    existing.forEach((object) => {
+                        const stringId = object._id.toString();
+                        delete objectMap[stringId];
+                    });
+
+                    const filteredObjects: Document[] = toArray(objectMap);
+
+                    if (filteredObjects.length) {
+                        return collection.insertMany(filteredObjects);
+                    }
+
+                    return Promise.resolve(null);
+                });
+    },
+};
+
+export default fixtures;

package/lib/getCollection.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoClient_1 = __importDefault(require("./mongoClient"));
+exports.default = (name) => mongoClient_1.default.getClient().db().collection(name);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0Q29sbGVjdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImdldENvbGxlY3Rpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFDQSxnRUFBd0M7QUFFeEMsa0JBQWUsQ0FBSSxJQUFZLEVBQWlCLEVBQUUsQ0FBQyxxQkFBVyxDQUFDLFNBQVMsRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsQ0FBQyJ9

package/lib/getCollection.ts

@@ -0,0 +1,4 @@
+import { Collection } from 'mongodb';
+import mongoClient from './mongoClient';
+
+export default <T>(name: string): Collection<T> => mongoClient.getClient().db().collection(name);

package/lib/getMongoLocker.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("@storyous/errors");
+const mongodb_1 = require("mongodb");
+const concurrentTask_1 = __importDefault(require("./concurrentTask"));
+const mongoErrorCodes_1 = __importDefault(require("./mongoErrorCodes"));
+const _removeDeprecatedIndex = async (collection) => {
+    const collectionStats = await collection.stats();
+    if (collectionStats.indexDetails.acquiredAt_1) {
+        await collection.dropIndex('acquiredAt_1');
+    }
+};
+exports.default = async (collection) => {
+    await _removeDeprecatedIndex(collection);
+    await collection.createIndex({ expiresAt: 1 }, { expireAfterSeconds: 0 });
+    return async (key, callback, { noLaterThan = 1000, startAttemptsDelay = 50, expireIn = 120000 } = {}) => {
+        const lockId = new mongodb_1.ObjectId();
+        const releaseLock = () => collection.deleteOne({ _id: key, lockId });
+        const acquireLock = async () => {
+            try {
+                const now = new Date();
+                /**
+                 * 3 possible situations
+                 * a) There is no lock -> upsert will create the document
+                 * b) There is an expired lock -> expiresAt: { $lte: now } will match and the document will be replaced
+                 * c) There is an unexpired lock -> expiresAt: { $lte: now } will not match,
+                 * database will try to insert the new one, but it will fail on duplicate key (_id) error
+                 */
+                await collection.replaceOne({ _id: key, expiresAt: { $lte: now } }, 
+                // replaceOne will use the _id from filter parameter when inserting new document
+                { lockId, expiresAt: new Date(now.getTime() + expireIn) }, { upsert: true });
+            }
+            catch (err) {
+                if (mongoErrorCodes_1.default.DUPLICATE_KEY.includes(err.code)) {
+                    throw errors_1.AppError.concurrentRequest('The lock is already acquired.');
+                }
+                await releaseLock(); // the lock could be possible acquired
+                throw err;
+            }
+        };
+        await (0, concurrentTask_1.default)(acquireLock, { noLaterThan, startAttemptsDelay });
+        try {
+            return await callback();
+        }
+        finally {
+            await releaseLock();
+        }
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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