web/server/routers/contentstack/hotelPage/utils.ts

import { GetHotelPageRefs } from "@/lib/graphql/Query/HotelPage/HotelPage.graphql"
import { GetHotelPageUrl } from "@/lib/graphql/Query/HotelPage/HotelPageUrl.graphql"
import { request } from "@/lib/graphql/request"
import { notFound } from "@/server/errors/trpc"

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

import { hotelPageRefsSchema, hotelPageUrlSchema } from "./output"
import {
  getHotelPageRefsCounter,
  getHotelPageRefsFailCounter,
  getHotelPageRefsSuccessCounter,
  getHotelPageUrlCounter,
  getHotelPageUrlFailCounter,
  getHotelPageUrlSuccessCounter,
} from "./telemetry"

import { HotelPageEnum } from "@/types/enums/hotelPage"
import type { System } from "@/types/requests/system"
import type {
  GetHotelPageRefsSchema,
  GetHotelPageUrlData,
  HotelPageRefs,
} from "@/types/trpc/routers/contentstack/hotelPage"
import type { Lang } from "@/constants/languages"

export async function fetchHotelPageRefs(lang: Lang, uid: string) {
  getHotelPageRefsCounter.add(1, { lang, uid })
  console.info(
    "contentstack.hotelPage.refs start",
    JSON.stringify({
      query: { lang, uid },
    })
  )

  const refsResponse = await request<GetHotelPageRefsSchema>(
    GetHotelPageRefs,
    { locale: lang, uid },
    {
      cache: "force-cache",
      next: {
        tags: [generateTag(lang, uid)],
      },
    }
  )
  if (!refsResponse.data) {
    const notFoundError = notFound(refsResponse)
    getHotelPageRefsFailCounter.add(1, {
      lang,
      uid,
      error_type: "http_error",
      error: JSON.stringify({
        code: notFoundError.code,
      }),
    })
    console.error(
      "contentstack.hotelPage.refs not found error",
      JSON.stringify({
        query: {
          lang,
          uid,
        },
        error: { code: notFoundError.code },
      })
    )
    throw notFoundError
  }
  return refsResponse.data
}

export function validateHotelPageRefs(
  data: GetHotelPageRefsSchema,
  lang: Lang,
  uid: string
) {
  const validatedData = hotelPageRefsSchema.safeParse(data)
  if (!validatedData.success) {
    getHotelPageRefsFailCounter.add(1, {
      lang,
      uid,
      error_type: "validation_error",
      error: JSON.stringify(validatedData.error),
    })
    console.error(
      "contentstack.hotelPage.refs validation error",
      JSON.stringify({
        query: { lang, uid },
        error: validatedData.error,
      })
    )
    return null
  }
  getHotelPageRefsSuccessCounter.add(1, { lang, uid })
  console.info(
    "contentstack.hotelPage.refs success",
    JSON.stringify({
      query: { lang, uid },
    })
  )

  return validatedData.data
}

export function generatePageTags(
  validatedData: HotelPageRefs,
  lang: Lang
): string[] {
  const connections = getConnections(validatedData)
  return [
    generateTagsFromSystem(lang, connections),
    generateTag(lang, validatedData.hotel_page.system.uid),
  ].flat()
}

export function getConnections({ hotel_page }: HotelPageRefs) {
  const connections: System["system"][] = [hotel_page.system]
  if (hotel_page.content) {
    hotel_page.content.forEach((block) => {
      switch (block.__typename) {
        case HotelPageEnum.ContentStack.blocks.ActivitiesCard: {
          if (block.upcoming_activities_card.length) {
            connections.push(...block.upcoming_activities_card)
          }
          break
        }
      }
      if (hotel_page.faq) {
        connections.push(...hotel_page.faq)
      }
    })
  }
  return connections
}

export async function getHotelPageUrl(lang: Lang, hotelId: string) {
  getHotelPageUrlCounter.add(1, { lang, hotelId })
  console.info(
    "contentstack.hotelPageUrl start",
    JSON.stringify({ query: { lang, hotelId } })
  )
  const response = await request<GetHotelPageUrlData>(
    GetHotelPageUrl,
    {
      locale: lang,
      hotelId,
    },
    {
      cache: "force-cache",
      next: {
        tags: [generateHotelUrlTag(lang, hotelId)],
      },
    }
  )

  if (!response.data) {
    getHotelPageUrlFailCounter.add(1, {
      lang,
      hotelId,
      error_type: "not_found",
      error: `Hotel page not found for hotelId: ${hotelId}`,
    })
    console.error(
      "contentstack.hotelPageUrl not found error",
      JSON.stringify({ query: { lang, hotelId } })
    )
    return null
  }

  const validatedHotelPageUrl = hotelPageUrlSchema.safeParse(response.data)

  if (!validatedHotelPageUrl.success) {
    getHotelPageUrlFailCounter.add(1, {
      lang,
      hotelId,
      error_type: "validation_error",
      error: JSON.stringify(validatedHotelPageUrl.error),
    })
    console.error(
      "contentstack.hotelPageUrl validation error",
      JSON.stringify({
        query: { lang, hotelId },
        error: validatedHotelPageUrl.error,
      })
    )
    return null
  }
  getHotelPageUrlSuccessCounter.add(1, { lang, hotelId })
  console.info(
    "contentstack.hotelPageUrl success",
    JSON.stringify({ query: { lang, hotelId } })
  )

  return validatedHotelPageUrl.data
}