@sprucelabs/data-stores 28.1.349 → 28.3.0

package/build/databases/MongoDatabase.d.ts

@@ -28,10 +28,8 @@ export default class MongoDatabase implements Database {
     private listIndexes;
     dropIndex(collection: string, index: Index): Promise<void>;
     getUniqueIndexes(collection: string): Promise<IndexWithFilter[]>;
-    getIndexes(collection: string, shouldIncludeUnique?: boolean): Promise<IndexWithFilter[] | {
-        fields: string[];
-        filter: any;
-    }[]>;
+    getIndexes(collection: string, shouldIncludeUnique?: boolean): Promise<IndexWithFilter[]>;
+    private mongoIndexToIndexWithFilter;
     createIndex(collection: string, index: Index): Promise<void>;
     private assertIndexDoesNotExist;
     private doesInclude;

package/build/databases/MongoDatabase.js

@@ -276,18 +276,12 @@ class MongoDatabase {
         try {
             const indexes = await this.listIndexes(collection);
             if (shouldIncludeUnique) {
-                return indexes.map((index) => ({
-                    fields: Object.keys(index.key),
-                    filter: index.partialFilterExpression,
-                }));
+                return indexes.map((index) => this.mongoIndexToIndexWithFilter(index));
             }
             const nonUniqueIndexes = [];
             for (const index of indexes) {
                 if (!index.unique) {
-                    nonUniqueIndexes.push({
-                        fields: Object.keys(index.key),
-                        filter: undefined,
-                    });
+                    nonUniqueIndexes.push(this.mongoIndexToIndexWithFilter(index));
                 }
             }
             return nonUniqueIndexes;
@@ -296,6 +290,13 @@ class MongoDatabase {
             return [];
         }
     }
+    mongoIndexToIndexWithFilter(index) {
+        return {
+            fields: Object.keys(index.key),
+            filter: index.partialFilterExpression,
+            name: index.name,
+        };
+    }
     async createIndex(collection, index) {
         const currentIndexes = await this.getIndexes(collection);
         this.assertIndexDoesNotExist(currentIndexes, index, collection);
@@ -394,8 +395,7 @@ class MongoDatabase {
         return (0, database_utilities_1.generateIndexName)(this.normalizeIndex(indexWithFilter));
     }
     normalizeIndex(index) {
-        const { fields, filter } = (0, database_utilities_1.normalizeIndex)(index);
-        return { fields, filter };
+        return (0, database_utilities_1.normalizeIndex)(index);
     }
     async syncUniqueIndexes(collectionName, indexes) {
         await this._syncIndexes(collectionName, indexes, 'createUniqueIndex', true);

package/build/databases/database.utilities.js

@@ -23,6 +23,9 @@ function areIndexesEqual(left, right) {
     return name1 === name2;
 }
 function generateIndexName(indexWithFilter) {
+    if (indexWithFilter.name) {
+        return indexWithFilter.name;
+    }
     let name = indexWithFilter.fields.join('_');
     if (indexWithFilter.filter) {
         name += '_filtered';
@@ -30,10 +33,15 @@ function generateIndexName(indexWithFilter) {
     return name;
 }
 function normalizeIndex(index) {
+    var _a;
     const fields = Array.isArray(index) ? index : index.fields;
     const filter = Array.isArray(index) ? undefined : index.filter;
     fields.sort();
-    return { fields, filter };
+    return {
+        fields,
+        filter,
+        name: (_a = index.name) !== null && _a !== void 0 ? _a : undefined,
+    };
 }
 function pluckMissingIndexes(left, right) {
     return (0, differenceWith_1.default)(left, right, areIndexesEqual);

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

@@ -28,10 +28,8 @@ export default class MongoDatabase implements Database {
     private listIndexes;
     dropIndex(collection: string, index: Index): Promise<void>;
     getUniqueIndexes(collection: string): Promise<IndexWithFilter[]>;
-    getIndexes(collection: string, shouldIncludeUnique?: boolean): Promise<IndexWithFilter[] | {
-        fields: string[];
-        filter: any;
-    }[]>;
+    getIndexes(collection: string, shouldIncludeUnique?: boolean): Promise<IndexWithFilter[]>;
+    private mongoIndexToIndexWithFilter;
     createIndex(collection: string, index: Index): Promise<void>;
     private assertIndexDoesNotExist;
     private doesInclude;

package/build/esm/databases/MongoDatabase.js

@@ -306,18 +306,12 @@ export default class MongoDatabase {
             try {
                 const indexes = yield this.listIndexes(collection);
                 if (shouldIncludeUnique) {
-                    return indexes.map((index) => ({
-                        fields: Object.keys(index.key),
-                        filter: index.partialFilterExpression,
-                    }));
+                    return indexes.map((index) => this.mongoIndexToIndexWithFilter(index));
                 }
                 const nonUniqueIndexes = [];
                 for (const index of indexes) {
                     if (!index.unique) {
-                        nonUniqueIndexes.push({
-                            fields: Object.keys(index.key),
-                            filter: undefined,
-                        });
+                        nonUniqueIndexes.push(this.mongoIndexToIndexWithFilter(index));
                     }
                 }
                 return nonUniqueIndexes;
@@ -327,6 +321,13 @@ export default class MongoDatabase {
             }
         });
     }
+    mongoIndexToIndexWithFilter(index) {
+        return {
+            fields: Object.keys(index.key),
+            filter: index.partialFilterExpression,
+            name: index.name,
+        };
+    }
     createIndex(collection, index) {
         return __awaiter(this, void 0, void 0, function* () {
             const currentIndexes = yield this.getIndexes(collection);
@@ -433,8 +434,7 @@ export default class MongoDatabase {
         return generateIndexName(this.normalizeIndex(indexWithFilter));
     }
     normalizeIndex(index) {
-        const { fields, filter } = normalizeIndex(index);
-        return { fields, filter };
+        return normalizeIndex(index);
     }
     syncUniqueIndexes(collectionName, indexes) {
         return __awaiter(this, void 0, void 0, function* () {

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

@@ -13,6 +13,9 @@ export function areIndexesEqual(left, right) {
     return name1 === name2;
 }
 export function generateIndexName(indexWithFilter) {
+    if (indexWithFilter.name) {
+        return indexWithFilter.name;
+    }
     let name = indexWithFilter.fields.join('_');
     if (indexWithFilter.filter) {
         name += '_filtered';
@@ -20,10 +23,15 @@ export function generateIndexName(indexWithFilter) {
     return name;
 }
 export function normalizeIndex(index) {
+    var _a;
     const fields = Array.isArray(index) ? index : index.fields;
     const filter = Array.isArray(index) ? undefined : index.filter;
     fields.sort();
-    return { fields, filter };
+    return {
+        fields,
+        filter,
+        name: (_a = index.name) !== null && _a !== void 0 ? _a : undefined,
+    };
 }
 export function pluckMissingIndexes(left, right) {
     return differenceWith(left, right, areIndexesEqual);

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

@@ -1,14 +1,16 @@
 import { Database, IndexWithFilter, TestConnect } from '../types/database.types';
 import { DataStore } from '../types/stores.types';
-declare const methods: readonly ["assertThrowsWithInvalidConnectionString", "assertThrowsWhenCantConnect", "assertThrowsWithBadDatabaseName", "assertEmptyDatabaseReturnsEmptyArray", "assertKnowsIfConnectionClosed", "assertFindOneOnEmptyDatabaseReturnsNull", "assertCanSortDesc", "assertCanSortAsc", "assertCanSortById", "assertCanQueryWithOr", "generateIdDifferentEachTime", "assertInsertingGeneratesId", "assertCanCreateMany", "assertCanLimitResults", "assertCanCreateWithObjectField", "assertCanCountOnId", "assertCanCount", "assertThrowsWhenUpdatingRecordNotFound", "assertCanUpdate", "assertCanUpdateMany", "assertCanPushOntoArrayValue", "assertCanUpdateWithObjectField", "assertCanUpdateFieldInObjectFieldWithTargettedWhere", "assertCanSaveAndGetNullAndUndefined", "assertCanUpsertOne", "assertCanUpsertNull", "assertCanPushToArrayOnUpsert", "assertCanSyncUniqueIndexesWithFilterExpression", "assertEmptyDatabaseReturnsEmptyArray", "assertFindOneOnEmptyDatabaseReturnsNull", "assertCanLimitResults", "assertCanLimitResultsToZero", "assertCanFindWithBooleanField", "assertCanQueryByGtLtGteLteNe", "assertCanQueryPathWithDotSyntax", "assertCanReturnOnlySelectFields", "assertCanSearchByRegex", "assertCanFindWithNe", "assertCanFindWithIn", "assertCanDeleteRecord", "assertCanDeleteOne", "assertHasNoUniqueIndexToStart", "assertCanCreateUniqueIndex", "assertCanCreateMultiFieldUniqueIndex", "assertCantCreateUniqueIndexTwice", "assertCanDropUniqueIndex", "assertCanDropCompoundUniqueIndex", "assertCantDropUniqueIndexThatDoesntExist", "assertCantDropIndexWhenNoIndexExists", "assertCantDropCompoundUniqueIndexThatDoesntExist", "assertSyncingUniqueIndexsAddsMissingIndexes", "assertSyncingUniqueIndexsSkipsExistingIndexs", "assertSyncingUniqueIndexesRemovesExtraIndexes", "assertSyncingUniqueIndexesIsRaceProof", "assertSyncingIndexesDoesNotAddAndRemove", "assertUniqueIndexBlocksDuplicates", "assertDuplicateKeyThrowsOnInsert", "assertSettingUniqueIndexViolationThrowsSpruceError", "assertCanCreateUniqueIndexOnNestedField", "assertUpsertWithUniqueIndex", "assertNestedFieldIndexUpdates", "assertHasNoIndexToStart", "assertCanCreateIndex", "assertCantCreateSameIndexTwice", "assertCanCreateMultiFieldIndex", "assertCanDropIndex", "assertCanDropCompoundIndex", "assertCantDropCompoundIndexThatDoesNotExist", "assertSyncIndexesSkipsExisting", "assertSyncIndexesRemovesExtraIndexes", "assertSyncIndexesHandlesRaceConditions", "assertSyncIndexesDoesNotRemoveExisting", "assertDuplicateFieldsWithMultipleUniqueIndexesWorkAsExpected", "assertCanSyncIndexesWithoutPartialThenAgainWithProperlyUpdates"];
-export type DatabaseAssertionName = (typeof methods)[number];
+declare const methods: readonly ["assertThrowsWithInvalidConnectionString", "assertThrowsWhenCantConnect", "assertThrowsWithBadDatabaseName", "assertKnowsIfConnectionClosed", "assertCanSortDesc", "assertCanSortAsc", "assertCanSortById", "assertCanQueryWithOr", "assertGeneratesIdDifferentEachTime", "assertInsertingGeneratesId", "assertCanCreateMany", "assertCanCreateWithObjectField", "assertCanCountOnId", "assertCanCount", "assertThrowsWhenUpdatingRecordNotFound", "assertCanUpdate", "assertCanUpdateMany", "assertCanPushOntoArrayValue", "assertCanUpdateWithObjectField", "assertCanUpdateFieldInObjectFieldWithTargettedWhere", "assertCanSaveAndGetNullAndUndefined", "assertCanUpsertOne", "assertCanUpsertNull", "assertCanPushToArrayOnUpsert", "assertCanSyncUniqueIndexesWithFilterExpression", "assertEmptyDatabaseReturnsEmptyArray", "assertFindOneOnEmptyDatabaseReturnsNull", "assertCanLimitResults", "assertCanLimitResultsToZero", "assertCanFindWithBooleanField", "assertCanQueryByGtLtGteLteNe", "assertCanQueryPathWithDotSyntax", "assertCanReturnOnlySelectFields", "assertCanSearchByRegex", "assertCanFindWithNe", "assertCanFindWithIn", "assertCanDeleteRecord", "assertCanDeleteOne", "assertHasNoUniqueIndexToStart", "assertCanCreateUniqueIndex", "assertCanCreateMultiFieldUniqueIndex", "assertCantCreateUniqueIndexTwice", "assertCanDropUniqueIndex", "assertCanDropCompoundUniqueIndex", "assertCantDropUniqueIndexThatDoesntExist", "assertCantDropIndexWhenNoIndexExists", "assertCantDropCompoundUniqueIndexThatDoesntExist", "assertSyncingUniqueIndexsAddsMissingIndexes", "assertSyncingUniqueIndexsSkipsExistingIndexs", "assertSyncingUniqueIndexesRemovesExtraIndexes", "assertSyncingUniqueIndexesIsRaceProof", "assertSyncingIndexesDoesNotAddAndRemove", "assertUniqueIndexBlocksDuplicates", "assertDuplicateKeyThrowsOnInsert", "assertSettingUniqueIndexViolationThrowsSpruceError", "assertCanCreateUniqueIndexOnNestedField", "assertUpsertWithUniqueIndex", "assertNestedFieldIndexUpdates", "assertHasNoIndexToStart", "assertCanCreateIndex", "assertCantCreateSameIndexTwice", "assertCanCreateMultiFieldIndex", "assertCanDropIndex", "assertCanDropCompoundIndex", "assertCantDropCompoundIndexThatDoesNotExist", "assertSyncIndexesSkipsExisting", "assertSyncIndexesRemovesExtraIndexes", "assertSyncIndexesHandlesRaceConditions", "assertSyncIndexesDoesNotRemoveExisting", "assertDuplicateFieldsWithMultipleUniqueIndexesWorkAsExpected", "assertCanSyncIndexesWithoutPartialThenAgainWithProperlyUpdates"];
+type OriginalMethods = (typeof methods)[number];
+type BangMethods = `!${OriginalMethods}`;
+export type DatabaseAssertionName = OriginalMethods | BangMethods;
 declare const databaseAssertUtil: {
     collectionName: string;
     runSuite(connect: TestConnect, tests?: DatabaseAssertionName[]): Promise<void>;
     _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>;
+    assertGeneratesIdDifferentEachTime(connect: TestConnect): Promise<void>;
     assertCanSortDesc(connect: TestConnect): Promise<void>;
     assertCanSortAsc(connect: TestConnect): Promise<void>;
     assertInsertingGeneratesId(connect: TestConnect): Promise<void>;

package/build/esm/tests/databaseAssertUtil.js

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { assertOptions } from '@sprucelabs/schema';
+import { assertOptions, SchemaError } from '@sprucelabs/schema';
 import { assert } from '@sprucelabs/test-utils';
 import { errorAssert } from '@sprucelabs/test-utils';
 import generateId from '../utilities/generateId.js';
@@ -17,17 +17,14 @@ const methods = [
     'assertThrowsWhenCantConnect',
     'assertThrowsWithBadDatabaseName',
     //inserting
-    'assertEmptyDatabaseReturnsEmptyArray',
     'assertKnowsIfConnectionClosed',
-    'assertFindOneOnEmptyDatabaseReturnsNull',
     'assertCanSortDesc',
     'assertCanSortAsc',
     'assertCanSortById',
     'assertCanQueryWithOr',
-    'generateIdDifferentEachTime',
+    'assertGeneratesIdDifferentEachTime',
     'assertInsertingGeneratesId',
     'assertCanCreateMany',
-    'assertCanLimitResults',
     'assertCanCreateWithObjectField',
     //counting
     'assertCanCountOnId',
@@ -103,6 +100,22 @@ const databaseAssertUtil = {
             const db = yield connectToDabatase(connect);
             yield db.dropDatabase();
             yield this.shutdown(db);
+            const hasIgnore = tests === null || tests === void 0 ? void 0 : tests.find((t) => t.startsWith('!'));
+            if (hasIgnore && tests) {
+                for (const method of tests) {
+                    if (!method.startsWith('!')) {
+                        throw new SchemaError({
+                            code: 'INVALID_PARAMETERS',
+                            parameters: ['tests'],
+                        });
+                    }
+                }
+                const doesMatch = (m) => {
+                    return !!tests.find((t) => t.substring(1) === m);
+                };
+                const filtered = methods.filter((m) => !doesMatch(m));
+                tests = filtered;
+            }
             const toRun = tests !== null && tests !== void 0 ? tests : methods;
             for (const method of toRun) {
                 try {
@@ -134,7 +147,7 @@ const databaseAssertUtil = {
             assert.isEqual(count, expectedUpdateCount);
         });
     },
-    generateIdDifferentEachTime(connect) {
+    assertGeneratesIdDifferentEachTime(connect) {
         return __awaiter(this, void 0, void 0, function* () {
             const db = yield connectToDabatase(connect);
             const id1 = db.generateId();

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

@@ -41,6 +41,7 @@ export type TestConnect = (connectionString?: string, dbName?: string) => Promis
 export interface IndexWithFilter {
     fields: string[];
     filter?: Record<string, any>;
+    name?: string;
 }
 export type Index = string[] | IndexWithFilter;
 export interface CreateOptions extends DatabaseInternalOptions {

package/build/tests/databaseAssertUtil.d.ts

@@ -1,14 +1,16 @@
 import { Database, IndexWithFilter, TestConnect } from '../types/database.types';
 import { DataStore } from '../types/stores.types';
-declare const methods: readonly ["assertThrowsWithInvalidConnectionString", "assertThrowsWhenCantConnect", "assertThrowsWithBadDatabaseName", "assertEmptyDatabaseReturnsEmptyArray", "assertKnowsIfConnectionClosed", "assertFindOneOnEmptyDatabaseReturnsNull", "assertCanSortDesc", "assertCanSortAsc", "assertCanSortById", "assertCanQueryWithOr", "generateIdDifferentEachTime", "assertInsertingGeneratesId", "assertCanCreateMany", "assertCanLimitResults", "assertCanCreateWithObjectField", "assertCanCountOnId", "assertCanCount", "assertThrowsWhenUpdatingRecordNotFound", "assertCanUpdate", "assertCanUpdateMany", "assertCanPushOntoArrayValue", "assertCanUpdateWithObjectField", "assertCanUpdateFieldInObjectFieldWithTargettedWhere", "assertCanSaveAndGetNullAndUndefined", "assertCanUpsertOne", "assertCanUpsertNull", "assertCanPushToArrayOnUpsert", "assertCanSyncUniqueIndexesWithFilterExpression", "assertEmptyDatabaseReturnsEmptyArray", "assertFindOneOnEmptyDatabaseReturnsNull", "assertCanLimitResults", "assertCanLimitResultsToZero", "assertCanFindWithBooleanField", "assertCanQueryByGtLtGteLteNe", "assertCanQueryPathWithDotSyntax", "assertCanReturnOnlySelectFields", "assertCanSearchByRegex", "assertCanFindWithNe", "assertCanFindWithIn", "assertCanDeleteRecord", "assertCanDeleteOne", "assertHasNoUniqueIndexToStart", "assertCanCreateUniqueIndex", "assertCanCreateMultiFieldUniqueIndex", "assertCantCreateUniqueIndexTwice", "assertCanDropUniqueIndex", "assertCanDropCompoundUniqueIndex", "assertCantDropUniqueIndexThatDoesntExist", "assertCantDropIndexWhenNoIndexExists", "assertCantDropCompoundUniqueIndexThatDoesntExist", "assertSyncingUniqueIndexsAddsMissingIndexes", "assertSyncingUniqueIndexsSkipsExistingIndexs", "assertSyncingUniqueIndexesRemovesExtraIndexes", "assertSyncingUniqueIndexesIsRaceProof", "assertSyncingIndexesDoesNotAddAndRemove", "assertUniqueIndexBlocksDuplicates", "assertDuplicateKeyThrowsOnInsert", "assertSettingUniqueIndexViolationThrowsSpruceError", "assertCanCreateUniqueIndexOnNestedField", "assertUpsertWithUniqueIndex", "assertNestedFieldIndexUpdates", "assertHasNoIndexToStart", "assertCanCreateIndex", "assertCantCreateSameIndexTwice", "assertCanCreateMultiFieldIndex", "assertCanDropIndex", "assertCanDropCompoundIndex", "assertCantDropCompoundIndexThatDoesNotExist", "assertSyncIndexesSkipsExisting", "assertSyncIndexesRemovesExtraIndexes", "assertSyncIndexesHandlesRaceConditions", "assertSyncIndexesDoesNotRemoveExisting", "assertDuplicateFieldsWithMultipleUniqueIndexesWorkAsExpected", "assertCanSyncIndexesWithoutPartialThenAgainWithProperlyUpdates"];
-export type DatabaseAssertionName = (typeof methods)[number];
+declare const methods: readonly ["assertThrowsWithInvalidConnectionString", "assertThrowsWhenCantConnect", "assertThrowsWithBadDatabaseName", "assertKnowsIfConnectionClosed", "assertCanSortDesc", "assertCanSortAsc", "assertCanSortById", "assertCanQueryWithOr", "assertGeneratesIdDifferentEachTime", "assertInsertingGeneratesId", "assertCanCreateMany", "assertCanCreateWithObjectField", "assertCanCountOnId", "assertCanCount", "assertThrowsWhenUpdatingRecordNotFound", "assertCanUpdate", "assertCanUpdateMany", "assertCanPushOntoArrayValue", "assertCanUpdateWithObjectField", "assertCanUpdateFieldInObjectFieldWithTargettedWhere", "assertCanSaveAndGetNullAndUndefined", "assertCanUpsertOne", "assertCanUpsertNull", "assertCanPushToArrayOnUpsert", "assertCanSyncUniqueIndexesWithFilterExpression", "assertEmptyDatabaseReturnsEmptyArray", "assertFindOneOnEmptyDatabaseReturnsNull", "assertCanLimitResults", "assertCanLimitResultsToZero", "assertCanFindWithBooleanField", "assertCanQueryByGtLtGteLteNe", "assertCanQueryPathWithDotSyntax", "assertCanReturnOnlySelectFields", "assertCanSearchByRegex", "assertCanFindWithNe", "assertCanFindWithIn", "assertCanDeleteRecord", "assertCanDeleteOne", "assertHasNoUniqueIndexToStart", "assertCanCreateUniqueIndex", "assertCanCreateMultiFieldUniqueIndex", "assertCantCreateUniqueIndexTwice", "assertCanDropUniqueIndex", "assertCanDropCompoundUniqueIndex", "assertCantDropUniqueIndexThatDoesntExist", "assertCantDropIndexWhenNoIndexExists", "assertCantDropCompoundUniqueIndexThatDoesntExist", "assertSyncingUniqueIndexsAddsMissingIndexes", "assertSyncingUniqueIndexsSkipsExistingIndexs", "assertSyncingUniqueIndexesRemovesExtraIndexes", "assertSyncingUniqueIndexesIsRaceProof", "assertSyncingIndexesDoesNotAddAndRemove", "assertUniqueIndexBlocksDuplicates", "assertDuplicateKeyThrowsOnInsert", "assertSettingUniqueIndexViolationThrowsSpruceError", "assertCanCreateUniqueIndexOnNestedField", "assertUpsertWithUniqueIndex", "assertNestedFieldIndexUpdates", "assertHasNoIndexToStart", "assertCanCreateIndex", "assertCantCreateSameIndexTwice", "assertCanCreateMultiFieldIndex", "assertCanDropIndex", "assertCanDropCompoundIndex", "assertCantDropCompoundIndexThatDoesNotExist", "assertSyncIndexesSkipsExisting", "assertSyncIndexesRemovesExtraIndexes", "assertSyncIndexesHandlesRaceConditions", "assertSyncIndexesDoesNotRemoveExisting", "assertDuplicateFieldsWithMultipleUniqueIndexesWorkAsExpected", "assertCanSyncIndexesWithoutPartialThenAgainWithProperlyUpdates"];
+type OriginalMethods = (typeof methods)[number];
+type BangMethods = `!${OriginalMethods}`;
+export type DatabaseAssertionName = OriginalMethods | BangMethods;
 declare const databaseAssertUtil: {
     collectionName: string;
     runSuite(connect: TestConnect, tests?: DatabaseAssertionName[]): Promise<void>;
     _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>;
+    assertGeneratesIdDifferentEachTime(connect: TestConnect): Promise<void>;
     assertCanSortDesc(connect: TestConnect): Promise<void>;
     assertCanSortAsc(connect: TestConnect): Promise<void>;
     assertInsertingGeneratesId(connect: TestConnect): Promise<void>;

package/build/tests/databaseAssertUtil.js

@@ -13,17 +13,14 @@ const methods = [
     'assertThrowsWhenCantConnect',
     'assertThrowsWithBadDatabaseName',
     //inserting
-    'assertEmptyDatabaseReturnsEmptyArray',
     'assertKnowsIfConnectionClosed',
-    'assertFindOneOnEmptyDatabaseReturnsNull',
     'assertCanSortDesc',
     'assertCanSortAsc',
     'assertCanSortById',
     'assertCanQueryWithOr',
-    'generateIdDifferentEachTime',
+    'assertGeneratesIdDifferentEachTime',
     'assertInsertingGeneratesId',
     'assertCanCreateMany',
-    'assertCanLimitResults',
     'assertCanCreateWithObjectField',
     //counting
     'assertCanCountOnId',
@@ -98,6 +95,22 @@ const databaseAssertUtil = {
         const db = await connectToDabatase(connect);
         await db.dropDatabase();
         await this.shutdown(db);
+        const hasIgnore = tests === null || tests === void 0 ? void 0 : tests.find((t) => t.startsWith('!'));
+        if (hasIgnore && tests) {
+            for (const method of tests) {
+                if (!method.startsWith('!')) {
+                    throw new schema_1.SchemaError({
+                        code: 'INVALID_PARAMETERS',
+                        parameters: ['tests'],
+                    });
+                }
+            }
+            const doesMatch = (m) => {
+                return !!tests.find((t) => t.substring(1) === m);
+            };
+            const filtered = methods.filter((m) => !doesMatch(m));
+            tests = filtered;
+        }
         const toRun = tests !== null && tests !== void 0 ? tests : methods;
         for (const method of toRun) {
             try {
@@ -124,7 +137,7 @@ const databaseAssertUtil = {
         const count = await db.count(this.collectionName, updates);
         test_utils_1.assert.isEqual(count, expectedUpdateCount);
     },
-    async generateIdDifferentEachTime(connect) {
+    async assertGeneratesIdDifferentEachTime(connect) {
         const db = await connectToDabatase(connect);
         const id1 = db.generateId();
         const id2 = db.generateId();

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

@@ -41,6 +41,7 @@ export type TestConnect = (connectionString?: string, dbName?: string) => Promis
 export interface IndexWithFilter {
     fields: string[];
     filter?: Record<string, any>;
+    name?: string;
 }
 export type Index = string[] | IndexWithFilter;
 export interface CreateOptions extends DatabaseInternalOptions {

package/package.json

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