@paid-ai/paid-node 0.4.1 → 0.5.0-alpha2

package/dist/esm/integrations/adapters/nextjs/routes.mjs

@@ -0,0 +1,235 @@
+import { nextjsAdapter } from "./base-adapter.mjs";
+import { createContactsHandler } from "../../controllers/contacts.mjs";
+import { createCustomerInvoicesHandler } from "../../controllers/invoices.mjs";
+import { createCustomersHandler, createGetCustomerHandler } from "../../controllers/customers.mjs";
+import { createOrdersHandler } from "../../controllers/orders.mjs";
+import { createProvisioningHandler } from "../../controllers/provision-users.mjs";
+import { createActivateOrderSyncHandler, createPayInvoiceHandler, createSetupIntentHandler } from "../../controllers/billing.mjs";
+/**
+ * Create a Next.js API route handler for synchronous order activation
+ *
+ * This creates an endpoint that activates an order and immediately charges
+ * the customer using a confirmation token from a payment provider.
+ *
+ * Organization ID is automatically fetched from the API key.
+ *
+ * @example
+ * ```typescript
+ * // src/app/api/orders/[orderId]/activate-sync/route.ts
+ * import { createActivateOrderSyncRoute } from '@paid-ai/paid-node/integrations/nextjs';
+ *
+ * export const POST = createActivateOrderSyncRoute({
+ *   defaultReturnUrl: process.env.NEXT_PUBLIC_BASE_URL + '/orders'
+ * });
+ * ```
+ *
+ * @example Client-side usage with route params
+ * ```typescript
+ * await fetch('/api/orders/ord_123/activate-sync', {
+ *   method: 'POST',
+ *   body: JSON.stringify({
+ *     confirmationToken: 'pi_123_secret_456',
+ *     returnUrl: 'https://example.com/return'
+ *   })
+ * });
+ * ```
+ *
+ * @example Client-side usage with body params
+ * ```typescript
+ * await fetch('/api/orders/activate-sync', {
+ *   method: 'POST',
+ *   body: JSON.stringify({
+ *     orderId: 'ord_123',
+ *     confirmationToken: 'pi_123_secret_456'
+ *   })
+ * });
+ * ```
+ */
+export function createActivateOrderSyncRoute(config = {}) {
+    const handler = createActivateOrderSyncHandler(config.defaultReturnUrl);
+    const adaptedHandler = nextjsAdapter(handler);
+    return (request, context) => adaptedHandler(request, context, config);
+}
+/**
+ * Create a Next.js API route handler for contact creation
+ *
+ * @example
+ * ```typescript
+ * // src/app/api/contacts/route.ts
+ * import { createContactsRoute } from '@paid-ai/paid-node/integrations/nextjs';
+ *
+ * export const POST = createContactsRoute();
+ * ```
+ */
+export function createContactsRoute(config = {}) {
+    const handler = createContactsHandler();
+    const adaptedHandler = nextjsAdapter(handler);
+    return (request, context) => adaptedHandler(request, context, config);
+}
+/**
+ * Create a Next.js API route handler for fetching customer invoices
+ *
+ * Organization ID is automatically fetched from the API key.
+ *
+ * @example
+ * ```typescript
+ * // src/app/api/customers/[customerExternalId]/invoices/route.ts
+ * import { createCustomerInvoicesRoute } from '@paid-ai/paid-node/integrations/nextjs';
+ *
+ * export const GET = createCustomerInvoicesRoute();
+ * ```
+ */
+export function createCustomerInvoicesRoute(config = {}) {
+    const handler = createCustomerInvoicesHandler();
+    const adaptedHandler = nextjsAdapter(handler);
+    return (request, context) => adaptedHandler(request, context, config);
+}
+/**
+ * Create a Next.js API route handler for fetching a customer by external ID
+ *
+ * @example
+ * ```typescript
+ * // src/app/api/customers/[customerExternalId]/route.ts
+ * import { createGetCustomerRoute } from '@paid-ai/paid-node/integrations/nextjs';
+ *
+ * export const GET = createGetCustomerRoute();
+ * ```
+ */
+export function createGetCustomerRoute(config = {}) {
+    const handler = createGetCustomerHandler();
+    const adaptedHandler = nextjsAdapter(handler);
+    return (request, context) => adaptedHandler(request, context, config);
+}
+/**
+ * Create a Next.js API route handler for customer creation
+ *
+ * @example
+ * ```typescript
+ * // src/app/api/customers/route.ts
+ * import { createCustomersRoute } from '@paid-ai/paid-node/integrations/nextjs';
+ *
+ * export const POST = createCustomersRoute();
+ * ```
+ *
+ * @example With custom config
+ * ```typescript
+ * export const POST = createCustomersRoute({
+ *   validate: async (body) => {
+ *     if (!body.email.includes('@company.com')) {
+ *       throw new Error('Only company emails allowed');
+ *     }
+ *   }
+ * });
+ * ```
+ */
+export function createCustomersRoute(config = {}) {
+    const handler = createCustomersHandler();
+    const adaptedHandler = nextjsAdapter(handler);
+    return (request, context) => adaptedHandler(request, context, config);
+}
+/**
+ * Create a Next.js API route handler for order creation
+ *
+ * @example
+ * ```typescript
+ * // src/app/api/orders/route.ts
+ * import { createOrdersRoute } from '@paid-ai/paid-node/integrations/nextjs';
+ *
+ * export const POST = createOrdersRoute();
+ * ```
+ *
+ * @example With auto-activation disabled
+ * ```typescript
+ * export const POST = createOrdersRoute({
+ *   helperOptions: { autoActivate: false }
+ * });
+ * ```
+ */
+export function createOrdersRoute(config = {}) {
+    const handler = createOrdersHandler(config.helperOptions);
+    const adaptedHandler = nextjsAdapter(handler);
+    return (request, context) => adaptedHandler(request, context, config);
+}
+/**
+ * Create a Next.js API route handler for invoice payment
+ *
+ * Organization ID is automatically fetched from the API key.
+ *
+ * @example
+ * ```typescript
+ * // src/app/api/invoices/[invoiceId]/pay/route.ts
+ * import { createPayInvoiceRoute } from '@paid-ai/paid-node/integrations/nextjs';
+ *
+ * export const POST = createPayInvoiceRoute();
+ * ```
+ */
+export function createPayInvoiceRoute(config = {}) {
+    const handler = createPayInvoiceHandler();
+    const adaptedHandler = nextjsAdapter(handler);
+    return (request, context) => adaptedHandler(request, context, config);
+}
+/**
+ * Create a Next.js API route handler for user provisioning
+ *
+ * This creates a single endpoint that provisions a complete user
+ * with customer, contact, and optional order.
+ *
+ * @example
+ * ```typescript
+ * // src/app/api/provision/route.ts
+ * import { createProvisioningRoute } from '@paid-ai/paid-node/integrations/nextjs';
+ *
+ * export const POST = createProvisioningRoute({
+ *   defaultAgentExternalId: process.env.PAID_AGENT_ID
+ * });
+ * ```
+ *
+ * @example Client-side usage
+ * ```typescript
+ * await fetch('/api/provision', {
+ *   method: 'POST',
+ *   body: JSON.stringify({ email: 'user@example.com' })
+ * });
+ * ```
+ */
+export function createProvisioningRoute(config = {}) {
+    const handler = createProvisioningHandler(config.orderOptions, config.defaultAgentExternalId);
+    const adaptedHandler = nextjsAdapter(handler);
+    return (request, context) => adaptedHandler(request, context, config);
+}
+/**
+ * Create a Next.js API route handler for setup intent creation
+ *
+ * Setup intents are used to add payment methods without immediate charge.
+ * This is useful for saving payment methods for future billing.
+ *
+ * Organization ID is automatically fetched from the API key.
+ *
+ * @example
+ * ```typescript
+ * // src/app/api/payment-methods/setup/route.ts
+ * import { createSetupIntentRoute } from '@paid-ai/paid-node/integrations/nextjs';
+ *
+ * export const POST = createSetupIntentRoute({
+ *   defaultReturnUrl: process.env.NEXT_PUBLIC_BASE_URL + '/billing'
+ * });
+ * ```
+ *
+ * @example Client-side usage
+ * ```typescript
+ * await fetch('/api/payment-methods/setup', {
+ *   method: 'POST',
+ *   body: JSON.stringify({
+ *     customerId: 'cus_123',
+ *     confirmationToken: 'seti_123_secret_456',
+ *     returnUrl: 'https://example.com/billing',
+ *     metadata: { source: 'settings_page' }
+ *   })
+ * });
+ * ```
+ */
+export function createSetupIntentRoute(config = {}) {
+    const handler = createSetupIntentHandler(config.defaultReturnUrl);
+    const adaptedHandler = nextjsAdapter(handler);
+    return (request, context) => adaptedHandler(request, context, config);
+}

