@sprucelabs/spruce-cli 17.1.13 → 17.1.14

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

@@ -0,0 +1,476 @@
+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;
+};
+import differenceWith from 'lodash/differenceWith.js';
+import isEqual from 'lodash/isEqual.js';
+import { MongoClient, MongoError } from 'mongodb';
+import SpruceError from '../errors/SpruceError.js';
+import generateId from '../utilities/generateId.js';
+import mongoUtil from '../utilities/mongo.utility.js';
+export const MONGO_TEST_URI = 'mongodb://localhost:27017';
+export default class MongoDatabase {
+    constructor(url, options) {
+        this.disableAutoGeneratedIdsOnTheseCollections = [];
+        this._isConnected = false;
+        const _a = options !== null && options !== void 0 ? options : {}, { dbName } = _a, rest = __rest(_a, ["dbName"]);
+        if (dbName === 'undefined') {
+            throw new SpruceError({
+                code: 'INVALID_DATABASE_NAME',
+                suppliedName: dbName,
+            });
+        }
+        try {
+            this.mongo = new MongoClient(url, Object.assign(Object.assign({}, (rest || {})), { serverSelectionTimeoutMS: 5000 }));
+        }
+        catch (err) {
+            if (err.message.includes('Invalid scheme')) {
+                throw new SpruceError({ code: 'INVALID_DB_CONNECTION_STRING' });
+            }
+            throw err;
+        }
+        this.dbName = dbName !== null && dbName !== void 0 ? dbName : 'mercury';
+    }
+    count(collection, query) {
+        const col = this.assertDbWhileAttempingTo('count records', collection).collection(collection);
+        return col.countDocuments(query ? this.toMongoIdAndNull(collection, query) : {});
+    }
+    generateId() {
+        return generateId();
+    }
+    delete(collection, query) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = yield this.assertDbWhileAttempingTo('delete many records', collection)
+                .collection(collection)
+                .deleteMany(this.toMongoIdAndNull(collection, query));
+            return (_a = results.deletedCount) !== null && _a !== void 0 ? _a : 0;
+        });
+    }
+    deleteOne(collection, query) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = yield this.assertDbWhileAttempingTo('delete one record', collection)
+                .collection(collection)
+                .deleteOne(this.toMongoIdAndNull(collection, query));
+            return (_a = results.deletedCount) !== null && _a !== void 0 ? _a : 0;
+        });
+    }
+    assertDbWhileAttempingTo(attempt, collectionName) {
+        if (!this.isConnected() || !this.db) {
+            throw new SpruceError({
+                code: 'DATABASE_NOT_CONNECTED',
+                operationAttempted: attempt,
+                collectionName,
+            });
+        }
+        return this.db;
+    }
+    findOne(collection, query, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let q;
+            try {
+                q = this.toMongoIdAndNull(collection, query || {});
+            }
+            catch (err) {
+                return null;
+            }
+            const match = yield this.assertDbWhileAttempingTo('found one record.', collection)
+                .collection(collection)
+                //@ts-ignore
+                .findOne(q, mongoUtil.queryOptionsToMongoFindOptions(options));
+            //@ts-ignore
+            return match ? this.normalizeRecord(match) : null;
+        });
+    }
+    find(collection, query, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let q;
+            try {
+                q = this.toMongoIdAndNull(collection, query || {});
+            }
+            catch (err) {
+                return [];
+            }
+            if ((options === null || options === void 0 ? void 0 : options.limit) === 0) {
+                return [];
+            }
+            const matches = yield this.assertDbWhileAttempingTo('find many records.', collection)
+                .collection(collection)
+                //@ts-ignore
+                .find(q, mongoUtil.queryOptionsToMongoFindOptions(options))
+                .toArray();
+            return matches.map((match) => this.normalizeRecord(match));
+        });
+    }
+    toMongoIdAndNull(collection, query) {
+        const isAutoGeneratingIds = this.disableAutoGeneratedIdsOnTheseCollections.indexOf(collection) === -1;
+        const q = mongoUtil.mapQuery(query, {
+            shouldTransformToObjectId: isAutoGeneratingIds,
+        });
+        Object.keys(q).forEach((key) => {
+            if (q[key] === undefined) {
+                q[key] = null;
+            }
+        });
+        return q;
+    }
+    createOne(collection, values) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const record = this.toMongoIdAndNull(collection, values);
+            try {
+                const created = yield this.assertDbWhileAttempingTo('create a new record.', collection)
+                    .collection(collection)
+                    .insertOne(record);
+                return this.findOne(collection, {
+                    id: created.insertedId.toHexString(),
+                });
+            }
+            catch (err) {
+                if (err instanceof MongoError) {
+                    if (err.code === 11000) {
+                        throw new SpruceError(Object.assign(Object.assign({ code: 'DUPLICATE_RECORD', collectionName: collection }, this.generateDuplicateFieldsForError(
+                        //@ts-ignore
+                        err.keyValue)), { action: 'create', originalError: err }));
+                    }
+                }
+                throw err;
+            }
+        });
+    }
+    create(collection, values) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const records = values.map((v) => this.toMongoIdAndNull(collection, v));
+            try {
+                const created = yield this.assertDbWhileAttempingTo('create many records.', collection)
+                    .collection(collection)
+                    .insertMany(records);
+                const ids = Object.values(created.insertedIds).map((i) => i.toHexString());
+                return this.find(collection, {
+                    id: { $in: ids },
+                });
+            }
+            catch (err) {
+                if (err instanceof MongoError) {
+                    if (err.code === 11000) {
+                        throw new SpruceError(Object.assign(Object.assign({ code: 'DUPLICATE_RECORD', collectionName: collection }, this.generateDuplicateFieldsForError(
+                        //@ts-ignore
+                        err.keyValue)), { action: 'create', originalError: err }));
+                    }
+                }
+                throw err;
+            }
+        });
+    }
+    normalizeRecord(record) {
+        const { _id } = record, rest = __rest(record, ["_id"]);
+        if (!_id) {
+            return rest;
+        }
+        return Object.assign({ id: _id.toString() }, rest);
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isConnected()) {
+                this._isConnected = false;
+                yield this.mongo.close(true);
+            }
+        });
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isConnected()) {
+                try {
+                    this._isConnected = true;
+                    yield this.mongo.connect();
+                }
+                catch (err) {
+                    if (err.name === 'MongoParseError') {
+                        throw new SpruceError({ code: 'INVALID_DB_CONNECTION_STRING' });
+                    }
+                    else if (err.message.includes('ECONNREFUSED')) {
+                        throw new SpruceError({ code: 'UNABLE_TO_CONNECT_TO_DB' });
+                    }
+                    else {
+                        throw new SpruceError({
+                            code: 'UNKNOWN_DATABASE_ERROR',
+                            originalError: err,
+                            databaseErrorMessage: err.message,
+                        });
+                    }
+                }
+            }
+            this.db = this.mongo.db(this.dbName);
+        });
+    }
+    isConnected() {
+        return this._isConnected;
+    }
+    dropCollection(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const collections = yield this.assertDbWhileAttempingTo('drop an entire collection.', '')
+                .listCollections()
+                .toArray();
+            const doesExist = !!collections.find((collection) => collection.name === name);
+            if (doesExist) {
+                const collection = this.assertDbWhileAttempingTo('drop the collection.', '').collection(name);
+                yield collection.drop();
+            }
+        });
+    }
+    dropDatabase() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.assertDbWhileAttempingTo('drop the entire database.').dropDatabase();
+        });
+    }
+    listIndexes(collection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.assertDbWhileAttempingTo('get indexes.', collection)
+                    .collection(collection)
+                    .listIndexes()
+                    .toArray();
+            }
+            catch (err) {
+                return [];
+            }
+        });
+    }
+    dropIndex(collection, fields) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const indexes = yield this.listIndexes(collection);
+            let found = false;
+            for (const index of indexes) {
+                if (isEqual(Object.keys(index.key), fields)) {
+                    yield this.assertDbWhileAttempingTo('drop a index.', collection)
+                        .collection(collection)
+                        .dropIndex(index.name);
+                    found = true;
+                }
+            }
+            if (!found) {
+                throw new SpruceError({ code: 'INDEX_NOT_FOUND', missingIndex: fields });
+            }
+        });
+    }
+    getUniqueIndexes(collection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const indexes = yield this.listIndexes(collection);
+                const uniqueIndexes = [];
+                for (const index of indexes) {
+                    if (index.unique) {
+                        uniqueIndexes.push(Object.keys(index.key));
+                    }
+                }
+                return uniqueIndexes;
+            }
+            catch (err) {
+                return [];
+            }
+        });
+    }
+    getIndexes(collection, shouldIncludeUnique = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const indexes = yield this.listIndexes(collection);
+                if (shouldIncludeUnique) {
+                    return indexes;
+                }
+                const nonUniqueIndexes = [];
+                for (const index of indexes) {
+                    if (!index.unique) {
+                        nonUniqueIndexes.push(Object.keys(index.key));
+                    }
+                }
+                return nonUniqueIndexes;
+            }
+            catch (err) {
+                return [];
+            }
+        });
+    }
+    createIndex(collection, fields) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentIndexes = yield this.getIndexes(collection);
+            yield this.assertIndexDoesNotExist(currentIndexes, fields);
+            const index = {};
+            fields.forEach((name) => {
+                index[name] = 1;
+            });
+            try {
+                yield this.assertDbWhileAttempingTo('create an index.', collection)
+                    .collection(collection)
+                    .createIndex(index);
+            }
+            catch (err) {
+                if ((err === null || err === void 0 ? void 0 : err.code) === 11000) {
+                    throw new SpruceError({
+                        code: 'DUPLICATE_KEY',
+                        friendlyMessage: `Could not create index! Index on '${collection}' has duplicate key for "${fields.join(',')}"`,
+                    });
+                }
+                else {
+                    throw err;
+                }
+            }
+        });
+    }
+    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;
+    }
+    syncIndexes(collectionName, indexes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentIndexes = yield this.getIndexes(collectionName);
+            const extraIndexes = differenceWith(currentIndexes, indexes, isEqual).filter((i) => !(i.length === 1 && i[0] === '_id'));
+            for (const index of indexes) {
+                if (!this.doesIndexExist(currentIndexes, index)) {
+                    yield this.createIndex(collectionName, index);
+                }
+            }
+            for (const extra of extraIndexes) {
+                yield this.dropIndex(collectionName, extra);
+            }
+        });
+    }
+    createUniqueIndex(collection, fields) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentIndexes = yield this.getUniqueIndexes(collection);
+            yield this.assertIndexDoesNotExist(currentIndexes, fields);
+            const index = {};
+            fields.forEach((name) => {
+                index[name] = 1;
+            });
+            try {
+                yield this.assertDbWhileAttempingTo('create a unique index.', collection)
+                    .collection(collection)
+                    .createIndex(index, { unique: true });
+            }
+            catch (err) {
+                if ((err === null || err === void 0 ? void 0 : err.code) === 11000) {
+                    throw new SpruceError({
+                        code: 'DUPLICATE_KEY',
+                        friendlyMessage: `Could not create index! Unique index on '${collection}' has duplicate key for "${fields.join(',')}"`,
+                    });
+                }
+                else {
+                    throw err;
+                }
+            }
+        });
+    }
+    syncUniqueIndexes(collectionName, indexes) {
+        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)) {
+                    yield this.createUniqueIndex(collectionName, index);
+                }
+            }
+            for (const extra of extraIndexes) {
+                yield this.dropIndex(collectionName, extra);
+            }
+        });
+    }
+    update(collection, query, updates) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const q = this.toMongoIdAndNull(collection, query);
+            const values = mongoUtil.prepareUpdates(updates);
+            const { modifiedCount } = yield this.assertDbWhileAttempingTo('update many records.', collection)
+                .collection(collection)
+                .updateMany(q, values);
+            return modifiedCount;
+        });
+    }
+    updateOne(collection, query, updates) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const q = this.toMongoIdAndNull(collection, query);
+            const values = mongoUtil.prepareUpdates(updates);
+            try {
+                const results = yield this.assertDbWhileAttempingTo('update one record.', collection)
+                    .collection(collection)
+                    .findOneAndUpdate(q, values, { returnDocument: 'after' });
+                if (!results.value) {
+                    throw new SpruceError({
+                        code: 'RECORD_NOT_FOUND',
+                        storeName: 'MongoDatabase',
+                        query: q,
+                    });
+                }
+                return this.normalizeRecord(results.value);
+            }
+            catch (err) {
+                if (err instanceof MongoError) {
+                    if (err.code === 11000) {
+                        throw new SpruceError(Object.assign(Object.assign({ code: 'DUPLICATE_RECORD', collectionName: collection }, this.generateDuplicateFieldsForError(
+                        //@ts-ignore
+                        err.keyValue)), { action: 'updateOne', originalError: err }));
+                    }
+                }
+                throw err;
+            }
+        });
+    }
+    upsertOne(collection, query, updates) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const q = this.toMongoIdAndNull(collection, query);
+            const values = this.toMongoIdAndNull(collection, updates);
+            try {
+                const results = yield this.assertDbWhileAttempingTo('upsert one record.', collection)
+                    .collection(collection)
+                    .findOneAndUpdate(q, { $set: values }, { upsert: true, returnDocument: 'after' });
+                //@ts-ignore
+                return this.normalizeRecord(results.value);
+            }
+            catch (err) {
+                if (err instanceof MongoError) {
+                    if (err.code === 11000) {
+                        throw new SpruceError(Object.assign(Object.assign({ code: 'DUPLICATE_RECORD', collectionName: collection }, this.generateDuplicateFieldsForError(
+                        //@ts-ignore
+                        err.keyValue)), { action: 'upsertOne', originalError: err }));
+                    }
+                }
+                throw err;
+            }
+        });
+    }
+    generateDuplicateFieldsForError(mongoIndexKeyValue) {
+        const duplicateFields = [];
+        const duplicateValues = [];
+        Object.keys(mongoIndexKeyValue !== null && mongoIndexKeyValue !== void 0 ? mongoIndexKeyValue : {}).forEach((name) => {
+            duplicateFields.push(name);
+            duplicateValues.push(mongoIndexKeyValue[name]);
+        });
+        return {
+            duplicateFields,
+            duplicateValues,
+        };
+    }
+}

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

