@devwithbobby/loops 0.1.12 → 0.1.14

package/src/component/lib.ts

@@ -1,29 +1,10 @@
 import { z } from "zod";
+import { internalLib } from "../types";
 import { za, zm, zq } from "../utils.js";
-import { internal } from "./_generated/api";
+import type { Doc } from "./_generated/dataModel.js";
+import { loopsFetch, sanitizeLoopsError } from "./helpers";
 import { contactValidator } from "./validators.js";
 
-const LOOPS_API_BASE_URL = "https://app.loops.so/api/v1";
-
-/**
- * Sanitize error messages to avoid leaking sensitive information
- */
-const sanitizeError = (status: number, errorText: string): Error => {
-	if (status === 401 || status === 403) {
-		return new Error("Authentication failed. Please check your API key.");
-	}
-	if (status === 404) {
-		return new Error("Resource not found.");
-	}
-	if (status === 429) {
-		return new Error("Rate limit exceeded. Please try again later.");
-	}
-	if (status >= 500) {
-		return new Error("Loops service error. Please try again later.");
-	}
-	return new Error(`Loops API error (${status}). Please try again.`);
-};
-
 /**
  * Internal mutation to store/update a contact in the database
  */
@@ -112,22 +93,24 @@ export const logEmailOperation = zm({
 	}),
 	returns: z.void(),
 	handler: async (ctx, args) => {
-		const operationData: Record<string, any> = {
+		const operationData: Omit<
+			Doc<"emailOperations">,
+			"_id" | "_creationTime"
+		> = {
 			operationType: args.operationType,
 			email: args.email,
 			timestamp: Date.now(),
 			success: args.success,
+			actorId: args.actorId,
+			transactionalId: args.transactionalId,
+			campaignId: args.campaignId,
+			loopId: args.loopId,
+			eventName: args.eventName,
+			messageId: args.messageId,
+			metadata: args.metadata,
 		};
 
-		if (args.actorId) operationData.actorId = args.actorId;
-		if (args.transactionalId) operationData.transactionalId = args.transactionalId;
-		if (args.campaignId) operationData.campaignId = args.campaignId;
-		if (args.loopId) operationData.loopId = args.loopId;
-		if (args.eventName) operationData.eventName = args.eventName;
-		if (args.messageId) operationData.messageId = args.messageId;
-		if (args.metadata) operationData.metadata = args.metadata;
-
-		await ctx.db.insert("emailOperations", operationData as any);
+		await ctx.db.insert("emailOperations", operationData);
 	},
 });
 
