docs: add comprehensive usage examples to README

Add detailed usage examples section with practical code samples for:
- Creating payments with different providers
- Creating invoices with embedded and relationship-based customer data
- Creating refunds
- Querying payments and invoices
- Updating payment status
- Using the test provider for local development
- REST API examples with cURL commands

Also add table of contents for easier navigation.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

.github/workflows/claude-code-review.yml

@@ -12,11 +12,8 @@ on:
 
 jobs:
   claude-review:
-    # Optional: Filter by PR author
-    # if: |
-    #   github.event.pull_request.user.login == 'external-contributor' ||
-    #   github.event.pull_request.user.login == 'new-developer' ||
-    #   github.event.pull_request.author_association == 'FIRST_TIME_CONTRIBUTOR'
+    # Only allow bvdaakster to trigger reviews
+    if: github.event.pull_request.user.login == 'bvdaakster'
     
     runs-on: ubuntu-latest
     permissions:

CLAUDE.md

@@ -2,161 +2,165 @@
 
 ## Project Overview
 
-This is a PayloadCMS plugin that provides billing and payment functionality with multiple payment provider integrations (Stripe, Mollie) and a test payment provider for local development.
+This is a PayloadCMS plugin that provides billing and payment functionality with flexible customer data management and invoice generation capabilities.
 
 ## Architecture Principles
 
 ### Core Design
-- **Provider Abstraction**: All payment providers implement a common interface for consistency
 - **TypeScript First**: Full TypeScript support with strict typing throughout
 - **PayloadCMS Integration**: Deep integration with Payload collections, hooks, and admin UI
-- **Extensible**: Easy to add new payment providers through the common interface
-- **Developer Experience**: Comprehensive testing tools and local development support
-
-### Payment Provider Interface
-All payment providers must implement the `PaymentProvider` interface:
-```typescript
-interface PaymentProvider {
-  createPayment(options: CreatePaymentOptions): Promise<Payment>
-  retrievePayment(id: string): Promise<Payment>
-  cancelPayment(id: string): Promise<Payment>
-  refundPayment(id: string, amount?: number): Promise<Refund>
-  handleWebhook(request: Request, signature?: string): Promise<WebhookEvent>
-}
-```
+- **Flexible Customer Data**: Support for both relationship-based and embedded customer information
+- **Callback-based Syncing**: Use customer info extractors to keep data in sync
 
 ### Collections Structure
 - **Payments**: Core payment tracking with provider-specific data
-- **Customers**: Customer management with billing information
-- **Invoices**: Invoice generation and management
+- **Customers**: Customer management with billing information (optional)
+- **Invoices**: Invoice generation with embedded customer info and optional customer relationship
 - **Refunds**: Refund tracking and management
 
 ## Code Organization
 
 ```
 src/
-├── providers/           # Payment provider implementations
-│   ├── stripe/         # Stripe integration
-│   ├── mollie/         # Mollie integration
-│   ├── test/           # Test provider for development
-│   └── base/           # Base provider interface and utilities
 ├── collections/        # PayloadCMS collection configurations
-├── endpoints/          # API endpoints (webhooks, etc.)
-├── hooks/             # PayloadCMS lifecycle hooks
-├── admin/             # Admin UI components and extensions
 ├── types/             # TypeScript type definitions
-└── utils/             # Shared utilities and helpers
+└── index.ts           # Main plugin entry point
 ```
 
-## Development Guidelines
+## Customer Data Management
 
-### Payment Provider Development
-1. **Implement Base Interface**: All providers must implement `PaymentProvider`
-2. **Error Handling**: Use consistent error types and proper error propagation
-3. **Webhook Security**: Always verify webhook signatures and implement replay protection
-4. **Idempotency**: Support idempotent operations where possible
-5. **Logging**: Use structured logging for debugging and monitoring
+### Customer Info Extractor Pattern
 
-### Testing Strategy
-- **Unit Tests**: Test individual provider methods and utilities
-- **Integration Tests**: Test provider integrations with mock APIs
-- **E2E Tests**: Test complete payment flows using test provider
-- **Webhook Tests**: Test webhook handling with various scenarios
+The plugin uses a callback-based approach to extract customer information from customer relationships:
 
-### TypeScript Guidelines
-- Use strict TypeScript configuration
-- Define proper interfaces for all external API responses
-- Use discriminated unions for provider-specific data
-- Implement proper generic types for extensibility
-
-### PayloadCMS Integration
-- Follow PayloadCMS plugin patterns and conventions
-- Use proper collection configurations with access control
-- Implement admin UI components using PayloadCMS patterns
-- Utilize PayloadCMS hooks for business logic
-
-### Security Considerations
-- **Webhook Verification**: Always verify webhook signatures
-- **API Key Storage**: Use environment variables for sensitive data
-- **Access Control**: Implement proper PayloadCMS access control
-- **Input Validation**: Validate all inputs and sanitize data
-- **Audit Logging**: Log all payment operations for audit trails
-
-## Environment Configuration
-
-### Required Environment Variables
-```bash
-# Stripe Configuration
-STRIPE_SECRET_KEY=sk_test_...
-STRIPE_PUBLISHABLE_KEY=pk_test_...
-STRIPE_WEBHOOK_SECRET=whsec_...
-
-# Mollie Configuration  
-MOLLIE_API_KEY=test_...
-MOLLIE_WEBHOOK_URL=https://yourapp.com/api/billing/webhooks/mollie
-
-# Test Provider Configuration
-NODE_ENV=development # Enables test provider
+```typescript
+// Define how to extract customer info from your customer collection
+const customerInfoExtractor: CustomerInfoExtractor = (customer) => ({
+  name: customer.name,
+  email: customer.email,
+  phone: customer.phone,
+  company: customer.company,
+  taxId: customer.taxId,
+  billingAddress: {
+    line1: customer.address.line1,
+    line2: customer.address.line2,
+    city: customer.address.city,
+    state: customer.address.state,
+    postalCode: customer.address.postalCode,
+    country: customer.address.country,
+  }
+})
 ```
 
-### Development Setup
-1. Use test provider for local development
-2. Configure webhook forwarding tools (ngrok, etc.) for local webhook testing
-3. Use provider sandbox/test modes during development
-4. Implement comprehensive logging for debugging
+### Invoice Customer Data Options
+
+1. **With Customer Relationship + Extractor**:
+   - Customer relationship required
+   - Customer info auto-populated and read-only
+   - Syncs automatically when customer changes
+
+2. **With Customer Relationship (no extractor)**:
+   - Customer relationship optional
+   - Customer info manually editable
+   - Either relationship OR customer info required
+
+3. **No Customer Collection**:
+   - Customer info fields always required and editable
+   - No relationship field available
 
 ## Plugin Configuration
 
 ### Basic Configuration
 ```typescript
+import { billingPlugin, defaultCustomerInfoExtractor } from '@xtr-dev/payload-billing'
+
 billingPlugin({
-  providers: {
-    // Provider configurations
-  },
   collections: {
-    // Collection name overrides
+    customers: 'customers',        // Customer collection slug
+    invoices: 'invoices',         // Invoice collection slug
+    payments: 'payments',         // Payment collection slug
+    refunds: 'refunds',          // Refund collection slug
+    customerRelation: false,      // Disable customer relationship
+    // OR
+    customerRelation: 'clients',  // Use custom collection slug
   },
-  webhooks: {
-    // Webhook configuration
-  },
-  admin: {
-    // Admin UI configuration
-  }
+  customerInfoExtractor: defaultCustomerInfoExtractor, // For built-in customer collection
 })
 ```
 
-### Advanced Configuration
-- Custom collection schemas
-- Provider-specific options
-- Webhook endpoint customization
-- Admin UI customization
+### Custom Customer Info Extractor
+```typescript
+billingPlugin({
+  customerInfoExtractor: (customer) => ({
+    name: customer.fullName,
+    email: customer.contactEmail,
+    phone: customer.phoneNumber,
+    company: customer.companyName,
+    taxId: customer.vatNumber,
+    billingAddress: {
+      line1: customer.billing.street,
+      line2: customer.billing.apartment,
+      city: customer.billing.city,
+      state: customer.billing.state,
+      postalCode: customer.billing.zip,
+      country: customer.billing.countryCode,
+    }
+  })
+})
+```
 
-## Error Handling Strategy
+## Development Guidelines
 
-### Provider Errors
-- Map provider-specific errors to common error types
-- Preserve original error information for debugging
-- Implement proper retry logic for transient failures
+### TypeScript Guidelines
+- Use strict TypeScript configuration
+- All customer info extractors must implement `CustomerInfoExtractor` interface
+- Ensure consistent camelCase naming for all address fields
 
-### Webhook Errors
-- Handle duplicate webhooks gracefully
-- Implement proper error responses for webhook failures
-- Log webhook processing errors with context
+### PayloadCMS Integration
+- Follow PayloadCMS plugin patterns and conventions
+- Use proper collection configurations with access control
+- Utilize PayloadCMS hooks for data syncing and validation
+
+### Field Validation Rules
+- When using `customerInfoExtractor`: customer relationship is required, customer info auto-populated
+- When not using extractor: either customer relationship OR customer info must be provided
+- When no customer collection: customer info is always required
+
+## Collections API
+
+### Invoice Collection Features
+- Automatic invoice number generation (INV-{timestamp})
+- Currency validation (3-letter ISO codes)
+- Automatic due date setting (30 days from creation)
+- Line item total calculations
+- Customer info syncing via hooks
+
+### Customer Data Syncing
+The `beforeChange` hook automatically:
+1. Detects when customer relationship changes
+2. Fetches customer data from the related collection
+3. Extracts customer info using the provided callback
+4. Updates invoice with extracted data
+5. Maintains data consistency across updates
+
+## Error Handling
+
+### Validation Errors
+- Customer relationship required when using extractor
+- Customer info required when not using relationship
+- Proper error messages for missing required fields
+
+### Data Extraction Errors
+- Failed customer fetches are logged and throw user-friendly errors
+- Invalid customer data is handled gracefully
 
 ## Performance Considerations
-- Implement proper caching where appropriate
-- Use database indexes for payment queries
-- Optimize webhook processing for high throughput
-- Consider rate limiting for API endpoints
-
-## Monitoring and Observability
-- Log all payment operations with structured data
-- Track payment success/failure rates
-- Monitor webhook processing times
-- Implement health check endpoints
+- Customer data is only fetched when relationship changes
+- Read-only fields prevent unnecessary manual edits
+- Efficient hook execution with proper change detection
 
 ## Documentation Requirements
 - Document all public APIs with examples
-- Provide integration guides for each payment provider
-- Include troubleshooting guides for common issues
+- Provide clear customer info extractor examples
+- Include configuration guides for different use cases
 - Maintain up-to-date TypeScript documentation

README.md

@@ -1,17 +1,38 @@
 # @xtr-dev/payload-billing
 
-A billing and payment provider plugin for PayloadCMS 3.x. Supports Stripe, Mollie, and local testing with comprehensive tracking.
+[![npm version](https://badge.fury.io/js/@xtr-dev%2Fpayload-billing.svg)](https://badge.fury.io/js/@xtr-dev%2Fpayload-billing)
 
-⚠️ **Pre-release Warning**: This package is currently in active development (v0.0.x). Breaking changes may occur before v1.0.0. Not recommended for production use.
+A billing and payment provider plugin for PayloadCMS 3.x. Supports Stripe, Mollie, and local testing with comprehensive tracking and flexible customer data management.
+
+⚠️ **Pre-release Warning**: This package is currently in active development (v0.1.x). Breaking changes may occur before v1.0.0. Not recommended for production use.
+
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Imports](#imports)
+- [Usage Examples](#usage-examples)
+  - [Creating a Payment](#creating-a-payment)
+  - [Creating an Invoice](#creating-an-invoice)
+  - [Creating a Refund](#creating-a-refund)
+  - [Querying Payments](#querying-payments)
+  - [Using REST API](#using-rest-api)
+- [Provider Types](#provider-types)
+- [Collections](#collections)
+- [Webhook Endpoints](#webhook-endpoints)
+- [Development](#development)
 
 ## Features
 
 - 💳 Multiple payment providers (Stripe, Mollie, Test)
-- 🧾 Invoice generation and management
+- 🧾 Invoice generation and management with embedded customer info
+- 👥 Flexible customer data management with relationship support
 - 📊 Complete payment tracking and history
 - 🪝 Secure webhook processing for all providers
 - 🧪 Built-in test provider for local development
 - 📱 Payment management in PayloadCMS admin
+- 🔄 Callback-based customer data syncing
 - 🔒 Full TypeScript support
 
 ## Installation
@@ -24,47 +45,137 @@ pnpm add @xtr-dev/payload-billing
 yarn add @xtr-dev/payload-billing
 ```
 
+### Provider Dependencies
+
+Payment providers are peer dependencies and must be installed separately based on which providers you plan to use:
+
+```bash
+# For Stripe support
+npm install stripe
+# or
+pnpm add stripe
+
+# For Mollie support
+npm install @mollie/api-client
+# or
+pnpm add @mollie/api-client
+```
+
 ## Quick Start
 
+### Basic Configuration
+
 ```typescript
 import { buildConfig } from 'payload'
-import { billingPlugin } from '@xtr-dev/payload-billing'
+import { billingPlugin, stripeProvider, mollieProvider } from '@xtr-dev/payload-billing'
 
 export default buildConfig({
   // ... your config
   plugins: [
     billingPlugin({
-      providers: {
-        stripe: {
+      providers: [
+        stripeProvider({
           secretKey: process.env.STRIPE_SECRET_KEY!,
-          publishableKey: process.env.STRIPE_PUBLISHABLE_KEY!,
-          webhookEndpointSecret: process.env.STRIPE_WEBHOOK_SECRET!,
-        },
-        mollie: {
+          webhookSecret: process.env.STRIPE_WEBHOOK_SECRET,
+        }),
+        mollieProvider({
           apiKey: process.env.MOLLIE_API_KEY!,
-          webhookUrl: process.env.MOLLIE_WEBHOOK_URL!,
-        },
-        test: {
-          enabled: process.env.NODE_ENV === 'development',
-          autoComplete: true,
-        }
+          webhookUrl: process.env.MOLLIE_WEBHOOK_URL,
+        }),
+      ],
+      collections: {
+        payments: 'payments',
+        invoices: 'invoices',
+        refunds: 'refunds',
       }
     })
   ]
 })
 ```
 
+### With Customer Management
+
+```typescript
+import { billingPlugin, CustomerInfoExtractor } from '@xtr-dev/payload-billing'
+
+// Define how to extract customer info from your customer collection
+const customerExtractor: CustomerInfoExtractor = (customer) => ({
+  name: customer.name,
+  email: customer.email,
+  phone: customer.phone,
+  company: customer.company,
+  taxId: customer.taxId,
+  billingAddress: {
+    line1: customer.address.line1,
+    line2: customer.address.line2,
+    city: customer.address.city,
+    state: customer.address.state,
+    postalCode: customer.address.postalCode,
+    country: customer.address.country,
+  }
+})
+
+billingPlugin({
+  // ... providers
+  collections: {
+    payments: 'payments',
+    invoices: 'invoices',
+    refunds: 'refunds',
+  },
+  customerRelationSlug: 'customers', // Enable customer relationships
+  customerInfoExtractor: customerExtractor, // Auto-sync customer data
+})
+```
+
+### Custom Customer Data Extraction
+
+```typescript
+import { CustomerInfoExtractor } from '@xtr-dev/payload-billing'
+
+const customExtractor: CustomerInfoExtractor = (customer) => ({
+  name: customer.fullName,
+  email: customer.contactEmail,
+  phone: customer.phoneNumber,
+  company: customer.companyName,
+  taxId: customer.vatNumber,
+  billingAddress: {
+    line1: customer.billing.street,
+    line2: customer.billing.apartment,
+    city: customer.billing.city,
+    state: customer.billing.state,
+    postalCode: customer.billing.zip,
+    country: customer.billing.countryCode,
+  }
+})
+
+billingPlugin({
+  // ... other config
+  customerRelationSlug: 'clients',
+  customerInfoExtractor: customExtractor,
+})
+```
+
 ## Imports
 
 ```typescript
 // Main plugin
 import { billingPlugin } from '@xtr-dev/payload-billing'
 
-// Provider utilities
-import { getPaymentProvider } from '@xtr-dev/payload-billing'
+// Payment providers
+import { stripeProvider, mollieProvider } from '@xtr-dev/payload-billing'
 
 // Types
-import type { PaymentProvider, CreatePaymentOptions, Payment } from '@xtr-dev/payload-billing'
+import type { 
+  PaymentProvider, 
+  Payment, 
+  Invoice, 
+  Refund,
+  BillingPluginConfig,
+  CustomerInfoExtractor,
+  MollieProviderConfig,
+  StripeProviderConfig,
+  ProviderData
+} from '@xtr-dev/payload-billing'
 ```
 
 ## Provider Types
@@ -83,16 +194,290 @@ Local development testing with configurable scenarios, automatic completion, deb
 The plugin adds these collections:
 
 - **payments** - Payment transactions with status and provider data
-- **customers** - Customer profiles with billing information
-- **invoices** - Invoice generation with line items and PDF support
+- **invoices** - Invoice generation with line items and embedded customer info
 - **refunds** - Refund tracking and management
 
+### Customer Data Management
+
+The plugin supports flexible customer data handling:
+
+1. **With Customer Relationship + Extractor**: Customer relationship required, customer info auto-populated and read-only, syncs automatically when customer changes
+
+2. **With Customer Relationship (no extractor)**: Customer relationship optional, customer info manually editable, either relationship OR customer info required
+
+3. **No Customer Collection**: Customer info fields always required and editable, no relationship field available
+
+## Usage Examples
+
+### Creating a Payment
+
+Payments are created through PayloadCMS's local API or REST API. The plugin automatically initializes the payment with the configured provider.
+
+```typescript
+// Using Payload Local API
+const payment = await payload.create({
+  collection: 'payments',
+  data: {
+    provider: 'stripe', // or 'mollie' or 'test'
+    amount: 2000, // Amount in cents ($20.00)
+    currency: 'USD',
+    description: 'Product purchase',
+    status: 'pending',
+    metadata: {
+      orderId: 'order-123',
+      customerId: 'cust-456'
+    }
+  }
+})
+```
+
+### Creating an Invoice
+
+Invoices can be created with customer information embedded or linked via relationship:
+
+```typescript
+// Create invoice with embedded customer info
+const invoice = await payload.create({
+  collection: 'invoices',
+  data: {
+    customerInfo: {
+      name: 'John Doe',
+      email: 'john@example.com',
+      phone: '+1234567890',
+      company: 'Acme Corp',
+      taxId: 'TAX-123'
+    },
+    billingAddress: {
+      line1: '123 Main St',
+      line2: 'Suite 100',
+      city: 'New York',
+      state: 'NY',
+      postalCode: '10001',
+      country: 'US'
+    },
+    currency: 'USD',
+    items: [
+      {
+        description: 'Web Development Services',
+        quantity: 10,
+        unitAmount: 5000 // $50.00 per hour
+      },
+      {
+        description: 'Hosting (Monthly)',
+        quantity: 1,
+        unitAmount: 2500 // $25.00
+      }
+    ],
+    taxAmount: 7500, // $75.00 tax
+    status: 'open'
+  }
+})
+
+console.log(`Invoice created: ${invoice.number}`)
+console.log(`Total amount: $${invoice.amount / 100}`)
+```
+
+### Creating an Invoice with Customer Relationship
+
+If you've configured a customer collection with `customerRelationSlug` and `customerInfoExtractor`:
+
+```typescript
+// Create invoice linked to customer (info auto-populated)
+const invoice = await payload.create({
+  collection: 'invoices',
+  data: {
+    customer: 'customer-id-123', // Customer relationship
+    currency: 'USD',
+    items: [
+      {
+        description: 'Subscription - Pro Plan',
+        quantity: 1,
+        unitAmount: 9900 // $99.00
+      }
+    ],
+    status: 'open'
+    // customerInfo and billingAddress are auto-populated from customer
+  }
+})
+```
+
+### Creating a Refund
+
+Refunds are linked to existing payments:
+
+```typescript
+const refund = await payload.create({
+  collection: 'refunds',
+  data: {
+    payment: payment.id, // Link to payment
+    providerId: 'refund-provider-id', // Provider's refund ID
+    amount: 1000, // Partial refund: $10.00
+    currency: 'USD',
+    status: 'succeeded',
+    reason: 'requested_by_customer',
+    description: 'Customer requested partial refund'
+  }
+})
+```
+
+### Querying Payments
+
+```typescript
+// Find all successful payments
+const payments = await payload.find({
+  collection: 'payments',
+  where: {
+    status: {
+      equals: 'succeeded'
+    }
+  }
+})
+
+// Find payments for a specific invoice
+const invoicePayments = await payload.find({
+  collection: 'payments',
+  where: {
+    invoice: {
+      equals: invoiceId
+    }
+  }
+})
+```
+
+### Updating Payment Status
+
+Payment status is typically updated via webhooks, but you can also update manually:
+
+```typescript
+const updatedPayment = await payload.update({
+  collection: 'payments',
+  id: payment.id,
+  data: {
+    status: 'succeeded',
+    providerData: {
+      // Provider-specific data
+      raw: providerResponse,
+      timestamp: new Date().toISOString(),
+      provider: 'stripe'
+    }
+  }
+})
+```
+
+### Marking an Invoice as Paid
+
+```typescript
+const paidInvoice = await payload.update({
+  collection: 'invoices',
+  id: invoice.id,
+  data: {
+    status: 'paid',
+    payment: payment.id // Link to payment
+    // paidAt is automatically set by the plugin
+  }
+})
+```
+
+### Using the Test Provider
+
+The test provider is useful for local development:
+
+```typescript
+// In your payload.config.ts
+import { billingPlugin, testProvider } from '@xtr-dev/payload-billing'
+
+billingPlugin({
+  providers: [
+    testProvider({
+      enabled: true,
+      testModeIndicators: {
+        showWarningBanners: true,
+        showTestBadges: true,
+        consoleWarnings: true
+      }
+    })
+  ],
+  collections: {
+    payments: 'payments',
+    invoices: 'invoices',
+    refunds: 'refunds',
+  }
+})
+```
+
+Then create test payments:
+
+```typescript
+const testPayment = await payload.create({
+  collection: 'payments',
+  data: {
+    provider: 'test',
+    amount: 5000,
+    currency: 'USD',
+    description: 'Test payment',
+    status: 'pending'
+  }
+})
+// Test provider automatically processes the payment
+```
+
+### Using REST API
+
+All collections can be accessed via PayloadCMS REST API:
+
+```bash
+# Create a payment
+curl -X POST http://localhost:3000/api/payments \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer YOUR_TOKEN" \
+  -d '{
+    "provider": "stripe",
+    "amount": 2000,
+    "currency": "USD",
+    "description": "Product purchase",
+    "status": "pending"
+  }'
+
+# Create an invoice
+curl -X POST http://localhost:3000/api/invoices \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer YOUR_TOKEN" \
+  -d '{
+    "customerInfo": {
+      "name": "John Doe",
+      "email": "john@example.com"
+    },
+    "billingAddress": {
+      "line1": "123 Main St",
+      "city": "New York",
+      "postalCode": "10001",
+      "country": "US"
+    },
+    "currency": "USD",
+    "items": [
+      {
+        "description": "Service",
+        "quantity": 1,
+        "unitAmount": 5000
+      }
+    ],
+    "status": "open"
+  }'
+
+# Get all payments
+curl http://localhost:3000/api/payments \
+  -H "Authorization: Bearer YOUR_TOKEN"
+
+# Get a specific invoice
+curl http://localhost:3000/api/invoices/INVOICE_ID \
+  -H "Authorization: Bearer YOUR_TOKEN"
+```
+
 ## Webhook Endpoints
 
