@wopr-network/platform-core 0.1.0

package/dist/billing/stripe/setup-intent.test.js

@@ -0,0 +1,58 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { beginTestTransaction, createTestDb, endTestTransaction, rollbackTestTransaction } from "../../test/db.js";
+import { createSetupIntent } from "./setup-intent.js";
+import { TenantCustomerRepository } from "./tenant-store.js";
+function mockStripe(overrides = {}) {
+    return {
+        setupIntents: {
+            create: overrides.setupIntentCreate ??
+                vi.fn().mockResolvedValue({
+                    id: "seti_test_123",
+                    client_secret: "seti_test_123_secret_abc",
+                }),
+        },
+    };
+}
+describe("createSetupIntent", () => {
+    let pool;
+    let db;
+    let store;
+    beforeAll(async () => {
+        ({ db, pool } = await createTestDb());
+        await beginTestTransaction(pool);
+    });
+    afterAll(async () => {
+        await endTestTransaction(pool);
+        await pool.close();
+    });
+    beforeEach(async () => {
+        await rollbackTestTransaction(pool);
+        store = new TenantCustomerRepository(db);
+    });
+    it("calls stripe.setupIntents.create with correct customer ID", async () => {
+        await store.upsert({ tenant: "t-1", processorCustomerId: "cus_abc123" });
+        const stripe = mockStripe();
+        const result = await createSetupIntent(stripe, store, { tenant: "t-1" });
+        expect(result.client_secret).toBe("seti_test_123_secret_abc");
+        expect(stripe.setupIntents.create).toHaveBeenCalledWith({
+            customer: "cus_abc123",
+            metadata: { wopr_tenant: "t-1" },
+        });
+    });
+    it("throws when tenant has no Stripe customer mapping", async () => {
+        const stripe = mockStripe();
+        await expect(createSetupIntent(stripe, store, { tenant: "t-unknown" })).rejects.toThrow("No Stripe customer found for tenant: t-unknown");
+    });
+    it("omits payment_method_types to allow dynamic payment methods", async () => {
+        await store.upsert({ tenant: "t-2", processorCustomerId: "cus_def456" });
+        const setupIntentCreate = vi.fn().mockResolvedValue({
+            id: "seti_test_456",
+            client_secret: "seti_test_456_secret_xyz",
+        });
+        const stripe = mockStripe({ setupIntentCreate });
+        await createSetupIntent(stripe, store, { tenant: "t-2" });
+        const callArgs = setupIntentCreate.mock.calls[0][0];
+        expect(callArgs.payment_method_types).toBeUndefined();
+        expect(callArgs.metadata).toEqual({ wopr_tenant: "t-2" });
+    });
+});

package/dist/billing/stripe/stripe-payment-processor.d.ts

