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

package/dist/cjs/integrations/controllers/contacts.js

@@ -0,0 +1,145 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContactWithDefaults = createContactWithDefaults;
+exports.createContact = createContact;
+exports.createContactsHandler = createContactsHandler;
+const base_handler_js_1 = require("../utils/base-handler.js");
+function generateContactDefaults(data) {
+    var _a, _b, _c, _d, _e, _f;
+    const timestamp = Date.now();
+    const email = data.email || `contact_${timestamp}@example.com`;
+    const firstName = data.firstName || "Joe";
+    const lastName = data.lastName || "Bloggs";
+    const phone = data.phone || "";
+    const salutation = data.salutation || "Mr";
+    const billingAddress = {
+        line1: ((_a = data.billingAddress) === null || _a === void 0 ? void 0 : _a.line1) || "123 Placeholder Street",
+        line2: ((_b = data.billingAddress) === null || _b === void 0 ? void 0 : _b.line2) || "",
+        city: ((_c = data.billingAddress) === null || _c === void 0 ? void 0 : _c.city) || "London",
+        state: ((_d = data.billingAddress) === null || _d === void 0 ? void 0 : _d.state) || "London",
+        zipCode: ((_e = data.billingAddress) === null || _e === void 0 ? void 0 : _e.zipCode) || "SW1A 1AA",
+        country: ((_f = data.billingAddress) === null || _f === void 0 ? void 0 : _f.country) || "UK",
+    };
+    return {
+        customerExternalId: data.customerExternalId,
+        email,
+        firstName,
+        lastName,
+        phone,
+        salutation,
+        billingAddress,
+    };
+}
+/**
+ * Internal helper to create a contact
+ */
+function createContactInternal(client, data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const contact = yield client.contacts.create({
+            customerExternalId: data.customerExternalId,
+            salutation: data.salutation,
+            firstName: data.firstName,
+            lastName: data.lastName,
+            email: data.email,
+            phone: data.phone,
+            billingStreet: data.billingAddress.line1,
+            billingCity: data.billingAddress.city,
+            billingCountry: data.billingAddress.country,
+            billingPostalCode: data.billingAddress.zipCode,
+        });
+        if (!contact.id) {
+            throw new Error("Contact created but missing ID");
+        }
+        return {
+            id: contact.id,
+        };
+    });
+}
+/**
+ * Create a contact with defaults for missing fields
+ *
+ * This helper generates reasonable placeholder values for any missing data,
+ * making it easy to create contacts for prototyping and development.
+ *
+ * @param client - PaidClient instance
+ * @param data - Contact data (only customerExternalId is required)
+ * @returns Created contact with ID
+ *
+ * @example
+ * ```typescript
+ * const contact = await createContactWithDefaults(client, {
+ *   customerExternalId: 'user-123',
+ *   email: 'user@example.com'
+ * });
+ * // Generates: firstName, lastName, address, etc.
+ * ```
+ */
+function createContactWithDefaults(client, data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!data.customerExternalId) {
+            throw new Error("customerExternalId is required");
+        }
+        const completeData = generateContactDefaults(data);
+        return createContactInternal(client, completeData);
+    });
+}
+/**
+ * Create a contact with explicit data (NO defaults applied)
+ *
+ * Required fields: customerExternalId, email, firstName, lastName, phone, salutation,
+ * and complete billingAddress (line1, line2, city, state, zipCode, country)
+ *
+ * Use createContactWithDefaults() if you want automatic default values for missing fields.
+ *
+ * @param client - PaidClient instance
+ * @param data - Complete contact data with ALL required fields
+ * @returns Created contact with ID
+ * @throws Error if any required fields are missing
+ *
+ * @example
+ * ```typescript
+ * const contact = await createContact(client, {
+ *   customerExternalId: 'user-123',
+ *   email: 'john@example.com',
+ *   firstName: 'John',
+ *   lastName: 'Doe',
+ *   phone: '+1234567890',
+ *   salutation: 'Mr',
+ *   billingAddress: {
+ *     line1: '123 Main St',
+ *     line2: 'Suite 100',
+ *     city: 'San Francisco',
+ *     state: 'CA',
+ *     zipCode: '94105',
+ *     country: 'US'
+ *   }
+ * });
+ * ```
+ */
+function createContact(client, data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return createContactInternal(client, data);
+    });
+}
+/**
+ * Create a framework-agnostic handler for contact creation
+ *
+ * This handler can be used with any framework adapter.
+ *
+ * @returns Handler function
+ */
+function createContactsHandler() {
+    return (0, base_handler_js_1.createHandler)((client, body) => __awaiter(this, void 0, void 0, function* () {
+        const contact = yield createContactWithDefaults(client, body);
+        return { success: true, data: contact };
+    }), { requiredFields: ['customerExternalId'] });
+}

