feat(SW-200): refactoring SEO metadata handling and added functionality for static pages

server/routers/contentstack/metadata/query.ts

@@ -1,45 +1,144 @@
+import { metrics } from "@opentelemetry/api"
+import { cache } from "react"
+
+import { Lang } from "@/constants/languages"
+import { GetAccountPageMetaData } from "@/lib/graphql/Query/AccountPage/MetaData.graphql"
+import { GetCollectionPageMetaData } from "@/lib/graphql/Query/CollectionPage/MetaData.graphql"
+import { GetContentPageMetaData } from "@/lib/graphql/Query/ContentPage/MetaData.graphql"
 import { GetLoyaltyPageMetaData } from "@/lib/graphql/Query/LoyaltyPage/MetaData.graphql"
+import { request } from "@/lib/graphql/request"
+import { notFound } from "@/server/errors/trpc"
 import { contentstackExtendedProcedureUID, router } from "@/server/trpc"
 
-import {
-  type GetLoyaltyPageMetaDataData,
-  getLoyaltyPageMetadataSchema,
-} from "./output"
-import { getMetaData, getResponse, type Variables } from "./utils"
+import { generateTag } from "@/utils/generateTag"
+
+import { metaDataSchema } from "./output"
+import { affix } from "./utils"
 
 import { PageTypeEnum } from "@/types/requests/pageType"
+import { RawMetaDataSchema } from "@/types/trpc/routers/contentstack/metadata"
 
-async function getLoyaltyPageMetaData(variables: Variables) {
-  const response = await getResponse<GetLoyaltyPageMetaDataData>(
-    GetLoyaltyPageMetaData,
-    variables
+const meter = metrics.getMeter("trpc.metaData")
+
+// OpenTelemetry metrics
+const fetchMetaDataCounter = meter.createCounter(
+  "trpc.contentstack.metaData.get"
+)
+const fetchMetaDataSuccessCounter = meter.createCounter(
+  "trpc.contentstack.metaData.get-success"
+)
+const fetchMetaDataFailCounter = meter.createCounter(
+  "trpc.contentstack.metaData.get-fail"
+)
+const transformMetaDataCounter = meter.createCounter(
+  "trpc.contentstack.metaData.transform"
+)
+const transformMetaDataSuccessCounter = meter.createCounter(
+  "trpc.contentstack.metaData.transform-success"
+)
+const transformMetaDataFailCounter = meter.createCounter(
+  "trpc.contentstack.metaData.transform-fail"
+)
+
+const fetchMetaData = cache(async function fetchMemoizedMetaData<T>(
+  query: string,
+  { uid, lang }: { uid: string; lang: Lang }
+) {
+  fetchMetaDataCounter.add(1, { lang, uid })
+  console.info(
+    "contentstack.metaData fetch start",
+    JSON.stringify({ query: { lang, uid } })
   )
-
-  const validatedMetadata = getLoyaltyPageMetadataSchema.safeParse(
-    response.data
+  const response = await request<T>(
+    query,
+    { locale: lang, uid },
+    {
+      cache: "force-cache",
+      next: {
+        tags: [generateTag(lang, uid, affix)],
+      },
+    }
   )
-
-  if (!validatedMetadata.success) {
+  if (!response.data) {
+    const notFoundError = notFound(response)
+    fetchMetaDataFailCounter.add(1, {
+      lang,
+      uid,
+      error_type: "not_found",
+      error: JSON.stringify({ code: notFoundError.code }),
+    })
     console.error(
-      `Failed to validate Loyaltypage MetaData Data - (uid: ${variables.uid})`
+      "contentstack.metaData fetch not found error",
+      JSON.stringify({
+        query: { lang, uid },
+        error: { code: notFoundError.code },
+      })
+    )
+    throw notFoundError
+  }
+
+  fetchMetaDataSuccessCounter.add(1, { lang, uid })
+  console.info(
+    "contentstack.metaData fetch success",
+    JSON.stringify({ query: { lang, uid } })
+  )
+
+  return response.data
+})
+
+function getTransformedMetaData(data: unknown) {
+  transformMetaDataCounter.add(1)
+  console.info("contentstack.metaData transform start")
+  const validatedMetaData = metaDataSchema.safeParse(data)
+
+  if (!validatedMetaData.success) {
+    transformMetaDataFailCounter.add(1, {
+      error_type: "validation_error",
+      error: JSON.stringify(validatedMetaData.error),
+    })
+    console.error(
+      "contentstack.metaData validation error",
+      JSON.stringify({
+        error: validatedMetaData.error,
+      })
     )
-    console.error(validatedMetadata.error)
     return null
   }
 
-  return getMetaData(validatedMetadata.data.loyalty_page)
+  transformMetaDataSuccessCounter.add(1)
+  console.info("contentstack.metaData transform success")
+
+  return validatedMetaData.data
 }
 
 export const metaDataQueryRouter = router({
   get: contentstackExtendedProcedureUID.query(async ({ ctx }) => {
     const variables = {
-      locale: ctx.lang,
+      lang: ctx.lang,
       uid: ctx.uid,
     }
 
     switch (ctx.contentType) {
+      case PageTypeEnum.accountPage:
+        const accountPageResponse = await fetchMetaData<{
+          account_page: RawMetaDataSchema
+        }>(GetAccountPageMetaData, variables)
+        return getTransformedMetaData(accountPageResponse.account_page)
+      case PageTypeEnum.collectionPage:
+        const collectionPageResponse = await fetchMetaData<{
+          collection_page: RawMetaDataSchema
+        }>(GetCollectionPageMetaData, variables)
+        return getTransformedMetaData(collectionPageResponse.collection_page)
+      case PageTypeEnum.contentPage:
+        const contentPageResponse = await fetchMetaData<{
+          content_page: RawMetaDataSchema
+        }>(GetContentPageMetaData, variables)
+        return getTransformedMetaData(contentPageResponse.content_page)
       case PageTypeEnum.loyaltyPage:
-        return await getLoyaltyPageMetaData(variables)
+        const loyaltyPageResponse = await fetchMetaData<{
+          loyalty_page: RawMetaDataSchema
+        }>(GetLoyaltyPageMetaData, variables)
+        return getTransformedMetaData(loyaltyPageResponse.loyalty_page)
       default:
         return null
     }