@@ -0,0 +1,49 @@
+import type Stripe from "stripe";
+import type { IAutoTopupEventLogRepository } from "../../credits/auto-topup-event-log-repository.js";
+import type { ICreditLedger } from "../../credits/credit-ledger.js";
+import { type ChargeOpts, type ChargeResult, type CheckoutOpts, type CheckoutSession, type Invoice, type IPaymentProcessor, type PortalOpts, type SavedPaymentMethod, type SetupResult, type WebhookResult } from "../payment-processor.js";
+import type { CreditPriceMap } from "./credit-prices.js";
+import type { ITenantCustomerRepository } from "./tenant-store.js";
+/** Result from the consumer-supplied webhook handler. */
+export interface StripeWebhookHandlerResult {
+    handled: boolean;
+    event_type: string;
+    tenant?: string;
+    creditedCents?: number;
+    reactivatedBots?: string[];
+    duplicate?: boolean;
+}
+export interface StripePaymentProcessorDeps {
+    stripe: Stripe;
+    tenantRepo: ITenantCustomerRepository;
+    webhookSecret: string;
+    priceMap?: CreditPriceMap;
+    creditLedger: ICreditLedger;
+    autoTopupEventLog?: IAutoTopupEventLogRepository;
+    /** Consumer-supplied webhook handler (handles domain-specific event processing). */
+    webhookHandler?: (event: Stripe.Event) => Promise<StripeWebhookHandlerResult>;
+}
+export declare class StripePaymentProcessor implements IPaymentProcessor {
+    readonly name = "stripe";
+    private readonly stripe;
+    private readonly tenantRepo;
+    private readonly webhookSecret;
+    private readonly priceMap;
+    private readonly creditLedger;
+    private readonly autoTopupEventLog?;
+    private readonly webhookHandler?;
+    constructor(deps: StripePaymentProcessorDeps);
+    createCheckoutSession(opts: CheckoutOpts): Promise<CheckoutSession>;
+    handleWebhook(payload: Buffer, signature: string): Promise<WebhookResult>;
+    supportsPortal(): boolean;
+    createPortalSession(opts: PortalOpts): Promise<{
+        url: string;
+    }>;
+    setupPaymentMethod(tenant: string): Promise<SetupResult>;
+    listPaymentMethods(tenant: string): Promise<SavedPaymentMethod[]>;
+    detachPaymentMethod(tenant: string, paymentMethodId: string): Promise<void>;
+    getCustomerEmail(tenantId: string): Promise<string>;
+    updateCustomerEmail(tenantId: string, email: string): Promise<void>;
+    listInvoices(tenantId: string): Promise<Invoice[]>;
+    charge(opts: ChargeOpts): Promise<ChargeResult>;
+}

package/dist/billing/stripe/stripe-payment-processor.js

