@dodopayments/convex 0.1.0

package/README.md

@@ -0,0 +1,443 @@
+# `@dodopayments/convex`
+
+A TypeScript library that provides a Convex component for seamless integration of Dodo Payments into your Convex applications.
+
+> **AI Agent Integration Guide:** See the AI Agent Prompt section below for detailed instructions and guidance for AI assistants.
+
+## Documentation
+
+Detailed documentation can be found at [Dodo Payments Convex Component](https://docs.dodopayments.com/developer-resources/convex-component)
+
+## Installation
+
+```bash
+npm install @dodopayments/convex
+```
+
+## Quick Start
+
+### 1. Add Component to Convex Config
+
+```typescript
+// convex/convex.config.ts
+import { defineApp } from "convex/server";
+import dodopayments from "@dodopayments/convex/convex.config";
+
+const app = defineApp();
+app.use(dodopayments);
+export default app;
+```
+
+### 2. Set Up Environment Variables
+
+Add your environment variables in the Convex dashboard (**Settings** → **Environment Variables**). You can open the dashboard by running:
+
+```sh
+npx convex dashboard
+```
+
+Set the following variables:
+
+- `DODO_PAYMENTS_API_KEY=your-api-key`
+- `DODO_PAYMENTS_ENVIRONMENT=test_mode`
+- `DODO_PAYMENTS_WEBHOOK_SECRET=your-webhook-secret` (if using webhooks)
+
+> **Note:** Convex backend functions only read environment variables set in the Convex dashboard. `.env` files are ignored. Always set secrets in the Convex dashboard for both production and development.
+
+### 3. Create Payment Functions
+
+```typescript
+// convex/dodo.ts
+import { DodoPayments } from "@dodopayments/convex";
+import { components } from "./_generated/api";
+
+export const dodo = new DodoPayments(components.dodopayments, {
+  // This function maps your Convex user to a Dodo Payments customer
+  // Customize it based on your authentication provider and/or user database
+  identify: async (ctx) => {
+    const identity = await ctx.auth.getUserIdentity();
+    if (!identity) {
+      return null; // User is not logged in
+    }
+    
+    // Lookup user from your database
+    const user = await ctx.db.query("users")
+       .withIndex("by_auth_id", (q) => q.eq("authId", identity.subject))
+       .first();
+     if (!user) {
+       return null; // User not found in database
+     }
+     
+     return {
+       dodoCustomerId: user.dodoCustomerId, // Use stored dodoCustomerId
+       customerData: {
+         name: user.name,
+         email: user.email,
+       },
+     };
+  },
+  apiKey: process.env.DODO_PAYMENTS_API_KEY!,
+  environment: process.env.DODO_PAYMENTS_ENVIRONMENT as "test_mode" | "live_mode",
+});
+
+// Export the API methods for use in your app
+export const { checkout, customerPortal } = dodo.api();
+```
+
+### 4. Set Up Webhooks (Optional)
+
+For handling Dodo Payments webhooks, create a file `convex/http.ts`:
+
+```typescript
+// convex/http.ts
+import { httpRouter } from "convex/server";
+import { createDodoWebhookHandler } from "@dodopayments/convex";
+
+const http = httpRouter();
+
+http.route({
+  path: "/dodopayments-webhook",
+  method: "POST",
+  handler: createDodoWebhookHandler({
+    onPaymentSucceeded: async (payload) => {
+      console.log("Payment succeeded:", payload.data.payment_id);
+      // Add your logic here to handle the successful payment
+    },
+    onSubscriptionActive: async (payload) => {
+      console.log("Subscription activated:", payload.data.subscription_id);
+      // Add your logic here
+    },
+    // Add other event handlers as needed
+  }),
+});
+
+export default http;
+```
+
+Add your webhook secret in the Convex dashboard (**Settings** → **Environment Variables**):
+
+- `DODO_PAYMENTS_WEBHOOK_SECRET=your-webhook-secret`
+
+### 5. Define Payment Actions
+
+```typescript
+// convex/payments.ts
+import { action } from "./_generated/server";
+import { v } from "convex/values";
+import { checkout } from "./dodo";
+
+export const createCheckout = action({
+  args: { 
+    product_cart: v.array(v.object({
+      product_id: v.string(),
+      quantity: v.number(),
+    })),
+    returnUrl: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    return await checkout(ctx, {
+      payload: {
+        product_cart: args.product_cart,
+        return_url: args.returnUrl,
+        billing_currency: "USD",
+        feature_flags: {
+          allow_discount_code: true,
+        },
+      },
+    });
+  },
+});
+```
+
+### 6. Frontend Usage
+
+```tsx
+import { useAction } from "convex/react";
+import { api } from "../convex/_generated/api";
+
+export function CheckoutButton() {
+  const createCheckout = useAction(api.payments.createCheckout);
+
+  const handleCheckout = async () => {
+    const { checkout_url } = await createCheckout({
+      product_cart: [{ product_id: "prod_123", quantity: 1 }],
+    });
+    window.location.href = checkout_url;
+  };
+
+  return <button onClick={handleCheckout}>Buy Now</button>;
+}
+```
+
+---
+
+## Prompt for LLM
+
+```text
+You are an expert Convex developer assistant. Your task is to guide a user through integrating the @dodopayments/convex component into their existing Convex application.
+
+The @dodopayments/convex adapter provides a Convex component for Dodo Payments' Checkout, Customer Portal, and Webhook functionalities, built using the official Convex component architecture pattern.
+
+First, install the necessary package:
+
+npm install @dodopayments/convex
+
+Here's how you should structure your response:
+
+1. Ask the user which functionalities they want to integrate.
+
+"Which parts of the @dodopayments/convex component would you like to integrate into your project? You can choose one or more of the following:
+
+- Checkout Function (for handling product checkouts)
+- Customer Portal Function (for managing customer subscriptions/details)
+- Webhook Handler (for receiving Dodo Payments webhook events)
+- All (integrate all three)"
+
+2. Based on the user's selection, provide detailed integration steps for each chosen functionality.
+
+If Checkout Function is selected:
+
+Purpose: This function handles different types of checkout flows and returns checkout URLs for programmatic handling.
+
+Integration Steps:
+
+Step 1: Add the component to your Convex configuration.
+
+// convex/convex.config.ts
+import { defineApp } from "convex/server";
+import dodopayments from "@dodopayments/convex/convex.config";
+
+const app = defineApp();
+app.use(dodopayments);
+export default app;
+
+Step 2: Guide the user to set up environment variables in the Convex dashboard. Instruct them to open the dashboard by running:
+
+npx convex dashboard
+
+Then add the required environment variables (e.g., DODO_PAYMENTS_API_KEY, DODO_PAYMENTS_ENVIRONMENT, DODO_PAYMENTS_WEBHOOK_SECRET) in **Settings → Environment Variables**. Do not use .env files for backend functions.
+
+DODO_PAYMENTS_API_KEY=your-api-key
+DODO_PAYMENTS_ENVIRONMENT=test_mode
+
+Step 3: Create your payment functions file.
+
+// convex/dodo.ts
+import { DodoPayments } from "@dodopayments/convex";
+import { components } from "./_generated/api";
+
+export const dodo = new DodoPayments(components.dodopayments, {
+  // This function maps your Convex user to a Dodo Payments customer
+  // Customize it based on your authentication provider
+  identify: async (ctx) => {
+    const identity = await ctx.auth.getUserIdentity();
+    if (!identity) {
+      return null; // User is not logged in
+    }
+    
+    // Option 1: Use identity data directly
+    return {
+      dodoCustomerId: identity.subject, // Use a stable identifier for the customer ID
+      customerData: { // Optional: additional customer information
+        name: identity.name,
+        email: identity.email,
+      },
+    };
+    
+    // Lookup user from your database
+    const user = await ctx.db.query("users")
+      .withIndex("by_auth_id", (q) => q.eq("authId", identity.subject))
+      .first();
+    if (!user) {
+      return null; // User not found in database
+    }
+
+    return {
+      dodoCustomerId: user.dodoCustomerId, // Use stored dodoCustomerId
+      customerData: {
+        name: user.name,
+        email: user.email,
+      },
+    };
+  },
+  apiKey: process.env.DODO_PAYMENTS_API_KEY!,
+  environment: process.env.DODO_PAYMENTS_ENVIRONMENT as "test_mode" | "live_mode",
+});
+
+// Export the API methods for use in your app
+export const { checkout, customerPortal } = dodo.api();
+
+Step 4: Create actions that use the checkout function.
+
+// convex/payments.ts
+import { action } from "./_generated/server";
+import { v } from "convex/values";
+import { checkout } from "./dodo";
+
+// Checkout session with full feature support
+export const createCheckout = action({
+  args: { 
+    product_cart: v.array(v.object({
+      product_id: v.string(),
+      quantity: v.number(),
+    })),
+    returnUrl: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    return await checkout(ctx, {
+      payload: {
+        product_cart: args.product_cart,
+        return_url: args.returnUrl,
+        billing_currency: "USD",
+        feature_flags: {
+          allow_discount_code: true,
+        },
+      },
+    });
+  },
+});
+
+Step 5: Use in your frontend.
+
+// Your frontend component
+import { useAction } from "convex/react";
+import { api } from "../convex/_generated/api";
+
+export function CheckoutButton() {
+  const createCheckout = useAction(api.payments.createCheckout);
+
+  const handleCheckout = async () => {
+    const { checkout_url } = await createCheckout({
+      product_cart: [{ product_id: "prod_123", quantity: 1 }],
+    });
+    window.location.href = checkout_url;
+  };
+
+  return <button onClick={handleCheckout}>Buy Now</button>;
+}
+
+Configuration Details:
+
+- `checkout()`: Checkout session with full feature support using session checkout.
+- Returns: `{"checkout_url": "https://checkout.dodopayments.com/..."}`
+
+For complete API documentation, refer to:
+- Checkout Sessions: https://docs.dodopayments.com/developer-resources/checkout-session
+- One-time Payments: https://docs.dodopayments.com/api-reference/payments/post-payments
+- Subscriptions: https://docs.dodopayments.com/api-reference/subscriptions/post-subscriptions
+
+If Customer Portal Function is selected:
+
+Purpose: This function allows customers to manage their subscriptions and payment methods.
+
+Integration Steps:
+
+Follow Steps 1-3 from the Checkout Function section, then:
+
+Step 4: Create a customer portal action.
+
+// convex/payments.ts (add to existing file)
+import { action } from "./_generated/server";
+import { v } from "convex/values";
+import { customerPortal } from "./dodo";
+
+export const getCustomerPortal = action({
+  args: {
+    send_email: v.optional(v.boolean()),
+  },
+  handler: async (ctx, args) => {
+    return await customerPortal(ctx, args);
+  },
+});
+
+Step 5: Use in your frontend.
+
+// Your frontend component
+import { useAction } from "convex/react";
+import { api } from "../convex/_generated/api";
+
+export function CustomerPortalButton() {
+  const getPortal = useAction(api.payments.getCustomerPortal);
+
+  const handlePortal = async () => {
+    const { portal_url } = await getPortal({ send_email: false });
+    window.location.href = portal_url;
+  };
+
+  return <button onClick={handlePortal}>Manage Subscription</button>;
+}
+
+Configuration Details:
+- Requires authenticated user (via `identify` function).
+- `send_email`: Optional boolean to send portal link via email.
+
+If Webhook Handler is selected:
+
+Purpose: This handler processes incoming webhook events from Dodo Payments, allowing your application to react to events like successful payments or subscription changes.
+
+Integration Steps:
+
+Step 1: Add the webhook secret to your environment variables in the Convex dashboard. You can open the dashboard by running:
+
+Guide the user to open the Convex dashboard by running:
+
+npx convex dashboard
+
+In the dashboard, go to **Settings → Environment Variables** and add:
+
+- `DODO_PAYMENTS_WEBHOOK_SECRET=whsec_...`
+
+Do not use .env files for backend functions; always set secrets in the Convex dashboard.
+
+Step 2: Create a file `convex/http.ts`:
+
+// convex/http.ts
+import { httpRouter } from "convex/server";
+import { createDodoWebhookHandler } from "@dodopayments/convex";
+
+const http = httpRouter();
+
+http.route({
+  path: "/dodopayments-webhook",
+  method: "POST",
+  handler: createDodoWebhookHandler({
+    onPaymentSucceeded: async (payload) => {
+      console.log("Payment succeeded:", payload.data.payment_id);
+      // Add your logic here to handle the successful payment
+    },
+    onSubscriptionActive: async (payload) => {
+      console.log("Subscription activated:", payload.data.subscription_id);
+      // Add your logic here
+    },
+    // Add other event handlers as needed
+  }),
+});
+
+export default http;
+
+Now, you can set the webhook endpoint URL in your Dodo Payments dashboard to `https://<your-convex-deployment-url>/dodopayments-webhook`.
+
+Environment Variable Setup:
+
+Set up the following environment variables in your Convex dashboard (Settings → Environment Variables). You can open the dashboard by running:
+
+npx convex dashboard
+
+Set:
+
+- `DODO_PAYMENTS_API_KEY=your-api-key`
+- `DODO_PAYMENTS_ENVIRONMENT=test_mode`
+- `DODO_PAYMENTS_WEBHOOK_SECRET=your-webhook-secret`
+
+Usage in your component configuration:
+
+apiKey: process.env.DODO_PAYMENTS_API_KEY!
+environment: process.env.DODO_PAYMENTS_ENVIRONMENT as "test_mode" | "live_mode"
+
+Important: Never commit sensitive environment variables directly into your code. Always use Convex environment variables for all sensitive information.
+
+If the user needs assistance setting up environment variables or deployment, ask them about their specific setup and provide guidance accordingly.
+
+Run `npx convex dev` after setting up the component to generate the necessary types.
+```
+

package/dist/client/index.d.ts

@@ -0,0 +1,42 @@
+import type { CheckoutSessionPayload } from "@dodopayments/core/checkout";
+import { GenericActionCtx } from "convex/server";
+type CustomerPortalArgs = {
+    send_email?: boolean;
+};
+export interface DodoPaymentsComponent {
+    lib: {
+        checkout: any;
+        customerPortal: any;
+    };
+}
+export type DodoPaymentsClientConfig = {
+    identify: (ctx: GenericActionCtx<any>) => Promise<{
+        dodoCustomerId: string;
+        customerData?: any;
+    } | null>;
+    apiKey: string;
+    environment: "test_mode" | "live_mode";
+};
+export declare class DodoPayments {
+    component: DodoPaymentsComponent;
+    private config;
+    constructor(component: DodoPaymentsComponent, config: DodoPaymentsClientConfig);
+    /**
+     * Returns the public API methods for the Dodo Payments client.
+     */
+    api(): {
+        /**
+         * Creates a Dodo Payments checkout session.
+         * Uses session checkout with full feature support.
+         */
+        checkout: (ctx: any, args: {
+            payload: CheckoutSessionPayload;
+        }) => Promise<any>;
+        /**
+         * Retrieves a URL for the customer portal.
+         * This function is designed to be called from a public Convex query in your app.
+         */
+        customerPortal: (ctx: any, args?: CustomerPortalArgs) => Promise<any>;
+    };
+}
+export {};

package/dist/component/_generated/server.js

@@ -0,0 +1,28 @@
+import { actionGeneric } from 'convex/server';
+
+/* eslint-disable */
+/**
+ * Generated utilities for implementing server-side Convex query and mutation functions.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+
+/**
+ * Define an action in this Convex app's public API.
+ *
+ * An action is a function which can execute any JavaScript code, including non-deterministic
+ * code and code with side-effects, like calling third-party services.
+ * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive.
+ * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}.
+ *
+ * @param func - The action. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
+ */
+const action = actionGeneric;
+
+export { action };
+//# sourceMappingURL=server.js.map

package/dist/component/_generated/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","sources":["../../../src/component/_generated/server.js"],"sourcesContent":["/* eslint-disable */\n/**\n * Generated utilities for implementing server-side Convex query and mutation functions.\n *\n * THIS CODE IS AUTOMATICALLY GENERATED.\n *\n * To regenerate, run `npx convex dev`.\n * @module\n */\n\nimport {\n  actionGeneric,\n  httpActionGeneric,\n  queryGeneric,\n  mutationGeneric,\n  internalActionGeneric,\n  internalMutationGeneric,\n  internalQueryGeneric,\n} from \"convex/server\";\n\n/**\n * Define a query in this Convex app's public API.\n *\n * This function will be allowed to read your Convex database and will be accessible from the client.\n *\n * @param func - The query function. It receives a {@link QueryCtx} as its first argument.\n * @returns The wrapped query. Include this as an `export` to name it and make it accessible.\n */\nexport const query = queryGeneric;\n\n/**\n * Define a query that is only accessible from other Convex functions (but not from the client).\n *\n * This function will be allowed to read from your Convex database. It will not be accessible from the client.\n *\n * @param func - The query function. It receives a {@link QueryCtx} as its first argument.\n * @returns The wrapped query. Include this as an `export` to name it and make it accessible.\n */\nexport const internalQuery = internalQueryGeneric;\n\n/**\n * Define a mutation in this Convex app's public API.\n *\n * This function will be allowed to modify your Convex database and will be accessible from the client.\n *\n * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.\n * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.\n */\nexport const mutation = mutationGeneric;\n\n/**\n * Define a mutation that is only accessible from other Convex functions (but not from the client).\n *\n * This function will be allowed to modify your Convex database. It will not be accessible from the client.\n *\n * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.\n * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.\n */\nexport const internalMutation = internalMutationGeneric;\n\n/**\n * Define an action in this Convex app's public API.\n *\n * An action is a function which can execute any JavaScript code, including non-deterministic\n * code and code with side-effects, like calling third-party services.\n * They can be run in Convex's JavaScript environment or in Node.js using the \"use node\" directive.\n * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}.\n *\n * @param func - The action. It receives an {@link ActionCtx} as its first argument.\n * @returns The wrapped action. Include this as an `export` to name it and make it accessible.\n */\nexport const action = actionGeneric;\n\n/**\n * Define an action that is only accessible from other Convex functions (but not from the client).\n *\n * @param func - The function. It receives an {@link ActionCtx} as its first argument.\n * @returns The wrapped function. Include this as an `export` to name it and make it accessible.\n */\nexport const internalAction = internalActionGeneric;\n\n/**\n * Define a Convex HTTP action.\n *\n * @param func - The function. It receives an {@link ActionCtx} as its first argument, and a `Request` object\n * as its second.\n * @returns The wrapped endpoint function. Route a URL path to this function in `convex/http.js`.\n */\nexport const httpAction = httpActionGeneric;\n"],"names":[],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAoDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,MAAM,GAAG;;;;"}

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

@@ -0,0 +1,2 @@
+declare const _default: import("convex/server").ComponentDefinition<any>;
+export default _default;

package/dist/component/convex.config.js

@@ -0,0 +1,6 @@
+import { defineComponent } from 'convex/server';
+
+var convex_config = defineComponent("dodopayments");
+
+export { convex_config as default };
+//# sourceMappingURL=convex.config.js.map

package/dist/component/convex.config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convex.config.js","sources":["../../src/component/convex.config.ts"],"sourcesContent":["import { defineComponent } from \"convex/server\";\n\nexport default defineComponent(\"dodopayments\");\n"],"names":[],"mappings":";;AAEA,oBAAe,eAAe,CAAC,cAAc,CAAC;;;;"}

package/dist/component/lib.d.ts

@@ -0,0 +1,54 @@
+export declare const checkout: import("convex/server").RegisteredAction<"public", {
+    payload: {
+        customer?: {
+            email?: string | undefined;
+            name?: string | undefined;
+            phone_number?: string | undefined;
+        } | undefined;
+        billing_address?: {
+            street?: string | undefined;
+            city?: string | undefined;
+            state?: string | undefined;
+            zipcode?: string | undefined;
+            country: string;
+        } | undefined;
+        return_url?: string | undefined;
+        allowed_payment_method_types?: string[] | undefined;
+        billing_currency?: string | undefined;
+        show_saved_payment_methods?: boolean | undefined;
+        confirm?: boolean | undefined;
+        discount_code?: string | undefined;
+        metadata?: Record<string, string> | undefined;
+        customization?: {
+            theme?: string | undefined;
+            show_order_details?: boolean | undefined;
+            show_on_demand_tag?: boolean | undefined;
+        } | undefined;
+        feature_flags?: {
+            allow_currency_selection?: boolean | undefined;
+            allow_discount_code?: boolean | undefined;
+            allow_phone_number_collection?: boolean | undefined;
+            allow_tax_id?: boolean | undefined;
+            always_create_new_customer?: boolean | undefined;
+        } | undefined;
+        subscription_data?: {
+            trial_period_days?: number | undefined;
+        } | undefined;
+        product_cart: {
+            product_id: string;
+            quantity: number;
+        }[];
+    };
+    apiKey: string;
+    environment: "test_mode" | "live_mode";
+}, Promise<{
+    checkout_url: string;
+}>>;
+export declare const customerPortal: import("convex/server").RegisteredAction<"public", {
+    send_email?: boolean | undefined;
+    apiKey: string;
+    environment: "test_mode" | "live_mode";
+    dodoCustomerId: string;
+}, Promise<{
+    portal_url: string;
+}>>;

package/dist/component/lib.js

@@ -0,0 +1,88 @@
+import { action } from './_generated/server.js';
+import { v } from 'convex/values';
+import { buildCheckoutUrl } from '../core/dist/checkout/checkout.js';
+import DodoPayments from 'dodopayments';
+
+const checkoutSessionPayloadValidator = v.object({
+    product_cart: v.array(v.object({
+        product_id: v.string(),
+        quantity: v.number(),
+    })),
+    customer: v.optional(v.object({
+        email: v.optional(v.string()),
+        name: v.optional(v.string()),
+        phone_number: v.optional(v.string()),
+    })),
+    billing_address: v.optional(v.object({
+        street: v.optional(v.string()),
+        city: v.optional(v.string()),
+        state: v.optional(v.string()),
+        country: v.string(),
+        zipcode: v.optional(v.string()),
+    })),
+    return_url: v.optional(v.string()),
+    allowed_payment_method_types: v.optional(v.array(v.string())),
+    billing_currency: v.optional(v.string()),
+    show_saved_payment_methods: v.optional(v.boolean()),
+    confirm: v.optional(v.boolean()),
+    discount_code: v.optional(v.string()),
+    metadata: v.optional(v.record(v.string(), v.string())),
+    customization: v.optional(v.object({
+        theme: v.optional(v.string()),
+        show_order_details: v.optional(v.boolean()),
+        show_on_demand_tag: v.optional(v.boolean()),
+    })),
+    feature_flags: v.optional(v.object({
+        allow_currency_selection: v.optional(v.boolean()),
+        allow_discount_code: v.optional(v.boolean()),
+        allow_phone_number_collection: v.optional(v.boolean()),
+        allow_tax_id: v.optional(v.boolean()),
+        always_create_new_customer: v.optional(v.boolean()),
+    })),
+    subscription_data: v.optional(v.object({
+        trial_period_days: v.optional(v.number()),
+    })),
+});
+const checkout = action({
+    args: {
+        payload: checkoutSessionPayloadValidator,
+        apiKey: v.string(),
+        environment: v.union(v.literal("test_mode"), v.literal("live_mode")),
+    },
+    returns: v.object({ checkout_url: v.string() }),
+    handler: async (_, { payload, apiKey, environment }) => {
+        const checkoutUrl = await buildCheckoutUrl({
+            sessionPayload: payload,
+            bearerToken: apiKey,
+            environment,
+            type: "session",
+        });
+        return { checkout_url: checkoutUrl };
+    },
+});
+const customerPortal = action({
+    args: {
+        dodoCustomerId: v.string(),
+        send_email: v.optional(v.boolean()),
+        apiKey: v.string(),
+        environment: v.union(v.literal("test_mode"), v.literal("live_mode")),
+    },
+    returns: v.object({ portal_url: v.string() }),
+    handler: async (_, { dodoCustomerId, send_email, apiKey, environment }) => {
+        if (!dodoCustomerId) {
+            throw new Error("dodoCustomerId is required for customerPortal.");
+        }
+        const dodopayments = new DodoPayments({
+            bearerToken: apiKey,
+            environment,
+        });
+        const params = {
+            send_email: Boolean(send_email),
+        };
+        const session = await dodopayments.customers.customerPortal.create(dodoCustomerId, params);
+        return { portal_url: session.link };
+    },
+});
+
+export { checkout, customerPortal };
+//# sourceMappingURL=lib.js.map