@devwithbobby/loops 0.1.18 → 0.2.0

package/{src → dist}/component/_generated/server.d.ts

@@ -1,4 +1,3 @@
-/* eslint-disable */
 /**
  * Generated utilities for implementing server-side Convex query and mutation functions.
  *
@@ -7,27 +6,8 @@
  * To regenerate, run `npx convex dev`.
  * @module
  */
-
-import {
-  ActionBuilder,
-  AnyComponents,
-  HttpActionBuilder,
-  MutationBuilder,
-  QueryBuilder,
-  GenericActionCtx,
-  GenericMutationCtx,
-  GenericQueryCtx,
-  GenericDatabaseReader,
-  GenericDatabaseWriter,
-  FunctionReference,
-} from "convex/server";
+import type { ActionBuilder, HttpActionBuilder, MutationBuilder, QueryBuilder, GenericActionCtx, GenericMutationCtx, GenericQueryCtx, GenericDatabaseReader, GenericDatabaseWriter } from "convex/server";
 import type { DataModel } from "./dataModel.js";
-
-type GenericCtx =
-  | GenericActionCtx<DataModel>
-  | GenericMutationCtx<DataModel>
-  | GenericQueryCtx<DataModel>;
-
 /**
  * Define a query in this Convex app's public API.
  *
@@ -37,7 +17,6 @@ type GenericCtx =
  * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
  */
 export declare const query: QueryBuilder<DataModel, "public">;
-
 /**
  * Define a query that is only accessible from other Convex functions (but not from the client).
  *
@@ -47,7 +26,6 @@ export declare const query: QueryBuilder<DataModel, "public">;
  * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
  */
 export declare const internalQuery: QueryBuilder<DataModel, "internal">;
-
 /**
  * Define a mutation in this Convex app's public API.
  *
@@ -57,7 +35,6 @@ export declare const internalQuery: QueryBuilder<DataModel, "internal">;
  * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
  */
 export declare const mutation: MutationBuilder<DataModel, "public">;
-
 /**
  * Define a mutation that is only accessible from other Convex functions (but not from the client).
  *
@@ -67,7 +44,6 @@ export declare const mutation: MutationBuilder<DataModel, "public">;
  * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
  */
 export declare const internalMutation: MutationBuilder<DataModel, "internal">;
-
 /**
  * Define an action in this Convex app's public API.
  *
@@ -80,7 +56,6 @@ export declare const internalMutation: MutationBuilder<DataModel, "internal">;
  * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
  */
 export declare const action: ActionBuilder<DataModel, "public">;
-
 /**
  * Define an action that is only accessible from other Convex functions (but not from the client).
  *
@@ -88,38 +63,36 @@ export declare const action: ActionBuilder<DataModel, "public">;
  * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
  */
 export declare const internalAction: ActionBuilder<DataModel, "internal">;
-
 /**
  * Define an HTTP action.
  *
- * This function will be used to respond to HTTP requests received by a Convex
- * deployment if the requests matches the path and method where this action
- * is routed. Be sure to route your action in `convex/http.js`.
+ * The wrapped function will be used to respond to HTTP requests received
+ * by a Convex deployment if the requests matches the path and method where
+ * this action is routed. Be sure to route your httpAction in `convex/http.js`.
  *
- * @param func - The function. It receives an {@link ActionCtx} as its first argument.
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument
+ * and a Fetch API `Request` object as its second.
  * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up.
  */
 export declare const httpAction: HttpActionBuilder;
-
 /**
  * A set of services for use within Convex query functions.
  *
  * The query context is passed as the first argument to any Convex query
  * function run on the server.
  *
- * This differs from the {@link MutationCtx} because all of the services are
- * read-only.
+ * If you're using code generation, use the `QueryCtx` type in `convex/_generated/server.d.ts` instead.
  */
 export type QueryCtx = GenericQueryCtx<DataModel>;
-
 /**
  * A set of services for use within Convex mutation functions.
  *
  * The mutation context is passed as the first argument to any Convex mutation
  * function run on the server.
+ *
+ * If you're using code generation, use the `MutationCtx` type in `convex/_generated/server.d.ts` instead.
  */
 export type MutationCtx = GenericMutationCtx<DataModel>;
