@sprucelabs/spruce-cli 17.1.14 → 17.1.17

package/node_modules/@sprucelabs/data-stores/build/errors/unknownDatabaseError.builder.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const schema_1 = require("@sprucelabs/schema");
-exports.default = (0, schema_1.buildErrorSchema)({
-    id: 'unknownDatabaseError',
-    name: 'unknown database error',
-    description: '',
-    fields: {
-        databaseErrorMessage: {
-            type: 'text',
-            isRequired: true,
-        },
-    },
-});

package/node_modules/@sprucelabs/data-stores/build/errors/unknownError.builder.d.ts

@@ -1,6 +0,0 @@
-declare const _default: {
-    id: string;
-    name: string;
-    fields: {};
-};
-export default _default;

package/node_modules/@sprucelabs/data-stores/build/errors/unknownError.builder.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const schema_1 = require("@sprucelabs/schema");
-exports.default = (0, schema_1.buildErrorSchema)({
-    id: 'unknownError',
-    name: 'Unknown Error',
-    fields: {},
-});

package/node_modules/@sprucelabs/data-stores/build/errors/unknownStoreError.builder.d.ts

@@ -1,19 +0,0 @@
-declare const _default: {
-    id: string;
-    name: string;
-    description: string;
-    fields: {
-        action: {
-            type: "text";
-            label: string;
-            isRequired: true;
-            hint: string;
-        };
-        storeName: {
-            type: "text";
-            label: string;
-            isRequired: true;
-        };
-    };
-};
-export default _default;

package/node_modules/@sprucelabs/data-stores/build/errors/unknownStoreError.builder.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const schema_1 = require("@sprucelabs/schema");
-exports.default = (0, schema_1.buildErrorSchema)({
-    id: 'unknownStoreError',
-    name: 'Unknown store error',
-    description: '',
-    fields: {
-        action: {
-            type: 'text',
-            label: 'Action',
-            isRequired: true,
-            hint: 'e.g. createPerson, updateLocation, etc',
-        },
-        storeName: {
-            type: 'text',
-            label: 'Store name',
-            isRequired: true,
-        },
-    },
-});

package/node_modules/@sprucelabs/data-stores/build/esm/.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/esm/.spruce/errors/errors.types.js

@@ -1,3 +0,0 @@
-/* eslint-disable @typescript-eslint/no-namespace */
-/* eslint-disable no-redeclare */
-export {};

package/node_modules/@sprucelabs/data-stores/build/esm/.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/esm/.spruce/errors/options.types.js

@@ -1 +0,0 @@
-export {};

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

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

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

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

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