@sprucelabs/data-stores 28.1.333 → 28.1.335

package/build/esm/tests/databaseAssertUtil.js

@@ -98,6 +98,7 @@ const databaseAssertUtil = {
                 'assertSyncIndexesHandlesRaceConditions',
                 'assertSyncIndexesDoesNotRemoveExisting',
                 'assertDuplicateFieldsWithMultipleUniqueIndexesWorkAsExpected',
+                'assertCanSyncIndexesWithoutPartialThenAgainWithProperlyUpdates',
             ];
             const db = yield connectToDabatase(connect);
             yield db.dropDatabase();
@@ -117,14 +118,13 @@ const databaseAssertUtil = {
             }
         });
     },
-    _getFilteredIndexes(db) {
+    _getIndexesWith_IdFilteredOut(db) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this._filterIdIndex(yield db.getIndexes(this.collectionName));
+            return this._filterOut_Id(yield db.getIndexes(this.collectionName));
         });
     },
-    _filterIdIndex(allIndexes) {
-        //@ts-ignore
-        return allIndexes.filter((i) => i[0] !== '_id');
+    _filterOut_Id(allIndexes) {
+        return allIndexes.filter((i) => i.fields[0] !== '_id');
     },
     _assertUpdateUpdatedRightNumberOfRecords(db, search, updates, expectedUpdateCount) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -247,20 +247,20 @@ const databaseAssertUtil = {
             yield db.createUniqueIndex(this.collectionName, ['uniqueField']);
             let indexes = (yield db.getUniqueIndexes(this.collectionName));
             assert.isLength(indexes, 1, 'getUniqueIndexes() did not return the unique index I tried to create!');
-            assert.isLength(indexes[0], 1, 'getUniqueIndexes() needs to return an array of arrays. Each item in the array should be an array of fields that make up the unique index.');
-            assert.isEqual(indexes[0][0].toLowerCase(), 'uniqueField'.toLowerCase(), 'getUniqueIndexes() did not add the expected field to the first unique index.');
+            assert.isLength(indexes[0].fields, 1, 'getUniqueIndexes() needs to return an array of IndexWithFilters. Each item in the array should be an array of fields that make up the unique index.');
+            assert.isEqual(indexes[0].fields[0].toLowerCase(), 'uniqueField'.toLowerCase(), 'getUniqueIndexes() did not add the expected field to the first unique index.');
             yield db.createUniqueIndex(this.collectionName, ['uniqueField2']);
-            indexes = (yield db.getUniqueIndexes(this.collectionName));
+            indexes = yield db.getUniqueIndexes(this.collectionName);
             assert.isLength(indexes, 2);
-            assert.isEqual(indexes[1][0].toLowerCase(), 'uniqueField2'.toLowerCase());
+            assert.isEqual(indexes[1].fields[0].toLowerCase(), 'uniqueField2'.toLowerCase());
             yield db.createUniqueIndex(this.collectionName, [
                 'uniqueField3',
                 'uniqueField4',
             ]);
-            indexes = (yield db.getUniqueIndexes(this.collectionName));
+            indexes = yield db.getUniqueIndexes(this.collectionName);
             assert.isLength(indexes, 3);
-            assert.isEqual(indexes[2][0].toLowerCase(), 'uniqueField3'.toLowerCase());
-            assert.isEqual(indexes[2][1].toLowerCase(), 'uniqueField4'.toLowerCase());
+            assert.isEqual(indexes[2].fields[0].toLowerCase(), 'uniqueField3'.toLowerCase());
+            assert.isEqual(indexes[2].fields[1].toLowerCase(), 'uniqueField4'.toLowerCase());
             yield this.shutdown(db);
         });
     },
@@ -748,12 +748,12 @@ const databaseAssertUtil = {
                 ['someField'],
                 ['otherField', 'otherField2'],
             ]);
-            let indexes = (yield db.getUniqueIndexes(this.collectionName));
+            let indexes = yield db.getUniqueIndexes(this.collectionName);
             assert.isLength(indexes, 3, 'syncUniqueIndexes() should have created 3 indexes.');
             yield db.syncUniqueIndexes(this.collectionName, [['uniqueField']]);
-            indexes = (yield db.getUniqueIndexes(this.collectionName));
+            indexes = yield db.getUniqueIndexes(this.collectionName);
             assert.isLength(indexes, 1);
