@lobehub/chat 1.119.2 → 1.120.1

package/src/services/__tests__/sync.test.ts

@@ -1,56 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { dataSync } from '@/database/_deprecated/core';
-import { StartDataSyncParams } from '@/types/sync';
-
-import { syncService } from '../sync';
-
-vi.mock('@/database/_deprecated/core', () => ({
-  dataSync: {
-    startDataSync: vi.fn(),
-    disconnect: vi.fn(),
-  },
-}));
-
-describe('SyncService', () => {
-  afterEach(() => {
-    vi.resetAllMocks();
-  });
-
-  describe('enabledSync', () => {
-    it('should return false when running on server side', async () => {
-      const params = { user: { id: '123' }, authToken: 'abc' } as unknown as StartDataSyncParams;
-
-      const origin = global.window;
-
-      // @ts-ignore
-      global.window = undefined;
-
-      const result = await syncService.enabledSync(params);
-
-      expect(result).toBe(false);
-      expect(dataSync.startDataSync).not.toHaveBeenCalled();
-
-      // reset
-      global.window = origin;
-    });
-
-    it('should start data sync and return true when running on client side', async () => {
-      const params = { user: { id: '123' }, authToken: 'abc' } as unknown as StartDataSyncParams;
-
-      const result = await syncService.enabledSync(params);
-
-      expect(result).toBe(true);
-      expect(dataSync.startDataSync).toHaveBeenCalledWith(params);
-    });
-  });
-
-  describe('disableSync', () => {
-    it('should disconnect data sync and return false', async () => {
-      const result = await syncService.disableSync();
-
-      expect(result).toBe(false);
-      expect(dataSync.disconnect).toHaveBeenCalled();
-    });
-  });
-});

package/src/services/sync.ts

@@ -1,19 +0,0 @@
-import { dataSync } from '@/database/_deprecated/core';
-import { StartDataSyncParams } from '@/types/sync';
-
-class SyncService {
-  enabledSync = async (params: StartDataSyncParams) => {
-    if (typeof window === 'undefined') return false;
-
-    await dataSync.startDataSync(params);
-    return true;
-  };
-
-  disableSync = async () => {
-    await dataSync.disconnect();
-
-    return false;
-  };
-}
-
-export const syncService = new SyncService();

package/src/store/user/slices/sync/action.test.ts

