@devwithbobby/loops 0.1.18 → 0.1.19

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/package.json

@@ -1,16 +1,18 @@
 {
 	"name": "@devwithbobby/loops",
-	"version": "0.1.18",
+	"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,13 +59,7 @@ 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(
@@ -73,11 +68,21 @@ export class Loops {
 					"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

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 {};

package/src/component/_generated/component.ts

@@ -0,0 +1,323 @@
+/* eslint-disable */
+/**
+ * Generated `ComponentApi` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type { FunctionReference } from "convex/server";
+
+/**
+ * A utility for referencing a Convex component's exposed API.
+ *
+ * Useful when expecting a parameter like `components.myComponent`.
+ * Usage:
+ * ```ts
+ * async function myFunction(ctx: QueryCtx, component: ComponentApi) {
+ *   return ctx.runQuery(component.someFile.someQuery, { ...args });
+ * }
+ * ```
+ */
+export type ComponentApi<Name extends string | undefined = string | undefined> =
+  {
+    lib: {
+      addContact: FunctionReference<
+        "action",
+        "internal",
+        {
+          apiKey: string;
+          contact: {
+            email: string;
+            firstName?: string;
+            lastName?: string;
+            source?: string;
+            subscribed?: boolean;
+            userGroup?: string;
+            userId?: string;
+          };
+        },
+        { id?: string; success: boolean },
+        Name
+      >;
+      batchCreateContacts: FunctionReference<
+        "action",
+        "internal",
+        {
+          apiKey: string;
+          contacts: Array<{
+            email: string;
+            firstName?: string;
+            lastName?: string;
+            source?: string;
+            subscribed?: boolean;
+            userGroup?: string;
+            userId?: string;
+          }>;
+        },
+        {
+          created?: number;
+          failed?: number;
+          results?: Array<{ email: string; error?: string; success: boolean }>;
+          success: boolean;
+        },
+        Name
+      >;
+      checkActorRateLimit: FunctionReference<
+        "query",
+        "internal",
+        { actorId: string; maxEmails: number; timeWindowMs: number },
+        {
+          allowed: boolean;
+          count: number;
+          limit: number;
+          retryAfter?: number;
+          timeWindowMs: number;
+        },
+        Name
+      >;
+      checkGlobalRateLimit: FunctionReference<
+        "query",
+        "internal",
+        { maxEmails: number; timeWindowMs: number },
+        {
+          allowed: boolean;
+          count: number;
+          limit: number;
+          timeWindowMs: number;
+        },
+        Name
+      >;
+      checkRecipientRateLimit: FunctionReference<
+        "query",
+        "internal",
+        { email: string; maxEmails: number; timeWindowMs: number },
+        {
+          allowed: boolean;
+          count: number;
+          limit: number;
+          retryAfter?: number;
+          timeWindowMs: number;
+        },
+        Name
+      >;
+      countContacts: FunctionReference<
+        "query",
+        "internal",
+        { source?: string; subscribed?: boolean; userGroup?: string },
+        number,
+        Name
+      >;
+      deleteContact: FunctionReference<
+        "action",
+        "internal",
+        { apiKey: string; email: string },
+        { success: boolean },
+        Name
+      >;
+      detectActorSpam: FunctionReference<
+        "query",
+        "internal",
+        { maxEmailsPerActor?: number; timeWindowMs?: number },
+        Array<{ actorId: string; count: number; timeWindowMs: number }>,
+        Name
+      >;
+      detectRapidFirePatterns: FunctionReference<
+        "query",
+        "internal",
+        { minEmailsInWindow?: number; timeWindowMs?: number },
+        Array<{
+          actorId?: string;
+          count: number;
+          email?: string;
+          firstTimestamp: number;
+          lastTimestamp: number;
+          timeWindowMs: number;
+        }>,
+        Name
+      >;
+      detectRecipientSpam: FunctionReference<
+        "query",
+        "internal",
+        { maxEmailsPerRecipient?: number; timeWindowMs?: number },
+        Array<{ count: number; email: string; timeWindowMs: number }>,
+        Name
+      >;
+      findContact: FunctionReference<
+        "action",
+        "internal",
+        { apiKey: string; email: string },
+        {
+          contact?: {
+            createdAt?: string | null;
+            email?: string | null;
+            firstName?: string | null;
+            id?: string | null;
+            lastName?: string | null;
+            source?: string | null;
+            subscribed?: boolean | null;
+            userGroup?: string | null;
+            userId?: string | null;
+          };
+          success: boolean;
+        },
+        Name
+      >;
+      getEmailStats: FunctionReference<
+        "query",
+        "internal",
+        { timeWindowMs?: number },
+        {
+          failedOperations: number;
+          operationsByType: Record<string, number>;
+          successfulOperations: number;
+          totalOperations: number;
+          uniqueActors: number;
+          uniqueRecipients: number;
+        },
+        Name
+      >;
+      listContacts: FunctionReference<
+        "query",
+        "internal",
+        {
+          limit?: number;
+          offset?: number;
+          source?: string;
+          subscribed?: boolean;
+          userGroup?: string;
+        },
+        {
+          contacts: Array<{
+            _id: string;
+            createdAt: number;
+            email: string;
+            firstName?: string;
+            lastName?: string;
+            loopsContactId?: string;
+            source?: string;
+            subscribed: boolean;
+            updatedAt: number;
+            userGroup?: string;
+            userId?: string;
+          }>;
+          hasMore: boolean;
+          limit: number;
+          offset: number;
+          total: number;
+        },
+        Name
+      >;
+      logEmailOperation: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          actorId?: string;
+          campaignId?: string;
+          email: string;
+          eventName?: string;
+          loopId?: string;
+          messageId?: string;
+          metadata?: Record<string, any>;
+          operationType: "transactional" | "event" | "campaign" | "loop";
+          success: boolean;
+          transactionalId?: string;
+        },
+        any,
+        Name
+      >;
+      removeContact: FunctionReference<
+        "mutation",
+        "internal",
+        { email: string },
+        any,
+        Name
+      >;
+      resubscribeContact: FunctionReference<
+        "action",
+        "internal",
+        { apiKey: string; email: string },
+        { success: boolean },
+        Name
+      >;
+      sendEvent: FunctionReference<
+        "action",
+        "internal",
+        {
+          apiKey: string;
+          email: string;
+          eventName: string;
+          eventProperties?: Record<string, any>;
+        },
+        { success: boolean },
+        Name
+      >;
+      sendTransactional: FunctionReference<
+        "action",
+        "internal",
+        {
+          apiKey: string;
+          dataVariables?: Record<string, any>;
+          email: string;
+          transactionalId: string;
+        },
+        { messageId?: string; success: boolean },
+        Name
+      >;
+      storeContact: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          email: string;
+          firstName?: string;
+          lastName?: string;
+          loopsContactId?: string;
+          source?: string;
+          subscribed?: boolean;
+          userGroup?: string;
+          userId?: string;
+        },
+        any,
+        Name
+      >;
+      triggerLoop: FunctionReference<
+        "action",
+        "internal",
+        {
+          apiKey: string;
+          dataVariables?: Record<string, any>;
+          email: string;
+          eventName?: string;
+          loopId: string;
+        },
+        { success: boolean; warning?: string },
+        Name
+      >;
+      unsubscribeContact: FunctionReference<
+        "action",
+        "internal",
+        { apiKey: string; email: string },
+        { success: boolean },
+        Name
+      >;
+      updateContact: FunctionReference<
+        "action",
+        "internal",
+        {
+          apiKey: string;
+          dataVariables?: Record<string, any>;
+          email: string;
+          firstName?: string;
+          lastName?: string;
+          source?: string;
+          subscribed?: boolean;
+          userGroup?: string;
+          userId?: string;
+        },
+        { success: boolean },
+        Name
+      >;
+    };
+  };

package/src/component/_generated/{dataModel.d.ts → 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(id)` in query and mutation functions.
+ * Documents can be loaded using `db.get(tableName, 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.