fix: circular dependencies (#4307)

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

@@ -25,7 +25,8 @@ import {
 } from 'rxjs/operators';
 
 import { logger } from '../logger';
-import { getWorkspaceMeta, workspaceSubjects } from '../workspace';
+import { getWorkspaceMeta } from '../workspace/meta';
+import { workspaceSubjects } from '../workspace/subjects';
 import { SecondaryWorkspaceSQLiteDB } from './secondary-db';
 import type { WorkspaceSQLiteDB } from './workspace-db-adapter';
 import { openWorkspaceDatabase } from './workspace-db-adapter';

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

@@ -6,7 +6,7 @@ import { applyUpdate, Doc as YDoc } from 'yjs';
 
 import { logger } from '../logger';
 import type { YOrigin } from '../type';
-import { getWorkspaceMeta } from '../workspace';
+import { getWorkspaceMeta } from '../workspace/meta';
 import { BaseSQLiteAdapter } from './base-db-adapter';
 import type { WorkspaceSQLiteDB } from './workspace-db-adapter';
 

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

@@ -5,7 +5,7 @@ import { applyUpdate, Doc as YDoc, encodeStateAsUpdate } from 'yjs';
 
 import { logger } from '../logger';
 import type { YOrigin } from '../type';
-import { getWorkspaceMeta } from '../workspace';
+import { getWorkspaceMeta } from '../workspace/meta';
 import { BaseSQLiteAdapter } from './base-db-adapter';
 import { dbSubjects } from './subjects';
 

apps/electron/src/helper/dialog/dialog.ts

@@ -21,13 +21,12 @@ import {
 import type { WorkspaceSQLiteDB } from '../db/workspace-db-adapter';
 import { logger } from '../logger';
 import { mainRPC } from '../main-rpc';
+import { listWorkspaces, storeWorkspaceMeta } from '../workspace';
 import {
   getWorkspaceDBPath,
   getWorkspaceMeta,
   getWorkspacesBasePath,
-  listWorkspaces,
-  storeWorkspaceMeta,
-} from '../workspace';
+} from '../workspace/meta';
 
 // NOTE:
 // we are using native dialogs because HTML dialogs do not give full file paths

apps/electron/src/helper/exposed.ts

@@ -6,6 +6,7 @@ import type {
 
 import { dbEvents, dbHandlers } from './db';
 import { dialogHandlers } from './dialog';
+import { provideExposed } from './provide';
 import { workspaceEvents, workspaceHandlers } from './workspace';
 
 type AllHandlers = {
@@ -25,7 +26,7 @@ export const events = {
   workspace: workspaceEvents,
 };
 
-export const getExposedMeta = () => {
+const getExposedMeta = () => {
   const handlersMeta = Object.entries(handlers).map(
     ([namespace, namespaceHandlers]) => {
       return [namespace, Object.keys(namespaceHandlers)] as [string, string[]];
@@ -43,3 +44,5 @@ export const getExposedMeta = () => {
     events: eventsMeta,
   };
 };
+
+provideExposed(getExposedMeta());

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

@@ -1,13 +1,17 @@
+import { assertExists } from '@blocksuite/global/utils';
 import type {
   HelperToMain,
   MainToHelper,
 } from '@toeverything/infra/preload/electron';
 import { AsyncCall } from 'async-call-rpc';
 
-import { getExposedMeta } from './exposed';
+import { exposed } from './provide';
 
 const helperToMainServer: HelperToMain = {
-  getMeta: () => getExposedMeta(),
+  getMeta: () => {
+    assertExists(exposed);
+    return exposed;
+  },
 };
 
 export const mainRPC = AsyncCall<MainToHelper>(helperToMainServer, {

apps/electron/src/helper/provide.ts

@@ -0,0 +1,11 @@
+import type { ExposedMeta } from '@toeverything/infra/preload/electron';
+
+/**
+ * A naive DI implementation to get rid of circular dependency.
+ */
+
+export let exposed: ExposedMeta | undefined;
+
+export const provideExposed = (exposedMeta: ExposedMeta) => {
+  exposed = exposedMeta;
+};

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

@@ -74,7 +74,7 @@ describe('delete workspace', () => {
 
 describe('getWorkspaceMeta', () => {
   test('can get meta', async () => {
-    const { getWorkspaceMeta } = await import('../handlers');
+    const { getWorkspaceMeta } = await import('../meta');
     const workspaceId = v4();
     const workspacePath = path.join(appDataPath, 'workspaces', workspaceId);
     const meta = {
@@ -86,7 +86,7 @@ describe('getWorkspaceMeta', () => {
   });
 
   test('can create meta if not exists', async () => {
-    const { getWorkspaceMeta } = await import('../handlers');
+    const { getWorkspaceMeta } = await import('../meta');
     const workspaceId = v4();
     const workspacePath = path.join(appDataPath, 'workspaces', workspaceId);
     await fs.ensureDir(workspacePath);
@@ -100,7 +100,7 @@ describe('getWorkspaceMeta', () => {
   });
 
   test('can migrate meta if db file is a link', async () => {
-    const { getWorkspaceMeta } = await import('../handlers');
+    const { getWorkspaceMeta } = await import('../meta');
     const workspaceId = v4();
     const workspacePath = path.join(appDataPath, 'workspaces', workspaceId);
     await fs.ensureDir(workspacePath);

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

@@ -4,20 +4,15 @@ 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 {
+  getDeletedWorkspacesBasePath,
+  getWorkspaceBasePath,
+  getWorkspaceMeta,
+  getWorkspacesBasePath,
+} from './meta';
 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][]
 > {
@@ -58,67 +53,6 @@ export async function deleteWorkspace(id: string) {
   }
 }
 
-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>

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

@@ -1,5 +1,6 @@
 import type { MainEventRegister, WorkspaceMeta } from '../type';
-import { deleteWorkspace, getWorkspaceMeta, listWorkspaces } from './handlers';
+import { deleteWorkspace, listWorkspaces } from './handlers';
+import { getWorkspaceMeta } from './meta';
 import { workspaceSubjects } from './subjects';
 
 export * from './handlers';

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

@@ -0,0 +1,78 @@
+import path from 'node:path';
+
+import fs from 'fs-extra';
+
+import { logger } from '../logger';
+import { mainRPC } from '../main-rpc';
+import type { WorkspaceMeta } from '../type';
+
+let _appDataPath = '';
+
+export async function getAppDataPath() {
+  if (_appDataPath) {
+    return _appDataPath;
+  }
+  _appDataPath = await mainRPC.getPath('sessionData');
+  return _appDataPath;
+}
+
+export async function getWorkspacesBasePath() {
+  return path.join(await getAppDataPath(), 'workspaces');
+}
+
+export async function getWorkspaceBasePath(workspaceId: string) {
+  return path.join(await getAppDataPath(), 'workspaces', workspaceId);
+}
+
+export 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;
+  }
+}