@lobehub/lobehub 2.0.0-next.249 → 2.0.0-next.250

package/src/store/file/slices/resource/syncEngine.ts

@@ -0,0 +1,326 @@
+import { debounce } from 'es-toolkit';
+import type { DebouncedFunc } from 'es-toolkit/compat';
+import pMap from 'p-map';
+
+import { resourceService } from '@/services/resource';
+import type { ResourceItem, SyncOperation } from '@/types/resource';
+
+/**
+ * Sync configuration
+ */
+const SYNC_CONFIG = {
+  BACKOFF_MULTIPLIER: 2,
+  BATCH_SIZE: 10,
+  CONCURRENCY: 3,
+  DEBOUNCE_MS: 300, // Wait after last operation
+  MAX_RETRIES: 3,
+  MAX_WAIT_MS: 2000, // Force sync after 2s
+  RETRY_DELAY_MS: 1000,
+} as const;
+
+/**
+ * State getter/setter interface
+ */
+interface StateManager {
+  getState: () => {
+    resourceList: ResourceItem[];
+    resourceMap: Map<string, ResourceItem>;
+    syncQueue: SyncOperation[];
+    syncingIds: Set<string>;
+  };
+  setState: (partial: {
+    resourceList?: ResourceItem[];
+    resourceMap?: Map<string, ResourceItem>;
+    syncQueue?: SyncOperation[];
+    syncingIds?: Set<string>;
+  }) => void;
+}
+
+/**
+ * ResourceSyncEngine - Background sync engine for resource operations
+ *
+ * Features:
+ * - Debounced sync (300ms, max 2s)
+ * - Batch processing (10 operations per batch)
+ * - Concurrency control (3 parallel requests)
+ * - Retry logic with exponential backoff (3 attempts)
+ * - Error state marking (no rollback)
+ */
+export class ResourceSyncEngine {
+  private debouncedSync: DebouncedFunc<() => Promise<void>>;
+  private stateManager: StateManager;
+
+  constructor(getState: StateManager['getState'], setState: StateManager['setState']) {
+    this.stateManager = { getState, setState };
+
+    this.debouncedSync = debounce(() => this.processQueue(), SYNC_CONFIG.DEBOUNCE_MS, {
+      edges: ['trailing'],
+    }) as DebouncedFunc<() => Promise<void>>;
+
+    // Add maxWait behavior manually since es-toolkit debounce doesn't support it
+    let lastExecution = 0;
+    const originalSync = this.debouncedSync;
+
+    this.debouncedSync = (() => {
+      const now = Date.now();
+      if (now - lastExecution >= SYNC_CONFIG.MAX_WAIT_MS) {
+        lastExecution = now;
+        originalSync.flush?.();
+        return originalSync();
+      } else {
+        return originalSync();
+      }
+    }) as unknown as DebouncedFunc<() => Promise<void>>;
+
+    this.debouncedSync.flush = originalSync.flush;
+    this.debouncedSync.cancel = originalSync.cancel;
+  }
+
+  /**
+   * Enqueue a sync operation and return a Promise that resolves when it completes
+   * For 'create' operations, resolves with the real resource ID
+   * For other operations, resolves with void
+   */
+  enqueue(operation: Omit<SyncOperation, 'resolve' | 'reject'>): Promise<any> {
+    return new Promise((resolve, reject) => {
+      const { syncQueue } = this.stateManager.getState();
+      const operationWithPromise: SyncOperation = {
+        ...operation,
+        reject,
+        resolve,
+      };
+
+      this.stateManager.setState({
+        syncQueue: [...syncQueue, operationWithPromise],
+      });
+
+      // Trigger debounced sync
+      this.debouncedSync();
+    });
+  }
+
+  /**
+   * Flush pending operations immediately
+   */
+  async flush(): Promise<void> {
+    this.debouncedSync.flush?.();
+    await this.processQueue();
+  }
+
+  /**
+   * Process the sync queue
+   */
+  private async processQueue(): Promise<void> {
+    const { syncQueue } = this.stateManager.getState();
+
+    if (syncQueue.length === 0) return;
+
+    // Take batch from queue
+    const batch = syncQueue.slice(0, SYNC_CONFIG.BATCH_SIZE);
+    const remaining = syncQueue.slice(SYNC_CONFIG.BATCH_SIZE);
+
+    // Update queue (remove batch)
+    this.stateManager.setState({ syncQueue: remaining });
+
+    // Process batch with concurrency limit
+    await pMap(
+      batch,
+      async (operation) => {
+        try {
+          await this.processOperation(operation);
+        } catch (error) {
+          await this.handleOperationError(operation, error as Error);
+        }
+      },
+      { concurrency: SYNC_CONFIG.CONCURRENCY },
+    );
+
+    // Continue processing if there are more operations
+    if (remaining.length > 0) {
+      await this.processQueue();
+    }
+  }
+
+  /**
+   * Process a single sync operation
+   */
+  private async processOperation(operation: SyncOperation): Promise<void> {
+    const { resourceId, type, payload } = operation;
+
+    // Mark as syncing
+    const { syncingIds } = this.stateManager.getState();
+    syncingIds.add(resourceId);
+    this.stateManager.setState({ syncingIds: new Set(syncingIds) });
+
+    try {
+      let realId: string | undefined;
+
+      switch (type) {
+        case 'create': {
+          const created = await resourceService.createResource(payload);
+          this.replaceTempResource(resourceId, created);
+          realId = created.id;
+          break;
+        }
+
+        case 'update': {
+          const updated = await resourceService.updateResource(resourceId, payload);
+          this.updateResourceInStore(updated);
+          break;
+        }
+
+        case 'delete': {
+          await resourceService.deleteResource(resourceId);
+          // Resource already removed from store optimistically
+          break;
+        }
+
+        case 'move': {
+          await resourceService.moveResource(resourceId, payload.parentId);
+          // Don't update store - resource has already been removed optimistically
+          // and should stay removed since it moved to a different location
+          break;
+        }
+      }
+
+      // Clear optimistic state on success
+      this.clearOptimisticState(resourceId);
+
+      // Resolve promise for this operation (return real ID for create)
+      operation.resolve?.(realId);
+    } finally {
+      // Unmark as syncing
+      const { syncingIds: currentSyncingIds } = this.stateManager.getState();
+      currentSyncingIds.delete(resourceId);
+      this.stateManager.setState({ syncingIds: new Set(currentSyncingIds) });
+    }
+  }
+
+  /**
+   * Handle operation error
+   */
+  private async handleOperationError(operation: SyncOperation, error: Error): Promise<void> {
+    const { resourceId, retryCount } = operation;
+
+    if (retryCount < SYNC_CONFIG.MAX_RETRIES) {
+      // Retry: increment count and re-queue with delay
+      const delay = SYNC_CONFIG.RETRY_DELAY_MS * SYNC_CONFIG.BACKOFF_MULTIPLIER ** retryCount;
+
+      setTimeout(() => {
+        const { syncQueue } = this.stateManager.getState();
+        this.stateManager.setState({
+          syncQueue: [
+            ...syncQueue,
+            {
+              ...operation,
+              retryCount: retryCount + 1,
+            },
+          ],
+        });
+        this.debouncedSync();
+      }, delay);
+    } else {
+      // Max retries reached: mark resource with error state and reject promise
+      this.markResourceError(resourceId, error);
+      operation.reject?.(error);
+    }
+  }
+
+  /**
+   * Replace temp resource with real resource from server
+   */
+  private replaceTempResource(tempId: string, realResource: ResourceItem): void {
+    const { resourceMap, resourceList } = this.stateManager.getState();
+
+    // Remove temp from map, add real
+    resourceMap.delete(tempId);
+    resourceMap.set(realResource.id, realResource);
+
+    // Replace in list
+    const listIndex = resourceList.findIndex((r) => r.id === tempId);
+    if (listIndex >= 0) {
+      resourceList[listIndex] = realResource;
+    }
+
+    this.stateManager.setState({
+      resourceList: [...resourceList],
+      resourceMap: new Map(resourceMap),
+    });
+  }
+
+  /**
+   * Update resource in store with fresh data from server
+   */
+  private updateResourceInStore(resource: ResourceItem): void {
+    const { resourceMap, resourceList } = this.stateManager.getState();
+
+    resourceMap.set(resource.id, resource);
+
+    const listIndex = resourceList.findIndex((r) => r.id === resource.id);
+    if (listIndex >= 0) {
+      resourceList[listIndex] = resource;
+    }
+
+    this.stateManager.setState({
+      resourceList: [...resourceList],
+      resourceMap: new Map(resourceMap),
+    });
+  }
+
+  /**
+   * Clear optimistic state from resource
+   */
+  private clearOptimisticState(resourceId: string): void {
+    const { resourceMap, resourceList } = this.stateManager.getState();
+    const resource = resourceMap.get(resourceId);
+
+    if (resource?._optimistic) {
+      const updated = { ...resource };
+      delete updated._optimistic;
+
+      resourceMap.set(resourceId, updated);
+
+      const listIndex = resourceList.findIndex((r) => r.id === resourceId);
+      if (listIndex >= 0) {
+        resourceList[listIndex] = updated;
+      }
+
+      this.stateManager.setState({
+        resourceList: [...resourceList],
+        resourceMap: new Map(resourceMap),
+      });
+    }
+  }
+
+  /**
+   * Mark resource with error state
+   */
+  private markResourceError(resourceId: string, error: Error): void {
+    const { resourceMap, resourceList } = this.stateManager.getState();
+    const resource = resourceMap.get(resourceId);
+
+    if (resource) {
+      const updated = {
+        ...resource,
+        _optimistic: {
+          error,
+          isPending: false,
+          lastSyncAttempt: new Date(),
+          retryCount: SYNC_CONFIG.MAX_RETRIES,
+        },
+      };
+
+      resourceMap.set(resourceId, updated);
+
+      const listIndex = resourceList.findIndex((r) => r.id === resourceId);
+      if (listIndex >= 0) {
+        resourceList[listIndex] = updated;
+      }
+
+      this.stateManager.setState({
+        resourceList: [...resourceList],
+        resourceMap: new Map(resourceMap),
+      });
+    }
+  }
+}

