feat(SW-2116): Use refId instead of confirmationNumber

apps/scandic-web/server/routers/booking/query.ts

@@ -1,5 +1,6 @@
 import * as api from "@/lib/api"
 import { badRequestError, serverErrorByStatus } from "@/server/errors/trpc"
+import { createRefIdPlugin } from "@/server/plugins/refIdToConfirmationNumber"
 import { createCounter } from "@/server/telemetry"
 import {
   router,
@@ -7,8 +8,10 @@ import {
   serviceProcedure,
 } from "@/server/trpc"
 
+import { getBookedHotelRoom } from "@/utils/booking"
+
+import { encrypt } from "../../../utils/encryption"
 import { getHotel } from "../hotels/utils"
-import { encrypt } from "../utils/encryption"
 import {
   createRefIdInput,
   findBookingInput,
@@ -17,28 +20,31 @@ import {
   getLinkedReservationsInput,
 } from "./input"
 import { createBookingSchema } from "./output"
-import { findBooking, getBookedHotelRoom, getBooking } from "./utils"
+import { findBooking, getBooking } from "./utils"
+
+const refIdPlugin = createRefIdPlugin()
 
 export const bookingQueryRouter = router({
   get: safeProtectedServiceProcedure
     .input(getBookingInput)
+    .concat(refIdPlugin.toConfirmationNumber)
     .use(async ({ ctx, input, next }) => {
       const lang = input.lang ?? ctx.lang
-      const token = ctx.session?.token.access_token ?? ctx.serviceToken
       return next({
         ctx: {
           lang,
-          token,
         },
       })
     })
-    .query(async function ({ ctx, input: { confirmationNumber } }) {
+    .query(async function ({ ctx }) {
+      const { confirmationNumber, lang, serviceToken } = ctx
+
       const getBookingCounter = createCounter("trpc.booking", "get")
       const metricsGetBooking = getBookingCounter.init({ confirmationNumber })
 
       metricsGetBooking.start()
 
-      const booking = await getBooking(confirmationNumber, ctx.lang, ctx.token)
+      const booking = await getBooking(confirmationNumber, lang, serviceToken)
 
       if (!booking) {
         metricsGetBooking.dataError(
@@ -52,9 +58,9 @@ export const bookingQueryRouter = router({
         {
           hotelId: booking.hotelId,
           isCardOnlyPayment: false,
-          language: ctx.lang,
+          language: lang,
         },
-        ctx.serviceToken
+        serviceToken
       )
 
       if (!hotelData) {
@@ -141,6 +147,7 @@ export const bookingQueryRouter = router({
     }),
   linkedReservations: safeProtectedServiceProcedure
     .input(getLinkedReservationsInput)
+    .concat(refIdPlugin.toConfirmationNumber)
     .use(async ({ ctx, input, next }) => {
       const lang = input.lang ?? ctx.lang
       const token = ctx.session?.token.access_token ?? ctx.serviceToken
@@ -151,27 +158,36 @@ export const bookingQueryRouter = router({
         },
       })
     })
-    .query(async function ({ ctx, input: { rooms } }) {
+    .query(async function ({ ctx }) {
+      const { confirmationNumber, lang, token } = ctx
+
       const getLinkedReservationsCounter = createCounter(
         "trpc.booking",
         "linkedReservations"
       )
       const metricsGetLinkedReservations = getLinkedReservationsCounter.init({
-        confirmationNumbers: rooms,
+        confirmationNumber,
       })
 
       metricsGetLinkedReservations.start()
 
-      const linkedReservationsResult = await Promise.allSettled(
-        rooms.map((room) =>
-          getBooking(room.confirmationNumber, ctx.lang, ctx.token)
+      const booking = await getBooking(confirmationNumber, lang, token)
+
+      if (!booking) {
+        return []
+      }
+
+      const linkedReservationsResults = await Promise.allSettled(
+        booking.linkedReservations.map((linkedReservation) =>
+          getBooking(linkedReservation.confirmationNumber, lang, token)
         )
       )
+
       const linkedReservations = []
-      for (const booking of linkedReservationsResult) {
-        if (booking.status === "fulfilled") {
-          if (booking.value) {
-            linkedReservations.push(booking.value)
+      for (const linkedReservationsResult of linkedReservationsResults) {
+        if (linkedReservationsResult.status === "fulfilled") {
+          if (linkedReservationsResult.value) {
+            linkedReservations.push(linkedReservationsResult.value)
           } else {
             metricsGetLinkedReservations.dataError(
               `Unexpected value for linked reservation`
@@ -188,44 +204,44 @@ export const bookingQueryRouter = router({
 
       return linkedReservations
     }),
-  status: serviceProcedure.input(getBookingStatusInput).query(async function ({
-    ctx,
-    input,
-  }) {
-    const { confirmationNumber } = input
+  status: serviceProcedure
+    .input(getBookingStatusInput)
+    .concat(refIdPlugin.toConfirmationNumber)
+    .query(async function ({ ctx }) {
+      const { confirmationNumber } = ctx
 
-    const getBookingStatusCounter = createCounter("trpc.booking", "status")
-    const metricsGetBookingStatus = getBookingStatusCounter.init({
-      confirmationNumber,
-    })
+      const getBookingStatusCounter = createCounter("trpc.booking", "status")
+      const metricsGetBookingStatus = getBookingStatusCounter.init({
+        confirmationNumber,
+      })
 
-    metricsGetBookingStatus.start()
+      metricsGetBookingStatus.start()
 
-    const apiResponse = await api.get(
-      api.endpoints.v1.Booking.status(confirmationNumber),
-      {
-        headers: {
-          Authorization: `Bearer ${ctx.serviceToken}`,
-        },
+      const apiResponse = await api.get(
+        api.endpoints.v1.Booking.status(confirmationNumber),
+        {
+          headers: {
+            Authorization: `Bearer ${ctx.serviceToken}`,
+          },
+        }
+      )
+
+      if (!apiResponse.ok) {
+        await metricsGetBookingStatus.httpError(apiResponse)
+        throw serverErrorByStatus(apiResponse.status, apiResponse)
       }
-    )
 
-    if (!apiResponse.ok) {
-      await metricsGetBookingStatus.httpError(apiResponse)
-      throw serverErrorByStatus(apiResponse.status, apiResponse)
-    }
+      const apiJson = await apiResponse.json()
+      const verifiedData = createBookingSchema.safeParse(apiJson)
+      if (!verifiedData.success) {
+        metricsGetBookingStatus.validationError(verifiedData.error)
+        throw badRequestError()
+      }
 
-    const apiJson = await apiResponse.json()
-    const verifiedData = createBookingSchema.safeParse(apiJson)
-    if (!verifiedData.success) {
-      metricsGetBookingStatus.validationError(verifiedData.error)
-      throw badRequestError()
-    }
+      metricsGetBookingStatus.success()
 
-    metricsGetBookingStatus.success()
-
-    return verifiedData.data
-  }),
+      return verifiedData.data
+    }),
   createRefId: serviceProcedure
     .input(createRefIdInput)
     .mutation(async function ({ input }) {