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({
    content: discriminatedUnionArray(contentBlock.options)
      .nullable()
      .transform((data) => {
        let spaPage: SpaPage | undefined
        let activitiesCard: ActivitiesCard | undefined
        data?.map((block) => {
          switch (block.typename) {
            case HotelPageEnum.ContentStack.blocks.ActivitiesCard:
              activitiesCard = block
              break
            case HotelPageEnum.ContentStack.blocks.SpaPage:
              spaPage = block
              break
            default:
              break
          }
        })
        return { spaPage, activitiesCard }
      }),
    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(),
      })
    ),
  }),
})

/** 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}`)
  })