@sprucelabs/spruce-cli 17.1.14 → 17.1.15

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

@@ -1,447 +0,0 @@
-"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;