Merged in chore/refactor-trpc-booking-routes (pull request #3510)

feat(BOOK-750): refactor booking endpoints * WIP * wip * wip * parse dates in UTC * wip * no more errors * Merge branch 'master' of bitbucket.org:scandic-swap/web into chore/refactor-trpc-booking-routes * . * cleanup * import named z from zod * fix(BOOK-750): updateBooking api endpoint expects dateOnly, we passed ISO date Approved-by: Anton Gunnarsson
2026-02-02 14:28:14 +00:00
parent 8ac2c4ba22
commit 16cc26632e
44 changed files with 1621 additions and 1041 deletions
--- a/packages/trpc/lib/routers/booking/mutation/addPackagesRoute.ts
+++ b/packages/trpc/lib/routers/booking/mutation/addPackagesRoute.ts
@@ -0,0 +1,42 @@
+import { z } from "zod"
+
+import { Lang } from "@scandic-hotels/common/constants/language"
+
+import { createRefIdPlugin } from "../../../plugins/refIdToConfirmationNumber"
+import { safeProtectedServiceProcedure } from "../../../procedures"
+import { addPackageToBooking } from "../../../services/booking/addPackageToBooking"
+
+const addPackageInput = z.object({
+  ancillaryComment: z.string(),
+  ancillaryDeliveryTime: z.string().nullish(),
+  packages: z.array(
+    z.object({
+      code: z.string(),
+      quantity: z.number(),
+      comment: z.string().optional(),
+    })
+  ),
+  language: z.nativeEnum(Lang),
+})
+const refIdPlugin = createRefIdPlugin()
+
+export const addPackagesRoute = safeProtectedServiceProcedure
+  .input(addPackageInput)
+  .concat(refIdPlugin.toConfirmationNumber)
+  .use(async ({ ctx, next }) => {
+    const token = await ctx.getScandicUserToken()
+    return next({
+      ctx: {
+        token,
+      },
+    })
+  })
+  .mutation(async function ({ ctx, input }) {
+    const { confirmationNumber } = ctx
+    const { language, refId, ...body } = input
+
+    return await addPackageToBooking(
+      { confirmationNumber, lang: language, ...body },
+      ctx.token ?? ctx.serviceToken
+    )
+  })
--- a/packages/trpc/lib/routers/booking/mutation/cancelBookingRoute.ts
+++ b/packages/trpc/lib/routers/booking/mutation/cancelBookingRoute.ts
@@ -0,0 +1,51 @@
+import { createLogger } from "@scandic-hotels/common/logger/createLogger"
+
+import { createRefIdPlugin } from "../../../plugins/refIdToConfirmationNumber"
+import { safeProtectedServiceProcedure } from "../../../procedures"
+import { cancelBooking } from "../../../services/booking/cancelBooking"
+import { cancelBookingsInput } from "../input"
+
+const bookingLogger = createLogger("trpc.booking.cancelBooking")
+const refIdPlugin = createRefIdPlugin()
+export const cancelBookingRoute = safeProtectedServiceProcedure
+  .input(cancelBookingsInput)
+  .concat(refIdPlugin.toConfirmationNumbers)
+  .use(async ({ ctx, next }) => {
+    const token = await ctx.getScandicUserToken()
+
+    return next({
+      ctx: {
+        token,
+      },
+    })
+  })
+  .mutation(async function ({ ctx, input }) {
+    const { confirmationNumbers } = ctx
+    const { language } = input
+
+    const token = ctx.token ?? ctx.serviceToken
+    const responses = await Promise.allSettled(
+      confirmationNumbers.map((confirmationNumber) =>
+        cancelBooking({ confirmationNumber, language }, token)
+      )
+    )
+
+    const cancelledRoomsSuccessfully: (string | null)[] = []
+    for (const [idx, response] of responses.entries()) {
+      if (response.status === "fulfilled") {
+        if (response.value) {
+          cancelledRoomsSuccessfully.push(confirmationNumbers[idx])
+          continue
+        }
+      } else {
+        bookingLogger.error(
+          `Cancelling booking failed for confirmationNumber: ${confirmationNumbers[idx]}`,
+          response.reason
+        )
+      }
+
+      cancelledRoomsSuccessfully.push(null)
+    }
+
+    return cancelledRoomsSuccessfully
+  })
--- a/packages/trpc/lib/routers/booking/mutation/create/index.ts
+++ b/packages/trpc/lib/routers/booking/mutation/create/index.ts
@@ -1,95 +0,0 @@
-import "server-only"
-
-import { PaymentMethodEnum } from "@scandic-hotels/common/constants/paymentMethod"
-import { createCounter } from "@scandic-hotels/common/telemetry"
-
-import * as api from "../../../../api"
-import { safeProtectedServiceProcedure } from "../../../../procedures"
-import { encrypt } from "../../../../utils/encryption"
-import { createBookingInput, createBookingSchema } from "./schema"
-
-export const create = safeProtectedServiceProcedure
-  .input(createBookingInput)
-  .use(async ({ ctx, next }) => {
-    const token = await ctx.getScandicUserToken()
-
-    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({
-      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 ?? ctx.serviceToken}`,
-    }
-
-    const includePartnerSpecific =
-      inputWithoutLang.payment?.paymentMethod ===
-      PaymentMethodEnum.PartnerPoints
-    if (includePartnerSpecific) {
-      const session = await ctx.auth()
-      const token = session?.token.access_token
-      if (!token) {
-        throw new Error(
-          "Cannot create booking with partner points without partner token"
-        )
-      }
-
-      inputWithoutLang.partnerSpecific = {
-        eurobonusAccessToken: session?.token.access_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()),
-    }
-  })
--- a/packages/trpc/lib/routers/booking/mutation/createBookingRoute/index.ts
+++ b/packages/trpc/lib/routers/booking/mutation/createBookingRoute/index.ts
@@ -0,0 +1,46 @@
+import "server-only"
+
+import { PaymentMethodEnum } from "@scandic-hotels/common/constants/paymentMethod"
+
+import { safeProtectedServiceProcedure } from "../../../../procedures"
+import { createBooking } from "../../../../services/booking/createBooking"
+import { encrypt } from "../../../../utils/encryption"
+import { createBookingInput } from "./schema"
+export const createBookingRoute = safeProtectedServiceProcedure
+  .input(createBookingInput)
+  .use(async ({ ctx, next }) => {
+    const token = await ctx.getScandicUserToken()
+
+    return next({
+      ctx: {
+        token,
+      },
+    })
+  })
+  .mutation(async function ({ ctx, input }) {
+    if (input.payment?.paymentMethod === PaymentMethodEnum.PartnerPoints) {
+      const session = await ctx.auth()
+      const token = session?.token.access_token
+      if (!token) {
+        throw new Error(
+          "Cannot create booking with partner points without partner token"
+        )
+      }
+
+      input.partnerSpecific = {
+        eurobonusAccessToken: session?.token.access_token,
+      }
+    }
+
+    const booking = await createBooking(input, ctx.token ?? ctx.serviceToken)
+    if ("error" in booking) {
+      return { ...booking }
+    }
+
+    const expire = Math.floor(Date.now() / 1000) + 60 // 1 minute expiry
+
+    return {
+      booking,
+      sig: encrypt(expire.toString()),
+    }
+  })
--- a/packages/trpc/lib/routers/booking/mutation/createBookingRoute/schema.ts
+++ b/packages/trpc/lib/routers/booking/mutation/createBookingRoute/schema.ts
@@ -1,11 +1,31 @@
 import { z } from "zod"

 import { Lang } from "@scandic-hotels/common/constants/language"
+import { PaymentMethodEnum } from "@scandic-hotels/common/constants/paymentMethod"

-import { langToApiLang } from "../../../../constants/apiLang"
 import { ChildBedTypeEnum } from "../../../../enums/childBedTypeEnum"
-import { calculateRefId } from "../../../../utils/refId"
-import { guestSchema } from "../../output"
+
+const paymentSchema = z.object({
+  paymentMethod: z.nativeEnum(PaymentMethodEnum),
+  card: z
+    .object({
+      alias: z.string(),
+      expiryDate: z.string(),
+      cardType: z.string(),
+    })
+    .optional(),
+  cardHolder: z
+    .object({
+      email: z.string().email(),
+      name: z.string(),
+      phoneCountryCode: z.string(),
+      phoneSubscriber: z.string(),
+    })
+    .optional(),
+  success: z.string(),
+  error: z.string(),
+  cancel: z.string(),
+})

 const roomsSchema = z
  .array(
@@ -75,28 +95,6 @@ const roomsSchema = z
    })
  })

-const paymentSchema = z.object({
-  paymentMethod: z.string(),
-  card: z
-    .object({
-      alias: z.string(),
-      expiryDate: z.string(),
-      cardType: z.string(),
-    })
-    .optional(),
-  cardHolder: z
-    .object({
-      email: z.string().email(),
-      name: z.string(),
-      phoneCountryCode: z.string(),
-      phoneSubscriber: z.string(),
-    })
-    .optional(),
-  success: z.string(),
-  error: z.string(),
-  cancel: z.string(),
-})
-
 export type CreateBookingInput = z.input<typeof createBookingInput>
 export const createBookingInput = z.object({
  hotelId: z.string(),
@@ -104,78 +102,10 @@ export const createBookingInput = z.object({
  checkOutDate: z.string(),
  rooms: roomsSchema,
  payment: paymentSchema.optional(),
-  language: z.nativeEnum(Lang).transform((val) => langToApiLang[val]),
+  language: z.nativeEnum(Lang),
  partnerSpecific: z
    .object({
      eurobonusAccessToken: z.string(),
    })
    .optional(),
 })
-
-export const createBookingSchema = z
-  .object({
-    data: z.object({
-      attributes: z.object({
-        reservationStatus: z.string(),
-        guest: guestSchema.optional(),
-        paymentUrl: z.string().nullable().optional(),
-        paymentMethod: z.string().nullable().optional(),
-        rooms: z
-          .array(
-            z.object({
-              confirmationNumber: z.string(),
-              cancellationNumber: z.string().nullable(),
-              priceChangedMetadata: z
-                .object({
-                  roomPrice: z.number(),
-                  totalPrice: z.number(),
-                })
-                .nullable()
-                .optional(),
-            })
-          )
-          .default([]),
-        errors: z
-          .array(
-            z.object({
-              confirmationNumber: z.string().nullable().optional(),
-              errorCode: z.string(),
-              description: z.string().nullable().optional(),
-              meta: z
-                .record(z.string(), z.union([z.string(), z.number()]))
-                .nullable()
-                .optional(),
-            })
-          )
-          .default([]),
-      }),
-      type: z.string(),
-      id: z.string(),
-      links: z.object({
-        self: z.object({
-          href: z.string().url(),
-          meta: z.object({
-            method: z.string(),
-          }),
-        }),
-      }),
-    }),
-  })
-  .transform((d) => ({
-    id: d.data.id,
-    links: d.data.links,
-    type: d.data.type,
-    reservationStatus: d.data.attributes.reservationStatus,
-    paymentUrl: d.data.attributes.paymentUrl,
-    paymentMethod: d.data.attributes.paymentMethod,
-    rooms: d.data.attributes.rooms.map((room) => {
-      const lastName = d.data.attributes.guest?.lastName ?? ""
-      return {
-        ...room,
-        refId: calculateRefId(room.confirmationNumber, lastName),
-      }
-    }),
-    errors: d.data.attributes.errors,
-    guest: d.data.attributes.guest,
-  }))
-export type CreateBookingSchema = z.infer<typeof createBookingSchema>
--- a/packages/trpc/lib/routers/booking/mutation/createRefIdRoute.ts
+++ b/packages/trpc/lib/routers/booking/mutation/createRefIdRoute.ts
@@ -0,0 +1,19 @@
+import { serverErrorByStatus } from "../../../errors"
+import { serviceProcedure } from "../../../procedures"
+import { encrypt } from "../../../utils/encryption"
+import { createRefIdInput } from "../input"
+
+export const createRefIdRoute = serviceProcedure
+  .input(createRefIdInput)
+  .mutation(async function ({ input }) {
+    const { confirmationNumber, lastName } = input
+    const encryptedRefId = encrypt(`${confirmationNumber},${lastName}`)
+
+    if (!encryptedRefId) {
+      throw serverErrorByStatus(422, "Was not able to encrypt ref id")
+    }
+
+    return {
+      refId: encryptedRefId,
+    }
+  })
--- a/packages/trpc/lib/routers/booking/mutation/guaranteeBookingRoute.ts
+++ b/packages/trpc/lib/routers/booking/mutation/guaranteeBookingRoute.ts
@@ -0,0 +1,43 @@
+import { z } from "zod"
+
+import { Lang } from "@scandic-hotels/common/constants/language"
+
+import { createRefIdPlugin } from "../../../plugins/refIdToConfirmationNumber"
+import { safeProtectedServiceProcedure } from "../../../procedures"
+import { guaranteeBooking } from "../../../services/booking/guaranteeBooking"
+
+const guaranteeBookingInput = z.object({
+  card: z
+    .object({
+      alias: z.string(),
+      expiryDate: z.string(),
+      cardType: z.string(),
+    })
+    .optional(),
+  language: z.nativeEnum(Lang),
+  success: z.string().nullable(),
+  error: z.string().nullable(),
+  cancel: z.string().nullable(),
+})
+
+const refIdPlugin = createRefIdPlugin()
+export const guaranteeBookingRoute = safeProtectedServiceProcedure
+  .input(guaranteeBookingInput)
+  .concat(refIdPlugin.toConfirmationNumber)
+  .use(async ({ ctx, next }) => {
+    const token = await ctx.getScandicUserToken()
+
+    return next({
+      ctx: {
+        token,
+      },
+    })
+  })
+  .mutation(async function ({ ctx, input }) {
+    const { confirmationNumber } = ctx
+    const { language, refId, ...body } = input
+
+    const token = ctx.token ?? ctx.serviceToken
+
+    return guaranteeBooking({ confirmationNumber, language, ...body }, token)
+  })
--- a/packages/trpc/lib/routers/booking/mutation/index.ts
+++ b/packages/trpc/lib/routers/booking/mutation/index.ts
@@ -1,226 +1,34 @@
-import { createLogger } from "@scandic-hotels/common/logger/createLogger"
+import { dt } from "@scandic-hotels/common/dt"
 import { createCounter } from "@scandic-hotels/common/telemetry"

 import { router } from "../../.."
 import * as api from "../../../api"
 import { createRefIdPlugin } from "../../../plugins/refIdToConfirmationNumber"
 import { safeProtectedServiceProcedure } from "../../../procedures"
+import { updateBooking } from "../../../services/booking/updateBooking"
 import {
-  addPackageInput,
-  cancelBookingsInput,
-  guaranteeBookingInput,
  removePackageInput,
  resendConfirmationInput,
  updateBookingInput,
 } from "../input"
-import { bookingConfirmationSchema } from "../output"
-import { cancelBooking } from "../utils"
-import { createBookingSchema } from "./create/schema"
-import { create } from "./create"
+import { addPackagesRoute } from "./addPackagesRoute"
+import { cancelBookingRoute } from "./cancelBookingRoute"
+import { createBookingRoute } from "./createBookingRoute"
+import { createRefIdRoute } from "./createRefIdRoute"
+import { guaranteeBookingRoute } from "./guaranteeBookingRoute"
+import { priceChangeRoute } from "./priceChangeRoute"
 import { validatePartnerPayment } from "./validatePartnerPayment"

 const refIdPlugin = createRefIdPlugin()
-const bookingLogger = createLogger("trpc.booking")

 export const bookingMutationRouter = router({
-  create,
+  create: createBookingRoute,
+  createRefId: createRefIdRoute,
  validatePartnerPayment,
-  priceChange: safeProtectedServiceProcedure
-    .concat(refIdPlugin.toConfirmationNumber)
-    .use(async ({ ctx, next }) => {
-      const token = await ctx.getScandicUserToken()
-
-      return next({
-        ctx: {
-          token,
-        },
-      })
-    })
-    .mutation(async function ({ ctx }) {
-      const { confirmationNumber } = ctx
-
-      const priceChangeCounter = createCounter("trpc.booking.price-change")
-      const metricsPriceChange = priceChangeCounter.init({ confirmationNumber })
-
-      metricsPriceChange.start()
-
-      const token = ctx.token ?? ctx.serviceToken
-      const headers = {
-        Authorization: `Bearer ${token}`,
-      }
-
-      const apiResponse = await api.put(
-        api.endpoints.v1.Booking.priceChange(confirmationNumber),
-        {
-          headers,
-        }
-      )
-
-      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(cancelBookingsInput)
-    .concat(refIdPlugin.toConfirmationNumbers)
-    .use(async ({ ctx, next }) => {
-      const token = await ctx.getScandicUserToken()
-
-      return next({
-        ctx: {
-          token,
-        },
-      })
-    })
-    .mutation(async function ({ ctx, input }) {
-      const { confirmationNumbers } = ctx
-      const { language } = input
-
-      const token = ctx.token ?? ctx.serviceToken
-      const responses = await Promise.allSettled(
-        confirmationNumbers.map((confirmationNumber) =>
-          cancelBooking(confirmationNumber, language, token)
-        )
-      )
-
-      const cancelledRoomsSuccessfully: (string | null)[] = []
-      for (const [idx, response] of responses.entries()) {
-        if (response.status === "fulfilled") {
-          if (response.value) {
-            cancelledRoomsSuccessfully.push(confirmationNumbers[idx])
-            continue
-          }
-        } else {
-          bookingLogger.error(
-            `Cancelling booking failed for confirmationNumber: ${confirmationNumbers[idx]}`,
-            response.reason
-          )
-        }
-
-        cancelledRoomsSuccessfully.push(null)
-      }
-
-      return cancelledRoomsSuccessfully
-    }),
-  packages: safeProtectedServiceProcedure
-    .input(addPackageInput)
-    .concat(refIdPlugin.toConfirmationNumber)
-    .use(async ({ ctx, next }) => {
-      const token = await ctx.getScandicUserToken()
-      return next({
-        ctx: {
-          token,
-        },
-      })
-    })
-    .mutation(async function ({ ctx, input }) {
-      const { confirmationNumber } = ctx
-      const { language, refId, ...body } = input
-
-      const addPackageCounter = createCounter("trpc.booking.package.add")
-      const metricsAddPackage = addPackageCounter.init({
-        confirmationNumber,
-        language,
-      })
-
-      metricsAddPackage.start()
-
-      const token = ctx.token ?? ctx.serviceToken
-      const headers = {
-        Authorization: `Bearer ${token}`,
-      }
-
-      const apiResponse = await api.post(
-        api.endpoints.v1.Booking.packages(confirmationNumber),
-        {
-          headers,
-          body: body,
-        },
-        { language }
-      )
-
-      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)
-    .concat(refIdPlugin.toConfirmationNumber)
-    .use(async ({ ctx, next }) => {
-      const token = await ctx.getScandicUserToken()
-
-      return next({
-        ctx: {
-          token,
-        },
-      })
-    })
-    .mutation(async function ({ ctx, input }) {
-      const { confirmationNumber } = ctx
-      const { language, refId, ...body } = input
-
-      const guaranteeBookingCounter = createCounter("trpc.booking.guarantee")
-      const metricsGuaranteeBooking = guaranteeBookingCounter.init({
-        confirmationNumber,
-        language,
-      })
-
-      metricsGuaranteeBooking.start()
-
-      const token = ctx.token ?? ctx.serviceToken
-      const headers = {
-        Authorization: `Bearer ${token}`,
-      }
-
-      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
-    }),
+  priceChange: priceChangeRoute,
+  cancel: cancelBookingRoute,
+  packages: addPackagesRoute,
+  guarantee: guaranteeBookingRoute,
  update: safeProtectedServiceProcedure
    .input(updateBookingInput)
    .concat(refIdPlugin.toConfirmationNumber)
@@ -235,43 +43,21 @@ export const bookingMutationRouter = router({
    })
    .mutation(async function ({ ctx, input }) {
      const { confirmationNumber } = ctx
-      const { language, refId, ...body } = input
-
-      const updateBookingCounter = createCounter("trpc.booking.update")
-      const metricsUpdateBooking = updateBookingCounter.init({
-        confirmationNumber,
-        language,
-      })
-
-      metricsUpdateBooking.start()
+      const { language, refId, ...rest } = input
      const token = ctx.token ?? ctx.serviceToken
-      const apiResponse = await api.put(
-        api.endpoints.v1.Booking.booking(confirmationNumber),
+
+      return updateBooking(
        {
-          body,
-          headers: {
-            Authorization: `Bearer ${token}`,
-          },
+          confirmationNumber,
+          lang: language,
+          checkInDate: rest.checkInDate ? dt.utc(rest.checkInDate) : undefined,
+          checkOutDate: rest.checkOutDate
+            ? dt.utc(rest.checkOutDate)
+            : undefined,
+          guest: rest.guest,
        },
-        { language }
+        token
      )
-
-      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)
--- a/packages/trpc/lib/routers/booking/mutation/priceChangeRoute.ts
+++ b/packages/trpc/lib/routers/booking/mutation/priceChangeRoute.ts
@@ -0,0 +1,24 @@
+import { createRefIdPlugin } from "../../../plugins/refIdToConfirmationNumber"
+import { safeProtectedServiceProcedure } from "../../../procedures"
+import { priceChange } from "../../../services/booking/priceChange"
+const refIdPlugin = createRefIdPlugin()
+
+export const priceChangeRoute = safeProtectedServiceProcedure
+  .concat(refIdPlugin.toConfirmationNumber)
+  .use(async ({ ctx, next }) => {
+    const token = await ctx.getScandicUserToken()
+
+    return next({
+      ctx: {
+        token,
+      },
+    })
+  })
+  .mutation(async function ({ ctx }) {
+    const { confirmationNumber } = ctx
+
+    return await priceChange(
+      { confirmationNumber },
+      ctx.token ?? ctx.serviceToken
+    )
+  })
--- a/packages/trpc/lib/routers/booking/mutation/validatePartnerPayment.ts
+++ b/packages/trpc/lib/routers/booking/mutation/validatePartnerPayment.ts
@@ -1,6 +1,6 @@
 import "server-only"

-import z from "zod"
+import { z } from "zod"

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