@lobehub/chat 1.46.7 → 1.47.0

package/src/features/DevPanel/index.tsx

@@ -0,0 +1,12 @@
+'use client';
+
+import FloatPanel from './FloatPanel';
+import PostgresViewer from './PostgresViewer';
+
+const DevPanel = () => (
+  <FloatPanel>
+    <PostgresViewer />
+  </FloatPanel>
+);
+
+export default DevPanel;

package/src/features/ModelSwitchPanel/index.tsx

@@ -9,7 +9,7 @@ import { useTranslation } from 'react-i18next';
 import { Flexbox } from 'react-layout-kit';
 
 import { ModelItemRender, ProviderItemRender } from '@/components/ModelSelect';
-import { isServerMode } from '@/const/version';
+import { isDeprecatedEdition } from '@/const/version';
 import { useEnabledChatModels } from '@/hooks/useEnabledChatModels';
 import { useIsMobile } from '@/hooks/useIsMobile';
 import { useAgentStore } from '@/store/agent';
@@ -76,7 +76,9 @@ const ModelSwitchPanel = memo<PropsWithChildren>(({ children }) => {
               </Flexbox>
             ),
             onClick: () => {
-              router.push(!isServerMode ? '/settings/llm' : `/settings/provider/${provider.id}`);
+              router.push(
+                isDeprecatedEdition ? '/settings/llm' : `/settings/provider/${provider.id}`,
+              );
             },
           },
         ];

package/src/hooks/useEnabledChatModels.ts

@@ -1,6 +1,6 @@
 import isEqual from 'fast-deep-equal';
 
-import { isServerMode } from '@/const/version';
+import { isDeprecatedEdition } from '@/const/version';
 import { useAiInfraStore } from '@/store/aiInfra';
 import { useUserStore } from '@/store/user';
 import { modelProviderSelectors } from '@/store/user/selectors';
