@storyous/mongodb 1.0.0

package/lib/getMongoLocker.ts

@@ -0,0 +1,71 @@
+import { AppError } from '@storyous/errors';
+import { Collection, ObjectId } from 'mongodb';
+import concurrentTask from './concurrentTask';
+import { Key } from './mongoClient';
+import mongoErrorCodes from './mongoErrorCodes';
+
+export type LockCallback<T> = () => Promise<T>;
+
+export type LockerOptions = {
+    noLaterThan?: number,
+    startAttemptsDelay?: number
+    expireIn?: number
+};
+
+const _removeDeprecatedIndex = async (collection: Collection) => {
+    const collectionStats = await collection.stats();
+    if (collectionStats.indexDetails.acquiredAt_1) {
+        await collection.dropIndex('acquiredAt_1');
+    }
+};
+
+export default async (collection: Collection) => {
+
+    await _removeDeprecatedIndex(collection);
+    await collection.createIndex({ expiresAt: 1 }, { expireAfterSeconds: 0 });
+
+    return async <T>(
+        key: Key,
+        callback: LockCallback<T>,
+        { noLaterThan = 1000, startAttemptsDelay = 50, expireIn = 120000 }: LockerOptions = {},
+    ): Promise<T> => {
+
+        const lockId = new ObjectId();
+
+        const releaseLock = () => collection.deleteOne({ _id: key as any, 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 as any, 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:any) {
+                if (mongoErrorCodes.DUPLICATE_KEY.includes(err.code)) {
+                    throw AppError.concurrentRequest('The lock is already acquired.');
+                }
+                await releaseLock(); // the lock could be possible acquired
+                throw err;
+            }
+        };
+
+        await concurrentTask(acquireLock, { noLaterThan, startAttemptsDelay });
+
+        try {
+            return await callback();
+
+        } finally {
+            await releaseLock();
+        }
+    };
+};

package/lib/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withTransaction = exports.runMigrations = exports.mongoLocker = exports.mongoClient = exports.MigrationsStore = exports.Migration = exports.getMongoLocker = exports.getCollection = exports.fixtures = exports.appData = void 0;
+const appData_1 = __importDefault(require("./appData"));
+exports.appData = appData_1.default;
+const fixtures_1 = __importDefault(require("./fixtures"));
+exports.fixtures = fixtures_1.default;
+const getCollection_1 = __importDefault(require("./getCollection"));
+exports.getCollection = getCollection_1.default;
+const getMongoLocker_1 = __importDefault(require("./getMongoLocker"));
+exports.getMongoLocker = getMongoLocker_1.default;
+const Migration_1 = __importDefault(require("./migrations/Migration"));
+exports.Migration = Migration_1.default;
+const MigrationsStore_1 = __importDefault(require("./migrations/MigrationsStore"));
+exports.MigrationsStore = MigrationsStore_1.default;
+const runMigrations_1 = __importDefault(require("./migrations/runMigrations"));
+exports.runMigrations = runMigrations_1.default;
+const mongoClient_1 = __importDefault(require("./mongoClient"));
+exports.mongoClient = mongoClient_1.default;
+const mongoLocker_1 = __importDefault(require("./mongoLocker"));
+exports.mongoLocker = mongoLocker_1.default;
+const withTransaction_1 = __importDefault(require("./withTransaction"));
+exports.withTransaction = withTransaction_1.default;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7QUFBQSx3REFBZ0M7QUFZNUIsa0JBWkcsaUJBQU8sQ0FZSDtBQVhYLDBEQUFrQztBQVk5QixtQkFaRyxrQkFBUSxDQVlIO0FBWFosb0VBQTRDO0FBWXhDLHdCQVpHLHVCQUFhLENBWUg7QUFYakIsc0VBQStFO0FBWTNFLHlCQVpHLHdCQUFjLENBWUg7QUFYbEIsdUVBQStDO0FBYzNDLG9CQWRHLG1CQUFTLENBY0g7QUFiYixtRkFBMkQ7QUFjdkQsMEJBZEcseUJBQWUsQ0FjSDtBQWJuQiwrRUFBdUQ7QUFnQm5ELHdCQWhCRyx1QkFBYSxDQWdCSDtBQWZqQixnRUFBd0M7QUFhcEMsc0JBYkcscUJBQVcsQ0FhSDtBQVpmLGdFQUF3QztBQWFwQyxzQkFiRyxxQkFBVyxDQWFIO0FBWmYsd0VBQWdEO0FBYzVDLDBCQWRHLHlCQUFlLENBY0gifQ==

