@lobehub/chat 0.162.24 → 0.163.0

package/src/store/user/slices/modelList/selectors/keyVaults.test.ts

@@ -0,0 +1,201 @@
+import { describe, expect, it } from 'vitest';
+
+import { UserStore } from '@/store/user';
+import {
+  AWSBedrockKeyVault,
+  AzureOpenAIKeyVault,
+  OpenAICompatibleKeyVault,
+} from '@/types/user/settings';
+import { merge } from '@/utils/merge';
+
+import { initialSettingsState } from '../../settings/initialState';
+import { keyVaultsConfigSelectors } from './keyVaults';
+
+describe('keyVaultsConfigSelectors', () => {
+  describe('isProviderEndpointNotEmpty', () => {
+    describe('OpenAICompatibleKeyVault', () => {
+      it('should return true if provider endpoint is not empty', () => {
+        const s = merge(initialSettingsState, {
+          settings: {
+            keyVaults: {
+              openai: {
+                endpoint: 'endpoint',
+              } as OpenAICompatibleKeyVault,
+            },
+          },
+        }) as unknown as UserStore;
+        expect(keyVaultsConfigSelectors.isProviderEndpointNotEmpty('openai')(s)).toBe(true);
+      });
+
+      it('should return false if provider endpoint is empty', () => {
+        const s = merge(initialSettingsState, {
+          settings: {
+            keyVaults: {
+              openai: {
+                endpoint: undefined,
+              } as OpenAICompatibleKeyVault,
+            },
+          },
+        }) as unknown as UserStore;
+        expect(keyVaultsConfigSelectors.isProviderEndpointNotEmpty('openai')(s)).toBe(false);
+      });
+    });
+
+    describe('AzureOpenAIKeyVault', () => {
+      it('should return true if provider endpoint is not empty', () => {
+        const s = merge(initialSettingsState, {
+          settings: {
+            keyVaults: {
+              azure: {
+                baseURL: 'baseURL',
+              } as AzureOpenAIKeyVault,
+            },
+          },
+        }) as unknown as UserStore;
+        expect(keyVaultsConfigSelectors.isProviderEndpointNotEmpty('azure')(s)).toBe(true);
+      });
+
+      it('should return false if provider endpoint is empty', () => {
+        const s = merge(initialSettingsState, {
+          settings: {
+            keyVaults: {
+              azure: {
+                baseURL: undefined,
+              } as AzureOpenAIKeyVault,
+            },
+          },
+        }) as unknown as UserStore;
+        expect(keyVaultsConfigSelectors.isProviderEndpointNotEmpty('azure')(s)).toBe(false);
+      });
+    });
+
+    // Always return false for AWSBedrockKeyVault
+    describe('AWSBedrockKeyVault', () => {
+      it('should return false if provider region is not empty for AWSBedrockKeyVault', () => {
+        const s = merge(initialSettingsState, {
+          settings: {
+            keyVaults: {
+              bedrock: {
+                region: 'region',
+              } as AWSBedrockKeyVault,
+            },
+          },
+        }) as unknown as UserStore;
+        expect(keyVaultsConfigSelectors.isProviderEndpointNotEmpty('bedrock')(s)).toBe(false);
+      });
+
+      it('should return false if provider region is empty for AWSBedrockKeyVault', () => {
+        const s = merge(initialSettingsState, {
+          settings: {
+            keyVaults: {
+              bedrock: {
+                region: undefined,
+              } as AWSBedrockKeyVault,
+            },
+          },
+        }) as unknown as UserStore;
+        expect(keyVaultsConfigSelectors.isProviderEndpointNotEmpty('bedrock')(s)).toBe(false);
+      });
+    });
+  });
+
+  describe('isProviderApiKeyNotEmpty', () => {
+    describe('OpenAICompatibleKeyVault', () => {
+      it('should return true if provider apikey is not empty', () => {
+        const s = merge(initialSettingsState, {
+          settings: {
+            keyVaults: {
+              openai: {
+                apiKey: 'apikey',
+              } as OpenAICompatibleKeyVault,
+            },
+          },
+        }) as unknown as UserStore;
+        expect(keyVaultsConfigSelectors.isProviderApiKeyNotEmpty('openai')(s)).toBe(true);
+      });
+
+      it('should return false if provider apikey is empty', () => {
+        const s = merge(initialSettingsState, {
+          settings: {
+            keyVaults: {
+              openai: {
+                apiKey: undefined,
+              } as OpenAICompatibleKeyVault,
+            },
+          },
+        }) as unknown as UserStore;
+        expect(keyVaultsConfigSelectors.isProviderApiKeyNotEmpty('openai')(s)).toBe(false);
+      });
+    });
+
+    describe('AzureOpenAIKeyVault', () => {
+      it('should return true if provider apikey is not empty', () => {
+        const s = merge(initialSettingsState, {
+          settings: {
+            keyVaults: {
+              azure: {
+                apiKey: 'apikey',
+              } as AzureOpenAIKeyVault,
+            },
+          },
+        }) as unknown as UserStore;
+        expect(keyVaultsConfigSelectors.isProviderApiKeyNotEmpty('azure')(s)).toBe(true);
+      });
+
+      it('should return false if provider apikey is empty', () => {
+        const s = merge(initialSettingsState, {
+          settings: {
+            keyVaults: {
+              azure: {
+                apiKey: undefined,
+              } as AzureOpenAIKeyVault,
+            },
+          },
+        }) as unknown as UserStore;
+        expect(keyVaultsConfigSelectors.isProviderApiKeyNotEmpty('azure')(s)).toBe(false);
+      });
+    });
+
+    describe('AWSBedrockKeyVault', () => {
+      it('should return true if provider accessKeyId is not empty for AWSBedrockKeyVault', () => {
+        const s = merge(initialSettingsState, {
+          settings: {
+            keyVaults: {
+              bedrock: {
+                accessKeyId: 'accessKeyId',
+              } as AWSBedrockKeyVault,
+            },
+          },
+        }) as unknown as UserStore;
+        expect(keyVaultsConfigSelectors.isProviderApiKeyNotEmpty('bedrock')(s)).toBe(true);
+      });
+
+      it('should return true if provider secretAccessKey is not empty for AWSBedrockKeyVault', () => {
+        const s = merge(initialSettingsState, {
+          settings: {
+            keyVaults: {
+              bedrock: {
+                secretAccessKey: 'secretAccessKey',
+              } as AWSBedrockKeyVault,
+            },
+          },
+        }) as unknown as UserStore;
+        expect(keyVaultsConfigSelectors.isProviderApiKeyNotEmpty('bedrock')(s)).toBe(true);
+      });
+
+      it('should return false if provider accessKeyId and secretAccessKey are both empty for AWSBedrockKeyVault', () => {
+        const s = merge(initialSettingsState, {
+          settings: {
+            keyVaults: {
+              bedrock: {
+                accessKeyId: undefined,
+                secretAccessKey: undefined,
+              } as AWSBedrockKeyVault,
+            },
+          },
+        }) as unknown as UserStore;
+        expect(keyVaultsConfigSelectors.isProviderApiKeyNotEmpty('bedrock')(s)).toBe(false);
+      });
+    });
+  });
+});

