@sprucelabs/data-stores 11.0.1 → 11.2.0

package/build/cursors/CursorPager.d.ts

@@ -0,0 +1,28 @@
+import { QueryOptions } from '../types/query.types';
+export interface CursorQueryOptions extends Omit<QueryOptions, 'skip'> {
+    limit: number;
+    next: string | null;
+    previous: string | null;
+}
+export interface RecordsWithCursors<Response extends Record<string, any>[] = Record<string, any>[]> {
+    records: Response;
+    next: string | null;
+    previous: string | null;
+}
+export default class CursorPager {
+    static find<S extends SimpleStore, Find extends S['find'] = S['find'], Query extends Parameters<Find>[0] = Parameters<Find>[0], PromisedResponse extends ReturnType<Find> = ReturnType<Find>, Response extends UnPromisify<PromisedResponse> = UnPromisify<PromisedResponse>>(store: S, query: Query, options: CursorQueryOptions): Promise<RecordsWithCursors<Response>>;
+    private static getSortFieldValuesFromRecord;
+    private static trackNewest;
+    private static parseCursor;
+    private static encodeCursor;
+    static prepareQueryOptions<O extends CursorQueryOptions & {
+        limit: number;
+    }>(options: O): O & {
+        sort: NonNullable<O['sort']>;
+    };
+}
+export interface SimpleStore {
+    find: (...args: any[]) => Promise<any>;
+}
+declare type UnPromisify<T> = T extends Promise<infer U> ? U : T;
+export {};

package/build/cursors/CursorPager.js

@@ -0,0 +1,122 @@
+"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 });
+const schema_1 = require("@sprucelabs/schema");
+const just_clone_1 = __importDefault(require("just-clone"));
+class CursorPager {
+    static async find(store, query, options) {
+        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 = await 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 = [] } = (0, just_clone_1.default)((0, schema_1.assertOptions)(options, ['limit']));
+        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: options.limit + 1, sort });
+    }
+}
+exports.default = CursorPager;

package/build/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/build/cursors/CursorPagerFaker.js

@@ -0,0 +1,21 @@
+"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 = response;
+    }
+    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/build/databases/NeDbDatabase.js

@@ -187,6 +187,9 @@ class NeDbDatabase extends AbstractMutexer_1.default {
             if (typeof mapped.limit === 'number') {
                 cursor.limit(mapped.limit);
             }
+            if (mapped.skip) {
+                cursor.skip(mapped.skip);
+            }
             cursor.exec((err, results) => {
                 if (err) {
                     reject(err);

package/build/esm/cursors/CursorPager.d.ts

@@ -0,0 +1,28 @@
+import { QueryOptions } from '../types/query.types';
+export interface CursorQueryOptions extends Omit<QueryOptions, 'skip'> {
+    limit: number;
+    next: string | null;
+    previous: string | null;
+}
+export interface RecordsWithCursors<Response extends Record<string, any>[] = Record<string, any>[]> {
+    records: Response;
+    next: string | null;
+    previous: string | null;
+}
+export default class CursorPager {
+    static find<S extends SimpleStore, Find extends S['find'] = S['find'], Query extends Parameters<Find>[0] = Parameters<Find>[0], PromisedResponse extends ReturnType<Find> = ReturnType<Find>, Response extends UnPromisify<PromisedResponse> = UnPromisify<PromisedResponse>>(store: S, query: Query, options: CursorQueryOptions): Promise<RecordsWithCursors<Response>>;
+    private static getSortFieldValuesFromRecord;
+    private static trackNewest;
+    private static parseCursor;
+    private static encodeCursor;
+    static prepareQueryOptions<O extends CursorQueryOptions & {
+        limit: number;
+    }>(options: O): O & {
+        sort: NonNullable<O['sort']>;
+    };
+}
+export interface SimpleStore {
+    find: (...args: any[]) => Promise<any>;
+}
+declare type UnPromisify<T> = T extends Promise<infer U> ? U : T;
+export {};

package/build/esm/cursors/CursorPager.js

@@ -0,0 +1,127 @@
+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 } 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 = [] } = clone(assertOptions(options, ['limit']));
+        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: options.limit + 1, sort });
+    }
+}

package/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/build/esm/cursors/CursorPagerFaker.js

@@ -0,0 +1,26 @@
+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 = response;
+    }
+    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/build/esm/databases/NeDbDatabase.js