package/dist/esm/integrations/client.d.mts

@@ -0,0 +1,49 @@
+/**
+ * Shared Paid client initialization utility
+ * Framework-agnostic
+ */
+import { PaidClient } from '../Client.mjs';
+export interface PaidClientConfig {
+    /**
+     * Paid API key - defaults to process.env.PAID_API_KEY
+     */
+    apiKey?: string;
+    /**
+     * Paid API URL - defaults to production
+     */
+    apiUrl?: string;
+}
+/**
+ * Initialize a Paid client with environment variable fallbacks
+ *
+ * @param config - Optional configuration overrides
+ * @returns Configured PaidClient instance
+ * @throws Error if API key is not provided or found in environment
+ *
+ * @example
+ * ```typescript
+ * const client = initializePaidClient();
+ * // Uses process.env.PAID_API_KEY
+ *
+ * const client = initializePaidClient({ apiKey: 'pk_xxx' });
+ * // Uses provided key
+ * ```
+ */
+export declare function initializePaidClient(config?: PaidClientConfig): PaidClient;
+/**
+ * Get organization ID from API key
+ *
+ * Calls the Paid API to resolve the organization ID associated with the API key.
+ *
+ * @param config - API configuration
+ * @returns Organization ID or null if not found
+ *
+ * @example
+ * ```typescript
+ * const orgId = await getOrganizationId({
+ *   apiKey: process.env.PAID_API_KEY,
+ *   apiUrl: 'https://api.agentpaid.io'
+ * });
+ * ```
+ */
+export declare function getOrganizationId(config?: PaidClientConfig): Promise<string | null>;

