fix: clean up hotel and its typings

server/routers/hotels/schemas/hotel/address.ts

@@ -0,0 +1,8 @@
+import { z } from "zod"
+
+export const addressSchema = z.object({
+  city: z.string(),
+  country: z.string(),
+  streetAddress: z.string(),
+  zipCode: z.string(),
+})

server/routers/hotels/schemas/hotel/contactInformation.ts

@@ -0,0 +1,8 @@
+import { z } from "zod"
+
+export const contactInformationSchema = z.object({
+  email: z.string(),
+  faxNumber: z.string().optional(),
+  phoneNumber: z.string(),
+  websiteUrl: z.string(),
+})

server/routers/hotels/schemas/hotel/content.ts

@@ -0,0 +1,40 @@
+import { z } from "zod"
+
+import { imageSchema } from "../image"
+
+export const hotelContentSchema = z.object({
+  images: imageSchema.default({
+    metaData: {
+      altText: "default image",
+      altText_En: "default image",
+      copyRight: "default image",
+      title: "default image",
+    },
+    imageSizes: {
+      large: "https://placehold.co/1280x720",
+      medium: "https://placehold.co/1280x720",
+      small: "https://placehold.co/1280x720",
+      tiny: "https://placehold.co/1280x720",
+    },
+  }),
+  restaurantsOverviewPage: z.object({
+    restaurantsContentDescriptionMedium: z.string().optional(),
+    restaurantsContentDescriptionShort: z.string().optional(),
+    restaurantsOverviewPageLink: z.string().optional(),
+    restaurantsOverviewPageLinkText: z.string().optional(),
+  }),
+  texts: z.object({
+    descriptions: z.object({
+      medium: z.string(),
+      short: z.string(),
+    }),
+    facilityInformation: z.string().optional(),
+    meetingDescription: z
+      .object({
+        medium: z.string().optional(),
+        short: z.string().optional(),
+      })
+      .optional(),
+    surroundingInformation: z.string(),
+  }),
+})

server/routers/hotels/schemas/hotel/detailedFacility.ts

@@ -0,0 +1,18 @@
+import { z } from "zod"
+
+import { FacilityEnum } from "@/types/enums/facilities"
+
+const detailedFacilitySchema = z.object({
+  filter: z.string().optional(),
+  icon: z.string().optional(),
+  id: z.nativeEnum(FacilityEnum),
+  name: z.string(),
+  public: z.boolean(),
+  sortOrder: z.number(),
+})
+
+export const detailedFacilitiesSchema = z
+  .array(detailedFacilitySchema)
+  .transform((facilities) =>
+    facilities.sort((a, b) => b.sortOrder - a.sortOrder)
+  )

server/routers/hotels/schemas/hotel/facts.ts

@@ -0,0 +1,80 @@
+import { z } from "zod"
+
+const ecoLabelsSchema = z.object({
+  euEcoLabel: z.boolean(),
+  greenGlobeLabel: z.boolean(),
+  nordicEcoLabel: z.boolean(),
+  svanenEcoLabelCertificateNumber: z.string().optional(),
+})
+
+export const checkinSchema = z.object({
+  checkInTime: z.string(),
+  checkOutTime: z.string(),
+  onlineCheckout: z.boolean(),
+  onlineCheckOutAvailableFrom: z.string().nullable().optional(),
+})
+
+const hotelFacilityDetailSchema = z
+  .object({
+    description: z.string(),
+    heading: z.string(),
+  })
+  .optional()
+
+/** Possibly more values */
+const hotelFacilityDetailsSchema = z.object({
+  breakfast: hotelFacilityDetailSchema,
+  checkout: hotelFacilityDetailSchema,
+  gym: hotelFacilityDetailSchema,
+  internet: hotelFacilityDetailSchema,
+  laundry: hotelFacilityDetailSchema,
+  luggage: hotelFacilityDetailSchema,
+  shop: hotelFacilityDetailSchema,
+  telephone: hotelFacilityDetailSchema,
+})
+
+const hotelInformationSchema = z
+  .object({
+    description: z.string(),
+    heading: z.string(),
+    link: z.string().optional(),
+  })
+  .optional()
+
+const hotelInformationsSchema = z.object({
+  accessibility: hotelInformationSchema,
+  safety: hotelInformationSchema,
+  sustainability: hotelInformationSchema,
+})
+
+const interiorSchema = z.object({
+  numberOfBeds: z.number(),
+  numberOfCribs: z.number(),
+  numberOfFloors: z.number(),
+  numberOfRooms: z.object({
+    connected: z.number(),
+    forAllergics: z.number().optional(),
+    forDisabled: z.number(),
+    nonSmoking: z.number(),
+    pet: z.number(),
+    withExtraBeds: z.number(),
+    total: z.number(),
+  }),
+})
+
+const receptionHoursSchema = z.object({
+  alwaysOpen: z.boolean(),
+  isClosed: z.boolean(),
+  openingTime: z.string().optional(),
+  closingTime: z.string().optional(),
+})
+
+export const hotelFactsSchema = z.object({
+  checkin: checkinSchema,
+  ecoLabels: ecoLabelsSchema,
+  hotelFacilityDetail: hotelFacilityDetailsSchema.default({}),
+  hotelInformation: hotelInformationsSchema.default({}),
+  interior: interiorSchema,
+  receptionHours: receptionHoursSchema,
+  yearBuilt: z.string(),
+})

