@sprucelabs/data-stores 8.0.124 → 8.1.1

package/build/databases/MongoDatabase.d.ts

@@ -27,11 +27,14 @@ export default class MongoDatabase implements Database {
     isConnected(): boolean;
     dropCollection(name: string): Promise<void>;
     dropDatabase(): Promise<void>;
-    getUniqueIndexes(collection: string): Promise<string[][]>;
     private listIndexes;
     dropIndex(collection: string, fields: string[]): Promise<void>;
-    private assertUniqueIndexDoesNotExist;
-    private doesUniqueIndexExist;
+    getUniqueIndexes(collection: string): Promise<string[][]>;
+    getIndexes(collection: string, shouldIncludeUnique?: boolean): Promise<any[]>;
+    createIndex(collection: string, fields: string[]): Promise<void>;
+    private assertIndexDoesNotExist;
+    private doesIndexExist;
+    syncIndexes(collectionName: string, indexes: string[][]): Promise<void>;
     createUniqueIndex(collection: string, fields: string[]): Promise<void>;
     syncUniqueIndexes(collectionName: string, indexes: string[][]): Promise<void>;
     update(collection: string, query: Record<string, any>, updates: Record<string, any>): Promise<any>;

package/build/databases/MongoDatabase.js

@@ -215,21 +215,6 @@ class MongoDatabase {
     async dropDatabase() {
         await this.assertDbWhileAttempingTo('drop the entire database.').dropDatabase();
     }
-    async getUniqueIndexes(collection) {
-        try {
-            const indexes = await this.listIndexes(collection);
-            const uniqueIndexes = [];
-            for (const index of indexes) {
-                if (index.unique) {
-                    uniqueIndexes.push(Object.keys(index.key));
-                }
-            }
-            return uniqueIndexes;
-        }
-        catch (err) {
-            return [];
-        }
-    }
     async listIndexes(collection) {
         try {
             return await this.assertDbWhileAttempingTo('get indexes.', collection)
@@ -256,22 +241,91 @@ class MongoDatabase {
             throw new SpruceError_1.default({ code: 'INDEX_NOT_FOUND', missingIndex: fields });
         }
     }
-    assertUniqueIndexDoesNotExist(currentIndexes, fields) {
-        if (this.doesUniqueIndexExist(currentIndexes, fields)) {
+    async getUniqueIndexes(collection) {
+        try {
+            const indexes = await this.listIndexes(collection);
+            const uniqueIndexes = [];
+            for (const index of indexes) {
+                if (index.unique) {
+                    uniqueIndexes.push(Object.keys(index.key));
+                }
+            }
+            return uniqueIndexes;
+        }
+        catch (err) {
+            return [];
+        }
+    }
+    async getIndexes(collection, shouldIncludeUnique = false) {
+        try {
+            const indexes = await this.listIndexes(collection);
+            if (shouldIncludeUnique) {
+                return indexes;
+            }
+            const nonUniqueIndexes = [];
+            for (const index of indexes) {
+                if (!index.unique) {
+                    nonUniqueIndexes.push(Object.keys(index.key));
+                }
+            }
+            return nonUniqueIndexes;
+        }
+        catch (err) {
+            return [];
+        }
+    }
+    async createIndex(collection, fields) {
+        const currentIndexes = await this.getIndexes(collection);
+        await this.assertIndexDoesNotExist(currentIndexes, fields);
+        const index = {};
+        fields.forEach((name) => {
+            index[name] = 1;
+        });
+        try {
+            await this.assertDbWhileAttempingTo('create an index.', collection)
+                .collection(collection)
+                .createIndex(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(',')}"`,
+                });
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    assertIndexDoesNotExist(currentIndexes, fields) {
+        if (this.doesIndexExist(currentIndexes, fields)) {
             throw new SpruceError_1.default({ code: 'INDEX_EXISTS', index: fields });
         }
     }
-    doesUniqueIndexExist(currentIndexes, fields) {
-        for (const uniq of currentIndexes !== null && currentIndexes !== void 0 ? currentIndexes : []) {
-            if ((0, lodash_1.isEqual)(uniq, fields)) {
+    doesIndexExist(currentIndexes, fields) {
+        for (const index of currentIndexes !== null && currentIndexes !== void 0 ? currentIndexes : []) {
+            if ((0, lodash_1.isEqual)(index, fields)) {
                 return true;
             }
         }
         return false;
     }
+    async syncIndexes(collectionName, indexes) {
+        const currentIndexes = await this.getIndexes(collectionName);
+        const extraIndexes = (0, lodash_1.differenceWith)(currentIndexes, indexes, lodash_1.isEqual).filter((i) => !(i.length === 1 && i[0] === '_id'));
+        for (const index of indexes) {
+            if (!this.doesIndexExist(currentIndexes, index)) {
+                await this.createIndex(collectionName, index);
+            }
+        }
+        for (const extra of extraIndexes) {
+            await this.dropIndex(collectionName, extra);
+        }
+    }
     async createUniqueIndex(collection, fields) {
         const currentIndexes = await this.getUniqueIndexes(collection);
-        await this.assertUniqueIndexDoesNotExist(currentIndexes, fields);
+        await this.assertIndexDoesNotExist(currentIndexes, fields);
         const index = {};
         fields.forEach((name) => {
             index[name] = 1;
@@ -297,7 +351,7 @@ class MongoDatabase {
         const currentIndexes = await this.getUniqueIndexes(collectionName);
         const extraIndexes = (0, lodash_1.differenceWith)(currentIndexes, indexes, lodash_1.isEqual);
         for (const index of indexes) {
-            if (!this.doesUniqueIndexExist(currentIndexes, index)) {
+            if (!this.doesIndexExist(currentIndexes, index)) {
                 await this.createUniqueIndex(collectionName, index);
             }
         }

package/build/databases/NeDbDatabase.d.ts

@@ -30,9 +30,12 @@ export default class NeDbDatabase extends AbstractMutexer implements Database {
     deleteOne(collection: string, query: Record<string, any>): Promise<number>;
     private assertPassesUniqueIndexes;
     getUniqueIndexes(collection: string): Promise<string[][]>;
+    getIndexes(collection: string, shouldIncludeUnique?: boolean): Promise<string[][]>;
     dropIndex(collection: string, fields: string[]): Promise<void>;
-    private assertUniqueIndexDoesNotExist;
-    private doesUniqueIndexExist;
+    private assertIndexDoesNotExist;
+    private doesIndexExist;
     createUniqueIndex(collection: string, fields: string[]): Promise<void>;
+    createIndex(collection: string, fields: string[]): Promise<void>;
     syncUniqueIndexes(collectionName: string, indexes: string[][]): Promise<void>;
+    syncIndexes(collectionName: string, indexes: string[][]): Promise<void>;
 }

package/build/databases/NeDbDatabase.js

@@ -298,12 +298,22 @@ class NeDbDatabase extends AbstractMutexer_1.default {
         await this.randomDelay();
         return (_a = col._uniqueIndexes) !== null && _a !== void 0 ? _a : [];
     }
+    async getIndexes(collection, shouldIncludeUnique = false) {
+        var _a, _b, _c;
+        const col = this.loadCollection(collection);
+        await this.randomDelay();
+        if (shouldIncludeUnique) {
+            const uniqIndexes = (_a = col._uniqueIndexes) !== null && _a !== void 0 ? _a : [];
+            return uniqIndexes.concat((_b = col._indexes) !== null && _b !== void 0 ? _b : []);
+        }
+        return (_c = col._indexes) !== null && _c !== void 0 ? _c : [];
+    }
     async dropIndex(collection, fields) {
-        var _a;
+        var _a, _b;
         const col = this.loadCollection(collection);
         await this.randomDelay();
         let found = false;
-        const newIndexes = [];
+        let newIndexes = [];
         for (const uniq of (_a = col._uniqueIndexes) !== null && _a !== void 0 ? _a : []) {
             if (!(0, lodash_1.isEqual)(uniq, fields)) {
                 newIndexes.push(uniq);
@@ -312,19 +322,35 @@ class NeDbDatabase extends AbstractMutexer_1.default {
                 found = true;
             }
         }
-        if (!found) {
-            throw new SpruceError_1.default({ code: 'INDEX_NOT_FOUND', missingIndex: fields });
+        if (found) {
+            col._uniqueIndexes = newIndexes;
+            return;
+        }
+        else {
+            newIndexes = [];
+            for (const index of (_b = col._indexes) !== null && _b !== void 0 ? _b : []) {
+                if (!(0, lodash_1.isEqual)(index, fields)) {
+                    newIndexes.push(index);
+                }
+                else {
+                    found = true;
+                }
+            }
+            if (found) {
+                col._indexes = newIndexes;
+                return;
+            }
         }
-        col._uniqueIndexes = newIndexes;
+        throw new SpruceError_1.default({ code: 'INDEX_NOT_FOUND', missingIndex: fields });
     }
-    assertUniqueIndexDoesNotExist(currentIndexes, fields) {
-        if (this.doesUniqueIndexExist(currentIndexes, fields)) {
+    assertIndexDoesNotExist(currentIndexes, fields) {
+        if (this.doesIndexExist(currentIndexes, fields)) {
             throw new SpruceError_1.default({ code: 'INDEX_EXISTS', index: fields });
         }
     }
-    doesUniqueIndexExist(currentIndexes, fields) {
-        for (const uniq of currentIndexes !== null && currentIndexes !== void 0 ? currentIndexes : []) {
-            if ((0, lodash_1.isEqual)(uniq, fields)) {
+    doesIndexExist(currentIndexes, fields) {
+        for (const index of currentIndexes !== null && currentIndexes !== void 0 ? currentIndexes : []) {
+            if ((0, lodash_1.isEqual)(index, fields)) {
                 return true;
             }
         }
@@ -336,7 +362,7 @@ class NeDbDatabase extends AbstractMutexer_1.default {
             col._uniqueIndexes = [];
         }
         await this.randomDelay();
-        this.assertUniqueIndexDoesNotExist(col._uniqueIndexes, fields);
+        this.assertIndexDoesNotExist(col._uniqueIndexes, fields);
         if (col._uniqueIndexes) {
             const tempUniqueIndexes = [...col._uniqueIndexes];
             tempUniqueIndexes.push(fields);
@@ -361,12 +387,21 @@ class NeDbDatabase extends AbstractMutexer_1.default {
         }
         col._uniqueIndexes.push(fields);
     }
+    async createIndex(collection, fields) {
+        const col = this.loadCollection(collection);
+        if (!col._indexes) {
+            col._indexes = [];
+        }
+        await this.randomDelay();
+        this.assertIndexDoesNotExist(col._indexes, fields);
+        col._indexes.push(fields);
+    }
     async syncUniqueIndexes(collectionName, indexes) {
         var _a;
         const currentIndexes = await this.getUniqueIndexes(collectionName);
         const extraIndexes = (0, lodash_1.differenceWith)(currentIndexes, indexes, lodash_1.isEqual);
         for (const index of indexes) {
-            if (!this.doesUniqueIndexExist(currentIndexes, index)) {
+            if (!this.doesIndexExist(currentIndexes, index)) {
                 try {
                     await this.createUniqueIndex(collectionName, index);
                 }
@@ -381,5 +416,25 @@ class NeDbDatabase extends AbstractMutexer_1.default {
             await this.dropIndex(collectionName, extra);
         }
     }
+    async syncIndexes(collectionName, indexes) {
+        var _a;
+        const currentIndexes = await this.getIndexes(collectionName);
+        const extraIndexes = (0, lodash_1.differenceWith)(currentIndexes, indexes, lodash_1.isEqual);
+        for (const index of indexes) {
+            if (!this.doesIndexExist(currentIndexes, index)) {
+                try {
+                    await this.createIndex(collectionName, index);
+                }
+                catch (err) {
+                    if (((_a = err.options) === null || _a === void 0 ? void 0 : _a.code) !== 'INDEX_EXISTS') {
+                        throw err;
+                    }
+                }
+            }
+        }
+        for (const extra of extraIndexes) {
+            await this.dropIndex(collectionName, extra);
+        }
+    }
 }
 exports.default = NeDbDatabase;

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

@@ -27,11 +27,14 @@ export default class MongoDatabase implements Database {
     isConnected(): boolean;
     dropCollection(name: string): Promise<void>;
     dropDatabase(): Promise<void>;
-    getUniqueIndexes(collection: string): Promise<string[][]>;
     private listIndexes;
     dropIndex(collection: string, fields: string[]): Promise<void>;
-    private assertUniqueIndexDoesNotExist;
-    private doesUniqueIndexExist;
+    getUniqueIndexes(collection: string): Promise<string[][]>;
+    getIndexes(collection: string, shouldIncludeUnique?: boolean): Promise<any[]>;
+    createIndex(collection: string, fields: string[]): Promise<void>;
+    private assertIndexDoesNotExist;
+    private doesIndexExist;
+    syncIndexes(collectionName: string, indexes: string[][]): Promise<void>;
     createUniqueIndex(collection: string, fields: string[]): Promise<void>;
     syncUniqueIndexes(collectionName: string, indexes: string[][]): Promise<void>;
     update(collection: string, query: Record<string, any>, updates: Record<string, any>): Promise<any>;

package/build/esm/databases/MongoDatabase.js

@@ -238,23 +238,6 @@ export default class MongoDatabase {
             yield this.assertDbWhileAttempingTo('drop the entire database.').dropDatabase();
         });
     }
-    getUniqueIndexes(collection) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const indexes = yield this.listIndexes(collection);
-                const uniqueIndexes = [];
-                for (const index of indexes) {
-                    if (index.unique) {
-                        uniqueIndexes.push(Object.keys(index.key));
-                    }
-                }
-                return uniqueIndexes;
-            }
-            catch (err) {
-                return [];
-            }
-        });
-    }
     listIndexes(collection) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
@@ -285,23 +268,100 @@ export default class MongoDatabase {
             }
         });
     }
-    assertUniqueIndexDoesNotExist(currentIndexes, fields) {
-        if (this.doesUniqueIndexExist(currentIndexes, fields)) {
+    getUniqueIndexes(collection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const indexes = yield this.listIndexes(collection);
+                const uniqueIndexes = [];
+                for (const index of indexes) {
+                    if (index.unique) {
+                        uniqueIndexes.push(Object.keys(index.key));
+                    }
+                }
+                return uniqueIndexes;
+            }
+            catch (err) {
+                return [];
+            }
+        });
+    }
+    getIndexes(collection, shouldIncludeUnique = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const indexes = yield this.listIndexes(collection);
+                if (shouldIncludeUnique) {
+                    return indexes;
+                }
+                const nonUniqueIndexes = [];
+                for (const index of indexes) {
+                    if (!index.unique) {
+                        nonUniqueIndexes.push(Object.keys(index.key));
+                    }
+                }
+                return nonUniqueIndexes;
+            }
+            catch (err) {
+                return [];
+            }
+        });
+    }
+    createIndex(collection, fields) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentIndexes = yield this.getIndexes(collection);
+            yield this.assertIndexDoesNotExist(currentIndexes, fields);
+            const index = {};
+            fields.forEach((name) => {
+                index[name] = 1;
+            });
+            try {
+                yield this.assertDbWhileAttempingTo('create an index.', collection)
+                    .collection(collection)
+                    .createIndex(index);
+            }
+            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 "${fields.join(',')}"`,
+                    });
+                }
+                else {
+                    throw err;
+                }
+            }
+        });
+    }
+    assertIndexDoesNotExist(currentIndexes, fields) {
+        if (this.doesIndexExist(currentIndexes, fields)) {
             throw new SpruceError({ code: 'INDEX_EXISTS', index: fields });
         }
     }
-    doesUniqueIndexExist(currentIndexes, fields) {
-        for (const uniq of currentIndexes !== null && currentIndexes !== void 0 ? currentIndexes : []) {
-            if (isEqual(uniq, fields)) {
+    doesIndexExist(currentIndexes, fields) {
+        for (const index of currentIndexes !== null && currentIndexes !== void 0 ? currentIndexes : []) {
+            if (isEqual(index, fields)) {
                 return true;
             }
         }
         return false;
     }
+    syncIndexes(collectionName, indexes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentIndexes = yield this.getIndexes(collectionName);
+            const extraIndexes = differenceWith(currentIndexes, indexes, isEqual).filter((i) => !(i.length === 1 && i[0] === '_id'));
+            for (const index of indexes) {
+                if (!this.doesIndexExist(currentIndexes, index)) {
+                    yield this.createIndex(collectionName, index);
+                }
+            }
+            for (const extra of extraIndexes) {
+                yield this.dropIndex(collectionName, extra);
+            }
+        });
+    }
     createUniqueIndex(collection, fields) {
         return __awaiter(this, void 0, void 0, function* () {
             const currentIndexes = yield this.getUniqueIndexes(collection);
-            yield this.assertUniqueIndexDoesNotExist(currentIndexes, fields);
+            yield this.assertIndexDoesNotExist(currentIndexes, fields);
             const index = {};
             fields.forEach((name) => {
                 index[name] = 1;
@@ -329,7 +389,7 @@ export default class MongoDatabase {
             const currentIndexes = yield this.getUniqueIndexes(collectionName);
             const extraIndexes = differenceWith(currentIndexes, indexes, isEqual);
             for (const index of indexes) {
-                if (!this.doesUniqueIndexExist(currentIndexes, index)) {
+                if (!this.doesIndexExist(currentIndexes, index)) {
                     yield this.createUniqueIndex(collectionName, index);
                 }
             }

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

@@ -30,9 +30,12 @@ export default class NeDbDatabase extends AbstractMutexer implements Database {
     deleteOne(collection: string, query: Record<string, any>): Promise<number>;
     private assertPassesUniqueIndexes;
     getUniqueIndexes(collection: string): Promise<string[][]>;
+    getIndexes(collection: string, shouldIncludeUnique?: boolean): Promise<string[][]>;
     dropIndex(collection: string, fields: string[]): Promise<void>;
-    private assertUniqueIndexDoesNotExist;
-    private doesUniqueIndexExist;
+    private assertIndexDoesNotExist;
+    private doesIndexExist;
     createUniqueIndex(collection: string, fields: string[]): Promise<void>;
+    createIndex(collection: string, fields: string[]): Promise<void>;
     syncUniqueIndexes(collectionName: string, indexes: string[][]): Promise<void>;
+    syncIndexes(collectionName: string, indexes: string[][]): Promise<void>;
 }

package/build/esm/databases/NeDbDatabase.js

@@ -336,13 +336,25 @@ export default class NeDbDatabase extends AbstractMutexer {
             return (_a = col._uniqueIndexes) !== null && _a !== void 0 ? _a : [];
         });
     }
+    getIndexes(collection, shouldIncludeUnique = false) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            const col = this.loadCollection(collection);
+            yield this.randomDelay();
+            if (shouldIncludeUnique) {
+                const uniqIndexes = (_a = col._uniqueIndexes) !== null && _a !== void 0 ? _a : [];
+                return uniqIndexes.concat((_b = col._indexes) !== null && _b !== void 0 ? _b : []);
+            }
+            return (_c = col._indexes) !== null && _c !== void 0 ? _c : [];
+        });
+    }
     dropIndex(collection, fields) {
-        var _a;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             const col = this.loadCollection(collection);
             yield this.randomDelay();
             let found = false;
-            const newIndexes = [];
+            let newIndexes = [];
             for (const uniq of (_a = col._uniqueIndexes) !== null && _a !== void 0 ? _a : []) {
                 if (!isEqual(uniq, fields)) {
                     newIndexes.push(uniq);
@@ -351,20 +363,36 @@ export default class NeDbDatabase extends AbstractMutexer {
                     found = true;
                 }
             }
-            if (!found) {
-                throw new SpruceError({ code: 'INDEX_NOT_FOUND', missingIndex: fields });
+            if (found) {
+                col._uniqueIndexes = newIndexes;
+                return;
             }
-            col._uniqueIndexes = newIndexes;
+            else {
+                newIndexes = [];
+                for (const index of (_b = col._indexes) !== null && _b !== void 0 ? _b : []) {
+                    if (!isEqual(index, fields)) {
+                        newIndexes.push(index);
+                    }
+                    else {
+                        found = true;
+                    }
+                }
+                if (found) {
+                    col._indexes = newIndexes;
+                    return;
+                }
+            }
+            throw new SpruceError({ code: 'INDEX_NOT_FOUND', missingIndex: fields });
         });
     }
-    assertUniqueIndexDoesNotExist(currentIndexes, fields) {
-        if (this.doesUniqueIndexExist(currentIndexes, fields)) {
+    assertIndexDoesNotExist(currentIndexes, fields) {
+        if (this.doesIndexExist(currentIndexes, fields)) {
             throw new SpruceError({ code: 'INDEX_EXISTS', index: fields });
         }
     }
-    doesUniqueIndexExist(currentIndexes, fields) {
-        for (const uniq of currentIndexes !== null && currentIndexes !== void 0 ? currentIndexes : []) {
-            if (isEqual(uniq, fields)) {
+    doesIndexExist(currentIndexes, fields) {
+        for (const index of currentIndexes !== null && currentIndexes !== void 0 ? currentIndexes : []) {
+            if (isEqual(index, fields)) {
                 return true;
             }
         }
@@ -377,7 +405,7 @@ export default class NeDbDatabase extends AbstractMutexer {
                 col._uniqueIndexes = [];
             }
             yield this.randomDelay();
-            this.assertUniqueIndexDoesNotExist(col._uniqueIndexes, fields);
+            this.assertIndexDoesNotExist(col._uniqueIndexes, fields);
             if (col._uniqueIndexes) {
                 const tempUniqueIndexes = [...col._uniqueIndexes];
                 tempUniqueIndexes.push(fields);
@@ -403,13 +431,24 @@ export default class NeDbDatabase extends AbstractMutexer {
             col._uniqueIndexes.push(fields);
         });
     }
+    createIndex(collection, fields) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const col = this.loadCollection(collection);
+            if (!col._indexes) {
+                col._indexes = [];
+            }
+            yield this.randomDelay();
+            this.assertIndexDoesNotExist(col._indexes, fields);
+            col._indexes.push(fields);
+        });
+    }
     syncUniqueIndexes(collectionName, indexes) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const currentIndexes = yield this.getUniqueIndexes(collectionName);
             const extraIndexes = differenceWith(currentIndexes, indexes, isEqual);
             for (const index of indexes) {
-                if (!this.doesUniqueIndexExist(currentIndexes, index)) {
+                if (!this.doesIndexExist(currentIndexes, index)) {
                     try {
                         yield this.createUniqueIndex(collectionName, index);
                     }
@@ -425,4 +464,26 @@ export default class NeDbDatabase extends AbstractMutexer {
             }
         });
     }
+    syncIndexes(collectionName, indexes) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentIndexes = yield this.getIndexes(collectionName);
+            const extraIndexes = differenceWith(currentIndexes, indexes, isEqual);
+            for (const index of indexes) {
+                if (!this.doesIndexExist(currentIndexes, index)) {
+                    try {
+                        yield this.createIndex(collectionName, index);
+                    }
+                    catch (err) {
+                        if (((_a = err.options) === null || _a === void 0 ? void 0 : _a.code) !== 'INDEX_EXISTS') {
+                            throw err;
+                        }
+                    }
+                }
+            }
+            for (const extra of extraIndexes) {
+                yield this.dropIndex(collectionName, extra);
+            }
+        });
+    }
 }

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

@@ -1,9 +1,13 @@
 import { QueryOptions } from './query.types';
 export declare type UniqueIndex = string[];
+export declare type Index = string[];
 export interface Database {
+    [x: string]: any;
     syncUniqueIndexes(collectionName: string, indexes: UniqueIndex[]): 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[]>;
     isConnected(): boolean;
     generateId(): string;
     connect(): Promise<void>;
@@ -21,4 +25,5 @@ export interface Database {
     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>;
 }

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

@@ -1,9 +1,13 @@
 import { QueryOptions } from './query.types';
 export declare type UniqueIndex = string[];
+export declare type Index = string[];
 export interface Database {
+    [x: string]: any;
     syncUniqueIndexes(collectionName: string, indexes: UniqueIndex[]): 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[]>;
     isConnected(): boolean;
     generateId(): string;
     connect(): Promise<void>;
@@ -21,4 +25,5 @@ export interface Database {
     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>;
 }

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "8.0.124",
+  "version": "8.1.1",
   "files": [
     "build/**/*",
     "!build/__tests__",
@@ -72,22 +72,22 @@
   },
   "dependencies": {
     "@sprucelabs/error": "^5.0.402",
-    "@sprucelabs/schema": "^26.0.115",
-    "@sprucelabs/spruce-core-schemas": "^23.0.118",
-    "@sprucelabs/spruce-skill-utils": "^24.1.66",
+    "@sprucelabs/schema": "^26.0.118",
+    "@sprucelabs/spruce-core-schemas": "^23.0.121",
+    "@sprucelabs/spruce-skill-utils": "^24.1.68",
     "globby": "^11.0.4",
     "lodash": "^4.17.21",
     "mongodb": "^4.1.0",
     "nedb": "^1.8.0"
   },
   "devDependencies": {
-    "@sprucelabs/esm-postbuild": "^1.0.383",
+    "@sprucelabs/esm-postbuild": "^1.0.386",
     "@sprucelabs/jest-json-reporter": "^6.0.328",
     "@sprucelabs/jest-sheets-reporter": "^1.3.12",
     "@sprucelabs/resolve-path-aliases": "^1.0.260",
     "@sprucelabs/semantic-release": "^4.0.8",
     "@sprucelabs/test": "^7.7.281",
-    "@sprucelabs/test-utils": "^3.0.453",
+    "@sprucelabs/test-utils": "^3.0.456",
     "@types/lodash": "^4.14.178",
     "@types/nedb": "^1.8.12",
     "@types/node": "17.0.5",