@sprucelabs/spruce-cli 17.1.11 → 17.1.14

package/node_modules/@sprucelabs/data-stores/build/databases/NeDbDatabase.js

@@ -0,0 +1,447 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+const dotenv_1 = __importDefault(require("dotenv"));
+const differenceWith_1 = __importDefault(require("lodash/differenceWith"));
+const get_1 = __importDefault(require("lodash/get"));
+const isEqual_1 = __importDefault(require("lodash/isEqual"));
+const isObject_1 = __importDefault(require("lodash/isObject"));
+const uniqBy_1 = __importDefault(require("lodash/uniqBy"));
+const nedb_1 = __importDefault(require("nedb"));
+const SpruceError_1 = __importDefault(require("../errors/SpruceError"));
+const AbstractMutexer_1 = __importDefault(require("../mutexers/AbstractMutexer"));
+const generateId_1 = __importDefault(require("../utilities/generateId"));
+const mongo_utility_1 = __importDefault(require("../utilities/mongo.utility"));
+dotenv_1.default.config();
+const NULL_PLACEHOLDER = '_____NULL_____';
+const UNDEFINED_PLACEHOLDER = '_____UNDEFINED_____';
+const SHOULD_SIMULATE_SLOW_QUERIES = process.env.SHOULD_SIMULATE_SLOW_QUERIES === 'true';
+const SLOW_QUERY_MAX_RANDOM_DELAY_MS = parseInt(`${(_a = process.env.SLOW_QUERY_MAX_RANDOM_DELAY_MS) !== null && _a !== void 0 ? _a : 100}`, 10);
+class NeDbDatabase extends AbstractMutexer_1.default {
+    constructor() {
+        super(...arguments);
+        this.collections = {};
+        this._isConnected = false;
+    }
+    generateId() {
+        return (0, generateId_1.default)();
+    }
+    async connect() {
+        this._isConnected = true;
+        await this.randomDelay();
+        return Promise.resolve();
+    }
+    async close() {
+        await this.randomDelay();
+        this._isConnected = false;
+        return Promise.resolve();
+    }
+    toMongoId(query) {
+        return mongo_utility_1.default.mapQuery(query, { shouldTransformToObjectId: false });
+    }
+    prepQuery(query) {
+        return this.valuesToDocument(this.toMongoId(query));
+    }
+    valuesToDocument(values) {
+        const withId = this.toMongoId(values);
+        const nullsToPlaceholder = this.handlePlaceholders(withId, NULL_PLACEHOLDER, (val) => val === null || typeof val === 'undefined' || val === NULL_PLACEHOLDER);
+        const undefinedToPlaceholder = this.handlePlaceholders(nullsToPlaceholder, UNDEFINED_PLACEHOLDER, (val) => val === undefined || val === UNDEFINED_PLACEHOLDER);
+        return undefinedToPlaceholder;
+    }
+    async setShouldAutoGenerateIds(collection, shouldAutoGenerateIds) {
+        const col = this.loadCollection(collection);
+        //@ts-ignore
+        col.indexes._id.unique = shouldAutoGenerateIds;
+        await this.randomDelay();
+    }
+    async randomDelay() {
+        if (SHOULD_SIMULATE_SLOW_QUERIES) {
+            const delay = Math.round(Math.random() * SLOW_QUERY_MAX_RANDOM_DELAY_MS);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+    }
+    isConnected() {
+        return this._isConnected;
+    }
+    normalizeRecord(record) {
+        const { _id } = record, rest = __rest(record, ["_id"]);
+        let values = this.handlePlaceholders(rest, null, (val) => val === null || val === NULL_PLACEHOLDER);
+        if (!_id) {
+            return values;
+        }
+        return Object.assign({ id: _id }, values);
+    }
+    handlePlaceholders(values, dropIn, checker) {
+        let withPlaceholders = Array.isArray(values) ? [] : {};
+        if (values instanceof RegExp) {
+            return values;
+        }
+        if (Array.isArray(values)) {
+            withPlaceholders = values.map((v) => this.handlePlaceholders(v, dropIn, checker));
+        }
+        else if ((0, isObject_1.default)(values)) {
+            Object.keys(values).forEach((key) => {
+                withPlaceholders[key] = this.handlePlaceholders(
+                //@ts-ignore
+                values[key], dropIn, checker);
+            });
+        }
+        else if (checker(values)) {
+            withPlaceholders = dropIn;
+        }
+        else {
+            withPlaceholders = values;
+        }
+        return withPlaceholders;
+    }
+    async count(collection, query) {
+        const col = this.loadCollection(collection);
+        await this.randomDelay();
+        return new Promise((resolve, reject) => {
+            col.count(this.prepQuery(query !== null && query !== void 0 ? query : {}), (err, count) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(count);
+                }
+            });
+        });
+    }
+    async createOne(collection, values) {
+        await this.randomDelay();
+        const all = await this.create(collection, [values]);
+        return all[0];
+    }
+    async create(collection, values) {
+        const mutexName = 'createMutex';
+        await this.lock(mutexName);
+        await this.randomDelay();
+        const col = this.loadCollection(collection);
+        const mapped = values
+            .map((v) => this.valuesToDocument(v))
+            .map((v) => (Object.assign({ _id: this.generateId() }, v)));
+        try {
+            await Promise.all(mapped.map((m) => this.assertPassesUniqueIndexes(collection, undefined, m, 'create')));
+        }
+        catch (err) {
+            this.unlock(mutexName);
+            throw err;
+        }
+        return new Promise((resolve, reject) => {
+            col.insert(mapped, (err, docs) => {
+                this.unlock(mutexName);
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(docs.map((doc) => this.normalizeRecord(doc)));
+                }
+            });
+        });
+    }
+    loadCollection(collection) {
+        if (!this.collections[collection]) {
+            this.collections[collection] = new nedb_1.default();
+        }
+        const c = this.collections[collection];
+        return c;
+    }
+    async dropCollection(name) {
+        await this.randomDelay();
+        delete this.collections[name];
+        return Promise.resolve();
+    }
+    async dropDatabase() {
+        await this.randomDelay();
+        this.collections = {};
+        return Promise.resolve();
+    }
+    async findOne(collection, query, options) {
+        const results = await this.find(collection, this.prepQuery(query !== null && query !== void 0 ? query : {}), Object.assign({ limit: 1 }, (options || {})));
+        return results[0];
+    }
+    async find(collection, query, options) {
+        await this.randomDelay();
+        if ((options === null || options === void 0 ? void 0 : options.limit) === 0) {
+            return [];
+        }
+        return new Promise((resolve, reject) => {
+            const col = this.loadCollection(collection);
+            const mapped = mongo_utility_1.default.queryOptionsToMongoFindOptions(options);
+            const q = this.prepQuery(query !== null && query !== void 0 ? query : {});
+            const cursor = col.find(q, mapped.projection);
+            if (mapped.sort) {
+                cursor.sort(mapped.sort);
+            }
+            if (typeof mapped.limit === 'number') {
+                cursor.limit(mapped.limit);
+            }
+            if (mapped.skip) {
+                cursor.skip(mapped.skip);
+            }
+            cursor.exec((err, results) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(results.map((r) => this.normalizeRecord(r)));
+                }
+            });
+        });
+    }
+    async update(collection, query, updates, neDbOptions) {
+        const results = this.updateOne(collection, query, updates, Object.assign(Object.assign({}, neDbOptions), { multi: true, returnUpdatedDocs: false }), 'update');
+        return results;
+    }
+    async updateOne(collection, query, updates, neDbOptions, action = 'updateOne') {
+        const preppedQuery = this.prepQuery(query);
+        const mutexKey = 'updateMutex';
+        await this.lock(mutexKey);
+        await this.randomDelay();
+        try {
+            await this.assertPassesUniqueIndexes(collection, query, updates, action);
+        }
+        catch (err) {
+            this.unlock(mutexKey);
+            throw err;
+        }
+        return new Promise((resolve, reject) => {
+            const col = this.loadCollection(collection);
+            const values = this.valuesToDocument(mongo_utility_1.default.prepareUpdates(updates));
+            col.update(preppedQuery, values, Object.assign({ returnUpdatedDocs: true }, (neDbOptions || {})), async (err, numUpdated, docs) => {
+                this.unlock(mutexKey);
+                if (err) {
+                    reject(err);
+                }
+                else if (!(neDbOptions === null || neDbOptions === void 0 ? void 0 : neDbOptions.multi) && numUpdated === 0) {
+                    reject(new SpruceError_1.default({
+                        code: 'RECORD_NOT_FOUND',
+                        storeName: 'NeDatabase',
+                        query: preppedQuery,
+                    }));
+                }
+                else {
+                    resolve(docs ? this.normalizeRecord(docs) : numUpdated);
+                }
+            });
+        });
+    }
+    upsertOne(collection, query, updates) {
+        return this.updateOne(collection, query, updates, { upsert: true }, 'upsertOne');
+    }
+    async delete(collection, query) {
+        await this.randomDelay();
+        return new Promise((resolve, reject) => {
+            const col = this.loadCollection(collection);
+            col.remove(this.prepQuery(query), { multi: true }, (err, numDeleted) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(numDeleted);
+                }
+            });
+        });
+    }
+    async deleteOne(collection, query) {
+        await this.randomDelay();
+        return new Promise((resolve, reject) => {
+            const col = this.loadCollection(collection);
+            col.remove(this.prepQuery(query), (err, numDeleted) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(numDeleted);
+                }
+            });
+        });
+    }
+    async assertPassesUniqueIndexes(collection, query, values, action) {
+        const col = this.loadCollection(collection);
+        await this.randomDelay();
+        if (col._uniqueIndexes) {
+            for (const fields of col._uniqueIndexes) {
+                const existing = query ? await this.findOne(collection, query) : null;
+                const q = {};
+                const duplicateFields = [];
+                const duplicateValues = [];
+                fields.forEach((f) => {
+                    q[f] = (0, get_1.default)(values, f);
+                    duplicateFields.push(f);
+                    duplicateValues.push(q[f]);
+                });
+                const destination = await this.findOne(collection, q);
+                if (destination && (existing === null || existing === void 0 ? void 0 : existing.id) !== destination.id) {
+                    throw new SpruceError_1.default({
+                        code: 'DUPLICATE_RECORD',
+                        collectionName: collection,
+                        duplicateFields,
+                        duplicateValues,
+                        action,
+                    });
+                }
+            }
+        }
+    }
+    async getUniqueIndexes(collection) {
+        var _a;
+        const col = this.loadCollection(collection);
+        await this.randomDelay();
+        return (_a = col._uniqueIndexes) !== null && _a !== void 0 ? _a : [];
+    }
+    async getIndexes(collection, shouldIncludeUnique = false) {
+        var _a, _b, _c;
+        const col = this.loadCollection(collection);
+        await this.randomDelay();
+        if (shouldIncludeUnique) {
+            const uniqIndexes = (_a = col._uniqueIndexes) !== null && _a !== void 0 ? _a : [];
+            return uniqIndexes.concat((_b = col._indexes) !== null && _b !== void 0 ? _b : []);
+        }
+        return (_c = col._indexes) !== null && _c !== void 0 ? _c : [];
+    }
+    async dropIndex(collection, fields) {
+        var _a, _b;
+        const col = this.loadCollection(collection);
+        await this.randomDelay();
+        let found = false;
+        let newIndexes = [];
+        for (const uniq of (_a = col._uniqueIndexes) !== null && _a !== void 0 ? _a : []) {
+            if (!(0, isEqual_1.default)(uniq, fields)) {
+                newIndexes.push(uniq);
+            }
+            else {
+                found = true;
+            }
+        }
+        if (found) {
+            col._uniqueIndexes = newIndexes;
+            return;
+        }
+        else {
+            newIndexes = [];
+            for (const index of (_b = col._indexes) !== null && _b !== void 0 ? _b : []) {
+                if (!(0, isEqual_1.default)(index, fields)) {
+                    newIndexes.push(index);
+                }
+                else {
+                    found = true;
+                }
+            }
+            if (found) {
+                col._indexes = newIndexes;
+                return;
+            }
+        }
+        throw new SpruceError_1.default({ code: 'INDEX_NOT_FOUND', missingIndex: fields });
+    }
+    assertIndexDoesNotExist(currentIndexes, fields) {
+        if (this.doesIndexExist(currentIndexes, fields)) {
+            throw new SpruceError_1.default({ code: 'INDEX_EXISTS', index: fields });
+        }
+    }
+    doesIndexExist(currentIndexes, fields) {
+        for (const index of currentIndexes !== null && currentIndexes !== void 0 ? currentIndexes : []) {
+            if ((0, isEqual_1.default)(index, fields)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    async createUniqueIndex(collection, fields) {
+        const col = this.loadCollection(collection);
+        if (!col._uniqueIndexes) {
+            col._uniqueIndexes = [];
+        }
+        await this.randomDelay();
+        this.assertIndexDoesNotExist(col._uniqueIndexes, fields);
+        if (col._uniqueIndexes) {
+            const tempUniqueIndexes = [...col._uniqueIndexes];
+            tempUniqueIndexes.push(fields);
+            const documents = (await this.find(collection, {})) || [];
+            for (const uniqueFields of tempUniqueIndexes) {
+                let parsedExisting = [];
+                for (const doc of documents) {
+                    const tempDoc = {};
+                    uniqueFields.forEach((f) => {
+                        tempDoc[f] = doc[f];
+                    });
+                    parsedExisting.push(tempDoc);
+                }
+                const uniqued = (0, uniqBy_1.default)(parsedExisting, JSON.stringify);
+                if (parsedExisting.length != uniqued.length) {
+                    throw new SpruceError_1.default({
+                        code: 'DUPLICATE_KEY',
+                        friendlyMessage: `Could not create index! Unique index on '${collection}' has duplicate key for "${fields.join(',')}"`,
+                    });
+                }
+            }
+        }
+        col._uniqueIndexes.push(fields);
+    }
+    async createIndex(collection, fields) {
+        const col = this.loadCollection(collection);
+        if (!col._indexes) {
+            col._indexes = [];
+        }
+        await this.randomDelay();
+        this.assertIndexDoesNotExist(col._indexes, fields);
+        col._indexes.push(fields);
+    }
+    async syncUniqueIndexes(collectionName, indexes) {
+        var _a;
+        const currentIndexes = await this.getUniqueIndexes(collectionName);
+        const extraIndexes = (0, differenceWith_1.default)(currentIndexes, indexes, isEqual_1.default);
+        for (const index of indexes) {
+            if (!this.doesIndexExist(currentIndexes, index)) {
+                try {
+                    await this.createUniqueIndex(collectionName, index);
+                }
+                catch (err) {
+                    if (((_a = err.options) === null || _a === void 0 ? void 0 : _a.code) !== 'INDEX_EXISTS') {
+                        throw err;
+                    }
+                }
+            }
+        }
+        for (const extra of extraIndexes) {
+            await this.dropIndex(collectionName, extra);
+        }
+    }
+    async syncIndexes(collectionName, indexes) {
+        var _a;
+        const currentIndexes = await this.getIndexes(collectionName);
+        const extraIndexes = (0, differenceWith_1.default)(currentIndexes, indexes, isEqual_1.default);
+        for (const index of indexes) {
+            if (!this.doesIndexExist(currentIndexes, index)) {
+                try {
+                    await this.createIndex(collectionName, index);
+                }
+                catch (err) {
+                    if (((_a = err.options) === null || _a === void 0 ? void 0 : _a.code) !== 'INDEX_EXISTS') {
+                        throw err;
+                    }
+                }
+            }
+        }
+        for (const extra of extraIndexes) {
+            await this.dropIndex(collectionName, extra);
+        }
+    }
+}
+exports.default = NeDbDatabase;