@lobehub/lobehub 2.1.24 → 2.1.26

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

@@ -72,7 +72,7 @@ export const ragEvalRouter = router({
     }),
 
   removeDataset: ragEvalProcedure
-    .input(z.object({ id: z.number() }))
+    .input(z.object({ id: z.string() }))
     .mutation(async ({ input, ctx }) => {
       return ctx.datasetModel.delete(input.id);
     }),
@@ -80,7 +80,7 @@ export const ragEvalRouter = router({
   updateDataset: ragEvalProcedure
     .input(
       z.object({
-        id: z.number(),
+        id: z.string(),
         value: insertEvalDatasetsSchema.partial(),
       }),
     )
@@ -92,7 +92,7 @@ export const ragEvalRouter = router({
   createDatasetRecords: ragEvalProcedure
     .input(
       z.object({
-        datasetId: z.number(),
+        datasetId: z.string(),
         question: z.string(),
         ideal: z.string().optional(),
         referenceFiles: z.array(z.string()).optional(),
@@ -105,13 +105,13 @@ export const ragEvalRouter = router({
     }),
 
   getDatasetRecords: ragEvalProcedure
-    .input(z.object({ datasetId: z.number() }))
+    .input(z.object({ datasetId: z.string() }))
     .query(async ({ ctx, input }): Promise<EvalDatasetRecord[]> => {
       return ctx.datasetRecordModel.query(input.datasetId);
     }),
 
   removeDatasetRecords: ragEvalProcedure
-    .input(z.object({ id: z.number() }))
+    .input(z.object({ id: z.string() }))
     .mutation(async ({ input, ctx }) => {
       return ctx.datasetRecordModel.delete(input.id);
     }),
@@ -119,7 +119,7 @@ export const ragEvalRouter = router({
   updateDatasetRecords: ragEvalProcedure
     .input(
       z.object({
-        id: z.number(),
+        id: z.string(),
         value: z
           .object({
             question: z.string(),
@@ -137,7 +137,7 @@ export const ragEvalRouter = router({
   importDatasetRecords: ragEvalProcedure
     .input(
       z.object({
-        datasetId: z.number(),
+        datasetId: z.string(),
         pathname: z.string(),
       }),
     )
@@ -173,7 +173,7 @@ export const ragEvalRouter = router({
 
   // Evaluation operations
   startEvaluationTask: ragEvalProcedure
-    .input(z.object({ id: z.number() }))
+    .input(z.object({ id: z.string() }))
     .mutation(async ({ input, ctx }) => {
       // Start evaluation task
       const evaluation = await ctx.evaluationModel.findById(input.id);
@@ -238,7 +238,7 @@ export const ragEvalRouter = router({
     }),
 
   checkEvaluationStatus: ragEvalProcedure
-    .input(z.object({ id: z.number() }))
+    .input(z.object({ id: z.string() }))
     .query(async ({ input, ctx }) => {
       const evaluation = await ctx.evaluationModel.findById(input.id);
 
@@ -288,7 +288,7 @@ export const ragEvalRouter = router({
     }),
 
   removeEvaluation: ragEvalProcedure
-    .input(z.object({ id: z.number() }))
+    .input(z.object({ id: z.string() }))
     .mutation(async ({ input, ctx }) => {
       return ctx.evaluationModel.delete(input.id);
     }),

package/src/services/ragEval.ts

@@ -12,7 +12,7 @@ import { uploadService } from '@/services/upload';
 
 class RAGEvalService {
   // Dataset
-  createDataset = async (params: CreateNewEvalDatasets): Promise<number | undefined> => {
+  createDataset = async (params: CreateNewEvalDatasets): Promise<string | undefined> => {
     return lambdaClient.ragEval.createDataset.mutate(params);
   };
 
@@ -20,34 +20,34 @@ class RAGEvalService {
     return lambdaClient.ragEval.getDatasets.query({ knowledgeBaseId });
   };
 
-  removeDataset = async (id: number): Promise<void> => {
+  removeDataset = async (id: string): Promise<void> => {
     await lambdaClient.ragEval.removeDataset.mutate({ id });
   };
 
   updateDataset = async (
-    id: number,
+    id: string,
     value: Partial<typeof insertEvalDatasetsSchema>,
   ): Promise<void> => {
     await lambdaClient.ragEval.updateDataset.mutate({ id, value });
   };
 
   // Dataset Records
-  getDatasetRecords = async (datasetId: number): Promise<EvalDatasetRecord[]> => {
+  getDatasetRecords = async (datasetId: string): Promise<EvalDatasetRecord[]> => {
     return lambdaClient.ragEval.getDatasetRecords.query({ datasetId });
   };
 
-  removeDatasetRecord = async (id: number): Promise<void> => {
+  removeDatasetRecord = async (id: string): Promise<void> => {
     await lambdaClient.ragEval.removeDatasetRecords.mutate({ id });
   };
 
-  importDatasetRecords = async (datasetId: number, file: File): Promise<void> => {
+  importDatasetRecords = async (datasetId: string, file: File): Promise<void> => {
     const { path } = await uploadService.uploadToServerS3(file, { directory: 'ragEval' });
 
     await lambdaClient.ragEval.importDatasetRecords.mutate({ datasetId, pathname: path });
   };
 
   // Evaluation
-  createEvaluation = async (params: CreateNewEvalEvaluation): Promise<number | undefined> => {
+  createEvaluation = async (params: CreateNewEvalEvaluation): Promise<string | undefined> => {
     return lambdaClient.ragEval.createEvaluation.mutate(params);
   };
 
@@ -55,15 +55,15 @@ class RAGEvalService {
     return lambdaClient.ragEval.getEvaluationList.query({ knowledgeBaseId });
   };
 
-  startEvaluationTask = async (id: number) => {
+  startEvaluationTask = async (id: string) => {
     return lambdaClient.ragEval.startEvaluationTask.mutate({ id });
   };
 
-  removeEvaluation = async (id: number): Promise<void> => {
+  removeEvaluation = async (id: string): Promise<void> => {
     await lambdaClient.ragEval.removeEvaluation.mutate({ id });
   };
 
-  checkEvaluationStatus = async (id: number): Promise<{ success: boolean }> => {
+  checkEvaluationStatus = async (id: string): Promise<{ success: boolean }> => {
     return lambdaClient.ragEval.checkEvaluationStatus.query({ id });
   };
 }

package/src/store/library/slices/ragEval/actions/dataset.ts

@@ -19,10 +19,10 @@ const FETCH_DATASET_RECORD_KEY = 'FETCH_DATASET_RECORD_KEY';
 export interface RAGEvalDatasetAction {
   createNewDataset: (params: CreateNewEvalDatasets) => Promise<void>;
 
-  importDataset: (file: File, datasetId: number) => Promise<void>;
+  importDataset: (file: File, datasetId: string) => Promise<void>;
   refreshDatasetList: () => Promise<void>;
-  removeDataset: (id: number) => Promise<void>;
-  useFetchDatasetRecords: (datasetId: number | null) => SWRResponse<EvalDatasetRecord[]>;
+  removeDataset: (id: string) => Promise<void>;
+  useFetchDatasetRecords: (datasetId: string | null) => SWRResponse<EvalDatasetRecord[]>;
   useFetchDatasets: (knowledgeBaseId: string) => SWRResponse<RAGEvalDataSetItem[]>;
 }
 

package/src/store/library/slices/ragEval/actions/evaluation.ts

@@ -9,13 +9,13 @@ import { type KnowledgeBaseStore } from '@/store/library/store';
 const FETCH_EVALUATION_LIST_KEY = 'FETCH_EVALUATION_LIST_KEY';
 
 export interface RAGEvalEvaluationAction {
-  checkEvaluationStatus: (id: number) => Promise<void>;
+  checkEvaluationStatus: (id: string) => Promise<void>;
 
   createNewEvaluation: (params: CreateNewEvalEvaluation) => Promise<void>;
   refreshEvaluationList: () => Promise<void>;
 
-  removeEvaluation: (id: number) => Promise<void>;
-  runEvaluation: (id: number) => Promise<void>;
+  removeEvaluation: (id: string) => Promise<void>;
+  runEvaluation: (id: string) => Promise<void>;
 
   useFetchEvaluationList: (knowledgeBaseId: string) => SWRResponse<RAGEvalDataSetItem[]>;
 }