@fantastic.dev/better-stripe 0.7.0 → 0.8.1

package/src/client/products/products.test.ts

@@ -50,17 +50,21 @@ function makeComponent(): Component {
  * product row (for updateProduct's account lookup); `account` is the store's
  * account record; both default to null.
  */
-function makeCtx(opts: {
-  product?: { _id?: string; accountId?: string } | null;
-  account?: { statementDescriptor?: string } | null;
-  mutation?: unknown;
-} = {}) {
-  const runQuery = vi.fn().mockImplementation((refObj: Record<symbol, string>) => {
-    const path = refObj[TO_REF] ?? "";
-    if (path.includes("getAccountByStripeId")) return opts.account ?? null;
-    if (path.includes("getProductByStripeId")) return opts.product ?? null;
-    return null;
-  });
+function makeCtx(
+  opts: {
+    product?: { _id?: string; accountId?: string } | null;
+    account?: { statementDescriptor?: string } | null;
+    mutation?: unknown;
+  } = {},
+) {
+  const runQuery = vi
+    .fn()
+    .mockImplementation((refObj: Record<symbol, string>) => {
+      const path = refObj[TO_REF] ?? "";
+      if (path.includes("getAccountByStripeId")) return opts.account ?? null;
+      if (path.includes("getProductByStripeId")) return opts.product ?? null;
+      return null;
+    });
   const runMutation = vi.fn().mockResolvedValue(opts.mutation ?? undefined);
   return { runQuery, runMutation } as unknown as RunCtx & {
     runQuery: ReturnType<typeof vi.fn>;
@@ -115,7 +119,10 @@ describe("createProduct", () => {
       name: "Widget",
     });
 
-    expect(result).toEqual({ productId: "internal_1", stripeProductId: "prod_1" });
+    expect(result).toEqual({
+      productId: "internal_1",
+      stripeProductId: "prod_1",
+    });
     // active defaults to true when omitted
     expect(stripe.products.create.mock.calls[0][0].active).toBe(true);
   });
@@ -261,7 +268,9 @@ describe("createProduct — per-store statement descriptor (BTS-67)", () => {
     ).toBeUndefined();
     // The account query is never made when there's no store.
     expect(ctx.runQuery).not.toHaveBeenCalledWith(
-      expect.objectContaining({ [TO_REF]: "betterStripe/core/queries/getAccountByStripeId" }),
+      expect.objectContaining({
+        [TO_REF]: "betterStripe/core/queries/getAccountByStripeId",
+      }),
       expect.anything(),
     );
   });
@@ -312,7 +321,9 @@ describe("deactivateProduct / deleteProduct", () => {
 
 describe("read delegators", () => {
   it("getProduct returns the queried row", async () => {
-    const ctx = { runQuery: vi.fn().mockResolvedValue({ _id: "x" }) } as unknown as RunCtx;
+    const ctx = {
+      runQuery: vi.fn().mockResolvedValue({ _id: "x" }),
+    } as unknown as RunCtx;
     expect(await getProduct(makeComponent(), ctx, { productId: "x" })).toEqual({
       _id: "x",
     });
@@ -377,7 +388,13 @@ describe("syncAllProducts", () => {
     const stripe = makeStripe();
     stripe.products.list.mockReturnValue(
       asyncIterable([
-        { id: "prod_1", name: "A", description: null, active: true, metadata: {} },
+        {
+          id: "prod_1",
+          name: "A",
+          description: null,
+          active: true,
+          metadata: {},
+        },
       ]),
     );
     // two prices for the SAME product → product should be looked up once (cache)
@@ -408,7 +425,11 @@ describe("syncAllProducts", () => {
       runQuery,
     } as unknown as RunCtx;
 
-    const result = await syncAllProducts(asStripe(stripe), makeComponent(), ctx);
+    const result = await syncAllProducts(
+      asStripe(stripe),
+      makeComponent(),
+      ctx,
+    );
 
     expect(result).toEqual({
       productsSynced: 1,
@@ -441,7 +462,11 @@ describe("syncAllProducts", () => {
       runQuery: vi.fn().mockResolvedValue(null), // product not found
     } as unknown as RunCtx;
 
-    const result = await syncAllProducts(asStripe(stripe), makeComponent(), ctx);
+    const result = await syncAllProducts(
+      asStripe(stripe),
+      makeComponent(),
+      ctx,
+    );
 
     expect(result.pricesSynced).toBe(0);
     expect(result.errorCount).toBe(0); // skipped, not errored
@@ -452,8 +477,20 @@ describe("syncAllProducts", () => {
     const stripe = makeStripe();
     stripe.products.list.mockReturnValue(
       asyncIterable([
-        { id: "prod_ok", name: "A", description: null, active: true, metadata: {} },
-        { id: "prod_bad", name: "B", description: null, active: true, metadata: {} },
+        {
+          id: "prod_ok",
+          name: "A",
+          description: null,
+          active: true,
+          metadata: {},
+        },
+        {
+          id: "prod_bad",
+          name: "B",
+          description: null,
+          active: true,
+          metadata: {},
+        },
       ]),
     );
     stripe.prices.list.mockReturnValue(asyncIterable([]));
@@ -466,7 +503,11 @@ describe("syncAllProducts", () => {
       runQuery: vi.fn(),
     } as unknown as RunCtx;
 
-    const result = await syncAllProducts(asStripe(stripe), makeComponent(), ctx);
+    const result = await syncAllProducts(
+      asStripe(stripe),
+      makeComponent(),
+      ctx,
+    );
 
     expect(result.productsSynced).toBe(1);
     expect(result.errorCount).toBe(1);

package/src/client/products/products.ts

@@ -79,7 +79,9 @@ export async function createProduct(
     description: opts.description ?? undefined,
     active: opts.active ?? true,
     metadata: opts.metadata ?? undefined,
-    ...(statementDescriptor ? { statement_descriptor: statementDescriptor } : {}),
+    ...(statementDescriptor
+      ? { statement_descriptor: statementDescriptor }
+      : {}),
   });
 
   await runMutationOrThrow(

package/src/client/utils/data.test.ts

@@ -54,6 +54,8 @@ describe("clearAll", () => {
       runMutation: vi.fn().mockRejectedValue(new Error("table locked")),
     } as unknown as RunCtx;
 
-    await expect(clearAll(makeComponent(), ctx)).rejects.toThrow("table locked");
+    await expect(clearAll(makeComponent(), ctx)).rejects.toThrow(
+      "table locked",
+    );
   });
 });

package/src/client/utils/owner.test.ts

@@ -17,7 +17,10 @@ describe("resolveOwnerAccount", () => {
 
   it("falls back to customer.id for an expanded customer object", () => {
     expect(
-      resolveOwnerAccount({ customer_account: null, customer: { id: "cus_x" } }),
+      resolveOwnerAccount({
+        customer_account: null,
+        customer: { id: "cus_x" },
+      }),
     ).toBe("cus_x");
   });
 

package/src/client/utils/owner.ts

@@ -20,7 +20,11 @@ export type CustomerOwned = {
 export function resolveOwnerAccount(obj: CustomerOwned): string | null {
   if (obj.customer_account) return obj.customer_account;
   if (typeof obj.customer === "string") return obj.customer;
-  if (obj.customer && typeof obj.customer === "object" && "id" in obj.customer) {
+  if (
+    obj.customer &&
+    typeof obj.customer === "object" &&
+    "id" in obj.customer
+  ) {
     return obj.customer.id ?? null;
   }
   return null;

package/src/client/utils/stripeDashboardUrl.ts

@@ -8,10 +8,7 @@ export const StripeDashboardResourcePath = {
 } as const;
 
 export type StripeDashboardResourceType =
-  | "product"
-  | "price"
-  | "customer"
-  | "subscription";
+  "product" | "price" | "customer" | "subscription";
 
 export type StripeMode = "test" | "live";
 

package/src/client/webhooks/handler.test.ts

@@ -1,20 +1,18 @@
 // @vitest-environment edge-runtime
 /**
- * Tests for `handleWebhookRequest` — the top-level webhook entrypoint that
- * owns request validation, signature verification (routing V1 vs. V2 by event
- * type prefix), the atomic dedup ledger, the sync dispatch into the processor,
- * and the success/failure HTTP contract.
- *
- * We exercise the function DIRECTLY (not via registerRoutes), mocking the
- * Stripe SDK module so `getStripeClient()` yields a controllable client:
- *   - V1 verification → `webhooks.constructEventAsync`
- *   - V2 verification → `parseEventNotificationAsync` (NEVER constructEventAsync;
- *     stripe-node v22 rejects thin payloads passed to constructEventAsync)
- *   - V2 account re-fetch → `v2.core.accounts.retrieve`
- * Every assertion is on the response status/body and on which component
- * mutation/query refs were invoked per branch.
+ * Exercises handleWebhookRequest directly with a controllable Stripe mock.
+ * Checks V1/V2 signature routing, account re-fetch, deduplication, processor
+ * dispatch, and HTTP responses, including the invoked component references.
  */
-import { type Mock, afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  type Mock,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  vi,
+} from "vitest";
 
 import type { Component } from "../helpers.js";
 import type { RegisterRoutesConfig, WebhookActionCtx } from "../types.js";
@@ -97,7 +95,9 @@ function makeCtx(
   } as unknown as WebhookActionCtx & { runMutation: Mock; runQuery: Mock };
 }
 
-function baseConfig(over?: Partial<RegisterRoutesConfig>): RegisterRoutesConfig {
+function baseConfig(
+  over?: Partial<RegisterRoutesConfig>,
+): RegisterRoutesConfig {
   return {
     stripeSecretKey: "sk_test_123",
     webhookSecret: "whsec_test",
@@ -105,10 +105,7 @@ function baseConfig(over?: Partial<RegisterRoutesConfig>): RegisterRoutesConfig
   } as RegisterRoutesConfig;
 }
 
-function makeRequest(
-  body: unknown,
-  headers?: Record<string, string>,
-): Request {
+function makeRequest(body: unknown, headers?: Record<string, string>): Request {
   return new Request("https://example.com/stripe/webhook", {
     method: "POST",
     body: typeof body === "string" ? body : JSON.stringify(body),

package/src/client/webhooks/helpers.test.ts

@@ -122,22 +122,29 @@ describe("deriveTrialFields", () => {
 
   it("marks isTrialing true only when status is exactly 'trialing'", () => {
     expect(
-      deriveTrialFields(sub({ status: "trialing", trial_start: null, trial_end: null }))
-        .isTrialing,
+      deriveTrialFields(
+        sub({ status: "trialing", trial_start: null, trial_end: null }),
+      ).isTrialing,
     ).toBe(true);
     expect(
-      deriveTrialFields(sub({ status: "active", trial_start: null, trial_end: null }))
-        .isTrialing,
+      deriveTrialFields(
+        sub({ status: "active", trial_start: null, trial_end: null }),
+      ).isTrialing,
     ).toBe(false);
     expect(
-      deriveTrialFields(sub({ status: "past_due", trial_start: null, trial_end: null }))
-        .isTrialing,
+      deriveTrialFields(
+        sub({ status: "past_due", trial_start: null, trial_end: null }),
+      ).isTrialing,
     ).toBe(false);
   });
 
   it("converts trial_start/trial_end epochs to ISO strings", () => {
     const result = deriveTrialFields(
-      sub({ status: "trialing", trial_start: 1704067200, trial_end: 1704153600 }),
+      sub({
+        status: "trialing",
+        trial_start: 1704067200,
+        trial_end: 1704153600,
+      }),
     );
     expect(result.trialStart).toBe("2024-01-01T00:00:00.000Z");
     expect(result.trialEnd).toBe("2024-01-02T00:00:00.000Z");
@@ -154,7 +161,9 @@ describe("deriveTrialFields", () => {
 
 describe("componentRef", () => {
   it("returns the ref via direct property lookup when the path exists", () => {
-    const component = makeComponent({ paths: ["billing/queries/getSubscription"] });
+    const component = makeComponent({
+      paths: ["billing/queries/getSubscription"],
+    });
     const result = componentRef(component, "billing/queries/getSubscription");
     expect((result as any)[TO_REF]).toBe(
       "betterStripe/billing/queries/getSubscription",
@@ -172,7 +181,9 @@ describe("componentRef", () => {
 
   it("throws when neither the path nor an anchor ref is available", () => {
     const component = makeComponent({ withAnchor: false });
-    expect(() => componentRef(component, "billing/mutations/upsertInvoice")).toThrow(
+    expect(() =>
+      componentRef(component, "billing/mutations/upsertInvoice"),
+    ).toThrow(
       /Cannot resolve component path: billing\/mutations\/upsertInvoice/,
     );
   });
@@ -208,7 +219,9 @@ describe("componentRef", () => {
 
 describe("getComponentRef", () => {
   it("resolves a mapped export via direct property lookup", () => {
-    const component = makeComponent({ paths: ["billing/queries/getSubscription"] });
+    const component = makeComponent({
+      paths: ["billing/queries/getSubscription"],
+    });
     const result = getComponentRef(component, "billing", "getSubscription");
     expect((result as any)[TO_REF]).toBe(
       "betterStripe/billing/queries/getSubscription",
@@ -235,9 +248,9 @@ describe("getComponentRef", () => {
 
   it("throws when no anchor ref exists on the component", () => {
     const component = makeComponent({ withAnchor: false });
-    expect(() => getComponentRef(component, "billing", "upsertInvoice")).toThrow(
-      /Cannot resolve component ref for upsertInvoice/,
-    );
+    expect(() =>
+      getComponentRef(component, "billing", "upsertInvoice"),
+    ).toThrow(/Cannot resolve component ref for upsertInvoice/);
   });
 });
 

package/src/client/webhooks/helpers.ts

@@ -275,3 +275,26 @@ export type WebhookContext = {
   stripe: Stripe;
   webhookSecret: string;
 };
+
+/**
+ * Fee/transfer fields (BTS-11) captured off a PaymentIntent for denormalization
+ * onto the `payments` row. Returns `{}` when the charge carried no fee/transfer.
+ */
+export function feeRoutingFromPaymentIntent(pi: Stripe.PaymentIntent): {
+  chargeType?: "destination";
+  destinationAccountId?: string;
+  applicationFeeAmount?: number;
+  feeCollectedAmount?: number;
+} {
+  const dest = pi.transfer_data?.destination;
+  const destinationAccountId = typeof dest === "string" ? dest : dest?.id;
+  const fee = pi.application_fee_amount ?? undefined;
+  if (!destinationAccountId && fee === undefined) return {};
+  return {
+    chargeType: "destination",
+    ...(destinationAccountId ? { destinationAccountId } : {}),
+    ...(fee !== undefined
+      ? { applicationFeeAmount: fee, feeCollectedAmount: fee }
+      : {}),
+  };
+}

package/src/client/webhooks/hooks.test.ts

@@ -40,8 +40,7 @@ function makeWhCtx(opts?: {
   return {
     ctx: {
       runQuery: vi.fn().mockResolvedValue(opts?.doc ?? null),
-      scheduler:
-        opts?.withScheduler === false ? undefined : { runAfter },
+      scheduler: opts?.withScheduler === false ? undefined : { runAfter },
     },
     component: makeComponent(),
     stripe: {} as never,

package/src/client/webhooks/processors.test.ts

@@ -1,17 +1,7 @@
 // @vitest-environment edge-runtime
 /**
- * Tests for the webhook event processor — the field-normalization surface that
- * turns Stripe wire objects into component upsert payloads. This is the riskiest
- * correctness area in the library: a wrong default or a mishandled
- * string-vs-object union silently corrupts a row with no error. We drive each
- * event type through `processEvent` and assert the EXACT payload handed to the
- * component mutation, covering every union branch, the `userId: ""` sentinel,
- * trial derivation, the payment-status collapse, and the checkout metadata
- * merge.
- *
- * `whCtx` is built WITHOUT `config.webhooks`, so `dispatchUpsert` routes through
- * `ctx.runMutation(componentRef(component, <path>), data)` — letting us read the
- * normalized payload straight off the runMutation mock.
+ * Drives Stripe event normalization through processEvent and checks the payloads
+ * passed to component mutations, including owner, fee, and trial fields.
  */
 import type Stripe from "stripe";
 import { beforeEach, describe, expect, it, vi } from "vitest";
@@ -24,34 +14,28 @@ const TO_REF = Symbol.for("toReferencePath");
 
 /** Fake component exposing every query/mutation ref processors.ts resolves. */
 function makeComponent() {
-  const ref = (path: string) => ({ [TO_REF]: `betterStripe/${path}` });
+  const refs = (namespace: string, names: string[]) =>
+    Object.fromEntries(
+      names.map((name) => [
+        name,
+        { [TO_REF]: `betterStripe/${namespace}/${name}` },
+      ]),
+    );
   return {
     products: {
-      queries: {
-        getProductByStripeId: ref("products/queries/getProductByStripeId"),
-      },
-      mutations: {
-        upsertProduct: ref("products/mutations/upsertProduct"),
-        upsertPrice: ref("products/mutations/upsertPrice"),
-      },
+      queries: refs("products/queries", ["getProductByStripeId"]),
+      mutations: refs("products/mutations", ["upsertProduct", "upsertPrice"]),
     },
     billing: {
-      queries: {
-        getCheckoutSessionByStripeId: ref(
-          "billing/queries/getCheckoutSessionByStripeId",
-        ),
-      },
-      mutations: {
-        upsertSubscription: ref("billing/mutations/upsertSubscription"),
-        upsertCheckoutSession: ref("billing/mutations/upsertCheckoutSession"),
-        upsertInvoice: ref("billing/mutations/upsertInvoice"),
-      },
+      queries: refs("billing/queries", ["getCheckoutSessionByStripeId"]),
+      mutations: refs("billing/mutations", [
+        "upsertSubscription",
+        "upsertCheckoutSession",
+        "upsertInvoice",
+      ]),
     },
     connect: {
-      mutations: {
-        upsertPayment: ref("connect/mutations/upsertPayment"),
-        upsertPayout: ref("connect/mutations/upsertPayout"),
-      },
+      mutations: refs("connect/mutations", ["upsertPayment", "upsertPayout"]),
     },
   };
 }

package/src/client/webhooks/processors.ts

@@ -15,6 +15,7 @@ import { resolveOwnerAccount } from "../utils/owner.js";
 import {
   type WebhookContext,
   componentRef,
+  feeRoutingFromPaymentIntent,
   deriveTrialFields,
   dispatchUpsert,
   epochToIso,
@@ -297,29 +298,6 @@ async function handleCheckoutEvent(
   });
 }
 
-/**
- * Fee/transfer fields (BTS-11) captured off a PaymentIntent for denormalization
- * onto the `payments` row. Returns `{}` when the charge carried no fee/transfer.
- */
-function feeRoutingFromPaymentIntent(pi: Stripe.PaymentIntent): {
-  chargeType?: "destination";
-  destinationAccountId?: string;
-  applicationFeeAmount?: number;
-  feeCollectedAmount?: number;
-} {
-  const dest = pi.transfer_data?.destination;
-  const destinationAccountId = typeof dest === "string" ? dest : dest?.id;
-  const fee = pi.application_fee_amount ?? undefined;
-  if (!destinationAccountId && fee === undefined) return {};
-  return {
-    chargeType: "destination",
-    ...(destinationAccountId ? { destinationAccountId } : {}),
-    ...(fee !== undefined
-      ? { applicationFeeAmount: fee, feeCollectedAmount: fee }
-      : {}),
-  };
-}
-
 /**
  * Apply a fixed/tier platform fee to a subscription invoice before it finalizes
  * (BTS-51). Percent-only fees ride on the subscription's `application_fee_percent`

package/src/client/webhooks.test.ts

@@ -37,8 +37,7 @@ vi.mock("stripe", () => {
 
 // Mock httpActionGeneric to capture the raw handler
 let _capturedHandler:
-  | ((ctx: any, request: Request) => Promise<Response>)
-  | undefined;
+  ((ctx: any, request: Request) => Promise<Response>) | undefined;
 
 vi.mock("convex/server", () => ({
   httpActionGeneric: (fn: any) => fn,

package/src/component/_generated/api.ts

@@ -19,6 +19,7 @@ import type * as core_queries from "../core/queries.js";
 import type * as core_validators from "../core/validators.js";
 import type * as lib_fees from "../lib/fees.js";
 import type * as lib_idempotency from "../lib/idempotency.js";
+import type * as lib_paymentSeller from "../lib/paymentSeller.js";
 import type * as lib_reversals from "../lib/reversals.js";
 import type * as lib_stripeFactory from "../lib/stripeFactory.js";
 import type * as products_mutations from "../products/mutations.js";
@@ -47,6 +48,7 @@ const fullApi: ApiFromModules<{
   "core/validators": typeof core_validators;
   "lib/fees": typeof lib_fees;
   "lib/idempotency": typeof lib_idempotency;
+  "lib/paymentSeller": typeof lib_paymentSeller;
   "lib/reversals": typeof lib_reversals;
   "lib/stripeFactory": typeof lib_stripeFactory;
   "products/mutations": typeof products_mutations;

package/src/component/connect/mutations.ts

@@ -1,9 +1,10 @@
 import { v } from "convex/values";
 
 import type { Doc, Id } from "../_generated/dataModel";
-import { mutation, type MutationCtx } from "../_generated/server";
+import { mutation } from "../_generated/server";
 import { feeRoutingFields } from "../lib/fees";
-import { computeReversalSlices } from "../lib/reversals";
+import { computeReversalSlices, deriveReversalState } from "../lib/reversals";
+import { paymentSeller } from "../lib/paymentSeller";
 import {
   disputeFields,
   paymentStatusValidator,
@@ -12,23 +13,7 @@ import {
   transferFields,
 } from "./validators";
 
-async function paymentSeller(
-  ctx: MutationCtx,
-  stripePaymentIntentId?: string,
-): Promise<string | undefined> {
-  if (!stripePaymentIntentId) return undefined;
-  const payment = await ctx.db
-    .query("payments")
-    .withIndex("by_stripe_payment_intent_id", (q) =>
-      q.eq("stripePaymentIntentId", stripePaymentIntentId),
-    )
-    .first();
-  return payment?.destinationAccountId;
-}
-
-// =============================================================================
-// PAYMENT MUTATIONS
-// =============================================================================
+// Payment mutations
 
 export const upsertPayment = mutation({
   args: {
@@ -125,9 +110,7 @@ export const upsertPayment = mutation({
   },
 });
 
-// =============================================================================
-// PAYOUT MUTATIONS
-// =============================================================================
+// Payout mutations
 
 export const upsertPayout = mutation({
   args: {
@@ -332,30 +315,6 @@ export const upsertDispute = mutation({
 // TRANSFER MUTATIONS (ledger — BTS-12)
 // =============================================================================
 
-/**
- * Derive reversal status + transfer status from a (transfer amount, cumulative
- * reversed amount) pair. Shared by upsert and reversal so the three reversal
- * fields can never drift.
- */
-function deriveReversalState(
-  amount: number,
-  reversedAmount: number,
-  baseStatus: "pending" | "paid" | "failed" | "reversed",
-) {
-  const reversalStatus =
-    reversedAmount <= 0
-      ? undefined
-      : reversedAmount >= amount
-        ? ("fully_reversed" as const)
-        : ("partially_reversed" as const);
-  return {
-    reversedAmount: reversedAmount > 0 ? reversedAmount : undefined,
-    reversalStatus,
-    status:
-      reversalStatus === "fully_reversed" ? ("reversed" as const) : baseStatus,
-  };
-}
-
 export const upsertTransfer = mutation({
   args: transferFields,
   returns: v.null(),

package/src/component/connect/schema.ts

@@ -34,9 +34,10 @@ export const payoutsTable = defineTable(payoutFields)
  * (BTS-103). One row per payment intent; consumed and deleted by
  * `upsertPayment`'s insert branch.
  */
-export const pendingFeeRefundsTable = defineTable(
-  pendingFeeRefundFields,
-).index("by_stripe_payment_intent_id", ["stripePaymentIntentId"]);
+export const pendingFeeRefundsTable = defineTable(pendingFeeRefundFields).index(
+  "by_stripe_payment_intent_id",
+  ["stripePaymentIntentId"],
+);
 
 /**
  * Refunds. Compound status indexes follow Plan 002: filtered list queries

package/src/component/connect.test.ts

@@ -15,11 +15,7 @@ describe("connect — refunds", () => {
       stripePaymentIntentId?: string;
       accountId?: string;
       status:
-        | "pending"
-        | "requires_action"
-        | "succeeded"
-        | "failed"
-        | "canceled";
+        "pending" | "requires_action" | "succeeded" | "failed" | "canceled";
     },
   ) => {
     await t.mutation(api.connect.mutations.upsertRefund, {

package/src/component/lib/paymentSeller.ts

@@ -0,0 +1,15 @@
+import type { MutationCtx } from "../_generated/server";
+
+export async function paymentSeller(
+  ctx: MutationCtx,
+  stripePaymentIntentId?: string,
+): Promise<string | undefined> {
+  if (!stripePaymentIntentId) return undefined;
+  const payment = await ctx.db
+    .query("payments")
+    .withIndex("by_stripe_payment_intent_id", (q) =>
+      q.eq("stripePaymentIntentId", stripePaymentIntentId),
+    )
+    .first();
+  return payment?.destinationAccountId;
+}