web/packages/trpc/lib/routers/contentstack/hotelPage/output.ts

import { z } from "zod"

import { removeMultipleSlashes } from "@scandic-hotels/common/utils/url"
import { nullableStringValidator } from "@scandic-hotels/common/utils/zod/stringValidator"

import { HotelPageEnum } from "../../../types/hotelPageEnum"
import { discriminatedUnionArray } from "../../../utils/discriminatedUnion"
import { activitiesCardSchema } from "../schemas/blocks/activitiesCard"
import { hotelFaqSchema } from "../schemas/blocks/hotelFaq"
import { spaPageSchema } from "../schemas/blocks/spaPage"
import { systemSchema } from "../schemas/system"

import type { ActivitiesCard, SpaPage } from "../../../types/hotelPage"

const contentBlockActivities = z
  .object({
    __typename: z.literal(HotelPageEnum.ContentStack.blocks.ActivitiesCard),
  })
  .merge(activitiesCardSchema)

const contentBlockSpaPage = z
  .object({
    __typename: z.literal(HotelPageEnum.ContentStack.blocks.SpaPage),
  })
  .merge(spaPageSchema)

export const contentBlock = z.discriminatedUnion("__typename", [
  contentBlockActivities,
  contentBlockSpaPage,
])

export const hotelPageSchema = z.object({
  hotel_page: z
    .object({
      hotel_navigation: z
        .object({
          overview: z.string().nullish(),
          rooms: z.string().nullish(),
          restaurant_bar: z.string().nullish(),
          conferences_meetings: z.string().nullish(),
          health_wellness: z.string().nullish(),
          activities: z.string().nullish(),
          offers: z.string().nullish(),
          faq: z.string().nullish(),
        })
        .nullish(),
      content: discriminatedUnionArray(contentBlock.options)
        .nullable()
        .transform((data) => {
          let spaPage: SpaPage | undefined
          let activitiesCards: ActivitiesCard[] = []

          data?.map((block) => {
            switch (block.typename) {
              case HotelPageEnum.ContentStack.blocks.ActivitiesCard:
                activitiesCards.push(block)
                break
              case HotelPageEnum.ContentStack.blocks.SpaPage:
                spaPage = block
                break
              default:
                break
            }
          })
          return { spaPage, activitiesCards }
        }),
      faq: hotelFaqSchema.nullable(),
      hotel_page_id: z.string().transform((id) => id.trim()),
      title: z.string(),
      url: z.string(),
      campaigns: z
        .object({
          heading: nullableStringValidator,
          preamble: nullableStringValidator,
          prioritized_campaignsConnection: z.object({
            edges: z.array(
              z.object({
                node: z.object({
                  system: z.object({
                    uid: z.string(),
                  }),
                }),
              })
            ),
          }),
        })
        .nullish()
        .transform((data) => {
          const prioritizedCampaigns =
            data?.prioritized_campaignsConnection.edges.map(
              (edge) => edge.node.system.uid
            ) || []
          return {
            heading: data?.heading,
            preamble: data?.preamble,
            prioritizedCampaigns,
          }
        }),
      system: systemSchema.merge(
        z.object({
          created_at: z.string(),
          updated_at: z.string(),
        })
      ),
    })
    .transform(({ hotel_navigation, ...rest }) => ({
      sectionHeadings: hotel_navigation,
      ...rest,
    })),
})

export const hotelPageUrlsSchema = z
  .object({
    all_hotel_page: z.object({
      items: z.array(
        z
          .object({
            url: z.string(),
            hotel_page_id: z.string().transform((id) => id.trim()),
            system: systemSchema,
          })
          .transform((data) => {
            return {
              url: removeMultipleSlashes(`/${data.system.locale}/${data.url}`),
              hotelId: data.hotel_page_id,
            }
          })
      ),
    }),
  })
  .transform(({ all_hotel_page }) => all_hotel_page.items)

export const batchedHotelPageUrlsSchema = z
  .array(
    z.object({
      data: hotelPageUrlsSchema,
    })
  )
  .transform((allItems) => {
    return allItems.flatMap((item) => item.data)
  })

export const hotelPageCountSchema = z
  .object({
    all_hotel_page: z.object({
      total: z.number(),
    }),
  })
  .transform(({ all_hotel_page }) => all_hotel_page.total)