refactor: enhance error handling and streamline data fetching in various routers and schemas

Author: Starefossen

src/lib/signing/sanity.ts

@@ -0,0 +1,68 @@
+import { clientReadUncached } from '@/lib/sanity/client'
+
+export interface SigningContractData {
+  _id: string
+  signatureStatus: string
+  signatureId: string
+  signerEmail: string
+  contractStatus?: string
+  contractSentAt?: string
+  organizerSignedBy?: string
+  organizerSignedAt?: string
+  contractDocument?: {
+    asset?: {
+      url?: string
+    }
+  }
+  sponsor?: {
+    name?: string
+  }
+  tier?: {
+    title?: string
+  }
+  conference?: {
+    _id?: string
+    title?: string
+    startDate?: string
+    city?: string
+    organizer?: string
+    sponsorEmail?: string
+    domains?: string[]
+    socialLinks?: string[]
+    salesNotificationChannel?: string
+  }
+  contactPersons?: Array<{ name?: string; email?: string; isPrimary?: boolean }>
+  contractValue?: number
+  contractCurrency?: string
+}
+
+const SIGNING_CONTRACT_QUERY = `*[_type == "sponsorForConference" && signatureId == $signingToken][0]{
+  _id,
+  signatureStatus,
+  signatureId,
+  signerEmail,
+  contractStatus,
+  contractSentAt,
+  organizerSignedBy,
+  organizerSignedAt,
+  contractDocument{
+    asset->{
+      url
+    }
+  },
+  "sponsor": sponsor->{ name },
+  "tier": tier->{ title },
+  "conference": conference->{ _id, title, startDate, city, organizer, sponsorEmail, domains, socialLinks, salesNotificationChannel },
+  contactPersons[]{ name, email, isPrimary },
+  contractValue,
+  contractCurrency
+}`
+
+export async function getSigningContract(
+  token: string,
+): Promise<SigningContractData | null> {
+  return clientReadUncached.fetch<SigningContractData | null>(
+    SIGNING_CONTRACT_QUERY,
+    { signingToken: token },
+  )
+}

src/lib/sponsor-crm/registration.ts