server/routers/hotels/schemas/hotel/gallery.ts

@@ -0,0 +1,8 @@
+import { z } from "zod"
+
+import { imageSchema } from "../image"
+
+export const gallerySchema = z.object({
+  heroImages: z.array(imageSchema),
+  smallerImages: z.array(imageSchema),
+})

server/routers/hotels/schemas/hotel/healthFacilities.ts

@@ -0,0 +1,41 @@
+import { z } from "zod"
+
+import { imageSchema } from "../image"
+
+const healthFacilitiesOpenHoursSchema = z.object({
+  alwaysOpen: z.boolean(),
+  closingTime: z.string().optional(),
+  isClosed: z.boolean(),
+  openingTime: z.string().optional(),
+  sortOrder: z.number().optional(),
+})
+
+export const healthFacilitySchema = z.object({
+  content: z.object({
+    images: z.array(imageSchema),
+    texts: z.object({
+      descriptions: z.object({
+        short: z.string(),
+        medium: z.string(),
+      }),
+      facilityInformation: z.string().optional(),
+      surroundingInformation: z.string().optional(),
+    }),
+  }),
+  details: z.array(
+    z.object({
+      name: z.string(),
+      type: z.string(),
+      value: z.string().optional(),
+    })
+  ),
+  openingDetails: z.object({
+    manualOpeningHours: z.string().optional(),
+    openingHours: z.object({
+      ordinary: healthFacilitiesOpenHoursSchema,
+      weekends: healthFacilitiesOpenHoursSchema,
+    }),
+    useManualOpeningHours: z.boolean(),
+  }),
+  type: z.string(),
+})

server/routers/hotels/schemas/hotel/include/include.ts

@@ -0,0 +1,37 @@
+import { z } from "zod"
+
+import { citySchema } from "@/server/routers/hotels/schemas/city"
+import { nearbyHotelsSchema } from "@/server/routers/hotels/schemas/hotel/include/nearbyHotels"
+import { restaurantsSchema } from "@/server/routers/hotels/schemas/hotel/include/restaurants"
+import {
+  roomCategoriesSchema,
+  transformRoomCategories,
+} from "@/server/routers/hotels/schemas/hotel/include/roomCategories"
+import { additionalDataSchema, transformAdditionalData } from "../../additionalData"
+
+export const includeSchema = z
+  .discriminatedUnion("type", [
+    additionalDataSchema,
+    citySchema,
+    nearbyHotelsSchema,
+    restaurantsSchema,
+    roomCategoriesSchema,
+  ])
+  .transform((data) => {
+    switch (data.type) {
+      case "additionalData":
+        return transformAdditionalData(data)
+      case "cities":
+      case "hotels":
+      case "restaurants":
+        return {
+          ...data.attributes,
+          id: data.id,
+          type: data.type,
+        }
+      case "roomcategories":
+        return transformRoomCategories(data)
+      default:
+        return null
+    }
+  })

server/routers/hotels/schemas/hotel/include/nearbyHotels.ts

