web/server/routers/contentstack/schemas/blocks/accordion.ts

import { z } from "zod"

import * as pageLinks from "@/server/routers/contentstack/schemas/pageLinks"

import { BlocksEnums } from "@/types/enums/blocks"

export const faqSchema = z.array(
  z.object({
    answer: z.object({
      json: z.any(),
      embedded_itemsConnection: z.object({
        edges: z.array(
          z.object({
            node: z
              .discriminatedUnion("__typename", [
                pageLinks.contentPageSchema,
                pageLinks.hotelPageSchema,
                pageLinks.loyaltyPageSchema,
              ])
              .transform((data) => {
                const link = pageLinks.transform(data)
                if (link) {
                  return link
                }
                return data
              }),
          })
        ),
      }),
    }),
    question: z.string(),
  })
)

export type FAQtype = z.infer<typeof accordionSchema> // MOVE

enum AccordionEnum {
  ContentPageBlocksAccordionBlockFaqGlobalFaq = "ContentPageBlocksAccordionBlockFaqGlobalFaq",
  ContentPageBlocksAccordionBlockFaqSpecificFaq = "ContentPageBlocksAccordionBlockFaqSpecificFaq",
}

export const accordionSchema = z.object({
  typename: z
    .literal(BlocksEnums.block.Accordion)
    .optional()
    .default(BlocksEnums.block.Accordion),
  title: z.string().optional().default(""),
  accordion: z
    .object({
      faq: z.array(
        z.object({
          __typename: z.enum([
            AccordionEnum.ContentPageBlocksAccordionBlockFaqGlobalFaq,
            AccordionEnum.ContentPageBlocksAccordionBlockFaqSpecificFaq,
          ]),
          global_faq: z
            .object({
              global_faqConnection: z.object({
                edges: z.array(
                  z.object({
                    node: z.object({
                      questions: faqSchema,
                    }),
                  })
                ),
              }),
            })
            .optional(),
          specific_faq: z
            .object({
              questions: faqSchema,
            })
            .optional(),
        })
      ),
    })
    .transform((data) => {
      return {
        ...data,
        faq: data.faq.flatMap((faq) => {
          switch (faq.__typename) {
            case AccordionEnum.ContentPageBlocksAccordionBlockFaqGlobalFaq:
              return (
                faq.global_faq?.global_faqConnection.edges.flatMap(
                  ({ node: faqConnection }) => {
                    return faqConnection.questions
                  }
                ) || []
              )
            case AccordionEnum.ContentPageBlocksAccordionBlockFaqSpecificFaq:
              return faq.specific_faq?.questions || []
          }
        }),
      }
    }),

  /*hotel_specific_faq: z.object({
    questions: faqSchema,
  }),*/
})

const actualRefs = z.discriminatedUnion("__typename", [
  pageLinks.accountPageRefSchema,
  pageLinks.contentPageRefSchema,
  pageLinks.hotelPageRefSchema,
  pageLinks.loyaltyPageRefSchema,
])

export const accordionRefsSchema = z.object({
  accordion: z
    .object({
      faq: z.array(
        z.object({
          __typename: z.enum([
            AccordionEnum.ContentPageBlocksAccordionBlockFaqGlobalFaq,
            AccordionEnum.ContentPageBlocksAccordionBlockFaqSpecificFaq,
          ]),
          global_faq: z
            .object({
              global_faqConnection: z.object({
                edges: z.array(
                  z.object({
                    node: z.object({
                      questions: z.array(
                        z.object({
                          answer: z.object({
                            embedded_itemsConnection: z.object({
                              edges: z.array(
                                z.object({
                                  node: actualRefs,
                                })
                              ),
                            }),
                          }),
                        })
                      ),
                    }),
                  })
                ),
              }),
            })
            .optional(),
          specific_faq: z
            .object({
              questions: z.array(
                z.object({
                  answer: z.object({
                    embedded_itemsConnection: z.object({
                      edges: z.array(
                        z.object({
                          node: actualRefs,
                        })
                      ),
                    }),
                  }),
                })
              ),
            })
            .optional(),
        })
      ),
    })
    .transform((data) => {
      return data.faq.flatMap((faq) => {
        switch (faq.__typename) {
          case AccordionEnum.ContentPageBlocksAccordionBlockFaqGlobalFaq:
            return (
              faq.global_faq?.global_faqConnection.edges.flatMap(
                ({ node: faqConnection }) => {
                  return faqConnection.questions.flatMap((question) =>
                    question.answer.embedded_itemsConnection.edges.flatMap(
                      ({ node }) => node.system
                    )
                  )
                }
              ) || []
            )
          case AccordionEnum.ContentPageBlocksAccordionBlockFaqSpecificFaq:
            return (
              faq.specific_faq?.questions.flatMap((question) =>
                question.answer.embedded_itemsConnection.edges.flatMap(
                  ({ node }) => node.system
                )
              ) || []
            )
        }
      })
    }),
})