package/lib/index.ts

@@ -0,0 +1,25 @@
+import appData from './appData';
+import fixtures from './fixtures';
+import getCollection from './getCollection';
+import getMongoLocker, { LockCallback, LockerOptions } from './getMongoLocker';
+import Migration from './migrations/Migration';
+import MigrationsStore from './migrations/MigrationsStore';
+import runMigrations from './migrations/runMigrations';
+import mongoClient from './mongoClient';
+import mongoLocker from './mongoLocker';
+import withTransaction from './withTransaction';
+
+export {
+    appData,
+    fixtures,
+    getCollection,
+    getMongoLocker,
+    LockCallback,
+    LockerOptions,
+    Migration,
+    MigrationsStore,
+    mongoClient,
+    mongoLocker,
+    runMigrations,
+    withTransaction,
+};

package/lib/migrations/Migration.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Migration {
+    constructor(description, up, down = () => null) {
+        this.description = description;
+        // NOTE 'up' and 'down' has to be as properties because of 'migrate' package
+        this.up = (next) => {
+            (async () => {
+                await up();
+                next();
+            })().catch(next);
+        };
+        this.down = (next) => {
+            (async () => {
+                await down();
+                next();
+            })().catch(next);
+        };
+    }
+}
+exports.default = Migration;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTWlncmF0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiTWlncmF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBRUEsTUFBcUIsU0FBUztJQVExQixZQUFhLFdBQW1CLEVBQUUsRUFBWSxFQUFFLElBQUksR0FBRyxHQUFHLEVBQUUsQ0FBQyxJQUFJO1FBQzdELElBQUksQ0FBQyxXQUFXLEdBQUcsV0FBVyxDQUFDO1FBRS9CLDRFQUE0RTtRQUM1RSxJQUFJLENBQUMsRUFBRSxHQUFHLENBQUMsSUFBa0IsRUFBRSxFQUFFO1lBQzdCLENBQUMsS0FBSyxJQUFJLEVBQUU7Z0JBQ1IsTUFBTSxFQUFFLEVBQUUsQ0FBQztnQkFDWCxJQUFJLEVBQUUsQ0FBQztZQUNYLENBQUMsQ0FBQyxFQUFFLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ3JCLENBQUMsQ0FBQztRQUVGLElBQUksQ0FBQyxJQUFJLEdBQUcsQ0FBQyxJQUFrQixFQUFFLEVBQUU7WUFDL0IsQ0FBQyxLQUFLLElBQUksRUFBRTtnQkFDUixNQUFNLElBQUksRUFBRSxDQUFDO2dCQUNiLElBQUksRUFBRSxDQUFDO1lBQ1gsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDckIsQ0FBQyxDQUFDO0lBQ04sQ0FBQztDQUNKO0FBMUJELDRCQTBCQyJ9

package/lib/migrations/Migration.ts

@@ -0,0 +1,29 @@
+type NextCallback = (err?: Error) => void;
+
+export default class Migration {
+
+    description: string;
+
+    up: Function;
+
+    down: Function;
+
+    constructor (description: string, up: Function, down = () => null) {
+        this.description = description;
+
+        // NOTE 'up' and 'down' has to be as properties because of 'migrate' package
+        this.up = (next: NextCallback) => {
+            (async () => {
+                await up();
+                next();
+            })().catch(next);
+        };
+
+        this.down = (next: NextCallback) => {
+            (async () => {
+                await down();
+                next();
+            })().catch(next);
+        };
+    }
+}