@@ -10,7 +10,7 @@ export const useEnabledChatModels = (): EnabledProviderWithModels[] => {
   const enabledList = useUserStore(modelProviderSelectors.modelProviderListForModelSelect, isEqual);
   const enabledChatModelList = useAiInfraStore((s) => s.enabledChatModelList, isEqual);
 
-  if (!isServerMode) {
+  if (isDeprecatedEdition) {
     return enabledList;
   }
 

package/src/hooks/useModelContextWindowTokens.ts

@@ -1,4 +1,4 @@
-import { isServerMode } from '@/const/version';
+import { isDeprecatedEdition } from '@/const/version';
 import { aiModelSelectors, useAiInfraStore } from '@/store/aiInfra';
 import { useUserStore } from '@/store/user';
 import { modelProviderSelectors } from '@/store/user/selectors';
@@ -8,7 +8,7 @@ export const useModelContextWindowTokens = (model: string, provider: string) =>
 
   // TODO: remove this in V2.0
   const oldValue = useUserStore(modelProviderSelectors.modelMaxToken(model));
-  if (!isServerMode) return oldValue;
+  if (isDeprecatedEdition) return oldValue;
   //
 
   return newValue as number;

package/src/hooks/useModelHasContextWindowToken.ts

@@ -1,4 +1,4 @@
-import { isServerMode } from '@/const/version';
+import { isDeprecatedEdition } from '@/const/version';
 import { useAgentStore } from '@/store/agent';
 import { agentSelectors } from '@/store/agent/slices/chat';
 import { aiModelSelectors, useAiInfraStore } from '@/store/aiInfra';
@@ -12,7 +12,7 @@ export const useModelHasContextWindowToken = () => {
 
   // TODO: remove this in V2.0
   const oldValue = useUserStore(modelProviderSelectors.isModelHasMaxToken(model));
-  if (!isServerMode) return oldValue;
+  if (isDeprecatedEdition) return oldValue;
   //
 
   return newValue;

package/src/hooks/useModelSupportToolUse.ts

@@ -1,4 +1,4 @@
-import { isServerMode } from '@/const/version';
+import { isDeprecatedEdition } from '@/const/version';
 import { aiModelSelectors, useAiInfraStore } from '@/store/aiInfra';
 import { useUserStore } from '@/store/user';
 import { modelProviderSelectors } from '@/store/user/selectors';
@@ -8,7 +8,7 @@ export const useModelSupportToolUse = (model: string, provider: string) => {
 
   // TODO: remove this in V2.0
   const oldValue = useUserStore(modelProviderSelectors.isModelEnabledFunctionCall(model));
-  if (!isServerMode) return oldValue;
+  if (isDeprecatedEdition) return oldValue;
   //
 
   return newValue;

package/src/hooks/useModelSupportVision.ts

@@ -1,4 +1,4 @@
-import { isServerMode } from '@/const/version';
+import { isDeprecatedEdition } from '@/const/version';
 import { aiModelSelectors, useAiInfraStore } from '@/store/aiInfra';
 import { useUserStore } from '@/store/user';
 import { modelProviderSelectors } from '@/store/user/selectors';
@@ -8,7 +8,7 @@ export const useModelSupportVision = (model: string, provider: string) => {
 
   // TODO: remove this in V2.0
   const oldValue = useUserStore(modelProviderSelectors.isModelEnabledVision(model));
-  if (!isServerMode) return oldValue;
+  if (isDeprecatedEdition) return oldValue;
   //
 
   return newValue;

package/src/layout/GlobalProvider/index.tsx

@@ -9,7 +9,7 @@ import {
   LOBE_THEME_NEUTRAL_COLOR,
   LOBE_THEME_PRIMARY_COLOR,
 } from '@/const/theme';
-import DebugUI from '@/features/DebugUI';
+import DevPanel from '@/features/DevPanel';
 import { getServerGlobalConfig } from '@/server/globalConfig';
 import { ServerConfigStoreProvider } from '@/store/serverConfig';
 import { getAntdLocale, parseBrowserLanguage } from '@/utils/locale';
@@ -65,9 +65,9 @@ const GlobalLayout = async ({ children }: PropsWithChildren) => {
             <Suspense>
               <StoreInitialization />
               <ReactScan />
+              {process.env.NODE_ENV === 'development' && <DevPanel />}
             </Suspense>
           </ServerConfigStoreProvider>
-          <DebugUI />
         </AppTheme>
         <AntdV5MonkeyPatch />
       </Locale>

package/src/services/_auth.ts

@@ -1,5 +1,5 @@
 import { JWTPayload, LOBE_CHAT_AUTH_HEADER } from '@/const/auth';
-import { isServerMode } from '@/const/version';
+import { isDeprecatedEdition } from '@/const/version';
 import { ModelProvider } from '@/libs/agent-runtime';
 import { aiProviderSelectors, useAiInfraStore } from '@/store/aiInfra';
 import { useUserStore } from '@/store/user';
@@ -94,7 +94,7 @@ export const createPayloadWithKeyVaults = (provider: string) => {
   let keyVaults = {};
 
   // TODO: remove this condition in V2.0
-  if (!isServerMode) {
+  if (isDeprecatedEdition) {
     keyVaults = keyVaultsConfigSelectors.getVaultByProvider(provider as any)(
       useUserStore.getState(),
     );

package/src/services/aiModel/client.ts

@@ -0,0 +1,60 @@
+import { clientDB } from '@/database/client/db';
+import { AiInfraRepos } from '@/database/repositories/aiInfra';
+import { AiModelModel } from '@/database/server/models/aiModel';
+import { BaseClientService } from '@/services/baseClientService';
+
+import { IAiModelService } from './type';
+
+export class ClientService extends BaseClientService implements IAiModelService {
+  private get aiModel(): AiModelModel {
+    return new AiModelModel(clientDB as any, this.userId);
+  }
+  private get aiInfraRepos(): AiInfraRepos {
+    return new AiInfraRepos(clientDB as any, this.userId, {});
+  }
+
+  createAiModel: IAiModelService['createAiModel'] = async (params) => {
+    const data = await this.aiModel.create(params);
+
+    return data?.id;
+  };
+
+  getAiProviderModelList: IAiModelService['getAiProviderModelList'] = async (id) => {
+    return this.aiInfraRepos.getAiProviderModelList(id);
+  };
+
+  getAiModelById: IAiModelService['getAiModelById'] = async (id) => {
+    return this.aiModel.findById(id);
+  };
+
+  toggleModelEnabled: IAiModelService['toggleModelEnabled'] = async (params) => {
+    return this.aiModel.toggleModelEnabled(params);
+  };
+
+  updateAiModel: IAiModelService['updateAiModel'] = async (id, providerId, value) => {
+    return this.aiModel.update(id, providerId, value);
+  };
+
+  batchUpdateAiModels: IAiModelService['batchUpdateAiModels'] = async (id, models) => {
+    return this.aiModel.batchUpdateAiModels(id, models);
+  };
+
+  batchToggleAiModels: IAiModelService['batchToggleAiModels'] = async (id, models, enabled) => {
+    return this.aiModel.batchToggleAiModels(id, models, enabled);
+  };
+
+  clearRemoteModels: IAiModelService['clearRemoteModels'] = async (providerId) => {
+    return this.aiModel.clearRemoteModels(providerId);
+  };
+
+  updateAiModelOrder: IAiModelService['updateAiModelOrder'] = async (providerId, items) => {
+    return this.aiModel.updateModelsOrder(providerId, items);
+  };
+
+  deleteAiModel: IAiModelService['deleteAiModel'] = async (params: {
+    id: string;
+    providerId: string;
+  }) => {
+    return this.aiModel.delete(params.id, params.providerId);
+  };
+}

package/src/services/aiModel/index.test.ts

@@ -0,0 +1,10 @@
+import { testService } from '~test-utils';
+
+import { ClientService } from './client';
+import { ServerService } from './server';
+
+describe('aiModelService', () => {
+  testService(ServerService);
+
+  testService(ClientService);
+});

package/src/services/aiModel/index.ts

@@ -0,0 +1,5 @@
+import { ClientService } from './client';
+import { ServerService } from './server';
+
+export const aiModelService =
+  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' ? new ServerService() : new ClientService();

package/src/services/aiModel/server.ts

@@ -0,0 +1,47 @@
+import { lambdaClient } from '@/libs/trpc/client';
+import { IAiModelService } from '@/services/aiModel/type';
+
+export class ServerService implements IAiModelService {
+  createAiModel: IAiModelService['createAiModel'] = async (params) => {
+    return lambdaClient.aiModel.createAiModel.mutate(params);
+  };
+
+  getAiProviderModelList: IAiModelService['getAiProviderModelList'] = async (id) => {
+    return lambdaClient.aiModel.getAiProviderModelList.query({ id });
+  };
+
+  getAiModelById: IAiModelService['getAiModelById'] = async (id) => {
+    return lambdaClient.aiModel.getAiModelById.query({ id });
+  };
+
+  toggleModelEnabled: IAiModelService['toggleModelEnabled'] = async (params) => {
+    return lambdaClient.aiModel.toggleModelEnabled.mutate(params);
+  };
+
+  updateAiModel: IAiModelService['updateAiModel'] = async (id, providerId, value) => {
+    return lambdaClient.aiModel.updateAiModel.mutate({ id, providerId, value });
+  };
+
+  batchUpdateAiModels: IAiModelService['batchUpdateAiModels'] = async (id, models) => {
+    return lambdaClient.aiModel.batchUpdateAiModels.mutate({ id, models });
+  };
+
+  batchToggleAiModels: IAiModelService['batchToggleAiModels'] = async (id, models, enabled) => {
+    return lambdaClient.aiModel.batchToggleAiModels.mutate({ enabled, id, models });
+  };
+
+  clearRemoteModels: IAiModelService['clearRemoteModels'] = async (providerId) => {
+    return lambdaClient.aiModel.clearRemoteModels.mutate({ providerId });
+  };
+
+  updateAiModelOrder: IAiModelService['updateAiModelOrder'] = async (providerId, items) => {
+    return lambdaClient.aiModel.updateAiModelOrder.mutate({ providerId, sortMap: items });
+  };
+
+  deleteAiModel: IAiModelService['deleteAiModel'] = async (params: {
+    id: string;
+    providerId: string;
+  }) => {
+    return lambdaClient.aiModel.removeAiModel.mutate(params);
+  };
+}

package/src/services/aiModel/type.ts

@@ -0,0 +1,30 @@
+/* eslint-disable typescript-sort-keys/interface */
+import {
+  AiModelSortMap,
+  AiProviderModelListItem,
+  CreateAiModelParams,
+  ToggleAiModelEnableParams,
+  UpdateAiModelParams,
+} from '@/types/aiModel';
+
+export interface IAiModelService {
+  createAiModel: (params: CreateAiModelParams) => Promise<any>;
+
+  getAiProviderModelList: (id: string) => Promise<AiProviderModelListItem[]>;
+
+  getAiModelById: (id: string) => Promise<any>;
+
+  toggleModelEnabled: (params: ToggleAiModelEnableParams) => Promise<any>;
+
+  updateAiModel: (id: string, providerId: string, value: UpdateAiModelParams) => Promise<any>;
+
+  batchUpdateAiModels: (id: string, models: AiProviderModelListItem[]) => Promise<any>;
+
+  batchToggleAiModels: (id: string, models: string[], enabled: boolean) => Promise<any>;
+
+  clearRemoteModels: (providerId: string) => Promise<any>;
+
+  updateAiModelOrder: (providerId: string, items: AiModelSortMap[]) => Promise<any>;
+
+  deleteAiModel: (params: { id: string; providerId: string }) => Promise<any>;
+}

package/src/services/aiProvider/client.ts

@@ -0,0 +1,64 @@
+import { clientDB } from '@/database/client/db';
+import { AiInfraRepos } from '@/database/repositories/aiInfra';
+import { AiProviderModel } from '@/database/server/models/aiProvider';
+import { BaseClientService } from '@/services/baseClientService';
+
+import { IAiProviderService } from './type';
+
+export class ClientService extends BaseClientService implements IAiProviderService {
+  private get aiProviderModel(): AiProviderModel {
+    return new AiProviderModel(clientDB as any, this.userId);
+  }
+  private get aiInfraRepos(): AiInfraRepos {
+    let config = {};
+    if (typeof window !== 'undefined') {
+      config = window.global_serverConfigStore.getState().serverConfig.aiProvider || {};
+    }
+
+    return new AiInfraRepos(clientDB as any, this.userId, config);
+  }
+
+  createAiProvider: IAiProviderService['createAiProvider'] = async (params) => {
+    const data = await this.aiProviderModel.create(params);
+
+    return data?.id;
+  };
+
+  getAiProviderById: IAiProviderService['getAiProviderById'] = async (id) => {
+    return this.aiProviderModel.getAiProviderById(id);
+  };
+
+  getAiProviderList: IAiProviderService['getAiProviderList'] = async () => {
+    return await this.aiInfraRepos.getAiProviderList();
+  };
+
+  getAiProviderRuntimeState: IAiProviderService['getAiProviderRuntimeState'] = async () => {
+    const runtimeConfig = await this.aiProviderModel.getAiProviderRuntimeConfig();
+
+    const enabledAiProviders = await this.aiInfraRepos.getUserEnabledProviderList();
+
+    const enabledAiModels = await this.aiInfraRepos.getEnabledModels();
+
+    return { enabledAiModels, enabledAiProviders, runtimeConfig };
+  };
+
+  toggleProviderEnabled: IAiProviderService['toggleProviderEnabled'] = async (id, enabled) => {
+    return this.aiProviderModel.toggleProviderEnabled(id, enabled);
+  };
+
+  updateAiProvider: IAiProviderService['updateAiProvider'] = async (id, value) => {
+    return this.aiProviderModel.update(id, value);
+  };
+
+  updateAiProviderConfig: IAiProviderService['updateAiProviderConfig'] = async (id, value) => {
+    return this.aiProviderModel.updateConfig(id, value);
+  };
+
+  updateAiProviderOrder: IAiProviderService['updateAiProviderOrder'] = async (items) => {
+    return this.aiProviderModel.updateOrder(items);
+  };
+
+  deleteAiProvider: IAiProviderService['deleteAiProvider'] = async (id) => {
+    return this.aiProviderModel.delete(id);
+  };
+}

package/src/services/aiProvider/index.test.ts

@@ -0,0 +1,10 @@
+import { testService } from '~test-utils';
+
+import { ClientService } from './client';
+import { ServerService } from './server';
+
+describe('aiProviderService', () => {
+  testService(ServerService);
+
+  testService(ClientService);
+});

package/src/services/aiProvider/index.ts

@@ -0,0 +1,5 @@
+import { ClientService } from './client';
+import { ServerService } from './server';
+
+export const aiProviderService =
+  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' ? new ServerService() : new ClientService();

package/src/services/aiProvider/server.ts

@@ -0,0 +1,43 @@
+import { lambdaClient } from '@/libs/trpc/client';
+
+import { IAiProviderService } from './type';
+
+export class ServerService implements IAiProviderService {
+  createAiProvider: IAiProviderService['createAiProvider'] = async (params) => {
+    return lambdaClient.aiProvider.createAiProvider.mutate(params);
+  };
+
+  getAiProviderList: IAiProviderService['getAiProviderList'] = async () => {
+    return lambdaClient.aiProvider.getAiProviderList.query();
+  };
+
+  getAiProviderById: IAiProviderService['getAiProviderById'] = async (id) => {
+    return lambdaClient.aiProvider.getAiProviderById.query({ id });
+  };
+
+  toggleProviderEnabled: IAiProviderService['toggleProviderEnabled'] = async (id, enabled) => {
+    return lambdaClient.aiProvider.toggleProviderEnabled.mutate({ enabled, id });
+  };
+
+  updateAiProvider: IAiProviderService['updateAiProvider'] = async (id, value) => {
+    return lambdaClient.aiProvider.updateAiProvider.mutate({ id, value });
+  };
+
+  updateAiProviderConfig: IAiProviderService['updateAiProviderConfig'] = async (id, value) => {
+    return lambdaClient.aiProvider.updateAiProviderConfig.mutate({ id, value });
+  };
+
+  updateAiProviderOrder: IAiProviderService['updateAiProviderOrder'] = async (items) => {
+    return lambdaClient.aiProvider.updateAiProviderOrder.mutate({ sortMap: items });
+  };
+
+  deleteAiProvider: IAiProviderService['deleteAiProvider'] = async (id) => {
+    return lambdaClient.aiProvider.removeAiProvider.mutate({ id });
+  };
+
+  getAiProviderRuntimeState: IAiProviderService['getAiProviderRuntimeState'] = async (
+    isLogin?: boolean,
+  ) => {
+    return lambdaClient.aiProvider.getAiProviderRuntimeState.query({ isLogin });
+  };
+}

package/src/services/aiProvider/type.ts

@@ -0,0 +1,26 @@
+import {
+  AiProviderRuntimeState,
+  AiProviderSortMap,
+  CreateAiProviderParams,
+  UpdateAiProviderConfigParams,
+} from '@/types/aiProvider';
+
+export interface IAiProviderService {
+  createAiProvider: (params: CreateAiProviderParams) => Promise<any>;
+
+  deleteAiProvider: (id: string) => Promise<any>;
+
+  getAiProviderById: (id: string) => Promise<any>;
+
+  getAiProviderList: () => Promise<any>;
+
+  getAiProviderRuntimeState: (isLogin?: boolean) => Promise<AiProviderRuntimeState>;
+
+  toggleProviderEnabled: (id: string, enabled: boolean) => Promise<any>;
+
+  updateAiProvider: (id: string, value: any) => Promise<any>;
+
+  updateAiProviderConfig: (id: string, value: UpdateAiProviderConfigParams) => Promise<any>;
+
+  updateAiProviderOrder: (items: AiProviderSortMap[]) => Promise<any>;
+}

package/src/services/chat.ts

@@ -7,7 +7,7 @@ import { INBOX_GUIDE_SYSTEMROLE } from '@/const/guide';
 import { INBOX_SESSION_ID } from '@/const/session';
 import { DEFAULT_AGENT_CONFIG } from '@/const/settings';
 import { TracePayload, TraceTagMap } from '@/const/trace';
-import { isServerMode } from '@/const/version';
+import { isDeprecatedEdition, isServerMode } from '@/const/version';
 import {
   AgentRuntime,
   AgentRuntimeError,
@@ -42,7 +42,7 @@ import { API_ENDPOINTS } from './_url';
 
 const isCanUseFC = (model: string, provider: string) => {
   // TODO: remove isDeprecatedEdition condition in V2.0
-  if (!isServerMode) {
+  if (isDeprecatedEdition) {
     return modelProviderSelectors.isModelEnabledFunctionCall(model)(useUserStore.getState());
   }
 
@@ -53,7 +53,7 @@ const findAzureDeploymentName = (model: string) => {
   let deploymentId = model;
 
   // TODO: remove isDeprecatedEdition condition in V2.0
-  if (!isServerMode) {
+  if (isDeprecatedEdition) {
     const chatModelCards = modelProviderSelectors.getModelCardsById(ModelProvider.Azure)(
       useUserStore.getState(),
     );
@@ -74,7 +74,7 @@ const findAzureDeploymentName = (model: string) => {
 
 const isEnableFetchOnClient = (provider: string) => {
   // TODO: remove this condition in V2.0
-  if (!isServerMode) {
+  if (isDeprecatedEdition) {
     return modelConfigSelectors.isProviderFetchOnClient(provider)(useUserStore.getState());
   } else {
     return aiProviderSelectors.isProviderFetchOnClient(provider)(useAiInfraStore.getState());
@@ -341,7 +341,7 @@ class ChatService {
     const isBuiltin = Object.values(ModelProvider).includes(provider as any);
 
     // TODO: remove `!isDeprecatedEdition` condition in V2.0
-    if (isServerMode && !isBuiltin) {
+    if (!isDeprecatedEdition && !isBuiltin) {
       const providerConfig = aiProviderSelectors.providerConfigById(provider)(
         useAiInfraStore.getState(),
       );

package/src/services/tableViewer/client.ts

@@ -0,0 +1,16 @@
+import { clientDB } from '@/database/client/db';
+import { TableViewerRepo } from '@/database/repositories/tableViewer';
+import { BaseClientService } from '@/services/baseClientService';
+
+export class ClientService extends BaseClientService {
+  private get tableViewerRepo(): TableViewerRepo {
+    return new TableViewerRepo(clientDB as any, this.userId);
+  }
+
+  getAllTables = async () => this.tableViewerRepo.getAllTables();
+
+  getTableDetails = async (tableName: string) => this.tableViewerRepo.getTableDetails(tableName);
+
+  getTableData = async (tableName: string) =>
+    this.tableViewerRepo.getTableData(tableName, { page: 1, pageSize: 300 });
+}

package/src/services/tableViewer/index.ts

@@ -0,0 +1,3 @@
+import { ClientService } from './client';
+
+export const tableViewerService = new ClientService();

package/src/store/aiInfra/slices/aiProvider/action.ts

@@ -3,7 +3,7 @@ import { SWRResponse, mutate } from 'swr';
 import { StateCreator } from 'zustand/vanilla';
 
 import { DEFAULT_MODEL_PROVIDER_LIST } from '@/config/modelProviders';
-import { isServerMode } from '@/const/version';
+import { isDeprecatedEdition } from '@/const/version';
 import { useClientDataSWR } from '@/libs/swr';
 import { aiProviderService } from '@/services/aiProvider';
 import { AiInfraStore } from '@/store/aiInfra/store';
@@ -170,7 +170,7 @@ export const createAiProviderSlice: StateCreator<
 
   useFetchAiProviderRuntimeState: (isLogin) =>
     useClientDataSWR<AiProviderRuntimeState | undefined>(
-      isServerMode ? [AiProviderSwrKey.fetchAiProviderRuntimeState, isLogin] : null,
+      !isDeprecatedEdition ? [AiProviderSwrKey.fetchAiProviderRuntimeState, isLogin] : null,
       async ([, isLogin]) => {
         if (isLogin) return aiProviderService.getAiProviderRuntimeState();
 

package/src/types/serverConfig.ts

@@ -24,7 +24,13 @@ export interface GlobalServerConfig {
   defaultAgent?: DeepPartial<UserDefaultAgent>;
   enableUploadFileToServer?: boolean;
   enabledAccessCode?: boolean;
+  /**
+   * @deprecated
+   */
   enabledOAuthSSO?: boolean;
+  /**
+   * @deprecated
+   */
   languageModel?: ServerLanguageModel;
   oAuthSSOProviders?: string[];
   systemAgent?: DeepPartial<UserSystemAgentConfig>;

package/src/types/tableViewer.ts

@@ -0,0 +1,30 @@
+export interface TableBasicInfo {
+  count: number;
+  name: string;
+  type: 'BASE TABLE' | 'VIEW';
+}
+
+export interface TableColumnInfo {
+  defaultValue?: string;
+  foreignKey?: {
+    column: string;
+    table: string;
+  };
+  isPrimaryKey: boolean;
+  name: string;
+  nullable: boolean;
+  type: string;
+}
+
+export interface PaginationParams {
+  page: number;
+  pageSize: number;
+  sortBy?: string;
+  sortOrder?: 'asc' | 'desc';
+}
+
+export interface FilterCondition {
+  column: string;
+  operator: 'equals' | 'contains' | 'startsWith' | 'endsWith';
+  value: any;
+}

package/tests/utils.tsx

@@ -9,3 +9,49 @@ const swrConfig = {
 export const withSWR = ({ children }: PropsWithChildren) => (
   <SWRConfig value={swrConfig}>{children}</SWRConfig>
 );
+
+interface TestServiceOptions {
+  /** 是否检查 async */
+  checkAsync?: boolean;
+  /** 自定义的额外检查 */
+  extraChecks?: (method: string, func: () => any) => void;
+  /** 是否跳过某些方法 */
+  skipMethods?: string[];
+}
+
+const builtinSkipProps = new Set(['userId']);
+
+export const testService = (ServiceClass: new () => any, options: TestServiceOptions = {}) => {
+  const { checkAsync = true, skipMethods = ['userId'], extraChecks } = options;
+
+  describe(ServiceClass.name, () => {
+    it('should implement all methods as arrow functions', () => {
+      const service = new ServiceClass();
+
+      const methods = Object.getOwnPropertyNames(service).filter(
+        (method) => !builtinSkipProps.has(method) || !skipMethods.includes(method),
+      );
+
+      methods.forEach((method) => {
+        const func = service[method];
+        // 检查是否为函数
+        expect(typeof func).toBe('function');
+
+        const funcString = func.toString();
+
+        // 验证是否是箭头函数
+        expect(funcString).toContain('=>');
+
+        // 可选的 async 检查
+        if (checkAsync) {
+          expect(funcString).toMatch(/^async.*=>/);
+        }
+
+        // 运行额外的自定义检查
+        if (extraChecks) {
+          extraChecks(method, func);
+        }
+      });
+    });
+  });
+};