@sprucelabs/data-stores 28.1.333 → 28.1.335

package/build/esm/databases/MongoDatabase.js

@@ -19,13 +19,11 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 import { buildLog } from '@sprucelabs/spruce-skill-utils';
-import differenceWith from 'lodash/differenceWith.js';
-import isEqual from 'lodash/isEqual.js';
 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 normalizeIndex from './normalizeIndex.js';
+import { doesIndexesInclude, generateIndexName, normalizeIndex, pluckMissingIndexes, } from './database.utilities.js';
 export const MONGO_TEST_URI = 'mongodb://localhost:27017';
 export default class MongoDatabase {
     constructor(url, options) {
@@ -250,10 +248,11 @@ export default class MongoDatabase {
     listIndexes(collection) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                return yield this.assertDbWhileAttempingTo('get indexes.', collection)
+                const indexes = yield this.assertDbWhileAttempingTo('get indexes.', collection)
                     .collection(collection)
                     .listIndexes()
                     .toArray();
+                return indexes.filter((index) => index.name !== '_id_');
             }
             catch (err) {
                 return [];
@@ -263,9 +262,10 @@ 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));
             let found = false;
             for (const thisIndex of indexes) {
-                if (isEqual(Object.keys(thisIndex.key), index)) {
+                if (thisIndex.name === name) {
                     yield this.assertDbWhileAttempingTo('drop a index.', collection)
                         .collection(collection)
                         .dropIndex(thisIndex.name);
@@ -288,7 +288,10 @@ export default 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;
@@ -303,12 +306,18 @@ export default class MongoDatabase {
             try {
                 const indexes = yield 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;
@@ -318,24 +327,26 @@ export default class MongoDatabase {
             }
         });
     }
-    createIndex(collection, fields) {
+    createIndex(collection, index) {
         return __awaiter(this, void 0, void 0, function* () {
             const currentIndexes = yield this.getIndexes(collection);
-            yield 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 {
                 yield 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({
                         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 {
@@ -344,33 +355,32 @@ export default class MongoDatabase {
             }
         });
     }
-    assertIndexDoesNotExist(currentIndexes, fields, collectionName) {
-        if (this.doesIndexExist(currentIndexes, fields)) {
+    assertIndexDoesNotExist(currentIndexes, index, collectionName) {
+        if (this.doesInclude(currentIndexes, index)) {
             throw new SpruceError({
                 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 (isEqual(normalizedFields, fields)) {
-                return true;
-            }
-        }
-        return false;
+    doesInclude(haystack, needle) {
+        return doesIndexesInclude(haystack, needle);
     }
     syncIndexes(collectionName, indexes) {
         return __awaiter(this, void 0, void 0, function* () {
+            yield this._syncIndexes(collectionName, indexes, 'createIndex');
+        });
+    }
+    _syncIndexes(collectionName_1, indexes_1, func_1) {
+        return __awaiter(this, arguments, void 0, function* (collectionName, indexes, func, shouldIncludeUnique = false) {
             var _a;
-            const currentIndexes = yield this.getIndexes(collectionName);
-            const extraIndexes = differenceWith(currentIndexes, indexes, isEqual).filter((i) => !(i.length === 1 && i[0] === '_id'));
+            const currentIndexes = yield this.getIndexes(collectionName, shouldIncludeUnique);
+            const indexesToDelete = pluckMissingIndexes(currentIndexes, indexes);
             for (const index of indexes) {
-                if (!this.doesIndexExist(currentIndexes, index)) {
+                if (!this.doesInclude(currentIndexes, this.normalizeIndex(index))) {
                     try {
-                        yield this.createIndex(collectionName, index);
+                        yield this[func](collectionName, index);
                     }
                     catch (err) {
                         if (((_a = err.options) === null || _a === void 0 ? void 0 : _a.code) !== 'INDEX_EXISTS') {
@@ -379,7 +389,7 @@ export default class MongoDatabase {
                     }
                 }
             }
-            for (const extra of extraIndexes) {
+            for (const extra of indexesToDelete) {
                 yield this.dropIndex(collectionName, extra);
             }
         });
@@ -387,16 +397,19 @@ export default class MongoDatabase {
     createUniqueIndex(collection, index) {
         return __awaiter(this, void 0, void 0, function* () {
             const currentIndexes = yield 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;
                 }
                 yield this.assertDbWhileAttempingTo('create a unique index.', collection)
                     .collection(collection)
@@ -406,7 +419,8 @@ export default class MongoDatabase {
                 if ((err === null || err === void 0 ? void 0 : err.code) === 11000) {
                     throw new SpruceError({
                         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 {
@@ -415,36 +429,16 @@ export default class MongoDatabase {
             }
         });
     }
+    generateIndexName(indexWithFilter) {
+        return generateIndexName(this.normalizeIndex(indexWithFilter));
+    }
     normalizeIndex(index) {
         const { fields, filter } = normalizeIndex(index);
         return { fields, filter };
     }
     syncUniqueIndexes(collectionName, indexes) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const currentIndexes = yield 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 {
-                        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);
-            }
+            yield this._syncIndexes(collectionName, indexes, 'createUniqueIndex', true);
         });
     }
     update(collection, query, updates) {

package/build/esm/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/esm/databases/NeDbDatabase.js

@@ -20,7 +20,6 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 var _a;
 import dotenv from 'dotenv';
-import differenceWith from 'lodash/differenceWith.js';
 import get from 'lodash/get.js';
 import isEqual from 'lodash/isEqual.js';
 import isObject from 'lodash/isObject.js';
@@ -30,7 +29,7 @@ import SpruceError from '../errors/SpruceError.js';
 import AbstractMutexer from '../mutexers/AbstractMutexer.js';
 import generateId from '../utilities/generateId.js';
 import mongoUtil from '../utilities/mongo.utility.js';
-import normalizeIndex from './normalizeIndex.js';
+import { doesIndexesInclude, normalizeIndex, pluckMissingIndexes, } from './database.utilities.js';
 dotenv.config();
 export default class NeDbDatabase extends AbstractMutexer {
     constructor() {
@@ -394,7 +393,7 @@ export default class NeDbDatabase extends AbstractMutexer {
             let found = false;
             let newIndexes = [];
             for (const uniq of (_a = col._uniqueIndexes) !== null && _a !== void 0 ? _a : []) {
-                if (!isEqual(uniq, fields)) {
+                if (!isEqual(uniq.fields, fields)) {
                     newIndexes.push(uniq);
                 }
                 else {
@@ -408,7 +407,7 @@ export default class NeDbDatabase extends AbstractMutexer {
             else {
                 newIndexes = [];
                 for (const index of (_b = col._indexes) !== null && _b !== void 0 ? _b : []) {
-                    if (!isEqual(index, fields)) {
+                    if (!isEqual(index.fields, fields)) {
                         newIndexes.push(index);
                     }
                     else {
@@ -427,22 +426,17 @@ export default class NeDbDatabase extends AbstractMutexer {
             });
         });
     }
-    assertIndexDoesNotExist(currentIndexes, fields, collectionName) {
-        if (this.doesIndexExist(currentIndexes, fields)) {
+    assertIndexDoesNotExist(currentIndexes, index, collectionName) {
+        if (this.doesInclude(currentIndexes, index)) {
             throw new SpruceError({
                 code: 'INDEX_EXISTS',
-                index: fields,
+                index: index.fields,
                 collectionName,
             });
         }
     }
-    doesIndexExist(currentIndexes, index) {
-        for (const existing of currentIndexes !== null && currentIndexes !== void 0 ? currentIndexes : []) {
-            if (isEqual(existing, index)) {
-                return true;
-            }
-        }
-        return false;
+    doesInclude(haystack, needle) {
+        return doesIndexesInclude(haystack, needle);
     }
     createUniqueIndex(collection, index) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -450,12 +444,12 @@ export default class NeDbDatabase extends AbstractMutexer {
             if (!col._uniqueIndexes) {
                 col._uniqueIndexes = [];
             }
-            const { fields, filter } = normalizeIndex(index);
+            const indexWithFilter = normalizeIndex(index);
             yield 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 = (yield this.find(collection)) || [];
                 for (const index of tempUniqueIndexes) {
                     const { fields: uniqueFields } = normalizeIndex(index);
@@ -476,7 +470,7 @@ export default class NeDbDatabase extends AbstractMutexer {
                     }
                 }
             }
-            col._uniqueIndexes.push(index);
+            col._uniqueIndexes.push(indexWithFilter);
         });
     }
     createIndex(collection, fields) {
@@ -486,22 +480,21 @@ export default class NeDbDatabase extends AbstractMutexer {
                 col._indexes = [];
             }
             yield 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 } = normalizeIndex(index);
+        return { fields, filter };
+    }
     syncUniqueIndexes(collectionName, indexes) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             const currentIndexes = yield this.getUniqueIndexes(collectionName);
-            const toDelete = [];
-            for (const index of currentIndexes) {
-                if (!this.doesIndexExist(indexes, index)) {
-                    toDelete.push(index);
-                }
-            }
+            const toDelete = pluckMissingIndexes(currentIndexes, indexes);
             for (const index of indexes) {
-                if (!this.doesIndexExist(currentIndexes, index)) {
+                if (!this.doesInclude(currentIndexes, index)) {
                     try {
                         yield this.createUniqueIndex(collectionName, index);
                     }
@@ -521,9 +514,9 @@ export default class NeDbDatabase extends AbstractMutexer {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             const currentIndexes = yield this.getIndexes(collectionName);
-            const extraIndexes = differenceWith(currentIndexes, indexes, isEqual);
+            const extraIndexes = pluckMissingIndexes(currentIndexes, indexes);
             for (const index of indexes) {
-                if (!this.doesIndexExist(currentIndexes, index)) {
+                if (!this.doesInclude(currentIndexes, index)) {
                     try {
                         yield this.createIndex(collectionName, index);
                     }

package/build/esm/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/esm/databases/database.utilities.js

@@ -0,0 +1,30 @@
+import differenceWith from 'lodash/differenceWith.js';
+export function doesIndexesInclude(haystack, needle) {
+    for (const index of haystack !== null && haystack !== void 0 ? haystack : []) {
+        if (areIndexesEqual(index, needle)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function areIndexesEqual(left, right) {
+    const name1 = generateIndexName(normalizeIndex(left));
+    const name2 = generateIndexName(normalizeIndex(right));
+    return name1 === name2;
+}
+export function generateIndexName(indexWithFilter) {
+    let name = indexWithFilter.fields.join('_');
+    if (indexWithFilter.filter) {
+        name += '_filtered';
+    }
+    return name;
+}
+export function normalizeIndex(index) {
+    const fields = Array.isArray(index) ? index : index.fields;
+    const filter = Array.isArray(index) ? undefined : index.filter;
+    fields.sort();
+    return { fields, filter };
+}
+export function pluckMissingIndexes(left, right) {
+    return differenceWith(left, right, areIndexesEqual);
+}

package/build/esm/index.d.ts

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

package/build/esm/index.js

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

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

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