@stratacommerce/stripe-connect 0.0.0-stage → 0.1.1

package/dist/facts.d.ts

@@ -0,0 +1,279 @@
+import { type ExtensionContext } from '@stratacommerce/extension-sdk';
+import { type ConnectFactReceipt } from '@stratacommerce/hub-protocol';
+export declare function createFacts(ctx: ExtensionContext): {
+    projectPending(limit?: number): Promise<number>;
+    receive(input: unknown): Promise<ConnectFactReceipt>;
+    /** The latest facts, for the admin. */
+    latest(limit?: number): Promise<({
+        status: "succeeded";
+        currency: string;
+        kind: "capture";
+        attemptId: string;
+        orderReference: string;
+        amountMinor: number;
+        scope: {
+            livemode: boolean;
+            hubEnvironmentId: string;
+            generation: number;
+            linkId: string;
+            hubOrigin: string;
+            hubAccountId: string;
+            hubStoreId: string;
+            paymentBindingId: string;
+            platformId: string;
+            stripeAccountId: string;
+            contextId: string;
+            environmentRole: "development" | "staging" | "production";
+        };
+        paymentIntentId: string;
+        factVersion: number;
+        objectId: string;
+        chargeId?: string | undefined;
+        balance?: {
+            id: string;
+            currency: string;
+            amountMinor: number;
+            feeMinor: number;
+            netMinor: number;
+        } | null | undefined;
+    } | {
+        status: "unknown" | "pending" | "requires_action" | "succeeded" | "failed" | "canceled";
+        currency: string;
+        kind: "refund";
+        operationId: string | null;
+        attemptId: string;
+        orderReference: string;
+        amountMinor: number;
+        scope: {
+            livemode: boolean;
+            hubEnvironmentId: string;
+            generation: number;
+            linkId: string;
+            hubOrigin: string;
+            hubAccountId: string;
+            hubStoreId: string;
+            paymentBindingId: string;
+            platformId: string;
+            stripeAccountId: string;
+            contextId: string;
+            environmentRole: "development" | "staging" | "production";
+        };
+        paymentIntentId: string;
+        factVersion: number;
+        objectId: string;
+    } | {
+        status: string;
+        currency: string;
+        kind: "dispute";
+        attemptId: string;
+        orderReference: string;
+        amountMinor: number;
+        scope: {
+            livemode: boolean;
+            hubEnvironmentId: string;
+            generation: number;
+            linkId: string;
+            hubOrigin: string;
+            hubAccountId: string;
+            hubStoreId: string;
+            paymentBindingId: string;
+            platformId: string;
+            stripeAccountId: string;
+            contextId: string;
+            environmentRole: "development" | "staging" | "production";
+        };
+        paymentIntentId: string;
+        factVersion: number;
+        objectId: string;
+        lostPrincipalMinor: number;
+        heldPrincipalMinor: number;
+        deadline: number | null;
+    } | {
+        currency: string;
+        kind: "application_fee";
+        attemptId: string;
+        orderReference: string;
+        amountMinor: number;
+        scope: {
+            livemode: boolean;
+            hubEnvironmentId: string;
+            generation: number;
+            linkId: string;
+            hubOrigin: string;
+            hubAccountId: string;
+            hubStoreId: string;
+            paymentBindingId: string;
+            platformId: string;
+            stripeAccountId: string;
+            contextId: string;
+            environmentRole: "development" | "staging" | "production";
+        };
+        paymentIntentId: string;
+        factVersion: number;
+        objectId: string;
+        refundedMinor: number;
+        balanceTransactionId: string | null;
+    } | {
+        currency: string;
+        kind: "fee_refund";
+        attemptId: string;
+        orderReference: string;
+        amountMinor: number;
+        scope: {
+            livemode: boolean;
+            hubEnvironmentId: string;
+            generation: number;
+            linkId: string;
+            hubOrigin: string;
+            hubAccountId: string;
+            hubStoreId: string;
+            paymentBindingId: string;
+            platformId: string;
+            stripeAccountId: string;
+            contextId: string;
+            environmentRole: "development" | "staging" | "production";
+        };
+        paymentIntentId: string;
+        factVersion: number;
+        objectId: string;
+        balanceTransactionId: string | null;
+        applicationFeeId: string;
+    })[]>;
+    /** Facts for one order, newest first: fees, disputes and refunds. */
+    forOrder(orderId: string): Promise<({
+        status: "succeeded";
+        currency: string;
+        kind: "capture";
+        attemptId: string;
+        orderReference: string;
+        amountMinor: number;
+        scope: {
+            livemode: boolean;
+            hubEnvironmentId: string;
+            generation: number;
+            linkId: string;
+            hubOrigin: string;
+            hubAccountId: string;
+            hubStoreId: string;
+            paymentBindingId: string;
+            platformId: string;
+            stripeAccountId: string;
+            contextId: string;
+            environmentRole: "development" | "staging" | "production";
+        };
+        paymentIntentId: string;
+        factVersion: number;
+        objectId: string;
+        chargeId?: string | undefined;
+        balance?: {
+            id: string;
+            currency: string;
+            amountMinor: number;
+            feeMinor: number;
+            netMinor: number;
+        } | null | undefined;
+    } | {
+        status: "unknown" | "pending" | "requires_action" | "succeeded" | "failed" | "canceled";
+        currency: string;
+        kind: "refund";
+        operationId: string | null;
+        attemptId: string;
+        orderReference: string;
+        amountMinor: number;
+        scope: {
+            livemode: boolean;
+            hubEnvironmentId: string;
+            generation: number;
+            linkId: string;
+            hubOrigin: string;
+            hubAccountId: string;
+            hubStoreId: string;
+            paymentBindingId: string;
+            platformId: string;
+            stripeAccountId: string;
+            contextId: string;
+            environmentRole: "development" | "staging" | "production";
+        };
+        paymentIntentId: string;
+        factVersion: number;
+        objectId: string;
+    } | {
+        status: string;
+        currency: string;
+        kind: "dispute";
+        attemptId: string;
+        orderReference: string;
+        amountMinor: number;
+        scope: {
+            livemode: boolean;
+            hubEnvironmentId: string;
+            generation: number;
+            linkId: string;
+            hubOrigin: string;
+            hubAccountId: string;
+            hubStoreId: string;
+            paymentBindingId: string;
+            platformId: string;
+            stripeAccountId: string;
+            contextId: string;
+            environmentRole: "development" | "staging" | "production";
+        };
+        paymentIntentId: string;
+        factVersion: number;
+        objectId: string;
+        lostPrincipalMinor: number;
+        heldPrincipalMinor: number;
+        deadline: number | null;
+    } | {
+        currency: string;
+        kind: "application_fee";
+        attemptId: string;
+        orderReference: string;
+        amountMinor: number;
+        scope: {
+            livemode: boolean;
+            hubEnvironmentId: string;
+            generation: number;
+            linkId: string;
+            hubOrigin: string;
+            hubAccountId: string;
+            hubStoreId: string;
+            paymentBindingId: string;
+            platformId: string;
+            stripeAccountId: string;
+            contextId: string;
+            environmentRole: "development" | "staging" | "production";
+        };
+        paymentIntentId: string;
+        factVersion: number;
+        objectId: string;
+        refundedMinor: number;
+        balanceTransactionId: string | null;
+    } | {
+        currency: string;
+        kind: "fee_refund";
+        attemptId: string;
+        orderReference: string;
+        amountMinor: number;
+        scope: {
+            livemode: boolean;
+            hubEnvironmentId: string;
+            generation: number;
+            linkId: string;
+            hubOrigin: string;
+            hubAccountId: string;
+            hubStoreId: string;
+            paymentBindingId: string;
+            platformId: string;
+            stripeAccountId: string;
+            contextId: string;
+            environmentRole: "development" | "staging" | "production";
+        };
+        paymentIntentId: string;
+        factVersion: number;
+        objectId: string;
+        balanceTransactionId: string | null;
+        applicationFeeId: string;
+    })[]>;
+};
+export type Facts = ReturnType<typeof createFacts>;

