feat: adjust select rate ui to latest design

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

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

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

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

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

@@ -1,40 +1,26 @@
 import { z } from "zod"
 
+import { nullableStringValidator } from "@/utils/zod/stringValidator"
+
 import { imageSchema } from "../image"
+import { restaurantsOverviewPageSchema } from "./include/additionalData/restaurantsOverviewPage"
+
+const descriptionSchema = z
+  .object({
+    medium: nullableStringValidator,
+    short: nullableStringValidator,
+  })
+  .nullish()
+
+const textsSchema = z.object({
+  descriptions: descriptionSchema,
+  facilityInformation: nullableStringValidator,
+  meetingDescription: descriptionSchema,
+  surroundingInformation: nullableStringValidator,
+})
 
 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(),
-  }),
+  images: imageSchema,
+  restaurantsOverviewPage: restaurantsOverviewPageSchema,
+  texts: textsSchema,
 })

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

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

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

@@ -1,50 +1,19 @@
 import { z } from "zod"
 
+import { nullableStringValidator } from "@/utils/zod/stringValidator"
+
+export const checkinSchema = z.object({
+  checkInTime: nullableStringValidator,
+  checkOutTime: nullableStringValidator,
+  onlineCheckout: z.boolean(),
+  onlineCheckOutAvailableFrom: nullableStringValidator,
+})
+
 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,