package/dist/cjs/integrations/controllers/customers.d.ts

@@ -0,0 +1,96 @@
+import { PaidClient } from "../../Client.js";
+import type { CustomerData, CustomerCreationResult, Address } from "../types.js";
+/**
+ * Create a customer with defaults for missing fields
+ *
+ * This helper generates reasonable placeholder values for any missing data,
+ * making it easy to create customers for prototyping and development.
+ *
+ * @param client - PaidClient instance
+ * @param data - Customer data (only externalId is required)
+ * @returns Created customer with ID
+ *
+ * @example
+ * ```typescript
+ * const customer = await createCustomerWithDefaults(client, {
+ *   externalId: 'user-123',
+ *   email: 'user@example.com'
+ * });
+ * // Generates: name, address, etc.
+ * ```
+ */
+export declare function createCustomerWithDefaults(client: PaidClient, data: CustomerData): Promise<CustomerCreationResult>;
+/**
+ * Create a customer with explicit data (NO defaults applied)
+ *
+ * Required fields: externalId, name, email, and complete billingAddress
+ * (line1, line2, city, state, zipCode, country)
+ *
+ * Use createCustomerWithDefaults() if you want automatic default values for missing fields.
+ *
+ * @param client - PaidClient instance
+ * @param data - Complete customer data with ALL required fields
+ * @returns Created customer with ID
+ * @throws Error if any required fields are missing
+ *
+ * @example
+ * ```typescript
+ * const customer = await createCustomer(client, {
+ *   externalId: 'user-123',
+ *   email: 'user@example.com',
+ *   name: 'John Doe',
+ *   billingAddress: {
+ *     line1: '123 Main St',
+ *     line2: '',
+ *     city: 'San Francisco',
+ *     state: 'CA',
+ *     zipCode: '94105',
+ *     country: 'US'
+ *   }
+ * });
+ * ```
+ */
+export declare function createCustomer(client: PaidClient, data: Required<Omit<CustomerData, 'firstName' | 'lastName' | 'company' | 'phone' | 'metadata' | 'billingAddress'>> & {
+    billingAddress: Required<Address>;
+}): Promise<CustomerCreationResult>;
+/**
+ * Create a framework-agnostic handler for customer creation
+ *
+ * This handler can be used with any framework adapter.
+ *
+ * @returns Handler function
+ */
+export declare function createCustomersHandler(): (request: import("../utils/base-handler.js").BaseRequestContext<CustomerData, Record<string, string>>, response: import("../utils/base-handler.js").BaseResponseContext, config?: import("../utils/base-handler.js").BaseHandlerConfig) => Promise<any>;
+/**
+ * Get a customer by external ID
+ *
+ * @param client - PaidClient instance
+ * @param customerExternalId - Customer's external ID
+ * @returns Customer data
+ *
+ * @example
+ * ```typescript
+ * const customer = await getCustomer(client, 'user-123');
+ * console.log(customer.name, customer.email);
+ * ```
+ */
+export declare function getCustomer(client: PaidClient, customerExternalId: string): Promise<any>;
+/**
+ * Create a framework-agnostic handler for fetching a customer by external ID
+ *
+ * This handler can be used with any framework adapter.
+ * The customer external ID should be provided either in params or query string.
+ *
+ * @returns Handler function
+ *
+ * @example
+ * ```typescript
+ * // In Next.js route: /api/customers/[customerExternalId]/route.ts
+ * import { createGetCustomerHandler } from '@paid-ai/paid-node/integrations';
+ * import { nextjsAdapter } from '@paid-ai/paid-node/integrations/nextjs';
+ *
+ * const handler = createGetCustomerHandler();
+ * export const GET = nextjsAdapter(handler);
+ * ```
+ */
+export declare function createGetCustomerHandler(): (request: import("../utils/base-handler.js").BaseRequestContext<any, Record<string, string>>, response: import("../utils/base-handler.js").BaseResponseContext, config?: import("../utils/base-handler.js").BaseHandlerConfig) => Promise<any>;

