@lobehub/chat 1.77.5 → 1.77.7

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

@@ -3,8 +3,8 @@ import { z } from 'zod';
 import { AiProviderModel } from '@/database/models/aiProvider';
 import { UserModel } from '@/database/models/user';
 import { AiInfraRepos } from '@/database/repositories/aiInfra';
-import { serverDB } from '@/database/server';
 import { authedProcedure, router } from '@/libs/trpc';
+import { serverDatabase } from '@/libs/trpc/lambda';
 import { getServerGlobalConfig } from '@/server/globalConfig';
 import { KeyVaultsGateKeeper } from '@/server/modules/KeyVaultsEncrypt';
 import {
@@ -16,7 +16,7 @@ import {
 } from '@/types/aiProvider';
 import { ProviderConfig } from '@/types/user/settings';
 
-const aiProviderProcedure = authedProcedure.use(async (opts) => {
+const aiProviderProcedure = authedProcedure.use(serverDatabase).use(async (opts) => {
   const { ctx } = opts;
 
   const { aiProvider } = await getServerGlobalConfig();
@@ -25,13 +25,13 @@ const aiProviderProcedure = authedProcedure.use(async (opts) => {
   return opts.next({
     ctx: {
       aiInfraRepos: new AiInfraRepos(
-        serverDB,
+        ctx.serverDB,
         ctx.userId,
         aiProvider as Record<string, ProviderConfig>,
       ),
-      aiProviderModel: new AiProviderModel(serverDB, ctx.userId),
+      aiProviderModel: new AiProviderModel(ctx.serverDB, ctx.userId),
       gateKeeper,
-      userModel: new UserModel(serverDB, ctx.userId),
+      userModel: new UserModel(ctx.serverDB, ctx.userId),
     },
   });
 });

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

@@ -9,28 +9,31 @@ import { EmbeddingModel } from '@/database/models/embedding';
 import { FileModel } from '@/database/models/file';
 import { MessageModel } from '@/database/models/message';
 import { knowledgeBaseFiles } from '@/database/schemas';
-import { serverDB } from '@/database/server';
 import { authedProcedure, router } from '@/libs/trpc';
+import { serverDatabase } from '@/libs/trpc/lambda';
 import { keyVaults } from '@/libs/trpc/middleware/keyVaults';
 import { getServerDefaultFilesConfig } from '@/server/globalConfig';
 import { initAgentRuntimeWithUserPayload } from '@/server/modules/AgentRuntime';
 import { ChunkService } from '@/server/services/chunk';
 import { SemanticSearchSchema } from '@/types/rag';
 
-const chunkProcedure = authedProcedure.use(keyVaults).use(async (opts) => {
-  const { ctx } = opts;
-
-  return opts.next({
-    ctx: {
-      asyncTaskModel: new AsyncTaskModel(serverDB, ctx.userId),
-      chunkModel: new ChunkModel(serverDB, ctx.userId),
-      chunkService: new ChunkService(ctx.userId),
-      embeddingModel: new EmbeddingModel(serverDB, ctx.userId),
-      fileModel: new FileModel(serverDB, ctx.userId),
-      messageModel: new MessageModel(serverDB, ctx.userId),
-    },
+const chunkProcedure = authedProcedure
+  .use(serverDatabase)
+  .use(keyVaults)
+  .use(async (opts) => {
+    const { ctx } = opts;
+
+    return opts.next({
+      ctx: {
+        asyncTaskModel: new AsyncTaskModel(ctx.serverDB, ctx.userId),
+        chunkModel: new ChunkModel(ctx.serverDB, ctx.userId),
+        chunkService: new ChunkService(ctx.userId),
+        embeddingModel: new EmbeddingModel(ctx.serverDB, ctx.userId),
+        fileModel: new FileModel(ctx.serverDB, ctx.userId),
+        messageModel: new MessageModel(ctx.serverDB, ctx.userId),
+      },
+    });
   });
-});
 
 export const chunkRouter = router({
   createEmbeddingChunksTask: chunkProcedure
@@ -173,7 +176,7 @@ export const chunkRouter = router({
         let finalFileIds = input.fileIds ?? [];
 
         if (input.knowledgeIds && input.knowledgeIds.length > 0) {
-          const knowledgeFiles = await serverDB.query.knowledgeBaseFiles.findMany({
+          const knowledgeFiles = await ctx.serverDB.query.knowledgeBaseFiles.findMany({
             where: inArray(knowledgeBaseFiles.knowledgeBaseId, input.knowledgeIds),
           });
 

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

@@ -1,13 +1,13 @@
 import { DrizzleMigrationModel } from '@/database/models/drizzleMigration';
 import { DataExporterRepos } from '@/database/repositories/dataExporter';
-import { serverDB } from '@/database/server';
 import { authedProcedure, router } from '@/libs/trpc';
+import { serverDatabase } from '@/libs/trpc/lambda';
 import { ExportDatabaseData } from '@/types/export';
 
-const exportProcedure = authedProcedure.use(async (opts) => {
+const exportProcedure = authedProcedure.use(serverDatabase).use(async (opts) => {
   const { ctx } = opts;
-  const dataExporterRepos = new DataExporterRepos(serverDB, ctx.userId);
-  const drizzleMigration = new DrizzleMigrationModel(serverDB);
+  const dataExporterRepos = new DataExporterRepos(ctx.serverDB, ctx.userId);
+  const drizzleMigration = new DrizzleMigrationModel(ctx.serverDB);
 
   return opts.next({
     ctx: { dataExporterRepos, drizzleMigration },

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

@@ -5,21 +5,21 @@ import { serverDBEnv } from '@/config/db';
 import { AsyncTaskModel } from '@/database/models/asyncTask';
 import { ChunkModel } from '@/database/models/chunk';
 import { FileModel } from '@/database/models/file';
-import { serverDB } from '@/database/server';
 import { authedProcedure, router } from '@/libs/trpc';
+import { serverDatabase } from '@/libs/trpc/lambda';
 import { S3 } from '@/server/modules/S3';
 import { getFullFileUrl } from '@/server/utils/files';
 import { AsyncTaskStatus, AsyncTaskType } from '@/types/asyncTask';
 import { FileListItem, QueryFileListSchema, UploadFileSchema } from '@/types/files';
 
-const fileProcedure = authedProcedure.use(async (opts) => {
+const fileProcedure = authedProcedure.use(serverDatabase).use(async (opts) => {
   const { ctx } = opts;
 
   return opts.next({
     ctx: {
-      asyncTaskModel: new AsyncTaskModel(serverDB, ctx.userId),
-      chunkModel: new ChunkModel(serverDB, ctx.userId),
-      fileModel: new FileModel(serverDB, ctx.userId),
+      asyncTaskModel: new AsyncTaskModel(ctx.serverDB, ctx.userId),
+      chunkModel: new ChunkModel(ctx.serverDB, ctx.userId),
+      fileModel: new FileModel(ctx.serverDB, ctx.userId),
     },
   });
 });

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

@@ -2,15 +2,15 @@ import { TRPCError } from '@trpc/server';
 import { z } from 'zod';
 
 import { DataImporterRepos } from '@/database/repositories/dataImporter';
-import { serverDB } from '@/database/server';
 import { authedProcedure, router } from '@/libs/trpc';
+import { serverDatabase } from '@/libs/trpc/lambda';
 import { S3 } from '@/server/modules/S3';
 import { ImportPgDataStructure } from '@/types/export';
 import { ImportResultData, ImporterEntryData } from '@/types/importer';
 
-const importProcedure = authedProcedure.use(async (opts) => {
+const importProcedure = authedProcedure.use(serverDatabase).use(async (opts) => {
   const { ctx } = opts;
-  const dataImporterService = new DataImporterRepos(serverDB, ctx.userId);
+  const dataImporterService = new DataImporterRepos(ctx.serverDB, ctx.userId);
 
   return opts.next({
     ctx: { dataImporterService },

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

@@ -2,16 +2,16 @@ import { z } from 'zod';
 
 import { KnowledgeBaseModel } from '@/database/models/knowledgeBase';
 import { insertKnowledgeBasesSchema } from '@/database/schemas';
-import { serverDB } from '@/database/server';
 import { authedProcedure, router } from '@/libs/trpc';
+import { serverDatabase } from '@/libs/trpc/lambda';
 import { KnowledgeBaseItem } from '@/types/knowledgeBase';
 
-const knowledgeBaseProcedure = authedProcedure.use(async (opts) => {
+const knowledgeBaseProcedure = authedProcedure.use(serverDatabase).use(async (opts) => {
   const { ctx } = opts;
 
   return opts.next({
     ctx: {
-      knowledgeBaseModel: new KnowledgeBaseModel(serverDB, ctx.userId),
+      knowledgeBaseModel: new KnowledgeBaseModel(ctx.serverDB, ctx.userId),
     },
   });
 });

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

@@ -2,19 +2,20 @@ import { z } from 'zod';
 
 import { MessageModel } from '@/database/models/message';
 import { updateMessagePluginSchema } from '@/database/schemas';
-import { serverDB } from '@/database/server';
+import { getServerDB } from '@/database/server';
 import { authedProcedure, publicProcedure, router } from '@/libs/trpc';
+import { serverDatabase } from '@/libs/trpc/lambda';
 import { getFullFileUrl } from '@/server/utils/files';
 import { ChatMessage } from '@/types/message';
 import { BatchTaskResult } from '@/types/service';
 
 type ChatMessageList = ChatMessage[];
 
-const messageProcedure = authedProcedure.use(async (opts) => {
+const messageProcedure = authedProcedure.use(serverDatabase).use(async (opts) => {
   const { ctx } = opts;
 
   return opts.next({
-    ctx: { messageModel: new MessageModel(serverDB, ctx.userId) },
+    ctx: { messageModel: new MessageModel(ctx.serverDB, ctx.userId) },
   });
 });
 
@@ -95,6 +96,7 @@ export const messageRouter = router({
     )
     .query(async ({ input, ctx }) => {
       if (!ctx.userId) return [];
+      const serverDB = await getServerDB();
 
       const messageModel = new MessageModel(serverDB, ctx.userId);
 

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

@@ -1,15 +1,16 @@
 import { z } from 'zod';
 
 import { PluginModel } from '@/database/models/plugin';
-import { serverDB } from '@/database/server';
+import { getServerDB } from '@/database/server';
 import { authedProcedure, publicProcedure, router } from '@/libs/trpc';
+import { serverDatabase } from '@/libs/trpc/lambda';
 import { LobeTool } from '@/types/tool';
 
-const pluginProcedure = authedProcedure.use(async (opts) => {
+const pluginProcedure = authedProcedure.use(serverDatabase).use(async (opts) => {
   const { ctx } = opts;
 
   return opts.next({
-    ctx: { pluginModel: new PluginModel(serverDB, ctx.userId) },
+    ctx: { pluginModel: new PluginModel(ctx.serverDB, ctx.userId) },
   });
 });
 
@@ -66,6 +67,7 @@ export const pluginRouter = router({
   getPlugins: publicProcedure.query(async ({ ctx }): Promise<LobeTool[]> => {
     if (!ctx.userId) return [];
 
+    const serverDB = await getServerDB();
     const pluginModel = new PluginModel(serverDB, ctx.userId);
 
     return pluginModel.query();

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

@@ -7,7 +7,6 @@ import { z } from 'zod';
 
 import { DEFAULT_EMBEDDING_MODEL, DEFAULT_MODEL } from '@/const/settings';
 import { FileModel } from '@/database/models/file';
-import { serverDB } from '@/database/server';
 import {
   EvalDatasetModel,
   EvalDatasetRecordModel,
@@ -15,6 +14,7 @@ import {
   EvaluationRecordModel,
 } from '@/database/server/models/ragEval';
 import { authedProcedure, router } from '@/libs/trpc';
+import { serverDatabase } from '@/libs/trpc/lambda';
 import { keyVaults } from '@/libs/trpc/middleware/keyVaults';
 import { S3 } from '@/server/modules/S3';
 import { createAsyncServerClient } from '@/server/routers/async';
@@ -29,20 +29,23 @@ import {
   insertEvalEvaluationSchema,
 } from '@/types/eval';
 
-const ragEvalProcedure = authedProcedure.use(keyVaults).use(async (opts) => {
-  const { ctx } = opts;
-
-  return opts.next({
-    ctx: {
-      datasetModel: new EvalDatasetModel(ctx.userId),
-      fileModel: new FileModel(serverDB, ctx.userId),
-      datasetRecordModel: new EvalDatasetRecordModel(ctx.userId),
-      evaluationModel: new EvalEvaluationModel(ctx.userId),
-      evaluationRecordModel: new EvaluationRecordModel(ctx.userId),
-      s3: new S3(),
-    },
+const ragEvalProcedure = authedProcedure
+  .use(serverDatabase)
+  .use(keyVaults)
+  .use(async (opts) => {
+    const { ctx } = opts;
+
+    return opts.next({
+      ctx: {
+        datasetModel: new EvalDatasetModel(ctx.userId),
+        fileModel: new FileModel(ctx.serverDB, ctx.userId),
+        datasetRecordModel: new EvalDatasetRecordModel(ctx.userId),
+        evaluationModel: new EvalEvaluationModel(ctx.userId),
+        evaluationRecordModel: new EvaluationRecordModel(ctx.userId),
+        s3: new S3(),
+      },
+    });
   });
-});
 
 export const ragEvalRouter = router({
   createDataset: ragEvalProcedure

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

@@ -3,21 +3,22 @@ import { z } from 'zod';
 import { SessionModel } from '@/database/models/session';
 import { SessionGroupModel } from '@/database/models/sessionGroup';
 import { insertAgentSchema, insertSessionSchema } from '@/database/schemas';
-import { serverDB } from '@/database/server';
+import { getServerDB } from '@/database/server';
 import { authedProcedure, publicProcedure, router } from '@/libs/trpc';
+import { serverDatabase } from '@/libs/trpc/lambda';
 import { AgentChatConfigSchema } from '@/types/agent';
 import { LobeMetaDataSchema } from '@/types/meta';
 import { BatchTaskResult } from '@/types/service';
 import { ChatSessionList } from '@/types/session';
 import { merge } from '@/utils/merge';
 
-const sessionProcedure = authedProcedure.use(async (opts) => {
+const sessionProcedure = authedProcedure.use(serverDatabase).use(async (opts) => {
   const { ctx } = opts;
 
   return opts.next({
     ctx: {
-      sessionGroupModel: new SessionGroupModel(serverDB, ctx.userId),
-      sessionModel: new SessionModel(serverDB, ctx.userId),
+      sessionGroupModel: new SessionGroupModel(ctx.serverDB, ctx.userId),
+      sessionModel: new SessionModel(ctx.serverDB, ctx.userId),
     },
   });
 });
@@ -95,6 +96,7 @@ export const sessionRouter = router({
         sessions: [],
       };
 
+    const serverDB = await getServerDB();
     const sessionModel = new SessionModel(serverDB, ctx.userId);
 
     return sessionModel.queryWithGroups();

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

@@ -2,16 +2,16 @@ import { z } from 'zod';
 
 import { SessionGroupModel } from '@/database/models/sessionGroup';
 import { insertSessionGroupSchema } from '@/database/schemas';
-import { serverDB } from '@/database/server';
 import { authedProcedure, router } from '@/libs/trpc';
+import { serverDatabase } from '@/libs/trpc/lambda';
 import { SessionGroupItem } from '@/types/session';
 
-const sessionProcedure = authedProcedure.use(async (opts) => {
+const sessionProcedure = authedProcedure.use(serverDatabase).use(async (opts) => {
   const { ctx } = opts;
 
   return opts.next({
     ctx: {
-      sessionGroupModel: new SessionGroupModel(serverDB, ctx.userId),
+      sessionGroupModel: new SessionGroupModel(ctx.serverDB, ctx.userId),
     },
   });
 });

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

@@ -3,17 +3,17 @@ import { z } from 'zod';
 import { MessageModel } from '@/database/models/message';
 import { ThreadModel } from '@/database/models/thread';
 import { insertThreadSchema } from '@/database/schemas';
-import { serverDB } from '@/database/server';
 import { authedProcedure, router } from '@/libs/trpc';
+import { serverDatabase } from '@/libs/trpc/lambda';
 import { ThreadItem, createThreadSchema } from '@/types/topic/thread';
 
-const threadProcedure = authedProcedure.use(async (opts) => {
+const threadProcedure = authedProcedure.use(serverDatabase).use(async (opts) => {
   const { ctx } = opts;
 
   return opts.next({
     ctx: {
-      messageModel: new MessageModel(serverDB, ctx.userId),
-      threadModel: new ThreadModel(serverDB, ctx.userId),
+      messageModel: new MessageModel(ctx.serverDB, ctx.userId),
+      threadModel: new ThreadModel(ctx.serverDB, ctx.userId),
     },
   });
 });

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

@@ -1,15 +1,16 @@
 import { z } from 'zod';
 
 import { TopicModel } from '@/database/models/topic';
-import { serverDB } from '@/database/server';
+import { getServerDB } from '@/database/server';
 import { authedProcedure, publicProcedure, router } from '@/libs/trpc';
+import { serverDatabase } from '@/libs/trpc/lambda';
 import { BatchTaskResult } from '@/types/service';
 
-const topicProcedure = authedProcedure.use(async (opts) => {
+const topicProcedure = authedProcedure.use(serverDatabase).use(async (opts) => {
   const { ctx } = opts;
 
   return opts.next({
-    ctx: { topicModel: new TopicModel(serverDB, ctx.userId) },
+    ctx: { topicModel: new TopicModel(ctx.serverDB, ctx.userId) },
   });
 });
 
@@ -101,6 +102,7 @@ export const topicRouter = router({
     .query(async ({ input, ctx }) => {
       if (!ctx.userId) return [];
 
+      const serverDB = await getServerDB();
       const topicModel = new TopicModel(serverDB, ctx.userId);
 
       return topicModel.query(input);

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

@@ -5,10 +5,10 @@ import { enableClerk } from '@/const/auth';
 import { MessageModel } from '@/database/models/message';
 import { SessionModel } from '@/database/models/session';
 import { UserModel, UserNotFoundError } from '@/database/models/user';
-import { serverDB } from '@/database/server';
 import { ClerkAuth } from '@/libs/clerk-auth';
 import { LobeNextAuthDbAdapter } from '@/libs/next-auth/adapter';
 import { authedProcedure, router } from '@/libs/trpc';
+import { serverDatabase } from '@/libs/trpc/lambda';
 import { KeyVaultsGateKeeper } from '@/server/modules/KeyVaultsEncrypt';
 import { UserService } from '@/server/services/user';
 import {
@@ -19,12 +19,12 @@ import {
 } from '@/types/user';
 import { UserSettings } from '@/types/user/settings';
 
-const userProcedure = authedProcedure.use(async (opts) => {
-  return opts.next({
+const userProcedure = authedProcedure.use(serverDatabase).use(async ({ ctx, next }) => {
+  return next({
     ctx: {
       clerkAuth: new ClerkAuth(),
-      nextAuthDbAdapter: LobeNextAuthDbAdapter(serverDB),
-      userModel: new UserModel(serverDB, opts.ctx.userId),
+      nextAuthDbAdapter: LobeNextAuthDbAdapter(ctx.serverDB),
+      userModel: new UserModel(ctx.serverDB, ctx.userId),
     },
   });
 });
@@ -77,10 +77,10 @@ export const userRouter = router({
       }
     }
 
-    const messageModel = new MessageModel(serverDB, ctx.userId);
+    const messageModel = new MessageModel(ctx.serverDB, ctx.userId);
     const hasMoreThan4Messages = await messageModel.hasMoreThanN(4);
 
-    const sessionModel = new SessionModel(serverDB, ctx.userId);
+    const sessionModel = new SessionModel(ctx.serverDB, ctx.userId);
     const hasAnyMessages = await messageModel.hasMoreThanN(0);
     const hasExtraSession = await sessionModel.hasMoreThanN(1);
 

package/src/server/routers/tools/__tests__/search.test.ts

@@ -21,6 +21,7 @@ vi.mock('@/config/tools', () => ({
 
 vi.mock('@/const/version', () => ({
   isServerMode: true,
+  isDesktop: false,
 }));
 
 const createCaller = createCallerFactory(searchRouter);

package/src/server/services/nextAuthUser/index.test.ts

@@ -6,7 +6,6 @@ import { UserModel } from '@/database/models/user';
 import { UserItem } from '@/database/schemas';
 import { serverDB } from '@/database/server';
 import { pino } from '@/libs/logger';
-import { LobeNextAuthDbAdapter } from '@/libs/next-auth/adapter';
 
 import { NextAuthUserService } from './index';
 
@@ -23,7 +22,7 @@ vi.mock('@/database/server');
 describe('NextAuthUserService', () => {
   let service: NextAuthUserService;
 
-  beforeEach(() => {
+  beforeEach(async () => {
     vi.clearAllMocks();
     service = new NextAuthUserService();
   });

package/src/server/translation.test.ts

@@ -1,12 +1,9 @@
 // @vitest-environment node
 import { cookies } from 'next/headers';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { DEFAULT_LANG, LOBE_LOCALE_COOKIE } from '@/const/locale';
+import { DEFAULT_LANG } from '@/const/locale';
 import { normalizeLocale } from '@/locales/resources';
-import * as env from '@/utils/env';
 
 import { getLocale, translation } from './translation';
 
@@ -15,15 +12,6 @@ vi.mock('next/headers', () => ({
   cookies: vi.fn(),
 }));
 
-vi.mock('node:fs', () => ({
-  existsSync: vi.fn(),
-  readFileSync: vi.fn(),
-}));
-
-vi.mock('node:path', () => ({
-  join: vi.fn(),
-}));
-
 vi.mock('@/const/locale', () => ({
   DEFAULT_LANG: 'en-US',
   LOBE_LOCALE_COOKIE: 'LOBE_LOCALE',
@@ -37,6 +25,28 @@ vi.mock('@/utils/env', () => ({
   isDev: false,
 }));
 
+// 模拟动态导入结果
+const mockTranslations = {
+  key1: 'Value 1',
+  key2: 'Value 2 with {{param}}',
+  nested: { key: 'Nested value' },
+};
+
+const mockDefaultTranslations = {
+  key1: '默认值 1',
+  key2: '默认值 2 带 {{param}}',
+  nested: { key: '默认嵌套值' },
+};
+
+// 重写导入函数
+vi.mock('@/../locales/en-US/common.json', async () => {
+  return mockTranslations;
+});
+
+vi.mock('@/locales/default/common', async () => {
+  return mockDefaultTranslations;
+});
+
 describe('getLocale', () => {
   const mockCookieStore = {
     get: vi.fn(),
@@ -61,17 +71,12 @@ describe('getLocale', () => {
 });
 
 describe('translation', () => {
-  const mockTranslations = {
-    key1: 'Value 1',
-    key2: 'Value 2 with {{param}}',
-    nested: { key: 'Nested value' },
-  };
-
   beforeEach(() => {
     vi.clearAllMocks();
-    (fs.existsSync as any).mockReturnValue(true);
-    (fs.readFileSync as any).mockReturnValue(JSON.stringify(mockTranslations));
-    (path.join as any).mockImplementation((...args: any) => args.join('/'));
+    // 重置 import 模拟
+    vi.doMock('@/../locales/en-US/common.json', async () => {
+      return mockTranslations;
+    });
   });
 
   it('should return correct translation object', async () => {
@@ -88,43 +93,58 @@ describe('translation', () => {
     expect(t('nested.key')).toBe('Nested value');
   });
 
-  it('should return key if translation is not found', async () => {
+  it('should handle multiple parameters in translation string', async () => {
+    // 模拟多参数翻译
+    vi.doMock('@/../locales/en-US/common.json', async () => ({
+      multiParam: 'Hello {{name}}, you have {{count}} messages',
+    }));
+
     const { t } = await translation('common', 'en-US');
-    expect(t('nonexistent.key')).toBe('nonexistent.key');
+    expect(t('multiParam', { name: 'John', count: '5' })).toBe('Hello John, you have 5 messages');
   });
 
-  it('should use fallback language if specified locale file does not exist', async () => {
-    (fs.existsSync as any).mockReturnValueOnce(false);
-    await translation('common', 'nonexistent-LANG');
-    expect(fs.readFileSync).toHaveBeenCalledWith(
-      expect.stringContaining(`/${DEFAULT_LANG}/common.json`),
-      'utf8',
-    );
+  it('should handle different namespaces', async () => {
+    // 模拟另一个命名空间
+    vi.doMock('@/../locales/en-US/chat.json', async () => ({
+      welcome: 'Welcome to the chat',
+    }));
+
+    const { t } = await translation('chat', 'en-US');
+    expect(t('welcome')).toBe('Welcome to the chat');
   });
 
-  it('should use zh-CN in dev mode when fallback is needed', async () => {
-    (fs.existsSync as any).mockReturnValueOnce(false);
-    (env.isDev as unknown as boolean) = true;
-    await translation('common', 'nonexistent-LANG');
-    expect(fs.readFileSync).toHaveBeenCalledWith(
-      expect.stringContaining('/zh-CN/common.json'),
-      'utf8',
-    );
+  it('should handle deep nested objects in translations', async () => {
+    // 模拟深层嵌套对象
+    vi.doMock('@/../locales/en-US/common.json', async () => ({
+      very: {
+        deeply: {
+          nested: {
+            key: 'Found the nested value',
+          },
+        },
+      },
+    }));
+
+    const { t } = await translation('common', 'en-US');
+    expect(t('very.deeply.nested.key')).toBe('Found the nested value');
   });
 
-  it('should handle file reading errors', async () => {
-    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    (fs.readFileSync as any).mockImplementation(() => {
-      throw new Error('File read error');
-    });
+  it('should handle empty parameters object', async () => {
+    vi.doMock('@/../locales/en-US/common.json', async () => ({
+      simpleText: 'Just a simple text',
+    }));
 
-    const result = await translation('common', 'en-US');
-    expect(result.t('any.key')).toBe('any.key');
-    expect(consoleErrorSpy).toHaveBeenCalledWith(
-      'Error while reading translation file',
-      expect.any(Error),
-    );
+    const { t } = await translation('common', 'en-US');
+    expect(t('simpleText', {})).toBe('Just a simple text');
+  });
 
-    consoleErrorSpy.mockRestore();
+  it('should handle missing parameters in translation string', async () => {
+    vi.doMock('@/../locales/en-US/common.json', async () => ({
+      withParam: 'Text with {{param}}',
+    }));
+
+    const { t } = await translation('common', 'en-US');
+    // 当缺少参数时应保留占位符
+    expect(t('withParam')).toBe('Text with {{param}}');
   });
 });