@sprucelabs/data-stores 19.1.67 → 19.2.0

package/build/.spruce/errors/dataStores/invalidConnectionStringScheme.schema.d.ts

@@ -0,0 +1,3 @@
+import { SpruceErrors } from '../errors.types';
+declare const invalidConnectionStringSchemeSchema: SpruceErrors.DataStores.InvalidConnectionStringSchemeSchema;
+export default invalidConnectionStringSchemeSchema;

package/build/.spruce/errors/dataStores/invalidConnectionStringScheme.schema.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@sprucelabs/schema");
+const invalidConnectionStringSchemeSchema = {
+    id: 'invalidConnectionStringScheme',
+    namespace: 'DataStores',
+    name: 'Invalid connection string scheme',
+    fields: {
+        /** . */
+        'connectionString': {
+            type: 'text',
+            isRequired: true,
+            options: undefined
+        },
+    }
+};
+schema_1.SchemaRegistry.getInstance().trackSchema(invalidConnectionStringSchemeSchema);
+exports.default = invalidConnectionStringSchemeSchema;

package/build/.spruce/errors/errors.types.d.ts

@@ -213,6 +213,25 @@ export declare namespace SpruceErrors.DataStores {
     }
     type InvalidDatabaseNameEntity = SchemaEntity<SpruceErrors.DataStores.InvalidDatabaseNameSchema>;
 }
