@sprucelabs/spruce-cli 17.1.14 → 17.1.15

package/node_modules/@sprucelabs/data-stores/build/.spruce/errors/errors.types.d.ts

@@ -1,383 +0,0 @@
-import { default as SchemaEntity } from '@sprucelabs/schema';
-import * as SpruceSchema from '@sprucelabs/schema';
-export declare namespace SpruceErrors.DataStores {
-    interface UnknownStoreError {
-        /** Action. e.g. createPerson, updateLocation, etc */
-        'action': string;
-        /** Store name. */
-        'storeName': string;
-    }
-    interface UnknownStoreErrorSchema extends SpruceSchema.Schema {
-        id: 'unknownStoreError';
-        namespace: 'DataStores';
-        name: 'Unknown store error';
-        fields: {
-            /** Action. e.g. createPerson, updateLocation, etc */
-            'action': {
-                label: 'Action';
-                type: 'text';
-                isRequired: true;
-                hint: 'e.g. createPerson, updateLocation, etc';
-                options: undefined;
-            };
-            /** Store name. */
-            'storeName': {
-                label: 'Store name';
-                type: 'text';
-                isRequired: true;
-                options: undefined;
-            };
-        };
-    }
-    type UnknownStoreErrorEntity = SchemaEntity<SpruceErrors.DataStores.UnknownStoreErrorSchema>;
-}
-export declare namespace SpruceErrors.DataStores {
-    interface UnknownError {
-    }
-    interface UnknownErrorSchema extends SpruceSchema.Schema {
-        id: 'unknownError';
-        namespace: 'DataStores';
-        name: 'Unknown Error';
-        fields: {};
-    }
-    type UnknownErrorEntity = SchemaEntity<SpruceErrors.DataStores.UnknownErrorSchema>;
-}
-export declare namespace SpruceErrors.DataStores {
-    interface UnknownDatabaseError {
-        'databaseErrorMessage': string;
-    }
-    interface UnknownDatabaseErrorSchema extends SpruceSchema.Schema {
-        id: 'unknownDatabaseError';
-        namespace: 'DataStores';
-        name: 'unknown database error';
-        fields: {
-            /** . */
-            'databaseErrorMessage': {
-                type: 'text';
-                isRequired: true;
-                options: undefined;
-            };
-        };
-    }
-    type UnknownDatabaseErrorEntity = SchemaEntity<SpruceErrors.DataStores.UnknownDatabaseErrorSchema>;
-}
-export declare namespace SpruceErrors.DataStores {
-    interface UnableToConnectToDb {
-    }
-    interface UnableToConnectToDbSchema extends SpruceSchema.Schema {
-        id: 'unableToConnectToDb';
-        namespace: 'DataStores';
-        name: 'Unable to connect to db';
-        fields: {};
-    }
-    type UnableToConnectToDbEntity = SchemaEntity<SpruceErrors.DataStores.UnableToConnectToDbSchema>;
-}
-export declare namespace SpruceErrors.DataStores {
-    interface ScrambleNotConfigured {
-    }
-    interface ScrambleNotConfiguredSchema extends SpruceSchema.Schema {
-        id: 'scrambleNotConfigured';
-        namespace: 'DataStores';
-        name: 'Scramble not configured';
-        fields: {};
-    }
-    type ScrambleNotConfiguredEntity = SchemaEntity<SpruceErrors.DataStores.ScrambleNotConfiguredSchema>;
-}
-export declare namespace SpruceErrors.DataStores {
-    interface RecordNotFoundQuery {
-        /** . */
-        [field: string]: (any) | undefined | null;
-    }
-    interface RecordNotFoundQuerySchema extends SpruceSchema.Schema {
-        id: 'record-not-found-query';
-        namespace: 'DataStores';
-        name: 'Search query';
-        dynamicFieldSignature: {
-            type: 'raw';
-            keyName: 'field';
-            options: {
-                valueType: `any`;
-            };
-        };
-    }
-    type RecordNotFoundQueryEntity = SchemaEntity<SpruceErrors.DataStores.RecordNotFoundQuerySchema>;
-}
-export declare namespace SpruceErrors.DataStores {
-    interface RecordNotFound {
-        /** Store name. */
-        'storeName': string;
-        /** Query. */
-        'query': SpruceErrors.DataStores.RecordNotFoundQuery;
-    }
-    interface RecordNotFoundSchema extends SpruceSchema.Schema {
-        id: 'recordNotFound';
-        namespace: 'DataStores';
-        name: 'Record not found';
-        fields: {
-            /** Store name. */
-            'storeName': {
-                label: 'Store name';
-                type: 'text';
-                isRequired: true;
-                options: undefined;
-            };
-            /** Query. */
-            'query': {
-                label: 'Query';
-                type: 'schema';
-                isRequired: true;
-                options: {
-                    schema: SpruceErrors.DataStores.RecordNotFoundQuerySchema;
-                };
-            };
-        };
-    }
-    type RecordNotFoundEntity = SchemaEntity<SpruceErrors.DataStores.RecordNotFoundSchema>;
-}
-export declare namespace SpruceErrors.DataStores {
-    interface MongoIdMappingError {
-    }
-    interface MongoIdMappingErrorSchema extends SpruceSchema.Schema {
-        id: 'mongoIdMappingError';
-        namespace: 'DataStores';
-        name: 'Mongo id mapping error';
-        fields: {};
-    }
-    type MongoIdMappingErrorEntity = SchemaEntity<SpruceErrors.DataStores.MongoIdMappingErrorSchema>;
-}
-export declare namespace SpruceErrors.DataStores {
-    interface InvalidStoreName {
-        'suppliedName': string;
-        'validNames': string[];
-    }
-    interface InvalidStoreNameSchema extends SpruceSchema.Schema {
-        id: 'invalidStoreName';
-        namespace: 'DataStores';
-        name: 'Invalid store';
-        fields: {
-            /** . */
-            'suppliedName': {
-                type: 'text';
-                isRequired: true;
-                options: undefined;
-            };
-            /** . */
-            'validNames': {
-                type: 'text';
-                isRequired: true;
-                isArray: true;
-                options: undefined;
-            };
-        };
-    }
-    type InvalidStoreNameEntity = SchemaEntity<SpruceErrors.DataStores.InvalidStoreNameSchema>;
-}
-export declare namespace SpruceErrors.DataStores {
-    interface InvalidStore {
-    }
-    interface InvalidStoreSchema extends SpruceSchema.Schema {
-        id: 'invalidStore';
-        namespace: 'DataStores';
-        name: 'Invalid store';
-        fields: {};
-    }
-    type InvalidStoreEntity = SchemaEntity<SpruceErrors.DataStores.InvalidStoreSchema>;
-}
-export declare namespace SpruceErrors.DataStores {
-    interface InvalidDbConnectionString {
-    }
-    interface InvalidDbConnectionStringSchema extends SpruceSchema.Schema {
-        id: 'invalidDbConnectionString';
-        namespace: 'DataStores';
-        name: 'Invalid db connection string';
-        fields: {};
-    }
-    type InvalidDbConnectionStringEntity = SchemaEntity<SpruceErrors.DataStores.InvalidDbConnectionStringSchema>;
-}
-export declare namespace SpruceErrors.DataStores {
-    interface InvalidDatabaseName {
-        'suppliedName': string;
-    }
-    interface InvalidDatabaseNameSchema extends SpruceSchema.Schema {
-        id: 'invalidDatabaseName';
-        namespace: 'DataStores';
-        name: 'Invalid database name';
-        fields: {
-            /** . */
-            'suppliedName': {
-                type: 'text';
-                isRequired: true;
-                options: undefined;
-            };
-        };
-    }
-    type InvalidDatabaseNameEntity = SchemaEntity<SpruceErrors.DataStores.InvalidDatabaseNameSchema>;
-}
-export declare namespace SpruceErrors.DataStores {
-    interface IndexNotFound {
-        /** Missing Index. */
-        'missingIndex': string[];
-    }
-    interface IndexNotFoundSchema extends SpruceSchema.Schema {
-        id: 'indexNotFound';
-        namespace: 'DataStores';
-        name: 'Index not found';
-        fields: {
-            /** Missing Index. */
-            'missingIndex': {
-                label: 'Missing Index';
-                type: 'text';
-                isRequired: true;
-                isArray: true;
-                options: undefined;
-            };
-        };
-    }
-    type IndexNotFoundEntity = SchemaEntity<SpruceErrors.DataStores.IndexNotFoundSchema>;
-}
-export declare namespace SpruceErrors.DataStores {
-    interface IndexExists {
-        /** Index Exists. */
-        'index': string[];
-    }
-    interface IndexExistsSchema extends SpruceSchema.Schema {
-        id: 'indexExists';
-        namespace: 'DataStores';
-        name: 'Index Exists';
-        fields: {
-            /** Index Exists. */
-            'index': {
-                label: 'Index Exists';
-                type: 'text';
-                isRequired: true;
-                isArray: true;
-                options: undefined;
-            };
-        };
-    }
-    type IndexExistsEntity = SchemaEntity<SpruceErrors.DataStores.IndexExistsSchema>;
-}
-import AbstractSpruceError from '@sprucelabs/error';
-import { FailedToLoadStoreErrorOptions } from "./options.types";
-export declare namespace SpruceErrors.DataStores {
-    interface FailedToLoadStores {
-        'errors': (AbstractSpruceError<FailedToLoadStoreErrorOptions>)[];
-    }
-    interface FailedToLoadStoresSchema extends SpruceSchema.Schema {
-        id: 'failedToLoadStores';
-        namespace: 'DataStores';
-        name: 'failed to load stores';
-        fields: {
-            /** . */
-            'errors': {
-                type: 'raw';
-                isRequired: true;
-                isArray: true;
-                options: {
-                    valueType: `AbstractSpruceError<FailedToLoadStoreErrorOptions>`;
-                };
-            };
-        };
-    }
-    type FailedToLoadStoresEntity = SchemaEntity<SpruceErrors.DataStores.FailedToLoadStoresSchema>;
-}
-export declare namespace SpruceErrors.DataStores {
-    interface FailedToLoadStore {
-        'name': string;
-    }
-    interface FailedToLoadStoreSchema extends SpruceSchema.Schema {
-        id: 'failedToLoadStore';
-        namespace: 'DataStores';
-        name: 'Failed to load store';
-        fields: {
-            /** . */
-            'name': {
-                type: 'text';
-                isRequired: true;
-                options: undefined;
-            };
-        };
-    }
-    type FailedToLoadStoreEntity = SchemaEntity<SpruceErrors.DataStores.FailedToLoadStoreSchema>;
-}
-export declare namespace SpruceErrors.DataStores {
-    interface DuplicateRecord {
-        'duplicateFields': string[];
-        'duplicateValues': string[];
-        'collectionName': string;
-        /** Action. e.g. create, update, etc. */
-        'action': string;
-    }
-    interface DuplicateRecordSchema extends SpruceSchema.Schema {
-        id: 'duplicateRecord';
-        namespace: 'DataStores';
-        name: 'Duplicate record';
-        fields: {
-            /** . */
-            'duplicateFields': {
-                type: 'text';
-                isRequired: true;
-                isArray: true;
-                options: undefined;
-            };
-            /** . */
-            'duplicateValues': {
-                type: 'text';
-                isRequired: true;
-                isArray: true;
-                options: undefined;
-            };
-            /** . */
-            'collectionName': {
-                type: 'text';
-                isRequired: true;
-                options: undefined;
-            };
-            /** Action. e.g. create, update, etc. */
-            'action': {
-                label: 'Action';
-                type: 'text';
-                isRequired: true;
-                hint: 'e.g. create, update, etc.';
-                options: undefined;
-            };
-        };
-    }
-    type DuplicateRecordEntity = SchemaEntity<SpruceErrors.DataStores.DuplicateRecordSchema>;
-}
-export declare namespace SpruceErrors.DataStores {
-    interface DuplicateKey {
-    }
-    interface DuplicateKeySchema extends SpruceSchema.Schema {
-        id: 'duplicateKey';
-        namespace: 'DataStores';
-        name: 'Duplicate Key';
-        fields: {};
-    }
-    type DuplicateKeyEntity = SchemaEntity<SpruceErrors.DataStores.DuplicateKeySchema>;
-}
-export declare namespace SpruceErrors.DataStores {
-    interface DatabaseNotConnected {
-        'operationAttempted': string;
-        'collectionName'?: string | undefined | null;
-    }
-    interface DatabaseNotConnectedSchema extends SpruceSchema.Schema {
-        id: 'databaseNotConnected';
-        namespace: 'DataStores';
-        name: 'Database not connected';
-        fields: {
-            /** . */
-            'operationAttempted': {
-                type: 'text';
-                isRequired: true;
-                options: undefined;
-            };
-            /** . */
-            'collectionName': {
-                type: 'text';
-                options: undefined;
-            };
-        };
-    }
-    type DatabaseNotConnectedEntity = SchemaEntity<SpruceErrors.DataStores.DatabaseNotConnectedSchema>;
-}