-
 /**
  * A set of services for use within Convex action functions.
  *
@@ -127,7 +100,6 @@ export type MutationCtx = GenericMutationCtx<DataModel>;
  * function run on the server.
  */
 export type ActionCtx = GenericActionCtx<DataModel>;
-
 /**
  * An interface to read from the database within Convex query functions.
  *
@@ -136,7 +108,6 @@ export type ActionCtx = GenericActionCtx<DataModel>;
  * building a query.
  */
 export type DatabaseReader = GenericDatabaseReader<DataModel>;
-
 /**
  * An interface to read from and write to the database within Convex mutation
  * functions.
@@ -147,3 +118,4 @@ export type DatabaseReader = GenericDatabaseReader<DataModel>;
  * for the guarantees Convex provides your functions.
  */
 export type DatabaseWriter = GenericDatabaseWriter<DataModel>;
+//# sourceMappingURL=server.d.ts.map

package/dist/component/_generated/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/component/_generated/server.ts"],"names":[],"mappings":"AACA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACV,aAAa,EACb,iBAAiB,EACjB,eAAe,EACf,YAAY,EACZ,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,eAAe,CAAC;AAUvB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK,EAAE,YAAY,CAAC,SAAS,EAAE,QAAQ,CAAgB,CAAC;AAErE;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,EAAE,YAAY,CAAC,SAAS,EAAE,UAAU,CACxC,CAAC;AAEvB;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,EAAE,eAAe,CAAC,SAAS,EAAE,QAAQ,CAAmB,CAAC;AAE9E;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,EAAE,eAAe,CAAC,SAAS,EAAE,UAAU,CAC3C,CAAC;AAE1B;;;;;;;;;;GAUG;AACH,eAAO,MAAM,MAAM,EAAE,aAAa,CAAC,SAAS,EAAE,QAAQ,CAAiB,CAAC;AAExE;;;;;GAKG;AACH,eAAO,MAAM,cAAc,EAAE,aAAa,CAAC,SAAS,EAAE,UAAU,CACzC,CAAC;AAExB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU,EAAE,iBAAqC,CAAC;AAO/D;;;;;;;GAOG;AACH,MAAM,MAAM,QAAQ,GAAG,eAAe,CAAC,SAAS,CAAC,CAAC;AAElD;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAAC;AAExD;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,gBAAgB,CAAC,SAAS,CAAC,CAAC;AAEpD;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,qBAAqB,CAAC,SAAS,CAAC,CAAC;AAE9D;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,GAAG,qBAAqB,CAAC,SAAS,CAAC,CAAC"}

package/{src → dist}/component/_generated/server.js

@@ -7,18 +7,7 @@
  * To regenerate, run `npx convex dev`.
  * @module
  */
-
-import {
-  actionGeneric,
-  httpActionGeneric,
-  queryGeneric,
-  mutationGeneric,
-  internalActionGeneric,
-  internalMutationGeneric,
-  internalQueryGeneric,
-  componentsGeneric,
-} from "convex/server";
-
+import { actionGeneric, httpActionGeneric, queryGeneric, mutationGeneric, internalActionGeneric, internalMutationGeneric, internalQueryGeneric, } from "convex/server";
 /**
  * Define a query in this Convex app's public API.
  *
@@ -28,7 +17,6 @@ import {
  * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
  */
 export const query = queryGeneric;
-
 /**
  * Define a query that is only accessible from other Convex functions (but not from the client).
  *
@@ -38,7 +26,6 @@ export const query = queryGeneric;
  * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
  */
 export const internalQuery = internalQueryGeneric;
-
 /**
  * Define a mutation in this Convex app's public API.
  *
@@ -48,7 +35,6 @@ export const internalQuery = internalQueryGeneric;
  * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
  */
 export const mutation = mutationGeneric;
-
 /**
  * Define a mutation that is only accessible from other Convex functions (but not from the client).
  *
@@ -58,7 +44,6 @@ export const mutation = mutationGeneric;
  * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
  */
 export const internalMutation = internalMutationGeneric;
-
 /**
  * Define an action in this Convex app's public API.
  *
@@ -71,7 +56,6 @@ export const internalMutation = internalMutationGeneric;
  * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
  */
 export const action = actionGeneric;
