@storyous/mongodb 1.0.8 → 1.0.9

package/__tests__/appData.test.d.ts

@@ -0,0 +1 @@
+import './getMongoClient';

package/__tests__/appData.test.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./getMongoClient");
+const assert_1 = __importDefault(require("assert"));
+const mocha_1 = require("mocha");
+const lib_1 = require("../lib");
+(0, mocha_1.describe)('packages/mongodb/appData', () => {
+    (0, mocha_1.it)('should ensureDocumentExists works', async () => {
+        const testDocument = { _id: new lib_1.ObjectId() };
+        const res = await lib_1.appData.ensureDocumentExists(testDocument);
+        assert_1.default.deepStrictEqual(res?.acknowledged, true);
+        const resAgain = await lib_1.appData.ensureDocumentExists(testDocument);
+        assert_1.default.deepStrictEqual(resAgain, null);
+    });
+    (0, mocha_1.it)('should updateDocument works', async () => {
+        const testDocument = { _id: new lib_1.ObjectId() };
+        await lib_1.appData.ensureDocumentExists(testDocument);
+        await lib_1.appData.updateDocument(testDocument._id, { $set: { foo: 'bar' } });
+        const res = await lib_1.appData.getDocument(testDocument._id);
+        assert_1.default.deepStrictEqual(res?.foo, 'bar');
+    });
+    (0, mocha_1.it)('should updateDocument works wit upsert', async () => {
+        const testDocument = { _id: new lib_1.ObjectId() };
+        await lib_1.appData.updateDocument(testDocument._id, { $set: { foo: 'bar' } }, true);
+        const res = await lib_1.appData.getDocument(testDocument._id);
+        assert_1.default.deepStrictEqual(res?.foo, 'bar');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwRGF0YS50ZXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiYXBwRGF0YS50ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsNEJBQTBCO0FBQzFCLG9EQUE0QjtBQUM1QixpQ0FBcUM7QUFDckMsZ0NBQTJDO0FBRTNDLElBQUEsZ0JBQVEsRUFBQywwQkFBMEIsRUFBRSxHQUFHLEVBQUU7SUFFdEMsSUFBQSxVQUFFLEVBQUMsbUNBQW1DLEVBQUUsS0FBSyxJQUFJLEVBQUU7UUFDL0MsTUFBTSxZQUFZLEdBQUcsRUFBRSxHQUFHLEVBQUUsSUFBSSxjQUFRLEVBQUUsRUFBRSxDQUFDO1FBRTdDLE1BQU0sR0FBRyxHQUFHLE1BQU0sYUFBTyxDQUFDLG9CQUFvQixDQUFDLFlBQVksQ0FBUSxDQUFDO1FBQ3BFLGdCQUFNLENBQUMsZUFBZSxDQUFDLEdBQUcsRUFBRSxZQUFZLEVBQUUsSUFBSSxDQUFDLENBQUM7UUFFaEQsTUFBTSxRQUFRLEdBQUcsTUFBTSxhQUFPLENBQUMsb0JBQW9CLENBQUMsWUFBWSxDQUFDLENBQUM7UUFDbEUsZ0JBQU0sQ0FBQyxlQUFlLENBQUMsUUFBUSxFQUFFLElBQUksQ0FBQyxDQUFDO0lBQzNDLENBQUMsQ0FBQyxDQUFDO0lBRUgsSUFBQSxVQUFFLEVBQUMsNkJBQTZCLEVBQUUsS0FBSyxJQUFJLEVBQUU7UUFDekMsTUFBTSxZQUFZLEdBQUcsRUFBRSxHQUFHLEVBQUUsSUFBSSxjQUFRLEVBQUUsRUFBRSxDQUFDO1FBQzdDLE1BQU0sYUFBTyxDQUFDLG9CQUFvQixDQUFDLFlBQVksQ0FBQyxDQUFDO1FBQ2pELE1BQU0sYUFBTyxDQUFDLGNBQWMsQ0FBQyxZQUFZLENBQUMsR0FBRyxFQUFFLEVBQUUsSUFBSSxFQUFFLEVBQUUsR0FBRyxFQUFFLEtBQUssRUFBRSxFQUFFLENBQUMsQ0FBQztRQUV6RSxNQUFNLEdBQUcsR0FBRyxNQUFNLGFBQU8sQ0FBQyxXQUFXLENBQUMsWUFBWSxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ3hELGdCQUFNLENBQUMsZUFBZSxDQUFDLEdBQUcsRUFBRSxHQUFHLEVBQUUsS0FBSyxDQUFDLENBQUM7SUFDNUMsQ0FBQyxDQUFDLENBQUM7SUFFSCxJQUFBLFVBQUUsRUFBQyx3Q0FBd0MsRUFBRSxLQUFLLElBQUksRUFBRTtRQUNwRCxNQUFNLFlBQVksR0FBRyxFQUFFLEdBQUcsRUFBRSxJQUFJLGNBQVEsRUFBRSxFQUFFLENBQUM7UUFDN0MsTUFBTSxhQUFPLENBQUMsY0FBYyxDQUFDLFlBQVksQ0FBQyxHQUFHLEVBQUUsRUFBRSxJQUFJLEVBQUUsRUFBRSxHQUFHLEVBQUUsS0FBSyxFQUFFLEVBQUUsRUFBRSxJQUFJLENBQUMsQ0FBQztRQUUvRSxNQUFNLEdBQUcsR0FBRyxNQUFNLGFBQU8sQ0FBQyxXQUFXLENBQUMsWUFBWSxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ3hELGdCQUFNLENBQUMsZUFBZSxDQUFDLEdBQUcsRUFBRSxHQUFHLEVBQUUsS0FBSyxDQUFDLENBQUM7SUFDNUMsQ0FBQyxDQUFDLENBQUM7QUFDUCxDQUFDLENBQUMsQ0FBQyJ9

package/__tests__/appData.test.ts

@@ -0,0 +1,34 @@
+import './getMongoClient';
+import assert from 'assert';
+import { describe, it } from 'mocha';
+import { appData, ObjectId } from '../lib';
+
+describe('packages/mongodb/appData', () => {
+
+    it('should ensureDocumentExists works', async () => {
+        const testDocument = { _id: new ObjectId() };
+
+        const res = await appData.ensureDocumentExists(testDocument) as any;
+        assert.deepStrictEqual(res?.acknowledged, true);
+
+        const resAgain = await appData.ensureDocumentExists(testDocument);
+        assert.deepStrictEqual(resAgain, null);
+    });
+
+    it('should updateDocument works', async () => {
+        const testDocument = { _id: new ObjectId() };
+        await appData.ensureDocumentExists(testDocument);
+        await appData.updateDocument(testDocument._id, { $set: { foo: 'bar' } });
+
+        const res = await appData.getDocument(testDocument._id);
+        assert.deepStrictEqual(res?.foo, 'bar');
+    });
+
+    it('should updateDocument works wit upsert', async () => {
+        const testDocument = { _id: new ObjectId() };
+        await appData.updateDocument(testDocument._id, { $set: { foo: 'bar' } }, true);
+
+        const res = await appData.getDocument(testDocument._id);
+        assert.deepStrictEqual(res?.foo, 'bar');
+    });
+});

package/__tests__/fixtures.test.d.ts

@@ -0,0 +1 @@
+export {};

package/__tests__/fixtures.test.js

@@ -0,0 +1,39 @@
+"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");
+const getMongoClient_1 = __importDefault(require("./getMongoClient"));
+(0, mocha_1.describe)('packages/mongodb/fixtures', () => {
+    let mongoClient;
+    let collection;
+    const collectionName = 'currency';
+    const oldArray = [
+        { _id: new lib_1.ObjectId(), name: 'CZK' },
+        { _id: new lib_1.ObjectId(), name: 'EUR' },
+    ];
+    const newArray = [
+        ...oldArray,
+        { _id: new lib_1.ObjectId(), name: 'USD' },
+    ];
+    (0, mocha_1.before)(async () => {
+        mongoClient = await (0, getMongoClient_1.default)();
+        collection = mongoClient.db().collection(collectionName);
+    });
+    (0, mocha_1.beforeEach)(async () => {
+        await collection.drop().catch(lodash_1.noop);
+    });
+    (0, mocha_1.it)('should fixtures work', async () => {
+        await lib_1.fixtures.ensureInCollection(oldArray, collection);
+        assert_1.default.deepStrictEqual(await collection.countDocuments(), 2);
+        await lib_1.fixtures.ensureInCollection(oldArray, collection);
+        assert_1.default.deepStrictEqual(await collection.countDocuments(), 2);
+        await lib_1.fixtures.ensureInCollection(newArray, collection);
+        assert_1.default.deepStrictEqual(await collection.countDocuments(), 3);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZml4dHVyZXMudGVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImZpeHR1cmVzLnRlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSxvREFBNEI7QUFDNUIsbUNBQThCO0FBQzlCLGlDQUVlO0FBRWYsZ0NBQTRDO0FBQzVDLHNFQUF3RDtBQUV4RCxJQUFBLGdCQUFRLEVBQUMsMkJBQTJCLEVBQUUsR0FBRyxFQUFFO0lBQ3ZDLElBQUksV0FBd0IsQ0FBQztJQUM3QixJQUFJLFVBQXNCLENBQUM7SUFDM0IsTUFBTSxjQUFjLEdBQUcsVUFBVSxDQUFDO0lBRWxDLE1BQU0sUUFBUSxHQUFHO1FBQ2IsRUFBRSxHQUFHLEVBQUUsSUFBSSxjQUFRLEVBQUUsRUFBRSxJQUFJLEVBQUUsS0FBSyxFQUFFO1FBQ3BDLEVBQUUsR0FBRyxFQUFFLElBQUksY0FBUSxFQUFFLEVBQUUsSUFBSSxFQUFFLEtBQUssRUFBRTtLQUN2QyxDQUFDO0lBRUYsTUFBTSxRQUFRLEdBQUc7UUFDYixHQUFHLFFBQVE7UUFDWCxFQUFFLEdBQUcsRUFBRSxJQUFJLGNBQVEsRUFBRSxFQUFFLElBQUksRUFBRSxLQUFLLEVBQUU7S0FDdkMsQ0FBQztJQUVGLElBQUEsY0FBTSxFQUFDLEtBQUssSUFBSSxFQUFFO1FBQ2QsV0FBVyxHQUFHLE1BQU0sSUFBQSx3QkFBd0IsR0FBRSxDQUFDO1FBQy9DLFVBQVUsR0FBRyxXQUFXLENBQUMsRUFBRSxFQUFFLENBQUMsVUFBVSxDQUFDLGNBQWMsQ0FBQyxDQUFDO0lBQzdELENBQUMsQ0FBQyxDQUFDO0lBRUgsSUFBQSxrQkFBVSxFQUFDLEtBQUssSUFBSSxFQUFFO1FBQ2xCLE1BQU0sVUFBVSxDQUFDLElBQUksRUFBRSxDQUFDLEtBQUssQ0FBQyxhQUFJLENBQUMsQ0FBQztJQUN4QyxDQUFDLENBQUMsQ0FBQztJQUVILElBQUEsVUFBRSxFQUFDLHNCQUFzQixFQUFFLEtBQUssSUFBSSxFQUFFO1FBQ2xDLE1BQU0sY0FBUSxDQUFDLGtCQUFrQixDQUFDLFFBQVEsRUFBRSxVQUFVLENBQUMsQ0FBQztRQUN4RCxnQkFBTSxDQUFDLGVBQWUsQ0FBQyxNQUFNLFVBQVUsQ0FBQyxjQUFjLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQztRQUU3RCxNQUFNLGNBQVEsQ0FBQyxrQkFBa0IsQ0FBQyxRQUFRLEVBQUUsVUFBVSxDQUFDLENBQUM7UUFDeEQsZ0JBQU0sQ0FBQyxlQUFlLENBQUMsTUFBTSxVQUFVLENBQUMsY0FBYyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUM7UUFFN0QsTUFBTSxjQUFRLENBQUMsa0JBQWtCLENBQUMsUUFBUSxFQUFFLFVBQVUsQ0FBQyxDQUFDO1FBQ3hELGdCQUFNLENBQUMsZUFBZSxDQUFDLE1BQU0sVUFBVSxDQUFDLGNBQWMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQ2pFLENBQUMsQ0FBQyxDQUFDO0FBQ1AsQ0FBQyxDQUFDLENBQUMifQ==

package/__tests__/fixtures.test.ts

@@ -0,0 +1,44 @@
+import assert from 'assert';
+import { noop } from 'lodash';
+import {
+    before, beforeEach, describe, it,
+} from 'mocha';
+import { Collection, MongoClient } from 'mongodb';
+import { fixtures, ObjectId } from '../lib';
+import connectAndGetMongoClient from './getMongoClient';
+
+describe('packages/mongodb/fixtures', () => {
+    let mongoClient: MongoClient;
+    let collection: Collection;
+    const collectionName = 'currency';
+
+    const oldArray = [
+        { _id: new ObjectId(), name: 'CZK' },
+        { _id: new ObjectId(), name: 'EUR' },
+    ];
+
+    const newArray = [
+        ...oldArray,
+        { _id: new ObjectId(), name: 'USD' },
+    ];
+
+    before(async () => {
+        mongoClient = await connectAndGetMongoClient();
+        collection = mongoClient.db().collection(collectionName);
+    });
+
+    beforeEach(async () => {
+        await collection.drop().catch(noop);
+    });
+
+    it('should fixtures work', async () => {
+        await fixtures.ensureInCollection(oldArray, collection);
+        assert.deepStrictEqual(await collection.countDocuments(), 2);
+
+        await fixtures.ensureInCollection(oldArray, collection);
+        assert.deepStrictEqual(await collection.countDocuments(), 2);
+
+        await fixtures.ensureInCollection(newArray, collection);
+        assert.deepStrictEqual(await collection.countDocuments(), 3);
+    });
+});

package/__tests__/getMongoClient.d.ts

@@ -0,0 +1,3 @@
+import { MongoClient } from 'mongodb';
+declare const connectAndGetMongoClient: () => Promise<MongoClient>;
+export default connectAndGetMongoClient;

package/__tests__/getMongoClient.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mocha_1 = require("mocha");
+const lib_1 = require("../lib");
+let connectPromise;
+const connectAndGetMongoClient = async () => {
+    if (!connectPromise) {
+        lib_1.mongoClient.init('mongodb://127.0.0.1:27017', { directConnection: true });
+        connectPromise = lib_1.mongoClient.getClient().connect();
+    }
+    await connectPromise;
+    return lib_1.mongoClient.getClient();
+};
+(0, mocha_1.before)(() => connectAndGetMongoClient());
+(0, mocha_1.after)(async () => {
+    await lib_1.mongoClient.getClient().close();
+});
+exports.default = connectAndGetMongoClient;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0TW9uZ29DbGllbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJnZXRNb25nb0NsaWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLGlDQUFzQztBQUV0QyxnQ0FBcUM7QUFFckMsSUFBSSxjQUFvQyxDQUFDO0FBRXpDLE1BQU0sd0JBQXdCLEdBQUcsS0FBSyxJQUFJLEVBQUU7SUFDeEMsSUFBSSxDQUFDLGNBQWMsRUFBRTtRQUNqQixpQkFBVyxDQUFDLElBQUksQ0FBQywyQkFBMkIsRUFBRSxFQUFFLGdCQUFnQixFQUFFLElBQUksRUFBRSxDQUFDLENBQUM7UUFDMUUsY0FBYyxHQUFHLGlCQUFXLENBQUMsU0FBUyxFQUFFLENBQUMsT0FBTyxFQUFFLENBQUM7S0FDdEQ7SUFFRCxNQUFNLGNBQWMsQ0FBQztJQUVyQixPQUFPLGlCQUFXLENBQUMsU0FBUyxFQUFFLENBQUM7QUFDbkMsQ0FBQyxDQUFDO0FBRUYsSUFBQSxjQUFNLEVBQUMsR0FBRyxFQUFFLENBQUMsd0JBQXdCLEVBQUUsQ0FBQyxDQUFDO0FBRXpDLElBQUEsYUFBSyxFQUFDLEtBQUssSUFBSSxFQUFFO0lBQ2IsTUFBTSxpQkFBVyxDQUFDLFNBQVMsRUFBRSxDQUFDLEtBQUssRUFBRSxDQUFDO0FBQzFDLENBQUMsQ0FBQyxDQUFDO0FBRUgsa0JBQWUsd0JBQXdCLENBQUMifQ==

package/__tests__/getMongoClient.ts

@@ -0,0 +1,24 @@
+import { after, before } from 'mocha';
+import { MongoClient } from 'mongodb';
+import { mongoClient } from '../lib';
+
+let connectPromise: Promise<MongoClient>;
+
+const connectAndGetMongoClient = async () => {
+    if (!connectPromise) {
+        mongoClient.init('mongodb://127.0.0.1:27017', { directConnection: true });
+        connectPromise = mongoClient.getClient().connect();
+    }
+
+    await connectPromise;
+
+    return mongoClient.getClient();
+};
+
+before(() => connectAndGetMongoClient());
+
+after(async () => {
+    await mongoClient.getClient().close();
+});
+
+export default connectAndGetMongoClient;

package/{dist/migrations/template.d.ts → __tests__/migrations/1642152064249-test.d.ts}

@@ -1,3 +1,3 @@
-import Migration from './Migration';
+import { Migration } from '@storyous/mongodb';
 declare const _default: Migration;
 export = _default;

package/__tests__/migrations/1642152064249-test.js

@@ -0,0 +1,7 @@
+"use strict";
+const mongodb_1 = require("@storyous/mongodb");
+module.exports = new mongodb_1.Migration('empty testing migration', async () => {
+    const collection = await (0, mongodb_1.getCollection)('exampleCollection');
+    await collection.createIndex({ updated: 1 });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMTY0MjE1MjA2NDI0OS10ZXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiMTY0MjE1MjA2NDI0OS10ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSwrQ0FBNkQ7QUFFN0QsaUJBQVMsSUFBSSxtQkFBUyxDQUFDLHlCQUF5QixFQUFFLEtBQUssSUFBSSxFQUFFO0lBQ3pELE1BQU0sVUFBVSxHQUFHLE1BQU0sSUFBQSx1QkFBYSxFQUFDLG1CQUFtQixDQUFDLENBQUM7SUFFNUQsTUFBTSxVQUFVLENBQUMsV0FBVyxDQUFDLEVBQUUsT0FBTyxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUM7QUFDakQsQ0FBQyxDQUFDLENBQUMifQ==

package/__tests__/migrations/1642152064249-test.ts

@@ -0,0 +1,7 @@
+import { getCollection, Migration } from '@storyous/mongodb';
+
+export = new Migration('empty testing migration', async () => {
+    const collection = await getCollection('exampleCollection');
+
+    await collection.createIndex({ updated: 1 });
+});

package/__tests__/mongoLocker.test.d.ts

@@ -0,0 +1 @@
+export {};

package/__tests__/mongoLocker.test.js

@@ -0,0 +1,151 @@
+"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 sinon_1 = __importDefault(require("sinon"));
+const lib_1 = require("../lib");
+const getMongoClient_1 = __importDefault(require("./getMongoClient"));
+(0, mocha_1.describe)('packages/mongodb/mongoLocker', () => {
+    let mongoClient;
+    let collection;
+    const collectionName = 'customLocks';
+    (0, mocha_1.beforeEach)(async () => {
+        mongoClient = await (0, getMongoClient_1.default)();
+        collection = mongoClient.db().collection(collectionName);
+        await collection.drop().catch(lodash_1.noop);
+    });
+    [
+        { description: 'default mongoLocker instance', locker: () => lib_1.mongoLocker },
+        { description: 'custom getMongoLocker', locker: () => (0, lib_1.getMongoLocker)(collection) },
+    ]
+        .forEach((suite) => {
+        (0, mocha_1.describe)(suite.description, () => {
+            let locker;
+            (0, mocha_1.beforeEach)(async () => {
+                locker = await suite.locker();
+            });
+            (0, mocha_1.it)('should acquire and release a lock', async () => {
+                let i = 0;
+                const callback = sinon_1.default.spy(() => ++i);
+                const result1 = await locker('AAA', callback);
+                assert_1.default.strictEqual(result1, 1);
+                const result2 = await locker('AAA', callback);
+                assert_1.default.strictEqual(result2, 2);
+                assert_1.default.deepStrictEqual(callback.callCount, 2);
+            });
+            (0, mocha_1.it)('should not be possible to acquire the lock twice at once', async () => {
+                const callback = sinon_1.default.spy(() => new Promise((resolve) => { setTimeout(resolve, 50); }));
+                const callLocker = () => locker('AAA', callback, { noLaterThan: 0 });
+                const concurrency = 10;
+                const promises = (0, lodash_1.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) {
+                        (0, assert_1.default)(/The lock is already acquired./.test(err?.message));
+                        stats.failed++;
+                    }
+                }
+                assert_1.default.deepStrictEqual(callback.callCount, 1, 'The callback should be called only once');
+                assert_1.default.deepStrictEqual(stats, {
+                    resolved: 1,
+                    failed: concurrency - 1,
+                });
+            });
+            (0, mocha_1.it)('should propagate an error and release the lock if the callback fails', async () => {
+                await assert_1.default.rejects(() => locker('AAA', async () => {
+                    throw new Error('Some error occurred');
+                }), /Some error occurred/);
+                const callback = sinon_1.default.spy();
+                await locker('AAA', callback);
+                assert_1.default.strictEqual(callback.callCount, 1);
+            });
+            (0, mocha_1.it)('should be able to handle few concurrent tasks by waiting some time and acquire retries', async () => {
+                const callTimes = [];
+                const callback = sinon_1.default.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((0, lodash_1.times)(3, callLocker));
+                assert_1.default.strictEqual(callback.callCount, 3);
+                callTimes.forEach((time, i) => {
+                    if (i > 0) {
+                        (0, assert_1.default)(time > callTimes[i - 1], 'There was a parallel callback execution!');
+                    }
+                });
+            });
+            (0, mocha_1.it)('should be possible to override a lock which expired yet', async () => {
+                const expireIn = 500;
+                const array = [];
+                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_1.default.deepStrictEqual(array, [1, 2, 3]);
+            });
+        });
+    });
+    (0, mocha_1.describe)('getMongoLocker', () => {
+        (0, mocha_1.it)('should create and TTL index on the right field', async () => {
+            await mongoClient.db()
+                .createCollection(collectionName);
+            let indexes = await collection.indexes();
+            assert_1.default.deepStrictEqual(indexes.length, 1); // ensure there is only mandatory _id index
+            const locker = await (0, lib_1.getMongoLocker)(collection);
+            indexes = await collection.indexes();
+            assert_1.default.deepStrictEqual(indexes.length, 2, 'No or wrong indexes has been created!');
+            assert_1.default.deepStrictEqual((0, lodash_1.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_1.default.strictEqual(document?._id, someKey);
+                (0, assert_1.default)(document.expiresAt >= new Date(startedAt.getTime() + expireIn), 'The expiresAt property has to be greater then startedAt + expiresIn');
+                (0, assert_1.default)(document.expiresAt < new Date(Date.now() + expireIn), 'The acquiredAt property has to be younger then present + expiresIn');
+            }, { expireIn });
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mongoLocker.test.js","sourceRoot":"","sources":["mongoLocker.test.ts"],"names":[],"mappings":"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"}

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.d.ts

@@ -0,0 +1 @@
+import './getMongoClient';

package/__tests__/runMigration.test.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./getMongoClient");
+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 () => {
+        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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVuTWlncmF0aW9uLnRlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJydW5NaWdyYXRpb24udGVzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLDRCQUEwQjtBQUMxQixvREFBNEI7QUFDNUIsaUNBQTZDO0FBQzdDLHFDQUF1QztBQUN2QyxnQ0FBZ0Q7QUFFaEQsSUFBQSxnQkFBUSxFQUFDLDZCQUE2QixFQUFFLEdBQUcsRUFBRTtJQUN6QyxJQUFBLGNBQU0sRUFBQyxLQUFLLElBQUksRUFBRTtRQUNkLE1BQU0sYUFBTyxDQUFDLFdBQVcsQ0FBQyxTQUFTLENBQUMsRUFBRSxHQUFHLEVBQUUsWUFBWSxFQUFFLENBQUMsQ0FBQztJQUMvRCxDQUFDLENBQUMsQ0FBQztJQUVILElBQUEsVUFBRSxFQUFDLDRCQUE0QixFQUFFLEtBQUssSUFBSSxFQUFFO1FBQ3hDLE1BQU0sSUFBQSxtQkFBYSxFQUNmLElBQUEsc0JBQVksR0FBRSxFQUNkLEdBQUcsU0FBUyxhQUFhLEVBQ3pCLEVBQUUsYUFBYSxFQUFFLEtBQUssRUFBRSxDQUMzQixDQUFDO1FBRUYsTUFBTSxTQUFTLEdBQUcsTUFBTSxhQUFPLENBQUMsV0FBVyxDQUFDLFlBQVksQ0FBQyxDQUFDO1FBQzFELGdCQUFNLENBQUMsZUFBZSxDQUFDLFNBQVMsRUFBRSxPQUFPLEVBQUUsdUJBQXVCLENBQUMsQ0FBQztJQUN4RSxDQUFDLENBQUMsQ0FBQztBQUNQLENBQUMsQ0FBQyxDQUFDIn0=

package/__tests__/runMigration.test.ts

@@ -0,0 +1,22 @@
+import './getMongoClient';
+import assert from 'assert';
+import { before, describe, it } from 'mocha';
+import { createLogger } from 'winston';
+import { appData, runMigrations } from '../lib';
+
+describe('packages/mongodb/migrations', () => {
+    before(async () => {
+        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.d.ts

@@ -0,0 +1 @@
+export {};