chore: improved error handling

jaflaten · jaflaten · commit 1d0d9f7b5c9d · 2025-03-11T15:46:42.000+01:00
diff --git a/src/app/(fhir)/fhir/resources/sykmelding/write-to-ehr/route.ts b/src/app/(fhir)/fhir/resources/sykmelding/write-to-ehr/route.ts
@@ -1,16 +1,15 @@
 import { logger } from '@navikt/next-logger'
 
 import { ensureValidFhirAuth } from '@fhir/auth/verify'
-import {
-    FhirDocumentReferenceResponse,
-    FhirDocumentReferenceResponseSchema,
-} from '@fhir/fhir-data/schema/documentReference'
+import { FhirDocumentReferenceBaseSchema } from '@fhir/fhir-data/schema/documentReference'
 import { sykInnApiService } from '@services/syk-inn-api/SykInnApiService'
 import { serverFhirResources } from '@fhir/fhir-data/fhir-data-server'
 
-type DocRefResponseResult = FhirDocumentReferenceResponse | [{ errors: { message: string } }]
+import { WriteToEhrResult } from '../../../../../../data-fetcher/data-service'
 
-export async function POST(request: Request): Promise<Response | DocRefResponseResult> {
+type WriteToEhrResponse = WriteToEhrResult | { errors: [{ message: string }] }
+
+export async function POST(request: Request): Promise<Response> {
     const authStatus = await ensureValidFhirAuth()
     if (authStatus !== 'ok') {
         return authStatus
@@ -33,52 +32,47 @@ export async function POST(request: Request): Promise<Response | DocRefResponseR
         logger.error(`Failed to retrieve sykmelding pdf ${sykmeldingPdfArrayBuffer.errorType}`)
         return new Response('Failed to retrieve sykmelding pdf', { status: 500 })
     }
-
     const sykmeldingBase64 = Buffer.from(sykmeldingPdfArrayBuffer).toString('base64')
 
-    // check if document reference already exists
     const existingDocumentReference = await serverFhirResources.getDocumentReference(sykmeldingId)
+    if ('outcome' in existingDocumentReference) {
+        return Response.json(existingDocumentReference satisfies WriteToEhrResult)
+    }
 
-    const verifiedExistingDocRef = FhirDocumentReferenceResponseSchema.safeParse(existingDocumentReference)
-    if (!verifiedExistingDocRef.success) {
-        logger.error(`Invalid existing DocumentReference: ${JSON.stringify(verifiedExistingDocRef.error, null, 2)}`)
-
+    if ('errorType' in existingDocumentReference && existingDocumentReference.errorType === 'INVALID_FHIR_RESPONSE') {
+        logger.error(new Error(existingDocumentReference.errorType, { cause: existingDocumentReference.zodErrors }))
         return Response.json(
-            [{ errors: { message: 'Invalid existing DocumentReference' } }] satisfies DocRefResponseResult,
+            { errors: [{ message: existingDocumentReference.errorType }] } satisfies WriteToEhrResponse,
             {
                 status: 400,
             },
         )
     }
 
-    if (existingDocumentReference) {
-        return Response.json(verifiedExistingDocRef.data satisfies DocRefResponseResult)
-    }
-
-    // create document reference as it didn't exist
-    const createdDocRef = await serverFhirResources.createDocumentReference(sykmeldingBase64, 'Sykmelding for Foo Bar') // TODO title
+    // Doesn't already exist, and hasn't returned invalid FHIR response, we can try and create it
+    const createdDocRef = await serverFhirResources.createDocumentReference(
+        sykmeldingBase64,
+        'Sykmelding for Foo Bar',
+        sykmeldingId,
+    ) // TODO title
     if ('errorType' in createdDocRef) {
-        logger.error(`Failed to create DocumentReference: ${JSON.stringify(createdDocRef, null, 2)}`)
-
-        return Response.json(
-            [{ errors: { message: 'Failed to create DocumentReference' } }] satisfies DocRefResponseResult,
-            {
-                status: 500,
-            },
-        )
+        logger.error(new Error(createdDocRef.errorType, { cause: createdDocRef.zodErrors }))
+        return Response.json({ errors: [{ message: createdDocRef.errorType }] } satisfies WriteToEhrResponse, {
+            status: 500,
+        })
     }
 
-    const verifiedCreatedDocRef = FhirDocumentReferenceResponseSchema.safeParse(createdDocRef)
+    const verifiedCreatedDocRef = FhirDocumentReferenceBaseSchema.safeParse(createdDocRef)
     if (!verifiedCreatedDocRef.success) {
         logger.error(`Invalid created DocumentReference: ${JSON.stringify(verifiedCreatedDocRef.error, null, 2)}`)
 
-        return Response.json(
-            [{ errors: { message: 'Invalid created DocumentReference' } }] satisfies DocRefResponseResult,
-            {
-                status: 400,
-            },
-        )
+        return Response.json({ errors: [verifiedCreatedDocRef.error] } satisfies WriteToEhrResponse, {
+            status: 400,
+        })
     }
 
-    return Response.json(verifiedCreatedDocRef.data satisfies DocRefResponseResult)
+    return Response.json({
+        outcome: 'NEWLY_CREATED',
+        documentReference: verifiedCreatedDocRef.data,
+    } satisfies WriteToEhrResult)
 }
diff --git a/src/app/api/mocks/fhir/(resources)/DocumentReference/[id]/route.ts b/src/app/api/mocks/fhir/(resources)/DocumentReference/[id]/route.ts
@@ -1,15 +1,23 @@
 import { logger as pinoLogger } from '@navikt/next-logger'
 
-import { cleanPath } from '../../utils'
-
 const logger = pinoLogger.child({}, { msgPrefix: '[FHIR-MOCK] ' })
 
-export async function GET(req: Request): Promise<Response> {
-    const url = new URL(req.url)
-    const fhirPath = cleanPath(url.pathname)
-    logger.info(`Incoming request: ${req.method} - ${fhirPath}`)
+const shouldReturn = false
+
+type RouteParams = {
+    params: Promise<{ id: string }>
+}
+
+export async function GET(_: Request, { params }: RouteParams): Promise<Response> {
+    const docRefId = (await params).id
+
+    logger.info(`Incoming request: GET DocumentReference/${docRefId}`)
 
     // verifyAuthed(req)
+    if (!shouldReturn) {
+        logger.info("Pretending document reference doesn't exist")
+        return new Response('Not found', { status: 404 })
+    }
 
     return mockedDocumentReference()
 }
diff --git a/src/app/api/mocks/fhir/(resources)/DocumentReference/route.ts b/src/app/api/mocks/fhir/(resources)/DocumentReference/route.ts
@@ -12,10 +12,6 @@ export async function POST(req: Request): Promise<Response> {
 
     verifyAuthed(req)
 
-    if (req.method !== 'POST') {
-        return new Response('DocumentReference without a specific id parameter only supports POST')
-    }
-
     return mockedDocumentReference()
 }
 
diff --git a/src/components/existing-sykmelding-kvittering/ExistingSykmeldingKvittering.tsx b/src/components/existing-sykmelding-kvittering/ExistingSykmeldingKvittering.tsx
@@ -98,7 +98,7 @@ function WritebackStatus({ sykmeldingId }: WritebackStatusProps): ReactElement {
         )
     }
 
-    if (!data || !data.id) {
+    if (!data || !data.documentReference.id) {
         return (
             <div className="mt-4">
                 <Alert variant="warning">Data er ikke tilgjengelig ennå. Vennligst prøv igjen senere.</Alert>
@@ -114,7 +114,7 @@ function WritebackStatus({ sykmeldingId }: WritebackStatusProps): ReactElement {
     return (
         <div className="my-4">
             <Heading size="small" level="3">
-                Sykmelding er skrevet til EPJ-systemet og lagret på DokumentReferanse: ${data.id}
+                Sykmelding er lagret i EPJ-systemet på DokumentReferanse: ${data.documentReference.id}
             </Heading>
         </div>
     )
diff --git a/src/data-fetcher/data-service.ts b/src/data-fetcher/data-service.ts
@@ -1,4 +1,5 @@
 import { SubmitSykmeldingFormValues } from '@services/syk-inn-api/SykInnApiSchema'
+import { FhirDocumentReferenceBase } from '@fhir/fhir-data/schema/documentReference'
 
 export type NotAvailable = typeof NotAvailable
 export const NotAvailable = {
@@ -36,7 +37,7 @@ export type DataService = {
     }
     mutation: {
         sendSykmelding: (sykmelding: SubmitSykmeldingFormValues) => Promise<NySykmelding>
-        writeToEhr: (sykmeldingId: string) => Promise<DocumentReferenceResponse>
+        writeToEhr: (sykmeldingId: string) => Promise<WriteToEhrResult>
     }
 }
 
@@ -126,14 +127,11 @@ export type ExistingSykmelding = {
     }
 }
 
-export type DocumentReferenceResponse = {
-    resourceType: string
-    id: string
-    meta: {
-        versionId: string
-        lastUpdated: string
-    }
+export type WriteToEhrResult = {
+    outcome: 'NEWLY_CREATED' | 'ALREADY_EXISTS'
+    documentReference: FhirDocumentReferenceBase
 }
+
 /**
  * Type guard to check if a resource (i.e. a data service function) is available or not. Used to conditionally render
  * the form based on whether the data is configured to be available.
diff --git a/src/fhir/fhir-data/fhir-data-server.ts b/src/fhir/fhir-data/fhir-data-server.ts
@@ -1,23 +1,33 @@
 import { decodeJwt } from 'jose'
 import { logger } from '@navikt/next-logger'
+import { ZodIssue } from 'zod'
 
 import { getSession } from '@fhir/auth/session'
-import { FhirDocumentReference, FhirDocumentReferenceResponseSchema } from '@fhir/fhir-data/schema/documentReference'
+import { FhirDocumentReference, FhirDocumentReferenceBaseSchema } from '@fhir/fhir-data/schema/documentReference'
 
 import { FhirPractitionerSchema } from '../fhir-data/schema/practitioner'
 import { getHpr } from '../fhir-data/schema/mappers/practitioner'
 import { getName } from '../fhir-data/schema/mappers/patient'
-import { BehandlerInfo, DocumentReferenceResponse } from '../../data-fetcher/data-service'
+import { BehandlerInfo, WriteToEhrResult } from '../../data-fetcher/data-service'
 
 /**
  * These FHIR resources are only available in the server runtime. They are not proxied through the backend.
  * They will use the session store and fetch resources directly from the FHIR server.
  */
 export const serverFhirResources = {
-    createDocumentReference: async (pdf: string, title: string): Promise<DocumentReferenceResponse> => {
+    createDocumentReference: async (
+        pdf: string,
+        title: string,
+        sykmeldingId: string,
+    ): Promise<
+        | WriteToEhrResult
+        | { errorType: 'INVALID_FHIR_RESPONSE'; zodErrors: ZodIssue[] }
+        | { errorType: 'INVALID_PRACTITIONER_ID'; zodErrors: ZodIssue[] }
+        | { errorType: 'INACTIVE_USER_SESSION'; zodErrors: ZodIssue[] }
+    > => {
         const currentSession = await getSession()
         if (currentSession == null) {
-            throw new Error('Active session is required')
+            return { errorType: 'INACTIVE_USER_SESSION', zodErrors: [] }
         }
 
         const decodedIdToken = decodeJwt(currentSession.idToken)
@@ -31,14 +41,21 @@ export const serverFhirResources = {
         const encounterId = currentSession.encounter
 
         if (typeof practitionerId !== 'string') {
-            throw new Error('practitionerId is not string')
+            return { errorType: 'INVALID_PRACTITIONER_ID', zodErrors: [] }
         }
-        const documentReference = prepareDocRefWithB64Data(practitionerId, patientId, encounterId, pdf, title)
+        const documentReferencePayload = prepareDocRefWithB64Data({
+            title,
+            pdf,
+            sykmeldingId,
+            encounterId,
+            patientId,
+            practitionerId,
+        })
 
         const resourcePath = `${currentSession.issuer}/DocumentReference/`
         const documentReferenceResponse = await fetch(resourcePath, {
             method: 'POST',
-            body: JSON.stringify(documentReference),
+            body: JSON.stringify(documentReferencePayload),
             headers: {
                 Authorization: `Bearer ${currentSession.accessToken}`,
                 ContentType: 'application/fhir+json',
@@ -55,24 +72,30 @@ export const serverFhirResources = {
                 logger.error(`Request to create DocumentReference failed with json: ${JSON.stringify(json)}`)
             }
 
-            throw new Error('Unable to create DocumentReference')
+            return { errorType: 'INVALID_FHIR_RESPONSE', zodErrors: [] }
         }
 
         const docRefResult = await documentReferenceResponse.json()
-        const parsedDocRefResult = FhirDocumentReferenceResponseSchema.safeParse(docRefResult)
+        const parsedDocRefResult = FhirDocumentReferenceBaseSchema.safeParse(docRefResult)
         if (!parsedDocRefResult.success) {
-            throw new Error('DocumentReference was not a valid FhirDocumentReference', {
-                cause: parsedDocRefResult.error,
-            })
+            return { errorType: 'INVALID_FHIR_RESPONSE', zodErrors: [] }
         }
 
-        return parsedDocRefResult.data
+        return { outcome: 'NEWLY_CREATED', documentReference: parsedDocRefResult.data }
     },
 
-    getDocumentReference: async (sykmeldingId: string): Promise<DocumentReferenceResponse> => {
+    getDocumentReference: async (
+        sykmeldingId: string,
+    ): Promise<
+        | WriteToEhrResult
+        | { errorType: 'DOCUMENT_NOT_FOUND' }
+        | { errorType: 'INVALID_FHIR_RESPONSE'; zodErrors: ZodIssue[] }
+        | { errorType: 'INACTIVE_USER_SESSION'; zodErrors: ZodIssue[] }
+        | { errorType: 'FAILED_TO_GET_DOCUMENT_REFERENCE'; zodErrors: ZodIssue[] }
+    > => {
         const currentSession = await getSession()
         if (currentSession == null) {
-            throw new Error('Active session is required')
+            return { errorType: 'INACTIVE_USER_SESSION', zodErrors: [] }
         }
         const resourcePath = `${currentSession.issuer}/DocumentReference/${sykmeldingId}`
         logger.info(`Resource path: ${resourcePath}`)
@@ -84,6 +107,11 @@ export const serverFhirResources = {
             },
         })
 
+        if (documentReferenceResponse.status === 404) {
+            logger.info(`DocumentReference/${sykmeldingId} was not found on FHIR server`)
+            return { errorType: 'DOCUMENT_NOT_FOUND' }
+        }
+
         if (!documentReferenceResponse.ok) {
             logger.error('Request to get DocumentReference failed', documentReferenceResponse)
             if (documentReferenceResponse.headers.get('Content-Type')?.includes('text/plain')) {
@@ -93,19 +121,20 @@ export const serverFhirResources = {
                 const json = await documentReferenceResponse.json()
                 logger.error(`Request to get DocumentReference failed with json: ${JSON.stringify(json)}`)
             }
-
-            throw new Error('Unable to get DocumentReference')
+            return { errorType: 'FAILED_TO_GET_DOCUMENT_REFERENCE', zodErrors: [] }
         }
 
-        const safeParsedDocumentReferenceResponse = FhirDocumentReferenceResponseSchema.safeParse(
+        const safeParsedDocumentReferenceResponse = FhirDocumentReferenceBaseSchema.safeParse(
             await documentReferenceResponse.json(),
         )
         if (!safeParsedDocumentReferenceResponse.success) {
-            throw new Error('DocumentReference was not a valid FhirDocumentReference', {
-                cause: safeParsedDocumentReferenceResponse.error,
-            })
+            return {
+                errorType: 'INVALID_FHIR_RESPONSE',
+                zodErrors: safeParsedDocumentReferenceResponse.error.errors,
+            }
         }
-        return safeParsedDocumentReferenceResponse.data
+
+        return { outcome: 'ALREADY_EXISTS', documentReference: safeParsedDocumentReferenceResponse.data }
     },
 
     getBehandlerInfo: async (): Promise<BehandlerInfo> => {
@@ -165,15 +194,26 @@ export const serverFhirResources = {
     },
 }
 
-function prepareDocRefWithB64Data(
-    patientId: string,
-    practitionerId: string,
-    encounterId: string,
-    pdf: string,
-    title: string,
-): FhirDocumentReference {
+type PrepareDocRefOpts = {
+    patientId: string
+    practitionerId: string
+    encounterId: string
+    pdf: string
+    title: string
+    sykmeldingId: string
+}
+
+function prepareDocRefWithB64Data({
+    patientId,
+    practitionerId,
+    encounterId,
+    pdf,
+    title,
+    sykmeldingId,
+}: PrepareDocRefOpts): Omit<FhirDocumentReference, 'meta'> {
     return {
         resourceType: 'DocumentReference',
+        id: sykmeldingId,
         status: 'current',
         type: {
             coding: [
diff --git a/src/fhir/fhir-data/non-fhir-data.ts b/src/fhir/fhir-data/non-fhir-data.ts
diff --git a/src/fhir/fhir-data/schema/documentReference.ts b/src/fhir/fhir-data/schema/documentReference.ts
diff --git a/src/services/syk-inn-api/SykInnApiService.ts b/src/services/syk-inn-api/SykInnApiService.ts

Original file line number	Diff line number	Diff line change
`@@ -12,10 +12,6 @@ export async function POST(req: Request): Promise<Response> {`
`12`	`12`
`13`	`13`	`verifyAuthed(req)`
`14`	`14`
`15`		`- if (req.method !== 'POST') {`
`16`		`- return new Response('DocumentReference without a specific id parameter only supports POST')`
`17`		`- }`
`18`		`-`
`19`	`15`	`return mockedDocumentReference()`
`20`	`16`	`}`
`21`	`17`
Original file line number	Diff line number	Diff line change
`@@ -98,7 +98,7 @@ function WritebackStatus({ sykmeldingId }: WritebackStatusProps): ReactElement {`
`98`	`98`	`)`
`99`	`99`	`}`
`100`	`100`
`101`		`- if (!data \|\| !data.id) {`
	`101`	`+ if (!data \|\| !data.documentReference.id) {`
`102`	`102`	`return (`
`103`	`103`	`<div className="mt-4">`
`104`	`104`	`<Alert variant="warning">Data er ikke tilgjengelig ennå. Vennligst prøv igjen senere.</Alert>`
`@@ -114,7 +114,7 @@ function WritebackStatus({ sykmeldingId }: WritebackStatusProps): ReactElement {`
`114`	`114`	`return (`
`115`	`115`	`<div className="my-4">`
`116`	`116`	`<Heading size="small" level="3">`
`117`		`- Sykmelding er skrevet til EPJ-systemet og lagret på DokumentReferanse: ${data.id}`
	`117`	`+ Sykmelding er lagret i EPJ-systemet på DokumentReferanse: ${data.documentReference.id}`
`118`	`118`	`</Heading>`
`119`	`119`	`</div>`
`120`	`120`	`)`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`import { SubmitSykmeldingFormValues } from '@services/syk-inn-api/SykInnApiSchema'`
	`2`	`+import { FhirDocumentReferenceBase } from '@fhir/fhir-data/schema/documentReference'`
`2`	`3`
`3`	`4`	`export type NotAvailable = typeof NotAvailable`
`4`	`5`	`export const NotAvailable = {`
`@@ -36,7 +37,7 @@ export type DataService = {`
`36`	`37`	`}`
`37`	`38`	`mutation: {`
`38`	`39`	`sendSykmelding: (sykmelding: SubmitSykmeldingFormValues) => Promise<NySykmelding>`
`39`		`- writeToEhr: (sykmeldingId: string) => Promise<DocumentReferenceResponse>`
	`40`	`+ writeToEhr: (sykmeldingId: string) => Promise<WriteToEhrResult>`
`40`	`41`	`}`
`41`	`42`	`}`
`42`	`43`
`@@ -126,14 +127,11 @@ export type ExistingSykmelding = {`
`126`	`127`	`}`
`127`	`128`	`}`
`128`	`129`
`129`		`-export type DocumentReferenceResponse = {`
`130`		`- resourceType: string`
`131`		`- id: string`
`132`		`- meta: {`
`133`		`- versionId: string`
`134`		`- lastUpdated: string`
`135`		`- }`
	`130`	`+export type WriteToEhrResult = {`
	`131`	`+ outcome: 'NEWLY_CREATED' \| 'ALREADY_EXISTS'`
	`132`	`+ documentReference: FhirDocumentReferenceBase`
`136`	`133`	`}`
	`134`	`+`
`137`	`135`	`/**`
`138`	`136`	`* Type guard to check if a resource (i.e. a data service function) is available or not. Used to conditionally render`
`139`	`137`	`* the form based on whether the data is configured to be available.`