@lobehub/chat 1.42.6 → 1.43.0

package/src/locales/default/auth.ts

@@ -1,8 +1,80 @@
 export default {
+  date: {
+    prevMonth: '上个月',
+    recent30Days: '最近30天',
+  },
+  header: {
+    desc: '管理您的账户信息。',
+    title: '账户',
+  },
+  heatmaps: {
+    legend: {
+      less: '不活跃',
+      more: '活跃',
+    },
+    months: {
+      apr: '四月',
+      aug: '八月',
+      dec: '十二月',
+      feb: '二月',
+      jan: '一月',
+      jul: '七月',
+      jun: '六月',
+      mar: '三月',
+      may: '五月',
+      nov: '十一月',
+      oct: '十月',
+      sep: '九月',
+    },
+    tooltip: '{{date}} 当日发送 {{count}} 条消息',
+    totalCount: '过去一年共发送 {{count}} 条消息',
+  },
   login: '登录',
   loginOrSignup: '登录 / 注册',
-  profile: '个人资料',
-  security: '安全',
+  profile: {
+    avatar: '头像',
+    email: '电子邮件地址',
+    username: '用户名',
+  },
   signout: '退出登录',
   signup: '注册',
+  stats: {
+    aiheatmaps: 'AI 指数',
+    assistants: '助手数',
+    assistantsRank: {
+      left: '助手名称',
+      right: '话题数',
+      title: '助手使用率',
+    },
+    createdAt: '用户创建于',
+    days: '天',
+    empty: {
+      desc: '请积累更多聊天数据后查看',
+      title: '暂无数据',
+    },
+    lastYearActivity: '过去一年活跃度',
+    messages: '消息数',
+    modelsRank: {
+      left: '模型名称',
+      right: '消息数',
+      title: '模型使用率',
+    },
+    share: {
+      title: '我的 AI 活跃指数',
+    },
+    topics: '话题数',
+    topicsRank: {
+      left: '话题名称',
+      right: '消息数',
+      title: '话题内容量',
+    },
+    updatedAt: '数据更新至',
+    welcome: '{{username}}, 这是你和 {{appName}} 相伴的第 <span>{{days}}</span> 天',
+    words: '累计字数',
+  },
+  tab: {
+    profile: '个人资料',
+    security: '安全',
+    stats: '数据统计',
+  },
 };

package/src/server/ld.test.ts

@@ -29,7 +29,7 @@ describe('Ld', () => {
 
       expect(org['@type']).toBe('Organization');
       expect(org.name).toBe('LobeHub');
-      expect(org.url).toBe('https://lobehub.com/');
+      expect(org.url).toBe('https://lobehub.com');
     });
   });
 

package/src/server/modules/AssistantStore/index.ts

@@ -36,7 +36,7 @@ export class AssistantStore {
       }
 
       if (!res.ok) {
-        console.error('fetch agent index error:', await res.text());
+        console.warn('fetch agent index error:', await res.text());
         return [];
       }
 
@@ -55,7 +55,8 @@ export class AssistantStore {
 
       return data;
     } catch (e) {
-      console.error('fetch agent index error:', e);
+      console.error('[AgentIndexFetchError] failed to fetch agent index, error detail:');
+      console.error(e);
 
       throw e;
     }

package/src/server/routers/lambda/message.ts

@@ -27,12 +27,33 @@ export const messageRouter = router({
       return { added: data.rowCount as number, ids: [], skips: [], success: true };
     }),
 
