Add R API container to dev dependencies script, and consume R API from app

.github/workflows/integration-tests.yml

@@ -25,7 +25,7 @@ jobs:
         with:
           data-file: ./mocks/mockoon.json
           port: 8001
-      - name: Check API server is running
+      - name: Check mocked R API server is running
         run: curl -s http://localhost:8001/mock-smoke
       - name: Set environment variables for app
         run: scripts/ci/copy-env-vars-to-dot-env-file

README.md

@@ -4,19 +4,18 @@ npx nuxi analyze
 
 # Tests
 
-To run unit tests, component tests and integration tests, first start the Mockoon server:
-```bash
-npx mockoon-cli start --data ./mocks/mockoon.json
-```
-
-Then, to run unit tests:
+To run unit tests:
 ```bash
 npm run test:unit
 # Or with coverage:
 npm run test:unit:coverage
 ```
 
-To run integration tests:
+To run integration tests, first start the Mockoon server:
+```bash
+npx mockoon-cli start --data ./mocks/mockoon.json
+```
+Then run:
 ```bash
 npm run test:integration
 ```
@@ -28,7 +27,7 @@ npm run test:ssr
 
 Run full-stack tests:
 
-1. Stop the Mockoon server
+1. Ensure Mockoon server is not running
 1. Run:
 ```bash
 npm run test:e2e

components/SideBar.vue

@@ -57,7 +57,7 @@
 
 <script lang="ts" setup>
 import { CIcon } from "@coreui/icons-vue";
-import type { VersionData } from "@/types/apiResponseTypes";
+import type { VersionData } from "@/types/daedalusApiResponseTypes";
 
 const { data: versionData } = useFetch("/api/versions") as { data: Ref<VersionData> };
 

server/api/versions.get.ts

@@ -1,19 +1,13 @@
 import { getVersionData } from "@/server/handlers/versions";
-import { errorMessage } from "@/server/utils/helpers";
-import type { VersionData } from "@/types/apiResponseTypes";
+import { defineEventHandlerWithErrors } from "@/server/utils/defineEventHandlerWithErrors";
+import type { VersionDataResponse } from "@/types/daedalusApiResponseTypes";
 
-export default defineEventHandler(async (event): Promise<VersionData> => {
-  // Delegate to handler function getVersionData so that the logic can be unit-tested.
-  const versionDataResponse = await getVersionData(event);
+export default defineEventHandlerWithErrors(
+  // TODO: Consider cacheing this server-side https://nitro.unjs.io/guide/cache
+  defineEventHandler(async (event): Promise<VersionDataResponse> => {
+    // Delegate to getVersionData so that the logic can be unit-tested.
+    const versionDataResponse = await getVersionData(event);
 
-  if (versionDataResponse.errors || !versionDataResponse.data) {
-    throw createError({
-      statusCode: versionDataResponse.statusCode,
-      statusMessage: versionDataResponse.statusText,
-      message: errorMessage(versionDataResponse.errors),
-      data: versionDataResponse.errors,
-    });
-  } else {
-    return versionDataResponse.data;
-  }
-});
+    return versionDataResponse;
+  }),
+);

server/handlers/versions.ts

@@ -1,7 +1,7 @@
 import type { EventHandlerRequest, H3Event } from "h3";
 import { fetchRApi } from "@/server/utils/rApi";
 import packageJson from "@/package.json";
-import type { VersionData, VersionDataResponse } from "@/types/apiResponseTypes";
+import type { VersionData, VersionDataResponse } from "@/types/daedalusApiResponseTypes";
 
 const rApiVersionEndpoint = "/";
 

server/utils/defineEventHandlerWithErrors.ts

@@ -0,0 +1,20 @@
+import type { EventHandler, EventHandlerRequest } from "h3";
+import type { ApiResponse } from "@/types/daedalusApiResponseTypes";
+
+export const defineEventHandlerWithErrors = <T extends EventHandlerRequest, D>(
+  handler: EventHandler<T, D>,
+): EventHandler<T, D> =>
+  defineEventHandler<T>(async (event) => {
+    const response = await handler(event) as ApiResponse;
+
+    if (response.errors || !response.data) {
+      throw createError({
+        statusCode: response.statusCode,
+        statusMessage: response.statusText,
+        message: errorMessage(response.errors),
+        data: response.errors,
+      });
+    } else {
+      return response.data;
+    }
+  });

server/utils/helpers.ts

@@ -1,8 +1,8 @@
-import type { ApiError } from "@/types/apiResponseTypes";
+import type { ApiError } from "@/types/daedalusApiResponseTypes";
 
 // Convert list of error objects to string
 export const errorMessage = (errors: Array<ApiError> | null) => {
   return errors?.map((apiError) => {
     return [apiError.error, apiError.detail].join(": ");
   }).join(", ");
 };

types/apiResponseTypes.ts → types/daedalusApiResponseTypes.ts

@@ -4,8 +4,7 @@ export interface ApiError {
   error: string
   detail: string
 }
-
-interface ServerApiResponse<T extends object> {
+export interface ApiResponse<T extends object = object> {
   statusText: string
   statusCode: number
   errors: Array<ApiError> | null
@@ -18,4 +17,4 @@ export interface VersionData {
   daedalusWebApp: string
 }
 
-export interface VersionDataResponse extends ServerApiResponse<VersionData> { }
+export interface VersionDataResponse extends ApiResponse<VersionData> { }