@sprucelabs/data-stores 19.1.67 → 19.2.0

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

@@ -0,0 +1,2 @@
+import databaseAssertUtil from './databaseAssertUtil';
+export default function pluckAssertionMethods(util: typeof databaseAssertUtil): ("collectionName" | "runSuite" | "_getFilteredIndexes" | "_filterIdIndex" | "_assertUpdateUpdatedRightNumberOfRecords" | "assertCanSortDesc" | "assertCanSortAsc" | "assertInsertingGeneratesId" | "assertThrowsWhenUpdatingRecordNotFound" | "shutdown" | "assertCanCreateUniqueIndex" | "assertHasNoUniqueIndexToStart" | "assertCanShutdown" | "assertCanDeleteOne" | "assertCanDeleteRecord" | "assertCanLimitResultsToZero" | "assertCanLimitResults" | "assertFindOneOnEmptyDatabaseReturnsNull" | "assertEmptyDatabaseReturnsEmptyArray" | "assertCanPushOntoArrayValue" | "assertCanCreateMany" | "assertCanUpdateMany" | "assertCanQueryWithOr" | "assertCanUpdate" | "assertCanSortById" | "assertCanCreateMultiFieldUniqueIndex" | "assertSettingUniqueIndexViolationThrowsSpruceError" | "assertDuplicateKeyThrowsOnInsert" | "assertSyncingIndexesDoesNotAddAndRemove" | "assertSyncingUniqueIndexesRemovesExtraIndexes" | "assertSyncingUniqueIndexsSkipsExistingIndexs" | "assertSyncingUniqueIndexsAddsMissingIndexes" | "assertCantDropCompoundUniqueIndexThatDoesntExist" | "assertCantDropIndexWhenNoIndexExists" | "assertCantDropUniqueIndexThatDoesntExist" | "assertCanDropCompoundUniqueIndex" | "assertCanDropUniqueIndex" | "assertCantCreateUniqueIndexTwice" | "assertSyncingUniqueIndexesIsRaceProof" | "assertUniqueIndexBlocksDuplicates" | "assertCanCreateUniqueIndexOnNestedField" | "assertCanPushToArrayOnUpsert" | "assertCanSearchByRegex" | "assertCanReturnOnlySelectFields" | "assertThrowsWithoutDatabaseName" | "assertThrowsWhenCantConnect" | "assertThrowsWithInvalidConnectionString" | "assertKnowsIfConnectionClosed" | "assertCanQueryPathWithDotSyntax" | "assertCanQueryByGtLtGteLte" | "assertCanFindWithNe" | "assertCanFindWithIn" | "assertCanCountOnId" | "assertCanCount" | "assertCanUpsertNull" | "assertCanSaveAndGetNullAndUndefined" | "assertSyncIndexesDoesNotRemoveExisting" | "assertSyncIndexesRemovesExtraIndexes" | "assertSyncIndexesSkipsExisting" | "assertCantDropCompoundIndexThatDoesNotExist" | "assertCanDropCompoundIndex" | "assertCanDropIndex" | "assertCanCreateMultiFieldIndex" | "assertCantCreateSameIndexTwice" | "assertCanCreateIndex" | "assertHasNoIndexToStart" | "assertNestedFieldIndexUpdates" | "assertUpsertWithUniqueIndex" | "assertSyncIndexesHandlesRaceConditions" | "assertDuplicateFieldsWithMultipleUniqueIndexesWorkAsExpected")[];

package/build/esm/tests/pluckAssertionMethods.js

@@ -0,0 +1,3 @@
+export default function pluckAssertionMethods(util) {
+    return Object.keys(util).filter((key) => key.startsWith('assert'));
+}

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

@@ -1,3 +1,4 @@
+import { Log } from '@sprucelabs/spruce-skill-utils';
 import { QueryOptions } from './query.types';
 export type UniqueIndex = string[];
 export type Index = string[];
@@ -27,3 +28,7 @@ export interface Database {
     createUniqueIndex(collection: string, fields: UniqueIndex): Promise<void>;
     createIndex(collection: string, fields: Index): Promise<void>;
 }
+export interface DatabaseOptions {
+    dbName?: string;
+    log?: Log;
+}

package/build/factories/DatabaseFactory.d.ts

