src/components/Questionnaire/QuestionnaireForm.tsx (3)

81-93: Enhance mutation implementation with better error handling and type safety

While the migration to TanStack's useMutation is good, consider these improvements:

1. Add type safety for the error object
2. Provide more context in error messages
3. Consider adding retry strategy for transient failures

  const { mutate: submitBatch, isPending: isProcessing } = useMutation({
    mutationFn: mutate(routes.batchRequest),
+   retry: (failureCount, error) => failureCount < 3 && isRetryableError(error),
    onSuccess: () => {
      toast.success("Questionnaire submitted successfully");
      onSubmit?.();
    },
-   onError: (error: any) => {
+   onError: (error: Error & { results?: ValidationErrorResponse[] }) => {
      if (error.results) {
        handleSubmissionError(error.results as ValidationErrorResponse[]);
      }
-     toast.error("Failed to submit questionnaire");
+     toast.error(`Failed to submit questionnaire: ${error.message || 'Unknown error occurred'}`);
    },
  });

---

246-247: Add error boundary around mutation execution

The mutation execution could benefit from try-catch error handling to gracefully handle synchronous errors.

-   // Execute the mutation
-   submitBatch({ requests });
+   try {
+     // Execute the mutation
+     submitBatch({ requests });
+   } catch (error) {
+     console.error('Failed to execute mutation:', error);
+     toast.error('An unexpected error occurred while submitting the questionnaire');
+   }

---

212-214: Consider adding explicit type predicate for response filtering

The response filtering logic could be more explicit with a type predicate function.

+ const isNonStructuredResponse = (response: QuestionnaireResponse): boolean => !response.structured_type;
+
- const nonStructuredResponses = form.responses.filter(
-   (response) => !response.structured_type,
- );
+ const nonStructuredResponses = form.responses.filter(isNonStructuredResponse);

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

src/components/Questionnaire/QuestionnaireForm.tsx (2)

82-95: Improve error handling type safety

The error handling could be more type-safe. Consider creating a custom type for the error response structure.

-    onError: (error: HTTPError) => {
-      const errorData = error.cause;
-      if (errorData?.results) {
+    onError: (error: HTTPError) => {
+      type BatchErrorResponse = {
+        results?: ValidationErrorResponse[];
+      };
+      const errorData = error.cause as BatchErrorResponse;
+      if (errorData?.results) {

---

Line range hint 214-248: Extract submission preparation logic for better readability

Consider extracting the request preparation logic into a separate helper function to improve code organization.

+  const prepareSubmissionRequest = (form: QuestionnaireFormState): BatchRequest | null => {
+    const nonStructuredResponses = form.responses.filter(
+      (response) => !response.structured_type,
+    );
+
+    if (nonStructuredResponses.length === 0) return null;
+
+    return {
+      url: `/api/v1/questionnaire/${form.questionnaire.slug}/submit/`,
+      method: "POST",
+      reference_id: form.questionnaire.id,
+      body: {
+        resource_id: encounterId,
+        encounter: encounterId,
+        patient: patientId,
+        results: nonStructuredResponses
+          .filter((response) => response.values.length > 0)
+          .map((response) => ({
+            question_id: response.question_id,
+            values: response.values.map((value) => ({
+              ...(value.value_code
+                ? { value_code: value.value_code }
+                : { value: String(value.value) }),
+            })),
+            note: response.note,
+            body_site: response.body_site,
+            method: response.method,
+          })),
+      },
+    };
+  };

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro