@devwithbobby/loops 0.1.19 → 0.2.0

package/src/component/_generated/api.ts

@@ -8,6 +8,7 @@
  * @module
  */
 
+import type * as aggregates from "../aggregates.js";
 import type * as helpers from "../helpers.js";
 import type * as http from "../http.js";
 import type * as lib from "../lib.js";
@@ -23,6 +24,7 @@ import type {
 import { anyApi, componentsGeneric } from "convex/server";
 
 const fullApi: ApiFromModules<{
+  aggregates: typeof aggregates;
   helpers: typeof helpers;
   http: typeof http;
   lib: typeof lib;
@@ -57,4 +59,191 @@ export const internal: FilterApi<
   FunctionReference<any, "internal">
 > = anyApi as any;
 
-export const components = componentsGeneric() as unknown as {};
+export const components = componentsGeneric() as unknown as {
+  contactAggregate: {
+    btree: {
+      aggregateBetween: FunctionReference<
+        "query",
+        "internal",
+        { k1?: any; k2?: any; namespace?: any },
+        { count: number; sum: number }
+      >;
+      aggregateBetweenBatch: FunctionReference<
+        "query",
+        "internal",
+        { queries: Array<{ k1?: any; k2?: any; namespace?: any }> },
+        Array<{ count: number; sum: number }>
+      >;
+      atNegativeOffset: FunctionReference<
+        "query",
+        "internal",
+        { k1?: any; k2?: any; namespace?: any; offset: number },
+        { k: any; s: number; v: any }
+      >;
+      atOffset: FunctionReference<
+        "query",
+        "internal",
+        { k1?: any; k2?: any; namespace?: any; offset: number },
+        { k: any; s: number; v: any }
+      >;
+      atOffsetBatch: FunctionReference<
+        "query",
+        "internal",
+        {
+          queries: Array<{
+            k1?: any;
+            k2?: any;
+            namespace?: any;
+            offset: number;
+          }>;
+        },
+        Array<{ k: any; s: number; v: any }>
+      >;
+      get: FunctionReference<
+        "query",
+        "internal",
+        { key: any; namespace?: any },
+        null | { k: any; s: number; v: any }
+      >;
+      offset: FunctionReference<
+        "query",
+        "internal",
+        { k1?: any; key: any; namespace?: any },
+        number
+      >;
+      offsetUntil: FunctionReference<
+        "query",
+        "internal",
+        { k2?: any; key: any; namespace?: any },
+        number
+      >;
+      paginate: FunctionReference<
+        "query",
+        "internal",
+        {
+          cursor?: string;
+          k1?: any;
+          k2?: any;
+          limit: number;
+          namespace?: any;
+          order: "asc" | "desc";
+        },
+        {
+          cursor: string;
+          isDone: boolean;
+          page: Array<{ k: any; s: number; v: any }>;
+        }
+      >;
+      paginateNamespaces: FunctionReference<
+        "query",
+        "internal",
+        { cursor?: string; limit: number },
+        { cursor: string; isDone: boolean; page: Array<any> }
+      >;
+      validate: FunctionReference<
+        "query",
+        "internal",
+        { namespace?: any },
+        any
+      >;
+    };
+    inspect: {
+      display: FunctionReference<"query", "internal", { namespace?: any }, any>;
+      dump: FunctionReference<"query", "internal", { namespace?: any }, string>;
+      inspectNode: FunctionReference<
+        "query",
+        "internal",
+        { namespace?: any; node?: string },
+        null
+      >;
+      listTreeNodes: FunctionReference<
+        "query",
+        "internal",
+        { take?: number },
+        Array<{
+          _creationTime: number;
+          _id: string;
+          aggregate?: { count: number; sum: number };
+          items: Array<{ k: any; s: number; v: any }>;
+          subtrees: Array<string>;
+        }>
+      >;
+      listTrees: FunctionReference<
+        "query",
+        "internal",
+        { take?: number },
+        Array<{
+          _creationTime: number;
+          _id: string;
+          maxNodeSize: number;
+          namespace?: any;
+          root: string;
+        }>
+      >;
+    };
+    public: {
+      clear: FunctionReference<
+        "mutation",
+        "internal",
+        { maxNodeSize?: number; namespace?: any; rootLazy?: boolean },
+        null
+      >;
+      delete_: FunctionReference<
+        "mutation",
+        "internal",
+        { key: any; namespace?: any },
+        null
+      >;
+      deleteIfExists: FunctionReference<
+        "mutation",
+        "internal",
+        { key: any; namespace?: any },
+        any
+      >;
+      init: FunctionReference<
+        "mutation",
+        "internal",
+        { maxNodeSize?: number; namespace?: any; rootLazy?: boolean },
+        null
+      >;
+      insert: FunctionReference<
+        "mutation",
+        "internal",
+        { key: any; namespace?: any; summand?: number; value: any },
+        null
+      >;
+      makeRootLazy: FunctionReference<
+        "mutation",
+        "internal",
+        { namespace?: any },
+        null
+      >;
+      replace: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          currentKey: any;
+          namespace?: any;
+          newKey: any;
+          newNamespace?: any;
+          summand?: number;
+          value: any;
+        },
+        null
+      >;
+      replaceOrInsert: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          currentKey: any;
+          namespace?: any;
+          newKey: any;
+          newNamespace?: any;
+          summand?: number;
+          value: any;
+        },
+        any
+      >;
+    };
+  };
+};

package/src/component/_generated/component.ts

@@ -42,6 +42,13 @@ export type ComponentApi<Name extends string | undefined = string | undefined> =
         { id?: string; success: boolean },
         Name
       >;
+      backfillContactAggregate: FunctionReference<
+        "mutation",
+        "internal",
+        { batchSize?: number; clear?: boolean; cursor?: string | null },
+        { cursor: string | null; isDone: boolean; processed: number },
+        Name
+      >;
       batchCreateContacts: FunctionReference<
         "action",
         "internal",
@@ -183,8 +190,8 @@ export type ComponentApi<Name extends string | undefined = string | undefined> =
         "query",
         "internal",
         {
+          cursor?: string | null;
           limit?: number;
-          offset?: number;
           source?: string;
           subscribed?: boolean;
           userGroup?: string;
@@ -203,10 +210,8 @@ export type ComponentApi<Name extends string | undefined = string | undefined> =
             userGroup?: string;
             userId?: string;
           }>;
-          hasMore: boolean;
-          limit: number;
-          offset: number;
-          total: number;
+          continueCursor: string | null;
+          isDone: boolean;
         },
         Name
       >;

package/src/component/_generated/dataModel.ts

@@ -38,7 +38,7 @@ export type Doc<TableName extends TableNames> = DocumentByName<
  * Convex documents are uniquely identified by their `Id`, which is accessible
  * on the `_id` field. To learn more, see [Document IDs](https://docs.convex.dev/using/document-ids).
  *
- * Documents can be loaded using `db.get(tableName, id)` in query and mutation functions.
+ * Documents can be loaded using `db.get(id)` in query and mutation functions.
  *
  * IDs are just strings at runtime, but this type can be used to distinguish them from other
  * strings when type checking.

package/src/component/aggregates.ts

@@ -0,0 +1,89 @@
+import { TableAggregate } from "@convex-dev/aggregate";
+import type { GenericMutationCtx, GenericQueryCtx } from "convex/server";
+import type { DataModel, Doc } from "./_generated/dataModel";
+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 as any;
+
+/**
+ * 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<{
+	Namespace: string | undefined;
+	Key: null;
+	DataModel: DataModel;
+	TableName: "contacts";
+}>(contactAggregateComponent, {
+	namespace: (doc) => doc.userGroup,
+	sortKey: () => null,
+});
+
+type MutationCtx = GenericMutationCtx<DataModel>;
+type QueryCtx = GenericQueryCtx<DataModel>;
+
+/**
+ * Insert a contact into the aggregate
+ */
+export async function aggregateInsert(
+	ctx: MutationCtx,
+	doc: Doc<"contacts">,
+): Promise<void> {
+	await contactAggregate.insertIfDoesNotExist(ctx, doc);
+}
+
+/**
+ * Delete a contact from the aggregate
+ */
+export async function aggregateDelete(
+	ctx: MutationCtx,
+	doc: Doc<"contacts">,
+): Promise<void> {
+	await contactAggregate.deleteIfExists(ctx, doc);
+}
+
+/**
+ * Replace a contact in the aggregate (when userGroup changes)
+ */
+export async function aggregateReplace(
+	ctx: MutationCtx,
+	oldDoc: Doc<"contacts">,
+	newDoc: Doc<"contacts">,
+): Promise<void> {
+	await contactAggregate.replaceOrInsert(ctx, oldDoc, newDoc);
+}
+
+/**
+ * Count contacts by userGroup namespace
+ */
+export async function aggregateCountByUserGroup(
+	ctx: QueryCtx,
+	userGroup: string | undefined,
+): Promise<number> {
+	return await contactAggregate.count(ctx, { namespace: userGroup });
+}
+
+/**
+ * Count all contacts across all userGroups
+ */
+export async function aggregateCountTotal(ctx: QueryCtx): Promise<number> {
+	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: MutationCtx,
+	namespace?: string,
+): Promise<void> {
+	await contactAggregate.clear(ctx, { namespace });
+}
+

package/src/component/convex.config.ts

@@ -1,5 +1,8 @@
+import aggregate from "@convex-dev/aggregate/convex.config";
 import { defineComponent } from "convex/server";
 
 const component = defineComponent("loops");
 
+component.use(aggregate, { name: "contactAggregate" });
+
 export default component;

package/src/component/http.ts

@@ -107,7 +107,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);
 		} catch (error) {