Merged develop into feat/sw-694-performance

server/routers/contentstack/reward/input.ts

@@ -17,3 +17,7 @@ export const rewardsCurrentInput = z.object({
   cursor: z.number().optional().default(0),
   lang: z.nativeEnum(Lang).optional(),
 })
+
+export const rewardsUpdateInput = z.object({
+  id: z.string(),
+})

server/routers/contentstack/reward/output.ts

@@ -2,24 +2,64 @@ 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()
-  ),
+const Coupon = z.object({
+  code: z.string().optional(),
+  status: z.string().optional(),
+  createdAt: z.string().datetime({ offset: true }).optional(),
+  customer: z.object({
+    id: z.string().optional(),
+  }),
+  name: z.string().optional(),
+  claimedAt: z.string().datetime({ offset: true }).optional(),
+  redeemedAt: z
+    .date({ coerce: true })
+    .optional()
+    .transform((value) => {
+      if (value?.getFullYear() === 1) {
+        return null
+      }
+      return value
+    }),
+  type: z.string().optional(),
+  value: z.number().optional(),
+  pool: z.string().optional(),
+  cfUnwrapped: z.boolean().default(false),
 })
 
+const SurpriseReward = z.object({
+  title: z.string().optional(),
+  id: z.string().optional(),
+  type: z.literal("coupon"),
+  status: z.string().optional(),
+  rewardId: z.string().optional(),
+  redeemLocation: z.string().optional(),
+  autoApplyReward: z.boolean().default(false),
+  rewardType: z.literal("Surprise"),
+  endsAt: z.string().datetime({ offset: true }).optional(),
+  coupons: z.array(Coupon).optional(),
+})
+
+export const validateApiRewardSchema = z
+  .object({
+    data: z.array(
+      z.discriminatedUnion("type", [
+        z.object({
+          title: z.string().optional(),
+          id: z.string().optional(),
+          type: z.literal("custom"),
+          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(),
+        }),
+        SurpriseReward,
+      ])
+    ),
+  })
+  .transform((data) => data.data)
+
 enum TierKey {
   tier1 = MembershipLevelEnum.L1,
   tier2 = MembershipLevelEnum.L2,
@@ -37,19 +77,17 @@ export const validateApiTierRewardsSchema = z.record(
     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()
+    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(),
+    })
   )
 )
 
@@ -77,6 +115,10 @@ export const validateCmsRewardsSchema = z
   })
   .transform((data) => data.data.all_reward.items)
 
+export type ApiReward = z.output<typeof validateApiRewardSchema>[0]
+
+export type SurpriseReward = z.output<typeof SurpriseReward>
+
 export type CmsRewardsResponse = z.input<typeof validateCmsRewardsSchema>
 
 export type Reward = z.output<typeof validateCmsRewardsSchema>[0]

server/routers/contentstack/reward/query.ts

@@ -19,15 +19,19 @@ import {
   rewardsAllInput,
   rewardsByLevelInput,
   rewardsCurrentInput,
+  rewardsUpdateInput,
 } from "./input"
 import {
   CmsRewardsResponse,
   Reward,
+  SurpriseReward,
   validateApiRewardSchema,
   validateApiTierRewardsSchema,
   validateCmsRewardsSchema,
 } from "./output"
 
+import { Surprise } from "@/types/components/blocks/surprises"
+
 const meter = metrics.getMeter("trpc.reward")
 // OpenTelemetry metrics: Reward
 
@@ -242,10 +246,10 @@ export const rewardQueryRouter = router({
         return null
       }
 
-      const rewardIds = validatedApiRewards.data.data
+      const rewardIds = validatedApiRewards.data
         .map((reward) => reward?.rewardId)
-        .filter(Boolean)
-        .sort() as string[]
+        .filter((rewardId): rewardId is string => !!rewardId)
+        .sort()
 
       const slicedData = rewardIds.slice(cursor, limit + cursor)
 
@@ -258,9 +262,21 @@ export const rewardQueryRouter = router({
       const nextCursor =
         limit + cursor < rewardIds.length ? limit + cursor : undefined
 
+      const surprisesIds = validatedApiRewards.data
+        .filter(
+          ({ type, rewardType }) =>
+            type === "coupon" && rewardType === "Surprise"
+        )
+        .map(({ rewardId }) => rewardId)
+
+      const rewards = cmsRewards.filter(
+        (reward) => !surprisesIds.includes(reward.reward_id)
+      )
+
       getCurrentRewardSuccessCounter.add(1)
+
       return {
-        rewards: cmsRewards,
+        rewards,
         nextCursor,
       }
     }),
@@ -374,4 +390,112 @@ export const rewardQueryRouter = router({
       getAllRewardSuccessCounter.add(1)
       return levelsWithRewards
     }),
+  surprises: contentStackBaseWithProtectedProcedure.query(async ({ ctx }) => {
+    getCurrentRewardCounter.add(1)
+
+    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.surprises validation error",
+        JSON.stringify({
+          query: { locale: ctx.lang },
+          error: validatedApiRewards.error,
+        })
+      )
+      return null
+    }
+
+    const rewardIds = validatedApiRewards.data
+      .map((reward) => reward?.rewardId)
+      .filter((rewardId): rewardId is string => !!rewardId)
+      .sort()
+
+    const cmsRewards = await getCmsRewards(ctx.lang, rewardIds)
+
+    if (!cmsRewards) {
+      return null
+    }
+
+    getCurrentRewardSuccessCounter.add(1)
+
+    const surprises =
+      validatedApiRewards.data
+        .filter(
+          (reward): reward is SurpriseReward =>
+            reward?.type === "coupon" && reward?.rewardType === "Surprise"
+        )
+        .map((surprise) => {
+          const reward = cmsRewards.find(
+            ({ reward_id }) => surprise.rewardId === reward_id
+          )
+
+          if (!reward) {
+            return null
+          }
+
+          return {
+            ...reward,
+            id: surprise.id,
+            endsAt: surprise.endsAt,
+          }
+        })
+        .filter((surprise): surprise is Surprise => !!surprise) ?? []
+
+    return surprises
+  }),
+  update: contentStackBaseWithProtectedProcedure
+    .input(rewardsUpdateInput)
+    .mutation(async ({ input, ctx }) => {
+      const response = await Promise.resolve({ ok: true })
+      // const response = await api.post(api.endpoints.v1.rewards, {
+      //   body: {
+      //     ids: [input.id],
+      //   },
+      // })
+      if (!response.ok) {
+        return false
+      }
+
+      return true
+    }),
 })