@sprucelabs/spruce-cli 17.1.14 → 17.1.15

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

@@ -1,476 +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;
-};
-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

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