@@ -212,6 +212,9 @@ export default class NeDbDatabase extends AbstractMutexer {
                 if (typeof mapped.limit === 'number') {
                     cursor.limit(mapped.limit);
                 }
+                if (mapped.skip) {
+                    cursor.skip(mapped.skip);
+                }
                 cursor.exec((err, results) => {
                     if (err) {
                         reject(err);

package/build/esm/index.d.ts

@@ -15,3 +15,7 @@ export * from './types/query.types';
 export * from './types/stores.types';
 export * from './constants';
 export { default as generateId } from './utilities/generateId';
+export { default as CursorPager } from './cursors/CursorPager';
+export * from './cursors/CursorPager';
+export { default as CursorPagerFaker } from './cursors/CursorPagerFaker';
+export * from './cursors/CursorPager';

package/build/esm/index.js

@@ -15,3 +15,7 @@ export * from './types/query.types.js';
 export * from './types/stores.types.js';
 export * from './constants.js';
 export { default as generateId } from './utilities/generateId.js';
+export { default as CursorPager } from './cursors/CursorPager.js';
+export * from './cursors/CursorPager.js';
+export { default as CursorPagerFaker } from './cursors/CursorPagerFaker.js';
+export * from './cursors/CursorPager.js';

package/build/esm/utilities/mongo.utility.js

@@ -21,8 +21,11 @@ const mongoUtil = {
                 friendlyMessage: '`id` cannot be undefined',
             });
         }
-        const { id, $or } = q, rest = __rest(q, ["id", "$or"]);
+        const { id, $or, $and } = q, rest = __rest(q, ["id", "$or", "$and"]);
         let normalizedValues = rest;
+        if (Array.isArray($and)) {
+            normalizedValues.$and = $and.map((a) => this.mapQuery(a, options));
+        }
         if (Array.isArray($or)) {
             normalizedValues.$or = $or.map((o) => this.mapQuery(o, options));
         }

package/build/index.d.ts

@@ -15,3 +15,7 @@ export * from './types/query.types';
 export * from './types/stores.types';
 export * from './constants';
 export { default as generateId } from './utilities/generateId';
+export { default as CursorPager } from './cursors/CursorPager';
+export * from './cursors/CursorPager';
+export { default as CursorPagerFaker } from './cursors/CursorPagerFaker';
+export * from './cursors/CursorPager';

package/build/index.js

@@ -17,7 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateId = exports.mongoUtil = exports.NeDbDatabase = exports.MongoDatabase = exports.StoreLoader = exports.DatabaseFactory = exports.StoreFactory = exports.AbstractStore = exports.DatabaseFixture = exports.AbstractDatabaseTest = void 0;
+exports.CursorPagerFaker = exports.CursorPager = exports.generateId = exports.mongoUtil = exports.NeDbDatabase = exports.MongoDatabase = exports.StoreLoader = exports.DatabaseFactory = exports.StoreFactory = exports.AbstractStore = exports.DatabaseFixture = exports.AbstractDatabaseTest = void 0;
 var AbstractDatabaseTest_1 = require("./tests/AbstractDatabaseTest");
 Object.defineProperty(exports, "AbstractDatabaseTest", { enumerable: true, get: function () { return __importDefault(AbstractDatabaseTest_1).default; } });
 var DatabaseFixture_1 = require("./fixtures/DatabaseFixture");
@@ -45,3 +45,9 @@ __exportStar(require("./types/stores.types"), exports);
 __exportStar(require("./constants"), exports);
 var generateId_1 = require("./utilities/generateId");
 Object.defineProperty(exports, "generateId", { enumerable: true, get: function () { return __importDefault(generateId_1).default; } });
+var CursorPager_1 = require("./cursors/CursorPager");
+Object.defineProperty(exports, "CursorPager", { enumerable: true, get: function () { return __importDefault(CursorPager_1).default; } });
+__exportStar(require("./cursors/CursorPager"), exports);
+var CursorPagerFaker_1 = require("./cursors/CursorPagerFaker");
+Object.defineProperty(exports, "CursorPagerFaker", { enumerable: true, get: function () { return __importDefault(CursorPagerFaker_1).default; } });
+__exportStar(require("./cursors/CursorPager"), exports);

package/build/utilities/mongo.utility.js

@@ -26,8 +26,11 @@ const mongoUtil = {
                 friendlyMessage: '`id` cannot be undefined',
             });
         }
-        const { id, $or } = q, rest = __rest(q, ["id", "$or"]);
+        const { id, $or, $and } = q, rest = __rest(q, ["id", "$or", "$and"]);
         let normalizedValues = rest;
+        if (Array.isArray($and)) {
+            normalizedValues.$and = $and.map((a) => this.mapQuery(a, options));
+        }
         if (Array.isArray($or)) {
             normalizedValues.$or = $or.map((o) => this.mapQuery(o, options));
         }

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "11.0.1",
+  "version": "11.2.0",
   "files": [
     "build/**/*",
     "!build/__tests__",
@@ -72,10 +72,11 @@
   },
   "dependencies": {
     "@sprucelabs/error": "^5.0.452",
-    "@sprucelabs/schema": "^28.0.5",
-    "@sprucelabs/spruce-core-schemas": "^27.0.1",
-    "@sprucelabs/spruce-skill-utils": "^26.0.4",
+    "@sprucelabs/schema": "^28.0.6",
+    "@sprucelabs/spruce-core-schemas": "^27.0.2",
+    "@sprucelabs/spruce-skill-utils": "^26.0.5",
     "globby": "^11.0.4",
+    "just-clone": "^5.0.1",
     "lodash": "^4.17.21",
     "mongodb": "^4.1.0",
     "nedb": "^1.8.0"