package/dist/esm/integrations/client.mjs

@@ -0,0 +1,89 @@
+/**
+ * Shared Paid client initialization utility
+ * Framework-agnostic
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { PaidClient } from '../Client.mjs';
+/**
+ * Initialize a Paid client with environment variable fallbacks
+ *
+ * @param config - Optional configuration overrides
+ * @returns Configured PaidClient instance
+ * @throws Error if API key is not provided or found in environment
+ *
+ * @example
+ * ```typescript
+ * const client = initializePaidClient();
+ * // Uses process.env.PAID_API_KEY
+ *
+ * const client = initializePaidClient({ apiKey: 'pk_xxx' });
+ * // Uses provided key
+ * ```
+ */
+export function initializePaidClient(config = {}) {
+    const apiKey = config.apiKey || process.env.PAID_API_KEY;
+    if (!apiKey) {
+        throw new Error('PAID_API_KEY not configured. Set process.env.PAID_API_KEY or pass apiKey in config.');
+    }
+    return new PaidClient({
+        token: apiKey,
+        baseUrl: config.apiUrl
+            ? `${config.apiUrl}/api/v1`
+            : process.env.PAID_API_URL
+                ? `${process.env.PAID_API_URL}/api/v1`
+                : undefined,
+    });
+}
+/**
+ * Get organization ID from API key
+ *
+ * Calls the Paid API to resolve the organization ID associated with the API key.
+ *
+ * @param config - API configuration
+ * @returns Organization ID or null if not found
+ *
+ * @example
+ * ```typescript
+ * const orgId = await getOrganizationId({
+ *   apiKey: process.env.PAID_API_KEY,
+ *   apiUrl: 'https://api.agentpaid.io'
+ * });
+ * ```
+ */
+export function getOrganizationId() {
+    return __awaiter(this, arguments, void 0, function* (config = {}) {
+        var _a;
+        const apiKey = config.apiKey || process.env.PAID_API_KEY;
+        const apiUrl = config.apiUrl || process.env.PAID_API_URL || 'https://api.agentpaid.io';
+        if (!apiKey) {
+            throw new Error('PAID_API_KEY not configured');
+        }
+        try {
+            const response = yield fetch(`${apiUrl}/api/organizations/organizationId`, {
+                method: 'GET',
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (!response.ok) {
+                console.error('Failed to get organization ID:', yield response.text());
+                return null;
+            }
+            const data = yield response.json();
+            return ((_a = data.data) === null || _a === void 0 ? void 0 : _a.organizationId) || null;
+        }
+        catch (error) {
+            console.error('Error fetching organization ID:', error);
+            return null;
+        }
+    });
+}

package/dist/esm/integrations/controllers/billing.d.mts

@@ -0,0 +1,196 @@
+export interface PayInvoiceConfig {
+    apiUrl: string;
+    apiKey: string;
+    organizationId: string;
+}
+export interface PayInvoiceRequest {
+    invoiceId: string;
+    confirmationToken: string;
+    returnUrl?: string;
+}
+export interface PayInvoiceResult {
+    success: boolean;
+    data?: any;
+}
+/**
+ * Pay an invoice with a payment confirmation token
+ * This helper processes payment for an existing invoice using a Stripe confirmation token.
+ *
+ * @param config - API configuration with organization context
+ * @param request - Payment request details
+ * @returns Payment result
+ *
+ * @example
+ * ```typescript
+ * const result = await payInvoice(
+ *   {
+ *     apiUrl: 'https://api.agentpaid.io',
+ *     apiKey: process.env.PAID_API_KEY,
+ *     organizationId: 'org_123'
+ *   },
+ *   {
+ *     invoiceId: 'inv_123',
+ *     confirmationToken: 'pm_tok_xxx',
+ *     returnUrl: 'https://example.com/thanks'
+ *   }
+ * );
+ * ```
+ */
+export declare function payInvoice(config: PayInvoiceConfig, request: PayInvoiceRequest): Promise<PayInvoiceResult>;
+interface PayInvoiceRequestWithBody {
+    invoiceId?: string;
+    confirmationToken: string;
+    returnUrl?: string;
+}
+/**
+ * Create a framework-agnostic handler for invoice payment
+ *
+ * This handler can be used with any framework adapter.
+ * Organization ID is automatically fetched from the API key.
+ *
+ * @returns Handler function
+ */
+export declare function createPayInvoiceHandler(): (request: import("../utils/base-handler.mjs").BaseRequestContext<PayInvoiceRequestWithBody, Record<string, string>>, response: import("../utils/base-handler.mjs").BaseResponseContext, config?: import("../utils/base-handler.mjs").BaseHandlerConfig) => Promise<any>;
+export interface ActivateOrderSyncConfig {
+    apiUrl: string;
+    apiKey: string;
+    organizationId: string;
+}
+export interface ActivateOrderSyncRequest {
+    orderId: string;
+    confirmationToken: string;
+    returnUrl?: string;
+}
+export interface ActivateOrderSyncResult {
+    success: boolean;
+    order: any;
+    billing: any;
+}
+/**
+ * Activate an order synchronously with payment
+ *
+ * This operation activates an order and immediately charges the customer
+ * using the provided confirmation token (from Stripe or other payment provider).
+ *
+ * @param config - API configuration with organization context
+ * @param request - Activation request with order ID and confirmation token
+ * @returns Activation result with order and billing information
+ *
+ * @example
+ * ```typescript
+ * const result = await activateOrderSync(
+ *   {
+ *     apiUrl: 'https://api.agentpaid.io',
+ *     apiKey: process.env.PAID_API_KEY,
+ *     organizationId: 'org_123'
+ *   },
+ *   {
+ *     orderId: 'ord_123',
+ *     confirmationToken: 'pi_123_secret_456',
+ *     returnUrl: 'https://example.com/return'
+ *   }
+ * );
+ * ```
+ */
+export declare function activateOrderSync(config: ActivateOrderSyncConfig, request: ActivateOrderSyncRequest): Promise<ActivateOrderSyncResult>;
+/**
+ * Internal request body type for the handler
+ */
+interface ActivateOrderSyncRequestBody {
+    orderId?: string;
+    confirmationToken: string;
+    returnUrl?: string;
+}
+/**
+ * Create a framework-agnostic handler for synchronous order activation
+ *
+ * This handler can be used with any framework adapter.
+ *
+ * @param defaultReturnUrl - Optional default return URL
+ * @returns Handler function
+ */
+export declare function createActivateOrderSyncHandler(defaultReturnUrl?: string): (request: import("../utils/base-handler.mjs").BaseRequestContext<ActivateOrderSyncRequestBody, Record<string, string>>, response: import("../utils/base-handler.mjs").BaseResponseContext, config?: import("../utils/base-handler.mjs").BaseHandlerConfig) => Promise<any>;
+export interface SetupIntentRequest {
+    customerId: string;
+    confirmationToken: string;
+    returnUrl?: string;
+    metadata?: Record<string, any>;
+}
+export interface SetupIntentResponse {
+    setupIntent: {
+        id: string;
+        client_secret: string;
+        status: string;
+        usage: string;
+        customer: string;
+    };
+    message: string;
+}
+export interface SetupIntentConfig {
+    apiUrl: string;
+    apiKey: string;
+    organizationId: string;
+}
+/**
+ * Create a setup intent for adding payment methods without immediate charge
+ *
+ * Setup intents are used to save payment methods for future use without
+ * charging the customer immediately. This is useful for:
+ * - Adding payment methods for subscription billing
+ * - Updating payment methods
+ * - Pre-authorizing payment methods
+ *
+ * @param config - API configuration with organization context
+ * @param request - Setup intent request with customer ID and confirmation token
+ * @returns Setup intent result with payment method details
+ *
+ * @example
+ * ```typescript
+ * const result = await createSetupIntent(
+ *   {
+ *     apiUrl: 'https://api.agentpaid.io',
+ *     apiKey: process.env.PAID_API_KEY,
+ *     organizationId: 'org_123'
+ *   },
+ *   {
+ *     customerId: 'cus_123',
+ *     confirmationToken: 'seti_123_secret_456',
+ *     returnUrl: 'https://example.com/return',
+ *     metadata: { source: 'web' }
+ *   }
+ * );
+ * ```
+ */
+export declare function createSetupIntent(config: SetupIntentConfig, request: SetupIntentRequest): Promise<SetupIntentResponse>;
+/**
+ * Create a framework-agnostic handler for setup intent creation
+ *
+ * This handler can be used with any framework adapter.
+ *
+ * @param defaultReturnUrl - Optional default return URL
+ * @returns Handler function
+ *
+ * @example
+ * ```typescript
+ * // Next.js API route
+ * import { createSetupIntentHandler } from '@paid-ai/paid-node/integrations';
+ *
+ * const handler = createSetupIntentHandler('https://myapp.com/billing');
+ *
+ * export async function POST(req: Request) {
+ *   return handler(
+ *     {
+ *       body: await req.json(),
+ *       headers: Object.fromEntries(req.headers),
+ *       method: 'POST'
+ *     },
+ *     {
+ *       json: (data, status = 200) => Response.json(data, { status }),
+ *       error: (message, status) => Response.json({ error: message }, { status })
+ *     }
+ *   );
+ * }
+ * ```
+ */
+export declare function createSetupIntentHandler(defaultReturnUrl?: string): (request: import("../utils/base-handler.mjs").BaseRequestContext<SetupIntentRequest, Record<string, string>>, response: import("../utils/base-handler.mjs").BaseResponseContext, config?: import("../utils/base-handler.mjs").BaseHandlerConfig) => Promise<any>;
+export {};