-
 /**
  * Define an action that is only accessible from other Convex functions (but not from the client).
  *
@@ -79,12 +63,15 @@ export const action = actionGeneric;
  * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
  */
 export const internalAction = internalActionGeneric;
-
 /**
- * Define a Convex HTTP action.
+ * Define an HTTP action.
  *
- * @param func - The function. It receives an {@link ActionCtx} as its first argument, and a `Request` object
- * as its second.
- * @returns The wrapped endpoint function. Route a URL path to this function in `convex/http.js`.
+ * The wrapped function will be used to respond to HTTP requests received
+ * by a Convex deployment if the requests matches the path and method where
+ * this action is routed. Be sure to route your httpAction in `convex/http.js`.
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument
+ * and a Fetch API `Request` object as its second.
+ * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up.
  */
 export const httpAction = httpActionGeneric;

package/dist/component/aggregates.d.ts

@@ -0,0 +1,42 @@
+import { TableAggregate } from "@convex-dev/aggregate";
+import type { GenericMutationCtx, GenericQueryCtx } from "convex/server";
+import type { DataModel, Doc } from "./_generated/dataModel";
+/**
+ * Aggregate for counting contacts.
+ * Uses userGroup as namespace for efficient filtered counting.
+ * Key is null since we only need counts, not ordering.
+ */
+export declare const contactAggregate: TableAggregate<{
+    Namespace: string | undefined;
+    Key: null;
+    DataModel: DataModel;
+    TableName: "contacts";
+}>;
+type MutationCtx = GenericMutationCtx<DataModel>;
+type QueryCtx = GenericQueryCtx<DataModel>;
+/**
+ * Insert a contact into the aggregate
+ */
+export declare function aggregateInsert(ctx: MutationCtx, doc: Doc<"contacts">): Promise<void>;
+/**
+ * Delete a contact from the aggregate
+ */
+export declare function aggregateDelete(ctx: MutationCtx, doc: Doc<"contacts">): Promise<void>;
+/**
+ * Replace a contact in the aggregate (when userGroup changes)
+ */
+export declare function aggregateReplace(ctx: MutationCtx, oldDoc: Doc<"contacts">, newDoc: Doc<"contacts">): Promise<void>;
+/**
+ * Count contacts by userGroup namespace
+ */
+export declare function aggregateCountByUserGroup(ctx: QueryCtx, userGroup: string | undefined): Promise<number>;
+/**
+ * Count all contacts across all userGroups
+ */
+export declare function aggregateCountTotal(ctx: QueryCtx): Promise<number>;
+/**
+ * Clear and reinitialize the aggregate (for backfill)
+ */
+export declare function aggregateClear(ctx: MutationCtx, namespace?: string): Promise<void>;
+export {};
+//# sourceMappingURL=aggregates.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aggregates.d.ts","sourceRoot":"","sources":["../../src/component/aggregates.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,KAAK,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACzE,OAAO,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAO7D;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;eACjB,MAAM,GAAG,SAAS;SACxB,IAAI;eACE,SAAS;eACT,UAAU;EAIpB,CAAC;AAEH,KAAK,WAAW,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAAC;AACjD,KAAK,QAAQ,GAAG,eAAe,CAAC,SAAS,CAAC,CAAC;AAE3C;;GAEG;AACH,wBAAsB,eAAe,CACpC,GAAG,EAAE,WAAW,EAChB,GAAG,EAAE,GAAG,CAAC,UAAU,CAAC,GAClB,OAAO,CAAC,IAAI,CAAC,CAEf;AAED;;GAEG;AACH,wBAAsB,eAAe,CACpC,GAAG,EAAE,WAAW,EAChB,GAAG,EAAE,GAAG,CAAC,UAAU,CAAC,GAClB,OAAO,CAAC,IAAI,CAAC,CAEf;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CACrC,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,GAAG,CAAC,UAAU,CAAC,EACvB,MAAM,EAAE,GAAG,CAAC,UAAU,CAAC,GACrB,OAAO,CAAC,IAAI,CAAC,CAEf;AAED;;GAEG;AACH,wBAAsB,yBAAyB,CAC9C,GAAG,EAAE,QAAQ,EACb,SAAS,EAAE,MAAM,GAAG,SAAS,GAC3B,OAAO,CAAC,MAAM,CAAC,CAEjB;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,GAAG,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,CAMxE;AAED;;GAEG;AACH,wBAAsB,cAAc,CACnC,GAAG,EAAE,WAAW,EAChB,SAAS,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CAEf"}

