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

import {
  GetStartPage,
  GetStartPageRefs,
} from "@/lib/graphql/Query/StartPage/StartPage.graphql"
import { request } from "@/lib/graphql/request"
import { notFound } from "@/server/errors/trpc"
import { contentstackExtendedProcedureUID, router } from "@/server/trpc"

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

import { startPageRefsSchema, startPageSchema } from "./output"
import {
  getStartPageCounter,
  getStartPageFailCounter,
  getStartPageRefsCounter,
  getStartPageRefsFailCounter,
  getStartPageRefsSuccessCounter,
  getStartPageSuccessCounter,
} from "./telemetry"
import { getConnections } from "./utils"

import {
  TrackingChannelEnum,
  type TrackingSDKPageData,
} from "@/types/components/tracking"
import { BlocksEnums } from "@/types/enums/blocks"
import type {
  GetStartPageData,
  GetStartPageRefsSchema,
} from "@/types/trpc/routers/contentstack/startPage"

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

    getStartPageRefsCounter.add(1, { lang, uid: `${uid}` })
    console.info(
      "contentstack.startPage.refs start",
      JSON.stringify({
        query: { lang, uid },
      })
    )
    const refsResponse = await request<GetStartPageRefsSchema>(
      GetStartPageRefs,
      {
        locale: lang,
        uid,
      },
      {
        cache: "force-cache",
        next: {
          tags: [generateTag(lang, uid)],
        },
      }
    )
    if (!refsResponse.data) {
      const notFoundError = notFound(refsResponse)
      getStartPageRefsFailCounter.add(1, {
        lang,
        uid,
        error_type: "not_found",
        error: JSON.stringify({ code: notFoundError.code }),
      })
      console.error(
        "contentstack.startPage.refs not found error",
        JSON.stringify({
          query: { lang, uid },
          error: { code: notFoundError.code },
        })
      )
      throw notFoundError
    }

    const validatedRefsData = startPageRefsSchema.safeParse(refsResponse.data)

    if (!validatedRefsData.success) {
      getStartPageRefsFailCounter.add(1, {
        lang,
        uid,
        error_type: "validation_error",
        error: JSON.stringify(validatedRefsData.error),
      })
      console.error(
        "contentstack.startPage.refs validation error",
        JSON.stringify({
          query: { lang, uid },
          error: validatedRefsData.error,
        })
      )
      return null
    }

    getStartPageRefsSuccessCounter.add(1, { lang, uid: `${uid}` })
    console.info(
      "contentstack.startPage.refs success",
      JSON.stringify({
        query: { lang, uid },
      })
    )

    getStartPageCounter.add(1, { lang, uid: `${uid}` })
    console.info(
      "contentstack.startPage start",
      JSON.stringify({
        query: { lang, uid },
      })
    )

    const connections = getConnections(validatedRefsData.data)

    const tags = [
      generateTagsFromSystem(lang, connections),
      generateTag(lang, validatedRefsData.data.start_page.system.uid),
    ].flat()
    const response = await request<GetStartPageData>(
      GetStartPage,
      {
        locale: lang,
        uid,
      },
      {
        cache: "force-cache",
        next: {
          tags,
        },
      }
    )

    if (!response.data) {
      const notFoundError = notFound(response)
      getStartPageFailCounter.add(1, {
        lang,
        uid: `${uid}`,
        error_type: "not_found",
        error: JSON.stringify({ code: notFoundError.code }),
      })
      console.error(
        "contentstack.startPage not found error",
        JSON.stringify({
          query: { lang, uid },
          error: { code: notFoundError.code },
        })
      )
      throw notFoundError
    }

    const startPage = startPageSchema.safeParse(response.data)

    if (!startPage.success) {
      getStartPageFailCounter.add(1, {
        lang,
        uid: `${uid}`,
        error_type: "validation_error",
        error: JSON.stringify(startPage.error),
      })
      console.error(
        "contentstack.startPage validation error",
        JSON.stringify({
          query: { lang, uid },
          error: startPage.error,
        })
      )
      return null
    }

    getStartPageSuccessCounter.add(1, { lang, uid: `${uid}` })
    console.info(
      "contentstack.startPage success",
      JSON.stringify({
        query: { lang, uid },
      })
    )

    const system = startPage.data.start_page.system
    const tracking: TrackingSDKPageData = {
      pageId: system.uid,
      domainLanguage: lang,
      publishDate: system.updated_at,
      createDate: system.created_at,
      channel: TrackingChannelEnum["start-page"],
      pageType: "start-page",
      pageName: startPage.data.trackingProps.url,
      siteSections: startPage.data.trackingProps.url,
      siteVersion: "new-web",
    }

    const session = await ctx.auth()

    return {
      startPage: {
        ...startPage.data.start_page,
        blocks: startPage.data.start_page.blocks.filter((block) => {
          if (
            block.typename === BlocksEnums.block.JoinScandicFriends &&
            session
          ) {
            return null
          }
          return block
        }),
      },
      tracking,
    }
  }),
})