Merged in feat/SW-286-collectionPage (pull request #765)

Feat(SW-286): CollectionPage

Approved-by: Erik Tiekstra
Approved-by: Fredrik Thorsson

server/routers/contentstack/collectionPage/index.ts

@@ -0,0 +1,5 @@
+import { mergeRouters } from "@/server/trpc"
+
+import { collectionPageQueryRouter } from "./query"
+
+export const collectionPageRouter = mergeRouters(collectionPageQueryRouter)

server/routers/contentstack/collectionPage/output.ts

@@ -0,0 +1,121 @@
+import { z } from "zod"
+
+import { discriminatedUnionArray } from "@/lib/discriminatedUnion"
+
+import {
+  cardGridRefsSchema,
+  cardsGridSchema,
+} from "../schemas/blocks/cardsGrid"
+import {
+  shortcutsRefsSchema,
+  shortcutsSchema,
+} from "../schemas/blocks/shortcuts"
+import { uspGridRefsSchema, uspGridSchema } from "../schemas/blocks/uspGrid"
+import { tempImageVaultAssetSchema } from "../schemas/imageVault"
+import {
+  linkAndTitleSchema,
+  linkConnectionRefs,
+} from "../schemas/linkConnection"
+import { systemSchema } from "../schemas/system"
+
+import { CollectionPageEnum } from "@/types/enums/collectionPage"
+
+// Block schemas
+export const collectionPageCards = z
+  .object({
+    __typename: z.literal(CollectionPageEnum.ContentStack.blocks.CardsGrid),
+  })
+  .merge(cardsGridSchema)
+
+export const collectionPageShortcuts = z
+  .object({
+    __typename: z.literal(CollectionPageEnum.ContentStack.blocks.Shortcuts),
+  })
+  .merge(shortcutsSchema)
+
+export const collectionPageUspGrid = z
+  .object({
+    __typename: z.literal(CollectionPageEnum.ContentStack.blocks.UspGrid),
+  })
+  .merge(uspGridSchema)
+
+export const blocksSchema = z.discriminatedUnion("__typename", [
+  collectionPageCards,
+  collectionPageShortcuts,
+  collectionPageUspGrid,
+])
+
+const navigationLinksSchema = z
+  .array(linkAndTitleSchema)
+  .nullable()
+  .transform((data) => {
+    if (!data) {
+      return null
+    }
+
+    return data
+      .filter((item) => !!item.link)
+      .map((item) => ({
+        url: item.link!.url,
+        title: item.title || item.link!.title,
+      }))
+  })
+
+// Content Page Schema and types
+export const collectionPageSchema = z.object({
+  collection_page: z.object({
+    hero_image: tempImageVaultAssetSchema,
+    blocks: discriminatedUnionArray(blocksSchema.options).nullable(),
+    title: z.string(),
+    header: z.object({
+      heading: z.string(),
+      preamble: z.string(),
+      navigation_links: navigationLinksSchema,
+    }),
+    system: systemSchema.merge(
+      z.object({
+        created_at: z.string(),
+        updated_at: z.string(),
+      })
+    ),
+  }),
+})
+
+/** REFS */
+const collectionPageCardsRefs = z
+  .object({
+    __typename: z.literal(CollectionPageEnum.ContentStack.blocks.CardsGrid),
+  })
+  .merge(cardGridRefsSchema)
+
+const collectionPageShortcutsRefs = z
+  .object({
+    __typename: z.literal(CollectionPageEnum.ContentStack.blocks.Shortcuts),
+  })
+  .merge(shortcutsRefsSchema)
+
+const collectionPageUspGridRefs = z
+  .object({
+    __typename: z.literal(CollectionPageEnum.ContentStack.blocks.UspGrid),
+  })
+  .merge(uspGridRefsSchema)
+
+const collectionPageBlockRefsItem = z.discriminatedUnion("__typename", [
+  collectionPageShortcutsRefs,
+  collectionPageCardsRefs,
+  collectionPageUspGridRefs,
+])
+
+const collectionPageHeaderRefs = z.object({
+  navigation_links: z.array(linkConnectionRefs),
+})
+
+export const collectionPageRefsSchema = z.object({
+  collection_page: z.object({
+    header: collectionPageHeaderRefs,
+    blocks: discriminatedUnionArray(
+      collectionPageBlockRefsItem.options
+    ).nullable(),
+    system: systemSchema,
+  }),
+})

server/routers/contentstack/collectionPage/query.ts

@@ -0,0 +1,78 @@
+import { Lang } from "@/constants/languages"
+import { GetCollectionPage } from "@/lib/graphql/Query/CollectionPage/CollectionPage.graphql"
+import { request } from "@/lib/graphql/request"
+import { contentstackExtendedProcedureUID, router } from "@/server/trpc"
+
+import { collectionPageSchema } from "./output"
+import {
+  fetchCollectionPageRefs,
+  generatePageTags,
+  getCollectionPageCounter,
+  validateCollectionPageRefs,
+} from "./utils"
+
+import {
+  TrackingChannelEnum,
+  type TrackingSDKPageData,
+} from "@/types/components/tracking"
+import { GetCollectionPageSchema } from "@/types/trpc/routers/contentstack/collectionPage"
+
+export const collectionPageQueryRouter = router({
+  get: contentstackExtendedProcedureUID.query(async ({ ctx }) => {
+    const { lang, uid } = ctx
+
+    const collectionPageRefsData = await fetchCollectionPageRefs(lang, uid)
+
+    const collectionPageRefs = validateCollectionPageRefs(
+      collectionPageRefsData,
+      lang,
+      uid
+    )
+    if (!collectionPageRefs) {
+      return null
+    }
+    const tags = generatePageTags(collectionPageRefs, lang)
+
+    getCollectionPageCounter.add(1, { lang, uid })
+    console.info(
+      "contentstack.collectionPage start",
+      JSON.stringify({
+        query: { lang, uid },
+      })
+    )
+
+    const response = await request<GetCollectionPageSchema>(
+      GetCollectionPage,
+      { locale: lang, uid },
+      {
+        cache: "force-cache",
+        next: {
+          tags,
+        },
+      }
+    )
+
+    const collectionPage = collectionPageSchema.safeParse(response.data)
+    if (!collectionPage.success) {
+      console.error(
+        `Failed to validate CollectionPage Data - (lang: ${lang}, uid: ${uid})`
+      )
+      console.error(collectionPage.error?.format())
+      return null
+    }
+
+    const tracking: TrackingSDKPageData = {
+      pageId: collectionPage.data.collection_page.system.uid,
+      lang: collectionPage.data.collection_page.system.locale as Lang,
+      publishedDate: collectionPage.data.collection_page.system.updated_at,
+      createdDate: collectionPage.data.collection_page.system.created_at,
+      channel: TrackingChannelEnum["collection-page"],
+      pageType: "collectionpage",
+    }
+
+    return {
+      collectionPage: collectionPage.data.collection_page,
+      tracking,
+    }
+  }),
+})

server/routers/contentstack/collectionPage/utils.ts

@@ -0,0 +1,152 @@
+import { metrics } from "@opentelemetry/api"
+
+import { Lang } from "@/constants/languages"
+import { GetCollectionPageRefs } from "@/lib/graphql/Query/CollectionPage/CollectionPage.graphql"
+import { request } from "@/lib/graphql/request"
+import { notFound } from "@/server/errors/trpc"
+
+import { generateTag, generateTagsFromSystem } from "@/utils/generateTag"
+
+import { collectionPageRefsSchema } from "./output"
+
+import { CollectionPageEnum } from "@/types/enums/collectionPage"
+import { System } from "@/types/requests/system"
+import {
+  CollectionPageRefs,
+  GetCollectionPageRefsSchema,
+} from "@/types/trpc/routers/contentstack/collectionPage"
+
+const meter = metrics.getMeter("trpc.collectionPage")
+// OpenTelemetry metrics: CollectionPage
+
+export const getCollectionPageCounter = meter.createCounter(
+  "trpc.contentstack.collectionPage.get"
+)
+
+const getCollectionPageRefsCounter = meter.createCounter(
+  "trpc.contentstack.collectionPage.get"
+)
+const getCollectionPageRefsFailCounter = meter.createCounter(
+  "trpc.contentstack.collectionPage.get-fail"
+)
+const getCollectionPageRefsSuccessCounter = meter.createCounter(
+  "trpc.contentstack.collectionPage.get-success"
+)
+
+export async function fetchCollectionPageRefs(lang: Lang, uid: string) {
+  getCollectionPageRefsCounter.add(1, { lang, uid })
+  console.info(
+    "contentstack.collectionPage.refs start",
+    JSON.stringify({
+      query: { lang, uid },
+    })
+  )
+  const refsResponse = await request<GetCollectionPageRefsSchema>(
+    GetCollectionPageRefs,
+    { locale: lang, uid },
+    {
+      cache: "force-cache",
+      next: {
+        tags: [generateTag(lang, uid)],
+      },
+    }
+  )
+
+  if (!refsResponse.data) {
+    const notFoundError = notFound(refsResponse)
+    getCollectionPageRefsFailCounter.add(1, {
+      lang,
+      uid,
+      error_type: "http_error",
+      error: JSON.stringify({
+        code: notFoundError.code,
+      }),
+    })
+    console.error(
+      "contentstack.collectionPage.refs not found error",
+      JSON.stringify({
+        query: {
+          lang,
+          uid,
+        },
+        error: { code: notFoundError.code },
+      })
+    )
+    throw notFoundError
+  }
+
+  return refsResponse.data
+}
+
+export function validateCollectionPageRefs(
+  data: GetCollectionPageRefsSchema,
+  lang: Lang,
+  uid: string
+) {
+  const validatedData = collectionPageRefsSchema.safeParse(data)
+  if (!validatedData.success) {
+    getCollectionPageRefsFailCounter.add(1, {
+      lang,
+      uid,
+      error_type: "validation_error",
+      error: JSON.stringify(validatedData.error),
+    })
+    console.error(
+      "contentstack.collectionPage.refs validation error",
+      JSON.stringify({
+        query: { lang, uid },
+        error: validatedData.error,
+      })
+    )
+    return null
+  }
+  getCollectionPageRefsSuccessCounter.add(1, { lang, uid })
+  console.info(
+    "contentstack.collectionPage.refs success",
+    JSON.stringify({
+      query: { lang, uid },
+    })
+  )
+
+  return validatedData.data
+}
+
+export function generatePageTags(
+  validatedData: CollectionPageRefs,
+  lang: Lang
+): string[] {
+  const connections = getConnections(validatedData)
+  return [
+    generateTagsFromSystem(lang, connections),
+    generateTag(lang, validatedData.collection_page.system.uid),
+  ].flat()
+}
+
+export function getConnections({ collection_page }: CollectionPageRefs) {
+  const connections: System["system"][] = [collection_page.system]
+  if (collection_page.blocks) {
+    collection_page.blocks.forEach((block) => {
+      switch (block.__typename) {
+        case CollectionPageEnum.ContentStack.blocks.Shortcuts: {
+          if (block.shortcuts.shortcuts.length) {
+            connections.push(...block.shortcuts.shortcuts)
+          }
+          break
+        }
+        case CollectionPageEnum.ContentStack.blocks.CardsGrid: {
+          if (block.cards_grid.length) {
+            connections.push(...block.cards_grid)
+          }
+          break
+        }
+        case CollectionPageEnum.ContentStack.blocks.UspGrid: {
+          if (block.usp_grid.length) {
+            connections.push(...block.usp_grid)
+          }
+        }
+      }
+    })
+  }
+
+  return connections
+}