Merged in feature/SW-3516-pass-eurobonus-number-on-booking (pull request #2902)

* feat(SW-3516): Include partnerLoyaltyNumber on bookings

- Added user context to BookingFlowProviders for user state management.
- Updated booking input and output schemas to accommodate new user data.
- Refactored booking mutation logic to include user-related information.
- Improved type definitions for better TypeScript support across booking components.


Approved-by: Anton Gunnarsson

packages/trpc/lib/routers/booking/mutation/index.ts

@@ -0,0 +1,332 @@
+import { createLogger } from "@scandic-hotels/common/logger/createLogger"
+import { createCounter } from "@scandic-hotels/common/telemetry"
+
+import { router } from "../../.."
+import * as api from "../../../api"
+import { createRefIdPlugin } from "../../../plugins/refIdToConfirmationNumber"
+import { safeProtectedServiceProcedure } from "../../../procedures"
+import { isValidSession } from "../../../utils/session"
+import {
+  addPackageInput,
+  cancelBookingsInput,
+  guaranteeBookingInput,
+  removePackageInput,
+  updateBookingInput,
+} from "../input"
+import { bookingConfirmationSchema } from "../output"
+import { cancelBooking } from "../utils"
+import { createBookingSchema } from "./create/schema"
+import { create } from "./create"
+
+const refIdPlugin = createRefIdPlugin()
+const bookingLogger = createLogger("trpc.booking")
+
+export const bookingMutationRouter = router({
+  create,
+  priceChange: safeProtectedServiceProcedure
+    .concat(refIdPlugin.toConfirmationNumber)
+    .use(async ({ ctx, next }) => {
+      const token = isValidSession(ctx.session)
+        ? ctx.session.token.access_token
+        : ctx.serviceToken
+
+      return next({
+        ctx: {
+          token,
+        },
+      })
+    })
+    .mutation(async function ({ ctx }) {
+      const { confirmationNumber, token } = ctx
+
+      const priceChangeCounter = createCounter("trpc.booking", "price-change")
+      const metricsPriceChange = priceChangeCounter.init({ confirmationNumber })
+
+      metricsPriceChange.start()
+
+      const headers = {
+        Authorization: `Bearer ${token}`,
+      }
+
+      const apiResponse = await api.put(
+        api.endpoints.v1.Booking.priceChange(confirmationNumber),
+        {
+          headers,
+        }
+      )
+
+      if (!apiResponse.ok) {
+        await metricsPriceChange.httpError(apiResponse)
+        return null
+      }
+
+      const apiJson = await apiResponse.json()
+      const verifiedData = createBookingSchema.safeParse(apiJson)
+      if (!verifiedData.success) {
+        metricsPriceChange.validationError(verifiedData.error)
+        return null
+      }
+
+      metricsPriceChange.success()
+
+      return verifiedData.data
+    }),
+  cancel: safeProtectedServiceProcedure
+    .input(cancelBookingsInput)
+    .concat(refIdPlugin.toConfirmationNumbers)
+    .use(async ({ ctx, next }) => {
+      const token = isValidSession(ctx.session)
+        ? ctx.session.token.access_token
+        : ctx.serviceToken
+
+      return next({
+        ctx: {
+          token,
+        },
+      })
+    })
+    .mutation(async function ({ ctx, input }) {
+      const { confirmationNumbers, token } = ctx
+      const { language } = input
+
+      const responses = await Promise.allSettled(
+        confirmationNumbers.map((confirmationNumber) =>
+          cancelBooking(confirmationNumber, language, token)
+        )
+      )
+
+      const cancelledRoomsSuccessfully: (string | null)[] = []
+      for (const [idx, response] of responses.entries()) {
+        if (response.status === "fulfilled") {
+          if (response.value) {
+            cancelledRoomsSuccessfully.push(confirmationNumbers[idx])
+            continue
+          }
+        } else {
+          bookingLogger.error(
+            `Cancelling booking failed for confirmationNumber: ${confirmationNumbers[idx]}`,
+            response.reason
+          )
+        }
+
+        cancelledRoomsSuccessfully.push(null)
+      }
+
+      return cancelledRoomsSuccessfully
+    }),
+  packages: safeProtectedServiceProcedure
+    .input(addPackageInput)
+    .concat(refIdPlugin.toConfirmationNumber)
+    .use(async ({ ctx, next }) => {
+      const token = isValidSession(ctx.session)
+        ? ctx.session.token.access_token
+        : ctx.serviceToken
+
+      return next({
+        ctx: {
+          token,
+        },
+      })
+    })
+    .mutation(async function ({ ctx, input }) {
+      const { confirmationNumber, token } = ctx
+      const { language, refId, ...body } = input
+
+      const addPackageCounter = createCounter("trpc.booking", "package.add")
+      const metricsAddPackage = addPackageCounter.init({
+        confirmationNumber,
+        language,
+      })
+
+      metricsAddPackage.start()
+
+      const headers = {
+        Authorization: `Bearer ${token}`,
+      }
+
+      const apiResponse = await api.post(
+        api.endpoints.v1.Booking.packages(confirmationNumber),
+        {
+          headers,
+          body: body,
+        },
+        { language }
+      )
+
+      if (!apiResponse.ok) {
+        await metricsAddPackage.httpError(apiResponse)
+        return null
+      }
+
+      const apiJson = await apiResponse.json()
+      const verifiedData = createBookingSchema.safeParse(apiJson)
+      if (!verifiedData.success) {
+        metricsAddPackage.validationError(verifiedData.error)
+        return null
+      }
+
+      metricsAddPackage.success()
+
+      return verifiedData.data
+    }),
+  guarantee: safeProtectedServiceProcedure
+    .input(guaranteeBookingInput)
+    .concat(refIdPlugin.toConfirmationNumber)
+    .use(async ({ ctx, next }) => {
+      const token = isValidSession(ctx.session)
+        ? ctx.session.token.access_token
+        : ctx.serviceToken
+
+      return next({
+        ctx: {
+          token,
+        },
+      })
+    })
+    .mutation(async function ({ ctx, input }) {
+      const { confirmationNumber, token } = ctx
+      const { language, refId, ...body } = input
+
+      const guaranteeBookingCounter = createCounter("trpc.booking", "guarantee")
+      const metricsGuaranteeBooking = guaranteeBookingCounter.init({
+        confirmationNumber,
+        language,
+      })
+
+      metricsGuaranteeBooking.start()
+
+      const headers = {
+        Authorization: `Bearer ${token}`,
+      }
+
+      const apiResponse = await api.put(
+        api.endpoints.v1.Booking.guarantee(confirmationNumber),
+        {
+          headers,
+          body: body,
+        },
+        { language }
+      )
+
+      if (!apiResponse.ok) {
+        await metricsGuaranteeBooking.httpError(apiResponse)
+        return null
+      }
+
+      const apiJson = await apiResponse.json()
+      const verifiedData = createBookingSchema.safeParse(apiJson)
+      if (!verifiedData.success) {
+        metricsGuaranteeBooking.validationError(verifiedData.error)
+        return null
+      }
+
+      metricsGuaranteeBooking.success()
+
+      return verifiedData.data
+    }),
+  update: safeProtectedServiceProcedure
+    .input(updateBookingInput)
+    .concat(refIdPlugin.toConfirmationNumber)
+    .use(async ({ ctx, next }) => {
+      const token = isValidSession(ctx.session)
+        ? ctx.session.token.access_token
+        : ctx.serviceToken
+
+      return next({
+        ctx: {
+          token,
+        },
+      })
+    })
+    .mutation(async function ({ ctx, input }) {
+      const { confirmationNumber, token } = ctx
+      const { language, refId, ...body } = input
+
+      const updateBookingCounter = createCounter("trpc.booking", "update")
+      const metricsUpdateBooking = updateBookingCounter.init({
+        confirmationNumber,
+        language,
+      })
+
+      metricsUpdateBooking.start()
+
+      const apiResponse = await api.put(
+        api.endpoints.v1.Booking.booking(confirmationNumber),
+        {
+          body,
+          headers: {
+            Authorization: `Bearer ${token}`,
+          },
+        },
+        { language }
+      )
+
+      if (!apiResponse.ok) {
+        await metricsUpdateBooking.httpError(apiResponse)
+        return null
+      }
+
+      const apiJson = await apiResponse.json()
+
+      const verifiedData = bookingConfirmationSchema.safeParse(apiJson)
+      if (!verifiedData.success) {
+        metricsUpdateBooking.validationError(verifiedData.error)
+        return null
+      }
+
+      metricsUpdateBooking.success()
+
+      return verifiedData.data
+    }),
+  removePackage: safeProtectedServiceProcedure
+    .input(removePackageInput)
+    .concat(refIdPlugin.toConfirmationNumber)
+    .use(async ({ ctx, next }) => {
+      const token = isValidSession(ctx.session)
+        ? ctx.session.token.access_token
+        : ctx.serviceToken
+
+      return next({
+        ctx: {
+          token,
+        },
+      })
+    })
+    .mutation(async function ({ ctx, input }) {
+      const { confirmationNumber, token } = ctx
+      const { codes, language } = input
+
+      const removePackageCounter = createCounter(
+        "trpc.booking",
+        "package.remove"
+      )
+      const metricsRemovePackage = removePackageCounter.init({
+        confirmationNumber,
+        codes,
+        language,
+      })
+
+      metricsRemovePackage.start()
+
+      const headers = {
+        Authorization: `Bearer ${token}`,
+      }
+
+      const apiResponse = await api.remove(
+        api.endpoints.v1.Booking.packages(confirmationNumber),
+        {
+          headers,
+        },
+        [["language", language], ...codes.map((code) => ["codes", code])]
+      )
+
+      if (!apiResponse.ok) {
+        await metricsRemovePackage.httpError(apiResponse)
+        return false
+      }
+
+      metricsRemovePackage.success()
+
+      return true
+    }),
+})