@autumnsgrove/groveengine 0.1.0

package/dist/payments/stripe/client.d.ts

@@ -0,0 +1,231 @@
+/**
+ * Stripe API Client for Cloudflare Workers
+ *
+ * A lightweight, fetch-based Stripe client that works in edge environments.
+ * Does not depend on the Node.js Stripe SDK.
+ */
+export interface StripeClientConfig {
+    secretKey: string;
+    apiVersion?: string;
+}
+export interface StripeRequestOptions {
+    method?: 'GET' | 'POST' | 'DELETE';
+    params?: Record<string, unknown>;
+    idempotencyKey?: string;
+    stripeAccount?: string;
+}
+export interface StripeError {
+    type: string;
+    code?: string;
+    message: string;
+    param?: string;
+    decline_code?: string;
+}
+export declare class StripeAPIError extends Error {
+    readonly type: string;
+    readonly code?: string;
+    readonly param?: string;
+    readonly statusCode: number;
+    constructor(error: StripeError, statusCode: number);
+}
+/**
+ * Stripe API Client
+ *
+ * Usage:
+ * ```ts
+ * const stripe = new StripeClient({ secretKey: 'sk_test_...' });
+ * const session = await stripe.request('checkout/sessions', {
+ *   method: 'POST',
+ *   params: { mode: 'payment', ... }
+ * });
+ * ```
+ */
+export declare class StripeClient {
+    private readonly secretKey;
+    private readonly apiVersion;
+    constructor(config: StripeClientConfig);
+    /**
+     * Make a request to the Stripe API
+     */
+    request<T>(endpoint: string, options?: StripeRequestOptions): Promise<T>;
+    /**
+     * Encode parameters for application/x-www-form-urlencoded
+     * Handles nested objects and arrays
+     */
+    private encodeParams;
+    /**
+     * Append params to URLSearchParams for GET requests
+     */
+    private appendSearchParams;
+    /**
+     * Verify a webhook signature
+     *
+     * @param payload - Raw request body as string
+     * @param signature - Stripe-Signature header value
+     * @param secret - Webhook signing secret
+     * @param tolerance - Max age of event in seconds (default 300)
+     */
+    verifyWebhookSignature(payload: string, signature: string, secret: string, tolerance?: number): Promise<{
+        valid: boolean;
+        event?: unknown;
+        error?: string;
+    }>;
+    /**
+     * Constant-time string comparison to prevent timing attacks
+     */
+    private secureCompare;
+}
+export interface StripeProduct {
+    id: string;
+    object: 'product';
+    active: boolean;
+    name: string;
+    description?: string;
+    images: string[];
+    metadata: Record<string, string>;
+    default_price?: string;
+    created: number;
+    updated: number;
+}
+export interface StripePrice {
+    id: string;
+    object: 'price';
+    active: boolean;
+    product: string;
+    currency: string;
+    unit_amount: number;
+    type: 'one_time' | 'recurring';
+    recurring?: {
+        interval: 'day' | 'week' | 'month' | 'year';
+        interval_count: number;
+    };
+    metadata: Record<string, string>;
+    created: number;
+}
+export interface StripeCheckoutSession {
+    id: string;
+    object: 'checkout.session';
+    url: string;
+    status: 'open' | 'complete' | 'expired';
+    mode: 'payment' | 'subscription' | 'setup';
+    customer?: string;
+    customer_email?: string;
+    amount_total: number;
+    currency: string;
+    payment_status: 'unpaid' | 'paid' | 'no_payment_required';
+    payment_intent?: string;
+    subscription?: string;
+    metadata: Record<string, string>;
+    expires_at: number;
+    client_reference_id?: string;
+}
+export interface StripeCustomer {
+    id: string;
+    object: 'customer';
+    email?: string;
+    name?: string;
+    phone?: string;
+    address?: StripeAddress;
+    metadata: Record<string, string>;
+    created: number;
+}
+export interface StripeAddress {
+    line1?: string;
+    line2?: string;
+    city?: string;
+    state?: string;
+    postal_code?: string;
+    country?: string;
+}
+export interface StripePaymentIntent {
+    id: string;
+    object: 'payment_intent';
+    amount: number;
+    currency: string;
+    status: 'requires_payment_method' | 'requires_confirmation' | 'requires_action' | 'processing' | 'requires_capture' | 'canceled' | 'succeeded';
+    customer?: string;
+    metadata: Record<string, string>;
+    latest_charge?: string;
+    created: number;
+}
+export interface StripeSubscription {
+    id: string;
+    object: 'subscription';
+    status: 'incomplete' | 'incomplete_expired' | 'trialing' | 'active' | 'past_due' | 'canceled' | 'unpaid' | 'paused';
+    customer: string;
+    items: {
+        data: Array<{
+            id: string;
+            price: StripePrice;
+            quantity: number;
+        }>;
+    };
+    current_period_start: number;
+    current_period_end: number;
+    cancel_at_period_end: boolean;
+    canceled_at?: number;
+    trial_start?: number;
+    trial_end?: number;
+    metadata: Record<string, string>;
+    created: number;
+}
+export interface StripeRefund {
+    id: string;
+    object: 'refund';
+    amount: number;
+    currency: string;
+    status: 'pending' | 'succeeded' | 'failed' | 'canceled';
+    payment_intent?: string;
+    reason?: 'duplicate' | 'fraudulent' | 'requested_by_customer';
+    metadata: Record<string, string>;
+    created: number;
+}
+export interface StripeAccount {
+    id: string;
+    object: 'account';
+    type: 'standard' | 'express' | 'custom';
+    email?: string;
+    country?: string;
+    default_currency?: string;
+    charges_enabled: boolean;
+    payouts_enabled: boolean;
+    details_submitted: boolean;
+    capabilities?: Record<string, 'active' | 'inactive' | 'pending'>;
+    requirements?: {
+        currently_due: string[];
+        eventually_due: string[];
+        past_due: string[];
+    };
+    created: number;
+}
+export interface StripeAccountLink {
+    object: 'account_link';
+    url: string;
+    expires_at: number;
+    created: number;
+}
+export interface StripeLoginLink {
+    object: 'login_link';
+    url: string;
+    created: number;
+}
+export interface StripeBillingPortalSession {
+    id: string;
+    object: 'billing_portal.session';
+    url: string;
+    customer: string;
+    return_url: string;
+    created: number;
+}
+export interface StripeEvent {
+    id: string;
+    object: 'event';
+    type: string;
+    data: {
+        object: unknown;
+        previous_attributes?: Record<string, unknown>;
+    };
+    account?: string;
+    created: number;
+    livemode: boolean;
+}