package/lib/migrations/MigrationsStore.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = require("lodash");
+const appData_1 = __importDefault(require("../appData"));
+const DOCUMENT_ID = 'migrations';
+const safeMigrationMsg = 'safeMigration is true, we do not allow empty migrations to be saved. '
+    + 'If this is new project, feel free to enable it';
+class MigrationsStore {
+    // eslint-disable-next-line no-empty-function
+    constructor(_logger, path, _safeMigration) {
+        this._logger = _logger;
+        this._safeMigration = _safeMigration;
+    }
+    save(set, cb) {
+        try {
+            this._logger.info('Migration SET', set);
+            const objToUpdate = (0, lodash_1.pick)(set, ['lastRun', 'migrations']);
+            if (this._safeMigration) {
+                this._checkValidMigrations(objToUpdate);
+                const numOfValidMigrations = objToUpdate.migrations
+                    .reduce((prev, cur) => (cur.timestamp ? prev + 1 : prev), 0);
+                // If all migrations are renewed=without timestamp (beside the first one that is trying to be applied)
+                // There can be something wrong
+                if (objToUpdate.migrations.length >= 3 && numOfValidMigrations <= 1) {
+                    this._logger.error(safeMigrationMsg);
+                    throw new Error(safeMigrationMsg);
+                }
+            }
+            appData_1.default.updateDocument(DOCUMENT_ID, { $set: objToUpdate }, true)
+                .then(() => { cb(null); })
+                .catch(cb);
+        }
+        catch (err) {
+            cb(err);
+        }
+    }
+    load(cb) {
+        appData_1.default.getDocument(DOCUMENT_ID)
+            .then((state) => {
+            if (this._safeMigration) {
+                this._checkValidMigrations(state);
+            }
+            cb(null, state || {
+                lastRun: null,
+                migrations: [],
+            });
+        })
+            .catch((err) => {
+            cb(err, { migrations: [] });
+        });
+    }
+    _checkValidMigrations(objWithMigrations) {
+        if (!objWithMigrations
+            || (0, lodash_1.isEmpty)(objWithMigrations.migrations)
+            || !(0, lodash_1.isArray)(objWithMigrations.migrations)) {
+            this._logger.error(safeMigrationMsg);
+            throw new Error(safeMigrationMsg);
+        }
+    }
+}
+exports.default = MigrationsStore;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/migrations/MigrationsStore.ts

@@ -0,0 +1,73 @@
+import { isArray, isEmpty, pick } from 'lodash';
+import { CallbackError, DoneCallback } from 'migrate';
+import { Logger } from 'winston';
+import appData from '../appData';
+
+const DOCUMENT_ID = 'migrations';
+
+const safeMigrationMsg = 'safeMigration is true, we do not allow empty migrations to be saved. '
+    + 'If this is new project, feel free to enable it';
+
+export default class MigrationsStore {
+    // eslint-disable-next-line no-empty-function
+    constructor (private _logger: Logger, path: string, private _safeMigration: boolean) {
+    }
+
+    public save (set: Object, cb: CallbackError) {
+        try {
+            this._logger.info('Migration SET', set);
+            const objToUpdate: any = pick(set, ['lastRun', 'migrations']);
+            if (this._safeMigration) {
+                this._checkValidMigrations(objToUpdate);
+
+                const numOfValidMigrations = objToUpdate.migrations
+                    .reduce((prev: number, cur: { timestamp: any; }) => (cur.timestamp ? prev + 1 : prev), 0);
+
+                // If all migrations are renewed=without timestamp (beside the first one that is trying to be applied)
+                // There can be something wrong
+                if (objToUpdate.migrations.length >= 3 && numOfValidMigrations <= 1) {
+                    this._logger.error(safeMigrationMsg);
+
+                    throw new Error(safeMigrationMsg);
+                }
+            }
+
+            appData.updateDocument(DOCUMENT_ID, { $set: objToUpdate }, true)
+                .then(
+                    () => { cb(null); },
+                )
+                .catch(cb);
+        } catch (err) {
+            cb(err);
+        }
+    }
+
+    public load (cb: DoneCallback) {
+        appData.getDocument(DOCUMENT_ID)
+            .then((state: any) => {
+                if (this._safeMigration) {
+                    this._checkValidMigrations(state);
+                }
+
+                cb(
+                    null, state || {
+                        lastRun: null,
+                        migrations: [],
+                    },
+                );
+            })
+            .catch((err) => {
+                cb(err, { migrations: [] });
+            });
+    }
+
+    private _checkValidMigrations (objWithMigrations?: { migrations: any } | null) {
+        if (
+            !objWithMigrations
+            || isEmpty(objWithMigrations.migrations)
+            || !isArray(objWithMigrations.migrations)) {
+            this._logger.error(safeMigrationMsg);
+            throw new Error(safeMigrationMsg);
+        }
+    }
+}