@@ -0,0 +1,41 @@
+import AbstractMutexer from '../mutexers/AbstractMutexer';
+import { Database } from '../types/database.types';
+import { QueryOptions } from '../types/query.types';
+export default class NeDbDatabase extends AbstractMutexer implements Database {
+    private collections;
+    private _isConnected;
+    generateId(): string;
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    private toMongoId;
+    private prepQuery;
+    private valuesToDocument;
+    setShouldAutoGenerateIds(collection: string, shouldAutoGenerateIds: boolean): Promise<void>;
+    private randomDelay;
+    isConnected(): boolean;
+    private normalizeRecord;
+    private handlePlaceholders;
+    count(collection: string, query?: Record<string, any>): Promise<number>;
+    createOne(collection: string, values: Record<string, any>): Promise<Record<string, any>>;
+    create(collection: string, values: Record<string, any>[]): Promise<Record<string, any>[]>;
+    private loadCollection;
+    dropCollection(name: string): Promise<void>;
+    dropDatabase(): Promise<void>;
+    findOne(collection: string, query?: Record<string, any>, options?: QueryOptions): Promise<Record<string, any> | null>;
+    find(collection: string, query?: Record<string, any>, options?: QueryOptions): Promise<Record<string, any>[]>;
+    update(collection: string, query: Record<string, any>, updates: Record<string, any>, neDbOptions?: Record<string, any>): Promise<number>;
+    updateOne(collection: string, query: Record<string, any>, updates: Record<string, any>, neDbOptions?: Record<string, any>, action?: string): Promise<Record<string, any>>;
+    upsertOne(collection: string, query: Record<string, any>, updates: Record<string, any>): Promise<Record<string, any>>;
+    delete(collection: string, query: Record<string, any>): Promise<number>;
+    deleteOne(collection: string, query: Record<string, any>): Promise<number>;
+    private assertPassesUniqueIndexes;
+    getUniqueIndexes(collection: string): Promise<string[][]>;
+    getIndexes(collection: string, shouldIncludeUnique?: boolean): Promise<string[][]>;
+    dropIndex(collection: string, fields: string[]): Promise<void>;
+    private assertIndexDoesNotExist;
+    private doesIndexExist;
+    createUniqueIndex(collection: string, fields: string[]): Promise<void>;
+    createIndex(collection: string, fields: string[]): Promise<void>;
+    syncUniqueIndexes(collectionName: string, indexes: string[][]): Promise<void>;
+    syncIndexes(collectionName: string, indexes: string[][]): Promise<void>;
+}