-            assert.isEqual(indexes[0][0].toLowerCase(), 'uniquefield');
+            assert.isEqual(indexes[0].fields[0].toLowerCase(), 'uniquefield');
             yield db.syncUniqueIndexes(this.collectionName, [
                 {
                     fields: ['uniqueField'],
@@ -770,7 +770,7 @@ const databaseAssertUtil = {
                     filter: { isActive: true },
                 },
             ]);
-            indexes = (yield db.getUniqueIndexes(this.collectionName));
+            indexes = yield db.getUniqueIndexes(this.collectionName);
             assert.isLength(indexes, 2, `Syncing unique indexs with filter is not removing extra indexes.`);
             yield this.shutdown(db);
         });
@@ -799,7 +799,7 @@ const databaseAssertUtil = {
             assert.isLength(indexes, 1, 'There should be 1 index after syncing.');
             yield db.syncUniqueIndexes(this.collectionName, [['someField']]);
             indexes = yield db.getUniqueIndexes(this.collectionName);
-            assert.isLength(indexes, 1, 'There should now be 2 indexes after syncing.');
+            assert.isLength(indexes, 1, 'syncUniqueIndexes() should have removed the index that was set before it that was different.');
             yield db.syncUniqueIndexes(this.collectionName, [
                 ['uniqueField'],
                 ['someField'],
@@ -816,11 +816,11 @@ const databaseAssertUtil = {
                 'someField',
                 'someOtherField',
             ]);
-            const err = yield assert.doesThrowAsync(() => db.dropIndex(this.collectionName, ['uniqueField', 'someOtherField']));
+            const err = yield assert.doesThrowAsync(() => db.dropIndex(this.collectionName, ['someOtherField', 'uniqueField']));
             lowerCaseMissingIndexValues(err);
             errorAssert.assertError(err, 'INDEX_NOT_FOUND', {
                 collectionName: this.collectionName,
-                missingIndex: ['uniquefield', 'someotherfield'],
+                missingIndex: ['someotherfield', 'uniquefield'],
             });
             yield this.shutdown(db);
         });
@@ -893,6 +893,7 @@ const databaseAssertUtil = {
         return __awaiter(this, void 0, void 0, function* () {
             const db = yield connectToDabatase(connect);
             yield assertCantCreateUniqueIndexTwice(db, this.collectionName, ['uniqueField'], 1);
+            yield assertCantCreateUniqueIndexTwice(db, this.collectionName, ['uniqueField', 'anotherField'], 2);
             yield this.shutdown(db);
         });
     },
@@ -1023,8 +1024,8 @@ const databaseAssertUtil = {
             }));
             errorAssert.assertError(err, 'DUPLICATE_RECORD', {
                 collectionName: this.collectionName,
-                duplicateFields: ['target.organizationId', 'slug'],
-                duplicateValues: ['go!', 'a slug'],
+                duplicateFields: ['slug', 'target.organizationId'],
+                duplicateValues: ['a slug', 'go!'],
                 action: 'create',
             });
             yield db.upsertOne(this.collectionName, {
@@ -1502,7 +1503,7 @@ const databaseAssertUtil = {
                 uniqueField: 'test',
                 slug: null,
                 someField3: 'test',
-            }), undefined, `Creating a duplicate record with should throw an error.`);
+            }), undefined, `Creating a duplicate record with should throw an error with a uniqueIndex with filter. Make sure syncUniqueIndexes() is actually created the index honoring the filter.`);
             yield db.createOne(this.collectionName, {
                 name: generateId(),
                 slug: '555-000-0000',
@@ -1596,6 +1597,56 @@ const databaseAssertUtil = {
             yield this.shutdown(db);
         });
     },
