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

import * as api from "@/lib/api"
import { getMembershipNumber } from "@/server/routers/user/utils"
import { createCounter } from "@/server/telemetry"
import { router, safeProtectedServiceProcedure } from "@/server/trpc"

import {
  addPackageInput,
  cancelBookingInput,
  createBookingInput,
  guaranteeBookingInput,
  priceChangeInput,
  removePackageInput,
  updateBookingInput,
} from "./input"
import { bookingConfirmationSchema, createBookingSchema } from "./output"

export const bookingMutationRouter = router({
  create: safeProtectedServiceProcedure
    .input(createBookingInput)
    .mutation(async function ({ ctx, input }) {
      const accessToken = ctx.session?.token.access_token ?? ctx.serviceToken
      const { language, ...inputWithoutLang } = input
      const { hotelId, checkInDate, checkOutDate } = inputWithoutLang

      const createBookingCounter = createCounter("trpc.booking", "create")
      const metricsCreateBooking = createBookingCounter.init({
        membershipNumber: await getMembershipNumber(ctx.session),
        checkInDate,
        checkOutDate,
        hotelId,
        language,
      })

      metricsCreateBooking.start()

      const headers = {
        Authorization: `Bearer ${accessToken}`,
      }

      const apiResponse = await api.post(
        api.endpoints.v1.Booking.bookings,
        {
          headers,
          body: inputWithoutLang,
        },
        { language }
      )

      if (!apiResponse.ok) {
        await metricsCreateBooking.httpError(apiResponse)

        const apiJson = await apiResponse.json()
        if ("errors" in apiJson && apiJson.errors.length) {
          const error = apiJson.errors[0]
          return { error: true, cause: error.code } as const
        }

        return null
      }

      const apiJson = await apiResponse.json()

      const verifiedData = createBookingSchema.safeParse(apiJson)
      if (!verifiedData.success) {
        metricsCreateBooking.validationError(verifiedData.error)
        return null
      }

      metricsCreateBooking.success()

      return verifiedData.data
    }),
  priceChange: safeProtectedServiceProcedure
    .input(priceChangeInput)
    .mutation(async function ({ ctx, input }) {
      const { confirmationNumber } = input

      const priceChangeCounter = createCounter("trpc.booking", "price-change")
      const metricsPriceChange = priceChangeCounter.init({ confirmationNumber })

      metricsPriceChange.start()

      const accessToken = ctx.session?.token.access_token ?? ctx.serviceToken

      const headers = {
        Authorization: `Bearer ${accessToken}`,
      }

      const apiResponse = await api.put(
        api.endpoints.v1.Booking.priceChange(confirmationNumber),
        {
          headers,
          body: input,
        }
      )

      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(cancelBookingInput)
    .mutation(async function ({ ctx, input }) {
      const accessToken = ctx.session?.token.access_token ?? ctx.serviceToken
      const { confirmationNumber, language } = input

      const cancelBookingCounter = createCounter("trpc.booking", "cancel")
      const metricsCancelBooking = cancelBookingCounter.init({
        confirmationNumber,
        language,
      })

      metricsCancelBooking.start()

      const headers = {
        Authorization: `Bearer ${accessToken}`,
      }

      const cancellationReason = {
        reasonCode: "WEB-CANCEL",
        reason: "WEB-CANCEL",
      }

      const apiResponse = await api.remove(
        api.endpoints.v1.Booking.cancel(confirmationNumber),
        {
          headers,
          body: JSON.stringify(cancellationReason),
        } as RequestInit,
        { language }
      )

      if (!apiResponse.ok) {
        await metricsCancelBooking.httpError(apiResponse)
        return false
      }

      const apiJson = await apiResponse.json()

      const verifiedData = createBookingSchema.safeParse(apiJson)

      if (!verifiedData.success) {
        metricsCancelBooking.validationError(verifiedData.error)
        return null
      }

      metricsCancelBooking.success()

      return verifiedData.data
    }),
  packages: safeProtectedServiceProcedure
    .input(addPackageInput)
    .mutation(async function ({ ctx, input }) {
      const accessToken = ctx.session?.token.access_token ?? ctx.serviceToken
      const { confirmationNumber, ...body } = input

      const addPackageCounter = createCounter("trpc.booking", "package.add")
      const metricsAddPackage = addPackageCounter.init({ confirmationNumber })

      metricsAddPackage.start()

      const headers = {
        Authorization: `Bearer ${accessToken}`,
      }

      const apiResponse = await api.post(
        api.endpoints.v1.Booking.packages(confirmationNumber),
        {
          headers,
          body: body,
        }
      )

      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)
    .mutation(async function ({ ctx, input }) {
      const accessToken = ctx.session?.token.access_token ?? ctx.serviceToken
      const { confirmationNumber, language, ...body } = input

      const guaranteeBookingCounter = createCounter("trpc.booking", "guarantee")
      const metricsGuaranteeBooking = guaranteeBookingCounter.init({
        confirmationNumber,
      })

      metricsGuaranteeBooking.start()

      const headers = {
        Authorization: `Bearer ${accessToken}`,
      }

      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)
    .mutation(async function ({ ctx, input }) {
      const accessToken = ctx.session?.token.access_token || ctx.serviceToken
      const { confirmationNumber, ...body } = input

      const updateBookingCounter = createCounter("trpc.booking", "update")
      const metricsUpdateBooking = updateBookingCounter.init({
        confirmationNumber,
      })

      metricsUpdateBooking.start()

      const apiResponse = await api.put(
        api.endpoints.v1.Booking.booking(confirmationNumber),
        {
          body,
          headers: {
            Authorization: `Bearer ${accessToken}`,
          },
        }
      )

      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)
    .mutation(async function ({ ctx, input }) {
      const accessToken = ctx.session?.token.access_token ?? ctx.serviceToken
      const { confirmationNumber, codes, language } = input

      const removePackageCounter = createCounter(
        "trpc.booking",
        "package.remove"
      )
      const metricsRemovePackage = removePackageCounter.init({
        confirmationNumber,
        codes,
        language,
      })

      metricsRemovePackage.start()

      const headers = {
        Authorization: `Bearer ${accessToken}`,
      }

      const apiResponse = await api.remove(
        api.endpoints.v1.Booking.packages(confirmationNumber),
        {
          headers,
        } as RequestInit,
        [["language", language], ...codes.map((code) => ["codes", code])]
      )

      if (!apiResponse.ok) {
        await metricsRemovePackage.httpError(apiResponse)
        return false
      }

      metricsRemovePackage.success()

      return true
    }),
})