Merged in feat/SW-1449-destination-page (pull request #1195)

Feat/SW-1449 destination page

* feat(SW-1449): Added destination country page

* feat(SW-1449): added destination city page


Approved-by: Fredrik Thorsson
Approved-by: Matilda Landström

server/routers/contentstack/destinationCountryPage/query.ts

@@ -0,0 +1,180 @@
+import {
+  GetDestinationCountryPage,
+  GetDestinationCountryPageRefs,
+} from "@/lib/graphql/Query/DestinationCountryPage/DestinationCountryPage.graphql"
+import { request } from "@/lib/graphql/request"
+import { notFound } from "@/server/errors/trpc"
+import { contentstackExtendedProcedureUID, router } from "@/server/trpc"
+
+import { generateTag } from "@/utils/generateTag"
+
+import {
+  destinationCountryPageRefsSchema,
+  destinationCountryPageSchema,
+} from "./output"
+import {
+  getDestinationCountryPageCounter,
+  getDestinationCountryPageFailCounter,
+  getDestinationCountryPageRefsCounter,
+  getDestinationCountryPageRefsFailCounter,
+  getDestinationCountryPageRefsSuccessCounter,
+  getDestinationCountryPageSuccessCounter,
+} from "./telemetry"
+
+import {
+  TrackingChannelEnum,
+  type TrackingSDKPageData,
+} from "@/types/components/tracking"
+import type {
+  GetDestinationCountryPageData,
+  GetDestinationCountryPageRefsSchema,
+} from "@/types/trpc/routers/contentstack/destinationCountryPage"
+
+export const destinationCountryPageQueryRouter = router({
+  get: contentstackExtendedProcedureUID.query(async ({ ctx }) => {
+    const { lang, uid } = ctx
+
+    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 } })
+    )
+
+    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: [generateTag(lang, uid)],
+        },
+      }
+    )
+    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 destinationCountryPage = destinationCountryPageSchema.safeParse(
+      response.data
+    )
+
+    if (!destinationCountryPage.success) {
+      getDestinationCountryPageFailCounter.add(1, {
+        lang,
+        uid: `${uid}`,
+        error_type: "validation_error",
+        error: JSON.stringify(destinationCountryPage.error),
+      })
+      console.error(
+        "contentstack.destinationCountryPage validation error",
+        JSON.stringify({
+          query: { lang, uid },
+          error: destinationCountryPage.error,
+        })
+      )
+      return null
+    }
+
+    getDestinationCountryPageSuccessCounter.add(1, { lang, uid: `${uid}` })
+    console.info(
+      "contentstack.destinationCountryPage success",
+      JSON.stringify({
+        query: { lang, uid },
+      })
+    )
+
+    const system = destinationCountryPage.data.destination_country_page.system
+    const tracking: TrackingSDKPageData = {
+      pageId: system.uid,
+      domainLanguage: lang,
+      publishDate: system.updated_at,
+      createDate: system.created_at,
+      channel: TrackingChannelEnum["destination-page"],
+      pageType: "staticcontentpage",
+      pageName: destinationCountryPage.data.trackingProps.url,
+      siteSections: destinationCountryPage.data.trackingProps.url,
+      siteVersion: "new-web",
+    }
+
+    return {
+      destinationCountryPage:
+        destinationCountryPage.data.destination_country_page,
+      tracking,
+    }
+  }),
+})