refactor: workspace provider (#2218)

apps/web/src/atoms/__tests__/atom.spec.ts

@@ -0,0 +1,71 @@
+/**
+ * @vitest-environment happy-dom
+ */
+import 'fake-indexeddb/auto';
+
+import { initPage } from '@affine/env/blocksuite';
+import {
+  rootCurrentWorkspaceIdAtom,
+  rootWorkspacesMetadataAtom,
+} from '@affine/workspace/atom';
+import { createIndexedDBDownloadProvider } from '@affine/workspace/providers';
+import { WorkspaceFlavour } from '@affine/workspace/type';
+import {
+  _cleanupBlockSuiteWorkspaceCache,
+  createEmptyBlockSuiteWorkspace,
+} from '@affine/workspace/utils';
+import type { ParagraphBlockModel } from '@blocksuite/blocks/models';
+import type { Page } from '@blocksuite/store';
+import { createStore } from 'jotai';
+import { describe, expect, test } from 'vitest';
+
+import { WorkspacePlugins } from '../../plugins';
+import { rootCurrentWorkspaceAtom } from '../root';
+
+describe('currentWorkspace atom', () => {
+  test('should be defined', async () => {
+    const store = createStore();
+    let id: string;
+    {
+      const workspace = createEmptyBlockSuiteWorkspace(
+        'test',
+        WorkspaceFlavour.LOCAL
+      );
+      const page = workspace.createPage('page0');
+      initPage(page);
+      const frameId = page.getBlockByFlavour('affine:frame').at(0)
+        ?.id as string;
+      id = page.addBlock(
+        'affine:paragraph',
+        {
+          text: new page.Text('test 1'),
+        },
+        frameId
+      );
+      const provider = createIndexedDBDownloadProvider(workspace);
+      provider.sync();
+      await provider.whenReady;
+      const workspaceId = await WorkspacePlugins[
+        WorkspaceFlavour.LOCAL
+      ].CRUD.create(workspace);
+      store.set(rootWorkspacesMetadataAtom, [
+        {
+          id: workspaceId,
+          flavour: WorkspaceFlavour.LOCAL,
+        },
+      ]);
+      _cleanupBlockSuiteWorkspaceCache();
+    }
+    store.set(
+      rootCurrentWorkspaceIdAtom,
+      store.get(rootWorkspacesMetadataAtom)[0].id
+    );
+    const workspace = await store.get(rootCurrentWorkspaceAtom);
+    expect(workspace).toBeDefined();
+    const page = workspace.blockSuiteWorkspace.getPage('page0') as Page;
+    expect(page).not.toBeNull();
+    const paragraphBlock = page.getBlockById(id) as ParagraphBlockModel;
+    expect(paragraphBlock).not.toBeNull();
+    expect(paragraphBlock.text.toString()).toBe('test 1');
+  });
+});

apps/web/src/atoms/root.ts

@@ -5,6 +5,10 @@ import {
   rootCurrentWorkspaceIdAtom,
   rootWorkspacesMetadataAtom,
 } from '@affine/workspace/atom';
+import type {
+  NecessaryProvider,
+  WorkspaceRegistry,
+} from '@affine/workspace/type';
 import { WorkspaceFlavour } from '@affine/workspace/type';
 import { assertExists } from '@blocksuite/store';
 import { atom } from 'jotai';
@@ -37,18 +41,38 @@ export const workspacesAtom = atom<Promise<AllWorkspace[]>>(async get => {
         WorkspacePlugins[workspace.flavour as keyof typeof WorkspacePlugins];
       assertExists(plugin);
       const { CRUD } = plugin;
-      return CRUD.get(workspace.id);
+      return CRUD.get(workspace.id).then(workspace => {
+        if (workspace === null) {
+          console.warn(
+            'workspace is null. this should not happen. If you see this error, please report it to the developer.'
+          );
+        }
+        return workspace;
+      });
     })
+  ).then(workspaces =>
+    workspaces.filter(
+      (workspace): workspace is WorkspaceRegistry['affine' | 'local'] =>
+        workspace !== null
+    )
   );
-  logger.info('workspaces', workspaces);
-  workspaces.forEach(workspace => {
-    if (workspace === null) {
-      console.warn(
-        'workspace is null. this should not happen. If you see this error, please report it to the developer.'
-      );
+  const workspaceProviders = workspaces.map(workspace =>
+    workspace.providers.filter(
+      (provider): provider is NecessaryProvider =>
+        'necessary' in provider && provider.necessary
+    )
+  );
+  const promises: Promise<void>[] = [];
+  for (const providers of workspaceProviders) {
+    for (const provider of providers) {
+      provider.sync();
+      promises.push(provider.whenReady);
     }
-  });
-  return workspaces.filter(workspace => workspace !== null) as AllWorkspace[];
+  }
+  // we will wait for all the necessary providers to be ready
+  await Promise.all(promises);
+  logger.info('workspaces', workspaces);
+  return workspaces;
 });
 
 /**
@@ -77,6 +101,15 @@ export const rootCurrentWorkspaceAtom = atom<Promise<AllWorkspace>>(
         `cannot find the workspace with id ${targetId} in the plugin ${targetWorkspace.flavour}.`
       );
     }
+    const providers = workspace.providers.filter(
+      (provider): provider is NecessaryProvider =>
+        'necessary' in provider && provider.necessary === true
+    );
+    for (const provider of providers) {
+      provider.sync();
+      // we will wait for the necessary providers to be ready
+      await provider.whenReady;
+    }
     return workspace;
   }
 );