@sprucelabs/spruce-cli 17.1.11 → 17.1.14

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

@@ -0,0 +1,496 @@
+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);
+            }
+        });
+    }
+}