package/node_modules/@sprucelabs/data-stores/build/.spruce/errors/errors.types.js

@@ -1,4 +0,0 @@
-"use strict";
-/* eslint-disable @typescript-eslint/no-namespace */
-/* eslint-disable no-redeclare */
-Object.defineProperty(exports, "__esModule", { value: true });

package/node_modules/@sprucelabs/data-stores/build/.spruce/errors/options.types.d.ts

@@ -1,58 +0,0 @@
-import { SpruceErrors } from "./errors.types";
-import { ErrorOptions as ISpruceErrorOptions } from "@sprucelabs/error";
-export interface UnknownStoreErrorErrorOptions extends SpruceErrors.DataStores.UnknownStoreError, ISpruceErrorOptions {
-    code: 'UNKNOWN_STORE_ERROR';
-}
-export interface UnknownErrorErrorOptions extends SpruceErrors.DataStores.UnknownError, ISpruceErrorOptions {
-    code: 'UNKNOWN_ERROR';
-}
-export interface UnknownDatabaseErrorErrorOptions extends SpruceErrors.DataStores.UnknownDatabaseError, ISpruceErrorOptions {
-    code: 'UNKNOWN_DATABASE_ERROR';
-}
-export interface UnableToConnectToDbErrorOptions extends SpruceErrors.DataStores.UnableToConnectToDb, ISpruceErrorOptions {
-    code: 'UNABLE_TO_CONNECT_TO_DB';
-}
-export interface ScrambleNotConfiguredErrorOptions extends SpruceErrors.DataStores.ScrambleNotConfigured, ISpruceErrorOptions {
-    code: 'SCRAMBLE_NOT_CONFIGURED';
-}
-export interface RecordNotFoundErrorOptions extends SpruceErrors.DataStores.RecordNotFound, ISpruceErrorOptions {
-    code: 'RECORD_NOT_FOUND';
-}
-export interface MongoIdMappingErrorErrorOptions extends SpruceErrors.DataStores.MongoIdMappingError, ISpruceErrorOptions {
-    code: 'MONGO_ID_MAPPING_ERROR';
-}
-export interface InvalidStoreNameErrorOptions extends SpruceErrors.DataStores.InvalidStoreName, ISpruceErrorOptions {
-    code: 'INVALID_STORE_NAME';
-}
-export interface InvalidStoreErrorOptions extends SpruceErrors.DataStores.InvalidStore, ISpruceErrorOptions {
-    code: 'INVALID_STORE';
-}
-export interface InvalidDbConnectionStringErrorOptions extends SpruceErrors.DataStores.InvalidDbConnectionString, ISpruceErrorOptions {
-    code: 'INVALID_DB_CONNECTION_STRING';
-}
-export interface InvalidDatabaseNameErrorOptions extends SpruceErrors.DataStores.InvalidDatabaseName, ISpruceErrorOptions {
-    code: 'INVALID_DATABASE_NAME';
-}
-export interface IndexNotFoundErrorOptions extends SpruceErrors.DataStores.IndexNotFound, ISpruceErrorOptions {
-    code: 'INDEX_NOT_FOUND';
-}
-export interface IndexExistsErrorOptions extends SpruceErrors.DataStores.IndexExists, ISpruceErrorOptions {
-    code: 'INDEX_EXISTS';
-}
-export interface FailedToLoadStoresErrorOptions extends SpruceErrors.DataStores.FailedToLoadStores, ISpruceErrorOptions {
-    code: 'FAILED_TO_LOAD_STORES';
-}
-export interface FailedToLoadStoreErrorOptions extends SpruceErrors.DataStores.FailedToLoadStore, ISpruceErrorOptions {
-    code: 'FAILED_TO_LOAD_STORE';
-}
-export interface DuplicateRecordErrorOptions extends SpruceErrors.DataStores.DuplicateRecord, ISpruceErrorOptions {
-    code: 'DUPLICATE_RECORD';
-}
-export interface DuplicateKeyErrorOptions extends SpruceErrors.DataStores.DuplicateKey, ISpruceErrorOptions {
-    code: 'DUPLICATE_KEY';
-}
-export interface DatabaseNotConnectedErrorOptions extends SpruceErrors.DataStores.DatabaseNotConnected, ISpruceErrorOptions {
-    code: 'DATABASE_NOT_CONNECTED';
-}
-declare type ErrorOptions = UnknownStoreErrorErrorOptions | UnknownErrorErrorOptions | UnknownDatabaseErrorErrorOptions | UnableToConnectToDbErrorOptions | ScrambleNotConfiguredErrorOptions | RecordNotFoundErrorOptions | MongoIdMappingErrorErrorOptions | InvalidStoreNameErrorOptions | InvalidStoreErrorOptions | InvalidDbConnectionStringErrorOptions | InvalidDatabaseNameErrorOptions | IndexNotFoundErrorOptions | IndexExistsErrorOptions | FailedToLoadStoresErrorOptions | FailedToLoadStoreErrorOptions | DuplicateRecordErrorOptions | DuplicateKeyErrorOptions | DatabaseNotConnectedErrorOptions;
-export default ErrorOptions;