package/dist/cjs/integrations/controllers/customers.js

@@ -0,0 +1,206 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCustomerWithDefaults = createCustomerWithDefaults;
+exports.createCustomer = createCustomer;
+exports.createCustomersHandler = createCustomersHandler;
+exports.getCustomer = getCustomer;
+exports.createGetCustomerHandler = createGetCustomerHandler;
+const base_handler_js_1 = require("../utils/base-handler.js");
+/**
+ * Generate placeholder values for missing customer fields
+ * Creates valid but fake data for rapid prototyping
+ */
+function generateCustomerDefaults(data) {
+    var _a, _b, _c, _d, _e, _f;
+    const timestamp = Date.now();
+    const randomId = Math.random().toString(36).substring(7);
+    const email = data.email || `user_${timestamp}@example.com`;
+    const name = data.name || `User ${randomId}`;
+    const nameParts = name.split(" ");
+    const firstName = data.firstName || nameParts[0] || "Joe";
+    const lastName = data.lastName || nameParts.slice(1).join(" ") || "Bloggs";
+    const billingAddress = {
+        line1: ((_a = data.billingAddress) === null || _a === void 0 ? void 0 : _a.line1) || "123 Placeholder Street",
+        line2: ((_b = data.billingAddress) === null || _b === void 0 ? void 0 : _b.line2) || "",
+        city: ((_c = data.billingAddress) === null || _c === void 0 ? void 0 : _c.city) || "London",
+        state: ((_d = data.billingAddress) === null || _d === void 0 ? void 0 : _d.state) || "London",
+        zipCode: ((_e = data.billingAddress) === null || _e === void 0 ? void 0 : _e.zipCode) || "SW1A 1AA",
+        country: ((_f = data.billingAddress) === null || _f === void 0 ? void 0 : _f.country) || "UK",
+    };
+    return {
+        externalId: data.externalId,
+        email,
+        name,
+        firstName,
+        lastName,
+        company: data.company || "",
+        phone: data.phone || "",
+        billingAddress,
+        metadata: data.metadata || {},
+    };
+}
+/**
+ * Internal helper to create a customer
+ */
+function createCustomerInternal(client, data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const customer = yield client.customers.create({
+            externalId: data.externalId,
+            name: data.name,
+            billingAddress: {
+                line1: data.billingAddress.line1,
+                line2: data.billingAddress.line2,
+                city: data.billingAddress.city,
+                state: data.billingAddress.state,
+                zipCode: data.billingAddress.zipCode,
+                country: data.billingAddress.country,
+            },
+        });
+        if (!customer.id) {
+            throw new Error("Customer created but missing ID");
+        }
+        return {
+            id: customer.id,
+            externalId: data.externalId,
+        };
+    });
+}
+/**
+ * Create a customer with defaults for missing fields
+ *
+ * This helper generates reasonable placeholder values for any missing data,
+ * making it easy to create customers for prototyping and development.
+ *
+ * @param client - PaidClient instance
+ * @param data - Customer data (only externalId is required)
+ * @returns Created customer with ID
+ *
+ * @example
+ * ```typescript
+ * const customer = await createCustomerWithDefaults(client, {
+ *   externalId: 'user-123',
+ *   email: 'user@example.com'
+ * });
+ * // Generates: name, address, etc.
+ * ```
+ */
+function createCustomerWithDefaults(client, data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const completeData = generateCustomerDefaults(data);
+        return createCustomerInternal(client, completeData);
+    });
+}
+/**
+ * Create a customer with explicit data (NO defaults applied)
+ *
+ * Required fields: externalId, name, email, and complete billingAddress
+ * (line1, line2, city, state, zipCode, country)
+ *
+ * Use createCustomerWithDefaults() if you want automatic default values for missing fields.
+ *
+ * @param client - PaidClient instance
+ * @param data - Complete customer data with ALL required fields
+ * @returns Created customer with ID
+ * @throws Error if any required fields are missing
+ *
+ * @example
+ * ```typescript
+ * const customer = await createCustomer(client, {
+ *   externalId: 'user-123',
+ *   email: 'user@example.com',
+ *   name: 'John Doe',
+ *   billingAddress: {
+ *     line1: '123 Main St',
+ *     line2: '',
+ *     city: 'San Francisco',
+ *     state: 'CA',
+ *     zipCode: '94105',
+ *     country: 'US'
+ *   }
+ * });
+ * ```
+ */
+function createCustomer(client, data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return createCustomerInternal(client, data);
+    });
+}
+/**
+ * Create a framework-agnostic handler for customer creation
+ *
+ * This handler can be used with any framework adapter.
+ *
+ * @returns Handler function
+ */
+function createCustomersHandler() {
+    return (0, base_handler_js_1.createHandler)((client, body) => __awaiter(this, void 0, void 0, function* () {
+        if (!body.externalId) {
+            throw new Error("externalId is required");
+        }
+        const customer = yield createCustomerWithDefaults(client, body);
+        return { success: true, data: customer };
+    }), { requiredFields: ['externalId'] });
+}
+/**
+ * Get a customer by external ID
+ *
+ * @param client - PaidClient instance
+ * @param customerExternalId - Customer's external ID
+ * @returns Customer data
+ *
+ * @example
+ * ```typescript
+ * const customer = await getCustomer(client, 'user-123');
+ * console.log(customer.name, customer.email);
+ * ```
+ */
+function getCustomer(client, customerExternalId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const customer = yield client.customers.getByExternalId(customerExternalId);
+        return customer;
+    });
+}
+/**
+ * Create a framework-agnostic handler for fetching a customer by external ID
+ *
+ * This handler can be used with any framework adapter.
+ * The customer external ID should be provided either in params or query string.
+ *
+ * @returns Handler function
+ *
+ * @example
+ * ```typescript
+ * // In Next.js route: /api/customers/[customerExternalId]/route.ts
+ * import { createGetCustomerHandler } from '@paid-ai/paid-node/integrations';
+ * import { nextjsAdapter } from '@paid-ai/paid-node/integrations/nextjs';
+ *
+ * const handler = createGetCustomerHandler();
+ * export const GET = nextjsAdapter(handler);
+ * ```
+ */
+function createGetCustomerHandler() {
+    return (0, base_handler_js_1.createHandler)((client, _body, params) => __awaiter(this, void 0, void 0, function* () {
+        const customerExternalId = params === null || params === void 0 ? void 0 : params.customerExternalId;
+        if (!customerExternalId) {
+            return {
+                success: false,
+                error: "customerExternalId is required",
+                status: 400,
+            };
+        }
+        const customer = yield getCustomer(client, customerExternalId);
+        return { success: true, data: customer };
+    }), {
+        allowedMethods: ['GET'],
+        requireOrganizationId: false,
+    });
+}

