@sprucelabs/spruce-cli 17.1.11 → 17.1.14

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

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

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

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

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