feat(nbstore): improve nbstore (#9512)

packages/common/nbstore/src/storage/index.ts

@@ -3,56 +3,60 @@ import EventEmitter2 from 'eventemitter2';
 import type { AwarenessStorage } from './awareness';
 import type { BlobStorage } from './blob';
 import type { DocStorage } from './doc';
-import type { Storage, StorageType } from './storage';
+import { DummyAwarenessStorage } from './dummy/awareness';
+import { DummyBlobStorage } from './dummy/blob';
+import { DummyDocStorage } from './dummy/doc';
+import { DummySyncStorage } from './dummy/sync';
+import type { StorageType } from './storage';
 import type { SyncStorage } from './sync';
 
 type Storages = DocStorage | BlobStorage | SyncStorage | AwarenessStorage;
 
+export type SpaceStorageOptions = {
+  [K in StorageType]?: Storages & { storageType: K };
+};
+
 export class SpaceStorage {
-  protected readonly storages: Map<StorageType, Storage> = new Map();
+  protected readonly storages: {
+    [K in StorageType]: Storages & { storageType: K };
+  };
   private readonly event = new EventEmitter2();
   private readonly disposables: Set<() => void> = new Set();
 
-  constructor(storages: Storage[] = []) {
-    this.storages = new Map(
-      storages.map(storage => [storage.storageType, storage])
-    );
-  }
-
-  tryGet<T extends StorageType>(
-    type: T
-  ): Extract<Storages, { storageType: T }> | undefined {
-    return this.storages.get(type) as unknown as Extract<
-      Storages,
-      { storageType: T }
-    >;
+  constructor(storages: SpaceStorageOptions) {
+    this.storages = {
+      awareness: storages.awareness ?? new DummyAwarenessStorage(),
+      blob: storages.blob ?? new DummyBlobStorage(),
+      doc: storages.doc ?? new DummyDocStorage(),
+      sync: storages.sync ?? new DummySyncStorage(),
+    };
   }
 
   get<T extends StorageType>(type: T): Extract<Storages, { storageType: T }> {
-    const storage = this.tryGet(type);
+    const storage = this.storages[type];
 
     if (!storage) {
       throw new Error(`Storage ${type} not registered.`);
     }
 
-    return storage as Extract<Storages, { storageType: T }>;
+    return storage as unknown as Extract<Storages, { storageType: T }>;
   }
 
   connect() {
-    Array.from(this.storages.values()).forEach(storage => {
+    Object.values(this.storages).forEach(storage => {
       storage.connection.connect();
     });
   }
 
   disconnect() {
-    Array.from(this.storages.values()).forEach(storage => {
+    Object.values(this.storages).forEach(storage => {
       storage.connection.disconnect();
     });
   }
 
   async waitForConnected(signal?: AbortSignal) {
     await Promise.all(
-      Array.from(this.storages.values()).map(storage =>
+      Object.values(this.storages).map(storage =>
         storage.connection.waitForConnected(signal)
       )
     );
@@ -61,13 +65,13 @@ export class SpaceStorage {
   async destroy() {
     this.disposables.forEach(disposable => disposable());
     this.event.removeAllListeners();
-    this.storages.clear();
   }
 }
 
 export * from './awareness';
 export * from './blob';
 export * from './doc';
+export * from './errors';
 export * from './history';
 export * from './storage';
 export * from './sync';