feat: create workspace from loading existing exported file (#2122)

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

packages/workspace/src/affine/login.ts

@@ -69,7 +69,7 @@ export const setLoginStorage = (login: LoginResponse) => {
 
 const signInWithElectron = async (firebaseAuth: FirebaseAuth) => {
   if (window.apis) {
-    const { url, requestInit } = await window.apis.getGoogleOauthCode();
+    const { url, requestInit } = await window.apis.ui.getGoogleOauthCode();
     const { id_token } = await fetch(url, requestInit).then(res => res.json());
     const credential = GoogleAuthProvider.credential(id_token);
     const user = await signInWithCredential(firebaseAuth, credential);

packages/workspace/src/blob/sqlite-blob-storage.ts

@@ -1,24 +1,28 @@
 import type { BlobStorage } from '@blocksuite/store';
+import { assertExists } from '@blocksuite/store';
 
 export const createSQLiteStorage = (workspaceId: string): BlobStorage => {
+  const apis = window.apis;
+  assertExists(apis);
   return {
     crud: {
       get: async (key: string) => {
-        const buffer = await window.apis.db.getBlob(workspaceId, key);
+        const buffer = await apis.db.getBlob(workspaceId, key);
         return buffer ? new Blob([buffer]) : null;
       },
       set: async (key: string, value: Blob) => {
-        return window.apis.db.addBlob(
+        await apis.db.addBlob(
           workspaceId,
           key,
           new Uint8Array(await value.arrayBuffer())
         );
+        return key;
       },
       delete: async (key: string) => {
-        return window.apis.db.deleteBlob(workspaceId, key);
+        return apis.db.deleteBlob(workspaceId, key);
       },
       list: async () => {
-        return window.apis.db.getPersistedBlobs(workspaceId);
+        return apis.db.getPersistedBlobs(workspaceId);
       },
     },
   };

packages/workspace/src/local/crud.ts

@@ -102,7 +102,7 @@ export const CRUD: WorkspaceCRUD<WorkspaceFlavour.LOCAL> = {
 
     // workspaces in desktop
     if (window.apis && environment.isDesktop) {
-      const desktopIds = await window.apis.workspace.list();
+      const desktopIds = (await window.apis.workspace.list()).map(([id]) => id);
       // the ids maybe a subset of the local storage
       const moreWorkspaces = desktopIds.filter(
         id => !allWorkspaceIDs.includes(id)

packages/workspace/src/providers/__tests__/sqlite-provider.spec.ts

@@ -21,7 +21,7 @@ const mockedAddBlob = vi.fn();
 vi.stubGlobal('window', {
   apis: {
     db: {
-      getDoc: async () => {
+      getDocAsUpdates: async () => {
         return Y.encodeStateAsUpdate(offlineYdoc);
       },
       applyDocUpdate: async (id: string, update: Uint8Array) => {
@@ -31,15 +31,24 @@ vi.stubGlobal('window', {
         // todo: may need to hack the way to get hash keys of blobs
         return [];
       },
-      onDBUpdate: (fn: (id: string) => void) => {
+      addBlob: mockedAddBlob,
+    } satisfies Partial<NonNullable<typeof window.apis>['db']>,
+  },
+  events: {
+    db: {
+      onDbFileUpdate: (fn: (id: string) => void) => {
         triggerDBUpdate = fn;
         return () => {
           triggerDBUpdate = null;
         };
       },
-      addBlob: mockedAddBlob,
-    } satisfies Partial<typeof window.apis.db>,
-  },
+
+      // not used in this test
+      onDbFileMissing: () => {
+        return () => {};
+      },
+    },
+  } satisfies Partial<NonNullable<typeof window.events>>,
 });
 
 vi.stubGlobal('environment', {

packages/workspace/src/providers/index.ts

@@ -162,18 +162,21 @@ const createSQLiteProvider = (
   blockSuiteWorkspace: BlockSuiteWorkspace
 ): SQLiteProvider => {
   const sqliteOrigin = Symbol('sqlite-provider-origin');
+  const apis = window.apis!;
+  const events = window.events!;
   // make sure it is being used in Electron with APIs
-  assertExists(environment.isDesktop && window.apis);
+  assertExists(apis);
+  assertExists(events);
 
   function handleUpdate(update: Uint8Array, origin: unknown) {
     if (origin === sqliteOrigin) {
       return;
     }
-    window.apis.db.applyDocUpdate(blockSuiteWorkspace.id, update);
+    apis.db.applyDocUpdate(blockSuiteWorkspace.id, update);
   }
 
   async function syncBlobIntoSQLite(bs: BlobManager) {
-    const persistedKeys = await window.apis.db.getPersistedBlobs(
+    const persistedKeys = await apis.db.getPersistedBlobs(
       blockSuiteWorkspace.id
     );
 
@@ -188,7 +191,7 @@ const createSQLiteProvider = (
           logger.warn('blob not found for', k);
           return;
         }
-        return window.apis.db.addBlob(
+        return window.apis?.db.addBlob(
           blockSuiteWorkspace.id,
           k,
           new Uint8Array(await blob.arrayBuffer())
@@ -199,7 +202,7 @@ const createSQLiteProvider = (
 
   async function syncUpdates() {
     logger.info('syncing updates from sqlite', blockSuiteWorkspace.id);
-    const updates = await window.apis.db.getDoc(blockSuiteWorkspace.id);
+    const updates = await apis.db.getDocAsUpdates(blockSuiteWorkspace.id);
 
     if (updates) {
       Y.applyUpdate(blockSuiteWorkspace.doc, updates, sqliteOrigin);
@@ -208,7 +211,7 @@ const createSQLiteProvider = (
     const mergeUpdates = Y.encodeStateAsUpdate(blockSuiteWorkspace.doc);
 
     // also apply updates to sqlite
-    window.apis.db.applyDocUpdate(blockSuiteWorkspace.id, mergeUpdates);
+    apis.db.applyDocUpdate(blockSuiteWorkspace.id, mergeUpdates);
 
     const bs = blockSuiteWorkspace.blobs;
 
@@ -240,7 +243,7 @@ const createSQLiteProvider = (
       blockSuiteWorkspace.doc.on('update', handleUpdate);
 
       let timer = 0;
-      unsubscribe = window.apis.db.onDBUpdate(workspaceId => {
+      unsubscribe = events.db.onDbFileUpdate(workspaceId => {
         if (workspaceId === blockSuiteWorkspace.id) {
           // throttle
           logger.debug('on db update', workspaceId);