-Automatic webhook endpoints are created:
-- `/api/billing/webhooks/stripe`
-- `/api/billing/webhooks/mollie`
-- `/api/billing/webhooks/test`
+Automatic webhook endpoints are created for configured providers:
+- `/api/payload-billing/stripe/webhook` - Stripe payment notifications
+- `/api/payload-billing/mollie/webhook` - Mollie payment notifications
 
 ## Requirements
 

dev/app/my-route/route.ts

@@ -1,11 +1,13 @@
 import configPromise from '@payload-config'
 import { getPayload } from 'payload'
+import { useBillingPlugin } from '../../../src/plugin'
 
 export const GET = async (request: Request) => {
   const payload = await getPayload({
     config: configPromise,
   })
 
+
   return Response.json({
     message: 'This is an example of a custom route.',
   })

dev/payload-types.ts

@@ -70,7 +70,6 @@ export interface Config {
     posts: Post;
     media: Media;
     payments: Payment;
-    customers: Customer;
     invoices: Invoice;
     refunds: Refund;
     users: User;
@@ -83,7 +82,6 @@ export interface Config {
     posts: PostsSelect<false> | PostsSelect<true>;
     media: MediaSelect<false> | MediaSelect<true>;
     payments: PaymentsSelect<false> | PaymentsSelect<true>;
-    customers: CustomersSelect<false> | CustomersSelect<true>;
     invoices: InvoicesSelect<false> | InvoicesSelect<true>;
     refunds: RefundsSelect<false> | RefundsSelect<true>;
     users: UsersSelect<false> | UsersSelect<true>;
@@ -92,7 +90,7 @@ export interface Config {
     'payload-migrations': PayloadMigrationsSelect<false> | PayloadMigrationsSelect<true>;
   };
   db: {
-    defaultIDType: string;
+    defaultIDType: number;
   };
   globals: {};
   globalsSelect: {};
@@ -128,7 +126,7 @@ export interface UserAuthOperations {
  * via the `definition` "posts".
  */
 export interface Post {
-  id: string;
+  id: number;
   updatedAt: string;
   createdAt: string;
 }
@@ -137,7 +135,7 @@ export interface Post {
  * via the `definition` "media".
  */
 export interface Media {
-  id: string;
+  id: number;
   updatedAt: string;
   createdAt: string;
   url?: string | null;
@@ -155,12 +153,12 @@ export interface Media {
  * via the `definition` "payments".
  */
 export interface Payment {
-  id: string;
+  id: number;
   provider: 'stripe' | 'mollie' | 'test';
   /**
    * The payment ID from the payment provider
    */
-  providerId: string;
+  providerId?: string | null;
   status: 'pending' | 'processing' | 'succeeded' | 'failed' | 'canceled' | 'refunded' | 'partially_refunded';
   /**
    * Amount in cents (e.g., 2000 = $20.00)
@@ -174,8 +172,7 @@ export interface Payment {
    * Payment description
    */
   description?: string | null;
-  customer?: (string | null) | Customer;
-  invoice?: (string | null) | Invoice;
+  invoice?: (number | null) | Invoice;
   /**
    * Additional metadata for the payment
    */
@@ -200,71 +197,8 @@ export interface Payment {
     | number
     | boolean
     | null;
-  refunds?: (string | Refund)[] | null;
-  updatedAt: string;
-  createdAt: string;
-}
-/**
- * This interface was referenced by `Config`'s JSON-Schema
- * via the `definition` "customers".
- */
-export interface Customer {
-  id: string;
-  /**
-   * Customer email address
-   */
-  email?: string | null;
-  /**
-   * Customer full name
-   */
-  name?: string | null;
-  /**
-   * Customer phone number
-   */
-  phone?: string | null;
-  address?: {
-    line1?: string | null;
-    line2?: string | null;
-    city?: string | null;
-    state?: string | null;
-    postal_code?: string | null;
-    /**
-     * ISO 3166-1 alpha-2 country code
-     */
-    country?: string | null;
-  };
-  /**
-   * Customer IDs from payment providers
-   */
-  providerIds?:
-    | {
-        [k: string]: unknown;
-      }
-    | unknown[]
-    | string
-    | number
-    | boolean
-    | null;
-  /**
-   * Additional customer metadata
-   */
-  metadata?:
-    | {
-        [k: string]: unknown;
-      }
-    | unknown[]
-    | string
-    | number
-    | boolean
-    | null;
-  /**
-   * Customer payments
-   */
-  payments?: (string | Payment)[] | null;
-  /**
-   * Customer invoices
-   */
-  invoices?: (string | Invoice)[] | null;
+  refunds?: (number | Refund)[] | null;
+  version?: number | null;
   updatedAt: string;
   createdAt: string;
 }
@@ -273,12 +207,62 @@ export interface Customer {
  * via the `definition` "invoices".
  */
 export interface Invoice {
-  id: string;
+  id: number;
   /**
    * Invoice number (e.g., INV-001)
    */
   number: string;
-  customer: string | Customer;
+  /**
+   * Customer billing information
+   */
+  customerInfo: {
+    /**
+     * Customer name
+     */
+    name: string;
+    /**
+     * Customer email address
+     */
+    email: string;
+    /**
+     * Customer phone number
+     */
+    phone?: string | null;
+    /**
+     * Company name (optional)
+     */
+    company?: string | null;
+    /**
+     * Tax ID or VAT number
+     */
+    taxId?: string | null;
+  };
+  /**
+   * Billing address
+   */
+  billingAddress: {
+    /**
+     * Address line 1
+     */
+    line1: string;
+    /**
+     * Address line 2
+     */
+    line2?: string | null;
+    city: string;
+    /**
+     * State or province
+     */
+    state?: string | null;
+    /**
+     * Postal or ZIP code
+     */
+    postalCode: string;
+    /**
+     * Country code (e.g., US, GB)
+     */
+    country: string;
+  };
   status: 'draft' | 'open' | 'paid' | 'void' | 'uncollectible';
   /**
    * ISO 4217 currency code (e.g., USD, EUR)
@@ -311,7 +295,7 @@ export interface Invoice {
   amount?: number | null;
   dueDate?: string | null;
   paidAt?: string | null;
-  payment?: (string | null) | Payment;
+  payment?: (number | null) | Payment;
   /**
    * Internal notes
    */
@@ -336,12 +320,12 @@ export interface Invoice {
  * via the `definition` "refunds".
  */
 export interface Refund {
-  id: string;
+  id: number;
   /**
    * The refund ID from the payment provider
    */
   providerId: string;
-  payment: string | Payment;
+  payment: number | Payment;
   status: 'pending' | 'processing' | 'succeeded' | 'failed' | 'canceled';
   /**
    * Refund amount in cents
@@ -391,7 +375,7 @@ export interface Refund {
  * via the `definition` "users".
  */
 export interface User {
-  id: string;
+  id: number;
   updatedAt: string;
   createdAt: string;
   email: string;
@@ -408,40 +392,36 @@ export interface User {
  * via the `definition` "payload-locked-documents".
  */
 export interface PayloadLockedDocument {
-  id: string;
+  id: number;
   document?:
     | ({
         relationTo: 'posts';
-        value: string | Post;
+        value: number | Post;
       } | null)
     | ({
         relationTo: 'media';
-        value: string | Media;
+        value: number | Media;
       } | null)
     | ({
         relationTo: 'payments';
-        value: string | Payment;
-      } | null)
-    | ({
-        relationTo: 'customers';
-        value: string | Customer;
+        value: number | Payment;
       } | null)
     | ({
         relationTo: 'invoices';
-        value: string | Invoice;
+        value: number | Invoice;
       } | null)
     | ({
         relationTo: 'refunds';
-        value: string | Refund;
+        value: number | Refund;
       } | null)
     | ({
         relationTo: 'users';
-        value: string | User;
+        value: number | User;
       } | null);
   globalSlug?: string | null;
   user: {
     relationTo: 'users';
-    value: string | User;
+    value: number | User;
   };
   updatedAt: string;
   createdAt: string;
@@ -451,10 +431,10 @@ export interface PayloadLockedDocument {
  * via the `definition` "payload-preferences".
  */
 export interface PayloadPreference {
-  id: string;
+  id: number;
   user: {
     relationTo: 'users';
-    value: string | User;
+    value: number | User;
   };
   key?: string | null;
   value?:
@@ -474,7 +454,7 @@ export interface PayloadPreference {
  * via the `definition` "payload-migrations".
  */
 export interface PayloadMigration {
-  id: string;
+  id: number;
   name?: string | null;
   batch?: number | null;
   updatedAt: string;
@@ -516,36 +496,11 @@ export interface PaymentsSelect<T extends boolean = true> {
   amount?: T;
   currency?: T;
   description?: T;
-  customer?: T;
   invoice?: T;
   metadata?: T;
   providerData?: T;
   refunds?: T;
-  updatedAt?: T;
-  createdAt?: T;
-}
-/**
- * This interface was referenced by `Config`'s JSON-Schema
- * via the `definition` "customers_select".
- */
-export interface CustomersSelect<T extends boolean = true> {
-  email?: T;
-  name?: T;
-  phone?: T;
-  address?:
-    | T
-    | {
-        line1?: T;
-        line2?: T;
-        city?: T;
-        state?: T;
-        postal_code?: T;
-        country?: T;
-      };
-  providerIds?: T;
-  metadata?: T;
-  payments?: T;
-  invoices?: T;
+  version?: T;
   updatedAt?: T;
   createdAt?: T;
 }
@@ -555,7 +510,25 @@ export interface CustomersSelect<T extends boolean = true> {
  */
 export interface InvoicesSelect<T extends boolean = true> {
   number?: T;
-  customer?: T;
+  customerInfo?:
+    | T
+    | {
+        name?: T;
+        email?: T;
+        phone?: T;
+        company?: T;
+        taxId?: T;
+      };
+  billingAddress?:
+    | T
+    | {
+        line1?: T;
+        line2?: T;
+        city?: T;
+        state?: T;
+        postalCode?: T;
+        country?: T;
+      };
   status?: T;
   currency?: T;
   items?:

dev/payload.config.ts

@@ -2,12 +2,13 @@ import { sqliteAdapter } from '@payloadcms/db-sqlite'
 import { lexicalEditor } from '@payloadcms/richtext-lexical'
 import path from 'path'
 import { buildConfig } from 'payload'
-import { billingPlugin } from '../dist/index.js'
 import sharp from 'sharp'
 import { fileURLToPath } from 'url'
 
-import { testEmailAdapter } from './helpers/testEmailAdapter.js'
-import { seed } from './seed.js'
+import { testEmailAdapter } from './helpers/testEmailAdapter'
+import { seed } from './seed'
+import billingPlugin from '../src/plugin'
+import { testProvider } from '../src/providers'
 
 const filename = fileURLToPath(import.meta.url)
 const dirname = path.dirname(filename)
@@ -48,18 +49,21 @@ const buildConfigWithSQLite = () => {
     },
     plugins: [
       billingPlugin({
-        providers: {
-          test: {
+        providers: [
+          testProvider({
             enabled: true,
-            autoComplete: true,
+            testModeIndicators: {
+              showWarningBanners: true,
+              showTestBadges: true,
+              consoleWarnings: true
             }
-        },
+          })
+        ],
         collections: {
           payments: 'payments',
-          customers: 'customers',
           invoices: 'invoices',
           refunds: 'refunds',
-        }
+        },
       }),
     ],
     secret: process.env.PAYLOAD_SECRET || 'test-secret_key',

dev/seed.ts

@@ -1,6 +1,6 @@
 import type { Payload } from 'payload'
 
-import { devUser } from './helpers/credentials.js'
+import { devUser } from './helpers/credentials'
 
 export const seed = async (payload: Payload) => {
   // Seed default user first
@@ -21,129 +21,9 @@ export const seed = async (payload: Payload) => {
   }
 
   // Seed billing sample data
-  await seedBillingData(payload)
+  // await seedBillingData(payload)
 }
 
-async function seedBillingData(payload: Payload): Promise<void> {
-  payload.logger.info('Seeding billing sample data...')
-
-  try {
-    // Check if we already have sample data
-    const existingCustomers = await payload.count({
-      collection: 'customers',
-      where: {
-        email: {
-          equals: 'john.doe@example.com',
-        },
-      },
-    })
-
-    if (existingCustomers.totalDocs > 0) {
-      payload.logger.info('Sample billing data already exists, skipping seed')
-      return
-    }
-
-    // Create a sample customer
-    const customer = await payload.create({
-      collection: 'customers',
-      data: {
-        email: 'john.doe@example.com',
-        name: 'John Doe',
-        phone: '+1-555-0123',
-        address: {
-          line1: '123 Main St',
-          city: 'New York',
-          state: 'NY',
-          postal_code: '10001',
-          country: 'US'
-        },
-        metadata: {
-          source: 'seed',
-          created_by: 'system'
-        }
-      }
-    })
-
-    payload.logger.info(`Created sample customer: ${customer.id}`)
-
-    // Create a sample invoice
-    const invoice = await payload.create({
-      collection: 'invoices',
-      data: {
-        number: 'INV-001-SAMPLE',
-        customer: customer.id,
-        currency: 'USD',
-        items: [
-          {
-            description: 'Web Development Services',
-            quantity: 10,
-            unitAmount: 5000, // $50.00 per hour
-            totalAmount: 50000 // $500.00 total
-          },
-          {
-            description: 'Design Consultation',
-            quantity: 2,
-            unitAmount: 7500, // $75.00 per hour
-            totalAmount: 15000 // $150.00 total
-          }
-        ],
-        subtotal: 65000, // $650.00
-        taxAmount: 5200, // $52.00 (8% tax)
-        amount: 70200, // $702.00 total
-        status: 'open',
-        dueDate: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString(), // 30 days from now
-        notes: 'Payment terms: Net 30 days. This is sample data for development.',
-        metadata: {
-          project: 'website-redesign',
-          billable_hours: 12,
-          sample: true
-        }
-      }
-    })
-
-    payload.logger.info(`Created sample invoice: ${invoice.number}`)
-
-    // Create a sample payment using test provider
-    const payment = await payload.create({
-      collection: 'payments',
-      data: {
-        provider: 'test',
-        providerId: `test_pay_sample_${Date.now()}`,
-        status: 'succeeded',
-        amount: 70200, // $702.00
-        currency: 'USD',
-        description: `Sample payment for invoice ${invoice.number}`,
-        customer: customer.id,
-        invoice: invoice.id,
-        metadata: {
-          invoice_number: invoice.number,
-          payment_method: 'test_card',
-          sample: true
-        },
-        providerData: {
-          testMode: true,
-          simulatedPayment: true,
-          autoCompleted: true
-        }
-      }
-    })
-
-    payload.logger.info(`Created sample payment: ${payment.id}`)
-
-    // Update invoice status to paid
-    await payload.update({
-      collection: 'invoices',
-      id: invoice.id,
-      data: {
-        status: 'paid',
-        payment: payment.id,
-        paidAt: new Date().toISOString()
-      }
-    })
-
-    payload.logger.info('Billing sample data seeded successfully!')
-
-  } catch (error) {
-    payload.logger.error('Error seeding billing data:', error)
-  }
-}
+// async function seedBillingData(payload: Payload): Promise<void> {
+//   payload.logger.info('Seeding billing sample data...')
+// }

docs/test-provider-example.md

@@ -0,0 +1,147 @@
+# Advanced Test Provider Example
+
+The advanced test provider allows you to test complex payment scenarios with an interactive UI for development purposes.
+
+## Basic Configuration
+
+```typescript
+import { billingPlugin, testProvider } from '@xtr-dev/payload-billing'
+
+// Configure the test provider
+const testProviderConfig = {
+  enabled: true, // Enable the test provider
+  defaultDelay: 2000, // Default delay in milliseconds
+  baseUrl: process.env.PAYLOAD_PUBLIC_SERVER_URL || 'http://localhost:3000',
+  customUiRoute: '/test-payment', // Custom route for test payment UI
+  testModeIndicators: {
+    showWarningBanners: true, // Show warning banners in test mode
+    showTestBadges: true, // Show test badges
+    consoleWarnings: true, // Show console warnings
+  }
+}
+
+// Add to your payload config
+export default buildConfig({
+  plugins: [
+    billingPlugin({
+      providers: [
+        testProvider(testProviderConfig)
+      ]
+    })
+  ]
+})
+```
+
+## Custom Scenarios
+
+You can define custom payment scenarios:
+
+```typescript
+const customScenarios = [
+  {
+    id: 'quick-success',
+    name: 'Quick Success',
+    description: 'Payment succeeds in 1 second',
+    outcome: 'paid' as const,
+    delay: 1000,
+    method: 'creditcard' as const
+  },
+  {
+    id: 'network-timeout',
+    name: 'Network Timeout',
+    description: 'Simulates network timeout',
+    outcome: 'failed' as const,
+    delay: 10000
+  },
+  {
+    id: 'user-abandonment',
+    name: 'User Abandonment',
+    description: 'User closes payment window',
+    outcome: 'cancelled' as const,
+    delay: 5000
+  }
+]
+
+const testProviderConfig = {
+  enabled: true,
+  scenarios: customScenarios,
+  // ... other config
+}
+```
+
+## Available Payment Outcomes
+
+- `paid` - Payment succeeds
+- `failed` - Payment fails
+- `cancelled` - Payment is cancelled by user
+- `expired` - Payment expires
+- `pending` - Payment remains pending
+
+## Available Payment Methods
+
+- `ideal` - iDEAL (Dutch banking)
+- `creditcard` - Credit/Debit Cards
+- `paypal` - PayPal
+- `applepay` - Apple Pay
+- `banktransfer` - Bank Transfer
+
+## Using the Test UI
+
+1. Create a payment using the test provider
+2. The payment will return a `paymentUrl` in the provider data
+3. Navigate to this URL to access the interactive test interface
+4. Select a payment method and scenario
+5. Click "Process Test Payment" to simulate the payment
+6. The payment status will update automatically based on the selected scenario
+
+## React Components
+
+Use the provided React components in your admin interface:
+
+```tsx
+import { TestModeWarningBanner, TestModeBadge, TestPaymentControls } from '@xtr-dev/payload-billing/client'
+
+// Show warning banner when in test mode
+<TestModeWarningBanner visible={isTestMode} />
+
+// Add test badge to payment status
+<div>
+  Payment Status: {status}
+  <TestModeBadge visible={isTestMode} />
+</div>
+
+// Payment testing controls
+<TestPaymentControls
+  paymentId={paymentId}
+  onScenarioSelect={(scenario) => console.log('Selected scenario:', scenario)}
+  onMethodSelect={(method) => console.log('Selected method:', method)}
+/>
+```
+
+## API Endpoints
+
+The test provider automatically registers these endpoints:
+
+- `GET /api/payload-billing/test/payment/:id` - Test payment UI
+- `POST /api/payload-billing/test/process` - Process test payment
+- `GET /api/payload-billing/test/status/:id` - Get payment status
+
+## Development Tips
+
+1. **Console Warnings**: Keep `consoleWarnings: true` to get notifications about test mode
+2. **Visual Indicators**: Use warning banners and badges to clearly mark test payments
+3. **Custom Scenarios**: Create scenarios that match your specific use cases
+4. **Automated Testing**: Use the test provider in your e2e tests for predictable payment outcomes
+5. **Method Testing**: Test different payment methods to ensure your UI handles them correctly
+
+## Production Safety
+
+The test provider includes several safety mechanisms:
+
+- Must be explicitly enabled with `enabled: true`
+- Clearly marked with test indicators
+- Console warnings when active
+- Separate endpoint namespace (`/payload-billing/test/`)
+- No real payment processing
+
+**Important**: Never use the test provider in production environments!

eslint.config.js

@@ -44,6 +44,7 @@ export default [
       'perfectionist/sort-switch-case': 'off',
       'perfectionist/sort-union-types': 'off',
       'perfectionist/sort-variable-declarations': 'off',
+      'perfectionist/sort-intersection-types': 'off',
     },
   },
   {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xtr-dev/payload-billing",
-  "version": "0.1.1",
+  "version": "0.1.12",
   "description": "PayloadCMS plugin for billing and payment provider integrations with tracking and local testing",
   "license": "MIT",
   "type": "module",
@@ -70,6 +70,7 @@
   "devDependencies": {
     "@changesets/cli": "^2.27.1",
     "@eslint/eslintrc": "^3.2.0",
+    "@mollie/api-client": "^3.7.0",
     "@payloadcms/db-mongodb": "3.37.0",
     "@payloadcms/db-postgres": "3.37.0",
     "@payloadcms/db-sqlite": "3.37.0",
@@ -99,16 +100,17 @@
     "rimraf": "3.0.2",
     "sharp": "0.34.2",
     "sort-package-json": "^2.10.0",
+    "stripe": "^18.5.0",
     "typescript": "5.7.3",
     "vite-tsconfig-paths": "^5.1.4",
     "vitest": "^3.1.2"
   },
   "peerDependencies": {
-    "payload": "^3.37.0"
+    "@mollie/api-client": "^3.7.0 || ^4.0.0",
+    "payload": "^3.37.0",
+    "stripe": "^18.5.0"
   },
   "dependencies": {
-    "stripe": "^14.15.0",
-    "@mollie/api-client": "^3.7.0",
     "zod": "^3.22.4"
   },
   "engines": {

pnpm-lock.yaml

@@ -8,12 +8,6 @@ importers:
 
   .:
     dependencies:
-      '@mollie/api-client':
-        specifier: ^3.7.0
-        version: 3.7.0
-      stripe:
-        specifier: ^14.15.0
-        version: 14.25.0
       zod:
         specifier: ^3.22.4
         version: 3.25.76
@@ -24,6 +18,9 @@ importers:
       '@eslint/eslintrc':
         specifier: ^3.2.0
         version: 3.3.1
+      '@mollie/api-client':
+        specifier: ^3.7.0
+        version: 3.7.0
       '@payloadcms/db-mongodb':
         specifier: 3.37.0
         version: 3.37.0(payload@3.37.0(graphql@16.11.0)(typescript@5.7.3))
@@ -111,6 +108,9 @@ importers:
       sort-package-json:
         specifier: ^2.10.0
         version: 2.15.1
+      stripe:
+        specifier: ^18.5.0
+        version: 18.5.0(@types/node@22.18.1)
       typescript:
         specifier: 5.7.3
         version: 5.7.3
@@ -5165,9 +5165,14 @@ packages:
   strip-literal@3.0.0:
     resolution: {integrity: sha512-TcccoMhJOM3OebGhSBEmp3UZ2SfDMZUEBdRA/9ynfLi8yYajyWX3JiXArcJt4Umh4vISpspkQIY8ZZoCqjbviA==}
 
-  stripe@14.25.0:
-    resolution: {integrity: sha512-wQS3GNMofCXwH8TSje8E1SE8zr6ODiGtHQgPtO95p9Mb4FhKC9jvXR2NUTpZ9ZINlckJcFidCmaTFV4P6vsb9g==}
+  stripe@18.5.0:
+    resolution: {integrity: sha512-Hp+wFiEQtCB0LlNgcFh5uVyKznpDjzyUZ+CNVEf+I3fhlYvh7rZruIg+jOwzJRCpy0ZTPMjlzm7J2/M2N6d+DA==}
     engines: {node: '>=12.*'}
+    peerDependencies:
+      '@types/node': '>=12.x.x'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
 
   strtok3@10.3.4:
     resolution: {integrity: sha512-KIy5nylvC5le1OdaaoCJ07L+8iQzJHGH6pWDuzS+d07Cu7n1MZ2x26P8ZKIWfbK02+XIL8Mp4RkWeqdUCrDMfg==}
@@ -8875,7 +8880,7 @@ snapshots:
       eslint: 9.35.0
       eslint-import-resolver-node: 0.3.9
       eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import-x@4.4.2(eslint@9.35.0)(typescript@5.7.3))(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.43.0(eslint@9.35.0)(typescript@5.7.3))(eslint@9.35.0))(eslint@9.35.0)
-      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.43.0(eslint@9.35.0)(typescript@5.7.3))(eslint-import-resolver-typescript@3.10.1)(eslint@9.35.0)
+      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.43.0(eslint@9.35.0)(typescript@5.7.3))(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import-x@4.4.2(eslint@9.35.0)(typescript@5.7.3))(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.43.0(eslint@9.35.0)(typescript@5.7.3))(eslint@9.35.0))(eslint@9.35.0))(eslint@9.35.0)
       eslint-plugin-jsx-a11y: 6.10.2(eslint@9.35.0)
       eslint-plugin-react: 7.37.5(eslint@9.35.0)
       eslint-plugin-react-hooks: 5.2.0(eslint@9.35.0)
@@ -8909,7 +8914,7 @@ snapshots:
       tinyglobby: 0.2.15
       unrs-resolver: 1.11.1
     optionalDependencies:
-      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.43.0(eslint@9.35.0)(typescript@5.7.3))(eslint-import-resolver-typescript@3.10.1)(eslint@9.35.0)
+      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.43.0(eslint@9.35.0)(typescript@5.7.3))(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import-x@4.4.2(eslint@9.35.0)(typescript@5.7.3))(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.43.0(eslint@9.35.0)(typescript@5.7.3))(eslint@9.35.0))(eslint@9.35.0))(eslint@9.35.0)
       eslint-plugin-import-x: 4.4.2(eslint@9.35.0)(typescript@5.7.3)
     transitivePeerDependencies:
       - supports-color
@@ -8960,7 +8965,7 @@ snapshots:
       - typescript
     optional: true
 
-  eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.43.0(eslint@9.35.0)(typescript@5.7.3))(eslint-import-resolver-typescript@3.10.1)(eslint@9.35.0):
+  eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.43.0(eslint@9.35.0)(typescript@5.7.3))(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import-x@4.4.2(eslint@9.35.0)(typescript@5.7.3))(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.43.0(eslint@9.35.0)(typescript@5.7.3))(eslint@9.35.0))(eslint@9.35.0))(eslint@9.35.0):
     dependencies:
       '@rtsao/scc': 1.1.0
       array-includes: 3.1.9
@@ -11434,10 +11439,11 @@ snapshots:
     dependencies:
       js-tokens: 9.0.1
 
-  stripe@14.25.0:
+  stripe@18.5.0(@types/node@22.18.1):
     dependencies:
-      '@types/node': 22.18.1
       qs: 6.14.0
+    optionalDependencies:
+      '@types/node': 22.18.1
 
   strtok3@10.3.4:
     dependencies:

src/__tests__/test-provider.test.ts

@@ -1,283 +0,0 @@
-import type { TestProviderConfig} from '../types';
-
-import { TestPaymentProvider } from '../providers/test/provider'
-import { PaymentStatus } from '../types'
-
-describe('TestPaymentProvider', () => {
-  let provider: TestPaymentProvider
-  let config: TestProviderConfig
-
-  beforeEach(() => {
-    config = {
-      autoComplete: true,
-      defaultDelay: 0,
-      enabled: true,
-    }
-    provider = new TestPaymentProvider(config)
-  })
-
-  afterEach(() => {
-    provider.clearStoredData()
-  })
-
-  describe('createPayment', () => {
-    it('should create a payment with succeeded status when autoComplete is true', async () => {
-      const payment = await provider.createPayment({
-        amount: 2000,
-        currency: 'USD',
-        description: 'Test payment',
-      })
-
-      expect(payment).toMatchObject({
-        amount: 2000,
-        currency: 'USD',
-        description: 'Test payment',
-        provider: 'test',
-        status: 'succeeded',
-      })
-      expect(payment.id).toBeDefined()
-      expect(payment.createdAt).toBeDefined()
-      expect(payment.updatedAt).toBeDefined()
-      expect(payment.providerData?.testMode).toBe(true)
-    })
-
-    it('should create a payment with pending status when autoComplete is false', async () => {
-      config.autoComplete = false
-      provider = new TestPaymentProvider(config)
-
-      const payment = await provider.createPayment({
-        amount: 1500,
-        currency: 'EUR',
-      })
-
-      expect(payment).toMatchObject({
-        amount: 1500,
-        currency: 'EUR',
-        status: 'pending',
-      })
-    })
-
-    it('should create a failed payment when simulateFailure is true', async () => {
-      const payment = await provider.createPayment({
-        amount: 1000,
-        currency: 'USD',
-        metadata: {
-          test: { simulateFailure: true },
-        },
-      })
-
-      expect(payment.status).toBe('failed')
-      expect(payment.providerData?.simulatedFailure).toBe(true)
-    })
-
-    it('should apply delay when specified', async () => {
-      const startTime = Date.now()
-      
-      await provider.createPayment({
-        amount: 1000,
-        currency: 'USD',
-        metadata: {
-          test: { delayMs: 100 },
-        },
-      })
-
-      const endTime = Date.now()
-      expect(endTime - startTime).toBeGreaterThanOrEqual(100)
-    })
-
-    it('should store payment data', async () => {
-      const payment = await provider.createPayment({
-        amount: 2000,
-        currency: 'USD',
-      })
-
-      const stored = provider.getStoredPayment(payment.id)
-      expect(stored).toEqual(payment)
-    })
-  })
-
-  describe('retrievePayment', () => {
-    it('should retrieve an existing payment', async () => {
-      const payment = await provider.createPayment({
-        amount: 2000,
-        currency: 'USD',
-      })
-
-      const retrieved = await provider.retrievePayment(payment.id)
-      expect(retrieved).toEqual(payment)
-    })
-
-    it('should throw error for non-existent payment', async () => {
-      await expect(provider.retrievePayment('non-existent')).rejects.toThrow(
-        'Payment non-existent not found'
-      )
-    })
-  })
-
-  describe('cancelPayment', () => {
-    it('should cancel a pending payment', async () => {
-      config.autoComplete = false
-      provider = new TestPaymentProvider(config)
-
-      const payment = await provider.createPayment({
-        amount: 2000,
-        currency: 'USD',
-      })
-
-      const canceled = await provider.cancelPayment(payment.id)
-      expect(canceled.status).toBe('canceled')
-      expect(canceled.updatedAt).not.toBe(payment.updatedAt)
-    })
-
-    it('should not cancel a succeeded payment', async () => {
-      const payment = await provider.createPayment({
-        amount: 2000,
-        currency: 'USD',
-      })
-
-      await expect(provider.cancelPayment(payment.id)).rejects.toThrow(
-        'Cannot cancel a succeeded payment'
-      )
-    })
-
-    it('should throw error for non-existent payment', async () => {
-      await expect(provider.cancelPayment('non-existent')).rejects.toThrow(
-        'Payment non-existent not found'
-      )
-    })
-  })
-
-  describe('refundPayment', () => {
-    it('should create a full refund for succeeded payment', async () => {
-      const payment = await provider.createPayment({
-        amount: 2000,
-        currency: 'USD',
-      })
-
-      const refund = await provider.refundPayment(payment.id)
-      
-      expect(refund).toMatchObject({
-        amount: 2000,
-        currency: 'USD',
-        paymentId: payment.id,
-        status: 'succeeded',
-      })
-      expect(refund.id).toBeDefined()
-      expect(refund.createdAt).toBeDefined()
-
-      // Check payment status is updated
-      const updatedPayment = await provider.retrievePayment(payment.id)
-      expect(updatedPayment.status).toBe('refunded')
-    })
-
-    it('should create a partial refund', async () => {
-      const payment = await provider.createPayment({
-        amount: 2000,
-        currency: 'USD',
-      })
-
-      const refund = await provider.refundPayment(payment.id, 1000)
-      
-      expect(refund.amount).toBe(1000)
-      
-      // Check payment status is updated to partially_refunded
-      const updatedPayment = await provider.retrievePayment(payment.id)
-      expect(updatedPayment.status).toBe('partially_refunded')
-    })
-
-    it('should not refund a non-succeeded payment', async () => {
-      config.autoComplete = false
-      provider = new TestPaymentProvider(config)
-
-      const payment = await provider.createPayment({
-        amount: 2000,
-        currency: 'USD',
-      })
-
-      await expect(provider.refundPayment(payment.id)).rejects.toThrow(
-        'Can only refund succeeded payments'
-      )
-    })
-
-    it('should not refund more than payment amount', async () => {
-      const payment = await provider.createPayment({
-        amount: 2000,
-        currency: 'USD',
-      })
-
-      await expect(provider.refundPayment(payment.id, 3000)).rejects.toThrow(
-        'Refund amount cannot exceed payment amount'
-      )
-    })
-  })
-
-  describe('handleWebhook', () => {
-    it('should handle webhook event', async () => {
-      const mockRequest = {
-        text: () => Promise.resolve(JSON.stringify({
-          type: 'payment.succeeded',
-          data: { paymentId: 'test_pay_123' }
-        }))
-      } as Request
-
-      const event = await provider.handleWebhook(mockRequest)
-
-      expect(event).toMatchObject({
-        type: 'payment.succeeded',
-        data: { paymentId: 'test_pay_123' },
-        provider: 'test',
-        verified: true,
-      })
-      expect(event.id).toBeDefined()
-    })
-
-    it('should throw error for invalid JSON', async () => {
-      const mockRequest = {
-        text: () => Promise.resolve('invalid json')
-      } as Request
-
-      await expect(provider.handleWebhook(mockRequest)).rejects.toThrow(
-        'Invalid JSON in webhook body'
-      )
-    })
-
-    it('should throw error when provider is disabled', async () => {
-      config.enabled = false
-      provider = new TestPaymentProvider(config)
-
-      const mockRequest = {
-        text: () => Promise.resolve('{}')
-      } as Request
-
-      await expect(provider.handleWebhook(mockRequest)).rejects.toThrow(
-        'Test provider is not enabled'
-      )
-    })
-  })
-
-  describe('data management', () => {
-    it('should clear all stored data', async () => {
-      await provider.createPayment({ amount: 1000, currency: 'USD' })
-      
-      expect(provider.getAllPayments()).toHaveLength(1)
-      
-      provider.clearStoredData()
-      
-      expect(provider.getAllPayments()).toHaveLength(0)
-      expect(provider.getAllRefunds()).toHaveLength(0)
-    })
-
-    it('should return all payments and refunds', async () => {
-      const payment1 = await provider.createPayment({ amount: 1000, currency: 'USD' })
-      const payment2 = await provider.createPayment({ amount: 2000, currency: 'EUR' })
-      const refund = await provider.refundPayment(payment1.id)
-
-      const payments = provider.getAllPayments()
-      const refunds = provider.getAllRefunds()
-
-      expect(payments).toHaveLength(2)
-      expect(refunds).toHaveLength(1)
-      expect(refunds[0]).toEqual(refund)
-    })
-  })
-})

src/collections/customers.ts

@@ -1,149 +0,0 @@
-import type { CollectionConfig } from 'payload'
-
-import type { 
-  AccessArgs,
-  CollectionAfterChangeHook,
-  CollectionBeforeChangeHook,
-  CustomerData,
-  CustomerDocument
-} from '../types/payload'
-
-export function createCustomersCollection(slug: string = 'customers'): CollectionConfig {
-  return {
-    slug,
-    access: {
-      create: ({ req: { user } }: AccessArgs) => !!user,
-      delete: ({ req: { user } }: AccessArgs) => !!user,
-      read: ({ req: { user } }: AccessArgs) => !!user,
-      update: ({ req: { user } }: AccessArgs) => !!user,
-    },
-    admin: {
-      defaultColumns: ['email', 'name', 'createdAt'],
-      group: 'Billing',
-      useAsTitle: 'email',
-    },
-    fields: [
-      {
-        name: 'email',
-        type: 'email',
-        admin: {
-          description: 'Customer email address',
-        },
-        index: true,
-        unique: true,
-      },
-      {
-        name: 'name',
-        type: 'text',
-        admin: {
-          description: 'Customer full name',
-        },
-      },
-      {
-        name: 'phone',
-        type: 'text',
-        admin: {
-          description: 'Customer phone number',
-        },
-      },
-      {
-        name: 'address',
-        type: 'group',
-        fields: [
-          {
-            name: 'line1',
-            type: 'text',
-            label: 'Address Line 1',
-          },
-          {
-            name: 'line2',
-            type: 'text',
-            label: 'Address Line 2',
-          },
-          {
-            name: 'city',
-            type: 'text',
-            label: 'City',
-          },
-          {
-            name: 'state',
-            type: 'text',
-            label: 'State/Province',
-          },
-          {
-            name: 'postal_code',
-            type: 'text',
-            label: 'Postal Code',
-          },
-          {
-            name: 'country',
-            type: 'text',
-            admin: {
-              description: 'ISO 3166-1 alpha-2 country code',
-            },
-            label: 'Country',
-            maxLength: 2,
-          },
-        ],
-      },
-      {
-        name: 'providerIds',
-        type: 'json',
-        admin: {
-          description: 'Customer IDs from payment providers',
-          readOnly: true,
-        },
-      },
-      {
-        name: 'metadata',
-        type: 'json',
-        admin: {
-          description: 'Additional customer metadata',
-        },
-      },
-      {
-        name: 'payments',
-        type: 'relationship',
-        admin: {
-          description: 'Customer payments',
-          readOnly: true,
-        },
-        hasMany: true,
-        relationTo: 'payments',
-      },
-      {
-        name: 'invoices',
-        type: 'relationship',
-        admin: {
-          description: 'Customer invoices',
-          readOnly: true,
-        },
-        hasMany: true,
-        relationTo: 'invoices',
-      },
-    ],
-    hooks: {
-      afterChange: [
-        ({ doc, operation, req }: CollectionAfterChangeHook<CustomerDocument>) => {
-          if (operation === 'create') {
-            req.payload.logger.info(`Customer created: ${doc.id} (${doc.email})`)
-          }
-        },
-      ],
-      beforeChange: [
-        ({ data, operation }: CollectionBeforeChangeHook<CustomerData>) => {
-          if (operation === 'create' || operation === 'update') {
-            // Normalize country code
-            if (data.address?.country) {
-              data.address.country = data.address.country.toUpperCase()
-              if (!/^[A-Z]{2}$/.test(data.address.country)) {
-                throw new Error('Country must be a 2-letter ISO code')
-              }
-            }
-          }
-        },
-      ],
-    },
-    timestamps: true,
-  }
-}

src/collections/hooks.ts

@@ -0,0 +1,13 @@
+import type { Payment } from '../plugin/types/index'
+import type { Payload } from 'payload'
+import { useBillingPlugin } from '../plugin/index'
+
+export const initProviderPayment = async (payload: Payload, payment: Partial<Payment>): Promise<Partial<Payment>> => {
+  const billing = useBillingPlugin(payload)
+  if (!payment.provider || !billing.providerConfig[payment.provider]) {
+    throw new Error(`Provider ${payment.provider} not found.`)
+  }
+  // Handle both async and non-async initPayment functions
+  const result = billing.providerConfig[payment.provider].initPayment(payload, payment)
+  return await Promise.resolve(result)
+}

src/collections/index.ts

@@ -1,4 +1,3 @@
-export { createCustomersCollection } from './customers'
 export { createInvoicesCollection } from './invoices'
 export { createPaymentsCollection } from './payments'
 export { createRefundsCollection } from './refunds'

src/collections/invoices.ts

@@ -1,30 +1,20 @@
-import type { CollectionConfig } from 'payload'
-
-import type { 
+import {
   AccessArgs,
   CollectionAfterChangeHook,
   CollectionBeforeChangeHook,
   CollectionBeforeValidateHook,
-  InvoiceData,
-  InvoiceDocument,
-  InvoiceItemData
-} from '../types/payload'
+  CollectionConfig, Field,
+} from 'payload'
+import type { BillingPluginConfig} from '@/plugin/config';
+import { defaults } from '@/plugin/config'
+import { extractSlug } from '@/plugin/utils'
+import { createContextLogger } from '@/utils/logger'
+import type { Invoice } from '@/plugin/types'
 
-export function createInvoicesCollection(slug: string = 'invoices'): CollectionConfig {
-  return {
-    slug,
-    access: {
-      create: ({ req: { user } }: AccessArgs) => !!user,
-      delete: ({ req: { user } }: AccessArgs) => !!user,
-      read: ({ req: { user } }: AccessArgs) => !!user,
-      update: ({ req: { user } }: AccessArgs) => !!user,
-    },
-    admin: {
-      defaultColumns: ['number', 'customer', 'status', 'amount', 'currency', 'dueDate'],
-      group: 'Billing',
-      useAsTitle: 'number',
-    },
-    fields: [
+export function createInvoicesCollection(pluginConfig: BillingPluginConfig): CollectionConfig {
+  const {customerRelationSlug, customerInfoExtractor} = pluginConfig
+  const overrides = typeof pluginConfig.collections?.invoices === 'object' ? pluginConfig.collections?.invoices : {}
+  let fields: Field[] = [
     {
       name: 'number',
       type: 'text',
@@ -35,14 +25,135 @@ export function createInvoicesCollection(slug: string = 'invoices'): CollectionC
       required: true,
       unique: true,
     },
-      {
+    // Optional customer relationship
+    ...(customerRelationSlug ? [{
       name: 'customer',
-        type: 'relationship',
+      type: 'relationship' as const,
       admin: {
-          position: 'sidebar',
+        position: 'sidebar' as const,
+        description: 'Link to customer record (optional)',
       },
-        relationTo: 'customers',
-        required: true,
+      relationTo: extractSlug(customerRelationSlug),
+      required: false,
+    }] : []),
+    // Basic customer info fields (embedded)
+    {
+      name: 'customerInfo',
+      type: 'group',
+      admin: {
+        description: customerRelationSlug && customerInfoExtractor
+          ? 'Customer billing information (auto-populated from customer relationship)'
+          : 'Customer billing information',
+        readOnly: !!(customerRelationSlug && customerInfoExtractor),
+      },
+      fields: [
+        {
+          name: 'name',
+          type: 'text',
+          admin: {
+            description: 'Customer name',
+            readOnly: !!(customerRelationSlug && customerInfoExtractor),
+          },
+          required: !customerRelationSlug || !customerInfoExtractor,
+        },
+        {
+          name: 'email',
+          type: 'email',
+          admin: {
+            description: 'Customer email address',
+            readOnly: !!(customerRelationSlug && customerInfoExtractor),
+          },
+          required: !customerRelationSlug || !customerInfoExtractor,
+        },
+        {
+          name: 'phone',
+          type: 'text',
+          admin: {
+            description: 'Customer phone number',
+            readOnly: !!(customerRelationSlug && customerInfoExtractor),
+          },
+        },
+        {
+          name: 'company',
+          type: 'text',
+          admin: {
+            description: 'Company name (optional)',
+            readOnly: !!(customerRelationSlug && customerInfoExtractor),
+          },
+        },
+        {
+          name: 'taxId',
+          type: 'text',
+          admin: {
+            description: 'Tax ID or VAT number',
+            readOnly: !!(customerRelationSlug && customerInfoExtractor),
+          },
+        },
+      ],
+    },
+    {
+      name: 'billingAddress',
+      type: 'group',
+      admin: {
+        description: customerRelationSlug && customerInfoExtractor
+          ? 'Billing address (auto-populated from customer relationship)'
+          : 'Billing address',
+        readOnly: !!(customerRelationSlug && customerInfoExtractor),
+      },
+      fields: [
+        {
+          name: 'line1',
+          type: 'text',
+          admin: {
+            description: 'Address line 1',
+            readOnly: !!(customerRelationSlug && customerInfoExtractor),
+          },
+          required: !customerRelationSlug || !customerInfoExtractor,
+        },
+        {
+          name: 'line2',
+          type: 'text',
+          admin: {
+            description: 'Address line 2',
+            readOnly: !!(customerRelationSlug && customerInfoExtractor),
+          },
+        },
+        {
+          name: 'city',
+          type: 'text',
+          admin: {
+            readOnly: !!(customerRelationSlug && customerInfoExtractor),
+          },
+          required: !customerRelationSlug || !customerInfoExtractor,
+        },
+        {
+          name: 'state',
+          type: 'text',
+          admin: {
+            description: 'State or province',
+            readOnly: !!(customerRelationSlug && customerInfoExtractor),
+          },
+        },
+        {
+          name: 'postalCode',
+          type: 'text',
+          admin: {
+            description: 'Postal or ZIP code',
+            readOnly: !!(customerRelationSlug && customerInfoExtractor),
+          },
+          required: !customerRelationSlug || !customerInfoExtractor,
+        },
+        {
+          name: 'country',
+          type: 'text',
+          admin: {
+            description: 'Country code (e.g., US, GB)',
+            readOnly: !!(customerRelationSlug && customerInfoExtractor),
+          },
+          maxLength: 2,
+          required: !customerRelationSlug || !customerInfoExtractor,
+        },
+      ],
     },
     {
       name: 'status',
@@ -155,7 +266,7 @@ export function createInvoicesCollection(slug: string = 'invoices'): CollectionC
       name: 'paidAt',
       type: 'date',
       admin: {
-          condition: (data: InvoiceData) => data.status === 'paid',
+        condition: (data) => data.status === 'paid',
         readOnly: true,
       },
     },
@@ -163,10 +274,10 @@ export function createInvoicesCollection(slug: string = 'invoices'): CollectionC
       name: 'payment',
       type: 'relationship',
       admin: {
-          condition: (data: InvoiceData) => data.status === 'paid',
+        condition: (data) => data.status === 'paid',
         position: 'sidebar',
       },
-        relationTo: 'payments',
+      relationTo: extractSlug(pluginConfig.collections?.payments || defaults.paymentsCollection),
     },
     {
       name: 'notes',
@@ -182,17 +293,72 @@ export function createInvoicesCollection(slug: string = 'invoices'): CollectionC
         description: 'Additional invoice metadata',
       },
     },
-    ],
+  ]
+  if (overrides?.fields) {
+    fields = overrides.fields({defaultFields: fields})
+  }
+  return {
+    slug: extractSlug(pluginConfig.collections?.invoices || defaults.invoicesCollection),
+    access: {
+      create: ({ req: { user } }: AccessArgs) => !!user,
+      delete: ({ req: { user } }: AccessArgs) => !!user,
+      read: ({ req: { user } }: AccessArgs) => !!user,
+      update: ({ req: { user } }: AccessArgs) => !!user,
+    },
+    admin: {
+      defaultColumns: ['number', 'customerInfo.name', 'status', 'amount', 'currency', 'dueDate'],
+      group: 'Billing',
+      useAsTitle: 'number',
+    },
+    fields,
     hooks: {
       afterChange: [
-        ({ doc, operation, req }: CollectionAfterChangeHook<InvoiceDocument>) => {
+        ({ doc, operation, req }) => {
           if (operation === 'create') {
-            req.payload.logger.info(`Invoice created: ${doc.number}`)
+            const logger = createContextLogger(req.payload, 'Invoices Collection')
+            logger.info(`Invoice created: ${doc.number}`)
           }
         },
-      ],
+      ] satisfies CollectionAfterChangeHook<Invoice>[],
       beforeChange: [
-        ({ data, operation }: CollectionBeforeChangeHook<InvoiceData>) => {
+        async ({ data, operation, req, originalDoc }) => {
+          // Sync customer info from relationship if extractor is provided
+          if (customerRelationSlug && customerInfoExtractor && data.customer) {
+            // Check if customer changed or this is a new invoice
+            const customerChanged = operation === 'create' ||
+              (originalDoc && originalDoc.customer !== data.customer)
+
+            if (customerChanged) {
+              try {
+                // Fetch the customer data
+                const customer = await req.payload.findByID({
+                  collection: customerRelationSlug as never,
+                  id: data.customer as never,
+                })
+
+                // Extract customer info using the provided callback
+                const extractedInfo = customerInfoExtractor(customer)
+
+                // Update the invoice data with extracted info
+                data.customerInfo = {
+                  name: extractedInfo.name,
+                  email: extractedInfo.email,
+                  phone: extractedInfo.phone,
+                  company: extractedInfo.company,
+                  taxId: extractedInfo.taxId,
+                }
+
+                if (extractedInfo.billingAddress) {
+                  data.billingAddress = extractedInfo.billingAddress
+                }
+              } catch (error) {
+                const logger = createContextLogger(req.payload, 'Invoices Collection')
+                logger.error(`Failed to extract customer info: ${error}`)
+                throw new Error('Failed to extract customer information')
+              }
+            }
+          }
+
           if (operation === 'create') {
             // Generate invoice number if not provided
             if (!data.number) {
@@ -221,19 +387,37 @@ export function createInvoicesCollection(slug: string = 'invoices'): CollectionC
             data.paidAt = new Date().toISOString()
           }
         },
-      ],
+      ] satisfies CollectionBeforeChangeHook<Invoice>[],
       beforeValidate: [
-        ({ data }: CollectionBeforeValidateHook<InvoiceData>) => {
+        ({ data }) => {
+          if (!data) return
+
+          // If using extractor, customer relationship is required
+          if (customerRelationSlug && customerInfoExtractor && !data.customer) {
+            throw new Error('Please select a customer')
+          }
+
+          // If not using extractor but have customer collection, either relationship or info is required
+          if (customerRelationSlug && !customerInfoExtractor &&
+              !data.customer && (!data.customerInfo?.name || !data.customerInfo?.email)) {
+            throw new Error('Either select a customer or provide customer information')
+          }
+
+          // If no customer collection, ensure customer info is provided
+          if (!customerRelationSlug && (!data.customerInfo?.name || !data.customerInfo?.email)) {
+            throw new Error('Customer name and email are required')
+          }
+
           if (data && data.items && Array.isArray(data.items)) {
             // Calculate totals for each line item
-            data.items = data.items.map((item: InvoiceItemData) => ({
+            data.items = data.items.map((item) => ({
               ...item,
               totalAmount: (item.quantity || 0) * (item.unitAmount || 0),
             }))
 
             // Calculate subtotal
             data.subtotal = data.items.reduce(
-              (sum: number, item: InvoiceItemData) => sum + (item.totalAmount || 0),
+              (sum: number, item) => sum + (item.totalAmount || 0),
               0
             )
 
@@ -241,7 +425,7 @@ export function createInvoicesCollection(slug: string = 'invoices'): CollectionC
             data.amount = (data.subtotal || 0) + (data.taxAmount || 0)
           }
         },
-      ],
+      ] satisfies CollectionBeforeValidateHook<Invoice>[],
     },
     timestamps: true,
   }

src/collections/payments.ts

@@ -1,28 +1,13 @@
-import type { CollectionConfig } from 'payload'
+import type { AccessArgs, CollectionBeforeChangeHook, CollectionConfig, Field } from 'payload'
+import type { BillingPluginConfig} from '../plugin/config';
+import { defaults } from '../plugin/config'
+import { extractSlug } from '../plugin/utils'
+import type { Payment } from '../plugin/types/payments'
+import { initProviderPayment } from './hooks'
 
-import type { 
-  AccessArgs,
-  CollectionAfterChangeHook,
-  CollectionBeforeChangeHook,
-  PaymentData,
-  PaymentDocument
-} from '../types/payload'
-
-export function createPaymentsCollection(slug: string = 'payments'): CollectionConfig {
-  return {
-    slug,
-    access: {
-      create: ({ req: { user } }: AccessArgs) => !!user,
-      delete: ({ req: { user } }: AccessArgs) => !!user,
-      read: ({ req: { user } }: AccessArgs) => !!user,
-      update: ({ req: { user } }: AccessArgs) => !!user,
-    },
-    admin: {
-      defaultColumns: ['id', 'provider', 'status', 'amount', 'currency', 'createdAt'],
-      group: 'Billing',
-      useAsTitle: 'id',
-    },
-    fields: [
+export function createPaymentsCollection(pluginConfig: BillingPluginConfig): CollectionConfig {
+  const overrides = typeof pluginConfig.collections?.payments === 'object' ? pluginConfig.collections?.payments : {}
+  let fields: Field[] = [
     {
       name: 'provider',
       type: 'select',
@@ -43,8 +28,8 @@ export function createPaymentsCollection(slug: string = 'payments'): CollectionC
         description: 'The payment ID from the payment provider',
       },
       label: 'Provider Payment ID',
-        required: true,
       unique: true,
+      index: true, // Ensure this field is indexed for webhook lookups
     },
     {
       name: 'status',
@@ -88,21 +73,13 @@ export function createPaymentsCollection(slug: string = 'payments'): CollectionC
         description: 'Payment description',
       },
     },
-      {
-        name: 'customer',
-        type: 'relationship',
-        admin: {
-          position: 'sidebar',
-        },
-        relationTo: 'customers',
-      },
     {
       name: 'invoice',
       type: 'relationship',
       admin: {
         position: 'sidebar',
       },
-        relationTo: 'invoices',
+      relationTo: extractSlug(pluginConfig.collections?.invoices || defaults.invoicesCollection),
     },
     {
       name: 'metadata',
@@ -127,19 +104,39 @@ export function createPaymentsCollection(slug: string = 'payments'): CollectionC
         readOnly: true,
       },
       hasMany: true,
-        relationTo: 'refunds',
+      relationTo: extractSlug(pluginConfig.collections?.refunds || defaults.refundsCollection),
     },
-    ],
-    hooks: {
-      afterChange: [
-        ({ doc, operation, req }: CollectionAfterChangeHook<PaymentDocument>) => {
-          if (operation === 'create') {
-            req.payload.logger.info(`Payment created: ${doc.id} (${doc.provider})`)
+    {
+      name: 'version',
+      type: 'number',
+      defaultValue: 1,
+      admin: {
+        hidden: true, // Hide from admin UI to prevent manual tampering
+      },
+      index: true, // Index for optimistic locking performance
+    },
+  ]
+  if (overrides?.fields) {
+    fields = overrides?.fields({defaultFields: fields})
   }
+  return {
+    slug: extractSlug(pluginConfig.collections?.payments || defaults.paymentsCollection),
+    access: overrides?.access || {
+      create: ({ req: { user } }: AccessArgs) => !!user,
+      delete: ({ req: { user } }: AccessArgs) => !!user,
+      read: ({ req: { user } }: AccessArgs) => !!user,
+      update: ({ req: { user } }: AccessArgs) => !!user,
     },
-      ],
+    admin: {
+      defaultColumns: ['id', 'provider', 'status', 'amount', 'currency', 'createdAt'],
+      group: 'Billing',
+      useAsTitle: 'id',
+      ...overrides?.admin
+    },
+    fields,
+    hooks: {
       beforeChange: [
-        ({ data, operation }: CollectionBeforeChangeHook<PaymentData>) => {
+        async ({ data, operation, req, originalDoc }) => {
           if (operation === 'create') {
             // Validate amount format
             if (data.amount && !Number.isInteger(data.amount)) {
@@ -153,9 +150,20 @@ export function createPaymentsCollection(slug: string = 'payments'): CollectionC
                 throw new Error('Currency must be a 3-letter ISO code')
               }
             }
+
+            await initProviderPayment(req.payload, data)
+          }
+
+          // Auto-increment version for manual updates (not webhook updates)
+          // Webhook updates handle their own versioning in updatePaymentStatus
+          if (operation === 'update' && !data.version) {
+            // If version is not being explicitly set (i.e., manual admin update),
+            // increment it automatically
+            const currentVersion = (originalDoc as Payment)?.version || 1
+            data.version = currentVersion + 1
           }
         },
-      ],
+      ] satisfies CollectionBeforeChangeHook<Payment>[],
     },
     timestamps: true,
   }

src/collections/refunds.ts

@@ -1,16 +1,13 @@
-import type { CollectionConfig } from 'payload'
+import type { AccessArgs, CollectionConfig } from 'payload'
+import { BillingPluginConfig, defaults } from '../plugin/config'
+import { extractSlug } from '../plugin/utils'
+import { Payment } from '../plugin/types/index'
+import { createContextLogger } from '../utils/logger'
 
-import type { 
-  AccessArgs,
-  CollectionAfterChangeHook,
-  CollectionBeforeChangeHook,
-  RefundData,
-  RefundDocument
-} from '../types/payload'
-
-export function createRefundsCollection(slug: string = 'refunds'): CollectionConfig {
+export function createRefundsCollection(pluginConfig: BillingPluginConfig): CollectionConfig {
+  // TODO: finish collection overrides
   return {
-    slug,
+    slug: extractSlug(pluginConfig.collections?.refunds || defaults.refundsCollection),
     access: {
       create: ({ req: { user } }: AccessArgs) => !!user,
       delete: ({ req: { user } }: AccessArgs) => !!user,
@@ -39,7 +36,7 @@ export function createRefundsCollection(slug: string = 'refunds'): CollectionCon
         admin: {
           position: 'sidebar',
         },
-        relationTo: 'payments',
+        relationTo: extractSlug(pluginConfig.collections?.payments || defaults.paymentsCollection),
         required: true,
       },
       {
@@ -113,34 +110,35 @@ export function createRefundsCollection(slug: string = 'refunds'): CollectionCon
     ],
     hooks: {
       afterChange: [
-        async ({ doc, operation, req }: CollectionAfterChangeHook<RefundDocument>) => {
+        async ({ doc, operation, req }) => {
           if (operation === 'create') {
-            req.payload.logger.info(`Refund created: ${doc.id} for payment: ${doc.payment}`)
+            const logger = createContextLogger(req.payload, 'Refunds Collection')
+            logger.info(`Refund created: ${doc.id} for payment: ${doc.payment}`)
 
             // Update the related payment's refund relationship
             try {
               const payment = await req.payload.findByID({
                 id: typeof doc.payment === 'string' ? doc.payment : doc.payment.id,
-                collection: 'payments',
-              })
+                collection: extractSlug(pluginConfig.collections?.payments || defaults.paymentsCollection),
+              }) as Payment
 
               const refundIds = Array.isArray(payment.refunds) ? payment.refunds : []
-              
               await req.payload.update({
                 id: typeof doc.payment === 'string' ? doc.payment : doc.payment.id,
-                collection: 'payments',
+                collection: extractSlug(pluginConfig.collections?.payments || defaults.paymentsCollection),
                 data: {
                   refunds: [...refundIds, doc.id],
                 },
               })
             } catch (error) {
-              req.payload.logger.error(`Failed to update payment refunds: ${error}`)
+              const logger = createContextLogger(req.payload, 'Refunds Collection')
+              logger.error(`Failed to update payment refunds: ${error}`)
             }
           }
         },
       ],
       beforeChange: [
-        ({ data, operation }: CollectionBeforeChangeHook<RefundData>) => {
+        ({ data, operation }) => {
           if (operation === 'create') {
             // Validate amount format
             if (data.amount && !Number.isInteger(data.amount)) {

src/exports/client.tsx

@@ -60,9 +60,130 @@ export const PaymentStatusBadge: React.FC<{ status: string }> = ({ status }) =>
   )
 }
 
+// Test mode indicator components
+export const TestModeWarningBanner: React.FC<{ visible?: boolean }> = ({ visible = true }) => {
+  if (!visible) return null
+
+  return (
+    <div style={{
+      background: 'linear-gradient(90deg, #ff6b6b, #ffa726)',
+      color: 'white',
+      padding: '12px 20px',
+      textAlign: 'center',
+      fontWeight: 600,
+      fontSize: '14px',
+      marginBottom: '20px',
+      borderRadius: '4px'
+    }}>
+      🧪 TEST MODE - Payment system is running in test mode for development
+    </div>
+  )
+}
+
+export const TestModeBadge: React.FC<{ visible?: boolean }> = ({ visible = true }) => {
+  if (!visible) return null
+
+  return (
+    <span style={{
+      display: 'inline-block',
+      background: '#6c757d',
+      color: 'white',
+      padding: '4px 8px',
+      borderRadius: '4px',
+      fontSize: '12px',
+      fontWeight: 600,
+      textTransform: 'uppercase',
+      marginLeft: '8px'
+    }}>
+      Test
+    </span>
+  )
+}
+
+export const TestPaymentControls: React.FC<{
+  paymentId?: string
+  onScenarioSelect?: (scenario: string) => void
+  onMethodSelect?: (method: string) => void
+}> = ({ paymentId, onScenarioSelect, onMethodSelect }) => {
+  const [selectedScenario, setSelectedScenario] = React.useState('')
+  const [selectedMethod, setSelectedMethod] = React.useState('')
+
+  const scenarios = [
+    { id: 'instant-success', name: 'Instant Success', description: 'Payment succeeds immediately' },
+    { id: 'delayed-success', name: 'Delayed Success', description: 'Payment succeeds after delay' },
+    { id: 'cancelled-payment', name: 'Cancelled Payment', description: 'User cancels payment' },
+    { id: 'declined-payment', name: 'Declined Payment', description: 'Payment declined' },
+    { id: 'expired-payment', name: 'Expired Payment', description: 'Payment expires' },
+    { id: 'pending-payment', name: 'Pending Payment', description: 'Payment stays pending' }
+  ]
+
+  const methods = [
+    { id: 'ideal', name: 'iDEAL', icon: '🏦' },
+    { id: 'creditcard', name: 'Credit Card', icon: '💳' },
+    { id: 'paypal', name: 'PayPal', icon: '🅿️' },
+    { id: 'applepay', name: 'Apple Pay', icon: '🍎' },
+    { id: 'banktransfer', name: 'Bank Transfer', icon: '🏛️' }
+  ]
+
+  return (
+    <div style={{ border: '1px solid #e9ecef', borderRadius: '8px', padding: '16px', margin: '16px 0' }}>
+      <h4 style={{ marginBottom: '12px', color: '#2c3e50' }}>🧪 Test Payment Controls</h4>
+
+      <div style={{ marginBottom: '16px' }}>
+        <label style={{ display: 'block', marginBottom: '8px', fontWeight: '600' }}>Payment Method:</label>
+        <select
+          value={selectedMethod}
+          onChange={(e) => {
+            setSelectedMethod(e.target.value)
+            onMethodSelect?.(e.target.value)
+          }}
+          style={{ width: '100%', padding: '8px', borderRadius: '4px', border: '1px solid #ccc' }}
+        >
+          <option value="">Select payment method...</option>
+          {methods.map(method => (
+            <option key={method.id} value={method.id}>
+              {method.icon} {method.name}
+            </option>
+          ))}
+        </select>
+      </div>
+
+      <div style={{ marginBottom: '16px' }}>
+        <label style={{ display: 'block', marginBottom: '8px', fontWeight: '600' }}>Test Scenario:</label>
+        <select
+          value={selectedScenario}
+          onChange={(e) => {
+            setSelectedScenario(e.target.value)
+            onScenarioSelect?.(e.target.value)
+          }}
+          style={{ width: '100%', padding: '8px', borderRadius: '4px', border: '1px solid #ccc' }}
+        >
+          <option value="">Select test scenario...</option>
+          {scenarios.map(scenario => (
+            <option key={scenario.id} value={scenario.id}>
+              {scenario.name} - {scenario.description}
+            </option>
+          ))}
+        </select>
+      </div>
+
+      {paymentId && (
+        <div style={{ marginTop: '12px', padding: '8px', background: '#f8f9fa', borderRadius: '4px' }}>
+          <small style={{ color: '#6c757d' }}>
+            Payment ID: <code>{paymentId}</code>
+          </small>
+        </div>
+      )}
+    </div>
+  )
+}
+
 export default {
   BillingDashboardWidget,
   formatCurrency,
   getPaymentStatusColor,
   PaymentStatusBadge,
+  TestModeWarningBanner,
+  TestModeBadge,
+  TestPaymentControls,
 }

src/index.ts

@@ -1,132 +1,21 @@
-import type { Config } from 'payload'
 
-import type { BillingPluginConfig } from './types'
+export { billingPlugin } from './plugin/index.js'
+export { mollieProvider, stripeProvider } from './providers/index.js'
+export type { BillingPluginConfig, CustomerInfoExtractor, AdvancedTestProviderConfig } from './plugin/config.js'
+export type { Invoice, Payment, Refund } from './plugin/types/index.js'
+export type { PaymentProvider, ProviderData } from './providers/types.js'
 
-import { createCustomersCollection } from './collections/customers'
-import { createInvoicesCollection } from './collections/invoices'
-import { createPaymentsCollection } from './collections/payments'
-import { createRefundsCollection } from './collections/refunds'
-import { providerRegistry } from './providers/base/provider'
-import { TestPaymentProvider } from './providers/test/provider'
+// Export logging utilities
+export { getPluginLogger, createContextLogger } from './utils/logger.js'
 
-export * from './providers/base/provider'
-export * from './providers/test/provider'
-export * from './types'
-
-export const billingPlugin = (pluginConfig: BillingPluginConfig = {}) => (config: Config): Config => {
-  if (pluginConfig.disabled) {
-    return config
-  }
-
-  // Initialize collections
-  if (!config.collections) {
-    config.collections = []
-  }
-
-  config.collections.push(
-    createPaymentsCollection(pluginConfig.collections?.payments || 'payments'),
-    createCustomersCollection(pluginConfig.collections?.customers || 'customers'),
-    createInvoicesCollection(pluginConfig.collections?.invoices || 'invoices'),
-    createRefundsCollection(pluginConfig.collections?.refunds || 'refunds'),
-  )
-
-  // Initialize endpoints
-  if (!config.endpoints) {
-    config.endpoints = []
-  }
-
-  config.endpoints?.push(
-    // Webhook endpoints
-    {
-      handler: async (req) => {
-        try {
-          const provider = providerRegistry.get(req.routeParams?.provider as string)
-          if (!provider) {
-            return Response.json({ error: 'Provider not found' }, { status: 404 })
-          }
-
-          const signature = req.headers.get('stripe-signature') || 
-                          req.headers.get('x-mollie-signature')
-
-          const event = await provider.handleWebhook(req as unknown as Request, signature || '')
-          
-          // TODO: Process webhook event and update database
-          
-          return Response.json({ eventId: event.id, received: true })
-        } catch (error) {
-          console.error('[BILLING] Webhook error:', error)
-          return Response.json({ error: 'Webhook processing failed' }, { status: 400 })
-        }
-      },
-      method: 'post',
-      path: '/billing/webhooks/:provider'
-    },
-    // Health check endpoint
-    {
-      handler: async () => {
-        const providers = providerRegistry.getAll().map(p => ({
-          name: p.name,
-          status: 'active'
-        }))
-        
-        return Response.json({
-          providers,
-          status: 'ok',
-          version: '0.1.0'
-        })
-      },
-      method: 'get',
-      path: '/billing/health'
-    }
-  )
-
-  // Initialize providers and onInit hook
-  const incomingOnInit = config.onInit
-
-  config.onInit = async (payload) => {
-    // Execute any existing onInit functions first
-    if (incomingOnInit) {
-      await incomingOnInit(payload)
-    }
-
-    // Initialize payment providers
-    initializeProviders(pluginConfig)
-    
-    // Log initialization
-    console.log('[BILLING] Plugin initialized with providers:', 
-      providerRegistry.getAll().map(p => p.name).join(', ')
-    )
-  }
-
-  return config
-}
-
-function initializeProviders(config: BillingPluginConfig) {
-  // Initialize test provider if enabled
-  if (config.providers?.test?.enabled) {
-    const testProvider = new TestPaymentProvider(config.providers.test)
-    providerRegistry.register(testProvider)
-  }
-
-  // TODO: Initialize Stripe provider
-  // TODO: Initialize Mollie provider
-}
-
-// Utility function to get payment provider
-export function getPaymentProvider(name: string) {
-  const provider = providerRegistry.get(name)
-  if (!provider) {
-    throw new Error(`Payment provider '${name}' not found`)
-  }
-  return provider
-}
-
-// Utility function to list available providers
-export function getAvailableProviders() {
-  return providerRegistry.getAll().map(p => ({
-    name: p.name,
-    // Add provider-specific info here
-  }))
-}
-
-export default billingPlugin
+// Export all providers
+export { testProvider } from './providers/test.js'
+export type {
+  StripeProviderConfig,
+  MollieProviderConfig,
+  TestProviderConfig,
+  TestProviderConfigResponse,
+  PaymentOutcome,
+  PaymentMethod,
+  PaymentScenario
+} from './providers/index.js'

src/plugin/config.ts

@@ -0,0 +1,60 @@
+import { CollectionConfig } from 'payload'
+import { FieldsOverride } from './utils'
+import { PaymentProvider } from './types/index'
+
+export const defaults = {
+  paymentsCollection: 'payments',
+  invoicesCollection: 'invoices',
+  refundsCollection: 'refunds',
+  customerRelationSlug: 'customer'
+}
+
+// Provider configurations
+
+export interface TestProviderConfig {
+  autoComplete?: boolean
+  defaultDelay?: number
+  enabled: boolean
+  failureRate?: number
+  simulateFailures?: boolean
+}
+
+// Re-export the actual test provider config instead of duplicating
+export type { TestProviderConfig as AdvancedTestProviderConfig } from '../providers/test'
+
+// Customer info extractor callback type
+export interface CustomerInfoExtractor {
+  (customer: any): {
+    name: string
+    email: string
+    phone?: string
+    company?: string
+    taxId?: string
+    billingAddress?: {
+      line1: string
+      line2?: string
+      city: string
+      state?: string
+      postalCode: string
+      country: string
+    }
+  }
+}
+
+// Plugin configuration
+export interface BillingPluginConfig {
+  admin?: {
+    customComponents?: boolean
+    dashboard?: boolean
+  }
+  collections?: {
+    invoices?: string | (Partial<CollectionConfig> & {fields?: FieldsOverride})
+    payments?: string | (Partial<CollectionConfig> & {fields?: FieldsOverride})
+    refunds?: string | (Partial<CollectionConfig> & {fields?: FieldsOverride})
+  }
+  customerInfoExtractor?: CustomerInfoExtractor // Callback to extract customer info from relationship
+  customerRelationSlug?: string // Customer collection slug for relationship
+  disabled?: boolean
+  providers?: (PaymentProvider | undefined | null)[]
+}
+

src/plugin/index.ts

@@ -0,0 +1,56 @@
+import { createInvoicesCollection, createPaymentsCollection, createRefundsCollection } from '../collections/index'
+import type { BillingPluginConfig } from './config'
+import type { Config, Payload } from 'payload'
+import { createSingleton } from './singleton'
+import type { PaymentProvider } from '../providers/index'
+
+const singleton = createSingleton(Symbol('billingPlugin'))
+
+type BillingPlugin = {
+  config: BillingPluginConfig
+  providerConfig: {
+    [key: string]: PaymentProvider
+  }
+}
+
+export const useBillingPlugin = (payload: Payload) => singleton.get(payload) as BillingPlugin
+
+export const billingPlugin = (pluginConfig: BillingPluginConfig = {}) => (config: Config): Config => {
+  if (pluginConfig.disabled) {
+    return config
+  }
+
+  config.collections = [
+    ...(config.collections || []),
+    createPaymentsCollection(pluginConfig),
+    createInvoicesCollection(pluginConfig),
+    createRefundsCollection(pluginConfig),
+  ];
+
+  (pluginConfig.providers || [])
+    .filter(provider => provider?.onConfig)
+    .forEach(provider => provider?.onConfig!(config, pluginConfig))
+
+  const incomingOnInit = config.onInit
+  config.onInit = async (payload) => {
+    if (incomingOnInit) {
+      await incomingOnInit(payload)
+    }
+    singleton.set(payload, {
+      config: pluginConfig,
+      providerConfig: (pluginConfig.providers || []).filter(Boolean).reduce(
+        (record, provider) => {
+          record[provider!.key] = provider as PaymentProvider
+          return record
+        },
+        {} as Record<string, PaymentProvider>
+      )
+    } satisfies BillingPlugin)
+    await Promise.all((pluginConfig.providers || [])
+      .filter(provider => provider?.onInit)
+      .map(provider => provider?.onInit!(payload)))
+  }
+
+  return config
+}
+export default billingPlugin

src/plugin/singleton.ts

@@ -0,0 +1,11 @@
+export const createSingleton = <T>(s?: symbol | string) => {
+  const symbol = !s ? Symbol() : s
+  return {
+    get(container: any) {
+      return container[symbol] as T
+    },
+    set(container: any, value: T) {
+      container[symbol] = value
+    },
+  }
+}

src/plugin/types/id.ts

@@ -0,0 +1 @@
+export type Id = string | number

src/plugin/types/index.ts

@@ -0,0 +1,5 @@
+export * from './id.js'
+export * from './invoices.js'
+export * from './payments.js'
+export * from './refunds.js'
+export * from '../../providers/types.js'

src/plugin/types/invoices.ts

@@ -0,0 +1,116 @@
+import { Payment } from './payments'
+import { Id } from './id'
+
+export interface Invoice<TCustomer = unknown> {
+  id: Id;
+  /**
+   * Invoice number (e.g., INV-001)
+   */
+  number: string;
+  /**
+   * Link to customer record (optional)
+   */
+  customer?: (Id | null) | TCustomer;
+  /**
+   * Customer billing information (auto-populated from customer relationship)
+   */
+  customerInfo?: {
+    /**
+     * Customer name
+     */
+    name?: string | null;
+    /**
+     * Customer email address
+     */
+    email?: string | null;
+    /**
+     * Customer phone number
+     */
+    phone?: string | null;
+    /**
+     * Company name (optional)
+     */
+    company?: string | null;
+    /**
+     * Tax ID or VAT number
+     */
+    taxId?: string | null;
+  };
+  /**
+   * Billing address (auto-populated from customer relationship)
+   */
+  billingAddress?: {
+    /**
+     * Address line 1
+     */
+    line1?: string | null;
+    /**
+     * Address line 2
+     */
+    line2?: string | null;
+    city?: string | null;
+    /**
+     * State or province
+     */
+    state?: string | null;
+    /**
+     * Postal or ZIP code
+     */
+    postalCode?: string | null;
+    /**
+     * Country code (e.g., US, GB)
+     */
+    country?: string | null;
+  };
+  status: 'draft' | 'open' | 'paid' | 'void' | 'uncollectible';
+  /**
+   * ISO 4217 currency code (e.g., USD, EUR)
+   */
+  currency: string;
+  items: {
+    description: string;
+    quantity: number;
+    /**
+     * Amount in cents
+     */
+    unitAmount: number;
+    /**
+     * Calculated: quantity × unitAmount
+     */
+    totalAmount?: number | null;
+    id?: Id | null;
+  }[];
+  /**
+   * Sum of all line items
+   */
+  subtotal?: number | null;
+  /**
+   * Tax amount in cents
+   */
+  taxAmount?: number | null;
+  /**
+   * Total amount (subtotal + tax)
+   */
+  amount?: number | null;
+  dueDate?: string | null;
+  paidAt?: string | null;
+  payment?: (number | null) | Payment;
+  /**
+   * Internal notes
+   */
+  notes?: string | null;
+  /**
+   * Additional invoice metadata
+   */
+  metadata?:
+    | {
+    [k: string]: unknown;
+  }
+    | unknown[]
+    | string
+    | number
+    | boolean
+    | null;
+  updatedAt: string;
+  createdAt: string;
+}

src/plugin/types/payments.ts

@@ -0,0 +1,57 @@
+import { Refund } from './refunds'
+import { Invoice } from './invoices'
+import { Id } from './id'
+
+export interface Payment {
+  id: Id;
+  provider: 'stripe' | 'mollie' | 'test';
+  /**
+   * The payment ID from the payment provider
+   */
+  providerId: Id;
+  status: 'pending' | 'processing' | 'succeeded' | 'failed' | 'canceled' | 'refunded' | 'partially_refunded';
+  /**
+   * Amount in cents (e.g., 2000 = $20.00)
+   */
+  amount: number;
+  /**
+   * ISO 4217 currency code (e.g., USD, EUR)
+   */
+  currency: string;
+  /**
+   * Payment description
+   */
+  description?: string | null;
+  invoice?: (Id | null) | Invoice;
+  /**
+   * Additional metadata for the payment
+   */
+  metadata?:
+    | {
+    [k: string]: unknown;
+  }
+    | unknown[]
+    | string
+    | number
+    | boolean
+    | null;
+  /**
+   * Raw data from the payment provider
+   */
+  providerData?:
+    | {
+    [k: string]: unknown;
+  }
+    | unknown[]
+    | string
+    | number
+    | boolean
+    | null;
+  refunds?: (number | Refund)[] | null;
+  /**
+   * Version number for optimistic locking (auto-incremented on updates)
+   */
+  version?: number;
+  updatedAt: string;
+  createdAt: string;
+}

src/plugin/types/refunds.ts

@@ -0,0 +1,53 @@
+import { Payment } from './payments'
+
+export interface Refund {
+  id: number;
+  /**
+   * The refund ID from the payment provider
+   */
+  providerId: string;
+  payment: number | Payment;
+  status: 'pending' | 'processing' | 'succeeded' | 'failed' | 'canceled';
+  /**
+   * Refund amount in cents
+   */
+  amount: number;
+  /**
+   * ISO 4217 currency code (e.g., USD, EUR)
+   */
+  currency: string;
+  /**
+   * Reason for the refund
+   */
+  reason?: ('duplicate' | 'fraudulent' | 'requested_by_customer' | 'other') | null;
+  /**
+   * Additional details about the refund
+   */
+  description?: string | null;
+  /**
+   * Additional refund metadata
+   */
+  metadata?:
+    | {
+    [k: string]: unknown;
+  }
+    | unknown[]
+    | string
+    | number
+    | boolean
+    | null;
+  /**
+   * Raw data from the payment provider
+   */
+  providerData?:
+    | {
+    [k: string]: unknown;
+  }
+    | unknown[]
+    | string
+    | number
+    | boolean
+    | null;
+  updatedAt: string;
+  createdAt: string;
+}

src/plugin/utils.ts

@@ -0,0 +1,15 @@
+import type { CollectionConfig, CollectionSlug, Field } from 'payload'
+import type { Id } from './types/index'
+
+export type FieldsOverride = (args: { defaultFields: Field[] }) => Field[]
+
+export const extractSlug =
+  (arg: string | Partial<CollectionConfig>) => (typeof arg === 'string' ? arg : arg.slug!) as CollectionSlug
+
+/**
+ * Safely cast ID types for PayloadCMS operations
+ * This utility provides a typed way to handle the mismatch between our Id type and PayloadCMS expectations
+ */
+export function toPayloadId(id: Id): any {
+  return id as any
+}

src/providers/base/provider.ts

@@ -1,63 +0,0 @@
-import type { CreatePaymentOptions, Payment, PaymentProvider, Refund, WebhookEvent } from '../../types'
-
-export abstract class BasePaymentProvider implements PaymentProvider {
-  abstract name: string
-
-  protected formatAmount(amount: number, currency: string): number {
-    this.validateAmount(amount)
-    this.validateCurrency(currency)
-    return amount
-  }
-  protected log(level: 'error' | 'info' | 'warn', message: string, data?: Record<string, unknown>): void {
-    const logData = {
-      message,
-      provider: this.name,
-      ...data,
-    }
-    
-    console[level](`[${this.name.toUpperCase()}]`, logData)
-  }
-  protected validateAmount(amount: number): void {
-    if (amount <= 0 || !Number.isInteger(amount)) {
-      throw new Error('Amount must be a positive integer in cents')
-    }
-  }
-  protected validateCurrency(currency: string): void {
-    if (!currency || currency.length !== 3) {
-      throw new Error('Currency must be a valid 3-letter ISO currency code')
-    }
-  }
-  abstract cancelPayment(id: string): Promise<Payment>
-
-  abstract createPayment(options: CreatePaymentOptions): Promise<Payment>
-
-  abstract handleWebhook(request: Request, signature?: string): Promise<WebhookEvent>
-
-  abstract refundPayment(id: string, amount?: number): Promise<Refund>
-
-  abstract retrievePayment(id: string): Promise<Payment>
-}
-
-export function createProviderRegistry() {
-  const providers = new Map<string, PaymentProvider>()
-
-  return {
-    register(provider: PaymentProvider): void {
-      providers.set(provider.name, provider)
-    },
-
-    get(name: string): PaymentProvider | undefined {
-      return providers.get(name)
-    },
-
-    getAll(): PaymentProvider[] {
-      return Array.from(providers.values())
-    },
-
-    has(name: string): boolean {
-      return providers.has(name)
-    }
-  }
-}
-
-export const providerRegistry = createProviderRegistry()

src/providers/currency.ts

@@ -0,0 +1,94 @@
+/**
+ * Currency utilities for payment processing
+ */
+
+// Currencies that don't use centesimal units (no decimal places)
+const NON_CENTESIMAL_CURRENCIES = new Set([
+  'BIF', // Burundian Franc
+  'CLP', // Chilean Peso
+  'DJF', // Djiboutian Franc
+  'GNF', // Guinean Franc
+  'JPY', // Japanese Yen
+  'KMF', // Comorian Franc
+  'KRW', // South Korean Won
+  'MGA', // Malagasy Ariary
+  'PYG', // Paraguayan Guaraní
+  'RWF', // Rwandan Franc
+  'UGX', // Ugandan Shilling
+  'VND', // Vietnamese Đồng
+  'VUV', // Vanuatu Vatu
+  'XAF', // Central African CFA Franc
+  'XOF', // West African CFA Franc
+  'XPF', // CFP Franc
+])
+
+// Currencies that use 3 decimal places
+const THREE_DECIMAL_CURRENCIES = new Set([
+  'BHD', // Bahraini Dinar
+  'IQD', // Iraqi Dinar
+  'JOD', // Jordanian Dinar
+  'KWD', // Kuwaiti Dinar
+  'LYD', // Libyan Dinar
+  'OMR', // Omani Rial
+  'TND', // Tunisian Dinar
+])
+
+/**
+ * Convert amount from smallest unit to decimal for display
+ * @param amount - Amount in smallest unit (e.g., cents for USD)
+ * @param currency - ISO 4217 currency code
+ * @returns Formatted amount string for the payment provider
+ */
+export function formatAmountForProvider(amount: number, currency: string): string {
+  const upperCurrency = currency.toUpperCase()
+
+  if (NON_CENTESIMAL_CURRENCIES.has(upperCurrency)) {
+    // No decimal places
+    return amount.toString()
+  }
+
+  if (THREE_DECIMAL_CURRENCIES.has(upperCurrency)) {
+    // 3 decimal places
+    return (amount / 1000).toFixed(3)
+  }
+
+  // Default: 2 decimal places (most currencies)
+  return (amount / 100).toFixed(2)
+}
+
+/**
+ * Get the number of decimal places for a currency
+ * @param currency - ISO 4217 currency code
+ * @returns Number of decimal places
+ */
+export function getCurrencyDecimals(currency: string): number {
+  const upperCurrency = currency.toUpperCase()
+
+  if (NON_CENTESIMAL_CURRENCIES.has(upperCurrency)) {
+    return 0
+  }
+
+  if (THREE_DECIMAL_CURRENCIES.has(upperCurrency)) {
+    return 3
+  }
+
+  return 2
+}
+
+/**
+ * Validate currency code format
+ * @param currency - Currency code to validate
+ * @returns True if valid ISO 4217 format
+ */
+export function isValidCurrencyCode(currency: string): boolean {
+  return /^[A-Z]{3}$/.test(currency.toUpperCase())
+}
+
+/**
+ * Validate amount is positive and within reasonable limits
+ * @param amount - Amount to validate
+ * @returns True if valid
+ */
+export function isValidAmount(amount: number): boolean {
+  return Number.isInteger(amount) && amount > 0 && amount <= 99999999999 // Max ~999 million in major units
+}

src/providers/index.ts

@@ -0,0 +1,10 @@
+export * from './mollie'
+export * from './stripe'
+export * from './test'
+export * from './types'
+export * from './currency'
+
+// Re-export provider configurations and types
+export type { StripeProviderConfig } from './stripe'
+export type { MollieProviderConfig } from './mollie'
+export type { TestProviderConfig, TestProviderConfigResponse, PaymentOutcome, PaymentMethod, PaymentScenario } from './test'

src/providers/mollie.ts

@@ -0,0 +1,161 @@
+import type { Payment } from '../plugin/types/payments'
+import type { PaymentProvider } from '../plugin/types/index'
+import type { Payload } from 'payload'
+import { createSingleton } from '../plugin/singleton'
+import type { createMollieClient, MollieClient } from '@mollie/api-client'
+import {
+  webhookResponses,
+  findPaymentByProviderId,
+  updatePaymentStatus,
+  updateInvoiceOnPaymentSuccess,
+  handleWebhookError,
+  validateProductionUrl
+} from './utils'
+import { formatAmountForProvider, isValidAmount, isValidCurrencyCode } from './currency'
+import { createContextLogger } from '../utils/logger'
+
+const symbol = Symbol('mollie')
+export type MollieProviderConfig = Parameters<typeof createMollieClient>[0]
+
+/**
+ * Type-safe mapping of Mollie payment status to internal status
+ */
+function mapMollieStatusToPaymentStatus(mollieStatus: string): Payment['status'] {
+  // Define known Mollie statuses for type safety
+  const mollieStatusMap: Record<string, Payment['status']> = {
+    'paid': 'succeeded',
+    'failed': 'failed',
+    'canceled': 'canceled',
+    'expired': 'canceled',
+    'pending': 'pending',
+    'open': 'pending',
+    'authorized': 'pending',
+  }
+
+  return mollieStatusMap[mollieStatus] || 'processing'
+}
+
+export const mollieProvider = (mollieConfig: MollieProviderConfig & {
+  webhookUrl?: string
+  redirectUrl?: string
+}) => {
+  // Validate required configuration at initialization
+  if (!mollieConfig.apiKey) {
+    throw new Error('Mollie API key is required')
+  }
+
+  const singleton = createSingleton<MollieClient>(symbol)
+  return {
+    key: 'mollie',
+    onConfig: (config, pluginConfig) => {
+      // Always register Mollie webhook since it doesn't require a separate webhook secret
+      // Mollie validates webhooks through payment ID verification
+      config.endpoints = [
+        ...(config.endpoints || []),
+        {
+          path: '/payload-billing/mollie/webhook',
+          method: 'post',
+          handler: async (req) => {
+            try {
+              const payload = req.payload
+              const mollieClient = singleton.get(payload)
+
+              // Parse the webhook body to get the Mollie payment ID
+              if (!req.text) {
+                return webhookResponses.missingBody()
+              }
+              const body = await req.text()
+              if (!body || !body.startsWith('id=')) {
+                return webhookResponses.invalidPayload()
+              }
+
+              const molliePaymentId = body.slice(3) // Remove 'id=' prefix
+
+              // Fetch the payment details from Mollie
+              const molliePayment = await mollieClient.payments.get(molliePaymentId)
+
+              // Find the corresponding payment in our database
+              const payment = await findPaymentByProviderId(payload, molliePaymentId, pluginConfig)
+
+              if (!payment) {
+                return webhookResponses.paymentNotFound()
+              }
+
+              // Map Mollie status to our status using proper type-safe mapping
+              const status = mapMollieStatusToPaymentStatus(molliePayment.status)
+
+              // Update the payment status and provider data
+              const updateSuccess = await updatePaymentStatus(
+                payload,
+                payment.id,
+                status,
+                molliePayment.toPlainObject(),
+                pluginConfig
+              )
+
+              // If payment is successful and update succeeded, update the invoice
+              if (status === 'succeeded' && updateSuccess) {
+                await updateInvoiceOnPaymentSuccess(payload, payment, pluginConfig)
+              } else if (!updateSuccess) {
+                const logger = createContextLogger(payload, 'Mollie Webhook')
+                logger.warn(`Failed to update payment ${payment.id}, skipping invoice update`)
+              }
+
+              return webhookResponses.success()
+            } catch (error) {
+              return handleWebhookError('Mollie', error, undefined, req.payload)
+            }
+          }
+        }
+      ]
+    },
+    onInit: async (payload: Payload) => {
+      const createMollieClient = (await import('@mollie/api-client')).default
+      const mollieClient = createMollieClient(mollieConfig)
+      singleton.set(payload, mollieClient)
+    },
+    initPayment: async (payload, payment) => {
+      // Validate required fields
+      if (!payment.amount) {
+        throw new Error('Amount is required')
+      }
+      if (!payment.currency) {
+        throw new Error('Currency is required')
+      }
+
+      // Validate amount
+      if (!isValidAmount(payment.amount)) {
+        throw new Error('Invalid amount: must be a positive integer within reasonable limits')
+      }
+
+      // Validate currency code
+      if (!isValidCurrencyCode(payment.currency)) {
+        throw new Error('Invalid currency: must be a 3-letter ISO code')
+      }
+
+      // Setup URLs with development defaults
+      const isProduction = process.env.NODE_ENV === 'production'
+      const redirectUrl = mollieConfig.redirectUrl ||
+        (!isProduction ? 'https://localhost:3000/payment/success' : undefined)
+      const webhookUrl = mollieConfig.webhookUrl ||
+        `${process.env.PAYLOAD_PUBLIC_SERVER_URL || (!isProduction ? 'https://localhost:3000' : '')}/api/payload-billing/mollie/webhook`
+
+      // Validate URLs for production
+      validateProductionUrl(redirectUrl, 'Redirect')
+      validateProductionUrl(webhookUrl, 'Webhook')
+
+      const molliePayment = await singleton.get(payload).payments.create({
+        amount: {
+          value: formatAmountForProvider(payment.amount, payment.currency),
+          currency: payment.currency.toUpperCase()
+        },
+        description: payment.description || '',
+        redirectUrl,
+        webhookUrl,
+      });
+      payment.providerId = molliePayment.id
+      payment.providerData = molliePayment.toPlainObject()
+      return payment
+    },
+  } satisfies PaymentProvider
+}

src/providers/stripe.ts

@@ -0,0 +1,266 @@
+import type { Payment } from '../plugin/types/payments'
+import type { PaymentProvider, ProviderData } from '../plugin/types/index'
+import type { Payload } from 'payload'
+import { createSingleton } from '../plugin/singleton'
+import type Stripe from 'stripe'
+import {
+  webhookResponses,
+  findPaymentByProviderId,
+  updatePaymentStatus,
+  updateInvoiceOnPaymentSuccess,
+  handleWebhookError,
+  logWebhookEvent
+} from './utils'
+import { isValidAmount, isValidCurrencyCode } from './currency'
+import { createContextLogger } from '../utils/logger'
+
+const symbol = Symbol('stripe')
+
+export interface StripeProviderConfig {
+  secretKey: string
+  webhookSecret?: string
+  apiVersion?: Stripe.StripeConfig['apiVersion']
+  returnUrl?: string
+  webhookUrl?: string
+}
+
+// Default API version for consistency
+const DEFAULT_API_VERSION: Stripe.StripeConfig['apiVersion'] = '2025-08-27.basil'
+
+export const stripeProvider = (stripeConfig: StripeProviderConfig) => {
+  // Validate required configuration at initialization
+  if (!stripeConfig.secretKey) {
+    throw new Error('Stripe secret key is required')
+  }
+
+  const singleton = createSingleton<Stripe>(symbol)
+
+  return {
+    key: 'stripe',
+    onConfig: (config, pluginConfig) => {
+      // Only register webhook endpoint if webhook secret is configured
+      if (stripeConfig.webhookSecret) {
+        config.endpoints = [
+          ...(config.endpoints || []),
+          {
+            path: '/payload-billing/stripe/webhook',
+            method: 'post',
+            handler: async (req) => {
+            try {
+              const payload = req.payload
+              const stripe = singleton.get(payload)
+
+              // Get the raw body for signature verification
+              let body: string
+              try {
+                if (!req.text) {
+                  return webhookResponses.missingBody()
+                }
+                body = await req.text()
+                if (!body) {
+                  return webhookResponses.missingBody()
+                }
+              } catch (error) {
+                return handleWebhookError('Stripe', error, 'Failed to read request body', req.payload)
+              }
+
+              const signature = req.headers.get('stripe-signature')
+
+              if (!signature) {
+                return webhookResponses.error('Missing webhook signature', 400, req.payload)
+              }
+
+              // webhookSecret is guaranteed to exist since we only register this endpoint when it's configured
+
+              // Verify webhook signature and construct event
+              let event: Stripe.Event
+              try {
+                event = stripe.webhooks.constructEvent(body, signature, stripeConfig.webhookSecret!)
+              } catch (err) {
+                return handleWebhookError('Stripe', err, 'Signature verification failed', req.payload)
+              }
+
+              // Handle different event types
+              switch (event.type) {
+                case 'payment_intent.succeeded':
+                case 'payment_intent.payment_failed':
+                case 'payment_intent.canceled': {
+                  const paymentIntent = event.data.object
+
+                  // Find the corresponding payment in our database
+                  const payment = await findPaymentByProviderId(payload, paymentIntent.id, pluginConfig)
+
+                  if (!payment) {
+                    logWebhookEvent('Stripe', `Payment not found for intent: ${paymentIntent.id}`, undefined, req.payload)
+                    return webhookResponses.success() // Still return 200 to acknowledge receipt
+                  }
+
+                  // Map Stripe status to our status
+                  let status: Payment['status'] = 'pending'
+
+                  if (paymentIntent.status === 'succeeded') {
+                    status = 'succeeded'
+                  } else if (paymentIntent.status === 'canceled') {
+                    status = 'canceled'
+                  } else if (paymentIntent.status === 'requires_payment_method' ||
+                             paymentIntent.status === 'requires_confirmation' ||
+                             paymentIntent.status === 'requires_action') {
+                    status = 'pending'
+                  } else if (paymentIntent.status === 'processing') {
+                    status = 'processing'
+                  } else {
+                    status = 'failed'
+                  }
+
+                  // Update the payment status and provider data
+                  const providerData: ProviderData<Stripe.PaymentIntent> = {
+                    raw: paymentIntent,
+                    timestamp: new Date().toISOString(),
+                    provider: 'stripe'
+                  }
+                  const updateSuccess = await updatePaymentStatus(
+                    payload,
+                    payment.id,
+                    status,
+                    providerData,
+                    pluginConfig
+                  )
+
+                  // If payment is successful and update succeeded, update the invoice
+                  if (status === 'succeeded' && updateSuccess) {
+                    await updateInvoiceOnPaymentSuccess(payload, payment, pluginConfig)
+                  } else if (!updateSuccess) {
+                    const logger = createContextLogger(payload, 'Stripe Webhook')
+                    logger.warn(`Failed to update payment ${payment.id}, skipping invoice update`)
+                  }
+                  break
+                }
+
+                case 'charge.refunded': {
+                  const charge = event.data.object
+
+                  // Find the payment by charge ID or payment intent
+                  let payment: Payment | null = null
+
+                  // First try to find by payment intent ID
+                  if (charge.payment_intent) {
+                    payment = await findPaymentByProviderId(
+                      payload,
+                      charge.payment_intent as string,
+                      pluginConfig
+                    )
+                  }
+
+                  // If not found, try charge ID
+                  if (!payment) {
+                    payment = await findPaymentByProviderId(payload, charge.id, pluginConfig)
+                  }
+
+                  if (payment) {
+                    // Determine if fully or partially refunded
+                    const isFullyRefunded = charge.amount_refunded === charge.amount
+
+                    const providerData: ProviderData<Stripe.Charge> = {
+                      raw: charge,
+                      timestamp: new Date().toISOString(),
+                      provider: 'stripe'
+                    }
+                    const updateSuccess = await updatePaymentStatus(
+                      payload,
+                      payment.id,
+                      isFullyRefunded ? 'refunded' : 'partially_refunded',
+                      providerData,
+                      pluginConfig
+                    )
+
+                    if (!updateSuccess) {
+                      const logger = createContextLogger(payload, 'Stripe Webhook')
+                      logger.warn(`Failed to update refund status for payment ${payment.id}`)
+                    }
+                  }
+                  break
+                }
+
+                default:
+                  // Unhandled event type
+                  logWebhookEvent('Stripe', `Unhandled event type: ${event.type}`, undefined, req.payload)
+              }
+
+              return webhookResponses.success()
+            } catch (error) {
+              return handleWebhookError('Stripe', error, undefined, req.payload)
+            }
+            }
+          }
+        ]
+      }
+    },
+    onInit: async (payload: Payload) => {
+      const { default: Stripe } = await import('stripe')
+      const stripe = new Stripe(stripeConfig.secretKey, {
+        apiVersion: stripeConfig.apiVersion || DEFAULT_API_VERSION,
+      })
+      singleton.set(payload, stripe)
+
+      // Log webhook registration status
+      if (!stripeConfig.webhookSecret) {
+        const logger = createContextLogger(payload, 'Stripe Provider')
+        logger.warn('Webhook endpoint not registered - webhookSecret not configured')
+      }
+    },
+    initPayment: async (payload, payment) => {
+      // Validate required fields
+      if (!payment.amount) {
+        throw new Error('Amount is required')
+      }
+      if (!payment.currency) {
+        throw new Error('Currency is required')
+      }
+
+      // Validate amount
+      if (!isValidAmount(payment.amount)) {
+        throw new Error('Invalid amount: must be a positive integer within reasonable limits')
+      }
+
+      // Validate currency code
+      if (!isValidCurrencyCode(payment.currency)) {
+        throw new Error('Invalid currency: must be a 3-letter ISO code')
+      }
+
+      // Validate description length if provided
+      if (payment.description && payment.description.length > 1000) {
+        throw new Error('Description must be 1000 characters or less')
+      }
+
+      const stripe = singleton.get(payload)
+
+      // Create a payment intent
+      const paymentIntent = await stripe.paymentIntents.create({
+        amount: payment.amount, // Stripe handles currency conversion internally
+        currency: payment.currency.toLowerCase(),
+        description: payment.description || undefined,
+        metadata: {
+          payloadPaymentId: payment.id?.toString() || '',
+          ...(typeof payment.metadata === 'object' &&
+              payment.metadata !== null &&
+              !Array.isArray(payment.metadata)
+              ? payment.metadata
+              : {})
+        } as Stripe.MetadataParam,
+        automatic_payment_methods: {
+          enabled: true,
+        },
+      })
+
+      payment.providerId = paymentIntent.id
+      const providerData: ProviderData<Stripe.PaymentIntent> = {
+        raw: { ...paymentIntent, client_secret: paymentIntent.client_secret },
+        timestamp: new Date().toISOString(),
+        provider: 'stripe'
+      }
+      payment.providerData = providerData
+
+      return payment
+    },
+  } satisfies PaymentProvider
+}

src/providers/test.ts

@@ -0,0 +1,941 @@
+import type { Payment } from '../plugin/types/payments'
+import type { PaymentProvider, ProviderData } from '../plugin/types/index'
+import type { BillingPluginConfig } from '../plugin/config'
+import type { Payload } from 'payload'
+import { handleWebhookError, logWebhookEvent } from './utils'
+import { isValidAmount, isValidCurrencyCode } from './currency'
+import { createContextLogger } from '../utils/logger'
+
+const TestModeWarningSymbol = Symbol('TestModeWarning')
+const hasGivenTestModeWarning = () => TestModeWarningSymbol in globalThis
+const setTestModeWarning = () => ((<any>globalThis)[TestModeWarningSymbol] = true)
+
+
+// Request validation schemas
+interface ProcessPaymentRequest {
+  paymentId: string
+  scenarioId: string
+  method: PaymentMethod
+}
+
+// Validation functions
+function validateProcessPaymentRequest(body: any): { isValid: boolean; data?: ProcessPaymentRequest; error?: string } {
+  if (!body || typeof body !== 'object') {
+    return { isValid: false, error: 'Request body must be a valid JSON object' }
+  }
+
+  const { paymentId, scenarioId, method } = body
+
+  if (!paymentId || typeof paymentId !== 'string') {
+    return { isValid: false, error: 'paymentId is required and must be a string' }
+  }
+
+  if (!scenarioId || typeof scenarioId !== 'string') {
+    return { isValid: false, error: 'scenarioId is required and must be a string' }
+  }
+
+  if (!method || typeof method !== 'string') {
+    return { isValid: false, error: 'method is required and must be a string' }
+  }
+
+  // Validate method is a valid payment method
+  const validMethods: PaymentMethod[] = ['ideal', 'creditcard', 'paypal', 'applepay', 'banktransfer']
+  if (!validMethods.includes(method as PaymentMethod)) {
+    return { isValid: false, error: `method must be one of: ${validMethods.join(', ')}` }
+  }
+
+  return {
+    isValid: true,
+    data: { paymentId, scenarioId, method: method as PaymentMethod }
+  }
+}
+
+function validatePaymentId(paymentId: string): { isValid: boolean; error?: string } {
+  if (!paymentId || typeof paymentId !== 'string') {
+    return { isValid: false, error: 'Payment ID is required and must be a string' }
+  }
+
+  // Validate payment ID format (should match test payment ID pattern)
+  if (!paymentId.startsWith('test_pay_')) {
+    return { isValid: false, error: 'Invalid payment ID format' }
+  }
+
+  return { isValid: true }
+}
+
+// Utility function to safely extract collection name
+function getPaymentsCollectionName(pluginConfig: BillingPluginConfig): string {
+  if (typeof pluginConfig.collections?.payments === 'string') {
+    return pluginConfig.collections.payments
+  }
+  return 'payments'
+}
+
+// Enhanced error handling utility for database operations
+async function updatePaymentInDatabase(
+  payload: Payload,
+  sessionId: string,
+  status: Payment['status'],
+  providerData: ProviderData,
+  pluginConfig: BillingPluginConfig
+): Promise<{ success: boolean; error?: string }> {
+  try {
+    const paymentsCollection = getPaymentsCollectionName(pluginConfig)
+    const payments = await payload.find({
+      collection: paymentsCollection as any, // PayloadCMS collection type constraint
+      where: { providerId: { equals: sessionId } },
+      limit: 1
+    })
+
+    if (payments.docs.length === 0) {
+      return { success: false, error: 'Payment not found in database' }
+    }
+
+    await payload.update({
+      collection: paymentsCollection as any, // PayloadCMS collection type constraint
+      id: payments.docs[0].id,
+      data: {
+        status,
+        providerData
+      }
+    })
+
+    return { success: true }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown database error'
+    const logger = createContextLogger(payload, 'Test Provider')
+    logger.error('Database update failed:', errorMessage)
+    return { success: false, error: errorMessage }
+  }
+}
+
+export type PaymentOutcome = 'paid' | 'failed' | 'cancelled' | 'expired' | 'pending'
+
+export type PaymentMethod = 'ideal' | 'creditcard' | 'paypal' | 'applepay' | 'banktransfer'
+
+export interface PaymentScenario {
+  id: string
+  name: string
+  description: string
+  outcome: PaymentOutcome
+  delay?: number // Delay in milliseconds before processing
+  method?: PaymentMethod
+}
+
+export interface TestProviderConfig {
+  enabled: boolean
+  scenarios?: PaymentScenario[]
+  customUiRoute?: string
+  testModeIndicators?: {
+    showWarningBanners?: boolean
+    showTestBadges?: boolean
+    consoleWarnings?: boolean
+  }
+  defaultDelay?: number
+  baseUrl?: string
+}
+
+export interface TestProviderConfigResponse {
+  enabled: boolean
+  scenarios: PaymentScenario[]
+  methods: Array<{
+    id: string
+    name: string
+    icon: string
+  }>
+  testModeIndicators: {
+    showWarningBanners: boolean
+    showTestBadges: boolean
+    consoleWarnings: boolean
+  }
+  defaultDelay: number
+  customUiRoute: string
+}
+
+// Properly typed session interface
+export interface TestPaymentSession {
+  id: string
+  payment: Partial<Payment>
+  scenario?: PaymentScenario
+  method?: PaymentMethod
+  createdAt: Date
+  status: PaymentOutcome
+}
+
+// Use the proper BillingPluginConfig type
+
+// Default payment scenarios
+const DEFAULT_SCENARIOS: PaymentScenario[] = [
+  {
+    id: 'instant-success',
+    name: 'Instant Success',
+    description: 'Payment succeeds immediately',
+    outcome: 'paid',
+    delay: 0
+  },
+  {
+    id: 'delayed-success',
+    name: 'Delayed Success',
+    description: 'Payment succeeds after a delay',
+    outcome: 'paid',
+    delay: 3000
+  },
+  {
+    id: 'cancelled-payment',
+    name: 'Cancelled Payment',
+    description: 'User cancels the payment',
+    outcome: 'cancelled',
+    delay: 1000
+  },
+  {
+    id: 'declined-payment',
+    name: 'Declined Payment',
+    description: 'Payment is declined by the provider',
+    outcome: 'failed',
+    delay: 2000
+  },
+  {
+    id: 'expired-payment',
+    name: 'Expired Payment',
+    description: 'Payment expires before completion',
+    outcome: 'expired',
+    delay: 5000
+  },
+  {
+    id: 'pending-payment',
+    name: 'Pending Payment',
+    description: 'Payment remains in pending state',
+    outcome: 'pending',
+    delay: 1500
+  }
+]
+
+// Payment method configurations
+const PAYMENT_METHODS: Record<PaymentMethod, { name: string; icon: string }> = {
+  ideal: { name: 'iDEAL', icon: '🏦' },
+  creditcard: { name: 'Credit Card', icon: '💳' },
+  paypal: { name: 'PayPal', icon: '🅿️' },
+  applepay: { name: 'Apple Pay', icon: '🍎' },
+  banktransfer: { name: 'Bank Transfer', icon: '🏛️' }
+}
+
+// In-memory storage for test payment sessions
+const testPaymentSessions = new Map<string, TestPaymentSession>()
+
+export const testProvider = (testConfig: TestProviderConfig) => {
+  if (!testConfig.enabled) {
+    return
+  }
+
+  const scenarios = testConfig.scenarios || DEFAULT_SCENARIOS
+  const baseUrl = testConfig.baseUrl || (process.env.PAYLOAD_PUBLIC_SERVER_URL || 'http://localhost:3000')
+  const uiRoute = testConfig.customUiRoute || '/test-payment'
+
+  // Test mode warnings will be logged in onInit when payload is available
+
+  return {
+    key: 'test',
+    onConfig: (config, pluginConfig) => {
+      // Register test payment UI endpoint
+      config.endpoints = [
+        ...(config.endpoints || []),
+        {
+          path: '/payload-billing/test/payment/:id',
+          method: 'get',
+          handler: (req) => {
+            // Extract payment ID from URL path
+            const urlParts = req.url?.split('/') || []
+            const paymentId = urlParts[urlParts.length - 1]
+
+            if (!paymentId) {
+              return new Response(JSON.stringify({ error: 'Payment ID required' }), {
+                status: 400,
+                headers: { 'Content-Type': 'application/json' }
+              })
+            }
+
+            // Validate payment ID format
+            const validation = validatePaymentId(paymentId)
+            if (!validation.isValid) {
+              return new Response(JSON.stringify({ error: validation.error }), {
+                status: 400,
+                headers: { 'Content-Type': 'application/json' }
+              })
+            }
+
+            const session = testPaymentSessions.get(paymentId)
+            if (!session) {
+              return new Response(JSON.stringify({ error: 'Payment session not found' }), {
+                status: 404,
+                headers: { 'Content-Type': 'application/json' }
+              })
+            }
+
+            // Generate test payment UI
+            const html = generateTestPaymentUI(session, scenarios, uiRoute, baseUrl, testConfig)
+            return new Response(html, {
+              headers: { 'Content-Type': 'text/html' }
+            })
+          }
+        },
+        {
+          path: '/payload-billing/test/config',
+          method: 'get',
+          handler: async (req) => {
+            const response: TestProviderConfigResponse = {
+              enabled: testConfig.enabled,
+              scenarios: scenarios,
+              methods: Object.entries(PAYMENT_METHODS).map(([id, method]) => ({
+                id,
+                name: method.name,
+                icon: method.icon
+              })),
+              testModeIndicators: {
+                showWarningBanners: testConfig.testModeIndicators?.showWarningBanners ?? true,
+                showTestBadges: testConfig.testModeIndicators?.showTestBadges ?? true,
+                consoleWarnings: testConfig.testModeIndicators?.consoleWarnings ?? true
+              },
+              defaultDelay: testConfig.defaultDelay || 1000,
+              customUiRoute: uiRoute
+            }
+            return new Response(JSON.stringify(response), {
+              headers: { 'Content-Type': 'application/json' }
+            })
+          }
+        },
+        {
+          path: '/payload-billing/test/process',
+          method: 'post',
+          handler: async (req) => {
+            try {
+              const payload = req.payload
+              const body = await req.json?.() || {}
+
+              // Validate request body
+              const validation = validateProcessPaymentRequest(body)
+              if (!validation.isValid) {
+                return new Response(JSON.stringify({ error: validation.error }), {
+                  status: 400,
+                  headers: { 'Content-Type': 'application/json' }
+                })
+              }
+
+              const { paymentId, scenarioId, method } = validation.data!
+
+              const session = testPaymentSessions.get(paymentId)
+              if (!session) {
+                return new Response(JSON.stringify({ error: 'Payment session not found' }), {
+                  status: 404,
+                  headers: { 'Content-Type': 'application/json' }
+                })
+              }
+
+              const scenario = scenarios.find(s => s.id === scenarioId)
+              if (!scenario) {
+                return new Response(JSON.stringify({ error: 'Invalid scenario ID' }), {
+                  status: 400,
+                  headers: { 'Content-Type': 'application/json' }
+                })
+              }
+
+              // Update session with selected scenario and method
+              session.scenario = scenario
+              session.method = method
+              session.status = 'pending'
+
+              // Process payment after delay
+              setTimeout(() => {
+                processTestPayment(payload, session, pluginConfig).catch(async (error) => {
+                  const logger = createContextLogger(payload, 'Test Provider')
+                  logger.error('Failed to process payment:', error)
+
+                  // Ensure session status is updated consistently
+                  session.status = 'failed'
+
+                  // Create error provider data
+                  const errorProviderData: ProviderData = {
+                    raw: {
+                      error: error instanceof Error ? error.message : 'Unknown processing error',
+                      processedAt: new Date().toISOString(),
+                      testMode: true
+                    },
+                    timestamp: new Date().toISOString(),
+                    provider: 'test'
+                  }
+
+                  // Update payment record in database with enhanced error handling
+                  const dbResult = await updatePaymentInDatabase(
+                    payload,
+                    session.id,
+                    'failed',
+                    errorProviderData,
+                    pluginConfig
+                  )
+
+                  if (!dbResult.success) {
+                    const logger = createContextLogger(payload, 'Test Provider')
+                    logger.error('Database error during failure handling:', dbResult.error)
+                    // Even if database update fails, we maintain session consistency
+                  } else {
+                    logWebhookEvent('Test Provider', `Payment ${session.id} marked as failed after processing error`, undefined, req.payload)
+                  }
+                })
+              }, scenario.delay || testConfig.defaultDelay || 1000)
+
+              return new Response(JSON.stringify({
+                success: true,
+                status: 'processing',
+                scenario: scenario.name,
+                delay: scenario.delay || testConfig.defaultDelay || 1000
+              }), {
+                headers: { 'Content-Type': 'application/json' }
+              })
+            } catch (error) {
+              return handleWebhookError('Test Provider', error, 'Failed to process test payment', req.payload)
+            }
+          }
+        },
+        {
+          path: '/payload-billing/test/status/:id',
+          method: 'get',
+          handler: (req) => {
+            // Extract payment ID from URL path
+            const urlParts = req.url?.split('/') || []
+            const paymentId = urlParts[urlParts.length - 1]
+
+            if (!paymentId) {
+              return new Response(JSON.stringify({ error: 'Payment ID required' }), {
+                status: 400,
+                headers: { 'Content-Type': 'application/json' }
+              })
+            }
+
+            // Validate payment ID format
+            const validation = validatePaymentId(paymentId)
+            if (!validation.isValid) {
+              return new Response(JSON.stringify({ error: validation.error }), {
+                status: 400,
+                headers: { 'Content-Type': 'application/json' }
+              })
+            }
+
+            const session = testPaymentSessions.get(paymentId)
+            if (!session) {
+              return new Response(JSON.stringify({ error: 'Payment session not found' }), {
+                status: 404,
+                headers: { 'Content-Type': 'application/json' }
+              })
+            }
+
+            return new Response(JSON.stringify({
+              status: session.status,
+              scenario: session.scenario?.name,
+              method: session.method ? PAYMENT_METHODS[session.method]?.name : undefined
+            }), {
+              headers: { 'Content-Type': 'application/json' }
+            })
+          }
+        }
+      ]
+    },
+    onInit: (payload: Payload) => {
+      logWebhookEvent('Test Provider', 'Test payment provider initialized', undefined, payload)
+
+      // Log test mode warnings if enabled
+      if (testConfig.testModeIndicators?.consoleWarnings !== false && !hasGivenTestModeWarning()) {
+        setTestModeWarning()
+        const logger = createContextLogger(payload, 'Test Provider')
+        logger.warn('🧪 Payment system is running in test mode')
+      }
+
+      // Clean up old sessions periodically (older than 1 hour)
+      setInterval(() => {
+        const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000)
+        testPaymentSessions.forEach((session, id) => {
+          if (session.createdAt < oneHourAgo) {
+            testPaymentSessions.delete(id)
+          }
+        })
+      }, 10 * 60 * 1000) // Clean every 10 minutes
+    },
+    initPayment: (payload, payment) => {
+      // Validate required fields
+      if (!payment.amount) {
+        throw new Error('Amount is required')
+      }
+      if (!payment.currency) {
+        throw new Error('Currency is required')
+      }
+
+      // Validate amount
+      if (!isValidAmount(payment.amount)) {
+        throw new Error('Invalid amount: must be a positive integer within reasonable limits')
+      }
+
+      // Validate currency code
+      if (!isValidCurrencyCode(payment.currency)) {
+        throw new Error('Invalid currency: must be a 3-letter ISO code')
+      }
+
+      // Generate unique test payment ID
+      const testPaymentId = `test_pay_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
+
+      // Create test payment session
+      const session = {
+        id: testPaymentId,
+        payment: { ...payment },
+        createdAt: new Date(),
+        status: 'pending' as PaymentOutcome
+      }
+
+      testPaymentSessions.set(testPaymentId, session)
+
+      // Set provider ID and data
+      payment.providerId = testPaymentId
+      const providerData: ProviderData = {
+        raw: {
+          id: testPaymentId,
+          amount: payment.amount,
+          currency: payment.currency,
+          description: payment.description,
+          status: 'pending',
+          testMode: true,
+          paymentUrl: `${baseUrl}/api/payload-billing/test/payment/${testPaymentId}`,
+          scenarios: scenarios.map(s => ({ id: s.id, name: s.name, description: s.description })),
+          methods: Object.entries(PAYMENT_METHODS).map(([key, value]) => ({
+            id: key,
+            name: value.name,
+            icon: value.icon
+          }))
+        },
+        timestamp: new Date().toISOString(),
+        provider: 'test'
+      }
+      payment.providerData = providerData
+
+      return payment
+    },
+  } satisfies PaymentProvider
+}
+
+// Helper function to process test payment based on scenario
+async function processTestPayment(
+  payload: Payload,
+  session: TestPaymentSession,
+  pluginConfig: BillingPluginConfig
+): Promise<void> {
+  try {
+    if (!session.scenario) return
+
+    // Map scenario outcome to payment status
+    let finalStatus: Payment['status'] = 'pending'
+    switch (session.scenario.outcome) {
+      case 'paid':
+        finalStatus = 'succeeded'
+        break
+      case 'failed':
+        finalStatus = 'failed'
+        break
+      case 'cancelled':
+        finalStatus = 'canceled'
+        break
+      case 'expired':
+        finalStatus = 'canceled' // Treat expired as canceled
+        break
+      case 'pending':
+        finalStatus = 'pending'
+        break
+    }
+
+    // Update session status
+    session.status = session.scenario.outcome
+
+    // Update payment with final status and provider data
+    const updatedProviderData: ProviderData = {
+      raw: {
+        ...session.payment,
+        id: session.id,
+        status: session.scenario.outcome,
+        scenario: session.scenario.name,
+        method: session.method,
+        processedAt: new Date().toISOString(),
+        testMode: true
+      },
+      timestamp: new Date().toISOString(),
+      provider: 'test'
+    }
+
+    // Use the utility function for database operations
+    const dbResult = await updatePaymentInDatabase(
+      payload,
+      session.id,
+      finalStatus,
+      updatedProviderData,
+      pluginConfig
+    )
+
+    if (dbResult.success) {
+      logWebhookEvent('Test Provider', `Payment ${session.id} processed with outcome: ${session.scenario.outcome}`, undefined, payload)
+    } else {
+      const logger = createContextLogger(payload, 'Test Provider')
+      logger.error('Failed to update payment in database:', dbResult.error)
+      // Update session status to indicate database error, but don't throw
+      // This allows the UI to still show the intended test result
+      session.status = 'failed'
+      throw new Error(`Database update failed: ${dbResult.error}`)
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown processing error'
+    const logger = createContextLogger(payload, 'Test Provider')
+    logger.error('Failed to process payment:', errorMessage)
+    session.status = 'failed'
+    throw error // Re-throw to be handled by the caller
+  }
+}
+
+// Helper function to generate test payment UI
+function generateTestPaymentUI(
+  session: TestPaymentSession,
+  scenarios: PaymentScenario[],
+  uiRoute: string,
+  baseUrl: string,
+  testConfig: TestProviderConfig
+): string {
+  const payment = session.payment
+  const testModeIndicators = testConfig.testModeIndicators || {}
+
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Test Payment - ${payment.description || 'Payment'}</title>
+    <style>
+        * { box-sizing: border-box; margin: 0; padding: 0; }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            padding: 20px;
+        }
+        .container {
+            max-width: 600px;
+            margin: 0 auto;
+            background: white;
+            border-radius: 12px;
+            box-shadow: 0 20px 40px rgba(0,0,0,0.1);
+            overflow: hidden;
+        }
+        ${testModeIndicators.showWarningBanners !== false ? `
+        .test-banner {
+            background: linear-gradient(90deg, #ff6b6b, #ffa726);
+            color: white;
+            padding: 12px 20px;
+            text-align: center;
+            font-weight: 600;
+            font-size: 14px;
+        }
+        ` : ''}
+        .header {
+            background: #f8f9fa;
+            padding: 30px 40px 20px;
+            border-bottom: 1px solid #e9ecef;
+        }
+        .title {
+            font-size: 24px;
+            font-weight: 700;
+            color: #2c3e50;
+            margin-bottom: 8px;
+        }
+        .amount {
+            font-size: 32px;
+            font-weight: 800;
+            color: #27ae60;
+            margin-bottom: 16px;
+        }
+        .description {
+            color: #6c757d;
+            font-size: 16px;
+            line-height: 1.5;
+        }
+        .content { padding: 40px; }
+        .section { margin-bottom: 30px; }
+        .section-title {
+            font-size: 18px;
+            font-weight: 600;
+            color: #2c3e50;
+            margin-bottom: 16px;
+            display: flex;
+            align-items: center;
+            gap: 8px;
+        }
+        .payment-methods {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(120px, 1fr));
+            gap: 12px;
+            margin-bottom: 20px;
+        }
+        .method {
+            border: 2px solid #e9ecef;
+            border-radius: 8px;
+            padding: 16px 12px;
+            text-align: center;
+            cursor: pointer;
+            transition: all 0.2s;
+            background: white;
+        }
+        .method:hover {
+            border-color: #007bff;
+            background: #f8f9ff;
+        }
+        .method.selected {
+            border-color: #007bff;
+            background: #007bff;
+            color: white;
+        }
+        .method-icon { font-size: 24px; margin-bottom: 8px; }
+        .method-name { font-size: 12px; font-weight: 500; }
+        .scenarios {
+            display: grid;
+            gap: 12px;
+            margin-bottom: 20px;
+        }
+        .scenario {
+            border: 2px solid #e9ecef;
+            border-radius: 8px;
+            padding: 16px;
+            cursor: pointer;
+            transition: all 0.2s;
+            background: white;
+        }
+        .scenario:hover {
+            border-color: #28a745;
+            background: #f8fff9;
+        }
+        .scenario.selected {
+            border-color: #28a745;
+            background: #28a745;
+            color: white;
+        }
+        .scenario-name { font-weight: 600; margin-bottom: 4px; }
+        .scenario-desc { font-size: 14px; opacity: 0.8; }
+        .process-btn {
+            width: 100%;
+            background: linear-gradient(135deg, #007bff, #0056b3);
+            color: white;
+            border: none;
+            padding: 16px;
+            border-radius: 8px;
+            font-size: 16px;
+            font-weight: 600;
+            cursor: pointer;
+            transition: all 0.2s;
+            margin-top: 20px;
+        }
+        .process-btn:hover:not(:disabled) {
+            transform: translateY(-2px);
+            box-shadow: 0 8px 20px rgba(0,123,255,0.3);
+        }
+        .process-btn:disabled {
+            opacity: 0.6;
+            cursor: not-allowed;
+            transform: none;
+        }
+        .status {
+            text-align: center;
+            padding: 20px;
+            border-radius: 8px;
+            margin-top: 20px;
+            font-weight: 600;
+        }
+        .status.processing { background: #fff3cd; color: #856404; }
+        .status.success { background: #d4edda; color: #155724; }
+        .status.error { background: #f8d7da; color: #721c24; }
+        .loading {
+            display: inline-block;
+            width: 20px;
+            height: 20px;
+            border: 3px solid #f3f3f3;
+            border-top: 3px solid #007bff;
+            border-radius: 50%;
+            animation: spin 1s linear infinite;
+            margin-right: 10px;
+        }
+        @keyframes spin {
+            0% { transform: rotate(0deg); }
+            100% { transform: rotate(360deg); }
+        }
+        ${testModeIndicators.showTestBadges !== false ? `
+        .test-badge {
+            display: inline-block;
+            background: #6c757d;
+            color: white;
+            padding: 4px 8px;
+            border-radius: 4px;
+            font-size: 12px;
+            font-weight: 600;
+            text-transform: uppercase;
+            margin-left: 8px;
+        }
+        ` : ''}
+    </style>
+</head>
+<body>
+    <div class="container">
+        ${testModeIndicators.showWarningBanners !== false ? `
+        <div class="test-banner">
+            🧪 TEST MODE - This is a simulated payment for development purposes
+        </div>
+        ` : ''}
+
+        <div class="header">
+            <div class="title">
+                Test Payment Checkout
+                ${testModeIndicators.showTestBadges !== false ? '<span class="test-badge">Test</span>' : ''}
+            </div>
+            <div class="amount">${payment.currency?.toUpperCase()} ${payment.amount ? (payment.amount / 100).toFixed(2) : '0.00'}</div>
+            ${payment.description ? `<div class="description">${payment.description}</div>` : ''}
+        </div>
+
+        <div class="content">
+            <div class="section">
+                <div class="section-title">
+                    💳 Select Payment Method
+                </div>
+                <div class="payment-methods">
+                    ${Object.entries(PAYMENT_METHODS).map(([key, method]) => `
+                        <div class="method" data-method="${key}">
+                            <div class="method-icon">${method.icon}</div>
+                            <div class="method-name">${method.name}</div>
+                        </div>
+                    `).join('')}
+                </div>
+            </div>
+
+            <div class="section">
+                <div class="section-title">
+                    🎭 Select Test Scenario
+                </div>
+                <div class="scenarios">
+                    ${scenarios.map(scenario => `
+                        <div class="scenario" data-scenario="${scenario.id}">
+                            <div class="scenario-name">${scenario.name}</div>
+                            <div class="scenario-desc">${scenario.description}</div>
+                        </div>
+                    `).join('')}
+                </div>
+            </div>
+
+            <button class="process-btn" id="processBtn" disabled>
+                Process Test Payment
+            </button>
+
+            <div id="status" class="status" style="display: none;"></div>
+        </div>
+    </div>
+
+    <script>
+        let selectedMethod = null;
+        let selectedScenario = null;
+
+        // Payment method selection
+        document.querySelectorAll('.method').forEach(method => {
+            method.addEventListener('click', () => {
+                document.querySelectorAll('.method').forEach(m => m.classList.remove('selected'));
+                method.classList.add('selected');
+                selectedMethod = method.dataset.method;
+                updateProcessButton();
+            });
+        });
+
+        // Scenario selection
+        document.querySelectorAll('.scenario').forEach(scenario => {
+            scenario.addEventListener('click', () => {
+                document.querySelectorAll('.scenario').forEach(s => s.classList.remove('selected'));
+                scenario.classList.add('selected');
+                selectedScenario = scenario.dataset.scenario;
+                updateProcessButton();
+            });
+        });
+
+        function updateProcessButton() {
+            const btn = document.getElementById('processBtn');
+            btn.disabled = !selectedMethod || !selectedScenario;
+        }
+
+        // Process payment
+        document.getElementById('processBtn').addEventListener('click', async () => {
+            const btn = document.getElementById('processBtn');
+            const status = document.getElementById('status');
+
+            btn.disabled = true;
+            btn.innerHTML = '<span class="loading"></span>Processing...';
+
+            try {
+                const response = await fetch('/api/payload-billing/test/process', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        paymentId: '${session.id}',
+                        scenarioId: selectedScenario,
+                        method: selectedMethod
+                    })
+                });
+
+                const result = await response.json();
+
+                if (result.success) {
+                    status.className = 'status processing';
+                    status.style.display = 'block';
+                    status.innerHTML = \`<span class="loading"></span>Processing payment with \${result.scenario}...\`;
+
+                    // Poll for status updates
+                    setTimeout(() => pollStatus(), result.delay || 1000);
+                } else {
+                    throw new Error(result.error || 'Failed to process payment');
+                }
+            } catch (error) {
+                status.className = 'status error';
+                status.style.display = 'block';
+                status.textContent = 'Error: ' + error.message;
+                btn.disabled = false;
+                btn.textContent = 'Process Test Payment';
+            }
+        });
+
+        async function pollStatus() {
+            try {
+                const response = await fetch('/api/payload-billing/test/status/${session.id}');
+                const result = await response.json();
+
+                const status = document.getElementById('status');
+                const btn = document.getElementById('processBtn');
+
+                if (result.status === 'paid') {
+                    status.className = 'status success';
+                    status.textContent = '✅ Payment successful!';
+                    setTimeout(() => {
+                        window.location.href = '${baseUrl}/success';
+                    }, 2000);
+                } else if (result.status === 'failed' || result.status === 'cancelled' || result.status === 'expired') {
+                    status.className = 'status error';
+                    status.textContent = \`❌ Payment \${result.status}\`;
+                    btn.disabled = false;
+                    btn.textContent = 'Try Again';
+                } else if (result.status === 'pending') {
+                    status.className = 'status processing';
+                    status.innerHTML = '<span class="loading"></span>Payment is still pending...';
+                    setTimeout(() => pollStatus(), 2000);
+                }
+            } catch (error) {
+                console.error('[Test Provider] Failed to poll status:', error);
+            }
+        }
+
+        ${testModeIndicators.consoleWarnings !== false ? `
+        console.warn('[Test Provider] 🧪 TEST MODE: This is a simulated payment interface for development purposes');
+        ` : ''}
+    </script>
+</body>
+</html>`
+}

src/providers/test/provider.ts

@@ -1,225 +0,0 @@
-import type { 
-  CreatePaymentOptions, 
-  Payment, 
-  PaymentStatus, 
-  Refund, 
-  TestProviderConfig,
-  WebhookEvent
-} from '../../types';
-
-import { 
-  RefundStatus
-} from '../../types'
-import { BasePaymentProvider } from '../base/provider'
-
-interface TestPaymentData {
-  delayMs?: number
-  failAfterMs?: number
-  simulateFailure?: boolean
-}
-
-export class TestPaymentProvider extends BasePaymentProvider {
-  private config: TestProviderConfig
-  private payments = new Map<string, Payment>()
-  private refunds = new Map<string, Refund>()
-  name = 'test'
-
-  constructor(config: TestProviderConfig) {
-    super()
-    this.config = config
-  }
-
-  private sleep(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms))
-  }
-
-  async cancelPayment(id: string): Promise<Payment> {
-    const payment = this.payments.get(id)
-    if (!payment) {
-      throw new Error(`Payment ${id} not found`)
-    }
-
-    if (payment.status === 'succeeded') {
-      throw new Error('Cannot cancel a succeeded payment')
-    }
-
-    const canceledPayment = {
-      ...payment,
-      status: 'canceled' as PaymentStatus,
-      updatedAt: new Date().toISOString()
-    }
-
-    this.payments.set(id, canceledPayment)
-    
-    this.log('info', 'Payment canceled', { paymentId: id })
-    
-    return canceledPayment
-  }
-
-  clearStoredData(): void {
-    this.payments.clear()
-    this.refunds.clear()
-    this.log('info', 'Test data cleared')
-  }
-
-  async createPayment(options: CreatePaymentOptions): Promise<Payment> {
-    const testData = options.metadata?.test as TestPaymentData || {}
-    const delay = testData.delayMs ?? this.config.defaultDelay ?? 0
-    
-    if (delay > 0) {
-      await this.sleep(delay)
-    }
-
-    const shouldFail = testData.simulateFailure ?? 
-      (this.config.simulateFailures && Math.random() < (this.config.failureRate ?? 0.1))
-
-    const paymentId = `test_pay_${Date.now()}_${Math.random().toString(36).substring(7)}`
-    
-    const payment: Payment = {
-      id: paymentId,
-      amount: options.amount,
-      createdAt: new Date().toISOString(),
-      currency: options.currency,
-      customer: options.customer,
-      description: options.description,
-      metadata: options.metadata,
-      provider: this.name,
-      providerData: {
-        autoCompleted: this.config.autoComplete,
-        delayApplied: delay,
-        simulatedFailure: shouldFail,
-        testMode: true
-      },
-      status: shouldFail ? 'failed' : (this.config.autoComplete ? 'succeeded' : 'pending'),
-      updatedAt: new Date().toISOString()
-    }
-
-    this.payments.set(paymentId, payment)
-    
-    this.log('info', 'Payment created', {
-      amount: options.amount,
-      currency: options.currency,
-      paymentId,
-      status: payment.status
-    })
-
-    // Simulate async status updates if configured
-    if (testData.failAfterMs && !shouldFail) {
-      setTimeout(() => {
-        const updatedPayment = { ...payment, status: 'failed' as PaymentStatus, updatedAt: new Date().toISOString() }
-        this.payments.set(paymentId, updatedPayment)
-        this.log('info', 'Payment failed after delay', { paymentId })
-      }, testData.failAfterMs)
-    }
-
-    return payment
-  }
-
-  getAllPayments(): Payment[] {
-    return Array.from(this.payments.values())
-  }
-
-  getAllRefunds(): Refund[] {
-    return Array.from(this.refunds.values())
-  }
-
-  // Test-specific methods
-  getStoredPayment(id: string): Payment | undefined {
-    return this.payments.get(id)
-  }
-
-  getStoredRefund(id: string): Refund | undefined {
-    return this.refunds.get(id)
-  }
-
-  async handleWebhook(request: Request, signature?: string): Promise<WebhookEvent> {
-    if (!this.config.enabled) {
-      throw new Error('Test provider is not enabled')
-    }
-
-    // For test provider, we'll simulate webhook events
-    const body = await request.text()
-    let eventData: Record<string, unknown>
-
-    try {
-      eventData = JSON.parse(body)
-    } catch (error) {
-      throw new Error('Invalid JSON in webhook body')
-    }
-
-    const event: WebhookEvent = {
-      id: `test_evt_${Date.now()}_${Math.random().toString(36).substring(7)}`,
-      type: (eventData.type as string) || 'payment.status_changed',
-      data: eventData,
-      provider: this.name,
-      verified: true // Test provider always considers webhooks verified
-    }
-
-    this.log('info', 'Webhook received', {
-      type: event.type,
-      dataKeys: Object.keys(event.data),
-      eventId: event.id
-    })
-
-    return event
-  }
-
-  async refundPayment(id: string, amount?: number): Promise<Refund> {
-    const payment = this.payments.get(id)
-    if (!payment) {
-      throw new Error(`Payment ${id} not found`)
-    }
-
-    if (payment.status !== 'succeeded') {
-      throw new Error('Can only refund succeeded payments')
-    }
-
-    const refundAmount = amount ?? payment.amount
-    if (refundAmount > payment.amount) {
-      throw new Error('Refund amount cannot exceed payment amount')
-    }
-
-    const refundId = `test_ref_${Date.now()}_${Math.random().toString(36).substring(7)}`
-    
-    const refund: Refund = {
-      id: refundId,
-      amount: refundAmount,
-      createdAt: new Date().toISOString(),
-      currency: payment.currency,
-      paymentId: id,
-      providerData: {
-        autoCompleted: this.config.autoComplete,
-        testMode: true
-      },
-      status: this.config.autoComplete ? 'succeeded' : 'pending'
-    }
-
-    this.refunds.set(refundId, refund)
-
-    // Update payment status
-    const newPaymentStatus: PaymentStatus = refundAmount === payment.amount ? 'refunded' : 'partially_refunded'
-    const updatedPayment = {
-      ...payment,
-      status: newPaymentStatus,
-      updatedAt: new Date().toISOString()
-    }
-    this.payments.set(id, updatedPayment)
-
-    this.log('info', 'Refund created', {
-      amount: refundAmount,
-      paymentId: id,
-      refundId,
-      status: refund.status
-    })
-
-    return refund
-  }
-
-  async retrievePayment(id: string): Promise<Payment> {
-    const payment = this.payments.get(id)
-    if (!payment) {
-      throw new Error(`Payment ${id} not found`)
-    }
-    return payment
-  }
-}

src/providers/types.ts

@@ -0,0 +1,21 @@
+import type { Payment } from '../plugin/types/payments'
+import type { Config, Payload } from 'payload'
+import type { BillingPluginConfig } from '../plugin/config'
+
+export type InitPayment = (payload: Payload, payment: Partial<Payment>) => Promise<Partial<Payment>> | Partial<Payment>
+
+export type PaymentProvider = {
+  key: string
+  onConfig?: (config: Config, pluginConfig: BillingPluginConfig) => void
+  onInit?: (payload: Payload) => Promise<void> | void
+  initPayment: InitPayment
+}
+
+/**
+ * Type-safe provider data wrapper
+ */
+export type ProviderData<T = unknown> = {
+  raw: T
+  timestamp: string
+  provider: string
+}

src/providers/utils.ts

@@ -0,0 +1,229 @@
+import type { Payload } from 'payload'
+import type { Payment } from '../plugin/types/payments'
+import type { BillingPluginConfig } from '../plugin/config'
+import type { ProviderData } from './types'
+import { defaults } from '../plugin/config'
+import { extractSlug, toPayloadId } from '../plugin/utils'
+import { createContextLogger } from '../utils/logger'
+
+/**
+ * Common webhook response utilities
+ * Note: Always return 200 for webhook acknowledgment to prevent information disclosure
+ */
+export const webhookResponses = {
+  success: () => Response.json({ received: true }, { status: 200 }),
+  error: (message: string, status = 400, payload?: Payload) => {
+    // Log error internally but don't expose details
+    if (payload) {
+      const logger = createContextLogger(payload, 'Webhook')
+      logger.error('Error:', message)
+    } else {
+      console.error('[Webhook] Error:', message)
+    }
+    return Response.json({ error: 'Invalid request' }, { status })
+  },
+  missingBody: () => Response.json({ received: true }, { status: 200 }),
+  paymentNotFound: () => Response.json({ received: true }, { status: 200 }),
+  invalidPayload: () => Response.json({ received: true }, { status: 200 }),
+}
+
+/**
+ * Find a payment by provider ID
+ */
+export async function findPaymentByProviderId(
+  payload: Payload,
+  providerId: string,
+  pluginConfig: BillingPluginConfig
+): Promise<Payment | null> {
+  const paymentsCollection = extractSlug(pluginConfig.collections?.payments || defaults.paymentsCollection)
+
+  const payments = await payload.find({
+    collection: paymentsCollection,
+    where: {
+      providerId: {
+        equals: providerId
+      }
+    }
+  })
+
+  return payments.docs.length > 0 ? payments.docs[0] as Payment : null
+}
+
+/**
+ * Update payment status and provider data with optimistic locking
+ */
+export async function updatePaymentStatus(
+  payload: Payload,
+  paymentId: string | number,
+  status: Payment['status'],
+  providerData: ProviderData<any>,
+  pluginConfig: BillingPluginConfig
+): Promise<boolean> {
+  const paymentsCollection = extractSlug(pluginConfig.collections?.payments || defaults.paymentsCollection)
+
+  try {
+    // First, fetch the current payment to get the current version
+    const currentPayment = await payload.findByID({
+      collection: paymentsCollection,
+      id: toPayloadId(paymentId),
+    }) as Payment
+
+    if (!currentPayment) {
+      const logger = createContextLogger(payload, 'Payment Update')
+      logger.error(`Payment ${paymentId} not found`)
+      return false
+    }
+
+    const currentVersion = currentPayment.version || 1
+
+    // Attempt to update with optimistic locking
+    // We'll use a transaction to ensure atomicity
+    const transactionID = await payload.db.beginTransaction()
+
+    if (!transactionID) {
+      const logger = createContextLogger(payload, 'Payment Update')
+      logger.error('Failed to begin transaction')
+      return false
+    }
+
+    try {
+      // Re-fetch within transaction to ensure consistency
+      const paymentInTransaction = await payload.findByID({
+        collection: paymentsCollection,
+        id: toPayloadId(paymentId),
+        req: { transactionID: transactionID }
+      }) as Payment
+
+      // Check if version still matches
+      if ((paymentInTransaction.version || 1) !== currentVersion) {
+        // Version conflict detected - payment was modified by another process
+        const logger = createContextLogger(payload, 'Payment Update')
+        logger.warn(`Version conflict for payment ${paymentId} (expected version: ${currentVersion}, got: ${paymentInTransaction.version})`)
+        await payload.db.rollbackTransaction(transactionID)
+        return false
+      }
+
+      // Update with new version
+      await payload.update({
+        collection: paymentsCollection,
+        id: toPayloadId(paymentId),
+        data: {
+          status,
+          providerData: {
+            ...providerData,
+            webhookProcessedAt: new Date().toISOString()
+          },
+          version: currentVersion + 1
+        },
+        req: { transactionID: transactionID }
+      })
+
+      await payload.db.commitTransaction(transactionID)
+      return true
+    } catch (error) {
+      await payload.db.rollbackTransaction(transactionID)
+      throw error
+    }
+  } catch (error) {
+    const logger = createContextLogger(payload, 'Payment Update')
+    logger.error(`Failed to update payment ${paymentId}:`, error)
+    return false
+  }
+}
+
+/**
+ * Update invoice status when payment succeeds
+ */
+export async function updateInvoiceOnPaymentSuccess(
+  payload: Payload,
+  payment: Payment,
+  pluginConfig: BillingPluginConfig
+): Promise<void> {
+  if (!payment.invoice) return
+
+  const invoicesCollection = extractSlug(pluginConfig.collections?.invoices || defaults.invoicesCollection)
+  const invoiceId = typeof payment.invoice === 'object'
+    ? payment.invoice.id
+    : payment.invoice
+
+  await payload.update({
+    collection: invoicesCollection,
+    id: toPayloadId(invoiceId),
+    data: {
+      status: 'paid',
+      payment: toPayloadId(payment.id)
+    }
+  })
+}
+
+/**
+ * Handle webhook errors with consistent logging
+ */
+export function handleWebhookError(
+  provider: string,
+  error: unknown,
+  context?: string,
+  payload?: Payload
+): Response {
+  const message = error instanceof Error ? error.message : 'Unknown error'
+  const fullContext = context ? `${provider} Webhook - ${context}` : `${provider} Webhook`
+
+  // Log detailed error internally for debugging
+  if (payload) {
+    const logger = createContextLogger(payload, fullContext)
+    logger.error('Error:', error)
+  } else {
+    console.error(`[${fullContext}] Error:`, error)
+  }
+
+  // Return generic response to avoid information disclosure
+  return Response.json({
+    received: false,
+    error: 'Processing error'
+  }, { status: 200 })
+}
+
+/**
+ * Log webhook events
+ */
+export function logWebhookEvent(
+  provider: string,
+  event: string,
+  details?: any,
+  payload?: Payload
+): void {
+  if (payload) {
+    const logger = createContextLogger(payload, `${provider} Webhook`)
+    logger.info(event, details ? JSON.stringify(details) : '')
+  } else {
+    console.log(`[${provider} Webhook] ${event}`, details ? JSON.stringify(details) : '')
+  }
+}
+
+/**
+ * Validate URL for production use
+ */
+export function validateProductionUrl(url: string | undefined, urlType: string): void {
+  const isProduction = process.env.NODE_ENV === 'production'
+
+  if (!isProduction) return
+
+  if (!url) {
+    throw new Error(`${urlType} URL is required for production`)
+  }
+
+  if (url.includes('localhost') || url.includes('127.0.0.1')) {
+    throw new Error(`${urlType} URL cannot use localhost in production`)
+  }
+
+  if (!url.startsWith('https://')) {
+    throw new Error(`${urlType} URL must use HTTPS in production`)
+  }
+
+  // Basic URL validation
+  try {
+    new URL(url)
+  } catch {
+    throw new Error(`${urlType} URL is not a valid URL`)
+  }
+}

src/types/index.ts

@@ -1,224 +0,0 @@
-import type { Config } from 'payload'
-
-// Base payment provider interface
-export interface PaymentProvider {
-  cancelPayment(id: string): Promise<Payment>
-  createPayment(options: CreatePaymentOptions): Promise<Payment>
-  handleWebhook(request: Request, signature?: string): Promise<WebhookEvent>
-  name: string
-  refundPayment(id: string, amount?: number): Promise<Refund>
-  retrievePayment(id: string): Promise<Payment>
-}
-
-// Payment types
-export interface CreatePaymentOptions {
-  amount: number
-  cancelUrl?: string
-  currency: string
-  customer?: string
-  description?: string
-  metadata?: Record<string, unknown>
-  returnUrl?: string
-}
-
-export interface Payment {
-  amount: number
-  createdAt: string
-  currency: string
-  customer?: string
-  description?: string
-  id: string
-  metadata?: Record<string, unknown>
-  provider: string
-  providerData?: Record<string, unknown>
-  status: PaymentStatus
-  updatedAt: string
-}
-
-export interface Refund {
-  amount: number
-  createdAt: string
-  currency: string
-  id: string
-  paymentId: string
-  providerData?: Record<string, unknown>
-  reason?: string
-  status: RefundStatus
-}
-
-export interface WebhookEvent {
-  data: Record<string, unknown>
-  id: string
-  provider: string
-  type: string
-  verified: boolean
-}
-
-// Status enums
-export type PaymentStatus = 
-  | 'canceled'
-  | 'failed'
-  | 'partially_refunded'
-  | 'pending'
-  | 'processing'
-  | 'refunded'
-  | 'succeeded'
-
-export type RefundStatus =
-  | 'canceled'
-  | 'failed'
-  | 'pending'
-  | 'processing'
-  | 'succeeded'
-
-// Provider configurations
-export interface StripeConfig {
-  apiVersion?: string
-  publishableKey: string
-  secretKey: string
-  webhookEndpointSecret: string
-}
-
-export interface MollieConfig {
-  apiKey: string
-  testMode?: boolean
-  webhookUrl: string
-}
-
-export interface TestProviderConfig {
-  autoComplete?: boolean
-  defaultDelay?: number
-  enabled: boolean
-  failureRate?: number
-  simulateFailures?: boolean
-}
-
-// Plugin configuration
-export interface BillingPluginConfig {
-  admin?: {
-    customComponents?: boolean
-    dashboard?: boolean
-  }
-  collections?: {
-    customers?: string
-    invoices?: string
-    payments?: string
-    refunds?: string
-  }
-  disabled?: boolean
-  providers?: {
-    mollie?: MollieConfig
-    stripe?: StripeConfig
-    test?: TestProviderConfig
-  }
-  webhooks?: {
-    basePath?: string
-    cors?: boolean
-  }
-}
-
-// Collection types
-export interface PaymentRecord {
-  amount: number
-  createdAt: string
-  currency: string
-  customer?: string
-  description?: string
-  id: string
-  metadata?: Record<string, unknown>
-  provider: string
-  providerData?: Record<string, unknown>
-  providerId: string
-  status: PaymentStatus
-  updatedAt: string
-}
-
-export interface CustomerRecord {
-  address?: {
-    city?: string
-    country?: string
-    line1?: string
-    line2?: string
-    postal_code?: string
-    state?: string
-  }
-  createdAt: string
-  email?: string
-  id: string
-  metadata?: Record<string, unknown>
-  name?: string
-  phone?: string
-  providerIds?: Record<string, string>
-  updatedAt: string
-}
-
-export interface InvoiceRecord {
-  amount: number
-  createdAt: string
-  currency: string
-  customer?: string
-  dueDate?: string
-  id: string
-  items: InvoiceItem[]
-  metadata?: Record<string, unknown>
-  number: string
-  paidAt?: string
-  status: InvoiceStatus
-  updatedAt: string
-}
-
-export interface InvoiceItem {
-  description: string
-  quantity: number
-  totalAmount: number
-  unitAmount: number
-}
-
-export type InvoiceStatus = 
-  | 'draft'
-  | 'open' 
-  | 'paid'
-  | 'uncollectible'
-  | 'void'
-
-// Plugin type
-export interface BillingPluginOptions extends BillingPluginConfig {
-  disabled?: boolean
-}
-
-// Error types
-export class BillingError extends Error {
-  constructor(
-    message: string,
-    public code: string,
-    public provider?: string,
-    public details?: Record<string, unknown>
-  ) {
-    super(message)
-    this.name = 'BillingError'
-  }
-}
-
-export class PaymentProviderError extends BillingError {
-  constructor(
-    message: string,
-    provider: string,
-    code?: string,
-    details?: Record<string, unknown>
-  ) {
-    super(message, code || 'PROVIDER_ERROR', provider, details)
-    this.name = 'PaymentProviderError'
-  }
-}
-
-export class WebhookError extends BillingError {
-  constructor(
-    message: string,
-    provider: string,
-    code?: string,
-    details?: Record<string, unknown>
-  ) {
-    super(message, code || 'WEBHOOK_ERROR', provider, details)
-    this.name = 'WebhookError'
-  }
-}

src/types/payload.ts

@@ -1,148 +0,0 @@
-/**
- * PayloadCMS type definitions for hooks and handlers
- */
-
-import type { PayloadRequest, User } from 'payload'
-
-// Collection hook types
-export interface CollectionBeforeChangeHook<T = Record<string, unknown>> {
-  data: T
-  operation: 'create' | 'delete' | 'update'
-  originalDoc?: T
-  req: PayloadRequest
-}
-
-export interface CollectionAfterChangeHook<T = Record<string, unknown>> {
-  doc: T
-  operation: 'create' | 'delete' | 'update'
-  previousDoc?: T
-  req: PayloadRequest
-}
-
-export interface CollectionBeforeValidateHook<T = Record<string, unknown>> {
-  data?: T
-  operation: 'create' | 'update'
-  originalDoc?: T
-  req: PayloadRequest
-}
-
-// Access control types
-export interface AccessArgs<T = unknown> {
-  data?: T
-  id?: number | string
-  req: {
-    payload: unknown
-    user: null | User
-  }
-}
-
-// Invoice item type for hooks
-export interface InvoiceItemData {
-  description: string
-  quantity: number
-  totalAmount?: number
-  unitAmount: number
-}
-
-// Invoice data type for hooks
-export interface InvoiceData {
-  amount?: number
-  currency?: string
-  customer?: string
-  dueDate?: string
-  items?: InvoiceItemData[]
-  metadata?: Record<string, unknown>
-  notes?: string
-  number?: string
-  paidAt?: string
-  payment?: string
-  status?: string
-  subtotal?: number
-  taxAmount?: number
-}
-
-// Payment data type for hooks
-export interface PaymentData {
-  amount?: number
-  currency?: string
-  customer?: string
-  description?: string
-  invoice?: string
-  metadata?: Record<string, unknown>
-  provider?: string
-  providerData?: Record<string, unknown>
-  providerId?: string
-  status?: string
-}
-
-// Customer data type for hooks
-export interface CustomerData {
-  address?: {
-    city?: string
-    country?: string
-    line1?: string
-    line2?: string
-    postal_code?: string
-    state?: string
-  }
-  email?: string
-  metadata?: Record<string, unknown>
-  name?: string
-  phone?: string
-  providerIds?: Record<string, string>
-}
-
-// Refund data type for hooks
-export interface RefundData {
-  amount?: number
-  currency?: string
-  description?: string
-  metadata?: Record<string, unknown>
-  payment?: { id: string } | string
-  providerData?: Record<string, unknown>
-  providerId?: string
-  reason?: string
-  status?: string
-}
-
-// Document types with required fields after creation
-export interface PaymentDocument extends PaymentData {
-  amount: number
-  createdAt: string
-  currency: string
-  id: string
-  provider: string
-  providerId: string
-  status: string
-  updatedAt: string
-}
-
-export interface CustomerDocument extends CustomerData {
-  createdAt: string
-  id: string
-  updatedAt: string
-}
-
-export interface InvoiceDocument extends InvoiceData {
-  amount: number
-  createdAt: string
-  currency: string
-  customer: string
-  id: string
-  items: InvoiceItemData[]
-  number: string
-  status: string
-  updatedAt: string
-}
-
-export interface RefundDocument extends RefundData {
-  amount: number
-  createdAt: string
-  currency: string
-  id: string
-  payment: { id: string } | string
-  providerId: string
-  refunds?: string[]
-  status: string
-  updatedAt: string
-}

src/utils/currency.ts

@@ -1,130 +0,0 @@
-/**
- * Currency utility functions for payment processing
- */
-
-// Common currency configurations
-export const CURRENCY_CONFIG = {
-  AUD: { name: 'Australian Dollar', decimals: 2, symbol: 'A$' },
-  CAD: { name: 'Canadian Dollar', decimals: 2, symbol: 'C$' },
-  CHF: { name: 'Swiss Franc', decimals: 2, symbol: 'Fr' },
-  DKK: { name: 'Danish Krone', decimals: 2, symbol: 'kr' },
-  EUR: { name: 'Euro', decimals: 2, symbol: '€' },
-  GBP: { name: 'British Pound', decimals: 2, symbol: '£' },
-  JPY: { name: 'Japanese Yen', decimals: 0, symbol: '¥' },
-  NOK: { name: 'Norwegian Krone', decimals: 2, symbol: 'kr' },
-  SEK: { name: 'Swedish Krona', decimals: 2, symbol: 'kr' },
-  USD: { name: 'US Dollar', decimals: 2, symbol: '$' },
-} as const
-
-export type SupportedCurrency = keyof typeof CURRENCY_CONFIG
-
-/**
- * Validates if a currency code is supported
- */
-export function isSupportedCurrency(currency: string): currency is SupportedCurrency {
-  return currency in CURRENCY_CONFIG
-}
-
-/**
- * Validates currency format (3-letter ISO code)
- */
-export function isValidCurrencyCode(currency: string): boolean {
-  return /^[A-Z]{3}$/.test(currency)
-}
-
-/**
- * Converts amount from cents to major currency unit
- */
-export function fromCents(amount: number, currency: string): number {
-  if (!isValidCurrencyCode(currency)) {
-    throw new Error(`Invalid currency code: ${currency}`)
-  }
-
-  const config = CURRENCY_CONFIG[currency as SupportedCurrency]
-  if (!config) {
-    // Default to 2 decimals for unknown currencies
-    return amount / 100
-  }
-
-  return config.decimals === 0 ? amount : amount / Math.pow(10, config.decimals)
-}
-
-/**
- * Converts amount from major currency unit to cents
- */
-export function toCents(amount: number, currency: string): number {
-  if (!isValidCurrencyCode(currency)) {
-    throw new Error(`Invalid currency code: ${currency}`)
-  }
-
-  const config = CURRENCY_CONFIG[currency as SupportedCurrency]
-  if (!config) {
-    // Default to 2 decimals for unknown currencies
-    return Math.round(amount * 100)
-  }
-
-  return config.decimals === 0 
-    ? Math.round(amount) 
-    : Math.round(amount * Math.pow(10, config.decimals))
-}
-
-/**
- * Formats amount for display with currency symbol
- */
-export function formatAmount(amount: number, currency: string, options?: {
-  showCode?: boolean
-  showSymbol?: boolean
-}): string {
-  const { showCode = false, showSymbol = true } = options || {}
-  
-  if (!isValidCurrencyCode(currency)) {
-    throw new Error(`Invalid currency code: ${currency}`)
-  }
-
-  const majorAmount = fromCents(amount, currency)
-  const config = CURRENCY_CONFIG[currency as SupportedCurrency]
-  
-  let formatted = majorAmount.toFixed(config?.decimals ?? 2)
-  
-  if (showSymbol && config?.symbol) {
-    formatted = `${config.symbol}${formatted}`
-  }
-  
-  if (showCode) {
-    formatted += ` ${currency}`
-  }
-  
-  return formatted
-}
-
-/**
- * Gets currency information
- */
-export function getCurrencyInfo(currency: string) {
-  if (!isValidCurrencyCode(currency)) {
-    throw new Error(`Invalid currency code: ${currency}`)
-  }
-
-  return CURRENCY_CONFIG[currency as SupportedCurrency] || {
-    name: currency,
-    decimals: 2,
-    symbol: currency
-  }
-}
-
-/**
- * Validates amount is positive and properly formatted
- */
-export function validateAmount(amount: number): void {
-  if (!Number.isFinite(amount)) {
-    throw new Error('Amount must be a finite number')
-  }
-  
-  if (amount <= 0) {
-    throw new Error('Amount must be positive')
-  }
-  
-  if (!Number.isInteger(amount)) {
-    throw new Error('Amount must be an integer (in cents)')
-  }
-}

src/utils/index.ts

@@ -1,3 +0,0 @@
-export * from './currency'
-export * from './logger'
-export * from './validation'

src/utils/logger.ts

@@ -1,113 +1,48 @@
+import type { Payload } from 'payload'
+
+let pluginLogger: any = null
+
 /**
- * Structured logging utilities for the billing plugin
+ * Get or create the plugin logger instance
+ * Uses PAYLOAD_BILLING_LOG_LEVEL environment variable to configure log level
+ * Defaults to 'info' if not set
  */
+export function getPluginLogger(payload: Payload) {
+  if (!pluginLogger && payload.logger) {
+    const logLevel = process.env.PAYLOAD_BILLING_LOG_LEVEL || 'info'
 
-export type LogLevel = 'debug' | 'error' | 'info' | 'warn'
+    pluginLogger = payload.logger.child({
+      level: logLevel,
+      plugin: '@xtr-dev/payload-billing'
+    })
 
-export interface LogContext {
-  [key: string]: unknown
-  amount?: number
-  currency?: string
-  customerId?: string
-  invoiceId?: string
-  paymentId?: string
-  provider?: string
-  refundId?: string
-  webhookId?: string
+    // Log the configured log level on first initialization
+    pluginLogger.info(`Logger initialized with level: ${logLevel}`)
   }
 
-export interface Logger {
-  debug(message: string, context?: LogContext): void
-  error(message: string, context?: LogContext): void
-  info(message: string, context?: LogContext): void
-  warn(message: string, context?: LogContext): void
+  // Fallback to console if logger not available (shouldn't happen in normal operation)
+  if (!pluginLogger) {
+    return {
+      debug: (...args: any[]) => console.log('[BILLING DEBUG]', ...args),
+      info: (...args: any[]) => console.log('[BILLING INFO]', ...args),
+      warn: (...args: any[]) => console.warn('[BILLING WARN]', ...args),
+      error: (...args: any[]) => console.error('[BILLING ERROR]', ...args),
+    }
+  }
+
+  return pluginLogger
 }
 
 /**
- * Creates a structured logger with consistent formatting
+ * Create a context-specific logger for a particular operation
  */
-export function createLogger(namespace: string = 'BILLING'): Logger {
-  const log = (level: LogLevel, message: string, context: LogContext = {}) => {
-    const timestamp = new Date().toISOString()
-    const logData = {
-      level: level.toUpperCase(),
-      message,
-      namespace,
-      timestamp,
-      ...context,
-    }
-
-    // Use console methods based on log level
-    const consoleMethod = console[level] || console.log
-    consoleMethod(`[${namespace}] ${message}`, logData)
-  }
+export function createContextLogger(payload: Payload, context: string) {
+  const logger = getPluginLogger(payload)
 
   return {
-    debug: (message: string, context?: LogContext) => log('debug', message, context),
-    error: (message: string, context?: LogContext) => log('error', message, context),
-    info: (message: string, context?: LogContext) => log('info', message, context),
-    warn: (message: string, context?: LogContext) => log('warn', message, context),
+    debug: (message: string, ...args: any[]) => logger.debug(`[${context}] ${message}`, ...args),
+    info: (message: string, ...args: any[]) => logger.info(`[${context}] ${message}`, ...args),
+    warn: (message: string, ...args: any[]) => logger.warn(`[${context}] ${message}`, ...args),
+    error: (message: string, ...args: any[]) => logger.error(`[${context}] ${message}`, ...args),
   }
 }
-
-/**
- * Default logger instance for the plugin
- */
-export const logger = createLogger('BILLING')
-
-/**
- * Creates a provider-specific logger
- */
-export function createProviderLogger(providerName: string): Logger {
-  return createLogger(`BILLING:${providerName.toUpperCase()}`)
-}
-
-/**
- * Log payment operations with consistent structure
- */
-export function logPaymentOperation(
-  operation: string,
-  paymentId: string,
-  provider: string,
-  context?: LogContext
-) {
-  logger.info(`Payment ${operation}`, {
-    operation,
-    paymentId,
-    provider,
-    ...context,
-  })
-}
-
-/**
- * Log webhook events with consistent structure
- */
-export function logWebhookEvent(
-  provider: string,
-  eventType: string,
-  webhookId: string,
-  context?: LogContext
-) {
-  logger.info(`Webhook received`, {
-    eventType,
-    provider,
-    webhookId,
-    ...context,
-  })
-}
-
-/**
- * Log errors with consistent structure
- */
-export function logError(
-  error: Error,
-  operation: string,
-  context?: LogContext
-) {
-  logger.error(`Operation failed: ${operation}`, {
-    error: error.message,
-    operation,
-    stack: error.stack,
-    ...context,
-  })
-}

src/utils/validation.ts

@@ -1,181 +0,0 @@
-/**
- * Validation utilities for billing data
- */
-
-import { z } from 'zod'
-
-import { isValidCurrencyCode } from './currency'
-
-/**
- * Zod schema for payment creation options
- */
-export const createPaymentSchema = z.object({
-  amount: z.number().int().positive('Amount must be positive').min(1, 'Amount must be at least 1 cent'),
-  cancelUrl: z.string().url('Invalid cancel URL').optional(),
-  currency: z.string().length(3, 'Currency must be 3 characters').regex(/^[A-Z]{3}$/, 'Currency must be uppercase'),
-  customer: z.string().optional(),
-  description: z.string().max(500, 'Description too long').optional(),
-  metadata: z.record(z.unknown()).optional(),
-  returnUrl: z.string().url('Invalid return URL').optional(),
-})
-
-/**
- * Zod schema for customer data
- */
-export const customerSchema = z.object({
-  name: z.string().max(100, 'Name too long').optional(),
-  address: z.object({
-    city: z.string().max(50).optional(),
-    country: z.string().length(2, 'Country must be 2 characters').regex(/^[A-Z]{2}$/, 'Country must be uppercase').optional(),
-    line1: z.string().max(100).optional(),
-    line2: z.string().max(100).optional(),
-    postal_code: z.string().max(20).optional(),
-    state: z.string().max(50).optional(),
-  }).optional(),
-  email: z.string().email('Invalid email address').optional(),
-  metadata: z.record(z.unknown()).optional(),
-  phone: z.string().max(20, 'Phone number too long').optional(),
-})
-
-/**
- * Zod schema for invoice items
- */
-export const invoiceItemSchema = z.object({
-  description: z.string().min(1, 'Description is required').max(200, 'Description too long'),
-  quantity: z.number().int().positive('Quantity must be positive'),
-  unitAmount: z.number().int().min(0, 'Unit amount must be non-negative'),
-})
-
-/**
- * Zod schema for invoice creation
- */
-export const invoiceSchema = z.object({
-  currency: z.string().length(3).regex(/^[A-Z]{3}$/),
-  customer: z.string().min(1, 'Customer is required'),
-  dueDate: z.string().datetime().optional(),
-  items: z.array(invoiceItemSchema).min(1, 'At least one item is required'),
-  metadata: z.record(z.unknown()).optional(),
-  notes: z.string().max(1000).optional(),
-  taxAmount: z.number().int().min(0).default(0),
-})
-
-/**
- * Validates payment creation data
- */
-export function validateCreatePayment(data: unknown) {
-  const result = createPaymentSchema.safeParse(data)
-  if (!result.success) {
-    throw new Error(`Invalid payment data: ${result.error.issues.map(i => i.message).join(', ')}`)
-  }
-  
-  // Additional currency validation
-  if (!isValidCurrencyCode(result.data.currency)) {
-    throw new Error(`Unsupported currency: ${result.data.currency}`)
-  }
-  
-  return result.data
-}
-
-/**
- * Validates customer data
- */
-export function validateCustomer(data: unknown) {
-  const result = customerSchema.safeParse(data)
-  if (!result.success) {
-    throw new Error(`Invalid customer data: ${result.error.issues.map(i => i.message).join(', ')}`)
-  }
-  return result.data
-}
-
-/**
- * Validates invoice data
- */
-export function validateInvoice(data: unknown) {
-  const result = invoiceSchema.safeParse(data)
-  if (!result.success) {
-    throw new Error(`Invalid invoice data: ${result.error.issues.map(i => i.message).join(', ')}`)
-  }
-  
-  // Additional currency validation
-  if (!isValidCurrencyCode(result.data.currency)) {
-    throw new Error(`Unsupported currency: ${result.data.currency}`)
-  }
-  
-  return result.data
-}
-
-/**
- * Validates webhook signature format
- */
-export function validateWebhookSignature(signature: string, provider: string): void {
-  if (!signature) {
-    throw new Error(`Missing webhook signature for ${provider}`)
-  }
-  
-  switch (provider) {
-    case 'mollie':
-      if (signature.length < 32) {
-        throw new Error('Invalid Mollie webhook signature length')
-      }
-      break
-    case 'stripe':
-      if (!signature.startsWith('t=')) {
-        throw new Error('Invalid Stripe webhook signature format')
-      }
-      break
-    case 'test':
-      // Test provider accepts any signature
-      break
-    default:
-      throw new Error(`Unknown provider: ${provider}`)
-  }
-}
-
-/**
- * Validates payment provider name
- */
-export function validateProviderName(provider: string): void {
-  const validProviders = ['stripe', 'mollie', 'test']
-  if (!validProviders.includes(provider)) {
-    throw new Error(`Invalid provider: ${provider}. Must be one of: ${validProviders.join(', ')}`)
-  }
-}
-
-/**
- * Validates payment amount and currency combination
- */
-export function validateAmountAndCurrency(amount: number, currency: string): void {
-  if (!Number.isInteger(amount) || amount <= 0) {
-    throw new Error('Amount must be a positive integer')
-  }
-  
-  if (!isValidCurrencyCode(currency)) {
-    throw new Error('Invalid currency code')
-  }
-  
-  // Validate minimum amounts for different currencies
-  const minimums: Record<string, number> = {
-    EUR: 50,  // €0.50
-    GBP: 30,  // £0.30
-    JPY: 50,  // ¥50
-    USD: 50,  // $0.50
-  }
-  
-  const minimum = minimums[currency] || 50
-  if (amount < minimum) {
-    throw new Error(`Amount too small for ${currency}. Minimum: ${minimum} cents`)
-  }
-}
-
-/**
- * Validates refund amount against original payment
- */
-export function validateRefundAmount(refundAmount: number, paymentAmount: number): void {
-  if (!Number.isInteger(refundAmount) || refundAmount <= 0) {
-    throw new Error('Refund amount must be a positive integer')
-  }
-  
-  if (refundAmount > paymentAmount) {
-    throw new Error('Refund amount cannot exceed original payment amount')
-  }
-}