package/dist/cjs/integrations/controllers/index.d.ts

@@ -0,0 +1,6 @@
+export { createCustomer, createCustomerWithDefaults, getCustomer, createGetCustomerHandler, createCustomersHandler, } from "./customers.js";
+export { createContact, createContactWithDefaults, createContactsHandler, } from "./contacts.js";
+export { createOrder, createOrderWithDefaults, createOrdersHandler, } from "./orders.js";
+export { payInvoice, createPayInvoiceHandler, type PayInvoiceConfig, type PayInvoiceRequest, type PayInvoiceResult, activateOrderSync, createActivateOrderSyncHandler, type ActivateOrderSyncConfig, type ActivateOrderSyncRequest, type ActivateOrderSyncResult, createSetupIntent, createSetupIntentHandler, type SetupIntentConfig, type SetupIntentRequest, type SetupIntentResponse, } from "./billing.js";
+export { getCustomerInvoices, createCustomerInvoicesHandler, type CustomerInvoicesResult, } from "./invoices.js";
+export { provisionNewUser, createProvisioningHandler, } from "./provision-users.js";

package/dist/cjs/integrations/controllers/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProvisioningHandler = exports.provisionNewUser = exports.createCustomerInvoicesHandler = exports.getCustomerInvoices = exports.createSetupIntentHandler = exports.createSetupIntent = exports.createActivateOrderSyncHandler = exports.activateOrderSync = exports.createPayInvoiceHandler = exports.payInvoice = exports.createOrdersHandler = exports.createOrderWithDefaults = exports.createOrder = exports.createContactsHandler = exports.createContactWithDefaults = exports.createContact = exports.createCustomersHandler = exports.createGetCustomerHandler = exports.getCustomer = exports.createCustomerWithDefaults = exports.createCustomer = void 0;
+var customers_js_1 = require("./customers.js");
+Object.defineProperty(exports, "createCustomer", { enumerable: true, get: function () { return customers_js_1.createCustomer; } });
+Object.defineProperty(exports, "createCustomerWithDefaults", { enumerable: true, get: function () { return customers_js_1.createCustomerWithDefaults; } });
+Object.defineProperty(exports, "getCustomer", { enumerable: true, get: function () { return customers_js_1.getCustomer; } });
+Object.defineProperty(exports, "createGetCustomerHandler", { enumerable: true, get: function () { return customers_js_1.createGetCustomerHandler; } });
+Object.defineProperty(exports, "createCustomersHandler", { enumerable: true, get: function () { return customers_js_1.createCustomersHandler; } });
+var contacts_js_1 = require("./contacts.js");
+Object.defineProperty(exports, "createContact", { enumerable: true, get: function () { return contacts_js_1.createContact; } });
+Object.defineProperty(exports, "createContactWithDefaults", { enumerable: true, get: function () { return contacts_js_1.createContactWithDefaults; } });
+Object.defineProperty(exports, "createContactsHandler", { enumerable: true, get: function () { return contacts_js_1.createContactsHandler; } });
+var orders_js_1 = require("./orders.js");
+Object.defineProperty(exports, "createOrder", { enumerable: true, get: function () { return orders_js_1.createOrder; } });
+Object.defineProperty(exports, "createOrderWithDefaults", { enumerable: true, get: function () { return orders_js_1.createOrderWithDefaults; } });
+Object.defineProperty(exports, "createOrdersHandler", { enumerable: true, get: function () { return orders_js_1.createOrdersHandler; } });
+var billing_js_1 = require("./billing.js");
+Object.defineProperty(exports, "payInvoice", { enumerable: true, get: function () { return billing_js_1.payInvoice; } });
+Object.defineProperty(exports, "createPayInvoiceHandler", { enumerable: true, get: function () { return billing_js_1.createPayInvoiceHandler; } });
+Object.defineProperty(exports, "activateOrderSync", { enumerable: true, get: function () { return billing_js_1.activateOrderSync; } });
+Object.defineProperty(exports, "createActivateOrderSyncHandler", { enumerable: true, get: function () { return billing_js_1.createActivateOrderSyncHandler; } });
+Object.defineProperty(exports, "createSetupIntent", { enumerable: true, get: function () { return billing_js_1.createSetupIntent; } });
+Object.defineProperty(exports, "createSetupIntentHandler", { enumerable: true, get: function () { return billing_js_1.createSetupIntentHandler; } });
+var invoices_js_1 = require("./invoices.js");
+Object.defineProperty(exports, "getCustomerInvoices", { enumerable: true, get: function () { return invoices_js_1.getCustomerInvoices; } });
+Object.defineProperty(exports, "createCustomerInvoicesHandler", { enumerable: true, get: function () { return invoices_js_1.createCustomerInvoicesHandler; } });
+var provision_users_js_1 = require("./provision-users.js");
+Object.defineProperty(exports, "provisionNewUser", { enumerable: true, get: function () { return provision_users_js_1.provisionNewUser; } });
+Object.defineProperty(exports, "createProvisioningHandler", { enumerable: true, get: function () { return provision_users_js_1.createProvisioningHandler; } });

