Revert "feat: db8 error handling (#6995)" (#6999)

This reverts commit f6c9909.

Author: pubkey

dist/types/plugins/dev-mode/error-messages.d.ts

@@ -43,6 +43,7 @@ export declare const ERROR_MESSAGES: {
     DB4: string;
     DB5: string;
     DB6: string;
+    DB8: string;
     DB9: string;
     DB11: string;
     DB12: string;

src/plugins/dev-mode/error-messages.ts

@@ -70,9 +70,9 @@ export const ERROR_MESSAGES = {
     DB5: 'RxDatabase.addCollections(): collection-name not allowed',
     DB6: 'RxDatabase.addCollections(): another instance created this collection with a different schema. Read this https://rxdb.info/questions-answers.html?console=qa#cant-change-the-schema ',
     // removed in 13.0.0 (now part of the encryption plugin) DB7: 'RxDatabase.addCollections(): schema encrypted but no password given',
-    // removed in xxxx (new instances wait for old instances to close) DB8: 'createRxDatabase(): A RxDatabase with the same name and adapter already exists.\n' +
-    //    'Make sure to use this combination only once or set ignoreDuplicate to true if you do this intentional-\n' +
-    //    'This often happens in react projects with hot reload that reloads the code without reloading the process.',
+    DB8: 'createRxDatabase(): A RxDatabase with the same name and adapter already exists.\n' +
+        'Make sure to use this combination only once or set ignoreDuplicate to true if you do this intentional-\n' +
+        'This often happens in react projects with hot reload that reloads the code without reloading the process.',
     DB9: 'ignoreDuplicate is only allowed in dev-mode and must never be used in production',
     // removed in 14.0.0 - PouchDB RxStorage is removed - DB9: 'createRxDatabase(): Adapter not added. Use addPouchPlugin(require(\'pouchdb-adapter-[adaptername]\'));',
     // removed in 14.0.0 - PouchDB RxStorage is removed DB10: 'createRxDatabase(): To use leveldown-adapters, you have to add the leveldb-plugin. Use addPouchPlugin(require(\'pouchdb-adapter-leveldb\'));',

src/rx-database.ts

@@ -85,7 +85,11 @@ import type { RxMigrationState } from './plugins/migration-schema/index.ts';
 import type { RxReactivityFactory } from './types/plugins/reactivity.d.ts';
 import { rxChangeEventBulkToRxChangeEvents } from './rx-change-event.ts';
 
-const DATABASE_CLOSED_PROMISE_MAP: Map<string, Set<Promise<void>>> = new Map();
+/**
+ * stores the used database names+storage names
+ * so we can throw when the same database is created more then once.
+ */
+const USED_DATABASE_NAMES: Set<string> = new Set();
 
 let DB_COUNT = 0;
 
@@ -126,11 +130,7 @@ export class RxDatabaseBase<
         public readonly hashFunction: HashFunction,
         public readonly cleanupPolicy?: Partial<RxCleanupPolicy>,
         public readonly allowSlowCount?: boolean,
-        public readonly reactivity?: RxReactivityFactory<any>,
-        /**
-         * Function invoked when the database instance is considered closed
-         */
-        public readonly onClosed?: () => void,
+        public readonly reactivity?: RxReactivityFactory<any>
     ) {
         DB_COUNT++;
 
@@ -493,9 +493,6 @@ export class RxDatabaseBase<
          * we should generate the property list on build time.
          */
         if (this.name === 'pseudoInstance') {
-            if (this.onClosed) {
-                this.onClosed();
-            }
             return PROMISE_RESOLVE_FALSE;
         }
 
@@ -512,7 +509,8 @@ export class RxDatabaseBase<
             ))
             // close internal storage instances
             .then(() => this.internalStore.close())
-            .then(() => this.onClosed && this.onClosed())
+            // remove combination from USED_COMBINATIONS-map
+            .then(() => USED_DATABASE_NAMES.delete(this.storage.name + '|' + this.name))
             .then(() => true);
     }
 
@@ -537,26 +535,23 @@ export class RxDatabaseBase<
 }
 
 /**
- * gets the name key for the passed database name and storage.
+ * checks if an instance with same name and storage already exists
+ * @throws {RxError} if used
  */