package/dist/component/aggregates.js

@@ -0,0 +1,54 @@
+import { TableAggregate } from "@convex-dev/aggregate";
+import { components } from "./_generated/api";
+// Cast components to the expected type for the aggregate library
+// biome-ignore lint/suspicious/noExplicitAny: Component API type mismatch with aggregate library
+const contactAggregateComponent = components.contactAggregate;
+/**
+ * Aggregate for counting contacts.
+ * Uses userGroup as namespace for efficient filtered counting.
+ * Key is null since we only need counts, not ordering.
+ */
+export const contactAggregate = new TableAggregate(contactAggregateComponent, {
+    namespace: (doc) => doc.userGroup,
+    sortKey: () => null,
+});
+/**
+ * Insert a contact into the aggregate
+ */
+export async function aggregateInsert(ctx, doc) {
+    await contactAggregate.insertIfDoesNotExist(ctx, doc);
+}
+/**
+ * Delete a contact from the aggregate
+ */
+export async function aggregateDelete(ctx, doc) {
+    await contactAggregate.deleteIfExists(ctx, doc);
+}
+/**
+ * Replace a contact in the aggregate (when userGroup changes)
+ */
+export async function aggregateReplace(ctx, oldDoc, newDoc) {
+    await contactAggregate.replaceOrInsert(ctx, oldDoc, newDoc);
+}
+/**
+ * Count contacts by userGroup namespace
+ */
+export async function aggregateCountByUserGroup(ctx, userGroup) {
+    return await contactAggregate.count(ctx, { namespace: userGroup });
+}
+/**
+ * Count all contacts across all userGroups
+ */
+export async function aggregateCountTotal(ctx) {
+    let total = 0;
+    for await (const namespace of contactAggregate.iterNamespaces(ctx)) {
+        total += await contactAggregate.count(ctx, { namespace });
+    }
+    return total;
+}
+/**
+ * Clear and reinitialize the aggregate (for backfill)
+ */
+export async function aggregateClear(ctx, namespace) {
+    await contactAggregate.clear(ctx, { namespace });
+}

package/dist/component/convex.config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convex.config.d.ts","sourceRoot":"","sources":["../../src/component/convex.config.ts"],"names":[],"mappings":"AAGA,QAAA,MAAM,SAAS,kDAA2B,CAAC;AA4B3C,eAAe,SAAS,CAAC"}
+{"version":3,"file":"convex.config.d.ts","sourceRoot":"","sources":["../../src/component/convex.config.ts"],"names":[],"mappings":"AAGA,QAAA,MAAM,SAAS,kDAA2B,CAAC;AAI3C,eAAe,SAAS,CAAC"}

package/dist/component/convex.config.js

@@ -1,25 +1,5 @@
+import aggregate from "@convex-dev/aggregate/convex.config";
 import { defineComponent } from "convex/server";
-import { api } from "./_generated/api";
 const component = defineComponent("loops");
-component.export(api, {
-    addContact: api.lib.addContact,
-    updateContact: api.lib.updateContact,
-    findContact: api.lib.findContact,
-    batchCreateContacts: api.lib.batchCreateContacts,
-    unsubscribeContact: api.lib.unsubscribeContact,
-    resubscribeContact: api.lib.resubscribeContact,
-    countContacts: api.lib.countContacts,
-    listContacts: api.lib.listContacts,
-    sendTransactional: api.lib.sendTransactional,
-    sendEvent: api.lib.sendEvent,
-    triggerLoop: api.lib.triggerLoop,
-    deleteContact: api.lib.deleteContact,
-    detectRecipientSpam: api.lib.detectRecipientSpam,
-    detectActorSpam: api.lib.detectActorSpam,
-    getEmailStats: api.lib.getEmailStats,
-    detectRapidFirePatterns: api.lib.detectRapidFirePatterns,
-    checkRecipientRateLimit: api.lib.checkRecipientRateLimit,
-    checkActorRateLimit: api.lib.checkActorRateLimit,
-    checkGlobalRateLimit: api.lib.checkGlobalRateLimit,
-});
+component.use(aggregate, { name: "contactAggregate" });
 export default component;

