@parsrun/payments 0.1.0

package/README.md

@@ -0,0 +1,184 @@
+# @parsrun/payments
+
+Edge-compatible payment processing for Pars with subscription and billing support.
+
+## Features
+
+- **Multi-Provider**: Stripe, Paddle, iyzico
+- **Subscriptions**: Full subscription lifecycle management
+- **Usage Billing**: Metered billing support
+- **Webhooks**: Secure webhook handling
+- **Dunning**: Failed payment recovery
+
+## Installation
+
+```bash
+pnpm add @parsrun/payments
+```
+
+## Quick Start
+
+```typescript
+import { createPaymentService } from '@parsrun/payments';
+
+const payments = createPaymentService({
+  provider: 'stripe',
+  secretKey: process.env.STRIPE_SECRET_KEY,
+  webhookSecret: process.env.STRIPE_WEBHOOK_SECRET,
+});
+
+// Create checkout session
+const session = await payments.createCheckout({
+  customerId: 'cus_xxx',
+  priceId: 'price_xxx',
+  successUrl: 'https://example.com/success',
+  cancelUrl: 'https://example.com/cancel',
+});
+```
+
+## API Overview
+
+### Providers
+
+#### Stripe
+
+```typescript
+import { createStripeProvider } from '@parsrun/payments/providers/stripe';
+
+const stripe = createStripeProvider({
+  secretKey: process.env.STRIPE_SECRET_KEY,
+  webhookSecret: process.env.STRIPE_WEBHOOK_SECRET,
+});
+```
+
+#### Paddle
+
+```typescript
+import { createPaddleProvider } from '@parsrun/payments/providers/paddle';
+
+const paddle = createPaddleProvider({
+  vendorId: process.env.PADDLE_VENDOR_ID,
+  apiKey: process.env.PADDLE_API_KEY,
+});
+```
+
+#### iyzico
+
+```typescript
+import { createIyzicoProvider } from '@parsrun/payments/providers/iyzico';
+
+const iyzico = createIyzicoProvider({
+  apiKey: process.env.IYZICO_API_KEY,
+  secretKey: process.env.IYZICO_SECRET_KEY,
+  sandbox: true,
+});
+```
+
+### Subscriptions
+
+```typescript
+// Create subscription
+const subscription = await payments.createSubscription({
+  customerId: 'cus_xxx',
+  priceId: 'price_xxx',
+  trialDays: 14,
+});
+
+// Cancel subscription
+await payments.cancelSubscription(subscriptionId, {
+  cancelAtPeriodEnd: true,
+});
+
+// Update subscription
+await payments.updateSubscription(subscriptionId, {
+  priceId: 'price_new',
+});
+```
+
+### Billing
+
+```typescript
+import { createBillingManager } from '@parsrun/payments/billing';
+
+const billing = createBillingManager({
+  provider: stripeProvider,
+  database: db,
+});
+
+// Get customer billing info
+const info = await billing.getCustomerBilling(customerId);
+
+// Create invoice
+const invoice = await billing.createInvoice({
+  customerId,
+  items: [{ description: 'Service', amount: 1000 }],
+});
+```
+
+### Usage Billing
+
+```typescript
+import { createUsageTracker } from '@parsrun/payments/usage';
+
+const usage = createUsageTracker({
+  provider: stripeProvider,
+});
+
+// Record usage
+await usage.record({
+  subscriptionId: 'sub_xxx',
+  quantity: 100,
+  timestamp: new Date(),
+});
+```
+
+### Webhooks
+
+```typescript
+import { createWebhookHandler } from '@parsrun/payments/webhooks';
+
+const webhooks = createWebhookHandler({
+  provider: stripeProvider,
+  handlers: {
+    'checkout.session.completed': async (event) => {
+      // Handle successful checkout
+    },
+    'invoice.payment_failed': async (event) => {
+      // Handle failed payment
+    },
+  },
+});
+
+app.post('/webhooks/stripe', webhooks.handle);
+```
+
+### Dunning (Payment Recovery)
+
+```typescript
+import { createDunningManager } from '@parsrun/payments/dunning';
+
+const dunning = createDunningManager({
+  provider: stripeProvider,
+  retrySchedule: [1, 3, 7, 14], // Days
+  onFinalFailure: async (subscription) => {
+    // Handle subscription cancellation
+  },
+});
+```
+
+## Exports
+
+```typescript
+import { ... } from '@parsrun/payments';                 // Main exports
+import { ... } from '@parsrun/payments/providers/stripe';  // Stripe
+import { ... } from '@parsrun/payments/providers/paddle';  // Paddle
+import { ... } from '@parsrun/payments/providers/iyzico';  // iyzico
+import { ... } from '@parsrun/payments/billing';           // Billing
+import { ... } from '@parsrun/payments/usage';             // Usage billing
+import { ... } from '@parsrun/payments/webhooks';          // Webhooks
+import { ... } from '@parsrun/payments/dunning';           // Dunning
+```
+
+## License
+
+MIT