package/dist/facts.js

@@ -0,0 +1,116 @@
+import { createPublicKey, verify } from 'node:crypto';
+import { isDeepStrictEqual } from 'node:util';
+import { and, desc, eq, lte, sql } from 'drizzle-orm';
+import { AppError } from '@stratacommerce/extension-sdk';
+import { connectDeliverySchema, connectSignedDeliverySchema } from '@stratacommerce/hub-protocol';
+import { assertConnectLink, CONNECT_PROVIDER, connectScopeOf } from './identity.js';
+import { enrollments, financialFacts, receipts } from './schema.js';
+// Signed payment facts from the Hub. The extension accepts them only while
+// the recipient enrollment's store link is the active link and usable here,
+// and records each receipt under a share lock on that link, so a revocation
+// can't interleave.
+export function createFacts(ctx) {
+    const db = ctx.db;
+    return {
+        async projectPending(limit = 100) {
+            const pending = await db.select().from(receipts).where(and(eq(receipts.state, 'pending'), lte(receipts.nextAttemptAt, new Date())))
+                .orderBy(sql `CASE WHEN ${receipts.errorCode} IS NOT NULL THEN 2 WHEN ${receipts.fact}->>'kind' = 'capture' THEN 0 ELSE 1 END`, receipts.nextAttemptAt, receipts.createdAt, receipts.deliveryId).limit(limit);
+            let projected = 0;
+            for (const receipt of pending) {
+                try {
+                    const fact = receipt.fact;
+                    const [latest] = await db.select().from(financialFacts).where(and(eq(financialFacts.originalBindingId, receipt.originalBindingId), eq(financialFacts.kind, fact.kind), eq(financialFacts.objectId, fact.objectId)));
+                    if (latest && latest.version > fact.factVersion) {
+                        await db.update(receipts).set({ state: 'projected' }).where(eq(receipts.deliveryId, receipt.deliveryId));
+                        continue;
+                    }
+                    const attempt = await ctx.payments.attempt(fact.attemptId);
+                    if (!attempt || attempt.orderId !== fact.orderReference || attempt.provider !== CONNECT_PROVIDER || !isDeepStrictEqual(connectScopeOf(attempt.identity), fact.scope) || attempt.currency !== fact.currency && fact.kind !== 'application_fee' && fact.kind !== 'fee_refund' ||
+                        attempt.providerSessionId && attempt.providerSessionId !== fact.paymentIntentId || fact.kind === 'capture' && attempt.amountCents !== fact.amountMinor)
+                        throw new AppError('Payment fact does not match the original checkout', 'PAYMENT_FACT_IDENTITY_MISMATCH', 409);
+                    if (fact.kind === 'capture') {
+                        await ctx.payments.recordCapture({ attemptId: attempt.id, identity: attempt.identity, providerSessionId: fact.paymentIntentId, providerPaymentId: fact.paymentIntentId, amountCents: fact.amountMinor, currency: fact.currency });
+                    }
+                    else if (fact.kind === 'refund') {
+                        await ctx.payments.recordRefund({ provider: CONNECT_PROVIDER, identity: attempt.identity, version: fact.factVersion, accountId: fact.scope.stripeAccountId, refundId: fact.objectId,
+                            providerSessionId: fact.paymentIntentId, amountCents: fact.amountMinor, currency: fact.currency, status: fact.status, operationId: fact.operationId, raw: {} });
+                    }
+                    // Disputes and fee settlements remain separate financial facts; they do not change orders.
+                    await db.update(receipts).set({ state: 'projected', errorCode: null }).where(eq(receipts.deliveryId, receipt.deliveryId));
+                    projected++;
+                }
+                catch (error) {
+                    await db.update(receipts).set({ errorCode: error instanceof AppError ? error.code : 'PAYMENT_PROJECTION_FAILED', nextAttemptAt: new Date(Date.now() + 60000) }).where(eq(receipts.deliveryId, receipt.deliveryId));
+                }
+            }
+            return projected;
+        },
+        async receive(input) {
+            const envelope = connectSignedDeliverySchema.parse(input), bytes = Buffer.from(envelope.payload, 'base64url');
+            let decoded;
+            try {
+                decoded = JSON.parse(bytes.toString('utf8'));
+            }
+            catch {
+                throw new AppError('Invalid payment delivery', 'PAYMENT_DELIVERY_INVALID', 400);
+            }
+            const delivery = connectDeliverySchema.parse(decoded);
+            const [recipient] = await db.select().from(enrollments).where(eq(enrollments.id, delivery.recipient.paymentBindingId));
+            if (!recipient || !['active', 'disabled'].includes(recipient.state) || !isDeepStrictEqual(recipient.scope, delivery.recipient) || delivery.issuer !== recipient.scope.hubOrigin)
+                throw new AppError('Payment recipient does not match this connection', 'PAYMENT_DELIVERY_SCOPE_INVALID', 403);
+            const link = await ctx.hub.link();
+            assertConnectLink(recipient.scope, link, ctx.environment);
+            if (recipient.linkId !== link.linkId)
+                throw new AppError('Reconnect the recipient to Hub', 'PAYMENT_DELIVERY_SCOPE_INVALID', 403);
+            const pem = recipient.publicKeys[delivery.keyId];
+            if (!pem)
+                throw new AppError('Refresh the trusted Hub delivery keys', 'PAYMENT_DELIVERY_KEY_UNKNOWN', 503);
+            if (!verify(null, bytes, createPublicKey(pem), Buffer.from(envelope.signature, 'base64url')))
+                throw new AppError('Invalid payment signature', 'PAYMENT_DELIVERY_SIGNATURE_INVALID', 403);
+            if (!isDeepStrictEqual(delivery.fact.scope, delivery.original) || (delivery.original.paymentBindingId !== recipient.id && !recipient.recoveryBindingIds.includes(delivery.original.paymentBindingId)))
+                throw new AppError('Historical payment authority is required', 'PAYMENT_DELIVERY_SCOPE_INVALID', 403);
+            const [original] = await db.select().from(enrollments).where(eq(enrollments.id, delivery.original.paymentBindingId));
+            if (!original || !isDeepStrictEqual(original.scope, delivery.original))
+                throw new AppError('Original payment scope does not match', 'PAYMENT_DELIVERY_SCOPE_INVALID', 403);
+            const age = Date.now() - Date.parse(delivery.issuedAt);
+            if (age > 300000 || age < -60000)
+                throw new AppError('Request a fresh signed delivery', 'PAYMENT_DELIVERY_EXPIRED', 400);
+            // A revocation waits for this receipt, or this receipt sees it: core
+            // fails the transaction when the link is no longer active.
+            return ctx.hub.transaction(recipient.linkId, async (tx) => {
+                const [current] = await tx.select().from(enrollments).where(eq(enrollments.id, recipient.id)).for('update');
+                if (!current || !['active', 'disabled'].includes(current.state) || current.linkId !== recipient.linkId || !isDeepStrictEqual(current.scope, delivery.recipient) || current.publicKeys[delivery.keyId] !== pem ||
+                    delivery.original.paymentBindingId !== current.id && !current.recoveryBindingIds.includes(delivery.original.paymentBindingId))
+                    throw new AppError('Payment authorization changed before receipt', 'PAYMENT_DELIVERY_SCOPE_INVALID', 403);
+                if (Date.now() - Date.parse(delivery.issuedAt) > 300000)
+                    throw new AppError('Request a fresh signed delivery', 'PAYMENT_DELIVERY_EXPIRED', 400);
+                const [existing] = await tx.select().from(receipts).where(eq(receipts.deliveryId, delivery.deliveryId));
+                if (existing) {
+                    if (existing.originalBindingId !== original.id || existing.recipientBindingId !== recipient.id || !isDeepStrictEqual(existing.fact, delivery.fact))
+                        throw new AppError('Delivery ID already has different contents', 'PAYMENT_DELIVERY_CONFLICT', 409);
+                    return { deliveryId: delivery.deliveryId };
+                }
+                const [previous] = await tx.select().from(financialFacts).where(and(eq(financialFacts.originalBindingId, original.id), eq(financialFacts.kind, delivery.fact.kind), eq(financialFacts.objectId, delivery.fact.objectId))).for('update');
+                if (previous?.version === delivery.fact.factVersion && !isDeepStrictEqual(previous.fact, delivery.fact))
+                    throw new AppError('Payment fact version conflicts', 'PAYMENT_DELIVERY_CONFLICT', 409);
+                const stale = !!previous && previous.version >= delivery.fact.factVersion;
+                if (!stale) {
+                    if (previous)
+                        await tx.update(financialFacts).set({ version: delivery.fact.factVersion, fact: delivery.fact }).where(eq(financialFacts.id, previous.id));
+                    else
+                        await tx.insert(financialFacts).values({ originalBindingId: original.id, paymentIntentId: delivery.fact.paymentIntentId, kind: delivery.fact.kind, objectId: delivery.fact.objectId, version: delivery.fact.factVersion, fact: delivery.fact });
+                }
+                await tx.insert(receipts).values({ deliveryId: delivery.deliveryId, originalBindingId: original.id, recipientBindingId: recipient.id, fact: delivery.fact, state: stale ? 'projected' : 'pending' });
+                return { deliveryId: delivery.deliveryId };
+            });
+        },
+        /** The latest facts, for the admin. */
+        async latest(limit = 100) {
+            return (await db.select({ fact: financialFacts.fact }).from(financialFacts).orderBy(desc(financialFacts.createdAt)).limit(limit)).map((row) => row.fact);
+        },
+        /** Facts for one order, newest first: fees, disputes and refunds. */
+        async forOrder(orderId) {
+            return (await db.select({ fact: financialFacts.fact }).from(financialFacts).where(sql `${financialFacts.fact}->>'orderReference' = ${orderId}`).orderBy(desc(financialFacts.createdAt))).map((row) => row.fact);
+        },
+    };
+}