package/lib/migrations/runMigrations.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const migrate_1 = require("migrate");
+const MigrationsStore_1 = __importDefault(require("./MigrationsStore"));
+/**
+ * In case of fail - logs the result and returns rejected promise
+ * @param {Logger} logger Logger
+ * @param {string} directory Path to directory where migrations are
+ * @param {boolean} continueOnError If app crashes on error or continue
+ * @param {boolean} safeMigration Do not allow to rewrite all migrations with empty array
+ */
+async function runMigrations(logger, directory, { continueOnError = false, safeMigration = true, }) {
+    return new Promise((resolve, reject) => {
+        (0, migrate_1.load)({
+            stateStore: new MigrationsStore_1.default(logger, directory, safeMigration),
+            migrationsDirectory: directory,
+            filterFunction: (file) => file.endsWith('.js'),
+        }, (err, set) => {
+            if (err) {
+                logger.error('Migrations did not run due to error', err);
+                reject(err);
+                return;
+            }
+            set.on('warning', (msg) => {
+                logger.warn('warning', msg);
+            });
+            set.on('migration', (migration, direction) => {
+                logger.info(`Running ${direction} migration`, { title: migration.title });
+            });
+            set.up((error) => {
+                if (error) {
+                    logger.error('A migration ended with error', error);
+                    if (!continueOnError) {
+                        reject(error);
+                        return;
+                    }
+                }
+                else {
+                    logger.info('Migrations successfully ran');
+                }
+                resolve();
+            });
+        });
+    });
+}
+exports.default = runMigrations;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVuTWlncmF0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInJ1bk1pZ3JhdGlvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSxxQ0FBNkM7QUFFN0Msd0VBQWdEO0FBRWhEOzs7Ozs7R0FNRztBQUNZLEtBQUssVUFBVSxhQUFhLENBQ3ZDLE1BQWMsRUFDZCxTQUFpQixFQUNqQixFQUNJLGVBQWUsR0FBRyxLQUFLLEVBQ3ZCLGFBQWEsR0FBRyxJQUFJLEdBQ3ZCO0lBRUQsT0FBTyxJQUFJLE9BQU8sQ0FBTyxDQUFDLE9BQU8sRUFBRSxNQUFNLEVBQUUsRUFBRTtRQUN6QyxJQUFBLGNBQUksRUFDQTtZQUNJLFVBQVUsRUFBRSxJQUFJLHlCQUFlLENBQUMsTUFBTSxFQUFFLFNBQVMsRUFBRSxhQUFhLENBQUM7WUFDakUsbUJBQW1CLEVBQUUsU0FBUztZQUM5QixjQUFjLEVBQUUsQ0FBQyxJQUFZLEVBQUUsRUFBRSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDO1NBQ3pELEVBQ0QsQ0FBQyxHQUFpQixFQUFFLEdBQWlCLEVBQUUsRUFBRTtZQUNyQyxJQUFJLEdBQUcsRUFBRTtnQkFDTCxNQUFNLENBQUMsS0FBSyxDQUFDLHFDQUFxQyxFQUFFLEdBQUcsQ0FBQyxDQUFDO2dCQUN6RCxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUM7Z0JBQ1osT0FBTzthQUNWO1lBRUQsR0FBRyxDQUFDLEVBQUUsQ0FBQyxTQUFTLEVBQUUsQ0FBQyxHQUFXLEVBQUUsRUFBRTtnQkFDOUIsTUFBTSxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsR0FBRyxDQUFDLENBQUM7WUFDaEMsQ0FBQyxDQUFDLENBQUM7WUFFSCxHQUFHLENBQUMsRUFBRSxDQUFDLFdBQVcsRUFBRSxDQUFDLFNBQWMsRUFBRSxTQUFpQixFQUFFLEVBQUU7Z0JBQ3RELE1BQU0sQ0FBQyxJQUFJLENBQUMsV0FBVyxTQUFTLFlBQVksRUFBRSxFQUFFLEtBQUssRUFBRSxTQUFTLENBQUMsS0FBSyxFQUFFLENBQUMsQ0FBQztZQUM5RSxDQUFDLENBQUMsQ0FBQztZQUVILEdBQUcsQ0FBQyxFQUFFLENBQUMsQ0FBQyxLQUFhLEVBQUUsRUFBRTtnQkFDckIsSUFBSSxLQUFLLEVBQUU7b0JBQ1AsTUFBTSxDQUFDLEtBQUssQ0FBQyw4QkFBOEIsRUFBRSxLQUFLLENBQUMsQ0FBQztvQkFDcEQsSUFBSSxDQUFDLGVBQWUsRUFBRTt3QkFDbEIsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDO3dCQUNkLE9BQU87cUJBQ1Y7aUJBQ0o7cUJBQU07b0JBQ0gsTUFBTSxDQUFDLElBQUksQ0FBQyw2QkFBNkIsQ0FBQyxDQUFDO2lCQUM5QztnQkFFRCxPQUFPLEVBQUUsQ0FBQztZQUNkLENBQUMsQ0FBQyxDQUFDO1FBQ1AsQ0FBQyxDQUFDLENBQUM7SUFDWCxDQUFDLENBQUMsQ0FBQztBQUNQLENBQUM7QUE3Q0QsZ0NBNkNDIn0=

