@sprucelabs/data-stores 19.3.3 → 20.0.1

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

@@ -14,6 +14,12 @@ const indexNotFoundSchema = {
             isArray: true,
             options: undefined
         },
+        /** . */
+        'collectionName': {
+            type: 'text',
+            isRequired: true,
+            options: undefined
+        },
     }
 };
 schema_1.SchemaRegistry.getInstance().trackSchema(indexNotFoundSchema);

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

@@ -236,6 +236,7 @@ export declare namespace SpruceErrors.DataStores {
     interface IndexNotFound {
         /** Missing Index. */
         'missingIndex': string[];
+        'collectionName': string;
     }
     interface IndexNotFoundSchema extends SpruceSchema.Schema {
         id: 'indexNotFound';
@@ -250,6 +251,12 @@ export declare namespace SpruceErrors.DataStores {
                 isArray: true;
                 options: undefined;
             };
+            /** . */
+            'collectionName': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
         };
     }
     type IndexNotFoundEntity = SchemaEntity<SpruceErrors.DataStores.IndexNotFoundSchema>;

package/build/databases/MongoDatabase.js

@@ -244,7 +244,11 @@ class MongoDatabase {
             }
         }
         if (!found) {
-            throw new SpruceError_1.default({ code: 'INDEX_NOT_FOUND', missingIndex: fields });
+            throw new SpruceError_1.default({
+                code: 'INDEX_NOT_FOUND',
+                missingIndex: fields,
+                collectionName: collection,
+            });
         }
     }
     async getUniqueIndexes(collection) {
@@ -282,7 +286,7 @@ class MongoDatabase {
     }
     async createIndex(collection, fields) {
         const currentIndexes = await this.getIndexes(collection);
-        await this.assertIndexDoesNotExist(currentIndexes, fields);
+        await this.assertIndexDoesNotExist(currentIndexes, fields, collection);
         const index = {};
         fields.forEach((name) => {
             index[name] = 1;
@@ -304,12 +308,12 @@ class MongoDatabase {
             }
         }
     }
-    assertIndexDoesNotExist(currentIndexes, fields) {
+    assertIndexDoesNotExist(currentIndexes, fields, collectionName) {
         if (this.doesIndexExist(currentIndexes, fields)) {
             throw new SpruceError_1.default({
                 code: 'INDEX_EXISTS',
                 index: fields,
-                collectionName: this.dbName,
+                collectionName,
             });
         }
     }
@@ -335,7 +339,7 @@ class MongoDatabase {
     }
     async createUniqueIndex(collection, fields) {
         const currentIndexes = await this.getUniqueIndexes(collection);
-        await this.assertIndexDoesNotExist(currentIndexes, fields);
+        await this.assertIndexDoesNotExist(currentIndexes, fields, collection);
         const index = {};
         fields.forEach((name) => {
             index[name] = 1;
@@ -388,7 +392,7 @@ class MongoDatabase {
                 throw new SpruceError_1.default({
                     code: 'RECORD_NOT_FOUND',
                     storeName: 'MongoDatabase',
-                    query: q,
+                    query,
                 });
             }
             return this.normalizeRecord(results.value);

package/build/databases/NeDbDatabase.js

@@ -232,7 +232,7 @@ class NeDbDatabase extends AbstractMutexer_1.default {
                     reject(new SpruceError_1.default({
                         code: 'RECORD_NOT_FOUND',
                         storeName: 'NeDatabase',
-                        query: preppedQuery,
+                        query,
                     }));
                 }
                 else {
@@ -348,7 +348,11 @@ class NeDbDatabase extends AbstractMutexer_1.default {
                 return;
             }
         }
-        throw new SpruceError_1.default({ code: 'INDEX_NOT_FOUND', missingIndex: fields });
+        throw new SpruceError_1.default({
+            code: 'INDEX_NOT_FOUND',
+            missingIndex: fields,
+            collectionName: 'test_collection',
+        });
     }
     assertIndexDoesNotExist(currentIndexes, fields, collectionName) {
         if (this.doesIndexExist(currentIndexes, fields)) {

package/build/errors/SpruceError.js

@@ -59,6 +59,9 @@ class SpruceError extends error_1.default {
                 break;
             case 'INVALID_DB_CONNECTION_STRING':
                 message = 'The database connection string you sent is no good!';
+                if (options.originalError) {
+                    message += '\n\nOriginal error:\n\n' + options.originalError.message;
+                }
                 break;
             case 'UNKNOWN_DATABASE_ERROR':
                 message = `Something went wrong with the database, the message is:\n\n"${options.databaseErrorMessage}"`;

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

@@ -9,6 +9,10 @@ declare const _default: {
             isArray: true;
             isRequired: true;
         };
+        collectionName: {
+            type: "text";
+            isRequired: true;
+        };
     };
 };
 export default _default;

package/build/errors/indexNotFound.builder.js

@@ -12,5 +12,9 @@ exports.default = (0, schema_1.buildErrorSchema)({
             isArray: true,
             isRequired: true,
         },
+        collectionName: {
+            type: 'text',
+            isRequired: true,
+        },
     },
 });

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

@@ -236,6 +236,7 @@ export declare namespace SpruceErrors.DataStores {
     interface IndexNotFound {
         /** Missing Index. */
         'missingIndex': string[];
+        'collectionName': string;
     }
     interface IndexNotFoundSchema extends SpruceSchema.Schema {
         id: 'indexNotFound';
@@ -250,6 +251,12 @@ export declare namespace SpruceErrors.DataStores {
                 isArray: true;
                 options: undefined;
             };
+            /** . */
+            'collectionName': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
         };
     }
     type IndexNotFoundEntity = SchemaEntity<SpruceErrors.DataStores.IndexNotFoundSchema>;

package/build/esm/databases/MongoDatabase.js

@@ -270,7 +270,11 @@ export default class MongoDatabase {
                 }
             }
             if (!found) {
-                throw new SpruceError({ code: 'INDEX_NOT_FOUND', missingIndex: fields });
+                throw new SpruceError({
+                    code: 'INDEX_NOT_FOUND',
+                    missingIndex: fields,
+                    collectionName: collection,
+                });
             }
         });
     }