package/node_modules/@sprucelabs/data-stores/build/.spruce/errors/options.types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/node_modules/@sprucelabs/data-stores/build/.spruce/schemas/fields/fieldClassMap.d.ts

@@ -1,2 +0,0 @@
-import { fieldClassMap } from '@sprucelabs/schema';
-export default fieldClassMap;

package/node_modules/@sprucelabs/data-stores/build/.spruce/schemas/fields/fieldClassMap.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const schema_1 = require("@sprucelabs/schema");
-exports.default = schema_1.fieldClassMap;

package/node_modules/@sprucelabs/data-stores/build/.spruce/schemas/fields/fields.types.d.ts

@@ -1 +0,0 @@
-export { FieldDefinitions, FieldDefinitionMap, FieldValueTypeGeneratorMap, FieldMap } from '@sprucelabs/schema';

package/node_modules/@sprucelabs/data-stores/build/.spruce/schemas/fields/fields.types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/node_modules/@sprucelabs/data-stores/build/.spruce/settings.json

@@ -1,22 +0,0 @@
-{
-  "installed": [
-    "test",
-    "schema",
-    "error"
-  ],
-  "skipped": [
-    "skill"
-  ],
-  "writer": {
-    "skipped": [
-      "tsconfig.json"
-    ],
-    "skips": [
-      "src/index.ts"
-    ]
-  },
-  "scriptUpdater": {
-    "skipped": [],
-    "skips": []
-  }
-}

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

@@ -1 +0,0 @@
-export declare const SCRAMBLE_VALUE = "***///scrambled///***";

package/node_modules/@sprucelabs/data-stores/build/constants.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SCRAMBLE_VALUE = void 0;
-exports.SCRAMBLE_VALUE = '***///scrambled///***';

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

@@ -1,29 +0,0 @@
-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;
-}
-declare type PrepareQueryOptions = CursorQueryOptions & {
-    limit: number;
-};
-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 PrepareQueryOptions = PrepareQueryOptions>(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/node_modules/@sprucelabs/data-stores/build/cursors/CursorPager.js

@@ -1,129 +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 });
-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 = [], limit, } = (0, just_clone_1.default)((0, schema_1.assertOptions)(options, ['limit']));
-        if (limit < 1) {
-            throw new schema_1.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 });
-    }
-}
-exports.default = CursorPager;

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