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

import { z } from "zod"

import { tempImageVaultAssetSchema } from "../imageVault"
import { systemSchema } from "../system"
import { buttonSchema } from "./utils/buttonLinkSchema"
import { linkConnectionRefsSchema } from "./utils/linkConnection"

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

const cardBlockSchema = z.object({
  __typename: z.literal(CardsGridEnum.cards.Card),
  // JSON - ImageVault Image
  background_image: tempImageVaultAssetSchema,
  body_text: z.string().optional().default(""),
  has_primary_button: z.boolean().default(false),
  has_secondary_button: z.boolean().default(false),
  has_sidepeek_button: z.boolean().optional().default(false),
  heading: z.string().optional().default(""),
  is_content_card: z.boolean().optional().default(false),
  primary_button: buttonSchema,
  scripted_top_title: z.string().optional(),
  secondary_button: buttonSchema,
  sidepeek_button: z
    .object({
      call_to_action_text: z.string().optional(),
    })
    .optional(),
  system: systemSchema,
  title: z.string().optional(),
})

const loyaltyCardBlockSchema = z.object({
  __typename: z.literal(CardsGridEnum.cards.LoyaltyCard),
  body_text: z.string().optional(),
  heading: z.string().optional().default(""),
  // JSON - ImageVault Image
  image: tempImageVaultAssetSchema,
  link: buttonSchema,
  system: systemSchema,
  title: z.string().optional(),
})

export const cardsGridSchema = z.object({
  typename: z
    .literal(BlocksEnums.block.CardsGrid)
    .optional()
    .default(BlocksEnums.block.CardsGrid),
  cards_grid: z
    .object({
      cardConnection: z.object({
        edges: z.array(
          z.object({
            node: z.discriminatedUnion("__typename", [
              cardBlockSchema,
              loyaltyCardBlockSchema,
            ]),
          })
        ),
      }),
      layout: z.enum(["twoColumnGrid", "threeColumnGrid", "twoPlusOne"]),
      preamble: z.string().optional().default(""),
      theme: z.enum(["one", "two", "three"]).nullable(),
      title: z.string().optional().default(""),
    })
    .transform((data) => {
      return {
        layout: data.layout,
        preamble: data.preamble,
        theme: data.theme,
        title: data.title,
        cards: data.cardConnection.edges.map((card) => {
          if (card.node.__typename === CardsGridEnum.cards.Card) {
            return {
              __typename: card.node.__typename,
              backgroundImage: card.node.background_image,
              body_text: card.node.body_text,
              heading: card.node.heading,
              isContentCard: card.node.is_content_card,
              primaryButton: card.node.has_primary_button
                ? card.node.primary_button
                : undefined,
              scripted_top_title: card.node.scripted_top_title,
              secondaryButton: card.node.has_secondary_button
                ? card.node.secondary_button
                : undefined,
              sidePeekButton:
                card.node.has_sidepeek_button &&
                card.node.sidepeek_button?.call_to_action_text
                  ? {
                      title: card.node.sidepeek_button.call_to_action_text,
                    }
                  : undefined,
              system: card.node.system,
              title: card.node.title,
            }
          } else {
            return {
              __typename: card.node.__typename,
              body_text: card.node.body_text,
              heading: card.node.heading,
              image: card.node.image,
              link: card.node.link,
              system: card.node.system,
              title: card.node.title,
            }
          }
        }),
      }
    }),
})

const cardBlockRefsSchema = z.object({
  __typename: z.literal(CardsGridEnum.cards.Card),
  primary_button: linkConnectionRefsSchema,
  secondary_button: linkConnectionRefsSchema,
  system: systemSchema,
})

const loyaltyCardBlockRefsSchema = z.object({
  __typename: z.literal(CardsGridEnum.cards.LoyaltyCard),
  link: linkConnectionRefsSchema,
  system: systemSchema,
})

export const cardGridRefsSchema = z.object({
  cards_grid: z
    .object({
      cardConnection: z.object({
        edges: z.array(
          z.object({
            node: z.discriminatedUnion("__typename", [
              cardBlockRefsSchema,
              loyaltyCardBlockRefsSchema,
            ]),
          })
        ),
      }),
    })
    .transform((data) => {
      return data.cardConnection.edges
        .map(({ node }) => {
          if (node.__typename === CardsGridEnum.cards.Card) {
            const cards = [node.system]
            if (node.primary_button) {
              cards.push(node.primary_button)
            }
            if (node.secondary_button) {
              cards.push(node.secondary_button)
            }
            return cards
          } else {
            const loyaltyCards = [node.system]
            if (node.link) {
              loyaltyCards.push(node.link)
            }
            return loyaltyCards
          }
        })
        .flat()
    }),
})