@@ -0,0 +1,41 @@
+import { z } from "zod"
+
+import { attributesSchema } from "@/server/routers/hotels/schemas/hotel"
+
+export const nearbyHotelsSchema = z.object({
+  attributes: z.lazy(() =>
+    z
+      .object({
+        displayWebPage: z
+          .object({
+            healthGym: z.boolean().default(false),
+            meetingRoom: z.boolean().default(false),
+            parking: z.boolean().default(false),
+            specialNeeds: z.boolean().default(false),
+          })
+          .default({
+            healthGym: false,
+            meetingRoom: false,
+            parking: false,
+            specialNeeds: false,
+          }),
+      })
+      .merge(
+        attributesSchema.pick({
+          address: true,
+          cityId: true,
+          cityName: true,
+          detailedFacilities: true,
+          hotelContent: true,
+          isActive: true,
+          isPublished: true,
+          location: true,
+          name: true,
+          operaId: true,
+          ratings: true,
+        })
+      )
+  ),
+  id: z.string(),
+  type: z.literal("hotels"),
+})

server/routers/hotels/schemas/hotel/include/restaurants.ts

@@ -0,0 +1,72 @@
+import { z } from "zod"
+
+import { imageSchema } from "@/server/routers/hotels/schemas/image"
+
+import { CurrencyEnum } from "@/types/enums/currency"
+
+const contentSchema = z.object({
+  images: z.array(imageSchema).default([]),
+  texts: z.object({
+    descriptions: z.object({
+      medium: z.string().default(""),
+      short: z.string().default(""),
+    }),
+  }),
+})
+
+const externalBreakfastSchema = z.object({
+  isAvailable: z.boolean().default(false),
+  localPriceForExternalGuests: z.object({
+    amount: z.number().default(0),
+    currency: z.nativeEnum(CurrencyEnum).default(CurrencyEnum.SEK),
+  }),
+})
+
+const menuItemSchema = z.object({
+  name: z.string(),
+  url: z.string().url(),
+})
+
+const daySchema = z.object({
+  alwaysOpen: z.boolean().default(false),
+  closingTime: z.string().default(""),
+  isClosed: z.boolean().default(false),
+  openingTime: z.string().default(""),
+  sortOrder: z.number().int().default(0),
+})
+
+const openingDetailsSchema = z.object({
+  alternateOpeningHours: z.object({
+    isActive: z.boolean().default(false),
+  }),
+  openingHours: z.object({
+    friday: daySchema,
+    isActive: z.boolean().default(false),
+    monday: daySchema,
+    name: z.string().default(""),
+    saturday: daySchema,
+    sunday: daySchema,
+    thursday: daySchema,
+    tuesday: daySchema,
+    wednesday: daySchema,
+  }),
+})
+
+export const restaurantsSchema = z.object({
+  attributes: z.object({
+    bookTableUrl: z.string().default(""),
+    content: contentSchema,
+    // When using .email().default("") is not sufficent
+    // so .optional also needs to be chained
+    email: z.string().email().optional(),
+    externalBreakfast: externalBreakfastSchema,
+    isPublished: z.boolean().default(false),
+    menus: z.array(menuItemSchema).default([]),
+    name: z.string().default(""),
+    openingDetails: z.array(openingDetailsSchema).default([]),
+    restaurantPage: z.boolean().default(false),
+    specialAlerts: z.array(z.object({})).default([]),
+  }),
+  id: z.string(),
+  type: z.literal("restaurants"),
+})

server/routers/hotels/schemas/hotel/include/roomCategories.ts

