@devwithbobby/loops 0.1.0 → 0.1.2

package/README.md

@@ -1,42 +1,49 @@
-# 🔨 Convex Component Template
+# @devwithbobby/loops
 
-[![pkg.pr.new](https://pkg.pr.new/badge/robertalv/loops-component)](https://pkg.pr.new/~/robertalv/loops-component)
+[![npm version](https://img.shields.io/npm/v/@devwithbobby/loops.svg)](https://www.npmjs.com/package/@devwithbobby/loops)
 
-A modern template for building reusable [Convex components](https://www.convex.dev/components) with Bun, TypeScript, and comprehensive testing.
+A Convex component for integrating with [Loops.so](https://loops.so) email marketing platform. Send transactional emails, manage contacts, trigger campaigns and loops, and monitor email operations with built-in spam detection and rate limiting.
 
-> **Note:** Replace `robertalv/loops-component` in the badge above with your GitHub username/organization and repository name once you set up your repository.
+## Features
 
-## Getting Started
+- ✅ **Contact Management** - Create, update, find, and delete contacts
+- ✅ **Transactional Emails** - Send one-off emails with templates
+- ✅ **Events** - Trigger email workflows based on events
+- ✅ **Campaigns** - Send campaigns to audiences or specific contacts
+- ✅ **Loops** - Trigger automated email sequences
+- ✅ **Monitoring** - Track all email operations with spam detection
+- ✅ **Rate Limiting** - Built-in rate limiting queries for abuse prevention
+- ✅ **Type-Safe** - Full TypeScript support with Zod validation
 
-### 1. Rename Your Component
-
-After cloning this template, run the rename script to customize it for your component:
+## Installation
 
 ```bash
-bun rename.ts
+npm install @devwithbobby/loops
+# or
+bun add @devwithbobby/loops
 ```
 
-The script will:
-- Prompt you for your component name (e.g., "document search", "rate limiter")
-- Ask for your NPM package name (default: `@samhoque/your-component-name`)
-- Ask for your GitHub repository (default: `samhoque/your-component-name`)
-- Automatically generate all case variants (PascalCase, camelCase, kebab-case, etc.)
-- Replace all template placeholders across the entire codebase
-- Update `package.json` with your package name
-- Optionally delete itself when done
-
-**What gets renamed:**
-- Package name in `package.json`
-- All imports and references throughout the codebase
-- Component class names, function names, and identifiers
-- Documentation examples in README and comments
+## Quick Start
+
+### 1. Install and Mount the Component
+
+In your `convex/convex.config.ts`:
+
+```typescript
+import loops from "@devwithbobby/loops/convex.config";
+import { defineApp } from "convex/server";
+
+const app = defineApp();
+app.use(loops);
+
+export default app;
+```
 
 ### 2. Set Up Environment Variables
 
 **⚠️ IMPORTANT: Set your Loops API key before using the component.**
 
 ```bash
-# Set the API key in your Convex environment variables
 npx convex env set LOOPS_API_KEY "your-loops-api-key-here"
 ```
 
@@ -44,474 +51,435 @@ npx convex env set LOOPS_API_KEY "your-loops-api-key-here"
 1. Go to Settings → Environment Variables
 2. Add `LOOPS_API_KEY` with your Loops.so API key
 
-📖 **See [ENV_SETUP.md](./ENV_SETUP.md) for detailed setup instructions and security best practices.**
-
-### 3. Install Dependencies & Start Development
-
-```bash
-bun install
-cd example && bun install && cd ..
-bun run dev:backend
-```
-
-Then in another terminal:
-```bash
-cd example
-bun run dev
-```
+Get your API key from [Loops.so Dashboard](https://app.loops.so/settings/api).
 
-## What are Convex Components?
+### 3. Use the Component
 
-Components are isolated, reusable units of Convex functionality with their own:
-- Functions (queries, mutations, actions)
-- Tables and schemas
-- File storage
-- Scheduled functions
+In your `convex/functions.ts` (or any convex file):
 
-Components plug into Convex apps (or parent components) through a public interface, enabling modular architecture with proper isolation and security.
+```typescript
+import { Loops } from "@devwithbobby/loops";
+import { components } from "./_generated/api";
+import { action } from "./_generated/server";
+import { v } from "convex/values";
+
+// Initialize the Loops client
+const loops = new Loops(components.loops);
+
+// Export functions wrapped with auth (required in production)
+export const addContact = action({
+  args: {
+    email: v.string(),
+    firstName: v.optional(v.string()),
+    lastName: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    // Add authentication check
+    const identity = await ctx.auth.getUserIdentity();
+    if (!identity) throw new Error("Unauthorized");
 
-## Project Structure
+    return await loops.addContact(ctx, args);
+  },
+});
 
-```
-src/
-  component/               # The Convex component source code
-    convex.config.ts       # Component configuration (exported via package.json)
-    schema.ts              # Convex schema definition
-    lib.ts                 # Component functions (queries, mutations)
-    _generated/            # Auto-generated Convex types (gitignored)
-
-  client/                  # Optional: Client library that runs in the app
-    index.ts               # Helper class for easier component interaction
-
-  react/                   # Optional: React components for UI
-    index.tsx              # React hooks and components
-
-test/
-  component/               # Component tests (separate from source)
-    setup.test.ts          # Test setup with module auto-discovery
-    *.test.ts              # Unit tests for the component
-
-example/
-  convex/                  # Example app that uses the component
-    convex.config.ts       # Example app configuration
-    schema.ts              # Example app schema
-    _generated/            # Auto-generated types (gitignored)
-  src/                     # Example app frontend
+export const sendWelcomeEmail = action({
+  args: {
+    email: v.string(),
+    name: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const identity = await ctx.auth.getUserIdentity();
+    if (!identity) throw new Error("Unauthorized");
+
+    // Send transactional email
+    return await loops.sendTransactional(ctx, {
+      transactionalId: "welcome-email-template-id",
+      email: args.email,
+      dataVariables: {
+        name: args.name,
+      },
+    });
+  },
+});
 ```
 
-## Key Commands
+## API Reference
 
-### Development
-```bash
-bun run dev:backend          # Start Convex dev with live component sources
-bun run build                # Build the component for distribution
-```
+### Contact Management
 
-### Testing
-```bash
-bun test                     # Run all tests
-bun test --watch             # Watch mode
-bun test --coverage          # Generate coverage reports
-bun test -t "pattern"        # Filter tests by name
-CLAUDECODE=1 bun test        # AI-friendly quiet output
-```
+#### Add or Update Contact
 
-### Linting and Formatting
-```bash
-bun run lint                 # Lint with Biome
-bun run lint:fix             # Auto-fix linting issues
-bun run format               # Format code with Biome
-bun run check                # Run both lint and format checks
-bun run check:fix            # Auto-fix all issues
+```typescript
+await loops.addContact(ctx, {
+  email: "user@example.com",
+  firstName: "John",
+  lastName: "Doe",
+  userId: "user123",
+  source: "webapp",
+  subscribed: true,
+  userGroup: "premium",
+});
 ```
 
-### Git Hooks (Lefthook)
-
-This project uses [Lefthook](https://github.com/evilmartians/lefthook) for Git hooks. Hooks are automatically installed when you run `bun install`.
+#### Update Contact
 
-**Pre-commit hook:**
-- Runs Biome check on staged files
-- Auto-fixes issues and stages the changes
-- Prevents commits with linting/formatting errors
-
-To skip hooks (not recommended):
-```bash
-git commit --no-verify
+```typescript
+await loops.updateContact(ctx, {
+  email: "user@example.com",
+  firstName: "Jane",
+  userGroup: "vip",
+});
 ```
 
-### CI/CD
+#### Find Contact
 
-The project includes a GitHub Actions workflow that runs on every push and pull request:
-
-**Workflow: Test and lint** (`.github/workflows/test-and-lint.yml`)
-- Installs dependencies with Bun
-- Builds the project
-- Publishes preview packages with `pkg.pr.new`
-- Runs all tests
-- Runs linting checks
-
-The workflow ensures code quality and prevents broken builds from being merged.
-
-#### pkg.pr.new Setup
-
-This project uses [pkg.pr.new](https://github.com/stackblitz-labs/pkg.pr.new) for continuous package previews. Each commit and PR automatically generates a preview release that can be installed without publishing to npm.
-
-**One-time setup required:**
-1. Install the [pkg.pr.new GitHub App](https://github.com/apps/pkg-pr-new) on your repository
-2. Once installed, the workflow will automatically publish preview packages on every commit/PR
+```typescript
+const contact = await loops.findContact(ctx, {
+  email: "user@example.com",
+});
+```
 
-**Using preview packages:**
-```bash
-# Install from a specific commit (Bun)
-bun add https://pkg.pr.new/robertalv/loops-component/robertalv/loops-component@COMMIT_SHA
+#### Delete Contact
 
-# Or with npm
-npm i https://pkg.pr.new/robertalv/loops-component/robertalv/loops-component@COMMIT_SHA
+```typescript
+await loops.deleteContact(ctx, {
+  email: "user@example.com",
+});
 ```
 
-Preview URLs will be posted as comments on your pull requests automatically.
-
-## Component Architecture
+#### Batch Create Contacts
 
-### 1. Component Definition
+```typescript
+await loops.batchCreateContacts(ctx, {
+  contacts: [
+    { email: "user1@example.com", firstName: "John" },
+    { email: "user2@example.com", firstName: "Jane" },
+  ],
+});
+```
 
-The component is defined in `src/component/convex.config.ts`:
+#### Unsubscribe/Resubscribe
 
 ```typescript
-import { defineComponent } from "convex/server";
-import { api } from "./_generated/api";
-
-const component = defineComponent("loopsComponent"); // Change "loopsComponent" to your component name
-component.export(api, { greet: api.lib.greet });
-export default component;
+await loops.unsubscribeContact(ctx, { email: "user@example.com" });
+await loops.resubscribeContact(ctx, { email: "user@example.com" });
 ```
 
-### 2. Package Exports
+#### Count Contacts
 
-The `package.json` exports the component using the `@convex-dev/component-source` condition:
+```typescript
+// Count all contacts
+const total = await loops.countContacts(ctx, {});
 
-```json
-{
-  "exports": {
-    "./convex.config": {
-      "@convex-dev/component-source": "./src/component/convex.config.ts"
-    }
-  }
-}
+// Count by filter
+const premium = await loops.countContacts(ctx, {
+  userGroup: "premium",
+  subscribed: true,
+});
 ```
 
-This enables live reloading during development.
+### Email Sending
 
-### 3. Component Usage
-
-Apps import and mount the component in their `convex.config.ts`:
+#### Send Transactional Email
 
 ```typescript
-import { defineApp } from "convex/server";
-import component from "@your-package/convex.config";
-
-const app = defineApp();
-app.use(component);
-export default app;
+await loops.sendTransactional(ctx, {
+  transactionalId: "template-id-from-loops",
+  email: "user@example.com",
+  dataVariables: {
+    name: "John",
+    orderId: "12345",
+  },
+});
 ```
 
-### 4. Client Library (Optional)
-
-The `src/client/` directory contains helper code that runs in the app (not the component):
+#### Send Event (Triggers Workflows)
 
 ```typescript
-export class Counter {
-  constructor(
-    private component: UseApi<typeof api>,
-    private options?: { initialValue?: number }
-  ) {}
-
-  async count(ctx: RunQueryCtx) {
-    return await ctx.runQuery(this.component.public.count, {});
-  }
-}
+await loops.sendEvent(ctx, {
+  email: "user@example.com",
+  eventName: "purchase_completed",
+  eventProperties: {
+    product: "Premium Plan",
+    amount: 99.99,
+  },
+});
 ```
 
-This pattern is useful for:
-- Hiding implementation details
-- Managing implicit dependencies (auth, env vars)
-- Providing a cleaner API surface
+#### Send Campaign
 
-## Calling Component Functions
+```typescript
+// Send to specific emails
+await loops.sendCampaign(ctx, {
+  campaignId: "campaign-id-from-loops",
+  emails: ["user1@example.com", "user2@example.com"],
+  dataVariables: { discount: "20%" },
+});
 
-### Subtransactions
+// Send to audience
+await loops.sendCampaign(ctx, {
+  campaignId: "campaign-id-from-loops",
+  audienceFilters: {
+    userGroup: "premium",
+    source: "webapp",
+  },
+});
+```
 
-Components use **subtransactions** for cross-component function calls:
+#### Trigger Loop (Automated Sequence)
 
 ```typescript
-// From the app or parent component
-const count = await ctx.runQuery(components.counter.public.count, args);
-const newCount = await ctx.runMutation(components.counter.public.increment, args);
+await loops.triggerLoop(ctx, {
+  loopId: "loop-id-from-loops",
+  email: "user@example.com",
+  dataVariables: {
+    onboardingStep: "welcome",
+  },
+});
 ```
 
-**Key semantics:**
-1. Sub-queries track reads for reactivity across components
-2. Sub-mutations contribute to the parent's ACID transaction
-3. Sub-mutations are isolated from each other (even with `Promise.all`)
-4. Parent errors roll back sub-mutations
-5. Sub-mutation errors can be caught without affecting parent
+### Monitoring & Analytics
 
-### Exposing Component Functions Publicly
-
-Components cannot be called directly from clients. The app must wrap them:
+#### Get Email Statistics
 
 ```typescript
-// in the app's convex/counter.ts
-export const count = query({
-  handler: async (ctx) => {
-    return await ctx.runQuery(components.counter.public.count, {});
-  },
+const stats = await loops.getEmailStats(ctx, {
+  timeWindowMs: 3600000, // Last hour
 });
+
+console.log(stats.totalOperations); // Total emails sent
+console.log(stats.successfulOperations); // Successful sends
+console.log(stats.failedOperations); // Failed sends
+console.log(stats.operationsByType); // Breakdown by type
+console.log(stats.uniqueRecipients); // Unique email addresses
 ```
 
-This allows the app to add auth, rate limiting, etc.
+#### Detect Spam Patterns
 
-## Working with Isolation
+```typescript
+// Detect recipients with suspicious activity
+const spamRecipients = await loops.detectRecipientSpam(ctx, {
+  timeWindowMs: 3600000,
+  maxEmailsPerRecipient: 10,
+});
 
-### Function Access Hierarchy
+// Detect actors with suspicious activity
+const spamActors = await loops.detectActorSpam(ctx, {
+  timeWindowMs: 3600000,
+  maxEmailsPerActor: 50,
+});
 
-```mermaid
-flowchart TD
-    A[Public Internet / React] --> B[App]
-    B --> C[Component1]
-    B --> D[Component2]
-    C --> E[Component3]
+// Detect rapid-fire patterns
+const rapidFire = await loops.detectRapidFirePatterns(ctx, {
+  timeWindowMs: 60000, // Last minute
+  maxEmailsPerWindow: 5,
+});
 ```
 
-- Clients can only call app functions (not component functions)
-- Apps can call their own functions and component public functions
-- Components can only call their own functions and child component public functions
-
-### Function Handles
+### Rate Limiting
 
-To allow components to call back into the app, use function handles:
+#### Check Rate Limits
 
 ```typescript
-// In the app
-const handle = await createFunctionHandle(api.myMutation);
+// Check recipient rate limit
+const recipientCheck = await loops.checkRecipientRateLimit(ctx, {
+  email: "user@example.com",
+  timeWindowMs: 3600000, // 1 hour
+  maxEmails: 10,
+});
 
-// Pass handle to component
-await ctx.runMutation(components.worker.public.process, { handler: handle });
+if (!recipientCheck.allowed) {
+  throw new Error(`Rate limit exceeded. Try again after ${recipientCheck.retryAfter}ms`);
+}
 
-// In the component
-export const process = mutation({
-  args: { handler: v.string() },
-  handler: async (ctx, args) => {
-    // Component can now call the app's function
-    const functionHandle: FunctionHandle<"mutation"> = args.handler;
-    await ctx.runMutation(functionHandle, {});
-  },
+// Check actor rate limit
+const actorCheck = await loops.checkActorRateLimit(ctx, {
+  actorId: "user123",
+  timeWindowMs: 60000, // 1 minute
+  maxEmails: 20,
+});
+
+// Check global rate limit
+const globalCheck = await loops.checkGlobalRateLimit(ctx, {
+  timeWindowMs: 60000,
+  maxEmails: 1000,
 });
 ```
 
-**Use cases:**
-- Migrations component iterating over app tables
-- Webhook handlers calling app logic
-- Background job processors
+**Example: Rate-limited email sending**
 
-### Table Access
+```typescript
+export const sendTransactionalWithRateLimit = action({
+  args: {
+    transactionalId: v.string(),
+    email: v.string(),
+    actorId: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const identity = await ctx.auth.getUserIdentity();
+    if (!identity) throw new Error("Unauthorized");
 
-Components have **isolated tables**:
-- Components can only read/write their own tables
-- Use `v.id("tableName")` for component tables
-- Use `v.string()` for IDs from other components/app
-- Use function handles to grant table access across boundaries
+    const actorId = args.actorId ?? identity.subject;
 
-### Environment Variables and Auth
+    // Check rate limit before sending
+    const rateLimitCheck = await loops.checkActorRateLimit(ctx, {
+      actorId,
+      timeWindowMs: 60000, // 1 minute
+      maxEmails: 10,
+    });
 
-Components **cannot access** `process.env` or `ctx.auth` directly. Pass them through:
+    if (!rateLimitCheck.allowed) {
+      throw new Error(
+        `Rate limit exceeded. Please try again after ${rateLimitCheck.retryAfter}ms.`
+      );
+    }
 
-```typescript
-// src/client/index.ts (runs in app context)
-class MyComponent {
-  constructor(
-    private component: UseApi<typeof api>,
-    private options?: { apiKey?: string }
-  ) {
-    this.apiKey = options?.apiKey ?? process.env.MY_API_KEY;
-  }
-
-  async doSomething(ctx: QueryCtx) {
-    return await ctx.runQuery(this.component.public.process, {
-      apiKey: this.apiKey,
-      auth: await ctx.auth.getUserIdentity(),
+    // Send email
+    return await loops.sendTransactional(ctx, {
+      ...args,
+      actorId,
     });
-  }
-}
+  },
+});
 ```
 
-### HTTP Actions
+## Using the API Helper
 
-Components cannot define HTTP routes directly. Instead, they export handlers that the app mounts:
+The component also exports an `api()` helper for easier re-exporting:
 
 ```typescript
-// src/client/index.ts
-export const httpHandler = httpAction(async (ctx, request) => {
-  // Handle HTTP request
-});
-
-// In app's convex/http.ts
-import { httpRouter } from "convex/server";
-import { httpHandler } from "@your-component/client";
-
-const http = httpRouter();
-http.route({ path: "/webhook", method: "POST", handler: httpHandler });
-export default http;
+import { Loops } from "@devwithbobby/loops";
+import { components } from "./_generated/api";
+
+const loops = new Loops(components.loops);
+
+// Export all functions at once
+export const {
+  addContact,
+  updateContact,
+  sendTransactional,
+  sendEvent,
+  sendCampaign,
+  triggerLoop,
+  countContacts,
+  // ... all other functions
+} = loops.api();
 ```
 
-### Pagination
-
-The built-in `.paginate()` doesn't work in components. Use [`convex-helpers` paginator](https://github.com/get-convex/convex-helpers) instead:
+**⚠️ Security Warning:** The `api()` helper exports functions without authentication. Always wrap these functions with auth checks in production:
 
 ```typescript
-import { paginationOptsValidator } from "convex-helpers/server/pagination";
-import { makePagination } from "convex-helpers/server/pagination";
-
-export const listItems = query({
-  args: { paginationOpts: paginationOptsValidator },
+export const addContact = action({
+  args: { email: v.string(), ... },
   handler: async (ctx, args) => {
-    return await makePagination(ctx.db.query("items"), args.paginationOpts);
+    const identity = await ctx.auth.getUserIdentity();
+    if (!identity) throw new Error("Unauthorized");
+
+    return await loops.addContact(ctx, args);
   },
 });
 ```
 
-## Testing Pattern
+## Security Best Practices
 
-This template uses `convex-test` with Bun's test runner. Tests are **separate from component source** to prevent bundling issues.
-
-### Test Setup (`test/component/setup.test.ts`)
-
-Auto-discovers component files and creates a test helper:
-
-```typescript
-import { convexTest as baseConvexTest } from "convex-test";
-import { Glob } from "bun";
-
-const glob = new Glob("**/*.ts");
-const modules: Record<string, string> = {};
-
-for await (const file of glob.scan("./src/component")) {
-  if (!file.startsWith("_generated/")) {
-    modules[file.replace(/\.ts$/, ".js")] = await Bun.file(
-      `./src/component/${file}`
-    ).text();
-  }
-}
+1. **Always add authentication** - Wrap all functions with auth checks
+2. **Use environment variables** - Store API key in Convex environment variables
+3. **Implement rate limiting** - Use the built-in rate limiting queries
+4. **Monitor for abuse** - Use spam detection queries to identify suspicious patterns
+5. **Sanitize errors** - Don't expose sensitive error details to clients
 
-export const convexTest = () => baseConvexTest(schema, modules);
-```
+See [SECURITY.md](./prds/SECURITY.md) for detailed security guidelines.
 
-### Writing Tests
+## Monitoring & Rate Limiting
 
-```typescript
-import { test, expect } from "bun:test";
-import { api } from "../../src/component/_generated/api";
-import { convexTest } from "./setup.test";
-
-test("greet returns greeting", async () => {
-  const t = convexTest();
-  const result = await t.query(api.lib.greet, { name: "Alice" });
-  expect(result).toBe("Hello, Alice!");
-});
+The component automatically logs all email operations for monitoring. Use the built-in queries to:
 
-test("with authentication", async () => {
-  const t = convexTest();
-  const asUser = t.withIdentity({ subject: "user123" });
-  const result = await asUser.query(api.lib.getCurrentUser, {});
-  expect(result.subject).toBe("user123");
-});
-```
+- Track email statistics
+- Detect spam patterns
+- Enforce rate limits
+- Monitor for abuse
 
-## Distribution
+See [MONITORING.md](./prds/MONITORING.md) and [RATE_LIMITING.md](./prds/RATE_LIMITING.md) for detailed guides.
 
-### Local Development
+## Environment Variables
 
-To use the component in another app during development:
+Set `LOOPS_API_KEY` in your Convex environment:
 
 ```bash
-bun run build
-bun pack  # or npm pack
+npx convex env set LOOPS_API_KEY "your-api-key"
 ```
 
-Then in the other app:
-```bash
-bun install ../path/to/component/your-component-0.1.0.tgz
-```
+See [ENV_SETUP.md](./prds/ENV_SETUP.md) for detailed setup instructions.
 
-### Publishing
+## Development
 
-This package is currently marked as `private` in package.json. To publish to npm:
+### Local Development
 
-1. Remove `"private": true` from package.json
-2. Run: `bun publish` (or `npm publish` if bun publish is not yet available)
+To use this component in development with live reloading:
 
-## Dashboard and Deployment
+```bash
+bun run dev:backend
+```
 
-### Component Visibility
+This starts Convex dev with `--live-component-sources` enabled, allowing changes to be reflected immediately.
 
-In the Convex dashboard, you can select each component to see:
-- Data tables
-- Functions
-- File storage
-- Logs
-- Scheduled functions
+### Building
 
-### Deployment Semantics
+```bash
+npm run build
+```
 
-1. **Function calls**: Top-level query/mutation counts as single function call (sub-calls are free)
-2. **Database bandwidth**: Component functions count bandwidth separately
-3. **Logging**: Component logs appear in dashboard and log streams
-4. **Exports**: Snapshot exports include all component data
-5. **Streaming exports**: Only include top-level app data (not components)
+### Testing
 
-## Code Style
+```bash
+npm test
+```
 
-- **Package manager**: Bun
-- **Linter/Formatter**: Biome
-- **Indentation**: Tabs
-- **Quotes**: Double quotes
-- **TypeScript**: Strict mode with extra checks
+## Project Structure
 
-## Examples
+```
+src/
+  component/               # The Convex component
+    convex.config.ts       # Component configuration
+    schema.ts              # Database schema
+    lib.ts                 # Component functions
+    validators.ts          # Zod validators
+    tables/                # Table definitions
+
+  client/                  # Client library
+    index.ts               # Loops client class
+    types.ts               # TypeScript types
+
+example/                   # Example app
+  convex/
+    example.ts             # Example usage
+```
 
-### First-Party Components
+## API Coverage
 
-All first-party components are open source:
+This component implements the following Loops.so API endpoints:
 
-- [loops-component](https://github.com/get-convex/loops-component) - Attaching components to app tables with triggers
-- [twilio](https://github.com/get-convex/twilio) - HTTP actions and webhooks
-- [aggregate](https://github.com/get-convex/aggregate) - Testing patterns
-- [migrations](https://github.com/get-convex/migrations) - Function handles and table access
+- ✅ Create/Update Contact
+- ✅ Delete Contact
+- ✅ Find Contact
+- ✅ Batch Create Contacts
+- ✅ Unsubscribe/Resubscribe Contact
+- ✅ Count Contacts (custom implementation)
+- ✅ Send Transactional Email
+- ✅ Send Event
+- ✅ Send Campaign
+- ✅ Trigger Loop
 
-## Important Notes
+## Contributing
 
-- **Generated files**: Never edit `_generated/` directories
-- **Test location**: Always place tests in `test/component/` (not `src/component/`)
-- **Component name**: Change `"loopsComponent"` in convex.config.ts to your component name
-- **Live reloading**: Enabled via `--live-component-sources` flag
-- **Peer dependencies**: Component uses the app's Convex installation
+Contributions are welcome! Please open an issue or submit a pull request.
 
-## Documentation
+## License
 
-- **[ENV_SETUP.md](./ENV_SETUP.md)** - Environment variable setup and security best practices
-- **[SECURITY.md](./SECURITY.md)** - Security considerations and guidelines
-- **[MONITORING.md](./MONITORING.md)** - Email monitoring and spam detection
-- **[RATE_LIMITING.md](./RATE_LIMITING.md)** - Rate limiting implementation guide
+Apache-2.0
 
 ## Resources
 
+- [Loops.so Documentation](https://loops.so/docs)
 - [Convex Components Documentation](https://www.convex.dev/components)
-- [Component Authoring Guide](https://docs.convex.dev/components/authoring)
 - [Convex Environment Variables](https://docs.convex.dev/production/environment-variables)
-- [convex-test](https://github.com/get-convex/convex-test)
-- [convex-helpers](https://github.com/get-convex/convex-helpers)
-- [Bun Documentation](https://bun.sh/docs)
-
-## License
-
-MIT