refactor: new provider (#4900)

packages/frontend/core/src/hooks/current/use-current-sync-engine.ts

@@ -0,0 +1,33 @@
+import type { SyncEngine, SyncEngineStatus } from '@affine/workspace/providers';
+import { useEffect, useState } from 'react';
+
+import { useCurrentWorkspace } from './use-current-workspace';
+
+export function useCurrentSyncEngine(): SyncEngine | undefined {
+  const [workspace] = useCurrentWorkspace();
+  // FIXME: This is a hack to get the sync engine, we need refactor this in the future.
+  const syncEngine = (
+    workspace.blockSuiteWorkspace.providers[0] as { engine?: SyncEngine }
+  )?.engine;
+
+  return syncEngine;
+}
+
+export function useCurrentSyncEngineStatus(): SyncEngineStatus | undefined {
+  const syncEngine = useCurrentSyncEngine();
+  const [status, setStatus] = useState<SyncEngineStatus>();
+
+  useEffect(() => {
+    if (syncEngine) {
+      setStatus(syncEngine.status);
+      return syncEngine.onStatusChange.on(status => {
+        setStatus(status);
+      }).dispose;
+    } else {
+      setStatus(undefined);
+    }
+    return;
+  }, [syncEngine]);
+
+  return status;
+}

packages/frontend/core/src/hooks/use-datasource-sync.ts

@@ -1,91 +0,0 @@
-import { pushNotificationAtom } from '@affine/component/notification-center';
-import type {
-  AffineSocketIOProvider,
-  LocalIndexedDBBackgroundProvider,
-  SQLiteProvider,
-} from '@affine/env/workspace';
-import { assertExists } from '@blocksuite/global/utils';
-import type { Workspace } from '@blocksuite/store';
-import { useSetAtom } from 'jotai';
-import { startTransition, useCallback, useMemo, useState } from 'react';
-import { type Status, syncDataSource } from 'y-provider';
-
-export function useDatasourceSync(workspace: Workspace) {
-  const [status, setStatus] = useState<Status>({
-    type: 'idle',
-  });
-  const pushNotification = useSetAtom(pushNotificationAtom);
-  const providers = workspace.providers;
-  const remoteProvider: AffineSocketIOProvider | undefined = useMemo(() => {
-    return providers.find(
-      (provider): provider is AffineSocketIOProvider =>
-        provider.flavour === 'affine-socket-io'
-    );
-  }, [providers]);
-  const localProvider = useMemo(() => {
-    const sqliteProvider = providers.find(
-      (provider): provider is SQLiteProvider => provider.flavour === 'sqlite'
-    );
-    const indexedDbProvider = providers.find(
-      (provider): provider is LocalIndexedDBBackgroundProvider =>
-        provider.flavour === 'local-indexeddb-background'
-    );
-    const provider = sqliteProvider || indexedDbProvider;
-    assertExists(provider, 'no local provider');
-    return provider;
-  }, [providers]);
-  return [
-    status,
-    useCallback(() => {
-      if (!remoteProvider) {
-        return;
-      }
-      startTransition(() => {
-        setStatus({
-          type: 'syncing',
-        });
-      });
-      syncDataSource(
-        () => [
-          workspace.doc.guid,
-          ...[...workspace.doc.subdocs].map(doc => doc.guid),
-        ],
-        remoteProvider.datasource,
-        localProvider.datasource
-      )
-        .then(async () => {
-          // by default, the syncing status will show for 2.4s
-          setTimeout(() => {
-            startTransition(() => {
-              setStatus({
-                type: 'synced',
-              });
-              pushNotification({
-                title: 'Synced successfully',
-                type: 'success',
-              });
-            });
-          }, 2400);
-        })
-        .catch(error => {
-          startTransition(() => {
-            setStatus({
-              type: 'error',
-              error,
-            });
-            pushNotification({
-              title: 'Unable to Sync',
-              message: 'Server error, please try again later.',
-              type: 'error',
-            });
-          });
-        });
-    }, [
-      remoteProvider,
-      localProvider.datasource,
-      workspace.doc.guid,
-      workspace.doc.subdocs,
-      pushNotification,
-    ]),
-  ] as const;
-}