Merged in feat/SW-1450-destination-page-cs-components (pull request #1204)

feat(SW-1450): added components in destination pages from cs

* feat(SW-1450): added components in destination pages from cs

* feat(SW-1450): added correct refs and removed classNames


Approved-by: Fredrik Thorsson

server/routers/contentstack/destinationCountryPage/output.ts

@@ -1,25 +1,120 @@
 import { z } from "zod"
 
+import * as pageLinks from "@/server/routers/contentstack/schemas/pageLinks"
+
+import { tempImageVaultAssetSchema } from "../schemas/imageVault"
 import { systemSchema } from "../schemas/system"
 
-export const destinationCountryPageSchema = z.object({
-  destination_country_page: z.object({
-    title: z.string(),
-    system: systemSchema.merge(
-      z.object({
-        created_at: z.string(),
-        updated_at: z.string(),
-      })
-    ),
-  }),
-  trackingProps: z.object({
-    url: z.string(),
-  }),
-})
+import type { ImageVaultAsset } from "@/types/components/imageVault"
+import {
+  TrackingChannelEnum,
+  type TrackingSDKPageData,
+} from "@/types/components/tracking"
+import { Country } from "@/types/enums/country"
+
+export const destinationCountryPageSchema = z
+  .object({
+    destination_country_page: z.object({
+      title: z.string(),
+      destination_settings: z.object({
+        country: z.nativeEnum(Country),
+      }),
+      heading: z.string(),
+      preamble: z.string(),
+      experiences: z
+        .object({
+          destination_experiences: z.array(z.string()),
+        })
+        .transform(({ destination_experiences }) => destination_experiences),
+      images: z
+        .array(z.object({ image: tempImageVaultAssetSchema }))
+        .transform((images) =>
+          images
+            .map((image) => image.image)
+            .filter((image): image is ImageVaultAsset => !!image)
+        ),
+      has_sidepeek: z.boolean().default(false),
+      sidepeek_button_text: z.string().default(""),
+      sidepeek_content: z.object({
+        heading: z.string(),
+        content: z.object({
+          json: z.any(),
+          embedded_itemsConnection: z.object({
+            edges: z.array(
+              z.object({
+                node: z
+                  .discriminatedUnion("__typename", [
+                    pageLinks.accountPageSchema,
+                    pageLinks.contentPageSchema,
+                    pageLinks.hotelPageSchema,
+                    pageLinks.loyaltyPageSchema,
+                    pageLinks.collectionPageSchema,
+                  ])
+                  .transform((data) => {
+                    const link = pageLinks.transform(data)
+                    if (link) {
+                      return link
+                    }
+                    return data
+                  }),
+              })
+            ),
+          }),
+        }),
+      }),
+      system: systemSchema.merge(
+        z.object({
+          created_at: z.string(),
+          updated_at: z.string(),
+        })
+      ),
+    }),
+    trackingProps: z.object({
+      url: z.string(),
+    }),
+  })
+  .transform((data) => {
+    const countryPageData = data.destination_country_page
+    const system = countryPageData.system
+    const trackingUrl = data.trackingProps.url
+    const tracking: TrackingSDKPageData = {
+      pageId: system.uid,
+      domainLanguage: system.locale,
+      publishDate: system.updated_at,
+      createDate: system.created_at,
+      channel: TrackingChannelEnum["destination-page"],
+      pageType: "staticcontentpage",
+      pageName: trackingUrl,
+      siteSections: trackingUrl,
+      siteVersion: "new-web",
+    }
+
+    return {
+      destinationCountryPage: countryPageData,
+      tracking,
+    }
+  })
 
 /** REFS */
 export const destinationCountryPageRefsSchema = z.object({
   destination_country_page: z.object({
+    sidepeek_content: z.object({
+      content: z.object({
+        embedded_itemsConnection: z.object({
+          edges: z.array(
+            z.object({
+              node: z.discriminatedUnion("__typename", [
+                pageLinks.accountPageRefSchema,
+                pageLinks.contentPageRefSchema,
+                pageLinks.hotelPageRefSchema,
+                pageLinks.loyaltyPageRefSchema,
+                pageLinks.collectionPageRefSchema,
+              ]),
+            })
+          ),
+        }),
+      }),
+    }),
     system: systemSchema,
   }),
 })

server/routers/contentstack/destinationCountryPage/query.ts

@@ -20,11 +20,8 @@ import {
   getDestinationCountryPageRefsSuccessCounter,
   getDestinationCountryPageSuccessCounter,
 } from "./telemetry"
+import { generatePageTags } from "./utils"
 
-import {
-  TrackingChannelEnum,
-  type TrackingSDKPageData,
-} from "@/types/components/tracking"
 import type {
   GetDestinationCountryPageData,
   GetDestinationCountryPageRefsSchema,
@@ -91,6 +88,8 @@ export const destinationCountryPageQueryRouter = router({
       JSON.stringify({ query: { lang, uid } })
     )
 
+    const tags = generatePageTags(validatedRefsData.data, lang)
+
     getDestinationCountryPageCounter.add(1, { lang, uid: `${uid}` })
     console.info(
       "contentstack.destinationCountryPage start",
@@ -107,7 +106,7 @@ export const destinationCountryPageQueryRouter = router({
       {
         cache: "force-cache",
         next: {
-          tags: [generateTag(lang, uid)],
+          tags,
         },
       }
     )
@@ -158,23 +157,6 @@ export const destinationCountryPageQueryRouter = router({
       })
     )
 
-    const system = destinationCountryPage.data.destination_country_page.system
-    const tracking: TrackingSDKPageData = {
-      pageId: system.uid,
-      domainLanguage: lang,
-      publishDate: system.updated_at,
-      createDate: system.created_at,
-      channel: TrackingChannelEnum["destination-page"],
-      pageType: "staticcontentpage",
-      pageName: destinationCountryPage.data.trackingProps.url,
-      siteSections: destinationCountryPage.data.trackingProps.url,
-      siteVersion: "new-web",
-    }
-
-    return {
-      destinationCountryPage:
-        destinationCountryPage.data.destination_country_page,
-      tracking,
-    }
+    return destinationCountryPage.data
   }),
 })

server/routers/contentstack/destinationCountryPage/utils.ts

@@ -0,0 +1,32 @@
+import { generateTag, generateTagsFromSystem } from "@/utils/generateTag"
+
+import type { System } from "@/types/requests/system"
+import type { GetDestinationCountryPageRefsSchema } from "@/types/trpc/routers/contentstack/destinationCountryPage"
+import type { Lang } from "@/constants/languages"
+
+export function generatePageTags(
+  validatedData: GetDestinationCountryPageRefsSchema,
+  lang: Lang
+): string[] {
+  const connections = getConnections(validatedData)
+  return [
+    generateTagsFromSystem(lang, connections),
+    generateTag(lang, validatedData.destination_country_page.system.uid),
+  ].flat()
+}
+
+export function getConnections({
+  destination_country_page,
+}: GetDestinationCountryPageRefsSchema) {
+  const connections: System["system"][] = [destination_country_page.system]
+
+  if (destination_country_page.sidepeek_content) {
+    destination_country_page.sidepeek_content.content.embedded_itemsConnection.edges.forEach(
+      ({ node }) => {
+        connections.push(node.system)
+      }
+    )
+  }
+
+  return connections
+}