@sprucelabs/spruce-cli 17.1.14 → 17.1.17

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

@@ -1,496 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-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 _a;
-import dotenv from 'dotenv';
-import differenceWith from 'lodash/differenceWith.js';
-import get from 'lodash/get.js';
-import isEqual from 'lodash/isEqual.js';
-import isObject from 'lodash/isObject.js';
-import uniqBy from 'lodash/uniqBy.js';
-import Datastore from 'nedb';
-import SpruceError from '../errors/SpruceError.js';
-import AbstractMutexer from '../mutexers/AbstractMutexer.js';
-import generateId from '../utilities/generateId.js';
-import mongoUtil from '../utilities/mongo.utility.js';
-dotenv.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);
-export default class NeDbDatabase extends AbstractMutexer {
-    constructor() {
-        super(...arguments);
-        this.collections = {};
-        this._isConnected = false;
-    }
-    generateId() {
-        return generateId();
-    }
-    connect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._isConnected = true;
-            yield this.randomDelay();
-            return Promise.resolve();
-        });
-    }
-    close() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.randomDelay();
-            this._isConnected = false;
-            return Promise.resolve();
-        });
-    }
-    toMongoId(query) {
-        return mongoUtil.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;
-    }
-    setShouldAutoGenerateIds(collection, shouldAutoGenerateIds) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const col = this.loadCollection(collection);
-            //@ts-ignore
-            col.indexes._id.unique = shouldAutoGenerateIds;
-            yield this.randomDelay();
-        });
-    }
-    randomDelay() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (SHOULD_SIMULATE_SLOW_QUERIES) {
-                const delay = Math.round(Math.random() * SLOW_QUERY_MAX_RANDOM_DELAY_MS);
-                yield 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 (isObject(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;
-    }
-    count(collection, query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const col = this.loadCollection(collection);
-            yield 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);
-                    }
-                });
-            });
-        });
-    }
-    createOne(collection, values) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.randomDelay();
-            const all = yield this.create(collection, [values]);
-            return all[0];
-        });
-    }
-    create(collection, values) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const mutexName = 'createMutex';
-            yield this.lock(mutexName);
-            yield this.randomDelay();
-            const col = this.loadCollection(collection);
-            const mapped = values
-                .map((v) => this.valuesToDocument(v))
-                .map((v) => (Object.assign({ _id: this.generateId() }, v)));
-            try {
-                yield 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 Datastore();
-        }
-        const c = this.collections[collection];
-        return c;
-    }
-    dropCollection(name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.randomDelay();
-            delete this.collections[name];
-            return Promise.resolve();
-        });
-    }
-    dropDatabase() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.randomDelay();
-            this.collections = {};
-            return Promise.resolve();
-        });
-    }
-    findOne(collection, query, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const results = yield this.find(collection, this.prepQuery(query !== null && query !== void 0 ? query : {}), Object.assign({ limit: 1 }, (options || {})));
-            return results[0];
-        });
-    }
-    find(collection, query, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield 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 = mongoUtil.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)));
-                    }
-                });
-            });
-        });
-    }
-    update(collection, query, updates, neDbOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const results = this.updateOne(collection, query, updates, Object.assign(Object.assign({}, neDbOptions), { multi: true, returnUpdatedDocs: false }), 'update');
-            return results;
-        });
-    }
-    updateOne(collection, query, updates, neDbOptions, action = 'updateOne') {
-        return __awaiter(this, void 0, void 0, function* () {
-            const preppedQuery = this.prepQuery(query);
-            const mutexKey = 'updateMutex';
-            yield this.lock(mutexKey);
-            yield this.randomDelay();
-            try {
-                yield 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(mongoUtil.prepareUpdates(updates));
-                col.update(preppedQuery, values, Object.assign({ returnUpdatedDocs: true }, (neDbOptions || {})), (err, numUpdated, docs) => __awaiter(this, void 0, void 0, function* () {
-                    this.unlock(mutexKey);
-                    if (err) {
-                        reject(err);
-                    }
-                    else if (!(neDbOptions === null || neDbOptions === void 0 ? void 0 : neDbOptions.multi) && numUpdated === 0) {
-                        reject(new SpruceError({
-                            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');
-    }
-    delete(collection, query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield 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);
-                    }
-                });
-            });
-        });
-    }
-    deleteOne(collection, query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield 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);
-                    }
-                });
-            });
-        });
-    }
-    assertPassesUniqueIndexes(collection, query, values, action) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const col = this.loadCollection(collection);
-            yield this.randomDelay();
-            if (col._uniqueIndexes) {
-                for (const fields of col._uniqueIndexes) {
-                    const existing = query ? yield this.findOne(collection, query) : null;
-                    const q = {};
-                    const duplicateFields = [];
-                    const duplicateValues = [];
-                    fields.forEach((f) => {
-                        q[f] = get(values, f);
-                        duplicateFields.push(f);
-                        duplicateValues.push(q[f]);
-                    });
-                    const destination = yield this.findOne(collection, q);
-                    if (destination && (existing === null || existing === void 0 ? void 0 : existing.id) !== destination.id) {
-                        throw new SpruceError({
-                            code: 'DUPLICATE_RECORD',
-                            collectionName: collection,
-                            duplicateFields,
-                            duplicateValues,
-                            action,
-                        });
-                    }
-                }
-            }
-        });
-    }
-    getUniqueIndexes(collection) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const col = this.loadCollection(collection);
-            yield this.randomDelay();
-            return (_a = col._uniqueIndexes) !== null && _a !== void 0 ? _a : [];
-        });
-    }
-    getIndexes(collection, shouldIncludeUnique = false) {
-        var _a, _b, _c;
-        return __awaiter(this, void 0, void 0, function* () {
-            const col = this.loadCollection(collection);
-            yield 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 : [];
-        });
-    }
-    dropIndex(collection, fields) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            const col = this.loadCollection(collection);
-            yield this.randomDelay();
-            let found = false;
-            let newIndexes = [];
-            for (const uniq of (_a = col._uniqueIndexes) !== null && _a !== void 0 ? _a : []) {
-                if (!isEqual(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 (!isEqual(index, fields)) {
-                        newIndexes.push(index);
-                    }
-                    else {
-                        found = true;
-                    }
-                }
-                if (found) {
-                    col._indexes = newIndexes;
-                    return;
-                }
-            }
-            throw new SpruceError({ code: 'INDEX_NOT_FOUND', missingIndex: fields });
-        });
-    }
-    assertIndexDoesNotExist(currentIndexes, fields) {
-        if (this.doesIndexExist(currentIndexes, fields)) {
-            throw new SpruceError({ code: 'INDEX_EXISTS', index: fields });
-        }
-    }
-    doesIndexExist(currentIndexes, fields) {
-        for (const index of currentIndexes !== null && currentIndexes !== void 0 ? currentIndexes : []) {
-            if (isEqual(index, fields)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    createUniqueIndex(collection, fields) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const col = this.loadCollection(collection);
-            if (!col._uniqueIndexes) {
-                col._uniqueIndexes = [];
-            }
-            yield this.randomDelay();
-            this.assertIndexDoesNotExist(col._uniqueIndexes, fields);
-            if (col._uniqueIndexes) {
-                const tempUniqueIndexes = [...col._uniqueIndexes];
-                tempUniqueIndexes.push(fields);
-                const documents = (yield 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 = uniqBy(parsedExisting, JSON.stringify);
-                    if (parsedExisting.length != uniqued.length) {
-                        throw new SpruceError({
-                            code: 'DUPLICATE_KEY',
-                            friendlyMessage: `Could not create index! Unique index on '${collection}' has duplicate key for "${fields.join(',')}"`,
-                        });
-                    }
-                }
-            }
-            col._uniqueIndexes.push(fields);
-        });
-    }
-    createIndex(collection, fields) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const col = this.loadCollection(collection);
-            if (!col._indexes) {
-                col._indexes = [];
-            }
-            yield this.randomDelay();
-            this.assertIndexDoesNotExist(col._indexes, fields);
-            col._indexes.push(fields);
-        });
-    }
-    syncUniqueIndexes(collectionName, indexes) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const currentIndexes = yield this.getUniqueIndexes(collectionName);
-            const extraIndexes = differenceWith(currentIndexes, indexes, isEqual);
-            for (const index of indexes) {
-                if (!this.doesIndexExist(currentIndexes, index)) {
-                    try {
-                        yield 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) {
-                yield this.dropIndex(collectionName, extra);
-            }
-        });
-    }
-    syncIndexes(collectionName, indexes) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const currentIndexes = yield this.getIndexes(collectionName);
-            const extraIndexes = differenceWith(currentIndexes, indexes, isEqual);
-            for (const index of indexes) {
-                if (!this.doesIndexExist(currentIndexes, index)) {
-                    try {
-                        yield 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) {
-                yield this.dropIndex(collectionName, extra);
-            }
-        });
-    }
-}