package/dist/cjs/integrations/controllers/invoices.d.ts

@@ -0,0 +1,40 @@
+import { PayInvoiceConfig } from "./billing.js";
+export interface CustomerInvoicesResult {
+    data: any[];
+}
+/**
+ * Get customer invoices
+ * Fetches all invoices for a customer by their external ID.
+ *
+ * @param config - API configuration with organization context
+ * @param customerExternalId - Customer's external ID
+ * @returns Customer invoices
+ *
+ * @example
+ * ```typescript
+ * const result = await getCustomerInvoices(
+ *   {
+ *     apiUrl: 'https://api.agentpaid.io',
+ *     apiKey: process.env.PAID_API_KEY,
+ *     organizationId: 'org_123'
+ *   },
+ *   'user-123'
+ * );
+ *
+ * console.log(`Found ${result.data.length} invoices`);
+ * ```
+ */
+export declare function getCustomerInvoices(config: PayInvoiceConfig, customerExternalId: string): Promise<CustomerInvoicesResult>;
+interface CustomerInvoicesRequest {
+    customerExternalId: string;
+}
+/**
+ * Create a framework-agnostic handler for fetching customer invoices
+ *
+ * This handler can be used with any framework adapter.
+ * Organization ID is automatically fetched from the API key.
+ *
+ * @returns Handler function
+ */
+export declare function createCustomerInvoicesHandler(): (request: import("../utils/base-handler.js").BaseRequestContext<CustomerInvoicesRequest, Record<string, string>>, response: import("../utils/base-handler.js").BaseResponseContext, config?: import("../utils/base-handler.js").BaseHandlerConfig) => Promise<any>;
+export {};

