@sprucelabs/spruce-cli 17.1.14 → 17.1.17

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

@@ -1,134 +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 { assertOptions, SchemaError } from '@sprucelabs/schema';
-import clone from 'just-clone';
-export default class CursorPager {
-    static find(store, query, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const _a = this.prepareQueryOptions(options), { next, previous } = _a, prepped = __rest(_a, ["next", "previous"]);
-            let cursorQuery;
-            let newest;
-            if (next || previous) {
-                cursorQuery = {};
-                const { sort } = prepped;
-                const cursor = this.parseCursor((next !== null && next !== void 0 ? next : previous));
-                let compare = sort[0].direction === 'asc' ? '$gt' : '$lt';
-                if (cursor.last.length > 1) {
-                    let inverse = compare === '$lt' ? '$gte' : '$lte';
-                    newest = cursor.newest;
-                    let sameNameCompare = '$lt';
-                    if (previous) {
-                        sameNameCompare = '$gt';
-                        inverse = compare;
-                    }
-                    cursorQuery = {
-                        $or: [
-                            {
-                                [sort[0].field]: { [compare]: cursor.last[0] },
-                            },
-                            {
-                                [sort[0].field]: cursor.last[0],
-                                id: { [sameNameCompare]: cursor.id },
-                            },
-                            {
-                                [sort[0].field]: { [inverse]: cursor.last[0] },
-                                id: { $gt: cursor.newest },
-                            },
-                        ],
-                    };
-                }
-                else {
-                    cursorQuery = {
-                        id: { [compare]: cursor.id },
-                    };
-                }
-            }
-            const records = yield store.find(!cursorQuery ? query : { $and: [cursorQuery, query] }, prepped);
-            let newNextCursor;
-            const hasExtra = records.length > options.limit;
-            if (hasExtra) {
-                records.pop();
-            }
-            if (previous) {
-                records.reverse();
-            }
-            if (previous || hasExtra) {
-                const record = records[records.length - 1];
-                newNextCursor = this.encodeCursor({
-                    id: record.id,
-                    newest: this.trackNewest(records, newest),
-                    last: this.getSortFieldValuesFromRecord(prepped, record),
-                });
-            }
-            let newPreviousCursor;
-            if (next || previous) {
-                const record = records[0];
-                newPreviousCursor = this.encodeCursor({
-                    id: record.id,
-                    newest: this.trackNewest(records, newest),
-                    last: this.getSortFieldValuesFromRecord(prepped, record),
-                });
-            }
-            return {
-                records,
-                next: newNextCursor !== null && newNextCursor !== void 0 ? newNextCursor : null,
-                previous: newPreviousCursor !== null && newPreviousCursor !== void 0 ? newPreviousCursor : null,
-            };
-        });
-    }
-    static getSortFieldValuesFromRecord(prepped, record) {
-        return prepped.sort.map((s) => { var _a; return (_a = record[s.field]) !== null && _a !== void 0 ? _a : null; });
-    }
-    static trackNewest(records, newest) {
-        return [...records.map((r) => r.id), newest]
-            .filter((id) => !!id)
-            .sort()
-            .pop();
-    }
-    static parseCursor(next) {
-        return JSON.parse(next);
-    }
-    static encodeCursor(cursor) {
-        return JSON.stringify(cursor);
-    }
-    static prepareQueryOptions(options) {
-        const { previous, sort = [], limit, } = clone(assertOptions(options, ['limit']));
-        if (limit < 1) {
-            throw new SchemaError({
-                code: 'INVALID_PARAMETERS',
-                parameters: ['limit'],
-                friendlyMessage: 'Your limit must be above zero!',
-            });
-        }
-        if (!sort.find((p) => p.field === 'id')) {
-            sort.push({
-                field: 'id',
-                direction: 'desc',
-            });
-        }
-        if (previous) {
-            for (const s of sort) {
-                s.direction = s.direction === 'asc' ? 'desc' : 'asc';
-            }
-        }
-        return Object.assign(Object.assign({}, options), { limit: limit + 1, sort });
-    }
-}

package/node_modules/@sprucelabs/data-stores/build/esm/cursors/CursorPagerFaker.d.ts

@@ -1,6 +0,0 @@
-import { CursorQueryOptions, RecordsWithCursors, SimpleStore } from './CursorPager';
-export default class CursorPagerFaker {
-    private static originalFind;
-    static setResponse(response: (store: SimpleStore, query: Record<string, any>, options: CursorQueryOptions) => Promise<Partial<RecordsWithCursors<Record<string, any>[]>>>): void;
-    static beforeEach(): Promise<void>;
-}

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

@@ -1,30 +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());
-    });
-};
-import CursorPager from './CursorPager.js';
-export default class CursorPagerFaker {
-    static setResponse(response) {
-        //@ts-ignore
-        CursorPager.find = (...args) => __awaiter(this, void 0, void 0, function* () {
-            //@ts-ignore
-            const results = yield response(...args);
-            return Object.assign({ next: null, previous: null, records: [] }, results);
-        });
-    }
-    static beforeEach() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.originalFind) {
-                this.originalFind = CursorPager.find.bind(CursorPager);
-            }
-            else {
-                CursorPager.find = this.originalFind;
-            }
-        });
-    }
-}

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