feat: bedtypes is selectable again

apps/scandic-web/server/routers/hotels/output.ts

@@ -23,10 +23,10 @@ import {
   breakfastPackageSchema,
   packageSchema,
 } from "./schemas/packages"
-import { rateSchema } from "./schemas/rate"
 import { relationshipsSchema } from "./schemas/relationships"
 import { roomConfigurationSchema } from "./schemas/roomAvailability/configuration"
 import { rateDefinitionSchema } from "./schemas/roomAvailability/rateDefinition"
+import { sortRoomConfigs } from "./utils"
 
 import { AvailabilityEnum } from "@/types/components/hotelReservation/selectHotel/selectHotel"
 import { RoomPackageCodeEnum } from "@/types/components/hotelReservation/selectRate/roomFilter"
@@ -42,7 +42,6 @@ import type {
 import type {
   Product,
   RateDefinition,
-  RoomConfiguration,
 } from "@/types/trpc/routers/hotel/roomAvailability"
 
 // NOTE: Find schema at: https://aks-test.scandichotels.com/hotel/swagger/v1/index.html
@@ -136,18 +135,6 @@ const cancellationRules = {
   NotCancellable: 0,
 } as const
 
-// Used to ensure `Available` rooms
-// are shown before all `NotAvailable`
-const statusLookup = {
-  [AvailabilityEnum.Available]: 1,
-  [AvailabilityEnum.NotAvailable]: 2,
-}
-
-function sortRoomConfigs(a: RoomConfiguration, b: RoomConfiguration) {
-  // @ts-expect-error - array indexing
-  return statusLookup[a.status] - statusLookup[b.status]
-}
-
 export const roomsAvailabilitySchema = z
   .object({
     data: z.object({
@@ -158,48 +145,10 @@ export const roomsAvailabilitySchema = z
         hotelId: z.number(),
         mustBeGuaranteed: z.boolean().optional(),
         occupancy: occupancySchema.optional(),
+        packages: z.array(packageSchema).optional().default([]),
         rateDefinitions: z.array(rateDefinitionSchema),
-        roomConfigurations: z
-          .array(roomConfigurationSchema)
-          .transform((data) => {
-            // Initial sort to guarantee if one bed is NotAvailable and whereas
-            // the other is Available to make sure data is added to the correct
-            // roomConfig
-            const configs = data.sort(sortRoomConfigs)
-            const roomConfigs = new Map<string, RoomConfiguration>()
-            for (const roomConfig of configs) {
-              if (roomConfigs.has(roomConfig.roomType)) {
-                const currentRoomConf = roomConfigs.get(roomConfig.roomType)
-                if (currentRoomConf) {
-                  currentRoomConf.features = roomConfig.features.reduce(
-                    (feats, feature) => {
-                      const currentFeatureIndex = feats.findIndex(
-                        (f) => f.code === feature.code
-                      )
-                      if (currentFeatureIndex !== -1) {
-                        feats[currentFeatureIndex].inventory =
-                          feats[currentFeatureIndex].inventory +
-                          feature.inventory
-                      } else {
-                        feats.push(feature)
-                      }
-                      return feats
-                    },
-                    currentRoomConf.features
-                  )
-                  currentRoomConf.roomsLeft =
-                    currentRoomConf.roomsLeft + roomConfig.roomsLeft
-                  roomConfigs.set(currentRoomConf.roomType, currentRoomConf)
-                }
-              } else {
-                roomConfigs.set(roomConfig.roomType, roomConfig)
-              }
-            }
-            return Array.from(roomConfigs.values())
-          }),
+        roomConfigurations: z.array(roomConfigurationSchema),
       }),
-      relationships: relationshipsSchema.optional(),
-      type: z.string().optional(),
     }),
   })
   .transform(({ data: { attributes } }) => {
@@ -425,8 +374,6 @@ export const roomsAvailabilitySchema = z
     }
   })
 
-export const ratesSchema = z.array(rateSchema)
-
 export const citiesByCountrySchema = z.object({
   data: z.array(
     citySchema.transform((data) => {
@@ -597,17 +544,6 @@ export const packagesSchema = z
           hotelId: z.number(),
           packages: z.array(packageSchema).default([]),
         }),
-        relationships: z
-          .object({
-            links: z.array(
-              z.object({
-                type: z.string(),
-                url: z.string(),
-              })
-            ),
-          })
-          .optional(),
-        type: z.string(),
       })
       .optional(),
   })