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

Conflicts:
	packages/data-center/src/datacenter.ts

packages/data-center/src/datacenter.ts

@@ -1,24 +1,25 @@
 import { Workspaces } from './workspaces';
 import type { WorkspacesChangeEvent } from './workspaces';
-import { Workspace } from '@blocksuite/store';
+import { BlobStorage, Workspace } from '@blocksuite/store';
 import { BaseProvider } from './provider/base';
 import { LocalProvider } from './provider/local/local';
 import { AffineProvider } from './provider';
+import type { WorkspaceMeta } from './types';
 import assert from 'assert';
 import { getLogger } from './logger';
 import { BlockSchema } from '@blocksuite/blocks/models';
 import { applyUpdate, encodeStateAsUpdate } from 'yjs';
 import { SelfHostedProvider } from './provider/selfhosted';
 import { TauriIPCProvider } from './provider/tauri-ipc';
-import { WorkspaceMeta } from './types';
 
 /**
  * @class DataCenter
- * @classdesc DataCenter is a data center, it can manage different providers for business
+ * @classdesc Data center is made for managing different providers for business
  */
 export class DataCenter {
   private readonly _workspaces = new Workspaces();
   private readonly _logger = getLogger('dc');
+  private readonly _blobStorage: BlobStorage = new BlobStorage();
   /**
    * A mainProvider must exist as the only data trustworthy source.
    */
@@ -36,12 +37,14 @@ export class DataCenter {
       new LocalProvider({
         logger: dc._logger,
         workspaces: dc._workspaces.createScope(),
+        blobs: dc._blobStorage,
       })
     );
     dc.registerProvider(
       new AffineProvider({
         logger: dc._logger,
         workspaces: dc._workspaces.createScope(),
+        blobs: dc._blobStorage,
       })
     );
     dc.registerProvider(new SelfHostedProvider());
@@ -258,6 +261,24 @@ export class DataCenter {
     }
   }
 
+  /**
+   * get user info by email
+   * @param workspaceId
+   * @param email
+   * @param provider
+   * @returns {Promise<User>} User info
+   */
+  public async getUserByEmail(
+    workspaceId: string,
+    email: string,
+    provider = 'affine'
+  ) {
+    const providerInstance = this.providerMap.get(provider);
+    if (providerInstance) {
+      return await providerInstance.getUserByEmail(workspaceId, email);
+    }
+  }
+
   private async _transWorkspaceProvider(
     workspace: Workspace,
     providerId: string
@@ -274,6 +295,7 @@ export class DataCenter {
     const newProvider = this.providerMap.get(providerId);
     assert(newProvider, `provide '${providerId}' is not registered`);
     this._logger(`create ${providerId} workspace: `, workspaceInfo.name);
+    // TODO optimize this function
     const newWorkspace = await newProvider.createWorkspace({
       name: workspaceInfo.name,
       avatar: workspaceInfo.avatar,
@@ -323,4 +345,22 @@ export class DataCenter {
     id;
     return;
   }
+
+  /**
+   * get blob url by workspaces id
+   * @param id
+   * @returns {Promise<string | null>} blob url
+   */
+  async getBlob(id: string): Promise<string | null> {
+    return await this._blobStorage.get(id);
+  }
+
+  /**
+   * up load blob and get a blob url
+   * @param id
+   * @returns {Promise<string | null>} blob url
+   */
+  async setBlob(blob: Blob): Promise<string> {
+    return await this._blobStorage.set(blob);
+  }
 }

packages/data-center/src/provider/affine/affine.ts

@@ -23,6 +23,7 @@ import { getAuthorizer } from './apis/token';
 import { WebsocketProvider } from './sync';
 import { IndexedDBProvider } from '../indexeddb';
 import { getDefaultHeadImgBlob } from '../../utils';
+import { getUserByEmail } from './apis/user';
 
 export class AffineProvider extends BaseProvider {
   public id = 'affine';
@@ -248,7 +249,8 @@ export class AffineProvider extends BaseProvider {
     if (!meta.avatar) {
       // set default avatar
       const blob = await getDefaultHeadImgBlob(meta.name);
-      meta.avatar = (await this.setBlob(blob)) || '';
+      const blobId = await this.setBlob(blob);
+      meta.avatar = (await this.getBlob(blobId)) || '';
     }
     const { id } = await createWorkspace(meta as Required<WorkspaceMeta>);
     this._logger('Creating affine workspace');
@@ -277,4 +279,19 @@ export class AffineProvider extends BaseProvider {
   public override async publish(id: string, isPublish: boolean): Promise<void> {
     await updateWorkspace({ id, public: isPublish });
   }
+
+  public override async getUserByEmail(
+    workspace_id: string,
+    email: string
+  ): Promise<User | null> {
+    const user = await getUserByEmail({ workspace_id, email });
+    return user
+      ? {
+          id: user.id,
+          name: user.name,
+          avatar: user.avatar_url,
+          email: user.email,
+        }
+      : null;
+  }
 }

packages/data-center/src/provider/affine/apis/index.ts

@@ -4,11 +4,9 @@ export type { Callback } from './token.js';
 import { getAuthorizer } from './token.js';
 import * as user from './user.js';
 import * as workspace from './workspace.js';
-import * as business from './business.js';
 
 export type Apis = typeof user &
   typeof workspace & {
-    business: typeof business;
     signInWithGoogle: ReturnType<typeof getAuthorizer>[0];
     onAuthStateChanged: ReturnType<typeof getAuthorizer>[1];
   };
@@ -18,7 +16,6 @@ export const getApis = (): Apis => {
   return {
     ...user,
     ...workspace,
-    business,
     signInWithGoogle,
     onAuthStateChanged,
   };

packages/data-center/src/provider/base.ts

@@ -9,6 +9,7 @@ const defaultLogger = () => {
 export interface ProviderConstructorParams {
   logger?: Logger;
   workspaces: WorkspacesScope;
+  blobs: BlobStorage;
 }
 
 export class BaseProvider {
@@ -17,9 +18,10 @@ export class BaseProvider {
   protected _logger!: Logger;
   protected _blobs!: BlobStorage;
 
-  public constructor({ logger, workspaces }: ProviderConstructorParams) {
+  public constructor({ logger, workspaces, blobs }: ProviderConstructorParams) {
     this._logger = (logger || defaultLogger) as Logger;
     this._workspaces = workspaces;
+    this._blobs = blobs;
   }
 
   /**
@@ -149,10 +151,25 @@ export class BaseProvider {
     return;
   }
 
+  /**
+   * create workspace by workspace meta
+   * @param {WorkspaceMeta} meta
+   */
   public async createWorkspace(
     meta: WorkspaceMeta
   ): Promise<Workspace | undefined> {
     meta;
     return;
   }
+
+  /**
+   * get user by email
+   * @param {string} id
+   * @param {string} email
+   * @returns
+   */
+  public async getUserByEmail(id: string, email: string): Promise<User | null> {
+    email;
+    return null;
+  }
 }

packages/data-center/src/provider/local/local.ts

@@ -82,7 +82,8 @@ export class LocalProvider extends BaseProvider {
     if (!meta.avatar) {
       // set default avatar
       const blob = await getDefaultHeadImgBlob(meta.name);
-      meta.avatar = (await this.setBlob(blob)) || '';
+      const blobId = await this.setBlob(blob);
+      meta.avatar = (await this.getBlob(blobId)) || '';
     }
     this._logger('Creating affine workspace');