package/dist/billing/index.d.ts

@@ -0,0 +1,121 @@
+import { g as ProviderStrategyConfig, k as BillingLogger, f as RegionDetectionContext, p as ProviderSelection, d as BillingRegion, F as FallbackConfig, h as FallbackOperation } from '../billing-service-LsAFesou.js';
+export { o as BillingCustomer, a as BillingError, q as BillingErrorCode, b as BillingErrorCodes, B as BillingService, j as BillingServiceConfig, n as BillingSubscription, C as CancelOptions, m as CancelResult, i as FallbackContext, G as GetSubscriptionOptions, P as ProviderRoutingRule, R as RegionDetectionResult, e as RegionDetector, S as SubscribeOptions, l as SubscribeResult, c as createBillingService } from '../billing-service-LsAFesou.js';
+import { PaymentProviderType, PaymentProvider } from '../types.js';
+import '../webhooks/index.js';
+import '@parsrun/types';
+
+/**
+ * @parsrun/payments - Provider Strategy
+ * Region-based provider routing and selection
+ */
+
+/**
+ * Provider Strategy
+ * Handles region-based provider routing and selection
+ */
+declare class ProviderStrategy {
+    private readonly defaultProvider;
+    private readonly regionProviders;
+    private readonly rules;
+    private readonly regionDetector;
+    private readonly logger;
+    constructor(config: ProviderStrategyConfig, logger?: BillingLogger);
+    /**
+     * Select provider for given context
+     */
+    selectProvider(context: RegionDetectionContext, forceProvider?: PaymentProviderType): Promise<ProviderSelection>;
+    /**
+     * Detect region from context
+     */
+    detectRegion(context: RegionDetectionContext): Promise<BillingRegion>;
+    /**
+     * Get all configured providers
+     */
+    getAllProviders(): PaymentProvider[];
+    /**
+     * Get provider by type
+     */
+    getProviderByType(type: PaymentProviderType): PaymentProvider | undefined;
+    /**
+     * Get default provider
+     */
+    getDefaultProvider(): PaymentProvider;
+    /**
+     * Get provider for region
+     */
+    getProviderForRegion(region: BillingRegion): PaymentProvider;
+    /**
+     * Check if region is supported
+     */
+    isRegionSupported(region: BillingRegion): boolean;
+    /**
+     * Get supported regions
+     */
+    getSupportedRegions(): BillingRegion[];
+    /**
+     * Find provider by type across all configured providers
+     */
+    private findProviderByType;
+}
+/**
+ * Create provider strategy
+ */
+declare function createProviderStrategy(config: ProviderStrategyConfig, logger?: BillingLogger): ProviderStrategy;
+
+/**
+ * @parsrun/payments - Fallback Executor
+ * Handles provider fallback with safety controls
+ */
+
+/**
+ * Fallback Executor
+ * Handles provider fallback with safety controls and logging
+ */
+declare class FallbackExecutor {
+    private readonly config;
+    private readonly logger;
+    constructor(config: FallbackConfig, logger?: BillingLogger);
+    /**
+     * Check if fallback is enabled
+     */
+    get isEnabled(): boolean;
+    /**
+     * Execute operation with fallback support
+     *
+     * @param operation - Operation name for safety checks
+     * @param primaryProvider - Primary provider to try first
+     * @param fallbackProviders - Fallback providers in order of preference
+     * @param execute - Function that executes the operation on a provider
+     */
+    execute<T>(operation: FallbackOperation, primaryProvider: PaymentProvider, fallbackProviders: PaymentProvider[], execute: (provider: PaymentProvider) => Promise<T>): Promise<{
+        result: T;
+        provider: PaymentProvider;
+        usedFallback: boolean;
+    }>;
+    /**
+     * Check if fallback is allowed for operation
+     */
+    canFallback(operation: FallbackOperation): boolean;
+    /**
+     * Check if error is retryable
+     */
+    isRetryableError(error: Error): boolean;
+    /**
+     * Notify fallback callback
+     */
+    private notifyFallback;
+    /**
+     * Notify all failed callback
+     */
+    private notifyAllFailed;
+}
+/**
+ * Create a disabled fallback executor (default behavior)
+ */
+declare function createDisabledFallback(): FallbackExecutor;
+/**
+ * Create fallback executor
+ */
+declare function createFallbackExecutor(config: FallbackConfig, logger?: BillingLogger): FallbackExecutor;
+
+export { BillingLogger, BillingRegion, FallbackConfig, FallbackExecutor, FallbackOperation, ProviderSelection, ProviderStrategy, ProviderStrategyConfig, RegionDetectionContext, createDisabledFallback, createFallbackExecutor, createProviderStrategy };