@sprucelabs/data-stores 26.3.0 → 26.3.2

package/build/.spruce/errors/dataStores/invalidFakeQueryResponse.schema.d.ts

@@ -0,0 +1,3 @@
+import { SpruceErrors } from '../errors.types';
+declare const invalidFakeQueryResponseSchema: SpruceErrors.DataStores.InvalidFakeQueryResponseSchema;
+export default invalidFakeQueryResponseSchema;

package/build/.spruce/errors/dataStores/invalidFakeQueryResponse.schema.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@sprucelabs/schema");
+const invalidFakeQueryResponseSchema = {
+    id: 'invalidFakeQueryResponse',
+    namespace: 'DataStores',
+    name: 'Invalid fake query response',
+    fields: {
+        /** . */
+        'query': {
+            type: 'text',
+            isRequired: true,
+            options: undefined
+        },
+        /** . */
+        'response': {
+            type: 'raw',
+            isRequired: true,
+            options: { valueType: `any`, }
+        },
+    }
+};
+schema_1.SchemaRegistry.getInstance().trackSchema(invalidFakeQueryResponseSchema);
+exports.default = invalidFakeQueryResponseSchema;

package/build/.spruce/errors/errors.types.d.ts

@@ -221,6 +221,34 @@ export declare namespace SpruceErrors.DataStores {
     }
     type InvalidStoreEntity = SchemaEntity<SpruceErrors.DataStores.InvalidStoreSchema>;
 }
