@devwithbobby/loops 0.1.17 → 0.1.19

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

@@ -1 +1 @@
-{"version":3,"file":"lib.d.ts","sourceRoot":"","sources":["../../src/component/lib.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;iBA6CvB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;iBAexB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;iBAkC5B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,aAAa;;;;mBAwCxB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;GAmFvB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;GA+GrB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;GAgDxB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;GAiD5B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,SAAS;;;;;;;GA4BpB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;GA0BxB,CAAC;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,WAAW;;;;;;;;;GA4DtB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;GA4DtB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;GA8D9B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;GA2B7B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;GA2B7B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;KA8C9B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,eAAe;;;;;;;KA4C1B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;GAkDxB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;KAsGlC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;GA+ClC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;GA6C9B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;GA8B/B,CAAC"}
+{"version":3,"file":"lib.d.ts","sourceRoot":"","sources":["../../src/component/lib.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;iBA6CvB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;iBAexB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;iBAkC5B,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa;;;;mBA0DxB,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;GA8FvB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;GA+GrB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;GAgDxB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;GAiD5B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,SAAS;;;;;;;GAyCpB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;GA0BxB,CAAC;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,WAAW;;;;;;;;;GA4DtB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;GA4DtB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;GA8D9B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;GA2B7B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;GA2B7B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;KA8C9B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,eAAe;;;;;;;KA4C1B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;GAkDxB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;KAsGlC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;GA+ClC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;GA6C9B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;GA8B/B,CAAC"}

package/dist/component/lib.js

@@ -107,6 +107,10 @@ export const logEmailOperation = zm({
 /**
  * Count contacts in the database
  * Can filter by audience criteria (userGroup, source, subscribed status)
+ *
+ * Note: When multiple filters are provided, only one index can be used.
+ * Additional filters are applied in-memory, which is efficient for small result sets.
+ * For large contact lists with multiple filters, consider using a composite index.
  */
 export const countContacts = zq({
     args: z.object({
@@ -116,6 +120,8 @@ export const countContacts = zq({
     }),
     returns: z.number(),
     handler: async (ctx, args) => {
+        // Build query using the most selective index available
+        // Priority: userGroup > source > subscribed
         let contacts;
         if (args.userGroup !== undefined) {
             contacts = await ctx.db
@@ -138,22 +144,37 @@ export const countContacts = zq({
         else {
             contacts = await ctx.db.query("contacts").collect();
         }
-        if (args.userGroup !== undefined && contacts) {
-            contacts = contacts.filter((c) => c.userGroup === args.userGroup);
-        }
-        if (args.source !== undefined && contacts) {
-            contacts = contacts.filter((c) => c.source === args.source);
+        // Apply additional filters if multiple criteria were provided
+        // This avoids redundant filtering when only one filter was used
+        const needsFiltering = (args.userGroup !== undefined ? 1 : 0) +
+            (args.source !== undefined ? 1 : 0) +
+            (args.subscribed !== undefined ? 1 : 0) >
+            1;
+        if (!needsFiltering) {
+            return contacts.length;
         }
-        if (args.subscribed !== undefined && contacts) {
-            contacts = contacts.filter((c) => c.subscribed === args.subscribed);
-        }
-        return contacts.length;
+        const filtered = contacts.filter((c) => {
+            if (args.userGroup !== undefined && c.userGroup !== args.userGroup) {
+                return false;
+            }
+            if (args.source !== undefined && c.source !== args.source) {
+                return false;
+            }
+            if (args.subscribed !== undefined && c.subscribed !== args.subscribed) {
+                return false;
+            }
+            return true;
+        });
+        return filtered.length;
     },
 });
 /**
  * List contacts from the database with pagination
  * Can filter by audience criteria (userGroup, source, subscribed status)
  * Returns actual contact data, not just a count
+ *
+ * Note: When multiple filters are provided, only one index can be used.
+ * Additional filters are applied in-memory before pagination.
  */
 export const listContacts = zq({
     args: z.object({
@@ -183,8 +204,8 @@ export const listContacts = zq({
         hasMore: z.boolean(),
     }),
     handler: async (ctx, args) => {
+        // Build query using the most selective index available
         let allContacts;
-        // Get all contacts matching the filters
         if (args.userGroup !== undefined) {
             allContacts = await ctx.db
                 .query("contacts")
@@ -206,15 +227,24 @@ export const listContacts = zq({
         else {
             allContacts = await ctx.db.query("contacts").collect();
         }
-        // Apply additional filters (for cases where we need to filter by multiple criteria)
-        if (args.userGroup !== undefined && allContacts) {
-            allContacts = allContacts.filter((c) => c.userGroup === args.userGroup);
-        }
-        if (args.source !== undefined && allContacts) {
-            allContacts = allContacts.filter((c) => c.source === args.source);
-        }
-        if (args.subscribed !== undefined && allContacts) {
-            allContacts = allContacts.filter((c) => c.subscribed === args.subscribed);
+        // Apply additional filters if multiple criteria were provided
+        const needsFiltering = (args.userGroup !== undefined ? 1 : 0) +
+            (args.source !== undefined ? 1 : 0) +
+            (args.subscribed !== undefined ? 1 : 0) >
+            1;
+        if (needsFiltering) {
+            allContacts = allContacts.filter((c) => {
+                if (args.userGroup !== undefined && c.userGroup !== args.userGroup) {
+                    return false;
+                }
+                if (args.source !== undefined && c.source !== args.source) {
+                    return false;
+                }
+                if (args.subscribed !== undefined && c.subscribed !== args.subscribed) {
+                    return false;
+                }
+                return true;
+            });
         }
         // Sort by createdAt (newest first)
         allContacts.sort((a, b) => b.createdAt - a.createdAt);
@@ -433,7 +463,7 @@ export const sendEvent = za({
     returns: z.object({
         success: z.boolean(),
     }),
-    handler: async (_ctx, args) => {
+    handler: async (ctx, args) => {
         const response = await loopsFetch(args.apiKey, "/events/send", {
             method: "POST",
             json: {
@@ -445,8 +475,20 @@ export const sendEvent = za({
         if (!response.ok) {
             const errorText = await response.text();
             console.error(`Loops API error [${response.status}]:`, errorText);
+            await ctx.runMutation(internalLib.logEmailOperation, {
+                operationType: "event",
+                email: args.email,
+                success: false,
+                eventName: args.eventName,
+            });
             throw sanitizeLoopsError(response.status, errorText);
         }
+        await ctx.runMutation(internalLib.logEmailOperation, {
+            operationType: "event",
+            email: args.email,
+            success: true,
+            eventName: args.eventName,
+        });
         return { success: true };
     },
 });

package/dist/component/schema.d.ts

@@ -29,13 +29,13 @@ declare const _default: import("convex/server").SchemaDefinition<{
         subscribed: ["subscribed", "_creationTime"];
     }, {}, {}>;
     emailOperations: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        metadata?: Record<string, any> | undefined;
         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";
@@ -57,7 +57,7 @@ declare const _default: import("convex/server").SchemaDefinition<{
         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}`>, {
+    }>, "required", "email" | "success" | "metadata" | "operationType" | "actorId" | "transactionalId" | "campaignId" | "loopId" | "eventName" | "timestamp" | "messageId" | `metadata.${string}`>, {
         email: ["email", "timestamp", "_creationTime"];
         actorId: ["actorId", "timestamp", "_creationTime"];
         operationType: ["operationType", "timestamp", "_creationTime"];

package/dist/component/tables/contacts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contacts.d.ts","sourceRoot":"","sources":["../../../src/component/tables/contacts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAYu99B,EAAG,SAAS;;;;;;;;uBAAgW,EAAG,SAAS;;CADl2+B,CAAC"}
+{"version":3,"file":"contacts.d.ts","sourceRoot":"","sources":["../../../src/component/tables/contacts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWnB,CAAC"}

package/dist/component/tables/emailOperations.d.ts

@@ -2,13 +2,13 @@ import { z } from "zod";
 export declare const EmailOperations: {
     name: "emailOperations";
     table: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        metadata?: Record<string, any> | undefined;
         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";
@@ -30,15 +30,15 @@ export declare const EmailOperations: {
         success: z.ZodBoolean;
         messageId: z.ZodOptional<z.ZodString>;
         metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    }>, "required", "email" | "success" | "operationType" | "actorId" | "transactionalId" | "campaignId" | "loopId" | "eventName" | "timestamp" | "messageId" | "metadata" | `metadata.${string}`>, {}, {}, {}>;
+    }>, "required", "email" | "success" | "metadata" | "operationType" | "actorId" | "transactionalId" | "campaignId" | "loopId" | "eventName" | "timestamp" | "messageId" | `metadata.${string}`>, {}, {}, {}>;
     doc: import("convex/values").VObject<{
+        metadata?: Record<string, any> | undefined;
         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";
@@ -59,7 +59,7 @@ export declare const EmailOperations: {
         metadata: import("convex/values").VRecord<Record<string, any> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VAny<"required", "required", string>, "optional", string>;
         _id: import("convex/values").VId<import("convex/values").GenericId<"emailOperations">, "required">;
         _creationTime: import("convex/values").VFloat64<number, "required">;
-    }, "required", "email" | "success" | "operationType" | "actorId" | "transactionalId" | "campaignId" | "loopId" | "eventName" | "timestamp" | "messageId" | "metadata" | "_creationTime" | `metadata.${string}` | "_id">;
+    }, "required", "email" | "success" | "metadata" | "operationType" | "actorId" | "transactionalId" | "campaignId" | "loopId" | "eventName" | "timestamp" | "messageId" | "_creationTime" | `metadata.${string}` | "_id">;
     withoutSystemFields: import("zodvex").ConvexValidatorFromZodFieldsAuto<{
         operationType: z.ZodEnum<{
             transactional: "transactional";

package/dist/component/tables/emailOperations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"emailOperations.d.ts","sourceRoot":"","sources":["../../../src/component/tables/emailOperations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAay29B,EAAG,SAAS;;;;;;;;uBAAgW,EAAG,SAAS;;CAD3v+B,CAAC"}
+{"version":3,"file":"emailOperations.d.ts","sourceRoot":"","sources":["../../../src/component/tables/emailOperations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAY1B,CAAC"}

package/dist/test.d.ts

@@ -0,0 +1,83 @@
+import type { TestConvex } from "convex-test";
+import type { GenericSchema, SchemaDefinition } from "convex/server";
+import schema from "./component/schema.js";
+/**
+ * Register the Loops component with the test convex instance.
+ *
+ * @param t - The test convex instance from convexTest().
+ * @param name - The name of the component as registered in convex.config.ts.
+ * @param modules - The modules object from import.meta.glob. Required.
+ */
+export declare function register(t: TestConvex<SchemaDefinition<GenericSchema, boolean>>, name?: string, modules?: Record<string, () => Promise<unknown>>): void;
+export { schema };
+declare const _default: {
+    register: typeof register;
+    schema: 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<{
+            metadata?: Record<string, any> | undefined;
+            actorId?: string | undefined;
+            transactionalId?: string | undefined;
+            campaignId?: string | undefined;
+            loopId?: string | undefined;
+            eventName?: string | undefined;
+            messageId?: string | 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" | "metadata" | "operationType" | "actorId" | "transactionalId" | "campaignId" | "loopId" | "eventName" | "timestamp" | "messageId" | `metadata.${string}`>, {
+            email: ["email", "timestamp", "_creationTime"];
+            actorId: ["actorId", "timestamp", "_creationTime"];
+            operationType: ["operationType", "timestamp", "_creationTime"];
+            timestamp: ["timestamp", "_creationTime"];
+        }, {}, {}>;
+    }, true>;
+};
+export default _default;
+//# sourceMappingURL=test.d.ts.map

package/dist/test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../src/test.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,MAAM,MAAM,uBAAuB,CAAC;AAE3C;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACvB,CAAC,EAAE,UAAU,CAAC,gBAAgB,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC,EACvD,IAAI,GAAE,MAAgB,EACtB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC,QAQhD;AAED,OAAO,EAAE,MAAM,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAElB,wBAAoC"}

package/dist/test.js

@@ -0,0 +1,16 @@
+import schema from "./component/schema.js";
+/**
+ * Register the Loops component with the test convex instance.
+ *
+ * @param t - The test convex instance from convexTest().
+ * @param name - The name of the component as registered in convex.config.ts.
+ * @param modules - The modules object from import.meta.glob. Required.
+ */
+export function register(t, name = "loops", modules) {
+    if (!modules) {
+        throw new Error("modules parameter is required. Pass import.meta.glob from your test file.");
+    }
+    t.registerComponent(name, schema, modules);
+}
+export { schema };
+export default { register, schema };

package/dist/utils.d.ts

@@ -33,19 +33,19 @@ export declare const zq: <A extends import("zod").ZodType | Record<string, impor
             document: {
                 _id: import("convex/values").GenericId<"emailOperations">;
                 _creationTime: number;
+                metadata?: Record<string, any> | undefined;
                 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;
             };
-            fieldPaths: ("email" | "success" | "operationType" | "actorId" | "transactionalId" | "campaignId" | "loopId" | "eventName" | "timestamp" | "messageId" | "metadata" | "_creationTime" | `metadata.${string}`) | "_id";
+            fieldPaths: ("email" | "success" | "metadata" | "operationType" | "actorId" | "transactionalId" | "campaignId" | "loopId" | "eventName" | "timestamp" | "messageId" | "_creationTime" | `metadata.${string}`) | "_id";
             indexes: {
                 email: ["email", "timestamp", "_creationTime"];
                 actorId: ["actorId", "timestamp", "_creationTime"];
@@ -95,19 +95,19 @@ export declare const zm: <A extends import("zod").ZodType | Record<string, impor
             document: {
                 _id: import("convex/values").GenericId<"emailOperations">;
                 _creationTime: number;
+                metadata?: Record<string, any> | undefined;
                 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;
             };
-            fieldPaths: ("email" | "success" | "operationType" | "actorId" | "transactionalId" | "campaignId" | "loopId" | "eventName" | "timestamp" | "messageId" | "metadata" | "_creationTime" | `metadata.${string}`) | "_id";
+            fieldPaths: ("email" | "success" | "metadata" | "operationType" | "actorId" | "transactionalId" | "campaignId" | "loopId" | "eventName" | "timestamp" | "messageId" | "_creationTime" | `metadata.${string}`) | "_id";
             indexes: {
                 email: ["email", "timestamp", "_creationTime"];
                 actorId: ["actorId", "timestamp", "_creationTime"];
@@ -157,19 +157,19 @@ export declare const za: <A extends import("zod").ZodType | Record<string, impor
             document: {
                 _id: import("convex/values").GenericId<"emailOperations">;
                 _creationTime: number;
+                metadata?: Record<string, any> | undefined;
                 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;
             };
-            fieldPaths: ("email" | "success" | "operationType" | "actorId" | "transactionalId" | "campaignId" | "loopId" | "eventName" | "timestamp" | "messageId" | "metadata" | "_creationTime" | `metadata.${string}`) | "_id";
+            fieldPaths: ("email" | "success" | "metadata" | "operationType" | "actorId" | "transactionalId" | "campaignId" | "loopId" | "eventName" | "timestamp" | "messageId" | "_creationTime" | `metadata.${string}`) | "_id";
             indexes: {
                 email: ["email", "timestamp", "_creationTime"];
                 actorId: ["actorId", "timestamp", "_creationTime"];

package/package.json

@@ -1,16 +1,18 @@
 {
 	"name": "@devwithbobby/loops",
-	"version": "0.1.17",
+	"version": "0.1.19",
 	"description": "Convex component for integrating with Loops.so email marketing platform",
 	"license": "Apache-2.0",
 	"type": "module",
 	"keywords": [
 		"convex",
 		"component",
-		"template",
-		"boilerplate",
-		"bun",
-		"biome",
+		"loops",
+		"loops.so",
+		"email",
+		"email-marketing",
+		"transactional-email",
+		"newsletter",
 		"typescript"
 	],
 	"repository": {
@@ -38,7 +40,13 @@
 			"@convex-dev/component-source": "./src/component/convex.config.ts",
 			"types": "./dist/component/convex.config.d.ts",
 			"default": "./src/component/convex.config.ts"
-		}
+		},
+		"./component": {
+			"@convex-dev/component-source": "./src/component/_generated/component.ts",
+			"types": "./dist/component/_generated/component.d.ts",
+			"default": "./dist/component/_generated/component.js"
+		},
+		"./test": "./src/test.ts"
 	},
 	"scripts": {
 		"dev": "run-p -r 'dev:backend' 'dev:frontend' 'build:watch'",
@@ -73,9 +81,7 @@
 		"zodvex": "^0.2.3"
 	},
 	"peerDependencies": {
-		"convex": "^1.0.0",
-		"react": "^18.0.0 || ^19.0.0",
-		"typescript": "^5.9.3"
+		"convex": "^1.0.0"
 	},
 	"devDependencies": {
 		"@arethetypeswrong/cli": "^0.18.2",

package/src/client/index.ts

@@ -1,9 +1,9 @@
 import { actionGeneric, queryGeneric } from "convex/server";
 import { v } from "convex/values";
-import type { Mounts } from "../component/_generated/api";
-import type { RunActionCtx, RunQueryCtx, UseApi } from "../types";
+import type { ComponentApi } from "../component/_generated/component.js";
+import type { RunActionCtx, RunQueryCtx } from "../types";
 
-export type LoopsComponent = UseApi<Mounts>;
+export type LoopsComponent = ComponentApi;
 
 export interface ContactData {
 	email: string;
@@ -32,6 +32,7 @@ export class Loops {
 		apiKey?: string;
 	};
 	private readonly lib: NonNullable<LoopsComponent["lib"]>;
+	private _apiKey?: string;
 
 	constructor(
 		component: LoopsComponent,
@@ -58,26 +59,30 @@ export class Loops {
 
 		this.lib = component.lib;
 		this.options = options;
-
-		const apiKey = options?.apiKey ?? process.env.LOOPS_API_KEY;
-		if (!apiKey) {
-			throw new Error(
-				"Loops API key is required. Set LOOPS_API_KEY in your Convex environment variables.",
-			);
-		}
+		this._apiKey = options?.apiKey;
 
 		if (options?.apiKey) {
 			console.warn(
 				"API key passed directly via options. " +
 					"For security, use LOOPS_API_KEY environment variable instead. " +
-					"See ENV_SETUP.md for details.",
+					"See README.md for details.",
 			);
 		}
-
-		this.apiKey = apiKey;
 	}
 
-	private readonly apiKey: string;
+	/**
+	 * Get the API key, checking environment at call time (not constructor time).
+	 * This allows the Loops client to be instantiated at module load time.
+	 */
+	private get apiKey(): string {
+		const key = this._apiKey ?? process.env.LOOPS_API_KEY;
+		if (!key) {
+			throw new Error(
+				"Loops API key is required. Set LOOPS_API_KEY in your Convex environment variables.",
+			);
+		}
+		return key;
+	}
 
 	/**
 	 * Add or update a contact in Loops
@@ -480,6 +485,18 @@ export class Loops {
 					return await this.countContacts(ctx, args);
 				},
 			}),
+			listContacts: queryGeneric({
+				args: {
+					userGroup: v.optional(v.string()),
+					source: v.optional(v.string()),
+					subscribed: v.optional(v.boolean()),
+					limit: v.optional(v.number()),
+					offset: v.optional(v.number()),
+				},
+				handler: async (ctx, args) => {
+					return await this.listContacts(ctx, args);
+				},
+			}),
 			detectRecipientSpam: queryGeneric({
 				args: {
 					timeWindowMs: v.optional(v.number()),

package/src/component/_generated/api.ts

@@ -0,0 +1,60 @@
+/* eslint-disable */
+/**
+ * Generated `api` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type * as helpers from "../helpers.js";
+import type * as http from "../http.js";
+import type * as lib from "../lib.js";
+import type * as tables_contacts from "../tables/contacts.js";
+import type * as tables_emailOperations from "../tables/emailOperations.js";
+import type * as validators from "../validators.js";
+
+import type {
+  ApiFromModules,
+  FilterApi,
+  FunctionReference,
+} from "convex/server";
+import { anyApi, componentsGeneric } from "convex/server";
+
+const fullApi: ApiFromModules<{
+  helpers: typeof helpers;
+  http: typeof http;
+  lib: typeof lib;
+  "tables/contacts": typeof tables_contacts;
+  "tables/emailOperations": typeof tables_emailOperations;
+  validators: typeof validators;
+}> = anyApi as any;
+
+/**
+ * A utility for referencing Convex functions in your app's public API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = api.myModule.myFunction;
+ * ```
+ */
+export const api: FilterApi<
+  typeof fullApi,
+  FunctionReference<any, "public">
+> = anyApi as any;
+
+/**
+ * A utility for referencing Convex functions in your app's internal API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = internal.myModule.myFunction;
+ * ```
+ */
+export const internal: FilterApi<
+  typeof fullApi,
+  FunctionReference<any, "internal">
+> = anyApi as any;
+
+export const components = componentsGeneric() as unknown as {};