refactor environment variables

Author: luantr

src/app/Providers.tsx

@@ -1,7 +1,7 @@
 'use client'
 
 import { PropsWithChildren } from 'react'
-import { configureLogger, logger } from '@navikt/next-logger'
+import { configureLogger } from '@navikt/next-logger'
 import { BASE_PATH } from '../../next.config'
 
 configureLogger({

src/app/api/flexjar/route.ts

@@ -1,9 +1,10 @@
 import { NextRequest, NextResponse } from 'next/server'
 import { logger } from '@navikt/next-logger'
-import { getServerEnv, isLocalOrDemo } from '@/constants/envs'
 import { verifyUserLoggedIn } from '@/auth/rsc'
 import { requestOboToken } from '@navikt/oasis'
 import { FlexJarTransportPayload } from '@navikt/flexjar-widget'
+import { isLocalOrDemo } from '@/env-variables/envHelpers'
+import { getServerEnv } from '@/env-variables/serverEnv'
 
 async function exchangeToken(idportenToken: string): Promise<string> {
   const { FLEXJAR_BACKEND_CLIENT_ID } = getServerEnv()

src/app/layout.tsx

@@ -1,5 +1,5 @@
 import '@/app/globals.css'
-import "@navikt/flexjar-widget/styles.css";
+import '@navikt/flexjar-widget/styles.css'
 
 import type { Metadata } from 'next'
 import Script from 'next/script'
@@ -8,9 +8,10 @@ import { fetchDecoratorReact } from '@navikt/nav-dekoratoren-moduler/ssr'
 
 import { Page } from '@navikt/ds-react'
 import { PageBlock } from '@navikt/ds-react/Page'
-import { isDemo, publicEnv } from '@/constants/envs'
 import Providers from '@/app/Providers'
 import DemoAlert from '@/components/DemoAlert'
+import { isDemo } from '@/env-variables/envHelpers'
+import { publicEnv } from '@/env-variables/publicEnv'
 
 export const metadata: Metadata = {
   title: 'Kartlegging av din situasjon',

src/app/preload.tsx

@@ -0,0 +1,15 @@
+'use client'
+
+import ReactDOM from 'react-dom'
+
+function Preload(): null {
+  ReactDOM.preload('https://cdn.nav.no/aksel/fonts/SourceSans3-normal.woff2', {
+    as: 'font',
+    type: 'font/woff2',
+    crossOrigin: 'anonymous',
+  })
+
+  return null
+}
+
+export default Preload

src/auth/rsc.ts

@@ -4,8 +4,8 @@ import { logger } from '@navikt/next-logger'
 import { headers } from 'next/headers'
 import { redirect } from 'next/navigation'
 import { getToken, validateToken } from '@navikt/oasis'
-import { isLocalOrDemo } from '@/constants/envs'
 import { BASE_PATH } from '../../next.config'
+import { isLocalOrDemo } from '@/env-variables/envHelpers'
 
 export async function verifyUserLoggedIn(): Promise<string> {
   if (isLocalOrDemo) {

src/auth/tokenUtils.ts

@@ -1,8 +1,7 @@
 'use server'
 
 import { requestOboToken } from '@navikt/oasis'
-
-import { getServerEnv } from '@/constants/envs'
+import { getServerEnv } from '@/env-variables/serverEnv'
 
 export async function exchangeIdportenTokenForMeroppfolgingBackendTokenx(
   idportenToken: string | null,

src/constants/envs.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod/v4'
+
+export function throwEnvSchemaParsingError(e: unknown): never {
+  if (e instanceof z.ZodError) {
+    throw new Error(
+      `The following envs are missing: ${
+        e.issues
+          .filter((it) => it.code === 'invalid_type' && it.message.includes('received undefined'))
+          .map((it) => it.path.join('.'))
+          .join(', ') || 'None are missing, but zod is not happy. Look at cause'
+      }`,
+      { cause: e },
+    )
+  } else {
+    throw e
+  }
+}
+export const isDemo = process.env.NEXT_PUBLIC_RUNTIME_ENVIRONMENT === 'demo'
+
+export const isLocalOrDemo = process.env.NEXT_PUBLIC_RUNTIME_ENVIRONMENT === 'local' || isDemo

src/env-variables/envHelpers.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod'
+import { throwEnvSchemaParsingError } from './envHelpers'
+
+export type PublicEnv = z.infer<typeof publicEnvSchema>
+export const publicEnvSchema = z.object({
+  NEXT_PUBLIC_RUNTIME_ENVIRONMENT: z.union([
+    z.literal('local'),
+    z.literal('test'),
+    z.literal('demo'),
+    z.literal('dev'),
+    z.literal('prod'),
+  ]),
+  NEXT_PUBLIC_ASSET_PREFIX: z.string().optional(),
+  NEXT_PUBLIC_TELEMETRY_URL: z.string().optional(),
+  NEXT_PUBLIC_BASE_PATH: z.string(),
+})
+
+/**
+ * These envs are available in the browser. They are replaced during the bundling step by NextJS.
+ */
+export const rawPublicEnv = {
+  NEXT_PUBLIC_RUNTIME_ENVIRONMENT: process.env.NEXT_PUBLIC_RUNTIME_ENVIRONMENT,
+  NEXT_PUBLIC_ASSET_PREFIX: process.env.NEXT_PUBLIC_ASSET_PREFIX,
+  NEXT_PUBLIC_TELEMETRY_URL: process.env.NEXT_PUBLIC_TELEMETRY_URL,
+  NEXT_PUBLIC_BASE_PATH: process.env.NEXT_PUBLIC_BASE_PATH,
+} satisfies Record<keyof PublicEnv, string | undefined>
+
+// Evaluate once at module load time with an IIFE.
+export const publicEnv: Readonly<PublicEnv> = (() => {
+  try {
+    return Object.freeze(publicEnvSchema.parse(rawPublicEnv))
+  } catch (err) {
+    throwEnvSchemaParsingError(err)
+  }
+})()

src/env-variables/publicEnv.ts

@@ -0,0 +1,58 @@
+import 'server-only'
+
+import { z } from 'zod'
+import { PublicEnv, publicEnvSchema, rawPublicEnv } from './publicEnv'
+import { throwEnvSchemaParsingError } from './envHelpers'
+
+export type ServerEnv = z.infer<typeof serverEnvSchema>
+export const serverEnvSchema = z.object({
+  // Provided by nais-*.yaml
+  MEROPPFOLGING_BACKEND_URL: z.string(),
+  FLEXJAR_BACKEND_HOST: z.string(),
+  FLEXJAR_BACKEND_CLIENT_ID: z.string(),
+  // Provided by nais
+  TOKEN_X_WELL_KNOWN_URL: z.string(),
+  TOKEN_X_CLIENT_ID: z.string(),
+  TOKEN_X_PRIVATE_JWK: z.string(),
+  IDPORTEN_WELL_KNOWN_URL: z.string(),
+  IDPORTEN_CLIENT_ID: z.string(),
+  NAIS_CLUSTER_NAME: z.string(),
+})
+
+const rawServerEnv = {
+  // Provided by nais-*.yml
+  MEROPPFOLGING_BACKEND_URL: process.env.MEROPPFOLGING_BACKEND_URL,
+  FLEXJAR_BACKEND_HOST: process.env.FLEXJAR_BACKEND_HOST,
+  FLEXJAR_BACKEND_CLIENT_ID: process.env.FLEXJAR_BACKEND_CLIENT_ID,
+
+  // Provided by nais
+  TOKEN_X_WELL_KNOWN_URL: process.env.TOKEN_X_WELL_KNOWN_URL,
+  TOKEN_X_CLIENT_ID: process.env.TOKEN_X_CLIENT_ID,
+  TOKEN_X_PRIVATE_JWK: process.env.TOKEN_X_PRIVATE_JWK,
+  IDPORTEN_WELL_KNOWN_URL: process.env.IDPORTEN_WELL_KNOWN_URL,
+  IDPORTEN_CLIENT_ID: process.env.IDPORTEN_CLIENT_ID,
+  NAIS_CLUSTER_NAME: process.env.NAIS_CLUSTER_NAME,
+} satisfies Record<keyof ServerEnv, string | undefined>
+
+let cachedServerEnv: Readonly<ServerEnv & PublicEnv> | undefined
+
+/**
+ * Validates server and public environment variables against zod schemas that define the
+ * expected variables, and returns an object containing all variables.
+ * Caches the result after the first invocation.
+ * Server environment variables don't need to be set in local or demo environment,
+ * as long as we don't call this function if isLocalOrDemo is true.
+ */
+export function getServerEnv(): Readonly<ServerEnv & PublicEnv> {
+  if (!cachedServerEnv) {
+    try {
+      cachedServerEnv = Object.freeze({
+        ...serverEnvSchema.parse(rawServerEnv),
+        ...publicEnvSchema.parse(rawPublicEnv),
+      })
+    } catch (e) {
+      throwEnvSchemaParsingError(e)
+    }
+  }
+  return cachedServerEnv
+}