+export declare namespace SpruceErrors.DataStores {
+    interface InvalidFakeQueryResponse {
+        'query': string;
+        'response': (any);
+    }
+    interface InvalidFakeQueryResponseSchema extends SpruceSchema.Schema {
+        id: 'invalidFakeQueryResponse';
+        namespace: 'DataStores';
+        name: 'Invalid fake query response';
+        fields: {
+            /** . */
+            'query': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+            /** . */
+            'response': {
+                type: 'raw';
+                isRequired: true;
+                options: {
+                    valueType: `any`;
+                };
+            };
+        };
+    }
+    type InvalidFakeQueryResponseEntity = SchemaEntity<SpruceErrors.DataStores.InvalidFakeQueryResponseSchema>;
+}
 export declare namespace SpruceErrors.DataStores {
     interface InvalidDbConnectionString {
     }

package/build/.spruce/errors/options.types.d.ts

@@ -33,6 +33,9 @@ export interface InvalidStoreNameErrorOptions extends SpruceErrors.DataStores.In
 export interface InvalidStoreErrorOptions extends SpruceErrors.DataStores.InvalidStore, ISpruceErrorOptions {
     code: 'INVALID_STORE';
 }
+export interface InvalidFakeQueryResponseErrorOptions extends SpruceErrors.DataStores.InvalidFakeQueryResponse, ISpruceErrorOptions {
+    code: 'INVALID_FAKE_QUERY_RESPONSE';
+}
 export interface InvalidDbConnectionStringErrorOptions extends SpruceErrors.DataStores.InvalidDbConnectionString, ISpruceErrorOptions {
     code: 'INVALID_DB_CONNECTION_STRING';
 }
@@ -63,5 +66,5 @@ export interface DuplicateKeyErrorOptions extends SpruceErrors.DataStores.Duplic
 export interface DatabaseNotConnectedErrorOptions extends SpruceErrors.DataStores.DatabaseNotConnected, ISpruceErrorOptions {
     code: 'DATABASE_NOT_CONNECTED';
 }
-type ErrorOptions = UnknownStoreErrorErrorOptions | UnknownErrorErrorOptions | UnknownDatabaseErrorErrorOptions | UnableToConnectToDbErrorOptions | ScrambleNotConfiguredErrorOptions | RecordNotFoundErrorOptions | QueryNotFakedErrorOptions | NotImplementedErrorOptions | MongoIdMappingErrorErrorOptions | InvalidStoreNameErrorOptions | InvalidStoreErrorOptions | InvalidDbConnectionStringErrorOptions | InvalidDatabaseNameErrorOptions | InvalidConnectionStringSchemeErrorOptions | IndexNotFoundErrorOptions | IndexExistsErrorOptions | FailedToLoadStoresErrorOptions | FailedToLoadStoreErrorOptions | DuplicateRecordErrorOptions | DuplicateKeyErrorOptions | DatabaseNotConnectedErrorOptions;
+type ErrorOptions = UnknownStoreErrorErrorOptions | UnknownErrorErrorOptions | UnknownDatabaseErrorErrorOptions | UnableToConnectToDbErrorOptions | ScrambleNotConfiguredErrorOptions | RecordNotFoundErrorOptions | QueryNotFakedErrorOptions | NotImplementedErrorOptions | MongoIdMappingErrorErrorOptions | InvalidStoreNameErrorOptions | InvalidStoreErrorOptions | InvalidFakeQueryResponseErrorOptions | InvalidDbConnectionStringErrorOptions | InvalidDatabaseNameErrorOptions | InvalidConnectionStringSchemeErrorOptions | IndexNotFoundErrorOptions | IndexExistsErrorOptions | FailedToLoadStoresErrorOptions | FailedToLoadStoreErrorOptions | DuplicateRecordErrorOptions | DuplicateKeyErrorOptions | DatabaseNotConnectedErrorOptions;
 export default ErrorOptions;

package/build/databases/NeDbDatabase.d.ts

@@ -40,7 +40,8 @@ export default class NeDbDatabase extends AbstractMutexer implements Database {
     createIndex(collection: string, fields: string[]): Promise<void>;
     syncUniqueIndexes(collectionName: string, indexes: string[][]): Promise<void>;
     syncIndexes(collectionName: string, indexes: string[][]): Promise<void>;
-    query<T>(query: string, params?: Record<string, any>): Promise<T>;
+    query<T>(query: string, params?: any[]): Promise<T[]>;
+    private assertValidFakedQueryResponse;
     fakeQuery<T>(query: string, cb: FakeQueryHandler<T>): void;
 }
-export type FakeQueryHandler<T> = (params?: Record<string, any>) => Promise<T> | T;
+export type FakeQueryHandler<T> = (params?: Record<string, any>) => Promise<T[]> | T[];

package/build/databases/NeDbDatabase.js

@@ -462,13 +462,24 @@ class NeDbDatabase extends AbstractMutexer_1.default {
     async query(query, params) {
         const cb = this.fakedQueries[query];
         if (cb) {
-            return cb(params);
+            const results = await cb(params);
+            this.assertValidFakedQueryResponse(results, query);
+            return results;
         }
         throw new SpruceError_1.default({
             code: 'QUERY_NOT_FAKED',
             query,
         });
     }
+    assertValidFakedQueryResponse(results, query) {
+        if (!Array.isArray(results)) {
+            throw new SpruceError_1.default({
+                code: 'INVALID_FAKE_QUERY_RESPONSE',
+                query,
+                response: results,
+            });
+        }
+    }
     fakeQuery(query, cb) {
         this.fakedQueries[query] = cb;
     }

package/build/errors/SpruceError.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const error_1 = __importDefault(require("@sprucelabs/error"));
 class SpruceError extends error_1.default {
     friendlyMessage() {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         const { options } = this;
         let message;
         switch (options === null || options === void 0 ? void 0 : options.code) {
@@ -103,12 +103,15 @@ If you are on a mac, using brew is recommended: https://brew.sh`;
                 message = 'A Not implemented just happened!';
                 break;
             case 'QUERY_NOT_FAKED':
-                message = `The query '${options.query}' was not faked. Try this.stores.fakeQuery(...).`;
+                message = `The query '${options.query}' was not faked. Try this.db.fakeQuery(...).`;
+                break;
+            case 'INVALID_FAKE_QUERY_RESPONSE':
+                message = `The query '${options.query}' was faked but the response was not an array. Make sure this.db.fakeQuery('${options.query}', () => []) returns an array.`;
                 break;
             default:
                 message = super.friendlyMessage();
         }
-        const fullMessage = message !== null && message !== void 0 ? message : options.friendlyMessage;
+        const fullMessage = (_d = options.friendlyMessage) !== null && _d !== void 0 ? _d : message;
         return fullMessage;
     }
 }

package/build/errors/invalidFakeQueryResponse.builder.d.ts

@@ -0,0 +1,18 @@
+declare const _default: {
+    id: string;
+    name: string;
+    fields: {
+        query: {
+            type: "text";
+            isRequired: true;
+        };
+        response: {
+            type: "raw";
+            isRequired: true;
+            options: {
+                valueType: string;
+            };
+        };
+    };
+};
+export default _default;

package/build/errors/invalidFakeQueryResponse.builder.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@sprucelabs/schema");
+exports.default = (0, schema_1.buildErrorSchema)({
+    id: 'invalidFakeQueryResponse',
+    name: 'Invalid fake query response',
+    fields: {
+        query: {
+            type: 'text',
+            isRequired: true,
+        },
+        response: {
+            type: 'raw',
+            isRequired: true,
+            options: {
+                valueType: 'any',
+            },
+        },
+    },
+});

package/build/esm/.spruce/errors/errors.types.d.ts

@@ -221,6 +221,34 @@ export declare namespace SpruceErrors.DataStores {
     }
     type InvalidStoreEntity = SchemaEntity<SpruceErrors.DataStores.InvalidStoreSchema>;
 }
+export declare namespace SpruceErrors.DataStores {
+    interface InvalidFakeQueryResponse {
+        'query': string;
+        'response': (any);
+    }
+    interface InvalidFakeQueryResponseSchema extends SpruceSchema.Schema {
+        id: 'invalidFakeQueryResponse';
+        namespace: 'DataStores';
+        name: 'Invalid fake query response';
+        fields: {
+            /** . */
+            'query': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+            /** . */
+            'response': {
+                type: 'raw';
+                isRequired: true;
+                options: {
+                    valueType: `any`;
+                };
+            };
+        };
+    }
+    type InvalidFakeQueryResponseEntity = SchemaEntity<SpruceErrors.DataStores.InvalidFakeQueryResponseSchema>;
+}
 export declare namespace SpruceErrors.DataStores {
     interface InvalidDbConnectionString {
     }

package/build/esm/.spruce/errors/options.types.d.ts

@@ -33,6 +33,9 @@ export interface InvalidStoreNameErrorOptions extends SpruceErrors.DataStores.In
 export interface InvalidStoreErrorOptions extends SpruceErrors.DataStores.InvalidStore, ISpruceErrorOptions {
     code: 'INVALID_STORE';
 }
+export interface InvalidFakeQueryResponseErrorOptions extends SpruceErrors.DataStores.InvalidFakeQueryResponse, ISpruceErrorOptions {
+    code: 'INVALID_FAKE_QUERY_RESPONSE';
+}
 export interface InvalidDbConnectionStringErrorOptions extends SpruceErrors.DataStores.InvalidDbConnectionString, ISpruceErrorOptions {
     code: 'INVALID_DB_CONNECTION_STRING';
 }
@@ -63,5 +66,5 @@ export interface DuplicateKeyErrorOptions extends SpruceErrors.DataStores.Duplic
 export interface DatabaseNotConnectedErrorOptions extends SpruceErrors.DataStores.DatabaseNotConnected, ISpruceErrorOptions {
     code: 'DATABASE_NOT_CONNECTED';
 }
-type ErrorOptions = UnknownStoreErrorErrorOptions | UnknownErrorErrorOptions | UnknownDatabaseErrorErrorOptions | UnableToConnectToDbErrorOptions | ScrambleNotConfiguredErrorOptions | RecordNotFoundErrorOptions | QueryNotFakedErrorOptions | NotImplementedErrorOptions | MongoIdMappingErrorErrorOptions | InvalidStoreNameErrorOptions | InvalidStoreErrorOptions | InvalidDbConnectionStringErrorOptions | InvalidDatabaseNameErrorOptions | InvalidConnectionStringSchemeErrorOptions | IndexNotFoundErrorOptions | IndexExistsErrorOptions | FailedToLoadStoresErrorOptions | FailedToLoadStoreErrorOptions | DuplicateRecordErrorOptions | DuplicateKeyErrorOptions | DatabaseNotConnectedErrorOptions;
+type ErrorOptions = UnknownStoreErrorErrorOptions | UnknownErrorErrorOptions | UnknownDatabaseErrorErrorOptions | UnableToConnectToDbErrorOptions | ScrambleNotConfiguredErrorOptions | RecordNotFoundErrorOptions | QueryNotFakedErrorOptions | NotImplementedErrorOptions | MongoIdMappingErrorErrorOptions | InvalidStoreNameErrorOptions | InvalidStoreErrorOptions | InvalidFakeQueryResponseErrorOptions | InvalidDbConnectionStringErrorOptions | InvalidDatabaseNameErrorOptions | InvalidConnectionStringSchemeErrorOptions | IndexNotFoundErrorOptions | IndexExistsErrorOptions | FailedToLoadStoresErrorOptions | FailedToLoadStoreErrorOptions | DuplicateRecordErrorOptions | DuplicateKeyErrorOptions | DatabaseNotConnectedErrorOptions;
 export default ErrorOptions;

package/build/esm/databases/NeDbDatabase.d.ts

@@ -40,7 +40,8 @@ export default class NeDbDatabase extends AbstractMutexer implements Database {
     createIndex(collection: string, fields: string[]): Promise<void>;
     syncUniqueIndexes(collectionName: string, indexes: string[][]): Promise<void>;
     syncIndexes(collectionName: string, indexes: string[][]): Promise<void>;
-    query<T>(query: string, params?: Record<string, any>): Promise<T>;
+    query<T>(query: string, params?: any[]): Promise<T[]>;
+    private assertValidFakedQueryResponse;
     fakeQuery<T>(query: string, cb: FakeQueryHandler<T>): void;
 }
-export type FakeQueryHandler<T> = (params?: Record<string, any>) => Promise<T> | T;
+export type FakeQueryHandler<T> = (params?: Record<string, any>) => Promise<T[]> | T[];

package/build/esm/databases/NeDbDatabase.js

@@ -513,7 +513,9 @@ export default class NeDbDatabase extends AbstractMutexer {
         return __awaiter(this, void 0, void 0, function* () {
             const cb = this.fakedQueries[query];
             if (cb) {
-                return cb(params);
+                const results = yield cb(params);
+                this.assertValidFakedQueryResponse(results, query);
+                return results;
             }
             throw new SpruceError({
                 code: 'QUERY_NOT_FAKED',
@@ -521,6 +523,15 @@ export default class NeDbDatabase extends AbstractMutexer {
             });
         });
     }
+    assertValidFakedQueryResponse(results, query) {
+        if (!Array.isArray(results)) {
+            throw new SpruceError({
+                code: 'INVALID_FAKE_QUERY_RESPONSE',
+                query,
+                response: results,
+            });
+        }
+    }
     fakeQuery(query, cb) {
         this.fakedQueries[query] = cb;
     }

package/build/esm/errors/SpruceError.js

@@ -1,7 +1,7 @@
 import AbstractSpruceError from '@sprucelabs/error';
 export default class SpruceError extends AbstractSpruceError {
     friendlyMessage() {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         const { options } = this;
         let message;
         switch (options === null || options === void 0 ? void 0 : options.code) {
@@ -98,12 +98,15 @@ If you are on a mac, using brew is recommended: https://brew.sh`;
                 message = 'A Not implemented just happened!';
                 break;
             case 'QUERY_NOT_FAKED':
-                message = `The query '${options.query}' was not faked. Try this.stores.fakeQuery(...).`;
+                message = `The query '${options.query}' was not faked. Try this.db.fakeQuery(...).`;
+                break;
+            case 'INVALID_FAKE_QUERY_RESPONSE':
+                message = `The query '${options.query}' was faked but the response was not an array. Make sure this.db.fakeQuery('${options.query}', () => []) returns an array.`;
                 break;
             default:
                 message = super.friendlyMessage();
         }
-        const fullMessage = message !== null && message !== void 0 ? message : options.friendlyMessage;
+        const fullMessage = (_d = options.friendlyMessage) !== null && _d !== void 0 ? _d : message;
         return fullMessage;
     }
 }

package/build/esm/errors/invalidFakeQueryResponse.builder.d.ts

@@ -0,0 +1,18 @@
+declare const _default: {
+    id: string;
+    name: string;
+    fields: {
+        query: {
+            type: "text";
+            isRequired: true;
+        };
+        response: {
+            type: "raw";
+            isRequired: true;
+            options: {
+                valueType: string;
+            };
+        };
+    };
+};
+export default _default;

package/build/esm/errors/invalidFakeQueryResponse.builder.js

@@ -0,0 +1,18 @@
+import { buildErrorSchema } from '@sprucelabs/schema';
+export default buildErrorSchema({
+    id: 'invalidFakeQueryResponse',
+    name: 'Invalid fake query response',
+    fields: {
+        query: {
+            type: 'text',
+            isRequired: true,
+        },
+        response: {
+            type: 'raw',
+            isRequired: true,
+            options: {
+                valueType: 'any',
+            },
+        },
+    },
+});

package/build/esm/factories/DatabaseFactory.d.ts

@@ -4,11 +4,13 @@ export default class DatabaseFactory {
     private static Adapters;
     private constructor();
     static addAdapter(scheme: string, Adapter: DatabaseConstructor): void;
-    static Database(options: {
-        dbName?: string;
-        dbConnectionString: string;
-    }): Database;
+    static Database(options: DatabaseFactoryOptions): Database;
     private static generateCacheKey;
     static reset(): void;
 }
 export type DatabaseConstructor = new (connectionString: string, options: DatabaseOptions) => Database;
+interface DatabaseFactoryOptions {
+    dbName?: string;
+    dbConnectionString: string;
+}
+export {};

package/build/esm/fixtures/DatabaseFixture.d.ts

@@ -1,3 +1,4 @@
+import { FakeQueryHandler } from '../databases/NeDbDatabase';
 import { Database } from '../types/database.types';
 export interface DatabaseFixtureOptions {
     dbConnectionString?: string;
@@ -12,6 +13,7 @@ export default class DatabaseFixture {
     constructor(options?: DatabaseFixtureOptions);
     connectToDatabase(): Promise<Database>;
     private static connect;
+    fakeQuery<T>(query: string, cb: FakeQueryHandler<T>): void;
     static setDefaultConnectOptions(options: DatabaseFixtureOptions): void;
     static generateDbName(): string;
     getDbName(): string;

package/build/esm/fixtures/DatabaseFixture.js

@@ -9,6 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { SchemaError } from '@sprucelabs/schema';
 import { MONGO_TEST_URI } from '../databases/MongoDatabase.js';
+import SpruceError from '../errors/SpruceError.js';
 import DatabaseFactory from '../factories/DatabaseFactory.js';
 const MEMORY = 'memory://';
 class DatabaseFixture {
@@ -53,6 +54,17 @@ class DatabaseFixture {
             return database;
         });
     }
+    fakeQuery(query, cb) {
+        const db = DatabaseFixture.activeDatabases[0];
+        if (!db) {
+            throw new SpruceError({
+                code: 'DATABASE_NOT_CONNECTED',
+                operationAttempted: 'fakeQuery',
+                friendlyMessage: "You can't fake a query until you connect to a database.",
+            });
+        }
+        db.fakeQuery(query, cb);
+    }
     static setDefaultConnectOptions(options) {
         this.defaultOptions = options;
     }

package/build/esm/types/database.types.d.ts

@@ -26,7 +26,7 @@ export interface Database {
     count(collection: string, query?: Record<string, any>): Promise<number>;
     createUniqueIndex(collection: string, fields: UniqueIndex): Promise<void>;
     createIndex(collection: string, fields: Index): Promise<void>;
-    query<T>(query: string, params?: Record<string, any>): Promise<T>;
+    query<T>(query: string, params?: Record<string, any>): Promise<T[]>;
 }
 export interface DatabaseOptions {
     dbName?: string;

package/build/factories/DatabaseFactory.d.ts

@@ -4,11 +4,13 @@ export default class DatabaseFactory {
     private static Adapters;
     private constructor();
     static addAdapter(scheme: string, Adapter: DatabaseConstructor): void;
-    static Database(options: {
-        dbName?: string;
-        dbConnectionString: string;
-    }): Database;
+    static Database(options: DatabaseFactoryOptions): Database;
     private static generateCacheKey;
     static reset(): void;
 }
 export type DatabaseConstructor = new (connectionString: string, options: DatabaseOptions) => Database;
+interface DatabaseFactoryOptions {
+    dbName?: string;
+    dbConnectionString: string;
+}
+export {};

package/build/fixtures/DatabaseFixture.d.ts

@@ -1,3 +1,4 @@
+import { FakeQueryHandler } from '../databases/NeDbDatabase';
 import { Database } from '../types/database.types';
 export interface DatabaseFixtureOptions {
     dbConnectionString?: string;
@@ -12,6 +13,7 @@ export default class DatabaseFixture {
     constructor(options?: DatabaseFixtureOptions);
     connectToDatabase(): Promise<Database>;
     private static connect;
+    fakeQuery<T>(query: string, cb: FakeQueryHandler<T>): void;
     static setDefaultConnectOptions(options: DatabaseFixtureOptions): void;
     static generateDbName(): string;
     getDbName(): string;

package/build/fixtures/DatabaseFixture.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const schema_1 = require("@sprucelabs/schema");
 const MongoDatabase_1 = require("../databases/MongoDatabase");
+const SpruceError_1 = __importDefault(require("../errors/SpruceError"));
 const DatabaseFactory_1 = __importDefault(require("../factories/DatabaseFactory"));
 const MEMORY = 'memory://';
 class DatabaseFixture {
@@ -45,6 +46,17 @@ class DatabaseFixture {
         DatabaseFixture.activeDatabases.push(database);
         return database;
     }
+    fakeQuery(query, cb) {
+        const db = DatabaseFixture.activeDatabases[0];
+        if (!db) {
+            throw new SpruceError_1.default({
+                code: 'DATABASE_NOT_CONNECTED',
+                operationAttempted: 'fakeQuery',
+                friendlyMessage: "You can't fake a query until you connect to a database.",
+            });
+        }
+        db.fakeQuery(query, cb);
+    }
     static setDefaultConnectOptions(options) {
         this.defaultOptions = options;
     }

package/build/types/database.types.d.ts

@@ -26,7 +26,7 @@ export interface Database {
     count(collection: string, query?: Record<string, any>): Promise<number>;
     createUniqueIndex(collection: string, fields: UniqueIndex): Promise<void>;
     createIndex(collection: string, fields: Index): Promise<void>;
-    query<T>(query: string, params?: Record<string, any>): Promise<T>;
+    query<T>(query: string, params?: Record<string, any>): Promise<T[]>;
 }
 export interface DatabaseOptions {
     dbName?: string;

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "26.3.0",
+  "version": "26.3.2",
   "files": [
     "build/**/*",
     "!build/__tests__",