package/dist/component/helpers.d.ts

@@ -1,4 +1,4 @@
-import { type HeadersInitParam } from "../types";
+import type { HeadersInitParam } from "../types";
 export declare const LOOPS_API_BASE_URL = "https://app.loops.so/api/v1";
 export declare const sanitizeLoopsError: (status: number, _errorText: string) => Error;
 export type LoopsRequestInit = Omit<RequestInit, "body"> & {

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

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/component/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAWjD,eAAO,MAAM,kBAAkB,gCAAgC,CAAC;AAEhE,eAAO,MAAM,kBAAkB,GAC9B,QAAQ,MAAM,EACd,YAAY,MAAM,KAChB,KAcF,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,WAAW,EAAE,MAAM,CAAC,GAAG;IAC1D,IAAI,CAAC,EAAE,OAAO,CAAC;CACf,CAAC;AAEF,eAAO,MAAM,UAAU,GACtB,QAAQ,MAAM,EACd,MAAM,MAAM,EACZ,OAAM,gBAAqB,sBAe3B,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,QAAQ,gBAAgB,YAQxD,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,MAAM,OAAO,EAAE,OAAO,YAAY,aAM9D,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,OAAO,YAAY,aAKhD,CAAC;AAEF,eAAO,MAAM,YAAY,GAAU,CAAC,EAAE,SAAS,OAAO,KAAG,OAAO,CAAC,CAAC,CAMjE,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,OAAO,MAAM,GAAG,IAAI,wBAWpD,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,OAAO,MAAM,GAAG,IAAI,EAAE,UAAU,MAAM,WAMrE,CAAC;AAEF,eAAO,MAAM,kBAAkB,cAQ9B,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,OAAO,OAAO,aAS1C,CAAC"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/component/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAWjD,eAAO,MAAM,kBAAkB,gCAAgC,CAAC;AAEhE,eAAO,MAAM,kBAAkB,WACtB,MAAM,cACF,MAAM,KAChB,KAcF,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,WAAW,EAAE,MAAM,CAAC,GAAG;IAC1D,IAAI,CAAC,EAAE,OAAO,CAAC;CACf,CAAC;AAEF,eAAO,MAAM,UAAU,WACd,MAAM,QACR,MAAM,SACN,gBAAgB,sBAetB,CAAC;AAEF,eAAO,MAAM,gBAAgB,WAAY,gBAAgB,YAQxD,CAAC;AAEF,eAAO,MAAM,YAAY,SAAU,OAAO,SAAS,YAAY,aAM9D,CAAC;AAEF,eAAO,MAAM,aAAa,UAAW,YAAY,aAKhD,CAAC;AAEF,eAAO,MAAM,YAAY,GAAU,CAAC,WAAW,OAAO,KAAG,OAAO,CAAC,CAAC,CAMjE,CAAC;AAEF,eAAO,MAAM,gBAAgB,UAAW,MAAM,GAAG,IAAI,wBAWpD,CAAC;AAEF,eAAO,MAAM,eAAe,UAAW,MAAM,GAAG,IAAI,YAAY,MAAM,WAMrE,CAAC;AAEF,eAAO,MAAM,kBAAkB,cAQ9B,CAAC;AAEF,eAAO,MAAM,YAAY,UAAW,OAAO,aAS1C,CAAC"}

package/dist/component/helpers.js

@@ -1,4 +1,3 @@
-import {} from "../types";
 const allowedOrigin = process.env.CONVEX_URL ??
     process.env.NEXT_PUBLIC_CONVEX_URL ??
     process.env.CONVEX_SITE_URL ??
