@lobehub/chat 1.39.3 → 1.40.1

package/src/services/topic/client.ts

@@ -4,14 +4,14 @@ import { TopicModel } from '@/database/server/models/topic';
 import { BaseClientService } from '@/services/baseClientService';
 import { ChatTopic } from '@/types/topic';
 
-import { CreateTopicParams, ITopicService, QueryTopicParams } from './type';
+import { ITopicService } from './type';
 
 export class ClientService extends BaseClientService implements ITopicService {
   private get topicModel(): TopicModel {
     return new TopicModel(clientDB as any, this.userId);
   }
 
-  async createTopic(params: CreateTopicParams): Promise<string> {
+  createTopic: ITopicService['createTopic'] = async (params) => {
     const item = await this.topicModel.create({
       ...params,
       sessionId: this.toDbSessionId(params.sessionId),
@@ -22,62 +22,62 @@ export class ClientService extends BaseClientService implements ITopicService {
     }
 
     return item.id;
-  }
+  };
 
-  async batchCreateTopics(importTopics: ChatTopic[]) {
+  batchCreateTopics: ITopicService['batchCreateTopics'] = async (importTopics) => {
     const data = await this.topicModel.batchCreate(importTopics as any);
 
     return { added: data.length, ids: [], skips: [], success: true };
-  }
+  };
 
-  async cloneTopic(id: string, newTitle?: string) {
+  cloneTopic: ITopicService['cloneTopic'] = async (id, newTitle) => {
     const data = await this.topicModel.duplicate(id, newTitle);
     return data.topic.id;
-  }
+  };
 
-  async getTopics(params: QueryTopicParams) {
+  getTopics: ITopicService['getTopics'] = async (params) => {
     const data = await this.topicModel.query({
       ...params,
       sessionId: this.toDbSessionId(params.sessionId),
     });
     return data as unknown as Promise<ChatTopic[]>;
-  }
+  };
 
-  async searchTopics(keyword: string, sessionId?: string) {
+  searchTopics: ITopicService['searchTopics'] = async (keyword, sessionId) => {
     const data = await this.topicModel.queryByKeyword(keyword, this.toDbSessionId(sessionId));
 
     return data as unknown as Promise<ChatTopic[]>;
-  }
+  };
 
-  async getAllTopics() {
+  getAllTopics: ITopicService['getAllTopics'] = async () => {
     const data = await this.topicModel.queryAll();
 
     return data as unknown as Promise<ChatTopic[]>;
-  }
+  };
 
-  async countTopics() {
+  countTopics: ITopicService['countTopics'] = async () => {
     return this.topicModel.count();
-  }
+  };
 
-  async updateTopic(id: string, data: Partial<ChatTopic>) {
+  updateTopic: ITopicService['updateTopic'] = async (id, data) => {
     return this.topicModel.update(id, data as any);
-  }
+  };
 
-  async removeTopic(id: string) {
+  removeTopic: ITopicService['removeTopic'] = async (id) => {
     return this.topicModel.delete(id);
-  }
+  };
 
-  async removeTopics(sessionId: string) {
+  removeTopics: ITopicService['removeTopics'] = async (sessionId) => {
     return this.topicModel.batchDeleteBySessionId(this.toDbSessionId(sessionId));
-  }
+  };
 
-  async batchRemoveTopics(topics: string[]) {
+  batchRemoveTopics: ITopicService['batchRemoveTopics'] = async (topics) => {
     return this.topicModel.batchDelete(topics);
-  }
+  };
 
-  async removeAllTopic() {
+  removeAllTopic: ITopicService['removeAllTopic'] = async () => {
     return this.topicModel.deleteAll();
-  }
+  };
 
   private toDbSessionId(sessionId?: string | null) {
     return sessionId === INBOX_SESSION_ID ? null : sessionId;

package/src/services/topic/server.ts

@@ -1,68 +1,51 @@
 import { INBOX_SESSION_ID } from '@/const/session';
 import { lambdaClient } from '@/libs/trpc/client';
-import { CreateTopicParams, ITopicService, QueryTopicParams } from '@/services/topic/type';
-import { BatchTaskResult } from '@/types/service';
-import { ChatTopic } from '@/types/topic';
+import { ITopicService } from '@/services/topic/type';
 
 export class ServerService implements ITopicService {
-  createTopic(params: CreateTopicParams): Promise<string> {
-    return lambdaClient.topic.createTopic.mutate({
+  createTopic: ITopicService['createTopic'] = (params) =>
+    lambdaClient.topic.createTopic.mutate({
       ...params,
       sessionId: this.toDbSessionId(params.sessionId),
     });
-  }
 
-  batchCreateTopics(importTopics: ChatTopic[]): Promise<BatchTaskResult> {
-    return lambdaClient.topic.batchCreateTopics.mutate(importTopics);
-  }
+  batchCreateTopics: ITopicService['batchCreateTopics'] = (importTopics) =>
+    lambdaClient.topic.batchCreateTopics.mutate(importTopics);
 
-  cloneTopic(id: string, newTitle?: string | undefined): Promise<string> {
-    return lambdaClient.topic.cloneTopic.mutate({ id, newTitle });
-  }
+  cloneTopic: ITopicService['cloneTopic'] = (id, newTitle) =>
+    lambdaClient.topic.cloneTopic.mutate({ id, newTitle });
 
-  getTopics(params: QueryTopicParams): Promise<ChatTopic[]> {
-    return lambdaClient.topic.getTopics.query({
+  getTopics: ITopicService['getTopics'] = (params) =>
+    lambdaClient.topic.getTopics.query({
       ...params,
       sessionId: this.toDbSessionId(params.sessionId),
     }) as any;
-  }
 
-  getAllTopics(): Promise<ChatTopic[]> {
-    return lambdaClient.topic.getAllTopics.query() as any;
-  }
+  getAllTopics: ITopicService['getAllTopics'] = () =>
+    lambdaClient.topic.getAllTopics.query() as any;
 
-  async countTopics() {
-    return lambdaClient.topic.countTopics.query();
-  }
+  countTopics: ITopicService['countTopics'] = async () => lambdaClient.topic.countTopics.query();
 
-  searchTopics(keywords: string, sessionId?: string | undefined): Promise<ChatTopic[]> {
-    return lambdaClient.topic.searchTopics.query({
+  searchTopics: ITopicService['searchTopics'] = (keywords, sessionId) =>
+    lambdaClient.topic.searchTopics.query({
       keywords,
       sessionId: this.toDbSessionId(sessionId),
     }) as any;
-  }
 
-  updateTopic(id: string, data: Partial<ChatTopic>): Promise<any> {
-    return lambdaClient.topic.updateTopic.mutate({ id, value: data });
-  }
+  updateTopic: ITopicService['updateTopic'] = (id, data) =>
+    lambdaClient.topic.updateTopic.mutate({ id, value: data });
 
-  removeTopic(id: string): Promise<any> {
-    return lambdaClient.topic.removeTopic.mutate({ id });
-  }
+  removeTopic: ITopicService['removeTopic'] = (id) => lambdaClient.topic.removeTopic.mutate({ id });
 
-  removeTopics(sessionId: string): Promise<any> {
-    return lambdaClient.topic.batchDeleteBySessionId.mutate({ id: this.toDbSessionId(sessionId) });
-  }
+  removeTopics: ITopicService['removeTopics'] = (sessionId) =>
+    lambdaClient.topic.batchDeleteBySessionId.mutate({ id: this.toDbSessionId(sessionId) });
 
-  batchRemoveTopics(topics: string[]): Promise<any> {
-    return lambdaClient.topic.batchDelete.mutate({ ids: topics });
-  }
+  batchRemoveTopics: ITopicService['batchRemoveTopics'] = (topics) =>
+    lambdaClient.topic.batchDelete.mutate({ ids: topics });
 
-  removeAllTopic(): Promise<any> {
-    return lambdaClient.topic.removeAllTopics.mutate();
-  }
+  removeAllTopic: ITopicService['removeAllTopic'] = () =>
+    lambdaClient.topic.removeAllTopics.mutate();
 
-  private toDbSessionId(sessionId?: string | null) {
-    return sessionId === INBOX_SESSION_ID ? null : sessionId;
-  }
+  private toDbSessionId = (sessionId?: string | null) =>
+    sessionId === INBOX_SESSION_ID ? null : sessionId;
 }

package/src/services/trace.ts

@@ -4,7 +4,7 @@ import { preferenceSelectors } from '@/store/user/selectors';
 import { TraceEventBasePayload, TraceEventPayloads } from '@/types/trace';
 
 class TraceService {
-  private async request<T>(data: T) {
+  private request = async <T>(data: T) => {
     try {
       return fetch(API_ENDPOINTS.trace, {
         body: JSON.stringify(data),
@@ -14,15 +14,15 @@ class TraceService {
     } catch (e) {
       console.error(e);
     }
-  }
+  };
 
-  async traceEvent(data: TraceEventPayloads & TraceEventBasePayload) {
+  traceEvent = async (data: TraceEventPayloads & TraceEventBasePayload) => {
     const enabled = preferenceSelectors.userAllowTrace(useUserStore.getState());
 
     if (!enabled) return;
 
     return this.request(data);
-  }
+  };
 }
 
 export const traceService = new TraceService();

package/src/services/user/client.ts

@@ -1,13 +1,10 @@
-import { DeepPartial } from 'utility-types';
-
 import { clientDB } from '@/database/client/db';
 import { users } from '@/database/schemas';
 import { MessageModel } from '@/database/server/models/message';
 import { SessionModel } from '@/database/server/models/session';
 import { UserModel } from '@/database/server/models/user';
 import { BaseClientService } from '@/services/baseClientService';
-import { UserGuide, UserInitializationState, UserPreference } from '@/types/user';
-import { UserSettings } from '@/types/user/settings';
+import { UserPreference } from '@/types/user';
 import { AsyncLocalStorage } from '@/utils/localStorage';
 
 import { IUserService } from './type';
@@ -30,7 +27,7 @@ export class ClientService extends BaseClientService implements IUserService {
     this.preferenceStorage = new AsyncLocalStorage('LOBE_PREFERENCE');
   }
 
-  async getUserState(): Promise<UserInitializationState> {
+  getUserState: IUserService['getUserState'] = async () => {
     // if user not exist in the db, create one to make sure the user exist
     await this.makeSureUserExist();
 
@@ -51,32 +48,31 @@ export class ClientService extends BaseClientService implements IUserService {
       isOnboard: true,
       preference: await this.preferenceStorage.getFromLocalStorage(),
     };
-  }
+  };
 
-  updateUserSettings = async (value: DeepPartial<UserSettings>) => {
+  updateUserSettings: IUserService['updateUserSettings'] = async (value) => {
     const { keyVaults, ...res } = value;
 
     return this.userModel.updateSetting({ ...res, keyVaults: JSON.stringify(keyVaults) });
   };
 
-  resetUserSettings = async () => {
+  resetUserSettings: IUserService['resetUserSettings'] = async () => {
     return this.userModel.deleteSetting();
   };
 
-  async updateAvatar(avatar: string) {
+  updateAvatar = async (avatar: string) => {
     await this.userModel.updateUser({ avatar });
-  }
+  };
 
-  async updatePreference(preference: Partial<UserPreference>) {
+  updatePreference: IUserService['updatePreference'] = async (preference) => {
     await this.preferenceStorage.saveToLocalStorage(preference);
-  }
+  };
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars,unused-imports/no-unused-vars
-  async updateGuide(guide: Partial<UserGuide>) {
+  updateGuide: IUserService['updateGuide'] = async () => {
     throw new Error('Method not implemented.');
-  }
+  };
 
-  async makeSureUserExist() {
+  makeSureUserExist = async () => {
     const existUsers = await clientDB.query.users.findMany();
 
     let user: { id: string };
@@ -88,5 +84,5 @@ export class ClientService extends BaseClientService implements IUserService {
     }
 
     return user;
-  }
+  };
 }

package/src/services/user/server.ts

@@ -1,32 +1,28 @@
-import { DeepPartial } from 'utility-types';
-
 import { lambdaClient } from '@/libs/trpc/client';
 import { IUserService } from '@/services/user/type';
-import { UserGuide, UserInitializationState, UserPreference } from '@/types/user';
-import { UserSettings } from '@/types/user/settings';
 
 export class ServerService implements IUserService {
-  getUserState = async (): Promise<UserInitializationState> => {
+  getUserState: IUserService['getUserState'] = async () => {
     return lambdaClient.user.getUserState.query();
   };
 
-  async makeUserOnboarded() {
+  makeUserOnboarded = async () => {
     return lambdaClient.user.makeUserOnboarded.mutate();
-  }
+  };
 
-  async updatePreference(preference: Partial<UserPreference>) {
+  updatePreference: IUserService['updatePreference'] = async (preference) => {
     return lambdaClient.user.updatePreference.mutate(preference);
-  }
+  };
 
-  async updateGuide(guide: Partial<UserGuide>) {
+  updateGuide: IUserService['updateGuide'] = async (guide) => {
     return lambdaClient.user.updateGuide.mutate(guide);
-  }
+  };
 
-  updateUserSettings = async (value: DeepPartial<UserSettings>, signal?: AbortSignal) => {
+  updateUserSettings: IUserService['updateUserSettings'] = async (value, signal) => {
     return lambdaClient.user.updateSettings.mutate(value, { signal });
   };
 
-  resetUserSettings = async () => {
+  resetUserSettings: IUserService['resetUserSettings'] = async () => {
     return lambdaClient.user.resetSettings.mutate();
   };
 }

package/src/services/user/type.ts

@@ -8,5 +8,5 @@ export interface IUserService {
   resetUserSettings: () => Promise<any>;
   updateGuide: (guide: Partial<UserGuide>) => Promise<any>;
   updatePreference: (preference: Partial<UserPreference>) => Promise<any>;
-  updateUserSettings: (patch: DeepPartial<UserSettings>) => Promise<any>;
+  updateUserSettings: (value: DeepPartial<UserSettings>, signal?: AbortSignal) => Promise<any>;
 }

package/src/store/chat/slices/message/reducer.ts

@@ -3,6 +3,7 @@ import { produce } from 'immer';
 
 import {
   ChatMessage,
+  ChatMessageExtra,
   ChatPluginPayload,
   ChatToolPayload,
   CreateMessageParams,
@@ -100,9 +101,9 @@ export const messagesReducer = (state: ChatMessage[], payload: MessageDispatch):
         if (!message) return;
 
         if (!message.extra) {
-          message.extra = { [key]: value } as any;
+          message.extra = { [key]: value } as ChatMessageExtra;
         } else {
-          message.extra[key] = value;
+          message.extra[key as keyof ChatMessageExtra] = value;
         }
 
         message.updatedAt = Date.now();

package/src/store/global/action.ts

@@ -1,7 +1,7 @@
 import isEqual from 'fast-deep-equal';
 import { produce } from 'immer';
 import { gt, parse, valid } from 'semver';
-import useSWR, { SWRResponse } from 'swr';
+import { SWRResponse } from 'swr';
 import type { StateCreator } from 'zustand/vanilla';
 
 import { INBOX_SESSION_ID } from '@/const/session';
@@ -42,6 +42,7 @@ export const globalActionSlice: StateCreator<
   switchBackToChat: (sessionId) => {
     get().router?.push(SESSION_CHAT_URL(sessionId || INBOX_SESSION_ID, get().isMobile));
   },
+
   toggleChatSideBar: (newValue) => {
     const showChatSideBar =
       typeof newValue === 'boolean' ? newValue : !get().status.showChatSideBar;
@@ -97,28 +98,32 @@ export const globalActionSlice: StateCreator<
   },
 
   useCheckLatestVersion: (enabledCheck = true) =>
-    useSWR(enabledCheck ? 'checkLatestVersion' : null, globalService.getLatestVersion, {
-      // check latest version every 30 minutes
-      focusThrottleInterval: 1000 * 60 * 30,
-      onSuccess: (data: string) => {
-        if (!valid(CURRENT_VERSION) || !valid(data)) return;
-
-        // Parse versions to ensure we're working with valid SemVer objects
-        const currentVersion = parse(CURRENT_VERSION);
-        const latestVersion = parse(data);
-
-        if (!currentVersion || !latestVersion) return;
-
-        // only compare major and minor versions
-        // solve the problem of frequent patch updates
-        const currentMajorMinor = `${currentVersion.major}.${currentVersion.minor}.0`;
-        const latestMajorMinor = `${latestVersion.major}.${latestVersion.minor}.0`;
-
-        if (gt(latestMajorMinor, currentMajorMinor)) {
-          set({ hasNewVersion: true, latestVersion: data }, false, n('checkLatestVersion'));
-        }
+    useOnlyFetchOnceSWR(
+      enabledCheck ? 'checkLatestVersion' : null,
+      async () => globalService.getLatestVersion(),
+      {
+        // check latest version every 30 minutes
+        focusThrottleInterval: 1000 * 60 * 30,
+        onSuccess: (data: string) => {
+          if (!valid(CURRENT_VERSION) || !valid(data)) return;
+
+          // Parse versions to ensure we're working with valid SemVer objects
+          const currentVersion = parse(CURRENT_VERSION);
+          const latestVersion = parse(data);
+
+          if (!currentVersion || !latestVersion) return;
+
+          // only compare major and minor versions
+          // solve the problem of frequent patch updates
+          const currentMajorMinor = `${currentVersion.major}.${currentVersion.minor}.0`;
+          const latestMajorMinor = `${latestVersion.major}.${latestVersion.minor}.0`;
+
+          if (gt(latestMajorMinor, currentMajorMinor)) {
+            set({ hasNewVersion: true, latestVersion: data }, false, n('checkLatestVersion'));
+          }
+        },
       },
-    }),
+    ),
 
   useInitSystemStatus: () =>
     useOnlyFetchOnceSWR<SystemStatus>(

package/src/store/global/initialState.ts

@@ -42,6 +42,7 @@ export interface SystemStatus {
    * 应用初始化时不启用 PGLite，只有当用户手动开启时才启用
    */
   isEnablePglite?: boolean;
+  latestChangelogId?: string;
   mobileShowPortal?: boolean;
   mobileShowTopic?: boolean;
   sessionsWidth: number;

package/src/types/changelog.ts

@@ -0,0 +1,6 @@
+export interface ChangelogIndexItem {
+  date: string;
+  id: string;
+  image?: string;
+  versionRange: string[];
+}

package/src/types/message/index.ts

@@ -56,20 +56,22 @@ export interface ChatFileChunk {
   text: string;
 }
 
+export interface ChatMessageExtra {
+  fromModel?: string;
+  fromProvider?: string;
+  // 翻译
+  translate?: ChatTranslate | false | null;
+  // TTS
+  tts?: ChatTTS;
+}
+
 export interface ChatMessage extends BaseDataModel {
   chunksList?: ChatFileChunk[];
   content: string;
   error?: ChatMessageError | null;
 
   // 扩展字段
-  extra?: {
-    fromModel?: string;
-    fromProvider?: string;
-    // 翻译
-    translate?: ChatTranslate | false | null;
-    // TTS
-    tts?: ChatTTS;
-  } & Record<string, any>;
+  extra?: ChatMessageExtra;
   fileList?: ChatFileItem[];
   /**
    * this is a deprecated field, only use in client db

package/src/app/@modal/features/InterceptingContext.tsx

@@ -1,9 +0,0 @@
-import { PropsWithChildren, createContext, memo } from 'react';
-
-export const InterceptContext = createContext(false);
-
-const InterceptingLayout = memo<PropsWithChildren>(({ children }) => {
-  return <InterceptContext.Provider value={true}>{children}</InterceptContext.Provider>;
-});
-
-export default InterceptingLayout;