@@ -1,164 +0,0 @@
-import { act, renderHook, waitFor } from '@testing-library/react';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { withSWR } from '~test-utils';
-
-import { syncService } from '@/services/sync';
-import { useUserStore } from '@/store/user';
-import { userProfileSelectors } from '@/store/user/selectors';
-import { syncSettingsSelectors } from '@/store/user/selectors';
-
-vi.mock('zustand/traditional');
-
-vi.mock('swr', async (importOriginal) => {
-  const modules = await importOriginal();
-  return {
-    ...(modules as any),
-    mutate: vi.fn(),
-  };
-});
-
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-describe('createSyncSlice', () => {
-  describe('refreshConnection', () => {
-    it('should not call triggerEnableSync when userId is empty', async () => {
-      const { result } = renderHook(() => useUserStore());
-      const onEvent = vi.fn();
-
-      vi.spyOn(userProfileSelectors, 'userId').mockReturnValueOnce(undefined as any);
-      const triggerEnableSyncSpy = vi.spyOn(result.current, 'triggerEnableSync');
-
-      await act(async () => {
-        await result.current.refreshConnection(onEvent);
-      });
-
-      expect(triggerEnableSyncSpy).not.toHaveBeenCalled();
-    });
-
-    it('should call triggerEnableSync when userId exists', async () => {
-      const { result } = renderHook(() => useUserStore());
-      const onEvent = vi.fn();
-      const userId = 'user-id';
-
-      vi.spyOn(userProfileSelectors, 'userId').mockReturnValueOnce(userId);
-      const triggerEnableSyncSpy = vi.spyOn(result.current, 'triggerEnableSync');
-
-      await act(async () => {
-        await result.current.refreshConnection(onEvent);
-      });
-
-      expect(triggerEnableSyncSpy).toHaveBeenCalledWith(userId, onEvent);
-    });
-  });
-
-  describe('triggerEnableSync', () => {
-    it('should return false when sync.channelName is empty', async () => {
-      const { result } = renderHook(() => useUserStore());
-      const userId = 'user-id';
-      const onEvent = vi.fn();
-
-      vi.spyOn(syncSettingsSelectors, 'webrtcConfig').mockReturnValueOnce({
-        channelName: '',
-        enabled: true,
-      });
-
-      const data = await act(async () => {
-        return result.current.triggerEnableSync(userId, onEvent);
-      });
-
-      expect(data).toBe(false);
-    });
-
-    it('should call globalService.enabledSync when sync.channelName exists', async () => {
-      const userId = 'user-id';
-      const onEvent = vi.fn();
-      const channelName = 'channel-name';
-      const channelPassword = 'channel-password';
-      const deviceName = 'device-name';
-      const signaling = 'signaling';
-
-      vi.spyOn(syncSettingsSelectors, 'webrtcConfig').mockReturnValueOnce({
-        channelName,
-        channelPassword,
-        signaling,
-        enabled: true,
-      });
-      vi.spyOn(syncSettingsSelectors, 'deviceName').mockReturnValueOnce(deviceName);
-      const enabledSyncSpy = vi.spyOn(syncService, 'enabledSync').mockResolvedValueOnce(true);
-      const { result } = renderHook(() => useUserStore());
-
-      const data = await act(async () => {
-        return result.current.triggerEnableSync(userId, onEvent);
-      });
-
-      expect(enabledSyncSpy).toHaveBeenCalledWith({
-        channel: { name: channelName, password: channelPassword },
-        onAwarenessChange: expect.any(Function),
-        onSyncEvent: onEvent,
-        onSyncStatusChange: expect.any(Function),
-        signaling,
-        user: expect.objectContaining({ id: userId, name: deviceName }),
-      });
-      expect(data).toBe(true);
-    });
-  });
-
-  describe('useEnabledSync', () => {
-    it('should return false when userId is empty', async () => {
-      const { result } = renderHook(
-        () =>
-          useUserStore().useEnabledSync(true, {
-            userEnableSync: true,
-            userId: undefined,
-            onEvent: vi.fn(),
-          }),
-        {
-          wrapper: withSWR,
-        },
-      );
-
-      await waitFor(() => expect(result.current.data).toBe(false));
-    });
-
-    it('should call syncService.disableSync when userEnableSync is false', async () => {
-      const disableSyncSpy = vi.spyOn(syncService, 'disableSync').mockResolvedValueOnce(false);
-
-      const { result } = renderHook(
-        () =>
-          useUserStore().useEnabledSync(true, {
-            userEnableSync: false,
-            userId: 'user-id',
-            onEvent: vi.fn(),
-          }),
-
-        { wrapper: withSWR },
-      );
-
-      await waitFor(() => expect(result.current.data).toBeUndefined());
-      expect(disableSyncSpy).toHaveBeenCalled();
-    });
-
-    it('should call triggerEnableSync when userEnableSync and userId exist', async () => {
-      const userId = 'user-id';
-      const onEvent = vi.fn();
-      const triggerEnableSyncSpy = vi.fn().mockResolvedValueOnce(true);
-
-      const { result } = renderHook(() => useUserStore());
-
-      // replace triggerEnableSync as a mock
-      result.current.triggerEnableSync = triggerEnableSyncSpy;
-
-      const { result: swrResult } = renderHook(
-        () => result.current.useEnabledSync(true, { userEnableSync: true, userId, onEvent }),
-        {
-          wrapper: withSWR,
-        },
-      );
-
-      await waitFor(() => expect(swrResult.current.data).toBe(true));
-      expect(triggerEnableSyncSpy).toHaveBeenCalledWith(userId, onEvent);
-    });
-  });
-});

package/src/store/user/slices/sync/action.ts

