Merge master

This commit is contained in:
Linus Flood
2025-05-02 14:01:50 +02:00
116 changed files with 2531 additions and 1682 deletions

View File

@@ -1,3 +1,5 @@
import { BookingStatusEnum } from "@/constants/booking"
import { bookingConfirmation } from "@/constants/routes/hotelReservation"
import * as api from "@/lib/api"
import { badRequestError, serverErrorByStatus } from "@/server/errors/trpc"
import { createCounter } from "@/server/telemetry"
@@ -6,39 +8,47 @@ import {
safeProtectedServiceProcedure,
serviceProcedure,
} from "@/server/trpc"
import { getBookedHotelRoom } from "@/stores/my-stay"
import { calculateRefId, parseRefId } from "@/utils/refId"
import { getHotel } from "../hotels/utils"
import { encrypt } from "../utils/encryption"
import {
bookingConfirmationInput,
createRefIdInput,
findBookingInput,
getBookingInput,
getBookingConfirmationErrorInput,
getBookingStatusInput,
getConfirmationCompletedInput,
getLinkedReservationsInput,
} from "./input"
import { createBookingSchema } from "./output"
import { findBooking, getBookedHotelRoom, getBooking } from "./utils"
import { findBooking, getBooking, getLinkedReservations } from "./utils"
import type { BookingSchema } from "@/types/trpc/routers/booking/confirmation"
export const bookingQueryRouter = router({
get: safeProtectedServiceProcedure
.input(getBookingInput)
confirmation: safeProtectedServiceProcedure
.input(bookingConfirmationInput)
.use(async ({ ctx, input, next }) => {
const lang = input.lang ?? ctx.lang
const token = ctx.session?.token.access_token ?? ctx.serviceToken
const { confirmationNumber } = parseRefId(input.refId)
return next({
ctx: {
lang,
token,
confirmationNumber,
},
})
})
.query(async function ({ ctx, input: { confirmationNumber } }) {
.query(async function ({
ctx: { confirmationNumber, lang, serviceToken },
}) {
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)
if (!booking) {
metricsGetBooking.dataError(
@@ -52,9 +62,9 @@ export const bookingQueryRouter = router({
{
hotelId: booking.hotelId,
isCardOnlyPayment: false,
language: ctx.lang,
language: lang,
},
ctx.serviceToken
serviceToken
)
if (!hotelData) {
@@ -68,15 +78,29 @@ export const bookingQueryRouter = router({
throw serverErrorByStatus(404)
}
const room = getBookedHotelRoom(
hotelData.roomCategories,
booking.roomTypeCode
)
if (!room) {
metricsGetBooking.dataError(
`Failed to extract booked room ${booking.roomTypeCode} from room categories for ${booking.hotelId}`,
{
roomTypeCode: booking.roomTypeCode,
hotelId: booking.hotelId,
}
)
throw serverErrorByStatus(404)
}
metricsGetBooking.success()
return {
...hotelData,
hotelData,
booking,
room: getBookedHotelRoom(
hotelData.roomCategories,
booking.roomTypeCode
),
room,
}
}),
findBooking: safeProtectedServiceProcedure
@@ -128,109 +152,248 @@ export const bookingQueryRouter = router({
throw serverErrorByStatus(404)
}
const room = getBookedHotelRoom(
hotelData.roomCategories,
booking.roomTypeCode
)
if (!room) {
metricsFindBooking.dataError(
`Failed to extract booked room ${booking.roomTypeCode} from room categories for ${booking.hotelId}`,
{
roomTypeCode: booking.roomTypeCode,
hotelId: booking.hotelId,
}
)
throw serverErrorByStatus(404)
}
metricsFindBooking.success()
return {
...hotelData,
hotelData,
booking,
room: getBookedHotelRoom(
hotelData.roomCategories,
booking.roomTypeCode
),
room,
}
}),
linkedReservations: safeProtectedServiceProcedure
.input(getLinkedReservationsInput)
.use(async ({ ctx, input, next }) => {
const lang = input.lang ?? ctx.lang
const token = ctx.session?.token.access_token ?? ctx.serviceToken
const { confirmationNumber } = parseRefId(input.refId)
return next({
ctx: {
lang,
token,
confirmationNumber,
},
})
})
.query(async function ({ ctx, input: { rooms } }) {
const getLinkedReservationsCounter = createCounter(
.query(async function ({ ctx: { confirmationNumber, lang } }) {
const linkedReservationsCounter = createCounter(
"trpc.booking",
"linkedReservations"
)
const metricsGetLinkedReservations = getLinkedReservationsCounter.init({
confirmationNumbers: rooms,
const metricsLinkedReservations = linkedReservationsCounter.init({
confirmationNumber,
})
metricsGetLinkedReservations.start()
metricsLinkedReservations.start()
const linkedReservationsResult = await Promise.allSettled(
rooms.map((room) =>
getBooking(room.confirmationNumber, ctx.lang, ctx.token)
)
const linkedReservations = await getLinkedReservations(
confirmationNumber,
lang
)
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`
if (!linkedReservations) {
metricsLinkedReservations.noDataError()
return null
}
const validLinkedReservations = linkedReservations.reduce<
BookingSchema[]
>((acc, linkedReservation) => {
if ("error" in linkedReservation) {
metricsLinkedReservations.dataError(
`Failed to get linked reservations ${linkedReservation.confirmationNumber}`,
{
linkedReservationConfirmationNumber:
linkedReservation.confirmationNumber,
}
)
return acc
}
}
metricsGetLinkedReservations.success()
acc.push(linkedReservation)
return acc
}, [])
return linkedReservations
metricsLinkedReservations.success()
return validLinkedReservations
}),
status: serviceProcedure.input(getBookingStatusInput).query(async function ({
ctx,
input,
}) {
const { confirmationNumber } = input
status: serviceProcedure
.input(getBookingStatusInput)
.use(async ({ input, next }) => {
const { confirmationNumber } = parseRefId(input.refId)
const getBookingStatusCounter = createCounter("trpc.booking", "status")
const metricsGetBookingStatus = getBookingStatusCounter.init({
confirmationNumber,
})
metricsGetBookingStatus.start()
const apiResponse = await api.get(
api.endpoints.v1.Booking.status(confirmationNumber),
{
headers: {
Authorization: `Bearer ${ctx.serviceToken}`,
return next({
ctx: {
confirmationNumber,
},
})
})
.query(async function ({ ctx: { confirmationNumber, serviceToken } }) {
const getBookingStatusCounter = createCounter("trpc.booking", "status")
const metricsGetBookingStatus = getBookingStatusCounter.init({
confirmationNumber,
})
metricsGetBookingStatus.start()
const apiResponse = await api.get(
api.endpoints.v1.Booking.status(confirmationNumber),
{
headers: {
Authorization: `Bearer ${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
}),
confirmationCompleted: serviceProcedure
.input(getConfirmationCompletedInput)
.use(async ({ input, next }) => {
const { confirmationNumber } = parseRefId(input.refId)
return next({
ctx: {
confirmationNumber,
},
})
})
.query(async function ({ ctx, input }) {
const { confirmationNumber } = ctx
const confirmationCompletedCounter = createCounter(
"trpc.booking",
"confirmationCompleted"
)
const metricsConfirmationCompleted = confirmationCompletedCounter.init({
confirmationNumber,
})
metricsConfirmationCompleted.start()
const apiResponse = await api.get(
api.endpoints.v1.Booking.status(confirmationNumber),
{
headers: {
Authorization: `Bearer ${ctx.serviceToken}`,
},
}
)
if (!apiResponse.ok) {
await metricsConfirmationCompleted.httpError(apiResponse)
throw serverErrorByStatus(apiResponse.status, apiResponse)
}
const apiJson = await apiResponse.json()
const verifiedData = createBookingSchema.safeParse(apiJson)
if (!verifiedData.success) {
metricsConfirmationCompleted.validationError(verifiedData.error)
throw badRequestError()
}
const confirmationUrl =
verifiedData.data.reservationStatus ===
BookingStatusEnum.BookingCompleted
? `${bookingConfirmation(input.lang)}?RefId=${verifiedData.data.rooms[0].refId}`
: ""
const result = {
...verifiedData.data,
redirectUrl: verifiedData.data.paymentUrl || confirmationUrl,
}
metricsConfirmationCompleted.success()
return result
}),
confirmationError: serviceProcedure
.input(getBookingConfirmationErrorInput)
.use(async ({ input, next }) => {
const { confirmationNumber } = parseRefId(input.refId)
return next({
ctx: {
confirmationNumber,
},
})
})
.query(async function ({ ctx }) {
const { confirmationNumber } = ctx
const confirmationErrorCounter = createCounter(
"trpc.booking",
"confirmationError"
)
const metricsConfirmationError = confirmationErrorCounter.init({
confirmationNumber,
})
metricsConfirmationError.start()
const apiResponse = await api.get(
api.endpoints.v1.Booking.status(confirmationNumber),
{
headers: {
Authorization: `Bearer ${ctx.serviceToken}`,
},
}
)
if (!apiResponse.ok) {
await metricsConfirmationError.httpError(apiResponse)
throw serverErrorByStatus(apiResponse.status, apiResponse)
}
const apiJson = await apiResponse.json()
const verifiedData = createBookingSchema.safeParse(apiJson)
if (!verifiedData.success) {
metricsConfirmationError.validationError(verifiedData.error)
throw badRequestError()
}
metricsConfirmationError.success()
return verifiedData.data
}),
return verifiedData.data
}),
createRefId: serviceProcedure
.input(createRefIdInput)
.mutation(async function ({ input }) {
const { confirmationNumber, lastName } = input
const encryptedRefId = encrypt(`${confirmationNumber},${lastName}`)
const encryptedRefId = calculateRefId(confirmationNumber, lastName)
if (!encryptedRefId) {
throw serverErrorByStatus(422, "Was not able to encrypt ref id")