feat: refactor of my stay

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

@@ -13,68 +13,54 @@ import {
   createRefIdInput,
   getBookingInput,
   getBookingStatusInput,
+  getLinkedReservationsInput,
 } from "./input"
-import { bookingConfirmationSchema, createBookingSchema } from "./output"
-import { getBookedHotelRoom } from "./utils"
+import { createBookingSchema } from "./output"
+import { getBookedHotelRoom, getBooking } from "./utils"
 
 export const bookingQueryRouter = router({
   get: safeProtectedServiceProcedure
     .input(getBookingInput)
-    .query(async function ({
-      ctx,
-      input: { confirmationNumber, lang: inputLang },
-    }) {
+    .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 } }) {
       const getBookingCounter = createCounter("trpc.booking", "get")
       const metricsGetBooking = getBookingCounter.init({ confirmationNumber })
 
       metricsGetBooking.start()
 
-      let lang = ctx.lang ?? inputLang
+      const booking = await getBooking(confirmationNumber, ctx.lang, ctx.token)
 
-      const token = ctx.session?.token.access_token ?? ctx.serviceToken
-
-      const apiResponse = await api.get(
-        api.endpoints.v1.Booking.booking(confirmationNumber),
-        {
-          headers: {
-            Authorization: `Bearer ${token}`,
-          },
-        }
-      )
-
-      if (!apiResponse.ok) {
-        await metricsGetBooking.httpError(apiResponse)
-
-        // If the booking is not found, return null.
-        // This scenario is expected to happen when a logged in user trying to access a booking that doesn't belong to them.
-        if (apiResponse.status === 400) {
-          return null
-        }
-
-        throw serverErrorByStatus(apiResponse.status, apiResponse)
-      }
-
-      const apiJson = await apiResponse.json()
-      const booking = bookingConfirmationSchema.safeParse(apiJson)
-      if (!booking.success) {
-        metricsGetBooking.validationError(booking.error)
-        throw badRequestError()
+      if (!booking) {
+        metricsGetBooking.dataError(
+          `Fail to get booking data for ${confirmationNumber}`,
+          { confirmationNumber }
+        )
+        return null
       }
 
       const hotelData = await getHotel(
         {
-          hotelId: booking.data.hotelId,
+          hotelId: booking.hotelId,
           isCardOnlyPayment: false,
-          language: lang,
+          language: ctx.lang,
         },
         ctx.serviceToken
       )
 
       if (!hotelData) {
         metricsGetBooking.dataError(
-          `Failed to get hotel data for ${booking.data.hotelId}`,
+          `Failed to get hotel data for ${booking.hotelId}`,
           {
-            hotelId: booking.data.hotelId,
+            hotelId: booking.hotelId,
           }
         )
 
@@ -85,13 +71,62 @@ export const bookingQueryRouter = router({
 
       return {
         ...hotelData,
-        booking: booking.data,
+        booking,
         room: getBookedHotelRoom(
           hotelData.roomCategories,
-          booking.data.roomTypeCode
+          booking.roomTypeCode
         ),
       }
     }),
+  linkedReservations: safeProtectedServiceProcedure
+    .input(getLinkedReservationsInput)
+    .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: { rooms } }) {
+      const getLinkedReservationsCounter = createCounter(
+        "trpc.booking",
+        "linkedReservations"
+      )
+      const metricsGetLinkedReservations = getLinkedReservationsCounter.init({
+        confirmationNumbers: rooms,
+      })
+
+      metricsGetLinkedReservations.start()
+
+      const linkedReservationsResult = await Promise.allSettled(
+        rooms.map((room) =>
+          getBooking(room.confirmationNumber, ctx.lang, ctx.token)
+        )
+      )
+      const linkedReservations = []
+      for (const booking of linkedReservationsResult) {
+        if (booking.status === "fulfilled") {
+          if (booking.value) {
+            linkedReservations.push(booking.value)
+          } else {
+            metricsGetLinkedReservations.dataError(
+              `Unexpected value for linked reservation`
+            )
+          }
+        } else {
+          metricsGetLinkedReservations.dataError(
+            `Failed to get linked reservation`
+          )
+        }
+      }
+
+      metricsGetLinkedReservations.success()
+
+      return linkedReservations
+    }),
   status: serviceProcedure.input(getBookingStatusInput).query(async function ({
     ctx,
     input,