@@ -1,101 +0,0 @@
-import useSWR, { SWRResponse } from 'swr';
-import type { StateCreator } from 'zustand/vanilla';
-
-import type { UserStore } from '@/store/user';
-import { OnSyncEvent, PeerSyncStatus } from '@/types/sync';
-import { browserInfo } from '@/utils/platform';
-import { setNamespace } from '@/utils/storeDebug';
-
-import { userProfileSelectors } from '../auth/selectors';
-import { syncSettingsSelectors } from './selectors';
-
-const n = setNamespace('sync');
-
-/**
- * 设置操作
- */
-export interface SyncAction {
-  refreshConnection: (onEvent: OnSyncEvent) => Promise<void>;
-  triggerEnableSync: (userId: string, onEvent: OnSyncEvent) => Promise<boolean>;
-  useEnabledSync: (
-    systemEnable: boolean | undefined,
-    params: {
-      onEvent: OnSyncEvent;
-      userEnableSync: boolean;
-      userId: string | undefined;
-    },
-  ) => SWRResponse;
-}
-
-export const createSyncSlice: StateCreator<
-  UserStore,
-  [['zustand/devtools', never]],
-  [],
-  SyncAction
-> = (set, get) => ({
-  refreshConnection: async (onEvent) => {
-    const userId = userProfileSelectors.userId(get());
-
-    if (!userId) return;
-
-    await get().triggerEnableSync(userId, onEvent);
-  },
-
-  triggerEnableSync: async (userId: string, onEvent: OnSyncEvent) => {
-    // double-check the sync ability
-    // if there is no channelName, don't start sync
-    const sync = syncSettingsSelectors.webrtcConfig(get());
-    if (!sync.channelName || !sync.signaling) return false;
-
-    const name = syncSettingsSelectors.deviceName(get());
-
-    const defaultUserName = `My ${browserInfo.browser} (${browserInfo.os})`;
-
-    set({ syncStatus: PeerSyncStatus.Connecting });
-    const { syncService } = await import('@/services/sync');
-
-    return syncService.enabledSync({
-      channel: {
-        name: sync.channelName,
-        password: sync.channelPassword,
-      },
-      onAwarenessChange(state) {
-        set({ syncAwareness: state });
-      },
-      onSyncEvent: onEvent,
-      onSyncStatusChange: (status) => {
-        set({ syncStatus: status });
-      },
-      signaling: sync.signaling,
-      user: {
-        id: userId,
-        // if user don't set the name, use default name
-        name: name || defaultUserName,
-        ...browserInfo,
-      },
-    });
-  },
-
-  useEnabledSync: (systemEnable, { userEnableSync, userId, onEvent }) =>
-    useSWR<boolean>(
-      systemEnable ? ['enableSync', userEnableSync, userId] : null,
-      async () => {
-        // if user don't enable sync or no userId ,don't start sync
-        if (!userId) return false;
-
-        // if user don't enable sync, stop sync
-        if (!userEnableSync) {
-          const { syncService } = await import('@/services/sync');
-          return syncService.disableSync();
-        }
-
-        return get().triggerEnableSync(userId, onEvent);
-      },
-      {
-        onSuccess: (syncEnabled) => {
-          set({ syncEnabled }, false, n('useEnabledSync'));
-        },
-        revalidateOnFocus: false,
-      },
-    ),
-});

package/src/store/user/slices/sync/initialState.ts

@@ -1,13 +0,0 @@
-import { PeerSyncStatus, SyncAwarenessState } from '@/types/sync';
-
-export interface UserSyncState {
-  syncAwareness: SyncAwarenessState[];
-  syncEnabled: boolean;
-  syncStatus: PeerSyncStatus;
-}
-
-export const initialSyncState: UserSyncState = {
-  syncAwareness: [],
-  syncEnabled: false,
-  syncStatus: PeerSyncStatus.Disabled,
-};

package/src/store/user/slices/sync/selectors.ts

@@ -1,20 +0,0 @@
-import { DEFAULT_SYNC_CONFIG } from '@/const/settings/sync';
-import { UserSyncSettings } from '@/types/user/settings';
-
-import type { UserStore } from '../../store';
-import { currentSettings } from '../settings/selectors/settings';
-
-const syncConfig = (s: UserStore): UserSyncSettings =>
-  currentSettings(s).sync || DEFAULT_SYNC_CONFIG;
-
-const webrtcConfig = (s: UserStore) => syncConfig(s).webrtc;
-const webrtcChannelName = (s: UserStore) => webrtcConfig(s).channelName;
-const enableWebRTC = (s: UserStore) => webrtcConfig(s).enabled;
-const deviceName = (s: UserStore) => syncConfig(s).deviceName;
-
-export const syncSettingsSelectors = {
-  deviceName,
-  enableWebRTC,
-  webrtcChannelName,
-  webrtcConfig,
-};