@sprucelabs/data-stores 26.2.9 → 26.3.1

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/dataStores/queryNotFaked.schema.d.ts

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

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@sprucelabs/schema");
+const queryNotFakedSchema = {
+    id: 'queryNotFaked',
+    namespace: 'DataStores',
+    name: 'Query not faked',
+    fields: {
+        /** . */
+        'query': {
+            type: 'text',
+            isRequired: true,
+            options: undefined
+        },
+        /** . */
+        'params': {
+            type: 'raw',
+            options: { valueType: `Record<string, any>`, }
+        },
+    }
+};
+schema_1.SchemaRegistry.getInstance().trackSchema(queryNotFakedSchema);
+exports.default = queryNotFakedSchema;

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

@@ -134,6 +134,33 @@ export declare namespace SpruceErrors.DataStores {
     }
     type RecordNotFoundEntity = SchemaEntity<SpruceErrors.DataStores.RecordNotFoundSchema>;
 }
+export declare namespace SpruceErrors.DataStores {
+    interface QueryNotFaked {
+        'query': string;
+        'params'?: (Record<string, any>) | undefined | null;
+    }
+    interface QueryNotFakedSchema extends SpruceSchema.Schema {
+        id: 'queryNotFaked';
+        namespace: 'DataStores';
+        name: 'Query not faked';
+        fields: {
+            /** . */
+            'query': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+            /** . */
+            'params': {
+                type: 'raw';
+                options: {
+                    valueType: `Record<string, any>`;
+                };
+            };
+        };
+    }
+    type QueryNotFakedEntity = SchemaEntity<SpruceErrors.DataStores.QueryNotFakedSchema>;
+}
 export declare namespace SpruceErrors.DataStores {
     interface NotImplemented {
     }
@@ -194,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

@@ -18,6 +18,9 @@ export interface ScrambleNotConfiguredErrorOptions extends SpruceErrors.DataStor
 export interface RecordNotFoundErrorOptions extends SpruceErrors.DataStores.RecordNotFound, ISpruceErrorOptions {
     code: 'RECORD_NOT_FOUND';
 }
+export interface QueryNotFakedErrorOptions extends SpruceErrors.DataStores.QueryNotFaked, ISpruceErrorOptions {
+    code: 'QUERY_NOT_FAKED';
+}
 export interface NotImplementedErrorOptions extends SpruceErrors.DataStores.NotImplemented, ISpruceErrorOptions {
     code: 'NOT_IMPLEMENTED';
 }
@@ -30,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';
 }
@@ -60,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 | 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/MongoDatabase.js

@@ -444,6 +444,7 @@ class MongoDatabase {
     async query() {
         throw new SpruceError_1.default({
             code: 'NOT_IMPLEMENTED',
+            friendlyMessage: `You cannot run a query using mongodb. Try a different database adapter!`,
         });
     }
 }

package/build/databases/NeDbDatabase.d.ts

