@sprucelabs/spruce-cli 17.1.11 → 17.1.14

package/node_modules/@sprucelabs/data-stores/build/cursors/CursorPagerFaker.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const CursorPager_1 = __importDefault(require("./CursorPager"));
+class CursorPagerFaker {
+    static setResponse(response) {
+        //@ts-ignore
+        CursorPager_1.default.find = async (...args) => {
+            //@ts-ignore
+            const results = await response(...args);
+            return Object.assign({ next: null, previous: null, records: [] }, results);
+        };
+    }
+    static async beforeEach() {
+        if (!this.originalFind) {
+            this.originalFind = CursorPager_1.default.find.bind(CursorPager_1.default);
+        }
+        else {
+            CursorPager_1.default.find = this.originalFind;
+        }
+    }
+}
+exports.default = CursorPagerFaker;

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

@@ -0,0 +1,44 @@
+import { MongoClientOptions } from 'mongodb';
+import { Database } from '../types/database.types';
+import { QueryOptions } from '../types/query.types';
+export declare const MONGO_TEST_URI = "mongodb://localhost:27017";
+export default class MongoDatabase implements Database {
+    private mongo;
+    private db?;
+    private dbName;
+    private disableAutoGeneratedIdsOnTheseCollections;
+    private _isConnected;
+    constructor(url: string, options?: MongoClientOptions & {
+        dbName?: string;
+    });
+    count(collection: string, query?: Record<string, any>): Promise<number>;
+    generateId(): string;
+    delete(collection: string, query: Record<string, any>): Promise<number>;
+    deleteOne(collection: string, query: Record<string, any>): Promise<number>;
+    private assertDbWhileAttempingTo;
+    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>[]>;
+    private toMongoIdAndNull;
+    createOne(collection: string, values: Record<string, any>): Promise<any>;
+    create(collection: string, values: Record<string, any>[]): Promise<Record<string, any>[]>;
+    private normalizeRecord;
+    close(): Promise<void>;
+    connect(): Promise<void>;
+    isConnected(): boolean;
+    dropCollection(name: string): Promise<void>;
+    dropDatabase(): Promise<void>;
+    private listIndexes;
+    dropIndex(collection: string, fields: string[]): Promise<void>;
+    getUniqueIndexes(collection: string): Promise<string[][]>;
+    getIndexes(collection: string, shouldIncludeUnique?: boolean): Promise<any[]>;
+    createIndex(collection: string, fields: string[]): Promise<void>;
+    private assertIndexDoesNotExist;
+    private doesIndexExist;
+    syncIndexes(collectionName: string, indexes: string[][]): Promise<void>;
+    createUniqueIndex(collection: string, fields: string[]): Promise<void>;
+    syncUniqueIndexes(collectionName: string, indexes: string[][]): Promise<void>;
+    update(collection: string, query: Record<string, any>, updates: Record<string, any>): Promise<any>;
+    updateOne(collection: string, query: Record<string, any>, updates: Record<string, any>): Promise<Record<string, any>>;
+    upsertOne(collection: string, query: Record<string, any>, updates: Record<string, any>): Promise<Record<string, any>>;
+    private generateDuplicateFieldsForError;
+}

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

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

package/node_modules/@sprucelabs/data-stores/build/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>;
+}