👽 Tar i bruk simpleproxy for innsending av ettersendelse

Co-authored-by: Tor Idland <tor.idland@nav.no>
Co-authored-by: Thomas Sebastian Rognes <thomas.sebastian.rognes@nav.no>
Co-authored-by: Robin Tordly <robin.tordly@nav.no>

lib/api/ErrorMedStatus.ts

@@ -0,0 +1,16 @@
+// TODO: Errorcode og developerMessage vil returneres fra innsending og oppslag etterhvert. Her må vi støtte begge deler parallelt
+// i en periode.
+
+export class ErrorMedStatus extends Error {
+  status: number;
+  developerMessage?: string;
+  errorCode?: string;
+  navCallId?: string;
+  constructor(message: string, status: number, navCallId = '', developerMessage = '', errorCode = '') {
+    super(message);
+    this.status = status;
+    this.developerMessage = developerMessage;
+    this.errorCode = errorCode;
+    this.navCallId = navCallId;
+  }
+}

lib/api/simpleTokenXProxy.ts

@@ -2,14 +2,17 @@ import { validateToken, requestOboToken, getToken } from '@navikt/oasis';
 import { logError, logInfo } from '@navikt/aap-felles-utils';
 import { randomUUID } from 'crypto';
 import { IncomingMessage } from 'http';
+import { ErrorMedStatus } from 'lib/api/ErrorMedStatus';
 
 interface Opts {
   url: string;
+  method?: 'GET' | 'POST' | 'DELETE';
   audience: string;
+  body?: object;
   req?: IncomingMessage;
 }
 
-export const simpleTokenXProxy = async ({ url, audience, req }: Opts) => {
+export const simpleTokenXProxy = async <T>({ url, audience, req, method = 'GET', body }: Opts): Promise<T> => {
   if (!req) {
     logError(`Request for ${url} er undefined`);
     throw new Error('Request for simpleTokenXProxy is undefined');
@@ -38,20 +41,32 @@ export const simpleTokenXProxy = async ({ url, audience, req }: Opts) => {
   logInfo(`${req.method} ${url}, callId ${navCallId}`);
 
   const response = await fetch(url, {
-    method: 'GET',
+    method: method,
     headers: {
       Authorization: `Bearer ${onBehalfOf.token}`,
       'Content-Type': 'application/json',
       'Nav-CallId': navCallId,
     },
+    body: method === 'POST' ? JSON.stringify(body) : undefined,
   });
 
-  if (response.ok) {
-    logInfo(`OK ${url}, status ${response.status}, callId ${navCallId}`);
-    return await response.json();
+  try {
+    if (response.ok) {
+      logInfo(`OK ${url}, status ${response.status}, callId ${navCallId}`);
+      const headers = response.headers.get('content-type');
+      const isJson = headers?.includes('application/json');
+
+      // TODO: Midlertidig, til innsending returnerer json på alle OK-responser
+      if (!isJson) {
+        return (await response.text()) as T;
+      }
+      return await response.json();
+    }
+  } catch (error) {
+    logError(`Unable to parse response for ${url}`, error);
   }
   logError(
     `Error fetching simpleTokenXProxy. Fikk responskode ${response.status} fra ${url} med navCallId: ${navCallId}`
   );
-  throw new Error('Error fetching simpleTokenXProxy');
+  throw new ErrorMedStatus('Error fetching simpleTokenXProxy', response.status, navCallId);
 };

pages/api/dokumentjson.ts

@@ -13,14 +13,11 @@ const handler = beskyttetApi(async (req, res) => {
   }
 });
 
-export const getDokumentJson = async (
-  journalpostId: string,
-  req?: IncomingMessage
-): Promise<Record<string, object>> => {
+export const getDokumentJson = async (journalpostId: string, req?: IncomingMessage) => {
   if (isMock()) return {};
   try {
     // TODO: Vi må ha type på dokumentJson
-    const dokumentJson: Record<string, object> = await simpleTokenXProxy({
+    const dokumentJson = await simpleTokenXProxy<Record<string, object>>({
       url: `${process.env.OPPSLAG_URL}/dokumenter/${journalpostId}/json`,
       audience: process.env.OPPSLAG_AUDIENCE ?? '',
       req,

pages/api/ettersendelseinnsending/send.ts

@@ -1,9 +1,9 @@
-import { beskyttetApi, getAccessTokenFromRequest, isMock, tokenXApiProxy } from '@navikt/aap-felles-utils';
-import metrics from 'lib/metrics';
+import { beskyttetApi, isMock, logError } from '@navikt/aap-felles-utils';
+import { IncomingMessage } from 'http';
+import { simpleTokenXProxy } from 'lib/api/simpleTokenXProxy';
 import { Ettersendelse, InnsendingBackendState, VedleggType } from 'lib/types/types';
 
 const handler = beskyttetApi(async (req, res) => {
-  const accessToken = getAccessTokenFromRequest(req);
   const { ettersendteVedlegg, søknadId }: Ettersendelse = JSON.parse(req.body);
 
   const ettersending = ettersendteVedlegg[0];
@@ -13,31 +13,32 @@ const handler = beskyttetApi(async (req, res) => {
       tittel: mapVedleggTypeTilVedleggstekst(ettersending.vedleggType),
     })),
   };
-  await sendEttersendelseInnsending(body, søknadId, accessToken);
+  await sendEttersendelseInnsending(body, søknadId, req);
 
   res.status(201).json({});
 });
 
 export const sendEttersendelseInnsending = async (
   data: InnsendingBackendState,
   innsendingsId?: string,
-  accessToken?: string
+  req?: IncomingMessage
 ) => {
   if (isMock()) {
     return {};
   }
-  const ettersendelse = await tokenXApiProxy({
-    url: `${process.env.INNSENDING_URL}/innsending${innsendingsId ? `/${innsendingsId}` : ''}`,
-    prometheusPath: '/innsending',
-    method: 'POST',
-    data: JSON.stringify(data),
-    audience: process.env.INNSENDING_AUDIENCE!,
-    bearerToken: accessToken,
-    noResponse: true,
-    metricsStatusCodeCounter: metrics.backendApiStatusCodeCounter,
-    metricsTimer: metrics.backendApiDurationHistogram,
-  });
-  return ettersendelse;
+  try {
+    const ettersendelse = await simpleTokenXProxy({
+      url: `${process.env.INNSENDING_URL}/innsending${innsendingsId ? `/${innsendingsId}` : ''}`,
+      audience: process.env.INNSENDING_AUDIENCE!,
+      method: 'POST',
+      req,
+      body: data,
+    });
+    return ettersendelse;
+  } catch (error) {
+    logError('Error sending ettersendelse', error);
+    throw new Error('Error sending ettersendelse');
+  }
 };
 
 function mapVedleggTypeTilVedleggstekst(vedleggType: VedleggType): string {

pages/api/soknader/soknader.ts

@@ -13,10 +13,10 @@ const handler = beskyttetApi(async (req, res) => {
   res.status(200).json(søknader);
 });
 
-export const getSøknaderInnsending = async (req?: IncomingMessage): Promise<InnsendingSøknad[]> => {
+export const getSøknaderInnsending = async (req?: IncomingMessage) => {
   if (isMock()) return mockSøknaderInnsending;
   try {
-    const søknader: InnsendingSøknad[] = await simpleTokenXProxy({
+    const søknader = await simpleTokenXProxy<InnsendingSøknad[]>({
       url: `${process.env.INNSENDING_URL}/innsending/søknader`,
       audience: process.env.INNSENDING_AUDIENCE ?? '',
       req,