@sprucelabs/data-stores 28.3.239 → 28.3.240

package/build/databases/MongoDatabase.js

@@ -403,10 +403,11 @@ class MongoDatabase {
     async update(collection, query, updates) {
         const q = this.toMongoIdAndNull(collection, query);
         const values = mongo_utility_1.default.prepareUpdates(updates);
-        const { modifiedCount } = await this.assertDbWhileAttempingTo('update many records.', collection)
+        const results = await this.assertDbWhileAttempingTo('update many records.', collection)
             .collection(collection)
             .updateMany(q, values);
-        return modifiedCount;
+        const { matchedCount } = results;
+        return matchedCount;
     }
     async updateOne(collection, query, updates) {
         const q = this.toMongoIdAndNull(collection, query);

package/build/databases/NeDbDatabase.js

@@ -219,7 +219,7 @@ class NeDbDatabase extends AbstractMutexer_1.default {
         });
     }
     async update(collection, query, updates, neDbOptions) {
-        const results = this.updateOne(collection, query, updates, Object.assign(Object.assign({}, neDbOptions), { multi: true, returnUpdatedDocs: false }), 'update');
+        const results = await this.updateOne(collection, query, updates, Object.assign(Object.assign({}, neDbOptions), { multi: true, returnUpdatedDocs: false }), 'update');
         return results;
     }
     async updateOne(collection, query, updates, neDbOptions, action = 'updateOne') {

package/build/esm/databases/MongoDatabase.js

@@ -445,10 +445,11 @@ export default class MongoDatabase {
         return __awaiter(this, void 0, void 0, function* () {
             const q = this.toMongoIdAndNull(collection, query);
             const values = mongoUtil.prepareUpdates(updates);
-            const { modifiedCount } = yield this.assertDbWhileAttempingTo('update many records.', collection)
+            const results = yield this.assertDbWhileAttempingTo('update many records.', collection)
                 .collection(collection)
                 .updateMany(q, values);
-            return modifiedCount;
+            const { matchedCount } = results;
+            return matchedCount;
         });
     }
     updateOne(collection, query, updates) {

package/build/esm/databases/NeDbDatabase.js

@@ -246,7 +246,7 @@ export default class NeDbDatabase extends AbstractMutexer {
     }
     update(collection, query, updates, neDbOptions) {
         return __awaiter(this, void 0, void 0, function* () {
-            const results = this.updateOne(collection, query, updates, Object.assign(Object.assign({}, neDbOptions), { multi: true, returnUpdatedDocs: false }), 'update');
+            const results = yield this.updateOne(collection, query, updates, Object.assign(Object.assign({}, neDbOptions), { multi: true, returnUpdatedDocs: false }), 'update');
             return results;
         });
     }

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

@@ -1,6 +1,6 @@
 import { Database, IndexWithFilter, TestConnect } from '../types/database.types';
 import { DataStore } from '../types/stores.types';
-declare const methods: readonly ["assertThrowsWithInvalidConnectionString", "assertThrowsWhenCantConnect", "assertThrowsWithBadDatabaseName", "assertKnowsIfConnectionClosed", "assertCanSortDesc", "assertCanSortAsc", "assertCanSortById", "assertCanQueryWithOr", "assertGeneratesIdDifferentEachTime", "assertInsertingGeneratesId", "assertCanCreateMany", "assertCanCreateWithObjectField", "assertCanCountOnId", "assertCanCount", "assertThrowsWhenUpdatingRecordNotFound", "assertCanUpdate", "assertCanUpdateMany", "assertCanPushOntoArrayValue", "assertCanUpdateWithObjectField", "assertCanUpdateFieldInObjectFieldWithTargettedWhere", "assertCanSaveAndGetNullAndUndefined", "assertCanUpsertOne", "assertCanUpsertNull", "assertCanPushToArrayOnUpsert", "assertCanSyncUniqueIndexesWithFilterExpression", "assertEmptyDatabaseReturnsEmptyArray", "assertFindOneOnEmptyDatabaseReturnsNull", "assertCanLimitResults", "assertCanLimitResultsToZero", "assertCanFindWithBooleanField", "assertCanQueryByGtLtGteLteNe", "assertCanQueryPathWithDotSyntax", "assertCanReturnOnlySelectFields", "assertCanSearchByRegex", "assertCanFindWithNe", "assertCanFindWithIn", "assertCanDeleteRecord", "assertCanDeleteOne", "assertHasNoUniqueIndexToStart", "assertCanCreateUniqueIndex", "assertCanCreateMultiFieldUniqueIndex", "assertCantCreateUniqueIndexTwice", "assertCanDropUniqueIndex", "assertCanDropCompoundUniqueIndex", "assertCantDropUniqueIndexThatDoesntExist", "assertCantDropIndexWhenNoIndexExists", "assertCantDropCompoundUniqueIndexThatDoesntExist", "assertSyncingUniqueIndexsAddsMissingIndexes", "assertSyncingUniqueIndexsSkipsExistingIndexs", "assertSyncingUniqueIndexesRemovesExtraIndexes", "assertSyncingUniqueIndexesIsRaceProof", "assertSyncingIndexesDoesNotAddAndRemove", "assertUniqueIndexBlocksDuplicates", "assertDuplicateKeyThrowsOnInsert", "assertSettingUniqueIndexViolationThrowsSpruceError", "assertCanCreateUniqueIndexOnNestedField", "assertUpsertWithUniqueIndex", "assertNestedFieldIndexUpdates", "assertHasNoIndexToStart", "assertCanCreateIndex", "assertCantCreateSameIndexTwice", "assertCanCreateMultiFieldIndex", "assertCanDropIndex", "assertCanDropCompoundIndex", "assertCantDropCompoundIndexThatDoesNotExist", "assertSyncIndexesSkipsExisting", "assertSyncIndexesRemovesExtraIndexes", "assertSyncIndexesHandlesRaceConditions", "assertSyncIndexesDoesNotRemoveExisting", "assertDuplicateFieldsWithMultipleUniqueIndexesWorkAsExpected", "assertCanSyncIndexesWithoutPartialThenAgainWithProperlyUpdates"];
+declare const methods: readonly ["assertThrowsWithInvalidConnectionString", "assertThrowsWhenCantConnect", "assertThrowsWithBadDatabaseName", "assertKnowsIfConnectionClosed", "assertCanSortDesc", "assertCanSortAsc", "assertCanSortById", "assertCanQueryWithOr", "assertGeneratesIdDifferentEachTime", "assertInsertingGeneratesId", "assertCanCreateMany", "assertCanCreateWithObjectField", "assertCanCountOnId", "assertCanCount", "assertThrowsWhenUpdatingRecordNotFound", "assertCanUpdate", "assertCanUpdateMany", "assertCanPushOntoArrayValue", "assertCanUpdateWithObjectField", "assertCanUpdateFieldInObjectFieldWithTargettedWhere", "assertCanSaveAndGetNullAndUndefined", "assertUpdateReturnsMatchedAndUpdatedCounts", "assertCanUpsertOne", "assertCanUpsertNull", "assertCanPushToArrayOnUpsert", "assertCanSyncUniqueIndexesWithFilterExpression", "assertEmptyDatabaseReturnsEmptyArray", "assertFindOneOnEmptyDatabaseReturnsNull", "assertCanLimitResults", "assertCanLimitResultsToZero", "assertCanFindWithBooleanField", "assertCanQueryByGtLtGteLteNe", "assertCanQueryPathWithDotSyntax", "assertCanReturnOnlySelectFields", "assertCanSearchByRegex", "assertCanFindWithNe", "assertCanFindWithIn", "assertCanDeleteRecord", "assertCanDeleteOne", "assertHasNoUniqueIndexToStart", "assertCanCreateUniqueIndex", "assertCanCreateMultiFieldUniqueIndex", "assertCantCreateUniqueIndexTwice", "assertCanDropUniqueIndex", "assertCanDropCompoundUniqueIndex", "assertCantDropUniqueIndexThatDoesntExist", "assertCantDropIndexWhenNoIndexExists", "assertCantDropCompoundUniqueIndexThatDoesntExist", "assertSyncingUniqueIndexsAddsMissingIndexes", "assertSyncingUniqueIndexsSkipsExistingIndexs", "assertSyncingUniqueIndexesRemovesExtraIndexes", "assertSyncingUniqueIndexesIsRaceProof", "assertSyncingIndexesDoesNotAddAndRemove", "assertUniqueIndexBlocksDuplicates", "assertDuplicateKeyThrowsOnInsert", "assertSettingUniqueIndexViolationThrowsSpruceError", "assertCanCreateUniqueIndexOnNestedField", "assertUpsertWithUniqueIndex", "assertNestedFieldIndexUpdates", "assertHasNoIndexToStart", "assertCanCreateIndex", "assertCantCreateSameIndexTwice", "assertCanCreateMultiFieldIndex", "assertCanDropIndex", "assertCanDropCompoundIndex", "assertCantDropCompoundIndexThatDoesNotExist", "assertSyncIndexesSkipsExisting", "assertSyncIndexesRemovesExtraIndexes", "assertSyncIndexesHandlesRaceConditions", "assertSyncIndexesDoesNotRemoveExisting", "assertDuplicateFieldsWithMultipleUniqueIndexesWorkAsExpected", "assertCanSyncIndexesWithoutPartialThenAgainWithProperlyUpdates"];
 type OriginalMethods = (typeof methods)[number];
 type BangMethods = `!${OriginalMethods}`;
 export type DatabaseAssertionName = OriginalMethods | BangMethods;
@@ -87,6 +87,7 @@ declare const databaseAssertUtil: {
     _assertCanCreateMultiFieldIndex(connect: TestConnect, fields: string[]): Promise<void>;
     canUpdateNestedField(connect: TestConnect): Promise<void>;
     canUpsertNestedField(connect: TestConnect): Promise<void>;
+    assertUpdateReturnsMatchedAndUpdatedCounts(connect: TestConnect): Promise<void>;
     assertHasLowerCaseToCamelCaseMappingEnabled(store: DataStore): void;
 };
 export default databaseAssertUtil;

package/build/esm/tests/databaseAssertUtil.js

@@ -37,6 +37,7 @@ const methods = [
     'assertCanUpdateWithObjectField',
     'assertCanUpdateFieldInObjectFieldWithTargettedWhere',
     'assertCanSaveAndGetNullAndUndefined',
+    'assertUpdateReturnsMatchedAndUpdatedCounts',
     //upserting
     'assertCanUpsertOne',
     'assertCanUpsertNull',
@@ -141,8 +142,8 @@ const databaseAssertUtil = {
     },
     _assertUpdateUpdatedRightNumberOfRecords(db, search, updates, expectedUpdateCount) {
         return __awaiter(this, void 0, void 0, function* () {
-            const updatedCount = yield db.update(this.collectionName, search, updates);
-            assert.isEqual(updatedCount, expectedUpdateCount, 'db.update() did not update the expected amount of records! Make sure it returns an integer of the number of records updated.');
+            const updated = yield db.update(this.collectionName, search, updates);
+            assert.isEqual(updated, expectedUpdateCount, 'db.update() did not update the expected amount of records! Make sure it returns an integer of the number of records updated.');
             const count = yield db.count(this.collectionName, updates);
             assert.isEqual(count, expectedUpdateCount);
         });
@@ -2005,6 +2006,27 @@ const databaseAssertUtil = {
             yield this.shutdown(db);
         });
     },
+    assertUpdateReturnsMatchedAndUpdatedCounts(connect) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const db = yield connectToDabatase(connect);
+            const record = yield db.createOne(this.collectionName, {
+                name: 'first',
+            });
+            let updated = yield db.update(this.collectionName, { id: record.id }, {
+                name: 'second',
+            });
+            assert.isEqual(updated, 1, 'update() should return the number of matched records (in this case 1)');
+            updated = yield db.update(this.collectionName, { id: record.id }, {
+                name: 'second',
+            });
+            assert.isEqual(updated, 1, 'update() did not return the correct number of matched records (in this case 1)');
+            updated = yield db.update(this.collectionName, { id: generateId() }, {
+                name: 'second',
+            });
+            assert.isEqual(updated, 0, 'update() did not return the correct number of matched records on an update (in this case 0).');
+            yield this.shutdown(db);
+        });
+    },
     assertHasLowerCaseToCamelCaseMappingEnabled(store) {
         assert.isTrue(
         //@ts-ignore

package/build/tests/databaseAssertUtil.d.ts

@@ -1,6 +1,6 @@
 import { Database, IndexWithFilter, TestConnect } from '../types/database.types';
 import { DataStore } from '../types/stores.types';
-declare const methods: readonly ["assertThrowsWithInvalidConnectionString", "assertThrowsWhenCantConnect", "assertThrowsWithBadDatabaseName", "assertKnowsIfConnectionClosed", "assertCanSortDesc", "assertCanSortAsc", "assertCanSortById", "assertCanQueryWithOr", "assertGeneratesIdDifferentEachTime", "assertInsertingGeneratesId", "assertCanCreateMany", "assertCanCreateWithObjectField", "assertCanCountOnId", "assertCanCount", "assertThrowsWhenUpdatingRecordNotFound", "assertCanUpdate", "assertCanUpdateMany", "assertCanPushOntoArrayValue", "assertCanUpdateWithObjectField", "assertCanUpdateFieldInObjectFieldWithTargettedWhere", "assertCanSaveAndGetNullAndUndefined", "assertCanUpsertOne", "assertCanUpsertNull", "assertCanPushToArrayOnUpsert", "assertCanSyncUniqueIndexesWithFilterExpression", "assertEmptyDatabaseReturnsEmptyArray", "assertFindOneOnEmptyDatabaseReturnsNull", "assertCanLimitResults", "assertCanLimitResultsToZero", "assertCanFindWithBooleanField", "assertCanQueryByGtLtGteLteNe", "assertCanQueryPathWithDotSyntax", "assertCanReturnOnlySelectFields", "assertCanSearchByRegex", "assertCanFindWithNe", "assertCanFindWithIn", "assertCanDeleteRecord", "assertCanDeleteOne", "assertHasNoUniqueIndexToStart", "assertCanCreateUniqueIndex", "assertCanCreateMultiFieldUniqueIndex", "assertCantCreateUniqueIndexTwice", "assertCanDropUniqueIndex", "assertCanDropCompoundUniqueIndex", "assertCantDropUniqueIndexThatDoesntExist", "assertCantDropIndexWhenNoIndexExists", "assertCantDropCompoundUniqueIndexThatDoesntExist", "assertSyncingUniqueIndexsAddsMissingIndexes", "assertSyncingUniqueIndexsSkipsExistingIndexs", "assertSyncingUniqueIndexesRemovesExtraIndexes", "assertSyncingUniqueIndexesIsRaceProof", "assertSyncingIndexesDoesNotAddAndRemove", "assertUniqueIndexBlocksDuplicates", "assertDuplicateKeyThrowsOnInsert", "assertSettingUniqueIndexViolationThrowsSpruceError", "assertCanCreateUniqueIndexOnNestedField", "assertUpsertWithUniqueIndex", "assertNestedFieldIndexUpdates", "assertHasNoIndexToStart", "assertCanCreateIndex", "assertCantCreateSameIndexTwice", "assertCanCreateMultiFieldIndex", "assertCanDropIndex", "assertCanDropCompoundIndex", "assertCantDropCompoundIndexThatDoesNotExist", "assertSyncIndexesSkipsExisting", "assertSyncIndexesRemovesExtraIndexes", "assertSyncIndexesHandlesRaceConditions", "assertSyncIndexesDoesNotRemoveExisting", "assertDuplicateFieldsWithMultipleUniqueIndexesWorkAsExpected", "assertCanSyncIndexesWithoutPartialThenAgainWithProperlyUpdates"];
+declare const methods: readonly ["assertThrowsWithInvalidConnectionString", "assertThrowsWhenCantConnect", "assertThrowsWithBadDatabaseName", "assertKnowsIfConnectionClosed", "assertCanSortDesc", "assertCanSortAsc", "assertCanSortById", "assertCanQueryWithOr", "assertGeneratesIdDifferentEachTime", "assertInsertingGeneratesId", "assertCanCreateMany", "assertCanCreateWithObjectField", "assertCanCountOnId", "assertCanCount", "assertThrowsWhenUpdatingRecordNotFound", "assertCanUpdate", "assertCanUpdateMany", "assertCanPushOntoArrayValue", "assertCanUpdateWithObjectField", "assertCanUpdateFieldInObjectFieldWithTargettedWhere", "assertCanSaveAndGetNullAndUndefined", "assertUpdateReturnsMatchedAndUpdatedCounts", "assertCanUpsertOne", "assertCanUpsertNull", "assertCanPushToArrayOnUpsert", "assertCanSyncUniqueIndexesWithFilterExpression", "assertEmptyDatabaseReturnsEmptyArray", "assertFindOneOnEmptyDatabaseReturnsNull", "assertCanLimitResults", "assertCanLimitResultsToZero", "assertCanFindWithBooleanField", "assertCanQueryByGtLtGteLteNe", "assertCanQueryPathWithDotSyntax", "assertCanReturnOnlySelectFields", "assertCanSearchByRegex", "assertCanFindWithNe", "assertCanFindWithIn", "assertCanDeleteRecord", "assertCanDeleteOne", "assertHasNoUniqueIndexToStart", "assertCanCreateUniqueIndex", "assertCanCreateMultiFieldUniqueIndex", "assertCantCreateUniqueIndexTwice", "assertCanDropUniqueIndex", "assertCanDropCompoundUniqueIndex", "assertCantDropUniqueIndexThatDoesntExist", "assertCantDropIndexWhenNoIndexExists", "assertCantDropCompoundUniqueIndexThatDoesntExist", "assertSyncingUniqueIndexsAddsMissingIndexes", "assertSyncingUniqueIndexsSkipsExistingIndexs", "assertSyncingUniqueIndexesRemovesExtraIndexes", "assertSyncingUniqueIndexesIsRaceProof", "assertSyncingIndexesDoesNotAddAndRemove", "assertUniqueIndexBlocksDuplicates", "assertDuplicateKeyThrowsOnInsert", "assertSettingUniqueIndexViolationThrowsSpruceError", "assertCanCreateUniqueIndexOnNestedField", "assertUpsertWithUniqueIndex", "assertNestedFieldIndexUpdates", "assertHasNoIndexToStart", "assertCanCreateIndex", "assertCantCreateSameIndexTwice", "assertCanCreateMultiFieldIndex", "assertCanDropIndex", "assertCanDropCompoundIndex", "assertCantDropCompoundIndexThatDoesNotExist", "assertSyncIndexesSkipsExisting", "assertSyncIndexesRemovesExtraIndexes", "assertSyncIndexesHandlesRaceConditions", "assertSyncIndexesDoesNotRemoveExisting", "assertDuplicateFieldsWithMultipleUniqueIndexesWorkAsExpected", "assertCanSyncIndexesWithoutPartialThenAgainWithProperlyUpdates"];
 type OriginalMethods = (typeof methods)[number];
 type BangMethods = `!${OriginalMethods}`;
 export type DatabaseAssertionName = OriginalMethods | BangMethods;
@@ -87,6 +87,7 @@ declare const databaseAssertUtil: {
     _assertCanCreateMultiFieldIndex(connect: TestConnect, fields: string[]): Promise<void>;
     canUpdateNestedField(connect: TestConnect): Promise<void>;
     canUpsertNestedField(connect: TestConnect): Promise<void>;
+    assertUpdateReturnsMatchedAndUpdatedCounts(connect: TestConnect): Promise<void>;
     assertHasLowerCaseToCamelCaseMappingEnabled(store: DataStore): void;
 };
 export default databaseAssertUtil;

package/build/tests/databaseAssertUtil.js

@@ -33,6 +33,7 @@ const methods = [
     'assertCanUpdateWithObjectField',
     'assertCanUpdateFieldInObjectFieldWithTargettedWhere',
     'assertCanSaveAndGetNullAndUndefined',
+    'assertUpdateReturnsMatchedAndUpdatedCounts',
     //upserting
     'assertCanUpsertOne',
     'assertCanUpsertNull',
@@ -132,8 +133,8 @@ const databaseAssertUtil = {
         return allIndexes.filter((i) => i.fields[0] !== '_id');
     },
     async _assertUpdateUpdatedRightNumberOfRecords(db, search, updates, expectedUpdateCount) {
-        const updatedCount = await db.update(this.collectionName, search, updates);
-        test_utils_1.assert.isEqual(updatedCount, expectedUpdateCount, 'db.update() did not update the expected amount of records! Make sure it returns an integer of the number of records updated.');
+        const updated = await db.update(this.collectionName, search, updates);
+        test_utils_1.assert.isEqual(updated, expectedUpdateCount, 'db.update() did not update the expected amount of records! Make sure it returns an integer of the number of records updated.');
         const count = await db.count(this.collectionName, updates);
         test_utils_1.assert.isEqual(count, expectedUpdateCount);
     },
@@ -1841,6 +1842,25 @@ const databaseAssertUtil = {
         test_utils_1.assert.isEqual(match.target.locationId, locationId, `Upserting lost existing key 'target.locationId'`);
         await this.shutdown(db);
     },
+    async assertUpdateReturnsMatchedAndUpdatedCounts(connect) {
+        const db = await connectToDabatase(connect);
+        const record = await db.createOne(this.collectionName, {
+            name: 'first',
+        });
+        let updated = await db.update(this.collectionName, { id: record.id }, {
+            name: 'second',
+        });
+        test_utils_1.assert.isEqual(updated, 1, 'update() should return the number of matched records (in this case 1)');
+        updated = await db.update(this.collectionName, { id: record.id }, {
+            name: 'second',
+        });
+        test_utils_1.assert.isEqual(updated, 1, 'update() did not return the correct number of matched records (in this case 1)');
+        updated = await db.update(this.collectionName, { id: (0, generateId_1.default)() }, {
+            name: 'second',
+        });
+        test_utils_1.assert.isEqual(updated, 0, 'update() did not return the correct number of matched records on an update (in this case 0).');
+        await this.shutdown(db);
+    },
     assertHasLowerCaseToCamelCaseMappingEnabled(store) {
         test_utils_1.assert.isTrue(
         //@ts-ignore

package/package.json

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