package/dist/identity.d.ts

@@ -0,0 +1,17 @@
+import { AppError, type HubLink, type PaymentIdentity, type StoreEnvironment } from '@stratacommerce/extension-sdk';
+import { type ConnectScope } from '@stratacommerce/hub-protocol';
+/** Connect's name in the payment provider registry. */
+export declare const CONNECT_PROVIDER = "stripe-connect:card";
+/**
+ * A Connect scope belongs to the store link it was enrolled through
+ * (docs/hub-store-link.md). Payment work runs only while that link is this
+ * environment's active, usable link, so a copied database refuses it. Live
+ * mode also needs STRATA_ENVIRONMENT=production.
+ */
+export declare function assertConnectLink(scope: ConnectScope, link: HubLink | null, environment: StoreEnvironment): asserts link is HubLink;
+/** Strata Hub is off for this store: STRATA_HUB_KEY isn't set on the API. */
+export declare function hubOff(): AppError;
+/** The payment identity of a Connect enrollment: its scope is the provider's details. */
+export declare function connectIdentity(enrollmentId: string, scope: ConnectScope): PaymentIdentity;
+/** The Connect scope inside a recorded identity, or an error when it isn't a Connect identity. */
+export declare function connectScopeOf(identity: PaymentIdentity): ConnectScope;

