web/server/routers/contentstack/metadata/query.ts

import { metrics } from "@opentelemetry/api"
import { cache } from "react"

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 { GetHotelPageMetadata } from "@/lib/graphql/Query/HotelPage/Metadata.graphql"
import { GetLoyaltyPageMetadata } from "@/lib/graphql/Query/LoyaltyPage/Metadata.graphql"
import { request } from "@/lib/graphql/request"
import { notFound } from "@/server/errors/trpc"
import { contentStackUidWithServiceProcedure, router } from "@/server/trpc"

import { generateTag } from "@/utils/generateTag"

import { getHotelData } from "../../hotels/query"
import { metadataSchema } from "./output"
import { affix } from "./utils"

import { PageContentTypeEnum } from "@/types/requests/contentType"
import type { RawMetadataSchema } from "@/types/trpc/routers/contentstack/metadata"
import type { Lang } from "@/constants/languages"

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 response = await request<T>(
    query,
    { locale: lang, uid },
    {
      cache: "force-cache",
      next: {
        tags: [generateTag(lang, uid, affix)],
      },
    }
  )
  if (!response.data) {
    const notFoundError = notFound(response)
    fetchMetadataFailCounter.add(1, {
      lang,
      uid,
      error_type: "not_found",
      error: JSON.stringify({ code: notFoundError.code }),
    })
    console.error(
      "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
})

async function getTransformedMetadata(data: unknown) {
  transformMetadataCounter.add(1)
  console.info("contentstack.metadata transform start")
  const validatedMetadata = await metadataSchema.safeParseAsync(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,
      })
    )
    return null
  }

  transformMetadataSuccessCounter.add(1)
  console.info("contentstack.metadata transform success")

  return validatedMetadata.data
}

export const metadataQueryRouter = router({
  get: contentStackUidWithServiceProcedure.query(async ({ ctx }) => {
    const variables = {
      lang: ctx.lang,
      uid: ctx.uid,
    }

    switch (ctx.contentType) {
      case PageContentTypeEnum.accountPage:
        const accountPageResponse = await fetchMetadata<{
          account_page: RawMetadataSchema
        }>(GetAccountPageMetadata, variables)
        return getTransformedMetadata(accountPageResponse.account_page)
      case PageContentTypeEnum.collectionPage:
        const collectionPageResponse = await fetchMetadata<{
          collection_page: RawMetadataSchema
        }>(GetCollectionPageMetadata, variables)
        return getTransformedMetadata(collectionPageResponse.collection_page)
      case PageContentTypeEnum.contentPage:
        const contentPageResponse = await fetchMetadata<{
          content_page: RawMetadataSchema
        }>(GetContentPageMetadata, variables)
        return getTransformedMetadata(contentPageResponse.content_page)
      case PageContentTypeEnum.loyaltyPage:
        const loyaltyPageResponse = await fetchMetadata<{
          loyalty_page: RawMetadataSchema
        }>(GetLoyaltyPageMetadata, variables)
        return getTransformedMetadata(loyaltyPageResponse.loyalty_page)
      case PageContentTypeEnum.hotelPage:
        const hotelPageResponse = await fetchMetadata<{
          hotel_page: RawMetadataSchema
        }>(GetHotelPageMetadata, variables)
        const hotelPageData = hotelPageResponse.hotel_page
        const hotelData = hotelPageData.hotel_page_id
          ? await getHotelData(
              { hotelId: hotelPageData.hotel_page_id, language: ctx.lang },
              ctx.serviceToken
            )
          : null

        return getTransformedMetadata({
          ...hotelPageData,
          hotelData: hotelData?.data.attributes,
        })
      default:
        return null
    }
  }),
})