@@ -143,7 +126,7 @@ export const countContacts = zq({
 	}),
 	returns: z.number(),
 	handler: async (ctx, args) => {
-		let contacts;
+		let contacts: Doc<"contacts">[];
 		if (args.userGroup !== undefined) {
 			contacts = await ctx.db
 				.query("contacts")
@@ -212,8 +195,8 @@ export const listContacts = zq({
 		hasMore: z.boolean(),
 	}),
 	handler: async (ctx, args) => {
-		let allContacts;
-		
+		let allContacts: Doc<"contacts">[];
+
 		// Get all contacts matching the filters
 		if (args.userGroup !== undefined) {
 			allContacts = await ctx.db
@@ -249,7 +232,12 @@ export const listContacts = zq({
 		allContacts.sort((a, b) => b.createdAt - a.createdAt);
 
 		const total = allContacts.length;
-		const paginatedContacts = allContacts.slice(args.offset, args.offset + args.limit);
+		const paginatedContacts = allContacts
+			.slice(args.offset, args.offset + args.limit)
+			.map((contact) => ({
+				...contact,
+				subscribed: contact.subscribed ?? true, // Ensure subscribed is always boolean
+			}));
 		const hasMore = args.offset + args.limit < total;
 
 		return {
@@ -277,58 +265,57 @@ export const addContact = za({
 		id: z.string().optional(),
 	}),
 	handler: async (ctx, args) => {
-		const response = await fetch(`${LOOPS_API_BASE_URL}/contacts/create`, {
+		const createResponse = await loopsFetch(args.apiKey, "/contacts/create", {
 			method: "POST",
-			headers: {
-				Authorization: `Bearer ${args.apiKey}`,
-				"Content-Type": "application/json",
-			},
-			body: JSON.stringify(args.contact),
+			json: args.contact,
 		});
 
-		if (!response.ok) {
-			const errorText = await response.text();
-			
-			if (response.status === 409) {
-				console.log(`Contact ${args.contact.email} already exists, updating instead`);
-				
-				const findResponse = await fetch(
-					`${LOOPS_API_BASE_URL}/contacts/find?email=${encodeURIComponent(args.contact.email)}`,
-					{
-						method: "GET",
-						headers: {
-							Authorization: `Bearer ${args.apiKey}`,
-							"Content-Type": "application/json",
-						},
-					}
+		if (!createResponse.ok) {
+			const errorText = await createResponse.text();
+
+			if (createResponse.status === 409) {
+				console.log(
+					`Contact ${args.contact.email} already exists, updating instead`,
+				);
+
+				const findResponse = await loopsFetch(
+					args.apiKey,
+					`/contacts/find?email=${encodeURIComponent(args.contact.email)}`,
+					{ method: "GET" },
 				);
 
 				if (!findResponse.ok) {
 					const findErrorText = await findResponse.text();
-					console.error(`Failed to find existing contact [${findResponse.status}]:`, findErrorText);
+					console.error(
+						`Failed to find existing contact [${findResponse.status}]:`,
+						findErrorText,
+					);
 				}
 
-				const updateResponse = await fetch(`${LOOPS_API_BASE_URL}/contacts/update`, {
-					method: "PUT",
-					headers: {
-						Authorization: `Bearer ${args.apiKey}`,
-						"Content-Type": "application/json",
+				const updateResponse = await loopsFetch(
+					args.apiKey,
+					"/contacts/update",
+					{
+						method: "PUT",
+						json: {
+							email: args.contact.email,
+							firstName: args.contact.firstName,
+							lastName: args.contact.lastName,
+							userId: args.contact.userId,
+							source: args.contact.source,
+							subscribed: args.contact.subscribed,
+							userGroup: args.contact.userGroup,
+						},
 					},
-					body: JSON.stringify({
-						email: args.contact.email,
-						firstName: args.contact.firstName,
-						lastName: args.contact.lastName,
-						userId: args.contact.userId,
-						source: args.contact.source,
-						subscribed: args.contact.subscribed,
-						userGroup: args.contact.userGroup,
-					}),
-				});
+				);
 
 				if (!updateResponse.ok) {
 					const updateErrorText = await updateResponse.text();
-					console.error(`Loops API error [${updateResponse.status}]:`, updateErrorText);
-					throw sanitizeError(updateResponse.status, updateErrorText);
+					console.error(
+						`Loops API error [${updateResponse.status}]:`,
+						updateErrorText,
+					);
+					throw sanitizeLoopsError(updateResponse.status, updateErrorText);
 				}
 
 				// Get contact ID if available
@@ -339,7 +326,7 @@ export const addContact = za({
 				}
 
 				// Store/update in our database
-				await ctx.runMutation(((internal as any).lib).storeContact as any, {
+				await ctx.runMutation(internalLib.storeContact, {
 					email: args.contact.email,
 					firstName: args.contact.firstName,
 					lastName: args.contact.lastName,
@@ -356,15 +343,14 @@ export const addContact = za({
 				};
 			}
 
-			// For other errors, throw as normal
-			console.error(`Loops API error [${response.status}]:`, errorText);
-			throw sanitizeError(response.status, errorText);
+			console.error(`Loops API error [${createResponse.status}]:`, errorText);
+			throw sanitizeLoopsError(createResponse.status, errorText);
 		}
 
 		// Contact was created successfully
-		const data = (await response.json()) as { id?: string };
+		const data = (await createResponse.json()) as { id?: string };
 
-		await ctx.runMutation(((internal as any).lib).storeContact as any, {
+		await ctx.runMutation(internalLib.storeContact, {
 			email: args.contact.email,
 			firstName: args.contact.firstName,
 			lastName: args.contact.lastName,
@@ -401,13 +387,9 @@ export const updateContact = za({
 		success: z.boolean(),
 	}),
 	handler: async (ctx, args) => {
-		const response = await fetch(`${LOOPS_API_BASE_URL}/contacts/update`, {
+		const response = await loopsFetch(args.apiKey, "/contacts/update", {
 			method: "PUT",
-			headers: {
-				Authorization: `Bearer ${args.apiKey}`,
-				"Content-Type": "application/json",
-			},
-			body: JSON.stringify({
+			json: {
 				email: args.email,
 				dataVariables: args.dataVariables,
 				firstName: args.firstName,
@@ -416,16 +398,16 @@ export const updateContact = za({
 				source: args.source,
 				subscribed: args.subscribed,
 				userGroup: args.userGroup,
-			}),
+			},
 		});
 
 		if (!response.ok) {
 			const errorText = await response.text();
 			console.error(`Loops API error [${response.status}]:`, errorText);
-			throw sanitizeError(response.status, errorText);
+			throw sanitizeLoopsError(response.status, errorText);
 		}
 
-		await ctx.runMutation(((internal as any).lib).storeContact as any, {
+		await ctx.runMutation(internalLib.storeContact, {
 			email: args.email,
 			firstName: args.firstName,
 			lastName: args.lastName,
@@ -454,35 +436,31 @@ export const sendTransactional = za({
 		messageId: z.string().optional(),
 	}),
 	handler: async (ctx, args) => {
-		const response = await fetch(`${LOOPS_API_BASE_URL}/transactional`, {
+		const response = await loopsFetch(args.apiKey, "/transactional", {
 			method: "POST",
-			headers: {
-				Authorization: `Bearer ${args.apiKey}`,
-				"Content-Type": "application/json",
-			},
-			body: JSON.stringify({
+			json: {
 				transactionalId: args.transactionalId,
 				email: args.email,
 				dataVariables: args.dataVariables,
-			}),
+			},
 		});
 
 		if (!response.ok) {
 			const errorText = await response.text();
 			console.error(`Loops API error [${response.status}]:`, errorText);
-			await ctx.runMutation(((internal as any).lib).logEmailOperation as any, {
+			await ctx.runMutation(internalLib.logEmailOperation, {
 				operationType: "transactional",
 				email: args.email,
 				success: false,
 				transactionalId: args.transactionalId,
 			});
-			
-			throw sanitizeError(response.status, errorText);
+
+			throw sanitizeLoopsError(response.status, errorText);
 		}
 
 		const data = (await response.json()) as { messageId?: string };
 
-		await ctx.runMutation(((internal as any).lib).logEmailOperation as any, {
+		await ctx.runMutation(internalLib.logEmailOperation, {
 			operationType: "transactional",
 			email: args.email,
 			success: true,
@@ -510,24 +488,20 @@ export const sendEvent = za({
 	returns: z.object({
 		success: z.boolean(),
 	}),
-	handler: async (ctx, args) => {
-		const response = await fetch(`${LOOPS_API_BASE_URL}/events/send`, {
+	handler: async (_ctx, args) => {
+		const response = await loopsFetch(args.apiKey, "/events/send", {
 			method: "POST",
-			headers: {
-				Authorization: `Bearer ${args.apiKey}`,
-				"Content-Type": "application/json",
-			},
-			body: JSON.stringify({
+			json: {
 				email: args.email,
 				eventName: args.eventName,
 				eventProperties: args.eventProperties,
-			}),
+			},
 		});
 
 		if (!response.ok) {
 			const errorText = await response.text();
 			console.error(`Loops API error [${response.status}]:`, errorText);
-			throw sanitizeError(response.status, errorText);
+			throw sanitizeLoopsError(response.status, errorText);
 		}
 
 		return { success: true };
@@ -546,22 +520,18 @@ export const deleteContact = za({
 		success: z.boolean(),
 	}),
 	handler: async (ctx, args) => {
-		const response = await fetch(`${LOOPS_API_BASE_URL}/contacts/delete`, {
+		const response = await loopsFetch(args.apiKey, "/contacts/delete", {
 			method: "POST",
-			headers: {
-				Authorization: `Bearer ${args.apiKey}`,
-				"Content-Type": "application/json",
-			},
-			body: JSON.stringify({ email: args.email }),
+			json: { email: args.email },
 		});
 
 		if (!response.ok) {
 			const errorText = await response.text();
 			console.error(`Loops API error [${response.status}]:`, errorText);
-			throw sanitizeError(response.status, errorText);
+			throw sanitizeLoopsError(response.status, errorText);
 		}
 
-		await ctx.runMutation(((internal as any).lib).removeContact as any, {
+		await ctx.runMutation(internalLib.removeContact, {
 			email: args.email,
 		});
 
@@ -574,15 +544,15 @@ export const deleteContact = za({
  * Note: Loops in Loops.so are triggered through events, not a direct API endpoint.
  * This function uses the events endpoint to trigger the loop.
  * The loop must be configured in the Loops dashboard to listen for events.
- * 
+ *
  * IMPORTANT: Loops.so doesn't have a direct /loops/trigger endpoint.
  * Loops are triggered by sending events. Make sure your loop in the dashboard
  * is configured to trigger on an event name (e.g., "loop_trigger").
- * 
+ *
  * If you need to trigger a specific loop, you should:
  * 1. Configure the loop in the dashboard to listen for a specific event name
  * 2. Use sendEvent() with that event name instead
- * 
+ *
  * This function is kept for backwards compatibility but works by sending an event.
  */
 export const triggerLoop = za({
@@ -602,10 +572,10 @@ export const triggerLoop = za({
 		// Loops are triggered through events. We'll use the events endpoint.
 		// Default event name if not provided
 		const eventName = args.eventName || `loop_${args.loopId}`;
-		
+
 		try {
 			// Send event to trigger the loop
-			await ctx.runAction(((internal as any).lib).sendEvent as any, {
+			await ctx.runAction(internalLib.sendEvent, {
 				apiKey: args.apiKey,
 				email: args.email,
 				eventName,
@@ -616,7 +586,7 @@ export const triggerLoop = za({
 			});
 
 			// Log as loop operation
-			await ctx.runMutation(((internal as any).lib).logEmailOperation as any, {
+			await ctx.runMutation(internalLib.logEmailOperation, {
 				operationType: "loop",
 				email: args.email,
 				success: true,
@@ -626,19 +596,22 @@ export const triggerLoop = za({
 
 			return {
 				success: true,
-				warning: "Loops are triggered via events. Ensure your loop is configured to listen for this event.",
+				warning:
+					"Loops are triggered via events. Ensure your loop is configured to listen for this event.",
 			};
 		} catch (error) {
 			// Log failed loop operation
-			await ctx.runMutation(((internal as any).lib).logEmailOperation as any, {
+			await ctx.runMutation(internalLib.logEmailOperation, {
 				operationType: "loop",
 				email: args.email,
 				success: false,
 				loopId: args.loopId,
 				eventName,
-				metadata: { error: error instanceof Error ? error.message : String(error) },
+				metadata: {
+					error: error instanceof Error ? error.message : String(error),
+				},
 			});
-			
+
 			throw error;
 		}
 	},
@@ -670,16 +643,11 @@ export const findContact = za({
 			})
 			.optional(),
 	}),
-	handler: async (ctx, args) => {
-		const response = await fetch(
-			`${LOOPS_API_BASE_URL}/contacts/find?email=${encodeURIComponent(args.email)}`,
-			{
-				method: "GET",
-				headers: {
-					Authorization: `Bearer ${args.apiKey}`,
-					"Content-Type": "application/json",
-				},
-			},
+	handler: async (_ctx, args) => {
+		const response = await loopsFetch(
+			args.apiKey,
+			`/contacts/find?email=${encodeURIComponent(args.email)}`,
+			{ method: "GET" },
 		);
 
 		if (!response.ok) {
@@ -688,10 +656,13 @@ export const findContact = za({
 			}
 			const errorText = await response.text();
 			console.error(`Loops API error [${response.status}]:`, errorText);
-			throw sanitizeError(response.status, errorText);
+			throw sanitizeLoopsError(response.status, errorText);
 		}
 
-		const data = (await response.json()) as Record<string, any> | Array<Record<string, any>>;
+		type LoopsContactRecord = Record<string, unknown>;
+		const data = (await response.json()) as
+			| LoopsContactRecord
+			| Array<LoopsContactRecord>;
 
 		// Handle case where Loops returns an array instead of a single object
 		let contact = Array.isArray(data) ? data[0] : data;
@@ -699,13 +670,16 @@ export const findContact = za({
 		// Convert null values to undefined for optional fields (Zod handles undefined but not null in optional())
 		if (contact) {
 			contact = Object.fromEntries(
-				Object.entries(contact).map(([key, value]) => [key, value === null ? undefined : value])
-			) as Record<string, any>;
+				Object.entries(contact).map(([key, value]) => [
+					key,
+					value === null ? undefined : value,
+				]),
+			) as LoopsContactRecord;
 		}
 
 		return {
 			success: true,
-			contact: contact as Record<string, any> | undefined,
+			contact: contact as LoopsContactRecord | undefined,
 		};
 	},
 });
@@ -724,22 +698,27 @@ export const batchCreateContacts = za({
 		success: z.boolean(),
 		created: z.number().optional(),
 		failed: z.number().optional(),
-		results: z.array(z.object({
-			email: z.string(),
-			success: z.boolean(),
-			error: z.string().optional(),
-		})).optional(),
+		results: z
+			.array(
+				z.object({
+					email: z.string(),
+					success: z.boolean(),
+					error: z.string().optional(),
+				}),
+			)
+			.optional(),
 	}),
 	handler: async (ctx, args) => {
 		let created = 0;
 		let failed = 0;
-		const results: Array<{ email: string; success: boolean; error?: string }> = [];
+		const results: Array<{ email: string; success: boolean; error?: string }> =
+			[];
 
 		// Create contacts one by one since Loops.so doesn't have a batch endpoint
 		for (const contact of args.contacts) {
 			try {
 				// Use the addContact function which handles create/update logic
-				const result = await ctx.runAction(((internal as any).lib).addContact as any, {
+				const result = await ctx.runAction(internalLib.addContact, {
 					apiKey: args.apiKey,
 					contact,
 				});
@@ -749,10 +728,10 @@ export const batchCreateContacts = za({
 					results.push({ email: contact.email, success: true });
 				} else {
 					failed++;
-					results.push({ 
-						email: contact.email, 
-						success: false, 
-						error: "Unknown error" 
+					results.push({
+						email: contact.email,
+						success: false,
+						error: "Unknown error",
 					});
 				}
 			} catch (error) {
@@ -787,22 +766,18 @@ export const unsubscribeContact = za({
 		success: z.boolean(),
 	}),
 	handler: async (ctx, args) => {
-		const response = await fetch(`${LOOPS_API_BASE_URL}/contacts/unsubscribe`, {
+		const response = await loopsFetch(args.apiKey, "/contacts/unsubscribe", {
 			method: "POST",
-			headers: {
-				Authorization: `Bearer ${args.apiKey}`,
-				"Content-Type": "application/json",
-			},
-			body: JSON.stringify({ email: args.email }),
+			json: { email: args.email },
 		});
 
 		if (!response.ok) {
 			const errorText = await response.text();
 			console.error(`Loops API error [${response.status}]:`, errorText);
-			throw sanitizeError(response.status, errorText);
+			throw sanitizeLoopsError(response.status, errorText);
 		}
 
-		await ctx.runMutation(((internal as any).lib).storeContact as any, {
+		await ctx.runMutation(internalLib.storeContact, {
 			email: args.email,
 			subscribed: false,
 		});
@@ -824,22 +799,18 @@ export const resubscribeContact = za({
 		success: z.boolean(),
 	}),
 	handler: async (ctx, args) => {
-		const response = await fetch(`${LOOPS_API_BASE_URL}/contacts/resubscribe`, {
+		const response = await loopsFetch(args.apiKey, "/contacts/resubscribe", {
 			method: "POST",
-			headers: {
-				Authorization: `Bearer ${args.apiKey}`,
-				"Content-Type": "application/json",
-			},
-			body: JSON.stringify({ email: args.email }),
+			json: { email: args.email },
 		});
 
 		if (!response.ok) {
 			const errorText = await response.text();
 			console.error(`Loops API error [${response.status}]:`, errorText);
-			throw sanitizeError(response.status, errorText);
+			throw sanitizeLoopsError(response.status, errorText);
 		}
 
-		await ctx.runMutation(((internal as any).lib).storeContact as any, {
+		await ctx.runMutation(internalLib.storeContact, {
 			email: args.email,
 			subscribed: true,
 		});
@@ -858,15 +829,17 @@ export const detectRecipientSpam = zq({
 		maxEmailsPerRecipient: z.number().default(10),
 	}),
 	returns: z.array(
-		z.object({
-			email: z.string(),
-			count: z.number(),
-			timeWindowMs: z.number(),
-		}),
+		z
+			.object({
+				email: z.string(),
+				count: z.number(),
+				timeWindowMs: z.number(),
+			})
+			.catchall(z.any()),
 	),
 	handler: async (ctx, args) => {
 		const cutoffTime = Date.now() - args.timeWindowMs;
-		
+
 		const operations = await ctx.db
 			.query("emailOperations")
 			.withIndex("timestamp", (q) => q.gte("timestamp", cutoffTime))
@@ -879,7 +852,11 @@ export const detectRecipientSpam = zq({
 			}
 		}
 
-		const suspicious: Array<{ email: string; count: number; timeWindowMs: number }> = [];
+		const suspicious: Array<{
+			email: string;
+			count: number;
+			timeWindowMs: number;
+		}> = [];
 		for (const [email, count] of emailCounts.entries()) {
 			if (count > args.maxEmailsPerRecipient) {
 				suspicious.push({
@@ -912,7 +889,7 @@ export const detectActorSpam = zq({
 	),
 	handler: async (ctx, args) => {
 		const cutoffTime = Date.now() - args.timeWindowMs;
-		
+
 		const operations = await ctx.db
 			.query("emailOperations")
 			.withIndex("timestamp", (q) => q.gte("timestamp", cutoffTime))
@@ -925,7 +902,11 @@ export const detectActorSpam = zq({
 			}
 		}
 
-		const suspicious: Array<{ actorId: string; count: number; timeWindowMs: number }> = [];
+		const suspicious: Array<{
+			actorId: string;
+			count: number;
+			timeWindowMs: number;
+		}> = [];
 		for (const [actorId, count] of actorCounts.entries()) {
 			if (count > args.maxEmailsPerActor) {
 				suspicious.push({
@@ -947,17 +928,19 @@ export const getEmailStats = zq({
 	args: z.object({
 		timeWindowMs: z.number().default(86400000),
 	}),
-	returns: z.object({
-		totalOperations: z.number(),
-		successfulOperations: z.number(),
-		failedOperations: z.number(),
-		operationsByType: z.record(z.string(), z.number()),
-		uniqueRecipients: z.number(),
-		uniqueActors: z.number(),
-	}),
+	returns: z
+		.object({
+			totalOperations: z.number(),
+			successfulOperations: z.number(),
+			failedOperations: z.number(),
+			operationsByType: z.record(z.string(), z.number()),
+			uniqueRecipients: z.number(),
+			uniqueActors: z.number(),
+		})
+		.catchall(z.any()),
 	handler: async (ctx, args) => {
 		const cutoffTime = Date.now() - args.timeWindowMs;
-		
+
 		const operations = await ctx.db
 			.query("emailOperations")
 			.withIndex("timestamp", (q) => q.gte("timestamp", cutoffTime))
@@ -975,11 +958,11 @@ export const getEmailStats = zq({
 		for (const op of operations) {
 			stats.operationsByType[op.operationType] =
 				(stats.operationsByType[op.operationType] ?? 0) + 1;
-			
+
 			if (op.email && op.email !== "audience") {
 				stats.uniqueRecipients.add(op.email);
 			}
-			
+
 			if (op.actorId) {
 				stats.uniqueActors.add(op.actorId);
 			}
@@ -1014,7 +997,7 @@ export const detectRapidFirePatterns = zq({
 	),
 	handler: async (ctx, args) => {
 		const cutoffTime = Date.now() - args.timeWindowMs;
-		
+
 		const operations = await ctx.db
 			.query("emailOperations")
 			.withIndex("timestamp", (q) => q.gte("timestamp", cutoffTime))
@@ -1037,7 +1020,7 @@ export const detectRapidFirePatterns = zq({
 				if (!emailGroups.has(op.email)) {
 					emailGroups.set(op.email, []);
 				}
-				emailGroups.get(op.email)!.push(op);
+				emailGroups.get(op.email)?.push(op);
 			}
 		}
 
@@ -1045,13 +1028,13 @@ export const detectRapidFirePatterns = zq({
 			for (let i = 0; i < ops.length; i++) {
 				const op = ops[i];
 				if (!op) continue;
-				
+
 				const windowStart = op.timestamp;
 				const windowEnd = windowStart + args.timeWindowMs;
 				const opsInWindow = ops.filter(
 					(op) => op.timestamp >= windowStart && op.timestamp <= windowEnd,
 				);
-				
+
 				if (opsInWindow.length >= args.minEmailsInWindow) {
 					patterns.push({
 						email,
@@ -1070,7 +1053,7 @@ export const detectRapidFirePatterns = zq({
 				if (!actorGroups.has(op.actorId)) {
 					actorGroups.set(op.actorId, []);
 				}
-				actorGroups.get(op.actorId)!.push(op);
+				actorGroups.get(op.actorId)?.push(op);
 			}
 		}
 
@@ -1078,13 +1061,13 @@ export const detectRapidFirePatterns = zq({
 			for (let i = 0; i < ops.length; i++) {
 				const op = ops[i];
 				if (!op) continue;
-				
+
 				const windowStart = op.timestamp;
 				const windowEnd = windowStart + args.timeWindowMs;
 				const opsInWindow = ops.filter(
 					(op) => op.timestamp >= windowStart && op.timestamp <= windowEnd,
 				);
-				
+
 				if (opsInWindow.length >= args.minEmailsInWindow) {
 					patterns.push({
 						actorId,
@@ -1111,13 +1094,15 @@ export const checkRecipientRateLimit = zq({
 		timeWindowMs: z.number(),
 		maxEmails: z.number(),
 	}),
-	returns: z.object({
-		allowed: z.boolean(),
-		count: z.number(),
-		limit: z.number(),
-		timeWindowMs: z.number(),
-		retryAfter: z.number().optional(),
-	}),
+	returns: z
+		.object({
+			allowed: z.boolean(),
+			count: z.number(),
+			limit: z.number(),
+			timeWindowMs: z.number(),
+			retryAfter: z.number().optional(),
+		})
+		.catchall(z.any()),
 	handler: async (ctx, args) => {
 		const cutoffTime = Date.now() - args.timeWindowMs;