feat: loosen up the zod validations and return null instead of throwing

server/routers/user/mutation.ts

@@ -1,3 +0,0 @@
-/**
- *  Add User mutations
- */

server/routers/user/output.ts

@@ -104,17 +104,17 @@ export const getFriendTransactionsSchema = z.object({
   data: z.array(
     z.object({
       attributes: z.object({
-        hotelOperaId: z.string(),
-        confirmationNumber: z.string(),
-        checkinDate: z.string(),
-        checkoutDate: z.string(),
-        nights: z.number(),
-        awardPoints: z.number(),
-        pointsCalculated: z.boolean(),
+        awardPoints: z.number().default(0),
+        checkinDate: z.string().default(""),
+        checkoutDate: z.string().default(""),
+        confirmationNumber: z.string().default(""),
+        hotelOperaId: z.string().default(""),
+        nights: z.number().default(1),
+        pointsCalculated: z.boolean().default(true),
         hotelInformation: z
           .object({
-            hotelName: z.string(),
-            city: z.string(),
+            city: z.string().default(""),
+            name: z.string().default(""),
             hotelContent: z.object({
               images: z.object({
                 metaData: z.object({
@@ -135,29 +135,28 @@ export const getFriendTransactionsSchema = z.object({
           .optional(),
       }),
       relationships: z.object({
+        booking: z.object({
+          data: z.object({
+            id: z.string().default(""),
+            type: z.string().default(""),
+          }),
+          links: z.object({
+            related: z.string().default(""),
+          }),
+        }),
         hotel: z
           .object({
-            links: z.object({
-              related: z.string(),
-            }),
-
             data: z.object({
-              id: z.string(),
-              type: z.string(),
+              id: z.string().default(""),
+              type: z.string().default(""),
+            }),
+            links: z.object({
+              related: z.string().default(""),
             }),
           })
           .optional(),
-        booking: z.object({
-          links: z.object({
-            related: z.string(),
-          }),
-          data: z.object({
-            id: z.string(),
-            type: z.string(),
-          }),
-        }),
       }),
-      type: z.string(),
+      type: z.string().default(""),
     })
   ),
   links: z
@@ -169,7 +168,3 @@ export const getFriendTransactionsSchema = z.object({
     })
     .nullable(),
 })
-
-type GetFriendTransactionsData = z.infer<typeof getFriendTransactionsSchema>
-
-export type Transaction = GetFriendTransactionsData["data"][number]

server/routers/user/query.ts

@@ -1,11 +1,4 @@
 import * as api from "@/lib/api"
-import {
-  badRequestError,
-  forbiddenError,
-  internalServerError,
-  notFound,
-  unauthorizedError,
-} from "@/server/errors/trpc"
 import { protectedProcedure, router } from "@/server/trpc"
 
 import { friendTransactionsInput, staysInput } from "./input"
@@ -34,26 +27,36 @@ export const userQueryRouter = router({
     })
 
     if (!apiResponse.ok) {
-      switch (apiResponse.status) {
-        case 400:
-          throw badRequestError(apiResponse)
-        case 401:
-          throw unauthorizedError(apiResponse)
-        case 403:
-          throw forbiddenError(apiResponse)
-        default:
-          throw internalServerError(apiResponse)
-      }
+      // switch (apiResponse.status) {
+      //   case 400:
+      //     throw badRequestError(apiResponse)
+      //   case 401:
+      //     throw unauthorizedError(apiResponse)
+      //   case 403:
+      //     throw forbiddenError(apiResponse)
+      //   default:
+      //     throw internalServerError(apiResponse)
+      // }
+      console.info(`API Response Failed - Getting User`)
+      console.info(`User: (${JSON.stringify(ctx.session.user)})`)
+      console.error(apiResponse)
+      return null
     }
 
     const apiJson = await apiResponse.json()
     if (!apiJson.data?.attributes) {
-      throw notFound(apiJson)
+      // throw notFound(apiJson)
+      console.error(
+        `User has no data - (user: ${JSON.stringify(ctx.session.user)})`
+      )
+      return null
     }
 
     const verifiedData = getUserSchema.safeParse(apiJson.data.attributes)
     if (!verifiedData.success) {
-      throw internalServerError(verifiedData.error)
+      console.info(`Failed to validate User - (name: ${ctx.session.user?.name}`)
+      console.error(verifiedData.error)
+      return null
     }
 
     return {
@@ -98,28 +101,35 @@ export const userQueryRouter = router({
         )
 
         if (!apiResponse.ok) {
-          switch (apiResponse.status) {
-            case 400:
-              throw badRequestError(apiResponse)
-            case 401:
-              throw unauthorizedError(apiResponse)
-            case 403:
-              throw forbiddenError(apiResponse)
-            default:
-              throw internalServerError(apiResponse)
-          }
+          // switch (apiResponse.status) {
+          //   case 400:
+          //     throw badRequestError(apiResponse)
+          //   case 401:
+          //     throw unauthorizedError(apiResponse)
+          //   case 403:
+          //     throw forbiddenError(apiResponse)
+          //   default:
+          //     throw internalServerError(apiResponse)
+          // }
+          console.info(`API Response Failed - Getting Previous Stays`)
+          console.info(`User: (${JSON.stringify(ctx.session.user)})`)
+          console.error(apiResponse)
+          return null
         }
 
         const apiJson = await apiResponse.json()
 
         const verifiedData = getStaysSchema.safeParse(apiJson)
         if (!verifiedData.success) {
-          throw internalServerError(verifiedData.error)
+          console.info(`Failed to validate Previous Stays Data`)
+          console.info(`User: (${JSON.stringify(ctx.session.user)})`)
+          console.error(verifiedData.error)
+          return null
         }
 
         const nextCursor =
           verifiedData.data.links &&
-            verifiedData.data.links.offset < verifiedData.data.links.totalCount
+          verifiedData.data.links.offset < verifiedData.data.links.totalCount
             ? verifiedData.data.links.offset
             : undefined
 
@@ -152,27 +162,34 @@ export const userQueryRouter = router({
         )
 
         if (!apiResponse.ok) {
-          switch (apiResponse.status) {
-            case 400:
-              throw badRequestError(apiResponse)
-            case 401:
-              throw unauthorizedError(apiResponse)
-            case 403:
-              throw forbiddenError(apiResponse)
-            default:
-              throw internalServerError(apiResponse)
-          }
+          // switch (apiResponse.status) {
+          //   case 400:
+          //     throw badRequestError(apiResponse)
+          //   case 401:
+          //     throw unauthorizedError(apiResponse)
+          //   case 403:
+          //     throw forbiddenError(apiResponse)
+          //   default:
+          //     throw internalServerError(apiResponse)
+          // }
+          console.info(`API Response Failed - Getting Upcoming Stays`)
+          console.info(`User: (${JSON.stringify(ctx.session.user)})`)
+          console.error(apiResponse)
+          return null
         }
 
         const apiJson = await apiResponse.json()
         const verifiedData = getStaysSchema.safeParse(apiJson)
         if (!verifiedData.success) {
-          throw internalServerError(verifiedData.error)
+          console.info(`Failed to validate Upcoming Stays Data`)
+          console.info(`User: (${JSON.stringify(ctx.session.user)})`)
+          console.error(verifiedData.error)
+          return null
         }
 
         const nextCursor =
           verifiedData.data.links &&
-            verifiedData.data.links.offset < verifiedData.data.links.totalCount
+          verifiedData.data.links.offset < verifiedData.data.links.totalCount
             ? verifiedData.data.links.offset
             : undefined
 
@@ -186,76 +203,70 @@ export const userQueryRouter = router({
     friendTransactions: protectedProcedure
       .input(friendTransactionsInput)
       .query(async (opts) => {
-        try {
-          const { limit, cursor } = opts.input
+        const { limit, cursor } = opts.input
 
-          const params = new URLSearchParams()
-          params.set("limit", limit.toString())
+        const params = new URLSearchParams()
+        params.set("limit", limit.toString())
 
-          if (cursor) {
-            params.set("offset", cursor.toString())
-          }
+        if (cursor) {
+          params.set("offset", cursor.toString())
+        }
 
-          const apiResponse = await api.get(
-            api.endpoints.v1.friendTransactions,
-            {
-              headers: {
-                Authorization: `Bearer ${opts.ctx.session.token.access_token}`,
-              },
+        const apiResponse = await api.get(
+          api.endpoints.v1.friendTransactions,
+          {
+            headers: {
+              Authorization: `Bearer ${opts.ctx.session.token.access_token}`,
             },
-            params
-          )
+          },
+          params
+        )
 
-          if (!apiResponse.ok) {
-            switch (apiResponse.status) {
-              case 400:
-                throw badRequestError()
-              case 401:
-                throw unauthorizedError()
-              case 403:
-                throw forbiddenError()
-              default:
-                throw internalServerError()
-            }
-          }
+        if (!apiResponse.ok) {
+          // switch (apiResponse.status) {
+          //   case 400:
+          //     throw badRequestError()
+          //   case 401:
+          //     throw unauthorizedError()
+          //   case 403:
+          //     throw forbiddenError()
+          //   default:
+          //     throw internalServerError()
+          // }
+          console.info(`API Response Failed - Getting Friend Transactions`)
+          console.info(`User: (${JSON.stringify(opts.ctx.session.user)})`)
+          console.error(apiResponse)
+          return null
+        }
 
-          const apiJson = await apiResponse.json()
-          // const apiJson = friendTransactionsMockJson
+        const apiJson = await apiResponse.json()
+        const verifiedData = getFriendTransactionsSchema.safeParse(apiJson)
+        if (!verifiedData.success) {
+          console.info(`Failed to validate Friend Transactions Data`)
+          console.info(`User: (${JSON.stringify(opts.ctx.session.user)})`)
+          console.error(verifiedData.error)
+          return null
+        }
 
-          if (!apiJson.data?.length) {
-            // throw internalServerError()
-          }
+        const nextCursor =
+          verifiedData.data.links &&
+          verifiedData.data.links.offset < verifiedData.data.links.totalCount
+            ? verifiedData.data.links.offset
+            : undefined
 
-          const verifiedData = getFriendTransactionsSchema.safeParse(apiJson)
-
-          if (!verifiedData.success) {
-            console.info(`Get Friend Transactions - Verified Data Error`)
-            console.error(verifiedData.error)
-            throw badRequestError()
-          }
-
-          const nextCursor =
-            verifiedData.data.links &&
-              verifiedData.data.links.offset < verifiedData.data.links.totalCount
-              ? verifiedData.data.links.offset
-              : undefined
-
-          return {
-            data: verifiedData.data.data.map(({ attributes }) => ({
+        return {
+          data: verifiedData.data.data.map(({ attributes }) => {
+            return {
+              awardPoints: attributes.awardPoints,
               checkinDate: attributes.checkinDate,
               checkoutDate: attributes.checkoutDate,
-              awardPoints: attributes.awardPoints,
-              hotelName: attributes.hotelInformation?.hotelName,
               city: attributes.hotelInformation?.city,
-              nights: attributes.nights,
               confirmationNumber: attributes.confirmationNumber,
-            })),
-            nextCursor,
-          }
-        } catch (error) {
-          console.info(`Get Friend Transactions Error`)
-          console.error(error)
-          throw internalServerError()
+              hotelName: attributes.hotelInformation?.name,
+              nights: attributes.nights,
+            }
+          }),
+          nextCursor,
         }
       }),
   }),