+    assertCanSyncIndexesWithoutPartialThenAgainWithProperlyUpdates(connect) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const db = yield connectToDabatase(connect);
+            yield db.syncUniqueIndexes(this.collectionName, [
+                ['uniqueField', 'someField3'],
+            ]);
+            yield db.syncUniqueIndexes(this.collectionName, [
+                {
+                    fields: ['uniqueField', 'someField3'],
+                    filter: {
+                        uniqueField: { $type: 'string' },
+                    },
+                },
+            ]);
+            yield db.createOne(this.collectionName, {
+                name: generateId(),
+                uniqueField: 1,
+                slug: null,
+                someField3: 'test',
+            });
+            try {
+                yield db.createOne(this.collectionName, {
+                    name: generateId(),
+                    uniqueField: 1,
+                    slug: null,
+                    someField3: 'test',
+                });
+            }
+            catch (_a) {
+                assert.fail(`An error was thrown trying to create a record that should not have matched on a unique index with a filter. Make sure your database adapter is properly syncing indexes. In this case, it should remove an index without a filter with an index with a filter.`);
+            }
+            yield db.createOne(this.collectionName, {
+                name: generateId(),
+                uniqueField: 'hey there',
+                slug: null,
+                someField3: 'how are you?',
+            });
+            try {
+                yield assert.doesThrowAsync(() => db.createOne(this.collectionName, {
+                    name: generateId(),
+                    uniqueField: 'hey there',
+                    slug: null,
+                    someField3: 'how are you?',
+                }));
+            }
+            catch (_b) {
+                assert.fail(`A record was created that should have been blocked by a unique index with a filter`);
+            }
+        });
+    },
     assertSyncIndexesRemovesExtraIndexes(connect) {
         return __awaiter(this, void 0, void 0, function* () {
             const db = yield connectToDabatase(connect);
@@ -1604,12 +1655,12 @@ const databaseAssertUtil = {
                 ['someField'],
                 ['otherField', 'otherField2'],
             ]);
-            let indexes = yield this._getFilteredIndexes(db);
+            let indexes = yield this._getIndexesWith_IdFilteredOut(db);
             assert.isLength(indexes, 3);
             yield db.syncIndexes(this.collectionName, [['name']]);
-            indexes = yield this._getFilteredIndexes(db);
+            indexes = yield this._getIndexesWith_IdFilteredOut(db);
             assert.isLength(indexes, 1);
-            assert.isEqual(indexes[0][0], 'name');
+            assert.isEqual(indexes[0].fields[0], 'name');
             yield this.shutdown(db);
         });
     },
@@ -1617,15 +1668,16 @@ const databaseAssertUtil = {
         return __awaiter(this, void 0, void 0, function* () {
             const db = yield connectToDabatase(connect);
             yield db.syncIndexes(this.collectionName, [['name']]);
-            let indexes = yield this._getFilteredIndexes(db);
+            let indexes = yield this._getIndexesWith_IdFilteredOut(db);
             assert.isLength(indexes, 1);
+            assert.isLength(indexes[0].fields, 1);
             yield db.syncIndexes(this.collectionName, [
                 ['name'],
                 ['someField'],
                 ['otherField', 'otherField2'],
             ]);
-            indexes = yield this._getFilteredIndexes(db);
-            assert.isLength(indexes, 3);
+            indexes = yield this._getIndexesWith_IdFilteredOut(db);
+            assert.isLength(indexes, 3, 'There should be 3 indexes after the last sync. 1 would have been skipped, the other 2 should have been added');
             yield this.shutdown(db);
         });
     },
@@ -1639,7 +1691,7 @@ const databaseAssertUtil = {
             const err = yield assert.doesThrowAsync(() => db.dropIndex(this.collectionName, ['uniqueField', 'someOtherField']));
             errorAssert.assertError(err, 'INDEX_NOT_FOUND', {
                 collectionName: this.collectionName,
-                missingIndex: ['uniqueField', 'someOtherField'],
+                missingIndex: ['someOtherField', 'uniqueField'],
             });
             yield this.shutdown(db);
         });
@@ -1649,13 +1701,13 @@ const databaseAssertUtil = {
             const db = yield connectToDabatase(connect);
             yield db.createIndex(this.collectionName, ['someField', 'otherField']);
             yield db.dropIndex(this.collectionName, ['someField', 'otherField']);
-            let indexes = yield this._getFilteredIndexes(db);
-            assert.isLength(indexes, 0);
+            let indexes = yield this._getIndexesWith_IdFilteredOut(db);
+            assert.isLength(indexes, 0, `The one index I created should have been dropped`);
             yield db.createIndex(this.collectionName, ['someField', 'someField2']);
             yield db.createIndex(this.collectionName, ['someField', 'someField3']);
             yield db.dropIndex(this.collectionName, ['someField', 'someField3']);
-            indexes = yield this._getFilteredIndexes(db);
-            assert.isLength(indexes, 1);
+            indexes = yield this._getIndexesWith_IdFilteredOut(db);
+            assert.isLength(indexes, 1, `I created 2 compound indexes, then dropped one, and expected 1 to remain.`);
             yield this.shutdown(db);
         });
     },