package/src/store/user/slices/modelList/selectors/keyVaults.ts

@@ -1,5 +1,7 @@
 import { UserStore } from '@/store/user';
 import {
+  AWSBedrockKeyVault,
+  AzureOpenAIKeyVault,
   GlobalLLMProviderKey,
   OpenAICompatibleKeyVault,
   UserKeyVaults,
@@ -15,10 +17,19 @@ const bedrockConfig = (s: UserStore) => keyVaultsSettings(s).bedrock || {};
 const ollamaConfig = (s: UserStore) => keyVaultsSettings(s).ollama || {};
 const azureConfig = (s: UserStore) => keyVaultsSettings(s).azure || {};
 const getVaultByProvider = (provider: GlobalLLMProviderKey) => (s: UserStore) =>
-  (keyVaultsSettings(s)[provider] || {}) as OpenAICompatibleKeyVault;
+  (keyVaultsSettings(s)[provider] || {}) as OpenAICompatibleKeyVault &
+    AzureOpenAIKeyVault &
+    AWSBedrockKeyVault;
 
-const isProviderEndpointNotEmpty = (provider: string) => (s: UserStore) =>
-  !!getVaultByProvider(provider as GlobalLLMProviderKey)(s)?.baseURL;
+const isProviderEndpointNotEmpty = (provider: string) => (s: UserStore) => {
+  const vault = getVaultByProvider(provider as GlobalLLMProviderKey)(s);
+  return !!vault?.baseURL || !!vault?.endpoint;
+};
+
+const isProviderApiKeyNotEmpty = (provider: string) => (s: UserStore) => {
+  const vault = getVaultByProvider(provider as GlobalLLMProviderKey)(s);
+  return !!vault?.apiKey || !!vault?.accessKeyId || !!vault?.secretAccessKey;
+};
 
 const password = (s: UserStore) => keyVaultsSettings(s).password || '';
 
@@ -26,6 +37,7 @@ export const keyVaultsConfigSelectors = {
   azureConfig,
   bedrockConfig,
   getVaultByProvider,
+  isProviderApiKeyNotEmpty,
   isProviderEndpointNotEmpty,
   ollamaConfig,
   openAIConfig,

package/src/store/user/slices/modelList/selectors/modelConfig.test.ts

@@ -35,6 +35,7 @@ describe('modelConfigSelectors', () => {
   });
 
   describe('isProviderFetchOnClient', () => {
+    // The next 4 case are base on the rules on https://github.com/lobehub/lobe-chat/pull/2753
     it('client fetch should disabled on default', () => {
       const s = merge(initialSettingsState, {
         settings: {
@@ -46,16 +47,43 @@ describe('modelConfigSelectors', () => {
           },
         },
       } as UserSettingsState) as unknown as UserStore;
+      expect(modelConfigSelectors.isProviderFetchOnClient('azure')(s)).toBe(false);
+    });
 
+    it('client fetch should disabled if no apikey or endpoint provided even user set it enabled', () => {
+      const s = merge(initialSettingsState, {
+        settings: {
+          languageModel: {
+            azure: { fetchOnClient: true },
+          },
+        },
+      } as UserSettingsState) as unknown as UserStore;
       expect(modelConfigSelectors.isProviderFetchOnClient('azure')(s)).toBe(false);
     });
 
-    it('client fetch should enabled if user set it enabled', () => {
+    it('client fetch should enable if only endpoint provided', () => {
+      const s = merge(initialSettingsState, {
+        settings: {
+          languageModel: {
+            azure: { fetchOnClient: false },
+          },
+          keyVaults: {
+            azure: { endpoint: 'https://example.com' },
+          },
+        },
+      } as UserSettingsState) as unknown as UserStore;
+      expect(modelConfigSelectors.isProviderFetchOnClient('azure')(s)).toBe(true);
+    });
+
+    it('client fetch should control by user when a apikey or endpoint provided', () => {
       const s = merge(initialSettingsState, {
         settings: {
           languageModel: {
             azure: { fetchOnClient: true },
           },
+          keyVaults: {
+            azure: { apiKey: 'some-key' },
+          },
         },
       } as UserSettingsState) as unknown as UserStore;
       expect(modelConfigSelectors.isProviderFetchOnClient('azure')(s)).toBe(true);

package/src/store/user/slices/modelList/selectors/modelConfig.ts

@@ -1,15 +1,35 @@
+import { UserStore } from '@/store/user';
 import { GlobalLLMProviderKey } from '@/types/user/settings';
 
-import { UserStore } from '../../../store';
 import { currentLLMSettings, getProviderConfigById } from '../../settings/selectors/settings';
+import { keyVaultsConfigSelectors } from './keyVaults';
 
 const isProviderEnabled = (provider: GlobalLLMProviderKey) => (s: UserStore) =>
   getProviderConfigById(provider)(s)?.enabled || false;
 
+/**
+ * @description The conditions to enable client fetch
+ * 1. If no baseUrl and apikey input, force on Server.
+ * 2. If only contains baseUrl, force on Client
+ * 3. Follow the user settings.
+ * 4. On Server, by default.
+ */
 const isProviderFetchOnClient = (provider: GlobalLLMProviderKey | string) => (s: UserStore) => {
   const config = getProviderConfigById(provider)(s);
+
+  // 1. If no baseUrl and apikey input, force on Server.
+  const isProviderEndpointNotEmpty =
+    keyVaultsConfigSelectors.isProviderEndpointNotEmpty(provider)(s);
+  const isProviderApiKeyNotEmpty = keyVaultsConfigSelectors.isProviderApiKeyNotEmpty(provider)(s);
+  if (!isProviderEndpointNotEmpty && !isProviderApiKeyNotEmpty) return false;
+
+  // 2. If only contains baseUrl, force on Client
+  if (isProviderEndpointNotEmpty && !isProviderApiKeyNotEmpty) return true;
+
+  // 3. Follow the user settings.
   if (typeof config?.fetchOnClient !== 'undefined') return config?.fetchOnClient;
 
+  // 4. On Server, by default.
   return false;
 };
 

package/src/types/user/settings/keyVaults.ts

@@ -3,7 +3,7 @@ export interface OpenAICompatibleKeyVault {
   baseURL?: string;
 }
 
-interface AzureOpenAIKeyVault {
+export interface AzureOpenAIKeyVault {
   apiKey?: string;
   apiVersion?: string;
   endpoint?: string;

package/tests/setup-db.ts

@@ -0,0 +1,7 @@
+// import env
+import { Crypto } from '@peculiar/webcrypto';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+global.crypto = new Crypto();

package/vitest.config.ts

@@ -22,12 +22,13 @@ export default defineConfig({
       ],
       provider: 'v8',
       reporter: ['text', 'json', 'lcov', 'text-summary'],
+      reportsDirectory: './coverage/app',
     },
     deps: {
       inline: ['vitest-canvas-mock'],
     },
-    // threads: false,
     environment: 'happy-dom',
+    exclude: ['**/node_modules/**', '**/dist/**', '**/build/**', 'src/database/server/**/**'],
     globals: true,
     setupFiles: './tests/setup.ts',
   },

package/vitest.server.config.ts

@@ -0,0 +1,23 @@
+import { resolve } from 'node:path';
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    alias: {
+      '@': resolve(__dirname, './src'),
+    },
+    coverage: {
+      all: false,
+      exclude: ['src/database/server/core/dbForTest.ts'],
+      provider: 'v8',
+      reporter: ['text', 'json', 'lcov', 'text-summary'],
+      reportsDirectory: './coverage/server',
+    },
+    environment: 'node',
+    include: ['src/database/server/**/**/*.test.ts'],
+    poolOptions: {
+      threads: { singleThread: true },
+    },
+    setupFiles: './tests/setup-db.ts',
+  },
+});