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

import "server-only"

import { createCounter } from "@scandic-hotels/common/telemetry"

import * as api from "../../../../api"
import { safeProtectedServiceProcedure } from "../../../../procedures"
import { encrypt } from "../../../../utils/encryption"
import { isValidSession } from "../../../../utils/session"
import { getMembershipNumber } from "../../../user/utils"
import { createBookingInput, createBookingSchema } from "./schema"

export const create = safeProtectedServiceProcedure
  .input(createBookingInput)
  .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 { language, ...inputWithoutLang } = input
    const { rooms, ...loggableInput } = inputWithoutLang

    const createBookingCounter = createCounter("trpc.booking", "create")
    const metricsCreateBooking = createBookingCounter.init({
      membershipNumber: await getMembershipNumber(ctx.session),
      language,
      ...loggableInput,
      rooms: inputWithoutLang.rooms.map(({ guest, ...room }) => {
        const { becomeMember, membershipNumber } = guest
        return { ...room, guest: { becomeMember, membershipNumber } }
      }),
    })

    metricsCreateBooking.start()

    const headers = {
      Authorization: `Bearer ${ctx.token}`,
    }

    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()

    const expire = Math.floor(Date.now() / 1000) + 60 // 1 minute expiry

    return {
      booking: verifiedData.data,
      sig: encrypt(expire.toString()),
    }
  })