@@ -58,7 +57,7 @@ export const readJsonBody = async (request) => {
     try {
         return (await request.json());
     }
-    catch (error) {
+    catch (_error) {
         throw new Error("Invalid JSON body");
     }
 };

package/dist/component/http.js

@@ -82,7 +82,7 @@ http.route({
                 source: url.searchParams.get("source") ?? undefined,
                 subscribed: booleanFromQuery(url.searchParams.get("subscribed")),
                 limit: numberFromQuery(url.searchParams.get("limit"), 100),
-                offset: numberFromQuery(url.searchParams.get("offset"), 0),
+                cursor: url.searchParams.get("cursor") ?? null,
             });
             return jsonResponse(data);
         }

package/dist/component/lib.d.ts

@@ -36,9 +36,15 @@ export declare const logEmailOperation: import("convex/server").RegisteredMutati
  * 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.
+ * For userGroup-only filtering, uses efficient O(log n) aggregate counting.
+ * For other filters (source, subscribed), uses indexed queries with a read limit.
+ *
+ * IMPORTANT: Before using this with existing data, run the backfillContactAggregate
+ * mutation to populate the aggregate with existing contacts.
+ *
+ * NOTE: When filtering by source or subscribed, counts are capped at MAX_COUNT_LIMIT
+ * to avoid query read limit errors. For exact counts with large datasets, use
+ * userGroup-only filtering which uses efficient aggregate counting.
  */
 export declare const countContacts: import("convex/server").RegisteredQuery<"public", {
     userGroup?: string | undefined;
@@ -46,19 +52,22 @@ export declare const countContacts: import("convex/server").RegisteredQuery<"pub
     subscribed?: boolean | undefined;
 }, Promise<number>>;
 /**
- * List contacts from the database with pagination
+ * List contacts from the database with cursor-based pagination
  * Can filter by audience criteria (userGroup, source, subscribed status)
  * Returns actual contact data, not just a count
  *
+ * Uses cursor-based pagination for efficient querying - only reads documents
+ * from the cursor position forward, not all preceding documents.
+ *
  * Note: When multiple filters are provided, only one index can be used.
- * Additional filters are applied in-memory before pagination.
+ * Additional filters are applied in-memory after fetching.
  */
 export declare const listContacts: import("convex/server").RegisteredQuery<"public", {
     limit: number;
-    offset: number;
     userGroup?: string | undefined;
     source?: string | undefined;
     subscribed?: boolean | undefined;
+    cursor?: string | null | undefined;
 }, Promise<{
     contacts: {
         _id: string;
@@ -73,10 +82,8 @@ export declare const listContacts: import("convex/server").RegisteredQuery<"publ
         userGroup?: string | undefined;
         loopsContactId?: string | undefined;
     }[];
-    total: number;
-    limit: number;
-    offset: number;
-    hasMore: boolean;
+    continueCursor: string | null;
+    isDone: boolean;
 }>>;
 /**
  * Add or update a contact in Loops
@@ -242,7 +249,10 @@ export declare const resubscribeContact: import("convex/server").RegisteredActio
 }>>;
 /**
  * Check for spam patterns: too many emails to the same recipient in a time window
- * Returns email addresses that received too many emails
+ * Returns email addresses that received too many emails.
+ *
+ * NOTE: Analysis is limited to the most recent MAX_SPAM_DETECTION_LIMIT operations
+ * in the time window to avoid query read limit errors.
  */
 export declare const detectRecipientSpam: import("convex/server").RegisteredQuery<"public", {
     timeWindowMs: number;
@@ -255,7 +265,10 @@ export declare const detectRecipientSpam: import("convex/server").RegisteredQuer
 }[]>>;
 /**
  * Check for spam patterns: too many emails from the same actor/user
- * Returns actor IDs that sent too many emails
+ * Returns actor IDs that sent too many emails.
+ *
+ * NOTE: Analysis is limited to the most recent MAX_SPAM_DETECTION_LIMIT operations
+ * in the time window to avoid query read limit errors.
  */
 export declare const detectActorSpam: import("convex/server").RegisteredQuery<"public", {
     timeWindowMs: number;
@@ -266,7 +279,11 @@ export declare const detectActorSpam: import("convex/server").RegisteredQuery<"p
     timeWindowMs: number;
 }[]>>;
 /**
- * Get recent email operation statistics for monitoring
+ * Get recent email operation statistics for monitoring.
+ *
+ * NOTE: Statistics are calculated from the most recent MAX_SPAM_DETECTION_LIMIT
+ * operations in the time window to avoid query read limit errors. For high-volume
+ * applications, consider using scheduled jobs with pagination for exact statistics.
  */
 export declare const getEmailStats: import("convex/server").RegisteredQuery<"public", {
     timeWindowMs: number;
@@ -281,7 +298,10 @@ export declare const getEmailStats: import("convex/server").RegisteredQuery<"pub
 }>>;
 /**
  * Detect rapid-fire email sending patterns (multiple emails sent in quick succession)
- * Returns suspicious patterns indicating potential spam
+ * Returns suspicious patterns indicating potential spam.
+ *
+ * NOTE: Analysis is limited to the most recent MAX_SPAM_DETECTION_LIMIT operations
+ * in the time window to avoid query read limit errors.
  */
 export declare const detectRapidFirePatterns: import("convex/server").RegisteredQuery<"public", {
     timeWindowMs: number;
@@ -296,7 +316,10 @@ export declare const detectRapidFirePatterns: import("convex/server").Registered
 }[]>>;
 /**
  * Rate limiting: Check if an email can be sent to a recipient
- * Based on recent email operations in the database
+ * Based on recent email operations in the database.
+ *
+ * Uses efficient .take() query - only reads the minimum number of documents
+ * needed to determine if the rate limit is exceeded.
  */
 export declare const checkRecipientRateLimit: import("convex/server").RegisteredQuery<"public", {
     email: string;
@@ -312,7 +335,10 @@ export declare const checkRecipientRateLimit: import("convex/server").Registered
 }>>;
 /**
  * Rate limiting: Check if an actor/user can send more emails
- * Based on recent email operations in the database
+ * Based on recent email operations in the database.
+ *
+ * Uses efficient .take() query - only reads the minimum number of documents
+ * needed to determine if the rate limit is exceeded.
  */
 export declare const checkActorRateLimit: import("convex/server").RegisteredQuery<"public", {
     actorId: string;
@@ -327,7 +353,10 @@ export declare const checkActorRateLimit: import("convex/server").RegisteredQuer
 }>>;
 /**
  * Rate limiting: Check global email sending rate
- * Checks total email operations across all senders
+ * Checks total email operations across all senders.
+ *
+ * Uses efficient .take() query - only reads the minimum number of documents
+ * needed to determine if the rate limit is exceeded.
  */
 export declare const checkGlobalRateLimit: import("convex/server").RegisteredQuery<"public", {
     timeWindowMs: number;
@@ -338,4 +367,24 @@ export declare const checkGlobalRateLimit: import("convex/server").RegisteredQue
     limit: number;
     timeWindowMs: number;
 }>>;
