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

import { env } from "@/env/server"
import {
  GetDestinationCountryPage,
  GetDestinationCountryPageRefs,
} from "@/lib/graphql/Query/DestinationCountryPage/DestinationCountryPage.graphql"
import { request } from "@/lib/graphql/request"
import { notFound } from "@/server/errors/trpc"
import { contentStackUidWithServiceProcedure, router } from "@/server/trpc"
import { toApiLang } from "@/server/utils"

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

import { getCitiesByCountry } from "../../hotels/utils"
import {
  destinationCountryPageRefsSchema,
  destinationCountryPageSchema,
} from "./output"
import {
  getDestinationCountryPageCounter,
  getDestinationCountryPageFailCounter,
  getDestinationCountryPageRefsCounter,
  getDestinationCountryPageRefsFailCounter,
  getDestinationCountryPageRefsSuccessCounter,
  getDestinationCountryPageSuccessCounter,
} from "./telemetry"
import { generatePageTags, getCityListDataByCityIdentifier } from "./utils"

import { ApiCountry } from "@/types/enums/country"
import type { RequestOptionsWithOutBody } from "@/types/fetch"
import type {
  GetDestinationCountryPageData,
  GetDestinationCountryPageRefsSchema,
} from "@/types/trpc/routers/contentstack/destinationCountryPage"

export const destinationCountryPageQueryRouter = router({
  get: contentStackUidWithServiceProcedure.query(async ({ ctx }) => {
    const { lang, uid, serviceToken } = ctx
    const apiLang = toApiLang(lang)

    getDestinationCountryPageRefsCounter.add(1, { lang, uid })
    console.info(
      "contentstack.destinationCountryPage.refs start",
      JSON.stringify({ query: { lang, uid } })
    )

    const refsResponse = await request<GetDestinationCountryPageRefsSchema>(
      GetDestinationCountryPageRefs,
      { locale: lang, uid },
      {
        cache: "force-cache",
        next: {
          tags: [generateTag(lang, uid)],
        },
      }
    )

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

    const validatedRefsData = destinationCountryPageRefsSchema.safeParse(
      refsResponse.data
    )
    if (!validatedRefsData.success) {
      getDestinationCountryPageRefsFailCounter.add(1, {
        lang,
        uid: `${uid}`,
        error_type: "validation_error",
        error: JSON.stringify(validatedRefsData.error),
      })
      console.error(
        "contentstack.destinationCountryPage.refs validation error",
        JSON.stringify({ query: { lang, uid }, error: validatedRefsData.error })
      )
      return null
    }
    getDestinationCountryPageRefsSuccessCounter.add(1, { lang, uid: `${uid}` })
    console.info(
      "contentstack.destinationCountryPage.refs success",
      JSON.stringify({ query: { lang, uid } })
    )

    const tags = generatePageTags(validatedRefsData.data, lang)

    getDestinationCountryPageCounter.add(1, { lang, uid: `${uid}` })
    console.info(
      "contentstack.destinationCountryPage start",
      JSON.stringify({
        query: { lang, uid },
      })
    )
    const response = await request<GetDestinationCountryPageData>(
      GetDestinationCountryPage,
      {
        locale: lang,
        uid,
      },
      {
        cache: "force-cache",
        next: {
          tags,
        },
      }
    )
    if (!response.data) {
      const notFoundError = notFound(response)
      getDestinationCountryPageFailCounter.add(1, {
        lang,
        uid: `${uid}`,
        error_type: "not_found",
        error: JSON.stringify({ code: notFoundError.code }),
      })
      console.error(
        "contentstack.destinationCountryPage not found error",
        JSON.stringify({
          query: { lang, uid },
          error: { code: notFoundError.code },
        })
      )
      throw notFoundError
    }

    const validatedResponse = destinationCountryPageSchema.safeParse(
      response.data
    )

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

    const params = new URLSearchParams({
      language: apiLang,
    })
    const options: RequestOptionsWithOutBody = {
      // needs to clear default option as only
      // cache or next.revalidate is permitted
      cache: undefined,
      headers: {
        Authorization: `Bearer ${serviceToken}`,
      },
      next: {
        revalidate: env.CACHE_TIME_HOTELS,
      },
    }
    const selectedCountry =
      validatedResponse.data.destinationCountryPage.destination_settings.country
    const apiCountry = ApiCountry[lang][selectedCountry]
    const cities = await getCitiesByCountry([apiCountry], options, params, lang)

    const publishedCities = cities[apiCountry].filter(
      (city) => city.isPublished
    )

    const cityPages = await Promise.all(
      publishedCities.map(async (city) => {
        if (!city.cityIdentifier) {
          return null
        }

        const data = await getCityListDataByCityIdentifier(
          lang,
          city.cityIdentifier
        )
        return data ? { ...data, cityName: city.name } : null
      })
    )

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

    return {
      ...validatedResponse.data,
      cities: cityPages
        .flat()
        .filter((city): city is NonNullable<typeof city> => !!city),
    }
  }),
})