@sprucelabs/data-stores 28.1.334 → 28.1.335

package/build/tests/databaseAssertUtil.js

@@ -93,6 +93,7 @@ const databaseAssertUtil = {
             'assertSyncIndexesHandlesRaceConditions',
             'assertSyncIndexesDoesNotRemoveExisting',
             'assertDuplicateFieldsWithMultipleUniqueIndexesWorkAsExpected',
+            'assertCanSyncIndexesWithoutPartialThenAgainWithProperlyUpdates',
         ];
         const db = await connectToDabatase(connect);
         await db.dropDatabase();
@@ -111,12 +112,11 @@ const databaseAssertUtil = {
             }
         }
     },
-    async _getFilteredIndexes(db) {
-        return this._filterIdIndex(await db.getIndexes(this.collectionName));
+    async _getIndexesWith_IdFilteredOut(db) {
+        return this._filterOut_Id(await db.getIndexes(this.collectionName));
     },
-    _filterIdIndex(allIndexes) {
-        //@ts-ignore
-        return allIndexes.filter((i) => i[0] !== '_id');
+    _filterOut_Id(allIndexes) {
+        return allIndexes.filter((i) => i.fields[0] !== '_id');
     },
     async _assertUpdateUpdatedRightNumberOfRecords(db, search, updates, expectedUpdateCount) {
         const updatedCount = await db.update(this.collectionName, search, updates);
@@ -224,20 +224,20 @@ const databaseAssertUtil = {
         await db.createUniqueIndex(this.collectionName, ['uniqueField']);
         let indexes = (await db.getUniqueIndexes(this.collectionName));
         test_utils_1.assert.isLength(indexes, 1, 'getUniqueIndexes() did not return the unique index I tried to create!');
-        test_utils_1.assert.isLength(indexes[0], 1, 'getUniqueIndexes() needs to return an array of arrays. Each item in the array should be an array of fields that make up the unique index.');
-        test_utils_1.assert.isEqual(indexes[0][0].toLowerCase(), 'uniqueField'.toLowerCase(), 'getUniqueIndexes() did not add the expected field to the first unique index.');
+        test_utils_1.assert.isLength(indexes[0].fields, 1, 'getUniqueIndexes() needs to return an array of IndexWithFilters. Each item in the array should be an array of fields that make up the unique index.');
+        test_utils_1.assert.isEqual(indexes[0].fields[0].toLowerCase(), 'uniqueField'.toLowerCase(), 'getUniqueIndexes() did not add the expected field to the first unique index.');
         await db.createUniqueIndex(this.collectionName, ['uniqueField2']);
-        indexes = (await db.getUniqueIndexes(this.collectionName));
+        indexes = await db.getUniqueIndexes(this.collectionName);
         test_utils_1.assert.isLength(indexes, 2);
-        test_utils_1.assert.isEqual(indexes[1][0].toLowerCase(), 'uniqueField2'.toLowerCase());
+        test_utils_1.assert.isEqual(indexes[1].fields[0].toLowerCase(), 'uniqueField2'.toLowerCase());
         await db.createUniqueIndex(this.collectionName, [
             'uniqueField3',
             'uniqueField4',
         ]);
-        indexes = (await db.getUniqueIndexes(this.collectionName));
+        indexes = await db.getUniqueIndexes(this.collectionName);
         test_utils_1.assert.isLength(indexes, 3);
-        test_utils_1.assert.isEqual(indexes[2][0].toLowerCase(), 'uniqueField3'.toLowerCase());
-        test_utils_1.assert.isEqual(indexes[2][1].toLowerCase(), 'uniqueField4'.toLowerCase());
+        test_utils_1.assert.isEqual(indexes[2].fields[0].toLowerCase(), 'uniqueField3'.toLowerCase());
+        test_utils_1.assert.isEqual(indexes[2].fields[1].toLowerCase(), 'uniqueField4'.toLowerCase());
         await this.shutdown(db);
     },
     async assertHasNoUniqueIndexToStart(connect) {
@@ -681,12 +681,12 @@ const databaseAssertUtil = {
             ['someField'],
             ['otherField', 'otherField2'],
         ]);
-        let indexes = (await db.getUniqueIndexes(this.collectionName));
+        let indexes = await db.getUniqueIndexes(this.collectionName);
         test_utils_1.assert.isLength(indexes, 3, 'syncUniqueIndexes() should have created 3 indexes.');
         await db.syncUniqueIndexes(this.collectionName, [['uniqueField']]);
-        indexes = (await db.getUniqueIndexes(this.collectionName));
+        indexes = await db.getUniqueIndexes(this.collectionName);
         test_utils_1.assert.isLength(indexes, 1);
-        test_utils_1.assert.isEqual(indexes[0][0].toLowerCase(), 'uniquefield');
+        test_utils_1.assert.isEqual(indexes[0].fields[0].toLowerCase(), 'uniquefield');
         await db.syncUniqueIndexes(this.collectionName, [
             {
                 fields: ['uniqueField'],
@@ -703,7 +703,7 @@ const databaseAssertUtil = {
                 filter: { isActive: true },
             },
         ]);
-        indexes = (await db.getUniqueIndexes(this.collectionName));
+        indexes = await db.getUniqueIndexes(this.collectionName);
         test_utils_1.assert.isLength(indexes, 2, `Syncing unique indexs with filter is not removing extra indexes.`);
         await this.shutdown(db);
     },
@@ -728,7 +728,7 @@ const databaseAssertUtil = {
         test_utils_1.assert.isLength(indexes, 1, 'There should be 1 index after syncing.');
         await db.syncUniqueIndexes(this.collectionName, [['someField']]);
         indexes = await db.getUniqueIndexes(this.collectionName);
-        test_utils_1.assert.isLength(indexes, 1, 'There should now be 2 indexes after syncing.');
+        test_utils_1.assert.isLength(indexes, 1, 'syncUniqueIndexes() should have removed the index that was set before it that was different.');
         await db.syncUniqueIndexes(this.collectionName, [
             ['uniqueField'],
             ['someField'],
@@ -743,11 +743,11 @@ const databaseAssertUtil = {
             'someField',
             'someOtherField',
         ]);
-        const err = await test_utils_1.assert.doesThrowAsync(() => db.dropIndex(this.collectionName, ['uniqueField', 'someOtherField']));
+        const err = await test_utils_1.assert.doesThrowAsync(() => db.dropIndex(this.collectionName, ['someOtherField', 'uniqueField']));
         lowerCaseMissingIndexValues(err);
         test_utils_2.errorAssert.assertError(err, 'INDEX_NOT_FOUND', {
             collectionName: this.collectionName,
-            missingIndex: ['uniquefield', 'someotherfield'],
+            missingIndex: ['someotherfield', 'uniquefield'],
         });
         await this.shutdown(db);
     },
@@ -810,6 +810,7 @@ const databaseAssertUtil = {
     async assertCantCreateUniqueIndexTwice(connect) {
         const db = await connectToDabatase(connect);
         await assertCantCreateUniqueIndexTwice(db, this.collectionName, ['uniqueField'], 1);
+        await assertCantCreateUniqueIndexTwice(db, this.collectionName, ['uniqueField', 'anotherField'], 2);
         await this.shutdown(db);
     },
     async assertSyncingUniqueIndexesIsRaceProof(connect) {
@@ -934,8 +935,8 @@ const databaseAssertUtil = {
         }));
         test_utils_2.errorAssert.assertError(err, 'DUPLICATE_RECORD', {
             collectionName: this.collectionName,
-            duplicateFields: ['target.organizationId', 'slug'],
-            duplicateValues: ['go!', 'a slug'],
+            duplicateFields: ['slug', 'target.organizationId'],
+            duplicateValues: ['a slug', 'go!'],
             action: 'create',
         });
         await db.upsertOne(this.collectionName, {
@@ -1377,7 +1378,7 @@ const databaseAssertUtil = {
             uniqueField: 'test',
             slug: null,
             someField3: 'test',
-        }), undefined, `Creating a duplicate record with should throw an error.`);
+        }), undefined, `Creating a duplicate record with should throw an error with a uniqueIndex with filter. Make sure syncUniqueIndexes() is actually created the index honoring the filter.`);
         await db.createOne(this.collectionName, {
             name: (0, generateId_1.default)(),
             slug: '555-000-0000',
@@ -1470,6 +1471,54 @@ const databaseAssertUtil = {
         });
         await this.shutdown(db);
     },
+    async assertCanSyncIndexesWithoutPartialThenAgainWithProperlyUpdates(connect) {
+        const db = await connectToDabatase(connect);
+        await db.syncUniqueIndexes(this.collectionName, [
+            ['uniqueField', 'someField3'],
+        ]);
+        await db.syncUniqueIndexes(this.collectionName, [
+            {
+                fields: ['uniqueField', 'someField3'],
+                filter: {
+                    uniqueField: { $type: 'string' },
+                },
+            },
+        ]);
+        await db.createOne(this.collectionName, {
+            name: (0, generateId_1.default)(),
+            uniqueField: 1,
+            slug: null,
+            someField3: 'test',
+        });
+        try {
+            await db.createOne(this.collectionName, {
+                name: (0, generateId_1.default)(),
+                uniqueField: 1,
+                slug: null,
+                someField3: 'test',
+            });
+        }
+        catch (_a) {
+            test_utils_1.assert.fail(`An error was thrown trying to create a record that should not have matched on a unique index with a filter. Make sure your database adapter is properly syncing indexes. In this case, it should remove an index without a filter with an index with a filter.`);
+        }
+        await db.createOne(this.collectionName, {
+            name: (0, generateId_1.default)(),
+            uniqueField: 'hey there',
+            slug: null,
+            someField3: 'how are you?',
+        });
+        try {
+            await test_utils_1.assert.doesThrowAsync(() => db.createOne(this.collectionName, {
+                name: (0, generateId_1.default)(),
+                uniqueField: 'hey there',
+                slug: null,
+                someField3: 'how are you?',
+            }));
+        }
+        catch (_b) {
+            test_utils_1.assert.fail(`A record was created that should have been blocked by a unique index with a filter`);
+        }
+    },
     async assertSyncIndexesRemovesExtraIndexes(connect) {
         const db = await connectToDabatase(connect);
         await db.syncIndexes(this.collectionName, [
@@ -1477,26 +1526,27 @@ const databaseAssertUtil = {
             ['someField'],
             ['otherField', 'otherField2'],
         ]);
-        let indexes = await this._getFilteredIndexes(db);
+        let indexes = await this._getIndexesWith_IdFilteredOut(db);
         test_utils_1.assert.isLength(indexes, 3);
         await db.syncIndexes(this.collectionName, [['name']]);
-        indexes = await this._getFilteredIndexes(db);
+        indexes = await this._getIndexesWith_IdFilteredOut(db);
         test_utils_1.assert.isLength(indexes, 1);
-        test_utils_1.assert.isEqual(indexes[0][0], 'name');
+        test_utils_1.assert.isEqual(indexes[0].fields[0], 'name');
         await this.shutdown(db);
     },
     async assertSyncIndexesSkipsExisting(connect) {
         const db = await connectToDabatase(connect);
         await db.syncIndexes(this.collectionName, [['name']]);
-        let indexes = await this._getFilteredIndexes(db);
+        let indexes = await this._getIndexesWith_IdFilteredOut(db);
         test_utils_1.assert.isLength(indexes, 1);
+        test_utils_1.assert.isLength(indexes[0].fields, 1);
         await db.syncIndexes(this.collectionName, [
             ['name'],
             ['someField'],
             ['otherField', 'otherField2'],
         ]);
-        indexes = await this._getFilteredIndexes(db);
-        test_utils_1.assert.isLength(indexes, 3);
+        indexes = await this._getIndexesWith_IdFilteredOut(db);
+        test_utils_1.assert.isLength(indexes, 3, 'There should be 3 indexes after the last sync. 1 would have been skipped, the other 2 should have been added');
         await this.shutdown(db);
     },
     async assertCantDropCompoundIndexThatDoesNotExist(connect) {
@@ -1508,7 +1558,7 @@ const databaseAssertUtil = {
         const err = await test_utils_1.assert.doesThrowAsync(() => db.dropIndex(this.collectionName, ['uniqueField', 'someOtherField']));
         test_utils_2.errorAssert.assertError(err, 'INDEX_NOT_FOUND', {
             collectionName: this.collectionName,
-            missingIndex: ['uniqueField', 'someOtherField'],
+            missingIndex: ['someOtherField', 'uniqueField'],
         });
         await this.shutdown(db);
     },
@@ -1516,25 +1566,25 @@ const databaseAssertUtil = {
         const db = await connectToDabatase(connect);
         await db.createIndex(this.collectionName, ['someField', 'otherField']);
         await db.dropIndex(this.collectionName, ['someField', 'otherField']);
-        let indexes = await this._getFilteredIndexes(db);
-        test_utils_1.assert.isLength(indexes, 0);
+        let indexes = await this._getIndexesWith_IdFilteredOut(db);
+        test_utils_1.assert.isLength(indexes, 0, `The one index I created should have been dropped`);
         await db.createIndex(this.collectionName, ['someField', 'someField2']);
         await db.createIndex(this.collectionName, ['someField', 'someField3']);
         await db.dropIndex(this.collectionName, ['someField', 'someField3']);
-        indexes = await this._getFilteredIndexes(db);
-        test_utils_1.assert.isLength(indexes, 1);
+        indexes = await this._getIndexesWith_IdFilteredOut(db);
+        test_utils_1.assert.isLength(indexes, 1, `I created 2 compound indexes, then dropped one, and expected 1 to remain.`);
         await this.shutdown(db);
     },
     async assertCanDropIndex(connect) {
         const db = await connectToDabatase(connect);
         await db.createIndex(this.collectionName, ['someField']);
         await db.dropIndex(this.collectionName, ['someField']);
-        let indexes = await this._getFilteredIndexes(db);
+        let indexes = await this._getIndexesWith_IdFilteredOut(db);
         test_utils_1.assert.isLength(indexes, 0);
         await db.createIndex(this.collectionName, ['someField2']);
         await db.createIndex(this.collectionName, ['someField3']);
         await db.dropIndex(this.collectionName, ['someField3']);
-        indexes = await this._getFilteredIndexes(db);
+        indexes = await this._getIndexesWith_IdFilteredOut(db);
         test_utils_1.assert.isLength(indexes, 1);
         await this.shutdown(db);
     },
@@ -1559,7 +1609,7 @@ const databaseAssertUtil = {
     async assertCantCreateSameIndexTwice(connect) {
         const db = await connectToDabatase(connect);
         await db.createIndex(this.collectionName, ['name']);
-        let indexes = await this._getFilteredIndexes(db);
+        let indexes = await this._getIndexesWith_IdFilteredOut(db);
         test_utils_1.assert.isLength(indexes, 1);
         const err = await test_utils_1.assert.doesThrowAsync(() => db.createIndex(this.collectionName, ['name']));
         test_utils_2.errorAssert.assertError(err, 'INDEX_EXISTS');
@@ -1568,23 +1618,23 @@ const databaseAssertUtil = {
     async assertCanCreateIndex(connect) {
         const db = await connectToDabatase(connect);
         await db.createIndex(this.collectionName, ['uniqueField']);
-        let indexes = await this._getFilteredIndexes(db);
+        let indexes = await this._getIndexesWith_IdFilteredOut(db);
         test_utils_1.assert.isArray(indexes, 'getIndexes() should return an array!');
         test_utils_1.assert.isLength(indexes, 1, 'getIndexes() should return the one index that was created!');
-        test_utils_1.assert.isLength(indexes[0], 1, 'getIndexes() should return an array of arrays! It should be returing the first index I created!');
-        test_utils_1.assert.isEqual(indexes[0][0].toLowerCase(), 'uniqueField'.toLowerCase());
+        test_utils_1.assert.isLength(indexes[0].fields, 1, 'getIndexes() should return an array of IndexWithFilter! It should be returing the first index I created with the first field!');
+        test_utils_1.assert.isEqual(indexes[0].fields[0].toLowerCase(), 'uniqueField'.toLowerCase());
         await db.createIndex(this.collectionName, ['uniqueField2']);
-        indexes = await this._getFilteredIndexes(db);
+        indexes = await this._getIndexesWith_IdFilteredOut(db);
         test_utils_1.assert.isLength(indexes, 2);
-        test_utils_1.assert.isEqual(indexes[1][0].toLowerCase(), 'uniqueField2'.toLowerCase());
+        test_utils_1.assert.isEqual(indexes[1].fields[0].toLowerCase(), 'uniqueField2'.toLowerCase());
         await db.createIndex(this.collectionName, [
             'uniqueField3',
             'uniqueField4',
         ]);
-        indexes = await this._getFilteredIndexes(db);
+        indexes = await this._getIndexesWith_IdFilteredOut(db);
         test_utils_1.assert.isLength(indexes, 3);
-        test_utils_1.assert.isEqual(indexes[2][0].toLowerCase(), 'uniqueField3'.toLowerCase());
-        test_utils_1.assert.isEqual(indexes[2][1].toLowerCase(), 'uniqueField4'.toLowerCase());
+        test_utils_1.assert.isEqual(indexes[2].fields[0].toLowerCase(), 'uniqueField3'.toLowerCase());
+        test_utils_1.assert.isEqual(indexes[2].fields[1].toLowerCase(), 'uniqueField4'.toLowerCase());
         await this.shutdown(db);
     },
     async assertHasNoIndexToStart(connect) {
@@ -1729,9 +1779,9 @@ const databaseAssertUtil = {
     async _assertCanCreateMultiFieldIndex(connect, fields) {
         const db = await connectToDabatase(connect);
         await db.createIndex(this.collectionName, fields);
-        const indexes = await this._getFilteredIndexes(db);
+        const indexes = await this._getIndexesWith_IdFilteredOut(db);
         test_utils_1.assert.isLength(indexes, 1, `getIndexes() should return the index it created. I expected 1 but got ${indexes.length}. Also, make sure you clear the indexes when resetting the database!`);
-        test_utils_1.assert.isEqualDeep(indexes[0].map((i) => i.toLowerCase()), fields.map((f) => f.toLowerCase()));
+        test_utils_1.assert.isEqualDeep(indexes[0].fields.map((i) => i.toLowerCase()), fields.map((f) => f.toLowerCase()));
         await this.shutdown(db);
     },
     assertHasLowerCaseToCamelCaseMappingEnabled(store) {
@@ -1744,11 +1794,11 @@ exports.default = databaseAssertUtil;
 async function assertCantCreateUniqueIndexTwice(db, collectionName, fields, expectedTotalUniqueIndexes) {
     await db.createUniqueIndex(collectionName, fields);
     let indexes = await db.getUniqueIndexes(collectionName);
-    test_utils_1.assert.isLength(indexes, expectedTotalUniqueIndexes, 'getUniqueIndexes() should return total unique indexs');
-    const err = await test_utils_1.assert.doesThrowAsync(() => db.createUniqueIndex(collectionName, ['uniqueField']), undefined, 'createUniqueIndex() should throw a DataStoreError({code: "INDEX_EXISTS"}) error.');
+    test_utils_1.assert.isLength(indexes, expectedTotalUniqueIndexes, 'getUniqueIndexes() should return all unique indexes');
+    const err = await test_utils_1.assert.doesThrowAsync(() => db.createUniqueIndex(collectionName, fields), undefined, 'createUniqueIndex() should throw a DataStoreError({code: "INDEX_EXISTS"}) error.');
     test_utils_2.errorAssert.assertError(err, 'INDEX_EXISTS', {
         collectionName,
-        index: ['uniqueField'],
+        index: fields,
     });
 }
 function lowerCaseErrorDuplicateFields(err) {

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

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

package/package.json

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

package/build/databases/normalizeIndex.d.ts

@@ -1,5 +0,0 @@
-import { IndexWithFilter } from '../types/database.types';
-export default function normalizeIndex(index: string[] | IndexWithFilter): {
-    fields: string[];
-    filter: Record<string, any> | undefined;
-};

package/build/databases/normalizeIndex.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = normalizeIndex;
-function normalizeIndex(index) {
-    const fields = Array.isArray(index) ? index : index.fields;
-    const filter = Array.isArray(index) ? undefined : index.filter;
-    return { fields, filter };
-}

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

@@ -1,5 +0,0 @@
-import { IndexWithFilter } from '../types/database.types';
-export default function normalizeIndex(index: string[] | IndexWithFilter): {
-    fields: string[];
-    filter: Record<string, any> | undefined;
-};

package/build/esm/databases/normalizeIndex.js

@@ -1,5 +0,0 @@
-export default function normalizeIndex(index) {
-    const fields = Array.isArray(index) ? index : index.fields;
-    const filter = Array.isArray(index) ? undefined : index.filter;
-    return { fields, filter };
-}