Merge remote-tracking branch 'refs/remotes/origin/feat/cloud-sync-saika'

Conflicts: packages/data-center/package.json packages/data-center/src/datacenter.ts packages/data-center/src/index.ts pnpm-lock.yaml
2026-02-24 01:42:55 +08:00 · 2023-01-11 18:30:57 +08:00
parent 2c06dbf2aa 7e77175679
commit 107419cb8d
27 changed files with 857 additions and 3855 deletions
--- a/packages/data-center/src/datacenter.ts
+++ b/packages/data-center/src/datacenter.ts
@@ -1,22 +1,26 @@
-import { WorkspaceMetaCollection } from './workspace-meta-collection.js';
-import type { WorkspaceMetaCollectionChangeEvent } from './workspace-meta-collection';
+import { WorkspaceUnitCollection } from './workspace-unit-collection.js';
+import type { WorkspaceUnitCollectionChangeEvent } from './workspace-unit-collection';
 import { Workspace as BlocksuiteWorkspace } from '@blocksuite/store';
-import { BaseProvider } from './provider/base';
+import type {
+  BaseProvider,
+  CreateWorkspaceInfoParams,
+  UpdateWorkspaceMetaParams,
+} from './provider/base';
 import { LocalProvider } from './provider/local/local';
 import { AffineProvider } from './provider';
-import type { Message, WorkspaceMeta } from './types';
+import type { Message } from './types';
 import assert from 'assert';
 import { getLogger } from './logger';
-import { applyUpdate, encodeStateAsUpdate } from 'yjs';
 import { createBlocksuiteWorkspace } from './utils/index.js';
 import { MessageCenter } from './message';