@@ -314,7 +318,7 @@ export default class MongoDatabase {
     createIndex(collection, fields) {
         return __awaiter(this, void 0, void 0, function* () {
             const currentIndexes = yield this.getIndexes(collection);
-            yield this.assertIndexDoesNotExist(currentIndexes, fields);
+            yield this.assertIndexDoesNotExist(currentIndexes, fields, collection);
             const index = {};
             fields.forEach((name) => {
                 index[name] = 1;
@@ -337,12 +341,12 @@ export default class MongoDatabase {
             }
         });
     }
-    assertIndexDoesNotExist(currentIndexes, fields) {
+    assertIndexDoesNotExist(currentIndexes, fields, collectionName) {
         if (this.doesIndexExist(currentIndexes, fields)) {
             throw new SpruceError({
                 code: 'INDEX_EXISTS',
                 index: fields,
-                collectionName: this.dbName,
+                collectionName,
             });
         }
     }
@@ -371,7 +375,7 @@ export default class MongoDatabase {
     createUniqueIndex(collection, fields) {
         return __awaiter(this, void 0, void 0, function* () {
             const currentIndexes = yield this.getUniqueIndexes(collection);
-            yield this.assertIndexDoesNotExist(currentIndexes, fields);
+            yield this.assertIndexDoesNotExist(currentIndexes, fields, collection);
             const index = {};
             fields.forEach((name) => {
                 index[name] = 1;
@@ -430,7 +434,7 @@ export default class MongoDatabase {
                     throw new SpruceError({
                         code: 'RECORD_NOT_FOUND',
                         storeName: 'MongoDatabase',
-                        query: q,
+                        query,
                     });
                 }
                 return this.normalizeRecord(results.value);

package/build/esm/databases/NeDbDatabase.js

@@ -261,7 +261,7 @@ export default class NeDbDatabase extends AbstractMutexer {
                         reject(new SpruceError({
                             code: 'RECORD_NOT_FOUND',
                             storeName: 'NeDatabase',
-                            query: preppedQuery,
+                            query,
                         }));
                     }
                     else {
@@ -389,7 +389,11 @@ export default class NeDbDatabase extends AbstractMutexer {
                     return;
                 }
             }
-            throw new SpruceError({ code: 'INDEX_NOT_FOUND', missingIndex: fields });
+            throw new SpruceError({
+                code: 'INDEX_NOT_FOUND',
+                missingIndex: fields,
+                collectionName: 'test_collection',
+            });
         });
     }
     assertIndexDoesNotExist(currentIndexes, fields, collectionName) {

package/build/esm/errors/SpruceError.js

@@ -54,6 +54,9 @@ export default class SpruceError extends AbstractSpruceError {
                 break;
             case 'INVALID_DB_CONNECTION_STRING':
                 message = 'The database connection string you sent is no good!';
+                if (options.originalError) {
+                    message += '\n\nOriginal error:\n\n' + options.originalError.message;
+                }
                 break;
             case 'UNKNOWN_DATABASE_ERROR':
                 message = `Something went wrong with the database, the message is:\n\n"${options.databaseErrorMessage}"`;

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

@@ -9,6 +9,10 @@ declare const _default: {
             isArray: true;
             isRequired: true;
         };
+        collectionName: {
+            type: "text";
+            isRequired: true;
+        };
     };
 };
 export default _default;

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

@@ -10,5 +10,9 @@ export default buildErrorSchema({
             isArray: true,
             isRequired: true,
         },
+        collectionName: {
+            type: 'text',
+            isRequired: true,
+        },
     },
 });

package/build/esm/index.d.ts

@@ -14,6 +14,7 @@ export * from './types/database.types';
 export * from './types/query.types';
 export * from './types/stores.types';
 export * from './constants';
+export { default as DataStoresError } from './errors/SpruceError';
 export { default as generateId } from './utilities/generateIdDeprecated';
 export { default as CursorPager } from './cursors/CursorPager';
 export * from './cursors/CursorPager';

package/build/esm/index.js

@@ -14,6 +14,7 @@ export * from './types/database.types.js';
 export * from './types/query.types.js';
 export * from './types/stores.types.js';
 export * from './constants.js';
+export { default as DataStoresError } from './errors/SpruceError.js';
 export { default as generateId } from './utilities/generateIdDeprecated.js';
 export { default as CursorPager } from './cursors/CursorPager.js';
 export * from './cursors/CursorPager.js';

package/build/esm/tests/databaseAssertUtil.d.ts

@@ -1,75 +1,82 @@
-import { Connect } from '../__tests__/behavioral/database/Database.test';
-import { Database, Index, UniqueIndex } from '../types/database.types';
+import { Database, Index, TestConnect, UniqueIndex } from '../types/database.types';
 declare const databaseAssertUtil: {
     collectionName: string;
-    runSuite(connect: Connect): Promise<void>;
+    runSuite(connect: TestConnect, tests?: string[]): Promise<void>;
     _getFilteredIndexes(db: Database): Promise<UniqueIndex[] | Index[]>;
     _filterIdIndex(allIndexes: UniqueIndex[] | Index[]): UniqueIndex[] | Index[];
     _assertUpdateUpdatedRightNumberOfRecords(db: Database, search: Record<string, any>, updates: Record<string, any>, expectedUpdateCount: number): Promise<void>;
-    assertCanSortDesc(connect: Connect): Promise<void>;
-    assertCanSortAsc(connect: Connect): Promise<void>;
-    assertInsertingGeneratesId(connect: Connect): Promise<void>;
-    assertThrowsWhenUpdatingRecordNotFound(connect: Connect): Promise<void>;
+    generateIdDifferentEachTime(connect: TestConnect): Promise<void>;
+    assertCanSortDesc(connect: TestConnect): Promise<void>;
+    assertCanSortAsc(connect: TestConnect): Promise<void>;
+    assertInsertingGeneratesId(connect: TestConnect): Promise<void>;
+    assertThrowsWhenUpdatingRecordNotFound(connect: TestConnect): Promise<void>;
     shutdown(db: Database): Promise<void>;
-    assertCanCreateUniqueIndex(connect: Connect): Promise<void>;
-    assertHasNoUniqueIndexToStart(connect: Connect): Promise<void>;
-    assertCanShutdown(connect: Connect): Promise<void>;
-    assertCanDeleteOne(connect: Connect): Promise<void>;
-    assertCanDeleteRecord(connect: Connect): Promise<void>;
-    assertCanLimitResultsToZero(connect: Connect): Promise<void>;
-    assertCanLimitResults(connect: Connect): Promise<void>;
-    assertFindOneOnEmptyDatabaseReturnsNull(connect: Connect): Promise<void>;
-    assertEmptyDatabaseReturnsEmptyArray(connect: Connect): Promise<void>;
-    assertCanPushOntoArrayValue(connect: Connect): Promise<void>;
-    assertCanCreateMany(connect: Connect): Promise<void>;
-    assertCanUpdateMany(connect: Connect): Promise<void>;
-    assertCanQueryWithOr(connect: Connect): Promise<void>;
-    assertCanUpdate(connect: Connect): Promise<void>;
-    assertCanSortById(connect: Connect): Promise<void>;
-    assertCanCreateMultiFieldUniqueIndex(connect: Connect): Promise<void>;
-    assertSettingUniqueIndexViolationThrowsSpruceError(connect: Connect): Promise<void>;
-    assertDuplicateKeyThrowsOnInsert(connect: Connect): Promise<void>;
-    assertSyncingIndexesDoesNotAddAndRemove(connect: Connect): Promise<void>;
-    assertSyncingUniqueIndexesRemovesExtraIndexes(connect: Connect): Promise<void>;
-    assertSyncingUniqueIndexsSkipsExistingIndexs(connect: Connect): Promise<void>;
-    assertSyncingUniqueIndexsAddsMissingIndexes(connect: Connect): Promise<void>;
-    assertCantDropCompoundUniqueIndexThatDoesntExist(connect: Connect): Promise<void>;
-    assertCantDropIndexWhenNoIndexExists(connect: Connect): Promise<void>;
-    assertCantDropUniqueIndexThatDoesntExist(connect: Connect): Promise<void>;
-    assertCanDropCompoundUniqueIndex(connect: Connect): Promise<void>;
-    assertCanDropUniqueIndex(connect: Connect): Promise<void>;
-    assertCantCreateUniqueIndexTwice(connect: Connect): Promise<void>;
-    assertSyncingUniqueIndexesIsRaceProof(connect: Connect): Promise<void>;
-    assertUniqueIndexBlocksDuplicates(connect: Connect): Promise<void>;
-    assertCanCreateUniqueIndexOnNestedField(connect: Connect): Promise<void>;
-    assertCanPushToArrayOnUpsert(connect: Connect): Promise<void>;
-    assertCanSearchByRegex(connect: Connect): Promise<void>;
-    assertCanReturnOnlySelectFields(connect: Connect): Promise<void>;
-    assertThrowsWithoutDatabaseName(connect: Connect): Promise<void>;
-    assertThrowsWhenCantConnect(connect: Connect): Promise<void>;
-    assertThrowsWithInvalidConnectionString(connect: Connect): Promise<void>;
-    assertKnowsIfConnectionClosed(connect: Connect): Promise<void>;
-    assertCanQueryPathWithDotSyntax(connect: Connect): Promise<void>;
-    assertCanQueryByGtLtGteLte(connect: Connect): Promise<void>;
-    assertCanFindWithNe(connect: Connect): Promise<void>;
-    assertCanFindWithIn(connect: Connect): Promise<void>;
-    assertCanCountOnId(connect: Connect): Promise<void>;
-    assertCanCount(connect: Connect): Promise<void>;
-    assertCanUpsertNull(connect: Connect): Promise<void>;
-    assertCanSaveAndGetNullAndUndefined(connect: Connect): Promise<void>;
-    assertSyncIndexesDoesNotRemoveExisting(connect: Connect): Promise<void>;
-    assertSyncIndexesRemovesExtraIndexes(connect: Connect): Promise<void>;
-    assertSyncIndexesSkipsExisting(connect: Connect): Promise<void>;
-    assertCantDropCompoundIndexThatDoesNotExist(connect: Connect): Promise<void>;
-    assertCanDropCompoundIndex(connect: Connect): Promise<void>;
-    assertCanDropIndex(connect: Connect): Promise<void>;
-    assertCanCreateMultiFieldIndex(connect: Connect, fields: any): Promise<void>;
-    assertCantCreateSameIndexTwice(connect: Connect): Promise<void>;
-    assertCanCreateIndex(connect: Connect): Promise<void>;
-    assertHasNoIndexToStart(connect: Connect): Promise<void>;
-    assertNestedFieldIndexUpdates(connect: Connect): Promise<void>;
-    assertUpsertWithUniqueIndex(connect: Connect): Promise<void>;
-    assertSyncIndexesHandlesRaceConditions(connect: Connect): Promise<void>;
-    assertDuplicateFieldsWithMultipleUniqueIndexesWorkAsExpected(connect: Connect): Promise<void>;
+    assertCanCreateUniqueIndex(connect: TestConnect): Promise<void>;
+    assertHasNoUniqueIndexToStart(connect: TestConnect): Promise<void>;
+    assertCanUpsertOne(connect: TestConnect): Promise<void>;
+    assertCanDeleteOne(connect: TestConnect): Promise<void>;
+    assertCanDeleteRecord(connect: TestConnect): Promise<void>;
+    assertCanLimitResultsToZero(connect: TestConnect): Promise<void>;
+    assertCanLimitResults(connect: TestConnect): Promise<void>;
+    assertFindOneOnEmptyDatabaseReturnsNull(connect: TestConnect): Promise<void>;
+    assertEmptyDatabaseReturnsEmptyArray(connect: TestConnect): Promise<void>;
+    assertCanPushOntoArrayValue(connect: TestConnect): Promise<void>;
+    assertCanCreateWithObjectField(connect: TestConnect): Promise<void>;
+    canUpdateWithObjectField(connect: TestConnect): Promise<void>;
+    canUpdateFieldInObjectFieldWithTargettedWhere(connect: TestConnect): Promise<void>;
+    assertCanCreateMany(connect: TestConnect): Promise<void>;
+    assertCanUpdateMany(connect: TestConnect): Promise<void>;
+    assertCanQueryWithOr(connect: TestConnect): Promise<void>;
+    assertCanUpdate(connect: TestConnect): Promise<void>;
+    assertCanSortById(connect: TestConnect): Promise<void>;
+    assertCanCreateMultiFieldUniqueIndex(connect: TestConnect): Promise<void>;
+    assertSettingUniqueIndexViolationThrowsSpruceError(connect: TestConnect): Promise<void>;
+    assertDuplicateKeyThrowsOnInsert(connect: TestConnect): Promise<void>;
+    assertSyncingIndexesDoesNotAddAndRemove(connect: TestConnect): Promise<void>;
+    assertSyncingUniqueIndexesRemovesExtraIndexes(connect: TestConnect): Promise<void>;
+    assertSyncingUniqueIndexsSkipsExistingIndexs(connect: TestConnect): Promise<void>;
+    assertSyncingUniqueIndexsAddsMissingIndexes(connect: TestConnect): Promise<void>;
+    assertCantDropCompoundUniqueIndexThatDoesntExist(connect: TestConnect): Promise<void>;
+    assertCantDropIndexWhenNoIndexExists(connect: TestConnect): Promise<void>;
+    assertCantDropUniqueIndexThatDoesntExist(connect: TestConnect): Promise<void>;
+    assertCanDropCompoundUniqueIndex(connect: TestConnect): Promise<void>;
+    assertCanDropUniqueIndex(connect: TestConnect): Promise<void>;
+    assertCantCreateUniqueIndexTwice(connect: TestConnect): Promise<void>;
+    assertSyncingUniqueIndexesIsRaceProof(connect: TestConnect): Promise<void>;
+    assertUniqueIndexBlocksDuplicates(connect: TestConnect): Promise<void>;
+    assertCanCreateUniqueIndexOnNestedField(connect: TestConnect): Promise<void>;
+    assertCanPushToArrayOnUpsert(connect: TestConnect): Promise<void>;
+    assertCanSearchByRegex(connect: TestConnect): Promise<void>;
+    assertCanReturnOnlySelectFields(connect: TestConnect): Promise<void>;
+    assertThrowsWithBadDatabaseName(connect: TestConnect): Promise<void>;
+    assertThrowsWhenCantConnect(connect: TestConnect): Promise<void>;
+    assertThrowsWithInvalidConnectionString(connect: TestConnect): Promise<void>;
+    assertKnowsIfConnectionClosed(connect: TestConnect): Promise<void>;
+    assertCanQueryPathWithDotSyntax(connect: TestConnect): Promise<void>;
+    assertCanQueryByGtLtGteLte(connect: TestConnect): Promise<void>;
+    assertCanFindWithNe(connect: TestConnect): Promise<void>;
+    assertCanFindWithIn(connect: TestConnect): Promise<void>;
+    assertCanFindWithBooleanField(connect: TestConnect): Promise<void>;
+    assertCanCountOnId(connect: TestConnect): Promise<void>;
+    assertCanCount(connect: TestConnect): Promise<void>;
+    assertCanUpsertNull(connect: TestConnect): Promise<void>;
+    assertCanSaveAndGetNullAndUndefined(connect: TestConnect): Promise<void>;
+    assertSyncIndexesDoesNotRemoveExisting(connect: TestConnect): Promise<void>;
+    assertSyncIndexesRemovesExtraIndexes(connect: TestConnect): Promise<void>;
+    assertSyncIndexesSkipsExisting(connect: TestConnect): Promise<void>;
+    assertCantDropCompoundIndexThatDoesNotExist(connect: TestConnect): Promise<void>;
+    assertCanDropCompoundIndex(connect: TestConnect): Promise<void>;
+    assertCanDropIndex(connect: TestConnect): Promise<void>;
+    assertCanCreateMultiFieldIndex(connect: TestConnect): Promise<void>;
+    assertCantCreateSameIndexTwice(connect: TestConnect): Promise<void>;
+    assertCanCreateIndex(connect: TestConnect): Promise<void>;
+    assertHasNoIndexToStart(connect: TestConnect): Promise<void>;
+    assertNestedFieldIndexUpdates(connect: TestConnect): Promise<void>;
+    assertUpsertWithUniqueIndex(connect: TestConnect): Promise<void>;
+    assertSyncIndexesHandlesRaceConditions(connect: TestConnect): Promise<void>;
+    assertDuplicateFieldsWithMultipleUniqueIndexesWorkAsExpected(connect: TestConnect): Promise<void>;
+    _assertThrowsExpectedNotFoundOnUpdateOne(db: Database, query: Record<string, any>): Promise<void>;
+    _assert$orReturnsExpectedTotalRecords(db: Database, $or: Record<string, any>[], expected: number): Promise<void>;
+    _assertCanCreateMultiFieldIndex(connect: TestConnect, fields: string[]): Promise<void>;
 };
 export default databaseAssertUtil;