-  count: messageProcedure.query(async ({ ctx }) => {
-    return ctx.messageModel.count();
-  }),
-  countToday: messageProcedure.query(async ({ ctx }) => {
-    return ctx.messageModel.countToday();
-  }),
+  count: messageProcedure
+    .input(
+      z
+        .object({
+          endDate: z.string().optional(),
+          range: z.tuple([z.string(), z.string()]).optional(),
+          startDate: z.string().optional(),
+        })
+        .optional(),
+    )
+    .query(async ({ ctx, input }) => {
+      return ctx.messageModel.count(input);
+    }),
+
+  countWords: messageProcedure
+    .input(
+      z
+        .object({
+          endDate: z.string().optional(),
+          range: z.tuple([z.string(), z.string()]).optional(),
+          startDate: z.string().optional(),
+        })
+        .optional(),
+    )
+    .query(async ({ ctx, input }) => {
+      return ctx.messageModel.countWords(input);
+    }),
 
   createMessage: messageProcedure
     .input(z.object({}).passthrough().partial())
@@ -56,6 +77,10 @@ export const messageRouter = router({
       return ctx.messageModel.queryBySessionId(input.sessionId);
     }),
 
+  getHeatmaps: messageProcedure.query(async ({ ctx }) => {
+    return ctx.messageModel.getHeatmaps();
+  }),
+
   // TODO: 未来这部分方法也需要使用 authedProcedure
   getMessages: publicProcedure
     .input(
@@ -74,6 +99,10 @@ export const messageRouter = router({
       return messageModel.query(input, { postProcessUrl: (path) => getFullFileUrl(path) });
     }),
 
+  rankModels: messageProcedure.query(async ({ ctx }) => {
+    return ctx.messageModel.rankModels();
+  }),
+
   removeAllMessages: messageProcedure.mutation(async ({ ctx }) => {
     return ctx.messageModel.deleteAllMessages();
   }),

package/src/server/routers/lambda/session.ts

@@ -57,9 +57,19 @@ export const sessionRouter = router({
       return data?.id;
     }),
 
-  countSessions: sessionProcedure.query(async ({ ctx }) => {
-    return ctx.sessionModel.count();
-  }),
+  countSessions: sessionProcedure
+    .input(
+      z
+        .object({
+          endDate: z.string().optional(),
+          range: z.tuple([z.string(), z.string()]).optional(),
+          startDate: z.string().optional(),
+        })
+        .optional(),
+    )
+    .query(async ({ ctx, input }) => {
+      return ctx.sessionModel.count(input);
+    }),
 
   createSession: sessionProcedure
     .input(
@@ -103,6 +113,10 @@ export const sessionRouter = router({
       return ctx.sessionModel.query({ current, pageSize });
     }),
 
+  rankSessions: sessionProcedure.input(z.number().optional()).query(async ({ ctx, input }) => {
+    return ctx.sessionModel.rank(input);
+  }),
+
   removeAllSessions: sessionProcedure.mutation(async ({ ctx }) => {
     return ctx.sessionModel.deleteAll();
   }),

package/src/server/routers/lambda/topic.ts

@@ -56,9 +56,19 @@ export const topicRouter = router({
       return data.topic.id;
     }),
 
-  countTopics: topicProcedure.query(async ({ ctx }) => {
-    return ctx.topicModel.count();
-  }),
+  countTopics: topicProcedure
+    .input(
+      z
+        .object({
+          endDate: z.string().optional(),
+          range: z.tuple([z.string(), z.string()]).optional(),
+          startDate: z.string().optional(),
+        })
+        .optional(),
+    )
+    .query(async ({ ctx, input }) => {
+      return ctx.topicModel.count(input);
+    }),
 
   createTopic: topicProcedure
     .input(
@@ -100,6 +110,10 @@ export const topicRouter = router({
     return (await ctx.topicModel.count()) === 0;
   }),
 
+  rankTopics: topicProcedure.input(z.number().optional()).query(async ({ ctx, input }) => {
+    return ctx.topicModel.rank(input);
+  }),
+
   removeAllTopics: topicProcedure.mutation(async ({ ctx }) => {
     return ctx.topicModel.deleteAll();
   }),

package/src/server/routers/lambda/user.ts

@@ -20,6 +20,10 @@ const userProcedure = authedProcedure.use(async (opts) => {
 });
 
 export const userRouter = router({
+  getUserRegistrationDuration: userProcedure.query(async ({ ctx }) => {
+    return ctx.userModel.getUserRegistrationDuration();
+  }),
+
   getUserState: userProcedure.query(async ({ ctx }): Promise<UserInitializationState> => {
     let state: Awaited<ReturnType<UserModel['getUserState']>> | undefined;
 

package/src/server/services/changelog/index.ts

@@ -54,7 +54,7 @@ export class ChangelogService {
       return this.mergeChangelogs(data.cloud, data.community).slice(0, 5);
     } catch (e) {
       const cause = (e as Error).cause as { code: string };
-      if (cause.code.includes('ETIMEDOUT')) {
+      if (cause?.code.includes('ETIMEDOUT')) {
         console.warn(
           '[ChangelogFetchTimeout] fail to fetch changelog lists due to network timeout. Please check your network connection.',
         );

package/src/services/message/_deprecated.ts

@@ -10,6 +10,7 @@ import {
   ChatTTS,
   ChatTranslate,
   CreateMessageParams,
+  ModelRankItem,
 } from '@/types/message';
 
 import { IMessageService } from './type';
@@ -56,6 +57,21 @@ export class ClientService implements IMessageService {
     return MessageModel.count();
   }
 
+  // @ts-ignore
+  async rankModels(): Promise<ModelRankItem[]> {
+    throw new Error('Method not implemented.');
+  }
+
+  // @ts-ignore
+  async countWords(): Promise<number> {
+    throw new Error('Method not implemented.');
+  }
+
+  // @ts-ignore
+  async getHeatmaps() {
+    throw new Error('Method not implemented.');
+  }
+
   async countTodayMessages() {
     const topics = await MessageModel.queryAll();
     return topics.filter(

package/src/services/message/client.test.ts

@@ -350,24 +350,6 @@ describe('MessageClientService', () => {
     });
   });
 
-  describe('countTodayMessages', () => {
-    it('should count the number of messages created today', async () => {
-      // Setup
-      const mockMessages = [
-        { ...mockMessage, id: undefined, createdAt: new Date(), userId },
-        { ...mockMessage, id: undefined, createdAt: new Date(), userId },
-        { ...mockMessage, id: undefined, createdAt: new Date('2023-01-01'), userId },
-      ];
-      await clientDB.insert(messages).values(mockMessages);
-
-      // Execute
-      const count = await messageService.countTodayMessages();
-
-      // Assert
-      expect(count).toBe(2);
-    });
-  });
-
   describe('updateMessageTTS', () => {
     it('should update the TTS field of a message', async () => {
       // Setup

package/src/services/message/client.ts

@@ -1,5 +1,3 @@
-import dayjs from 'dayjs';
-
 import { INBOX_SESSION_ID } from '@/const/session';
 import { clientDB } from '@/database/client/db';
 import { MessageModel } from '@/database/server/models/message';
@@ -52,15 +50,20 @@ export class ClientService extends BaseClientService implements IMessageService
     return data as unknown as ChatMessage[];
   };
 
-  countMessages: IMessageService['countMessages'] = async () => {
-    return this.messageModel.count();
+  countMessages: IMessageService['countMessages'] = async (params) => {
+    return this.messageModel.count(params);
+  };
+
+  countWords: IMessageService['countWords'] = async (params) => {
+    return this.messageModel.countWords(params);
+  };
+
+  rankModels: IMessageService['rankModels'] = async () => {
+    return this.messageModel.rankModels();
   };
 
-  countTodayMessages: IMessageService['countTodayMessages'] = async () => {
-    const topics = await this.messageModel.queryAll();
-    return topics.filter(
-      (item) => dayjs(item.createdAt).format('YYYY-MM-DD') === dayjs().format('YYYY-MM-DD'),
-    ).length;
+  getHeatmaps: IMessageService['getHeatmaps'] = async () => {
+    return this.messageModel.getHeatmaps();
   };
 
   getAllMessagesInSession: IMessageService['getAllMessagesInSession'] = async (sessionId) => {

package/src/services/message/server.ts

@@ -36,12 +36,20 @@ export class ServerService implements IMessageService {
     });
   };
 
-  countMessages: IMessageService['countMessages'] = async () => {
-    return lambdaClient.message.count.query();
+  countMessages: IMessageService['countMessages'] = async (params) => {
+    return lambdaClient.message.count.query(params);
   };
 
-  countTodayMessages: IMessageService['countTodayMessages'] = async () => {
-    return lambdaClient.message.countToday.query();
+  countWords: IMessageService['countWords'] = async (params) => {
+    return lambdaClient.message.countWords.query(params);
+  };
+
+  rankModels: IMessageService['rankModels'] = async () => {
+    return lambdaClient.message.rankModels.query();
+  };
+
+  getHeatmaps: IMessageService['getHeatmaps'] = async () => {
+    return lambdaClient.message.getHeatmaps.query();
   };
 
   updateMessageError: IMessageService['updateMessageError'] = async (id, error) => {

package/src/services/message/type.ts

@@ -1,3 +1,5 @@
+import type { HeatmapsProps } from '@lobehub/charts';
+
 import { MessageItem } from '@/database/schemas';
 import {
   ChatMessage,
@@ -5,6 +7,7 @@ import {
   ChatTTS,
   ChatTranslate,
   CreateMessageParams,
+  ModelRankItem,
 } from '@/types/message';
 
 /* eslint-disable typescript-sort-keys/interface */
@@ -16,9 +19,18 @@ export interface IMessageService {
   getMessages(sessionId: string, topicId?: string): Promise<ChatMessage[]>;
   getAllMessages(): Promise<ChatMessage[]>;
   getAllMessagesInSession(sessionId: string): Promise<ChatMessage[]>;
-  countMessages(): Promise<number>;
-  countTodayMessages(): Promise<number>;
-
+  countMessages(params?: {
+    endDate?: string;
+    range?: [string, string];
+    startDate?: string;
+  }): Promise<number>;
+  countWords(params?: {
+    endDate?: string;
+    range?: [string, string];
+    startDate?: string;
+  }): Promise<number>;
+  rankModels(): Promise<ModelRankItem[]>;
+  getHeatmaps(): Promise<HeatmapsProps['data']>;
   updateMessageError(id: string, error: ChatMessageError): Promise<any>;
   updateMessage(id: string, message: Partial<MessageItem>): Promise<any>;
   updateMessageTTS(id: string, tts: Partial<ChatTTS> | false): Promise<any>;

package/src/services/session/_deprecated.ts

@@ -82,6 +82,11 @@ export class ClientService implements ISessionService {
     return SessionModel.count();
   }
 
+  // @ts-ignore
+  async rankSessions() {
+    throw new Error('Method not implemented.');
+  }
+
   async hasSessions() {
     return (await this.countSessions()) !== 0;
   }

package/src/services/session/client.ts

@@ -74,8 +74,12 @@ export class ClientService extends BaseClientService implements ISessionService
     }
   };
 
-  countSessions: ISessionService['countSessions'] = async () => {
-    return this.sessionModel.count();
+  countSessions: ISessionService['countSessions'] = async (params) => {
+    return this.sessionModel.count(params);
+  };
+
+  rankSessions: ISessionService['rankSessions'] = async (limit) => {
+    return this.sessionModel.rank(limit);
   };
 
   searchSessions: ISessionService['searchSessions'] = async (keyword) => {

package/src/services/session/server.ts

@@ -36,8 +36,12 @@ export class ServerService implements ISessionService {
     return lambdaClient.session.getGroupedSessions.query();
   };
 
-  countSessions: ISessionService['countSessions'] = () => {
-    return lambdaClient.session.countSessions.query();
+  countSessions: ISessionService['countSessions'] = async (params) => {
+    return lambdaClient.session.countSessions.query(params);
+  };
+
+  rankSessions: ISessionService['rankSessions'] = async (limit) => {
+    return lambdaClient.session.rankSessions.query(limit);
   };
 
   updateSession: ISessionService['updateSession'] = (id, data) => {

package/src/services/session/type.ts

@@ -11,6 +11,7 @@ import {
   LobeSessions,
   SessionGroupItem,
   SessionGroups,
+  SessionRankItem,
   UpdateSessionParams,
 } from '@/types/session';
 
@@ -31,7 +32,12 @@ export interface ISessionService {
    * @deprecated
    */
   getSessionsByType(type?: 'agent' | 'group' | 'all'): Promise<LobeSessions>;
-  countSessions(): Promise<number>;
+  countSessions(params?: {
+    endDate?: string;
+    range?: [string, string];
+    startDate?: string;
+  }): Promise<number>;
+  rankSessions(limit?: number): Promise<SessionRankItem[]>;
   searchSessions(keyword: string): Promise<LobeSessions>;
 
   updateSession(id: string, data: Partial<UpdateSessionParams>): Promise<any>;

package/src/services/topic/_deprecated.ts

@@ -38,6 +38,11 @@ export class ClientService implements ITopicService {
     return TopicModel.count();
   }
 
+  // @ts-ignore
+  async rankTopics() {
+    throw new Error('Method not implemented.');
+  }
+
   async updateTopicFavorite(id: string, favorite?: boolean) {
     return this.updateTopic(id, { favorite });
   }

package/src/services/topic/client.ts

@@ -55,8 +55,12 @@ export class ClientService extends BaseClientService implements ITopicService {
     return data as unknown as Promise<ChatTopic[]>;
   };
 
-  countTopics: ITopicService['countTopics'] = async () => {
-    return this.topicModel.count();
+  countTopics: ITopicService['countTopics'] = async (params) => {
+    return this.topicModel.count(params);
+  };
+
+  rankTopics: ITopicService['rankTopics'] = async (limit) => {
+    return this.topicModel.rank(limit);
   };
 
   updateTopic: ITopicService['updateTopic'] = async (id, data) => {

package/src/services/topic/server.ts

@@ -24,7 +24,13 @@ export class ServerService implements ITopicService {
   getAllTopics: ITopicService['getAllTopics'] = () =>
     lambdaClient.topic.getAllTopics.query() as any;
 
-  countTopics: ITopicService['countTopics'] = async () => lambdaClient.topic.countTopics.query();
+  countTopics: ITopicService['countTopics'] = async (params) => {
+    return lambdaClient.topic.countTopics.query(params);
+  };
+
+  rankTopics: ITopicService['rankTopics'] = async (limit) => {
+    return lambdaClient.topic.rankTopics.query(limit);
+  };
 
   searchTopics: ITopicService['searchTopics'] = (keywords, sessionId) =>
     lambdaClient.topic.searchTopics.query({

package/src/services/topic/type.ts

@@ -1,6 +1,6 @@
 /* eslint-disable typescript-sort-keys/interface */
 import { BatchTaskResult } from '@/types/service';
-import { ChatTopic } from '@/types/topic';
+import { ChatTopic, TopicRankItem } from '@/types/topic';
 
 export interface CreateTopicParams {
   favorite?: boolean;
@@ -22,7 +22,12 @@ export interface ITopicService {
 
   getTopics(params: QueryTopicParams): Promise<ChatTopic[]>;
   getAllTopics(): Promise<ChatTopic[]>;
-  countTopics(): Promise<number>;
+  countTopics(params?: {
+    endDate?: string;
+    range?: [string, string];
+    startDate?: string;
+  }): Promise<number>;
+  rankTopics(limit?: number): Promise<TopicRankItem[]>;
   searchTopics(keyword: string, sessionId?: string): Promise<ChatTopic[]>;
 
   updateTopic(id: string, data: Partial<ChatTopic>): Promise<any>;

package/src/services/user/_deprecated.ts

@@ -16,6 +16,10 @@ export class ClientService implements IUserService {
     this.preferenceStorage = new AsyncLocalStorage('LOBE_PREFERENCE');
   }
 
+  getUserRegistrationDuration = async () => {
+    throw new Error('Method not implemented.');
+  };
+
   async getUserState(): Promise<UserInitializationState> {
     const user = await UserModel.getUser();
     const messageCount = await MessageModel.count();

package/src/services/user/client.ts

@@ -27,6 +27,10 @@ export class ClientService extends BaseClientService implements IUserService {
     this.preferenceStorage = new AsyncLocalStorage('LOBE_PREFERENCE');
   }
 
+  getUserRegistrationDuration: IUserService['getUserRegistrationDuration'] = async () => {
+    return this.userModel.getUserRegistrationDuration();
+  };
+
   getUserState: IUserService['getUserState'] = async () => {
     // if user not exist in the db, create one to make sure the user exist
     await this.makeSureUserExist();

package/src/services/user/server.ts

@@ -2,6 +2,10 @@ import { lambdaClient } from '@/libs/trpc/client';
 import { IUserService } from '@/services/user/type';
 
 export class ServerService implements IUserService {
+  getUserRegistrationDuration: IUserService['getUserRegistrationDuration'] = async () => {
+    return lambdaClient.user.getUserRegistrationDuration.query();
+  };
+
   getUserState: IUserService['getUserState'] = async () => {
     return lambdaClient.user.getUserState.query();
   };

package/src/services/user/type.ts

@@ -4,6 +4,11 @@ import { UserGuide, UserInitializationState, UserPreference } from '@/types/user
 import { UserSettings } from '@/types/user/settings';
 
 export interface IUserService {
+  getUserRegistrationDuration: () => Promise<{
+    createdAt: string;
+    duration: number;
+    updatedAt: string;
+  }>;
   getUserState: () => Promise<UserInitializationState>;
   resetUserSettings: () => Promise<any>;
   updateGuide: (guide: Partial<UserGuide>) => Promise<any>;

package/src/store/global/initialState.ts

@@ -31,6 +31,12 @@ export enum SettingsTabs {
   TTS = 'tts',
 }
 
+export enum ProfileTabs {
+  Profile = 'profile',
+  Security = 'security',
+  Stats = 'stats',
+}
+
 export interface SystemStatus {
   // which sessionGroup should expand
   expandSessionGroupKeys: string[];

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

@@ -1,11 +1,8 @@
-import { act, renderHook, waitFor } from '@testing-library/react';
+import { act, renderHook } from '@testing-library/react';
 import { mutate } from 'swr';
 import { afterEach, describe, expect, it, vi } from 'vitest';
-import { withSWR } from '~test-utils';
 
-import { userService } from '@/services/user';
 import { useUserStore } from '@/store/user';
-import { switchLang } from '@/utils/client/switchLang';
 
 vi.mock('zustand/traditional');
 
@@ -170,33 +167,4 @@ describe('createAuthSlice', () => {
       expect(signIn).not.toHaveBeenCalled();
     });
   });
-
-  describe('openUserProfile', () => {
-    it('should call clerkOpenUserProfile when Clerk is enabled', async () => {
-      enableClerk = true;
-
-      const clerkOpenUserProfileMock = vi.fn();
-      useUserStore.setState({ clerkOpenUserProfile: clerkOpenUserProfileMock });
-
-      const { result } = renderHook(() => useUserStore());
-
-      await act(async () => {
-        await result.current.openUserProfile();
-      });
-
-      expect(clerkOpenUserProfileMock).toHaveBeenCalled();
-    });
-    it('should not call clerkOpenUserProfile when Clerk is disabled', async () => {
-      const clerkOpenUserProfileMock = vi.fn();
-      useUserStore.setState({ clerkOpenUserProfile: clerkOpenUserProfileMock });
-
-      const { result } = renderHook(() => useUserStore());
-
-      await act(async () => {
-        await result.current.openUserProfile();
-      });
-
-      expect(clerkOpenUserProfileMock).not.toHaveBeenCalled();
-    });
-  });
 });