package/lib/migrations/runMigrations.ts

@@ -0,0 +1,57 @@
+import { load, MigrationSet } from 'migrate';
+import { Logger } from 'winston';
+import MigrationsStore from './MigrationsStore';
+
+/**
+ * In case of fail - logs the result and returns rejected promise
+ * @param {Logger} logger Logger
+ * @param {string} directory Path to directory where migrations are
+ * @param {boolean} continueOnError If app crashes on error or continue
+ * @param {boolean} safeMigration Do not allow to rewrite all migrations with empty array
+ */
+export default async function runMigrations (
+    logger: Logger,
+    directory: string,
+    {
+        continueOnError = false,
+        safeMigration = true,
+    },
+) {
+    return new Promise<void>((resolve, reject) => {
+        load(
+            {
+                stateStore: new MigrationsStore(logger, directory, safeMigration),
+                migrationsDirectory: directory,
+                filterFunction: (file: string) => file.endsWith('.js'),
+            },
+            (err: Error | null, set: MigrationSet) => {
+                if (err) {
+                    logger.error('Migrations did not run due to error', err);
+                    reject(err);
+                    return;
+                }
+
+                set.on('warning', (msg: string) => {
+                    logger.warn('warning', msg);
+                });
+
+                set.on('migration', (migration: any, direction: string) => {
+                    logger.info(`Running ${direction} migration`, { title: migration.title });
+                });
+
+                set.up((error?: Error) => {
+                    if (error) {
+                        logger.error('A migration ended with error', error);
+                        if (!continueOnError) {
+                            reject(error);
+                            return;
+                        }
+                    } else {
+                        logger.info('Migrations successfully ran');
+                    }
+
+                    resolve();
+                });
+            });
+    });
+}

package/lib/migrations/template.js

