@lobehub/chat 0.148.8 → 0.148.10

package/src/store/session/slices/session/reducers.test.ts

@@ -0,0 +1,79 @@
+import { nanoid } from 'nanoid';
+import { describe, expect, it, vi } from 'vitest';
+
+import { LobeAgentConfig } from '@/types/agent';
+import { LobeAgentSession, LobeSessions } from '@/types/session';
+
+import { SessionDispatch, sessionsReducer } from './reducers';
+
+describe('sessionsReducer', () => {
+  const mockSession = {
+    id: nanoid(),
+    config: {
+      model: 'gpt-3.5-turbo',
+    } as any,
+    meta: {
+      title: 'Test Agent',
+      description: 'A test agent',
+      avatar: '',
+    },
+  } as any;
+
+  const initialState: LobeSessions = [];
+
+  it('should add a new session', () => {
+    const addAction: SessionDispatch = {
+      session: mockSession,
+      type: 'addSession',
+    };
+
+    const newState = sessionsReducer(initialState, addAction);
+
+    expect(newState).toHaveLength(1);
+    expect(newState[0]).toMatchObject({
+      ...mockSession,
+      createdAt: expect.any(Date),
+      updatedAt: expect.any(Date),
+    });
+  });
+
+  it('should remove an existing session', () => {
+    const state: LobeSessions = [mockSession];
+    const removeAction: SessionDispatch = {
+      id: mockSession.id,
+      type: 'removeSession',
+    };
+
+    const newState = sessionsReducer(state, removeAction);
+
+    expect(newState).toHaveLength(0);
+  });
+
+  it('should update an existing session', () => {
+    const state: LobeSessions = [mockSession];
+    const updateAction: SessionDispatch = {
+      id: mockSession.id,
+      type: 'updateSession',
+      value: { group: 'abc' },
+    };
+
+    const newState = sessionsReducer(state, updateAction);
+
+    expect(newState).toHaveLength(1);
+    expect(newState[0]).toMatchObject({
+      ...mockSession,
+      group: 'abc',
+      updatedAt: expect.any(Date),
+    });
+  });
+
+  it('should return the same state for unknown action', () => {
+    const state: LobeSessions = [mockSession];
+    // @ts-ignore
+    const unknownAction: SessionDispatch = { type: 'unknown' };
+
+    const newState = sessionsReducer(state, unknownAction);
+
+    expect(newState).toEqual(state);
+  });
+});

package/src/store/session/slices/session/reducers.ts

@@ -0,0 +1,61 @@
+import { produce } from 'immer';
+
+import { LobeAgentSession, LobeSessions } from '@/types/session';
+
+interface AddSession {
+  session: LobeAgentSession;
+  type: 'addSession';
+}
+
+interface RemoveSession {
+  id: string;
+  type: 'removeSession';
+}
+
+interface UpdateSession {
+  id: string;
+  type: 'updateSession';
+  value: Partial<LobeAgentSession>;
+}
+
+export type SessionDispatch = AddSession | RemoveSession | UpdateSession;
+
+export const sessionsReducer = (state: LobeSessions, payload: SessionDispatch): LobeSessions => {
+  switch (payload.type) {
+    case 'addSession': {
+      return produce(state, (draft) => {
+        const { session } = payload;
+        if (!session) return;
+
+        // TODO: 后续将 Date 类型做个迁移，就可以移除这里的 ignore 了
+        // @ts-ignore
+        draft.unshift({ ...session, createdAt: new Date(), updatedAt: new Date() });
+      });
+    }
+
+    case 'removeSession': {
+      return produce(state, (draftState) => {
+        const index = draftState.findIndex((item) => item.id === payload.id);
+        if (index !== -1) {
+          draftState.splice(index, 1);
+        }
+      });
+    }
+
+    case 'updateSession': {
+      return produce(state, (draftState) => {
+        const { value, id } = payload;
+        const index = draftState.findIndex((item) => item.id === id);
+
+        if (index !== -1) {
+          // @ts-ignore
+          draftState[index] = { ...draftState[index], ...value, updatedAt: new Date() };
+        }
+      });
+    }
+
+    default: {
+      return produce(state, () => {});
+    }
+  }
+};

package/src/store/session/slices/sessionGroup/action.test.ts

@@ -8,6 +8,15 @@ afterEach(() => {
   vi.restoreAllMocks();
 });
 
