fix: adjust some styles (#2438)

Co-authored-by: Himself65 <himself65@outlook.com>

.eslintignore

@@ -5,6 +5,3 @@ out
 storybook-static
 affine-out
 _next
-lib
-.eslintrc.js
-packages/i18n/src/i18n-generated.ts

.eslintrc.js

@@ -1,50 +1,3 @@
-const { resolve } = require('node:path');
-
-const createPattern = packageName => [
-  {
-    group: ['**/dist', '**/dist/**'],
-    message: 'Do not import from dist',
-    allowTypeImports: false,
-  },
-  {
-    group: ['**/src', '**/src/**'],
-    message: 'Do not import from src',
-    allowTypeImports: false,
-  },
-  {
-    group: [`@affine/${packageName}`],
-    message: 'Do not import package itself',
-    allowTypeImports: false,
-  },
-  {
-    group: [`@toeverything/${packageName}`],
-    message: 'Do not import package itself',
-    allowTypeImports: false,
-  },
-];
-
-const allPackages = [
-  'packages/cli',
-  'packages/component',
-  'packages/debug',
-  'packages/env',
-  'packages/graphql',
-  'packages/hooks',
-  'packages/i18n',
-  'packages/jotai',
-  'packages/native',
-  'packages/plugin-infra',
-  'packages/templates',
-  'packages/theme',
-  'packages/workspace',
-  'packages/y-indexeddb',
-  'apps/web',
-  'apps/server',
-  'apps/electron',
-  'plugins/copilot',
-  'plugins/bookmark-block',
-];
-
 /**
  * @type {import('eslint').Linter.Config}
  */
@@ -74,28 +27,23 @@ const config = {
     },
     ecmaVersion: 'latest',
     sourceType: 'module',
-    project: resolve(__dirname, './tsconfig.eslint.json'),
   },
   plugins: [
     'react',
     '@typescript-eslint',
     'simple-import-sort',
-    'sonarjs',
     'import',
     'unused-imports',
     'unicorn',
   ],
   rules: {
-    'array-callback-return': 'error',
     'no-undef': 'off',
     'no-empty': 'off',
     'no-func-assign': 'off',
     'no-cond-assign': 'off',
-    'no-constant-binary-expression': 'error',
-    'no-constructor-return': 'error',
     'react/prop-types': 'off',
     '@typescript-eslint/consistent-type-imports': 'error',
-    '@typescript-eslint/no-non-null-assertion': 'error',
+    '@typescript-eslint/no-non-null-assertion': 'off',
     '@typescript-eslint/no-explicit-any': 'off',
     '@typescript-eslint/no-empty-function': 'off',
     '@typescript-eslint/no-unused-vars': [
@@ -109,15 +57,7 @@ const config = {
     'unused-imports/no-unused-imports': 'error',
     'simple-import-sort/imports': 'error',
     'simple-import-sort/exports': 'error',
-    '@typescript-eslint/ban-ts-comment': [
-      'error',
-      {
-        'ts-expect-error': 'allow-with-description',
-        'ts-ignore': true,
-        'ts-nocheck': true,
-        'ts-check': false,
-      },
-    ],
+    '@typescript-eslint/ban-ts-comment': 0,
     '@typescript-eslint/no-restricted-imports': [
       'error',
       {
@@ -142,21 +82,6 @@ const config = {
         ignore: ['^\\[[a-zA-Z0-9-_]+\\]\\.tsx$'],
       },
     ],
-    'sonarjs/no-all-duplicated-branches': 'error',
-    'sonarjs/no-element-overwrite': 'error',
-    'sonarjs/no-empty-collection': 'error',
-    'sonarjs/no-extra-arguments': 'error',
-    'sonarjs/no-identical-conditions': 'error',
-    'sonarjs/no-identical-expressions': 'error',
-    'sonarjs/no-ignored-return': 'error',
-    'sonarjs/no-one-iteration-loop': 'error',
-    'sonarjs/no-use-of-empty-return-value': 'error',
-    'sonarjs/non-existent-operator': 'error',
-    'sonarjs/no-collapsible-if': 'error',
-    'sonarjs/no-same-line-conditional': 'error',
-    'sonarjs/no-duplicated-branches': 'error',
-    'sonarjs/no-collection-size-mischeck': 'error',
-    'sonarjs/no-useless-catch': 'error',
   },
   overrides: [
     {
@@ -171,51 +96,6 @@ const config = {
         '@typescript-eslint/no-var-requires': 0,
       },
     },
-    ...allPackages.map(pkg => ({
-      files: [`${pkg}/src/**/*.ts`, `${pkg}/src/**/*.tsx`],
-      parserOptions: {
-        project: resolve(__dirname, './tsconfig.eslint.json'),
-      },
-      rules: {
-        '@typescript-eslint/no-restricted-imports': [
-          'error',
-          {
-            patterns: createPattern(pkg),
-          },
-        ],
-        '@typescript-eslint/no-floating-promises': [
-          'error',
-          {
-            ignoreVoid: false,
-            ignoreIIFE: false,
-          },
-        ],
-      },
-    })),
-    {
-      files: [
-        '**/__tests__/**/*',
-        '**/*.stories.tsx',
-        '**/*.spec.ts',
-        '**/tests/**/*',
-        'scripts/**/*',
-        '**/benchmark/**/*',
-        '**/__debug__/**/*',
-      ],
-      rules: {
-        '@typescript-eslint/no-non-null-assertion': 0,
-        '@typescript-eslint/ban-ts-comment': [
-          'error',
-          {
-            'ts-expect-error': false,
-            'ts-ignore': true,
-            'ts-nocheck': true,
-            'ts-check': false,
-          },
-        ],
-        '@typescript-eslint/no-floating-promises': 0,
-      },
-    },
   ],
 };
 

.github/CLA.md

@@ -58,4 +58,3 @@ Example:
 - Howard Do, @howarddo2208, 2023/04/20
 - 三咲智子 Kevin Deng, @sxzz, 2023/04/21
 - Moeyua, @moeyua, 2023/04/22
-- Shishu, @shishudesu, 2023/05/19

.github/CODEOWNERS

@@ -0,0 +1 @@
+**/en.json @JimmFly

.github/actions/build-rust/action.yml

@@ -29,23 +29,21 @@ runs:
       if: ${{ inputs.target != 'x86_64-unknown-linux-gnu' && inputs.target != 'aarch64-unknown-linux-gnu' }}
       shell: bash
       run: yarn workspace @affine/native build --target ${{ inputs.target }}
+      env:
+        CARGO_BUILD_INCREMENTAL: 'false'
 
     - name: Build
       if: ${{ inputs.target == 'x86_64-unknown-linux-gnu' }}
       uses: addnab/docker-run-action@v3
       with:
         image: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-debian
-        options: --user 0:0 -v ${{ github.workspace }}/.cargo-cache/git/db:/usr/local/cargo/git/db -v ${{ github.workspace }}/.cargo/registry/cache:/usr/local/cargo/registry/cache -v ${{ github.workspace }}/.cargo/registry/index:/usr/local/cargo/registry/index -v ${{ github.workspace }}:/build -w /build
-        run: >-
-          export CC=x86_64-unknown-linux-gnu-gcc &&
-          export CC_x86_64_unknown_linux_gnu=x86_64-unknown-linux-gnu-gcc &&
-          yarn workspace @affine/native build --target ${{ inputs.target }}
+        options: --user 0:0 -e CARGO_BUILD_INCREMENTAL=false -v ${{ github.workspace }}/.cargo-cache/git/db:/usr/local/cargo/git/db -v ${{ github.workspace }}/.cargo/registry/cache:/usr/local/cargo/registry/cache -v ${{ github.workspace }}/.cargo/registry/index:/usr/local/cargo/registry/index -v ${{ github.workspace }}:/build -w /build
+        run: yarn workspace @affine/native build --target ${{ inputs.target }}
 
     - name: Build
       if: ${{ inputs.target == 'aarch64-unknown-linux-gnu' }}
       uses: addnab/docker-run-action@v3
       with:
         image: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-debian-aarch64
-        options: --user 0:0 -v ${{ github.workspace }}/.cargo-cache/git/db:/usr/local/cargo/git/db -v ${{ github.workspace }}/.cargo/registry/cache:/usr/local/cargo/registry/cache -v ${{ github.workspace }}/.cargo/registry/index:/usr/local/cargo/registry/index -v ${{ github.workspace }}:/build -w /build
-        run: >-
-          yarn workspace @affine/native build --target ${{ inputs.target }}
+        options: --user 0:0 -e CARGO_BUILD_INCREMENTAL=false -v ${{ github.workspace }}/.cargo-cache/git/db:/usr/local/cargo/git/db -v ${{ github.workspace }}/.cargo/registry/cache:/usr/local/cargo/registry/cache -v ${{ github.workspace }}/.cargo/registry/index:/usr/local/cargo/registry/index -v ${{ github.workspace }}:/build -w /build
+        run: yarn workspace @affine/native build --target ${{ inputs.target }}

.github/labeler.yml

@@ -8,17 +8,11 @@ test:
   - '**/tests/**/*'
   - '**/__tests__/**/*'
 
-plugin:copilot:
-  - 'plugins/copilot/**/*'
-
 mod:dev:
   - 'scripts/**/*'
   - 'packages/cli/**/*'
   - 'packages/debug/**/*'
 
-mod:plugin-infra:
-  - 'packages/plugin-infra/**/*'
-
 mod:workspace: 'packages/workspace/**/*'
 
 mod:i18n: 'packages/i18n/**/*'

.github/workflows/add-to-project.yml

@@ -0,0 +1,24 @@
+name: Add to GitHub projects
+
+on:
+  issues:
+    types:
+      - opened
+  pull_request_target:
+    types:
+      - opened
+      - reopened
+
+jobs:
+  add-to-project:
+    name: Add issues and pull requests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/add-to-project@v0.4.0
+        with:
+          # You can target a repository in a different organization
+          # to the issue
+          project-url: https://github.com/orgs/toeverything/projects/10
+          github-token: ${{ secrets.ADD_TO_PROJECT_PAT }}
+          # labeled: bug, needs-triage
+          # label-operator: OR

.github/workflows/build.yml

@@ -23,7 +23,6 @@ on:
 env:
   DEBUG: napi:*
   APP_NAME: affine
-  COVERAGE: true
   MACOSX_DEPLOYMENT_TARGET: '10.13'
 
 jobs:
@@ -36,12 +35,7 @@ jobs:
       - uses: actions/checkout@v3
       - name: Setup Node.js
         uses: ./.github/actions/setup-node
-      - name: Run checks
-        run: |
-          yarn i18n-codegen gen
-          yarn typecheck
-          yarn lint --max-warnings=0
-          yarn circular
+      - run: yarn lint --max-warnings=0
 
   build-storybook:
     name: Build Storybook
@@ -52,15 +46,15 @@ jobs:
       - uses: actions/checkout@v3
       - name: Setup Node.js
         uses: ./.github/actions/setup-node
-      - run: yarn nx build @affine/storybook
+      - run: yarn build:storybook
       - name: Upload storybook artifact
         uses: actions/upload-artifact@v3
         with:
           name: storybook
-          path: ./packages/storybook/storybook-static
+          path: ./packages/component/storybook-static
           if-no-files-found: error
 
-  build-web:
+  build:
     name: Build @affine/web
     runs-on: ubuntu-latest
     environment: development
@@ -77,15 +71,20 @@ jobs:
           key: ${{ runner.os }}-nextjs-${{ hashFiles('**/yarn.lock') }}-${{ hashFiles('**.[jt]s', '**.[jt]sx') }}
           restore-keys: |
             ${{ runner.os }}-nextjs-${{ hashFiles('**/yarn.lock') }}-
-      - name: Build Web
-        run: yarn nx build @affine/web
+      - name: Build
+        run: yarn build
         env:
+          NEXT_PUBLIC_FIREBASE_API_KEY: ${{ secrets.NEXT_PUBLIC_FIREBASE_API_KEY }}
+          NEXT_PUBLIC_FIREBASE_AUTH_DOMAIN: ${{ secrets.NEXT_PUBLIC_FIREBASE_AUTH_DOMAIN }}
+          NEXT_PUBLIC_FIREBASE_PROJECT_ID: ${{ secrets.NEXT_PUBLIC_FIREBASE_PROJECT_ID }}
+          NEXT_PUBLIC_FIREBASE_STORAGE_BUCKET: ${{ secrets.NEXT_PUBLIC_FIREBASE_STORAGE_BUCKET }}
+          NEXT_PUBLIC_FIREBASE_MESSAGING_SENDER_ID: ${{ secrets.NEXT_PUBLIC_FIREBASE_MESSAGING_SENDER_ID }}
+          NEXT_PUBLIC_FIREBASE_APP_ID: ${{ secrets.NEXT_PUBLIC_FIREBASE_APP_ID }}
+          NEXT_PUBLIC_FIREBASE_MEASUREMENT_ID: ${{ secrets.NEXT_PUBLIC_FIREBASE_MEASUREMENT_ID }}
           API_SERVER_PROFILE: local
-          ENABLE_DEBUG_PAGE: 1
-          ENABLE_PLUGIN: true
-          ENABLE_ALL_PAGE_FILTER: true
+          ENABLE_DEBUG_PAGE: true
           ENABLE_LEGACY_PROVIDER: true
-          ENABLE_PRELOADING: false
+          COVERAGE: true
 
       - name: Upload artifact
         uses: actions/upload-artifact@v3
@@ -94,18 +93,24 @@ jobs:
           path: ./apps/web/.next
           if-no-files-found: error
 
-      - name: Build Web (Desktop)
-        run: yarn nx build @affine/web
+      - name: Build @affine/web for desktop
+        run: yarn build
         env:
+          NEXT_PUBLIC_FIREBASE_API_KEY: ${{ secrets.NEXT_PUBLIC_FIREBASE_API_KEY }}
+          NEXT_PUBLIC_FIREBASE_AUTH_DOMAIN: ${{ secrets.NEXT_PUBLIC_FIREBASE_AUTH_DOMAIN }}
+          NEXT_PUBLIC_FIREBASE_PROJECT_ID: ${{ secrets.NEXT_PUBLIC_FIREBASE_PROJECT_ID }}
+          NEXT_PUBLIC_FIREBASE_STORAGE_BUCKET: ${{ secrets.NEXT_PUBLIC_FIREBASE_STORAGE_BUCKET }}
+          NEXT_PUBLIC_FIREBASE_MESSAGING_SENDER_ID: ${{ secrets.NEXT_PUBLIC_FIREBASE_MESSAGING_SENDER_ID }}
+          NEXT_PUBLIC_FIREBASE_APP_ID: ${{ secrets.NEXT_PUBLIC_FIREBASE_APP_ID }}
+          NEXT_PUBLIC_FIREBASE_MEASUREMENT_ID: ${{ secrets.NEXT_PUBLIC_FIREBASE_MEASUREMENT_ID }}
           API_SERVER_PROFILE: affine
-          ENABLE_DEBUG_PAGE: 1
-          ENABLE_PLUGIN: true
-          ENABLE_ALL_PAGE_FILTER: true
+          ENABLE_DEBUG_PAGE: true
           ENABLE_LEGACY_PROVIDER: false
-          ENABLE_PRELOADING: false
+          COVERAGE: true
 
       - name: Export static resources
-        run: yarn workspace @affine/web export
+        run: yarn export
+        working-directory: apps/web
 
       - name: Upload static resources artifact
         uses: actions/upload-artifact@v3
@@ -154,7 +159,8 @@ jobs:
         env:
           DATABASE_URL: postgresql://affine:affine@localhost:5432/affine
       - name: Run server tests
-        run: yarn nx test:coverage @affine/server
+        run: yarn test:coverage
+        working-directory: apps/server
         env:
           DATABASE_URL: postgresql://affine:affine@localhost:5432/affine
       - name: Upload server test coverage results
@@ -181,11 +187,19 @@ jobs:
         uses: actions/download-artifact@v3
         with:
           name: storybook
-          path: ./packages/storybook/storybook-static
+          path: ./packages/component/storybook-static
       - name: Run storybook tests
-        working-directory: ./packages/storybook
+        working-directory: ./packages/component
         run: |
-          yarn exec concurrently -k -s first -n "SB,TEST" -c "magenta,blue" "yarn exec serve ./storybook-static -l 6006" "yarn exec wait-on tcp:6006 && yarn test"
+          yarn exec concurrently -k -s first -n "SB,TEST" -c "magenta,blue" "yarn exec serve ./storybook-static -l 6006" "yarn exec wait-on tcp:6006 && yarn test-storybook --coverage"
+      - name: Upload storybook test coverage results
+        uses: codecov/codecov-action@v3
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          files: ./packages/component/coverage/storybook/coverage-storybook.json
+          flags: storybook-test
+          name: affine
+          fail_ci_if_error: true
 
   e2e-test:
     name: E2E Test
@@ -195,7 +209,7 @@ jobs:
       matrix:
         shard: [1, 2, 3, 4]
     environment: development
-    needs: [build-web, build-storybook]
+    needs: [build, build-storybook]
     services:
       octobase:
         image: ghcr.io/toeverything/cloud-self-hosted:nightly-latest
@@ -222,14 +236,14 @@ jobs:
         uses: actions/download-artifact@v3
         with:
           name: storybook
-          path: ./packages/storybook/storybook-static
+          path: ./packages/component/storybook-static
 
       - name: Wait for Octobase Ready
         run: |
           node ./scripts/wait-3000-healthz.mjs
 
       - name: Run playwright tests
-        run: yarn e2e --forbid-only --shard=${{ matrix.shard }}/${{ strategy.job-total }}
+        run: yarn test --forbid-only --shard=${{ matrix.shard }}/${{ strategy.job-total }}
         env:
           COVERAGE: true
 
@@ -253,7 +267,7 @@ jobs:
           path: ./test-results
           if-no-files-found: ignore
 
-  desktop-test:
+  dekstop-test:
     name: Desktop Test
     runs-on: ${{ matrix.spec.os }}
     environment: development
@@ -290,7 +304,7 @@ jobs:
               target: x86_64-pc-windows-msvc,
               test: true,
             }
-    needs: [build-web]
+    needs: [build]
     steps:
       - uses: actions/checkout@v3
       - name: Setup Node.js
@@ -304,17 +318,27 @@ jobs:
       - name: Run unit tests
         if: ${{ matrix.spec.test }}
         shell: bash
-        run: yarn nx test @affine/monorepo
+        run: |
+          rm -rf apps/electron/node_modules/better-sqlite3/build
+          yarn --cwd apps/electron/node_modules/better-sqlite3 run install
+          yarn test:unit
         env:
           NATIVE_TEST: 'true'
       - name: Build layers
-        run: yarn workspace @affine/electron build
+        run: yarn workspace @affine/electron build-layers
+
       - name: Download static resource artifact
         uses: actions/download-artifact@v3
         with:
           name: next-js-static
           path: ./apps/electron/resources/web-static
 
+      - name: Rebuild Electron dependences
+        shell: bash
+        run: |
+          rm -rf apps/electron/node_modules/better-sqlite3/build
+          yarn workspace @affine/electron rebuild:for-electron --arch=${{ matrix.spec.arch }}
+
       - name: Run desktop tests
         if: ${{ matrix.spec.test && matrix.spec.os == 'ubuntu-latest' }}
         run: xvfb-run --auto-servernum --server-args="-screen 0 1280x960x24" -- yarn workspace @affine/electron test
@@ -341,11 +365,6 @@ jobs:
           name: affine
           fail_ci_if_error: true
 
-      - name: Run desktop tests
-        if: ${{ matrix.spec.test && matrix.spec.os != 'ubuntu-latest' }}
-        run: yarn test
-        working-directory: apps/electron
-
       - name: Upload test results
         if: ${{ failure() }}
         uses: actions/upload-artifact@v3
@@ -374,7 +393,7 @@ jobs:
         uses: ./.github/actions/setup-node
 
       - name: Unit Test
-        run: yarn nx test:coverage @affine/monorepo
+        run: yarn run test:unit:coverage
 
       - name: Upload unit test coverage results
         uses: codecov/codecov-action@v3

.github/workflows/languages-sync.yml

@@ -13,6 +13,14 @@ on:
       - '.github/workflows/languages-sync.yml'
   workflow_dispatch:
 
+# Cancels all previous workflow runs for pull requests that have not completed.
+# See https://docs.github.com/en/actions/using-jobs/using-concurrency
+concurrency:
+  # The concurrency group contains the workflow name and the branch name for
+  # pull requests or the commit hash for any other events.
+  group: ${{ github.workflow }}-${{ github.event_name == 'pull_request' && github.head_ref || github.sha }}
+  cancel-in-progress: true
+
 jobs:
   main:
     runs-on: ubuntu-latest

.github/workflows/nightly-build.yml

@@ -50,14 +50,22 @@ jobs:
         working-directory: apps/electron
         run: yarn generate-assets
         env:
+          NEXT_PUBLIC_FIREBASE_API_KEY: ${{ secrets.NEXT_PUBLIC_FIREBASE_API_KEY }}
+          NEXT_PUBLIC_FIREBASE_AUTH_DOMAIN: ${{ secrets.NEXT_PUBLIC_FIREBASE_AUTH_DOMAIN }}
+          NEXT_PUBLIC_FIREBASE_PROJECT_ID: ${{ secrets.NEXT_PUBLIC_FIREBASE_PROJECT_ID }}
+          NEXT_PUBLIC_FIREBASE_STORAGE_BUCKET: ${{ secrets.NEXT_PUBLIC_FIREBASE_STORAGE_BUCKET }}
+          NEXT_PUBLIC_FIREBASE_MESSAGING_SENDER_ID: ${{ secrets.NEXT_PUBLIC_FIREBASE_MESSAGING_SENDER_ID }}
+          NEXT_PUBLIC_FIREBASE_APP_ID: ${{ secrets.NEXT_PUBLIC_FIREBASE_APP_ID }}
+          NEXT_PUBLIC_FIREBASE_MEASUREMENT_ID: ${{ secrets.NEXT_PUBLIC_FIREBASE_MEASUREMENT_ID }}
+          AFFINE_GOOGLE_CLIENT_ID: ${{ secrets.AFFINE_GOOGLE_CLIENT_ID }}
+          AFFINE_GOOGLE_CLIENT_SECRET: ${{ secrets.AFFINE_GOOGLE_CLIENT_SECRET }}
           SENTRY_ORG: ${{ secrets.SENTRY_ORG }}
           SENTRY_PROJECT: ${{ secrets.SENTRY_PROJECT }}
           NEXT_PUBLIC_SENTRY_DSN: ${{ secrets.NEXT_PUBLIC_SENTRY_DSN }}
           SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
           API_SERVER_PROFILE: prod
           ENABLE_TEST_PROPERTIES: false
-          ENABLE_IMAGE_PREVIEW_MODAL: true
-          ENABLE_BOOKMARK_OPERATION: true
+          ENABLE_IMAGE_PREVIEW_MODAL: false
           RELEASE_VERSION: ${{ needs.set-build-version.outputs.version }}
 
       - name: Upload Artifact (web-static)
@@ -119,9 +127,14 @@ jobs:
         with:
           name: before-make-web-static
           path: apps/electron/resources/web-static
+      - name: Rebuild Electron dependences
+        shell: bash
+        run: |
+          rm -rf apps/electron/node_modules/better-sqlite3/build
+          yarn workspace @affine/electron rebuild:for-electron --arch=${{ matrix.spec.arch }}
 
       - name: Build layers
-        run: yarn workspace @affine/electron build
+        run: yarn workspace @affine/electron build-layers
 
       - name: Signing By Apple Developer ID
         if: ${{ matrix.spec.platform == 'darwin' }}

.github/workflows/release-desktop-app.yml

@@ -51,13 +51,22 @@ jobs:
       - name: generate-assets
         run: yarn workspace @affine/electron generate-assets
         env:
+          NEXT_PUBLIC_FIREBASE_API_KEY: ${{ secrets.NEXT_PUBLIC_FIREBASE_API_KEY }}
+          NEXT_PUBLIC_FIREBASE_AUTH_DOMAIN: ${{ secrets.NEXT_PUBLIC_FIREBASE_AUTH_DOMAIN }}
+          NEXT_PUBLIC_FIREBASE_PROJECT_ID: ${{ secrets.NEXT_PUBLIC_FIREBASE_PROJECT_ID }}
+          NEXT_PUBLIC_FIREBASE_STORAGE_BUCKET: ${{ secrets.NEXT_PUBLIC_FIREBASE_STORAGE_BUCKET }}
+          NEXT_PUBLIC_FIREBASE_MESSAGING_SENDER_ID: ${{ secrets.NEXT_PUBLIC_FIREBASE_MESSAGING_SENDER_ID }}
+          NEXT_PUBLIC_FIREBASE_APP_ID: ${{ secrets.NEXT_PUBLIC_FIREBASE_APP_ID }}
+          NEXT_PUBLIC_FIREBASE_MEASUREMENT_ID: ${{ secrets.NEXT_PUBLIC_FIREBASE_MEASUREMENT_ID }}
+          AFFINE_GOOGLE_CLIENT_ID: ${{ secrets.AFFINE_GOOGLE_CLIENT_ID }}
+          AFFINE_GOOGLE_CLIENT_SECRET: ${{ secrets.AFFINE_GOOGLE_CLIENT_SECRET }}
           SENTRY_ORG: ${{ secrets.SENTRY_ORG }}
           SENTRY_PROJECT: ${{ secrets.SENTRY_PROJECT }}
+          NEXT_PUBLIC_SENTRY_DSN: ${{ secrets.NEXT_PUBLIC_SENTRY_DSN }}
           SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
           API_SERVER_PROFILE: prod
           ENABLE_TEST_PROPERTIES: false
-          ENABLE_IMAGE_PREVIEW_MODAL: true
-          ENABLE_BOOKMARK_OPERATION: true
+          ENABLE_IMAGE_PREVIEW_MODAL: false
           RELEASE_VERSION: ${{ github.event.inputs.version }}
 
       - name: Upload Artifact (web-static)
@@ -116,8 +125,14 @@ jobs:
           name: before-make-web-static
           path: apps/electron/resources/web-static
 
+      - name: Rebuild Electron dependences
+        shell: bash
+        run: |
+          rm -rf apps/electron/node_modules/better-sqlite3/build
+          yarn workspace @affine/electron rebuild:for-electron --arch=${{ matrix.spec.arch }}
+
       - name: Build layers
-        run: yarn workspace @affine/electron build
+        run: yarn workspace @affine/electron build-layers
 
       - name: Signing By Apple Developer ID
         if: ${{ matrix.spec.platform == 'darwin' }}

.gitignore

@@ -28,9 +28,9 @@ node_modules
 
 # IDE - VSCode
 .vscode/*
+!.vscode/settings.json
 !.vscode/tasks.json
-!.vscode/settings.template.json
-!.vscode/launch.template.json
+!.vscode/launch.json
 !.vscode/extensions.json
 
 # misc
@@ -66,11 +66,7 @@ i18n-generated.ts
 # Cache
 .eslintcache
 next-env.d.ts
-.rollup.cache
 
 # Rust
 target
 *.node
-tsconfig.node.tsbuildinfo
-lib
-affine.db

.prettierignore

@@ -1,4 +1 @@
 pnpm-lock.yaml
-target
-lib
-test-results

.vscode/launch.json

@@ -6,12 +6,6 @@
       "name": "Run Dev",
       "request": "launch",
       "type": "node-terminal"
-    },
-    {
-      "command": "yarn run dev:local",
-      "name": "Run Dev Locally",
-      "request": "launch",
-      "type": "node-terminal"
     }
   ]
 }

.vscode/settings.json

@@ -34,11 +34,9 @@
     "packages/**/*.spec.tsx",
     "apps/web/**/*.spec.ts",
     "apps/web/**/*.spec.tsx",
-    "apps/electron/src/**/*.spec.ts",
+    "apps/electron/layers/**/*.spec.ts",
     "tests/unit/**/*.spec.ts",
     "tests/unit/**/*.spec.tsx"
   ],