@@ -1664,12 +1716,12 @@ const databaseAssertUtil = {
             const db = yield connectToDabatase(connect);
             yield db.createIndex(this.collectionName, ['someField']);
             yield db.dropIndex(this.collectionName, ['someField']);
-            let indexes = yield this._getFilteredIndexes(db);
+            let indexes = yield this._getIndexesWith_IdFilteredOut(db);
             assert.isLength(indexes, 0);
             yield db.createIndex(this.collectionName, ['someField2']);
             yield db.createIndex(this.collectionName, ['someField3']);
             yield db.dropIndex(this.collectionName, ['someField3']);
-            indexes = yield this._getFilteredIndexes(db);
+            indexes = yield this._getIndexesWith_IdFilteredOut(db);
             assert.isLength(indexes, 1);
             yield this.shutdown(db);
         });
@@ -1698,7 +1750,7 @@ const databaseAssertUtil = {
         return __awaiter(this, void 0, void 0, function* () {
             const db = yield connectToDabatase(connect);
             yield db.createIndex(this.collectionName, ['name']);
-            let indexes = yield this._getFilteredIndexes(db);
+            let indexes = yield this._getIndexesWith_IdFilteredOut(db);
             assert.isLength(indexes, 1);
             const err = yield assert.doesThrowAsync(() => db.createIndex(this.collectionName, ['name']));
             errorAssert.assertError(err, 'INDEX_EXISTS');
@@ -1709,23 +1761,23 @@ const databaseAssertUtil = {
         return __awaiter(this, void 0, void 0, function* () {
             const db = yield connectToDabatase(connect);
             yield db.createIndex(this.collectionName, ['uniqueField']);
-            let indexes = yield this._getFilteredIndexes(db);
+            let indexes = yield this._getIndexesWith_IdFilteredOut(db);
             assert.isArray(indexes, 'getIndexes() should return an array!');
             assert.isLength(indexes, 1, 'getIndexes() should return the one index that was created!');
-            assert.isLength(indexes[0], 1, 'getIndexes() should return an array of arrays! It should be returing the first index I created!');
-            assert.isEqual(indexes[0][0].toLowerCase(), 'uniqueField'.toLowerCase());
+            assert.isLength(indexes[0].fields, 1, 'getIndexes() should return an array of IndexWithFilter! It should be returing the first index I created with the first field!');
+            assert.isEqual(indexes[0].fields[0].toLowerCase(), 'uniqueField'.toLowerCase());
             yield db.createIndex(this.collectionName, ['uniqueField2']);
-            indexes = yield this._getFilteredIndexes(db);
+            indexes = yield this._getIndexesWith_IdFilteredOut(db);
             assert.isLength(indexes, 2);
-            assert.isEqual(indexes[1][0].toLowerCase(), 'uniqueField2'.toLowerCase());
+            assert.isEqual(indexes[1].fields[0].toLowerCase(), 'uniqueField2'.toLowerCase());
             yield db.createIndex(this.collectionName, [
                 'uniqueField3',
                 'uniqueField4',
             ]);
-            indexes = yield this._getFilteredIndexes(db);
+            indexes = yield this._getIndexesWith_IdFilteredOut(db);
             assert.isLength(indexes, 3);
-            assert.isEqual(indexes[2][0].toLowerCase(), 'uniqueField3'.toLowerCase());
-            assert.isEqual(indexes[2][1].toLowerCase(), 'uniqueField4'.toLowerCase());
+            assert.isEqual(indexes[2].fields[0].toLowerCase(), 'uniqueField3'.toLowerCase());
+            assert.isEqual(indexes[2].fields[1].toLowerCase(), 'uniqueField4'.toLowerCase());
             yield this.shutdown(db);
         });
     },
@@ -1886,9 +1938,9 @@ const databaseAssertUtil = {
         return __awaiter(this, void 0, void 0, function* () {
             const db = yield connectToDabatase(connect);
             yield db.createIndex(this.collectionName, fields);
-            const indexes = yield this._getFilteredIndexes(db);
+            const indexes = yield this._getIndexesWith_IdFilteredOut(db);
             assert.isLength(indexes, 1, `getIndexes() should return the index it created. I expected 1 but got ${indexes.length}. Also, make sure you clear the indexes when resetting the database!`);
-            assert.isEqualDeep(indexes[0].map((i) => i.toLowerCase()), fields.map((f) => f.toLowerCase()));
+            assert.isEqualDeep(indexes[0].fields.map((i) => i.toLowerCase()), fields.map((f) => f.toLowerCase()));
             yield this.shutdown(db);
         });
     },
@@ -1903,11 +1955,11 @@ function assertCantCreateUniqueIndexTwice(db, collectionName, fields, expectedTo
     return __awaiter(this, void 0, void 0, function* () {
         yield db.createUniqueIndex(collectionName, fields);
         let indexes = yield db.getUniqueIndexes(collectionName);
-        assert.isLength(indexes, expectedTotalUniqueIndexes, 'getUniqueIndexes() should return total unique indexs');
-        const err = yield assert.doesThrowAsync(() => db.createUniqueIndex(collectionName, ['uniqueField']), undefined, 'createUniqueIndex() should throw a DataStoreError({code: "INDEX_EXISTS"}) error.');
+        assert.isLength(indexes, expectedTotalUniqueIndexes, 'getUniqueIndexes() should return all unique indexes');
+        const err = yield assert.doesThrowAsync(() => db.createUniqueIndex(collectionName, fields), undefined, 'createUniqueIndex() should throw a DataStoreError({code: "INDEX_EXISTS"}) error.');
         errorAssert.assertError(err, 'INDEX_EXISTS', {
             collectionName,
-            index: ['uniqueField'],
+            index: fields,
         });
     });
 }

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

@@ -2,11 +2,11 @@ import { Log } from '@sprucelabs/spruce-skill-utils';
 import { QueryOptions } from './query.types';
 export interface Database {
     [x: string]: any;
-    syncUniqueIndexes(collectionName: string, indexes: UniqueIndex[]): Promise<void>;
+    syncUniqueIndexes(collectionName: string, indexes: Index[]): Promise<void>;
     syncIndexes(collectionName: string, indexes: Index[]): Promise<void>;
-    dropIndex(collectionName: string, fields: UniqueIndex): Promise<void>;
-    getUniqueIndexes(collectionName: string): Promise<UniqueIndex[]>;
-    getIndexes(collectionName: string): Promise<Index[] | UniqueIndex[]>;
+    dropIndex(collectionName: string, index: Index): Promise<void>;
+    getUniqueIndexes(collectionName: string): Promise<IndexWithFilter[]>;
+    getIndexes(collectionName: string): Promise<IndexWithFilter[]>;
     isConnected(): boolean;
     generateId(): string;
     connect(): Promise<void>;
@@ -24,8 +24,8 @@ export interface Database {
     delete(collection: string, query: Record<string, any>): Promise<number>;
     deleteOne(collection: string, query: Record<string, any>): Promise<number>;
     count(collection: string, query?: Record<string, any>): Promise<number>;
-    createUniqueIndex(collection: string, fields: UniqueIndex): Promise<void>;
-    createIndex(collection: string, fields: Index): Promise<void>;
+    createUniqueIndex(collection: string, index: Index): Promise<void>;
+    createIndex(collection: string, index: Index): Promise<void>;
     query<T>(query: string, params?: any[]): Promise<T[]>;
 }
 export interface DatabaseOptions {
@@ -40,10 +40,9 @@ export type TestConnect = (connectionString?: string, dbName?: string) => Promis
 }>;
 export interface IndexWithFilter {
     fields: string[];
-    filter: Record<string, any>;
+    filter?: Record<string, any>;
 }
-export type UniqueIndex = string[] | IndexWithFilter;
-export type Index = string[];
+export type Index = string[] | IndexWithFilter;
 export interface CreateOptions extends DatabaseInternalOptions {
 }
 export interface DatabaseInternalOptions {

package/build/index.d.ts

@@ -21,7 +21,7 @@ export * from './cursors/CursorPager';
 export { default as CursorPagerFaker } from './cursors/CursorPagerFaker';
 export * from './cursors/CursorPager';
 export { default as DatabaseFieldMapperPlugin } from './plugins/DatabaseFieldMapperPlugin';
-export { default as normalizeIndex } from './databases/normalizeIndex';
+export * from './databases/database.utilities';
 /**
  * @deprecated databaseAssertUtil -> databaseAssert
  */

package/build/index.js

@@ -17,7 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BatchArrayCursor = exports.BatchCursorImpl = exports.storePluginAssert = exports.databaseAssert = exports.databaseAssertUtil = exports.normalizeIndex = exports.DatabaseFieldMapperPlugin = exports.CursorPagerFaker = exports.CursorPager = exports.generateId = exports.DataStoresError = exports.mongoUtil = exports.NeDbDatabase = exports.MongoDatabase = exports.StoreLoader = exports.DatabaseFactory = exports.StoreFactory = exports.AbstractStore = exports.DatabaseFixture = exports.AbstractDatabaseTest = void 0;
+exports.BatchArrayCursor = exports.BatchCursorImpl = exports.storePluginAssert = exports.databaseAssert = exports.databaseAssertUtil = exports.DatabaseFieldMapperPlugin = exports.CursorPagerFaker = exports.CursorPager = exports.generateId = exports.DataStoresError = exports.mongoUtil = exports.NeDbDatabase = exports.MongoDatabase = exports.StoreLoader = exports.DatabaseFactory = exports.StoreFactory = exports.AbstractStore = exports.DatabaseFixture = exports.AbstractDatabaseTest = void 0;
 var AbstractDatabaseTest_1 = require("./tests/AbstractDatabaseTest");
 Object.defineProperty(exports, "AbstractDatabaseTest", { enumerable: true, get: function () { return __importDefault(AbstractDatabaseTest_1).default; } });
 var DatabaseFixture_1 = require("./fixtures/DatabaseFixture");
@@ -55,8 +55,7 @@ Object.defineProperty(exports, "CursorPagerFaker", { enumerable: true, get: func
 __exportStar(require("./cursors/CursorPager"), exports);
 var DatabaseFieldMapperPlugin_1 = require("./plugins/DatabaseFieldMapperPlugin");
 Object.defineProperty(exports, "DatabaseFieldMapperPlugin", { enumerable: true, get: function () { return __importDefault(DatabaseFieldMapperPlugin_1).default; } });
-var normalizeIndex_1 = require("./databases/normalizeIndex");
-Object.defineProperty(exports, "normalizeIndex", { enumerable: true, get: function () { return __importDefault(normalizeIndex_1).default; } });
+__exportStar(require("./databases/database.utilities"), exports);
 /**
  * @deprecated databaseAssertUtil -> databaseAssert
  */

package/build/tests/databaseAssertUtil.d.ts

@@ -1,10 +1,10 @@
-import { Database, Index, TestConnect, UniqueIndex } from '../types/database.types';
+import { Database, IndexWithFilter, TestConnect } from '../types/database.types';
 import { DataStore } from '../types/stores.types';
 declare const databaseAssertUtil: {
     collectionName: string;
     runSuite(connect: TestConnect, tests?: string[]): Promise<void>;
-    _getFilteredIndexes(db: Database): Promise<string[][]>;
-    _filterIdIndex(allIndexes: UniqueIndex[] | Index[]): UniqueIndex[] | Index[];
+    _getIndexesWith_IdFilteredOut(db: Database): Promise<IndexWithFilter[]>;
+    _filterOut_Id(allIndexes: IndexWithFilter[]): IndexWithFilter[];
     _assertUpdateUpdatedRightNumberOfRecords(db: Database, search: Record<string, any>, updates: Record<string, any>, expectedUpdateCount: number): Promise<void>;
     generateIdDifferentEachTime(connect: TestConnect): Promise<void>;
     assertCanSortDesc(connect: TestConnect): Promise<void>;
@@ -64,6 +64,7 @@ declare const databaseAssertUtil: {
     assertCanSaveAndGetNullAndUndefined(connect: TestConnect): Promise<void>;
     assertSyncIndexesDoesNotRemoveExisting(connect: TestConnect): Promise<void>;
     assertCanSyncUniqueIndexesWithFilterExpression(connect: TestConnect): Promise<void>;
+    assertCanSyncIndexesWithoutPartialThenAgainWithProperlyUpdates(connect: TestConnect): Promise<void>;
     assertSyncIndexesRemovesExtraIndexes(connect: TestConnect): Promise<void>;
     assertSyncIndexesSkipsExisting(connect: TestConnect): Promise<void>;
     assertCantDropCompoundIndexThatDoesNotExist(connect: TestConnect): Promise<void>;