@@ -0,0 +1,97 @@
+import { z } from "zod"
+
+import { imageMetaDataSchema, imageSizesSchema } from "../../image"
+
+const minMaxSchema = z.object({
+  max: z.number(),
+  min: z.number(),
+})
+
+const bedTypeSchema = z.object({
+  description: z.string().default(""),
+  type: z.string(),
+  widthRange: minMaxSchema,
+})
+
+const occupancySchema = z.object({
+  adults: z.number(),
+  children: z.number(),
+  total: z.number(),
+})
+
+const roomContentSchema = z.object({
+  images: z.array(
+    z.object({
+      imageSizes: imageSizesSchema,
+      metaData: imageMetaDataSchema,
+    })
+  ),
+  texts: z.object({
+    descriptions: z.object({
+      medium: z.string().optional(),
+      short: z.string().optional(),
+    }),
+  }),
+})
+
+const roomTypesSchema = z.object({
+  code: z.string(),
+  description: z.string(),
+  fixedExtraBed: bedTypeSchema,
+  isLackingCribs: z.boolean(),
+  isLackingExtraBeds: z.boolean(),
+  mainBed: bedTypeSchema,
+  name: z.string(),
+  occupancy: occupancySchema,
+  roomCount: z.number(),
+  roomSize: minMaxSchema,
+})
+
+const roomFacilitiesSchema = z.object({
+  availableInAllRooms: z.boolean(),
+  icon: z.string().optional(),
+  isUniqueSellingPoint: z.boolean(),
+  name: z.string(),
+  sortOrder: z.number(),
+})
+
+export const roomCategoriesSchema = z.object({
+  attributes: z.object({
+    content: roomContentSchema,
+    name: z.string(),
+    occupancy: minMaxSchema,
+    roomFacilities: z.array(roomFacilitiesSchema),
+    roomSize: minMaxSchema,
+    roomTypes: z.array(roomTypesSchema),
+    sortOrder: z.number(),
+  }),
+  id: z.string(),
+  type: z.literal("roomcategories"),
+})
+
+export function transformRoomCategories(
+  data: z.output<typeof roomCategoriesSchema>
+) {
+  return {
+    descriptions: data.attributes.content.texts.descriptions,
+    id: data.id,
+    images: data.attributes.content.images,
+    name: data.attributes.name,
+    occupancy: data.attributes.occupancy,
+    roomFacilities: data.attributes.roomFacilities,
+    roomSize: data.attributes.roomSize,
+    roomTypes: data.attributes.roomTypes,
+    sortOrder: data.attributes.sortOrder,
+    type: data.type,
+    totalOccupancy:
+      data.attributes.occupancy.min === data.attributes.occupancy.max
+        ? {
+          max: data.attributes.occupancy.max,
+          range: `${data.attributes.occupancy.max}`,
+        }
+        : {
+          max: data.attributes.occupancy.max,
+          range: `${data.attributes.occupancy.min}-${data.attributes.occupancy.max}`,
+        },
+  }
+}

server/routers/hotels/schemas/hotel/location.ts

@@ -0,0 +1,7 @@
+import { z } from "zod"
+
+export const locationSchema = z.object({
+  distanceToCentre: z.number(),
+  latitude: z.number(),
+  longitude: z.number(),
+})

server/routers/hotels/schemas/hotel/merchantInformation.ts

@@ -0,0 +1,21 @@
+import { z } from "zod"
+
+import type { PaymentMethodEnum } from "@/constants/booking"
+
+export const merchantInformationSchema = z.object({
+  alternatePaymentOptions: z
+    .record(z.string(), z.boolean())
+    .transform((val) => {
+      return Object.entries(val)
+        .filter(([_, enabled]) => enabled)
+        .map(([key]) => key)
+        .filter((key): key is PaymentMethodEnum => !!key)
+    }),
+  cards: z.record(z.string(), z.boolean()).transform((val) => {
+    return Object.entries(val)
+      .filter(([_, enabled]) => enabled)
+      .map(([key]) => key)
+      .filter((key): key is PaymentMethodEnum => !!key)
+  }),
+  webMerchantId: z.string(),
+})

server/routers/hotels/schemas/hotel/parking.ts

@@ -0,0 +1,41 @@
+import { z } from "zod"
+
+const periodSchema = z.object({
+  amount: z.number().optional(),
+  endTime: z.string().optional(),
+  period: z.string().optional(),
+  startTime: z.string().optional(),
+})
+
+const currencySchema = z
+  .object({
+    currency: z.string().optional(),
+    ordinary: z.array(periodSchema).optional(),
+    range: z
+      .object({
+        min: z.number().optional(),
+        max: z.number().optional(),
+      })
+      .optional(),
+    weekend: z.array(periodSchema).optional(),
+  })
+  .optional()
+
+const pricingSchema = z.object({
+  freeParking: z.boolean(),
+  localCurrency: currencySchema,
+  paymentType: z.string().optional(),
+  requestedCurrency: currencySchema,
+})
+
+export const parkingSchema = z.object({
+  address: z.string().optional(),
+  canMakeReservation: z.boolean(),
+  distanceToHotel: z.number().optional(),
+  externalParkingUrl: z.string().optional(),
+  name: z.string().optional(),
+  numberOfChargingSpaces: z.number().optional(),
+  numberOfParkingSpots: z.number().optional(),
+  pricing: pricingSchema,
+  type: z.string().optional(),
+})