@@ -1,7 +1,9 @@
-import { Database } from '../types/database.types';
+import { Database, DatabaseOptions } from '../types/database.types';
 export default class DatabaseFactory {
     private static cache;
+    private static Adapters;
     private constructor();
+    static addAdapter(scheme: string, Adapter: DatabaseConstructor): void;
     static Database(options: {
         dbName?: string;
         dbConnectionString: string;
@@ -9,3 +11,4 @@ export default class DatabaseFactory {
     private static generateCacheKey;
     static reset(): void;
 }
+export type DatabaseConstructor = new (connectionString: string, options: DatabaseOptions) => Database;

package/build/factories/DatabaseFactory.js

@@ -6,8 +6,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const schema_1 = require("@sprucelabs/schema");
 const MongoDatabase_1 = __importDefault(require("../databases/MongoDatabase"));
 const NeDbDatabase_1 = __importDefault(require("../databases/NeDbDatabase"));
+const SpruceError_1 = __importDefault(require("../errors/SpruceError"));
 class DatabaseFactory {
     constructor() { }
+    static addAdapter(scheme, Adapter) {
+        this.Adapters[scheme] = Adapter;
+    }
     static Database(options) {
         const { dbName, dbConnectionString } = options;
         let database;
@@ -20,11 +24,17 @@ class DatabaseFactory {
         }
         const cacheKey = this.generateCacheKey(options);
         if (!this.cache[cacheKey]) {
-            if (dbConnectionString.startsWith('memory')) {
-                database = new NeDbDatabase_1.default();
+            for (const [key, Adapter] of Object.entries(this.Adapters)) {
+                if (dbConnectionString.startsWith(key)) {
+                    database = new Adapter(dbConnectionString, { dbName });
+                    break;
+                }
             }
-            else {
-                database = new MongoDatabase_1.default(dbConnectionString, { dbName });
+            if (!database) {
+                throw new SpruceError_1.default({
+                    code: 'INVALID_CONNECTION_STRING_SCHEME',
+                    connectionString: dbConnectionString,
+                });
             }
             this.cache[cacheKey] = database;
         }
@@ -45,3 +55,7 @@ class DatabaseFactory {
 }
 exports.default = DatabaseFactory;
 DatabaseFactory.cache = {};
+DatabaseFactory.Adapters = {
+    'mongodb://': MongoDatabase_1.default,
+    'memory://': NeDbDatabase_1.default,
+};

package/build/index.d.ts

@@ -19,3 +19,4 @@ export { default as CursorPager } from './cursors/CursorPager';
 export * from './cursors/CursorPager';
 export { default as CursorPagerFaker } from './cursors/CursorPagerFaker';
 export * from './cursors/CursorPager';
+export { default as databaseAssertUtil } from './tests/databaseAssertUtil';

package/build/index.js

@@ -17,7 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CursorPagerFaker = exports.CursorPager = exports.generateId = exports.mongoUtil = exports.NeDbDatabase = exports.MongoDatabase = exports.StoreLoader = exports.DatabaseFactory = exports.StoreFactory = exports.AbstractStore = exports.DatabaseFixture = exports.AbstractDatabaseTest = void 0;
+exports.databaseAssertUtil = exports.CursorPagerFaker = exports.CursorPager = exports.generateId = exports.mongoUtil = exports.NeDbDatabase = exports.MongoDatabase = exports.StoreLoader = exports.DatabaseFactory = exports.StoreFactory = exports.AbstractStore = exports.DatabaseFixture = exports.AbstractDatabaseTest = void 0;
 var AbstractDatabaseTest_1 = require("./tests/AbstractDatabaseTest");
 Object.defineProperty(exports, "AbstractDatabaseTest", { enumerable: true, get: function () { return __importDefault(AbstractDatabaseTest_1).default; } });
 var DatabaseFixture_1 = require("./fixtures/DatabaseFixture");
@@ -51,3 +51,5 @@ __exportStar(require("./cursors/CursorPager"), exports);
 var CursorPagerFaker_1 = require("./cursors/CursorPagerFaker");
 Object.defineProperty(exports, "CursorPagerFaker", { enumerable: true, get: function () { return __importDefault(CursorPagerFaker_1).default; } });
 __exportStar(require("./cursors/CursorPager"), exports);
+var databaseAssertUtil_1 = require("./tests/databaseAssertUtil");
+Object.defineProperty(exports, "databaseAssertUtil", { enumerable: true, get: function () { return __importDefault(databaseAssertUtil_1).default; } });

package/build/tests/databaseAssertUtil.d.ts

@@ -0,0 +1,75 @@
+import { Connect } from '../__tests__/behavioral/database/Database.test';
+import { Database, Index, UniqueIndex } from '../types/database.types';
+declare const databaseAssertUtil: {
+    collectionName: string;
+    runSuite(connect: Connect): Promise<void>;
+    _getFilteredIndexes(db: Database): Promise<UniqueIndex[] | Index[]>;
+    _filterIdIndex(allIndexes: UniqueIndex[] | Index[]): UniqueIndex[] | Index[];
+    _assertUpdateUpdatedRightNumberOfRecords(db: Database, search: Record<string, any>, updates: Record<string, any>, expectedUpdateCount: number): Promise<void>;
+    assertCanSortDesc(connect: Connect): Promise<void>;
+    assertCanSortAsc(connect: Connect): Promise<void>;
+    assertInsertingGeneratesId(connect: Connect): Promise<void>;
+    assertThrowsWhenUpdatingRecordNotFound(connect: Connect): Promise<void>;
+    shutdown(db: Database): Promise<void>;
+    assertCanCreateUniqueIndex(connect: Connect): Promise<void>;
+    assertHasNoUniqueIndexToStart(connect: Connect): Promise<void>;
+    assertCanShutdown(connect: Connect): Promise<void>;
+    assertCanDeleteOne(connect: Connect): Promise<void>;
+    assertCanDeleteRecord(connect: Connect): Promise<void>;
+    assertCanLimitResultsToZero(connect: Connect): Promise<void>;
+    assertCanLimitResults(connect: Connect): Promise<void>;
+    assertFindOneOnEmptyDatabaseReturnsNull(connect: Connect): Promise<void>;
+    assertEmptyDatabaseReturnsEmptyArray(connect: Connect): Promise<void>;
+    assertCanPushOntoArrayValue(connect: Connect): Promise<void>;
+    assertCanCreateMany(connect: Connect): Promise<void>;
+    assertCanUpdateMany(connect: Connect): Promise<void>;
+    assertCanQueryWithOr(connect: Connect): Promise<void>;
+    assertCanUpdate(connect: Connect): Promise<void>;
+    assertCanSortById(connect: Connect): Promise<void>;
+    assertCanCreateMultiFieldUniqueIndex(connect: Connect): Promise<void>;
+    assertSettingUniqueIndexViolationThrowsSpruceError(connect: Connect): Promise<void>;
+    assertDuplicateKeyThrowsOnInsert(connect: Connect): Promise<void>;
+    assertSyncingIndexesDoesNotAddAndRemove(connect: Connect): Promise<void>;
+    assertSyncingUniqueIndexesRemovesExtraIndexes(connect: Connect): Promise<void>;
+    assertSyncingUniqueIndexsSkipsExistingIndexs(connect: Connect): Promise<void>;
+    assertSyncingUniqueIndexsAddsMissingIndexes(connect: Connect): Promise<void>;
+    assertCantDropCompoundUniqueIndexThatDoesntExist(connect: Connect): Promise<void>;
+    assertCantDropIndexWhenNoIndexExists(connect: Connect): Promise<void>;
+    assertCantDropUniqueIndexThatDoesntExist(connect: Connect): Promise<void>;
+    assertCanDropCompoundUniqueIndex(connect: Connect): Promise<void>;
+    assertCanDropUniqueIndex(connect: Connect): Promise<void>;
+    assertCantCreateUniqueIndexTwice(connect: Connect): Promise<void>;
+    assertSyncingUniqueIndexesIsRaceProof(connect: Connect): Promise<void>;
+    assertUniqueIndexBlocksDuplicates(connect: Connect): Promise<void>;
+    assertCanCreateUniqueIndexOnNestedField(connect: Connect): Promise<void>;
+    assertCanPushToArrayOnUpsert(connect: Connect): Promise<void>;
+    assertCanSearchByRegex(connect: Connect): Promise<void>;
+    assertCanReturnOnlySelectFields(connect: Connect): Promise<void>;
+    assertThrowsWithoutDatabaseName(connect: Connect): Promise<void>;
+    assertThrowsWhenCantConnect(connect: Connect): Promise<void>;
+    assertThrowsWithInvalidConnectionString(connect: Connect): Promise<void>;
+    assertKnowsIfConnectionClosed(connect: Connect): Promise<void>;
+    assertCanQueryPathWithDotSyntax(connect: Connect): Promise<void>;
+    assertCanQueryByGtLtGteLte(connect: Connect): Promise<void>;
+    assertCanFindWithNe(connect: Connect): Promise<void>;
+    assertCanFindWithIn(connect: Connect): Promise<void>;
+    assertCanCountOnId(connect: Connect): Promise<void>;
+    assertCanCount(connect: Connect): Promise<void>;
+    assertCanUpsertNull(connect: Connect): Promise<void>;
+    assertCanSaveAndGetNullAndUndefined(connect: Connect): Promise<void>;
+    assertSyncIndexesDoesNotRemoveExisting(connect: Connect): Promise<void>;
+    assertSyncIndexesRemovesExtraIndexes(connect: Connect): Promise<void>;
+    assertSyncIndexesSkipsExisting(connect: Connect): Promise<void>;
+    assertCantDropCompoundIndexThatDoesNotExist(connect: Connect): Promise<void>;
+    assertCanDropCompoundIndex(connect: Connect): Promise<void>;
+    assertCanDropIndex(connect: Connect): Promise<void>;
+    assertCanCreateMultiFieldIndex(connect: Connect, fields: any): Promise<void>;
+    assertCantCreateSameIndexTwice(connect: Connect): Promise<void>;
+    assertCanCreateIndex(connect: Connect): Promise<void>;
+    assertHasNoIndexToStart(connect: Connect): Promise<void>;
+    assertNestedFieldIndexUpdates(connect: Connect): Promise<void>;
+    assertUpsertWithUniqueIndex(connect: Connect): Promise<void>;
+    assertSyncIndexesHandlesRaceConditions(connect: Connect): Promise<void>;
+    assertDuplicateFieldsWithMultipleUniqueIndexesWorkAsExpected(connect: Connect): Promise<void>;
+};
+export default databaseAssertUtil;