Merge remote-tracking branch 'origin/feat/datacenter-dev' into feat/datacenter-dev

packages/app/src/hooks/use-workspace-helper.ts

@@ -64,6 +64,14 @@ export const useWorkspaceHelper = () => {
     currentWorkspace && (await dataCenter.leaveWorkspace(currentWorkspace?.id));
   };
 
+  const acceptInvite = async (inviteCode: string) => {
+    let inviteInfo;
+    if (inviteCode) {
+      inviteInfo = await dataCenter.acceptInvitation(inviteCode);
+    }
+    return inviteInfo;
+  };
+
   return {
     createWorkspace,
     publishWorkspace,
@@ -71,5 +79,6 @@ export const useWorkspaceHelper = () => {
     enableWorkspace,
     deleteWorkSpace,
     leaveWorkSpace,
+    acceptInvite,
   };
 };

packages/app/src/pages/invite/[invite_code].tsx

@@ -1,44 +1,37 @@
+import { useWorkspaceHelper } from '@/hooks/use-workspace-helper';
+import { useAppState } from '@/providers/app-state-provider';
 import { styled } from '@/styles';
 import { Empty } from '@/ui/empty';
-import { Avatar } from '@mui/material';
+// import { Avatar } from '@mui/material';
-// import { getDataCenter } from '@affine/datacenter';
 import { useRouter } from 'next/router';
 import { useEffect, useState } from 'react';
 
