835 lines
20 KiB
TypeScript
835 lines
20 KiB
TypeScript
import { z, ZodError, ZodIssueCode } from "zod"
|
|
|
|
import {
|
|
AlertTypeEnum,
|
|
AlertVisibleOnEnum,
|
|
} from "@scandic-hotels/common/constants/alert"
|
|
import { Lang } from "@scandic-hotels/common/constants/language"
|
|
import { logger } from "@scandic-hotels/common/logger"
|
|
import { removeMultipleSlashes } from "@scandic-hotels/common/utils/url"
|
|
import { nullableStringValidator } from "@scandic-hotels/common/utils/zod/stringValidator"
|
|
|
|
import { discriminatedUnion } from "../../../utils/discriminatedUnion"
|
|
import {
|
|
infoCardBlockRefsSchema,
|
|
infoCardBlockSchema,
|
|
transformCardBlockRefs,
|
|
transformInfoCardBlock,
|
|
} from "../schemas/blocks/cardsGrid"
|
|
import { linkConnectionRefsSchema } from "../schemas/blocks/utils/linkConnection"
|
|
import {
|
|
linkRefsUnionSchema,
|
|
linkUnionSchema,
|
|
rawLinkUnionSchema,
|
|
transformPageLink,
|
|
transformPageLinkRef,
|
|
} from "../schemas/pageLinks"
|
|
import { systemSchema } from "../schemas/system"
|
|
|
|
// Help me write this zod schema based on the type ContactConfig
|
|
export const validateContactConfigSchema = z.object({
|
|
all_contact_config: z.object({
|
|
items: z.array(
|
|
z.object({
|
|
email: z.object({
|
|
name: z.string().nullable(),
|
|
address: z.string().nullable(),
|
|
}),
|
|
email_loyalty: z.object({
|
|
name: z.string().nullable(),
|
|
address: z.string().nullable(),
|
|
}),
|
|
mailing_address: z.object({
|
|
zip: z.string().nullable(),
|
|
street: z.string().nullable(),
|
|
name: z.string().nullable(),
|
|
city: z.string().nullable(),
|
|
country: z.string().nullable(),
|
|
}),
|
|
phone: z.object({
|
|
number: z.string().nullable(),
|
|
name: z.string().nullable(),
|
|
footnote: z.string().nullable(),
|
|
}),
|
|
phone_loyalty: z.object({
|
|
number: z.string().nullable(),
|
|
name: z.string().nullable(),
|
|
footnote: z.string().nullable(),
|
|
}),
|
|
visiting_address: z.object({
|
|
zip: z.string().nullable(),
|
|
country: z.string().nullable(),
|
|
city: z.string().nullable(),
|
|
street: z.string().nullable(),
|
|
}),
|
|
})
|
|
),
|
|
}),
|
|
})
|
|
|
|
export enum ContactFieldGroupsEnum {
|
|
email = "email",
|
|
email_loyalty = "email_loyalty",
|
|
mailing_address = "mailing_address",
|
|
phone = "phone",
|
|
phone_loyalty = "phone_loyalty",
|
|
visiting_address = "visiting_address",
|
|
}
|
|
|
|
export type ContactFieldGroups = keyof typeof ContactFieldGroupsEnum
|
|
|
|
export type ContactConfigData = z.infer<typeof validateContactConfigSchema>
|
|
|
|
export type ContactConfig = ContactConfigData["all_contact_config"]["items"][0]
|
|
|
|
export type ContactFields = {
|
|
display_text: string | null
|
|
contact_field: string
|
|
footnote?: string | null
|
|
}
|
|
|
|
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
|
const validateNavigationItem = z.object({
|
|
links: z.array(z.object({ href: z.string(), title: z.string() })),
|
|
title: z.string(),
|
|
})
|
|
|
|
export type NavigationItem = z.infer<typeof validateNavigationItem>
|
|
|
|
const validateExternalLink = z
|
|
.object({
|
|
href: z.string(),
|
|
title: z.string(),
|
|
})
|
|
.optional()
|
|
|
|
const validateInternalLink = z
|
|
.object({
|
|
edges: z
|
|
.array(
|
|
z.object({
|
|
node: z.object({
|
|
system: z.object({
|
|
uid: z.string(),
|
|
locale: z.nativeEnum(Lang),
|
|
}),
|
|
url: z.string(),
|
|
title: z.string(),
|
|
web: z
|
|
.object({
|
|
original_url: z.string(),
|
|
})
|
|
.optional(),
|
|
}),
|
|
})
|
|
)
|
|
.max(1),
|
|
})
|
|
.transform((data) => {
|
|
const node = data.edges[0]?.node
|
|
if (!node) {
|
|
return null
|
|
}
|
|
const url = node.url
|
|
const originalUrl = node.web?.original_url
|
|
const lang = node.system.locale
|
|
|
|
return {
|
|
url: originalUrl || removeMultipleSlashes(`/${lang}/${url}`),
|
|
title: node.title,
|
|
}
|
|
})
|
|
.optional()
|
|
|
|
export const validateLinkItem = z
|
|
.object({
|
|
title: z.string(),
|
|
open_in_new_tab: z.boolean(),
|
|
link: validateExternalLink,
|
|
pageConnection: validateInternalLink,
|
|
})
|
|
.transform((data) => {
|
|
return {
|
|
url: data.pageConnection?.url ?? data.link?.href ?? "",
|
|
title: data?.title ?? data.link?.title,
|
|
openInNewTab: data.open_in_new_tab,
|
|
isExternal: !data.pageConnection?.url,
|
|
}
|
|
})
|
|
|
|
const validateLinks = z
|
|
.array(validateLinkItem)
|
|
.transform((data) => data.filter((item) => item.url))
|
|
|
|
export const validateSecondaryLinks = z.array(
|
|
z.object({
|
|
title: z.string(),
|
|
links: validateLinks,
|
|
})
|
|
)
|
|
|
|
export const validateLinksWithType = z.array(
|
|
z.object({
|
|
type: z.string(),
|
|
href: validateExternalLink,
|
|
})
|
|
)
|
|
|
|
export const validateFooterConfigSchema = z
|
|
.object({
|
|
all_footer: z.object({
|
|
items: z.array(
|
|
z.object({
|
|
main_links: validateLinks.nullish().transform((val) => val ?? []),
|
|
app_downloads: z.object({
|
|
title: z.string(),
|
|
links: validateLinksWithType
|
|
.nullish()
|
|
.transform((val) => val ?? []),
|
|
}),
|
|
secondary_links: validateSecondaryLinks
|
|
.nullish()
|
|
.transform((val) => val ?? []),
|
|
social_media: z.object({
|
|
links: validateLinksWithType
|
|
.nullish()
|
|
.transform((val) => val ?? []),
|
|
}),
|
|
tertiary_links: validateLinks.nullish().transform((val) => val ?? []),
|
|
})
|
|
),
|
|
}),
|
|
})
|
|
.transform((data) => {
|
|
const {
|
|
main_links,
|
|
app_downloads,
|
|
secondary_links,
|
|
social_media,
|
|
tertiary_links,
|
|
} = data.all_footer.items[0]
|
|
|
|
return {
|
|
mainLinks: main_links,
|
|
appDownloads: app_downloads,
|
|
secondaryLinks: secondary_links,
|
|
socialMedia: social_media,
|
|
tertiaryLinks: tertiary_links,
|
|
}
|
|
})
|
|
|
|
const pageConnectionRefs = z.object({
|
|
edges: z
|
|
.array(
|
|
z.object({
|
|
node: z.object({
|
|
system: systemSchema,
|
|
}),
|
|
})
|
|
)
|
|
.max(1),
|
|
})
|
|
|
|
export const validateFooterRefConfigSchema = z.object({
|
|
all_footer: z.object({
|
|
items: z
|
|
.array(
|
|
z.object({
|
|
main_links: z
|
|
.array(
|
|
z.object({
|
|
pageConnection: pageConnectionRefs,
|
|
})
|
|
)
|
|
.nullable(),
|
|
secondary_links: z
|
|
.array(
|
|
z.object({
|
|
links: z.array(
|
|
z.object({
|
|
pageConnection: pageConnectionRefs,
|
|
})
|
|
),
|
|
})
|
|
)
|
|
.nullable(),
|
|
tertiary_links: z
|
|
.array(
|
|
z.object({
|
|
pageConnection: pageConnectionRefs,
|
|
})
|
|
)
|
|
.nullable(),
|
|
system: systemSchema,
|
|
})
|
|
)
|
|
.length(1),
|
|
}),
|
|
})
|
|
|
|
/**
|
|
* New Header Validation
|
|
*/
|
|
|
|
const linkRefsSchema = z
|
|
.object({
|
|
linkConnection: z.object({
|
|
edges: z.array(
|
|
z.object({
|
|
node: linkRefsUnionSchema,
|
|
})
|
|
),
|
|
}),
|
|
})
|
|
.transform((data) => {
|
|
if (data.linkConnection.edges.length) {
|
|
const link = transformPageLinkRef(data.linkConnection.edges[0].node)
|
|
if (link) {
|
|
return {
|
|
link,
|
|
}
|
|
}
|
|
}
|
|
return { link: null }
|
|
})
|
|
|
|
const menuItemsRefsSchema = z.intersection(
|
|
linkRefsSchema,
|
|
z
|
|
.object({
|
|
cardConnection: z.object({
|
|
edges: z.array(
|
|
z.object({
|
|
node: infoCardBlockRefsSchema,
|
|
})
|
|
),
|
|
}),
|
|
see_all_link: linkRefsSchema,
|
|
submenu: z.array(
|
|
z.object({
|
|
links: z.array(linkRefsSchema),
|
|
})
|
|
),
|
|
})
|
|
.transform((data) => {
|
|
let card = null
|
|
if (data.cardConnection.edges.length) {
|
|
card = transformCardBlockRefs(data.cardConnection.edges[0].node)
|
|
}
|
|
|
|
return {
|
|
card,
|
|
see_all_link: data.see_all_link,
|
|
submenu: data.submenu,
|
|
}
|
|
})
|
|
)
|
|
|
|
const topLinkRefsSchema = z.object({
|
|
logged_in: linkRefsSchema.nullable(),
|
|
logged_out: linkRefsSchema.nullable(),
|
|
})
|
|
|
|
export const headerRefsSchema = z
|
|
.object({
|
|
all_header: z.object({
|
|
items: z
|
|
.array(
|
|
z.object({
|
|
menu_items: z.array(menuItemsRefsSchema),
|
|
system: systemSchema,
|
|
top_link: topLinkRefsSchema,
|
|
})
|
|
)
|
|
.max(1),
|
|
}),
|
|
})
|
|
.transform((data) => {
|
|
if (!data.all_header.items.length) {
|
|
logger.error(`Zod Error - No header returned in refs request`)
|
|
throw new ZodError([
|
|
{
|
|
code: ZodIssueCode.custom,
|
|
fatal: true,
|
|
message: "No header returned (Refs)",
|
|
path: ["all_header.items"],
|
|
},
|
|
])
|
|
}
|
|
|
|
return {
|
|
header: data.all_header.items[0],
|
|
}
|
|
})
|
|
|
|
const internalOrExternalLinkSchema = z
|
|
.object({
|
|
is_contentstack_link: z.boolean().nullish(),
|
|
external_link: z
|
|
.object({
|
|
href: nullableStringValidator,
|
|
title: z.string().nullish(),
|
|
})
|
|
.nullish(),
|
|
title: nullableStringValidator,
|
|
linkConnection: z.object({
|
|
edges: z.array(
|
|
z.object({
|
|
node: linkUnionSchema.transform((data) => {
|
|
const link = transformPageLink(data)
|
|
if (link) {
|
|
return link
|
|
}
|
|
return data
|
|
}),
|
|
})
|
|
),
|
|
}),
|
|
})
|
|
.transform(
|
|
({ is_contentstack_link, external_link, linkConnection, title }) => {
|
|
if (is_contentstack_link !== false && linkConnection.edges.length) {
|
|
const linkRef = linkConnection.edges[0].node
|
|
return {
|
|
title: title || linkRef.title,
|
|
url: linkRef.url,
|
|
}
|
|
} else if (is_contentstack_link === false && external_link?.href) {
|
|
return {
|
|
title: title || external_link.title || "",
|
|
url: external_link.href,
|
|
}
|
|
} else {
|
|
return {
|
|
title,
|
|
}
|
|
}
|
|
}
|
|
)
|
|
|
|
const linkSchema = z
|
|
.object({
|
|
linkConnection: z.object({
|
|
edges: z.array(
|
|
z.object({
|
|
node: discriminatedUnion(rawLinkUnionSchema.options),
|
|
})
|
|
),
|
|
}),
|
|
})
|
|
.transform((data) => {
|
|
if (data.linkConnection.edges.length) {
|
|
const linkNode = data.linkConnection.edges[0].node
|
|
if (linkNode) {
|
|
const link = transformPageLink(linkNode)
|
|
if (link) {
|
|
return {
|
|
link,
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return {
|
|
link: null,
|
|
}
|
|
})
|
|
|
|
const titleSchema = z.object({
|
|
title: nullableStringValidator,
|
|
})
|
|
|
|
/**
|
|
* Intersection has to be used since you are not
|
|
* allowed to merge two schemas where one uses
|
|
* transform
|
|
*/
|
|
const linkAndTitleSchema = z.intersection(linkSchema, titleSchema)
|
|
|
|
/**
|
|
* Same as above 👆
|
|
*/
|
|
export const menuItemSchema = z
|
|
.intersection(
|
|
internalOrExternalLinkSchema,
|
|
z
|
|
.object({
|
|
cardConnection: z.object({
|
|
edges: z.array(
|
|
z.object({
|
|
node: infoCardBlockSchema,
|
|
})
|
|
),
|
|
}),
|
|
see_all_link: internalOrExternalLinkSchema,
|
|
submenu: z.array(
|
|
z.object({
|
|
links: z.array(internalOrExternalLinkSchema),
|
|
title: nullableStringValidator,
|
|
})
|
|
),
|
|
})
|
|
.transform((data) => {
|
|
let card = null
|
|
if (data.cardConnection.edges.length) {
|
|
card = transformInfoCardBlock(data.cardConnection.edges[0].node)
|
|
}
|
|
|
|
return {
|
|
card,
|
|
seeAllLink: data.see_all_link,
|
|
submenu: data.submenu,
|
|
}
|
|
})
|
|
)
|
|
.transform(({ title, url, card, seeAllLink, submenu }) => {
|
|
return {
|
|
title,
|
|
link: submenu.length ? null : { url },
|
|
seeAllLink: submenu.length ? seeAllLink : null,
|
|
card,
|
|
submenu,
|
|
}
|
|
})
|
|
|
|
// TODO When original IconName enum is moved to common we should use it
|
|
enum IconName {
|
|
Gift = "Gift",
|
|
InfoCircle = "InfoCircle",
|
|
PriceTag = "PriceTag",
|
|
}
|
|
|
|
const topLinkItemSchema = z.intersection(
|
|
internalOrExternalLinkSchema,
|
|
z.object({
|
|
icon: z
|
|
.enum(["loyalty", "info", "offer"])
|
|
.nullable()
|
|
.transform((icon) => {
|
|
switch (icon) {
|
|
case "loyalty":
|
|
return IconName.Gift
|
|
case "info":
|
|
return IconName.InfoCircle
|
|
case "offer":
|
|
return IconName.PriceTag
|
|
default:
|
|
return null
|
|
}
|
|
}),
|
|
})
|
|
)
|
|
|
|
export const topLinkSchema = z.object({
|
|
logged_in: topLinkItemSchema.nullable(),
|
|
logged_out: topLinkItemSchema.nullable(),
|
|
})
|
|
|
|
export const headerSchema = z
|
|
.object({
|
|
all_header: z.object({
|
|
items: z
|
|
.array(
|
|
z.object({
|
|
menu_items: z.array(menuItemSchema),
|
|
top_link: topLinkSchema,
|
|
})
|
|
)
|
|
.max(1),
|
|
}),
|
|
})
|
|
.transform((data) => {
|
|
if (!data.all_header.items.length) {
|
|
logger.error(`Zod Error - No header returned in request`)
|
|
throw new ZodError([
|
|
{
|
|
code: ZodIssueCode.custom,
|
|
fatal: true,
|
|
message: "No header returned",
|
|
path: ["all_header.items"],
|
|
},
|
|
])
|
|
}
|
|
|
|
const header = data.all_header.items[0]
|
|
return {
|
|
header: {
|
|
menuItems: header.menu_items,
|
|
topLink: header.top_link,
|
|
},
|
|
}
|
|
})
|
|
|
|
export const alertSchema = z
|
|
.object({
|
|
type: z.nativeEnum(AlertTypeEnum),
|
|
text: z.string(),
|
|
heading: z.string(),
|
|
phone_contact: z.object({
|
|
display_text: z.string(),
|
|
phone_number: z.string().nullable(),
|
|
footnote: z.string().nullable(),
|
|
}),
|
|
has_link: z.boolean(),
|
|
link: linkAndTitleSchema,
|
|
has_sidepeek_button: z.boolean(),
|
|
sidepeek_button: z.object({
|
|
cta_text: z.string(),
|
|
}),
|
|
sidepeek_content: z.object({
|
|
heading: z.string(),
|
|
content: z.object({
|
|
json: z.any(),
|
|
embedded_itemsConnection: z.object({
|
|
edges: z.array(
|
|
z.object({
|
|
node: linkUnionSchema.transform((data) => {
|
|
const link = transformPageLink(data)
|
|
if (link) {
|
|
return link
|
|
}
|
|
return data
|
|
}),
|
|
})
|
|
),
|
|
}),
|
|
}),
|
|
}),
|
|
visible_on: z.array(z.string()).nullish().default([]),
|
|
})
|
|
.transform(
|
|
({
|
|
type,
|
|
heading,
|
|
text,
|
|
phone_contact,
|
|
has_link,
|
|
link,
|
|
has_sidepeek_button,
|
|
sidepeek_button,
|
|
sidepeek_content,
|
|
visible_on,
|
|
}) => {
|
|
const hasLink = has_link && link.link
|
|
return {
|
|
type,
|
|
text,
|
|
heading,
|
|
visible_on,
|
|
phoneContact:
|
|
phone_contact.display_text && phone_contact.phone_number
|
|
? {
|
|
displayText: phone_contact.display_text,
|
|
phoneNumber: phone_contact.phone_number,
|
|
footnote: phone_contact.footnote,
|
|
}
|
|
: null,
|
|
hasSidepeekButton: !!has_sidepeek_button,
|
|
link: hasLink
|
|
? {
|
|
url: link.link.url,
|
|
title: link.title,
|
|
}
|
|
: null,
|
|
sidepeekButton:
|
|
!hasLink && has_sidepeek_button ? sidepeek_button : null,
|
|
sidepeekContent:
|
|
!hasLink && has_sidepeek_button ? sidepeek_content : null,
|
|
}
|
|
}
|
|
)
|
|
|
|
export const siteConfigSchema = z
|
|
.object({
|
|
all_site_config: z.object({
|
|
items: z
|
|
.array(
|
|
z.object({
|
|
sitewide_alert: z.object({
|
|
alerts: z
|
|
.array(
|
|
z.object({
|
|
booking_widget_disabled: z.boolean(),
|
|
alertConnection: z.object({
|
|
edges: z.array(
|
|
z.object({
|
|
node: alertSchema,
|
|
})
|
|
),
|
|
}),
|
|
})
|
|
)
|
|
.nullable(),
|
|
}),
|
|
})
|
|
)
|
|
.max(1),
|
|
}),
|
|
})
|
|
.transform((data) => {
|
|
if (!data.all_site_config.items.length) {
|
|
return {
|
|
sitewideAlert: null,
|
|
bookingWidgetDisabled: false,
|
|
}
|
|
}
|
|
|
|
const sitewideAlertWeb =
|
|
data.all_site_config.items[0].sitewide_alert.alerts?.find((alert) =>
|
|
alert.alertConnection.edges[0]?.node.visible_on?.includes(
|
|
AlertVisibleOnEnum.WEB
|
|
)
|
|
)
|
|
|
|
return {
|
|
sitewideAlert: sitewideAlertWeb?.alertConnection.edges[0]?.node || null,
|
|
bookingWidgetDisabled: sitewideAlertWeb?.booking_widget_disabled,
|
|
}
|
|
})
|
|
|
|
const sidepeekContentRefSchema = z.object({
|
|
content: z.object({
|
|
embedded_itemsConnection: z.object({
|
|
edges: z.array(
|
|
z.object({
|
|
node: linkRefsUnionSchema,
|
|
})
|
|
),
|
|
}),
|
|
}),
|
|
})
|
|
|
|
const alertConnectionRefSchema = z.object({
|
|
edges: z.array(
|
|
z.object({
|
|
node: z.object({
|
|
link: linkRefsSchema,
|
|
sidepeek_content: sidepeekContentRefSchema,
|
|
system: systemSchema,
|
|
}),
|
|
})
|
|
),
|
|
visible_on: z.array(z.string()).nullish().default([]),
|
|
})
|
|
|
|
export const siteConfigRefSchema = z.object({
|
|
all_site_config: z.object({
|
|
items: z.array(
|
|
z.object({
|
|
sitewide_alert: z
|
|
.object({
|
|
alerts: z
|
|
.array(
|
|
z.object({
|
|
alertConnection: alertConnectionRefSchema,
|
|
})
|
|
)
|
|
.nullable(),
|
|
})
|
|
.transform((data) => {
|
|
const sitewideAlertWeb = data.alerts?.find((alert) =>
|
|
alert.alertConnection.visible_on?.includes(AlertVisibleOnEnum.WEB)
|
|
)
|
|
return { alert: sitewideAlertWeb || null }
|
|
}),
|
|
system: systemSchema,
|
|
})
|
|
),
|
|
}),
|
|
})
|
|
|
|
const bannerSchema = z
|
|
.object({
|
|
tag: z.string(),
|
|
text: z.string(),
|
|
link: linkAndTitleSchema,
|
|
booking_code: z.string().nullish(),
|
|
visible_on: z.array(z.string()).nullish().default([]),
|
|
})
|
|
.transform(({ tag, text, link, visible_on, booking_code }) => {
|
|
const linkUrl = link.link?.url || null
|
|
return {
|
|
tag,
|
|
text,
|
|
link: linkUrl
|
|
? {
|
|
url: linkUrl,
|
|
title: link.title,
|
|
}
|
|
: null,
|
|
booking_code,
|
|
visible_on,
|
|
}
|
|
})
|
|
|
|
const bannerRefSchema = z
|
|
.object({
|
|
link: linkConnectionRefsSchema,
|
|
visible_on: z.array(z.string()).nullish().default([]),
|
|
system: systemSchema,
|
|
})
|
|
.transform(({ link, visible_on, system }) => {
|
|
return {
|
|
linkSystem: link,
|
|
visible_on,
|
|
system,
|
|
}
|
|
})
|
|
|
|
export const sitewideCampaignBannerSchema = z
|
|
.object({
|
|
all_sitewide_campaign_banner: z.object({
|
|
items: z
|
|
.array(
|
|
z.object({
|
|
bannerConnection: z.object({
|
|
edges: z.array(
|
|
z.object({
|
|
node: bannerSchema,
|
|
})
|
|
),
|
|
}),
|
|
})
|
|
)
|
|
.max(1),
|
|
}),
|
|
})
|
|
.transform((data) => {
|
|
if (!data.all_sitewide_campaign_banner.items.length) {
|
|
return null
|
|
}
|
|
|
|
const sitewideCampaignBannerWeb =
|
|
data.all_sitewide_campaign_banner.items[0].bannerConnection.edges.find(
|
|
(banner) => banner.node.visible_on?.includes(AlertVisibleOnEnum.WEB)
|
|
)
|
|
|
|
return sitewideCampaignBannerWeb?.node ?? null
|
|
})
|
|
|
|
export const sitewideCampaignBannerRefSchema = z.object({
|
|
all_sitewide_campaign_banner: z
|
|
.object({
|
|
items: z.array(
|
|
z.object({
|
|
bannerConnection: z.object({
|
|
edges: z.array(
|
|
z.object({
|
|
node: bannerRefSchema,
|
|
})
|
|
),
|
|
}),
|
|
system: systemSchema,
|
|
})
|
|
),
|
|
})
|
|
.transform((data) => {
|
|
const webBanner = data.items.find((item) => {
|
|
const bannerNode = item.bannerConnection.edges[0]?.node
|
|
return bannerNode?.visible_on?.includes(AlertVisibleOnEnum.WEB)
|
|
})
|
|
|
|
return webBanner ?? null
|
|
}),
|
|
})
|