+vi.mock('@/components/AntdStaticMethods', () => ({
+  message: {
+    loading: vi.fn(),
+    success: vi.fn(),
+    error: vi.fn(),
+    destroy: vi.fn(),
+  },
+}));
+
 describe('createSessionGroupSlice', () => {
   describe('addSessionGroup', () => {
     it('should add a session group and refresh sessions', async () => {

package/src/store/session/slices/sessionGroup/action.ts

@@ -1,17 +1,23 @@
+import { t } from 'i18next';
 import { StateCreator } from 'zustand/vanilla';
 
+import { message } from '@/components/AntdStaticMethods';
 import { sessionService } from '@/services/session';
 import { SessionStore } from '@/store/session';
 import { SessionGroupItem } from '@/types/session';
 
+import { SessionGroupsDispatch, sessionGroupsReducer } from './reducer';
+
+/* eslint-disable typescript-sort-keys/interface */
 export interface SessionGroupAction {
   addSessionGroup: (name: string) => Promise<string>;
   clearSessionGroups: () => Promise<void>;
   removeSessionGroup: (id: string) => Promise<void>;
-  updateSessionGroupId: (sessionId: string, groupId: string) => Promise<void>;
   updateSessionGroupName: (id: string, name: string) => Promise<void>;
   updateSessionGroupSort: (items: SessionGroupItem[]) => Promise<void>;
+  internal_dispatchSessionGroups: (payload: SessionGroupsDispatch) => void;
 }
+/* eslint-enable */
 
 export const createSessionGroupSlice: StateCreator<
   SessionStore,
@@ -36,11 +42,6 @@ export const createSessionGroupSlice: StateCreator<
     await sessionService.removeSessionGroup(id);
     await get().refreshSessions();
   },
-  updateSessionGroupId: async (sessionId, group) => {
-    await sessionService.updateSession(sessionId, { group });
-
-    await get().refreshSessions();
-  },
 
   updateSessionGroupName: async (id, name) => {
     await sessionService.updateSessionGroup(id, { name });
@@ -48,7 +49,25 @@ export const createSessionGroupSlice: StateCreator<
   },
   updateSessionGroupSort: async (items) => {
     const sortMap = items.map((item, index) => ({ id: item.id, sort: index }));
+
+    get().internal_dispatchSessionGroups({ sortMap, type: 'updateSessionGroupOrder' });
+
+    message.loading({
+      content: t('sessionGroup.sorting', { ns: 'chat' }),
+      duration: 0,
+      key: 'updateSessionGroupSort',
+    });
+
     await sessionService.updateSessionGroupOrder(sortMap);
+    message.destroy('updateSessionGroupSort');
+    message.success(t('sessionGroup.sortSuccess', { ns: 'chat' }));
+
     await get().refreshSessions();
   },
+
+  /* eslint-disable sort-keys-fix/sort-keys-fix */
+  internal_dispatchSessionGroups: (payload) => {
+    const nextSessionGroups = sessionGroupsReducer(get().sessionGroups, payload);
+    get().internal_processSessions(get().sessions, nextSessionGroups, 'updateSessionGroups');
+  },
 });

package/src/store/session/slices/sessionGroup/reducer.test.ts

@@ -0,0 +1,86 @@
+import { nanoid } from 'nanoid';
+import { describe, expect, it } from 'vitest';
+
+import { SessionGroupItem } from '@/types/session';
+
+import { sessionGroupsReducer } from './reducer';
+
+describe('sessionGroupsReducer', () => {
+  const initialState: SessionGroupItem[] = [
+    {
+      id: nanoid(),
+      name: 'Group 1',
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    },
+    {
+      id: nanoid(),
+      name: 'Group 2',
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      sort: 1,
+    },
+  ];
+
+  it('should add a new session group item', () => {
+    const newItem: SessionGroupItem = {
+      id: nanoid(),
+      name: 'New Group',
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    };
+
+    const result = sessionGroupsReducer(initialState, {
+      type: 'addSessionGroupItem',
+      item: newItem,
+    });
+
+    expect(result).toHaveLength(3);
+    expect(result).toContainEqual(newItem);
+  });
+
+  it('should delete a session group item', () => {
+    const itemToDelete = initialState[0].id;
+
+    const result = sessionGroupsReducer(initialState, {
+      type: 'deleteSessionGroupItem',
+      id: itemToDelete,
+    });
+
+    expect(result).toHaveLength(1);
+    expect(result).not.toContainEqual(expect.objectContaining({ id: itemToDelete }));
+  });
+
+  it('should update a session group item', () => {
+    const itemToUpdate = initialState[0].id;
+    const updatedItem = { name: 'Updated Group' };
+
+    const result = sessionGroupsReducer(initialState, {
+      type: 'updateSessionGroupItem',
+      id: itemToUpdate,
+      item: updatedItem,
+    });
+
+    expect(result).toHaveLength(2);
+    expect(result).toContainEqual(expect.objectContaining({ id: itemToUpdate, ...updatedItem }));
+  });
+
+  it('should update session group order', () => {
+    const sortMap = [
+      { id: initialState[1].id, sort: 0 },
+      { id: initialState[0].id, sort: 1 },
+    ];
+
+    const result = sessionGroupsReducer(initialState, { type: 'updateSessionGroupOrder', sortMap });
+
+    expect(result).toHaveLength(2);
+    expect(result[0].id).toBe(initialState[1].id);
+    expect(result[1].id).toBe(initialState[0].id);
+  });
+
+  it('should return the initial state for unknown action', () => {
+    const result = sessionGroupsReducer(initialState, { type: 'unknown' } as any);
+
+    expect(result).toEqual(initialState);
+  });
+});

package/src/store/session/slices/sessionGroup/reducer.ts

@@ -0,0 +1,56 @@
+import { SessionGroupItem } from '@/types/session';
+
+export type AddSessionGroupAction = { item: SessionGroupItem; type: 'addSessionGroupItem' };
+export type DeleteSessionGroupAction = { id: string; type: 'deleteSessionGroupItem' };
+export type UpdateSessionGroupAction = {
+  id: string;
+  item: Partial<SessionGroupItem>;
+  type: 'updateSessionGroupItem';
+};
+export type UpdateSessionGroupOrderAction = {
+  sortMap: { id: string; sort?: number }[];
+  type: 'updateSessionGroupOrder';
+};
+
+export type SessionGroupsDispatch =
+  | AddSessionGroupAction
+  | DeleteSessionGroupAction
+  | UpdateSessionGroupAction
+  | UpdateSessionGroupOrderAction;
+
+export const sessionGroupsReducer = (
+  state: SessionGroupItem[],
+  payload: SessionGroupsDispatch,
+): SessionGroupItem[] => {
+  switch (payload.type) {
+    case 'addSessionGroupItem': {
+      return [...state, payload.item];
+    }
+
+    case 'deleteSessionGroupItem': {
+      return state.filter((item) => item.id !== payload.id);
+    }
+
+    case 'updateSessionGroupItem': {
+      return state.map((item) => {
+        if (item.id === payload.id) {
+          return { ...item, ...payload.item };
+        }
+        return item;
+      });
+    }
+
+    case 'updateSessionGroupOrder': {
+      return state
+        .map((item) => {
+          const sort = payload.sortMap.find((i) => i.id === item.id)?.sort;
+          return { ...item, sort };
+        })
+        .sort((a, b) => (a.sort || 0) - (b.sort || 0));
+    }
+
+    default: {
+      return state;
+    }
+  }
+};

package/src/store/session/slices/sessionGroup/selectors.ts

@@ -1,10 +1,6 @@
 import { SessionStore } from '@/store/session';
 
-const sessionGroupItems = (s: SessionStore) =>
-  s.customSessionGroups.map((group) => ({
-    id: group.id,
-    name: group.name,
-  }));
+const sessionGroupItems = (s: SessionStore) => s.sessionGroups;
 
 const getGroupById = (id: string) => (s: SessionStore) =>
   sessionGroupItems(s).find((group) => group.id === id);

package/src/types/service.ts

@@ -0,0 +1,7 @@
+export interface BatchTaskResult {
+  added: number;
+  errors?: Error[];
+  ids: string[];
+  skips: string[];
+  success: boolean;
+}

package/src/types/session.ts

@@ -44,15 +44,13 @@ export interface LobeAgentSettings {
 
 export type LobeSessions = LobeAgentSession[];
 
-export interface CustomSessionGroup {
+export interface CustomSessionGroup extends SessionGroupItem {
   children: LobeSessions;
-  id: SessionGroupId;
-  name: string;
 }
 
+export type LobeSessionGroups = SessionGroupItem[];
+
 export interface ChatSessionList {
-  all: LobeSessions;
-  customGroup: CustomSessionGroup[];
-  default: LobeSessions;
-  pinned: LobeSessions;
+  sessionGroups: LobeSessionGroups;
+  sessions: LobeSessions;
 }

package/src/utils/uuid.ts

@@ -1,9 +1,9 @@
 // generate('1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', 16); //=> "4f90d13a42"
 import { customAlphabet } from 'nanoid/non-secure';
 
-export const nanoid = customAlphabet(
-  '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
-  8,
-);
+export const createNanoId = (size = 8) =>
+  customAlphabet('1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', size);
+
+export const nanoid = createNanoId();
 
 export { v4 as uuid } from 'uuid';