-const User = ({ name, avatar }: { name: string; avatar?: string }) => {
+// const User = ({ name, avatar }: { name: string; avatar?: string }) => {
-  return (
+//   return (
-    <UserContent>
+//     <UserContent>
-      {avatar ? (
+//       {avatar ? (
-        <Avatar src={avatar}></Avatar>
+//         <Avatar src={avatar}></Avatar>
-      ) : (
+//       ) : (
-        <UserIcon>{name.slice(0, 1)}</UserIcon>
+//         <UserIcon>{name.slice(0, 1)}</UserIcon>
-      )}
+//       )}
-      <span>{name}</span>
+//       <span>{name}</span>
-    </UserContent>
+//     </UserContent>
-  );
+//   );
-};
+// };
 
 export default function DevPage() {
   const router = useRouter();
   const [successInvited, setSuccessInvited] = useState<boolean>(false);
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const { acceptInvite } = useWorkspaceHelper();
-  const [inviteData, setInviteData] = useState<any>(null);
+  const { user } = useAppState();
   useEffect(() => {
-    // getDataCenter()
+    router.query.invite_code &&
-    //   .then(dc =>
+      acceptInvite(router.query.invite_code as string).then(data => {
-    //     dc.apis.acceptInviting({
+        if (data && data.accepted) {
-    //       invitingCode: router.query.invite_code as string,
+          setSuccessInvited(true);
-    //     })
+          user && router.push(`/workspace/${data.workspace_id}`);
-    //   )
+        }
-    //   .then(data => {
+      });
-    //     setSuccessInvited(true);
-    //     setInviteData(data);
-    //   })
-    //   .catch(err => {
-    //     console.log('err: ', err);
-    //   });
-    setSuccessInvited(true);
-    setInviteData(null);
   }, [router.query.invite_code]);
 
   return (
@@ -47,11 +40,12 @@ export default function DevPage() {
         <Empty width={310} height={310}></Empty>
 
         <Content>
-          <User name={inviteData?.name ? inviteData.name : '-'}></User> invited
+          {/* TODO add inviteInfo*/}
-          you to join
+          {/* <User name={inviteData?.name ? inviteData.name : '-'}></User> invited */}
-          <User
+          {/* you to join */}
+          {/* <User
             name={inviteData?.workspaceName ? inviteData.workspaceName : '-'}
-          ></User>
+          ></User> */}
           {successInvited ? (
             <Status>
               <svg

packages/data-center/src/datacenter.ts

@@ -416,13 +416,14 @@ export class DataCenter {
   /**
    * accept invitation
    * @param {string} inviteCode
+   * @returns {Promise<Permission | null>} permission
    */
   async acceptInvitation(inviteCode: string, providerStr = 'affine') {
     const provider = this.providerMap.get(providerStr);
     if (provider) {
       return await provider.acceptInvitation(inviteCode);
     }
-    return [];
+    return null;
   }
 
   onMessage(cb: (message: Message) => void) {

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

@@ -102,10 +102,19 @@ export class AffineProvider extends BaseProvider {
     });
   }
 
-  private _handlerAffineListMessage({ ws_details, metadata }: ChannelMessage) {
+  private async _handlerAffineListMessage({
+    ws_details,
+    metadata,
+  }: ChannelMessage) {
     this._logger('receive server message');
-    Object.entries(ws_details).forEach(async ([id, detail]) => {
+    const addedWorkspaces: WorkspaceUnit[] = [];
+    const removeWorkspaceList = this._workspaces.list().map(w => w.id);
+    for (const [id, detail] of Object.entries(ws_details)) {
       const { name, avatar } = metadata[id];
+      const index = removeWorkspaceList.indexOf(id);
+      if (index !== -1) {
+        removeWorkspaceList.splice(index, 1);
+      }
       assert(name);
       const workspace = {
         name: name,
@@ -122,15 +131,20 @@ export class AffineProvider extends BaseProvider {
         syncMode: 'core' as SyncMode,
       };
       if (this._workspaces.get(id)) {
+        // update workspaces
         this._workspaces.update(id, workspace);
       } else {
         const workspaceUnit = await loadWorkspaceUnit(
           { id, ...workspace },
           this._apis
         );
-        this._workspaces.add(workspaceUnit);
+        addedWorkspaces.push(workspaceUnit);
       }
-    });
+    }
+    // add workspaces
+    this._workspaces.add(addedWorkspaces);
+    // remove workspaces
+    this._workspaces.remove(removeWorkspaceList);
   }
 
   private _getWebsocketProvider(workspace: BlocksuiteWorkspace) {
@@ -386,7 +400,7 @@ export class AffineProvider extends BaseProvider {
     return this._apis.getWorkspaceMembers({ id });
   }
 
-  public override async acceptInvitation(invitingCode: string): Promise<void> {
+  public override async acceptInvitation(invitingCode: string) {
-    await this._apis.acceptInviting({ invitingCode });
+    return await this._apis.acceptInviting({ invitingCode });
   }
 }

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

@@ -197,13 +197,13 @@ export interface AcceptInvitingParams {
 
 export async function acceptInviting(
   params: AcceptInvitingParams
-): Promise<void> {
+): Promise<Permission> {
-  await bareClient
+  try {
-    .post(`api/invitation/${params.invitingCode}`)
+    return bareClient.post(`api/invitation/${params.invitingCode}`).json();
-    .catch(error => {
+  } catch (error) {
-      sendMessage(messageCode.acceptInvitingFailed);
+    sendMessage(messageCode.acceptInvitingFailed);
-      throw new RequestError('accept inviting failed', error);
+    throw new RequestError('accept inviting failed', error);
-    });
+  }
 }
 
 export async function uploadBlob(params: { blob: Blob }): Promise<string> {

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

@@ -4,6 +4,7 @@ import { Logger, User } from '../types';
 import type { WorkspaceUnitCollectionScope } from '../workspace-unit-collection';
 import type { WorkspaceUnitCtorParams, WorkspaceUnit } from '../workspace-unit';
 import { Member } from './affine/apis';
+import { Permission } from './affine/apis/workspace.js';
 
 const defaultLogger = () => {
   return;
@@ -233,8 +234,10 @@ export class BaseProvider {
    * @param {string} inviteCode
    * @returns
    */
-  public async acceptInvitation(inviteCode: string): Promise<void> {
+  public async acceptInvitation(
+    inviteCode: string
+  ): Promise<Permission | null> {
     inviteCode;
-    return;
+    return null;
   }
 }

packages/data-center/src/workspace-unit-collection.ts

@@ -8,7 +8,7 @@ export interface WorkspaceUnitCollectionScope {
   get: (workspaceId: string) => WorkspaceUnit | undefined;
   list: () => WorkspaceUnit[];
   add: (workspace: WorkspaceUnit | WorkspaceUnit[]) => void;
-  remove: (workspaceId: string) => boolean;
+  remove: (workspaceId: string | string[]) => boolean;
   clear: () => void;
   update: (
     workspaceId: string,
@@ -18,7 +18,7 @@ export interface WorkspaceUnitCollectionScope {
 
 export interface WorkspaceUnitCollectionChangeEvent {
   added?: WorkspaceUnit[];
-  deleted?: WorkspaceUnit;
+  deleted?: WorkspaceUnit[];
   updated?: WorkspaceUnit;
 }
 
@@ -62,16 +62,22 @@ export class WorkspaceUnitCollection {
       const workspaceUnits = Array.isArray(workspaceUnit)
         ? workspaceUnit
         : [workspaceUnit];
+      let added = false;
 
       workspaceUnits.forEach(workspaceUnit => {
         if (this._workspaceUnitMap.has(workspaceUnit.id)) {
           // FIXME: multiple add same workspace
           return;
         }
+        added = true;
         this._workspaceUnitMap.set(workspaceUnit.id, workspaceUnit);
         scopedWorkspaceIds.add(workspaceUnit.id);
       });
 
+      if (!added) {
+        return;
+      }
+
       this._events.emit('change', [
         {
           added: workspaceUnits,
@@ -79,27 +85,39 @@ export class WorkspaceUnitCollection {
       ]);
     };
 
-    const remove = (workspaceId: string) => {
+    const remove = (workspaceId: string | string[]) => {
-      if (!scopedWorkspaceIds.has(workspaceId)) {
+      const workspaceIds = Array.isArray(workspaceId)
-        return true;
+        ? workspaceId
-      }
+        : [workspaceId];
+      const workspaceUnits: WorkspaceUnit[] = [];
 
-      const workspaceUnit = this._workspaceUnitMap.get(workspaceId);
+      workspaceIds.forEach(workspaceId => {
-      if (workspaceUnit) {
+        if (!scopedWorkspaceIds.has(workspaceId)) {
-        const ret = this._workspaceUnitMap.delete(workspaceId);
+          return;
-        // If deletion failed, return.
-        if (!ret) {
-          return ret;
         }
+        const workspaceUnit = this._workspaceUnitMap.get(workspaceId);
+        if (workspaceUnit) {
+          const ret = this._workspaceUnitMap.delete(workspaceId);
+          // If deletion failed, return.
+          if (!ret) {
+            return;
+          }
 
-        scopedWorkspaceIds.delete(workspaceId);
+          workspaceUnits.push(workspaceUnit);
+          scopedWorkspaceIds.delete(workspaceId);
+        }
+      });
 
-        this._events.emit('change', [
+      if (!workspaceUnits.length) {
-          {
+        return false;
-            deleted: workspaceUnit,
-          } as WorkspaceUnitCollectionChangeEvent,
-        ]);
       }
+
+      this._events.emit('change', [
+        {
+          deleted: workspaceUnits,
+        } as WorkspaceUnitCollectionChangeEvent,
+      ]);
+
       return true;
     };