package/dist/cjs/integrations/controllers/invoices.js

@@ -0,0 +1,72 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCustomerInvoices = getCustomerInvoices;
+exports.createCustomerInvoicesHandler = createCustomerInvoicesHandler;
+const api_fetch_js_1 = require("../utils/api-fetch.js");
+const base_handler_js_1 = require("../utils/base-handler.js");
+/**
+ * Get customer invoices
+ * Fetches all invoices for a customer by their external ID.
+ *
+ * @param config - API configuration with organization context
+ * @param customerExternalId - Customer's external ID
+ * @returns Customer invoices
+ *
+ * @example
+ * ```typescript
+ * const result = await getCustomerInvoices(
+ *   {
+ *     apiUrl: 'https://api.agentpaid.io',
+ *     apiKey: process.env.PAID_API_KEY,
+ *     organizationId: 'org_123'
+ *   },
+ *   'user-123'
+ * );
+ *
+ * console.log(`Found ${result.data.length} invoices`);
+ * ```
+ */
+function getCustomerInvoices(config, customerExternalId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!customerExternalId) {
+            throw new Error("customerExternalId is required");
+        }
+        const data = yield (0, api_fetch_js_1.paidApiFetch)(config, `/api/organizations/${config.organizationId}/customer/external/${customerExternalId}/invoices`, { method: "GET" });
+        return { data: data.data || data || [] };
+    });
+}
+/**
+ * Create a framework-agnostic handler for fetching customer invoices
+ *
+ * This handler can be used with any framework adapter.
+ * Organization ID is automatically fetched from the API key.
+ *
+ * @returns Handler function
+ */
+function createCustomerInvoicesHandler() {
+    return (0, base_handler_js_1.createHandler)((_client, _body, params, organizationId) => __awaiter(this, void 0, void 0, function* () {
+        if (!organizationId) {
+            return { success: false, error: 'Organization ID not found', status: 500 };
+        }
+        const customerExternalId = params === null || params === void 0 ? void 0 : params.customerExternalId;
+        if (!customerExternalId) {
+            return { success: false, error: 'customerExternalId is required', status: 400 };
+        }
+        const apiKey = process.env.PAID_API_KEY || '';
+        const apiUrl = process.env.PAID_API_URL || 'https://api.agentpaid.io';
+        const result = yield getCustomerInvoices({ apiUrl, apiKey, organizationId }, customerExternalId);
+        return {
+            success: true,
+            data: result.data,
+        };
+    }), { allowedMethods: ['GET'], requireOrganizationId: true });
+}

