@devwithbobby/loops 0.1.12 → 0.1.14

package/dist/component/lib.js

@@ -1,26 +1,8 @@
 import { z } from "zod";
+import { internalLib } from "../types";
 import { za, zm, zq } from "../utils.js";
-import { internal } from "./_generated/api";
+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, errorText) => {
-    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
  */
@@ -111,21 +93,14 @@ export const logEmailOperation = zm({
             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);
     },
 });
@@ -244,7 +219,12 @@ export const listContacts = zq({
         // Sort by createdAt (newest first)
         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 {
             contacts: paginatedContacts,
@@ -270,36 +250,22 @@ 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) {
+        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 fetch(`${LOOPS_API_BASE_URL}/contacts/find?email=${encodeURIComponent(args.contact.email)}`, {
-                    method: "GET",
-                    headers: {
-                        Authorization: `Bearer ${args.apiKey}`,
-                        "Content-Type": "application/json",
-                    },
-                });
+                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);
                 }
-                const updateResponse = await fetch(`${LOOPS_API_BASE_URL}/contacts/update`, {
+                const updateResponse = await loopsFetch(args.apiKey, "/contacts/update", {
                     method: "PUT",
-                    headers: {
-                        Authorization: `Bearer ${args.apiKey}`,
-                        "Content-Type": "application/json",
-                    },
-                    body: JSON.stringify({
+                    json: {
                         email: args.contact.email,
                         firstName: args.contact.firstName,
                         lastName: args.contact.lastName,
@@ -307,12 +273,12 @@ export const addContact = za({
                         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);
+                    throw sanitizeLoopsError(updateResponse.status, updateErrorText);
                 }
                 // Get contact ID if available
                 let contactId;
@@ -321,7 +287,7 @@ export const addContact = za({
                     contactId = findData.id;
                 }
                 // Store/update in our database
-                await ctx.runMutation((internal.lib).storeContact, {
+                await ctx.runMutation(internalLib.storeContact, {
                     email: args.contact.email,
                     firstName: args.contact.firstName,
                     lastName: args.contact.lastName,
@@ -336,13 +302,12 @@ export const addContact = za({
                     id: contactId,
                 };
             }
-            // 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());
-        await ctx.runMutation((internal.lib).storeContact, {
+        const data = (await createResponse.json());
+        await ctx.runMutation(internalLib.storeContact, {
             email: args.contact.email,
             firstName: args.contact.firstName,
             lastName: args.contact.lastName,
@@ -377,13 +342,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,
@@ -392,14 +353,14 @@ 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.lib).storeContact, {
+        await ctx.runMutation(internalLib.storeContact, {
             email: args.email,
             firstName: args.firstName,
             lastName: args.lastName,
@@ -426,31 +387,27 @@ 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.lib).logEmailOperation, {
+            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());
-        await ctx.runMutation((internal.lib).logEmailOperation, {
+        await ctx.runMutation(internalLib.logEmailOperation, {
             operationType: "transactional",
             email: args.email,
             success: true,
@@ -476,23 +433,19 @@ 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 };
     },
@@ -509,20 +462,16 @@ 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.lib).removeContact, {
+        await ctx.runMutation(internalLib.removeContact, {
             email: args.email,
         });
         return { success: true };
@@ -563,7 +512,7 @@ export const triggerLoop = za({
         const eventName = args.eventName || `loop_${args.loopId}`;
         try {
             // Send event to trigger the loop
-            await ctx.runAction((internal.lib).sendEvent, {
+            await ctx.runAction(internalLib.sendEvent, {
                 apiKey: args.apiKey,
                 email: args.email,
                 eventName,
@@ -573,7 +522,7 @@ export const triggerLoop = za({
                 },
             });
             // Log as loop operation
-            await ctx.runMutation((internal.lib).logEmailOperation, {
+            await ctx.runMutation(internalLib.logEmailOperation, {
                 operationType: "loop",
                 email: args.email,
                 success: true,
@@ -587,13 +536,15 @@ export const triggerLoop = za({
         }
         catch (error) {
             // Log failed loop operation
-            await ctx.runMutation((internal.lib).logEmailOperation, {
+            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;
         }
@@ -625,28 +576,25 @@ 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) {
             if (response.status === 404) {
                 return { success: false, contact: undefined };
             }
             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());
         // Handle case where Loops returns an array instead of a single object
         let contact = Array.isArray(data) ? data[0] : data;
         // 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]));
+            contact = Object.fromEntries(Object.entries(contact).map(([key, value]) => [
+                key,
+                value === null ? undefined : value,
+            ]));
         }
         return {
             success: true,
@@ -668,11 +616,13 @@ export const batchCreateContacts = za({
         success: z.boolean(),
         created: z.number().optional(),
         failed: z.number().optional(),
-        results: z.array(z.object({
+        results: z
+            .array(z.object({
             email: z.string(),
             success: z.boolean(),
             error: z.string().optional(),
-        })).optional(),
+        }))
+            .optional(),
     }),
     handler: async (ctx, args) => {
         let created = 0;
@@ -682,7 +632,7 @@ export const batchCreateContacts = za({
         for (const contact of args.contacts) {
             try {
                 // Use the addContact function which handles create/update logic
-                const result = await ctx.runAction((internal.lib).addContact, {
+                const result = await ctx.runAction(internalLib.addContact, {
                     apiKey: args.apiKey,
                     contact,
                 });
@@ -695,7 +645,7 @@ export const batchCreateContacts = za({
                     results.push({
                         email: contact.email,
                         success: false,
-                        error: "Unknown error"
+                        error: "Unknown error",
                     });
                 }
             }
@@ -729,20 +679,16 @@ 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.lib).storeContact, {
+        await ctx.runMutation(internalLib.storeContact, {
             email: args.email,
             subscribed: false,
         });
@@ -762,20 +708,16 @@ 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.lib).storeContact, {
+        await ctx.runMutation(internalLib.storeContact, {
             email: args.email,
             subscribed: true,
         });
@@ -791,11 +733,13 @@ export const detectRecipientSpam = zq({
         timeWindowMs: z.number().default(3600000),
         maxEmailsPerRecipient: z.number().default(10),
     }),
-    returns: z.array(z.object({
+    returns: z.array(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
@@ -867,14 +811,16 @@ export const getEmailStats = zq({
     args: z.object({
         timeWindowMs: z.number().default(86400000),
     }),
-    returns: z.object({
+    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
@@ -937,7 +883,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);
             }
         }
         for (const [email, ops] of emailGroups.entries()) {
@@ -965,7 +911,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);
             }
         }
         for (const [actorId, ops] of actorGroups.entries()) {
@@ -1000,13 +946,15 @@ export const checkRecipientRateLimit = zq({
         timeWindowMs: z.number(),
         maxEmails: z.number(),
     }),
-    returns: z.object({
+    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;
         const operations = await ctx.db

package/dist/component/schema.d.ts

@@ -1,3 +1,68 @@
-declare const _default: any;
+declare const _default: import("convex/server").SchemaDefinition<{
+    contacts: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        firstName?: string | undefined;
+        lastName?: string | undefined;
+        userId?: string | undefined;
+        source?: string | undefined;
+        subscribed?: boolean | undefined;
+        userGroup?: string | undefined;
+        loopsContactId?: string | undefined;
+        email: string;
+        createdAt: number;
+        updatedAt: number;
+    }, import("zodvex").ConvexValidatorFromZodFieldsAuto<{
+        email: import("zod").ZodString;
+        firstName: import("zod").ZodOptional<import("zod").ZodString>;
+        lastName: import("zod").ZodOptional<import("zod").ZodString>;
+        userId: import("zod").ZodOptional<import("zod").ZodString>;
+        source: import("zod").ZodOptional<import("zod").ZodString>;
+        subscribed: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        userGroup: import("zod").ZodOptional<import("zod").ZodString>;
+        loopsContactId: import("zod").ZodOptional<import("zod").ZodString>;
+        createdAt: import("zod").ZodNumber;
+        updatedAt: import("zod").ZodNumber;
+    }>, "required", "email" | "firstName" | "lastName" | "userId" | "source" | "subscribed" | "userGroup" | "loopsContactId" | "createdAt" | "updatedAt">, {
+        email: ["email", "_creationTime"];
+        userId: ["userId", "_creationTime"];
+        userGroup: ["userGroup", "_creationTime"];
+        source: ["source", "_creationTime"];
+        subscribed: ["subscribed", "_creationTime"];
+    }, {}, {}>;
+    emailOperations: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        actorId?: string | undefined;
+        transactionalId?: string | undefined;
+        campaignId?: string | undefined;
+        loopId?: string | undefined;
+        eventName?: string | undefined;
+        messageId?: string | undefined;
+        metadata?: Record<string, any> | undefined;
+        email: string;
+        success: boolean;
+        operationType: "transactional" | "event" | "campaign" | "loop";
+        timestamp: number;
+    }, import("zodvex").ConvexValidatorFromZodFieldsAuto<{
+        operationType: import("zod").ZodEnum<{
+            transactional: "transactional";
+            event: "event";
+            campaign: "campaign";
+            loop: "loop";
+        }>;
+        email: import("zod").ZodString;
+        actorId: import("zod").ZodOptional<import("zod").ZodString>;
+        transactionalId: import("zod").ZodOptional<import("zod").ZodString>;
+        campaignId: import("zod").ZodOptional<import("zod").ZodString>;
+        loopId: import("zod").ZodOptional<import("zod").ZodString>;
+        eventName: import("zod").ZodOptional<import("zod").ZodString>;
+        timestamp: import("zod").ZodNumber;
+        success: import("zod").ZodBoolean;
+        messageId: import("zod").ZodOptional<import("zod").ZodString>;
+        metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+    }>, "required", "email" | "success" | "operationType" | "actorId" | "transactionalId" | "campaignId" | "loopId" | "eventName" | "timestamp" | "messageId" | "metadata" | `metadata.${string}`>, {
+        email: ["email", "timestamp", "_creationTime"];
+        actorId: ["actorId", "timestamp", "_creationTime"];
+        operationType: ["operationType", "timestamp", "_creationTime"];
+        timestamp: ["timestamp", "_creationTime"];
+    }, {}, {}>;
+}, true>;
 export default _default;
 //# sourceMappingURL=schema.d.ts.map

package/dist/component/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/component/schema.ts"],"names":[],"mappings":";AAIA,wBAYG"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/component/schema.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,wBAYG"}