feat: implement load and warp workspace in ipc provider

packages/data-center/src/datacenter.ts

@@ -41,11 +41,11 @@ export class DataCenter {
       };
     };
     // TODO: switch different provider
-    dc.registerProvider(new LocalProvider(getInitParams()));
-    dc.registerProvider(new AffineProvider(getInitParams()));
     if (typeof window !== 'undefined' && window.CLIENT_APP) {
       dc.registerProvider(new TauriIPCProvider(getInitParams()));
     }
+    dc.registerProvider(new LocalProvider(getInitParams()));
+    dc.registerProvider(new AffineProvider(getInitParams()));
 
     return dc;
   }

packages/data-center/src/provider/tauri-ipc/index.ts

@@ -5,133 +5,122 @@ import { LocalProvider } from '../local/index.js';
 import * as ipcMethods from './ipc/methods.js';
 import { ProviderConstructorParams } from '../base.js';
 import { BlockSchema } from '@blocksuite/blocks/models.js';
-import { Workspace } from '@blocksuite/store';
-import { ConfigStore } from 'src/store.js';
-import { User, Workspace as WS, WorkspaceMeta, Logger } from '../../types';
-import { getDefaultHeadImgBlob } from 'src/utils/index.js';
+import { Workspace as BlocksuiteWorkspace } from '@blocksuite/store';
+import { WorkspaceMeta, WorkspaceInfo } from '../../types';
 import { IPCBlobProvider } from './blocksuite-provider/blob.js';
-import { PermissionType, WorkspaceDetail } from '../affine/apis/workspace.js';
+import { WorkspaceDetail } from '../affine/apis/workspace.js';
+import { setDefaultAvatar } from '../utils.js';
 
 export class TauriIPCProvider extends LocalProvider {
   static id = 'tauri-ipc';
   #ipc = ipcMethods;
-  private _workspacesCache: Map<string, Workspace> = new Map();
+  private _workspacesCache: Map<string, BlocksuiteWorkspace> = new Map();
 
   constructor(params: ProviderConstructorParams) {
     super(params);
     // TODO: let blocksuite's blob provider get blob receive workspace id. Currently, all blobs are placed together
-    this._blobs.addProvider(new IPCBlobProvider());
   }
 
-  async initData() {
-    assert(this._workspace.room);
-    this._logger('Loading local data');
-    const {
-      doc,
-      room,
-      meta: { id },
-    } = this._workspace;
-    this.#initDocFromIPC(id, doc);
-    this.#connectDocToIPC(id, doc);
-    this._logger('Local data loaded');
+  async init() {
+    // nothing to init until load workspace
   }
 
   async #initDocFromIPC(workspaceID: string, doc: Y.Doc) {
     this._logger(`Loading ${workspaceID}...`);
-    const updates = await this.#ipc.getYDocument({ id: Number(workspaceID) });
+    const updates = await this.#ipc.getYDocument({ id: workspaceID });
     if (updates) {
       await new Promise(resolve => {
         doc.once('update', resolve);
         Y.applyUpdate(doc, new Uint8Array(updates.update));
       });
       this._logger(`Loaded: ${workspaceID}`);
-
-      // only add to list as online workspace
-      this._signals.listAdd.emit({
-        workspace: workspaceID,
-        provider: this.id,
-        locally: true,
-      });
     }
   }
 
   async #connectDocToIPC(workspaceID: string, doc: Y.Doc) {
     this._logger(`Connecting yDoc for ${workspaceID}...`);
-    doc.on(
-      'update',
-      async (
-        update: Uint8Array,
-        _origin: any,
-        _yDocument: Y.Doc,
-        _transaction: Y.Transaction
-      ) => {
-        try {
-          // TODO: need handle potential data race when update is frequent?
-          // TODO: update seems too frequent upon each keydown, why no batching?
-          const success = await this.#ipc.updateYDocument({
-            update: Array.from(update),
-            id: Number(workspaceID),
-          });
-          if (!success) {
-            throw new Error(
-              `YDoc update failed, id: ${this.workspace.meta.id}`
-            );
-          }
-        } catch (error) {
-          // TODO: write error log to disk, and add button to open them in settings panel
-          console.error("#yDocument.on('update'", error);
+    doc.on('update', async (update: Uint8Array) => {
+      try {
+        // TODO: need handle potential data race when update is frequent?
+        // TODO: update seems too frequent upon each keydown, why no batching?
+        const success = await this.#ipc.updateYDocument({
+          update: Array.from(update),
+          id: workspaceID,
+        });
+        if (!success) {
+          throw new Error(`YDoc update failed, id: ${workspaceID}`);
         }
+      } catch (error) {
+        // TODO: write error log to disk, and add button to open them in settings panel
+        console.error("#yDocument.on('update'", error);
       }
-    );
-  }
-
-  static async auth(
-    _config: Readonly<ConfigStore<string>>,
-    _logger: Logger,
-    _signals: DataCenterSignals
-  ) {
-    // no auth on local provider
+    });
   }
 
   async clear() {
     await super.clear();
   }
 