@@ -0,0 +1,7 @@
+"use strict";
+const mongodb_1 = require("@storyous/mongodb");
+module.exports = new mongodb_1.Migration('[ADD DESCRIPTION HERE]', async () => {
+    // add logic here
+    await (0, mongodb_1.getCollection)('exampleCollection');
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVtcGxhdGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJ0ZW1wbGF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsK0NBQTZEO0FBRTdELGlCQUFTLElBQUksbUJBQVMsQ0FBQyx3QkFBd0IsRUFBRSxLQUFLLElBQUksRUFBRTtJQUN4RCxpQkFBaUI7SUFDakIsTUFBTSxJQUFBLHVCQUFhLEVBQUMsbUJBQW1CLENBQUMsQ0FBQztBQUM3QyxDQUFDLENBQUMsQ0FBQyJ9

package/lib/migrations/template.ts

@@ -0,0 +1,6 @@
+import { getCollection, Migration } from '@storyous/mongodb';
+
+export = new Migration('[ADD DESCRIPTION HERE]', async () => {
+    // add logic here
+    await getCollection('exampleCollection');
+});

package/lib/mongoClient.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = require("lodash");
+const mongodb_1 = require("mongodb");
+const mongoClient = {
+    _client: null,
+    init(mongodbUrl, mongoOptions) {
+        this._client = new mongodb_1.MongoClient(mongodbUrl, (0, lodash_1.defaultsDeep)(mongoOptions, { directConnection: true }));
+    },
+    getClient() {
+        if (this._client) {
+            return this._client;
+        }
+        throw new Error('MongoDb must be initialized before use.');
+    },
+};
+exports.default = mongoClient;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9uZ29DbGllbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJtb25nb0NsaWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLG1DQUFzQztBQUN0QyxxQ0FBb0U7QUFJcEUsTUFBTSxXQUFXLEdBQUc7SUFDaEIsT0FBTyxFQUFxQixJQUFJO0lBRWhDLElBQUksQ0FBRSxVQUFrQixFQUFFLFlBQWlDO1FBQ3ZELElBQUksQ0FBQyxPQUFPLEdBQUcsSUFBSSxxQkFBVyxDQUMxQixVQUFVLEVBQ1YsSUFBQSxxQkFBWSxFQUFDLFlBQVksRUFBRSxFQUFFLGdCQUFnQixFQUFFLElBQUksRUFBRSxDQUFDLENBQ3pELENBQUM7SUFDTixDQUFDO0lBRUQsU0FBUztRQUNMLElBQUksSUFBSSxDQUFDLE9BQU8sRUFBRTtZQUNkLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQztTQUN2QjtRQUVELE1BQU0sSUFBSSxLQUFLLENBQUMseUNBQXlDLENBQUMsQ0FBQztJQUMvRCxDQUFDO0NBQ0osQ0FBQztBQUVGLGtCQUFlLFdBQVcsQ0FBQyJ9

package/lib/mongoClient.ts

@@ -0,0 +1,25 @@
+import { defaultsDeep } from 'lodash';
+import { MongoClient, MongoClientOptions, ObjectId } from 'mongodb';
+
+export type Key = string | number | ObjectId;
+
+const mongoClient = {
+    _client: <MongoClient|null> null,
+
+    init (mongodbUrl: string, mongoOptions?: MongoClientOptions) {
+        this._client = new MongoClient(
+            mongodbUrl,
+            defaultsDeep(mongoOptions, { directConnection: true }),
+        );
+    },
+
+    getClient () {
+        if (this._client) {
+            return this._client;
+        }
+
+        throw new Error('MongoDb must be initialized before use.');
+    },
+};
+
+export default mongoClient;

package/lib/mongoErrorCodes.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const DUPLICATE_KEY_INSERT = 11000;
+const DUPLICATE_KEY_UPDATE = 11001;
+const mongoErrorCodes = {
+    DUPLICATE_KEY_INSERT,
+    DUPLICATE_KEY_UPDATE,
+    DUPLICATE_KEY: [DUPLICATE_KEY_INSERT, DUPLICATE_KEY_UPDATE],
+};
+exports.default = mongoErrorCodes;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9uZ29FcnJvckNvZGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsibW9uZ29FcnJvckNvZGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEsTUFBTSxvQkFBb0IsR0FBRyxLQUFLLENBQUM7QUFDbkMsTUFBTSxvQkFBb0IsR0FBRyxLQUFLLENBQUM7QUFFbkMsTUFBTSxlQUFlLEdBQUc7SUFDcEIsb0JBQW9CO0lBQ3BCLG9CQUFvQjtJQUNwQixhQUFhLEVBQUUsQ0FBQyxvQkFBb0IsRUFBRSxvQkFBb0IsQ0FBQztDQUM5RCxDQUFDO0FBRUYsa0JBQWUsZUFBZSxDQUFDIn0=

package/lib/mongoErrorCodes.ts

@@ -0,0 +1,10 @@
+const DUPLICATE_KEY_INSERT = 11000;
+const DUPLICATE_KEY_UPDATE = 11001;
+
+const mongoErrorCodes = {
+    DUPLICATE_KEY_INSERT,
+    DUPLICATE_KEY_UPDATE,
+    DUPLICATE_KEY: [DUPLICATE_KEY_INSERT, DUPLICATE_KEY_UPDATE],
+};
+
+export default mongoErrorCodes;

package/lib/mongoLocker.js

@@ -0,0 +1,17 @@
+"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 getMongoLocker_1 = __importDefault(require("./getMongoLocker"));
+let lockerPromise;
+async function default_1(key, callback, options = {}) {
+    if (!lockerPromise) {
+        lockerPromise = (0, getMongoLocker_1.default)((0, getCollection_1.default)('appLocks'));
+    }
+    const locker = await lockerPromise;
+    return locker(key, callback, options);
+}
+exports.default = default_1;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9uZ29Mb2NrZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJtb25nb0xvY2tlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLG9FQUE0QztBQUM1QyxzRUFBK0U7QUFHL0UsSUFBSSxhQUFnRCxDQUFDO0FBRXRDLEtBQUssb0JBQWUsR0FBUSxFQUFFLFFBQXlCLEVBQUUsVUFBeUIsRUFBRTtJQUMvRixJQUFJLENBQUMsYUFBYSxFQUFFO1FBQ2hCLGFBQWEsR0FBRyxJQUFBLHdCQUFjLEVBQUMsSUFBQSx1QkFBYSxFQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUM7S0FDN0Q7SUFFRCxNQUFNLE1BQU0sR0FBRyxNQUFNLGFBQWEsQ0FBQztJQUVuQyxPQUFPLE1BQU0sQ0FBQyxHQUFHLEVBQUUsUUFBUSxFQUFFLE9BQU8sQ0FBQyxDQUFDO0FBQzFDLENBQUM7QUFSRCw0QkFRQyJ9

package/lib/mongoLocker.ts

@@ -0,0 +1,15 @@
+import getCollection from './getCollection';
+import getMongoLocker, { LockCallback, LockerOptions } from './getMongoLocker';
+import { Key } from './mongoClient';
+
+let lockerPromise: ReturnType<typeof getMongoLocker>;
+
+export default async function <T> (key: Key, callback: LockCallback<T>, options: LockerOptions = {}): Promise<T> {
+    if (!lockerPromise) {
+        lockerPromise = getMongoLocker(getCollection('appLocks'));
+    }
+
+    const locker = await lockerPromise;
+
+    return locker(key, callback, options);
+}

package/lib/withTransaction.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 });
+const mongoClient_1 = __importDefault(require("./mongoClient"));
+exports.default = async (callback, options) => {
+    const session = mongoClient_1.default.getClient().startSession();
+    try {
+        let result;
+        await session.withTransaction(async () => {
+            result = await callback(session);
+        }, options);
+        // @ts-ignore
+        return result;
+    }
+    finally {
+        await session.endSession();
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2l0aFRyYW5zYWN0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsid2l0aFRyYW5zYWN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQ0EsZ0VBQXdDO0FBRXhDLGtCQUFlLEtBQUssRUFDaEIsUUFBZ0QsRUFDaEQsT0FBNEIsRUFDbEIsRUFBRTtJQUVaLE1BQU0sT0FBTyxHQUFHLHFCQUFXLENBQUMsU0FBUyxFQUFFLENBQUMsWUFBWSxFQUFFLENBQUM7SUFFdkQsSUFBSTtRQUNBLElBQUksTUFBUyxDQUFDO1FBRWQsTUFBTSxPQUFPLENBQUMsZUFBZSxDQUFDLEtBQUssSUFBSSxFQUFFO1lBQ3JDLE1BQU0sR0FBRyxNQUFNLFFBQVEsQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUNyQyxDQUFDLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFFWixhQUFhO1FBQ2IsT0FBTyxNQUFNLENBQUM7S0FFakI7WUFBUztRQUNOLE1BQU0sT0FBTyxDQUFDLFVBQVUsRUFBRSxDQUFDO0tBQzlCO0FBQ0wsQ0FBQyxDQUFDIn0=

package/lib/withTransaction.ts

@@ -0,0 +1,24 @@
+import { ClientSession, TransactionOptions } from 'mongodb';
+import mongoClient from './mongoClient';
+
+export default async <T> (
+    callback: (session: ClientSession) => Promise<T>,
+    options?: TransactionOptions,
+): Promise<T> => {
+
+    const session = mongoClient.getClient().startSession();
+
+    try {
+        let result: T;
+
+        await session.withTransaction(async () => {
+            result = await callback(session);
+        }, options);
+
+        // @ts-ignore
+        return result;
+
+    } finally {
+        await session.endSession();
+    }
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@storyous/mongodb",
+  "version": "1.0.0",
+  "description": "",
+  "homepage": "https://github.com/Storyous/mono-utils#readme",
+  "license": "ISC",
+  "main": "lib/index.ts",
+  "scripts": {
+    "start": "tsc",
+    "build": "tsc && npm publish"
+  },
+  "mocha": {
+    "recursive": true,
+    "timeout": 15000,
+    "extension": [
+      "ts"
+    ],
+    "exit": true,
+    "require": "ts-node/register"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Storyous/mono-utils.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Storyous/mono-utils/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@storyous/errors": "^1.0.0",
+    "lodash": "^4.17.21",
+    "migrate": "^1.8.0",
+    "mongodb": "^4.5.0",
+    "winston": "^3.7.2"
+  },
+  "gitHead": "2ba0209d33ac7cd2fd1136a9123134f656750102"
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+    "extends": "../../tsconfig.json",
+
+    "compilerOptions": {
+        "typeRoots": [
+            "./types"
+        ]
+    },
+
+    "include": [
+        "lib",
+        "__tests__"
+    ]
+}