diff --git a/packages/features/user-analyses/src/server/api.ts b/packages/features/user-analyses/src/server/api.ts
index e44faec..e7d9ed2 100644
--- a/packages/features/user-analyses/src/server/api.ts
+++ b/packages/features/user-analyses/src/server/api.ts
@@ -43,31 +43,13 @@ class UserAnalysesApi {
   async getUserAnalysis(
     analysisOrderId: number,
   ): Promise<AnalysisResultDetailsMapped | null> {
-    const authUser = await this.client.auth.getUser();
-    const { data, error: userError } = authUser;
-
-    if (userError) {
-      console.error('Failed to get user', userError);
-      throw userError;
-    }
-
-    const { user } = data;
-
     const analysisOrder = await this.getAnalysisOrder({ analysisOrderId });
     const orderedAnalysisElementIds = analysisOrder.analysis_element_ids ?? [];
     if (orderedAnalysisElementIds.length === 0) {
       console.error('No ordered analysis element ids found for analysis order id=', analysisOrderId);
       return null;
     }
-    const { data: orderedAnalysisElements, error: orderedAnalysisElementsError } = await this.client
-      .schema('medreport')
-      .from('analysis_elements')
-      .select('analysis_id_original,analysis_name_lab')
-      .in('id', orderedAnalysisElementIds);
-    if (orderedAnalysisElementsError) {
-      console.error('Failed to get ordered analysis elements for analysis order id=', analysisOrderId, orderedAnalysisElementsError);
-      throw orderedAnalysisElementsError;
-    }
+    const orderedAnalysisElements = await this.getOrderedAnalysisElements({ analysisOrderId, orderedAnalysisElementIds });
 
     const orderedAnalysisElementOriginalIds = orderedAnalysisElements.map(({ analysis_id_original }) => analysis_id_original);
     if (orderedAnalysisElementOriginalIds.length === 0) {
@@ -75,6 +57,44 @@ class UserAnalysesApi {
       return null;
     }
 
+    const responseWithElements = await this.getAnalysisResponseWithElements({ analysisOrderId });
+    if (!responseWithElements) {
+      return null;
+    }
+
+    const mappedOrderedAnalysisElements = await this.getMappedOrderedAnalysisElements({
+      analysisResponseElements: responseWithElements.elements,
+      orderedAnalysisElements,
+    });
+
+    const feedback = responseWithElements.summary?.doctor_analysis_feedback?.[0];
+    return {
+      id: analysisOrderId,
+      order: {
+        status: analysisOrder.status,
+        medusaOrderId: analysisOrder.medusa_order_id,
+        createdAt: new Date(analysisOrder.created_at),
+      },
+      orderedAnalysisElementIds,
+      orderedAnalysisElements: mappedOrderedAnalysisElements,
+      summary:
+        feedback?.status === 'COMPLETED'
+          ? (responseWithElements.summary?.doctor_analysis_feedback?.[0] ?? null)
+          : null,
+    };
+  }
+
+  async getAnalysisResponseWithElements({
+    analysisOrderId,
+  }: {
+    analysisOrderId: number;
+  }) {
+    const { data, error: userError } = await this.client.auth.getUser();
+    if (userError) {
+      throw userError;
+    }
+    const { user } = data;
+
     const { data: analysisResponse } = await this.client
       .schema('medreport')
       .from('analysis_responses')
@@ -87,23 +107,45 @@ class UserAnalysesApi {
       .eq('analysis_order_id', analysisOrderId)
       .throwOnError();
 
-    const responseWithElements = analysisResponse?.[0] as AnalysisResultDetails | null;
-    if (!responseWithElements) {
-      return null;
+    return analysisResponse?.[0] as AnalysisResultDetails | null;
+  }
+
+  async getOrderedAnalysisElements({
+    analysisOrderId,
+    orderedAnalysisElementIds,
+  }: {
+    analysisOrderId: number;
+    orderedAnalysisElementIds: number[];
+  }) {
+    const { data: orderedAnalysisElements, error: orderedAnalysisElementsError } = await this.client
+      .schema('medreport')
+      .from('analysis_elements')
+      .select('analysis_id_original,analysis_name_lab')
+      .in('id', orderedAnalysisElementIds);
+    if (orderedAnalysisElementsError) {
+      console.error(`Failed to get ordered analysis elements for analysis order id=${analysisOrderId}`, orderedAnalysisElementsError);
+      throw orderedAnalysisElementsError;
     }
+    return orderedAnalysisElements;
+  }
 
-    const analysisResponseElements = responseWithElements.elements;
-
-    const feedback = responseWithElements.summary?.doctor_analysis_feedback?.[0];
-
+  async getMappedOrderedAnalysisElements({
+    analysisResponseElements,
+    orderedAnalysisElements,
+  }: {
+    analysisResponseElements: AnalysisResultDetails['elements'];
+    orderedAnalysisElements: { analysis_id_original: string; analysis_name_lab: string }[];
+  }) {
     const mappedOrderedAnalysisElements = orderedAnalysisElements.map(({ analysis_id_original, analysis_name_lab }) => {
-      return this.getOrderedAnalysisElements({
+      return this.getOrderedAnalysisElement({
         analysisIdOriginal: analysis_id_original,
         analysisNameLab: analysis_name_lab,
         analysisResponseElements,
       });
     }).sort((a, b) => a.analysisName.localeCompare(b.analysisName));
-    const nestedAnalysisElementIds = mappedOrderedAnalysisElements.map(({ results }) => results?.nestedElements.map(({ analysisElementOriginalId }) => analysisElementOriginalId)).flat().filter(Boolean);
+    const nestedAnalysisElementIds = mappedOrderedAnalysisElements
+      .map(({ results }) => results?.nestedElements.map(({ analysisElementOriginalId }) => analysisElementOriginalId))
+      .flat().filter(Boolean);
     if (nestedAnalysisElementIds.length > 0) {
       const { data: nestedAnalysisElements, error: nestedAnalysisElementsError } = await this.client
         .schema('medreport')
@@ -139,29 +181,18 @@ class UserAnalysesApi {
                 analysisElementOriginalId,
                 analysisName: nestedAnalysisElement.analysis_name_lab,
               });
+            } else {
+              console.error('Nested analysis element not found for analysis element original id=', analysisElementOriginalId);
             }
           });
         });
       }
     }
 
-    return {
-      id: analysisOrderId,
-      order: {
-        status: analysisOrder.status,
-        medusaOrderId: analysisOrder.medusa_order_id,
-        createdAt: new Date(analysisOrder.created_at),
-      },
-      orderedAnalysisElementIds,
-      orderedAnalysisElements: mappedOrderedAnalysisElements,
-      summary:
-        feedback?.status === 'COMPLETED'
-          ? (responseWithElements.summary?.doctor_analysis_feedback?.[0] ?? null)
-          : null,
-    };
+    return mappedOrderedAnalysisElements;
   }
 
-  getOrderedAnalysisElements({
+  getOrderedAnalysisElement({
     analysisIdOriginal,
     analysisNameLab,
     analysisResponseElements,