@@ -4,6 +4,7 @@ import { QueryOptions } from '../types/query.types';
 export default class NeDbDatabase extends AbstractMutexer implements Database {
     private collections;
     private _isConnected;
+    private fakedQueries;
     generateId(): string;
     connect(): Promise<void>;
     close(): Promise<void>;
@@ -39,5 +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>(): 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[];

package/build/databases/NeDbDatabase.js

@@ -36,6 +36,7 @@ class NeDbDatabase extends AbstractMutexer_1.default {
         super(...arguments);
         this.collections = {};
         this._isConnected = false;
+        this.fakedQueries = {};
     }
     generateId() {
         return (0, generateId_1.default)();
@@ -458,10 +459,29 @@ class NeDbDatabase extends AbstractMutexer_1.default {
             await this.dropIndex(collectionName, extra);
         }
     }
-    async query() {
+    async query(query, params) {
+        const cb = this.fakedQueries[query];
+        if (cb) {
+            const results = await cb(params);
+            this.assertValidFakedQueryResponse(results, query);
+            return results;
+        }
         throw new SpruceError_1.default({
-            code: 'NOT_IMPLEMENTED',
+            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;
+    }
 }
 exports.default = NeDbDatabase;

package/build/errors/SpruceError.js

@@ -102,6 +102,12 @@ If you are on a mac, using brew is recommended: https://brew.sh`;
             case 'NOT_IMPLEMENTED':
                 message = 'A Not implemented just happened!';
                 break;
+            case 'QUERY_NOT_FAKED':
+                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();
         }

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/errors/queryNotFaked.builder.d.ts

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

package/build/errors/queryNotFaked.builder.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@sprucelabs/schema");
+exports.default = (0, schema_1.buildErrorSchema)({
+    id: 'queryNotFaked',
+    name: 'Query not faked',
+    fields: {
+        query: {
+            type: 'text',
+            isRequired: true,
+        },
+        params: {
+            type: 'raw',
+            options: { valueType: 'Record<string, any>' },
+        },
+    },
+});

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

@@ -134,6 +134,33 @@ export declare namespace SpruceErrors.DataStores {
     }
     type RecordNotFoundEntity = SchemaEntity<SpruceErrors.DataStores.RecordNotFoundSchema>;
 }
+export declare namespace SpruceErrors.DataStores {
+    interface QueryNotFaked {
+        'query': string;
+        'params'?: (Record<string, any>) | undefined | null;
+    }
+    interface QueryNotFakedSchema extends SpruceSchema.Schema {
+        id: 'queryNotFaked';
+        namespace: 'DataStores';
+        name: 'Query not faked';
+        fields: {
+            /** . */
+            'query': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+            /** . */
+            'params': {
+                type: 'raw';
+                options: {
+                    valueType: `Record<string, any>`;
+                };
+            };
+        };
+    }
+    type QueryNotFakedEntity = SchemaEntity<SpruceErrors.DataStores.QueryNotFakedSchema>;
+}
 export declare namespace SpruceErrors.DataStores {
     interface NotImplemented {
     }
@@ -194,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

@@ -18,6 +18,9 @@ export interface ScrambleNotConfiguredErrorOptions extends SpruceErrors.DataStor
 export interface RecordNotFoundErrorOptions extends SpruceErrors.DataStores.RecordNotFound, ISpruceErrorOptions {
     code: 'RECORD_NOT_FOUND';
 }
+export interface QueryNotFakedErrorOptions extends SpruceErrors.DataStores.QueryNotFaked, ISpruceErrorOptions {
+    code: 'QUERY_NOT_FAKED';
+}
 export interface NotImplementedErrorOptions extends SpruceErrors.DataStores.NotImplemented, ISpruceErrorOptions {
     code: 'NOT_IMPLEMENTED';
 }
@@ -30,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';
 }
@@ -60,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 | 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/MongoDatabase.js

@@ -490,6 +490,7 @@ export default class MongoDatabase {
         return __awaiter(this, void 0, void 0, function* () {
             throw new SpruceError({
                 code: 'NOT_IMPLEMENTED',
+                friendlyMessage: `You cannot run a query using mongodb. Try a different database adapter!`,
             });
         });
     }

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

@@ -4,6 +4,7 @@ import { QueryOptions } from '../types/query.types';
 export default class NeDbDatabase extends AbstractMutexer implements Database {
     private collections;
     private _isConnected;
+    private fakedQueries;
     generateId(): string;
     connect(): Promise<void>;
     close(): Promise<void>;
@@ -39,5 +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>(): 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[];

package/build/esm/databases/NeDbDatabase.js

@@ -40,6 +40,7 @@ export default class NeDbDatabase extends AbstractMutexer {
         super(...arguments);
         this.collections = {};
         this._isConnected = false;
+        this.fakedQueries = {};
     }
     generateId() {
         return generateId();
@@ -508,11 +509,30 @@ export default class NeDbDatabase extends AbstractMutexer {
             }
         });
     }
-    query() {
+    query(query, params) {
         return __awaiter(this, void 0, void 0, function* () {
+            const cb = this.fakedQueries[query];
+            if (cb) {
+                const results = yield cb(params);
+                this.assertValidFakedQueryResponse(results, query);
+                return results;
+            }
             throw new SpruceError({
-                code: 'NOT_IMPLEMENTED',
+                code: 'QUERY_NOT_FAKED',
+                query,
             });
         });
     }
+    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

@@ -97,6 +97,12 @@ If you are on a mac, using brew is recommended: https://brew.sh`;
             case 'NOT_IMPLEMENTED':
                 message = 'A Not implemented just happened!';
                 break;
+            case 'QUERY_NOT_FAKED':
+                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();
         }

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/errors/queryNotFaked.builder.d.ts

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

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

@@ -0,0 +1,15 @@
+import { buildErrorSchema } from '@sprucelabs/schema';
+export default buildErrorSchema({
+    id: 'queryNotFaked',
+    name: 'Query not faked',
+    fields: {
+        query: {
+            type: 'text',
+            isRequired: true,
+        },
+        params: {
+            type: 'raw',
+            options: { valueType: 'Record<string, any>' },
+        },
+    },
+});

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): Promise<T>;
+    query<T>(query: string, params?: Record<string, any>): Promise<T[]>;
 }
 export interface DatabaseOptions {
     dbName?: string;

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): 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.2.9",
+  "version": "26.3.1",
   "files": [
     "build/**/*",
     "!build/__tests__",