package/src/store/file/store.ts

@@ -8,6 +8,8 @@ import { type FileAction, createFileSlice } from './slices/chat';
 import { type FileChunkAction, createFileChunkSlice } from './slices/chunk';
 import { type DocumentAction, createDocumentSlice } from './slices/document';
 import { type FileManageAction, createFileManageSlice } from './slices/fileManager';
+import { type ResourceAction, createResourceSlice } from './slices/resource/action';
+import { type ResourceState } from './slices/resource/initialState';
 import { type TTSFileAction, createTTSFileSlice } from './slices/tts';
 import { type FileUploadAction, createFileUploadSlice } from './slices/upload/action';
 
@@ -19,7 +21,9 @@ export type FileStore = FilesStoreState &
   TTSFileAction &
   FileManageAction &
   FileChunkAction &
-  FileUploadAction;
+  FileUploadAction &
+  ResourceAction &
+  ResourceState;
 
 const createStore: StateCreator<FileStore, [['zustand/devtools', never]]> = (...parameters) => ({
   ...initialState,
@@ -29,6 +33,7 @@ const createStore: StateCreator<FileStore, [['zustand/devtools', never]]> = (...
   ...createTTSFileSlice(...parameters),
   ...createFileChunkSlice(...parameters),
   ...createFileUploadSlice(...parameters),
+  ...createResourceSlice(...parameters),
 });
 
 //  ===============  Implement useStore ============ //

package/src/store/{knowledgeBase → library}/initialState.ts

@@ -1,5 +1,5 @@
-import { type KnowledgeBaseState, initialKnowledgeBaseState } from '../knowledgeBase/slices/crud';
-import { type RAGEvalState, initialDatasetState } from '../knowledgeBase/slices/ragEval';
+import { type KnowledgeBaseState, initialKnowledgeBaseState } from '../library/slices/crud';
+import { type RAGEvalState, initialDatasetState } from '../library/slices/ragEval';
 
 export type KnowledgeBaseStoreState = KnowledgeBaseState & RAGEvalState;
 

package/src/store/{knowledgeBase → library}/slices/content/action.test.ts

@@ -2,7 +2,7 @@ import { act, renderHook } from '@testing-library/react';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { knowledgeBaseService } from '@/services/knowledgeBase';
-import { useFileStore } from '@/store/file';
+import * as resourceHooks from '@/store/file/slices/resource/hooks';
 
 import { useKnowledgeBaseStore as useStore } from '../../store';
 
@@ -47,10 +47,9 @@ describe('KnowledgeBaseContentActions', () => {
           },
         ]);
 