+import type { WorkspaceUnit } from './workspace-unit';

 /**
 * @class DataCenter
 * @classdesc Data center is made for managing different providers for business
 */
 export class DataCenter {
-  private readonly _workspaceMetaCollection = new WorkspaceMetaCollection();
+  private readonly _workspaceUnitCollection = new WorkspaceUnitCollection();
  private readonly _logger = getLogger('dc');
  private _workspaceInstances: Map<string, BlocksuiteWorkspace> = new Map();
  private _messageCenter = new MessageCenter();
@@ -35,7 +39,7 @@ export class DataCenter {
    const getInitParams = () => {
      return {
        logger: dc._logger,
-        workspaces: dc._workspaceMetaCollection.createScope(),
+        workspaces: dc._workspaceUnitCollection.createScope(),
        messageCenter: dc._messageCenter,
      };
    };
@@ -46,11 +50,15 @@ export class DataCenter {
      typeof window.__TAURI_IPC__ === 'function'
    ) {
      const { TauriIPCProvider } = await import('./provider/tauri-ipc');
-      dc.registerProvider(new TauriIPCProvider(getInitParams()));
+      await dc.registerProvider(new TauriIPCProvider(getInitParams()));
    } else {
-      dc.registerProvider(new LocalProvider(getInitParams()));
+      await dc.registerProvider(new LocalProvider(getInitParams()));
+    }
+    await dc.registerProvider(new AffineProvider(getInitParams()));
+
+    for (const provider of dc.providerMap.values()) {
+      await provider.loadWorkspaces();
    }
-    dc.registerProvider(new AffineProvider(getInitParams()));

    return dc;
  }
@@ -59,12 +67,12 @@ export class DataCenter {
   * Register provider.
   * We will automatically set the first provider to default provider.
   */
-  registerProvider(provider: BaseProvider) {
+  async registerProvider(provider: BaseProvider) {
    if (!this._mainProvider) {
      this._mainProvider = provider;
    }

-    provider.init();
+    await provider.init();
    this.providerMap.set(provider.id, provider);
  }

@@ -77,7 +85,7 @@ export class DataCenter {
  }

  public get workspaces() {
-    return this._workspaceMetaCollection.workspaces;
+    return this._workspaceUnitCollection.workspaces;
  }

  public async refreshWorkspaces() {
@@ -91,20 +99,19 @@ export class DataCenter {
   * @param {string} name workspace name
   * @returns {Promise<Workspace>}
   */
-  public async createWorkspace(workspaceMeta: WorkspaceMeta) {
+  public async createWorkspace(params: CreateWorkspaceInfoParams) {
    assert(
      this._mainProvider,
      'There is no provider. You should add provider first.'
    );

-    const workspaceInfo = await this._mainProvider.createWorkspaceInfo(
-      workspaceMeta
-    );
+    const workspaceMeta = await this._mainProvider.createWorkspaceInfo(params);

-    const workspace = createBlocksuiteWorkspace(workspaceInfo.id);
+    const workspace = createBlocksuiteWorkspace(workspaceMeta.id);

    await this._mainProvider.createWorkspace(workspace, workspaceMeta);
-    return workspace;
+    const workspaceUnit = this._workspaceUnitCollection.find(workspaceMeta.id);
+    return workspaceUnit;
  }

  /**
@@ -112,7 +119,7 @@ export class DataCenter {
   * @param {string} workspaceId workspace id
   */
  public async deleteWorkspace(workspaceId: string) {
-    const workspaceInfo = this._workspaceMetaCollection.find(workspaceId);
+    const workspaceInfo = this._workspaceUnitCollection.find(workspaceId);
    assert(workspaceInfo, 'Workspace not found');
    const provider = this.providerMap.get(workspaceInfo.provider);
    assert(provider, `Workspace exists, but we couldn't find its provider.`);
@@ -124,10 +131,10 @@ export class DataCenter {
   * @param {string} workspaceId workspace id
   */
  private _getBlocksuiteWorkspace(workspaceId: string) {
-    const workspaceInfo = this._workspaceMetaCollection.find(workspaceId);
+    const workspaceInfo = this._workspaceUnitCollection.find(workspaceId);
    assert(workspaceInfo, 'Workspace not found');
    return (
-      this._workspaceInstances.get(workspaceId) ||
+      // this._workspaceInstances.get(workspaceId) ||
      createBlocksuiteWorkspace(workspaceId)
    );
  }
@@ -155,21 +162,26 @@ export class DataCenter {
  /**
   * load workspace instance by id
   * @param {string} workspaceId workspace id
-   * @returns {Promise<BlocksuiteWorkspace>}
+   * @returns {Promise<WorkspaceUnit>}
   */
  public async loadWorkspace(workspaceId: string) {
-    const workspaceInfo = this._workspaceMetaCollection.find(workspaceId);
-    assert(workspaceInfo, 'Workspace not found');
-    const currentProvider = this.providerMap.get(workspaceInfo.provider);
+    const workspaceUnit = this._workspaceUnitCollection.find(workspaceId);
+    assert(workspaceUnit, 'Workspace not found');
+    const currentProvider = this.providerMap.get(workspaceUnit.provider);
    if (currentProvider) {
      currentProvider.closeWorkspace(workspaceId);
    }
-    const provider = this.providerMap.get(workspaceInfo.provider);
-    assert(provider, `provide '${workspaceInfo.provider}' is not registered`);
-    this._logger(`Loading ${workspaceInfo.provider} workspace: `, workspaceId);
+    const provider = this.providerMap.get(workspaceUnit.provider);
+    assert(provider, `provide '${workspaceUnit.provider}' is not registered`);
+    this._logger(`Loading ${workspaceUnit.provider} workspace: `, workspaceId);
    const workspace = this._getBlocksuiteWorkspace(workspaceId);
    this._workspaceInstances.set(workspaceId, workspace);
-    return await provider.warpWorkspace(workspace);
+    await provider.warpWorkspace(workspace);
+    this._workspaceUnitCollection.workspaces.forEach(workspaceUnit => {
+      workspaceUnit.setBlocksuiteWorkspace(null);
+    });
+    workspaceUnit.setBlocksuiteWorkspace(workspace);
+    return workspaceUnit;
  }

  /**
@@ -189,22 +201,30 @@ export class DataCenter {
   * @param {Function} callback callback function
   */
  public async onWorkspacesChange(
-    callback: (workspaces: WorkspaceMetaCollectionChangeEvent) => void
+    callback: (workspaces: WorkspaceUnitCollectionChangeEvent) => void,
+    { immediate = true }: { immediate?: boolean } = {}
  ) {
-    this._workspaceMetaCollection.on('change', callback);
+    if (immediate) {
+      callback({
+        added: this._workspaceUnitCollection.workspaces,
+      });
+    }
+    this._workspaceUnitCollection.on('change', callback);
  }

  /**
   * change workspaces meta
   * @param {WorkspaceMeta} workspaceMeta workspace meta
-   * @param {BlocksuiteWorkspace} workspace workspace instance
+   * @param {WorkspaceUnit} workspace workspace instance
   */
  public async updateWorkspaceMeta(
-    { name, avatar }: Partial<WorkspaceMeta>,
-    workspace: BlocksuiteWorkspace
+    { name, avatar }: UpdateWorkspaceMetaParams,
+    workspaceUnit: WorkspaceUnit
  ) {
-    assert(workspace?.room, 'No workspace to set meta');
-    const update: Partial<WorkspaceMeta> = {};
+    assert(workspaceUnit?.id, 'No workspace to set meta');
+    const workspace = workspaceUnit.blocksuiteWorkspace;
+    assert(workspace);
+    const update: Partial<UpdateWorkspaceMetaParams> = {};
    if (name) {
      workspace.meta.setName(name);
      update.name = name;
@@ -214,10 +234,10 @@ export class DataCenter {
      update.avatar = avatar;
    }
    // may run for change workspace meta
-    const workspaceInfo = this._workspaceMetaCollection.find(workspace.room);
+    const workspaceInfo = this._workspaceUnitCollection.find(workspaceUnit.id);
    assert(workspaceInfo, 'Workspace not found');
    const provider = this.providerMap.get(workspaceInfo.provider);
-    provider?.updateWorkspaceMeta(workspace.room, update);
+    provider?.updateWorkspaceMeta(workspaceUnit.id, update);
  }

  /**
@@ -226,7 +246,7 @@ export class DataCenter {
   * @param id workspace id
   */
  public async leaveWorkspace(workspaceId: string) {
-    const workspaceInfo = this._workspaceMetaCollection.find(workspaceId);
+    const workspaceInfo = this._workspaceUnitCollection.find(workspaceId);
    assert(workspaceInfo, 'Workspace not found');
    const provider = this.providerMap.get(workspaceInfo.provider);
    if (provider) {
@@ -236,7 +256,7 @@ export class DataCenter {
  }

  public async setWorkspacePublish(workspaceId: string, isPublish: boolean) {
-    const workspaceInfo = this._workspaceMetaCollection.find(workspaceId);
+    const workspaceInfo = this._workspaceUnitCollection.find(workspaceId);
    assert(workspaceInfo, 'Workspace not found');
    const provider = this.providerMap.get(workspaceInfo.provider);
    if (provider) {
@@ -244,12 +264,17 @@ export class DataCenter {
    }
  }

-  public async inviteMember(id: string, email: string) {
-    const workspaceInfo = this._workspaceMetaCollection.find(id);
+  /**
+   * invite the new member to the workspace
+   * @param {string} workspaceId workspace id
+   * @param {string} email
+   */
+  public async inviteMember(workspaceId: string, email: string) {
+    const workspaceInfo = this._workspaceUnitCollection.find(workspaceId);
    assert(workspaceInfo, 'Workspace not found');
    const provider = this.providerMap.get(workspaceInfo.provider);
    if (provider) {
-      await provider.invite(id, email);
+      await provider.invite(workspaceId, email);
    }
  }

@@ -258,7 +283,7 @@ export class DataCenter {
   * @param {number} permissionId permission id
   */
  public async removeMember(workspaceId: string, permissionId: number) {
-    const workspaceInfo = this._workspaceMetaCollection.find(workspaceId);
+    const workspaceInfo = this._workspaceUnitCollection.find(workspaceId);
    assert(workspaceInfo, 'Workspace not found');
    const provider = this.providerMap.get(workspaceInfo.provider);
    if (provider) {
@@ -289,7 +314,7 @@ export class DataCenter {
    providerId: string
  ) {
    assert(workspace.room, 'No workspace id');
-    const workspaceInfo = this._workspaceMetaCollection.find(workspace.room);
+    const workspaceInfo = this._workspaceUnitCollection.find(workspace.room);
    assert(workspaceInfo, 'Workspace not found');
    if (workspaceInfo.provider === providerId) {
      this._logger('Workspace provider is same');
@@ -302,11 +327,12 @@ export class DataCenter {
    this._logger(`create ${providerId} workspace: `, workspaceInfo.name);
    const newWorkspaceInfo = await newProvider.createWorkspaceInfo({
      name: workspaceInfo.name,
-      avatar: workspaceInfo.avatar,
+      // avatar: workspaceInfo.avatar,
    });
    const newWorkspace = createBlocksuiteWorkspace(newWorkspaceInfo.id);
    // TODO optimize this function
    await newProvider.createWorkspace(newWorkspace, {
+      ...newWorkspaceInfo,
      name: workspaceInfo.name,
      avatar: workspaceInfo.avatar,
    });
@@ -315,7 +341,7 @@ export class DataCenter {
    this._logger(
      `update workspace data from ${workspaceInfo.provider} to ${providerId}`
    );
-    applyUpdate(newWorkspace.doc, encodeStateAsUpdate(workspace.doc));
+    await newProvider.assign(newWorkspace, workspace);
    assert(newWorkspace, 'Create workspace failed');
    await currentProvider.deleteWorkspace(workspace.room);
    return newWorkspace.room;
@@ -325,9 +351,13 @@ export class DataCenter {
   * Enable workspace cloud
   * @param {string} id ID of workspace.
   */
-  public async enableWorkspaceCloud(workspace: BlocksuiteWorkspace) {
-    assert(workspace?.room, 'No workspace to enable cloud');
-    return await this._transWorkspaceProvider(workspace, 'affine');
+  public async enableWorkspaceCloud(workspace: WorkspaceUnit) {
+    assert(workspace?.id, 'No workspace to enable cloud');
+    assert(workspace.blocksuiteWorkspace);
+    return await this._transWorkspaceProvider(
+      workspace.blocksuiteWorkspace,
+      'affine'
+    );
  }

  /**
@@ -364,10 +394,10 @@ export class DataCenter {
   * @returns {Promise<string | null>} blob url
   */
  async getBlob(
-    workspace: BlocksuiteWorkspace,
+    workspaceUnit: WorkspaceUnit,
    id: string
  ): Promise<string | null> {
-    const blob = await workspace.blobs;
+    const blob = await workspaceUnit.blocksuiteWorkspace?.blobs;
    return (await blob?.get(id)) || '';
  }

@@ -376,11 +406,25 @@ export class DataCenter {
   * @param id
   * @returns {Promise<string | null>} blob url
   */
-  async setBlob(workspace: BlocksuiteWorkspace, blob: Blob): Promise<string> {
-    const blobStorage = await workspace.blobs;
+  async setBlob(workspace: WorkspaceUnit, blob: Blob): Promise<string> {
+    const blobStorage = await workspace.blocksuiteWorkspace?.blobs;
    return (await blobStorage?.set(blob)) || '';
  }

+  /**
+   * get members of a workspace
+   * @param workspaceId
+   */
+  async getMembers(workspaceId: string) {
+    const workspaceInfo = this._workspaceUnitCollection.find(workspaceId);
+    assert(workspaceInfo, 'Workspace not found');
+    const provider = this.providerMap.get(workspaceInfo.provider);
+    if (provider) {
+      return await provider.getWorkspaceMembers(workspaceId);
+    }
+    return [];
+  }
+
  onMessage(cb: (message: Message) => void) {
    return this._messageCenter.onMessage(cb);
  }
--- a/packages/data-center/src/index.ts
+++ b/packages/data-center/src/index.ts
@@ -27,6 +27,6 @@ export const getDataCenter = _initializeDataCenter();

 export type { DataCenter };
 export type { AccessTokenMessage } from './provider/affine/apis';
-export * from './types';
+export { WorkspaceUnit } from './workspace-unit';
 export { getLogger } from './logger';
 export * from './message';
--- a/packages/data-center/src/message/index.ts
+++ b/packages/data-center/src/message/index.ts
@@ -1,2 +1,2 @@
-export { MessageCenter } from './message';
-export { MessageCode } from './code';
+export { MessageCenter } from './message.js';
+export { MessageCode } from './code.js';
--- a/packages/data-center/src/message/message.ts
+++ b/packages/data-center/src/message/message.ts
@@ -1,6 +1,6 @@
 import { Observable } from 'lib0/observable';
 import { Message } from '../types';
-import { MessageCode } from './code';
+import { MessageCode } from './code.js';

 export class MessageCenter extends Observable<string> {
  constructor() {
--- a/packages/data-center/src/provider/affine/affine.ts
+++ b/packages/data-center/src/provider/affine/affine.ts
@@ -1,9 +1,12 @@
 import { BaseProvider } from '../base.js';
-import type { ProviderConstructorParams } from '../base';
-import type { User, WorkspaceInfo, WorkspaceMeta } from '../../types';
+import type {
+  ProviderConstructorParams,
+  CreateWorkspaceInfoParams,
+  WorkspaceMeta0,
+} from '../base';
+import type { User } from '../../types';
 import { Workspace as BlocksuiteWorkspace } from '@blocksuite/store';
 import { BlockSchema } from '@blocksuite/blocks/models';
-import { applyUpdate } from 'yjs';
 import { storage } from './storage.js';
 import assert from 'assert';
 import { WebsocketProvider } from './sync.js';
@@ -12,28 +15,39 @@ import { getApis } from './apis/index.js';
 import type { Apis, WorkspaceDetail, Callback } from './apis';
 import { setDefaultAvatar } from '../utils.js';
 import { MessageCode } from '../../message';
+import { token } from './apis/token.js';
+import { WebsocketClient } from './channel';

 export interface AffineProviderConstructorParams
  extends ProviderConstructorParams {
  apis?: Apis;
 }

+const {
+  Y: { applyUpdate, encodeStateAsUpdate },
+} = BlocksuiteWorkspace;
+
 export class AffineProvider extends BaseProvider {
  public id = 'affine';
  private _workspacesCache: Map<string, BlocksuiteWorkspace> = new Map();
  private _onTokenRefresh?: Callback = undefined;
  private _wsMap: Map<string, WebsocketProvider> = new Map();
  private _apis: Apis;
+  private _channel: WebsocketClient;
  // private _idbMap: Map<string, IndexedDBProvider> = new Map();

  constructor({ apis, ...params }: AffineProviderConstructorParams) {
    super(params);
    this._apis = apis || getApis();
-    this.init().then(() => {
-      if (this._apis.token.isLogin) {
-        this.loadWorkspaces();
-      }
-    });
+    this._channel = new WebsocketClient(
+      `${window.location.protocol === 'https:' ? 'wss' : 'ws'}://${
+        window.location.host
+      }/global/sync/`,
+      this._logger
+    );
+    if (token.isLogin) {
+      this._connectChannel();
+    }
  }

  override async init() {
@@ -64,6 +78,32 @@ export class AffineProvider extends BaseProvider {
    }
  }

+  private _connectChannel() {
+    this._channel.connect();
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    this._channel.on('message', (message: any) => {
+      console.log('message', message);
+    });
+  }
+
+  private _getWebsocketProvider(workspace: BlocksuiteWorkspace) {
+    const { doc, room } = workspace;
+    assert(room);
+    assert(doc);
+    let ws = this._wsMap.get(room);
+    if (!ws) {
+      const wsUrl = `${
+        window.location.protocol === 'https:' ? 'wss' : 'ws'
+      }://${window.location.host}/api/sync/`;
+      ws = new WebsocketProvider(wsUrl, room, doc, {
+        params: { token: this._apis.token.refresh },
+      });
+      this._wsMap.set(room, ws);
+    }
+    return ws;
+  }
+
  private async _applyCloudUpdates(blocksuiteWorkspace: BlocksuiteWorkspace) {
    const { doc, room: workspaceId } = blocksuiteWorkspace;
    assert(workspaceId, 'Blocksuite Workspace without room(workspaceId).');
@@ -78,20 +118,10 @@ export class AffineProvider extends BaseProvider {

  override async warpWorkspace(workspace: BlocksuiteWorkspace) {
    await this._applyCloudUpdates(workspace);
-    const { doc, room } = workspace;
+    const { room } = workspace;
    assert(room);
    this.linkLocal(workspace);
-
-    let ws = this._wsMap.get(room);
-    if (!ws) {
-      const wsUrl = `${
-        window.location.protocol === 'https:' ? 'wss' : 'ws'
-      }://${window.location.host}/api/sync/`;
-      ws = new WebsocketProvider(wsUrl, room, doc, {
-        params: { token: this._apis.token.refresh },
-      });
-      this._wsMap.set(room, ws);
-    }
+    const ws = this._getWebsocketProvider(workspace);
    // close all websocket links
    Array.from(this._wsMap.entries()).forEach(([id, ws]) => {
      if (id !== room) {
@@ -115,12 +145,13 @@ export class AffineProvider extends BaseProvider {
      return [];
    }
    const workspacesList = await this._apis.getWorkspaces();
-    const workspaces: WorkspaceInfo[] = workspacesList.map(w => {
+    const workspaces: WorkspaceMeta0[] = workspacesList.map(w => {
      return {
        ...w,
        memberCount: 0,
        name: '',
        provider: 'affine',
+        syncMode: 'core',
      };
    });
    const workspaceInstances = workspaces.map(({ id }) => {
@@ -198,6 +229,9 @@ export class AffineProvider extends BaseProvider {
      }
    }
    const user = await this._apis.signInWithGoogle?.();
+    if (!this._channel.connected) {
+      this._connectChannel();
+    }
    if (!user) {
      this._messageCenter.send(MessageCode.loginError);
    }
@@ -205,6 +239,7 @@ export class AffineProvider extends BaseProvider {

  public override async getUserInfo(): Promise<User | undefined> {
    const user = this._apis.token.user;
+    await this.init;
    return user
      ? {
          id: user.id,
@@ -268,19 +303,17 @@ export class AffineProvider extends BaseProvider {
  }

  public override async createWorkspaceInfo(
-    meta: WorkspaceMeta
-  ): Promise<WorkspaceInfo> {
-    const { id } = await this._apis.createWorkspace(
-      meta as Required<WorkspaceMeta>
-    );
+    meta: CreateWorkspaceInfoParams
+  ): Promise<WorkspaceMeta0> {
+    const { id } = await this._apis.createWorkspace(meta);

-    const workspaceInfo: WorkspaceInfo = {
+    const workspaceInfo: WorkspaceMeta0 = {
      name: meta.name,
      id: id,
-      isPublish: false,
+      published: false,
      avatar: '',
      owner: await this.getUserInfo(),
-      isLocal: true,
+      syncMode: 'core',
      memberCount: 1,
      provider: 'affine',
    };
@@ -289,7 +322,7 @@ export class AffineProvider extends BaseProvider {

  public override async createWorkspace(
    blocksuiteWorkspace: BlocksuiteWorkspace,
-    meta: WorkspaceMeta
+    meta: WorkspaceMeta0
  ): Promise<BlocksuiteWorkspace | undefined> {
    const workspaceId = blocksuiteWorkspace.room;
    assert(workspaceId, 'Blocksuite Workspace without room(workspaceId).');
@@ -298,13 +331,13 @@ export class AffineProvider extends BaseProvider {
    this._applyCloudUpdates(blocksuiteWorkspace);
    this.linkLocal(blocksuiteWorkspace);

-    const workspaceInfo: WorkspaceInfo = {
+    const workspaceInfo: WorkspaceMeta0 = {
      name: meta.name,
      id: workspaceId,
-      isPublish: false,
+      published: false,
      avatar: '',
      owner: undefined,
-      isLocal: true,
+      syncMode: 'core',
      memberCount: 1,
      provider: 'affine',
    };
@@ -335,4 +368,33 @@ export class AffineProvider extends BaseProvider {
        }
      : null;
  }
+
+  public override async assign(
+    to: BlocksuiteWorkspace,
+    from: BlocksuiteWorkspace
+  ): Promise<BlocksuiteWorkspace> {
+    assert(to.room, 'Blocksuite Workspace without room(workspaceId).');
+    const ws = this._getWebsocketProvider(to);
+    applyUpdate(to.doc, encodeStateAsUpdate(from.doc));
+    // TODO: upload blobs and make sure doc is synced
+    await new Promise<void>((resolve, reject) => {
+      ws.once('synced', () => {
+        setTimeout(() => resolve(), 1000);
+      });
+      ws.once('lost-connection', () => reject());
+      ws.once('connection-error', () => reject());
+    });
+    return to;
+  }
+
+  public override async logout(): Promise<void> {
+    token.clear();
+    this._channel.disconnect();
+    this._wsMap.forEach(ws => ws.disconnect());
+    storage.removeItem('token');
+  }
+
+  public override async getWorkspaceMembers(id: string) {
+    return this._apis.getWorkspaceMembers({ id });
+  }
 }
--- a/packages/data-center/src/provider/affine/apis/token.ts
+++ b/packages/data-center/src/provider/affine/apis/token.ts
@@ -140,6 +140,10 @@ class Token {
      this.callbacks.splice(index, 1);
    }
  }
+
+  clear() {
+    this._setToken();
+  }
 }

 export const token = new Token();
--- a/packages/data-center/src/provider/affine/apis/workspace.ts
+++ b/packages/data-center/src/provider/affine/apis/workspace.ts
@@ -79,7 +79,6 @@ export async function getWorkspaceMembers(

 export interface CreateWorkspaceParams {
  name: string;
-  avatar: string;
 }

 export async function createWorkspace(
--- a/packages/data-center/src/provider/affine/channel.ts
+++ b/packages/data-center/src/provider/affine/channel.ts
@@ -0,0 +1,53 @@
+import websocket from 'lib0/websocket';
+import { Logger } from 'src/types';
+import { token } from './apis/token';
+
+const RECONNECT_INTERVAL_TIME = 5000;
+const MAX_RECONNECT_TIMES = 50;
+
+export class WebsocketClient extends websocket.WebsocketClient {
+  public shouldReconnect = false;
+  private _reconnectInterval: number | null = null;
+  private _logger: Logger;
+  constructor(
+    url: string,
+    logger: Logger,
+    options?: { binaryType: 'arraybuffer' | 'blob' | null }
+  ) {
+    super(url, options);
+    this._logger = logger;
+    this._setupChannel();
+  }
+
+  private _setupChannel() {
+    this.on('connect', () => {
+      this._logger('Affine channel connected');
+      this.shouldReconnect = true;
+      if (this._reconnectInterval) {
+        window.clearInterval(this._reconnectInterval);
+      }
+    });
+
+    this.on('disconnect', ({ error }: { error: Error }) => {
+      if (error) {
+        let times = 0;
+        // Try reconnect if connect error has occurred
+        this._reconnectInterval = window.setInterval(() => {
+          if (this.shouldReconnect && token.isLogin && !this.connected) {
+            try {
+              this.connect();
+              this._logger(`try reconnect channel ${++times} times`);
+              if (times > MAX_RECONNECT_TIMES) {
+                this._logger('reconnect failed, max reconnect times reached');
+                this._reconnectInterval &&
+                  window.clearInterval(this._reconnectInterval);
+              }
+            } catch (e) {
+              this._logger('reconnect failed', e);
+            }
+          }
+        }, RECONNECT_INTERVAL_TIME);
+      }
+    });
+  }
+}
--- a/packages/data-center/src/provider/base.ts
+++ b/packages/data-center/src/provider/base.ts
@@ -1,7 +1,9 @@
 import { Workspace as BlocksuiteWorkspace, uuidv4 } from '@blocksuite/store';
 import { MessageCenter } from '../message';
-import { Logger, User, WorkspaceInfo, WorkspaceMeta } from '../types';
-import type { WorkspaceMetaCollectionScope } from '../workspace-meta-collection';
+import { Logger, User } from '../types';
+import type { WorkspaceUnitCollectionScope } from '../workspace-unit-collection';
+import type { WorkspaceUnitCtorParams } from '../workspace-unit';
+import { Member } from './affine/apis';

 const defaultLogger = () => {
  return;
@@ -9,13 +11,19 @@ const defaultLogger = () => {

 export interface ProviderConstructorParams {
  logger?: Logger;
-  workspaces: WorkspaceMetaCollectionScope;
+  workspaces: WorkspaceUnitCollectionScope;
  messageCenter: MessageCenter;
 }

+export type WorkspaceMeta0 = WorkspaceUnitCtorParams;
+export type CreateWorkspaceInfoParams = Pick<WorkspaceUnitCtorParams, 'name'>;
+export type UpdateWorkspaceMetaParams = Partial<
+  Pick<WorkspaceUnitCtorParams, 'name' | 'avatar'>
+>;
+
 export class BaseProvider {
  public readonly id: string = 'base';
-  protected _workspaces!: WorkspaceMetaCollectionScope;
+  protected _workspaces!: WorkspaceUnitCollectionScope;
  protected _logger!: Logger;
  protected _messageCenter!: MessageCenter;

@@ -37,8 +45,8 @@ export class BaseProvider {
  }

  public async createWorkspaceInfo(
-    meta: WorkspaceMeta
-  ): Promise<WorkspaceInfo> {
+    params: CreateWorkspaceInfoParams
+  ): Promise<WorkspaceMeta0> {
    throw new Error(`provider: ${this.id} createWorkspaceInfo Not implemented`);
  }

@@ -70,7 +78,7 @@ export class BaseProvider {
  /**
   * load workspaces
   **/
-  public async loadWorkspaces(): Promise<WorkspaceInfo[]> {
+  public async loadWorkspaces(): Promise<WorkspaceMeta0[]> {
    throw new Error(`provider: ${this.id} loadWorkSpace Not implemented`);
  }

@@ -157,10 +165,10 @@ export class BaseProvider {
   */
  public async updateWorkspaceMeta(
    id: string,
-    meta: Partial<WorkspaceMeta>
+    params: UpdateWorkspaceMetaParams
  ): Promise<void> {
    id;
-    meta;
+    params;
    return;
  }

@@ -170,7 +178,7 @@ export class BaseProvider {
   */
  public async createWorkspace(
    blocksuiteWorkspace: BlocksuiteWorkspace,
-    meta: WorkspaceMeta
+    meta: WorkspaceMeta0
  ): Promise<BlocksuiteWorkspace | undefined> {
    return blocksuiteWorkspace;
  }
@@ -196,4 +204,24 @@ export class BaseProvider {
  ): Promise<BlocksuiteWorkspace> {
    return workspace;
  }
+
+  /**
+   * merge one workspaces to another
+   * @param workspace
+   * @returns
+   */
+  public async assign(to: BlocksuiteWorkspace, from: BlocksuiteWorkspace) {
+    from;
+    return to;
+  }
+
+  /**
+   * get workspace members
+   * @param {string} workspaceId
+   * @returns
+   */
+  public getWorkspaceMembers(workspaceId: string): Promise<Member[]> {
+    workspaceId;
+    return Promise.resolve([]);
+  }
 }
--- a/packages/data-center/src/provider/local/indexeddb/indexeddb.ts
+++ b/packages/data-center/src/provider/local/indexeddb/indexeddb.ts
@@ -1,14 +1,19 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import * as idb from 'lib0/indexeddb.js';
 import { Observable } from 'lib0/observable.js';
-import type { Doc } from 'yjs';
-import { applyUpdate, encodeStateAsUpdate, transact } from 'yjs';
+import { Workspace as BlocksuiteWorkspace } from '@blocksuite/store';

 const customStoreName = 'custom';
 const updatesStoreName = 'updates';

 const PREFERRED_TRIM_SIZE = 500;

+const {
+  Y: { applyUpdate, transact, encodeStateAsUpdate },
+} = BlocksuiteWorkspace;
+
+type Doc = Parameters<typeof transact>[0];
+
 const fetchUpdates = async (provider: IndexedDBProvider) => {
  const [updatesStore] = idb.transact(provider.db as IDBDatabase, [
    updatesStoreName,
--- a/packages/data-center/src/provider/local/indexeddb/utils.ts
+++ b/packages/data-center/src/provider/local/indexeddb/utils.ts
@@ -0,0 +1,20 @@
+import assert from 'assert';
+import * as idb from 'lib0/indexeddb.js';
+import { Workspace as BlocksuiteWorkspace } from '@blocksuite/store';
+
+const { encodeStateAsUpdate } = BlocksuiteWorkspace.Y;
+
+export const initStore = async (blocksuiteWorkspace: BlocksuiteWorkspace) => {
+  const workspaceId = blocksuiteWorkspace.room;
+  assert(workspaceId);
+  await idb.deleteDB(workspaceId);
+  const db = await idb.openDB(workspaceId, db =>
+    idb.createStores(db, [['updates', { autoIncrement: true }], ['custom']])
+  );
+  const currState = encodeStateAsUpdate(blocksuiteWorkspace.doc);
+  const [updatesStore] = idb.transact(db, ['updates']); // , 'readonly')
+
+  if (updatesStore) {
+    await idb.addAutoKey(updatesStore, currState);
+  }
+};
--- a/packages/data-center/src/provider/local/local.spec.ts
+++ b/packages/data-center/src/provider/local/local.spec.ts
@@ -1,13 +1,15 @@
 import { test, expect } from '@playwright/test';
-import { WorkspaceMetaCollection } from '../../workspace-meta-collection.js';
+import { WorkspaceUnitCollection } from '../../workspace-unit-collection.js';
 import { LocalProvider } from './local.js';
 import { createBlocksuiteWorkspace } from '../../utils/index.js';
+import { MessageCenter } from '../../message/index.js';
 import 'fake-indexeddb/auto';

 test.describe.serial('local provider', () => {
-  const workspaceMetaCollection = new WorkspaceMetaCollection();
+  const workspaceMetaCollection = new WorkspaceUnitCollection();
  const provider = new LocalProvider({
    workspaces: workspaceMetaCollection.createScope(),
+    messageCenter: new MessageCenter(),
  });

  const workspaceName = 'workspace-test';
@@ -16,23 +18,20 @@ test.describe.serial('local provider', () => {
  test('create workspace', async () => {
    const workspaceInfo = await provider.createWorkspaceInfo({
      name: workspaceName,
-      avatar: 'avatar-url-test',
    });
    workspaceId = workspaceInfo.id;
    const blocksuiteWorkspace = createBlocksuiteWorkspace(workspaceId);
-    await provider.createWorkspace(blocksuiteWorkspace, {
-      name: workspaceName,
-      avatar: 'avatar-url-test',
-    });
+    await provider.createWorkspace(blocksuiteWorkspace, workspaceInfo);

    expect(workspaceMetaCollection.workspaces.length).toEqual(1);
    expect(workspaceMetaCollection.workspaces[0].name).toEqual(workspaceName);
  });

  test('workspace list cache', async () => {
-    const workspacesMetaCollection1 = new WorkspaceMetaCollection();
+    const workspacesMetaCollection1 = new WorkspaceUnitCollection();
    const provider1 = new LocalProvider({
      workspaces: workspacesMetaCollection1.createScope(),
+      messageCenter: new MessageCenter(),
    });
    await provider1.loadWorkspaces();
    expect(workspacesMetaCollection1.workspaces.length).toEqual(1);
--- a/packages/data-center/src/provider/local/local.ts
+++ b/packages/data-center/src/provider/local/local.ts
@@ -1,9 +1,14 @@
 import { BaseProvider } from '../base.js';
-import type { ProviderConstructorParams } from '../base';
+import type {
+  ProviderConstructorParams,
+  WorkspaceMeta0,
+  UpdateWorkspaceMetaParams,
+  CreateWorkspaceInfoParams,
+} from '../base';
 import { varStorage as storage } from 'lib0/storage';
-import { WorkspaceInfo, WorkspaceMeta } from '../../types';
 import { Workspace as BlocksuiteWorkspace, uuidv4 } from '@blocksuite/store';
-import { IndexedDBProvider } from './indexeddb.js';
+import { IndexedDBProvider } from './indexeddb/indexeddb.js';
+import { initStore } from './indexeddb/utils.js';
 import assert from 'assert';
 import { setDefaultAvatar } from '../utils.js';

@@ -15,11 +20,26 @@ export class LocalProvider extends BaseProvider {

  constructor(params: ProviderConstructorParams) {
    super(params);
-    this.loadWorkspaces();
  }

-  private _storeWorkspaces(workspaces: WorkspaceInfo[]) {
-    storage.setItem(WORKSPACE_KEY, JSON.stringify(workspaces));
+  private _storeWorkspaces(workspaces: WorkspaceMeta0[]) {
+    storage.setItem(
+      WORKSPACE_KEY,
+      JSON.stringify(
+        workspaces.map(w => {
+          return {
+            id: w.id,
+            name: w.name,
+            avatar: w.avatar,
+            owner: w.owner,
+            published: w.published,
+            memberCount: w.memberCount,
+            provider: w.provider,
+            syncMode: w.syncMode,
+          };
+        })
+      )
+    );
  }

  public override async linkLocal(workspace: BlocksuiteWorkspace) {
@@ -41,12 +61,12 @@ export class LocalProvider extends BaseProvider {
    return workspace;
  }

-  override loadWorkspaces(): Promise<WorkspaceInfo[]> {
+  override loadWorkspaces(): Promise<WorkspaceMeta0[]> {
    const workspaceStr = storage.getItem(WORKSPACE_KEY);
-    let workspaces: WorkspaceInfo[] = [];
+    let workspaces: WorkspaceMeta0[] = [];
    if (workspaceStr) {
      try {
-        workspaces = JSON.parse(workspaceStr) as WorkspaceInfo[];
+        workspaces = JSON.parse(workspaceStr) as WorkspaceMeta0[];
        workspaces.forEach(workspace => {
          this._workspaces.add(workspace);
        });
@@ -70,22 +90,22 @@ export class LocalProvider extends BaseProvider {

  public override async updateWorkspaceMeta(
    id: string,
-    meta: Partial<WorkspaceMeta>
+    meta: UpdateWorkspaceMetaParams
  ) {
    this._workspaces.update(id, meta);
    this._storeWorkspaces(this._workspaces.list());
  }

  public override async createWorkspaceInfo(
-    meta: WorkspaceMeta
-  ): Promise<WorkspaceInfo> {
-    const workspaceInfo: WorkspaceInfo = {
+    meta: CreateWorkspaceInfoParams
+  ): Promise<WorkspaceMeta0> {
+    const workspaceInfo: WorkspaceMeta0 = {
      name: meta.name,
      id: uuidv4(),
-      isPublish: false,
+      published: false,
      avatar: '',
      owner: undefined,
-      isLocal: true,
+      syncMode: 'core',
      memberCount: 1,
      provider: 'local',
    };
@@ -94,25 +114,16 @@ export class LocalProvider extends BaseProvider {

  public override async createWorkspace(
    blocksuiteWorkspace: BlocksuiteWorkspace,
-    meta: WorkspaceMeta
+    meta: WorkspaceMeta0
  ): Promise<BlocksuiteWorkspace | undefined> {
    const workspaceId = blocksuiteWorkspace.room;
    assert(workspaceId, 'Blocksuite Workspace without room(workspaceId).');
-    assert(meta.name, 'Workspace name is required');
    this._logger('Creating affine workspace');

-    const workspaceInfo: WorkspaceInfo = {
-      name: meta.name,
-      id: workspaceId,
-      isPublish: false,
-      avatar: '',
-      owner: undefined,
-      isLocal: true,
-      memberCount: 1,
-      provider: 'local',
+    const workspaceInfo: WorkspaceMeta0 = {
+      ...meta,
    };

-    this.linkLocal(blocksuiteWorkspace);
    blocksuiteWorkspace.meta.setName(meta.name);

    if (!meta.avatar) {
@@ -120,6 +131,8 @@ export class LocalProvider extends BaseProvider {
      workspaceInfo.avatar = blocksuiteWorkspace.meta.avatar;
    }

+    await initStore(blocksuiteWorkspace);
+
    this._workspaces.add(workspaceInfo);
    this._storeWorkspaces(this._workspaces.list());

--- a/packages/data-center/src/provider/utils.ts
+++ b/packages/data-center/src/provider/utils.ts
@@ -5,6 +5,9 @@ import { getDefaultHeadImgBlob } from '../utils/index.js';
 export const setDefaultAvatar = async (
  blocksuiteWorkspace: BlocksuiteWorkspace
 ) => {
+  if (typeof document === 'undefined') {
+    return;
+  }
  const blob = await getDefaultHeadImgBlob(blocksuiteWorkspace.meta.name);
  const blobStorage = await blocksuiteWorkspace.blobs;
  assert(blobStorage, 'No blob storage');
--- a/packages/data-center/src/types/index.ts
+++ b/packages/data-center/src/types/index.ts
@@ -1,15 +1,15 @@
 import { getLogger } from '../logger';

-export type WorkspaceInfo = {
-  name: string;
-  id: string;
-  isPublish?: boolean;
-  avatar?: string;
-  owner?: User;
-  isLocal?: boolean;
-  memberCount: number;
-  provider: string;
-};
+// export type WorkspaceInfo = {
+//   name: string;
+//   id: string;
+//   isPublish?: boolean;
+//   avatar?: string;
+//   owner?: User;
+//   isLocal?: boolean;
+//   memberCount: number;
+//   provider: string;
+// };

 export type User = {
  name: string;
@@ -18,7 +18,7 @@ export type User = {
  avatar: string;
 };

-export type WorkspaceMeta = Pick<WorkspaceInfo, 'name' | 'avatar'>;
+// export type WorkspaceMeta = Pick<WorkspaceInfo, 'name' | 'avatar'>;

 export type Logger = ReturnType<typeof getLogger>;

--- a/packages/data-center/src/workspace-meta-collection.spec.ts
+++ b/packages/data-center/src/workspace-meta-collection.spec.ts
@@ -1,50 +0,0 @@
-import { test, expect } from '@playwright/test';
-import { WorkspaceMetaCollection } from './workspace-meta-collection.js';
-import type { WorkspaceMetaCollectionChangeEvent } from './workspace-meta-collection';
-
-test.describe.serial('workspace meta collection observable', () => {
-  const workspaces = new WorkspaceMetaCollection();
-
-  const scope = workspaces.createScope();
-
-  test('add workspace', () => {
-    workspaces.once('change', (event: WorkspaceMetaCollectionChangeEvent) => {
-      expect(event.added?.id).toEqual('123');
-    });
-    scope.add({
-      id: '123',
-      name: 'test',
-      memberCount: 1,
-      provider: '',
-    });
-  });
-
-  test('list workspace', () => {
-    const list = scope.list();
-    expect(list.length).toEqual(1);
-    expect(list[0].id).toEqual('123');
-  });
-
-  test('get workspace', () => {
-    expect(scope.get('123')?.id).toEqual('123');
-  });
-
-  test('update workspace', () => {
-    workspaces.once('change', (event: WorkspaceMetaCollectionChangeEvent) => {
-      expect(event.updated?.name).toEqual('demo');
-    });
-    scope.update('123', { name: 'demo' });
-  });
-
-  test('get workspace form other scope', () => {
-    const scope1 = workspaces.createScope();
-    expect(scope1.get('123')).toBeFalsy();
-  });
-
-  test('delete workspace', () => {
-    workspaces.once('change', (event: WorkspaceMetaCollectionChangeEvent) => {
-      expect(event.deleted?.id).toEqual('123');
-    });
-    scope.remove('123');
-  });
-});
--- a/packages/data-center/src/workspace-meta-collection.ts
+++ b/packages/data-center/src/workspace-meta-collection.ts
@@ -1,127 +0,0 @@
-import { Observable } from 'lib0/observable';
-import type { WorkspaceInfo, WorkspaceMeta } from './types';
-
-export interface WorkspaceMetaCollectionScope {
-  get: (workspaceId: string) => WorkspaceInfo | undefined;
-  list: () => WorkspaceInfo[];
-  add: (workspace: WorkspaceInfo) => void;
-  remove: (workspaceId: string) => boolean;
-  clear: () => void;
-  update: (workspaceId: string, workspaceMeta: Partial<WorkspaceMeta>) => void;
-}
-
-export interface WorkspaceMetaCollectionChangeEvent {
-  added?: WorkspaceInfo;
-  deleted?: WorkspaceInfo;
-  updated?: WorkspaceInfo;
-}
-
-export class WorkspaceMetaCollection extends Observable<'change'> {
-  private _workspacesMap = new Map<string, WorkspaceInfo>();
-
-  get workspaces(): WorkspaceInfo[] {
-    return Array.from(this._workspacesMap.values());
-  }
-
-  find(workspaceId: string) {
-    return this._workspacesMap.get(workspaceId);
-  }
-
-  createScope(): WorkspaceMetaCollectionScope {
-    const scopedWorkspaceIds = new Set<string>();
-
-    const get = (workspaceId: string) => {
-      if (!scopedWorkspaceIds.has(workspaceId)) {
-        return;
-      }
-      return this._workspacesMap.get(workspaceId);
-    };
-
-    const add = (workspace: WorkspaceInfo) => {
-      if (this._workspacesMap.has(workspace.id)) {
-        throw new Error(`Duplicate workspace id.`);
-      }
-      this._workspacesMap.set(workspace.id, workspace);
-      scopedWorkspaceIds.add(workspace.id);
-
-      this.emit('change', [
-        {
-          added: workspace,
-        } as WorkspaceMetaCollectionChangeEvent,
-      ]);
-    };
-
-    const remove = (workspaceId: string) => {
-      if (!scopedWorkspaceIds.has(workspaceId)) {
-        return true;
-      }
-
-      const workspace = this._workspacesMap.get(workspaceId);
-      if (workspace) {
-        const ret = this._workspacesMap.delete(workspaceId);
-        // If deletion failed, return.
-        if (!ret) {
-          return ret;
-        }
-
-        scopedWorkspaceIds.delete(workspaceId);
-
-        this.emit('change', [
-          {
-            deleted: workspace,
-          } as WorkspaceMetaCollectionChangeEvent,
-        ]);
-      }
-      return true;
-    };
-
-    const clear = () => {
-      scopedWorkspaceIds.forEach(id => {
-        remove(id);
-      });
-    };
-
-    const update = (
-      workspaceId: string,
-      workspaceMeta: Partial<WorkspaceMeta>
-    ) => {
-      if (!scopedWorkspaceIds.has(workspaceId)) {
-        return true;
-      }
-
-      const workspace = this._workspacesMap.get(workspaceId);
-      if (!workspace) {
-        return true;
-      }
-
-      this._workspacesMap.set(workspaceId, { ...workspace, ...workspaceMeta });
-
-      this.emit('change', [
-        {
-          updated: this._workspacesMap.get(workspaceId),
-        } as WorkspaceMetaCollectionChangeEvent,
-      ]);
-    };
-
-    // TODO: need to optimize
-    const list = () => {
-      const workspaces: WorkspaceInfo[] = [];
-      scopedWorkspaceIds.forEach(id => {
-        const workspace = this._workspacesMap.get(id);
-        if (workspace) {
-          workspaces.push(workspace);
-        }
-      });
-      return workspaces;
-    };
-
-    return {
-      get,
-      list,
-      add,
-      remove,
-      clear,
-      update,
-    };
-  }
-}
--- a/packages/data-center/src/workspace-unit-collection.spec.ts
+++ b/packages/data-center/src/workspace-unit-collection.spec.ts
@@ -0,0 +1,60 @@
+import { test, expect } from '@playwright/test';
+import { WorkspaceUnitCollection } from './workspace-unit-collection.js';
+import type { WorkspaceUnitCollectionChangeEvent } from './workspace-unit-collection';
+
+test.describe.serial('workspace meta collection observable', () => {
+  const workspaceUnitCollection = new WorkspaceUnitCollection();
+
+  const scope = workspaceUnitCollection.createScope();
+
+  test('add workspace', () => {
+    workspaceUnitCollection.once(
+      'change',
+      (event: WorkspaceUnitCollectionChangeEvent) => {
+        expect(event.added?.[0]?.id).toEqual('123');
+      }
+    );
+    scope.add({
+      id: '123',
+      name: 'test',
+      memberCount: 1,
+      provider: '',
+      syncMode: 'core',
+    });
+  });
+
+  test('list workspace', () => {
+    const list = scope.list();
+    expect(list.length).toEqual(1);
+    expect(list[0].id).toEqual('123');
+  });
+
+  test('get workspace', () => {
+    expect(scope.get('123')?.id).toEqual('123');
+  });
+
+  test('update workspace', () => {
+    workspaceUnitCollection.once(
+      'change',
+      (event: WorkspaceUnitCollectionChangeEvent) => {
+        expect(event.updated?.name).toEqual('demo');
+      }
+    );
+    scope.update('123', { name: 'demo' });
+  });
+
+  test('get workspace form other scope', () => {
+    const scope1 = workspaceUnitCollection.createScope();
+    expect(scope1.get('123')).toBeFalsy();
+  });
+
+  test('delete workspace', () => {
+    workspaceUnitCollection.once(
+      'change',
+      (event: WorkspaceUnitCollectionChangeEvent) => {
+        expect(event.deleted?.id).toEqual('123');
+      }
+    );
+    scope.remove('123');
+  });
+});
--- a/packages/data-center/src/workspace-unit-collection.ts
+++ b/packages/data-center/src/workspace-unit-collection.ts
@@ -0,0 +1,152 @@
+import { Observable } from 'lib0/observable';
+import { WorkspaceUnit } from './workspace-unit.js';
+import type {
+  WorkspaceUnitCtorParams,
+  UpdateWorkspaceUnitParams,
+} from './workspace-unit';
+
+export interface WorkspaceUnitCollectionScope {
+  get: (workspaceId: string) => WorkspaceUnit | undefined;
+  list: () => WorkspaceUnit[];
+  add: (workspace: WorkspaceUnitCtorParams) => void;
+  remove: (workspaceId: string) => boolean;
+  clear: () => void;
+  update: (
+    workspaceId: string,
+    workspaceMeta: UpdateWorkspaceUnitParams
+  ) => void;
+}
+
+export interface WorkspaceUnitCollectionChangeEvent {
+  added?: WorkspaceUnit[];
+  deleted?: WorkspaceUnit;
+  updated?: WorkspaceUnit;
+}
+
+export class WorkspaceUnitCollection {
+  private _events = new Observable();
+  private _workspaceUnitMap = new Map<string, WorkspaceUnit>();
+
+  get workspaces(): WorkspaceUnit[] {
+    return Array.from(this._workspaceUnitMap.values());
+  }
+
+  public on(
+    type: 'change',
+    callback: (event: WorkspaceUnitCollectionChangeEvent) => void
+  ) {
+    this._events.on(type, callback);
+  }
+
+  public once(
+    type: 'change',
+    callback: (event: WorkspaceUnitCollectionChangeEvent) => void
+  ) {
+    this._events.once(type, callback);
+  }
+
+  find(workspaceId: string) {
+    return this._workspaceUnitMap.get(workspaceId);
+  }
+
+  createScope(): WorkspaceUnitCollectionScope {
+    const scopedWorkspaceIds = new Set<string>();
+
+    const get = (workspaceId: string) => {
+      if (!scopedWorkspaceIds.has(workspaceId)) {
+        return;
+      }
+      return this._workspaceUnitMap.get(workspaceId);
+    };
+
+    const add = (workspace: WorkspaceUnitCtorParams) => {
+      if (this._workspaceUnitMap.has(workspace.id)) {
+        throw new Error(`Duplicate workspace id.`);
+      }
+
+      const workspaceUnit = new WorkspaceUnit(workspace);
+      this._workspaceUnitMap.set(workspace.id, workspaceUnit);
+
+      scopedWorkspaceIds.add(workspace.id);
+
+      this._events.emit('change', [
+        {
+          added: [workspaceUnit],
+        } as WorkspaceUnitCollectionChangeEvent,
+      ]);
+    };
+
+    const remove = (workspaceId: string) => {
+      if (!scopedWorkspaceIds.has(workspaceId)) {
+        return true;
+      }
+
+      const workspaceUnit = this._workspaceUnitMap.get(workspaceId);
+      if (workspaceUnit) {
+        const ret = this._workspaceUnitMap.delete(workspaceId);
+        // If deletion failed, return.
+        if (!ret) {
+          return ret;
+        }
+
+        scopedWorkspaceIds.delete(workspaceId);
+
+        this._events.emit('change', [
+          {
+            deleted: workspaceUnit,
+          } as WorkspaceUnitCollectionChangeEvent,
+        ]);
+      }
+      return true;
+    };
+
+    const clear = () => {
+      scopedWorkspaceIds.forEach(id => {
+        remove(id);
+      });
+    };
+
+    const update = (
+      workspaceId: string,
+      workspaceMeta: UpdateWorkspaceUnitParams
+    ) => {
+      if (!scopedWorkspaceIds.has(workspaceId)) {
+        return true;
+      }
+
+      const workspaceUnit = this._workspaceUnitMap.get(workspaceId);
+      if (!workspaceUnit) {
+        return true;
+      }
+
+      workspaceUnit.update(workspaceMeta);
+
+      this._events.emit('change', [
+        {
+          updated: workspaceUnit,
+        } as WorkspaceUnitCollectionChangeEvent,
+      ]);
+    };
+
+    // TODO: need to optimize
+    const list = () => {
+      const workspaceUnits: WorkspaceUnit[] = [];
+      scopedWorkspaceIds.forEach(id => {
+        const workspaceUnit = this._workspaceUnitMap.get(id);
+        if (workspaceUnit) {
+          workspaceUnits.push(workspaceUnit);
+        }
+      });
+      return workspaceUnits;
+    };
+
+    return {
+      get,
+      list,
+      add,
+      remove,
+      clear,
+      update,
+    };
+  }
+}
--- a/packages/data-center/src/workspace-unit.ts
+++ b/packages/data-center/src/workspace-unit.ts
@@ -0,0 +1,64 @@
+import { Workspace as BlocksuiteWorkspace } from '@blocksuite/store';
+import type { User } from './types';
+
+export type SyncMode = 'all' | 'core';
+
+export interface WorkspaceUnitCtorParams {
+  id: string;
+  name: string;
+  avatar?: string;
+  owner?: User;
+  published?: boolean;
+  memberCount: number;
+  provider: string;
+  syncMode: SyncMode;
+
+  blocksuiteWorkspace?: BlocksuiteWorkspace | null;
+}
+
+export type UpdateWorkspaceUnitParams = Partial<
+  Omit<WorkspaceUnitCtorParams, 'id'>
+>;
+
+export class WorkspaceUnit {
+  public readonly id: string;
+  public name!: string;
+  public avatar?: string;
+  public owner?: User;
+  public published?: boolean;
+  public memberCount!: number;
+  public provider!: string;
+  public syncMode: 'all' | 'core' = 'core';
+
+  private _blocksuiteWorkspace?: BlocksuiteWorkspace | null;
+
+  constructor(params: WorkspaceUnitCtorParams) {
+    this.id = params.id;
+    this.update(params);
+  }
+
+  get blocksuiteWorkspace() {
+    return this._blocksuiteWorkspace;
+  }
+
+  setBlocksuiteWorkspace(blocksuiteWorkspace: BlocksuiteWorkspace | null) {
+    if (blocksuiteWorkspace && blocksuiteWorkspace?.room !== this.id) {
+      throw new Error('Workspace id inconsistent.');
+    }
+    this._blocksuiteWorkspace = blocksuiteWorkspace;
+  }
+
+  update(params: UpdateWorkspaceUnitParams) {
+    Object.assign(this, params);
+  }
+
+  get isPublish() {
+    console.error('Suggest changing to published');
+    return this.published;
+  }
+
+  get isLocal() {
+    console.error('Suggest changing to syncMode');
+    return this.syncMode === 'all';
+  }
+}