@lobehub/chat 1.42.5 → 1.43.0

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();
-    });
-  });
 });

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

@@ -14,7 +14,6 @@ export interface UserAuthAction {
    * universal login method
    */
   openLogin: () => Promise<void>;
-  openUserProfile: () => Promise<void>;
 }
 
 export const createAuthSlice: StateCreator<
@@ -63,12 +62,4 @@ export const createAuthSlice: StateCreator<
       signIn();
     }
   },
-
-  openUserProfile: async () => {
-    if (enableClerk) {
-      get().clerkOpenUserProfile?.();
-
-      return;
-    }
-  },
 });

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

@@ -34,7 +34,7 @@ describe('createCommonSlice', () => {
   describe('updateAvatar', () => {
     it('should update avatar', async () => {
       const { result } = renderHook(() => useUserStore());
-      const avatar = 'new-avatar';
+      const avatar = 'data:image/png;base64,';
 
       const spyOn = vi.spyOn(result.current, 'refreshUserState');
       const updateAvatarSpy = vi
@@ -45,7 +45,7 @@ describe('createCommonSlice', () => {
         await result.current.updateAvatar(avatar);
       });
 
-      expect(updateAvatarSpy).toHaveBeenCalledWith(avatar);
+      expect(updateAvatarSpy).toHaveBeenCalledWith('data:image/png;base64,');
       expect(spyOn).toHaveBeenCalled();
     });
   });

package/src/types/message/index.ts

@@ -161,3 +161,8 @@ export interface SendThreadMessageParams {
   message: string;
   onlyAddUserMessage?: boolean;
 }
+
+export interface ModelRankItem {
+  count: number;
+  id: string | null;
+}

package/src/types/session/index.ts

@@ -15,3 +15,11 @@ export interface UpdateSessionParams {
   pinned?: boolean;
   updatedAt: Date;
 }
+
+export interface SessionRankItem {
+  avatar: string | null;
+  backgroundColor: string | null;
+  count: number;
+  id: string;
+  title: string | null;
+}

package/src/types/topic/topic.ts

@@ -44,3 +44,10 @@ export interface ChatTopic extends Omit<BaseDataModel, 'meta'> {
 }
 
 export type ChatTopicMap = Record<string, ChatTopic>;
+
+export interface TopicRankItem {
+  count: number;
+  id: string;
+  sessionId: string | null;
+  title: string | null;
+}

package/src/utils/format.ts

@@ -88,7 +88,7 @@ export const formatNumber = (num: any, fractionDigits?: number) => {
   return `${numeral(a).format('0,0')}.${b}`;
 };
 
-export const formatIntergerNumber = (num: any) => {
+export const formatIntergerNumber = (num?: any) => {
   if (!num && num !== 0) return '--';
 
   return numeral(num).format('0,0');

package/src/utils/time.ts

@@ -0,0 +1,23 @@
+import dayjs, { Dayjs } from 'dayjs';
+
+const getQuarterStart = (date: Dayjs) => {
+  const month = date.month();
+  const quarterStartMonth = Math.floor(month / 3) * 3;
+  return date.month(quarterStartMonth).startOf('month');
+};
+
+export const today = () => dayjs().startOf('day');
+export const thisWeek = () => dayjs().startOf('week');
+export const thisMonth = () => dayjs().startOf('month');
+export const thisQuarter = () => getQuarterStart(today());
+export const thisYear = () => dayjs().startOf('year');
+
+export const hoursAgo = (hours: number) => dayjs().subtract(hours, 'hours').startOf('hours');
+
+export const daysAgo = (days: number) => dayjs().subtract(days, 'days').startOf('day');
+
+export const weeksAgo = (weeks: number) => dayjs().subtract(weeks, 'week').startOf('week');
+
+export const monthsAgo = (months: number) => dayjs().subtract(months, 'month').startOf('month');
+
+export const lastMonth = () => monthsAgo(1).endOf('month');

package/src/app/(main)/profile/[[...slugs]]/Client.tsx

@@ -1,76 +0,0 @@
-'use client';
-
-import { UserProfile } from '@clerk/nextjs';
-import { ElementsConfig } from '@clerk/types';
-import { createStyles } from 'antd-style';
-import { memo } from 'react';
-
-export const useStyles = createStyles(
-  ({ css, token, cx }, mobile: boolean) =>
-    ({
-      cardBox: css`
-        width: 100%;
-        max-width: unset;
-        height: 100%;
-
-        border: unset;
-        border-radius: unset;
-        box-shadow: unset;
-      `,
-      footer: cx(
-        mobile &&
-          css`
-            display: none;
-          `,
-      ),
-      navbar: css`
-        flex: none;
-
-        width: 280px;
-        max-width: unset;
-        margin-inline-end: 0;
-        padding-block: 24px 16px;
-        padding-inline: 12px;
-
-        background: ${token.colorBgContainer};
-        border-inline-end: 1px solid ${token.colorSplit};
-      `,
-      navbarMobileMenuRow: cx(
-        mobile &&
-          css`
-            display: none;
-          `,
-      ),
-      pageScrollBox: css`
-        align-self: center;
-        width: 100%;
-        max-width: 1024px;
-      `,
-      rootBox: css`
-        width: 100%;
-        height: 100%;
-      `,
-      scrollBox: css`
-        background: ${token.colorBgLayout};
-        border: unset;
-        border-radius: unset;
-      `,
-    }) as Partial<{
-      // eslint-disable-next-line unused-imports/no-unused-vars
-      [k in keyof ElementsConfig]: any;
-    }>,
-);
-
-const Client = memo<{ mobile?: boolean }>(({ mobile }) => {
-  const { styles } = useStyles(mobile);
-
-  return (
-    <UserProfile
-      appearance={{
-        elements: styles,
-      }}
-    />
-  );
-});
-
-export default Client;