package/dist/payments/stripe/client.js

@@ -0,0 +1,198 @@
+/**
+ * Stripe API Client for Cloudflare Workers
+ *
+ * A lightweight, fetch-based Stripe client that works in edge environments.
+ * Does not depend on the Node.js Stripe SDK.
+ */
+const STRIPE_API_VERSION = '2024-11-20.acacia';
+const STRIPE_API_BASE = 'https://api.stripe.com/v1';
+export class StripeAPIError extends Error {
+    type;
+    code;
+    param;
+    statusCode;
+    constructor(error, statusCode) {
+        super(error.message);
+        this.name = 'StripeAPIError';
+        this.type = error.type;
+        this.code = error.code;
+        this.param = error.param;
+        this.statusCode = statusCode;
+    }
+}
+/**
+ * Stripe API Client
+ *
+ * Usage:
+ * ```ts
+ * const stripe = new StripeClient({ secretKey: 'sk_test_...' });
+ * const session = await stripe.request('checkout/sessions', {
+ *   method: 'POST',
+ *   params: { mode: 'payment', ... }
+ * });
+ * ```
+ */
+export class StripeClient {
+    secretKey;
+    apiVersion;
+    constructor(config) {
+        this.secretKey = config.secretKey;
+        this.apiVersion = config.apiVersion || STRIPE_API_VERSION;
+    }
+    /**
+     * Make a request to the Stripe API
+     */
+    async request(endpoint, options = {}) {
+        const { method = 'GET', params, idempotencyKey, stripeAccount } = options;
+        const url = new URL(`${STRIPE_API_BASE}/${endpoint}`);
+        // For GET requests, append params as query string
+        if (method === 'GET' && params) {
+            this.appendSearchParams(url.searchParams, params);
+        }
+        const headers = {
+            'Authorization': `Bearer ${this.secretKey}`,
+            'Stripe-Version': this.apiVersion,
+        };
+        // For POST requests, encode params as form data
+        let body;
+        if (method === 'POST' && params) {
+            headers['Content-Type'] = 'application/x-www-form-urlencoded';
+            body = this.encodeParams(params);
+        }
+        // Idempotency key for POST requests
+        if (idempotencyKey) {
+            headers['Idempotency-Key'] = idempotencyKey;
+        }
+        // Stripe Connect: make request on behalf of connected account
+        if (stripeAccount) {
+            headers['Stripe-Account'] = stripeAccount;
+        }
+        const response = await fetch(url.toString(), {
+            method,
+            headers,
+            body,
+        });
+        const data = await response.json();
+        if (!response.ok) {
+            throw new StripeAPIError(data.error || { type: 'api_error', message: 'Unknown error' }, response.status);
+        }
+        return data;
+    }
+    /**
+     * Encode parameters for application/x-www-form-urlencoded
+     * Handles nested objects and arrays
+     */
+    encodeParams(params, prefix = '') {
+        const parts = [];
+        for (const [key, value] of Object.entries(params)) {
+            if (value === undefined || value === null)
+                continue;
+            const fullKey = prefix ? `${prefix}[${key}]` : key;
+            if (Array.isArray(value)) {
+                value.forEach((item, index) => {
+                    if (typeof item === 'object' && item !== null) {
+                        parts.push(this.encodeParams(item, `${fullKey}[${index}]`));
+                    }
+                    else {
+                        parts.push(`${encodeURIComponent(`${fullKey}[${index}]`)}=${encodeURIComponent(String(item))}`);
+                    }
+                });
+            }
+            else if (typeof value === 'object') {
+                parts.push(this.encodeParams(value, fullKey));
+            }
+            else {
+                parts.push(`${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`);
+            }
+        }
+        return parts.filter(Boolean).join('&');
+    }
+    /**
+     * Append params to URLSearchParams for GET requests
+     */
+    appendSearchParams(searchParams, params, prefix = '') {
+        for (const [key, value] of Object.entries(params)) {
+            if (value === undefined || value === null)
+                continue;
+            const fullKey = prefix ? `${prefix}[${key}]` : key;
+            if (Array.isArray(value)) {
+                value.forEach((item, index) => {
+                    if (typeof item === 'object' && item !== null) {
+                        this.appendSearchParams(searchParams, item, `${fullKey}[${index}]`);
+                    }
+                    else {
+                        searchParams.append(`${fullKey}[${index}]`, String(item));
+                    }
+                });
+            }
+            else if (typeof value === 'object') {
+                this.appendSearchParams(searchParams, value, fullKey);
+            }
+            else {
+                searchParams.append(fullKey, String(value));
+            }
+        }
+    }
+    /**
+     * Verify a webhook signature
+     *
+     * @param payload - Raw request body as string
+     * @param signature - Stripe-Signature header value
+     * @param secret - Webhook signing secret
+     * @param tolerance - Max age of event in seconds (default 300)
+     */
+    async verifyWebhookSignature(payload, signature, secret, tolerance = 300) {
+        try {
+            // Parse the signature header
+            const parts = signature.split(',').reduce((acc, part) => {
+                const [key, value] = part.split('=');
+                if (key && value) {
+                    acc[key] = value;
+                }
+                return acc;
+            }, {});
+            const timestamp = parts['t'];
+            const v1Signature = parts['v1'];
+            if (!timestamp || !v1Signature) {
+                return { valid: false, error: 'Invalid signature format' };
+            }
+            // Check timestamp tolerance
+            const timestampSeconds = parseInt(timestamp, 10);
+            const now = Math.floor(Date.now() / 1000);
+            if (now - timestampSeconds > tolerance) {
+                return { valid: false, error: 'Webhook timestamp too old' };
+            }
+            // Compute expected signature
+            const signedPayload = `${timestamp}.${payload}`;
+            const encoder = new TextEncoder();
+            const key = await crypto.subtle.importKey('raw', encoder.encode(secret), { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
+            const signatureBytes = await crypto.subtle.sign('HMAC', key, encoder.encode(signedPayload));
+            const expectedSignature = Array.from(new Uint8Array(signatureBytes))
+                .map(b => b.toString(16).padStart(2, '0'))
+                .join('');
+            // Constant-time comparison
+            if (!this.secureCompare(expectedSignature, v1Signature)) {
+                return { valid: false, error: 'Signature mismatch' };
+            }
+            // Parse and return the event
+            const event = JSON.parse(payload);
+            return { valid: true, event };
+        }
+        catch (err) {
+            return { valid: false, error: `Verification failed: ${err}` };
+        }
+    }
+    /**
+     * Constant-time string comparison to prevent timing attacks
+     */
+    secureCompare(a, b) {
+        if (a.length !== b.length) {
+            return false;
+        }
+        let result = 0;
+        for (let i = 0; i < a.length; i++) {
+            result |= a.charCodeAt(i) ^ b.charCodeAt(i);
+        }
+        return result === 0;
+    }
+}

package/dist/payments/stripe/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Stripe Payment Provider
+ *
+ * @example
+ * ```ts
+ * import { createStripeProvider } from './';
+ *
+ * const stripe = createStripeProvider({
+ *   secretKey: platform.env.STRIPE_SECRET_KEY,
+ *   webhookSecret: platform.env.STRIPE_WEBHOOK_SECRET,
+ * });
+ *
+ * const session = await stripe.createCheckoutSession(items, options, resolveVariant);
+ * ```
+ */
+export { StripeClient, StripeAPIError } from './client.js';
+export { StripeProvider, createStripeProvider } from './provider.js';
+export type { StripeClientConfig, StripeRequestOptions, StripeError, StripeProduct, StripePrice, StripeCheckoutSession, StripeCustomer, StripeAddress, StripePaymentIntent, StripeSubscription, StripeRefund, StripeAccount, StripeAccountLink, StripeLoginLink, StripeBillingPortalSession, StripeEvent, } from './client.js';

package/dist/payments/stripe/index.js

@@ -0,0 +1,17 @@
+/**
+ * Stripe Payment Provider
+ *
+ * @example
+ * ```ts
+ * import { createStripeProvider } from './';
+ *
+ * const stripe = createStripeProvider({
+ *   secretKey: platform.env.STRIPE_SECRET_KEY,
+ *   webhookSecret: platform.env.STRIPE_WEBHOOK_SECRET,
+ * });
+ *
+ * const session = await stripe.createCheckoutSession(items, options, resolveVariant);
+ * ```
+ */
+export { StripeClient, StripeAPIError } from './client.js';
+export { StripeProvider, createStripeProvider } from './provider.js';

package/dist/payments/stripe/provider.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Stripe Payment Provider Implementation
+ *
+ * Implements the PaymentProvider interface using Stripe's API.
+ * Supports Stripe Connect for marketplace functionality.
+ */
+import type { PaymentProvider, PaymentProviderConfig, ProductBase, ProductVariant, CartItem, CheckoutOptions, CheckoutSession, PaymentStatus, RefundRequest, RefundResult, Subscription, Customer, WebhookResult, ConnectAccount, ConnectOnboardingOptions, ConnectOnboardingResult } from '../types.js';
+export declare class StripeProvider implements PaymentProvider {
+    readonly name = "stripe";
+    private readonly client;
+    private readonly webhookSecret?;
+    private readonly connectWebhookSecret?;
+    constructor(config: PaymentProviderConfig);
+    syncProduct(product: ProductBase): Promise<{
+        providerProductId: string;
+    }>;
+    syncPrice(variant: ProductVariant, providerProductId: string): Promise<{
+        providerPriceId: string;
+    }>;
+    archiveProduct(providerProductId: string): Promise<void>;
+    createCheckoutSession(items: CartItem[], options: CheckoutOptions, resolveVariant: (variantId: string) => Promise<ProductVariant | null>): Promise<CheckoutSession>;
+    getCheckoutSession(sessionId: string): Promise<CheckoutSession | null>;
+    private mapCheckoutSession;
+    getPaymentStatus(providerPaymentId: string): Promise<PaymentStatus>;
+    refund(request: RefundRequest, providerPaymentId: string): Promise<RefundResult>;
+    getSubscription(providerSubscriptionId: string): Promise<Subscription | null>;
+    cancelSubscription(providerSubscriptionId: string, cancelImmediately?: boolean): Promise<void>;
+    resumeSubscription(providerSubscriptionId: string): Promise<void>;
+    private mapSubscription;
+    syncCustomer(customer: Partial<Customer>): Promise<{
+        providerCustomerId: string;
+    }>;
+    getCustomer(providerCustomerId: string): Promise<Customer | null>;
+    createBillingPortalSession(providerCustomerId: string, returnUrl: string): Promise<{
+        url: string;
+    }>;
+    handleWebhook(request: Request): Promise<WebhookResult>;
+    private mapEventType;
+    createConnectAccount(options: ConnectOnboardingOptions): Promise<ConnectOnboardingResult>;
+    getConnectAccount(providerAccountId: string): Promise<ConnectAccount | null>;
+    createConnectAccountLink(providerAccountId: string, options: Pick<ConnectOnboardingOptions, 'returnUrl' | 'refreshUrl'>): Promise<{
+        url: string;
+        expiresAt?: Date;
+    }>;
+    createConnectLoginLink(providerAccountId: string): Promise<{
+        url: string;
+    }>;
+    private mapConnectAccount;
+}
+export declare function createStripeProvider(config: PaymentProviderConfig): StripeProvider;