@sprucelabs/data-stores 31.0.8 → 31.0.10

package/build/databases/MongoDatabase.d.ts

@@ -36,7 +36,6 @@ export default class MongoDatabase implements Database {
     syncIndexes(collectionName: string, indexes: Index[]): Promise<void>;
     private _syncIndexes;
     createUniqueIndex(collection: string, index: string[] | IndexWithFilter): Promise<void>;
-    private generateIndexName;
     private normalizeIndex;
     syncUniqueIndexes(collectionName: string, indexes: Index[]): Promise<void>;
     update(collection: string, query: Record<string, any>, updates: Record<string, any>): Promise<number>;

package/build/databases/MongoDatabase.js

@@ -236,10 +236,11 @@ class MongoDatabase {
     }
     async dropIndex(collection, index) {
         const indexes = await this.listIndexes(collection);
-        const name = this.generateIndexName(this.normalizeIndex(index));
+        const name = this.normalizeIndex(index).name;
         let found = false;
         for (const thisIndex of indexes) {
-            if (thisIndex.name === name) {
+            if (this.normalizeIndex(this.mongoIndexToIndexWithFilter(thisIndex))
+                .name === name) {
                 await this.assertDbWhileAttempingTo('drop a index.', collection)
                     .collection(collection)
                     .dropIndex(thisIndex.name);
@@ -260,10 +261,10 @@ class MongoDatabase {
             const uniqueIndexes = [];
             for (const index of indexes) {
                 if (index.unique) {
-                    uniqueIndexes.push({
+                    uniqueIndexes.push(this.normalizeIndex({
                         fields: Object.keys(index.key),
                         filter: index.partialFilterExpression,
-                    });
+                    }));
                 }
             }
             return uniqueIndexes;
@@ -291,31 +292,32 @@ class MongoDatabase {
         }
     }
     mongoIndexToIndexWithFilter(index) {
-        return {
+        return (0, database_utilities_1.normalizeIndex)({
             fields: Object.keys(index.key),
             filter: index.partialFilterExpression,
             name: index.name,
-        };
+        });
     }
     async createIndex(collection, index) {
         const currentIndexes = await this.getIndexes(collection);
         this.assertIndexDoesNotExist(currentIndexes, index, collection);
         const indexSpec = {};
-        this.normalizeIndex(index).fields.forEach((name) => {
+        const normalized = this.normalizeIndex(index);
+        normalized.fields.forEach((name) => {
             indexSpec[name] = 1;
         });
         try {
             await this.assertDbWhileAttempingTo('create an index.', collection)
                 .collection(collection)
                 .createIndex(indexSpec, {
-                name: this.generateIndexName(index),
+                name: normalized.name,
             });
         }
         catch (err) {
             if ((err === null || err === void 0 ? void 0 : err.code) === 11000) {
                 throw new SpruceError_1.default({
                     code: 'DUPLICATE_KEY',
-                    friendlyMessage: `Could not create index! Index on '${collection}' has duplicate key for "${this.normalizeIndex(index).fields.join(',')}"`,
+                    friendlyMessage: `Could not create index! Index on '${collection}' has duplicate key for "${normalized.fields.join(',')}"`,
                 });
             }
             else {
@@ -338,15 +340,17 @@ class MongoDatabase {
     async syncIndexes(collectionName, indexes) {
         await this._syncIndexes(collectionName, indexes, 'createIndex');
     }
-    async _syncIndexes(collectionName, indexes, func, shouldIncludeUnique = false) {
+    async _syncIndexes(collectionName, indexes, func, isSyncingUniqueIndexes = false) {
         var _a;
-        const currentIndexes = await this.getIndexes(collectionName, shouldIncludeUnique);
+        const currentIndexes = isSyncingUniqueIndexes
+            ? await this.getUniqueIndexes(collectionName)
+            : await this.getIndexes(collectionName);
         const indexesToDelete = (0, database_utilities_1.pluckMissingIndexes)(currentIndexes, indexes);
         for (const extra of indexesToDelete) {
             await this.dropIndex(collectionName, extra);
         }
         for (const index of indexes) {
-            if (!this.doesInclude(currentIndexes, this.normalizeIndex(index))) {
+            if (!this.doesInclude(currentIndexes, this.normalizeIndex(index, isSyncingUniqueIndexes))) {
                 try {
                     await this[func](collectionName, index);
                 }
@@ -360,7 +364,7 @@ class MongoDatabase {
     }
     async createUniqueIndex(collection, index) {
         const currentIndexes = await this.getUniqueIndexes(collection);
-        const indexWithFilter = this.normalizeIndex(index);
+        const indexWithFilter = this.normalizeIndex(index, true);
         this.assertIndexDoesNotExist(currentIndexes, indexWithFilter, collection);
         const created = {};
         indexWithFilter.fields.forEach((name) => {
@@ -369,7 +373,7 @@ class MongoDatabase {
         try {
             const options = {
                 unique: true,
-                name: this.generateIndexName(indexWithFilter),
+                name: indexWithFilter.name,
             };
             if (indexWithFilter.filter) {
                 options.partialFilterExpression = indexWithFilter.filter;
@@ -391,11 +395,8 @@ class MongoDatabase {
             }
         }
     }
-    generateIndexName(indexWithFilter) {
-        return (0, database_utilities_1.generateIndexName)(this.normalizeIndex(indexWithFilter));
-    }
-    normalizeIndex(index) {
-        return (0, database_utilities_1.normalizeIndex)(index);
+    normalizeIndex(index, isUnique) {
+        return (0, database_utilities_1.normalizeIndex)(index, isUnique);
     }
     async syncUniqueIndexes(collectionName, indexes) {
         await this._syncIndexes(collectionName, indexes, 'createUniqueIndex', true);

package/build/databases/NeDbDatabase.js

@@ -440,31 +440,37 @@ class NeDbDatabase extends AbstractMutexer_1.default {
             col._indexes = [];
         }
         await this.randomDelay();
-        this.assertIndexDoesNotExist(col._indexes, this.normalizeIndex(fields), collection);
-        col._indexes.push({ fields });
+        const normalized = this.normalizeIndex(fields);
+        this.assertIndexDoesNotExist(col._indexes, normalized, collection);
+        col._indexes.push(normalized);
     }
     normalizeIndex(index) {
-        const { fields, filter } = (0, database_utilities_1.normalizeIndex)(index);
-        return { fields, filter };
+        return (0, database_utilities_1.normalizeIndex)(index);
     }
     async syncUniqueIndexes(collectionName, indexes) {
         var _a;
+        await this.lock('syncUniqueIndexesMutex');
         const currentIndexes = await this.getUniqueIndexes(collectionName);
         const toDelete = (0, database_utilities_1.pluckMissingIndexes)(currentIndexes, indexes);
-        for (const index of indexes) {
-            if (!this.doesInclude(currentIndexes, index)) {
-                try {
-                    await this.createUniqueIndex(collectionName, index);
-                }
-                catch (err) {
-                    if (((_a = err.options) === null || _a === void 0 ? void 0 : _a.code) !== 'INDEX_EXISTS') {
-                        throw err;
+        try {
+            for (const index of indexes) {
+                if (!this.doesInclude(currentIndexes, index)) {
+                    try {
+                        await this.createUniqueIndex(collectionName, index);
+                    }
+                    catch (err) {
+                        if (((_a = err.options) === null || _a === void 0 ? void 0 : _a.code) !== 'INDEX_EXISTS') {
+                            throw err;
+                        }
                     }
                 }
             }
+            for (const extra of toDelete) {
+                await this.dropIndex(collectionName, extra);
+            }
         }
-        for (const extra of toDelete) {
-            await this.dropIndex(collectionName, extra);
+        finally {
+            this.unlock('syncUniqueIndexesMutex');
         }
     }
     async syncIndexes(collectionName, indexes) {

package/build/databases/database.utilities.d.ts

@@ -1,6 +1,5 @@
 import { IndexWithFilter, Index } from '../types/database.types';
 export declare function doesIndexesInclude(haystack: Index[], needle: Index): boolean;
 export declare function areIndexesEqual(left: Index, right: Index): boolean;
-export declare function generateIndexName(indexWithFilter: IndexWithFilter): string;
-export declare function normalizeIndex(index: Index): IndexWithFilter;
+export declare function normalizeIndex(index: Index, isUnique?: boolean): IndexWithFilter;
 export declare function pluckMissingIndexes(left: Index[], right: Index[]): Index[];

package/build/databases/database.utilities.js

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.doesIndexesInclude = doesIndexesInclude;
 exports.areIndexesEqual = areIndexesEqual;
-exports.generateIndexName = generateIndexName;
 exports.normalizeIndex = normalizeIndex;
 exports.pluckMissingIndexes = pluckMissingIndexes;
 const differenceWith_1 = __importDefault(require("lodash/differenceWith"));
@@ -22,7 +21,7 @@ function areIndexesEqual(left, right) {
     const name2 = generateIndexName(normalizeIndex(right));
     return name1 === name2;
 }
-function generateIndexName(indexWithFilter) {
+function generateIndexName(indexWithFilter, isUnique) {
     if (indexWithFilter.name) {
         return indexWithFilter.name;
     }
@@ -30,18 +29,23 @@ function generateIndexName(indexWithFilter) {
     if (indexWithFilter.filter) {
         name += '_filtered';
     }
+    if (isUnique) {
+        name += '_unique';
+    }
     return name;
 }
-function normalizeIndex(index) {
-    var _a;
+function normalizeIndex(index, isUnique) {
     const fields = Array.isArray(index) ? index : index.fields;
     const filter = Array.isArray(index) ? undefined : index.filter;
     fields.sort();
-    return {
+    const normalized = {
         fields,
-        filter,
-        name: (_a = index.name) !== null && _a !== void 0 ? _a : undefined,
     };
+    if (filter) {
+        normalized.filter = filter;
+    }
+    normalized.name = generateIndexName(normalized, isUnique);
+    return normalized;
 }
 function pluckMissingIndexes(left, right) {
     return (0, differenceWith_1.default)(left, right, areIndexesEqual);

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

@@ -36,7 +36,6 @@ export default class MongoDatabase implements Database {
     syncIndexes(collectionName: string, indexes: Index[]): Promise<void>;
     private _syncIndexes;
     createUniqueIndex(collection: string, index: string[] | IndexWithFilter): Promise<void>;
-    private generateIndexName;
     private normalizeIndex;
     syncUniqueIndexes(collectionName: string, indexes: Index[]): Promise<void>;
     update(collection: string, query: Record<string, any>, updates: Record<string, any>): Promise<number>;

package/build/esm/databases/MongoDatabase.js

@@ -23,7 +23,7 @@ import { MongoClient, MongoError, } from 'mongodb';
 import SpruceError from '../errors/SpruceError.js';
 import generateId from '../utilities/generateId.js';
 import mongoUtil from '../utilities/mongo.utility.js';
-import { doesIndexesInclude, generateIndexName, normalizeIndex, pluckMissingIndexes, } from './database.utilities.js';
+import { doesIndexesInclude, normalizeIndex, pluckMissingIndexes, } from './database.utilities.js';
 export const MONGO_TEST_URI = 'mongodb://localhost:27017';
 export default class MongoDatabase {
     constructor(url, options) {
@@ -262,10 +262,11 @@ export default class MongoDatabase {
     dropIndex(collection, index) {
         return __awaiter(this, void 0, void 0, function* () {
             const indexes = yield this.listIndexes(collection);
-            const name = this.generateIndexName(this.normalizeIndex(index));
+            const name = this.normalizeIndex(index).name;
             let found = false;
             for (const thisIndex of indexes) {
-                if (thisIndex.name === name) {
+                if (this.normalizeIndex(this.mongoIndexToIndexWithFilter(thisIndex))
+                    .name === name) {
                     yield this.assertDbWhileAttempingTo('drop a index.', collection)
                         .collection(collection)
                         .dropIndex(thisIndex.name);
@@ -288,10 +289,10 @@ export default class MongoDatabase {
                 const uniqueIndexes = [];
                 for (const index of indexes) {
                     if (index.unique) {
-                        uniqueIndexes.push({
+                        uniqueIndexes.push(this.normalizeIndex({
                             fields: Object.keys(index.key),
                             filter: index.partialFilterExpression,
-                        });
+                        }));
                     }
                 }
                 return uniqueIndexes;
@@ -322,32 +323,33 @@ export default class MongoDatabase {
         });
     }
     mongoIndexToIndexWithFilter(index) {
-        return {
+        return normalizeIndex({
             fields: Object.keys(index.key),
             filter: index.partialFilterExpression,
             name: index.name,
-        };
+        });
     }
     createIndex(collection, index) {
         return __awaiter(this, void 0, void 0, function* () {
             const currentIndexes = yield this.getIndexes(collection);
             this.assertIndexDoesNotExist(currentIndexes, index, collection);
             const indexSpec = {};
-            this.normalizeIndex(index).fields.forEach((name) => {
+            const normalized = this.normalizeIndex(index);
+            normalized.fields.forEach((name) => {
                 indexSpec[name] = 1;
             });
             try {
                 yield this.assertDbWhileAttempingTo('create an index.', collection)
                     .collection(collection)
                     .createIndex(indexSpec, {
-                    name: this.generateIndexName(index),
+                    name: normalized.name,
                 });
             }
             catch (err) {
                 if ((err === null || err === void 0 ? void 0 : err.code) === 11000) {
                     throw new SpruceError({
                         code: 'DUPLICATE_KEY',
-                        friendlyMessage: `Could not create index! Index on '${collection}' has duplicate key for "${this.normalizeIndex(index).fields.join(',')}"`,
+                        friendlyMessage: `Could not create index! Index on '${collection}' has duplicate key for "${normalized.fields.join(',')}"`,
                     });
                 }
                 else {
@@ -374,15 +376,17 @@ export default class MongoDatabase {
         });
     }
     _syncIndexes(collectionName_1, indexes_1, func_1) {
-        return __awaiter(this, arguments, void 0, function* (collectionName, indexes, func, shouldIncludeUnique = false) {
+        return __awaiter(this, arguments, void 0, function* (collectionName, indexes, func, isSyncingUniqueIndexes = false) {
             var _a;
-            const currentIndexes = yield this.getIndexes(collectionName, shouldIncludeUnique);
+            const currentIndexes = isSyncingUniqueIndexes
+                ? yield this.getUniqueIndexes(collectionName)
+                : yield this.getIndexes(collectionName);
             const indexesToDelete = pluckMissingIndexes(currentIndexes, indexes);
             for (const extra of indexesToDelete) {
                 yield this.dropIndex(collectionName, extra);
             }
             for (const index of indexes) {
-                if (!this.doesInclude(currentIndexes, this.normalizeIndex(index))) {
+                if (!this.doesInclude(currentIndexes, this.normalizeIndex(index, isSyncingUniqueIndexes))) {
                     try {
                         yield this[func](collectionName, index);
                     }
@@ -398,7 +402,7 @@ export default class MongoDatabase {
     createUniqueIndex(collection, index) {
         return __awaiter(this, void 0, void 0, function* () {
             const currentIndexes = yield this.getUniqueIndexes(collection);
-            const indexWithFilter = this.normalizeIndex(index);
+            const indexWithFilter = this.normalizeIndex(index, true);
             this.assertIndexDoesNotExist(currentIndexes, indexWithFilter, collection);
             const created = {};
             indexWithFilter.fields.forEach((name) => {
@@ -407,7 +411,7 @@ export default class MongoDatabase {
             try {
                 const options = {
                     unique: true,
-                    name: this.generateIndexName(indexWithFilter),
+                    name: indexWithFilter.name,
                 };
                 if (indexWithFilter.filter) {
                     options.partialFilterExpression = indexWithFilter.filter;
@@ -430,11 +434,8 @@ export default class MongoDatabase {
             }
         });
     }
-    generateIndexName(indexWithFilter) {
-        return generateIndexName(this.normalizeIndex(indexWithFilter));
-    }
-    normalizeIndex(index) {
-        return normalizeIndex(index);
+    normalizeIndex(index, isUnique) {
+        return normalizeIndex(index, isUnique);
     }
     syncUniqueIndexes(collectionName, indexes) {
         return __awaiter(this, void 0, void 0, function* () {

package/build/esm/databases/NeDbDatabase.js

@@ -485,33 +485,39 @@ export default class NeDbDatabase extends AbstractMutexer {
                 col._indexes = [];
             }
             yield this.randomDelay();
-            this.assertIndexDoesNotExist(col._indexes, this.normalizeIndex(fields), collection);
-            col._indexes.push({ fields });
+            const normalized = this.normalizeIndex(fields);
+            this.assertIndexDoesNotExist(col._indexes, normalized, collection);
+            col._indexes.push(normalized);
         });
     }
     normalizeIndex(index) {
-        const { fields, filter } = normalizeIndex(index);
-        return { fields, filter };
+        return normalizeIndex(index);
     }
     syncUniqueIndexes(collectionName, indexes) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
+            yield this.lock('syncUniqueIndexesMutex');
             const currentIndexes = yield this.getUniqueIndexes(collectionName);
             const toDelete = pluckMissingIndexes(currentIndexes, indexes);
-            for (const index of indexes) {
-                if (!this.doesInclude(currentIndexes, index)) {
-                    try {
-                        yield this.createUniqueIndex(collectionName, index);
-                    }
-                    catch (err) {
-                        if (((_a = err.options) === null || _a === void 0 ? void 0 : _a.code) !== 'INDEX_EXISTS') {
-                            throw err;
+            try {
+                for (const index of indexes) {
+                    if (!this.doesInclude(currentIndexes, index)) {
+                        try {
+                            yield this.createUniqueIndex(collectionName, index);
+                        }
+                        catch (err) {
+                            if (((_a = err.options) === null || _a === void 0 ? void 0 : _a.code) !== 'INDEX_EXISTS') {
+                                throw err;
+                            }
                         }
                     }
                 }
+                for (const extra of toDelete) {
+                    yield this.dropIndex(collectionName, extra);
+                }
             }
-            for (const extra of toDelete) {
-                yield this.dropIndex(collectionName, extra);
+            finally {
+                this.unlock('syncUniqueIndexesMutex');
             }
         });
     }

package/build/esm/databases/database.utilities.d.ts

@@ -1,6 +1,5 @@
 import { IndexWithFilter, Index } from '../types/database.types';
 export declare function doesIndexesInclude(haystack: Index[], needle: Index): boolean;
 export declare function areIndexesEqual(left: Index, right: Index): boolean;
-export declare function generateIndexName(indexWithFilter: IndexWithFilter): string;
-export declare function normalizeIndex(index: Index): IndexWithFilter;
+export declare function normalizeIndex(index: Index, isUnique?: boolean): IndexWithFilter;
 export declare function pluckMissingIndexes(left: Index[], right: Index[]): Index[];

package/build/esm/databases/database.utilities.js

@@ -12,7 +12,7 @@ export function areIndexesEqual(left, right) {
     const name2 = generateIndexName(normalizeIndex(right));
     return name1 === name2;
 }
-export function generateIndexName(indexWithFilter) {
+function generateIndexName(indexWithFilter, isUnique) {
     if (indexWithFilter.name) {
         return indexWithFilter.name;
     }
@@ -20,18 +20,23 @@ export function generateIndexName(indexWithFilter) {
     if (indexWithFilter.filter) {
         name += '_filtered';
     }
+    if (isUnique) {
+        name += '_unique';
+    }
     return name;
 }
-export function normalizeIndex(index) {
-    var _a;
+export function normalizeIndex(index, isUnique) {
     const fields = Array.isArray(index) ? index : index.fields;
     const filter = Array.isArray(index) ? undefined : index.filter;
     fields.sort();
-    return {
+    const normalized = {
         fields,
-        filter,
-        name: (_a = index.name) !== null && _a !== void 0 ? _a : undefined,
     };
+    if (filter) {
+        normalized.filter = filter;
+    }
+    normalized.name = generateIndexName(normalized, isUnique);
+    return normalized;
 }
 export function pluckMissingIndexes(left, right) {
     return differenceWith(left, right, areIndexesEqual);

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", "assertUpdateReturnsMatchedCounts", "assertCanUpsertOne", "assertCanUpsertNull", "assertCanPushToArrayOnUpsert", "assertCanSyncUniqueIndexesWithFilterExpression", "assertEmptyDatabaseReturnsEmptyArray", "assertFindOneOnEmptyDatabaseReturnsNull", "assertCanLimitResults", "assertCanLimitResultsToZero", "assertCanFindWithBooleanField", "assertCanQueryByGtLtGteLteNe", "assertCanQueryPathWithDotSyntax", "assertCanReturnOnlySelectFields", "assertCanSearchByRegex", "assertCanFindWithNe", "assertCanFindWithIn", "assertCanFindOrWithBadIdField", "assertCanDeleteRecord", "assertCanDeleteOne", "assertHasNoUniqueIndexToStart", "assertCanCreateUniqueIndex", "assertCanCreateMultiFieldUniqueIndex", "assertCantCreateUniqueIndexTwice", "assertCanDropUniqueIndex", "assertCanDropCompoundUniqueIndex", "assertCantDropUniqueIndexThatDoesntExist", "assertCantDropIndexWhenNoIndexExists", "assertCantDropCompoundUniqueIndexThatDoesntExist", "assertSyncingUniqueIndexesAddsMissingIndexes", "assertSyncingUniqueIndexesSkipsExistingIndexes", "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", "assertUpdateReturnsMatchedCounts", "assertCanUpsertOne", "assertCanUpsertNull", "assertCanPushToArrayOnUpsert", "assertCanSyncUniqueIndexesWithFilterExpression", "assertEmptyDatabaseReturnsEmptyArray", "assertFindOneOnEmptyDatabaseReturnsNull", "assertCanLimitResults", "assertCanLimitResultsToZero", "assertCanFindWithBooleanField", "assertCanQueryByGtLtGteLteNe", "assertCanQueryPathWithDotSyntax", "assertCanReturnOnlySelectFields", "assertCanSearchByRegex", "assertCanFindWithNe", "assertCanFindWithIn", "assertCanFindOrWithBadIdField", "assertCanDeleteRecord", "assertCanDeleteOne", "assertHasNoUniqueIndexToStart", "assertCanCreateUniqueIndex", "assertCanCreateMultiFieldUniqueIndex", "assertCantCreateUniqueIndexTwice", "assertCanDropUniqueIndex", "assertCanDropCompoundUniqueIndex", "assertCantDropUniqueIndexThatDoesntExist", "assertCantDropIndexWhenNoIndexExists", "assertCantDropCompoundUniqueIndexThatDoesntExist", "assertSyncingUniqueIndexesAddsMissingIndexes", "assertSyncingUniqueIndexesSkipsExistingUniqueIndexes", "assertSyncingUniqueIndexesRemovesExtraUniqueIndexes", "assertSyncingUniqueIndexesIsRaceProof", "assertSyncUniqueIndexesSkipsOnesThatExist", "assertCanHaveUniqueIndexOnFieldThatIsAlreadyInIndex", "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;
@@ -37,9 +37,10 @@ declare const databaseAssertUtil: {
     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>;
-    assertSyncingUniqueIndexesSkipsExistingIndexes(connect: TestConnect): Promise<void>;
+    assertSyncUniqueIndexesSkipsOnesThatExist(connect: TestConnect): Promise<void>;
+    assertCanHaveUniqueIndexOnFieldThatIsAlreadyInIndex(connect: TestConnect): Promise<void>;
+    assertSyncingUniqueIndexesRemovesExtraUniqueIndexes(connect: TestConnect): Promise<void>;
+    assertSyncingUniqueIndexesSkipsExistingUniqueIndexes(connect: TestConnect): Promise<void>;
     assertSyncingUniqueIndexesAddsMissingIndexes(connect: TestConnect): Promise<void>;
     assertCantDropCompoundUniqueIndexThatDoesntExist(connect: TestConnect): Promise<void>;
     assertCantDropIndexWhenNoIndexExists(connect: TestConnect): Promise<void>;
@@ -49,6 +50,7 @@ declare const databaseAssertUtil: {
     assertCantCreateUniqueIndexTwice(connect: TestConnect): Promise<void>;
     assertSyncingUniqueIndexesIsRaceProof(connect: TestConnect): Promise<void>;
     assertUniqueIndexBlocksDuplicates(connect: TestConnect): Promise<void>;
+    syncingUniqueIndexDoesNotTouchNonUniqueIndexes(connect: TestConnect): Promise<void>;
     assertCanCreateUniqueIndexOnNestedField(connect: TestConnect): Promise<void>;
     assertCanPushToArrayOnUpsert(connect: TestConnect): Promise<void>;
     assertCanSearchByRegex(connect: TestConnect): Promise<void>;

package/build/esm/tests/databaseAssertUtil.js

@@ -70,10 +70,11 @@ const methods = [
     'assertCantDropIndexWhenNoIndexExists',
     'assertCantDropCompoundUniqueIndexThatDoesntExist',
     'assertSyncingUniqueIndexesAddsMissingIndexes',
-    'assertSyncingUniqueIndexesSkipsExistingIndexes',
-    'assertSyncingUniqueIndexesRemovesExtraIndexes',
+    'assertSyncingUniqueIndexesSkipsExistingUniqueIndexes',
+    'assertSyncingUniqueIndexesRemovesExtraUniqueIndexes',
     'assertSyncingUniqueIndexesIsRaceProof',
-    'assertSyncingIndexesDoesNotAddAndRemove',
+    'assertSyncUniqueIndexesSkipsOnesThatExist',
+    'assertCanHaveUniqueIndexOnFieldThatIsAlreadyInIndex',
     'assertUniqueIndexBlocksDuplicates',
     'assertDuplicateKeyThrowsOnInsert',
     'assertSettingUniqueIndexViolationThrowsSpruceError',
@@ -747,7 +748,7 @@ const databaseAssertUtil = {
             yield this.shutdown(db);
         });
     },
-    assertSyncingIndexesDoesNotAddAndRemove(connect) {
+    assertSyncUniqueIndexesSkipsOnesThatExist(connect) {
         return __awaiter(this, void 0, void 0, function* () {
             const db = yield connectToDabatase(connect);
             yield db.createUniqueIndex(this.collectionName, ['otherField']);
@@ -765,7 +766,17 @@ const databaseAssertUtil = {
             yield this.shutdown(db);
         });
     },
-    assertSyncingUniqueIndexesRemovesExtraIndexes(connect) {
+    assertCanHaveUniqueIndexOnFieldThatIsAlreadyInIndex(connect) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const db = yield connectToDabatase(connect);
+            yield db.syncIndexes(this.collectionName, [
+                ['nested.field1'],
+                ['nested.field2'],
+            ]);
+            yield db.syncUniqueIndexes(this.collectionName, [['nested.field1']]);
+        });
+    },
+    assertSyncingUniqueIndexesRemovesExtraUniqueIndexes(connect) {
         return __awaiter(this, void 0, void 0, function* () {
             const db = yield connectToDabatase(connect);
             yield db.syncUniqueIndexes(this.collectionName, [
@@ -800,7 +811,7 @@ const databaseAssertUtil = {
             yield this.shutdown(db);
         });
     },
-    assertSyncingUniqueIndexesSkipsExistingIndexes(connect) {
+    assertSyncingUniqueIndexesSkipsExistingUniqueIndexes(connect) {
         return __awaiter(this, void 0, void 0, function* () {
             const db = yield connectToDabatase(connect);
             yield db.syncUniqueIndexes(this.collectionName, [['uniqueField']]);
@@ -925,6 +936,7 @@ const databaseAssertUtil = {
     assertSyncingUniqueIndexesIsRaceProof(connect) {
         return __awaiter(this, void 0, void 0, function* () {
             const db = yield connectToDabatase(connect);
+            debugger;
             const syncs = [
                 db.syncUniqueIndexes(this.collectionName, [
                     ['otherField', 'otherField2'],
@@ -958,6 +970,9 @@ const databaseAssertUtil = {
                 ]),
             ];
             yield Promise.all(syncs);
+            const saved = yield db.getUniqueIndexes(this.collectionName);
+            assert.isLength(saved, 1, 'After many simultaneous syncUniqueIndexes() calls, there should only be one unique index created.');
+            assert.isEqualDeep(saved[0].fields, ['otherField', 'otherField2'], 'After many simultaneous syncUniqueIndexes() calls, the unique index created does not have the expected fields.');
             yield this.shutdown(db);
         });
     },
@@ -1017,6 +1032,28 @@ const databaseAssertUtil = {
             yield this.shutdown(db);
         });
     },
+    syncingUniqueIndexDoesNotTouchNonUniqueIndexes(connect) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const db = yield connectToDabatase(connect);
+            yield db.createIndex(this.collectionName, ['someField']);
+            yield db.syncUniqueIndexes(this.collectionName, [['uniqueField']]);
+            const indexes = yield db.getIndexes(this.collectionName);
+            const uniqueIndexes = yield db.getUniqueIndexes(this.collectionName);
+            assert.isEqualDeep(indexes, [
+                {
+                    fields: ['someField'],
+                    name: 'someField',
+                },
+            ], 'index was modified when syncing unique indexes');
+            assert.isEqualDeep(uniqueIndexes, [
+                {
+                    fields: ['uniqueField'],
+                    name: 'uniqueField',
+                },
+            ], 'unique indexes are not as expected after syncing unique indexes');
+            yield this.shutdown(db);
+        });
+    },
     assertCanCreateUniqueIndexOnNestedField(connect) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;

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

@@ -42,6 +42,7 @@ export interface IndexWithFilter {
     fields: string[];
     filter?: Record<string, any>;
     name?: string;
+    isUnique?: boolean;
 }
 export type Index = string[] | IndexWithFilter;
 export interface CreateOptions extends DatabaseInternalOptions {

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", "assertUpdateReturnsMatchedCounts", "assertCanUpsertOne", "assertCanUpsertNull", "assertCanPushToArrayOnUpsert", "assertCanSyncUniqueIndexesWithFilterExpression", "assertEmptyDatabaseReturnsEmptyArray", "assertFindOneOnEmptyDatabaseReturnsNull", "assertCanLimitResults", "assertCanLimitResultsToZero", "assertCanFindWithBooleanField", "assertCanQueryByGtLtGteLteNe", "assertCanQueryPathWithDotSyntax", "assertCanReturnOnlySelectFields", "assertCanSearchByRegex", "assertCanFindWithNe", "assertCanFindWithIn", "assertCanFindOrWithBadIdField", "assertCanDeleteRecord", "assertCanDeleteOne", "assertHasNoUniqueIndexToStart", "assertCanCreateUniqueIndex", "assertCanCreateMultiFieldUniqueIndex", "assertCantCreateUniqueIndexTwice", "assertCanDropUniqueIndex", "assertCanDropCompoundUniqueIndex", "assertCantDropUniqueIndexThatDoesntExist", "assertCantDropIndexWhenNoIndexExists", "assertCantDropCompoundUniqueIndexThatDoesntExist", "assertSyncingUniqueIndexesAddsMissingIndexes", "assertSyncingUniqueIndexesSkipsExistingIndexes", "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", "assertUpdateReturnsMatchedCounts", "assertCanUpsertOne", "assertCanUpsertNull", "assertCanPushToArrayOnUpsert", "assertCanSyncUniqueIndexesWithFilterExpression", "assertEmptyDatabaseReturnsEmptyArray", "assertFindOneOnEmptyDatabaseReturnsNull", "assertCanLimitResults", "assertCanLimitResultsToZero", "assertCanFindWithBooleanField", "assertCanQueryByGtLtGteLteNe", "assertCanQueryPathWithDotSyntax", "assertCanReturnOnlySelectFields", "assertCanSearchByRegex", "assertCanFindWithNe", "assertCanFindWithIn", "assertCanFindOrWithBadIdField", "assertCanDeleteRecord", "assertCanDeleteOne", "assertHasNoUniqueIndexToStart", "assertCanCreateUniqueIndex", "assertCanCreateMultiFieldUniqueIndex", "assertCantCreateUniqueIndexTwice", "assertCanDropUniqueIndex", "assertCanDropCompoundUniqueIndex", "assertCantDropUniqueIndexThatDoesntExist", "assertCantDropIndexWhenNoIndexExists", "assertCantDropCompoundUniqueIndexThatDoesntExist", "assertSyncingUniqueIndexesAddsMissingIndexes", "assertSyncingUniqueIndexesSkipsExistingUniqueIndexes", "assertSyncingUniqueIndexesRemovesExtraUniqueIndexes", "assertSyncingUniqueIndexesIsRaceProof", "assertSyncUniqueIndexesSkipsOnesThatExist", "assertCanHaveUniqueIndexOnFieldThatIsAlreadyInIndex", "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;
@@ -37,9 +37,10 @@ declare const databaseAssertUtil: {
     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>;
-    assertSyncingUniqueIndexesSkipsExistingIndexes(connect: TestConnect): Promise<void>;
+    assertSyncUniqueIndexesSkipsOnesThatExist(connect: TestConnect): Promise<void>;
+    assertCanHaveUniqueIndexOnFieldThatIsAlreadyInIndex(connect: TestConnect): Promise<void>;
+    assertSyncingUniqueIndexesRemovesExtraUniqueIndexes(connect: TestConnect): Promise<void>;
+    assertSyncingUniqueIndexesSkipsExistingUniqueIndexes(connect: TestConnect): Promise<void>;
     assertSyncingUniqueIndexesAddsMissingIndexes(connect: TestConnect): Promise<void>;
     assertCantDropCompoundUniqueIndexThatDoesntExist(connect: TestConnect): Promise<void>;
     assertCantDropIndexWhenNoIndexExists(connect: TestConnect): Promise<void>;
@@ -49,6 +50,7 @@ declare const databaseAssertUtil: {
     assertCantCreateUniqueIndexTwice(connect: TestConnect): Promise<void>;
     assertSyncingUniqueIndexesIsRaceProof(connect: TestConnect): Promise<void>;
     assertUniqueIndexBlocksDuplicates(connect: TestConnect): Promise<void>;
+    syncingUniqueIndexDoesNotTouchNonUniqueIndexes(connect: TestConnect): Promise<void>;
     assertCanCreateUniqueIndexOnNestedField(connect: TestConnect): Promise<void>;
     assertCanPushToArrayOnUpsert(connect: TestConnect): Promise<void>;
     assertCanSearchByRegex(connect: TestConnect): Promise<void>;

package/build/tests/databaseAssertUtil.js

@@ -66,10 +66,11 @@ const methods = [
     'assertCantDropIndexWhenNoIndexExists',
     'assertCantDropCompoundUniqueIndexThatDoesntExist',
     'assertSyncingUniqueIndexesAddsMissingIndexes',
-    'assertSyncingUniqueIndexesSkipsExistingIndexes',
-    'assertSyncingUniqueIndexesRemovesExtraIndexes',
+    'assertSyncingUniqueIndexesSkipsExistingUniqueIndexes',
+    'assertSyncingUniqueIndexesRemovesExtraUniqueIndexes',
     'assertSyncingUniqueIndexesIsRaceProof',
-    'assertSyncingIndexesDoesNotAddAndRemove',
+    'assertSyncUniqueIndexesSkipsOnesThatExist',
+    'assertCanHaveUniqueIndexOnFieldThatIsAlreadyInIndex',
     'assertUniqueIndexBlocksDuplicates',
     'assertDuplicateKeyThrowsOnInsert',
     'assertSettingUniqueIndexViolationThrowsSpruceError',
@@ -683,7 +684,7 @@ const databaseAssertUtil = {
         });
         await this.shutdown(db);
     },
-    async assertSyncingIndexesDoesNotAddAndRemove(connect) {
+    async assertSyncUniqueIndexesSkipsOnesThatExist(connect) {
         const db = await connectToDabatase(connect);
         await db.createUniqueIndex(this.collectionName, ['otherField']);
         await db.createUniqueIndex(this.collectionName, ['someField']);
@@ -699,7 +700,15 @@ const databaseAssertUtil = {
         ]);
         await this.shutdown(db);
     },
-    async assertSyncingUniqueIndexesRemovesExtraIndexes(connect) {
+    async assertCanHaveUniqueIndexOnFieldThatIsAlreadyInIndex(connect) {
+        const db = await connectToDabatase(connect);
+        await db.syncIndexes(this.collectionName, [
+            ['nested.field1'],
+            ['nested.field2'],
+        ]);
+        await db.syncUniqueIndexes(this.collectionName, [['nested.field1']]);
+    },
+    async assertSyncingUniqueIndexesRemovesExtraUniqueIndexes(connect) {
         const db = await connectToDabatase(connect);
         await db.syncUniqueIndexes(this.collectionName, [
             ['uniqueField'],
@@ -732,7 +741,7 @@ const databaseAssertUtil = {
         test_utils_1.assert.isLength(indexes, 2, `Syncing unique indexes with filter is not removing extra indexes.`);
         await this.shutdown(db);
     },
-    async assertSyncingUniqueIndexesSkipsExistingIndexes(connect) {
+    async assertSyncingUniqueIndexesSkipsExistingUniqueIndexes(connect) {
         const db = await connectToDabatase(connect);
         await db.syncUniqueIndexes(this.collectionName, [['uniqueField']]);
         let indexes = await db.getUniqueIndexes(this.collectionName);
@@ -840,6 +849,7 @@ const databaseAssertUtil = {
     },
     async assertSyncingUniqueIndexesIsRaceProof(connect) {
         const db = await connectToDabatase(connect);
+        debugger;
         const syncs = [
             db.syncUniqueIndexes(this.collectionName, [
                 ['otherField', 'otherField2'],
@@ -873,6 +883,9 @@ const databaseAssertUtil = {
             ]),
         ];
         await Promise.all(syncs);
+        const saved = await db.getUniqueIndexes(this.collectionName);
+        test_utils_1.assert.isLength(saved, 1, 'After many simultaneous syncUniqueIndexes() calls, there should only be one unique index created.');
+        test_utils_1.assert.isEqualDeep(saved[0].fields, ['otherField', 'otherField2'], 'After many simultaneous syncUniqueIndexes() calls, the unique index created does not have the expected fields.');
         await this.shutdown(db);
     },
     async assertUniqueIndexBlocksDuplicates(connect) {
@@ -929,6 +942,26 @@ const databaseAssertUtil = {
         test_utils_2.errorAssert.assertError(err, 'DUPLICATE_RECORD');
         await this.shutdown(db);
     },
+    async syncingUniqueIndexDoesNotTouchNonUniqueIndexes(connect) {
+        const db = await connectToDabatase(connect);
+        await db.createIndex(this.collectionName, ['someField']);
+        await db.syncUniqueIndexes(this.collectionName, [['uniqueField']]);
+        const indexes = await db.getIndexes(this.collectionName);
+        const uniqueIndexes = await db.getUniqueIndexes(this.collectionName);
+        test_utils_1.assert.isEqualDeep(indexes, [
+            {
+                fields: ['someField'],
+                name: 'someField',
+            },
+        ], 'index was modified when syncing unique indexes');
+        test_utils_1.assert.isEqualDeep(uniqueIndexes, [
+            {
+                fields: ['uniqueField'],
+                name: 'uniqueField',
+            },
+        ], 'unique indexes are not as expected after syncing unique indexes');
+        await this.shutdown(db);
+    },
     async assertCanCreateUniqueIndexOnNestedField(connect) {
         var _a;
         const db = await connectToDabatase(connect);

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

@@ -42,6 +42,7 @@ export interface IndexWithFilter {
     fields: string[];
     filter?: Record<string, any>;
     name?: string;
+    isUnique?: boolean;
 }
 export type Index = string[] | IndexWithFilter;
 export interface CreateOptions extends DatabaseInternalOptions {

package/package.json

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