@sprucelabs/data-stores 28.1.333 → 28.1.335

package/build/databases/MongoDatabase.d.ts

@@ -1,5 +1,5 @@
 import { MongoClientOptions, MongoClient } from 'mongodb';
-import { Database, DatabaseOptions, IndexWithFilter, UniqueIndex } from '../types/database.types';
+import { Database, DatabaseOptions, Index, IndexWithFilter } from '../types/database.types';
 import { QueryOptions } from '../types/query.types';
 export declare const MONGO_TEST_URI = "mongodb://localhost:27017";
 export default class MongoDatabase implements Database {
@@ -26,16 +26,21 @@ export default class MongoDatabase implements Database {
     dropCollection(name: string): Promise<void>;
     dropDatabase(): Promise<void>;
     private listIndexes;
-    dropIndex(collection: string, index: UniqueIndex): Promise<void>;
-    getUniqueIndexes(collection: string): Promise<string[][]>;
-    getIndexes(collection: string, shouldIncludeUnique?: boolean): Promise<any[]>;
-    createIndex(collection: string, fields: string[]): Promise<void>;
+    dropIndex(collection: string, index: Index): Promise<void>;
+    getUniqueIndexes(collection: string): Promise<IndexWithFilter[]>;
+    getIndexes(collection: string, shouldIncludeUnique?: boolean): Promise<IndexWithFilter[] | {
+        fields: string[];
+        filter: any;
+    }[]>;
+    createIndex(collection: string, index: Index): Promise<void>;
     private assertIndexDoesNotExist;
-    private doesIndexExist;
-    syncIndexes(collectionName: string, indexes: string[][]): Promise<void>;
+    private doesInclude;
+    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: UniqueIndex[]): Promise<void>;
+    syncUniqueIndexes(collectionName: string, indexes: Index[]): Promise<void>;
     update(collection: string, query: Record<string, any>, updates: Record<string, any>): Promise<number>;
     updateOne(collection: string, query: Record<string, any>, updates: Record<string, any>): Promise<Record<string, any>>;
     upsertOne(collection: string, query: Record<string, any>, updates: Record<string, any>): Promise<Record<string, any>>;

package/build/databases/MongoDatabase.js

@@ -16,13 +16,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MONGO_TEST_URI = void 0;
 const spruce_skill_utils_1 = require("@sprucelabs/spruce-skill-utils");
-const differenceWith_1 = __importDefault(require("lodash/differenceWith"));
-const isEqual_1 = __importDefault(require("lodash/isEqual"));
 const mongodb_1 = require("mongodb");
 const SpruceError_1 = __importDefault(require("../errors/SpruceError"));
 const generateId_1 = __importDefault(require("../utilities/generateId"));
 const mongo_utility_1 = __importDefault(require("../utilities/mongo.utility"));
-const normalizeIndex_1 = __importDefault(require("./normalizeIndex"));
+const database_utilities_1 = require("./database.utilities");
 exports.MONGO_TEST_URI = 'mongodb://localhost:27017';
 class MongoDatabase {
     constructor(url, options) {
@@ -226,10 +224,11 @@ class MongoDatabase {
     }
     async listIndexes(collection) {
         try {
-            return await this.assertDbWhileAttempingTo('get indexes.', collection)
+            const indexes = await this.assertDbWhileAttempingTo('get indexes.', collection)
                 .collection(collection)
                 .listIndexes()
                 .toArray();
+            return indexes.filter((index) => index.name !== '_id_');
         }
         catch (err) {
             return [];
@@ -237,9 +236,10 @@ class MongoDatabase {
     }
     async dropIndex(collection, index) {
         const indexes = await this.listIndexes(collection);
+        const name = this.generateIndexName(this.normalizeIndex(index));
         let found = false;
         for (const thisIndex of indexes) {
-            if ((0, isEqual_1.default)(Object.keys(thisIndex.key), index)) {
+            if (thisIndex.name === name) {
                 await this.assertDbWhileAttempingTo('drop a index.', collection)
                     .collection(collection)
                     .dropIndex(thisIndex.name);
@@ -249,7 +249,7 @@ class MongoDatabase {
         if (!found) {
             throw new SpruceError_1.default({
                 code: 'INDEX_NOT_FOUND',
-                missingIndex: (0, normalizeIndex_1.default)(index).fields,
+                missingIndex: (0, database_utilities_1.normalizeIndex)(index).fields,
                 collectionName: collection,
             });
         }
@@ -260,7 +260,10 @@ class MongoDatabase {
             const uniqueIndexes = [];
             for (const index of indexes) {
                 if (index.unique) {
-                    uniqueIndexes.push(Object.keys(index.key));
+                    uniqueIndexes.push({
+                        fields: Object.keys(index.key),
+                        filter: index.partialFilterExpression,
+                    });
                 }
             }
             return uniqueIndexes;
@@ -273,12 +276,18 @@ class MongoDatabase {
         try {
             const indexes = await this.listIndexes(collection);
             if (shouldIncludeUnique) {
-                return indexes;
+                return indexes.map((index) => ({
+                    fields: Object.keys(index.key),
+                    filter: index.partialFilterExpression,
+                }));
             }
             const nonUniqueIndexes = [];
             for (const index of indexes) {
                 if (!index.unique) {
-                    nonUniqueIndexes.push(Object.keys(index.key));
+                    nonUniqueIndexes.push({
+                        fields: Object.keys(index.key),
+                        filter: undefined,
+                    });
                 }
             }
             return nonUniqueIndexes;
@@ -287,23 +296,25 @@ class MongoDatabase {
             return [];
         }
     }
-    async createIndex(collection, fields) {
+    async createIndex(collection, index) {
         const currentIndexes = await this.getIndexes(collection);
-        await this.assertIndexDoesNotExist(currentIndexes, fields, collection);
-        const index = {};
-        fields.forEach((name) => {
-            index[name] = 1;
+        this.assertIndexDoesNotExist(currentIndexes, index, collection);
+        const indexSpec = {};
+        this.normalizeIndex(index).fields.forEach((name) => {
+            indexSpec[name] = 1;
         });
         try {
             await this.assertDbWhileAttempingTo('create an index.', collection)
                 .collection(collection)
-                .createIndex(index);
+                .createIndex(indexSpec, {
+                name: this.generateIndexName(index),
+            });
         }
         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 "${fields.join(',')}"`,
+                    friendlyMessage: `Could not create index! Index on '${collection}' has duplicate key for "${this.normalizeIndex(index).fields.join(',')}"`,
                 });
             }
             else {
@@ -311,32 +322,29 @@ class MongoDatabase {
             }
         }
     }
-    assertIndexDoesNotExist(currentIndexes, fields, collectionName) {
-        if (this.doesIndexExist(currentIndexes, fields)) {
+    assertIndexDoesNotExist(currentIndexes, index, collectionName) {
+        if (this.doesInclude(currentIndexes, index)) {
             throw new SpruceError_1.default({
                 code: 'INDEX_EXISTS',
-                index: fields,
+                index: this.normalizeIndex(index).fields,
                 collectionName,
             });
         }
     }
-    doesIndexExist(currentIndexes, fields) {
-        for (const index of currentIndexes !== null && currentIndexes !== void 0 ? currentIndexes : []) {
-            const { fields: normalizedFields } = this.normalizeIndex(index);
-            if ((0, isEqual_1.default)(normalizedFields, fields)) {
-                return true;
-            }
-        }
-        return false;
+    doesInclude(haystack, needle) {
+        return (0, database_utilities_1.doesIndexesInclude)(haystack, needle);
     }
     async syncIndexes(collectionName, indexes) {
+        await this._syncIndexes(collectionName, indexes, 'createIndex');
+    }
+    async _syncIndexes(collectionName, indexes, func, shouldIncludeUnique = false) {
         var _a;
-        const currentIndexes = await this.getIndexes(collectionName);
-        const extraIndexes = (0, differenceWith_1.default)(currentIndexes, indexes, isEqual_1.default).filter((i) => !(i.length === 1 && i[0] === '_id'));
+        const currentIndexes = await this.getIndexes(collectionName, shouldIncludeUnique);
+        const indexesToDelete = (0, database_utilities_1.pluckMissingIndexes)(currentIndexes, indexes);
         for (const index of indexes) {
-            if (!this.doesIndexExist(currentIndexes, index)) {
+            if (!this.doesInclude(currentIndexes, this.normalizeIndex(index))) {
                 try {
-                    await this.createIndex(collectionName, index);
+                    await this[func](collectionName, index);
                 }
                 catch (err) {
                     if (((_a = err.options) === null || _a === void 0 ? void 0 : _a.code) !== 'INDEX_EXISTS') {
@@ -345,22 +353,25 @@ class MongoDatabase {
                 }
             }
         }
-        for (const extra of extraIndexes) {
+        for (const extra of indexesToDelete) {
             await this.dropIndex(collectionName, extra);
         }
     }
     async createUniqueIndex(collection, index) {
         const currentIndexes = await this.getUniqueIndexes(collection);
-        const { fields, filter } = this.normalizeIndex(index);
-        this.assertIndexDoesNotExist(currentIndexes, fields, collection);
+        const indexWithFilter = this.normalizeIndex(index);
+        this.assertIndexDoesNotExist(currentIndexes, indexWithFilter, collection);
         const created = {};
-        fields.forEach((name) => {
+        indexWithFilter.fields.forEach((name) => {
             created[name] = 1;
         });
         try {
-            const options = { unique: true };
-            if (filter) {
-                options.partialFilterExpression = filter;
+            const options = {
+                unique: true,
+                name: this.generateIndexName(indexWithFilter),
+            };
+            if (indexWithFilter.filter) {
+                options.partialFilterExpression = indexWithFilter.filter;
             }
             await this.assertDbWhileAttempingTo('create a unique index.', collection)
                 .collection(collection)
@@ -370,7 +381,8 @@ class MongoDatabase {
             if ((err === null || err === void 0 ? void 0 : err.code) === 11000) {
                 throw new SpruceError_1.default({
                     code: 'DUPLICATE_KEY',
-                    friendlyMessage: `Could not create index! Unique index on '${collection}' has duplicate key for "${fields.join(',')}"`,
+                    originalError: err,
+                    friendlyMessage: `Could not create index! Unique index on '${collection}' has duplicate key for "${indexWithFilter.fields.join(',')}"\n\nOriginal error:\n\n${err.message}`,
                 });
             }
             else {
@@ -378,35 +390,15 @@ class MongoDatabase {
             }
         }
     }
+    generateIndexName(indexWithFilter) {
+        return (0, database_utilities_1.generateIndexName)(this.normalizeIndex(indexWithFilter));
+    }
     normalizeIndex(index) {
-        const { fields, filter } = (0, normalizeIndex_1.default)(index);
+        const { fields, filter } = (0, database_utilities_1.normalizeIndex)(index);
         return { fields, filter };
     }
     async syncUniqueIndexes(collectionName, indexes) {
-        var _a;
-        const currentIndexes = await this.getUniqueIndexes(collectionName);
-        const toDelete = [];
-        for (const index of currentIndexes) {
-            if (!this.doesIndexExist(indexes, index)) {
-                toDelete.push(index);
-            }
-        }
-        for (const index of indexes) {
-            const { fields } = this.normalizeIndex(index);
-            if (!this.doesIndexExist(currentIndexes, fields)) {
-                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);
-        }
+        await this._syncIndexes(collectionName, indexes, 'createUniqueIndex', true);
     }
     async update(collection, query, updates) {
         const q = this.toMongoIdAndNull(collection, query);

package/build/databases/NeDbDatabase.d.ts

@@ -1,5 +1,5 @@
 import AbstractMutexer from '../mutexers/AbstractMutexer';
-import { CreateOptions, Database, DatabaseInternalOptions, UniqueIndex } from '../types/database.types';
+import { CreateOptions, Database, DatabaseInternalOptions, Index, IndexWithFilter } from '../types/database.types';
 import { QueryOptions } from '../types/query.types';
 export default class NeDbDatabase extends AbstractMutexer implements Database {
     private collections;
@@ -31,14 +31,15 @@ export default class NeDbDatabase extends AbstractMutexer implements Database {
     delete(collection: string, query: Record<string, any>): Promise<number>;
     deleteOne(collection: string, query: Record<string, any>): Promise<number>;
     private assertPassesUniqueIndexes;
-    getUniqueIndexes(collection: string): Promise<UniqueIndex[]>;
-    getIndexes(collection: string, shouldIncludeUnique?: boolean): Promise<UniqueIndex[]>;
-    dropIndex(collection: string, index: UniqueIndex): Promise<void>;
+    getUniqueIndexes(collection: string): Promise<IndexWithFilter[]>;
+    getIndexes(collection: string, shouldIncludeUnique?: boolean): Promise<IndexWithFilter[]>;
+    dropIndex(collection: string, index: Index): Promise<void>;
     private assertIndexDoesNotExist;
-    private doesIndexExist;
-    createUniqueIndex(collection: string, index: UniqueIndex): Promise<void>;
+    private doesInclude;
+    createUniqueIndex(collection: string, index: Index): Promise<void>;
     createIndex(collection: string, fields: string[]): Promise<void>;
-    syncUniqueIndexes(collectionName: string, indexes: UniqueIndex[]): Promise<void>;
+    private normalizeIndex;
+    syncUniqueIndexes(collectionName: string, indexes: Index[]): Promise<void>;
     syncIndexes(collectionName: string, indexes: string[][]): Promise<void>;
     query<T>(query: string, params?: any[]): Promise<T[]>;
     private queryToKey;

package/build/databases/NeDbDatabase.js

@@ -16,7 +16,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 const dotenv_1 = __importDefault(require("dotenv"));
-const differenceWith_1 = __importDefault(require("lodash/differenceWith"));
 const get_1 = __importDefault(require("lodash/get"));
 const isEqual_1 = __importDefault(require("lodash/isEqual"));
 const isObject_1 = __importDefault(require("lodash/isObject"));
@@ -26,7 +25,7 @@ const SpruceError_1 = __importDefault(require("../errors/SpruceError"));
 const AbstractMutexer_1 = __importDefault(require("../mutexers/AbstractMutexer"));
 const generateId_1 = __importDefault(require("../utilities/generateId"));
 const mongo_utility_1 = __importDefault(require("../utilities/mongo.utility"));
-const normalizeIndex_1 = __importDefault(require("./normalizeIndex"));
+const database_utilities_1 = require("./database.utilities");
 dotenv_1.default.config();
 class NeDbDatabase extends AbstractMutexer_1.default {
     constructor() {
@@ -290,7 +289,7 @@ class NeDbDatabase extends AbstractMutexer_1.default {
         await this.randomDelay();
         if (col._uniqueIndexes) {
             for (const index of col._uniqueIndexes) {
-                const { fields, filter } = (0, normalizeIndex_1.default)(index);
+                const { fields, filter } = (0, database_utilities_1.normalizeIndex)(index);
                 if (filter) {
                     let shouldSkip = false;
                     for (const key in filter) {
@@ -348,12 +347,12 @@ class NeDbDatabase extends AbstractMutexer_1.default {
     async dropIndex(collection, index) {
         var _a, _b;
         const col = this.loadCollection(collection);
-        const { fields } = (0, normalizeIndex_1.default)(index);
+        const { fields } = (0, database_utilities_1.normalizeIndex)(index);
         await this.randomDelay();
         let found = false;
         let newIndexes = [];
         for (const uniq of (_a = col._uniqueIndexes) !== null && _a !== void 0 ? _a : []) {
-            if (!(0, isEqual_1.default)(uniq, fields)) {
+            if (!(0, isEqual_1.default)(uniq.fields, fields)) {
                 newIndexes.push(uniq);
             }
             else {
@@ -367,7 +366,7 @@ class NeDbDatabase extends AbstractMutexer_1.default {
         else {
             newIndexes = [];
             for (const index of (_b = col._indexes) !== null && _b !== void 0 ? _b : []) {
-                if (!(0, isEqual_1.default)(index, fields)) {
+                if (!(0, isEqual_1.default)(index.fields, fields)) {
                     newIndexes.push(index);
                 }
                 else {
@@ -385,37 +384,32 @@ class NeDbDatabase extends AbstractMutexer_1.default {
             collectionName: 'test_collection',
         });
     }
-    assertIndexDoesNotExist(currentIndexes, fields, collectionName) {
-        if (this.doesIndexExist(currentIndexes, fields)) {
+    assertIndexDoesNotExist(currentIndexes, index, collectionName) {
+        if (this.doesInclude(currentIndexes, index)) {
             throw new SpruceError_1.default({
                 code: 'INDEX_EXISTS',
-                index: fields,
+                index: index.fields,
                 collectionName,
             });
         }
     }
-    doesIndexExist(currentIndexes, index) {
-        for (const existing of currentIndexes !== null && currentIndexes !== void 0 ? currentIndexes : []) {
-            if ((0, isEqual_1.default)(existing, index)) {
-                return true;
-            }
-        }
-        return false;
+    doesInclude(haystack, needle) {
+        return (0, database_utilities_1.doesIndexesInclude)(haystack, needle);
     }
     async createUniqueIndex(collection, index) {
         const col = this.loadCollection(collection);
         if (!col._uniqueIndexes) {
             col._uniqueIndexes = [];
         }
-        const { fields, filter } = (0, normalizeIndex_1.default)(index);
+        const indexWithFilter = (0, database_utilities_1.normalizeIndex)(index);
         await this.randomDelay();
-        this.assertIndexDoesNotExist(col._uniqueIndexes, fields, collection);
-        if (col._uniqueIndexes && !filter) {
+        this.assertIndexDoesNotExist(col._uniqueIndexes, indexWithFilter, collection);
+        if (col._uniqueIndexes && !indexWithFilter.filter) {
             const tempUniqueIndexes = [...col._uniqueIndexes];
-            tempUniqueIndexes.push(fields);
+            tempUniqueIndexes.push(indexWithFilter);
             const documents = (await this.find(collection)) || [];
             for (const index of tempUniqueIndexes) {
-                const { fields: uniqueFields } = (0, normalizeIndex_1.default)(index);
+                const { fields: uniqueFields } = (0, database_utilities_1.normalizeIndex)(index);
                 let parsedExisting = [];
                 for (const doc of documents) {
                     const tempDoc = {};
@@ -433,7 +427,7 @@ class NeDbDatabase extends AbstractMutexer_1.default {
                 }
             }
         }
-        col._uniqueIndexes.push(index);
+        col._uniqueIndexes.push(indexWithFilter);
     }
     async createIndex(collection, fields) {
         const col = this.loadCollection(collection);
@@ -441,20 +435,19 @@ class NeDbDatabase extends AbstractMutexer_1.default {
             col._indexes = [];
         }
         await this.randomDelay();
-        this.assertIndexDoesNotExist(col._indexes, fields, collection);
-        col._indexes.push(fields);
+        this.assertIndexDoesNotExist(col._indexes, this.normalizeIndex(fields), collection);
+        col._indexes.push({ fields });
+    }
+    normalizeIndex(index) {
+        const { fields, filter } = (0, database_utilities_1.normalizeIndex)(index);
+        return { fields, filter };
     }
     async syncUniqueIndexes(collectionName, indexes) {
         var _a;
         const currentIndexes = await this.getUniqueIndexes(collectionName);
-        const toDelete = [];
-        for (const index of currentIndexes) {
-            if (!this.doesIndexExist(indexes, index)) {
-                toDelete.push(index);
-            }
-        }
+        const toDelete = (0, database_utilities_1.pluckMissingIndexes)(currentIndexes, indexes);
         for (const index of indexes) {
-            if (!this.doesIndexExist(currentIndexes, index)) {
+            if (!this.doesInclude(currentIndexes, index)) {
                 try {
                     await this.createUniqueIndex(collectionName, index);
                 }
@@ -472,9 +465,9 @@ class NeDbDatabase extends AbstractMutexer_1.default {
     async syncIndexes(collectionName, indexes) {
         var _a;
         const currentIndexes = await this.getIndexes(collectionName);
-        const extraIndexes = (0, differenceWith_1.default)(currentIndexes, indexes, isEqual_1.default);
+        const extraIndexes = (0, database_utilities_1.pluckMissingIndexes)(currentIndexes, indexes);
         for (const index of indexes) {
-            if (!this.doesIndexExist(currentIndexes, index)) {
+            if (!this.doesInclude(currentIndexes, index)) {
                 try {
                     await this.createIndex(collectionName, index);
                 }

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

@@ -0,0 +1,6 @@
+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 pluckMissingIndexes(left: Index[], right: Index[]): Index[];

package/build/databases/database.utilities.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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"));
+function doesIndexesInclude(haystack, needle) {
+    for (const index of haystack !== null && haystack !== void 0 ? haystack : []) {
+        if (areIndexesEqual(index, needle)) {
+            return true;
+        }
+    }
+    return false;
+}
+function areIndexesEqual(left, right) {
+    const name1 = generateIndexName(normalizeIndex(left));
+    const name2 = generateIndexName(normalizeIndex(right));
+    return name1 === name2;
+}
+function generateIndexName(indexWithFilter) {
+    let name = indexWithFilter.fields.join('_');
+    if (indexWithFilter.filter) {
+        name += '_filtered';
+    }
+    return name;
+}
+function normalizeIndex(index) {
+    const fields = Array.isArray(index) ? index : index.fields;
+    const filter = Array.isArray(index) ? undefined : index.filter;
+    fields.sort();
+    return { fields, filter };
+}
+function pluckMissingIndexes(left, right) {
+    return (0, differenceWith_1.default)(left, right, areIndexesEqual);
+}

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

@@ -1,5 +1,5 @@
 import { MongoClientOptions, MongoClient } from 'mongodb';
-import { Database, DatabaseOptions, IndexWithFilter, UniqueIndex } from '../types/database.types';
+import { Database, DatabaseOptions, Index, IndexWithFilter } from '../types/database.types';
 import { QueryOptions } from '../types/query.types';
 export declare const MONGO_TEST_URI = "mongodb://localhost:27017";
 export default class MongoDatabase implements Database {
@@ -26,16 +26,21 @@ export default class MongoDatabase implements Database {
     dropCollection(name: string): Promise<void>;
     dropDatabase(): Promise<void>;
     private listIndexes;
-    dropIndex(collection: string, index: UniqueIndex): Promise<void>;
-    getUniqueIndexes(collection: string): Promise<string[][]>;
-    getIndexes(collection: string, shouldIncludeUnique?: boolean): Promise<any[]>;
-    createIndex(collection: string, fields: string[]): Promise<void>;
+    dropIndex(collection: string, index: Index): Promise<void>;
+    getUniqueIndexes(collection: string): Promise<IndexWithFilter[]>;
+    getIndexes(collection: string, shouldIncludeUnique?: boolean): Promise<IndexWithFilter[] | {
+        fields: string[];
+        filter: any;
+    }[]>;
+    createIndex(collection: string, index: Index): Promise<void>;
     private assertIndexDoesNotExist;
-    private doesIndexExist;
-    syncIndexes(collectionName: string, indexes: string[][]): Promise<void>;
+    private doesInclude;
+    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: UniqueIndex[]): Promise<void>;
+    syncUniqueIndexes(collectionName: string, indexes: Index[]): Promise<void>;
     update(collection: string, query: Record<string, any>, updates: Record<string, any>): Promise<number>;
     updateOne(collection: string, query: Record<string, any>, updates: Record<string, any>): Promise<Record<string, any>>;
     upsertOne(collection: string, query: Record<string, any>, updates: Record<string, any>): Promise<Record<string, any>>;