web/apps/partner-sas/middleware.ts

import * as Sentry from "@sentry/nextjs"
import {
  type NextFetchEvent,
  type NextMiddleware,
  type NextRequest,
  NextResponse,
} from "next/server"

import { Lang } from "@scandic-hotels/common/constants/language"
import { logger } from "@scandic-hotels/common/logger"
import { findLang } from "@scandic-hotels/common/utils/languages"

import * as bookingFlow from "@/middlewares/bookingFlow"
import * as invalidUrl from "@/middlewares/invalidUrl"
import * as silentAuthMiddleware from "@/middlewares/silentAuthMiddleware"
import * as trailingSlash from "@/middlewares/trailingSlash"
import { getDefaultRequestHeaders } from "@/middlewares/utils"

import type { MiddlewareMatcher } from "./middlewares/types"

export const middleware: NextMiddleware = async (request, event) => {
  // auth() overrides the request origin, we need the original for internal rewrites
  // @see getInternalNextURL()
  request.headers.set("x-sh-origin", request.nextUrl.origin)

  const headers = getDefaultRequestHeaders(request)
  const apiMiddlewareResults = await executeMiddlewares({
    request,
    event,
    defaultHeaders: headers,
    middlewares: [silentAuthMiddleware],
  })

  if (apiMiddlewareResults) {
    return apiMiddlewareResults
  }

  const lang = findLang(request.nextUrl.pathname)
  if (!lang) {
    // Lang is required for all page middleware.
    // Without it we shortcircuit early.

    // Default to English if no lang is found.
    headers.set("x-lang", Lang.en)
    return NextResponse.next({
      request: {
        headers,
      },
    })
  }

  // Note that the order of middlewares is important since that is the order they are matched by.
  const pageMiddlewareResults = await executeMiddlewares({
    request,
    event,
    lang,
    defaultHeaders: headers,
    middlewares: [invalidUrl, trailingSlash, bookingFlow],
  })

  if (pageMiddlewareResults) {
    return pageMiddlewareResults
  }

  // Follow through with normal App router rules.
  return NextResponse.next({
    request: {
      headers,
    },
  })
}

async function executeMiddlewares({
  middlewares,
  request,
  event,
  lang = Lang.en,
  defaultHeaders,
}: {
  middlewares: {
    middleware: NextMiddleware
    matcher: MiddlewareMatcher
  }[]
  request: NextRequest
  event: NextFetchEvent
  lang?: Lang
  defaultHeaders: Headers
}) {
  try {
    for (let i = 0; i < middlewares.length; ++i) {
      const middleware = middlewares[i]

      if (middleware.matcher(request)) {
        const result = await middleware.middleware(request, event)

        const _continue = result?.headers.get("x-continue")
        if (_continue) {
          continue
        }
        // Clean up internal headers
        result?.headers.delete("x-sh-origin")

        return result
      }
    }
  } catch (e) {
    if (e instanceof NextResponse && e.status) {
      const cause = await e.json()
      logger.error(`NextResponse Error in middleware`, cause)
      Sentry.captureException(cause)

      return NextResponse.rewrite(
        new URL(`/${lang}/middleware-error/${e.status}`, request.nextUrl),
        {
          request: {
            headers: defaultHeaders,
          },
          status: e.status,
          statusText: e.statusText,
        }
      )
    }

    logger.error(`Error in middleware`, e)
    Sentry.captureException(e)

    return NextResponse.rewrite(
      new URL(`/${lang}/middleware-error/500`, request.nextUrl),
      {
        request: {
          headers: defaultHeaders,
        },
        status: 500,
        statusText: "Internal Server Error",
      }
    )
  }
}

export const config = {
  /**
   *  Copied from Clerk to protect all routes by default and handle
   *  public routes inside middleware.
   *  (https://clerk.com/docs/quickstarts/nextjs?utm_source=sponsorship&utm_medium=youtube&utm_campaign=code-with-antonio&utm_content=12-31-2023#add-authentication-to-your-app)
   */
  matcher: [
    "/((?!.+\\.[\\w]+$|_next|_static|.netlify|api|trpc|sitemap).*)",
    "/api/web/auth/callback/sas",
  ],
}