package/dist/identity.js

@@ -0,0 +1,34 @@
+import { AppError } from '@stratacommerce/extension-sdk';
+import { connectScopeSchema } from '@stratacommerce/hub-protocol';
+/** Connect's name in the payment provider registry. */
+export const CONNECT_PROVIDER = 'stripe-connect:card';
+/**
+ * A Connect scope belongs to the store link it was enrolled through
+ * (docs/hub-store-link.md). Payment work runs only while that link is this
+ * environment's active, usable link, so a copied database refuses it. Live
+ * mode also needs STRATA_ENVIRONMENT=production.
+ */
+export function assertConnectLink(scope, link, environment) {
+    if (!link)
+        throw new AppError('This store’s Hub link is missing or unusable here. Connect this environment to Strata Hub, then reconnect payments.', 'PAYMENT_LINK_UNUSABLE', 409);
+    if (scope.linkId !== link.linkId || scope.hubOrigin !== link.hubOrigin || scope.hubAccountId !== link.account.id ||
+        scope.hubStoreId !== link.store.id || scope.hubEnvironmentId !== link.environment.id)
+        throw new AppError('This payment connection belongs to another Hub link. Reconnect payments in Strata Hub.', 'PAYMENT_ENVIRONMENT_MISMATCH', 409);
+    if (scope.livemode && environment !== 'production')
+        throw new AppError('Live payments need STRATA_ENVIRONMENT=production.', 'PAYMENT_ENVIRONMENT_MISMATCH', 409);
+}
+/** Strata Hub is off for this store: STRATA_HUB_KEY isn't set on the API. */
+export function hubOff() {
+    return new AppError('Strata Hub is off for this store, so Stripe Connect payments are unavailable. Set STRATA_HUB_KEY on the API to turn it back on.', 'HUB_DISABLED', 409);
+}
+/** The payment identity of a Connect enrollment: its scope is the provider's details. */
+export function connectIdentity(enrollmentId, scope) {
+    return { provider: CONNECT_PROVIDER, accountId: scope.stripeAccountId, connectionId: enrollmentId, livemode: scope.livemode, details: scope };
+}
+/** The Connect scope inside a recorded identity, or an error when it isn't a Connect identity. */
+export function connectScopeOf(identity) {
+    const scope = connectScopeSchema.safeParse(identity.details);
+    if (identity.provider !== CONNECT_PROVIDER || !scope.success || identity.accountId !== scope.data.stripeAccountId || identity.connectionId !== scope.data.paymentBindingId || identity.livemode !== scope.data.livemode)
+        throw new AppError('Original Connect identity is required', 'PAYMENT_SCOPE_INVALID', 409);
+    return scope.data;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { CONNECT_PROVIDER, connectIdentity, connectScopeOf } from './identity.js';
+export { ConnectHubClient, ConnectPaymentProvider } from './provider.js';
+declare const _default: import("@stratacommerce/extension-sdk").ExtensionModule;
+export default _default;

package/dist/index.js

@@ -0,0 +1,30 @@
+import { defineExtension } from '@stratacommerce/extension-sdk';
+import { createEnrollments } from './enrollments.js';
+import { createFacts } from './facts.js';
+import { migrations } from './migrations.js';
+import { connectRegistration } from './provider.js';
+import { registerAdminRoutes, registerHubRoutes } from './routes.js';
+export { CONNECT_PROVIDER, connectIdentity, connectScopeOf } from './identity.js';
+export { ConnectHubClient, ConnectPaymentProvider } from './provider.js';
+// Card payments through Strata Hub's Stripe Connect platform
+// (docs/stripe-connect-operations.md). The Hub calls Stripe; this extension
+// enrolls the store, takes checkouts through the Hub and records the Hub's
+// signed payment facts.
+export default defineExtension({
+    manifest: {
+        id: 'stripe-connect',
+        name: 'Stripe Connect',
+        version: '0.1.1',
+        apiVersion: '^1.0.0',
+        category: 'payment',
+        description: 'Card payments through Strata Hub’s Stripe Connect platform. Needs a store linked to Strata Hub.',
+    },
+    migrations,
+    register(ctx) {
+        const enrollments = createEnrollments(ctx), facts = createFacts(ctx);
+        ctx.payments.register('card', connectRegistration({ ctx, enrollments, facts }));
+        registerHubRoutes(ctx, enrollments, facts);
+        registerAdminRoutes(ctx, enrollments, facts);
+        ctx.jobs.every('project-facts', 60_000, async () => { await facts.projectPending(); });
+    },
+});

package/dist/migrations.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionMigration } from '@stratacommerce/extension-sdk';
+export declare const migrations: ExtensionMigration[];

