@sprucelabs/spruce-cli 17.1.14 → 17.1.17

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

@@ -1,25 +0,0 @@
-"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

@@ -1,44 +0,0 @@
-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

@@ -1,432 +0,0 @@
-"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

@@ -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>;
-}