fix: response rag

src/application/hooks/rag/useClassicalQuery.ts

@@ -25,4 +25,4 @@ export function useClassicalQuery() {
         mode: request.mode,
       }),
   });
-}
+}

src/application/hooks/rag/useRagQuery.ts

@@ -17,4 +17,4 @@ export function useRagQuery() {
         top_k: request.topK,
       }),
   });
-}
+}

src/domain/entities/rag/chunkResponse.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+
+/**
+ * Schema Zod pour un chunk retourné par LightRAG.
+ * Correspond au modèle backend ChunkResponse.
+ */
+export const ChunkResponseSchema = z.object({
+  reference_id: z.string().nullable().optional(),
+  content: z.string(),
+  file_path: z.string(),
+  chunk_id: z.string(),
+});
+
+/**
+ * Type TypeScript dérivé du schema Zod.
+ */
+export type ChunkResponse = z.infer<typeof ChunkResponseSchema>;

src/domain/entities/rag/classicalQueryResponse.ts

@@ -0,0 +1,38 @@
+import { z } from "zod";
+
+/**
+ * Schema Zod pour un chunk retourné par Classical RAG.
+ * Correspond au modèle backend ClassicalChunkResponse.
+ */
+export const ClassicalChunkResponseSchema = z.object({
+  chunk_id: z.string(),
+  content: z.string(),
+  file_path: z.string(),
+  relevance_score: z.number(),
+  metadata: z.any().default({}),
+  bm25_score: z.number().optional(),
+  vector_score: z.number().optional(),
+  combined_score: z.number().optional(),
+});
+
+/**
+ * Type TypeScript dérivé du schema Zod.
+ */
+export type ClassicalChunkResponse = z.infer<typeof ClassicalChunkResponseSchema>;
+
+/**
+ * Schema Zod pour la réponse complète de Classical RAG.
+ * Correspond au modèle backend ClassicalQueryResponse.
+ */
+export const ClassicalQueryResponseSchema = z.object({
+  status: z.string(),
+  message: z.string().default(""),
+  queries: z.array(z.string()).default([]),
+  chunks: z.array(ClassicalChunkResponseSchema).default([]),
+  mode: z.string().default("vector"),
+});
+
+/**
+ * Type TypeScript dérivé du schema Zod.
+ */
+export type ClassicalQueryResponse = z.infer<typeof ClassicalQueryResponseSchema>;

src/domain/entities/rag/queryRequest.ts

@@ -28,9 +28,3 @@ export interface ClassicalQueryRequest {
   mode: ClassicalQueryMode;
 }
 
-export interface RagQueryResponse {
-  status: string;
-  message?: string;
-  data: unknown;
-  metadata?: unknown;
-}

src/domain/ports/rag/ragQueryPort.ts

@@ -1,10 +1,8 @@
-import type {
-  LightRAGQueryRequest,
-  ClassicalQueryRequest,
-  RagQueryResponse,
-} from "@/domain/entities/rag/queryRequest";
+import type { LightRAGQueryRequest, ClassicalQueryRequest } from "@/domain/entities/rag/queryRequest";
+import type { ChunkResponse } from "@/domain/entities/rag/chunkResponse";
+import type { ClassicalQueryResponse } from "@/domain/entities/rag/classicalQueryResponse";
 
 export interface IRagQueryPort {
-  queryLightRAG(request: LightRAGQueryRequest): Promise<RagQueryResponse>;
-  queryClassical(request: ClassicalQueryRequest): Promise<RagQueryResponse>;
-}
+  queryLightRAG(request: LightRAGQueryRequest): Promise<ChunkResponse[]>;
+  queryClassical(request: ClassicalQueryRequest): Promise<ClassicalQueryResponse>;
+}

src/infrastructure/api/rag/ragQueryApi.ts

@@ -1,15 +1,7 @@
 import { ragApiClient } from "@/infrastructure/api/ragAxiosInstance";
 import type { IRagQueryPort } from "@/domain/ports/rag/ragQueryPort";
-
-function mapMetadata(metadata: Record<string, unknown> | undefined): Record<string, unknown> | undefined {
-  if (!metadata) return undefined;
-  const mapped: Record<string, unknown> = {};
-  for (const [key, value] of Object.entries(metadata)) {
-    const camelKey = key.replaceAll(/_([a-z])/g, (_, letter) => letter.toUpperCase());
-    mapped[camelKey] = value;
-  }
-  return mapped;
-}
+import { ChunkResponseSchema } from "@/domain/entities/rag/chunkResponse";
+import { ClassicalQueryResponseSchema } from "@/domain/entities/rag/classicalQueryResponse";
 
 export const ragQueryApi: IRagQueryPort = {
   async queryLightRAG(request) {
@@ -19,16 +11,8 @@ export const ragQueryApi: IRagQueryPort = {
       mode: request.mode,
       top_k: request.top_k,
     });
-    if (Array.isArray(response.data)) {
-      return { status: "success", data: response.data, message: undefined, metadata: undefined };
-    }
-    const data = response.data as Record<string, unknown>;
-    return {
-      status: data.status as string,
-      message: data.message as string | undefined,
-      data: data.data,
-      metadata: mapMetadata(data.metadata as Record<string, unknown> | undefined),
-    };
+    const parsed = ChunkResponseSchema.array().parse(response.data);
+    return parsed;
   },
 
   async queryClassical(request) {
@@ -45,15 +29,7 @@ export const ragQueryApi: IRagQueryPort = {
       body.vector_distance_threshold = request.vector_distance_threshold;
     }
     const response = await ragApiClient.post<unknown>("/api/v1/classical/query", body);
-    if (Array.isArray(response.data)) {
-      return { status: "success", data: response.data, message: undefined, metadata: undefined };
-    }
-    const data = response.data as Record<string, unknown>;
-    return {
-      status: data.status as string,
-      message: data.message as string | undefined,
-      data: data.data,
-      metadata: mapMetadata(data.metadata as Record<string, unknown> | undefined),
-    };
+    const parsed = ClassicalQueryResponseSchema.parse(response.data);
+    return parsed;
   },
-};
+};