@@ -0,0 +1,166 @@
+import { Credit } from "../../credits/credit.js";
+import { chargeAutoTopup } from "../../credits/auto-topup-charge.js";
+import { PaymentMethodOwnershipError, } from "../payment-processor.js";
+import { createCreditCheckoutSession } from "./checkout.js";
+import { createPortalSession } from "./portal.js";
+import { createSetupIntent } from "./setup-intent.js";
+export class StripePaymentProcessor {
+    name = "stripe";
+    stripe;
+    tenantRepo;
+    webhookSecret;
+    priceMap;
+    creditLedger;
+    autoTopupEventLog;
+    webhookHandler;
+    constructor(deps) {
+        this.stripe = deps.stripe;
+        this.tenantRepo = deps.tenantRepo;
+        this.webhookSecret = deps.webhookSecret;
+        this.priceMap = deps.priceMap ?? new Map();
+        this.creditLedger = deps.creditLedger;
+        this.autoTopupEventLog = deps.autoTopupEventLog;
+        this.webhookHandler = deps.webhookHandler;
+    }
+    async createCheckoutSession(opts) {
+        let priceId = opts.priceId;
+        if (!priceId) {
+            // Fall back to looking up by amount when no explicit priceId provided.
+            const amountCents = opts.amount instanceof Credit ? opts.amount.toCentsFloor() : Number(opts.amount);
+            for (const [id, point] of this.priceMap.entries()) {
+                if (point.creditCents === amountCents || point.amountCents === amountCents) {
+                    priceId = id;
+                    break;
+                }
+            }
+            if (!priceId) {
+                throw new Error(`No Stripe price tier matches amount ${amountCents} cents. Configure STRIPE_CREDIT_PRICE_* env vars.`);
+            }
+        }
+        const session = await createCreditCheckoutSession(this.stripe, this.tenantRepo, {
+            tenant: opts.tenant,
+            priceId,
+            successUrl: opts.successUrl,
+            cancelUrl: opts.cancelUrl,
+        });
+        return {
+            id: session.id,
+            url: session.url ?? "",
+        };
+    }
+    async handleWebhook(payload, signature) {
+        const event = this.stripe.webhooks.constructEvent(payload, signature, this.webhookSecret);
+        if (!this.webhookHandler) {
+            return { handled: false, eventType: event.type };
+        }
+        const result = await this.webhookHandler(event);
+        return {
+            handled: result.handled,
+            eventType: result.event_type,
+            tenant: result.tenant,
+            credited: result.creditedCents != null ? Credit.fromCents(result.creditedCents) : undefined,
+            reactivatedBots: result.reactivatedBots,
+            duplicate: result.duplicate,
+        };
+    }
+    supportsPortal() {
+        return true;
+    }
+    async createPortalSession(opts) {
+        const session = await createPortalSession(this.stripe, this.tenantRepo, {
+            tenant: opts.tenant,
+            returnUrl: opts.returnUrl,
+        });
+        return { url: session.url };
+    }
+    async setupPaymentMethod(tenant) {
+        const intent = await createSetupIntent(this.stripe, this.tenantRepo, {
+            tenant,
+        });
+        return {
+            clientSecret: intent.client_secret ?? "",
+        };
+    }
+    async listPaymentMethods(tenant) {
+        const mapping = await this.tenantRepo.getByTenant(tenant);
+        if (!mapping) {
+            return [];
+        }
+        const methods = await this.stripe.customers.listPaymentMethods(mapping.processor_customer_id);
+        return methods.data.map((pm, index) => ({
+            id: pm.id,
+            label: formatPaymentMethodLabel(pm),
+            isDefault: index === 0,
+        }));
+    }
+    async detachPaymentMethod(tenant, paymentMethodId) {
+        const mapping = await this.tenantRepo.getByTenant(tenant);
+        if (!mapping) {
+            throw new Error(`No Stripe customer found for tenant: ${tenant}`);
+        }
+        const pm = await this.stripe.paymentMethods.retrieve(paymentMethodId);
+        if (!pm.customer || pm.customer !== mapping.processor_customer_id) {
+            throw new PaymentMethodOwnershipError();
+        }
+        await this.stripe.paymentMethods.detach(paymentMethodId);
+    }
+    async getCustomerEmail(tenantId) {
+        const mapping = await this.tenantRepo.getByTenant(tenantId);
+        if (!mapping) {
+            return "";
+        }
+        const customer = await this.stripe.customers.retrieve(mapping.processor_customer_id);
+        if (customer.deleted) {
+            return "";
+        }
+        return customer.email ?? "";
+    }
+    async updateCustomerEmail(tenantId, email) {
+        const mapping = await this.tenantRepo.getByTenant(tenantId);
+        if (!mapping) {
+            throw new Error(`No Stripe customer found for tenant: ${tenantId}`);
+        }
+        await this.stripe.customers.update(mapping.processor_customer_id, { email });
+    }
+    async listInvoices(tenantId) {
+        const mapping = await this.tenantRepo.getByTenant(tenantId);
+        if (!mapping) {
+            return [];
+        }
+        const invoices = await this.stripe.invoices.list({
+            customer: mapping.processor_customer_id,
+            limit: 24,
+        });
+        return invoices.data.map((inv) => ({
+            id: inv.id,
+            date: new Date(inv.created * 1000).toISOString(),
+            amountCents: inv.amount_due,
+            status: inv.status ?? "unknown",
+            downloadUrl: inv.invoice_pdf ?? "",
+        }));
+    }
+    async charge(opts) {
+        if (!this.autoTopupEventLog) {
+            throw new Error("autoTopupEventLog is required for charge()");
+        }
+        const amount = opts.amount instanceof Credit ? opts.amount : Credit.fromCents(Number(opts.amount));
+        const result = await chargeAutoTopup({
+            stripe: this.stripe,
+            tenantRepo: this.tenantRepo,
+            creditLedger: this.creditLedger,
+            eventLogRepo: this.autoTopupEventLog,
+        }, opts.tenant, amount, opts.source);
+        return {
+            success: result.success,
+            paymentReference: result.paymentReference,
+            error: result.error,
+        };
+    }
+}
+function formatPaymentMethodLabel(pm) {
+    if (pm.card) {
+        const brand = pm.card.brand.charAt(0).toUpperCase() + pm.card.brand.slice(1);
+        return `${brand} ending ${pm.card.last4}`;
+    }
+    return `Payment method ${pm.id}`;
+}

package/dist/billing/stripe/stripe-payment-processor.test.d.ts

@@ -0,0 +1 @@
+export {};