package/dist/migrations.js

@@ -0,0 +1,6 @@
+export const migrations = [
+    {
+        "name": "0000_init",
+        "sql": "CREATE SCHEMA IF NOT EXISTS \"ext_stripe_connect\";\n--> statement-breakpoint\nCREATE TABLE \"ext_stripe_connect\".\"enrollments\" (\n\t\"id\" uuid PRIMARY KEY NOT NULL,\n\t\"link_id\" uuid NOT NULL,\n\t\"scope\" jsonb NOT NULL,\n\t\"policy\" jsonb NOT NULL,\n\t\"state\" text NOT NULL,\n\t\"nonce_hash\" text NOT NULL,\n\t\"expires_at\" timestamp with time zone NOT NULL,\n\t\"token_box\" text,\n\t\"public_keys\" jsonb DEFAULT '{}'::jsonb NOT NULL,\n\t\"recovery_binding_ids\" jsonb DEFAULT '[]'::jsonb NOT NULL,\n\t\"approved_by\" uuid,\n\t\"approved_at\" timestamp with time zone,\n\t\"created_at\" timestamp with time zone DEFAULT now() NOT NULL\n);\n--> statement-breakpoint\nCREATE TABLE \"ext_stripe_connect\".\"financial_facts\" (\n\t\"id\" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,\n\t\"original_binding_id\" uuid NOT NULL,\n\t\"payment_intent_id\" text NOT NULL,\n\t\"kind\" text NOT NULL,\n\t\"object_id\" text NOT NULL,\n\t\"version\" integer NOT NULL,\n\t\"fact\" jsonb NOT NULL,\n\t\"created_at\" timestamp with time zone DEFAULT now() NOT NULL\n);\n--> statement-breakpoint\nCREATE TABLE \"ext_stripe_connect\".\"receipts\" (\n\t\"delivery_id\" uuid PRIMARY KEY NOT NULL,\n\t\"original_binding_id\" uuid NOT NULL,\n\t\"recipient_binding_id\" uuid NOT NULL,\n\t\"fact\" jsonb NOT NULL,\n\t\"state\" text DEFAULT 'pending' NOT NULL,\n\t\"error_code\" text,\n\t\"next_attempt_at\" timestamp with time zone DEFAULT now() NOT NULL,\n\t\"created_at\" timestamp with time zone DEFAULT now() NOT NULL\n);\n--> statement-breakpoint\nCREATE UNIQUE INDEX \"financial_fact_identity\" ON \"ext_stripe_connect\".\"financial_facts\" USING btree (\"original_binding_id\",\"kind\",\"object_id\");--> statement-breakpoint\nCREATE INDEX \"receipts_pending\" ON \"ext_stripe_connect\".\"receipts\" USING btree (\"state\",\"next_attempt_at\");"
+    }
+];