-  public override async createWorkspace(
+  public override async createWorkspaceInfo(
     meta: WorkspaceMeta
-  ): Promise<Workspace | undefined> {
-    assert(meta.name, 'Workspace name is required');
-    if (!meta.avatar) {
-      // set default avatar
-      const blob = await getDefaultHeadImgBlob(meta.name);
-      meta.avatar = (await this.setBlob(blob)) || '';
-    }
+  ): Promise<WorkspaceInfo> {
     const { id } = await this.#ipc.createWorkspace({
       name: meta.name,
       // TODO: get userID here
       user_id: 0,
     });
-    this._logger('Creating affine workspace');
-    const nw = new Workspace({
-      room: id,
-    }).register(BlockSchema);
-    nw.meta.setName(meta.name);
-    nw.meta.setAvatar(meta.avatar);
-    // this._initWorkspaceDb(nw);
 
-    const workspaceInfo: WS = {
+    const workspaceInfo: WorkspaceInfo = {
       name: meta.name,
-      id,
+      id: id,
+      isPublish: false,
+      avatar: '',
+      owner: await this.getUserInfo(),
+      isLocal: true,
+      memberCount: 1,
+      provider: this.id,
+    };
+    return workspaceInfo;
+  }
+
+  override async warpWorkspace(blocksuiteWorkspace: BlocksuiteWorkspace) {
+    const { doc, room } = blocksuiteWorkspace;
+    assert(room);
+
+    (await blocksuiteWorkspace.blobs)?.addProvider(new IPCBlobProvider());
+    await this.#initDocFromIPC(room, doc);
+    await this.#connectDocToIPC(room, doc);
+
+    return blocksuiteWorkspace;
+  }
+
+  public override async createWorkspace(
+    blocksuiteWorkspace: BlocksuiteWorkspace,
+    meta: WorkspaceMeta
+  ): Promise<BlocksuiteWorkspace | undefined> {
+    const workspaceId = blocksuiteWorkspace.room;
+    assert(workspaceId, 'Blocksuite Workspace without room(workspaceId).');
+    this._logger('Creating affine workspace');
+
+    this.linkLocal(blocksuiteWorkspace);
+
+    const workspaceInfo: WorkspaceInfo = {
+      name: meta.name,
+      id: workspaceId,
       isPublish: false,
       avatar: '',
       owner: undefined,
       isLocal: true,
       memberCount: 1,
-      provider: 'local',
+      provider: 'affine',
     };
 
+    if (!blocksuiteWorkspace.meta.avatar) {
+      await setDefaultAvatar(blocksuiteWorkspace);
+      workspaceInfo.avatar = blocksuiteWorkspace.meta.avatar;
+    }
     this._workspaces.add(workspaceInfo);
-    return nw;
+    return blocksuiteWorkspace;
   }
 
   override async loadWorkspaces() {
@@ -139,7 +128,7 @@ export class TauriIPCProvider extends LocalProvider {
     const { workspaces: workspacesList } = await this.#ipc.getWorkspaces({
       user_id: 0,
     });
-    const workspaces: WS[] = workspacesList.map(w => {
+    const workspaces: WorkspaceInfo[] = workspacesList.map(w => {
       return {
         ...w,
         memberCount: 0,
@@ -150,12 +139,12 @@ export class TauriIPCProvider extends LocalProvider {
     const workspaceInstances = workspaces.map(({ id }) => {
       const workspace =
         this._workspacesCache.get(id) ||
-        new Workspace({
+        new BlocksuiteWorkspace({
           room: id,
         }).register(BlockSchema);
       this._workspacesCache.set(id, workspace);
       if (workspace) {
-        return new Promise<Workspace>(resolve => {
+        return new Promise<BlocksuiteWorkspace>(resolve => {
           this.#ipc.getYDocument({ id }).then(({ update }) => {
             Y.applyUpdate(workspace.doc, new Uint8Array(update));
             resolve(workspace);