Merged in feat/sw-2863-move-contentstack-router-to-trpc-package (pull request #2389)

feat(SW-2863): Move contentstack router to trpc package

* Add exports to packages and lint rule to prevent relative imports

* Add env to trpc package

* Add eslint to trpc package

* Apply lint rules

* Use direct imports from trpc package

* Add lint-staged config to trpc

* Move lang enum to common

* Restructure trpc package folder structure

* WIP first step

* update internal imports in trpc

* Fix most errors in scandic-web

Just 100 left...

* Move Props type out of trpc

* Fix CategorizedFilters types

* Move more schemas in hotel router

* Fix deps

* fix getNonContentstackUrls

* Fix import error

* Fix entry error handling

* Fix generateMetadata metrics

* Fix alertType enum

* Fix duplicated types

* lint:fix

* Merge branch 'master' into feat/sw-2863-move-contentstack-router-to-trpc-package

* Fix broken imports

* Merge branch 'master' into feat/sw-2863-move-contentstack-router-to-trpc-package


Approved-by: Linus Flood

packages/trpc/lib/routers/contentstack/hotelPage/output.ts

@@ -0,0 +1,152 @@
+import { z } from "zod"
+
+import { removeMultipleSlashes } from "@scandic-hotels/common/utils/url"
+
+import { HotelPageEnum } from "../../../types/hotelPageEnum"
+import { discriminatedUnionArray } from "../../../utils/discriminatedUnion"
+import {
+  activitiesCardRefSchema,
+  activitiesCardSchema,
+} from "../schemas/blocks/activitiesCard"
+import { hotelFaqRefsSchema, hotelFaqSchema } from "../schemas/blocks/hotelFaq"
+import { spaPageRefSchema, spaPageSchema } from "../schemas/blocks/spaPage"
+import { systemSchema } from "../schemas/system"
+
+import type { ActivitiesCard, SpaPage } from "../../../types/hotelPage"
+
+const contentBlockActivities = z
+  .object({
+    __typename: z.literal(HotelPageEnum.ContentStack.blocks.ActivitiesCard),
+  })
+  .merge(activitiesCardSchema)
+
+const contentBlockSpaPage = z
+  .object({
+    __typename: z.literal(HotelPageEnum.ContentStack.blocks.SpaPage),
+  })
+  .merge(spaPageSchema)
+
+export const contentBlock = z.discriminatedUnion("__typename", [
+  contentBlockActivities,
+  contentBlockSpaPage,
+])
+
+export const hotelPageSchema = z.object({
+  hotel_page: z
+    .object({
+      hotel_navigation: z
+        .object({
+          overview: z.string().nullish(),
+          rooms: z.string().nullish(),
+          restaurant_bar: z.string().nullish(),
+          conferences_meetings: z.string().nullish(),
+          health_wellness: z.string().nullish(),
+          activities: z.string().nullish(),
+          offers: z.string().nullish(),
+          faq: z.string().nullish(),
+        })
+        .nullish(),
+      content: discriminatedUnionArray(contentBlock.options)
+        .nullable()
+        .transform((data) => {
+          let spaPage: SpaPage | undefined
+          let activitiesCards: ActivitiesCard[] = []
+
+          data?.map((block) => {
+            switch (block.typename) {
+              case HotelPageEnum.ContentStack.blocks.ActivitiesCard:
+                activitiesCards.push(block)
+                break
+              case HotelPageEnum.ContentStack.blocks.SpaPage:
+                spaPage = block
+                break
+              default:
+                break
+            }
+          })
+          return { spaPage, activitiesCards }
+        }),
+      faq: hotelFaqSchema.nullable(),
+      hotel_page_id: z.string(),
+      title: z.string(),
+      url: z.string(),
+      system: systemSchema.merge(
+        z.object({
+          created_at: z.string(),
+          updated_at: z.string(),
+        })
+      ),
+    })
+    .transform(({ hotel_navigation, ...rest }) => ({
+      sectionHeadings: hotel_navigation,
+      ...rest,
+    })),
+})
+
+/** REFS */
+const hotelPageActivitiesCardRefs = z
+  .object({
+    __typename: z.literal(HotelPageEnum.ContentStack.blocks.ActivitiesCard),
+  })
+  .merge(activitiesCardRefSchema)
+
+const hotelPageSpaPageRefs = z
+  .object({
+    __typename: z.literal(HotelPageEnum.ContentStack.blocks.SpaPage),
+  })
+  .merge(spaPageRefSchema)
+
+const hotelPageBlockRefsItem = z.discriminatedUnion("__typename", [
+  hotelPageActivitiesCardRefs,
+  hotelPageSpaPageRefs,
+])
+
+export const hotelPageRefsSchema = z.object({
+  hotel_page: z.object({
+    content: discriminatedUnionArray(hotelPageBlockRefsItem.options).nullable(),
+    faq: hotelFaqRefsSchema.nullable(),
+    system: systemSchema,
+  }),
+  trackingProps: z.object({
+    url: z.string(),
+  }),
+})
+
+export const hotelPageUrlsSchema = z
+  .object({
+    all_hotel_page: z.object({
+      items: z.array(
+        z
+          .object({
+            url: z.string(),
+            hotel_page_id: z.string(),
+            system: systemSchema,
+          })
+          .transform((data) => {
+            return {
+              url: removeMultipleSlashes(`/${data.system.locale}/${data.url}`),
+              hotelId: data.hotel_page_id,
+            }
+          })
+      ),
+    }),
+  })
+  .transform(({ all_hotel_page }) => all_hotel_page.items)
+
+export const batchedHotelPageUrlsSchema = z
+  .array(
+    z.object({
+      data: hotelPageUrlsSchema,
+    })
+  )
+  .transform((allItems) => {
+    return allItems.flatMap((item) => item.data)
+  })
+
+export const hotelPageCountSchema = z
+  .object({
+    all_hotel_page: z.object({
+      total: z.number(),
+    }),
+  })
+  .transform(({ all_hotel_page }) => all_hotel_page.total)