package/dist/provider.d.ts

@@ -0,0 +1,65 @@
+import { type CreateSessionInput, type ExtensionContext, type PaymentIdentity, type PaymentProvider, type PaymentProviderRegistration, type ProviderRefund, type RefundResult } from '@stratacommerce/extension-sdk';
+import type { Enrollments } from './enrollments.js';
+import type { Facts } from './facts.js';
+export declare class ConnectHubClient {
+    readonly origin: string;
+    private token;
+    private transport;
+    private revoked?;
+    /** `revoked` runs when the Hub no longer knows the token, as after a disconnect in the Hub. */
+    constructor(origin: string, token: string, transport?: typeof fetch, revoked?: (() => Promise<unknown>) | undefined);
+    request(path: string, body?: unknown): Promise<unknown>;
+}
+export interface ConnectServices {
+    ctx: ExtensionContext;
+    enrollments: Enrollments;
+    facts: Facts;
+}
+export declare class ConnectPaymentProvider implements PaymentProvider {
+    private services;
+    readonly identity: PaymentIdentity;
+    private recipientId;
+    private makeClient?;
+    readonly name = "stripe-connect:card";
+    readonly accountId: string;
+    private readonly scope;
+    constructor(services: ConnectServices, identity: PaymentIdentity, recipientId: string, makeClient?: (() => Promise<ConnectHubClient>) | undefined);
+    private get db();
+    private client;
+    private original;
+    private sync;
+    createSession(input: CreateSessionInput): Promise<{
+        sessionId: string;
+        accountId: string;
+        client: {
+            clientSecret: string;
+            publishableKey: string;
+            stripeAccount: string;
+            livemode: boolean;
+            contextId: string;
+        };
+    }>;
+    processRefund(input: Parameters<PaymentProvider['processRefund']>[0]): Promise<RefundResult>;
+    cancelSession(paymentIntentId: string): Promise<void>;
+    cancelAttempt(attemptId: string): Promise<void>;
+    getCapture(paymentIntentId: string): Promise<{
+        provider: string;
+        identity: {
+            provider: string;
+            accountId: string | null;
+            connectionId: string;
+            livemode: boolean;
+            details: Record<string, unknown>;
+        };
+        accountId: string;
+        providerSessionId: string;
+        providerPaymentId: string;
+        amountCents: number;
+        currency: string;
+        raw: {};
+    }>;
+    getRefunds(paymentIntentId: string): Promise<ProviderRefund[]>;
+    getRefund(refundId: string): Promise<ProviderRefund>;
+}
+/** The registration for `stripe-connect:card`. */
+export declare function connectRegistration(services: ConnectServices): PaymentProviderRegistration;