Merged in feat/SW-3461-setup-auth-with-sas-eurobonus (pull request #2825)

Feat/SW-3461 setup auth with sas eurobonus

* feat(SW-3461): Setup auth for sas eurobonus

* .

* feat: setup auth towards SAS

* Fix auth via SAS and add logout route

* .

* merge

* auth via SAS

* fix powered by scandic logo

* Merge branch 'master' of bitbucket.org:scandic-swap/web into feat/SW-3461-setup-auth-with-sas-eurobonus

* Include access_token in jwt after successful login

* merge


Approved-by: Anton Gunnarsson

apps/partner-sas/app/[lang]/(auth)/login/route.ts

@@ -0,0 +1,100 @@
+import { type NextRequest, NextResponse } from "next/server"
+import { AuthError } from "next-auth"
+
+import { logger } from "@scandic-hotels/common/logger"
+
+import { internalServerError } from "@/server/errors/next"
+import { getPublicURL } from "@/server/utils"
+
+import { signIn } from "@/auth"
+
+import type { Lang } from "@scandic-hotels/common/constants/language"
+
+export async function GET(
+  request: NextRequest,
+  context: { params: Promise<{ lang: Lang }> }
+) {
+  const contextParams = await context.params
+  const publicURL = getPublicURL(request)
+
+  let redirectHeaders: Headers | undefined = undefined
+  let redirectTo: string
+
+  const redirectToCookieValue = request.cookies.get("redirectTo")?.value // Cookie gets set by authRequired middleware
+  const redirectToSearchParamValue =
+    request.nextUrl.searchParams.get("redirectTo")
+  const redirectToFallback = "/"
+
+  logger.debug(`[login] redirectTo cookie value: ${redirectToCookieValue}`)
+  logger.debug(
+    `[login] redirectTo search param value: ${redirectToSearchParamValue}`
+  )
+
+  redirectTo =
+    redirectToCookieValue || redirectToSearchParamValue || redirectToFallback
+
+  // Make relative URL to absolute URL
+  if (redirectTo.startsWith("/")) {
+    logger.debug(`[login] make redirectTo absolute, from ${redirectTo}`)
+    redirectTo = new URL(redirectTo, publicURL).href
+    logger.debug(`[login] make redirectTo absolute, to ${redirectTo}`)
+  }
+
+  // Clean up cookie from authRequired middleware
+  redirectHeaders = new Headers()
+  redirectHeaders.append(
+    "set-cookie",
+    "redirectTo=; Expires=Thu, 01 Jan 1970 00:00:00 UTC; Path=/; HttpOnly; SameSite=Lax"
+  )
+
+  const SAS_LANGUAGE_MAP: Record<Lang, string> = {
+    no: "nb",
+    sv: "sv",
+    fi: "fi",
+    da: "da",
+    en: "en",
+    de: "de",
+  }
+
+  try {
+    logger.debug(`[login] final redirectUrl: ${redirectTo}`)
+
+    /** Record<string, any> is next-auth typings */
+    const params = {
+      ui_locales: SAS_LANGUAGE_MAP[contextParams.lang],
+      scope: ["openid", "profile", "email"].join(" "),
+    } satisfies Record<string, string>
+
+    /**
+     * Passing `redirect: false` to `signIn` will return the URL instead of
+     * automatically redirecting to it inside of `signIn`.
+     * https://github.com/nextauthjs/next-auth/blob/3c035ec/packages/next-auth/src/lib/actions.ts#L76
+     */
+    const redirectUrl = await signIn(
+      "sas",
+      {
+        redirectTo,
+        redirect: false,
+      },
+      params
+    )
+
+    if (redirectUrl) {
+      const redirectOpts = {
+        headers: redirectHeaders,
+      }
+      logger.debug(`[login] redirecting to: ${redirectUrl}`, redirectOpts)
+      return NextResponse.redirect(redirectUrl, redirectOpts)
+    } else {
+      logger.error(`[login] missing redirectUrl reponse from signIn()`)
+    }
+  } catch (error) {
+    if (error instanceof AuthError) {
+      logger.error("signInAuthError", { signInAuthError: error })
+    } else {
+      logger.error("signInError", { signInError: error })
+    }
+  }
+
+  return internalServerError()
+}

apps/partner-sas/app/[lang]/(auth)/logout/route.ts

@@ -0,0 +1,17 @@
+import { type NextRequest } from "next/server"
+
+import { getPublicURL } from "@/server/utils"
+
+import { signOut } from "@/auth"
+
+import type { Lang } from "@scandic-hotels/common/constants/language"
+
+export async function GET(
+  request: NextRequest,
+  _context: { params: Promise<{ lang: Lang }> }
+) {
+  const publicURL = getPublicURL(request)
+
+  const redirectTo: string = publicURL
+  await signOut({ redirectTo, redirect: true })
+}

apps/partner-sas/app/[lang]/layout.tsx

@@ -6,10 +6,9 @@ import "../../globals.css"
 
 import { ReactQueryDevtools } from "@tanstack/react-query-devtools"
 import Script from "next/script"
+import { SessionProvider } from "next-auth/react"
 
 import { BookingFlowConfig } from "@scandic-hotels/booking-flow/BookingFlowConfig"
-import { BookingFlowContextProvider } from "@scandic-hotels/booking-flow/BookingFlowContextProvider"
-import { BookingFlowTrackingProvider } from "@scandic-hotels/booking-flow/BookingFlowTrackingProvider"
 import { NuqsAdapter } from "@scandic-hotels/booking-flow/utils/nuqs"
 import { Lang } from "@scandic-hotels/common/constants/language"
 import { ToastHandler } from "@scandic-hotels/design-system/ToastHandler"
@@ -25,20 +24,9 @@ import { getMessages } from "@/i18n"
 import ClientIntlProvider from "@/i18n/Provider"
 import { setLang } from "@/i18n/serverContext"
 
+import { BookingFlowProviders } from "../../components/BookingFlowProviders"
 import { Footer } from "../../components/Footer/Footer"
 import { Header } from "../../components/Header/Header"
-import {
-  trackAccordionItemOpen,
-  trackBedSelection,
-  trackBookingSearchClick,
-  trackBreakfastSelection,
-  trackGenericEvent,
-  trackGlaSaveCardAttempt,
-  trackLoginClick,
-  trackOpenSidePeek,
-  trackPaymentEvent,
-  trackUpdatePaymentMethod,
-} from "../utils/tracking"
 
 import type { Metadata } from "next"
 
@@ -82,35 +70,18 @@ export default async function RootLayout(props: RootLayoutProps) {
       </head>
       <body className="scandic">
         <div className="root">
-          <ClientIntlProvider
-            defaultLocale={Lang.en}
-            locale={parsedLanguage}
-            messages={messages}
-          >
-            <NuqsAdapter>
-              <TrpcProvider>
-                <RACRouterProvider>
-                  <BookingFlowConfig config={bookingFlowConfig}>
-                    <BookingFlowContextProvider
-                      data={{
-                        // TODO
-                        isLoggedIn: false,
-                      }}
-                    >
-                      <BookingFlowTrackingProvider
-                        trackingFunctions={{
-                          trackBookingSearchClick,
-                          trackAccordionItemOpen,
-                          trackOpenSidePeek,
-                          trackGenericEvent,
-                          trackGlaSaveCardAttempt,
-                          trackLoginClick,
-                          trackPaymentEvent,
-                          trackUpdatePaymentMethod,
-                          trackBreakfastSelection,
-                          trackBedSelection,
-                        }}
-                      >
+          <SessionProvider basePath="/api/web/auth">
+            <ClientIntlProvider
+              defaultLocale={Lang.en}
+              locale={parsedLanguage}
+              messages={messages}
+            >
+              <NuqsAdapter>
+                {/* TODO handle onError */}
+                <TrpcProvider>
+                  <RACRouterProvider>
+                    <BookingFlowConfig config={bookingFlowConfig}>
+                      <BookingFlowProviders>
                         <SiteWideAlert />
                         <Header />
                         {props.bookingwidget}
@@ -119,13 +90,13 @@ export default async function RootLayout(props: RootLayoutProps) {
                         <ToastHandler />
                         <CookieBotConsent />
                         <ReactQueryDevtools initialIsOpen={false} />
-                      </BookingFlowTrackingProvider>
-                    </BookingFlowContextProvider>
-                  </BookingFlowConfig>
-                </RACRouterProvider>
-              </TrpcProvider>
-            </NuqsAdapter>
-          </ClientIntlProvider>
+                      </BookingFlowProviders>
+                    </BookingFlowConfig>
+                  </RACRouterProvider>
+                </TrpcProvider>
+              </NuqsAdapter>
+            </ClientIntlProvider>
+          </SessionProvider>
         </div>
 
         <Script

apps/partner-sas/app/api/web/auth/[...nextauth]/route.ts

@@ -0,0 +1,11 @@
+import { GET as DEFAULT_GET, POST as DEFAULT_POST } from "@/auth"
+
+import type { NextRequest } from "next/server"
+
+export function GET(req: NextRequest) {
+  return DEFAULT_GET(req)
+}
+
+export function POST(req: NextRequest) {
+  return DEFAULT_POST(req)
+}

apps/partner-sas/app/utils/tracking.ts

@@ -1,152 +0,0 @@
-"use client"
-
-import type {
-  PaymentEvent,
-  PaymentFailEvent,
-} from "@scandic-hotels/tracking/types"
-import type { BreakfastPackages } from "@scandic-hotels/trpc/routers/hotels/output"
-
-export function trackBookingSearchClick(
-  searchTerm: string,
-  searchType: "hotel" | "destination"
-) {
-  console.warn("TODO: Implement trackBookingSearchClick", {
-    searchTerm,
-    searchType,
-  })
-}
-
-export function trackAccordionItemOpen(option: string) {
-  console.warn("TODO: Implement trackAccordionItemOpen", { option })
-}
-
-export function trackOpenSidePeek(input: {
-  name: string | null
-  hotelId: string
-  includePathname?: boolean
-  roomTypeCode?: string | null
-}) {
-  console.warn("TODO: Implement trackOpenSidePeek", { input })
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function trackGenericEvent(data: any) {
-  console.warn("TODO: Implement trackGenericEvent", { data })
-}
-
-export function trackGlaSaveCardAttempt({
-  hotelId,
-  hasSavedCreditCard,
-  creditCardType,
-  lateArrivalGuarantee,
-}: {
-  hotelId: string
-  hasSavedCreditCard: boolean
-  creditCardType?: string
-  lateArrivalGuarantee: "mandatory" | "yes" | "no" | "na"
-}) {
-  console.warn("TODO: Implement trackGlaSaveCardAttempt", {
-    event: "glaCardSaveAttempt",
-    hotelInfo: {
-      hotelId,
-      lateArrivalGuarantee,
-      guaranteedProduct: "room",
-    },
-    paymentInfo: {
-      status: "glacardsaveattempt",
-      isSavedCreditCard: hasSavedCreditCard,
-      type: creditCardType,
-    },
-  })
-}
-
-export function trackLoginClick(
-  position:
-    | "top menu"
-    | "hamburger menu"
-    | "join scandic friends sidebar"
-    | "enter details"
-    | "my stay"
-) {
-  console.warn("TODO: Implement trackLoginClick", {
-    event: "loginStart",
-    login: {
-      position,
-      action: "login start",
-      ctaName: "login",
-    },
-  })
-}
-
-export function trackPaymentEvent(paymentEvent: PaymentEvent) {
-  console.warn("TODO: Implement trackPaymentEvent", {
-    event: paymentEvent.event,
-    hotelInfo: {
-      hotelId: paymentEvent.hotelId,
-    },
-    paymentInfo: {
-      isSavedCard: paymentEvent.isSavedCreditCard,
-      status: paymentEvent.status,
-      type: paymentEvent.method,
-      smsEnable: paymentEvent.smsEnable,
-      errorMessage: isPaymentFailEvent(paymentEvent)
-        ? paymentEvent.errorMessage
-        : undefined,
-    },
-  })
-}
-
-export function trackUpdatePaymentMethod({ method }: { method: string }) {
-  console.warn("TODO: Implement trackUpdatePaymentMethod", {
-    event: "paymentSelection",
-    hotelInfo: {
-      hotelId: "", // TODO: Needs to be verified with analytics if this should even be here
-    },
-    cta: {
-      name: method,
-    },
-  })
-}
-
-export function trackBreakfastSelection({
-  breakfastPackage,
-  hotelId,
-  units,
-}: {
-  breakfastPackage: BreakfastPackages[number]
-  hotelId: string
-  units: number
-}) {
-  console.warn("TODO: Implement trackBreakfastSelection", {
-    event: "breakfastSelection",
-    selection: {
-      name: "breakfast options selection click",
-    },
-    ...(units > 0 && {
-      ancillaries: [
-        {
-          hotelId,
-          productCategory: "",
-          productId: breakfastPackage.code,
-          productUnits: units,
-          productPrice: breakfastPackage.localPrice.price * units,
-          productPoints: 0,
-          productType: "food",
-          productName: breakfastPackage.packageType,
-        },
-      ],
-    }),
-  })
-}
-export function trackBedSelection(bedType: string) {
-  console.warn("TODO: Implement trackBedSelection", {
-    event: "bedSelection",
-    selection: {
-      name: "bed options selection click",
-      bedType: bedType,
-    },
-  })
-}
-function isPaymentFailEvent(event: PaymentEvent): event is PaymentFailEvent {
-  return "errorMessage" in event
-}