package/dist/cjs/integrations/controllers/orders.d.ts

@@ -0,0 +1,72 @@
+import type { PaidClient } from "../../Client.js";
+import type { OrderConfig, OrderCreationResult, OrderOptions } from "../types.js";
+/**
+ * Create an order with defaults for missing fields
+ *
+ * This helper generates reasonable defaults for dates, names, and other fields,
+ * making it easy to create orders for prototyping and development.
+ *
+ * @param client - PaidClient instance
+ * @param config - Order configuration (customerId, customerExternalId, agentExternalId required)
+ * @param options - Additional options for order creation
+ * @returns Created order with ID
+ *
+ * @example
+ * ```typescript
+ * const order = await createOrderWithDefaults(client, {
+ *   customerId: 'cus_123',
+ *   customerExternalId: 'user-123',
+ *   agentExternalId: 'agent-prod'
+ * });
+ * // Generates: startDate, endDate (1 year), name, description, currency (USD)
+ * ```
+ */
+export declare function createOrderWithDefaults(client: PaidClient, config: OrderConfig, options?: OrderOptions): Promise<OrderCreationResult>;
+/**
+ * Create an order with explicit configuration (NO defaults applied)
+ *
+ * Required fields: customerId, customerExternalId, agentExternalId, name, description,
+ * startDate, endDate, currency, orderLines
+ *
+ * Use createOrderWithDefaults() if you want automatic default values for missing fields.
+ *
+ * @param client - PaidClient instance
+ * @param config - Complete order configuration with ALL required fields
+ * @param options - Additional options for order creation
+ * @returns Created order with ID
+ * @throws Error if any required fields are missing
+ *
+ * @example
+ * ```typescript
+ * const order = await createOrder(client, {
+ *   customerId: 'cus_123',
+ *   customerExternalId: 'user-123',
+ *   billingContactId: 'contact_123',
+ *   agentExternalId: 'agent-prod',
+ *   name: 'Pro Plan Subscription',
+ *   description: 'Monthly subscription to Pro plan',
+ *   startDate: '2024-01-01',
+ *   endDate: '2025-01-01',
+ *   currency: 'USD',
+ *   orderLines: [{
+ *     agentExternalId: 'agent-prod',
+ *     name: 'Pro Plan',
+ *     description: 'Pro plan features'
+ *   }]
+ * }, { autoActivate: true });
+ * ```
+ */
+export declare function createOrder(client: PaidClient, config: Required<OrderConfig>, options?: OrderOptions): Promise<OrderCreationResult>;
+interface OrderRequest extends OrderConfig {
+    autoActivate?: boolean;
+}
+/**
+ * Create a framework-agnostic handler for order creation
+ *
+ * This handler can be used with any framework adapter.
+ *
+ * @param helperOptions - Default options for order creation
+ * @returns Handler function
+ */
+export declare function createOrdersHandler(helperOptions?: OrderOptions): (request: import("../utils/base-handler.js").BaseRequestContext<OrderRequest, Record<string, string>>, response: import("../utils/base-handler.js").BaseResponseContext, config?: import("../utils/base-handler.js").BaseHandlerConfig) => Promise<any>;
+export {};