web/packages/trpc/lib/routers/contentstack/loyaltyPage/query.ts

import { createCounter } from "@scandic-hotels/common/telemetry"
import { notFound } from "@scandic-hotels/trpc/errors"
import { contentstackExtendedProcedureUID } from "@scandic-hotels/trpc/procedures"

import { router } from "../../.."
import {
  GetLoyaltyPage,
  GetLoyaltyPageRefs,
} from "../../../graphql/Query/LoyaltyPage/LoyaltyPage.graphql"
import { request } from "../../../graphql/request"
import {
  generateRefsResponseTag,
  generateTag,
  generateTagsFromSystem,
} from "../../../utils/generateTag"
import { loyaltyPageRefsSchema, loyaltyPageSchema } from "./output"
import { getConnections } from "./utils"

import type {
  GetLoyaltyPageRefsSchema,
  GetLoyaltyPageSchema,
} from "../../../types/loyaltyPage"
import type { TrackingPageData } from "../../types"

export const loyaltyPageQueryRouter = router({
  get: contentstackExtendedProcedureUID.query(async ({ ctx }) => {
    const { lang, uid } = ctx

    const getLoyaltyPageRefsCounter = createCounter(
      "trpc.contentstack",
      "loyaltyPage.get.refs"
    )
    const metricsGetLoyaltyPageRefs = getLoyaltyPageRefsCounter.init({
      lang,
      uid,
    })

    metricsGetLoyaltyPageRefs.start()

    const variables = { locale: lang, uid }
    const refsResponse = await request<GetLoyaltyPageRefsSchema>(
      GetLoyaltyPageRefs,
      variables,
      {
        key: generateRefsResponseTag(lang, uid),
        ttl: "max",
      }
    )

    if (!refsResponse.data) {
      const notFoundError = notFound(refsResponse)
      metricsGetLoyaltyPageRefs.noDataError()
      throw notFoundError
    }

    const validatedLoyaltyPageRefs = loyaltyPageRefsSchema.safeParse(
      refsResponse.data
    )
    if (!validatedLoyaltyPageRefs.success) {
      metricsGetLoyaltyPageRefs.validationError(validatedLoyaltyPageRefs.error)
      return null
    }

    metricsGetLoyaltyPageRefs.success()

    const connections = getConnections(validatedLoyaltyPageRefs.data)

    const tags = [
      generateTagsFromSystem(lang, connections),
      generateTag(lang, validatedLoyaltyPageRefs.data.loyalty_page.system.uid),
    ].flat()

    const getLoyaltyPageCounter = createCounter(
      "trpc.contentstack",
      "loyaltyPage.get"
    )
    const metricsGetLoyaltyPage = getLoyaltyPageCounter.init({ lang, uid })

    metricsGetLoyaltyPage.start()

    const response = await request<GetLoyaltyPageSchema>(
      GetLoyaltyPage,
      variables,
      {
        key: tags,
        ttl: "max",
      }
    )

    if (!response.data) {
      const notFoundError = notFound(response)
      metricsGetLoyaltyPage.noDataError()
      throw notFoundError
    }

    const validatedLoyaltyPage = loyaltyPageSchema.safeParse(response.data)
    if (!validatedLoyaltyPage.success) {
      metricsGetLoyaltyPage.validationError(validatedLoyaltyPage.error)
      return null
    }

    const loyaltyPage = validatedLoyaltyPage.data.loyalty_page

    const tracking: TrackingPageData = {
      pageId: loyaltyPage.system.uid,
      domainLanguage: lang,
      publishDate: loyaltyPage.system.updated_at,
      createDate: loyaltyPage.system.created_at,
      channel: "scandic-friends",
      pageType: "loyaltycontentpage",
      pageName: validatedLoyaltyPage.data.trackingProps.url,
      siteSections: validatedLoyaltyPage.data.trackingProps.url,
      siteVersion: "new-web",
    }

    metricsGetLoyaltyPage.success()

    // Assert LoyaltyPage type to get correct typings for RTE fields
    return {
      loyaltyPage,
      tracking,
    }
  }),
})