+/**
+ * Backfill the contact aggregate with existing contacts.
+ * Run this mutation after upgrading to a version with aggregate support.
+ *
+ * This processes contacts in batches to avoid timeout issues with large datasets.
+ * Call repeatedly with the returned cursor until isDone is true.
+ *
+ * Usage:
+ * 1. First call with clear: true to reset the aggregate
+ * 2. Subsequent calls with the returned cursor until isDone is true
+ */
+export declare const backfillContactAggregate: import("convex/server").RegisteredMutation<"public", {
+    batchSize: number;
+    cursor?: string | null | undefined;
+    clear?: boolean | undefined;
+}, Promise<{
+    processed: number;
+    cursor: string | null;
+    isDone: boolean;
+}>>;
 //# sourceMappingURL=lib.d.ts.map

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;;;;;;;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"}
+{"version":3,"file":"lib.d.ts","sourceRoot":"","sources":["../../src/component/lib.ts"],"names":[],"mappings":"AAkBA;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;iBA2DvB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;iBAiBxB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;iBAkC5B,CAAC;AAUH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,aAAa;;;;mBA8DxB,CAAC;AAEH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;GAgGvB,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;AASH;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;KA8C9B,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,eAAe;;;;;;;KA4C1B,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;GAkDxB,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;KAsGlC,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;GAiDlC,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;GA+C9B,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;GAiC/B,CAAC;AAEH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;GAsCnC,CAAC"}