@solvapay/server 1.0.8-preview.8 → 1.0.8

package/dist/src/paywall.js

@@ -1,700 +0,0 @@
-/**
- * SolvaPay SDK - Universal Paywall Protection
- *
- * One API that works everywhere:
- * - HTTP frameworks (Fastify, Express)
- * - MCP servers
- * - Class-based and functional programming
- */
-import { withRetry, createRequestDeduplicator } from './utils';
-/**
- * Error thrown when a paywall is triggered (purchase required or usage limit exceeded).
- *
- * This error is automatically thrown by the paywall protection system when:
- * - Customer doesn't have required purchase
- * - Customer has exceeded usage limits
- * - Customer needs to upgrade their plan
- *
- * The error includes structured content with checkout URLs and metadata for
- * building custom paywall UIs.
- *
- * @example
- * ```typescript
- * import { PaywallError } from '@solvapay/server';
- *
- * try {
- *   const result = await payable.http(createTask)(req, res);
- *   return result;
- * } catch (error) {
- *   if (error instanceof PaywallError) {
- *     // Custom paywall handling
- *     return res.status(402).json({
- *       error: error.message,
- *       checkoutUrl: error.structuredContent.checkoutUrl,
- *       // Additional metadata available in error.structuredContent
- *     });
- *   }
- *   throw error;
- * }
- * ```
- *
- * @see {@link PaywallStructuredContent} for the structured content format
- * @since 1.0.0
- */
-export class PaywallError extends Error {
-    structuredContent;
-    /**
-     * Creates a new PaywallError instance.
-     *
-     * @param message - Error message
-     * @param structuredContent - Structured content with checkout URLs and metadata
-     */
-    constructor(message, structuredContent) {
-        super(message);
-        this.structuredContent = structuredContent;
-        this.name = 'PaywallError';
-    }
-}
-/** JSON body shape for HTTP adapters and MCP text content (stable fields for clients). */
-export function paywallErrorToClientPayload(error) {
-    const sc = error.structuredContent;
-    const base = {
-        success: false,
-        error: sc.kind === 'activation_required' ? 'Activation required' : 'Payment required',
-        product: sc.product,
-        checkoutUrl: sc.checkoutUrl,
-        message: sc.message,
-    };
-    if (sc.kind === 'activation_required') {
-        base.kind = 'activation_required';
-        if (sc.plans !== undefined)
-            base.plans = sc.plans;
-        if (sc.balance !== undefined)
-            base.balance = sc.balance;
-        if (sc.productDetails !== undefined)
-            base.productDetails = sc.productDetails;
-        if (sc.confirmationUrl !== undefined)
-            base.confirmationUrl = sc.confirmationUrl;
-    }
-    return base;
-}
-/**
- * Shared customer lookup deduplicator across all SolvaPay instances
- *
- * This prevents duplicate customer lookups when multiple SolvaPay instances
- * are created in the same process (e.g., in different API routes).
- *
- * Features:
- * - Deduplicates concurrent requests (multiple requests share the same promise)
- * - Caches results for 60 seconds (prevents duplicate sequential requests)
- * - Automatic cleanup of expired cache entries
- * - Memory-safe with max cache size
- */
-const sharedCustomerLookupDeduplicator = createRequestDeduplicator({
-    cacheTTL: 60000, // Cache results for 60 seconds (reduces API calls significantly)
-    maxCacheSize: 1000, // Maximum cache entries
-    cacheErrors: false, // Don't cache errors - retry on next request
-});
-/**
- * Universal SolvaPay Protection - One API for everything
- */
-export class SolvaPayPaywall {
-    apiClient;
-    customerCreationAttempts = new Set();
-    customerRefMapping = new Map();
-    debug;
-    limitsCache = new Map();
-    limitsCacheTTL;
-    constructor(apiClient, options = {}) {
-        this.apiClient = apiClient;
-        this.debug = options.debug ?? process.env.SOLVAPAY_DEBUG === 'true';
-        this.limitsCacheTTL = options.limitsCacheTTL ?? 10_000;
-    }
-    log(...args) {
-        if (this.debug) {
-            // eslint-disable-next-line no-console
-            console.log(...args);
-        }
-    }
-    resolveProduct(metadata) {
-        return metadata.product || process.env.SOLVAPAY_PRODUCT || 'default-product';
-    }
-    generateRequestId() {
-        const timestamp = Date.now();
-        const random = Math.random().toString(36).substring(2, 11);
-        return `solvapay_${timestamp}_${random}`;
-    }
-    /**
-     * Core protection method - works for both MCP and HTTP
-     */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    async protect(handler, metadata = {}, getCustomerRef) {
-        const product = this.resolveProduct(metadata);
-        const configuredPlanRef = metadata.plan?.trim();
-        const usagePlanRef = configuredPlanRef || 'unspecified';
-        const usageType = metadata.usageType || 'requests';
-        return async (args) => {
-            const startTime = Date.now();
-            const requestId = this.generateRequestId();
-            const inputCustomerRef = getCustomerRef
-                ? getCustomerRef(args)
-                : args.auth?.customer_ref || 'anonymous';
-            // Auto-create customer if needed and get the backend reference
-            // Pass inputCustomerRef as both customerRef (cache key) and externalRef (for backend lookup)
-            let backendCustomerRef;
-            // If the input ref is already a SolvaPay customer ID (starts with 'cus_'),
-            // use it directly without attempting lookup/creation by externalRef.
-            if (inputCustomerRef.startsWith('cus_')) {
-                backendCustomerRef = inputCustomerRef;
-            }
-            else {
-                // Auto-create customer if needed and get the backend reference
-                // Pass inputCustomerRef as both customerRef (cache key) and externalRef (for backend lookup)
-                backendCustomerRef = await this.ensureCustomer(inputCustomerRef, inputCustomerRef);
-            }
-            let resolvedMeterName;
-            try {
-                const limitsCacheKey = `${backendCustomerRef}:${product}:${configuredPlanRef || ''}:${usageType}`;
-                const cachedLimits = this.limitsCache.get(limitsCacheKey);
-                const now = Date.now();
-                let withinLimits;
-                let remaining;
-                let checkoutUrl;
-                let lastLimitsCheck;
-                const hasFreshCachedLimits = cachedLimits && now - cachedLimits.timestamp < this.limitsCacheTTL;
-                if (hasFreshCachedLimits) {
-                    checkoutUrl = cachedLimits.checkoutUrl;
-                    resolvedMeterName = cachedLimits.meterName;
-                    if (cachedLimits.remaining > 0) {
-                        cachedLimits.remaining--;
-                        if (cachedLimits.remaining <= 0) {
-                            this.limitsCache.delete(limitsCacheKey);
-                        }
-                        withinLimits = true;
-                        remaining = cachedLimits.remaining;
-                    }
-                    else {
-                        // A zero-remaining entry indicates we already consumed the final unit.
-                        // Block one immediate follow-up request from cache, then force re-check next time.
-                        withinLimits = false;
-                        remaining = 0;
-                        this.limitsCache.delete(limitsCacheKey);
-                    }
-                }
-                else {
-                    if (cachedLimits) {
-                        this.limitsCache.delete(limitsCacheKey);
-                    }
-                    const limitsCheck = await this.apiClient.checkLimits({
-                        customerRef: backendCustomerRef,
-                        productRef: product,
-                        ...(configuredPlanRef ? { planRef: configuredPlanRef } : {}),
-                        meterName: usageType,
-                    });
-                    lastLimitsCheck = limitsCheck;
-                    withinLimits = limitsCheck.withinLimits;
-                    remaining = limitsCheck.remaining;
-                    checkoutUrl = limitsCheck.checkoutUrl;
-                    resolvedMeterName = limitsCheck.meterName;
-                    const consumedAllowance = withinLimits && remaining > 0;
-                    if (consumedAllowance) {
-                        // checkLimits reflects pre-request allowance. Consume one unit for this in-flight request
-                        // so cached follow-up requests don't get an extra free call.
-                        remaining = Math.max(0, remaining - 1);
-                    }
-                    if (consumedAllowance) {
-                        this.limitsCache.set(limitsCacheKey, {
-                            remaining,
-                            checkoutUrl,
-                            meterName: resolvedMeterName,
-                            timestamp: now,
-                        });
-                    }
-                }
-                if (!withinLimits) {
-                    const latencyMs = Date.now() - startTime;
-                    this.trackUsage(backendCustomerRef, product, usagePlanRef, resolvedMeterName || usageType, 'paywall', requestId, latencyMs);
-                    if (lastLimitsCheck?.activationRequired) {
-                        const confirmationUrl = lastLimitsCheck.confirmationUrl;
-                        const payCheckoutUrl = confirmationUrl || lastLimitsCheck.checkoutUrl || checkoutUrl || '';
-                        throw new PaywallError('Activation required', {
-                            kind: 'activation_required',
-                            product,
-                            message: 'Product activation is required before this tool can be used.',
-                            checkoutUrl: payCheckoutUrl,
-                            confirmationUrl,
-                            plans: lastLimitsCheck.plans,
-                            balance: lastLimitsCheck.balance,
-                            productDetails: lastLimitsCheck.product,
-                        });
-                    }
-                    throw new PaywallError('Payment required', {
-                        kind: 'payment_required',
-                        product,
-                        checkoutUrl: checkoutUrl || '',
-                        message: `Purchase required. Remaining: ${remaining}`,
-                    });
-                }
-                const result = await handler(args);
-                const latencyMs = Date.now() - startTime;
-                this.trackUsage(backendCustomerRef, product, usagePlanRef, resolvedMeterName || usageType, 'success', requestId, latencyMs);
-                return result;
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    const errorType = error instanceof PaywallError ? 'PaywallError' : 'API Error';
-                    this.log(`❌ Error in paywall [${errorType}]: ${error.message}`);
-                }
-                else {
-                    this.log(`❌ Error in paywall:`, error);
-                }
-                if (!(error instanceof PaywallError)) {
-                    const latencyMs = Date.now() - startTime;
-                    this.trackUsage(backendCustomerRef, product, usagePlanRef, resolvedMeterName || usageType, 'fail', requestId, latencyMs);
-                }
-                throw error;
-            }
-        };
-    }
-    /**
-     * Ensures a customer exists in the backend, creating them if necessary.
-     * This is a public helper for testing, pre-creating customers, and internal use.
-     * Only attempts creation once per customer (idempotent).
-     * Returns the backend customer reference to use in API calls.
-     *
-     * @param customerRef - The customer reference used as a cache key (e.g., Supabase user ID)
-     * @param externalRef - Optional external reference for backend lookup (e.g., Supabase user ID)
-     *   If provided, will lookup existing customer by externalRef before creating new one.
-     *   The externalRef is stored on the SolvaPay backend for customer lookup.
-     * @param options - Optional customer details (email, name) for customer creation
-     */
-    async ensureCustomer(customerRef, externalRef, options) {
-        // Return cached mapping if exists (per-instance cache)
-        if (this.customerRefMapping.has(customerRef)) {
-            return this.customerRefMapping.get(customerRef);
-        }
-        // Skip for anonymous users
-        if (customerRef === 'anonymous') {
-            return customerRef;
-        }
-        // If customerRef is already a SolvaPay ID (starts with 'cus_'),
-        // return it directly. We cannot "ensure" (create) a customer with a specific ID,
-        // and using it as an externalRef causes issues.
-        if (customerRef.startsWith('cus_')) {
-            return customerRef;
-        }
-        // Use shared deduplicator to prevent duplicate lookups across all instances
-        // This is especially important when multiple routes call ensureCustomer concurrently
-        const cacheKey = externalRef || customerRef;
-        // Check if we have a cached result in per-instance cache first (fast path)
-        if (this.customerRefMapping.has(customerRef)) {
-            const cached = this.customerRefMapping.get(customerRef);
-            return cached;
-        }
-        // Use shared deduplicator (handles both concurrent requests and cache)
-        const backendRef = await sharedCustomerLookupDeduplicator.deduplicate(cacheKey, async () => {
-            // If externalRef is provided, try to lookup existing customer first
-            if (externalRef) {
-                try {
-                    const existingCustomer = await this.apiClient.getCustomer({ externalRef });
-                    if (existingCustomer && existingCustomer.customerRef) {
-                        const ref = existingCustomer.customerRef;
-                        // Store the mapping for future use (per-instance cache)
-                        this.customerRefMapping.set(customerRef, ref);
-                        // Also track that we've attempted creation for this externalRef to prevent duplicates
-                        this.customerCreationAttempts.add(customerRef);
-                        if (externalRef !== customerRef) {
-                            this.customerCreationAttempts.add(externalRef);
-                        }
-                        return ref;
-                    }
-                }
-                catch (error) {
-                    // 404 means customer doesn't exist yet - this is expected, continue to creation
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    if (!errorMessage.includes('404') && !errorMessage.includes('not found')) {
-                        // Unexpected error - log but continue to fallback behavior
-                        this.log(`⚠️  Error looking up customer by externalRef: ${errorMessage}`);
-                    }
-                }
-            }
-            // If already attempted but no mapping, use original ref
-            // Check both customerRef and externalRef to prevent duplicates
-            if (this.customerCreationAttempts.has(customerRef) ||
-                (externalRef && this.customerCreationAttempts.has(externalRef))) {
-                // If we have a mapping, use it; otherwise return the original ref
-                const mappedRef = this.customerRefMapping.get(customerRef);
-                return mappedRef || customerRef;
-            }
-            // Skip if createCustomer is not available
-            if (!this.apiClient.createCustomer) {
-                console.warn(`⚠️  Cannot auto-create customer ${customerRef}: createCustomer method not available on API client`);
-                return customerRef;
-            }
-            this.customerCreationAttempts.add(customerRef);
-            try {
-                // Prepare customer creation params
-                // Use provided email/name, or fallback to auto-generated values
-                // Use a timestamp-based email to avoid conflicts with old orphaned records
-                const createParams = {
-                    email: options?.email || `${customerRef}-${Date.now()}@auto-created.local`,
-                    metadata: {},
-                };
-                if (options?.name) {
-                    createParams.name = options.name;
-                }
-                if (externalRef) {
-                    createParams.externalRef = externalRef;
-                }
-                const result = await this.apiClient.createCustomer(createParams);
-                // Extract the backend reference from the response
-                const resultObj = result;
-                const ref = resultObj.customerRef || resultObj.reference || customerRef;
-                // Store the mapping (per-instance cache)
-                this.customerRefMapping.set(customerRef, ref);
-                return ref;
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                if (errorMessage.includes('409') || errorMessage.includes('already exists')) {
-                    // Try to lookup by externalRef first if available
-                    if (externalRef) {
-                        try {
-                            const searchResult = await this.apiClient.getCustomer({ externalRef });
-                            if (searchResult && searchResult.customerRef) {
-                                this.customerRefMapping.set(customerRef, searchResult.customerRef);
-                                return searchResult.customerRef;
-                            }
-                        }
-                        catch (lookupError) {
-                            this.log(`⚠️ Failed to lookup existing customer by externalRef after 409:`, lookupError instanceof Error ? lookupError.message : lookupError);
-                        }
-                    }
-                    // If conflict is due to email uniqueness but externalRef lookup failed,
-                    // retry creation with a generated email while preserving externalRef.
-                    // This allows resolving stale customers created before externalRef was set.
-                    const isEmailConflict = errorMessage.includes('email') || errorMessage.includes('identifier email');
-                    if (externalRef && isEmailConflict && options?.email) {
-                        try {
-                            const byEmail = await this.apiClient.getCustomer({ email: options.email });
-                            if (byEmail && byEmail.customerRef) {
-                                this.customerRefMapping.set(customerRef, byEmail.customerRef);
-                                this.log(`⚠️ Resolved customer ${customerRef} by email after conflict; using existing customer ${byEmail.customerRef}`);
-                                return byEmail.customerRef;
-                            }
-                        }
-                        catch (emailLookupError) {
-                            this.log(`⚠️ Email lookup failed after customer conflict for ${customerRef}:`, emailLookupError instanceof Error ? emailLookupError.message : emailLookupError);
-                        }
-                        try {
-                            const retryParams = {
-                                email: `${customerRef}-${Date.now()}@auto-created.local`,
-                                externalRef,
-                                metadata: {},
-                            };
-                            if (options?.name) {
-                                retryParams.name = options.name;
-                            }
-                            const retryResult = await this.apiClient.createCustomer(retryParams);
-                            const retryObj = retryResult;
-                            const retryRef = retryObj.customerRef || retryObj.reference || customerRef;
-                            this.customerRefMapping.set(customerRef, retryRef);
-                            this.log(`⚠️ Retried customer creation for ${customerRef} with generated email after email conflict`);
-                            return retryRef;
-                        }
-                        catch (retryError) {
-                            this.log(`⚠️ Retry create customer with generated email failed for ${customerRef}:`, retryError instanceof Error ? retryError.message : retryError);
-                        }
-                    }
-                    // We have a known conflict but could not resolve the existing customer reference.
-                    // Returning the original app user ID here causes downstream 404s in payment APIs.
-                    const unresolvedMessage = errorMessage || 'Customer already exists but could not be resolved';
-                    throw new Error(`Failed to resolve existing customer for ${customerRef} after conflict: ${unresolvedMessage}. ` +
-                        'Ensure the existing customer is linked to this externalRef.');
-                }
-                this.log(`❌ Failed to auto-create customer ${customerRef}:`, error instanceof Error ? error.message : error);
-                throw error;
-            }
-        });
-        // Store the mapping in per-instance cache for faster subsequent lookups
-        if (backendRef !== customerRef) {
-            this.customerRefMapping.set(customerRef, backendRef);
-        }
-        return backendRef;
-    }
-    async trackUsage(customerRef, _productRef, _planRef, action, outcome, requestId, actionDuration) {
-        await withRetry(() => this.apiClient.trackUsage({
-            customerRef,
-            actionType: 'api_call',
-            units: 1,
-            outcome,
-            productRef: _productRef,
-            duration: actionDuration,
-            metadata: { action: action || 'api_requests', requestId },
-            timestamp: new Date().toISOString(),
-        }), {
-            maxRetries: 2,
-            initialDelay: 500,
-            shouldRetry: error => error.message.includes('Customer not found'),
-            onRetry: (_error, attempt) => {
-                console.warn(`⚠️  Customer not found (attempt ${attempt + 1}/3), retrying in 500ms...`);
-            },
-        }).catch(error => {
-            console.error('Usage tracking failed:', error);
-        });
-    }
-}
-/**
- * Universal SolvaPay factory - One API for MCP and HTTP
- */
-export function createPaywall(config) {
-    const paywall = new SolvaPayPaywall(config.apiClient);
-    // Functional approach - works for both MCP and HTTP
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    function protect(metadata = {}) {
-        return function (handler) {
-            return paywall.protect(handler, metadata);
-        };
-    }
-    // Class-based decorator
-    function Paywall(metadata = {}) {
-        return function (target, propertyKey, descriptor) {
-            // Handle both descriptor and direct property assignment
-            const method = descriptor?.value || target[propertyKey];
-            if (typeof method !== 'function') {
-                throw new Error('@Paywall decorator can only be applied to methods');
-            }
-            // Store metadata on the method
-            method._paywallMetadata = metadata;
-            if (descriptor) {
-                // Standard method decorator
-                descriptor.value = method;
-                return descriptor;
-            }
-            else {
-                // Legacy decorator or direct property
-                target[propertyKey] = method;
-                return target;
-            }
-        };
-    }
-    function createHttpHandler(methodOrMetadata, handlerOrOptions) {
-        if (typeof methodOrMetadata === 'function') {
-            const method = methodOrMetadata;
-            const metadata = method
-                ._paywallMetadata;
-            const options = handlerOrOptions;
-            if (!metadata) {
-                throw new Error('Method must be decorated with @Paywall');
-            }
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            return async (req, reply) => {
-                try {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    const extractArgs = options?.extractArgs || defaultExtractArgs;
-                    const getCustomerRef = 
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    options?.getCustomerRef ||
-                        ((req) => req.auth?.customer_ref || 'anonymous');
-                    const args = extractArgs(req);
-                    const protectedMethod = await paywall.protect(method, metadata, getCustomerRef);
-                    const result = await protectedMethod(args);
-                    const transformResponse = options?.transformResponse ||
-                        ((result) => result);
-                    return transformResponse(result, reply);
-                }
-                catch (error) {
-                    return handleHttpError(error, reply);
-                }
-            };
-        }
-        const metadata = methodOrMetadata;
-        const handler = handlerOrOptions;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return async (req, reply) => {
-            try {
-                const args = defaultExtractArgs(req);
-                const getCustomerRef = (args) => args.auth?.customer_ref || 'anonymous';
-                const protectedHandler = await paywall.protect(handler, metadata, getCustomerRef);
-                const result = await protectedHandler(args);
-                // Handle Express response (has res.status) vs Fastify (has reply.code)
-                if (reply && reply.status && typeof reply.json === 'function') {
-                    // Express: call res.json() and don't return a value
-                    reply.json(result);
-                    return;
-                }
-                // Fastify: return the result for auto-serialization
-                return result;
-            }
-            catch (error) {
-                return handleHttpError(error, reply);
-            }
-        };
-    }
-    function createMCPHandler(methodOrMetadata, handler) {
-        if (typeof methodOrMetadata === 'function') {
-            const method = methodOrMetadata;
-            const metadata = method
-                ._paywallMetadata;
-            if (!metadata) {
-                throw new Error('Method must be decorated with @Paywall');
-            }
-            const getCustomerRef = (args) => args.auth?.customer_ref || 'anonymous';
-            return paywall.protect(method, metadata, getCustomerRef);
-        }
-        const metadata = methodOrMetadata;
-        const getCustomerRef = (args) => args.auth?.customer_ref || 'anonymous';
-        return paywall.protect(handler, metadata, getCustomerRef);
-    }
-    function createNextHandler(metadata, handler, options) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return async (request, context) => {
-            try {
-                const extractArgs = options?.extractArgs || defaultExtractNextArgs;
-                const getCustomerRef = options?.getCustomerRef || defaultGetCustomerRef;
-                const transformResponse = options?.transformResponse || ((result) => result);
-                const args = await extractArgs(request, context);
-                const customerRef = await getCustomerRef(request);
-                args.auth = { customer_ref: customerRef };
-                const protectedHandler = await paywall.protect(handler, metadata, (args) => args.auth?.customer_ref || 'anonymous');
-                const result = await protectedHandler(args);
-                const transformedResult = transformResponse(result);
-                return new Response(JSON.stringify(transformedResult), {
-                    headers: { 'Content-Type': 'application/json' },
-                });
-            }
-            catch (error) {
-                return handleNextError(error);
-            }
-        };
-    }
-    return {
-        protect, // Function wrapper
-        Paywall, // Class decorator
-        createHttpHandler,
-        createMCPHandler,
-        createNextHandler, // Next.js API routes
-        ensureCustomer: (customerRef) => paywall.ensureCustomer(customerRef), // Customer creation helper
-        paywall, // Low-level access
-    };
-}
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function defaultExtractArgs(req) {
-    return {
-        ...(req.body || {}),
-        ...(req.params || {}),
-        ...(req.query || {}),
-        auth: { customer_ref: req.headers?.['x-customer-ref'] || req.auth?.customer_ref },
-    };
-}
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function handleHttpError(error, reply) {
-    if (error instanceof PaywallError) {
-        const errorResponse = paywallErrorToClientPayload(error);
-        // Express (has reply.status)
-        if (reply && reply.status && typeof reply.json === 'function') {
-            reply.status(402).json(errorResponse);
-            return;
-        }
-        // Fastify (has reply.code)
-        if (reply && reply.code) {
-            reply.code(402);
-        }
-        return errorResponse;
-    }
-    const errorResponse = {
-        success: false,
-        error: error instanceof Error ? error.message : 'Internal server error',
-    };
-    // Express (has reply.status)
-    if (reply && reply.status && typeof reply.json === 'function') {
-        reply.status(500).json(errorResponse);
-        return;
-    }
-    // Fastify (has reply.code)
-    if (reply && reply.code) {
-        reply.code(500);
-    }
-    return errorResponse;
-}
-// Next.js helper functions
-async function defaultExtractNextArgs(request, context) {
-    const url = new URL(request.url);
-    const query = Object.fromEntries(url.searchParams.entries());
-    // Parse request body if present
-    let body = {};
-    try {
-        if (request.method !== 'GET' &&
-            request.headers.get('content-type')?.includes('application/json')) {
-            body = await request.json();
-        }
-    }
-    catch {
-        // If parsing fails, continue with empty body
-    }
-    let routeParams = {};
-    if (context?.params) {
-        const params = context.params;
-        if (typeof params === 'object' && params !== null && 'then' in params) {
-            routeParams = (await params) || {};
-        }
-        else {
-            routeParams = params || {};
-        }
-    }
-    return {
-        ...body,
-        ...query,
-        ...routeParams,
-    };
-}
-async function defaultGetCustomerRef(request) {
-    // Try to get from JWT token first
-    const authHeader = request.headers.get('authorization');
-    if (authHeader && authHeader.startsWith('Bearer ')) {
-        try {
-            // Dynamic import to avoid requiring jose if not used
-            const { jwtVerify } = await import('jose');
-            const token = authHeader.substring(7);
-            const jwtSecret = new TextEncoder().encode(process.env.OAUTH_JWKS_SECRET);
-            const { payload } = await jwtVerify(token, jwtSecret, {
-                issuer: process.env.OAUTH_ISSUER,
-                audience: process.env.OAUTH_CLIENT_ID || 'test-client-id',
-            });
-            if (payload.sub) {
-                return ensureCustomerRef(payload.sub);
-            }
-        }
-        catch {
-            // Fall through to use header fallback
-        }
-    }
-    // Fallback to x-customer-ref header or default
-    const customerRef = request.headers.get('x-customer-ref') || 'demo_user';
-    return ensureCustomerRef(customerRef);
-}
-export function ensureCustomerRef(customerRef) {
-    // Ensure customer ref is properly formatted
-    // Return customer ref as-is (preserve UUIDs with hyphens, etc.)
-    if (!customerRef || customerRef === 'anonymous') {
-        return 'anonymous';
-    }
-    return customerRef;
-}
-function handleNextError(error) {
-    if (error instanceof PaywallError) {
-        return new Response(JSON.stringify(paywallErrorToClientPayload(error)), {
-            status: 402,
-            headers: { 'Content-Type': 'application/json' },
-        });
-    }
-    return new Response(JSON.stringify({
-        success: false,
-        error: error instanceof Error ? error.message : 'Internal server error',
-    }), {
-        status: 500,
-        headers: { 'Content-Type': 'application/json' },
-    });
-}
-// All exports are already defined above where each item is declared
-//# sourceMappingURL=paywall.js.map