web/server/routers/contentstack/hotelPage/output.ts

import { z } from "zod"

import { discriminatedUnionArray } from "@/lib/discriminatedUnion"

import { removeMultipleSlashes } from "@/utils/url"

import {
  activitiesCardRefSchema,
  activitiesCardSchema,
} from "../schemas/blocks/activitiesCard"
import { hotelFaqRefsSchema, hotelFaqSchema } from "../schemas/blocks/hotelFaq"
import { spaPageRefSchema, spaPageSchema } from "../schemas/blocks/spaPage"
import { systemSchema } from "../schemas/system"

import { HotelPageEnum } from "@/types/enums/hotelPage"
import type {
  ActivitiesCard,
  SpaPage,
} from "@/types/trpc/routers/contentstack/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().optional(),
          rooms: z.string().optional(),
          restaurant_bar: z.string().optional(),
          conferences_meetings: z.string().optional(),
          health_wellness: z.string().optional(),
          activities: z.string().optional(),
          offers: z.string().optional(),
          faq: z.string().optional(),
        })
        .nullable(),
      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,
      hotel_page_id: z.string(),
      title: z.string(),
      url: z.string(),
      system: systemSchema.merge(
        z.object({
          created_at: z.string(),
          updated_at: z.string(),
        })
      ),
    })
    .transform(({ hotel_navigation, ...rest }) => ({
      tabValues: hotel_navigation,
      ...rest,
    })),
})

/** REFS */
const hotelPageActivitiesCardRefs = z
  .object({
    __typename: z.literal(HotelPageEnum.ContentStack.blocks.ActivitiesCard),
  })
  .merge(activitiesCardRefSchema)

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

const hotelPageBlockRefsItem = z.discriminatedUnion("__typename", [
  hotelPageActivitiesCardRefs,
  hotelPageSpaPageRefs,
])

export const hotelPageRefsSchema = z.object({
  hotel_page: z.object({
    content: discriminatedUnionArray(hotelPageBlockRefsItem.options).nullable(),
    faq: hotelFaqRefsSchema.nullable(),
    system: systemSchema,
  }),
  trackingProps: z.object({
    url: z.string(),
  }),
})

export const hotelPageUrlSchema = z
  .object({
    all_hotel_page: z.object({
      items: z
        .array(
          z.object({
            url: z.string(),
            system: systemSchema,
          })
        )
        .max(1),
    }),
  })
  .transform((data) => {
    const page = data.all_hotel_page.items[0]
    if (!page) {
      return null
    }

    const lang = page.system.locale
    return removeMultipleSlashes(`/${lang}/${page.url}`)
  })