+  svanenEcoLabelCertificateNumber: nullableStringValidator,
 })
 
 const interiorSchema = z.object({
@@ -53,7 +22,7 @@ const interiorSchema = z.object({
   numberOfFloors: z.number(),
   numberOfRooms: z.object({
     connected: z.number(),
-    forAllergics: z.number().optional(),
+    forAllergics: z.number(),
     forDisabled: z.number(),
     nonSmoking: z.number(),
     pet: z.number(),
@@ -64,17 +33,15 @@ const interiorSchema = z.object({
 
 const receptionHoursSchema = z.object({
   alwaysOpen: z.boolean(),
+  closingTime: nullableStringValidator,
   isClosed: z.boolean(),
-  openingTime: z.string().optional(),
-  closingTime: z.string().optional(),
+  openingTime: nullableStringValidator,
 })
 
 export const hotelFactsSchema = z.object({
   checkin: checkinSchema,
   ecoLabels: ecoLabelsSchema,
-  hotelFacilityDetail: hotelFacilityDetailsSchema.default({}),
-  hotelInformation: hotelInformationsSchema.default({}),
   interior: interiorSchema,
   receptionHours: receptionHoursSchema,
-  yearBuilt: z.string(),
+  yearBuilt: nullableStringValidator,
 })

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

@@ -1,8 +0,0 @@
-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

@@ -1,41 +1,61 @@
 import { z } from "zod"
 
+import { nullableArrayObjectValidator } from "@/utils/zod/arrayValidator"
+import { nullableNumberValidator } from "@/utils/zod/numberValidator"
+import { nullableStringValidator } from "@/utils/zod/stringValidator"
+
 import { imageSchema } from "../image"
 
 const healthFacilitiesOpenHoursSchema = z.object({
   alwaysOpen: z.boolean(),
-  closingTime: z.string().optional(),
+  closingTime: nullableStringValidator,
   isClosed: z.boolean(),
-  openingTime: z.string().optional(),
-  sortOrder: z.number().optional(),
+  openingTime: nullableStringValidator,
+  sortOrder: nullableNumberValidator,
+})
+
+const descriptionSchema = z
+  .object({
+    medium: nullableStringValidator,
+    short: nullableStringValidator,
+  })
+  .nullish()
+
+const detailsSchema = z.object({
+  name: nullableStringValidator,
+  type: nullableStringValidator,
+  value: nullableStringValidator,
+})
+
+const textsSchema = z.object({
+  descriptions: descriptionSchema,
+  facilityInformation: nullableStringValidator,
+  meetingDescription: descriptionSchema,
+  surroundingInformation: nullableStringValidator,
 })
 
 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(),
-    }),
+    images: z
+      .array(imageSchema)
+      .nullish()
+      .transform((arr) => (arr ? arr.filter(Boolean) : [])),
+    texts: textsSchema,
   }),
-  details: z.array(
-    z.object({
-      name: z.string(),
-      type: z.string(),
-      value: z.string().optional(),
-    })
-  ),
+  details: nullableArrayObjectValidator(detailsSchema),
   openingDetails: z.object({
-    manualOpeningHours: z.string().optional(),
+    manualOpeningHours: nullableStringValidator,
     openingHours: z.object({
       ordinary: healthFacilitiesOpenHoursSchema,
       weekends: healthFacilitiesOpenHoursSchema,
     }),
-    useManualOpeningHours: z.boolean(),
+    useManualOpeningHours: z
+      .boolean()
+      .nullish()
+      .transform((b) => !!b),
   }),
-  type: z.string(),
+  type: nullableStringValidator,
 })
+
+export const healthFacilitiesSchema =
+  nullableArrayObjectValidator(healthFacilitySchema)

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

@@ -0,0 +1,48 @@
+import { z } from "zod"
+
+import { nullableArrayObjectValidator } from "@/utils/zod/arrayValidator"
+import { nullableStringValidator } from "@/utils/zod/stringValidator"
+
+import { displayWebPageSchema } from "./additionalData/displayWebPage"
+import { facilitySchema } from "./additionalData/facility"
+import { gallerySchema } from "./additionalData/gallery"
+import { restaurantsOverviewPageSchema } from "./additionalData/restaurantsOverviewPage"
+import { specialNeedGroupSchema } from "./additionalData/specialNeedGroups"
+
+export const extraPageSchema = z.object({
+  elevatorPitch: nullableStringValidator,
+  mainBody: nullableStringValidator,
+  nameInUrl: nullableStringValidator,
+})
+
+export const additionalDataSchema = z.object({
+  attributes: z.object({
+    accessibility: facilitySchema.nullish(),
+    conferencesAndMeetings: facilitySchema.nullish(),
+    displayWebPage: displayWebPageSchema,
+    gallery: gallerySchema.nullish(),
+    healthAndFitness: extraPageSchema,
+    healthAndWellness: facilitySchema.nullish(),
+    hotelParking: extraPageSchema,
+    hotelRoomElevatorPitchText: nullableStringValidator,
+    hotelSpecialNeeds: extraPageSchema,
+    id: nullableStringValidator,
+    meetingRooms: extraPageSchema,
+    name: nullableStringValidator,
+    parkingImages: facilitySchema.nullish(),
+    restaurantImages: facilitySchema.nullish(),
+    restaurantsOverviewPage: restaurantsOverviewPageSchema,
+    specialNeedGroups: nullableArrayObjectValidator(specialNeedGroupSchema),
+  }),
+  type: z.literal("additionalData"),
+})
+
+export function transformAdditionalData(
+  data: z.output<typeof additionalDataSchema>
+) {
+  return {
+    ...data.attributes,
+    id: data.attributes.id,
+    type: data.type,
+  }
+}

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

@@ -0,0 +1,8 @@
+import { z } from "zod"
+
+export const displayWebPageSchema = z.object({
+  healthGym: z.boolean(),
+  meetingRoom: z.boolean(),
+  parking: z.boolean(),
+  specialNeeds: z.boolean(),
+})

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

@@ -0,0 +1,13 @@
+import { z } from "zod"
+
+import { imageSchema } from "@/server/routers/hotels/schemas/image"
+
+import { nullableStringValidator } from "@/utils/zod/stringValidator"
+
+export const facilitySchema = z.object({
+  headingText: nullableStringValidator,
+  heroImages: z
+    .array(imageSchema)
+    .nullish()
+    .transform((arr) => (arr ? arr.filter(Boolean) : [])),
+})

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

@@ -0,0 +1,13 @@
+import { z } from "zod"
+
+import { imageSchema } from "@/server/routers/hotels/schemas/image"
+
+const imagesSchema = z
+  .array(imageSchema)
+  .nullish()
+  .transform((arr) => (arr ? arr.filter(Boolean) : []))
+
+export const gallerySchema = z.object({
+  heroImages: imagesSchema,
+  smallerImages: imagesSchema,
+})

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

@@ -0,0 +1,10 @@
+import { z } from "zod"
+
+import { nullableStringValidator } from "@/utils/zod/stringValidator"
+
+export const restaurantsOverviewPageSchema = z.object({
+  restaurantsContentDescriptionMedium: nullableStringValidator,
+  restaurantsContentDescriptionShort: nullableStringValidator,
+  restaurantsOverviewPageLink: nullableStringValidator,
+  restaurantsOverviewPageLinkText: nullableStringValidator,
+})

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

@@ -0,0 +1,14 @@
+import { z } from "zod"
+
+import { nullableArrayObjectValidator } from "@/utils/zod/arrayValidator"
+import { nullableStringValidator } from "@/utils/zod/stringValidator"
+
+const specialNeedSchema = z.object({
+  details: nullableStringValidator,
+  name: nullableStringValidator,
+})
+
+export const specialNeedGroupSchema = z.object({
+  name: nullableStringValidator,
+  specialNeeds: nullableArrayObjectValidator(specialNeedSchema),
+})

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

@@ -8,10 +8,7 @@ import {
   transformRoomCategories,
 } from "@/server/routers/hotels/schemas/hotel/include/roomCategories"
 
-import {
-  additionalDataSchema,
-  transformAdditionalData,
-} from "../../additionalData"
+import { additionalDataSchema, transformAdditionalData } from "./additionalData"
 
 export const includeSchema = z
   .discriminatedUnion("type", [

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

@@ -1,6 +1,9 @@
 import { z } from "zod"
 
-import { imageMetaDataSchema, imageSizesSchema } from "../../image"
+import { imageSchema } from "@/server/routers/hotels/schemas/image"
+
+import { nullableArrayObjectValidator } from "@/utils/zod/arrayValidator"
+import { nullableStringValidator } from "@/utils/zod/stringValidator"
 
 const minMaxSchema = z.object({
   max: z.number(),
@@ -8,8 +11,8 @@ const minMaxSchema = z.object({
 })
 
 const bedTypeSchema = z.object({
-  description: z.string().default(""),
-  type: z.string(),
+  description: nullableStringValidator,
+  type: nullableStringValidator,
   widthRange: minMaxSchema,
 })
 
@@ -20,28 +23,26 @@ const occupancySchema = z.object({
 })
 
 const roomContentSchema = z.object({
-  images: z.array(
-    z.object({
-      imageSizes: imageSizesSchema,
-      metaData: imageMetaDataSchema,
-    })
-  ),
+  images: z
+    .array(imageSchema)
+    .nullish()
+    .transform((arr) => (arr ? arr.filter(Boolean) : [])),
   texts: z.object({
     descriptions: z.object({
-      medium: z.string().optional(),
-      short: z.string().optional(),
+      medium: nullableStringValidator,
+      short: nullableStringValidator,
     }),
   }),
 })
 
 const roomTypesSchema = z.object({
-  code: z.string(),
-  description: z.string(),
+  code: nullableStringValidator,
+  description: nullableStringValidator,
   fixedExtraBed: bedTypeSchema,
   isLackingCribs: z.boolean(),
   isLackingExtraBeds: z.boolean(),
   mainBed: bedTypeSchema,
-  name: z.string(),
+  name: nullableStringValidator,
   occupancy: occupancySchema,
   roomCount: z.number(),
   roomSize: minMaxSchema,
@@ -58,11 +59,11 @@ const roomFacilitiesSchema = z.object({
 export const roomCategoriesSchema = z.object({
   attributes: z.object({
     content: roomContentSchema,
-    name: z.string(),
+    name: nullableStringValidator,
     occupancy: minMaxSchema,
-    roomFacilities: z.array(roomFacilitiesSchema),
+    roomFacilities: nullableArrayObjectValidator(roomFacilitiesSchema),
     roomSize: minMaxSchema,
-    roomTypes: z.array(roomTypesSchema),
+    roomTypes: nullableArrayObjectValidator(roomTypesSchema),
     sortOrder: z.number(),
   }),
   id: z.string(),

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

@@ -1,5 +1,7 @@
 import { z } from "zod"
 
+import { nullableStringValidator } from "@/utils/zod/stringValidator"
+
 import type { PaymentMethodEnum } from "@/constants/booking"
 
 export const merchantInformationSchema = z.object({
@@ -17,5 +19,5 @@ export const merchantInformationSchema = z.object({
       .map(([key]) => key)
       .filter((key): key is PaymentMethodEnum => !!key)
   }),
-  webMerchantId: z.string().optional(),
+  webMerchantId: nullableStringValidator,
 })

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

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

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

@@ -1,24 +1,25 @@
 import { z } from "zod"
 
+import { nullableNumberValidator } from "@/utils/zod/numberValidator"
+import { nullableStringValidator } from "@/utils/zod/stringValidator"
+
 import { getPoiGroupByCategoryName } from "../../utils"
 import { locationSchema } from "./location"
 
 export const pointOfInterestSchema = z
   .object({
     category: z.object({
-      name: z.string().optional(),
-      group: z.string().optional(),
+      name: nullableStringValidator,
     }),
-    distance: z.number().optional(),
-    isHighlighted: z.boolean().optional(),
-    location: locationSchema.optional(),
-    name: z.string().optional(),
+    distance: nullableNumberValidator,
+    location: locationSchema,
+    name: nullableStringValidator,
   })
   .transform((poi) => ({
     categoryName: poi.category.name,
     coordinates: {
-      lat: poi.location?.latitude ?? 0,
-      lng: poi.location?.longitude ?? 0,
+      lat: poi.location.latitude,
+      lng: poi.location.longitude,
     },
     distance: poi.distance,
     group: getPoiGroupByCategoryName(poi.category.name),
@@ -27,6 +28,8 @@ export const pointOfInterestSchema = z
 
 export const pointOfInterestsSchema = z
   .array(pointOfInterestSchema)
+  .nullish()
+  .transform((arr) => (arr ? arr.filter(Boolean) : []))
   .transform((pois) =>
     pois.sort((a, b) => (a.distance ?? 0) - (b.distance ?? 0))
   )

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

@@ -1,31 +1,57 @@
 import { z } from "zod"
 
+import { nullableArrayObjectValidator } from "@/utils/zod/arrayValidator"
+import {
+  nullableStringUrlValidator,
+  nullableStringValidator,
+} from "@/utils/zod/stringValidator"
+
 const awardSchema = z.object({
-  displayName: z.string(),
-  images: z.object({
-    large: z.string(),
-    medium: z.string(),
-    small: z.string(),
-  }),
+  displayName: nullableStringValidator,
+  images: z
+    .object({
+      large: nullableStringValidator,
+      medium: nullableStringValidator,
+      small: nullableStringValidator,
+    })
+    .nullish()
+    .transform((obj) =>
+      obj
+        ? obj
+        : {
+            small: "",
+            medium: "",
+            large: "",
+          }
+    ),
 })
 
 const reviewsSchema = z
   .object({
-    widgetHtmlTagId: z.string(),
-    widgetScriptEmbedUrlIframe: z.string(),
-    widgetScriptEmbedUrlJavaScript: z.string(),
+    widgetHtmlTagId: nullableStringValidator,
+    widgetScriptEmbedUrlIframe: nullableStringValidator,
+    widgetScriptEmbedUrlJavaScript: nullableStringValidator,
   })
-  .optional()
+  .nullish()
+  .transform((obj) =>
+    obj
+      ? obj
+      : {
+          widgetHtmlTagId: "",
+          widgetScriptEmbedUrlIframe: "",
+          widgetScriptEmbedUrlJavaScript: "",
+        }
+  )
 
 export const ratingsSchema = z
   .object({
     tripAdvisor: z.object({
-      awards: z.array(awardSchema),
+      awards: nullableArrayObjectValidator(awardSchema),
       numberOfReviews: z.number(),
       rating: z.number(),
-      ratingImageUrl: z.string(),
+      ratingImageUrl: nullableStringUrlValidator,
       reviews: reviewsSchema,
-      webUrl: z.string(),
+      webUrl: nullableStringUrlValidator,
     }),
   })
   .optional()

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

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

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

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

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

@@ -17,6 +17,8 @@ const specialAlertSchema = z.object({
 
 export const specialAlertsSchema = z
   .array(specialAlertSchema)
+  .nullish()
+  .transform((arr) => (arr ? arr.filter(Boolean) : []))
   .transform((data) => {
     const now = dt().utc().format("YYYY-MM-DD")
     const filteredAlerts = data.filter((alert) => {
@@ -35,4 +37,3 @@ export const specialAlertsSchema = z
       displayInBookingFlow: alert.displayInBookingFlow,
     }))
   })
-  .default([])

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

@@ -1,11 +0,0 @@
-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),
-})