@parsrun/payments 0.1.0

package/dist/billing/index.js

@@ -0,0 +1,1082 @@
+// src/webhooks/index.ts
+var WebhookHandlerRegistry = class {
+  handlers = /* @__PURE__ */ new Map();
+  /**
+   * Register a handler for a specific event type
+   */
+  on(type2, handler) {
+    const handlers = this.handlers.get(type2) ?? [];
+    handlers.push(handler);
+    this.handlers.set(type2, handlers);
+    return this;
+  }
+  /**
+   * Register handlers for checkout events
+   */
+  onCheckout(handler) {
+    this.on("checkout.session.completed", handler);
+    this.on("checkout.session.expired", handler);
+    return this;
+  }
+  /**
+   * Register handlers for subscription events
+   */
+  onSubscription(handler) {
+    this.on("subscription.created", handler);
+    this.on("subscription.updated", handler);
+    this.on("subscription.deleted", handler);
+    this.on("subscription.trial_will_end", handler);
+    return this;
+  }
+  /**
+   * Register handlers for payment events
+   */
+  onPayment(handler) {
+    this.on("payment.succeeded", handler);
+    this.on("payment.failed", handler);
+    return this;
+  }
+  /**
+   * Register handlers for invoice events
+   */
+  onInvoice(handler) {
+    this.on("invoice.created", handler);
+    this.on("invoice.paid", handler);
+    this.on("invoice.payment_failed", handler);
+    this.on("invoice.upcoming", handler);
+    return this;
+  }
+  /**
+   * Register handlers for customer events
+   */
+  onCustomer(handler) {
+    this.on("customer.created", handler);
+    this.on("customer.updated", handler);
+    this.on("customer.deleted", handler);
+    return this;
+  }
+  /**
+   * Get handlers for an event type
+   */
+  getHandlers(type2) {
+    const specificHandlers = this.handlers.get(type2) ?? [];
+    const globalHandlers = this.handlers.get("*") ?? [];
+    return [...specificHandlers, ...globalHandlers];
+  }
+  /**
+   * Execute all handlers for an event
+   */
+  async handle(event) {
+    const handlers = this.getHandlers(event.type);
+    for (const handler of handlers) {
+      await handler(event);
+    }
+  }
+};
+var WebhookProcessor = class {
+  provider;
+  registry;
+  constructor(provider, registry) {
+    this.provider = provider;
+    this.registry = registry ?? new WebhookHandlerRegistry();
+  }
+  /**
+   * Get the handler registry
+   */
+  get handlers() {
+    return this.registry;
+  }
+  /**
+   * Process a webhook request
+   */
+  async process(request) {
+    try {
+      const payload = await request.text();
+      const signature = this.getSignature(request);
+      if (!signature) {
+        return {
+          success: false,
+          error: "Missing webhook signature"
+        };
+      }
+      const event = await this.provider.verifyWebhook(payload, signature);
+      if (!event) {
+        return {
+          success: false,
+          error: "Invalid webhook signature"
+        };
+      }
+      await this.registry.handle(event);
+      return {
+        success: true,
+        event
+      };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : "Unknown error"
+      };
+    }
+  }
+  /**
+   * Process raw webhook payload
+   */
+  async processRaw(payload, signature) {
+    try {
+      const event = await this.provider.verifyWebhook(payload, signature);
+      if (!event) {
+        return {
+          success: false,
+          error: "Invalid webhook signature"
+        };
+      }
+      await this.registry.handle(event);
+      return {
+        success: true,
+        event
+      };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : "Unknown error"
+      };
+    }
+  }
+  getSignature(request) {
+    const stripeSignature = request.headers.get("stripe-signature");
+    if (stripeSignature) return stripeSignature;
+    const paddleSignature = request.headers.get("paddle-signature");
+    if (paddleSignature) return paddleSignature;
+    return null;
+  }
+};
+
+// src/billing/types.ts
+var BillingErrorCodes = {
+  NO_PROVIDER_CONFIGURED: "NO_PROVIDER_CONFIGURED",
+  PROVIDER_UNAVAILABLE: "PROVIDER_UNAVAILABLE",
+  ALL_PROVIDERS_FAILED: "ALL_PROVIDERS_FAILED",
+  REGION_NOT_SUPPORTED: "REGION_NOT_SUPPORTED",
+  SUBSCRIPTION_NOT_FOUND: "SUBSCRIPTION_NOT_FOUND",
+  CUSTOMER_NOT_FOUND: "CUSTOMER_NOT_FOUND",
+  FALLBACK_DISABLED: "FALLBACK_DISABLED",
+  OPERATION_NOT_ALLOWED: "OPERATION_NOT_ALLOWED"
+};
+var BillingError = class extends Error {
+  constructor(message, code, provider, cause) {
+    super(message);
+    this.code = code;
+    this.provider = provider;
+    this.cause = cause;
+    this.name = "BillingError";
+  }
+};
+
+// src/billing/provider-strategy.ts
+var defaultRegionDetector = (context) => {
+  if (!context.countryCode) {
+    return "GLOBAL";
+  }
+  const countryToRegion = {
+    // Turkey
+    TR: "TR",
+    // EU countries
+    DE: "EU",
+    FR: "EU",
+    IT: "EU",
+    ES: "EU",
+    NL: "EU",
+    BE: "EU",
+    AT: "EU",
+    PT: "EU",
+    GR: "EU",
+    PL: "EU",
+    CZ: "EU",
+    RO: "EU",
+    HU: "EU",
+    SE: "EU",
+    DK: "EU",
+    FI: "EU",
+    IE: "EU",
+    SK: "EU",
+    BG: "EU",
+    HR: "EU",
+    LT: "EU",
+    LV: "EU",
+    SI: "EU",
+    EE: "EU",
+    CY: "EU",
+    LU: "EU",
+    MT: "EU",
+    // UK
+    GB: "UK",
+    UK: "UK",
+    // US
+    US: "US",
+    // APAC
+    JP: "APAC",
+    CN: "APAC",
+    KR: "APAC",
+    AU: "APAC",
+    NZ: "APAC",
+    SG: "APAC",
+    HK: "APAC",
+    TW: "APAC",
+    IN: "APAC",
+    ID: "APAC",
+    MY: "APAC",
+    TH: "APAC",
+    PH: "APAC",
+    VN: "APAC",
+    // LATAM
+    BR: "LATAM",
+    MX: "LATAM",
+    AR: "LATAM",
+    CL: "LATAM",
+    CO: "LATAM",
+    PE: "LATAM",
+    VE: "LATAM",
+    EC: "LATAM",
+    UY: "LATAM",
+    PY: "LATAM"
+  };
+  return countryToRegion[context.countryCode.toUpperCase()] ?? "GLOBAL";
+};
+var ProviderStrategy = class {
+  defaultProvider;
+  regionProviders;
+  rules;
+  regionDetector;
+  logger;
+  constructor(config, logger) {
+    this.defaultProvider = config.default;
+    this.regionProviders = /* @__PURE__ */ new Map();
+    this.rules = config.rules ?? [];
+    this.regionDetector = config.regionDetector ?? defaultRegionDetector;
+    this.logger = logger ?? void 0;
+    if (config.regions) {
+      for (const [region, provider] of Object.entries(config.regions)) {
+        this.regionProviders.set(region, provider);
+      }
+    }
+    this.rules.sort((a, b) => (a.priority ?? 100) - (b.priority ?? 100));
+  }
+  /**
+   * Select provider for given context
+   */
+  async selectProvider(context, forceProvider) {
+    if (forceProvider) {
+      const provider = this.findProviderByType(forceProvider);
+      if (provider) {
+        this.logger?.debug("Provider forced", { provider: forceProvider });
+        return {
+          provider,
+          type: forceProvider,
+          region: await this.detectRegion(context),
+          reason: "forced"
+        };
+      }
+      throw new BillingError(
+        `Forced provider "${forceProvider}" not configured`,
+        "NO_PROVIDER_CONFIGURED",
+        forceProvider
+      );
+    }
+    const region = await this.detectRegion(context);
+    this.logger?.debug("Region detected", { region, context });
+    for (const rule of this.rules) {
+      if (rule.regions.includes(region)) {
+        if (rule.condition && !rule.condition(context)) {
+          continue;
+        }
+        this.logger?.debug("Rule matched", {
+          regions: rule.regions,
+          provider: rule.provider.type
+        });
+        return {
+          provider: rule.provider,
+          type: rule.provider.type,
+          region,
+          reason: "rule"
+        };
+      }
+    }
+    const regionProvider = this.regionProviders.get(region);
+    if (regionProvider) {
+      this.logger?.debug("Region provider selected", {
+        region,
+        provider: regionProvider.type
+      });
+      return {
+        provider: regionProvider,
+        type: regionProvider.type,
+        region,
+        reason: "region"
+      };
+    }
+    this.logger?.debug("Using default provider", {
+      region,
+      provider: this.defaultProvider.type
+    });
+    return {
+      provider: this.defaultProvider,
+      type: this.defaultProvider.type,
+      region,
+      reason: "default"
+    };
+  }
+  /**
+   * Detect region from context
+   */
+  async detectRegion(context) {
+    try {
+      return await this.regionDetector(context);
+    } catch (error) {
+      this.logger?.warn("Region detection failed, using GLOBAL", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return "GLOBAL";
+    }
+  }
+  /**
+   * Get all configured providers
+   */
+  getAllProviders() {
+    const providers = /* @__PURE__ */ new Set();
+    providers.add(this.defaultProvider);
+    for (const provider of this.regionProviders.values()) {
+      providers.add(provider);
+    }
+    for (const rule of this.rules) {
+      providers.add(rule.provider);
+    }
+    return Array.from(providers);
+  }
+  /**
+   * Get provider by type
+   */
+  getProviderByType(type2) {
+    return this.findProviderByType(type2);
+  }
+  /**
+   * Get default provider
+   */
+  getDefaultProvider() {
+    return this.defaultProvider;
+  }
+  /**
+   * Get provider for region
+   */
+  getProviderForRegion(region) {
+    return this.regionProviders.get(region) ?? this.defaultProvider;
+  }
+  /**
+   * Check if region is supported
+   */
+  isRegionSupported(region) {
+    if (region === "GLOBAL") return true;
+    for (const rule of this.rules) {
+      if (rule.regions.includes(region)) return true;
+    }
+    return this.regionProviders.has(region);
+  }
+  /**
+   * Get supported regions
+   */
+  getSupportedRegions() {
+    const regions = /* @__PURE__ */ new Set(["GLOBAL"]);
+    for (const region of this.regionProviders.keys()) {
+      regions.add(region);
+    }
+    for (const rule of this.rules) {
+      for (const region of rule.regions) {
+        regions.add(region);
+      }
+    }
+    return Array.from(regions);
+  }
+  /**
+   * Find provider by type across all configured providers
+   */
+  findProviderByType(type2) {
+    if (this.defaultProvider.type === type2) {
+      return this.defaultProvider;
+    }
+    for (const provider of this.regionProviders.values()) {
+      if (provider.type === type2) {
+        return provider;
+      }
+    }
+    for (const rule of this.rules) {
+      if (rule.provider.type === type2) {
+        return rule.provider;
+      }
+    }
+    return void 0;
+  }
+};
+function createProviderStrategy(config, logger) {
+  return new ProviderStrategy(config, logger);
+}
+
+// src/types.ts
+import {
+  type,
+  currencyCode,
+  money,
+  paymentCustomer,
+  createCustomerRequest,
+  cardDetails,
+  paymentMethod,
+  paymentIntentStatus,
+  paymentIntent,
+  createPaymentIntentRequest,
+  subscriptionStatus,
+  priceInterval,
+  price,
+  subscription,
+  createSubscriptionRequest,
+  refundStatus,
+  refund,
+  createRefundRequest,
+  webhookEventType,
+  webhookEvent,
+  stripeConfig,
+  paddleConfig,
+  iyzicoConfig,
+  paymentsConfig
+} from "@parsrun/types";
+var PaymentErrorCodes = {
+  INVALID_CONFIG: "INVALID_CONFIG",
+  CUSTOMER_NOT_FOUND: "CUSTOMER_NOT_FOUND",
+  SUBSCRIPTION_NOT_FOUND: "SUBSCRIPTION_NOT_FOUND",
+  CHECKOUT_FAILED: "CHECKOUT_FAILED",
+  PAYMENT_FAILED: "PAYMENT_FAILED",
+  WEBHOOK_VERIFICATION_FAILED: "WEBHOOK_VERIFICATION_FAILED",
+  API_ERROR: "API_ERROR",
+  RATE_LIMITED: "RATE_LIMITED"
+};
+
+// src/billing/fallback-executor.ts
+var DEFAULT_RETRYABLE_ERRORS = [
+  PaymentErrorCodes.API_ERROR,
+  PaymentErrorCodes.RATE_LIMITED,
+  "PROVIDER_UNAVAILABLE",
+  "ECONNREFUSED",
+  "ETIMEDOUT",
+  "ENOTFOUND",
+  "NetworkError",
+  "fetch failed"
+];
+var DEFAULT_ALLOWED_OPERATIONS = ["createCheckout"];
+var FallbackExecutor = class {
+  config;
+  logger;
+  constructor(config, logger) {
+    this.config = {
+      enabled: config.enabled,
+      maxAttempts: config.maxAttempts ?? 1,
+      allowedOperations: config.allowedOperations ?? DEFAULT_ALLOWED_OPERATIONS,
+      retryableErrors: config.retryableErrors ?? DEFAULT_RETRYABLE_ERRORS,
+      providers: config.providers,
+      onFallback: config.onFallback,
+      onAllFailed: config.onAllFailed
+    };
+    this.logger = logger;
+  }
+  /**
+   * Check if fallback is enabled
+   */
+  get isEnabled() {
+    return this.config.enabled;
+  }
+  /**
+   * 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
+   */
+  async execute(operation, primaryProvider, fallbackProviders, execute) {
+    const canFallback = this.canFallback(operation);
+    let lastError;
+    let attempt = 0;
+    const providers = [primaryProvider];
+    if (canFallback) {
+      for (const fb of fallbackProviders) {
+        if (fb !== primaryProvider && providers.length <= this.config.maxAttempts) {
+          providers.push(fb);
+        }
+      }
+    }
+    for (const provider of providers) {
+      attempt++;
+      const isUsingFallback = provider !== primaryProvider;
+      try {
+        this.logger?.debug(`Attempting ${operation}`, {
+          provider: provider.type,
+          attempt,
+          isUsingFallback
+        });
+        const result = await execute(provider);
+        if (isUsingFallback) {
+          this.logger?.info(`Fallback succeeded`, {
+            operation,
+            provider: provider.type,
+            originalProvider: primaryProvider.type
+          });
+        }
+        return {
+          result,
+          provider,
+          usedFallback: isUsingFallback
+        };
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        this.logger?.warn(`Provider ${provider.type} failed`, {
+          operation,
+          error: lastError.message,
+          attempt,
+          maxAttempts: providers.length
+        });
+        if (isUsingFallback || !canFallback || attempt >= providers.length || !this.isRetryableError(lastError)) {
+          if (attempt >= providers.length) {
+            if (this.config.onAllFailed) {
+              await this.notifyAllFailed(
+                operation,
+                primaryProvider.type,
+                lastError,
+                attempt
+              );
+            }
+            break;
+          }
+          continue;
+        }
+        if (this.config.onFallback && attempt < providers.length) {
+          const nextProvider = providers[attempt];
+          if (nextProvider) {
+            await this.notifyFallback(
+              operation,
+              primaryProvider.type,
+              nextProvider.type,
+              lastError,
+              attempt,
+              providers.length
+            );
+          }
+        }
+      }
+    }
+    throw new BillingError(
+      `All providers failed for ${operation}: ${lastError?.message}`,
+      "ALL_PROVIDERS_FAILED",
+      primaryProvider.type,
+      lastError
+    );
+  }
+  /**
+   * Check if fallback is allowed for operation
+   */
+  canFallback(operation) {
+    if (!this.config.enabled) {
+      return false;
+    }
+    return this.config.allowedOperations.includes(operation);
+  }
+  /**
+   * Check if error is retryable
+   */
+  isRetryableError(error) {
+    const errorCode = error.code;
+    const errorMessage = error.message;
+    for (const retryable of this.config.retryableErrors) {
+      if (errorCode === retryable) return true;
+      if (errorMessage.includes(retryable)) return true;
+    }
+    return false;
+  }
+  /**
+   * Notify fallback callback
+   */
+  async notifyFallback(operation, originalProvider, fallbackProvider, error, attempt, totalAttempts) {
+    if (!this.config.onFallback) return;
+    const context = {
+      operation,
+      originalProvider,
+      fallbackProvider,
+      error,
+      attempt,
+      totalAttempts,
+      allFailed: false
+    };
+    try {
+      await this.config.onFallback(context);
+    } catch (callbackError) {
+      this.logger?.error("Fallback callback failed", {
+        error: callbackError instanceof Error ? callbackError.message : String(callbackError)
+      });
+    }
+  }
+  /**
+   * Notify all failed callback
+   */
+  async notifyAllFailed(operation, originalProvider, error, totalAttempts) {
+    if (!this.config.onAllFailed) return;
+    const context = {
+      operation,
+      originalProvider,
+      // fallbackProvider is omitted when all failed (undefined not allowed in type)
+      error,
+      attempt: totalAttempts,
+      totalAttempts,
+      allFailed: true
+    };
+    try {
+      await this.config.onAllFailed(context);
+    } catch (callbackError) {
+      this.logger?.error("All-failed callback failed", {
+        error: callbackError instanceof Error ? callbackError.message : String(callbackError)
+      });
+    }
+  }
+};
+function createDisabledFallback() {
+  return new FallbackExecutor({ enabled: false });
+}
+function createFallbackExecutor(config, logger) {
+  return new FallbackExecutor(config, logger);
+}
+
+// src/billing/billing-service.ts
+var consoleLogger = {
+  debug: (msg, ctx) => console.debug(`[Billing] ${msg}`, ctx ?? ""),
+  info: (msg, ctx) => console.info(`[Billing] ${msg}`, ctx ?? ""),
+  warn: (msg, ctx) => console.warn(`[Billing] ${msg}`, ctx ?? ""),
+  error: (msg, ctx) => console.error(`[Billing] ${msg}`, ctx ?? "")
+};
+var nullLogger = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+var BillingService = class {
+  strategy;
+  fallback;
+  webhookRegistry;
+  webhookProcessors;
+  logger;
+  tenantId;
+  debug;
+  constructor(config) {
+    this.debug = config.debug ?? false;
+    this.logger = config.logger ?? (this.debug ? consoleLogger : nullLogger);
+    this.tenantId = config.tenantId;
+    this.strategy = new ProviderStrategy(config.providers, this.logger);
+    this.fallback = config.fallback ? new FallbackExecutor(config.fallback, this.logger) : createDisabledFallback();
+    this.webhookRegistry = new WebhookHandlerRegistry();
+    this.webhookProcessors = /* @__PURE__ */ new Map();
+    for (const provider of this.strategy.getAllProviders()) {
+      const processor = new WebhookProcessor(provider, this.webhookRegistry);
+      this.webhookProcessors.set(provider.type, processor);
+    }
+    this.logger.info("BillingService initialized", {
+      providers: this.strategy.getAllProviders().map((p) => p.type),
+      regions: this.strategy.getSupportedRegions(),
+      fallbackEnabled: this.fallback.isEnabled
+    });
+  }
+  // ============================================================================
+  // High-Level API
+  // ============================================================================
+  /**
+   * Subscribe a customer to a plan
+   *
+   * This is the recommended way to handle subscriptions:
+   * 1. Creates or retrieves customer
+   * 2. Selects provider based on region
+   * 3. Creates checkout session
+   * 4. Returns checkout URL for redirect
+   *
+   * @example
+   * ```typescript
+   * const { checkoutUrl } = await billing.subscribe({
+   *   email: "user@example.com",
+   *   planId: "price_monthly",
+   *   successUrl: "https://app.com/success",
+   *   cancelUrl: "https://app.com/cancel",
+   *   countryCode: "TR",
+   * });
+   * redirect(checkoutUrl);
+   * ```
+   */
+  async subscribe(options) {
+    const context = {
+      email: options.email,
+      countryCode: options.countryCode,
+      customerId: options.customerId
+    };
+    const selection = await this.strategy.selectProvider(
+      context,
+      options.forceProvider
+    );
+    this.logger.info("Starting subscription", {
+      email: options.email,
+      planId: options.planId,
+      provider: selection.type,
+      region: selection.region
+    });
+    let customerId = options.customerId;
+    if (!customerId) {
+      const customer = await this.executeWithFallback(
+        "createCustomer",
+        selection,
+        async (provider) => {
+          return provider.createCustomer({
+            email: options.email,
+            name: options.name,
+            metadata: {
+              ...options.metadata,
+              region: selection.region,
+              ...this.tenantId && { tenantId: this.tenantId }
+            }
+          });
+        }
+      );
+      customerId = customer.id;
+    }
+    const checkout = await this.executeWithFallback(
+      "createCheckout",
+      selection,
+      async (provider) => {
+        return provider.createCheckout({
+          customerId,
+          customerEmail: options.email,
+          lineItems: [{ priceId: options.planId, quantity: 1 }],
+          successUrl: options.successUrl,
+          cancelUrl: options.cancelUrl,
+          mode: "subscription",
+          trialDays: options.trialDays,
+          metadata: {
+            ...options.metadata,
+            region: selection.region,
+            ...this.tenantId && { tenantId: this.tenantId }
+          }
+        });
+      }
+    );
+    return {
+      checkoutUrl: checkout.url,
+      sessionId: checkout.id,
+      customerId,
+      provider: selection.type,
+      region: selection.region
+    };
+  }
+  /**
+   * Cancel a subscription
+   *
+   * @example
+   * ```typescript
+   * const result = await billing.cancel({
+   *   subscriptionId: "sub_xxx",
+   *   immediate: false, // Cancel at period end
+   * });
+   * ```
+   */
+  async cancel(options) {
+    const provider = options.provider ? this.strategy.getProviderByType(options.provider) : await this.findSubscriptionProvider(options.subscriptionId);
+    if (!provider) {
+      throw new BillingError(
+        `Cannot find provider for subscription: ${options.subscriptionId}`,
+        "SUBSCRIPTION_NOT_FOUND"
+      );
+    }
+    this.logger.info("Canceling subscription", {
+      subscriptionId: options.subscriptionId,
+      provider: provider.type,
+      immediate: options.immediate
+    });
+    const subscription2 = await provider.cancelSubscription(
+      options.subscriptionId,
+      !options.immediate
+      // cancelAtPeriodEnd = !immediate
+    );
+    return {
+      subscriptionId: subscription2.id,
+      status: subscription2.status,
+      endsAt: subscription2.cancelAtPeriodEnd ? subscription2.currentPeriodEnd : /* @__PURE__ */ new Date(),
+      provider: provider.type
+    };
+  }
+  /**
+   * Get subscription(s) for a customer
+   *
+   * @example
+   * ```typescript
+   * // Get by customer ID
+   * const subs = await billing.getSubscriptions({ customerId: "cus_xxx" });
+   *
+   * // Get specific subscription
+   * const sub = await billing.getSubscription({ subscriptionId: "sub_xxx" });
+   * ```
+   */
+  async getSubscriptions(options) {
+    const results = [];
+    if (options.subscriptionId) {
+      const sub = await this.getSubscription(options);
+      if (sub) results.push(sub);
+      return results;
+    }
+    const providers = options.provider ? [this.strategy.getProviderByType(options.provider)].filter(Boolean) : this.strategy.getAllProviders();
+    for (const provider of providers) {
+      if (!provider) continue;
+      try {
+        if (options.customerId) {
+          const subs = await provider.listSubscriptions(options.customerId);
+          for (const sub of subs) {
+            results.push({ ...sub, provider: provider.type });
+          }
+        }
+      } catch (error) {
+        this.logger.warn(`Failed to get subscriptions from ${provider.type}`, {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return results;
+  }
+  /**
+   * Get a single subscription
+   */
+  async getSubscription(options) {
+    if (!options.subscriptionId) {
+      const subs = await this.getSubscriptions(options);
+      return subs[0] ?? null;
+    }
+    const providers = options.provider ? [this.strategy.getProviderByType(options.provider)].filter(Boolean) : this.strategy.getAllProviders();
+    for (const provider of providers) {
+      if (!provider) continue;
+      try {
+        const sub = await provider.getSubscription(options.subscriptionId);
+        if (sub) {
+          return { ...sub, provider: provider.type };
+        }
+      } catch {
+      }
+    }
+    return null;
+  }
+  /**
+   * Get customer by ID
+   */
+  async getCustomer(customerId, provider) {
+    const providers = provider ? [this.strategy.getProviderByType(provider)].filter(Boolean) : this.strategy.getAllProviders();
+    for (const p of providers) {
+      if (!p) continue;
+      try {
+        const customer = await p.getCustomer(customerId);
+        if (customer) {
+          return { ...customer, provider: p.type };
+        }
+      } catch {
+      }
+    }
+    return null;
+  }
+  /**
+   * Create a customer portal session
+   */
+  async createPortalSession(customerId, returnUrl, provider) {
+    const p = provider ? this.strategy.getProviderByType(provider) : await this.findCustomerProvider(customerId);
+    if (!p) {
+      throw new BillingError(
+        `Cannot find provider for customer: ${customerId}`,
+        "CUSTOMER_NOT_FOUND"
+      );
+    }
+    const session = await p.createPortalSession({ customerId, returnUrl });
+    return { url: session.url, provider: p.type };
+  }
+  // ============================================================================
+  // Provider Selection
+  // ============================================================================
+  /**
+   * Select provider for a region/context
+   */
+  async selectProvider(context, forceProvider) {
+    return this.strategy.selectProvider(context, forceProvider);
+  }
+  /**
+   * Get all configured providers
+   */
+  getProviders() {
+    return this.strategy.getAllProviders();
+  }
+  /**
+   * Get provider by type
+   */
+  getProvider(type2) {
+    return this.strategy.getProviderByType(type2);
+  }
+  /**
+   * Get supported regions
+   */
+  getSupportedRegions() {
+    return this.strategy.getSupportedRegions();
+  }
+  // ============================================================================
+  // Webhooks
+  // ============================================================================
+  /**
+   * Register webhook handler for all providers
+   *
+   * @example
+   * ```typescript
+   * billing.onWebhook("subscription.created", async (event) => {
+   *   console.log(`New subscription from ${event.provider}:`, event.data);
+   * });
+   *
+   * // Handle all events
+   * billing.onWebhook("*", async (event) => {
+   *   await saveToAuditLog(event);
+   * });
+   * ```
+   */
+  onWebhook(type2, handler) {
+    this.webhookRegistry.on(type2, handler);
+    return this;
+  }
+  /**
+   * Handle webhook request
+   *
+   * @example
+   * ```typescript
+   * app.post("/webhooks/:provider", async (c) => {
+   *   const provider = c.req.param("provider") as PaymentProviderType;
+   *   const result = await billing.handleWebhook(c.req.raw, provider);
+   *   return c.json({ received: result.success });
+   * });
+   * ```
+   */
+  async handleWebhook(request, provider) {
+    const processor = this.webhookProcessors.get(provider);
+    if (!processor) {
+      this.logger.error(`No webhook processor for provider: ${provider}`);
+      return {
+        success: false,
+        error: `Unknown provider: ${provider}`
+      };
+    }
+    return processor.process(request);
+  }
+  /**
+   * Handle raw webhook payload
+   */
+  async handleWebhookRaw(payload, signature, provider) {
+    const processor = this.webhookProcessors.get(provider);
+    if (!processor) {
+      return {
+        success: false,
+        error: `Unknown provider: ${provider}`
+      };
+    }
+    return processor.processRaw(payload, signature);
+  }
+  // ============================================================================
+  // Low-Level Provider Access
+  // ============================================================================
+  /**
+   * Execute operation on specific provider
+   *
+   * Use this for advanced operations not covered by high-level API
+   *
+   * @example
+   * ```typescript
+   * const prices = await billing.withProvider("stripe", async (provider) => {
+   *   return provider.listPrices?.("prod_xxx") ?? [];
+   * });
+   * ```
+   */
+  async withProvider(type2, operation) {
+    const provider = this.strategy.getProviderByType(type2);
+    if (!provider) {
+      throw new BillingError(
+        `Provider not configured: ${type2}`,
+        "NO_PROVIDER_CONFIGURED",
+        type2
+      );
+    }
+    return operation(provider);
+  }
+  // ============================================================================
+  // Private Helpers
+  // ============================================================================
+  /**
+   * Execute operation with fallback support
+   */
+  async executeWithFallback(operation, selection, execute) {
+    const fallbackProviders = this.strategy.getAllProviders().filter((p) => p !== selection.provider);
+    const result = await this.fallback.execute(
+      operation,
+      selection.provider,
+      fallbackProviders,
+      execute
+    );
+    if (result.usedFallback) {
+      this.logger.warn(`Operation used fallback provider`, {
+        operation,
+        original: selection.type,
+        fallback: result.provider.type
+      });
+    }
+    return result.result;
+  }
+  /**
+   * Find which provider owns a subscription
+   */
+  async findSubscriptionProvider(subscriptionId) {
+    for (const provider of this.strategy.getAllProviders()) {
+      try {
+        const sub = await provider.getSubscription(subscriptionId);
+        if (sub) return provider;
+      } catch {
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Find which provider owns a customer
+   */
+  async findCustomerProvider(customerId) {
+    for (const provider of this.strategy.getAllProviders()) {
+      try {
+        const customer = await provider.getCustomer(customerId);
+        if (customer) return provider;
+      } catch {
+      }
+    }
+    return void 0;
+  }
+};
+function createBillingService(config) {
+  return new BillingService(config);
+}
+export {
+  BillingError,
+  BillingErrorCodes,
+  BillingService,
+  FallbackExecutor,
+  ProviderStrategy,
+  createBillingService,
+  createDisabledFallback,
+  createFallbackExecutor,
+  createProviderStrategy
+};
+//# sourceMappingURL=index.js.map