-  "rust-analyzer.check.extraEnv": {
-    "DATABASE_URL": "sqlite:affine.db"
-  }
+  "deepscan.enable": true
 }

.yarnrc.yml

@@ -16,4 +16,4 @@ plugins:
   - path: .yarn/plugins/@yarnpkg/plugin-workspace-tools.cjs
     spec: '@yarnpkg/plugin-workspace-tools'
 
-yarnPath: .yarn/releases/yarn-3.6.0.cjs
+yarnPath: .yarn/releases/yarn-3.5.0.cjs

Cargo.toml

@@ -1,8 +1,5 @@
 [workspace]
-members = ["./packages/native", "./packages/native/schema"]
-
-[profile.dev.package.sqlx-macros]
-opt-level = 3
+members = ["./packages/native"]
 
 [profile.release]
 lto = true

README.md

@@ -24,13 +24,12 @@ See https://github.com/all-?/all-contributors/issues/361#issuecomment-637166066
 
 <!-- ALL-CONTRIBUTORS-BADGE:END -->
 
-[![AFFiNE Web](<https://img.shields.io/badge/-Try%20It%20Online%20%E2%86%92-rgb(84,56,255)?style=flat-square&logoColor=white&logo=affine>)](https://app.affine.pro)
+[![AFFiNE Web](<https://img.shields.io/badge/-Try%20It%20Online%20%E2%86%92-rgb(84,56,255)?style=flat-square&logoColor=white&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAACXBIWXMAAADAAAAAwAEwd99eAAABjElEQVRYhe1W0U3DMBB9RfyTDeoNyAYNG2QDOgJsECYgGxA26AZ4hIxgJqCZ4PjIGV+tUxK7raqiPsmKdXe5e3fOs7IiIlwSdxetfiNw7QRKAD0Ax/ssrI5QgQOw5v03AJOTJHcCL1x84LVmWzJyJlBg7P4BwCvb3pmIAbBPykZEqaulEU7YHNva1HypxUsKqIS9EvbynASs0n3ss+ciUIsuO8VvhL9emjdFBa3YO8XvALwpsZNYSqBB0PwUWgRZNksSL5GhlN0ngGd+dkpsD6AG8IGlslxwTh2fa09EBc3Dir32rRysuQlUAL54/wTAcpePPAXHPsOTGXhSEv69rAlYpZOt6DSO29J4D/TRRLJk6AvtaZSY9PkCFYVLqI9i/NF5YkkECgrXa6P4fVEn4iolrhNxRQqBZu7FqMNdZiMqAUPj2KdGZyicu1dHzlGqBHxn2sdTR53bmeJ+ebJd7LtXhGH4uQEwd0ttAPzMxGi5/6BdxTuMej41Bs59gGP+CU+Cq/4tvxH4HwR+Ab3Uqr/VGbqEAAAAAElFTkSuQmCC>)](https://app.affine.pro)
 [![AFFiNE macOS M1/M2 Chip](https://img.shields.io/badge/-macOS_M_Chip%20%E2%86%92-black?style=flat-square&logo=apple&logoColor=white)](https://affine.pro/download)
 [![AFFiNE macOS x64](https://img.shields.io/badge/-macOS_x86%20%E2%86%92-black?style=flat-square&logo=apple&logoColor=white)](https://affine.pro/download)
 [![AFFiNE Window x64](https://img.shields.io/badge/-Windows%20%E2%86%92-blue?style=flat-square&logo=windows&logoColor=white)](https://affine.pro/download)
 [![AFFiNE Linux](https://img.shields.io/badge/-Linux%20%E2%86%92-yellow?style=flat-square&logo=linux&logoColor=white)](https://affine.pro/download)
 
-[![Releases](https://img.shields.io/github/downloads/toeverything/AFFiNE/total)](https://github.com/toeverything/AFFiNE/releases/latest)
 [![stars-icon]](https://github.com/toeverything/AFFiNE)
 [![All Contributors][all-contributors-badge]](#contributors)
 [![codecov]](https://codecov.io/gh/toeverything/AFFiNE)
@@ -45,7 +44,7 @@ See https://github.com/all-?/all-contributors/issues/361#issuecomment-637166066
 ---
 
 <div align="center">
-    <a href="http://affine.pro"><img src="https://img.shields.io/badge/-AFFiNE-06449d?style=social&logo=affine" height=25></a>
+    <a href="http://affine.pro"><img src="https://img.shields.io/badge/-AFFiNE-06449d?style=social&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEsAAABLCAMAAAAPkIrYAAAAP1BMVEU8b9w8b9w+b947cNw7b9w6b908b909b9w8b9w7b9w8b9w7cN08b9w7b908b9w7b9w8b907cNw8b9w8b91HcEx3NJCJAAAAFXRSTlP/3QWSgA+lHPlu6Di4XtIrxk/xRADGudUoAAAB9UlEQVR42tWYwbKjIBREG0GJKkRj/v9bZ1ZvRC99rzib11tTB9qqnKoW3/+X38vy7ifzQ1b/wk/8Q1bCv3y6Z6wFh2x2llIRGB6xRhzz6p+wVhRJD1gRZZYHrADYSyqsjFPGZtYbuFESesUysZXlcMnYyJpxTW5keQh5N7G6CUJCE2uHFNfEGiBmbmB1H4jxDawNcqbuPmtAJTtj6RZ0lpIwiR5jNmgfNtHHwLXPWfFYcS2NMdxkjac/dNaNCJPo3yf9pFuseHbDrBsRFguGs8te8Q4rXzTjVSPCIHp3FePKWbzi30xE+4zlBMmoJaGLfpLUmAmLiN4Xyibahy76WZRQMLJ2WX27on2oFvQVac8yi4p+J2forA0V8W1c++AVS1f1H6p9KKLHxk9RWKmsyB+VLC76gV65DLjokdg5KmsEMXsiDwXWSmTc9ezSoKJHoi9zUVihbMHfQOSsXB7Mrz1S1huKPde69sEsiKgNt8hYTjiWlAyENeu7IFe1D15RSEBN+yCiXw17K1RZm/w7UtJVWYN8f1ZyLlkVb2bT4vIVVrINH1dqX2YttkHmIWsfVWs646wcRFYis6fIVGpfYq1kjpGSW8kSRD+xYSmXRM0Ang9eSZioVdy/5pWaLqzIRyIpuVxYozvGf1m67I7pf/s3UXv+AP61NI2Y+BbSAAAAAElFTkSuQmCC" height=25></a>
     &nbsp;
     <a href="https://community.affine.pro"><img src="https://img.shields.io/badge/-Community-424549?style=social&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAAXNJREFUWEftlitLRUEURtdVEVExWUx2qxgNVouoXYtNDP4Tw20WtftAsItZrHaTYBJREZ98MAc248wcZxi4CGfSeezHmm/23kyPAa/egPPTAXQK/FsFBP7ldVDRZoqcgO9I+2bHy3ZIJBfTCPCZM1tqAxwBmzUBrNQNbEx+5b0B5oEN4NCBrAMnMaiUAuPAs3HU82TLEZwBqwGbaJ4UgKQ8CFR6SoEl4LIWwCJwZQCegKkWBWLHVKSActvdzgG3DqitDf3/VQBskBDALrDnAKXUo3ueAF5KinAf2DKOmnzD7l214bdbA6hC1XHZNQa8hSBC0hwDa57xDHDvvvWB7ciOZoE79+8CWPbsBGc769eFxJdWIKcuyIdRoG3W7AAC1dJkHDIOo8B78+4rEBo8r4AkLFk6Jk3HaeDBBTgHVmIAfpJUz+cAFXVBreQCvQYW/lqEjV1NAMUMqpAaxQMHyDnjYtuS+0BxstwaqJooFqxToFPgB5FuPCEB6XK2AAAAAElFTkSuQmCC" height=25></a>
     &nbsp;
@@ -70,11 +69,11 @@ See https://github.com/all-?/all-contributors/issues/361#issuecomment-637166066
 
 Before we tell you how to get started with AFFiNE, we'd like to shamelessly plug our awesome user and developer communities across [official social platforms](https://community.affine.pro/c/start-here/)! Once you’re familiar with using the software, maybe you will share your wisdom with others and even consider joining the [AFFiNE Ambassador program](https://community.affine.pro/c/start-here/affine-ambassador) to help spread AFFiNE to the world.
 
-## Getting started & staying tuned with us.
+## Getting started & Stay tunned with us.
 
 ⚠️ Please note that AFFiNE is still under active development and is not yet ready for production use. ⚠️
 
-[![affine.pro](https://img.shields.io/static/v1?label=Try%20it%20Online&logo=affine&message=%E2%86%92&style=for-the-badge)](https://app.affine.pro) No installation or registration required! Head over to our website and try it out now.
+[![affine.pro](https://img.shields.io/static/v1?label=Try%20it%20Online&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAAhpJREFUWEdjZEACtnl3MxgY/0YzMjAaMzAwcCLLUYH9/T/D/7MM/5mXHp6kPANmHiOI4Zx9Xfg3C+tKBob/zlSwiAgjGPey/vkdvneq5luwA+zy7+yhn+Vwv+89NFHFhREU7IyM/6YT4WyqK/n/nymT0Tb/1mFGBkYbqptOhIH/Gf4fYbTLv/2NBgmOCOvBSr6DHPCfWNW0UEe2A2x1uRlakiXBbtpx6jND+7KXZLmPbAdURokzeJjxwi31rrzH8OX7P5IdQbYDtnUoMXBzMMEt7Fj2imH7qU/0cQBy8MNsPHL5K0P13Of0cQB68MNsJScaSI4CHk4mhq3tSnCf3n36k0FZmh3Mn7L+DcPqgx9ICgWSHeBpxsdQESUGtgRk+eqDH+H8O09/MiR3P6atA1qTJRlsdLnhPgYlPOQQCW96wPDi3R+iHUFSCKAHP8wydEeREg0kOQA9+JOgwR1qL8CQEygC9jWp0UCSA+aVysIT3JqDHxgmr38DtlRCiIVhZZ0CPNhB6QDkEGIA0Q4gZAkuxxFyBNEOQA7ml+/+MIQ1PUAxG1kelAhB6YMYQLQDCPmQUAjhcgxRDiDWcEKOxOYIohyQGyjCEGIvANaPLfhhBiNHA6hmBBXNhABRDgCV/aBQAAFQpYMrn4PUgNTCACiXEMoNRDmAkC8okR8UDhjYRumAN8sHvGMCSkAD2jUDOWDAO6ewbDQQ3XMAy/oxKownQR0AAAAASUVORK5CYII=&message=%E2%86%92&style=for-the-badge)](https://app.affine.pro) No installation or registration required! Head over to our website and try it out now.
 
 [![community.affine.pro](https://img.shields.io/static/v1?label=Join%20the%20community&message=%E2%86%92&style=for-the-badge)](https://community.affine.pro) Our wonderful community, where you can meet and engage with the team, developers and other like-minded enthusiastic user of AFFiNE.
 
@@ -83,7 +82,7 @@ Star us, and you will receive all releases notifications from GitHub without any
 
 ## Features
 
-- **Hyper merged** — Write, draw and plan all at once. Assemble any blocks you love on any canvas you like to enjoy seamless transitions between workflows with AFFiNE.
+- **Hyper merged** — Write, draw and plan all at once. Assemble any blocks you love on any canvas you like to enjoy seamless transitions bewtween workflows with AFFiNE.
 - **Privacy focussed** — AFFiNE is built with your privacy in mind and is one of our key concerns. We want you to keep control of your data, allowing you to store it as you like, where you like while still being able to freely edit and view your data on-demand.
 - **Offline-first** - With your privacy in mind we also decided to go offline-first. This means that AFFiNE can be used offline, whether you want to view or edit, with support for conflict-free merging when you are back online.
 - **Clean, intuitive design** — With AFFiNE you can concentrate on editing with a clean and modern interface. Which is responsive, so it looks great on tablets too, and mobile support is coming in the future.
@@ -120,15 +119,6 @@ If you have questions, you are welcome to contact us. One of the best places to
 | [@toeverything/y-indexeddb](packages/y-indexeddb)         | IndexedDB database adapter for Yjs | [![](https://img.shields.io/npm/dm/@toeverything/y-indexeddb?style=flat-square&color=eee)](https://www.npmjs.com/package/@toeverything/y-indexeddb) |
 | [@toeverything/theme](packages/theme)                     | AFFiNE theme                       | [![](https://img.shields.io/npm/dm/@toeverything/theme?style=flat-square&color=eee)](https://www.npmjs.com/package/@toeverything/theme)             |
 
-## Plugins
-
-> Plugins are a way to extend the functionality of AFFiNE.
-
-| Name                                             |                                           |
-| ------------------------------------------------ | ----------------------------------------- |
-| [@affine/bookmark-block](plugins/bookmark-block) | A block for bookmarking a website         |
-| [@affine/copilot](plugins/copilot)               | AI Copilot that help you document writing |
-
 ## Thanks
 
 We would also like to give thanks to open-source projects that make AFFiNE possible:
@@ -136,12 +126,11 @@ We would also like to give thanks to open-source projects that make AFFiNE possi
 - [BlockSuite](https://github.com/toeverything/BlockSuite) - 💠 BlockSuite is the open-source collaborative editor project behind AFFiNE.
 - [OctoBase](https://github.com/toeverything/OctoBase) - 🐙 OctoBase is the open-source database behind AFFiNE, local-first, yet collaborative. A light-weight, scalable, data engine written in Rust.
 - [Yjs](https://github.com/yjs/yjs) & [Yrs](https://github.com/y-crdt/y-crdt) - Fundamental support of CRDTs for our implementation on state management and data sync.
-- [Electron](https://github.com/electron/electron) - Build cross-platform desktop apps with JavaScript, HTML, and CSS.
+- [Next.js](https://github.com/vercel/next.js) - The React Framework.
 - [React](https://github.com/facebook/react) - View layer support and web GUI framework.
 - [Rust](https://github.com/rust-lang/rust) - High performance language that extends the ability and availability of our real-time backend, OctoBase.
 - [Jotai](https://github.com/pmndrs/jotai) - Primitive and flexible state management for React.
 - [MUI](https://github.com/mui/material-ui) - Our most used graphic UI component library.
-- [async-call-rpc](https://github.com/Jack-Works/async-call-rpc) - A lightweight JSON RPC client & server.
 - Other upstream [dependencies](https://github.com/toeverything/AFFiNE/network/dependencies).
 
 Thanks a lot to the community for providing such powerful and simple libraries, so that we can focus more on the implementation of the product logic, and we hope that in the future our projects will also provide a more easy-to-use knowledge base for everyone.
@@ -151,7 +140,7 @@ Thanks a lot to the community for providing such powerful and simple libraries,
 We would like to express our gratitude to all the individuals who have already contributed to AFFiNE! If you have any AFFiNE-related project, documentation, tool or template, please feel free to contribute it by submitting a pull request to our curated list on GitHub: [awesome-affine](https://github.com/toeverything/awesome-affine).
 
 <a href="https://github.com/toeverything/affine/graphs/contributors">
-  <img alt="contributors" src="https://opencollective.com/affine/contributors.svg?width=890&button=false" />
+  <img src="https://user-images.githubusercontent.com/5910926/237263745-36bb975d-83d6-4a7c-a152-d9ad020e5023.png" />
 </a>
 
 ## Self-Host

apps/electron/.gitignore

@@ -1,6 +1,5 @@
 *.autogen.*
 dist
-e2e-dist-*
 
 resources/web-static
 

apps/electron/README.md

@@ -7,7 +7,6 @@ To run AFFiNE Desktop Client Application locally, run the following commands:
 ```sh
 # in repo root
 yarn install
-yarn workspace @affine/native build
 yarn dev
 
 # in apps/electron
@@ -17,6 +16,22 @@ yarn dev # or yarn prod for production build
 
 ## Troubleshooting
 
+### better-sqlite3 error
+
+When running tests or starting electron, you may encounter the following error:
+
+> Error: The module 'apps/electron/node_modules/better-sqlite3/build/Release/better_sqlite3.node'
+
+This is due to the fact that the `better-sqlite3` package is built for the Node.js version in Electron & in your machine. To fix this, run the following command based on different cases:
+
+```sh
+# for running unit tests, we are not using Electron's node:
+yarn rebuild better-sqlite3
+
+# for running Electron, we are using Electron's node:
+yarn postinstall
+```
+
 ## Credits
 
 Most of the boilerplate code is generously borrowed from the following

apps/electron/forge.config.js

@@ -1,5 +1,4 @@
 /* eslint-disable @typescript-eslint/no-var-requires */
-
 const { z } = require('zod');
 
 const {
@@ -52,6 +51,8 @@ module.exports = {
           teamId: process.env.APPLE_TEAM_ID,
         }
       : undefined,
+    // do we need the following line?
+    extraResource: ['./resources/app-update.yml'],
   },
   makers: [
     {
@@ -93,7 +94,7 @@ module.exports = {
       config: {
         name: 'AFFiNE',
         setupIcon: icoPath,
-        loadingGif: './resources/icons/affine_installing.gif',
+        // loadingGif: './resources/icons/loading.gif',
       },
     },
   ],
@@ -103,27 +104,6 @@ module.exports = {
       // so stable and canary will not share the same app data
       packageJson.productName = productName;
     },
-    prePackage: async () => {
-      const { rm, cp } = require('node:fs/promises');
-      const { resolve } = require('node:path');
-
-      await rm(
-        resolve(__dirname, './node_modules/@toeverything/plugin-infra'),
-        {
-          recursive: true,
-          force: true,
-        }
-      );
-
-      await cp(
-        resolve(__dirname, '../../packages/plugin-infra'),
-        resolve(__dirname, './node_modules/@toeverything/plugin-infra'),
-        {
-          recursive: true,
-          force: true,
-        }
-      );
-    },
     generateAssets: async (_, platform, arch) => {
       if (process.env.SKIP_GENERATE_ASSETS) {
         return;

apps/electron/layers/constraints.ts

@@ -0,0 +1,7 @@
+/* eslint-disable @typescript-eslint/consistent-type-imports */
+// This file contains the main process events
+// It will guide preload and main process on the correct event types and payloads
+
+export type MainIPCHandlerMap = typeof import('./main/src/exposed').handlers;
+
+export type MainIPCEventMap = typeof import('./main/src/exposed').events;

apps/electron/layers/main/src/application-menu.ts

@@ -1,9 +1,9 @@
 import { app, Menu } from 'electron';
 
-import { revealLogFile } from '../logger';
-import { checkForUpdatesAndNotify } from '../updater';
-import { isMacOS } from '../utils';
-import { applicationMenuSubjects } from './subject';
+import { isMacOS } from '../../utils';
+import { subjects } from './events';
+import { checkForUpdatesAndNotify } from './handlers/updater';
+import { revealLogFile } from './logger';
 
 // Unique id for menuitems
 const MENUITEM_NEW_PAGE = 'affine:new-page';
@@ -43,7 +43,7 @@ export function createApplicationMenu() {
           label: 'New Page',
           accelerator: isMac ? 'Cmd+N' : 'Ctrl+N',
           click: () => {
-            applicationMenuSubjects.newPageAction.next();
+            subjects.applicationMenu.newPageAction.next();
           },
         },
         { type: 'separator' },
@@ -117,9 +117,9 @@ export function createApplicationMenu() {
           },
         },
         {
-          label: 'Open log file',
+          label: 'Open logs folder',
           click: async () => {
-            await revealLogFile();
+            revealLogFile();
           },
         },
         {
@@ -132,9 +132,9 @@ export function createApplicationMenu() {
     },
   ];
 
-  // @ts-expect-error: The snippet is copied from Electron official docs.
-  //                   It's working as expected. No idea why it contains type errors.
-  //                   Just ignore for now.
+  // @ts-ignore The snippet is copied from Electron official docs.
+  //            It's working as expected. No idea why it contains type errors.
+  //            Just ignore for now.
   const menu = Menu.buildFromTemplate(template);
   Menu.setApplicationMenu(menu);
 

apps/electron/layers/main/src/context.ts

@@ -0,0 +1,12 @@
+import { app } from 'electron';
+
+export const appContext = {
+  get appName() {
+    return app.name;
+  },
+  get appDataPath() {
+    return app.getPath('sessionData');
+  },
+};
+
+export type AppContext = typeof appContext;

apps/electron/layers/main/src/events/application-menu.ts

@@ -1,8 +1,10 @@
-import type { MainEventRegister } from '../type';
-import { applicationMenuSubjects } from './subject';
+import { Subject } from 'rxjs';
 
-export * from './create';
-export * from './subject';
+import type { MainEventListener } from './type';
+
+export const applicationMenuSubjects = {
+  newPageAction: new Subject<void>(),
+};
 
 /**
  * Events triggered by application menu
@@ -17,4 +19,4 @@ export const applicationMenuEvents = {
       sub.unsubscribe();
     };
   },
-} satisfies Record<string, MainEventRegister>;
+} satisfies Record<string, MainEventListener>;

apps/electron/layers/main/src/events/db.ts

@@ -0,0 +1,38 @@
+import { Subject } from 'rxjs';
+
+import type { MainEventListener } from './type';
+
+interface DBFilePathMeta {
+  workspaceId: string;
+  path: string;
+  realPath: string;
+}
+
+export const dbSubjects = {
+  // emit workspace ids
+  dbFileMissing: new Subject<string>(),
+  // emit workspace ids
+  dbFileUpdate: new Subject<string>(),
+  dbFilePathChange: new Subject<DBFilePathMeta>(),
+};
+
+export const dbEvents = {
+  onDBFileMissing: (fn: (workspaceId: string) => void) => {
+    const sub = dbSubjects.dbFileMissing.subscribe(fn);
+    return () => {
+      sub.unsubscribe();
+    };
+  },
+  onDBFileUpdate: (fn: (workspaceId: string) => void) => {
+    const sub = dbSubjects.dbFileUpdate.subscribe(fn);
+    return () => {
+      sub.unsubscribe();
+    };
+  },
+  onDBFilePathChange: (fn: (meta: DBFilePathMeta) => void) => {
+    const sub = dbSubjects.dbFilePathChange.subscribe(fn);
+    return () => {
+      sub.unsubscribe();
+    };
+  },
+} satisfies Record<string, MainEventListener>;

apps/electron/layers/main/src/events/index.ts

@@ -0,0 +1,9 @@
+export * from './register';
+
+import { applicationMenuSubjects } from './application-menu';
+import { dbSubjects } from './db';
+
+export const subjects = {
+  db: dbSubjects,
+  applicationMenu: applicationMenuSubjects,
+};

apps/electron/layers/main/src/events/register.ts

@@ -1,12 +1,14 @@
 import { app, BrowserWindow } from 'electron';
 
+import { logger } from '../logger';
 import { applicationMenuEvents } from './application-menu';
-import { logger } from './logger';
-import { updaterEvents } from './updater/event';
+import { dbEvents } from './db';
+import { updaterEvents } from './updater';
 
 export const allEvents = {
-  applicationMenu: applicationMenuEvents,
+  db: dbEvents,
   updater: updaterEvents,
+  applicationMenu: applicationMenuEvents,
 };
 
 function getActiveWindows() {
@@ -17,18 +19,9 @@ export function registerEvents() {
   // register events
   for (const [namespace, namespaceEvents] of Object.entries(allEvents)) {
     for (const [key, eventRegister] of Object.entries(namespaceEvents)) {
-      const subscription = eventRegister((...args: any[]) => {
+      const subscription = eventRegister((...args: any) => {
         const chan = `${namespace}:${key}`;
-        logger.info(
-          '[ipc-event]',
-          chan,
-          args.filter(
-            a =>
-              a !== undefined &&
-              typeof a !== 'function' &&
-              typeof a !== 'object'
-          )
-        );
+        logger.info('[ipc-event]', chan, args);
         getActiveWindows().forEach(win => win.webContents.send(chan, ...args));
       });
       app.on('before-quit', () => {

apps/electron/layers/main/src/events/type.ts

@@ -0,0 +1 @@
+export type MainEventListener = (...args: any[]) => () => void;

apps/electron/layers/main/src/events/updater.ts

@@ -1,8 +1,8 @@
 import { BehaviorSubject, Subject } from 'rxjs';
 
-import type { MainEventRegister } from '../type';
+import type { MainEventListener } from './type';
 
-export interface UpdateMeta {
+interface UpdateMeta {
   version: string;
   allowAutoUpdate: boolean;
 }
@@ -33,4 +33,4 @@ export const updaterEvents = {
       sub.unsubscribe();
     };
   },
-} satisfies Record<string, MainEventRegister>;
+} satisfies Record<string, MainEventListener>;

apps/electron/layers/main/src/exposed.ts

@@ -0,0 +1,5 @@
+import { allEvents as events } from './events';
+import { allHandlers as handlers } from './handlers';
+
+// this will be used by preload script to expose all handlers and events to the renderer process
+export { events, handlers };

apps/electron/layers/main/src/handlers/__tests__/handlers.spec.ts

@@ -0,0 +1,501 @@
+import assert from 'node:assert';
+import path from 'node:path';
+
+import fs from 'fs-extra';
+import type { Subscription } from 'rxjs';
+import { v4 } from 'uuid';
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
+import * as Y from 'yjs';
+
+import type { MainIPCHandlerMap } from '../../../../constraints';
+
+const registeredHandlers = new Map<
+  string,
+  ((...args: any[]) => Promise<any>)[]
+>();
+
+const delay = (ms: number) => new Promise(r => setTimeout(r, ms));
+
+type WithoutFirstParameter<T> = T extends (_: any, ...args: infer P) => infer R
+  ? (...args: P) => R
+  : T;
+
+// common mock dispatcher for ipcMain.handle AND app.on
+// alternatively, we can use single parameter for T & F, eg, dispatch('workspace:list'),
+// however this is too hard to be typed correctly
+async function dispatch<
+  T extends keyof MainIPCHandlerMap,
+  F extends keyof MainIPCHandlerMap[T]
+>(
+  namespace: T,
+  functionName: F,
+  // @ts-ignore
+  ...args: Parameters<WithoutFirstParameter<MainIPCHandlerMap[T][F]>>
+): // @ts-ignore
+ReturnType<MainIPCHandlerMap[T][F]> {
+  // @ts-ignore
+  const handlers = registeredHandlers.get(namespace + ':' + functionName);
+  assert(handlers);
+
+  // we only care about the first handler here
+  return await handlers[0](null, ...args);
+}
+
+const SESSION_DATA_PATH = path.join(__dirname, './tmp', 'affine-test');
+
+const browserWindow = {
+  isDestroyed: () => {
+    return false;
+  },
+  setWindowButtonVisibility: (_v: boolean) => {
+    // will be stubbed later
+  },
+  webContents: {
+    send: (_type: string, ..._args: any[]) => {
+      // will be stubbed later
+    },
+  },
+};
+
+const ipcMain = {
+  handle: (key: string, callback: (...args: any[]) => Promise<any>) => {
+    const handlers = registeredHandlers.get(key) || [];
+    handlers.push(callback);
+    registeredHandlers.set(key, handlers);
+  },
+  setMaxListeners: (_n: number) => {
+    // noop
+  },
+};
+
+const nativeTheme = {
+  themeSource: 'light',
+};
+
+function compareBuffer(a: Uint8Array | null, b: Uint8Array | null) {
+  if (
+    (a === null && b === null) ||
+    a === null ||
+    b === null ||
+    a.length !== b.length
+  ) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+const electronModule = {
+  app: {
+    getPath: (name: string) => {
+      assert(name === 'sessionData');
+      return SESSION_DATA_PATH;
+    },
+    name: 'affine-test',
+    on: (name: string, callback: (...args: any[]) => any) => {
+      const handlers = registeredHandlers.get(name) || [];
+      handlers.push(callback);
+      registeredHandlers.set(name, handlers);
+    },
+    addEventListener: (...args: any[]) => {
+      // @ts-ignore
+      electronModule.app.on(...args);
+    },
+    removeEventListener: () => {},
+  },
+  BrowserWindow: {
+    getAllWindows: () => {
+      return [browserWindow];
+    },
+  },
+  nativeTheme: nativeTheme,
+  ipcMain,
+  shell: {} as Partial<Electron.Shell>,
+  dialog: {} as Partial<Electron.Dialog>,
+};
+
+// dynamically import handlers so that we can inject local variables to mocks
+vi.doMock('electron', () => {
+  return electronModule;
+});
+
+let connectableSubscription: Subscription;
+
+beforeEach(async () => {
+  const { registerHandlers } = await import('../register');
+  registerHandlers();
+
+  // should also register events
+  const { registerEvents } = await import('../../events');
+  registerEvents();
+  await fs.mkdirp(SESSION_DATA_PATH);
+  const { database$ } = await import('../db/ensure-db');
+
+  connectableSubscription = database$.connect();
+});
+
+afterEach(async () => {
+  // reset registered handlers
+  registeredHandlers.get('before-quit')?.forEach(fn => fn());
+
+  connectableSubscription.unsubscribe();
+
+  await fs.remove(SESSION_DATA_PATH);
+});
+
+describe('ensureSQLiteDB', () => {
+  test('should create db file on connection if it does not exist', async () => {
+    const id = v4();
+    const { ensureSQLiteDB } = await import('../db/ensure-db');
+    const workspaceDB = await ensureSQLiteDB(id);
+    const file = workspaceDB.path;
+    const fileExists = await fs.pathExists(file);
+    expect(fileExists).toBe(true);
+  });
+
+  test('when db file is removed', async () => {
+    // stub webContents.send
+    const sendSpy = vi.spyOn(browserWindow.webContents, 'send');
+    const id = v4();
+    const { ensureSQLiteDB } = await import('../db/ensure-db');
+    let workspaceDB = await ensureSQLiteDB(id);
+    const file = workspaceDB.path;
+    const fileExists = await fs.pathExists(file);
+    expect(fileExists).toBe(true);
+
+    // Can't remove file on Windows, because the sqlite is still holding the file handle
+    if (process.platform === 'win32') {
+      return;
+    }
+
+    await fs.remove(file);
+
+    // wait for 2000ms for file watcher to detect file removal
+    await delay(2000);
+
+    expect(sendSpy).toBeCalledWith('db:onDBFileMissing', id);
+
+    // ensureSQLiteDB should recreate the db file
+    workspaceDB = await ensureSQLiteDB(id);
+    const fileExists2 = await fs.pathExists(file);
+    expect(fileExists2).toBe(true);
+    sendSpy.mockRestore();
+  });
+
+  test('when db file is updated', async () => {
+    const id = v4();
+    const { ensureSQLiteDB } = await import('../db/ensure-db');
+    const { dbSubjects } = await import('../../events/db');
+    const workspaceDB = await ensureSQLiteDB(id);
+    const file = workspaceDB.path;
+    const fileExists = await fs.pathExists(file);
+    expect(fileExists).toBe(true);
+    const dbUpdateSpy = vi.spyOn(dbSubjects.dbFileUpdate, 'next');
+    await delay(100);
+    // writes some data to the db file
+    await fs.appendFile(file, 'random-data', { encoding: 'binary' });
+    // write again
+    await fs.appendFile(file, 'random-data', { encoding: 'binary' });
+
+    // wait for 2000ms for file watcher to detect file change
+    await delay(2000);
+
+    expect(dbUpdateSpy).toBeCalledWith(id);
+    dbUpdateSpy.mockRestore();
+  });
+});
+
+describe('workspace handlers', () => {
+  test('list all workspace ids', async () => {
+    const ids = [v4(), v4()];
+    const { ensureSQLiteDB } = await import('../db/ensure-db');
+    await Promise.all(ids.map(id => ensureSQLiteDB(id)));
+    const list = await dispatch('workspace', 'list');
+    expect(list.map(([id]) => id).sort()).toEqual(ids.sort());
+  });
+
+  test('delete workspace', async () => {
+    // @TODO dispatch is hanging on Windows
+    if (process.platform === 'win32') {
+      return;
+    }
+    const ids = [v4(), v4()];
+    const { ensureSQLiteDB } = await import('../db/ensure-db');
+    await Promise.all(ids.map(id => ensureSQLiteDB(id)));
+    await dispatch('workspace', 'delete', ids[1]);
+    const list = await dispatch('workspace', 'list');
+    expect(list.map(([id]) => id)).toEqual([ids[0]]);
+  });
+});
+
+describe('UI handlers', () => {
+  test('theme-change', async () => {
+    await dispatch('ui', 'handleThemeChange', 'dark');
+    expect(nativeTheme.themeSource).toBe('dark');
+    await dispatch('ui', 'handleThemeChange', 'light');
+    expect(nativeTheme.themeSource).toBe('light');
+  });
+
+  test('sidebar-visibility-change (macOS)', async () => {
+    vi.stubGlobal('process', { platform: 'darwin' });
+    const setWindowButtonVisibility = vi.fn();
+    browserWindow.setWindowButtonVisibility = setWindowButtonVisibility;
+    await dispatch('ui', 'handleSidebarVisibilityChange', true);
+    expect(setWindowButtonVisibility).toBeCalledWith(true);
+    await dispatch('ui', 'handleSidebarVisibilityChange', false);
+    expect(setWindowButtonVisibility).toBeCalledWith(false);
+    vi.unstubAllGlobals();
+  });
+
+  test('sidebar-visibility-change (non-macOS)', async () => {
+    vi.stubGlobal('process', { platform: 'linux' });
+    const setWindowButtonVisibility = vi.fn();
+    browserWindow.setWindowButtonVisibility = setWindowButtonVisibility;
+    await dispatch('ui', 'handleSidebarVisibilityChange', true);
+    expect(setWindowButtonVisibility).not.toBeCalled();
+    vi.unstubAllGlobals();
+  });
+});
+
+describe('db handlers', () => {
+  test('apply doc and get doc updates', async () => {
+    const workspaceId = v4();
+    const bin = await dispatch('db', 'getDocAsUpdates', workspaceId);
+    // ? is this a good test?
+    expect(bin.every((byte: number) => byte === 0)).toBe(true);
+
+    const ydoc = new Y.Doc();
+    const ytext = ydoc.getText('test');
+    ytext.insert(0, 'hello world');
+    const bin2 = Y.encodeStateAsUpdate(ydoc);
+
+    await dispatch('db', 'applyDocUpdate', workspaceId, bin2);
+
+    const bin3 = await dispatch('db', 'getDocAsUpdates', workspaceId);
+    const ydoc2 = new Y.Doc();
+    Y.applyUpdate(ydoc2, bin3);
+    const ytext2 = ydoc2.getText('test');
+    expect(ytext2.toString()).toBe('hello world');
+  });
+
+  test('get non existent blob', async () => {
+    const workspaceId = v4();
+    const bin = await dispatch('db', 'getBlob', workspaceId, 'non-existent-id');
+    expect(bin).toBeNull();
+  });
+
+  test('list blobs (empty)', async () => {
+    const workspaceId = v4();
+    const list = await dispatch('db', 'getPersistedBlobs', workspaceId);
+    expect(list).toEqual([]);
+  });
+
+  test('CRUD blobs', async () => {
+    const testBin = new Uint8Array([1, 2, 3, 4, 5]);
+    const testBin2 = new Uint8Array([6, 7, 8, 9, 10]);
+    const workspaceId = 'test-workspace-id';
+
+    // add blob
+    await dispatch('db', 'addBlob', workspaceId, 'testBin', testBin);
+
+    // get blob
+    expect(
+      compareBuffer(
+        await dispatch('db', 'getBlob', workspaceId, 'testBin'),
+        testBin
+      )
+    ).toBe(true);
+
+    // add another blob
+    await dispatch('db', 'addBlob', workspaceId, 'testBin2', testBin2);
+    expect(
+      compareBuffer(
+        await dispatch('db', 'getBlob', workspaceId, 'testBin2'),
+        testBin2
+      )
+    ).toBe(true);
+
+    // list blobs
+    let lists = await dispatch('db', 'getPersistedBlobs', workspaceId);
+    expect(lists).toHaveLength(2);
+    expect(lists).toContain('testBin');
+    expect(lists).toContain('testBin2');
+
+    // delete blob
+    await dispatch('db', 'deleteBlob', workspaceId, 'testBin');
+    lists = await dispatch('db', 'getPersistedBlobs', workspaceId);
+    expect(lists).toEqual(['testBin2']);
+  });
+});
+
+describe('dialog handlers', () => {
+  test('revealDBFile', async () => {
+    const mockShowItemInFolder = vi.fn();
+    electronModule.shell.showItemInFolder = mockShowItemInFolder;
+
+    const id = v4();
+    const { ensureSQLiteDB } = await import('../db/ensure-db');
+    const db = await ensureSQLiteDB(id);
+
+    await dispatch('dialog', 'revealDBFile', id);
+    expect(mockShowItemInFolder).toBeCalledWith(db.path);
+  });
+
+  test('saveDBFileAs (skipped)', async () => {
+    const mockShowSaveDialog = vi.fn(() => {
+      return { filePath: undefined };
+    }) as any;
+    const mockShowItemInFolder = vi.fn();
+    electronModule.dialog.showSaveDialog = mockShowSaveDialog;
+    electronModule.shell.showItemInFolder = mockShowItemInFolder;
+
+    const id = v4();
+    const { ensureSQLiteDB } = await import('../db/ensure-db');
+    await ensureSQLiteDB(id);
+
+    await dispatch('dialog', 'saveDBFileAs', id);
+    expect(mockShowSaveDialog).toBeCalled();
+    expect(mockShowItemInFolder).not.toBeCalled();
+    electronModule.dialog = {};
+    electronModule.shell = {};
+  });
+
+  test('saveDBFileAs', async () => {
+    const newSavedPath = path.join(SESSION_DATA_PATH, 'saved-to');
+    const mockShowSaveDialog = vi.fn(() => {
+      return { filePath: newSavedPath };
+    }) as any;
+    const mockShowItemInFolder = vi.fn();
+    electronModule.dialog.showSaveDialog = mockShowSaveDialog;
+    electronModule.shell.showItemInFolder = mockShowItemInFolder;
+
+    const id = v4();
+    const { ensureSQLiteDB } = await import('../db/ensure-db');
+    await ensureSQLiteDB(id);
+
+    await dispatch('dialog', 'saveDBFileAs', id);
+    expect(mockShowSaveDialog).toBeCalled();
+    expect(mockShowItemInFolder).toBeCalledWith(newSavedPath);
+
+    // check if file is saved to new path
+    expect(await fs.exists(newSavedPath)).toBe(true);
+  });
+
+  test('loadDBFile (skipped)', async () => {
+    const mockShowOpenDialog = vi.fn(() => {
+      return { filePaths: undefined };
+    }) as any;
+    electronModule.dialog.showOpenDialog = mockShowOpenDialog;
+
+    const res = await dispatch('dialog', 'loadDBFile');
+    expect(mockShowOpenDialog).toBeCalled();
+    expect(res.canceled).toBe(true);
+  });
+
+  test('loadDBFile (error, in app-data)', async () => {
+    const mockShowOpenDialog = vi.fn(() => {
+      return {
+        filePaths: [path.join(SESSION_DATA_PATH, 'workspaces')],
+      };
+    }) as any;
+    electronModule.dialog.showOpenDialog = mockShowOpenDialog;
+
+    const res = await dispatch('dialog', 'loadDBFile');
+    expect(mockShowOpenDialog).toBeCalled();
+    expect(res.error).toBe('DB_FILE_PATH_INVALID');
+  });
+
+  test('loadDBFile (error, not a valid db file)', async () => {
+    // create a random db file
+    const basePath = path.join(SESSION_DATA_PATH, 'random-path');
+    const dbPath = path.join(basePath, 'xxx.db');
+    await fs.ensureDir(basePath);
+    await fs.writeFile(dbPath, 'hello world');
+
+    const mockShowOpenDialog = vi.fn(() => {
+      return { filePaths: [dbPath] };
+    }) as any;
+    electronModule.dialog.showOpenDialog = mockShowOpenDialog;
+
+    const res = await dispatch('dialog', 'loadDBFile');
+    expect(mockShowOpenDialog).toBeCalled();
+    expect(res.error).toBe('DB_FILE_INVALID');
+
+    electronModule.dialog = {};
+  });
+
+  test('loadDBFile', async () => {
+    // we use ensureSQLiteDB to create a valid db file
+    const id = v4();
+    const { ensureSQLiteDB } = await import('../db/ensure-db');
+    const db = await ensureSQLiteDB(id);
+
+    // copy db file to dbPath
+    const basePath = path.join(SESSION_DATA_PATH, 'random-path');
+    const originDBFilePath = path.join(basePath, 'xxx.db');
+    await fs.ensureDir(basePath);
+    await fs.copyFile(db.path, originDBFilePath);
+
+    // on Windows, we skip this test because we can't delete the db file
+    if (process.platform === 'win32') {
+      return;
+    }
+
+    // remove db
+    await fs.remove(db.path);
+
+    // try load originDBFilePath
+    const mockShowOpenDialog = vi.fn(() => {
+      return { filePaths: [originDBFilePath] };
+    }) as any;
+    electronModule.dialog.showOpenDialog = mockShowOpenDialog;
+
+    const res = await dispatch('dialog', 'loadDBFile');
+    expect(mockShowOpenDialog).toBeCalled();
+    expect(res.workspaceId).not.toBeUndefined();
+
+    const importedDb = await ensureSQLiteDB(res.workspaceId!);
+    expect(await fs.realpath(importedDb.path)).toBe(originDBFilePath);
+    expect(importedDb.path).not.toBe(originDBFilePath);
+
+    // try load it again, will trigger error (db file already loaded)
+    const res2 = await dispatch('dialog', 'loadDBFile');
+    expect(res2.error).toBe('DB_FILE_ALREADY_LOADED');
+  });
+
+  test('moveDBFile', async () => {
+    const newPath = path.join(SESSION_DATA_PATH, 'xxx');
+    const mockShowSaveDialog = vi.fn(() => {
+      return { filePath: newPath };
+    }) as any;
+    electronModule.dialog.showSaveDialog = mockShowSaveDialog;
+
+    const id = v4();
+    const { ensureSQLiteDB } = await import('../db/ensure-db');
+    await ensureSQLiteDB(id);
+    const res = await dispatch('dialog', 'moveDBFile', id);
+    expect(mockShowSaveDialog).toBeCalled();
+    expect(res.filePath).toBe(newPath);
+    electronModule.dialog = {};
+  });
+
+  test('moveDBFile (skipped)', async () => {
+    const mockShowSaveDialog = vi.fn(() => {
+      return { filePath: null };
+    }) as any;
+    electronModule.dialog.showSaveDialog = mockShowSaveDialog;
+
+    const id = v4();
+    const { ensureSQLiteDB } = await import('../db/ensure-db');
+    await ensureSQLiteDB(id);
+
+    const res = await dispatch('dialog', 'moveDBFile', id);
+    expect(mockShowSaveDialog).toBeCalled();
+    expect(res.filePath).toBe(undefined);
+    electronModule.dialog = {};
+  });
+});

apps/electron/layers/main/src/handlers/db/ensure-db.ts

@@ -0,0 +1,160 @@
+import type { NotifyEvent } from '@affine/native/event';
+import { createFSWatcher } from '@affine/native/fs-watcher';
+import { app } from 'electron';
+import {
+  connectable,
+  defer,
+  from,
+  fromEvent,
+  identity,
+  lastValueFrom,
+  Observable,
+  ReplaySubject,
+  Subject,
+} from 'rxjs';
+import {
+  debounceTime,
+  exhaustMap,
+  filter,
+  groupBy,
+  ignoreElements,
+  mergeMap,
+  shareReplay,
+  startWith,
+  switchMap,
+  take,
+  takeUntil,
+  tap,
+} from 'rxjs/operators';
+
+import { appContext } from '../../context';
+import { subjects } from '../../events';
+import { logger } from '../../logger';
+import { ts } from '../../utils';
+import type { WorkspaceSQLiteDB } from './sqlite';
+import { openWorkspaceDatabase } from './sqlite';
+
+const databaseInput$ = new Subject<string>();
+export const databaseConnector$ = new ReplaySubject<WorkspaceSQLiteDB>();
+
+const groupedDatabaseInput$ = databaseInput$.pipe(groupBy(identity));
+
+export const database$ = connectable(
+  groupedDatabaseInput$.pipe(
+    mergeMap(workspaceDatabase$ =>
+      workspaceDatabase$.pipe(
+        // only open the first db with the same workspaceId, and emit it to the downstream
+        exhaustMap(workspaceId => {
+          logger.info('[ensureSQLiteDB] open db connection', workspaceId);
+          return from(openWorkspaceDatabase(appContext, workspaceId)).pipe(
+            switchMap(db => {
+              return startWatchingDBFile(db).pipe(
+                // ignore all events and only emit the db to the downstream
+                ignoreElements(),
+                startWith(db)
+              );
+            })
+          );
+        }),
+        shareReplay(1)
+      )
+    ),
+    tap({
+      complete: () => {
+        logger.info('[FSWatcher] close all watchers');
+        createFSWatcher().close();
+      },
+    })
+  ),
+  {
+    connector: () => databaseConnector$,
+    resetOnDisconnect: true,
+  }
+);
+
+export const databaseConnectableSubscription = database$.connect();
+
+// 1. File delete
+// 2. File move
+//   - on Linux, it's `type: { modify: { kind: 'rename', mode: 'from' } }`
+//   - on Windows, it's `type: { remove: { kind: 'any' } }`
+//   - on macOS, it's `type: { modify: { kind: 'rename', mode: 'any' } }`
+export function isRemoveOrMoveEvent(event: NotifyEvent) {
+  return (
+    typeof event.type === 'object' &&
+    ('remove' in event.type ||
+      ('modify' in event.type &&
+        event.type.modify.kind === 'rename' &&
+        (event.type.modify.mode === 'from' ||
+          event.type.modify.mode === 'any')))
+  );
+}
+
+// if we removed the file, we will stop watching it
+function startWatchingDBFile(db: WorkspaceSQLiteDB) {
+  const FSWatcher = createFSWatcher();
+  return new Observable<NotifyEvent>(subscriber => {
+    logger.info('[FSWatcher] start watching db file', db.workspaceId);
+    const subscription = FSWatcher.watch(db.path, {
+      recursive: false,
+    }).subscribe(
+      event => {
+        logger.info('[FSWatcher]', event);
+        subscriber.next(event);
+        // remove file or move file, complete the observable and close db
+        if (isRemoveOrMoveEvent(event)) {
+          subscriber.complete();
+        }
+      },
+      err => {
+        subscriber.error(err);
+      }
+    );
+    return () => {
+      // destroy on unsubscribe
+      logger.info('[FSWatcher] cleanup db file watcher', db.workspaceId);
+      db.destroy();
+      subscription.unsubscribe();
+    };
+  }).pipe(
+    debounceTime(1000),
+    filter(event => !isRemoveOrMoveEvent(event)),
+    tap({
+      next: () => {
+        logger.info(
+          '[FSWatcher] db file changed on disk',
+          db.workspaceId,
+          ts() - db.lastUpdateTime,
+          'ms'
+        );
+        db.reconnectDB();
+        subjects.db.dbFileUpdate.next(db.workspaceId);
+      },
+      complete: () => {
+        // todo: there is still a possibility that the file is deleted
+        // but we didn't get the event soon enough and another event tries to
+        // access the db
+        logger.info('[FSWatcher] db file missing', db.workspaceId);
+        subjects.db.dbFileMissing.next(db.workspaceId);
+        db.destroy();
+      },
+    }),
+    takeUntil(defer(() => fromEvent(app, 'before-quit')))
+  );
+}
+
+export function ensureSQLiteDB(id: string) {
+  const deferValue = lastValueFrom(
+    database$.pipe(
+      filter(db => db.workspaceId === id && db.db.open),
+      take(1),
+      tap({
+        error: err => {
+          logger.error('[ensureSQLiteDB] error', err);
+        },
+      })
+    )
+  );
+  databaseInput$.next(id);
+  return deferValue;
+}

apps/electron/layers/main/src/handlers/db/index.ts

@@ -0,0 +1,42 @@
+import fs from 'fs-extra';
+
+import { appContext } from '../../context';
+import type { NamespaceHandlers } from '../type';
+import { ensureSQLiteDB } from './ensure-db';
+
+export const dbHandlers = {
+  getDocAsUpdates: async (_, id: string) => {
+    const workspaceDB = await ensureSQLiteDB(id);
+    return workspaceDB.getDocAsUpdates();
+  },
+  applyDocUpdate: async (_, id: string, update: Uint8Array) => {
+    const workspaceDB = await ensureSQLiteDB(id);
+    return workspaceDB.applyUpdate(update);
+  },
+  addBlob: async (_, workspaceId: string, key: string, data: Uint8Array) => {
+    const workspaceDB = await ensureSQLiteDB(workspaceId);
+    return workspaceDB.addBlob(key, data);
+  },
+  getBlob: async (_, workspaceId: string, key: string) => {
+    const workspaceDB = await ensureSQLiteDB(workspaceId);
+    return workspaceDB.getBlob(key);
+  },
+  deleteBlob: async (_, workspaceId: string, key: string) => {
+    const workspaceDB = await ensureSQLiteDB(workspaceId);
+    return workspaceDB.deleteBlob(key);
+  },
+  getPersistedBlobs: async (_, workspaceId: string) => {
+    const workspaceDB = await ensureSQLiteDB(workspaceId);
+    return workspaceDB.getPersistentBlobKeys();
+  },
+  getDefaultStorageLocation: async () => {
+    return appContext.appDataPath;
+  },
+  getDBFilePath: async (_, workspaceId: string) => {
+    const workspaceDB = await ensureSQLiteDB(workspaceId);
+    return {
+      path: workspaceDB.path,
+      realPath: await fs.realpath(workspaceDB.path),
+    };
+  },
+} satisfies NamespaceHandlers;

apps/electron/layers/main/src/handlers/db/sqlite.ts

@@ -0,0 +1,247 @@
+import path from 'node:path';
+
+import type { Database } from 'better-sqlite3';
+import sqlite from 'better-sqlite3';
+import fs from 'fs-extra';
+import * as Y from 'yjs';
+
+import type { AppContext } from '../../context';
+import { dbSubjects } from '../../events/db';
+import { logger } from '../../logger';
+import { ts } from '../../utils';
+
+const schemas = [
+  `CREATE TABLE IF NOT EXISTS "updates" (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  data BLOB NOT NULL,
+  timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL
+)`,
+  `CREATE TABLE IF NOT EXISTS "blobs" (
+  key TEXT PRIMARY KEY NOT NULL,
+  data BLOB NOT NULL,
+  timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL
+)`,
+];
+
+interface UpdateRow {
+  id: number;
+  data: Buffer;
+  timestamp: string;
+}
+
+interface BlobRow {
+  key: string;
+  data: Buffer;
+  timestamp: string;
+}
+
+const SQLITE_ORIGIN = Symbol('sqlite-origin');
+
+export class WorkspaceSQLiteDB {
+  db: Database;
+  ydoc = new Y.Doc();
+  firstConnect = false;
+  lastUpdateTime = ts();
+  destroyed = false;
+
+  constructor(public path: string, public workspaceId: string) {
+    this.db = this.reconnectDB();
+  }
+
+  // release resources
+  destroy = () => {
+    this.db?.close();
+    this.ydoc.destroy();
+  };
+
+  getWorkspaceName = () => {
+    return this.ydoc.getMap('space:meta').get('name') as string;
+  };
+
+  reconnectDB = () => {
+    logger.log('[WorkspaceSQLiteDB] open db', this.workspaceId);
+    if (this.db) {
+      this.db.close();
+    }
+
+    fs.realpath(this.path)
+      .then(realPath => {
+        dbSubjects.dbFilePathChange.next({
+          workspaceId: this.workspaceId,
+          path: this.path,
+          realPath,
+        });
+      })
+      .catch(() => {
+        // skip error
+      });
+
+    // use cached version?
+    const db = (this.db = sqlite(this.path));
+    db.exec(schemas.join(';'));
+
+    if (!this.firstConnect) {
+      this.ydoc.on('update', (update: Uint8Array, origin) => {
+        if (origin !== SQLITE_ORIGIN) {
+          this.addUpdateToSQLite(update);
+        }
+      });
+    }
+
+    Y.transact(this.ydoc, () => {
+      const updates = this.getUpdates();
+      updates.forEach(update => {
+        // give SQLITE_ORIGIN to skip self update
+        Y.applyUpdate(this.ydoc, update.data, SQLITE_ORIGIN);
+      });
+    });
+
+    this.lastUpdateTime = ts();
+
+    if (this.firstConnect) {
+      logger.info('db reconnected', this.workspaceId);
+    } else {
+      logger.info('db connected', this.workspaceId);
+    }
+
+    this.firstConnect = true;
+
+    return db;
+  };
+
+  getDocAsUpdates = () => {
+    return Y.encodeStateAsUpdate(this.ydoc);
+  };
+
+  // non-blocking and use yDoc to validate the update
+  // after that, the update is added to the db
+  applyUpdate = (data: Uint8Array) => {
+    Y.applyUpdate(this.ydoc, data);
+
+    // todo: trim the updates when the number of records is too large
+    // 1. store the current ydoc state in the db
+    // 2. then delete the old updates
+    // yjs-idb will always trim the db for the first time after DB is loaded
+    this.lastUpdateTime = ts();
+    logger.debug('applyUpdate', this.workspaceId, this.lastUpdateTime);
+  };
+
+  addBlob = (key: string, data: Uint8Array) => {
+    this.lastUpdateTime = ts();
+    try {
+      const statement = this.db.prepare(
+        'INSERT INTO blobs (key, data) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET data = ?'
+      );
+      statement.run(key, data, data);
+      return key;
+    } catch (error) {
+      logger.error('addBlob', error);
+    }
+  };
+
+  getBlob = (key: string) => {
+    try {
+      const statement = this.db.prepare('SELECT data FROM blobs WHERE key = ?');
+      const row = statement.get(key) as BlobRow;
+      if (!row) {
+        return null;
+      }
+      return row.data;
+    } catch (error) {
+      logger.error('getBlob', error);
+      return null;
+    }
+  };
+
+  deleteBlob = (key: string) => {
+    this.lastUpdateTime = ts();
+    try {
+      const statement = this.db.prepare('DELETE FROM blobs WHERE key = ?');
+      statement.run(key);
+    } catch (error) {
+      logger.error('deleteBlob', error);
+    }
+  };
+
+  getPersistentBlobKeys = () => {
+    try {
+      const statement = this.db.prepare('SELECT key FROM blobs');
+      const rows = statement.all() as BlobRow[];
+      return rows.map(row => row.key);
+    } catch (error) {
+      logger.error('getPersistentBlobKeys', error);
+      return [];
+    }
+  };
+
+  private getUpdates = () => {
+    try {
+      const statement = this.db.prepare('SELECT * FROM updates');
+      const rows = statement.all() as UpdateRow[];
+      return rows;
+    } catch (error) {
+      logger.error('getUpdates', error);
+      return [];
+    }
+  };
+
+  // batch write instead write per key stroke?
+  private addUpdateToSQLite = (data: Uint8Array) => {
+    try {
+      const start = performance.now();
+      const statement = this.db.prepare(
+        'INSERT INTO updates (data) VALUES (?)'
+      );
+      statement.run(data);
+      logger.debug(
+        'addUpdateToSQLite',
+        this.workspaceId,
+        'length:',
+        data.length,
+        performance.now() - start,
+        'ms'
+      );
+    } catch (error) {
+      logger.error('addUpdateToSQLite', error);
+    }
+  };
+}
+
+export async function getWorkspaceDBPath(
+  context: AppContext,
+  workspaceId: string
+) {
+  const basePath = path.join(context.appDataPath, 'workspaces', workspaceId);
+  await fs.ensureDir(basePath);
+  return path.join(basePath, 'storage.db');
+}
+
+export async function openWorkspaceDatabase(
+  context: AppContext,
+  workspaceId: string
+) {
+  const dbPath = await getWorkspaceDBPath(context, workspaceId);
+  return new WorkspaceSQLiteDB(dbPath, workspaceId);
+}
+
+export function isValidDBFile(path: string) {
+  let db: Database | null = null;
+  try {
+    db = sqlite(path);
+    // check if db has two tables, one for updates and onefor blobs
+    const statement = db.prepare(
+      `SELECT name FROM sqlite_schema WHERE type='table'`
+    );
+    const rows = statement.all() as { name: string }[];
+    const tableNames = rows.map(row => row.name);
+    if (!tableNames.includes('updates') || !tableNames.includes('blobs')) {
+      return false;
+    }
+    db.close();
+    return true;
+  } catch (error) {
+    logger.error('isValidDBFile', error);
+    db?.close();
+    return false;
+  }
+}

apps/electron/layers/main/src/handlers/dialog/dialog.ts

@@ -1,33 +1,26 @@
 import path from 'node:path';
 
+import { dialog, shell } from 'electron';
 import fs from 'fs-extra';
 import { nanoid } from 'nanoid';
 
-import { ensureSQLiteDB } from '../db/ensure-db';
-import type { WorkspaceSQLiteDB } from '../db/workspace-db-adapter';
-import { logger } from '../logger';
-import { mainRPC } from '../main-rpc';
-import {
-  getWorkspaceDBPath,
-  getWorkspaceMeta,
-  getWorkspacesBasePath,
-  listWorkspaces,
-  storeWorkspaceMeta,
-} from '../workspace';
+import { appContext } from '../../context';
+import { logger } from '../../logger';
+import { ensureSQLiteDB, isRemoveOrMoveEvent } from '../db/ensure-db';
+import type { WorkspaceSQLiteDB } from '../db/sqlite';
+import { getWorkspaceDBPath, isValidDBFile } from '../db/sqlite';
+import { listWorkspaces } from '../workspace/workspace';
 
 // NOTE:
 // we are using native dialogs because HTML dialogs do not give full file paths
 
 export async function revealDBFile(workspaceId: string) {
-  const meta = await getWorkspaceMeta(workspaceId);
-  if (!meta) {
-    return;
-  }
-  await mainRPC.showItemInFolder(meta.secondaryDBPath ?? meta.mainDBPath);
+  const workspaceDB = await ensureSQLiteDB(workspaceId);
+  shell.showItemInFolder(await fs.realpath(workspaceDB.path));
 }
 
 // provide a backdoor to set dialog path for testing in playwright
-export interface FakeDialogResult {
+interface FakeDialogResult {
   canceled?: boolean;
   filePath?: string;
   filePaths?: string[];
@@ -61,20 +54,12 @@ const ErrorMessages = [
 
 type ErrorMessage = (typeof ErrorMessages)[number];
 
-export interface SaveDBFileResult {
+interface SaveDBFileResult {
   filePath?: string;
   canceled?: boolean;
   error?: ErrorMessage;
 }
 
-const extension = 'affine';
-
-function getDefaultDBFileName(name: string, id: string) {
-  const fileName = `${name}_${id}.${extension}`;
-  // make sure fileName is a valid file name
-  return fileName.replace(/[/\\?%*:|"<>]/g, '-');
-}
-
 /**
  * This function is called when the user clicks the "Save" button in the "Save Workspace" dialog.
  *
@@ -87,18 +72,12 @@ export async function saveDBFileAs(
     const db = await ensureSQLiteDB(workspaceId);
     const ret =
       getFakedResult() ??
-      (await mainRPC.showSaveDialog({
+      (await dialog.showSaveDialog({
         properties: ['showOverwriteConfirmation'],
         title: 'Save Workspace',
         showsTagField: false,
         buttonLabel: 'Save',
-        filters: [
-          {
-            extensions: [extension],
-            name: '',
-          },
-        ],
-        defaultPath: getDefaultDBFileName(db.getWorkspaceName(), workspaceId),
+        defaultPath: `${db.getWorkspaceName()}_${workspaceId}.db`,
         message: 'Save Workspace as a SQLite Database file',
       }));
     const filePath = ret.filePath;
@@ -110,9 +89,7 @@ export async function saveDBFileAs(
 
     await fs.copyFile(db.path, filePath);
     logger.log('saved', filePath);
-    mainRPC.showItemInFolder(filePath).catch(err => {
-      console.error(err);
-    });
+    shell.showItemInFolder(filePath);
     return { filePath };
   } catch (err) {
     logger.error('saveDBFileAs', err);
@@ -122,7 +99,7 @@ export async function saveDBFileAs(
   }
 }
 
-export interface SelectDBFileLocationResult {
+interface SelectDBFileLocationResult {
   filePath?: string;
   error?: ErrorMessage;
   canceled?: boolean;
@@ -132,20 +109,27 @@ export async function selectDBFileLocation(): Promise<SelectDBFileLocationResult
   try {
     const ret =
       getFakedResult() ??
-      (await mainRPC.showOpenDialog({
-        properties: ['openDirectory'],
-        title: 'Set Workspace Storage Location',
+      (await dialog.showSaveDialog({
+        properties: ['showOverwriteConfirmation'],
+        title: 'Set database location',
+        showsTagField: false,
         buttonLabel: 'Select',
-        defaultPath: await mainRPC.getPath('documents'),
+        defaultPath: `workspace-storage.db`,
         message: "Select a location to store the workspace's database file",
       }));
-    const dir = ret.filePaths?.[0];
-    if (ret.canceled || !dir) {
+    const filePath = ret.filePath;
+    if (ret.canceled || !filePath) {
       return {
         canceled: true,
       };
     }
-    return { filePath: dir };
+    // the same db file cannot be loaded twice
+    if (await dbFileAlreadyLoaded(filePath)) {
+      return {
+        error: 'DB_FILE_ALREADY_LOADED',
+      };
+    }
+    return { filePath };
   } catch (err) {
     logger.error('selectDBFileLocation', err);
     return {
@@ -154,7 +138,7 @@ export async function selectDBFileLocation(): Promise<SelectDBFileLocationResult
   }
 }
 
-export interface LoadDBFileResult {
+interface LoadDBFileResult {
   workspaceId?: string;
   error?: ErrorMessage;
   canceled?: boolean;
@@ -178,7 +162,7 @@ export async function loadDBFile(): Promise<LoadDBFileResult> {
   try {
     const ret =
       getFakedResult() ??
-      (await mainRPC.showOpenDialog({
+      (await dialog.showOpenDialog({
         properties: ['openFile'],
         title: 'Load Workspace',
         buttonLabel: 'Load',
@@ -186,10 +170,10 @@ export async function loadDBFile(): Promise<LoadDBFileResult> {
           {
             name: 'SQLite Database',
             // do we want to support other file format?
-            extensions: ['db', 'affine'],
+            extensions: ['db'],
           },
         ],
-        message: 'Load Workspace from a AFFiNE file',
+        message: 'Load Workspace from a SQLite Database file',
       }));
     const filePath = ret.filePaths?.[0];
     if (ret.canceled || !filePath) {
@@ -198,7 +182,7 @@ export async function loadDBFile(): Promise<LoadDBFileResult> {
     }
 
     // the imported file should not be in app data dir
-    if (filePath.startsWith(await getWorkspacesBasePath())) {
+    if (filePath.startsWith(path.join(appContext.appDataPath, 'workspaces'))) {
       logger.warn('loadDBFile: db file in app data dir');
       return { error: 'DB_FILE_PATH_INVALID' };
     }
@@ -208,27 +192,19 @@ export async function loadDBFile(): Promise<LoadDBFileResult> {
       return { error: 'DB_FILE_ALREADY_LOADED' };
     }
 
-    const { SqliteConnection } = await import('@affine/native');
-
-    if (!(await SqliteConnection.validate(filePath))) {
+    if (!isValidDBFile(filePath)) {
       // TODO: report invalid db file error?
       return { error: 'DB_FILE_INVALID' }; // invalid db file
     }
 
-    // copy the db file to a new workspace id
+    // symlink the db file to a new workspace id
     const workspaceId = nanoid(10);
-    const internalFilePath = await getWorkspaceDBPath(workspaceId);
+    const linkedFilePath = await getWorkspaceDBPath(appContext, workspaceId);
 
-    await fs.ensureDir(await getWorkspacesBasePath());
+    await fs.ensureDir(path.join(appContext.appDataPath, 'workspaces'));
 
-    await fs.copy(filePath, internalFilePath);
-    logger.info(`loadDBFile, copy: ${filePath} -> ${internalFilePath}`);
-
-    await storeWorkspaceMeta(workspaceId, {
-      id: workspaceId,
-      mainDBPath: internalFilePath,
-      secondaryDBPath: filePath,
-    });
+    await fs.symlink(filePath, linkedFilePath, 'file');
+    logger.info(`loadDBFile, symlink: ${filePath} -> ${linkedFilePath}`);
 
     return { workspaceId };
   } catch (err) {
@@ -239,7 +215,7 @@ export async function loadDBFile(): Promise<LoadDBFileResult> {
   }
 }
 
-export interface MoveDBFileResult {
+interface MoveDBFileResult {
   filePath?: string;
   error?: ErrorMessage;
   canceled?: boolean;
@@ -249,50 +225,58 @@ export interface MoveDBFileResult {
  * This function is called when the user clicks the "Move" button in the "Move Workspace Storage" setting.
  *
  * It will
- * - copy the source db file to a new location
- * - remove the old db external file
- * - update the external db file path in the workspace meta
+ * - move the source db file to a new location
+ * - symlink the new location to the old db file
  * - return the new file path
  */
 export async function moveDBFile(
   workspaceId: string,
-  dbFileDir?: string
+  dbFileLocation?: string
 ): Promise<MoveDBFileResult> {
   let db: WorkspaceSQLiteDB | null = null;
   try {
+    const { moveFile, FsWatcher } = await import('@affine/native');
     db = await ensureSQLiteDB(workspaceId);
-    const meta = await getWorkspaceMeta(workspaceId);
-
-    const oldDir = meta.secondaryDBPath
-      ? path.dirname(meta.secondaryDBPath)
-      : null;
-    const defaultDir = oldDir ?? (await mainRPC.getPath('documents'));
-
-    const newName = getDefaultDBFileName(db.getWorkspaceName(), workspaceId);
-
-    const newDirPath =
-      dbFileDir ??
+    // get the real file path of db
+    const realpath = await fs.realpath(db.path);
+    const isLink = realpath !== db.path;
+    const watcher = FsWatcher.watch(realpath, { recursive: false });
+    const waitForRemove = new Promise<void>(resolve => {
+      const subscription = watcher.subscribe(event => {
+        if (isRemoveOrMoveEvent(event)) {
+          subscription.unsubscribe();
+          // resolve after FSWatcher in `database$` is fired
+          setImmediate(() => {
+            resolve();
+          });
+        }
+      });
+    });
+    const newFilePath =
+      dbFileLocation ??
       (
         getFakedResult() ??
-        (await mainRPC.showOpenDialog({
-          properties: ['openDirectory'],
+        (await dialog.showSaveDialog({
+          properties: ['showOverwriteConfirmation'],
           title: 'Move Workspace Storage',
-          buttonLabel: 'Move',
-          defaultPath: defaultDir,
+          showsTagField: false,
+          buttonLabel: 'Save',
+          defaultPath: realpath,
           message: 'Move Workspace storage file',
         }))
-      ).filePaths?.[0];
+      ).filePath;
 
     // skips if
     // - user canceled the dialog
-    // - user selected the same dir
-    if (!newDirPath || newDirPath === oldDir) {
+    // - user selected the same file
+    // - user selected the same file in the link file in app data dir
+    if (!newFilePath || newFilePath === realpath || db.path === newFilePath) {
       return {
         canceled: true,
       };
     }
 
-    const newFilePath = path.join(newDirPath, newName);
+    db.db.close();
 
     if (await fs.pathExists(newFilePath)) {
       return {
@@ -300,35 +284,30 @@ export async function moveDBFile(
       };
     }
 
-    logger.info(`[moveDBFile] copy ${meta.mainDBPath} -> ${newFilePath}`);
-
-    await fs.copy(meta.mainDBPath, newFilePath);
-
-    // remove the old db file, but we don't care if it fails
-    if (meta.secondaryDBPath) {
-      await fs
-        .remove(meta.secondaryDBPath)
-        .then(() => {
-          logger.info(`[moveDBFile] removed ${meta.secondaryDBPath}`);
-        })
-        .catch(err => {
-          logger.error(
-            `[moveDBFile] remove ${meta.secondaryDBPath} failed`,
-            err
-          );
-        });
+    if (isLink) {
+      // remove the old link to unblock new link
+      await fs.unlink(db.path);
     }
 
-    // update meta
-    await storeWorkspaceMeta(workspaceId, {
-      secondaryDBPath: newFilePath,
-    });
+    logger.info(`[moveDBFile] move ${realpath} -> ${newFilePath}`);
+
+    await moveFile(realpath, newFilePath);
+
+    await fs.ensureSymlink(newFilePath, db.path, 'file');
+    logger.info(`[moveDBFile] symlink: ${realpath} -> ${newFilePath}`);
+    // wait for the file move event emits to the FileWatcher in database$ in ensure-db.ts
+    // so that the db will be destroyed and we can call the `ensureSQLiteDB` in the next step
+    // or the FileWatcher will continue listen on the `realpath` and emit file change events
+    // then the database will reload while receiving these events; and the moved database file will be recreated while reloading database
+    await waitForRemove;
+    logger.info(`removed`);
+    await ensureSQLiteDB(workspaceId);
 
     return {
       filePath: newFilePath,
     };
   } catch (err) {
-    await db?.destroy();
+    db?.destroy();
     logger.error('[moveDBFile]', err);
     return {
       error: 'UNKNOWN_ERROR',
@@ -337,7 +316,8 @@ export async function moveDBFile(
 }
 
 async function dbFileAlreadyLoaded(path: string) {
-  const meta = await listWorkspaces();
-  const paths = meta.map(m => m[1].secondaryDBPath);
-  return paths.includes(path);
+  const meta = await listWorkspaces(appContext);
+  const realpath = await fs.realpath(path);
+  const paths = meta.map(m => m[1].realpath);
+  return paths.includes(realpath);
 }

apps/electron/layers/main/src/handlers/dialog/index.ts

@@ -1,3 +1,4 @@
+import type { NamespaceHandlers } from '../type';
 import {
   loadDBFile,
   moveDBFile,
@@ -8,24 +9,25 @@ import {
 } from './dialog';
 
 export const dialogHandlers = {
-  revealDBFile: async (workspaceId: string) => {
+  revealDBFile: async (_, workspaceId: string) => {
     return revealDBFile(workspaceId);
   },
   loadDBFile: async () => {
     return loadDBFile();
   },
-  saveDBFileAs: async (workspaceId: string) => {
+  saveDBFileAs: async (_, workspaceId: string) => {
     return saveDBFileAs(workspaceId);
   },
-  moveDBFile: (workspaceId: string, dbFileLocation?: string) => {
+  moveDBFile: (_, workspaceId: string, dbFileLocation?: string) => {
     return moveDBFile(workspaceId, dbFileLocation);
   },
   selectDBFileLocation: async () => {
     return selectDBFileLocation();
   },
   setFakeDialogResult: async (
+    _,
     result: Parameters<typeof setFakeDialogResult>[0]
   ) => {
     return setFakeDialogResult(result);
   },
-};
+} satisfies NamespaceHandlers;

apps/electron/layers/main/src/handlers/index.ts

@@ -0,0 +1 @@
+export * from './register';

apps/electron/layers/main/src/handlers/register.ts

@@ -1,16 +1,20 @@
-import type {
-  DebugHandlerManager,
-  ExportHandlerManager,
-  UIHandlerManager,
-  UnwrapManagerHandlerToServerSide,
-  UpdaterHandlerManager,
-} from '@toeverything/infra';
 import { ipcMain } from 'electron';
 
-import { exportHandlers } from './export';
-import { getLogFilePath, logger, revealLogFile } from './logger';
+import { getLogFilePath, logger, revealLogFile } from '../logger';
+import { dbHandlers } from './db';
+import { dialogHandlers } from './dialog';
 import { uiHandlers } from './ui';
 import { updaterHandlers } from './updater';
+import { workspaceHandlers } from './workspace';
+
+type IsomorphicHandler = (
+  e: Electron.IpcMainInvokeEvent,
+  ...args: any[]
+) => Promise<any>;
+
+type NamespaceHandlers = {
+  [key: string]: IsomorphicHandler;
+};
 
 export const debugHandlers = {
   revealLogFile: async () => {
@@ -21,32 +25,15 @@ export const debugHandlers = {
   },
 };
 
-type AllHandlers = {
-  debug: UnwrapManagerHandlerToServerSide<
-    Electron.IpcMainInvokeEvent,
-    DebugHandlerManager
-  >;
-  export: UnwrapManagerHandlerToServerSide<
-    Electron.IpcMainInvokeEvent,
-    ExportHandlerManager
-  >;
-  ui: UnwrapManagerHandlerToServerSide<
-    Electron.IpcMainInvokeEvent,
-    UIHandlerManager
-  >;
-  updater: UnwrapManagerHandlerToServerSide<
-    Electron.IpcMainInvokeEvent,
-    UpdaterHandlerManager
-  >;
-};
-
 // Note: all of these handlers will be the single-source-of-truth for the apis exposed to the renderer process
 export const allHandlers = {
-  debug: debugHandlers,
+  workspace: workspaceHandlers,
   ui: uiHandlers,
-  export: exportHandlers,
+  db: dbHandlers,
+  dialog: dialogHandlers,
+  debug: debugHandlers,
   updater: updaterHandlers,
-} satisfies AllHandlers;
+} satisfies Record<string, NamespaceHandlers>;
 
 export const registerHandlers = () => {
   // TODO: listen to namespace instead of individual event types
@@ -57,7 +44,6 @@ export const registerHandlers = () => {
       ipcMain.handle(chan, async (e, ...args) => {
         const start = performance.now();
         try {
-          // @ts-expect-error - TODO: fix this
           const result = await handler(e, ...args);
           logger.info(
             '[ipc-api]',

apps/electron/layers/main/src/handlers/type.ts

@@ -1,5 +1,3 @@
-export type MainEventRegister = (...args: any[]) => () => void;
-
 export type IsomorphicHandler = (
   e: Electron.IpcMainInvokeEvent,
   ...args: any[]

apps/electron/layers/main/src/handlers/ui/google-auth.ts

@@ -1,7 +1,7 @@
 import { app, BrowserWindow, shell } from 'electron';
 import { parse } from 'url';
 
-import { logger } from '../logger';
+import { logger } from '../../logger';
 
 const redirectUri = 'https://affine.pro/client/auth-callback';
 
@@ -28,12 +28,10 @@ export const getExchangeTokenParams = (code: string) => {
 };
 
 export function getGoogleOauthCode() {
+  shell.openExternal(oauthEndpoint);
+
   return new Promise<ReturnType<typeof getExchangeTokenParams>>(
     (resolve, reject) => {
-      shell.openExternal(oauthEndpoint).catch(e => {
-        logger.error('Failed to open external url', e);
-        reject(e);
-      });
       const handleOpenUrl = async (_: any, url: string) => {
         const mainWindow = BrowserWindow.getAllWindows().find(
           w => !w.isDestroyed()

apps/electron/layers/main/src/handlers/ui/index.ts

@@ -1,7 +1,7 @@
 import { app, BrowserWindow, nativeTheme } from 'electron';
 
+import { isMacOS } from '../../../../utils';
 import type { NamespaceHandlers } from '../type';
-import { isMacOS } from '../utils';
 import { getGoogleOauthCode } from './google-auth';
 
 export const uiHandlers = {
@@ -39,12 +39,4 @@ export const uiHandlers = {
   getGoogleOauthCode: async () => {
     return getGoogleOauthCode();
   },
-  /**
-   * @deprecated Remove this when bookmark block plugin is migrated to plugin-infra
-   */
-  getBookmarkDataByLink: async (_, link: string) => {
-    return globalThis.asyncCall[
-      'com.blocksuite.bookmark-block.get-bookmark-data-by-link'
-    ](link);
-  },
 } satisfies NamespaceHandlers;

apps/electron/layers/main/src/handlers/updater/index.ts

@@ -1,7 +1,7 @@
 import { app } from 'electron';
 
 import type { NamespaceHandlers } from '../type';
-import { checkForUpdatesAndNotify, quitAndInstall } from './electron-updater';
+import { checkForUpdatesAndNotify, quitAndInstall } from './updater';
 
 export const updaterHandlers = {
   currentVersion: async () => {
@@ -15,4 +15,4 @@ export const updaterHandlers = {
   },
 } satisfies NamespaceHandlers;
 
-export * from './electron-updater';
+export * from './updater';

apps/electron/layers/main/src/handlers/updater/updater.ts

@@ -2,9 +2,9 @@ import { app } from 'electron';
 import type { AppUpdater } from 'electron-updater';
 import { z } from 'zod';
 
-import { logger } from '../logger';
-import { isMacOS } from '../utils';
-import { updaterSubjects } from './event';
+import { isMacOS } from '../../../../utils';
+import { updaterSubjects } from '../../events/updater';
+import { logger } from '../../logger';
 
 export const ReleaseTypeSchema = z.enum([
   'stable',
@@ -29,25 +29,24 @@ export const quitAndInstall = async () => {
 let lastCheckTime = 0;
 export const checkForUpdatesAndNotify = async (force = true) => {
   if (!_autoUpdater) {
-    return void 0;
+    return; // ?
   }
   // check every 30 minutes (1800 seconds) at most
   if (force || lastCheckTime + 1000 * 1800 < Date.now()) {
     lastCheckTime = Date.now();
-    return await _autoUpdater.checkForUpdatesAndNotify();
+    return _autoUpdater.checkForUpdatesAndNotify();
   }
-  return void 0;
 };
 
 export const registerUpdater = async () => {
+  // require it will cause some side effects and will break generate-main-exposed-meta,
   // so we wrap it in a function
   // eslint-disable-next-line @typescript-eslint/no-var-requires
   const { autoUpdater } = require('electron-updater');
 
   _autoUpdater = autoUpdater;
 
-  // skip auto update in dev mode
-  if (!_autoUpdater || isDev) {
+  if (!_autoUpdater) {
     return;
   }
 
@@ -69,9 +68,7 @@ export const registerUpdater = async () => {
   // register events for checkForUpdatesAndNotify
   _autoUpdater.on('update-available', info => {
     if (allowAutoUpdate) {
-      _autoUpdater?.downloadUpdate().catch(e => {
-        logger.error('Failed to download update', e);
-      });
+      _autoUpdater!.downloadUpdate();
       logger.info('Update available, downloading...', info);
     }
     updaterSubjects.updateAvailable.next({

apps/electron/layers/main/src/handlers/workspace/index.ts

@@ -0,0 +1,8 @@
+import { appContext } from '../../context';
+import type { NamespaceHandlers } from '../type';
+import { deleteWorkspace, listWorkspaces } from './workspace';
+
+export const workspaceHandlers = {
+  list: async () => listWorkspaces(appContext),
+  delete: async (_, id: string) => deleteWorkspace(appContext, id),
+} satisfies NamespaceHandlers;

apps/electron/layers/main/src/handlers/workspace/workspace.ts

@@ -0,0 +1,60 @@
+import path from 'node:path';
+
+import fs from 'fs-extra';
+
+import type { AppContext } from '../../context';
+import { logger } from '../../logger';
+
+interface WorkspaceMeta {
+  path: string;
+  realpath: string;
+}
+
+export async function listWorkspaces(
+  context: AppContext
+): Promise<[workspaceId: string, meta: WorkspaceMeta][]> {
+  const basePath = path.join(context.appDataPath, 'workspaces');
+  try {
+    await fs.ensureDir(basePath);
+    const dirs = await fs.readdir(basePath, {
+      withFileTypes: true,
+    });
+
+    const meta = await Promise.all(
+      dirs.map(async dir => {
+        const dbFilePath = path.join(basePath, dir.name, 'storage.db');
+        if (dir.isDirectory() && (await fs.exists(dbFilePath))) {
+          // try read storage.db under it
+          const realpath = await fs.realpath(dbFilePath);
+          return [dir.name, { path: dbFilePath, realpath }] as [
+            string,
+            WorkspaceMeta
+          ];
+        } else {
+          return null;
+        }
+      })
+    );
+
+    return meta.filter((w): w is [string, WorkspaceMeta] => !!w);
+  } catch (error) {
+    logger.error('listWorkspaces', error);
+    return [];
+  }
+}
+
+export async function deleteWorkspace(context: AppContext, id: string) {
+  const basePath = path.join(context.appDataPath, 'workspaces', id);
+  const movedPath = path.join(
+    context.appDataPath,
+    'delete-workspaces',
+    `${id}`
+  );
+  try {
+    return await fs.move(basePath, movedPath, {
+      overwrite: true,
+    });
+  } catch (error) {
+    logger.error('deleteWorkspace', error);
+  }
+}

apps/electron/layers/main/src/index.ts

@@ -2,17 +2,14 @@ import './security-restrictions';
 
 import { app } from 'electron';
 
-import { createApplicationMenu } from './application-menu/create';
+import { createApplicationMenu } from './application-menu';
 import { registerEvents } from './events';
 import { registerHandlers } from './handlers';
-import { ensureHelperProcess } from './helper-process';
+import { registerUpdater } from './handlers/updater';
 import { logger } from './logger';
 import { restoreOrCreateWindow } from './main-window';
-import { registerPlugin } from './plugin';
 import { registerProtocol } from './protocol';
-import { registerUpdater } from './updater';
 
-if (require('electron-squirrel-startup')) app.quit();
 // allow tests to overwrite app name through passing args
 if (process.argv.includes('--app-name')) {
   const appNameIndex = process.argv.indexOf('--app-name');
@@ -31,9 +28,7 @@ if (!isSingleInstance) {
 }
 
 app.on('second-instance', () => {
-  restoreOrCreateWindow().catch(e =>
-    console.error('Failed to restore or create window:', e)
-  );
+  restoreOrCreateWindow();
 });
 
 app.on('open-url', async (_, _url) => {
@@ -60,12 +55,20 @@ app.on('activate', restoreOrCreateWindow);
 app
   .whenReady()
   .then(registerProtocol)
-  .then(registerPlugin)
   .then(registerHandlers)
   .then(registerEvents)
-  .then(ensureHelperProcess)
   .then(restoreOrCreateWindow)
   .then(createApplicationMenu)
-  .then()
   .then(registerUpdater)
   .catch(e => console.error('Failed create window:', e));
+/**
+ * Check new app version in production mode only
+ */
+// FIXME: add me back later
+// if (import.meta.env.PROD) {
+//   app
+//     .whenReady()
+//     .then(() => import('electron-updater'))
+//     .then(({ autoUpdater }) => autoUpdater.checkForUpdatesAndNotify())
+//     .catch(e => console.error('Failed check updates:', e));
+// }

apps/electron/layers/main/src/logger.ts

@@ -1,14 +1,13 @@
 import { shell } from 'electron';
 import log from 'electron-log';
 
-export const logger = log.scope('main');
-log.initialize();
+export const logger = log;
 
 export function getLogFilePath() {
   return log.transports.file.getFile().path;
 }
 
-export async function revealLogFile() {
+export function revealLogFile() {
   const filePath = getLogFilePath();
-  return await shell.openPath(filePath);
+  shell.showItemInFolder(filePath);
 }

apps/electron/layers/main/src/main-window.ts

@@ -1,13 +1,9 @@
-import assert from 'node:assert';
-
 import { BrowserWindow, nativeTheme } from 'electron';
 import electronWindowState from 'electron-window-state';
 import { join } from 'path';
 
-import { getExposedMeta } from './exposed';
-import { ensureHelperProcess } from './helper-process';
+import { isMacOS, isWindows } from '../../utils';
 import { logger } from './logger';
-import { isMacOS, isWindows } from './utils';
 
 const IS_DEV: boolean =
   process.env.NODE_ENV === 'development' && !process.env.CI;
@@ -21,13 +17,6 @@ async function createWindow() {
     defaultHeight: 800,
   });
 
-  const helperProcessManager = await ensureHelperProcess();
-  const helperExposedMeta = await helperProcessManager.rpc?.getMeta();
-
-  assert(helperExposedMeta, 'helperExposedMeta should be defined');
-
-  const mainExposedMeta = getExposedMeta();
-
   const browserWindow = new BrowserWindow({
     titleBarStyle: isMacOS()
       ? 'hiddenInset'
@@ -50,12 +39,7 @@ async function createWindow() {
       sandbox: false,
       webviewTag: false, // The webview tag is not recommended. Consider alternatives like iframe or Electron's BrowserView. https://www.electronjs.org/docs/latest/api/webview-tag#warning
       spellcheck: false, // FIXME: enable?
-      preload: join(__dirname, './preload.js'),
-      // serialize exposed meta that to be used in preload
-      additionalArguments: [
-        `--main-exposed-meta=` + JSON.stringify(mainExposedMeta),
-        `--helper-exposed-meta=` + JSON.stringify(helperExposedMeta),
-      ],
+      preload: join(__dirname, '../preload/index.js'),
     },
   });
 
@@ -63,8 +47,6 @@ async function createWindow() {
 
   mainWindowState.manage(browserWindow);
 
-  let helperConnectionUnsub: (() => void) | undefined;
-
   /**
    * If you install `show: true` then it can cause issues when trying to close the window.
    * Use `show: false` and listener events `ready-to-show` to fix these issues.
@@ -78,9 +60,6 @@ async function createWindow() {
     } else {
       browserWindow.show();
     }
-    helperConnectionUnsub = helperProcessManager.connectRenderer(
-      browserWindow.webContents
-    );
 
     logger.info('main window is ready to show');
 
@@ -94,7 +73,6 @@ async function createWindow() {
   browserWindow.on('close', e => {
     e.preventDefault();
     browserWindow.destroy();
-    helperConnectionUnsub?.();
     // TODO: gracefully close the app, for example, ask user to save unsaved changes
   });
 

apps/electron/layers/main/src/protocol.ts

@@ -16,7 +16,7 @@ protocol.registerSchemesAsPrivileged([
 
 function toAbsolutePath(url: string) {
   let realpath = decodeURIComponent(url);
-  const webStaticDir = join(__dirname, '../resources/web-static');
+  const webStaticDir = join(__dirname, '../../../resources/web-static');
   if (url.startsWith('./')) {
     // if is a file type, load the file in resources
     if (url.split('/').at(-1)?.includes('.')) {
@@ -34,7 +34,6 @@ export function registerProtocol() {
     const url = request.url.replace(/^file:\/\//, '');
     const realpath = toAbsolutePath(url);
     callback(realpath);
-    console.log('interceptFileProtocol realpath', request.url, realpath);
     return true;
   });
 

apps/electron/layers/main/src/utils.ts

@@ -0,0 +1,19 @@
+export function debounce<T extends (...args: any[]) => void>(
+  fn: T,
+  delay: number
+) {
+  let timeoutId: NodeJS.Timer | undefined;
+  return (...args: Parameters<T>) => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      fn(...args);
+      timeoutId = undefined;
+    }, delay);
+  };
+}
+
+export function ts() {
+  return new Date().getTime();
+}

apps/electron/layers/preload/preload.d.ts

@@ -0,0 +1,7 @@
+/* eslint-disable @typescript-eslint/consistent-type-imports */
+
+interface Window {
+  apis: typeof import('./src/affine-apis').apis;
+  events: typeof import('./src/affine-apis').events;
+  appInfo: typeof import('./src/affine-apis').appInfo;
+}

apps/electron/layers/preload/src/affine-apis.ts

@@ -0,0 +1,92 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+// NOTE: we will generate preload types from this file
+
+import { ipcRenderer } from 'electron';
+
+import type { MainIPCEventMap, MainIPCHandlerMap } from '../../constraints';
+
+type WithoutFirstParameter<T> = T extends (_: any, ...args: infer P) => infer R
+  ? (...args: P) => R
+  : T;
+
+type HandlersMap<N extends keyof MainIPCHandlerMap> = {
+  [K in keyof MainIPCHandlerMap[N]]: WithoutFirstParameter<
+    MainIPCHandlerMap[N][K]
+  >;
+};
+
+type PreloadHandlers = {
+  [N in keyof MainIPCHandlerMap]: HandlersMap<N>;
+};
+
+type MainExposedMeta = {
+  handlers: [namespace: string, handlerNames: string[]][];
+  events: [namespace: string, eventNames: string[]][];
+};
+
+// main handlers that can be invoked from the renderer process
+const apis: PreloadHandlers = (() => {
+  // the following were generated by the build script
+  // 1. bundle extra main/src/expose.ts entry
+  // 2. use generate-main-exposed-meta.mjs to generate exposed-meta.js in dist
+  //
+  // we cannot directly import main/src/handlers.ts because it will be bundled into the preload bundle
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const {
+    handlers: handlersMeta,
+  }: MainExposedMeta = require('../main/exposed-meta');
+
+  const all = handlersMeta.map(([namespace, functionNames]) => {
+    const namespaceApis = functionNames.map(name => {
+      const channel = `${namespace}:${name}`;
+      return [
+        name,
+        (...args: any[]) => {
+          return ipcRenderer.invoke(channel, ...args);
+        },
+      ];
+    });
+    return [namespace, Object.fromEntries(namespaceApis)];
+  });
+
+  return Object.fromEntries(all);
+})();
+
+// main events that can be listened to from the renderer process
+const events: MainIPCEventMap = (() => {
+  const {
+    events: eventsMeta,
+  }: MainExposedMeta = require('../main/exposed-meta');
+
+  // NOTE: ui may try to listen to a lot of the same events, so we increase the limit...
+  ipcRenderer.setMaxListeners(100);
+
+  const all = eventsMeta.map(([namespace, eventNames]) => {
+    const namespaceEvents = eventNames.map(name => {
+      const channel = `${namespace}:${name}`;
+      return [
+        name,
+        (callback: (...args: any[]) => void) => {
+          const fn: (
+            event: Electron.IpcRendererEvent,
+            ...args: any[]
+          ) => void = (_, ...args) => {
+            callback(...args);
+          };
+          ipcRenderer.on(channel, fn);
+          return () => {
+            ipcRenderer.off(channel, fn);
+          };
+        },
+      ];
+    });
+    return [namespace, Object.fromEntries(namespaceEvents)];
+  });
+  return Object.fromEntries(all);
+})();
+
+const appInfo = {
+  electron: true,
+};
+
+export { apis, appInfo, events };

apps/electron/layers/preload/src/index.ts

@@ -0,0 +1,18 @@
+/**
+ * @module preload
+ */
+
+import { contextBridge } from 'electron';
+
+import * as affineApis from './affine-apis';
+
+/**
+ * The "Main World" is the JavaScript context that your main renderer code runs in.
+ * By default, the page you load in your renderer executes code in this world.
+ *
+ * @see https://www.electronjs.org/docs/api/context-bridge
+ */
+
+contextBridge.exposeInMainWorld('apis', affineApis.apis);
+contextBridge.exposeInMainWorld('events', affineApis.events);
+contextBridge.exposeInMainWorld('appInfo', affineApis.appInfo);

apps/electron/layers/utils.ts

@@ -0,0 +1,7 @@
+export const isMacOS = () => {
+  return process.platform === 'darwin';
+};
+
+export const isWindows = () => {
+  return process.platform === 'win32';
+};

apps/electron/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@affine/electron",
   "private": true,
-  "version": "0.6.1-beta.1",
+  "version": "0.6.0-canary.5",
   "author": "affine",
   "repository": {
     "url": "https://github.com/toeverything/AFFiNE",
@@ -10,29 +10,25 @@
   "description": "AFFiNE App",
   "homepage": "https://github.com/toeverything/AFFiNE",
   "scripts": {
-    "dev": "yarn cross-env DEV_SERVER_URL=http://localhost:8080 node scripts/dev.mjs",
-    "watch": "yarn cross-env DEV_SERVER_URL=http://localhost:8080 node scripts/dev.mjs --watch",
-    "prod": "yarn node scripts/dev.mjs",
-    "build": "zx scripts/build-layers.mjs",
+    "dev": "yarn electron-rebuild && yarn cross-env DEV_SERVER_URL=http://localhost:8080 node scripts/dev.mjs",
+    "watch": "yarn electron-rebuild && yarn cross-env DEV_SERVER_URL=http://localhost:8080 node scripts/dev.mjs --watch",
+    "prod": "yarn electron-rebuild && yarn node scripts/dev.mjs",
+    "build-layers": "zx scripts/build-layers.mjs",
     "generate-assets": "zx scripts/generate-assets.mjs",
+    "generate-main-exposed-meta": "zx scripts/generate-main-exposed-meta.mjs",
     "package": "electron-forge package",
     "make": "electron-forge make",
-    "test": "DEBUG=pw:browser playwright test"
+    "rebuild:for-unit-test": "yarn rebuild better-sqlite3",
+    "rebuild:for-electron": "yarn electron-rebuild",
+    "test": "playwright test"
   },
   "config": {
     "forge": "./forge.config.js"
   },
-  "main": "./dist/main.js",
-  "exports": {
-    "./scripts/plugins/build-plugins.mjs": "./scripts/plugins/build-plugins.mjs"
-  },
+  "main": "./dist/layers/main/index.js",
   "devDependencies": {
     "@affine-test/kit": "workspace:*",
     "@affine/native": "workspace:*",
-    "@blocksuite/blocks": "0.0.0-20230607055421-9b20fcaf-nightly",
-    "@blocksuite/editor": "0.0.0-20230607055421-9b20fcaf-nightly",
-    "@blocksuite/lit": "0.0.0-20230607055421-9b20fcaf-nightly",
-    "@blocksuite/store": "0.0.0-20230607055421-9b20fcaf-nightly",
     "@electron-forge/cli": "^6.1.1",
     "@electron-forge/core": "^6.1.1",
     "@electron-forge/core-utils": "^6.1.1",
@@ -41,31 +37,28 @@
     "@electron-forge/maker-squirrel": "^6.1.1",
     "@electron-forge/maker-zip": "^6.1.1",
     "@electron-forge/shared-types": "^6.1.1",
+    "@electron/rebuild": "^3.2.13",
     "@electron/remote": "2.0.9",
-    "@toeverything/infra": "workspace:*",
+    "@types/better-sqlite3": "^7.6.4",
     "@types/fs-extra": "^11.0.1",
     "@types/uuid": "^9.0.1",
     "cross-env": "7.0.3",
-    "electron": "=25.0.1",
+    "electron": "24.3.1",
     "electron-log": "^5.0.0-beta.24",
     "electron-squirrel-startup": "1.0.0",
     "electron-window-state": "^5.0.3",
     "esbuild": "^0.17.19",
     "fs-extra": "^11.1.1",
-    "jotai": "^2.1.1",
-    "playwright": "=1.33.0",
+    "playwright": "^1.33.0",
     "ts-node": "^10.9.1",
     "undici": "^5.22.1",
     "uuid": "^9.0.0",
-    "which": "^3.0.1",
     "zx": "^7.2.2"
   },
   "dependencies": {
-    "@toeverything/plugin-infra": "workspace:*",
-    "async-call-rpc": "^6.3.1",
+    "better-sqlite3": "^8.3.0",
+    "chokidar": "^3.5.3",
     "electron-updater": "^5.3.0",
-    "link-preview-js": "^3.0.4",
-    "lodash-es": "^4.17.21",
     "nanoid": "^4.0.2",
     "rxjs": "^7.8.1",
     "yjs": "^13.6.1"

apps/electron/scripts/build-layers.mjs

@@ -1,12 +1,9 @@
 #!/usr/bin/env zx
 import 'zx/globals';
 
-import { resolve } from 'node:path';
-
-import { spawnSync } from 'child_process';
 import * as esbuild from 'esbuild';
 
-import { config, rootDir } from './common.mjs';
+import { config } from './common.mjs';
 
 const NODE_ENV =
   process.env.NODE_ENV === 'development' ? 'development' : 'production';
@@ -18,24 +15,18 @@ if (process.platform === 'win32') {
 
 async function buildLayers() {
   const common = config();
-  console.log('Build plugin infra');
-  spawnSync('yarn', ['build'], {
-    stdio: 'inherit',
-    cwd: resolve(rootDir, './packages/plugin-infra'),
-  });
+  await esbuild.build(common.preload);
 
-  console.log('Build plugins');
-  await import('./plugins/build-plugins.mjs');
-
-  await esbuild.build(common.workers);
   await esbuild.build({
-    ...common.layers,
+    ...common.main,
     define: {
-      ...common.define,
+      ...common.main.define,
       'process.env.NODE_ENV': `"${NODE_ENV}"`,
       'process.env.BUILD_TYPE': `"${process.env.BUILD_TYPE || 'stable'}"`,
     },
   });
+
+  await $`yarn workspace @affine/electron generate-main-exposed-meta`;
 }
 
 await buildLayers();

apps/electron/scripts/common.mjs

@@ -2,10 +2,7 @@ import { resolve } from 'node:path';
 
 import { fileURLToPath } from 'url';
 
-export const electronDir = fileURLToPath(new URL('..', import.meta.url));
-
-export const rootDir = resolve(electronDir, '..', '..');
-
+export const root = fileURLToPath(new URL('..', import.meta.url));
 export const NODE_MAJOR_VERSION = 18;
 
 // hard-coded for now:
@@ -18,7 +15,7 @@ const mode = (process.env.NODE_ENV = process.env.NODE_ENV || 'development');
 // List of env that will be replaced by esbuild
 const ENV_MACROS = ['AFFINE_GOOGLE_CLIENT_ID', 'AFFINE_GOOGLE_CLIENT_SECRET'];
 
-/** @return {{layers: import('esbuild').BuildOptions, workers: import('esbuild').BuildOptions}} */
+/** @return {{main: import('esbuild').BuildOptions, preload: import('esbuild').BuildOptions}} */
 export const config = () => {
   const define = Object.fromEntries([
     ...ENV_MACROS.map(key => [
@@ -26,7 +23,6 @@ export const config = () => {
       JSON.stringify(process.env[key] ?? ''),
     ]),
     ['process.env.NODE_ENV', `"${mode}"`],
-    ['process.env.USE_WORKER', '"true"'],
   ]);
 
   if (DEV_SERVER_URL) {
@@ -34,18 +30,16 @@ export const config = () => {
   }
 
   return {
-    layers: {
+    main: {
       entryPoints: [
-        resolve(electronDir, './src/main/index.ts'),
-        resolve(electronDir, './src/preload/index.ts'),
-        resolve(electronDir, './src/helper/index.ts'),
+        resolve(root, './layers/main/src/index.ts'),
+        resolve(root, './layers/main/src/exposed.ts'),
       ],
-      entryNames: '[dir]',
-      outdir: resolve(electronDir, './dist'),
+      outdir: resolve(root, './dist/layers/main'),
       bundle: true,
       target: `node${NODE_MAJOR_VERSION}`,
       platform: 'node',
-      external: ['electron', 'electron-updater', '@toeverything/plugin-infra'],
+      external: ['electron', 'yjs', 'better-sqlite3', 'electron-updater'],
       define: define,
       format: 'cjs',
       loader: {
@@ -54,23 +48,14 @@ export const config = () => {
       assetNames: '[name]',
       treeShaking: true,
     },
-    workers: {
-      entryPoints: [
-        resolve(electronDir, './src/main/workers/plugin.worker.ts'),
-      ],
-      entryNames: '[dir]/[name]',
-      outdir: resolve(electronDir, './dist/workers'),
+    preload: {
+      entryPoints: [resolve(root, './layers/preload/src/index.ts')],
+      outdir: resolve(root, './dist/layers/preload'),
       bundle: true,
       target: `node${NODE_MAJOR_VERSION}`,
       platform: 'node',
-      external: ['@toeverything/plugin-infra', 'async-call-rpc'],
+      external: ['electron', '../main/exposed-meta'],
       define: define,
-      format: 'cjs',
-      loader: {
-        '.node': 'copy',
-      },
-      assetNames: '[name]',
-      treeShaking: true,
     },
   };
 };

apps/electron/scripts/dev.mjs

@@ -1,13 +1,12 @@
 /* eslint-disable no-async-promise-executor */
-import { spawn } from 'node:child_process';
+import { execSync, spawn } from 'node:child_process';
 import { readFileSync } from 'node:fs';
-import path, { resolve } from 'node:path';
+import path from 'node:path';
 
 import electronPath from 'electron';
 import * as esbuild from 'esbuild';
-import which from 'which';
 
-import { config, electronDir, rootDir } from './common.mjs';
+import { config, root } from './common.mjs';
 
 // this means we don't spawn electron windows, mainly for testing
 const watchMode = process.argv.includes('--watch');
@@ -22,10 +21,7 @@ const stderrFilterPatterns = [
 
 // these are set before calling `config`, so we have a chance to override them
 try {
-  const devJson = readFileSync(
-    path.resolve(electronDir, './dev.json'),
-    'utf-8'
-  );
+  const devJson = readFileSync(path.resolve(root, './dev.json'), 'utf-8');
   const devEnv = JSON.parse(devJson);
   Object.assign(process.env, devEnv);
 } catch (err) {
@@ -68,29 +64,20 @@ function spawnOrReloadElectron() {
 }
 
 const common = config();
-const yarnPath = which.sync('yarn');
-async function watchPlugins() {
-  spawn(yarnPath, ['dev'], {
-    stdio: 'inherit',
-    cwd: resolve(rootDir, './packages/plugin-infra'),
-  });
-  await import('./plugins/dev-plugins.mjs');
-}
 
-async function watchLayers() {
+function watchPreload() {
   return new Promise(async resolve => {
     let initialBuild = false;
-
-    const buildContext = await esbuild.context({
-      ...common.layers,
+    const preloadBuild = await esbuild.context({
+      ...common.preload,
       plugins: [
-        ...(common.layers.plugins ?? []),
+        ...(common.preload.plugins ?? []),
         {
-          name: 'electron-dev:reload-app-on-layers-change',
+          name: 'electron-dev:reload-app-on-preload-change',
           setup(build) {
             build.onEnd(() => {
               if (initialBuild) {
-                console.log(`[layers] has changed, [re]launching electron...`);
+                console.log(`[preload] has changed, [re]launching electron...`);
                 spawnOrReloadElectron();
               } else {
                 resolve();
@@ -101,24 +88,27 @@ async function watchLayers() {
         },
       ],
     });
-    await buildContext.watch();
+    // watch will trigger build.onEnd() on first run & on subsequent changes
+    await preloadBuild.watch();
   });
 }
 
-async function watchWorkers() {
+async function watchMain() {
   return new Promise(async resolve => {
     let initialBuild = false;
 
-    const buildContext = await esbuild.context({
-      ...common.workers,
+    const mainBuild = await esbuild.context({
+      ...common.main,
       plugins: [
-        ...(common.workers.plugins ?? []),
+        ...(common.main.plugins ?? []),
         {
-          name: 'electron-dev:reload-app-on-workers-change',
+          name: 'electron-dev:reload-app-on-main-change',
           setup(build) {
             build.onEnd(() => {
+              execSync('yarn generate-main-exposed-meta');
+
               if (initialBuild) {
-                console.log(`[workers] has changed, [re]launching electron...`);
+                console.log(`[main] has changed, [re]launching electron...`);
                 spawnOrReloadElectron();
               } else {
                 resolve();
@@ -129,14 +119,13 @@ async function watchWorkers() {
         },
       ],
     });
-    await buildContext.watch();
+    await mainBuild.watch();
   });
 }
 
 async function main() {
-  await watchPlugins();
-  await watchLayers();
-  await watchWorkers();
+  await watchMain();
+  await watchPreload();
 
   if (watchMode) {
     console.log(`Watching for changes...`);

apps/electron/scripts/generate-assets.mjs

@@ -32,6 +32,10 @@ if (releaseVersionEnv && electronPackageJson.version !== releaseVersionEnv) {
 }
 // copy web dist files to electron dist
 
+// step 1: clean up
+await cleanup();
+echo('Clean up done');
+
 if (process.platform === 'win32') {
   $.shell = 'powershell.exe';
   $.prefix = '';
@@ -39,11 +43,11 @@ if (process.platform === 'win32') {
 
 cd(repoRootDir);
 
-// step 1: build web (nextjs) dist
+// step 2: build web (nextjs) dist
 if (!process.env.SKIP_WEB_BUILD) {
   process.env.ENABLE_LEGACY_PROVIDER = 'false';
-  await $`yarn nx build @affine/web`;
-  await $`yarn nx export @affine/web`;
+  await $`yarn build`;
+  await $`yarn export`;
 
   // step 1.5: amend sourceMappingURL to allow debugging in devtools
   await glob('**/*.{js,css}', { cwd: affineWebOutDir }).then(files => {
@@ -63,7 +67,7 @@ if (!process.env.SKIP_WEB_BUILD) {
   await fs.move(affineWebOutDir, publicAffineOutDir, { overwrite: true });
 }
 
-// step 2: update app-updater.yml content with build type in resources folder
+// step 3: update app-updater.yml content with build type in resources folder
 if (process.env.BUILD_TYPE === 'internal') {
   const appUpdaterYml = path.join(publicDistDir, 'app-update.yml');
   const appUpdaterYmlContent = await fs.readFile(appUpdaterYml, 'utf-8');
@@ -73,3 +77,15 @@ if (process.env.BUILD_TYPE === 'internal') {
   );
   await fs.writeFile(appUpdaterYml, newAppUpdaterYmlContent);
 }
+
+/// --------
+/// --------
+/// --------
+async function cleanup() {
+  if (!process.env.SKIP_WEB_BUILD) {
+    await fs.emptyDir(publicAffineOutDir);
+  }
+  await fs.emptyDir(path.join(electronRootDir, 'layers', 'main', 'dist'));
+  await fs.emptyDir(path.join(electronRootDir, 'layers', 'preload', 'dist'));
+  await fs.remove(path.join(electronRootDir, 'out'));
+}

apps/electron/scripts/generate-main-exposed-meta.mjs

@@ -0,0 +1,36 @@
+const mainDistDir = path.resolve(__dirname, '../dist/layers/main');
+
+// be careful and avoid any side effects in
+const { handlers, events } = await import(
+  'file://' + path.resolve(mainDistDir, 'exposed.js')
+);
+
+const handlersMeta = Object.entries(handlers).map(
+  ([namespace, namespaceHandlers]) => {
+    return [
+      namespace,
+      Object.keys(namespaceHandlers).map(handlerName => handlerName),
+    ];
+  }
+);
+
+const eventsMeta = Object.entries(events).map(
+  ([namespace, namespaceHandlers]) => {
+    return [
+      namespace,
+      Object.keys(namespaceHandlers).map(handlerName => handlerName),
+    ];
+  }
+);
+
+const meta = {
+  handlers: handlersMeta,
+  events: eventsMeta,
+};
+
+await fs.writeFile(
+  path.resolve(mainDistDir, 'exposed-meta.js'),
+  `module.exports = ${JSON.stringify(meta)};`
+);
+
+console.log('generate main exposed-meta.js done');

apps/electron/scripts/plugins/build-plugins.mjs

@@ -1,20 +0,0 @@
-#!/usr/bin/env node
-import { build } from 'esbuild';
-
-import { definePluginServerConfig } from './utils.mjs';
-
-await build({
-  ...definePluginServerConfig('bookmark-block'),
-  external: [
-    // server.ts
-    'link-preview-js',
-    // ui.ts
-    '@toeverything/plugin-infra',
-    '@affine/component',
-    '@blocksuite/store',
-    '@blocksuite/blocks',
-    'react',
-    'react-dom',
-    'foxact',
-  ],
-});

apps/electron/scripts/plugins/dev-plugins.mjs

@@ -1,22 +0,0 @@
-#!/usr/bin/env node
-import { context } from 'esbuild';
-
-import { definePluginServerConfig } from './utils.mjs';
-
-const plugin = await context({
-  ...definePluginServerConfig('bookmark-block'),
-  external: [
-    // server.ts
-    'link-preview-js',
-    // ui.ts
-    '@toeverything/plugin-infra',
-    '@affine/component',
-    '@blocksuite/store',
-    '@blocksuite/blocks',
-    'react',
-    'react-dom',
-    'foxact',
-  ],
-});
-
-await plugin.watch();

apps/electron/scripts/plugins/utils.mjs

@@ -1,34 +0,0 @@
-import { resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-export const rootDir = fileURLToPath(new URL('../../../..', import.meta.url));
-export const electronOutputDir = resolve(
-  rootDir,
-  'apps',
-  'electron',
-  'dist',
-  'plugins'
-);
-export const pluginDir = resolve(rootDir, 'plugins');
-
-/**
- *
- * @param pluginDirName {string}
- * @return {import('esbuild').BuildOptions}
- */
-export function definePluginServerConfig(pluginDirName) {
-  const pluginRootDir = resolve(pluginDir, pluginDirName);
-  const mainEntryFile = resolve(pluginRootDir, 'src/index.ts');
-  const serverOutputDir = resolve(electronOutputDir, pluginDirName);
-  return {
-    entryPoints: [mainEntryFile],
-    platform: 'neutral',
-    format: 'esm',
-    outExtension: {
-      '.js': '.mjs',
-    },
-    outdir: serverOutputDir,
-    bundle: true,
-    splitting: true,
-  };
-}

apps/electron/src/helper/db/__tests__/ensure-db.spec.ts

@@ -1,134 +0,0 @@
-import path from 'node:path';
-import { setTimeout } from 'node:timers/promises';
-
-import fs from 'fs-extra';
-import { v4 } from 'uuid';
-import { afterEach, beforeEach, expect, test, vi } from 'vitest';
-
-const tmpDir = path.join(__dirname, 'tmp');
-const appDataPath = path.join(tmpDir, 'app-data');
-
-vi.doMock('../../main-rpc', () => ({
-  mainRPC: {
-    getPath: async () => appDataPath,
-  },
-}));
-
-const constructorStub = vi.fn();
-const destroyStub = vi.fn();
-destroyStub.mockReturnValue(Promise.resolve());
-
-function existProcess() {
-  process.emit('beforeExit', 0);
-}
-
-vi.doMock('../secondary-db', () => {
-  return {
-    SecondaryWorkspaceSQLiteDB: class {
-      constructor(...args: any[]) {
-        constructorStub(...args);
-      }
-
-      connectIfNeeded = () => Promise.resolve();
-
-      pull = () => Promise.resolve();
-
-      destroy = destroyStub;
-    },
-  };
-});
-
-beforeEach(() => {
-  vi.useFakeTimers({ shouldAdvanceTime: true });
-});
-
-afterEach(async () => {
-  existProcess();
-  // wait for the db to be closed on Windows
-  if (process.platform === 'win32') {
-    await setTimeout(200);
-  }
-  await fs.remove(tmpDir);
-  vi.useRealTimers();
-});
-
-test('can get a valid WorkspaceSQLiteDB', async () => {
-  const { ensureSQLiteDB } = await import('../ensure-db');
-  const workspaceId = v4();
-  const db0 = await ensureSQLiteDB(workspaceId);
-  expect(db0).toBeDefined();
-  expect(db0.workspaceId).toBe(workspaceId);
-
-  const db1 = await ensureSQLiteDB(v4());
-  expect(db1).not.toBe(db0);
-  expect(db1.workspaceId).not.toBe(db0.workspaceId);
-
-  // ensure that the db is cached
-  expect(await ensureSQLiteDB(workspaceId)).toBe(db0);
-});
-
-test('db should be destroyed when app quits', async () => {
-  const { ensureSQLiteDB } = await import('../ensure-db');
-  const workspaceId = v4();
-  const db0 = await ensureSQLiteDB(workspaceId);
-  const db1 = await ensureSQLiteDB(v4());
-
-  expect(db0.db).not.toBeNull();
-  expect(db1.db).not.toBeNull();
-
-  existProcess();
-
-  // wait the async `db.destroy()` to be called
-  await setTimeout(100);
-
-  expect(db0.db).toBeNull();
-  expect(db1.db).toBeNull();
-});
-
-test('db should be removed in db$Map after destroyed', async () => {
-  const { ensureSQLiteDB, db$Map } = await import('../ensure-db');
-  const workspaceId = v4();
-  const db = await ensureSQLiteDB(workspaceId);
-  await db.destroy();
-  await setTimeout(100);
-  expect(db$Map.has(workspaceId)).toBe(false);
-});
-
-test('if db has a secondary db path, we should also poll that', async () => {
-  const { ensureSQLiteDB } = await import('../ensure-db');
-  const { storeWorkspaceMeta } = await import('../../workspace');
-  const workspaceId = v4();
-  await storeWorkspaceMeta(workspaceId, {
-    secondaryDBPath: path.join(tmpDir, 'secondary.db'),
-  });
-
-  const db = await ensureSQLiteDB(workspaceId);
-
-  await setTimeout(10);
-
-  expect(constructorStub).toBeCalledTimes(1);
-  expect(constructorStub).toBeCalledWith(path.join(tmpDir, 'secondary.db'), db);
-
-  // if secondary meta is changed
-  await storeWorkspaceMeta(workspaceId, {
-    secondaryDBPath: path.join(tmpDir, 'secondary2.db'),
-  });
-
-  // wait the async `db.destroy()` to be called
-  await setTimeout(100);
-  expect(constructorStub).toBeCalledTimes(2);
-  expect(destroyStub).toBeCalledTimes(1);
-
-  // if secondary meta is changed (but another workspace)
-  await storeWorkspaceMeta(v4(), {
-    secondaryDBPath: path.join(tmpDir, 'secondary3.db'),
-  });
-  await vi.advanceTimersByTimeAsync(1500);
-  expect(constructorStub).toBeCalledTimes(2);
-  expect(destroyStub).toBeCalledTimes(1);
-
-  // if primary is destroyed, secondary should also be destroyed
-  await db.destroy();
-  await setTimeout(100);
-  expect(destroyStub).toBeCalledTimes(2);
-});

apps/electron/src/helper/db/__tests__/workspace-db-adapter.spec.ts

@@ -1,99 +0,0 @@
-import path from 'node:path';
-
-import fs from 'fs-extra';
-import { v4 } from 'uuid';
-import { afterEach, expect, test, vi } from 'vitest';
-import * as Y from 'yjs';
-
-import { dbSubjects } from '../subjects';
-
-const tmpDir = path.join(__dirname, 'tmp');
-const appDataPath = path.join(tmpDir, 'app-data');
-
-vi.doMock('../../main-rpc', () => ({
-  mainRPC: {
-    getPath: async () => appDataPath,
-  },
-}));
-
-afterEach(async () => {
-  await fs.remove(tmpDir);
-});
-
-function getTestUpdates() {
-  const testYDoc = new Y.Doc();
-  const yText = testYDoc.getText('test');
-  yText.insert(0, 'hello');
-  const updates = Y.encodeStateAsUpdate(testYDoc);
-
-  return updates;
-}
-test('can create new db file if not exists', async () => {
-  const { openWorkspaceDatabase } = await import('../workspace-db-adapter');
-  const workspaceId = v4();
-  const db = await openWorkspaceDatabase(workspaceId);
-  const dbPath = path.join(
-    appDataPath,
-    `workspaces/${workspaceId}`,
-    `storage.db`
-  );
-  expect(await fs.exists(dbPath)).toBe(true);
-  await db.destroy();
-});
-
-test('on applyUpdate (from self), will not trigger update', async () => {
-  const { openWorkspaceDatabase } = await import('../workspace-db-adapter');
-  const workspaceId = v4();
-  const onUpdate = vi.fn();
-
-  const db = await openWorkspaceDatabase(workspaceId);
-  db.update$.subscribe(onUpdate);
-  db.applyUpdate(getTestUpdates(), 'self');
-  expect(onUpdate).not.toHaveBeenCalled();
-  await db.destroy();
-});
-
-test('on applyUpdate (from renderer), will trigger update', async () => {
-  const { openWorkspaceDatabase } = await import('../workspace-db-adapter');
-  const workspaceId = v4();
-  const onUpdate = vi.fn();
-  const onExternalUpdate = vi.fn();
-
-  const db = await openWorkspaceDatabase(workspaceId);
-  db.update$.subscribe(onUpdate);
-  const sub = dbSubjects.externalUpdate.subscribe(onExternalUpdate);
-  db.applyUpdate(getTestUpdates(), 'renderer');
-  expect(onUpdate).toHaveBeenCalled();
-  sub.unsubscribe();
-  await db.destroy();
-});
-
-test('on applyUpdate (from external), will trigger update & send external update event', async () => {
-  const { openWorkspaceDatabase } = await import('../workspace-db-adapter');
-  const workspaceId = v4();
-  const onUpdate = vi.fn();
-  const onExternalUpdate = vi.fn();
-
-  const db = await openWorkspaceDatabase(workspaceId);
-  db.update$.subscribe(onUpdate);
-  const sub = dbSubjects.externalUpdate.subscribe(onExternalUpdate);
-  db.applyUpdate(getTestUpdates(), 'external');
-  expect(onUpdate).toHaveBeenCalled();
-  expect(onExternalUpdate).toHaveBeenCalled();
-  sub.unsubscribe();
-  await db.destroy();
-});
-
-test('on destroy, check if resources have been released', async () => {
-  const { openWorkspaceDatabase } = await import('../workspace-db-adapter');
-  const workspaceId = v4();
-  const db = await openWorkspaceDatabase(workspaceId);
-  const updateSub = {
-    complete: vi.fn(),
-    next: vi.fn(),
-  };
-  db.update$ = updateSub as any;
-  await db.destroy();
-  expect(db.db).toBe(null);
-  expect(updateSub.complete).toHaveBeenCalled();
-});

apps/electron/src/helper/db/base-db-adapter.ts

@@ -1,116 +0,0 @@
-import { SqliteConnection } from '@affine/native';
-
-import { logger } from '../logger';
-
-/**
- * A base class for SQLite DB adapter that provides basic methods around updates & blobs
- */
-export abstract class BaseSQLiteAdapter {
-  db: SqliteConnection | null = null;
-  abstract role: string;
-
-  constructor(public readonly path: string) {}
-
-  async connectIfNeeded() {
-    if (!this.db) {
-      this.db = new SqliteConnection(this.path);
-      await this.db.connect();
-      logger.info(`[SQLiteAdapter:${this.role}]`, 'connected:', this.path);
-    }
-    return this.db;
-  }
-
-  async destroy() {
-    const { db } = this;
-    this.db = null;
-    // log after close will sometimes crash the app when quitting
-    logger.info(`[SQLiteAdapter:${this.role}]`, 'destroyed:', this.path);
-    await db?.close();
-  }
-
-  async addBlob(key: string, data: Uint8Array) {
-    try {
-      if (!this.db) {
-        logger.warn(`${this.path} is not connected`);
-        return;
-      }
-      await this.db.addBlob(key, data);
-    } catch (error) {
-      logger.error('addBlob', error);
-    }
-  }
-
-  async getBlob(key: string) {
-    try {
-      if (!this.db) {
-        logger.warn(`${this.path} is not connected`);
-        return;
-      }
-      const blob = await this.db.getBlob(key);
-      return blob?.data;
-    } catch (error) {
-      logger.error('getBlob', error);
-      return null;
-    }
-  }
-
-  async deleteBlob(key: string) {
-    try {
-      if (!this.db) {
-        logger.warn(`${this.path} is not connected`);
-        return;
-      }
-      await this.db.deleteBlob(key);
-    } catch (error) {
-      logger.error(`${this.path} delete blob failed`, error);
-    }
-  }
-
-  async getBlobKeys() {
-    try {
-      if (!this.db) {
-        logger.warn(`${this.path} is not connected`);
-        return [];
-      }
-      return await this.db.getBlobKeys();
-    } catch (error) {
-      logger.error(`getBlobKeys failed`, error);
-      return [];
-    }
-  }
-
-  async getUpdates() {
-    try {
-      if (!this.db) {
-        logger.warn(`${this.path} is not connected`);
-        return [];
-      }
-      return await this.db.getUpdates();
-    } catch (error) {
-      logger.error('getUpdates', error);
-      return [];
-    }
-  }
-
-  // add a single update to SQLite
-  async addUpdateToSQLite(updates: Uint8Array[]) {
-    // batch write instead write per key stroke?
-    try {
-      if (!this.db) {
-        logger.warn(`${this.path} is not connected`);
-        return;
-      }
-      const start = performance.now();
-      await this.db.insertUpdates(updates);
-      logger.debug(
-        `[SQLiteAdapter][${this.role}] addUpdateToSQLite`,
-        'length:',
-        updates.length,
-        performance.now() - start,
-        'ms'
-      );
-    } catch (error) {
-      logger.error('addUpdateToSQLite', this.path, error);
-    }
-  }
-}

apps/electron/src/helper/db/ensure-db.ts

@@ -1,140 +0,0 @@
-import type { Subject } from 'rxjs';
-import { Observable } from 'rxjs';
-import {
-  concat,
-  defer,
-  from,
-  fromEvent,
-  interval,
-  lastValueFrom,
-  merge,
-} from 'rxjs';
-import {
-  concatMap,
-  distinctUntilChanged,
-  filter,
-  ignoreElements,
-  last,
-  map,
-  shareReplay,
-  startWith,
-  switchMap,
-  take,
-  takeUntil,
-  tap,
-} from 'rxjs/operators';
-
-import { logger } from '../logger';
-import { getWorkspaceMeta, workspaceSubjects } from '../workspace';
-import { SecondaryWorkspaceSQLiteDB } from './secondary-db';
-import type { WorkspaceSQLiteDB } from './workspace-db-adapter';
-import { openWorkspaceDatabase } from './workspace-db-adapter';
-
-// export for testing
-export const db$Map = new Map<string, Observable<WorkspaceSQLiteDB>>();
-
-// use defer to prevent `app` is undefined while running tests
-const beforeQuit$ = defer(() => fromEvent(process, 'beforeExit'));
-
-// return a stream that emit a single event when the subject completes
-function completed<T>(subject: Subject<T>) {
-  return new Observable(subscriber => {
-    const sub = subject.subscribe({
-      complete: () => {
-        subscriber.next();
-        subscriber.complete();
-      },
-    });
-    return () => sub.unsubscribe();
-  });
-}
-
-function getWorkspaceDB$(id: string) {
-  if (!db$Map.has(id)) {
-    db$Map.set(
-      id,
-      from(openWorkspaceDatabase(id)).pipe(
-        tap({
-          next: db => {
-            logger.info(
-              '[ensureSQLiteDB] db connection established',
-              db.workspaceId
-            );
-          },
-        }),
-        switchMap(db =>
-          // takeUntil the polling stream, and then destroy the db
-          concat(
-            startPollingSecondaryDB(db).pipe(
-              ignoreElements(),
-              startWith(db),
-              takeUntil(merge(beforeQuit$, completed(db.update$))),
-              last(),
-              tap({
-                next() {
-                  logger.info(
-                    '[ensureSQLiteDB] polling secondary db complete',
-                    db.workspaceId
-                  );
-                },
-              })
-            ),
-            defer(async () => {
-              try {
-                await db.destroy();
-                db$Map.delete(id);
-                return db;
-              } catch (err) {
-                logger.error('[ensureSQLiteDB] destroy db failed', err);
-                throw err;
-              }
-            })
-          ).pipe(startWith(db))
-        ),
-        shareReplay(1)
-      )
-    );
-  }
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-  return db$Map.get(id)!;
-}
-
-function startPollingSecondaryDB(db: WorkspaceSQLiteDB) {
-  return merge(
-    getWorkspaceMeta(db.workspaceId),
-    workspaceSubjects.meta.pipe(
-      map(({ meta }) => meta),
-      filter(meta => meta.id === db.workspaceId)
-    )
-  ).pipe(
-    map(meta => meta?.secondaryDBPath),
-    filter((p): p is string => !!p),
-    distinctUntilChanged(),
-    switchMap(path => {
-      // on secondary db path change, destroy the old db and create a new one
-      const secondaryDB = new SecondaryWorkspaceSQLiteDB(path, db);
-      return new Observable<SecondaryWorkspaceSQLiteDB>(subscriber => {
-        subscriber.next(secondaryDB);
-        return () => secondaryDB.destroy();
-      });
-    }),
-    switchMap(secondaryDB => {
-      return interval(300000).pipe(
-        startWith(0),
-        concatMap(() => secondaryDB.pull()),
-        tap({
-          error: err => {
-            logger.error(`[ensureSQLiteDB] polling secondary db error`, err);
-          },
-          complete: () => {
-            logger.info('[ensureSQLiteDB] polling secondary db complete');
-          },
-        })
-      );
-    })
-  );
-}
-
-export function ensureSQLiteDB(id: string) {
-  return lastValueFrom(getWorkspaceDB$(id).pipe(take(1)));
-}

apps/electron/src/helper/db/index.ts

@@ -1,48 +0,0 @@
-import { mainRPC } from '../main-rpc';
-import type { MainEventRegister } from '../type';
-import { ensureSQLiteDB } from './ensure-db';
-import { dbSubjects } from './subjects';
-
-export * from './ensure-db';
-export * from './subjects';
-
-export const dbHandlers = {
-  getDocAsUpdates: async (id: string) => {
-    const workspaceDB = await ensureSQLiteDB(id);
-    return workspaceDB.getDocAsUpdates();
-  },
-  applyDocUpdate: async (id: string, update: Uint8Array) => {
-    const workspaceDB = await ensureSQLiteDB(id);
-    return workspaceDB.applyUpdate(update);
-  },
-  addBlob: async (workspaceId: string, key: string, data: Uint8Array) => {
-    const workspaceDB = await ensureSQLiteDB(workspaceId);
-    return workspaceDB.addBlob(key, data);
-  },
-  getBlob: async (workspaceId: string, key: string) => {
-    const workspaceDB = await ensureSQLiteDB(workspaceId);
-    return workspaceDB.getBlob(key);
-  },
-  deleteBlob: async (workspaceId: string, key: string) => {
-    const workspaceDB = await ensureSQLiteDB(workspaceId);
-    return workspaceDB.deleteBlob(key);
-  },
-  getBlobKeys: async (workspaceId: string) => {
-    const workspaceDB = await ensureSQLiteDB(workspaceId);
-    return workspaceDB.getBlobKeys();
-  },
-  getDefaultStorageLocation: async () => {
-    return await mainRPC.getPath('sessionData');
-  },
-};
-
-export const dbEvents = {
-  onExternalUpdate: (
-    fn: (update: { workspaceId: string; update: Uint8Array }) => void
-  ) => {
-    const sub = dbSubjects.externalUpdate.subscribe(fn);
-    return () => {
-      sub.unsubscribe();
-    };
-  },
-} satisfies Record<string, MainEventRegister>;

apps/electron/src/helper/db/merge-update.ts

@@ -1,11 +0,0 @@
-import * as Y from 'yjs';
-
-export function mergeUpdate(updates: Uint8Array[]) {
-  const yDoc = new Y.Doc();
-  Y.transact(yDoc, () => {
-    for (const update of updates) {
-      Y.applyUpdate(yDoc, update);
-    }
-  });
-  return Y.encodeStateAsUpdate(yDoc);
-}

apps/electron/src/helper/db/secondary-db.ts

@@ -1,215 +0,0 @@
-import assert from 'node:assert';
-
-import type { SqliteConnection } from '@affine/native';
-import { debounce } from 'lodash-es';
-import * as Y from 'yjs';
-
-import { logger } from '../logger';
-import type { YOrigin } from '../type';
-import { getWorkspaceMeta } from '../workspace';
-import { BaseSQLiteAdapter } from './base-db-adapter';
-import { mergeUpdate } from './merge-update';
-import type { WorkspaceSQLiteDB } from './workspace-db-adapter';
-
-const FLUSH_WAIT_TIME = 5000;
-const FLUSH_MAX_WAIT_TIME = 10000;
-
-export class SecondaryWorkspaceSQLiteDB extends BaseSQLiteAdapter {
-  role = 'secondary';
-  yDoc = new Y.Doc();
-  firstConnected = false;
-  destroyed = false;
-
-  updateQueue: Uint8Array[] = [];
-
-  unsubscribers = new Set<() => void>();
-
-  constructor(
-    public override path: string,
-    public upstream: WorkspaceSQLiteDB
-  ) {
-    super(path);
-    this.setupAndListen();
-    logger.debug('[SecondaryWorkspaceSQLiteDB] created', this.workspaceId);
-  }
-
-  override async destroy() {
-    await this.flushUpdateQueue();
-    this.unsubscribers.forEach(unsub => unsub());
-    this.yDoc.destroy();
-    await super.destroy();
-    this.destroyed = true;
-  }
-
-  get workspaceId() {
-    return this.upstream.workspaceId;
-  }
-
-  // do not update db immediately, instead, push to a queue
-  // and flush the queue in a future time
-  async addUpdateToUpdateQueue(db: SqliteConnection, update: Uint8Array) {
-    this.updateQueue.push(update);
-    await this.debouncedFlush();
-  }
-
-  async flushUpdateQueue() {
-    if (this.destroyed) {
-      return;
-    }
-    logger.debug(
-      'flushUpdateQueue',
-      this.workspaceId,
-      'queue',
-      this.updateQueue.length
-    );
-    const updates = [...this.updateQueue];
-    this.updateQueue = [];
-    await this.run(async () => {
-      await this.addUpdateToSQLite(updates);
-    });
-  }
-
-  // flush after 5s, but will not wait for more than 10s
-  debouncedFlush = debounce(this.flushUpdateQueue, FLUSH_WAIT_TIME, {
-    maxWait: FLUSH_MAX_WAIT_TIME,
-  });
-
-  runCounter = 0;
-
-  // wrap the fn with connect and close
-  async run<T extends (...args: any[]) => any>(
-    fn: T
-  ): Promise<
-    (T extends (...args: any[]) => infer U ? Awaited<U> : unknown) | undefined
-  > {
-    try {
-      if (this.destroyed) {
-        return;
-      }
-      await this.connectIfNeeded();
-      this.runCounter++;
-      return await fn();
-    } catch (err) {
-      logger.error(err);
-      throw err;
-    } finally {
-      this.runCounter--;
-      if (this.runCounter === 0) {
-        // just close db, but not the yDoc
-        await super.destroy();
-      }
-    }
-  }
-
-  setupAndListen() {
-    if (this.firstConnected) {
-      return;
-    }
-    this.firstConnected = true;
-
-    const onUpstreamUpdate = (update: Uint8Array, origin: YOrigin) => {
-      if (origin === 'renderer') {
-        // update to upstream yDoc should be replicated to self yDoc
-        this.applyUpdate(update, 'upstream');
-      }
-    };
-
-    const onSelfUpdate = async (update: Uint8Array, origin: YOrigin) => {
-      // for self update from upstream, we need to push it to external DB
-      if (origin === 'upstream' && this.db) {
-        await this.addUpdateToUpdateQueue(this.db, update);
-      }
-
-      if (origin === 'self') {
-        this.upstream.applyUpdate(update, 'external');
-      }
-    };
-
-    // listen to upstream update
-    this.upstream.yDoc.on('update', onUpstreamUpdate);
-    this.yDoc.on('update', onSelfUpdate);
-
-    this.unsubscribers.add(() => {
-      this.upstream.yDoc.off('update', onUpstreamUpdate);
-      this.yDoc.off('update', onSelfUpdate);
-    });
-
-    this.run(() => {
-      // apply all updates from upstream
-      const upstreamUpdate = this.upstream.getDocAsUpdates();
-      // to initialize the yDoc, we need to apply all updates from the db
-      this.applyUpdate(upstreamUpdate, 'upstream');
-    })
-      .then(() => {
-        logger.debug('run success');
-      })
-      .catch(err => {
-        logger.error('run error', err);
-      });
-  }
-
-  applyUpdate = (data: Uint8Array, origin: YOrigin = 'upstream') => {
-    Y.applyUpdate(this.yDoc, data, origin);
-  };
-
-  // TODO: have a better solution to handle blobs
-  async syncBlobs() {
-    await this.run(async () => {
-      // skip if upstream db is not connected (maybe it is already closed)
-      const blobsKeys = await this.getBlobKeys();
-      if (!this.upstream.db || this.upstream.db?.isClose) {
-        return;
-      }
-      const upstreamBlobsKeys = await this.upstream.getBlobKeys();
-      // put every missing blob to upstream
-      for (const key of blobsKeys) {
-        if (!upstreamBlobsKeys.includes(key)) {
-          const blob = await this.getBlob(key);
-          if (blob) {
-            await this.upstream.addBlob(key, blob);
-            logger.debug('syncBlobs', this.workspaceId, key);
-          }
-        }
-      }
-    });
-  }
-
-  /**
-   * pull from external DB file and apply to embedded yDoc
-   * workflow:
-   * - connect to external db
-   * - get updates
-   * - apply updates to local yDoc
-   * - get blobs and put new blobs to upstream
-   * - disconnect
-   */
-  async pull() {
-    const start = performance.now();
-    assert(this.upstream.db, 'upstream db should be connected');
-    const updates = await this.run(async () => {
-      // TODO: no need to get all updates, just get the latest ones (using a cursor, etc)?
-      await this.syncBlobs();
-      return (await this.getUpdates()).map(update => update.data);
-    });
-
-    if (!updates || this.destroyed) {
-      return;
-    }
-
-    const merged = mergeUpdate(updates);
-    this.applyUpdate(merged, 'self');
-
-    logger.debug(
-      'pull external updates',
-      this.path,
-      updates.length,
-      (performance.now() - start).toFixed(2),
-      'ms'
-    );
-  }
-}
-
-export async function getSecondaryWorkspaceDBPath(workspaceId: string) {
-  const meta = await getWorkspaceMeta(workspaceId);
-  return meta?.secondaryDBPath;
-}

apps/electron/src/helper/db/subjects.ts

@@ -1,5 +0,0 @@
-import { Subject } from 'rxjs';
-
-export const dbSubjects = {
-  externalUpdate: new Subject<{ workspaceId: string; update: Uint8Array }>(),
-};

apps/electron/src/helper/db/workspace-db-adapter.ts

@@ -1,102 +0,0 @@
-import { Subject } from 'rxjs';
-import * as Y from 'yjs';
-
-import { logger } from '../logger';
-import type { YOrigin } from '../type';
-import { getWorkspaceMeta } from '../workspace';
-import { BaseSQLiteAdapter } from './base-db-adapter';
-import { mergeUpdate } from './merge-update';
-import { dbSubjects } from './subjects';
-
-export class WorkspaceSQLiteDB extends BaseSQLiteAdapter {
-  role = 'primary';
-  yDoc = new Y.Doc();
-  firstConnected = false;
-
-  update$ = new Subject<void>();
-
-  constructor(public override path: string, public workspaceId: string) {
-    super(path);
-  }
-
-  override async destroy() {
-    await super.destroy();
-    this.yDoc.destroy();
-
-    // when db is closed, we can safely remove it from ensure-db list
-    this.update$.complete();
-    this.firstConnected = false;
-  }
-
-  getWorkspaceName = () => {
-    return this.yDoc.getMap('space:meta').get('name') as string;
-  };
-
-  async init() {
-    const db = await super.connectIfNeeded();
-
-    if (!this.firstConnected) {
-      this.yDoc.on('update', async (update: Uint8Array, origin: YOrigin) => {
-        if (origin === 'renderer') {
-          await this.addUpdateToSQLite([update]);
-        } else if (origin === 'external') {
-          dbSubjects.externalUpdate.next({
-            workspaceId: this.workspaceId,
-            update,
-          });
-          await this.addUpdateToSQLite([update]);
-          logger.debug('external update', this.workspaceId);
-        }
-      });
-    }
-
-    const updates = await this.getUpdates();
-    const merged = mergeUpdate(updates.map(update => update.data));
-
-    // to initialize the yDoc, we need to apply all updates from the db
-    this.applyUpdate(merged, 'self');
-
-    this.firstConnected = true;
-    this.update$.next();
-
-    return db;
-  }
-
-  getDocAsUpdates = () => {
-    return Y.encodeStateAsUpdate(this.yDoc);
-  };
-
-  // non-blocking and use yDoc to validate the update
-  // after that, the update is added to the db
-  applyUpdate = (data: Uint8Array, origin: YOrigin = 'renderer') => {
-    // todo: trim the updates when the number of records is too large
-    // 1. store the current ydoc state in the db
-    // 2. then delete the old updates
-    // yjs-idb will always trim the db for the first time after DB is loaded
-    Y.applyUpdate(this.yDoc, data, origin);
-  };
-
-  override async addBlob(key: string, value: Uint8Array) {
-    this.update$.next();
-    const res = await super.addBlob(key, value);
-    return res;
-  }
-
-  override async deleteBlob(key: string) {
-    this.update$.next();
-    await super.deleteBlob(key);
-  }
-
-  override async addUpdateToSQLite(data: Uint8Array[]) {
-    this.update$.next();
-    await super.addUpdateToSQLite(data);
-  }
-}
-
-export async function openWorkspaceDatabase(workspaceId: string) {
-  const meta = await getWorkspaceMeta(workspaceId);
-  const db = new WorkspaceSQLiteDB(meta.mainDBPath, workspaceId);
-  await db.init();
-  logger.info(`openWorkspaceDatabase [${workspaceId}]`);
-  return db;
-}

apps/electron/src/helper/exposed.ts

@@ -1,33 +0,0 @@
-import { dbEvents, dbHandlers } from './db';
-import { dialogHandlers } from './dialog';
-import { workspaceEvents, workspaceHandlers } from './workspace';
-
-export const handlers = {
-  db: dbHandlers,
-  workspace: workspaceHandlers,
-  dialog: dialogHandlers,
-};
-
-export const events = {
-  db: dbEvents,
-  workspace: workspaceEvents,
-};
-
-export const getExposedMeta = () => {
-  const handlersMeta = Object.entries(handlers).map(
-    ([namespace, namespaceHandlers]) => {
-      return [namespace, Object.keys(namespaceHandlers)] as [string, string[]];
-    }
-  );
-
-  const eventsMeta = Object.entries(events).map(
-    ([namespace, namespaceHandlers]) => {
-      return [namespace, Object.keys(namespaceHandlers)] as [string, string[]];
-    }
-  );
-
-  return {
-    handlers: handlersMeta,
-    events: eventsMeta,
-  };
-};

apps/electron/src/helper/index.ts

@@ -1,88 +0,0 @@
-import type { EventBasedChannel } from 'async-call-rpc';
-import { AsyncCall } from 'async-call-rpc';
-
-import { events, handlers } from './exposed';
-import { logger } from './logger';
-
-const createMessagePortMainChannel = (
-  connection: Electron.MessagePortMain
-): EventBasedChannel => {
-  return {
-    on(listener) {
-      const f = (e: Electron.MessageEvent) => {
-        listener(e.data);
-      };
-      connection.on('message', f);
-      // MUST start the connection to receive messages
-      connection.start();
-      return () => {
-        connection.off('message', f);
-      };
-    },
-    send(data) {
-      connection.postMessage(data);
-    },
-  };
-};
-
-function setupRendererConnection(rendererPort: Electron.MessagePortMain) {
-  const flattenedHandlers = Object.entries(handlers).flatMap(
-    ([namespace, namespaceHandlers]) => {
-      return Object.entries(namespaceHandlers).map(([name, handler]) => {
-        const handlerWithLog = async (...args: any[]) => {
-          try {
-            const start = performance.now();
-            const result = await handler(...args);
-            logger.info(
-              '[async-api]',
-              `${namespace}.${name}`,
-              args.filter(
-                arg => typeof arg !== 'function' && typeof arg !== 'object'
-              ),
-              '-',
-              (performance.now() - start).toFixed(2),
-              'ms'
-            );
-            return result;
-          } catch (error) {
-            logger.error('[async-api]', `${namespace}.${name}`, error);
-          }
-        };
-        return [`${namespace}:${name}`, handlerWithLog];
-      });
-    }
-  );
-  const rpc = AsyncCall<PeersAPIs.RendererToHelper>(
-    Object.fromEntries(flattenedHandlers),
-    {
-      channel: createMessagePortMainChannel(rendererPort),
-      log: false,
-    }
-  );
-
-  for (const [namespace, namespaceEvents] of Object.entries(events)) {
-    for (const [key, eventRegister] of Object.entries(namespaceEvents)) {
-      const subscription = eventRegister((...args: any[]) => {
-        const chan = `${namespace}:${key}`;
-        rpc.postEvent(chan, ...args).catch(err => {
-          console.error(err);
-        });
-      });
-      process.on('exit', () => {
-        subscription();
-      });
-    }
-  }
-}
-
-function main() {
-  process.parentPort.on('message', e => {
-    if (e.data.channel === 'renderer-connect' && e.ports.length === 1) {
-      const rendererPort = e.ports[0];
-      setupRendererConnection(rendererPort);
-      logger.info('[helper] renderer connected');
-    }
-  });
-}
-
-main();

apps/electron/src/helper/logger.ts

@@ -1,3 +0,0 @@
-import log from 'electron-log';
-
-export const logger = log.scope('helper');

apps/electron/src/helper/main-rpc.ts

@@ -1,33 +0,0 @@
-import { AsyncCall, type EventBasedChannel } from 'async-call-rpc';
-
-import { getExposedMeta } from './exposed';
-
-function createMessagePortMainChannel(
-  connection: Electron.ParentPort
-): EventBasedChannel {
-  return {
-    on(listener) {
-      const f = (e: Electron.MessageEvent) => {
-        listener(e.data);
-      };
-      connection.on('message', f);
-      return () => {
-        connection.off('message', f);
-      };
-    },
-    send(data) {
-      connection.postMessage(data);
-    },
-  };
-}
-
-const helperToMainServer: PeersAPIs.HelperToMain = {
-  getMeta: () => getExposedMeta(),
-};
-
-export const mainRPC = AsyncCall<PeersAPIs.MainToHelper>(helperToMainServer, {
-  strict: {
-    unknownMessage: false,
-  },
-  channel: createMessagePortMainChannel(process.parentPort),
-});

apps/electron/src/helper/type.ts

@@ -1,9 +0,0 @@
-export interface WorkspaceMeta {
-  id: string;
-  mainDBPath: string;
-  secondaryDBPath?: string; // assume there will be only one
-}
-
-export type YOrigin = 'self' | 'external' | 'upstream' | 'renderer';
-
-export type MainEventRegister = (...args: any[]) => () => void;

apps/electron/src/helper/workspace/__tests__/.gitignore

@@ -1 +0,0 @@
-tmp

apps/electron/src/helper/workspace/__tests__/handlers.spec.ts

@@ -1,142 +0,0 @@
-import path from 'node:path';
-
-import fs from 'fs-extra';
-import { v4 } from 'uuid';
-import { afterEach, describe, expect, test, vi } from 'vitest';
-
-const tmpDir = path.join(__dirname, 'tmp');
-const appDataPath = path.join(tmpDir, 'app-data');
-
-vi.doMock('../../db/ensure-db', () => ({
-  ensureSQLiteDB: async () => ({
-    destroy: () => {},
-  }),
-}));
-
-vi.doMock('../../main-rpc', () => ({
-  mainRPC: {
-    getPath: async () => appDataPath,
-  },
-}));
-
-afterEach(async () => {
-  await fs.remove(tmpDir);
-});
-
-describe('list workspaces', () => {
-  test('listWorkspaces (valid)', async () => {
-    const { listWorkspaces } = await import('../handlers');
-    const workspaceId = v4();
-    const workspacePath = path.join(appDataPath, 'workspaces', workspaceId);
-    const meta = {
-      id: workspaceId,
-    };
-    await fs.ensureDir(workspacePath);
-    await fs.writeJSON(path.join(workspacePath, 'meta.json'), meta);
-    const workspaces = await listWorkspaces();
-    expect(workspaces).toEqual([[workspaceId, meta]]);
-  });
-
-  test('listWorkspaces (without meta json file)', async () => {
-    const { listWorkspaces } = await import('../handlers');
-    const workspaceId = v4();
-    const workspacePath = path.join(appDataPath, 'workspaces', workspaceId);
-    await fs.ensureDir(workspacePath);
-    const workspaces = await listWorkspaces();
-    expect(workspaces).toEqual([
-      [
-        workspaceId,
-        // meta file will be created automatically
-        { id: workspaceId, mainDBPath: path.join(workspacePath, 'storage.db') },
-      ],
-    ]);
-  });
-});
-
-describe('delete workspace', () => {
-  test('deleteWorkspace', async () => {
-    const { deleteWorkspace } = await import('../handlers');
-    const workspaceId = v4();
-    const workspacePath = path.join(appDataPath, 'workspaces', workspaceId);
-    await fs.ensureDir(workspacePath);
-    await deleteWorkspace(workspaceId);
-    expect(await fs.pathExists(workspacePath)).toBe(false);
-    // removed workspace will be moved to deleted-workspaces
-    expect(
-      await fs.pathExists(
-        path.join(appDataPath, 'deleted-workspaces', workspaceId)
-      )
-    ).toBe(true);
-  });
-});
-
-describe('getWorkspaceMeta', () => {
-  test('can get meta', async () => {
-    const { getWorkspaceMeta } = await import('../handlers');
-    const workspaceId = v4();
-    const workspacePath = path.join(appDataPath, 'workspaces', workspaceId);
-    const meta = {
-      id: workspaceId,
-    };
-    await fs.ensureDir(workspacePath);
-    await fs.writeJSON(path.join(workspacePath, 'meta.json'), meta);
-    expect(await getWorkspaceMeta(workspaceId)).toEqual(meta);
-  });
-
-  test('can create meta if not exists', async () => {
-    const { getWorkspaceMeta } = await import('../handlers');
-    const workspaceId = v4();
-    const workspacePath = path.join(appDataPath, 'workspaces', workspaceId);
-    await fs.ensureDir(workspacePath);
-    expect(await getWorkspaceMeta(workspaceId)).toEqual({
-      id: workspaceId,
-      mainDBPath: path.join(workspacePath, 'storage.db'),
-    });
-    expect(
-      await fs.pathExists(path.join(workspacePath, 'meta.json'))
-    ).toBeTruthy();
-  });
-
-  test('can migrate meta if db file is a link', async () => {
-    const { getWorkspaceMeta } = await import('../handlers');
-    const workspaceId = v4();
-    const workspacePath = path.join(appDataPath, 'workspaces', workspaceId);
-    await fs.ensureDir(workspacePath);
-    const sourcePath = path.join(tmpDir, 'source.db');
-    await fs.writeFile(sourcePath, 'test');
-
-    await fs.ensureSymlink(sourcePath, path.join(workspacePath, 'storage.db'));
-
-    expect(await getWorkspaceMeta(workspaceId)).toEqual({
-      id: workspaceId,
-      mainDBPath: path.join(workspacePath, 'storage.db'),
-      secondaryDBPath: sourcePath,
-    });
-
-    expect(
-      await fs.pathExists(path.join(workspacePath, 'meta.json'))
-    ).toBeTruthy();
-  });
-});
-
-test('storeWorkspaceMeta', async () => {
-  const { storeWorkspaceMeta } = await import('../handlers');
-  const workspaceId = v4();
-  const workspacePath = path.join(appDataPath, 'workspaces', workspaceId);
-  await fs.ensureDir(workspacePath);
-  const meta = {
-    id: workspaceId,
-    mainDBPath: path.join(workspacePath, 'storage.db'),
-  };
-  await storeWorkspaceMeta(workspaceId, meta);
-  expect(await fs.readJSON(path.join(workspacePath, 'meta.json'))).toEqual(
-    meta
-  );
-  await storeWorkspaceMeta(workspaceId, {
-    secondaryDBPath: path.join(tmpDir, 'test.db'),
-  });
-  expect(await fs.readJSON(path.join(workspacePath, 'meta.json'))).toEqual({
-    ...meta,
-    secondaryDBPath: path.join(tmpDir, 'test.db'),
-  });
-});

apps/electron/src/helper/workspace/handlers.ts

@@ -1,143 +0,0 @@
-import path from 'node:path';
-
-import fs from 'fs-extra';
-
-import { ensureSQLiteDB } from '../db/ensure-db';
-import { logger } from '../logger';
-import { mainRPC } from '../main-rpc';
-import type { WorkspaceMeta } from '../type';
-import { workspaceSubjects } from './subjects';
-
-let _appDataPath = '';
-
-async function getAppDataPath() {
-  if (_appDataPath) {
-    return _appDataPath;
-  }
-  _appDataPath = await mainRPC.getPath('sessionData');
-  return _appDataPath;
-}
-
-export async function listWorkspaces(): Promise<
-  [workspaceId: string, meta: WorkspaceMeta][]
-> {
-  const basePath = await getWorkspacesBasePath();
-  try {
-    await fs.ensureDir(basePath);
-    const dirs = (
-      await fs.readdir(basePath, {
-        withFileTypes: true,
-      })
-    ).filter(d => d.isDirectory());
-    const metaList = (
-      await Promise.all(
-        dirs.map(async dir => {
-          // ? shall we put all meta in a single file instead of one file per workspace?
-          return await getWorkspaceMeta(dir.name);
-        })
-      )
-    ).filter((w): w is WorkspaceMeta => !!w);
-    return metaList.map(meta => [meta.id, meta]);
-  } catch (error) {
-    logger.error('listWorkspaces', error);
-    return [];
-  }
-}
-
-export async function deleteWorkspace(id: string) {
-  const basePath = await getWorkspaceBasePath(id);
-  const movedPath = path.join(await getDeletedWorkspacesBasePath(), `${id}`);
-  try {
-    const db = await ensureSQLiteDB(id);
-    await db.destroy();
-    return await fs.move(basePath, movedPath, {
-      overwrite: true,
-    });
-  } catch (error) {
-    logger.error('deleteWorkspace', error);
-  }
-}
-
-export async function getWorkspacesBasePath() {
-  return path.join(await getAppDataPath(), 'workspaces');
-}
-
-export async function getWorkspaceBasePath(workspaceId: string) {
-  return path.join(await getAppDataPath(), 'workspaces', workspaceId);
-}
-
-async function getDeletedWorkspacesBasePath() {
-  return path.join(await getAppDataPath(), 'deleted-workspaces');
-}
-
-export async function getWorkspaceDBPath(workspaceId: string) {
-  return path.join(await getWorkspaceBasePath(workspaceId), 'storage.db');
-}
-
-export async function getWorkspaceMetaPath(workspaceId: string) {
-  return path.join(await getWorkspaceBasePath(workspaceId), 'meta.json');
-}
-
-/**
- * Get workspace meta, create one if not exists
- * This function will also migrate the workspace if needed
- */
-export async function getWorkspaceMeta(
-  workspaceId: string
-): Promise<WorkspaceMeta> {
-  try {
-    const basePath = await getWorkspaceBasePath(workspaceId);
-    const metaPath = await getWorkspaceMetaPath(workspaceId);
-    if (!(await fs.exists(metaPath))) {
-      // since not meta is found, we will migrate symlinked db file if needed
-      await fs.ensureDir(basePath);
-      const dbPath = await getWorkspaceDBPath(workspaceId);
-
-      // todo: remove this after migration (in stable version)
-      const realDBPath = (await fs.exists(dbPath))
-        ? await fs.realpath(dbPath)
-        : dbPath;
-      const isLink = realDBPath !== dbPath;
-      if (isLink) {
-        await fs.copy(realDBPath, dbPath);
-      }
-      // create one if not exists
-      const meta = {
-        id: workspaceId,
-        mainDBPath: dbPath,
-        secondaryDBPath: isLink ? realDBPath : undefined,
-      };
-      await fs.writeJSON(metaPath, meta);
-      return meta;
-    } else {
-      const meta = await fs.readJSON(metaPath);
-      return meta;
-    }
-  } catch (err) {
-    logger.error('getWorkspaceMeta failed', err);
-    throw err;
-  }
-}
-
-export async function storeWorkspaceMeta(
-  workspaceId: string,
-  meta: Partial<WorkspaceMeta>
-) {
-  try {
-    const basePath = await getWorkspaceBasePath(workspaceId);
-    await fs.ensureDir(basePath);
-    const metaPath = path.join(basePath, 'meta.json');
-    const currentMeta = await getWorkspaceMeta(workspaceId);
-    const newMeta = {
-      ...currentMeta,
-      ...meta,
-    };
-    await fs.writeJSON(metaPath, newMeta);
-    workspaceSubjects.meta.next({
-      workspaceId,
-      meta: newMeta,
-    });
-  } catch (err) {
-    logger.error('storeWorkspaceMeta failed', err);
-  }
-}

apps/electron/src/helper/workspace/index.ts

@@ -1,25 +0,0 @@
-import type { MainEventRegister, WorkspaceMeta } from '../type';
-import { deleteWorkspace, getWorkspaceMeta, listWorkspaces } from './handlers';
-import { workspaceSubjects } from './subjects';
-
-export * from './handlers';
-export * from './subjects';
-
-export const workspaceEvents = {
-  onMetaChange: (
-    fn: (meta: { workspaceId: string; meta: WorkspaceMeta }) => void
-  ) => {
-    const sub = workspaceSubjects.meta.subscribe(fn);
-    return () => {
-      sub.unsubscribe();
-    };
-  },
-} satisfies Record<string, MainEventRegister>;
-
-export const workspaceHandlers = {
-  list: async () => listWorkspaces(),
-  delete: async (id: string) => deleteWorkspace(id),
-  getMeta: async (id: string) => {
-    return getWorkspaceMeta(id);
-  },
-};

apps/electron/src/helper/workspace/subjects.ts

@@ -1,7 +0,0 @@
-import { Subject } from 'rxjs';
-
-import type { WorkspaceMeta } from '../type';
-
-export const workspaceSubjects = {
-  meta: new Subject<{ workspaceId: string; meta: WorkspaceMeta }>(),
-};

apps/electron/src/main/__tests__/.gitignore

@@ -1 +0,0 @@
-tmp

apps/electron/src/main/__tests__/integration.spec.ts

@@ -1,173 +0,0 @@
-import assert from 'node:assert';
-import path from 'node:path';
-import { setTimeout } from 'node:timers/promises';
-
-import fs from 'fs-extra';
-import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
-
-import type { MainIPCHandlerMap } from '../exposed';
-
-const registeredHandlers = new Map<
-  string,
-  ((...args: any[]) => Promise<any>)[]
->();
-
-type WithoutFirstParameter<T> = T extends (_: any, ...args: infer P) => infer R
-  ? (...args: P) => R
-  : T;
-
-// common mock dispatcher for ipcMain.handle AND app.on
-// alternatively, we can use single parameter for T & F, eg, dispatch('workspace:list'),
-// however this is too hard to be typed correctly
-async function dispatch<
-  T extends keyof MainIPCHandlerMap,
-  F extends keyof MainIPCHandlerMap[T]
->(
-  namespace: T,
-  functionName: F,
-  ...args: Parameters<WithoutFirstParameter<MainIPCHandlerMap[T][F]>>
-): // @ts-expect-error
-ReturnType<MainIPCHandlerMap[T][F]> {
-  // @ts-expect-error
-  const handlers = registeredHandlers.get(namespace + ':' + functionName);
-  assert(handlers);
-
-  // we only care about the first handler here
-  return await handlers[0](null, ...args);
-}
-
-const SESSION_DATA_PATH = path.join(__dirname, './tmp', 'affine-test');
-const DOCUMENTS_PATH = path.join(__dirname, './tmp', 'affine-test-documents');
-
-const browserWindow = {
-  isDestroyed: () => {
-    return false;
-  },
-  setWindowButtonVisibility: (_v: boolean) => {
-    // will be stubbed later
-  },
-  webContents: {
-    send: (_type: string, ..._args: any[]) => {
-      // will be stubbed later
-    },
-  },
-};
-
-const ipcMain = {
-  handle: (key: string, callback: (...args: any[]) => Promise<any>) => {
-    const handlers = registeredHandlers.get(key) || [];
-    handlers.push(callback);
-    registeredHandlers.set(key, handlers);
-  },
-  setMaxListeners: (_n: number) => {
-    // noop
-  },
-};
-
-const nativeTheme = {
-  themeSource: 'light',
-};
-
-const electronModule = {
-  app: {
-    getPath: (name: string) => {
-      if (name === 'sessionData') {
-        return SESSION_DATA_PATH;
-      } else if (name === 'documents') {
-        return DOCUMENTS_PATH;
-      }
-      throw new Error('not implemented');
-    },
-    name: 'affine-test',
-    on: (name: string, callback: (...args: any[]) => any) => {
-      const handlers = registeredHandlers.get(name) || [];
-      handlers.push(callback);
-      registeredHandlers.set(name, handlers);
-    },
-    addListener: (...args: any[]) => {
-      // @ts-expect-error
-      electronModule.app.on(...args);
-    },
-    removeListener: () => {},
-  },
-  BrowserWindow: {
-    getAllWindows: () => {
-      return [browserWindow];
-    },
-  },
-  nativeTheme: nativeTheme,
-  ipcMain,
-  shell: {} as Partial<Electron.Shell>,
-  dialog: {} as Partial<Electron.Dialog>,
-};
-
-// dynamically import handlers so that we can inject local variables to mocks
-vi.doMock('electron', () => {
-  return electronModule;
-});
-
-beforeEach(async () => {
-  const { registerHandlers } = await import('../handlers');
-  registerHandlers();
-
-  // should also register events
-  const { registerEvents } = await import('../events');
-  registerEvents();
-  await fs.mkdirp(SESSION_DATA_PATH);
-
-  registeredHandlers.get('ready')?.forEach(fn => fn());
-});
-
-afterEach(async () => {
-  // reset registered handlers
-  registeredHandlers.get('before-quit')?.forEach(fn => fn());
-  // wait for the db to be closed on Windows
-  if (process.platform === 'win32') {
-    await setTimeout(200);
-  }
-  await fs.remove(SESSION_DATA_PATH);
-});
-
-describe('UI handlers', () => {
-  test('theme-change', async () => {
-    await dispatch('ui', 'handleThemeChange', 'dark');
-    expect(nativeTheme.themeSource).toBe('dark');
-    await dispatch('ui', 'handleThemeChange', 'light');
-    expect(nativeTheme.themeSource).toBe('light');
-  });
-
-  test('sidebar-visibility-change (macOS)', async () => {
-    vi.stubGlobal('process', { platform: 'darwin' });
-    const setWindowButtonVisibility = vi.fn();
-    browserWindow.setWindowButtonVisibility = setWindowButtonVisibility;
-    await dispatch('ui', 'handleSidebarVisibilityChange', true);
-    expect(setWindowButtonVisibility).toBeCalledWith(true);
-    await dispatch('ui', 'handleSidebarVisibilityChange', false);
-    expect(setWindowButtonVisibility).toBeCalledWith(false);
-    vi.unstubAllGlobals();
-  });
-
-  test('sidebar-visibility-change (non-macOS)', async () => {
-    vi.stubGlobal('process', { platform: 'linux' });
-    const setWindowButtonVisibility = vi.fn();
-    browserWindow.setWindowButtonVisibility = setWindowButtonVisibility;
-    await dispatch('ui', 'handleSidebarVisibilityChange', true);
-    expect(setWindowButtonVisibility).not.toBeCalled();
-    vi.unstubAllGlobals();
-  });
-});
-
-describe('applicationMenu', () => {
-  // test some basic IPC events
-  test('applicationMenu event', async () => {
-    const { applicationMenuSubjects } = await import('../application-menu');
-    const sendStub = vi.fn();
-    browserWindow.webContents.send = sendStub;
-    applicationMenuSubjects.newPageAction.next();
-    expect(sendStub).toHaveBeenCalledWith(
-      'applicationMenu:onNewPageAction',
-      undefined
-    );
-    browserWindow.webContents.send = () => {};
-  });
-});

apps/electron/src/main/application-menu/subject.ts

@@ -1,5 +0,0 @@
-import { Subject } from 'rxjs';
-
-export const applicationMenuSubjects = {
-  newPageAction: new Subject<void>(),
-};

apps/electron/src/main/export/index.ts

@@ -1,10 +0,0 @@
-import type { NamespaceHandlers } from '../type';
-import { savePDFFileAs } from './pdf';
-
-export const exportHandlers = {
-  savePDFFileAs: async (_, title: string) => {
-    return savePDFFileAs(title);
-  },
-} satisfies NamespaceHandlers;
-
-export * from './pdf';

apps/electron/src/main/export/pdf.ts

@@ -1,61 +0,0 @@
-import { BrowserWindow, dialog, shell } from 'electron';
-import fs from 'fs-extra';
-
-import { logger } from '../logger';
-import type { ErrorMessage } from './utils';
-import { getFakedResult } from './utils';
-
-export interface SavePDFFileResult {
-  filePath?: string;
-  canceled?: boolean;
-  error?: ErrorMessage;
-}
-
-/**
- * This function is called when the user clicks the "Export to PDF" button in the electron.
- *
- * It will just copy the file to the given path
- */
-export async function savePDFFileAs(
-  pageTitle: string
-): Promise<SavePDFFileResult> {
-  try {
-    const ret =
-      getFakedResult() ??
-      (await dialog.showSaveDialog({
-        properties: ['showOverwriteConfirmation'],
-        title: 'Save PDF',
-        showsTagField: false,
-        buttonLabel: 'Save',
-        defaultPath: `${pageTitle}.pdf`,
-        message: 'Save Page as a PDF file',
-      }));
-    const filePath = ret.filePath;
-    if (ret.canceled || !filePath) {
-      return {
-        canceled: true,
-      };
-    }
-
-    await BrowserWindow.getFocusedWindow()
-      ?.webContents.printToPDF({
-        pageSize: 'A4',
-        printBackground: true,
-        landscape: false,
-      })
-      .then(data => {
-        fs.writeFile(filePath, data, error => {
-          if (error) throw error;
-          logger.log(`Wrote PDF successfully to ${filePath}`);
-        });
-      });
-
-    await shell.openPath(filePath);
-    return { filePath };
-  } catch (err) {
-    logger.error('savePDFFileAs', err);
-    return {
-      error: 'UNKNOWN_ERROR',
-    };
-  }
-}

apps/electron/src/main/export/utils.ts

@@ -1,24 +0,0 @@
-// provide a backdoor to set dialog path for testing in playwright
-interface FakeDialogResult {
-  canceled?: boolean;
-  filePath?: string;
-  filePaths?: string[];
-}
-// result will be used in the next call to showOpenDialog
-// if it is being read once, it will be reset to undefined
-let fakeDialogResult: FakeDialogResult | undefined = undefined;
-export function getFakedResult() {
-  const result = fakeDialogResult;
-  fakeDialogResult = undefined;
-  return result;
-}
-
-export function setFakeDialogResult(result: FakeDialogResult | undefined) {
-  fakeDialogResult = result;
-  // for convenience, we will fill filePaths with filePath if it is not set
-  if (result?.filePaths === undefined && result?.filePath !== undefined) {
-    result.filePaths = [result.filePath];
-  }
-}
-const ErrorMessages = ['FILE_ALREADY_EXISTS', 'UNKNOWN_ERROR'] as const;
-export type ErrorMessage = (typeof ErrorMessages)[number];

apps/electron/src/main/exposed.ts

@@ -1,29 +0,0 @@
-import { allEvents as events } from './events';
-import { allHandlers as handlers } from './handlers';
-
-// this will be used by preload script to expose all handlers and events to the renderer process
-// - register in exposeInMainWorld in preload
-// - provide type hints
-export { events, handlers };
-
-export const getExposedMeta = () => {
-  const handlersMeta = Object.entries(handlers).map(
-    ([namespace, namespaceHandlers]) => {
-      return [namespace, Object.keys(namespaceHandlers)];
-    }
-  );
-
-  const eventsMeta = Object.entries(events).map(
-    ([namespace, namespaceHandlers]) => {
-      return [namespace, Object.keys(namespaceHandlers)];
-    }
-  );
-
-  return {
-    handlers: handlersMeta,
-    events: eventsMeta,
-  };
-};
-
-export type MainIPCHandlerMap = typeof handlers;
-export type MainIPCEventMap = typeof events;

apps/electron/src/main/helper-process.ts

@@ -1,111 +0,0 @@
-import path from 'node:path';
-
-import { type _AsyncVersionOf, AsyncCall } from 'async-call-rpc';
-import {
-  app,
-  dialog,
-  MessageChannelMain,
-  shell,
-  type UtilityProcess,
-  utilityProcess,
-  type WebContents,
-} from 'electron';
-
-import { logger } from './logger';
-import { MessageEventChannel } from './utils';
-
-const HELPER_PROCESS_PATH = path.join(__dirname, './helper.js');
-
-function pickAndBind<T extends object, U extends keyof T>(
-  obj: T,
-  keys: U[]
-): { [K in U]: T[K] } {
-  return keys.reduce((acc, key) => {
-    const prop = obj[key];
-    acc[key] =
-      typeof prop === 'function'
-        ? // @ts-expect-error - a hack to bind the function
-          prop.bind(obj)
-        : prop;
-    return acc;
-  }, {} as any);
-}
-
-class HelperProcessManager {
-  ready: Promise<void>;
-  #process: UtilityProcess;
-
-  // a rpc server for the main process -> helper process
-  rpc?: _AsyncVersionOf<PeersAPIs.HelperToMain>;
-
-  static instance = new HelperProcessManager();
-
-  private constructor() {
-    const helperProcess = utilityProcess.fork(HELPER_PROCESS_PATH);
-    this.#process = helperProcess;
-    this.ready = new Promise((resolve, reject) => {
-      helperProcess.once('spawn', () => {
-        try {
-          this.#connectMain();
-          resolve();
-        } catch (err) {
-          logger.error('[helper] connectMain error', err);
-          reject(err);
-        }
-      });
-    });
-
-    app.on('before-quit', () => {
-      this.#process.kill();
-    });
-  }
-
-  // bridge renderer <-> helper process
-  connectRenderer(renderer: WebContents) {
-    // connect to the helper process
-    const { port1: helperPort, port2: rendererPort } = new MessageChannelMain();
-    this.#process.postMessage({ channel: 'renderer-connect' }, [helperPort]);
-    renderer.postMessage('helper-connection', null, [rendererPort]);
-
-    return () => {
-      helperPort.close();
-      rendererPort.close();
-    };
-  }
-
-  // bridge main <-> helper process
-  // also set up the RPC to the helper process
-  #connectMain() {
-    const dialogMethods = pickAndBind(dialog, [
-      'showOpenDialog',
-      'showSaveDialog',
-    ]);
-    const shellMethods = pickAndBind(shell, [
-      'openExternal',
-      'showItemInFolder',
-    ]);
-    const appMethods = pickAndBind(app, ['getPath']);
-
-    const mainToHelperServer: PeersAPIs.MainToHelper = {
-      ...dialogMethods,
-      ...shellMethods,
-      ...appMethods,
-    };
-
-    const server = AsyncCall<PeersAPIs.HelperToMain>(mainToHelperServer, {
-      strict: {
-        // the channel is shared for other purposes as well so that we do not want to
-        // restrict to only JSONRPC messages
-        unknownMessage: false,
-      },
-      channel: new MessageEventChannel(this.#process),
-    });
-    this.rpc = server;
-  }
-}
-
-export async function ensureHelperProcess() {
-  const helperProcessManager = HelperProcessManager.instance;
-  await helperProcessManager.ready;
-  return helperProcessManager;
-}

apps/electron/src/main/plugin.ts

@@ -1,70 +0,0 @@
-import { join, resolve } from 'node:path';
-import { Worker } from 'node:worker_threads';
-
-import { logger } from '@affine/electron/main/logger';
-import { AsyncCall } from 'async-call-rpc';
-import { ipcMain } from 'electron';
-
-import { MessageEventChannel } from './utils';
-
-declare global {
-  // fixme(himself65):
-  //  remove this when bookmark block plugin is migrated to plugin-infra
-  // eslint-disable-next-line no-var
-  var asyncCall: Record<string, (...args: any) => PromiseLike<any>>;
-}
-
-export function registerPlugin() {
-  const pluginWorkerPath = join(__dirname, './workers/plugin.worker.js');
-  const asyncCall = AsyncCall<
-    Record<string, (...args: any) => PromiseLike<any>>
-  >(
-    {
-      log: (...args: any[]) => {
-        logger.log('Plugin Worker', ...args);
-      },
-    },
-    {
-      channel: new MessageEventChannel(new Worker(pluginWorkerPath)),
-    }
-  );
-  globalThis.asyncCall = asyncCall;
-  logger.info('import plugin manager');
-  import('@toeverything/plugin-infra/manager')
-    .then(({ rootStore, affinePluginsAtom }) => {
-      logger.info('import plugin manager');
-      const bookmarkPluginPath = join(
-        process.env.PLUGIN_DIR ?? resolve(__dirname, './plugins'),
-        './bookmark-block/index.mjs'
-      );
-      logger.info('bookmark plugin path:', bookmarkPluginPath);
-      import('file://' + bookmarkPluginPath);
-      let dispose: () => void = () => {
-        // noop
-      };
-      rootStore.sub(affinePluginsAtom, () => {
-        dispose();
-        const plugins = rootStore.get(affinePluginsAtom);
-        Object.values(plugins).forEach(plugin => {
-          logger.info('register plugin', plugin.definition.id);
-          plugin.definition.commands.forEach(command => {
-            logger.info('register plugin command', command);
-            ipcMain.handle(command, (event, ...args) =>
-              asyncCall[command](...args)
-            );
-          });
-        });
-        dispose = () => {
-          Object.values(plugins).forEach(plugin => {
-            plugin.definition.commands.forEach(command => {
-              logger.info('unregister plugin command', command);
-              ipcMain.removeHandler(command);
-            });
-          });
-        };
-      });
-    })
-    .catch(error => {
-      logger.error('import plugin manager error', error);
-    });
-}

apps/electron/src/main/utils.ts

@@ -1,40 +0,0 @@
-import type { EventBasedChannel } from 'async-call-rpc';
-
-export function getTime() {
-  return new Date().getTime();
-}
-
-export const isMacOS = () => {
-  return process.platform === 'darwin';
-};
-
-export const isWindows = () => {
-  return process.platform === 'win32';
-};
-
-interface MessagePortLike {
-  postMessage: (data: unknown) => void;
-  addListener: (event: 'message', listener: (...args: any[]) => void) => void;
-  removeListener: (
-    event: 'message',
-    listener: (...args: any[]) => void
-  ) => void;
-}
-
-export class MessageEventChannel implements EventBasedChannel {
-  constructor(private worker: MessagePortLike) {}
-
-  on(listener: (data: unknown) => void) {
-    const f = (data: unknown) => {
-      listener(data);
-    };
-    this.worker.addListener('message', f);
-    return () => {
-      this.worker.removeListener('message', f);
-    };
-  }
-
-  send(data: unknown) {
-    this.worker.postMessage(data);
-  }
-}

apps/electron/src/main/workers/plugin.worker.ts

@@ -1,69 +0,0 @@
-import { join, resolve } from 'node:path';
-import { parentPort } from 'node:worker_threads';
-
-import { AsyncCall } from 'async-call-rpc';
-
-import { MessageEventChannel } from '../utils';
-
-const commandProxy: Record<string, (...args: any[]) => Promise<any>> = {};
-
-if (!parentPort) {
-  throw new Error('parentPort is undefined');
-}
-
-const mainThread = AsyncCall<{
-  log: (...args: any[]) => Promise<void>;
-}>(commandProxy, {
-  channel: new MessageEventChannel(parentPort),
-});
-
-globalThis.console.log = mainThread.log;
-globalThis.console.error = mainThread.log;
-globalThis.console.info = mainThread.log;
-globalThis.console.debug = mainThread.log;
-globalThis.console.warn = mainThread.log;
-
-console.log('import plugin infra');
-
-import('@toeverything/plugin-infra/manager')
-  .then(({ rootStore, affinePluginsAtom }) => {
-    const bookmarkPluginPath = join(
-      process.env.PLUGIN_DIR ?? resolve(__dirname, '../plugins'),
-      './bookmark-block/index.mjs'
-    );
-
-    console.log('import bookmark plugin', bookmarkPluginPath);
-
-    import('file://' + bookmarkPluginPath).catch(console.log);
-    rootStore.sub(affinePluginsAtom, () => {
-      const plugins = rootStore.get(affinePluginsAtom);
-      Object.values(plugins).forEach(plugin => {
-        console.log('handle plugin', plugin.definition.id);
-        if (plugin.serverAdapter) {
-          try {
-            plugin.serverAdapter({
-              registerCommand: (command, fn) => {
-                console.log('register command', command);
-                commandProxy[command] = fn;
-              },
-              unregisterCommand: command => {
-                console.log('unregister command', command);
-                delete commandProxy[command];
-              },
-            });
-          } catch (e) {
-            console.log(
-              'error when handle plugin',
-              plugin.definition.id,
-              `${e}`
-            );
-          }
-        } else {
-          console.log('no server adapter, skipping.');
-        }
-      });
-    });
-  })
-  .catch(err => {
-    console.error(err);
-  });

apps/electron/src/preload/affine-apis.ts

@@ -1,193 +0,0 @@
-// NOTE: we will generate preload types from this file
-import { AsyncCall, type EventBasedChannel } from 'async-call-rpc';
-import { ipcRenderer } from 'electron';
-import { Subject } from 'rxjs';
-
-type ExposedMeta = {
-  handlers: [namespace: string, handlerNames: string[]][];
-  events: [namespace: string, eventNames: string[]][];
-};
-
-export function getAffineAPIs() {
-  const mainAPIs = getMainAPIs();
-  const helperAPIs = getHelperAPIs();
-
-  return {
-    apis: {
-      ...mainAPIs.apis,
-      ...helperAPIs.apis,
-    },
-    events: {
-      ...mainAPIs.events,
-      ...helperAPIs.events,
-    },
-  };
-}
-
-export const appInfo = {
-  electron: true,
-};
-
-function getMainAPIs() {
-  const meta: ExposedMeta = (() => {
-    const val = process.argv
-      .find(arg => arg.startsWith('--main-exposed-meta='))
-      ?.split('=')[1];
-
-    return val ? JSON.parse(val) : null;
-  })();
-
-  // main handlers that can be invoked from the renderer process
-  const apis: any = (() => {
-    const { handlers: handlersMeta } = meta;
-
-    const all = handlersMeta.map(([namespace, functionNames]) => {
-      const namespaceApis = functionNames.map(name => {
-        const channel = `${namespace}:${name}`;
-        return [
-          name,
-          (...args: any[]) => {
-            return ipcRenderer.invoke(channel, ...args);
-          },
-        ];
-      });
-      return [namespace, Object.fromEntries(namespaceApis)];
-    });
-
-    return Object.fromEntries(all);
-  })();
-
-  // main events that can be listened to from the renderer process
-  const events: any = (() => {
-    const { events: eventsMeta } = meta;
-
-    // NOTE: ui may try to listen to a lot of the same events, so we increase the limit...
-    ipcRenderer.setMaxListeners(100);
-
-    const all = eventsMeta.map(([namespace, eventNames]) => {
-      const namespaceEvents = eventNames.map(name => {
-        const channel = `${namespace}:${name}`;
-        return [
-          name,
-          (callback: (...args: any[]) => void) => {
-            const fn: (
-              event: Electron.IpcRendererEvent,
-              ...args: any[]
-            ) => void = (_, ...args) => {
-              callback(...args);
-            };
-            ipcRenderer.on(channel, fn);
-            return () => {
-              ipcRenderer.off(channel, fn);
-            };
-          },
-        ];
-      });
-      return [namespace, Object.fromEntries(namespaceEvents)];
-    });
-    return Object.fromEntries(all);
-  })();
-
-  return { apis, events };
-}
-
-const helperPort$ = new Promise<MessagePort>(resolve =>
-  ipcRenderer.on('helper-connection', async e => {
-    console.info('[preload] helper-connection', e);
-    resolve(e.ports[0]);
-  })
-);
-
-const createMessagePortChannel = (port: MessagePort): EventBasedChannel => {
-  return {
-    on(listener) {
-      port.onmessage = e => {
-        listener(e.data);
-      };
-      port.start();
-      return () => {
-        port.onmessage = null;
-        port.close();
-      };
-    },
-    send(data) {
-      port.postMessage(data);
-    },
-  };
-};
-
-function getHelperAPIs() {
-  const events$ = new Subject<{ channel: string; args: any[] }>();
-  const meta: ExposedMeta = (() => {
-    const val = process.argv
-      .find(arg => arg.startsWith('--helper-exposed-meta='))
-      ?.split('=')[1];
-
-    return val ? JSON.parse(val) : null;
-  })();
-
-  const rendererToHelperServer: PeersAPIs.RendererToHelper = {
-    postEvent: (channel, ...args) => {
-      events$.next({ channel, args });
-    },
-  };
-
-  const rpc = AsyncCall<PeersAPIs.HelperToRenderer>(rendererToHelperServer, {
-    channel: helperPort$.then(helperPort =>
-      createMessagePortChannel(helperPort)
-    ),
-    log: false,
-  });
-
-  const toHelperHandler = (namespace: string, name: string) => {
-    return rpc[`${namespace}:${name}`];
-  };
-
-  const toHelperEventSubscriber = (namespace: string, name: string) => {
-    return (callback: (...args: any[]) => void) => {
-      const subscription = events$.subscribe(({ channel, args }) => {
-        if (channel === `${namespace}:${name}`) {
-          callback(...args);
-        }
-      });
-      return () => {
-        subscription.unsubscribe();
-      };
-    };
-  };
-
-  const setup = (meta: ExposedMeta) => {
-    const { handlers: handlersMeta, events: eventsMeta } = meta;
-
-    const helperHandlers = Object.fromEntries(
-      handlersMeta.map(([namespace, functionNames]) => {
-        return [
-          namespace,
-          Object.fromEntries(
-            functionNames.map(name => {
-              return [name, toHelperHandler(namespace, name)];
-            })
-          ),
-        ];
-      })
-    );
-
-    const helperEvents = Object.fromEntries(
-      eventsMeta.map(([namespace, eventNames]) => {
-        return [
-          namespace,
-          Object.fromEntries(
-            eventNames.map(name => {
-              return [name, toHelperEventSubscriber(namespace, name)];
-            })
-          ),
-        ];
-      })
-    );
-    return [helperHandlers, helperEvents];
-  };
-
-  const [apis, events] = setup(meta);
-
-  return { apis, events };
-}