refactor(infra): directory structure (#4615)

packages/frontend/core/src/adapters/cloud/ui.tsx

@@ -0,0 +1,93 @@
+import { PageNotFoundError } from '@affine/env/constant';
+import type {
+  WorkspaceFlavour,
+  WorkspaceUISchema,
+} from '@affine/env/workspace';
+import { initEmptyPage } from '@toeverything/infra/blocksuite';
+import { lazy, useCallback } from 'react';
+
+import type { OnLoadEditor } from '../../components/page-detail-editor';
+import { useCurrentUser } from '../../hooks/affine/use-current-user';
+import { useIsWorkspaceOwner } from '../../hooks/affine/use-is-workspace-owner';
+import { useWorkspace } from '../../hooks/use-workspace';
+import {
+  BlockSuitePageList,
+  NewWorkspaceSettingDetail,
+  PageDetailEditor,
+  Provider,
+  WorkspaceHeader,
+} from '../shared';
+
+const LoginCard = lazy(() =>
+  import('../../components/cloud/login-card').then(({ LoginCard }) => ({
+    default: LoginCard,
+  }))
+);
+
+export const UI = {
+  Provider,
+  LoginCard,
+  Header: WorkspaceHeader,
+  PageDetail: ({ currentWorkspaceId, currentPageId, onLoadEditor }) => {
+    const workspace = useWorkspace(currentWorkspaceId);
+    const page = workspace.blockSuiteWorkspace.getPage(currentPageId);
+    if (!page) {
+      throw new PageNotFoundError(workspace.blockSuiteWorkspace, currentPageId);
+    }
+    // this should be safe because we are under cloud workspace adapter
+    const currentUser = useCurrentUser();
+    const onLoad = useCallback<OnLoadEditor>(
+      (...args) => {
+        const dispose = onLoadEditor(...args);
+        workspace.blockSuiteWorkspace.awarenessStore.awareness.setLocalStateField(
+          'user',
+          {
+            name: currentUser.name,
+          }
+        );
+        return dispose;
+      },
+      [currentUser, workspace, onLoadEditor]
+    );
+
+    return (
+      <>
+        <PageDetailEditor
+          pageId={currentPageId}
+          onInit={useCallback(async page => initEmptyPage(page), [])}
+          onLoad={onLoad}
+          workspace={workspace.blockSuiteWorkspace}
+        />
+      </>
+    );
+  },
+  PageList: ({ blockSuiteWorkspace, onOpenPage, collection }) => {
+    return (
+      <BlockSuitePageList
+        listType="all"
+        collection={collection}
+        onOpenPage={onOpenPage}
+        blockSuiteWorkspace={blockSuiteWorkspace}
+      />
+    );
+  },
+  NewSettingsDetail: ({
+    currentWorkspaceId,
+    onTransformWorkspace,
+    onDeleteLocalWorkspace,
+    onDeleteCloudWorkspace,
+    onLeaveWorkspace,
+  }) => {
+    const isOwner = useIsWorkspaceOwner(currentWorkspaceId);
+    return (
+      <NewWorkspaceSettingDetail
+        onDeleteLocalWorkspace={onDeleteLocalWorkspace}
+        onDeleteCloudWorkspace={onDeleteCloudWorkspace}
+        onLeaveWorkspace={onLeaveWorkspace}
+        workspaceId={currentWorkspaceId}
+        onTransferWorkspace={onTransformWorkspace}
+        isOwner={isOwner}
+      />
+    );
+  },
+} satisfies WorkspaceUISchema<WorkspaceFlavour.AFFINE_CLOUD>;

packages/frontend/core/src/adapters/local/index.tsx

@@ -0,0 +1,137 @@
+import { DebugLogger } from '@affine/debug';
+import {
+  DEFAULT_WORKSPACE_NAME,
+  PageNotFoundError,
+} from '@affine/env/constant';
+import type { LocalIndexedDBDownloadProvider } from '@affine/env/workspace';
+import type { WorkspaceAdapter } from '@affine/env/workspace';
+import {
+  LoadPriority,
+  ReleaseType,
+  WorkspaceFlavour,
+} from '@affine/env/workspace';
+import {
+  CRUD,
+  saveWorkspaceToLocalStorage,
+} from '@affine/workspace/local/crud';
+import {
+  getOrCreateWorkspace,
+  globalBlockSuiteSchema,
+} from '@affine/workspace/manager';
+import { createIndexedDBDownloadProvider } from '@affine/workspace/providers';
+import { getBlockSuiteWorkspaceAtom } from '@toeverything/infra/__internal__/workspace';
+import { getCurrentStore } from '@toeverything/infra/atom';
+import { initEmptyPage } from '@toeverything/infra/blocksuite';
+import { buildShowcaseWorkspace } from '@toeverything/infra/blocksuite';
+import { useAtomValue } from 'jotai';
+import { nanoid } from 'nanoid';
+import { useCallback } from 'react';
+
+import { setPageModeAtom } from '../../atoms';
+import {
+  BlockSuitePageList,
+  NewWorkspaceSettingDetail,
+  PageDetailEditor,
+  Provider,
+  WorkspaceHeader,
+} from '../shared';
+
+const logger = new DebugLogger('use-create-first-workspace');
+
+export const LocalAdapter: WorkspaceAdapter<WorkspaceFlavour.LOCAL> = {
+  releaseType: ReleaseType.STABLE,
+  flavour: WorkspaceFlavour.LOCAL,
+  loadPriority: LoadPriority.LOW,
+  Events: {
+    'app:access': async () => true,
+    'app:init': () => {
+      const blockSuiteWorkspace = getOrCreateWorkspace(
+        nanoid(),
+        WorkspaceFlavour.LOCAL
+      );
+      blockSuiteWorkspace.meta.setName(DEFAULT_WORKSPACE_NAME);
+      if (runtimeConfig.enablePreloading) {
+        buildShowcaseWorkspace(blockSuiteWorkspace, {
+          schema: globalBlockSuiteSchema,
+          store: getCurrentStore(),
+          atoms: {
+            pageMode: setPageModeAtom,
+          },
+        }).catch(err => {
+          logger.error('init page with preloading failed', err);
+        });
+      } else {
+        const page = blockSuiteWorkspace.createPage();
+        blockSuiteWorkspace.setPageMeta(page.id, {
+          jumpOnce: true,
+        });
+        initEmptyPage(page).catch(error => {
+          logger.error('init page with empty failed', error);
+        });
+      }
+      const provider = createIndexedDBDownloadProvider(
+        blockSuiteWorkspace.id,
+        blockSuiteWorkspace.doc,
+        {
+          awareness: blockSuiteWorkspace.awarenessStore.awareness,
+        }
+      ) as LocalIndexedDBDownloadProvider;
+      provider.sync();
+      provider.whenReady.catch(console.error);
+      saveWorkspaceToLocalStorage(blockSuiteWorkspace.id);
+      logger.debug('create first workspace');
+      return [blockSuiteWorkspace.id];
+    },
+  },
+  CRUD,
+  UI: {
+    Header: WorkspaceHeader,
+    Provider,
+    PageDetail: ({ currentWorkspaceId, currentPageId, onLoadEditor }) => {
+      const [workspaceAtom] = getBlockSuiteWorkspaceAtom(currentWorkspaceId);
+      const workspace = useAtomValue(workspaceAtom);
+      const page = workspace.getPage(currentPageId);
+      if (!page) {
+        throw new PageNotFoundError(workspace, currentPageId);
+      }
+      return (
+        <>
+          <PageDetailEditor
+            pageId={currentPageId}
+            onInit={useCallback(async page => initEmptyPage(page), [])}
+            onLoad={onLoadEditor}
+            workspace={workspace}
+          />
+        </>
+      );
+    },
+    PageList: ({ blockSuiteWorkspace, onOpenPage, collection }) => {
+      return (
+        <BlockSuitePageList
+          listType="all"
+          collection={collection}
+          onOpenPage={onOpenPage}
+          blockSuiteWorkspace={blockSuiteWorkspace}
+        />
+      );
+    },
+    NewSettingsDetail: ({
+      currentWorkspaceId,
+      onTransformWorkspace,
+      onDeleteLocalWorkspace,
+      onDeleteCloudWorkspace,
+      onLeaveWorkspace,
+    }) => {
+      return (
+        <NewWorkspaceSettingDetail
+          onDeleteLocalWorkspace={onDeleteLocalWorkspace}
+          onDeleteCloudWorkspace={onDeleteCloudWorkspace}
+          onLeaveWorkspace={onLeaveWorkspace}
+          workspaceId={currentWorkspaceId}
+          onTransferWorkspace={onTransformWorkspace}
+          isOwner={true}
+        />
+      );
+    },
+  },
+};

packages/frontend/core/src/adapters/public-cloud/ui.tsx

@@ -0,0 +1,45 @@
+import { PageNotFoundError } from '@affine/env/constant';
+import type { WorkspaceFlavour } from '@affine/env/workspace';
+import { type WorkspaceUISchema } from '@affine/env/workspace';
+import { initEmptyPage } from '@toeverything/infra/blocksuite';
+import { useCallback } from 'react';
+
+import { useWorkspace } from '../../hooks/use-workspace';
+import { BlockSuitePageList, PageDetailEditor, Provider } from '../shared';
+
+export const UI = {
+  Provider,
+  Header: () => {
+    return null;
+  },
+  PageDetail: ({ currentWorkspaceId, currentPageId, onLoadEditor }) => {
+    const workspace = useWorkspace(currentWorkspaceId);
+    const page = workspace.blockSuiteWorkspace.getPage(currentPageId);
+    if (!page) {
+      throw new PageNotFoundError(workspace.blockSuiteWorkspace, currentPageId);
+    }
+    return (
+      <>
+        <PageDetailEditor
+          pageId={currentPageId}
+          onInit={useCallback(async page => initEmptyPage(page), [])}
+          onLoad={onLoadEditor}
+          workspace={workspace.blockSuiteWorkspace}
+        />
+      </>
+    );
+  },
+  PageList: ({ blockSuiteWorkspace, onOpenPage, collection }) => {
+    return (
+      <BlockSuitePageList
+        listType="all"
+        collection={collection}
+        onOpenPage={onOpenPage}
+        blockSuiteWorkspace={blockSuiteWorkspace}
+      />
+    );
+  },
+  NewSettingsDetail: () => {
+    throw new Error('Not implemented');
+  },
+} satisfies WorkspaceUISchema<WorkspaceFlavour.AFFINE_PUBLIC>;

packages/frontend/core/src/adapters/shared.ts

@@ -0,0 +1,35 @@
+import { lazy } from 'react';
+
+export const Provider = lazy(() =>
+  import('../components/cloud/provider').then(({ Provider }) => ({
+    default: Provider,
+  }))
+);
+
+export const NewWorkspaceSettingDetail = lazy(() =>
+  import('../components/affine/new-workspace-setting-detail').then(
+    ({ WorkspaceSettingDetail }) => ({
+      default: WorkspaceSettingDetail,
+    })
+  )
+);
+
+export const BlockSuitePageList = lazy(() =>
+  import('../components/blocksuite/block-suite-page-list').then(
+    ({ BlockSuitePageList }) => ({
+      default: BlockSuitePageList,
+    })
+  )
+);
+
+export const PageDetailEditor = lazy(() =>
+  import('../components/page-detail-editor').then(({ PageDetailEditor }) => ({
+    default: PageDetailEditor,
+  }))
+);
+
+export const WorkspaceHeader = lazy(() =>
+  import('../components/workspace-header').then(({ WorkspaceHeader }) => ({
+    default: WorkspaceHeader,
+  }))
+);

packages/frontend/core/src/adapters/workspace.ts

@@ -0,0 +1,76 @@
+import { Unreachable } from '@affine/env/constant';
+import type {
+  AppEvents,
+  WorkspaceAdapter,
+  WorkspaceUISchema,
+} from '@affine/env/workspace';
+import {
+  LoadPriority,
+  ReleaseType,
+  WorkspaceFlavour,
+} from '@affine/env/workspace';
+import { CRUD as CloudCRUD } from '@affine/workspace/affine/crud';
+import { startSync, stopSync } from '@affine/workspace/affine/sync';
+
+import { UI as CloudUI } from './cloud/ui';
+import { LocalAdapter } from './local';
+import { UI as PublicCloudUI } from './public-cloud/ui';
+
+const unimplemented = () => {
+  throw new Error('Not implemented');
+};
+
+const bypassList = async () => {
+  return [];
+};
+
+export const WorkspaceAdapters = {
+  [WorkspaceFlavour.LOCAL]: LocalAdapter,
+  [WorkspaceFlavour.AFFINE_CLOUD]: {
+    releaseType: ReleaseType.UNRELEASED,
+    flavour: WorkspaceFlavour.AFFINE_CLOUD,
+    loadPriority: LoadPriority.HIGH,
+    Events: {
+      'app:access': async () => {
+        try {
+          const { getSession } = await import('next-auth/react');
+          const session = await getSession();
+          return !!session;
+        } catch (e) {
+          console.error('failed to get session', e);
+          return false;
+        }
+      },
+      'service:start': startSync,
+      'service:stop': stopSync,
+    } as Partial<AppEvents>,
+    CRUD: CloudCRUD,
+    UI: CloudUI,
+  },
+  [WorkspaceFlavour.AFFINE_PUBLIC]: {
+    releaseType: ReleaseType.UNRELEASED,
+    flavour: WorkspaceFlavour.AFFINE_PUBLIC,
+    loadPriority: LoadPriority.LOW,
+    Events: {} as Partial<AppEvents>,
+    // todo: implement this
+    CRUD: {
+      get: unimplemented,
+      list: bypassList,
+      delete: unimplemented,
+      create: unimplemented,
+    },
+    UI: PublicCloudUI,
+  },
+} satisfies {
+  [Key in WorkspaceFlavour]: WorkspaceAdapter<Key>;
+};
+
+export function getUIAdapter<Flavour extends WorkspaceFlavour>(
+  flavour: Flavour
+): WorkspaceUISchema<Flavour> {
+  const ui = WorkspaceAdapters[flavour].UI as WorkspaceUISchema<Flavour>;
+  if (!ui) {
+    throw new Unreachable();
+  }
+  return ui;
+}