feat(SW-353): dynamic rewards

server/routers/contentstack/index.ts

@@ -7,9 +7,11 @@ import { breadcrumbsRouter } from "./breadcrumbs"
 import { contentPageRouter } from "./contentPage"
 import { hotelPageRouter } from "./hotelPage"
 import { languageSwitcherRouter } from "./languageSwitcher"
+import { loyaltyLevelRouter } from "./loyaltyLevel"
 import { loyaltyPageRouter } from "./loyaltyPage"
 import { metaDataRouter } from "./metadata"
 import { myPagesRouter } from "./myPages"
+import { rewardRouter } from "./reward"
 
 export const contentstackRouter = router({
   accountPage: accountPageRouter,
@@ -22,4 +24,6 @@ export const contentstackRouter = router({
   contentPage: contentPageRouter,
   myPages: myPagesRouter,
   metaData: metaDataRouter,
+  rewards: rewardRouter,
+  loyaltyLevels: loyaltyLevelRouter,
 })

server/routers/contentstack/loyaltyLevel/index.ts

@@ -0,0 +1,5 @@
+import { mergeRouters } from "@/server/trpc"
+
+import { loyaltyLevelQueryRouter } from "./query"
+
+export const loyaltyLevelRouter = mergeRouters(loyaltyLevelQueryRouter)

server/routers/contentstack/loyaltyLevel/input.ts

@@ -0,0 +1,7 @@
+import { z } from "zod"
+
+import { MembershipLevelEnum } from "@/constants/membershipLevels"
+
+export const loyaltyLevelInput = z.object({
+  level: z.nativeEnum(MembershipLevelEnum),
+})

server/routers/contentstack/loyaltyLevel/output.ts

@@ -0,0 +1,24 @@
+import { z } from "zod"
+
+import { MembershipLevelEnum } from "@/constants/membershipLevels"
+
+export const validateLoyaltyLevelsSchema = z
+  .object({
+    all_loyalty_level: z.object({
+      items: z.array(
+        z.object({
+          level_id: z.nativeEnum(MembershipLevelEnum),
+          name: z.string(),
+          user_facing_tag: z.string().optional(),
+          description: z.string().optional(),
+          required_nights: z.number().optional().nullable(),
+          required_points: z.number(),
+        })
+      ),
+    }),
+  })
+  .transform((data) => data.all_loyalty_level.items)
+
+export type LoyaltyLevelsResponse = z.input<typeof validateLoyaltyLevelsSchema>
+
+export type LoyaltyLevel = z.output<typeof validateLoyaltyLevelsSchema>[0]

server/routers/contentstack/loyaltyLevel/query.ts

@@ -0,0 +1,147 @@
+import { metrics } from "@opentelemetry/api"
+
+import {
+  MembershipLevel,
+  MembershipLevelEnum,
+} from "@/constants/membershipLevels"
+import {
+  GetAllLoyaltyLevels,
+  GetLoyaltyLevel,
+} from "@/lib/graphql/Query/LoyaltyLevels.graphql"
+import { request } from "@/lib/graphql/request"
+import { Context } from "@/server/context"
+import { notFound } from "@/server/errors/trpc"
+import { contentstackBaseProcedure, router } from "@/server/trpc"
+
+import { generateLoyaltyConfigTag } from "@/utils/generateTag"
+
+import { loyaltyLevelInput } from "./input"
+import { LoyaltyLevelsResponse, validateLoyaltyLevelsSchema } from "./output"
+
+const meter = metrics.getMeter("trpc.loyaltyLevel")
+// OpenTelemetry metrics: Loyalty Level
+const getAllLoyaltyLevelCounter = meter.createCounter(
+  "trpc.contentstack.loyaltyLevel.all"
+)
+
+const getAllLoyaltyLevelSuccessCounter = meter.createCounter(
+  "trpc.contentstack.loyaltyLevel.all-success"
+)
+const getAllLoyaltyLevelFailCounter = meter.createCounter(
+  "trpc.contentstack.loyaltyLevel.all-fail"
+)
+
+export async function getAllLoyaltyLevels(ctx: Context) {
+  getAllLoyaltyLevelCounter.add(1)
+
+  // Ideally we should fetch all available tiers from API, but since they
+  // are static, we can just use the enum values. We want to know which
+  // levels we are fetching so that we can use tags to cache them
+  const allLevelIds = Object.values(MembershipLevelEnum)
+
+  const tags = allLevelIds.map((levelId) =>
+    generateLoyaltyConfigTag(ctx.lang, "loyalty_level", levelId)
+  )
+
+  const loyaltyLevelsConfigResponse = await request<LoyaltyLevelsResponse>(
+    GetAllLoyaltyLevels,
+    { lang: ctx.lang, level_ids: allLevelIds },
+    { next: { tags }, cache: "force-cache" }
+  )
+
+  if (!loyaltyLevelsConfigResponse.data) {
+    getAllLoyaltyLevelFailCounter.add(1)
+    const notFoundError = notFound(loyaltyLevelsConfigResponse)
+    console.error(
+      "contentstack.loyaltyLevels not found error",
+      JSON.stringify({
+        query: {
+          lang: ctx.lang,
+        },
+        error: { code: notFoundError.code },
+      })
+    )
+    throw notFoundError
+  }
+
+  const validatedLoyaltyLevels = validateLoyaltyLevelsSchema.safeParse(
+    loyaltyLevelsConfigResponse.data
+  )
+  if (!validatedLoyaltyLevels.success) {
+    getAllLoyaltyLevelFailCounter.add(1)
+    console.error(validatedLoyaltyLevels.error)
+    console.error(
+      "contentstack.rewards validation error",
+      JSON.stringify({
+        query: {
+          lang: ctx.lang,
+        },
+        error: validatedLoyaltyLevels.error,
+      })
+    )
+    return []
+  }
+
+  getAllLoyaltyLevelSuccessCounter.add(1)
+  return validatedLoyaltyLevels.data
+}
+
+export async function getLoyaltyLevel(ctx: Context, level_id: MembershipLevel) {
+  getAllLoyaltyLevelCounter.add(1)
+
+  const loyaltyLevelsConfigResponse = await request<LoyaltyLevelsResponse>(
+    GetLoyaltyLevel,
+    { lang: ctx.lang, level_id },
+    {
+      next: {
+        tags: [generateLoyaltyConfigTag(ctx.lang, "loyalty_level", level_id)],
+      },
+      cache: "force-cache",
+    }
+  )
+  if (
+    !loyaltyLevelsConfigResponse.data ||
+    !loyaltyLevelsConfigResponse.data.all_loyalty_level.items.length
+  ) {
+    getAllLoyaltyLevelFailCounter.add(1)
+    const notFoundError = notFound(loyaltyLevelsConfigResponse)
+    console.error(
+      "contentstack.loyaltyLevels not found error",
+      JSON.stringify({
+        query: { lang: ctx.lang, level_id },
+        error: { code: notFoundError.code },
+      })
+    )
+    throw notFoundError
+  }
+
+  const validatedLoyaltyLevels = validateLoyaltyLevelsSchema.safeParse(
+    loyaltyLevelsConfigResponse.data
+  )
+  if (!validatedLoyaltyLevels.success) {
+    getAllLoyaltyLevelFailCounter.add(1)
+    console.error(validatedLoyaltyLevels.error)
+    console.error(
+      "contentstack.rewards validation error",
+      JSON.stringify({
+        query: { lang: ctx.lang, level_id },
+        error: validatedLoyaltyLevels.error,
+      })
+    )
+    return null
+  }
+
+  getAllLoyaltyLevelSuccessCounter.add(1)
+  return validatedLoyaltyLevels.data[0]
+}
+
+export const loyaltyLevelQueryRouter = router({
+  byLevel: contentstackBaseProcedure
+    .input(loyaltyLevelInput)
+    .query(async function ({ ctx, input }) {
+      return getLoyaltyLevel(ctx, input.level)
+    }),
+  all: contentstackBaseProcedure.query(async function ({ ctx }) {
+    return getAllLoyaltyLevels(ctx)
+  }),
+})

server/routers/contentstack/reward/index.ts

@@ -0,0 +1,5 @@
+import { mergeRouters } from "@/server/trpc"
+
+import { rewardQueryRouter } from "./query"
+
+export const rewardRouter = mergeRouters(rewardQueryRouter)

server/routers/contentstack/reward/input.ts

@@ -0,0 +1,19 @@
+import { z } from "zod"
+
+import { Lang } from "@/constants/languages"
+import { MembershipLevelEnum } from "@/constants/membershipLevels"
+
+export const rewardsByLevelInput = z.object({
+  level_id: z.nativeEnum(MembershipLevelEnum),
+  unique: z.boolean().default(false),
+})
+
+export const rewardsAllInput = z
+  .object({ unique: z.boolean() })
+  .default({ unique: false })
+
+export const rewardsCurrentInput = z.object({
+  limit: z.number().min(0).default(3),
+  cursor: z.number().optional().default(0),
+  lang: z.nativeEnum(Lang).optional(),
+})

server/routers/contentstack/reward/output.ts

@@ -0,0 +1,82 @@
+import { z } from "zod"
+
+import { MembershipLevelEnum } from "@/constants/membershipLevels"
+
+export const validateApiRewardSchema = z.object({
+  data: z.array(
+    z
+      .object({
+        title: z.string().optional(),
+        id: z.string().optional(),
+        type: z.string().optional(),
+        status: z.string().optional(),
+        rewardId: z.string().optional(),
+        redeemLocation: z.string().optional(),
+        autoApplyReward: z.boolean().default(false),
+        rewardType: z.string().optional(),
+        rewardTierLevel: z.string().optional(),
+      })
+      .optional()
+  ),
+})
+
+enum TierKey {
+  tier1 = MembershipLevelEnum.L1,
+  tier2 = MembershipLevelEnum.L2,
+  tier3 = MembershipLevelEnum.L3,
+  tier4 = MembershipLevelEnum.L4,
+  tier5 = MembershipLevelEnum.L5,
+  tier6 = MembershipLevelEnum.L6,
+  tier7 = MembershipLevelEnum.L7,
+}
+
+type Key = keyof typeof TierKey
+
+export const validateApiTierRewardsSchema = z.record(
+  z.nativeEnum(TierKey).transform((data) => {
+    return TierKey[data as unknown as Key]
+  }),
+  z.array(
+    z
+      .object({
+        title: z.string().optional(),
+        id: z.string().optional(),
+        type: z.string().optional(),
+        status: z.string().optional(),
+        rewardId: z.string().optional(),
+        redeemLocation: z.string().optional(),
+        autoApplyReward: z.boolean().default(false),
+        rewardType: z.string().optional(),
+        rewardTierLevel: z.string().optional(),
+      })
+      .optional()
+  )
+)
+
+export const validateCmsRewardsSchema = z
+  .object({
+    data: z.object({
+      all_reward: z.object({
+        items: z.array(
+          z.object({
+            taxonomies: z.array(
+              z.object({
+                term_uid: z.string().optional(),
+              })
+            ),
+            label: z.string().optional(),
+            reward_id: z.string(),
+            grouped_label: z.string().optional(),
+            description: z.string().optional(),
+            grouped_description: z.string().optional(),
+            value: z.string().optional(),
+          })
+        ),
+      }),
+    }),
+  })
+  .transform((data) => data.data.all_reward.items)
+
+export type CmsRewardsResponse = z.input<typeof validateCmsRewardsSchema>
+
+export type Reward = z.output<typeof validateCmsRewardsSchema>[0]

server/routers/contentstack/reward/query.ts

@@ -0,0 +1,371 @@
+import { metrics } from "@opentelemetry/api"
+
+import { Lang } from "@/constants/languages"
+import * as api from "@/lib/api"
+import { GetRewards } from "@/lib/graphql/Query/Rewards.graphql"
+import { request } from "@/lib/graphql/request"
+import { Context } from "@/server/context"
+import { notFound } from "@/server/errors/trpc"
+import {
+  contentStackBaseWithProfileServiceProcedure,
+  contentStackBaseWithProtectedProcedure,
+  router,
+} from "@/server/trpc"
+
+import { generateLoyaltyConfigTag } from "@/utils/generateTag"
+
+import { getAllLoyaltyLevels, getLoyaltyLevel } from "../loyaltyLevel/query"
+import {
+  rewardsAllInput,
+  rewardsByLevelInput,
+  rewardsCurrentInput,
+} from "./input"
+import {
+  CmsRewardsResponse,
+  Reward,
+  validateApiRewardSchema,
+  validateApiTierRewardsSchema,
+  validateCmsRewardsSchema,
+} from "./output"
+
+const meter = metrics.getMeter("trpc.reward")
+// OpenTelemetry metrics: Reward
+
+const getCurrentRewardCounter = meter.createCounter(
+  "trpc.contentstack.reward.current"
+)
+const getCurrentRewardSuccessCounter = meter.createCounter(
+  "trpc.contentstack.reward.current-success"
+)
+
+const getCurrentRewardFailCounter = meter.createCounter(
+  "trpc.contentstack.reward.current-fail"
+)
+
+const getByLevelRewardCounter = meter.createCounter(
+  "trpc.contentstack.reward.byLevel"
+)
+const getByLevelRewardSuccessCounter = meter.createCounter(
+  "trpc.contentstack.reward.byLevel-success"
+)
+
+const getByLevelRewardFailCounter = meter.createCounter(
+  "trpc.contentstack.reward.byLevel-fail"
+)
+
+const getAllRewardCounter = meter.createCounter("trpc.contentstack.reward.all")
+
+const getAllRewardSuccessCounter = meter.createCounter(
+  "trpc.contentstack.reward.all-success"
+)
+const getAllRewardFailCounter = meter.createCounter(
+  "trpc.contentstack.reward.all-fail"
+)
+
+function getUniqueRewardIds(rewardIds: string[]) {
+  const uniqueRewardIds = new Set(rewardIds)
+  return Array.from(uniqueRewardIds)
+}
+
+async function getAllApiRewards(ctx: Context & { serviceToken: string }) {
+  const apiResponse = await api.get(api.endpoints.v1.tierRewards, {
+    cache: undefined, // override defaultOptions
+    headers: {
+      Authorization: `Bearer ${ctx.serviceToken}`,
+    },
+    // One hour. Since the service token is refreshed every hour, this is the longest cache we can have.
+    next: { revalidate: 60 * 60 },
+  })
+
+  if (!apiResponse.ok) {
+    const text = await apiResponse.text()
+    getCurrentRewardFailCounter.add(1, {
+      error_type: "http_error",
+      error: JSON.stringify({
+        status: apiResponse.status,
+        statusText: apiResponse.statusText,
+        text,
+      }),
+    })
+    console.error(
+      "api.rewards.tierRewards error ",
+      JSON.stringify({
+        error: {
+          status: apiResponse.status,
+          statusText: apiResponse.statusText,
+          text,
+        },
+      })
+    )
+  }
+
+  const data = await apiResponse.json()
+  const validatedApiTierRewards = validateApiTierRewardsSchema.safeParse(data)
+
+  if (!validatedApiTierRewards.success) {
+    getAllRewardFailCounter.add(1, {
+      error_type: "validation_error",
+      error: JSON.stringify(validatedApiTierRewards.error),
+    })
+    console.error(validatedApiTierRewards.error)
+    console.error(
+      "api.rewards validation error",
+      JSON.stringify({
+        error: validatedApiTierRewards.error,
+      })
+    )
+    return null
+  }
+
+  return validatedApiTierRewards.data
+}
+
+async function getCmsRewards(locale: Lang, rewardIds: string[]) {
+  const tags = rewardIds.map((id) =>
+    generateLoyaltyConfigTag(locale, "reward", id)
+  )
+
+  const cmsRewardsResponse = await request<CmsRewardsResponse>(
+    GetRewards,
+    {
+      locale: locale,
+      rewardIds,
+    },
+    { next: { tags }, cache: "force-cache" }
+  )
+
+  if (!cmsRewardsResponse.data) {
+    getAllRewardFailCounter.add(1, {
+      lang: locale,
+      error_type: "validation_error",
+      error: JSON.stringify(cmsRewardsResponse.data),
+    })
+    const notFoundError = notFound(cmsRewardsResponse)
+    console.error(
+      "contentstack.rewards not found error",
+      JSON.stringify({
+        query: {
+          locale,
+          rewardIds,
+        },
+        error: { code: notFoundError.code },
+      })
+    )
+    throw notFoundError
+  }
+
+  const validatedCmsRewards =
+    validateCmsRewardsSchema.safeParse(cmsRewardsResponse)
+
+  if (!validatedCmsRewards.success) {
+    getAllRewardFailCounter.add(1, {
+      locale,
+      rewardIds,
+      error_type: "validation_error",
+      error: JSON.stringify(validatedCmsRewards.error),
+    })
+    console.error(validatedCmsRewards.error)
+    console.error(
+      "contentstack.rewards validation error",
+      JSON.stringify({
+        query: { locale, rewardIds },
+        error: validatedCmsRewards.error,
+      })
+    )
+    return null
+  }
+
+  return validatedCmsRewards.data
+}
+
+export const rewardQueryRouter = router({
+  current: contentStackBaseWithProtectedProcedure
+    .input(rewardsCurrentInput)
+    .query(async function ({ input, ctx }) {
+      getCurrentRewardCounter.add(1)
+
+      const { limit, cursor } = input
+
+      const apiResponse = await api.get(api.endpoints.v1.rewards, {
+        cache: undefined, // override defaultOptions
+        headers: {
+          Authorization: `Bearer ${ctx.session.token.access_token}`,
+        },
+        next: { revalidate: 60 * 60 },
+      })
+
+      if (!apiResponse.ok) {
+        const text = await apiResponse.text()
+        getCurrentRewardFailCounter.add(1, {
+          error_type: "http_error",
+          error: JSON.stringify({
+            status: apiResponse.status,
+            statusText: apiResponse.statusText,
+            text,
+          }),
+        })
+        console.error(
+          "api.reward error ",
+          JSON.stringify({
+            error: {
+              status: apiResponse.status,
+              statusText: apiResponse.statusText,
+              text,
+            },
+          })
+        )
+        return null
+      }
+
+      const data = await apiResponse.json()
+
+      const validatedApiRewards = validateApiRewardSchema.safeParse(data)
+
+      if (!validatedApiRewards.success) {
+        getCurrentRewardFailCounter.add(1, {
+          locale: ctx.lang,
+          error_type: "validation_error",
+          error: JSON.stringify(validatedApiRewards.error),
+        })
+        console.error(validatedApiRewards.error)
+        console.error(
+          "contentstack.rewards validation error",
+          JSON.stringify({
+            query: { locale: ctx.lang },
+            error: validatedApiRewards.error,
+          })
+        )
+        return null
+      }
+
+      const rewardIds = validatedApiRewards.data.data
+        .map((reward) => reward?.rewardId)
+        .filter(Boolean)
+        .sort() as string[]
+
+      const slicedData = rewardIds.slice(cursor, limit + cursor)
+
+      const cmsRewards = await getCmsRewards(ctx.lang, slicedData)
+
+      if (!cmsRewards) {
+        return null
+      }
+
+      const nextCursor =
+        limit + cursor < rewardIds.length ? limit + cursor : undefined
+
+      getCurrentRewardSuccessCounter.add(1)
+      return {
+        rewards: cmsRewards,
+        nextCursor,
+      }
+    }),
+  byLevel: contentStackBaseWithProfileServiceProcedure
+    .input(rewardsByLevelInput)
+    .query(async function ({ input, ctx }) {
+      getByLevelRewardCounter.add(1)
+      const { level_id } = input
+
+      const allUpcomingApiRewards = await getAllApiRewards(ctx)
+
+      if (!allUpcomingApiRewards || !allUpcomingApiRewards[level_id]) {
+        getByLevelRewardFailCounter.add(1)
+
+        return null
+      }
+
+      let apiRewards = allUpcomingApiRewards[level_id]!
+
+      if (input.unique) {
+        apiRewards = allUpcomingApiRewards[level_id]!.filter(
+          (reward) => reward?.rewardTierLevel === level_id
+        )
+      }
+
+      const rewardIds = apiRewards
+        .map((reward) => reward?.rewardId)
+        .filter((id): id is string => Boolean(id))
+
+      const contentStackRewards = await getCmsRewards(ctx.lang, rewardIds)
+      if (!contentStackRewards) {
+        return null
+      }
+
+      const loyaltyLevelsConfig = await getLoyaltyLevel(ctx, input.level_id)
+
+      const levelsWithRewards = apiRewards
+        .map((reward) => {
+          const contentStackReward = contentStackRewards.find((r) => {
+            return r.reward_id === reward?.rewardId
+          })
+
+          if (contentStackReward) {
+            return contentStackReward
+          } else {
+            console.error("No contentStackReward found", reward?.rewardId)
+          }
+        })
+        .filter((reward): reward is Reward => Boolean(reward))
+
+      getByLevelRewardSuccessCounter.add(1)
+      return { level: loyaltyLevelsConfig, rewards: levelsWithRewards }
+    }),
+  all: contentStackBaseWithProfileServiceProcedure
+    .input(rewardsAllInput)
+    .query(async function ({ input, ctx }) {
+      getAllRewardCounter.add(1)
+      const allApiRewards = await getAllApiRewards(ctx)
+
+      if (!allApiRewards) {
+        return []
+      }
+
+      const rewardIds = Object.values(allApiRewards)
+        .flatMap((level) => level.map((reward) => reward?.rewardId))
+        .filter((id): id is string => Boolean(id))
+
+      const contentStackRewards = await getCmsRewards(
+        ctx.lang,
+        getUniqueRewardIds(rewardIds)
+      )
+
+      if (!contentStackRewards) {
+        return []
+      }
+
+      const loyaltyLevelsConfig = await getAllLoyaltyLevels(ctx)
+      const levelsWithRewards = Object.entries(allApiRewards).map(
+        ([level, rewards]) => {
+          const combinedRewards = rewards
+            .filter((r) => (input.unique ? r?.rewardTierLevel === level : true))
+            .map((reward) => {
+              const contentStackReward = contentStackRewards.find((r) => {
+                return r.reward_id === reward?.rewardId
+              })
+
+              if (contentStackReward) {
+                return contentStackReward
+              } else {
+                console.error("No contentStackReward found", reward?.rewardId)
+              }
+            })
+            .filter((reward): reward is Reward => Boolean(reward))
+
+          const levelConfig = loyaltyLevelsConfig.find(
+            (l) => l.level_id === level
+          )
+
+          if (!levelConfig) {
+            getAllRewardFailCounter.add(1)
+
+            console.error("contentstack.loyaltyLevels level not found")
+            throw notFound()
+          }
+          return { ...levelConfig, rewards: combinedRewards }
+        }
+      )
+
+      getAllRewardSuccessCounter.add(1)
+      return levelsWithRewards
+    }),
+})

server/routers/hotels/query.ts

@@ -11,10 +11,10 @@ import {
 } from "@/server/errors/trpc"
 import { extractHotelImages } from "@/server/routers/utils/hotels"
 import {
-  contentStackUidWithServiceProcedure,
+  contentStackUidWithHotelServiceProcedure,
+  hotelServiceProcedure,
   publicProcedure,
   router,
-  serviceProcedure,
 } from "@/server/trpc"
 import { toApiLang } from "@/server/utils"
 
@@ -83,7 +83,7 @@ async function getContentstackData(
 }
 
 export const hotelQueryRouter = router({
-  get: contentStackUidWithServiceProcedure
+  get: contentStackUidWithHotelServiceProcedure
     .input(getHotelInputSchema)
     .query(async ({ ctx, input }) => {
       const { lang, uid } = ctx
@@ -178,34 +178,34 @@ export const hotelQueryRouter = router({
 
       const roomCategories = included
         ? included
-          .filter((item) => item.type === "roomcategories")
-          .map((roomCategory) => {
-            const validatedRoom = roomSchema.safeParse(roomCategory)
-            if (!validatedRoom.success) {
-              getHotelFailCounter.add(1, {
-                hotelId,
-                lang,
-                include,
-                error_type: "validation_error",
-                error: JSON.stringify(
-                  validatedRoom.error.issues.map(({ code, message }) => ({
-                    code,
-                    message,
-                  }))
-                ),
-              })
-              console.error(
-                "api.hotels.hotel validation error",
-                JSON.stringify({
-                  query: { hotelId, params },
-                  error: validatedRoom.error,
+            .filter((item) => item.type === "roomcategories")
+            .map((roomCategory) => {
+              const validatedRoom = roomSchema.safeParse(roomCategory)
+              if (!validatedRoom.success) {
+                getHotelFailCounter.add(1, {
+                  hotelId,
+                  lang,
+                  include,
+                  error_type: "validation_error",
+                  error: JSON.stringify(
+                    validatedRoom.error.issues.map(({ code, message }) => ({
+                      code,
+                      message,
+                    }))
+                  ),
                 })
-              )
-              throw badRequestError()
-            }
+                console.error(
+                  "api.hotels.hotel validation error",
+                  JSON.stringify({
+                    query: { hotelId, params },
+                    error: validatedRoom.error,
+                  })
+                )
+                throw badRequestError()
+              }
 
-            return validatedRoom.data
-          })
+              return validatedRoom.data
+            })
         : []
 
       const activities = contentstackData?.content
@@ -233,7 +233,7 @@ export const hotelQueryRouter = router({
       }
     }),
   availability: router({
-    get: serviceProcedure
+    get: hotelServiceProcedure
       .input(getAvailabilityInputSchema)
       .query(async ({ input, ctx }) => {
         const {
@@ -395,7 +395,7 @@ export const hotelQueryRouter = router({
       }),
   }),
   hotelData: router({
-    get: serviceProcedure
+    get: hotelServiceProcedure
       .input(getlHotelDataInputSchema)
       .query(async ({ ctx, input }) => {
         const { hotelId, language, include } = input
@@ -493,7 +493,7 @@ export const hotelQueryRouter = router({
       }),
   }),
   locations: router({
-    get: serviceProcedure.query(async function ({ ctx }) {
+    get: hotelServiceProcedure.query(async function ({ ctx }) {
       const searchParams = new URLSearchParams()
       searchParams.set("language", toApiLang(ctx.lang))
 

server/tokenManager.ts

@@ -4,7 +4,9 @@ import { ServiceTokenResponse } from "@/types/tokens"
 
 const SERVICE_TOKEN_REVALIDATE_SECONDS = 3599 // 59 minutes and 59 seconds.
 
-export async function fetchServiceToken(): Promise<ServiceTokenResponse> {
+export async function fetchServiceToken(
+  scopes: string[]
+): Promise<ServiceTokenResponse> {
   try {
     const response = await fetch(`${env.CURITY_ISSUER_USER}/oauth/v2/token`, {
       method: "POST",
@@ -16,7 +18,7 @@ export async function fetchServiceToken(): Promise<ServiceTokenResponse> {
         grant_type: "client_credentials",
         client_id: env.CURITY_CLIENT_ID_SERVICE,
         client_secret: env.CURITY_CLIENT_SECRET_SERVICE,
-        scope: ["hotel"].join(","),
+        scope: scopes.join(","),
       }),
       next: {
         revalidate: SERVICE_TOKEN_REVALIDATE_SECONDS,

server/trpc.ts

@@ -13,6 +13,7 @@ import {
 import { type Context, createContext } from "./context"
 import { fetchServiceToken } from "./tokenManager"
 import { transformer } from "./transformer"
+import { langInput } from "./utils"
 
 import type { Session } from "next-auth"
 
@@ -39,7 +40,19 @@ export const { createCallerFactory, mergeRouters, router } = t
 export const publicProcedure = t.procedure
 export const contentstackBaseProcedure = t.procedure.use(async function (opts) {
   if (!opts.ctx.lang) {
-    throw badRequestError("Missing Lang in tRPC context")
+    // When fetching data client side with TRPC we don't pass through middlewares and therefore do not get the lang through headers
+    // We can then pass lang as an input in the request and set it to the context in the procedure
+    const input = await opts.getRawInput()
+    const parsedInput = langInput.safeParse(input)
+    if (!parsedInput.success) {
+      throw badRequestError("Missing Lang in tRPC context")
+    }
+
+    return opts.next({
+      ctx: {
+        lang: parsedInput.data.lang,
+      },
+    })
   }
 
   return opts.next({
@@ -108,10 +121,10 @@ export const safeProtectedProcedure = t.procedure.use(async function (opts) {
   })
 })
 
-export const serviceProcedure = t.procedure.use(async (opts) => {
-  const { access_token } = await fetchServiceToken()
+export const profileServiceProcedure = t.procedure.use(async (opts) => {
+  const { access_token } = await fetchServiceToken(["profile"])
   if (!access_token) {
-    throw internalServerError("Failed to obtain service token")
+    throw internalServerError("Failed to obtain profile service token")
   }
   return opts.next({
     ctx: {
@@ -120,6 +133,17 @@ export const serviceProcedure = t.procedure.use(async (opts) => {
   })
 })
 
+export const hotelServiceProcedure = t.procedure.use(async (opts) => {
+  const { access_token } = await fetchServiceToken(["hotel"])
+  if (!access_token) {
+    throw internalServerError("Failed to obtain hotel service token")
+  }
+  return opts.next({
+    ctx: {
+      serviceToken: access_token,
+    },
+  })
+})
 export const serverActionProcedure = t.procedure.experimental_caller(
   experimental_nextAppDirCaller({
     createContext,
@@ -149,5 +173,11 @@ export const protectedServerActionProcedure = serverActionProcedure.use(
 
 // NOTE: This is actually save to use, just the implementation could change
 // in minor version bumps. Please read: https://trpc.io/docs/faq#unstable
-export const contentStackUidWithServiceProcedure =
-  contentstackExtendedProcedureUID.unstable_concat(serviceProcedure)
+export const contentStackUidWithHotelServiceProcedure =
+  contentstackExtendedProcedureUID.unstable_concat(hotelServiceProcedure)
+
+export const contentStackBaseWithProfileServiceProcedure =
+  contentstackBaseProcedure.unstable_concat(profileServiceProcedure)
+
+export const contentStackBaseWithProtectedProcedure =
+  contentstackBaseProcedure.unstable_concat(protectedProcedure)