server/routers/hotels/schemas/hotel/poi.ts

@@ -0,0 +1,32 @@
+import { z } from "zod"
+
+import { getPoiGroupByCategoryName } from "../../utils"
+import { locationSchema } from "./location"
+
+export const pointOfInterestSchema = z
+  .object({
+    category: z.object({
+      name: z.string().optional(),
+      group: z.string().optional(),
+    }),
+    distance: z.number().optional(),
+    isHighlighted: z.boolean().optional(),
+    location: locationSchema.optional(),
+    name: z.string().optional(),
+  })
+  .transform((poi) => ({
+    categoryName: poi.category.name,
+    coordinates: {
+      lat: poi.location?.latitude ?? 0,
+      lng: poi.location?.longitude ?? 0,
+    },
+    distance: poi.distance,
+    group: getPoiGroupByCategoryName(poi.category.name),
+    name: poi.name,
+  }))
+
+export const pointOfInterestsSchema = z
+  .array(pointOfInterestSchema)
+  .transform((pois) =>
+    pois.sort((a, b) => (a.distance ?? 0) - (b.distance ?? 0))
+  )

server/routers/hotels/schemas/hotel/rating.ts

@@ -0,0 +1,31 @@
+import { z } from "zod"
+
+const awardSchema = z.object({
+  displayName: z.string(),
+  images: z.object({
+    large: z.string(),
+    medium: z.string(),
+    small: z.string(),
+  }),
+})
+
+const reviewsSchema = z
+  .object({
+    widgetHtmlTagId: z.string(),
+    widgetScriptEmbedUrlIframe: z.string(),
+    widgetScriptEmbedUrlJavaScript: z.string(),
+  })
+  .optional()
+
+export const ratingsSchema = z
+  .object({
+    tripAdvisor: z.object({
+      awards: z.array(awardSchema),
+      numberOfReviews: z.number(),
+      rating: z.number(),
+      ratingImageUrl: z.string(),
+      reviews: reviewsSchema,
+      webUrl: z.string(),
+    }),
+  })
+  .optional()

server/routers/hotels/schemas/hotel/rewardNight.ts

@@ -0,0 +1,10 @@
+import { z } from "zod"
+
+export const rewardNightSchema = z.object({
+  campaign: z.object({
+    end: z.string(),
+    points: z.number(),
+    start: z.string(),
+  }),
+  points: z.number(),
+})

server/routers/hotels/schemas/hotel/socialMedia.ts

@@ -0,0 +1,6 @@
+import { z } from "zod"
+
+export const socialMediaSchema = z.object({
+  facebook: z.string().optional(),
+  instagram: z.string().optional(),
+})

server/routers/hotels/schemas/hotel/specialAlerts.ts

@@ -0,0 +1,35 @@
+import { z } from "zod"
+
+import { dt } from "@/lib/dt"
+
+import { AlertTypeEnum } from "@/types/enums/alert"
+
+const specialAlertSchema = z.object({
+  description: z.string().optional(),
+  displayInBookingFlow: z.boolean(),
+  endDate: z.string().optional(),
+  startDate: z.string().optional(),
+  title: z.string().optional(),
+  type: z.string(),
+})
+
+export const specialAlertsSchema = z
+  .array(specialAlertSchema)
+  .transform((data) => {
+    const now = dt().utc().format("YYYY-MM-DD")
+    const filteredAlerts = data.filter((alert) => {
+      const shouldShowNow =
+        alert.startDate && alert.endDate
+          ? alert.startDate <= now && alert.endDate >= now
+          : true
+      const hasText = alert.description || alert.title
+      return shouldShowNow && hasText
+    })
+    return filteredAlerts.map((alert, idx) => ({
+      heading: alert.title || null,
+      id: `alert-${alert.type}-${idx}`,
+      text: alert.description || null,
+      type: AlertTypeEnum.Info,
+    }))
+  })
+  .default([])

server/routers/hotels/schemas/hotel/specialNeedGroups.ts

@@ -0,0 +1,11 @@
+import { z } from "zod"
+
+const specialNeedSchema = z.object({
+  details: z.string(),
+  name: z.string(),
+})
+
+export const specialNeedGroupSchema = z.object({
+  name: z.string(),
+  specialNeeds: z.array(specialNeedSchema),
+})