@@ -6,6 +6,7 @@ import {
 import { getCurrentDateTime } from '@/lib/time'
 import { prepareArrayWithKeys } from '@/lib/sanity/helpers'
 import type { ContactPerson, BillingInfo } from '@/lib/sponsor/types'
+import type { Conference } from '@/lib/conference/types'
 
 export interface RegistrationSponsorInfo {
   _id: string
@@ -274,3 +275,79 @@ export async function completeRegistration(
 export function buildPortalUrl(baseUrl: string, token: string): string {
   return `${baseUrl}/sponsor/portal/${token}`
 }
+
+export interface SfcNotificationData {
+  sponsorName: string
+  tierTitle: string | null
+  contractValue: number | null
+  contractCurrency: string | null
+  conference: Conference | null
+}
+
+export async function getSfcForNotification(
+  sfcId: string,
+): Promise<SfcNotificationData | null> {
+  return clientRead.fetch<SfcNotificationData | null>(
+    `*[_type == "sponsorForConference" && _id == $id][0]{
+      "sponsorName": sponsor->name,
+      "tierTitle": tier->title,
+      contractValue,
+      contractCurrency,
+      "conference": conference->{ ... }
+    }`,
+    { id: sfcId },
+  )
+}
+
+export interface SfcPortalInviteData {
+  _id: string
+  status: string | null
+  registrationToken: string | null
+  registrationComplete: boolean
+  contractStatus: string | null
+  sponsor: { name: string } | null
+  contactPersons: Array<{
+    name: string
+    email: string
+    isPrimary?: boolean
+  }> | null
+  tier: { title: string } | null
+  contractValue: number | null
+  contractCurrency: string | null
+  conference: {
+    title: string
+    city: string | null
+    startDate: string | null
+    organizer: string | null
+    sponsorEmail: string | null
+    socialLinks: string[] | null
+  } | null
+}
+
+export async function getSfcForPortalInvite(
+  sfcId: string,
+): Promise<SfcPortalInviteData | null> {
+  return clientRead.fetch<SfcPortalInviteData | null>(
+    `*[_type == "sponsorForConference" && _id == $id][0]{
+      _id,
+      status,
+      registrationToken,
+      registrationComplete,
+      contractStatus,
+      sponsor->{ name },
+      contactPersons[]{ name, email, isPrimary },
+      tier->{ title },
+      contractValue,
+      contractCurrency,
+      conference->{
+        title,
+        city,
+        startDate,
+        organizer,
+        sponsorEmail,
+        socialLinks
+      }
+    }`,
+    { id: sfcId },
+  )
+}

src/lib/travel-support/sanity.ts

@@ -45,8 +45,8 @@ export async function getTravelSupport(
 
 export async function getTravelSupportById(id: string): Promise<{
   travelSupport:
-    | (TravelSupportWithSpeaker & { expenses: TravelExpense[] })
-    | null
+  | (TravelSupportWithSpeaker & { expenses: TravelExpense[] })
+  | null
   error: Error | null
 }> {
   try {
@@ -382,14 +382,32 @@ export async function updateExpenseStatus(
   }
 }
 
+export async function getTravelExpenseById(
+  expenseId: string,
+): Promise<TravelExpense | null> {
+  return clientRead.fetch<TravelExpense | null>(
+    `*[_type == "travelExpense" && _id == $expenseId][0] {
+      ...,
+      travelSupport
+    }`,
+    { expenseId },
+  )
+}
+
+export async function getTravelExpenseRef(
+  expenseId: string,
+): Promise<{ travelSupport: { _ref: string } } | null> {
+  return clientRead.fetch<{ travelSupport: { _ref: string } } | null>(
+    `*[_type == "travelExpense" && _id == $expenseId][0] { travelSupport }`,
+    { expenseId },
+  )
+}
+
 export async function deleteTravelExpense(
   expenseId: string,
 ): Promise<{ success: boolean; error: Error | null }> {
   try {
-    const expense = await clientRead.fetch<{ travelSupport: { _ref: string } }>(
-      `*[_type == "travelExpense" && _id == $expenseId][0] { travelSupport }`,
-      { expenseId },
-    )
+    const expense = await getTravelExpenseRef(expenseId)
 
     await clientWrite.delete(expenseId)
 

src/server/routers/badge.ts

@@ -52,7 +52,7 @@ export const badgeRouter = router({
         const publicKeyHex = process.env.BADGE_ISSUER_PUBLIC_KEY
         if (!publicKeyHex) {
           throw new TRPCError({
-            code: 'INTERNAL_SERVER_ERROR',
+            code: 'PRECONDITION_FAILED',
             message: 'Public key not configured',
           })
         }

src/server/routers/featured.ts

@@ -48,7 +48,7 @@ export const featuredRouter = router({
 
         throw new TRPCError({
           code: 'INTERNAL_SERVER_ERROR',
-          message: 'Unexpected error getting featured speakers',
+          message: 'Failed to get featured speakers',
           cause: error,
         })
       }
@@ -82,7 +82,7 @@ export const featuredRouter = router({
 
         throw new TRPCError({
           code: 'INTERNAL_SERVER_ERROR',
-          message: 'Unexpected error getting featured talks',
+          message: 'Failed to get featured talks',
           cause: error,
         })
       }
@@ -124,7 +124,7 @@ export const featuredRouter = router({
 
           throw new TRPCError({
             code: 'INTERNAL_SERVER_ERROR',
-            message: 'Unexpected error adding featured speaker',
+            message: 'Failed to add featured speaker',
             cause: error,
           })
         }
@@ -166,7 +166,7 @@ export const featuredRouter = router({
 
           throw new TRPCError({
             code: 'INTERNAL_SERVER_ERROR',
-            message: 'Unexpected error removing featured speaker',
+            message: 'Failed to remove featured speaker',
             cause: error,
           })
         }
@@ -209,7 +209,7 @@ export const featuredRouter = router({
 
           throw new TRPCError({
             code: 'INTERNAL_SERVER_ERROR',
-            message: 'Unexpected error adding featured talk',
+            message: 'Failed to add featured talk',
             cause: error,
           })
         }
@@ -252,7 +252,7 @@ export const featuredRouter = router({
 
           throw new TRPCError({
             code: 'INTERNAL_SERVER_ERROR',
-            message: 'Unexpected error removing featured talk',
+            message: 'Failed to remove featured talk',
             cause: error,
           })
         }
@@ -285,7 +285,7 @@ export const featuredRouter = router({
 
         throw new TRPCError({
           code: 'INTERNAL_SERVER_ERROR',
-          message: 'Unexpected error getting featured content summary',
+          message: 'Failed to get featured content summary',
           cause: error,
         })
       }

src/server/routers/registration.ts

@@ -12,17 +12,18 @@ import {
   completeRegistration,
   generateRegistrationToken,
   buildPortalUrl,
+  getSfcForNotification,
+  getSfcForPortalInvite,
 } from '@/lib/sponsor-crm/registration'
 import type { RegistrationSubmission } from '@/lib/sponsor-crm/registration'
 import {
   logRegistrationComplete,
   logEmailSent,
   logContractStatusChange,
 } from '@/lib/sponsor-crm/activity'
-import { clientReadUncached, clientWrite } from '@/lib/sanity/client'
+import { clientWrite } from '@/lib/sanity/client'
 import { getConferenceForCurrentDomain } from '@/lib/conference/sanity'
 import { notifySponsorRegistrationComplete } from '@/lib/slack/notify'
-import type { Conference } from '@/lib/conference/types'
 
 export const registrationRouter = router({
   validate: publicProcedure
@@ -73,26 +74,7 @@ export const registrationRouter = router({
 
         // Send Slack notification to sales channel
         try {
-          const sfcData = await clientReadUncached.fetch<{
-            sponsorName: string
-            tierTitle: string | null
-            contractValue: number | null
-            contractCurrency: string | null
-            conference: Conference | null
-          }>(
-            `*[_type == "sponsorForConference" && _id == $id][0]{
-              "sponsorName": sponsor->name,
-              "tierTitle": tier->title,
-              contractValue,
-              contractCurrency,
-              "conference": conference->{
-                _id, title, city, country, startDate, endDate,
-                organizer, salesNotificationChannel, domains,
-                socialLinks
-              }
-            }`,
-            { id: sponsorForConferenceId },
-          )
+          const sfcData = await getSfcForNotification(sponsorForConferenceId)
 
           if (sfcData?.conference) {
             await notifySponsorRegistrationComplete(
@@ -120,7 +102,7 @@ export const registrationRouter = router({
 
       if (error || !token) {
         throw new TRPCError({
-          code: 'INTERNAL_SERVER_ERROR',
+          code: 'PRECONDITION_FAILED',
           message: error?.message || 'Failed to generate registration token',
         })
       }
@@ -148,52 +130,7 @@ export const registrationRouter = router({
     )
     .mutation(async ({ input, ctx }) => {
       // Fetch full sponsor + conference data for the email
-      const sfc = await clientReadUncached.fetch<{
-        _id: string
-        status: string | null
-        registrationToken: string | null
-        registrationComplete: boolean
-        contractStatus: string | null
-        sponsor: { name: string } | null
-        contactPersons: Array<{
-          name: string
-          email: string
-          isPrimary?: boolean
-        }> | null
-        tier: { title: string } | null
-        contractValue: number | null
-        contractCurrency: string | null
-        conference: {
-          title: string
-          city: string | null
-          startDate: string | null
-          organizer: string | null
-          sponsorEmail: string | null
-          socialLinks: string[] | null
-        } | null
-      }>(
-        `*[_type == "sponsorForConference" && _id == $id][0]{
-          _id,
-          status,
-          registrationToken,
-          registrationComplete,
-          contractStatus,
-          sponsor->{ name },
-          contactPersons[]{ name, email, isPrimary },
-          tier->{ title },
-          contractValue,
-          contractCurrency,
-          conference->{
-            title,
-            city,
-            startDate,
-            organizer,
-            sponsorEmail,
-            socialLinks
-          }
-        }`,
-        { id: input.sponsorForConferenceId },
-      )
+      const sfc = await getSfcForPortalInvite(input.sponsorForConferenceId)
 
       if (!sfc) {
         throw new TRPCError({