fix(SW-696): add unwrap to surprises

add animations to sliding cards

various minor fixes

server/routers/contentstack/reward/input.ts

@@ -18,6 +18,9 @@ export const rewardsCurrentInput = z.object({
   lang: z.nativeEnum(Lang).optional(),
 })
 
-export const rewardsUpdateInput = z.object({
-  id: z.string(),
-})
+export const rewardsUpdateInput = z.array(
+  z.object({
+    rewardId: z.string(),
+    couponCode: z.string(),
+  })
+)

server/routers/contentstack/reward/query.ts

@@ -4,6 +4,7 @@ import { notFound } from "@/server/errors/trpc"
 import {
   contentStackBaseWithProtectedProcedure,
   contentStackBaseWithServiceProcedure,
+  protectedProcedure,
   router,
 } from "@/server/trpc"
 
@@ -16,7 +17,6 @@ import {
 } from "./input"
 import {
   Reward,
-  SurpriseReward,
   validateApiRewardSchema,
   validateCategorizedRewardsSchema,
 } from "./output"
@@ -36,8 +36,6 @@ import {
   getUniqueRewardIds,
 } from "./utils"
 
-import { Surprise } from "@/types/components/blocks/surprises"
-
 const ONE_HOUR = 60 * 60
 
 export const rewardQueryRouter = router({
@@ -327,42 +325,84 @@ export const rewardQueryRouter = router({
 
     getCurrentRewardSuccessCounter.add(1)
 
-    const surprises =
-      validatedApiRewards.data
-        .filter(
-          (reward): reward is SurpriseReward =>
-            reward?.type === "coupon" && reward?.rewardType === "Surprise"
+    const surprises = validatedApiRewards.data
+      // TODO: Add predicates once legacy endpoints are removed
+      .filter((reward) => {
+        if (reward?.rewardType !== "Surprise") {
+          return false
+        }
+
+        if (!("coupon" in reward)) {
+          return false
+        }
+
+        const unwrappedCoupons =
+          reward.coupon?.filter((coupon) => !coupon.unwrapped) || []
+        if (unwrappedCoupons.length === 0) {
+          return false
+        }
+
+        return true
+      })
+      .map((surprise) => {
+        const reward = cmsRewards.find(
+          ({ reward_id }) => surprise.rewardId === reward_id
         )
-        .map((surprise) => {
-          const reward = cmsRewards.find(
-            ({ reward_id }) => surprise.rewardId === reward_id
-          )
 
-          if (!reward) {
-            return null
-          }
+        if (!reward) {
+          return null
+        }
 
-          return {
-            ...reward,
-            id: surprise.id,
-            endsAt: surprise.endsAt,
-          }
-        })
-        .filter((surprise): surprise is Surprise => !!surprise) ?? []
+        return {
+          ...reward,
+          id: surprise.id,
+          coupons: "coupon" in surprise ? surprise.coupon || [] : [],
+        }
+      })
+      .flatMap((surprises) => (surprises ? [surprises] : []))
 
     return surprises
   }),
-  update: contentStackBaseWithProtectedProcedure
+  unwrap: protectedProcedure
     .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
+      const promises = input.map(({ rewardId, couponCode }) => {
+        return api.post(api.endpoints.v1.Profile.Reward.unwrap, {
+          body: {
+            rewardId,
+            couponCode,
+          },
+          headers: {
+            Authorization: `Bearer ${ctx.session.token.access_token}`,
+          },
+        })
+      })
+
+      const responses = await Promise.all(promises)
+
+      const errors = await Promise.all(
+        responses.map(async (apiResponse) => {
+          if (!apiResponse.ok) {
+            const text = await apiResponse.text()
+            console.error(
+              "contentstack.unwrap validation error",
+              JSON.stringify({
+                error: {
+                  status: apiResponse.status,
+                  statusText: apiResponse.statusText,
+                  text,
+                },
+                query: {},
+              })
+            )
+            return false
+          }
+          return true
+        })
+      )
+
+      if (errors.filter((ok) => !ok).length > 0) {
+        return null
       }
 
       return true