Parse varsel API response

package.json

@@ -58,7 +58,6 @@
         "js-cookie": "^3.0.5",
         "postcss-modules": "latest",
         "prettier": "^3.2.5",
-        "ts-pattern": "^5.0.5",
-        "zod": "^3.22.4"
+        "ts-pattern": "^5.0.5"
     }
 }

packages/server/package.json

@@ -17,7 +17,8 @@
         "decorator-shared": "workspace:*",
         "unleash-client": "^4.1.1",
         "csp-header": "^5.2.1",
-        "@builder.io/partytown": "^0.8.1"
+        "@builder.io/partytown": "^0.8.1",
+        "zod": "^3.22.4"
     },
     "devDependencies": {
         "msw": "^2.2.14",

packages/server/src/notifications.test.ts

@@ -11,6 +11,23 @@ import { SetupServerApi, setupServer } from "msw/node";
 import { env } from "./env/server";
 import { Varsler, getNotifications } from "./notifications";
 
+type AnyOkUnion = {
+    ok: boolean;
+    [key: string]: unknown;
+};
+
+export function expectOK<T extends AnyOkUnion>(
+    result: T,
+): asserts result is Extract<T, { ok: true }> {
+    expect(result.ok).toBe(true);
+}
+
+export function expectNotOK<T extends AnyOkUnion>(
+    result: T,
+): asserts result is Extract<T, { ok: false }> {
+    expect(result.ok).toBe(false);
+}
+
 describe("notifications", () => {
     let server: SetupServerApi;
 
@@ -64,7 +81,8 @@ describe("notifications", () => {
             }),
         });
 
-        expect(result).toEqual([
+        expectOK(result);
+        expect(result.data).toEqual([
             {
                 id: "a",
                 type: "task",

packages/server/src/notifications.ts

@@ -1,19 +1,24 @@
 import { env } from "./env/server";
+import { z } from "zod";
 
-type Varsel = {
-    eventId: string;
-    type: "oppgave" | "beskjed";
-    tidspunkt: string;
-    isMasked: boolean;
-    tekst: string | null;
-    link: string | null;
-    eksternVarslingKanaler: string[];
-};
+const varselSchema = z.object({
+    eventId: z.string(),
+    type: z.enum(["oppgave", "beskjed"]),
+    tidspunkt: z.string(),
+    isMasked: z.boolean(),
+    tekst: z.string().nullable(),
+    link: z.string().nullable(),
+    eksternVarslingKanaler: z.array(z.string()),
+});
 
-export type Varsler = {
-    oppgaver: Varsel[];
-    beskjeder: Varsel[];
-};
+const varslerSchema = z.object({
+    oppgaver: z.array(varselSchema),
+    beskjeder: z.array(varselSchema),
+});
+
+type Varsel = z.infer<typeof varselSchema>;
+
+export type Varsler = z.infer<typeof varslerSchema>;
 
 export type MaskedNotification = {
     id: string;
@@ -54,11 +59,51 @@ const varslerToNotifications = (varsler: Varsler): Notification[] =>
         ),
     );
 
-export const getNotifications = async ({ request }: { request: Request }) =>
-    fetch(`${env.VARSEL_API_URL}/varselbjelle/varsler`, {
-        headers: {
-            cookie: request.headers.get("cookie") || "",
+type Result<Data> = { ok: true; data: Data } | { ok: false; error: Error };
+
+export const getNotifications = async ({
+    request,
+}: {
+    request: Request;
+}): Promise<Result<Notification[]>> => {
+    const fetchResult = await fetch(
+        `${env.VARSEL_API_URL}/varselbjelle/varsler`,
+        {
+            headers: {
+                cookie: request.headers.get("cookie") || "",
+            },
         },
-    })
-        .then((res) => res.json() as Promise<Varsler>)
-        .then(varslerToNotifications);
+    );
+
+    if (!fetchResult.ok) {
+        return {
+            ok: false,
+            error: Error(await fetchResult.text()),
+        };
+    }
+
+    try {
+        const json = await fetchResult.json();
+
+        const validationResult = varslerSchema.safeParse(json);
+        if (!validationResult.success) {
+            return {
+                ok: false,
+                error: validationResult.error,
+            };
+        }
+
+        return {
+            ok: true,
+            data: varslerToNotifications(validationResult.data),
+        };
+    } catch (error) {
+        if (error instanceof Error) {
+            return {
+                ok: false,
+                error,
+            };
+        }
+        throw error;
+    }
+};

packages/server/src/request-handler.ts

@@ -24,6 +24,7 @@ import { makeFrontpageUrl } from "decorator-shared/urls";
 import { csrHandler } from "./csr";
 import { search } from "./search";
 import { getNotifications } from "./notifications";
+import html from "decorator-shared/html";
 
 type FileSystemService = {
     getFile: (path: string) => Blob;
@@ -165,20 +166,24 @@ const requestHandler = async (
 
                     // @TODO: Tests for important urls, like logout
                     return match(data.context)
-                        .with("privatperson", async () =>
-                            UserMenuDropdown({
+                        .with("privatperson", async () => {
+                            const result = await getNotifications({
+                                request,
+                            });
+                            if (!result.ok) {
+                                return html`<div>Error</div>`;
+                            }
+                            return UserMenuDropdown({
                                 texts: localTexts,
                                 name: data.name,
-                                notifications: await getNotifications({
-                                    request,
-                                }),
+                                notifications: result.data,
                                 level: data.level,
                                 logoutUrl: logoutUrl as string,
                                 minsideUrl: clientEnv.MIN_SIDE_URL,
                                 personopplysningerUrl:
                                     clientEnv.PERSONOPPLYSNINGER_URL,
-                            }),
-                        )
+                            });
+                        })
                         .with("arbeidsgiver", () =>
                             ArbeidsgiverUserMenu({
                                 texts: localTexts,