-function getDatabaseNameKey(
+function throwIfDatabaseNameUsed(
     name: string,
     storage: RxStorage<any, any>
 ) {
-    return storage.name + '|' + name;
-}
-
-/**
- * ponyfill for https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers
- */
-function createPromiseWithResolvers<T>() {
-    let resolve!: (value: T | PromiseLike<T>) => void;
-    let reject!: (reason?: any) => void;
-    const promise = new Promise<T>((res, rej) => {
-      resolve = res;
-      reject = rej;
-    });
-    return { promise, resolve, reject };
+    const key = storage.name + '|' + name;
+    if (!USED_DATABASE_NAMES.has(key)) {
+        return;
+    } else {
+        throw newRxError('DB8', {
+            name,
+            storage: storage.name,
+            link: 'https://rxdb.info/rx-database.html#ignoreduplicate'
+        });
+    }
 }
 
 /**
@@ -621,47 +616,39 @@ export function createRxDatabase<
         options,
         localDocuments
     });
-
-    if (ignoreDuplicate) {
+    // check if combination already used
+    if (!ignoreDuplicate) {
+        throwIfDatabaseNameUsed(name, storage);
+    } else {
         if (!overwritable.isDevMode()) {
             throw newRxError('DB9', {
                 database: name
             });
         }
     }
+    USED_DATABASE_NAMES.add(storage.name + '|' + name);
 
-    const closedPromiseWithResolvers = createPromiseWithResolvers<void>();
-    const databaseNameKey = getDatabaseNameKey(name, storage);
     const databaseInstanceToken = randomToken(10);
-    const databaseClosedPromiseMapEntry = DATABASE_CLOSED_PROMISE_MAP.get(databaseNameKey) || new Set<Promise<void>>();
-    const databaseClosedPromise = closedPromiseWithResolvers.promise.then(() => {
-        databaseClosedPromiseMapEntry.delete(databaseClosedPromise);
-    });
-    const databaseClosedPromisesToAwait = ignoreDuplicate ? [] : Array.from(databaseClosedPromiseMapEntry);
 
-    DATABASE_CLOSED_PROMISE_MAP.set(databaseNameKey, databaseClosedPromiseMapEntry);
-    databaseClosedPromiseMapEntry.add(databaseClosedPromise);
-
-    return Promise.all(databaseClosedPromisesToAwait).then(() => {
-        return createRxDatabaseStorageInstance<
-            Internals,
-            InstanceCreationOptions
-        >(
-            databaseInstanceToken,
-            storage,
-            name,
-            instanceCreationOptions as any,
-            multiInstance,
-            password
-        )
+    return createRxDatabaseStorageInstance<
+        Internals,
+        InstanceCreationOptions
+    >(
+        databaseInstanceToken,
+        storage,
+        name,
+        instanceCreationOptions as any,
+        multiInstance,
+        password
+    )
         /**
          * Creating the internal store might fail
          * if some RxStorage wrapper is used that does some checks
          * and then throw.
          * In that case we have to properly clean up the database.
          */
         .catch(err => {
-            closedPromiseWithResolvers.resolve();
+            USED_DATABASE_NAMES.delete(storage.name + '|' + name);
             throw err;
         })
         .then(storageInstance => {
@@ -678,8 +665,7 @@ export function createRxDatabase<
                 hashFunction,
                 cleanupPolicy,
                 allowSlowCount,
-                reactivity,
-                closedPromiseWithResolvers.resolve
+                reactivity
             ) as any;
 
             return runAsyncPluginHooks('createRxDatabase', {
@@ -697,7 +683,6 @@ export function createRxDatabase<
                 }
             }).then(() => rxDatabase);
         });
-    });
 }
 
 /**

test/unit/rx-database.test.ts

@@ -212,51 +212,19 @@ describeParallel('rx-database.test.ts', () => {
             });
             it('do not allow 2 databases with same name and storage', async () => {
                 const name = randomToken(10);
-                const storage = config.storage.getStorage();
-
-                let db1: RxDatabase | undefined;
-                let db2: RxDatabase | undefined;
-
-                const db1Promise = createRxDatabase({
-                    name,
-                    storage,
-                }).then((db1PromiseValue) => {
-                    db1 = db1PromiseValue;
-                    assert.ok(db2 === undefined);
-
-                    setTimeout(() => {
-                        db1PromiseValue.close();
-                    }, 500);
-
-                    return db1PromiseValue;
-                });
-                const db2Promise = createRxDatabase({
-                    name,
-                    storage,
-                }).then((db2PromiseValue) => {
-                    db2 = db2PromiseValue;
-                    assert.ok(db1?.closed);
-
-                    return db2PromiseValue;
-                });
-
-
-                const resolvedDb1 = await db1Promise;
-                const resolvedDb2 = await db2Promise;
-
-                assert.ok(resolvedDb1.closed);
-                assert.ok(!resolvedDb2.closed);
-
-                resolvedDb2.close();
-
-                const db3 = await createRxDatabase({
+                const db = await createRxDatabase({
                     name,
-                    storage,
+                    storage: config.storage.getStorage()
                 });
-
-                assert.ok(!db3.closed);
-
-                db3.close();
+                await AsyncTestUtil.assertThrows(
+                    () => createRxDatabase({
+                        name,
+                        storage: config.storage.getStorage()
+                    }),
+                    'RxError',
+                    'ignoreDuplicate'
+                );
+                db.close();
             });
         });
     });