+export declare namespace SpruceErrors.DataStores {
+    interface InvalidConnectionStringScheme {
+        'connectionString': string;
+    }
+    interface InvalidConnectionStringSchemeSchema extends SpruceSchema.Schema {
+        id: 'invalidConnectionStringScheme';
+        namespace: 'DataStores';
+        name: 'Invalid connection string scheme';
+        fields: {
+            /** . */
+            'connectionString': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+        };
+    }
+    type InvalidConnectionStringSchemeEntity = SchemaEntity<SpruceErrors.DataStores.InvalidConnectionStringSchemeSchema>;
+}
 export declare namespace SpruceErrors.DataStores {
     interface IndexNotFound {
         /** Missing Index. */

package/build/.spruce/errors/options.types.d.ts

@@ -33,6 +33,9 @@ export interface InvalidDbConnectionStringErrorOptions extends SpruceErrors.Data
 export interface InvalidDatabaseNameErrorOptions extends SpruceErrors.DataStores.InvalidDatabaseName, ISpruceErrorOptions {
     code: 'INVALID_DATABASE_NAME';
 }
+export interface InvalidConnectionStringSchemeErrorOptions extends SpruceErrors.DataStores.InvalidConnectionStringScheme, ISpruceErrorOptions {
+    code: 'INVALID_CONNECTION_STRING_SCHEME';
+}
 export interface IndexNotFoundErrorOptions extends SpruceErrors.DataStores.IndexNotFound, ISpruceErrorOptions {
     code: 'INDEX_NOT_FOUND';
 }
@@ -54,5 +57,5 @@ export interface DuplicateKeyErrorOptions extends SpruceErrors.DataStores.Duplic
 export interface DatabaseNotConnectedErrorOptions extends SpruceErrors.DataStores.DatabaseNotConnected, ISpruceErrorOptions {
     code: 'DATABASE_NOT_CONNECTED';
 }
-type ErrorOptions = UnknownStoreErrorErrorOptions | UnknownErrorErrorOptions | UnknownDatabaseErrorErrorOptions | UnableToConnectToDbErrorOptions | ScrambleNotConfiguredErrorOptions | RecordNotFoundErrorOptions | MongoIdMappingErrorErrorOptions | InvalidStoreNameErrorOptions | InvalidStoreErrorOptions | InvalidDbConnectionStringErrorOptions | InvalidDatabaseNameErrorOptions | IndexNotFoundErrorOptions | IndexExistsErrorOptions | FailedToLoadStoresErrorOptions | FailedToLoadStoreErrorOptions | DuplicateRecordErrorOptions | DuplicateKeyErrorOptions | DatabaseNotConnectedErrorOptions;
+type ErrorOptions = UnknownStoreErrorErrorOptions | UnknownErrorErrorOptions | UnknownDatabaseErrorErrorOptions | UnableToConnectToDbErrorOptions | ScrambleNotConfiguredErrorOptions | RecordNotFoundErrorOptions | MongoIdMappingErrorErrorOptions | InvalidStoreNameErrorOptions | InvalidStoreErrorOptions | InvalidDbConnectionStringErrorOptions | InvalidDatabaseNameErrorOptions | InvalidConnectionStringSchemeErrorOptions | IndexNotFoundErrorOptions | IndexExistsErrorOptions | FailedToLoadStoresErrorOptions | FailedToLoadStoreErrorOptions | DuplicateRecordErrorOptions | DuplicateKeyErrorOptions | DatabaseNotConnectedErrorOptions;
 export default ErrorOptions;

package/build/databases/MongoDatabase.d.ts

@@ -1,6 +1,5 @@
-import { Log } from '@sprucelabs/spruce-skill-utils';
 import { MongoClientOptions, MongoClient } from 'mongodb';
-import { Database } from '../types/database.types';
+import { Database, DatabaseOptions } from '../types/database.types';
 import { QueryOptions } from '../types/query.types';
 export declare const MONGO_TEST_URI = "mongodb://localhost:27017";
 export default class MongoDatabase implements Database {
@@ -9,10 +8,7 @@ export default class MongoDatabase implements Database {
     private dbName;
     private disableAutoGeneratedIdsOnTheseCollections;
     private _isConnected;
-    constructor(url: string, options?: MongoClientOptions & {
-        dbName?: string;
-        log?: Log;
-    });
+    constructor(url: string, options?: MongoClientOptions & DatabaseOptions);
     count(collection: string, query?: Record<string, any>): Promise<number>;
     generateId(): string;
     delete(collection: string, query: Record<string, any>): Promise<number>;

package/build/errors/SpruceError.js

@@ -93,6 +93,9 @@ If you are on a mac, using brew is recommended: https://brew.sh`;
             case 'DUPLICATE_KEY':
                 message = `An index was trying to be created that exists. Original error is:\n\n${(_c = options.friendlyMessage) !== null && _c !== void 0 ? _c : '**missing**'}`;
                 break;
+            case 'INVALID_CONNECTION_STRING_SCHEME':
+                message = `There is no database adapter setup for: ${options.connectionString.split('://')[0]}`;
+                break;
             default:
                 message = super.friendlyMessage();
         }

package/build/errors/invalidConnectionStringSchema.builder.d.ts

@@ -0,0 +1,11 @@
+declare const _default: {
+    id: string;
+    name: string;
+    fields: {
+        connectionString: {
+            type: "text";
+            isRequired: true;
+        };
+    };
+};
+export default _default;

package/build/errors/invalidConnectionStringSchema.builder.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@sprucelabs/schema");
+exports.default = (0, schema_1.buildErrorSchema)({
+    id: 'invalidConnectionStringScheme',
+    name: 'Invalid connection string scheme',
+    fields: {
+        connectionString: {
+            type: 'text',
+            isRequired: true,
+        },
+    },
+});

package/build/esm/.spruce/errors/errors.types.d.ts

@@ -213,6 +213,25 @@ export declare namespace SpruceErrors.DataStores {
     }
     type InvalidDatabaseNameEntity = SchemaEntity<SpruceErrors.DataStores.InvalidDatabaseNameSchema>;
 }
+export declare namespace SpruceErrors.DataStores {
+    interface InvalidConnectionStringScheme {
+        'connectionString': string;
+    }
+    interface InvalidConnectionStringSchemeSchema extends SpruceSchema.Schema {
+        id: 'invalidConnectionStringScheme';
+        namespace: 'DataStores';
+        name: 'Invalid connection string scheme';
+        fields: {
+            /** . */
+            'connectionString': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+        };
+    }
+    type InvalidConnectionStringSchemeEntity = SchemaEntity<SpruceErrors.DataStores.InvalidConnectionStringSchemeSchema>;
+}
 export declare namespace SpruceErrors.DataStores {
     interface IndexNotFound {
         /** Missing Index. */

package/build/esm/.spruce/errors/options.types.d.ts

@@ -33,6 +33,9 @@ export interface InvalidDbConnectionStringErrorOptions extends SpruceErrors.Data
 export interface InvalidDatabaseNameErrorOptions extends SpruceErrors.DataStores.InvalidDatabaseName, ISpruceErrorOptions {
     code: 'INVALID_DATABASE_NAME';
 }
+export interface InvalidConnectionStringSchemeErrorOptions extends SpruceErrors.DataStores.InvalidConnectionStringScheme, ISpruceErrorOptions {
+    code: 'INVALID_CONNECTION_STRING_SCHEME';
+}
 export interface IndexNotFoundErrorOptions extends SpruceErrors.DataStores.IndexNotFound, ISpruceErrorOptions {
     code: 'INDEX_NOT_FOUND';
 }
@@ -54,5 +57,5 @@ export interface DuplicateKeyErrorOptions extends SpruceErrors.DataStores.Duplic
 export interface DatabaseNotConnectedErrorOptions extends SpruceErrors.DataStores.DatabaseNotConnected, ISpruceErrorOptions {
     code: 'DATABASE_NOT_CONNECTED';
 }
-type ErrorOptions = UnknownStoreErrorErrorOptions | UnknownErrorErrorOptions | UnknownDatabaseErrorErrorOptions | UnableToConnectToDbErrorOptions | ScrambleNotConfiguredErrorOptions | RecordNotFoundErrorOptions | MongoIdMappingErrorErrorOptions | InvalidStoreNameErrorOptions | InvalidStoreErrorOptions | InvalidDbConnectionStringErrorOptions | InvalidDatabaseNameErrorOptions | IndexNotFoundErrorOptions | IndexExistsErrorOptions | FailedToLoadStoresErrorOptions | FailedToLoadStoreErrorOptions | DuplicateRecordErrorOptions | DuplicateKeyErrorOptions | DatabaseNotConnectedErrorOptions;
+type ErrorOptions = UnknownStoreErrorErrorOptions | UnknownErrorErrorOptions | UnknownDatabaseErrorErrorOptions | UnableToConnectToDbErrorOptions | ScrambleNotConfiguredErrorOptions | RecordNotFoundErrorOptions | MongoIdMappingErrorErrorOptions | InvalidStoreNameErrorOptions | InvalidStoreErrorOptions | InvalidDbConnectionStringErrorOptions | InvalidDatabaseNameErrorOptions | InvalidConnectionStringSchemeErrorOptions | IndexNotFoundErrorOptions | IndexExistsErrorOptions | FailedToLoadStoresErrorOptions | FailedToLoadStoreErrorOptions | DuplicateRecordErrorOptions | DuplicateKeyErrorOptions | DatabaseNotConnectedErrorOptions;
 export default ErrorOptions;

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

@@ -1,6 +1,5 @@
-import { Log } from '@sprucelabs/spruce-skill-utils';
 import { MongoClientOptions, MongoClient } from 'mongodb';
-import { Database } from '../types/database.types';
+import { Database, DatabaseOptions } from '../types/database.types';
 import { QueryOptions } from '../types/query.types';
 export declare const MONGO_TEST_URI = "mongodb://localhost:27017";
 export default class MongoDatabase implements Database {
@@ -9,10 +8,7 @@ export default class MongoDatabase implements Database {
     private dbName;
     private disableAutoGeneratedIdsOnTheseCollections;
     private _isConnected;
-    constructor(url: string, options?: MongoClientOptions & {
-        dbName?: string;
-        log?: Log;
-    });
+    constructor(url: string, options?: MongoClientOptions & DatabaseOptions);
     count(collection: string, query?: Record<string, any>): Promise<number>;
     generateId(): string;
     delete(collection: string, query: Record<string, any>): Promise<number>;

package/build/esm/errors/SpruceError.js

@@ -88,6 +88,9 @@ If you are on a mac, using brew is recommended: https://brew.sh`;
             case 'DUPLICATE_KEY':
                 message = `An index was trying to be created that exists. Original error is:\n\n${(_c = options.friendlyMessage) !== null && _c !== void 0 ? _c : '**missing**'}`;
                 break;
+            case 'INVALID_CONNECTION_STRING_SCHEME':
+                message = `There is no database adapter setup for: ${options.connectionString.split('://')[0]}`;
+                break;
             default:
                 message = super.friendlyMessage();
         }

package/build/esm/errors/invalidConnectionStringSchema.builder.d.ts

@@ -0,0 +1,11 @@
+declare const _default: {
+    id: string;
+    name: string;
+    fields: {
+        connectionString: {
+            type: "text";
+            isRequired: true;
+        };
+    };
+};
+export default _default;

package/build/esm/errors/invalidConnectionStringSchema.builder.js

@@ -0,0 +1,11 @@
+import { buildErrorSchema } from '@sprucelabs/schema';
+export default buildErrorSchema({
+    id: 'invalidConnectionStringScheme',
+    name: 'Invalid connection string scheme',
+    fields: {
+        connectionString: {
+            type: 'text',
+            isRequired: true,
+        },
+    },
+});

package/build/esm/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/esm/factories/DatabaseFactory.js

@@ -1,8 +1,12 @@
 import { SchemaError } from '@sprucelabs/schema';
 import MongoDatabase from '../databases/MongoDatabase.js';
 import NeDbDatabase from '../databases/NeDbDatabase.js';
+import SpruceError from '../errors/SpruceError.js';
 export default class DatabaseFactory {
     constructor() { }
+    static addAdapter(scheme, Adapter) {
+        this.Adapters[scheme] = Adapter;
+    }
     static Database(options) {
         const { dbName, dbConnectionString } = options;
         let database;
@@ -15,11 +19,17 @@ export default class DatabaseFactory {
         }
         const cacheKey = this.generateCacheKey(options);
         if (!this.cache[cacheKey]) {
-            if (dbConnectionString.startsWith('memory')) {
-                database = new NeDbDatabase();
+            for (const [key, Adapter] of Object.entries(this.Adapters)) {
+                if (dbConnectionString.startsWith(key)) {
+                    database = new Adapter(dbConnectionString, { dbName });
+                    break;
+                }
             }
-            else {
-                database = new MongoDatabase(dbConnectionString, { dbName });
+            if (!database) {
+                throw new SpruceError({
+                    code: 'INVALID_CONNECTION_STRING_SCHEME',
+                    connectionString: dbConnectionString,
+                });
             }
             this.cache[cacheKey] = database;
         }
@@ -39,3 +49,7 @@ export default class DatabaseFactory {
     }
 }
 DatabaseFactory.cache = {};
+DatabaseFactory.Adapters = {
+    'mongodb://': MongoDatabase,
+    'memory://': NeDbDatabase,
+};

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

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

package/build/esm/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;