-      const refreshFileListSpy = vi.fn().mockResolvedValue(undefined);
-      vi.spyOn(useFileStore, 'getState').mockReturnValue({
-        refreshFileList: refreshFileListSpy,
-      } as any);
+      const revalidateResourcesSpy = vi
+        .spyOn(resourceHooks, 'revalidateResources')
+        .mockResolvedValue(undefined);
 
       await act(async () => {
         await result.current.addFilesToKnowledgeBase(knowledgeBaseId, fileIds);
@@ -58,8 +57,8 @@ describe('KnowledgeBaseContentActions', () => {
 
       expect(addFilesSpy).toHaveBeenCalledWith(knowledgeBaseId, fileIds);
       expect(addFilesSpy).toHaveBeenCalledTimes(1);
-      expect(refreshFileListSpy).toHaveBeenCalled();
-      expect(refreshFileListSpy).toHaveBeenCalledTimes(1);
+      expect(revalidateResourcesSpy).toHaveBeenCalled();
+      expect(revalidateResourcesSpy).toHaveBeenCalledTimes(1);
     });
 
     it('should handle single file addition', async () => {
@@ -79,17 +78,16 @@ describe('KnowledgeBaseContentActions', () => {
           },
         ]);
 
-      const refreshFileListSpy = vi.fn().mockResolvedValue(undefined);
-      vi.spyOn(useFileStore, 'getState').mockReturnValue({
-        refreshFileList: refreshFileListSpy,
-      } as any);
+      const revalidateResourcesSpy = vi
+        .spyOn(resourceHooks, 'revalidateResources')
+        .mockResolvedValue(undefined);
 
       await act(async () => {
         await result.current.addFilesToKnowledgeBase(knowledgeBaseId, fileIds);
       });
 
       expect(addFilesSpy).toHaveBeenCalledWith(knowledgeBaseId, fileIds);
-      expect(refreshFileListSpy).toHaveBeenCalled();
+      expect(revalidateResourcesSpy).toHaveBeenCalled();
     });
 
     it('should handle empty file array', async () => {
@@ -102,17 +100,16 @@ describe('KnowledgeBaseContentActions', () => {
         .spyOn(knowledgeBaseService, 'addFilesToKnowledgeBase')
         .mockResolvedValue([]);
 
-      const refreshFileListSpy = vi.fn().mockResolvedValue(undefined);
-      vi.spyOn(useFileStore, 'getState').mockReturnValue({
-        refreshFileList: refreshFileListSpy,
-      } as any);
+      const revalidateResourcesSpy = vi
+        .spyOn(resourceHooks, 'revalidateResources')
+        .mockResolvedValue(undefined);
 
       await act(async () => {
         await result.current.addFilesToKnowledgeBase(knowledgeBaseId, fileIds);
       });
 
       expect(addFilesSpy).toHaveBeenCalledWith(knowledgeBaseId, fileIds);
-      expect(refreshFileListSpy).toHaveBeenCalled();
+      expect(revalidateResourcesSpy).toHaveBeenCalled();
     });
 
     describe('error handling', () => {
@@ -125,10 +122,9 @@ describe('KnowledgeBaseContentActions', () => {
 
         vi.spyOn(knowledgeBaseService, 'addFilesToKnowledgeBase').mockRejectedValue(serviceError);
 
-        const refreshFileListSpy = vi.fn().mockResolvedValue(undefined);
-        vi.spyOn(useFileStore, 'getState').mockReturnValue({
-          refreshFileList: refreshFileListSpy,
-        } as any);
+        const revalidateResourcesSpy = vi
+          .spyOn(resourceHooks, 'revalidateResources')
+          .mockResolvedValue(undefined);
 
         await expect(async () => {
           await act(async () => {
@@ -136,7 +132,7 @@ describe('KnowledgeBaseContentActions', () => {
           });
         }).rejects.toThrow('Failed to add files to knowledge base');
 
-        expect(refreshFileListSpy).not.toHaveBeenCalled();
+        expect(revalidateResourcesSpy).not.toHaveBeenCalled();
       });
 
       it('should handle refresh file list errors', async () => {
@@ -155,10 +151,7 @@ describe('KnowledgeBaseContentActions', () => {
           },
         ]);
 
-        const refreshFileListSpy = vi.fn().mockRejectedValue(refreshError);
-        vi.spyOn(useFileStore, 'getState').mockReturnValue({
-          refreshFileList: refreshFileListSpy,
-        } as any);
+        vi.spyOn(resourceHooks, 'revalidateResources').mockRejectedValue(refreshError);
 
         await expect(async () => {
           await act(async () => {
@@ -180,10 +173,9 @@ describe('KnowledgeBaseContentActions', () => {
         .spyOn(knowledgeBaseService, 'removeFilesFromKnowledgeBase')
         .mockResolvedValue({} as any);
 
-      const refreshFileListSpy = vi.fn().mockResolvedValue(undefined);
-      vi.spyOn(useFileStore, 'getState').mockReturnValue({
-        refreshFileList: refreshFileListSpy,
-      } as any);
+      const revalidateResourcesSpy = vi
+        .spyOn(resourceHooks, 'revalidateResources')
+        .mockResolvedValue(undefined);
 
       await act(async () => {
         await result.current.removeFilesFromKnowledgeBase(knowledgeBaseId, fileIds);
@@ -191,8 +183,8 @@ describe('KnowledgeBaseContentActions', () => {
 
       expect(removeFilesSpy).toHaveBeenCalledWith(knowledgeBaseId, fileIds);
       expect(removeFilesSpy).toHaveBeenCalledTimes(1);
-      expect(refreshFileListSpy).toHaveBeenCalled();
-      expect(refreshFileListSpy).toHaveBeenCalledTimes(1);
+      expect(revalidateResourcesSpy).toHaveBeenCalled();
+      expect(revalidateResourcesSpy).toHaveBeenCalledTimes(1);
     });
 
     it('should handle single file removal', async () => {
@@ -205,17 +197,16 @@ describe('KnowledgeBaseContentActions', () => {
         .spyOn(knowledgeBaseService, 'removeFilesFromKnowledgeBase')
         .mockResolvedValue({} as any);
 
-      const refreshFileListSpy = vi.fn().mockResolvedValue(undefined);
-      vi.spyOn(useFileStore, 'getState').mockReturnValue({
-        refreshFileList: refreshFileListSpy,
-      } as any);
+      const revalidateResourcesSpy = vi
+        .spyOn(resourceHooks, 'revalidateResources')
+        .mockResolvedValue(undefined);
 
       await act(async () => {
         await result.current.removeFilesFromKnowledgeBase(knowledgeBaseId, fileIds);
       });
 
       expect(removeFilesSpy).toHaveBeenCalledWith(knowledgeBaseId, fileIds);
-      expect(refreshFileListSpy).toHaveBeenCalled();
+      expect(revalidateResourcesSpy).toHaveBeenCalled();
     });
 
     it('should handle empty file array', async () => {
@@ -228,17 +219,16 @@ describe('KnowledgeBaseContentActions', () => {
         .spyOn(knowledgeBaseService, 'removeFilesFromKnowledgeBase')
         .mockResolvedValue({} as any);
 
-      const refreshFileListSpy = vi.fn().mockResolvedValue(undefined);
-      vi.spyOn(useFileStore, 'getState').mockReturnValue({
-        refreshFileList: refreshFileListSpy,
-      } as any);
+      const revalidateResourcesSpy = vi
+        .spyOn(resourceHooks, 'revalidateResources')
+        .mockResolvedValue(undefined);
 
       await act(async () => {
         await result.current.removeFilesFromKnowledgeBase(knowledgeBaseId, fileIds);
       });
 
       expect(removeFilesSpy).toHaveBeenCalledWith(knowledgeBaseId, fileIds);
-      expect(refreshFileListSpy).toHaveBeenCalled();
+      expect(revalidateResourcesSpy).toHaveBeenCalled();
     });
 
     describe('error handling', () => {
@@ -253,10 +243,9 @@ describe('KnowledgeBaseContentActions', () => {
           serviceError,
         );
 
-        const refreshFileListSpy = vi.fn().mockResolvedValue(undefined);
-        vi.spyOn(useFileStore, 'getState').mockReturnValue({
-          refreshFileList: refreshFileListSpy,
-        } as any);
+        const revalidateResourcesSpy = vi
+          .spyOn(resourceHooks, 'revalidateResources')
+          .mockResolvedValue(undefined);
 
         await expect(async () => {
           await act(async () => {
@@ -264,7 +253,7 @@ describe('KnowledgeBaseContentActions', () => {
           });
         }).rejects.toThrow('Failed to remove files from knowledge base');
 
-        expect(refreshFileListSpy).not.toHaveBeenCalled();
+        expect(revalidateResourcesSpy).not.toHaveBeenCalled();
       });
 
       it('should handle refresh file list errors', async () => {
@@ -276,10 +265,7 @@ describe('KnowledgeBaseContentActions', () => {
 
         vi.spyOn(knowledgeBaseService, 'removeFilesFromKnowledgeBase').mockResolvedValue({} as any);
 
-        const refreshFileListSpy = vi.fn().mockRejectedValue(refreshError);
-        vi.spyOn(useFileStore, 'getState').mockReturnValue({
-          refreshFileList: refreshFileListSpy,
-        } as any);
+        vi.spyOn(resourceHooks, 'revalidateResources').mockRejectedValue(refreshError);
 
         await expect(async () => {
           await act(async () => {

package/src/store/{knowledgeBase → library}/slices/content/action.ts

@@ -1,8 +1,8 @@
 import { type StateCreator } from 'zustand/vanilla';
 
 import { knowledgeBaseService } from '@/services/knowledgeBase';
-import { useFileStore } from '@/store/file';
-import { type KnowledgeBaseStore } from '@/store/knowledgeBase/store';
+import { revalidateResources } from '@/store/file/slices/resource/hooks';
+import { type KnowledgeBaseStore } from '@/store/library/store';
 
 export interface KnowledgeBaseContentAction {
   addFilesToKnowledgeBase: (knowledgeBaseId: string, ids: string[]) => Promise<void>;
@@ -17,11 +17,15 @@ export const createContentSlice: StateCreator<
 > = () => ({
   addFilesToKnowledgeBase: async (knowledgeBaseId, ids) => {
     await knowledgeBaseService.addFilesToKnowledgeBase(knowledgeBaseId, ids);
-    await useFileStore.getState().refreshFileList();
+
+    // Revalidate resource list to show updated KB associations
+    await revalidateResources();
   },
 
   removeFilesFromKnowledgeBase: async (knowledgeBaseId, ids) => {
     await knowledgeBaseService.removeFilesFromKnowledgeBase(knowledgeBaseId, ids);
-    await useFileStore.getState().refreshFileList();
+
+    // Revalidate resource list to show updated KB associations
+    await revalidateResources();
   },
 });

package/src/store/{knowledgeBase → library}/slices/crud/action.ts

@@ -3,7 +3,7 @@ import { type StateCreator } from 'zustand/vanilla';
 
 import { mutate, useClientDataSWR } from '@/libs/swr';
 import { knowledgeBaseService } from '@/services/knowledgeBase';
-import { type KnowledgeBaseStore } from '@/store/knowledgeBase/store';
+import { type KnowledgeBaseStore } from '@/store/library/store';
 import { type CreateKnowledgeBaseParams, type KnowledgeBaseItem } from '@/types/knowledgeBase';
 
 const FETCH_KNOWLEDGE_BASE_LIST_KEY = 'FETCH_KNOWLEDGE_BASE';

package/src/store/{knowledgeBase → library}/slices/crud/selectors.ts

@@ -1,4 +1,4 @@
-import { type KnowledgeBaseStoreState } from '@/store/knowledgeBase/initialState';
+import { type KnowledgeBaseStoreState } from '@/store/library/initialState';
 
 const activeKnowledgeBaseId = (s: KnowledgeBaseStoreState) => s.activeKnowledgeBaseId;
 

package/src/store/{knowledgeBase → library}/slices/ragEval/actions/dataset.ts

@@ -11,7 +11,7 @@ import { type StateCreator } from 'zustand/vanilla';
 import { notification } from '@/components/AntdStaticMethods';
 import { mutate, useClientDataSWR } from '@/libs/swr';
 import { ragEvalService } from '@/services/ragEval';
-import { type KnowledgeBaseStore } from '@/store/knowledgeBase/store';
+import { type KnowledgeBaseStore } from '@/store/library/store';
 
 const FETCH_DATASET_LIST_KEY = 'FETCH_DATASET_LIST';
 const FETCH_DATASET_RECORD_KEY = 'FETCH_DATASET_RECORD_KEY';

package/src/store/{knowledgeBase → library}/slices/ragEval/actions/evaluation.ts

@@ -4,7 +4,7 @@ import { type StateCreator } from 'zustand/vanilla';
 
 import { mutate, useClientDataSWR } from '@/libs/swr';
 import { ragEvalService } from '@/services/ragEval';
-import { type KnowledgeBaseStore } from '@/store/knowledgeBase/store';
+import { type KnowledgeBaseStore } from '@/store/library/store';
 
 const FETCH_EVALUATION_LIST_KEY = 'FETCH_EVALUATION_LIST_KEY';
 

package/src/store/{knowledgeBase → library}/slices/ragEval/actions/index.ts

@@ -1,6 +1,6 @@
 import { type StateCreator } from 'zustand/vanilla';
 
-import { type KnowledgeBaseStore } from '@/store/knowledgeBase/store';
+import { type KnowledgeBaseStore } from '@/store/library/store';
 
 import { type RAGEvalDatasetAction, createRagEvalDatasetSlice } from './dataset';
 import { type RAGEvalEvaluationAction, createRagEvalEvaluationSlice } from './evaluation';