@fantastic.dev/better-stripe 0.23.0 → 0.23.1

package/src/client/connect/payoutAdoptionTestHelpers.ts

@@ -0,0 +1,253 @@
+// @vitest-environment edge-runtime
+import { convexTest } from "convex-test";
+import { makeFunctionReference } from "convex/server";
+import { vi } from "vitest";
+import type Stripe from "stripe";
+import schema from "../../component/schema.js";
+import type { Component, RunCtx } from "../helpers.js";
+import { releaseRecipientPayout } from "./payoutExecution.js";
+import { adoptRecipientPayouts } from "./payoutAdoption.js";
+const modules = import.meta.glob("../../component/**/*.*s");
+const symbol = Symbol.for("toReferencePath");
+export const component = {
+  payoutPolicy: {
+    queries: { get: { [symbol]: "betterStripe/payoutPolicy/queries/get" } },
+  },
+} as unknown as Component;
+export const scope = {
+  accountId: "acct_recipient",
+  ownerKey: "owner",
+  operationKey: "release-1",
+  currency: "usd",
+  independentLiabilities: 0,
+};
+export async function setup(amounts = [600, 400], currency = "usd") {
+  const t = convexTest(schema, modules);
+  await t.run(async (ctx) => {
+    await ctx.db.insert("payoutPolicies", {
+      accountId: scope.accountId,
+      ownerKey: scope.ownerKey,
+      mode: "stripe_managed",
+      status: "ready",
+      revision: 0,
+      operationKey: "enable",
+      country: "US",
+      thresholds: [],
+      holdDeadline: Date.now() + 86400000,
+    });
+    for (let i = 0; i < amounts.length; i++)
+      await ctx.db.insert("transfers", {
+        stripeTransferId: `tr_${i}`,
+        destinationAccountId: scope.accountId,
+        sourceChargeId: `ch_${i}`,
+        amount: amounts[i],
+        currency,
+        status: "paid",
+        role: i % 2 ? "affiliate" : "store",
+      });
+  });
+  const path = (ref: Record<symbol, string>) =>
+    ref[symbol].replace("betterStripe/", "").replace(/\/(\w+)$/, ":$1");
+  const ctx = {
+    runQuery: (ref: Record<symbol, string>, args: never) =>
+      t.query(makeFunctionReference<"query">(path(ref)), args),
+    runMutation: (ref: Record<symbol, string>, args: never) =>
+      t.mutation(makeFunctionReference<"mutation">(path(ref)), args),
+  } as unknown as RunCtx;
+  let transactions = amounts.map((amount, i) => ({
+    id: `txn_${i}`,
+    source: `py_${i}`,
+    amount,
+    fee: 0,
+    net: amount,
+    currency,
+    created: 100,
+    available_on: 200,
+    status: "available",
+    type: "payment",
+    exchange_rate: null,
+  }));
+  let payout: Record<string, unknown> | undefined;
+  const history: Record<string, unknown>[] = [];
+  const provider = {
+    accounts: {
+      listExternalAccounts: vi.fn(async () => ({
+        data: [
+          {
+            id: "ba_one",
+            object: "bank_account",
+            currency,
+            default_for_currency: true,
+          },
+        ],
+        has_more: false,
+      })),
+    },
+    transfers: {
+      retrieve: vi.fn(async (id: string) => {
+        const i = Number(id.slice(3));
+        return {
+          id,
+          destination: scope.accountId,
+          destination_payment: `py_${i}`,
+          source_transaction: `ch_${i}`,
+          amount: amounts[i],
+          currency,
+          amount_reversed: 0,
+        };
+      }),
+      listReversals: vi.fn(async () => ({ data: [], has_more: false })),
+    },
+    charges: {
+      retrieve: vi.fn(async (id: string) => {
+        const i = Number(id.slice(3));
+        return {
+          id,
+          source_transfer: `tr_${i}`,
+          amount: amounts[i],
+          currency,
+          paid: true,
+          status: "succeeded",
+          balance_transaction: `txn_${i}`,
+        };
+      }),
+    },
+    balanceTransactions: {
+      list: vi.fn(async (params: { source?: string; limit?: number }) => ({
+        data: params.source
+          ? transactions.filter((t) => t.source === params.source)
+          : transactions.slice(0, params.limit),
+        has_more: false,
+      })),
+      retrieve: vi.fn(async (id: string) =>
+        transactions.find((t) => t.id === id),
+      ),
+    },
+    balance: {
+      retrieve: vi.fn(async () => ({
+        available: [
+          {
+            currency,
+            amount: transactions
+              .filter((t) => t.status === "available")
+              .reduce((a, t) => a + t.net, 0),
+            source_types: {
+              card: transactions
+                .filter((t) => t.status === "available")
+                .reduce((a, t) => a + t.net, 0),
+            },
+          },
+        ],
+        pending: [],
+      })),
+    },
+    payouts: {
+      list: vi.fn(async () => ({
+        data: [...history].reverse(),
+        has_more: false,
+      })),
+      retrieve: vi.fn(async (id?: string) =>
+        id ? history.find((p) => p.id === id) : payout,
+      ),
+      create: vi.fn(
+        async (params: {
+          amount: number;
+          currency: string;
+          metadata: object;
+        }) => {
+          const id = history.length ? `po_${history.length + 1}` : "po_one";
+          const debitId = history.length
+            ? `txn_debit_${history.length + 1}`
+            : "txn_debit";
+          payout = {
+            id,
+            ...params,
+            status: "paid",
+            automatic: false,
+            method: "standard",
+            type: "bank_account",
+            source_type: "card",
+            destination: "ba_one",
+            created: Math.floor(Date.now() / 1000),
+            arrival_date: Math.floor(Date.now() / 1000),
+            balance_transaction: debitId,
+            failure_balance_transaction: null,
+            reversed_by: null,
+          };
+          transactions = [
+            {
+              id: debitId,
+              source: id,
+              amount: -params.amount,
+              fee: 0,
+              net: -params.amount,
+              currency,
+              created: Math.floor(Date.now() / 1000),
+              available_on: Math.floor(Date.now() / 1000),
+              status: "available",
+              type: "payout",
+              exchange_rate: null,
+            },
+            ...transactions,
+          ];
+          history.push(payout);
+          return payout;
+        },
+      ),
+    },
+  };
+  const verify = vi.fn(async () => ({
+    status: "verified" as const,
+    policy: (await t.run((ctx) => ctx.db.query("payoutPolicies").first()))!,
+  }));
+  const run = (extra = {}) =>
+    releaseRecipientPayout(
+      provider as unknown as Stripe,
+      component,
+      ctx,
+      { ...scope, currency, ...extra },
+      verify,
+    );
+  return {
+    t,
+    ctx,
+    provider,
+    verify,
+    run,
+    setTransactions: (rows: typeof transactions) => {
+      transactions = rows;
+    },
+    transactions: () => transactions,
+  };
+}
+export async function historical(currency = "usd") {
+  const amounts = [600, 400];
+  const s = await setup(amounts, currency);
+  await s.provider.payouts.create({
+    amount: 1000,
+    currency,
+    metadata: {},
+  });
+  s.provider.payouts.create.mockClear();
+  const opts = {
+    accountId: scope.accountId,
+    ownerKey: scope.ownerKey,
+    currency,
+    expectedRevision: 0,
+    payouts: [
+      {
+        stripePayoutId: "po_one",
+        allocations: [
+          { stripeTransferId: "tr_0", amount: 600 },
+          { stripeTransferId: "tr_1", amount: 400 },
+        ],
+      },
+    ],
+  };
+  const adopt = (extra = {}) =>
+    adoptRecipientPayouts(s.provider as unknown as Stripe, component, s.ctx, {
+      ...opts,
+      ...extra,
+    });
+  return { ...s, adopt, opts, amounts };
+}

package/src/client/connect/payoutReturnedAdoption.test.ts

@@ -0,0 +1,157 @@
+// @vitest-environment edge-runtime
+import { expect, it, vi } from "vitest";
+import { historical, scope } from "./payoutAdoptionTestHelpers.js";
+
+it.each([
+  ["usd", "failed", 0],
+  ["jpy", "canceled", 25],
+  ["kwd", "failed", 25],
+] as const)(
+  "adopts and replays returned %s principal with %s status and %i fee",
+  async (currency, status, fee) => {
+    const s = await historical(currency);
+    const payout = await s.provider.payouts.retrieve();
+    if (!payout) throw new Error("Missing fixture payout");
+    vi.useFakeTimers();
+    try {
+      vi.setSystemTime(Date.now() + 2000);
+      const returnedAt = Math.floor(Date.now() / 1000);
+      payout.status = status;
+      payout.failure_balance_transaction = "txn_return";
+      s.setTransactions([
+        {
+          id: "txn_return",
+          source: "po_one",
+          amount: 1000,
+          fee,
+          net: 1000 - fee,
+          currency,
+          created: returnedAt,
+          available_on: returnedAt,
+          status: "available",
+          type: status === "failed" ? "payout_failure" : "payout_cancel",
+          exchange_rate: null,
+        },
+        ...s.transactions(),
+      ]);
+      const expected = {
+        status: "adopted",
+        oldestHeldAt: returnedAt * 1000,
+        claims: [
+          { status: "returned", amount: 1000, currency, providerFee: fee },
+        ],
+      };
+      expect(await s.adopt()).toMatchObject(expected);
+      expect(await s.adopt()).toMatchObject(expected);
+      expect(
+        await s.t.run((ctx) => ctx.db.query("payoutReleaseClaims").collect()),
+      ).toHaveLength(1);
+      expect(
+        await s.t.run((ctx) =>
+          ctx.db.query("payoutSourceAllocations").collect(),
+        ),
+      ).toMatchObject([
+        { paidAmount: 0, reservedAmount: 0 },
+        { paidAmount: 0, reservedAmount: 0 },
+      ]);
+      expect(s.provider.payouts.create).not.toHaveBeenCalled();
+
+      // Add later source funding; the returned principal is payable once, net of its fee.
+      s.amounts.push(300);
+      vi.setSystemTime(Date.now() + 10000);
+      const created = Math.floor(Date.now() / 1000);
+      await s.t.run(async (ctx) => {
+        await ctx.db.insert("transfers", {
+          stripeTransferId: "tr_2",
+          destinationAccountId: scope.accountId,
+          sourceChargeId: "ch_2",
+          amount: 300,
+          currency,
+          status: "paid",
+          role: "store",
+        });
+        const policy = await ctx.db.query("payoutPolicies").first();
+        if (!policy) throw new Error("Missing fixture policy");
+        await ctx.db.patch("payoutPolicies", policy._id, {
+          mode: "custom",
+          thresholds: [{ currency, amount: 1 }],
+        });
+      });
+      s.setTransactions([
+        ...s.transactions(),
+        {
+          id: "txn_2",
+          source: "py_2",
+          amount: 300,
+          fee: 0,
+          net: 300,
+          currency,
+          created,
+          available_on: created,
+          status: "available",
+          type: "payment",
+          exchange_rate: null,
+        },
+      ]);
+      expect(await s.run()).toMatchObject({
+        status: "updated",
+        claim: { status: "paid", amount: 1300 - fee, currency },
+      });
+      expect(await s.run()).toMatchObject({
+        status: "updated",
+        claim: { status: "paid", amount: 1300 - fee, currency },
+      });
+      expect(s.provider.payouts.create).toHaveBeenCalledTimes(1);
+    } finally {
+      vi.useRealTimers();
+    }
+  },
+);
+
+it.each(["pending", "wrong_currency", "wrong_principal"] as const)(
+  "holds or rejects %s returns without importing partial history",
+  async (kind) => {
+    const s = await historical();
+    const payout = await s.provider.payouts.retrieve();
+    if (!payout) throw new Error("Missing fixture payout");
+    payout.status = "failed";
+    payout.failure_balance_transaction = "txn_return";
+    const now = Math.floor(Date.now() / 1000);
+    const amount = kind === "wrong_principal" ? 999 : 1000;
+    s.setTransactions([
+      {
+        id: "txn_return",
+        source: "po_one",
+        amount,
+        fee: 0,
+        net: amount,
+        currency: kind === "wrong_currency" ? "eur" : "usd",
+        created: now,
+        available_on: now,
+        status: kind === "pending" ? "pending" : "available",
+        type: "payout_failure",
+        exchange_rate: null,
+      },
+      ...s.transactions(),
+    ]);
+    if (kind === "wrong_principal")
+      await expect(s.adopt()).rejects.toThrow(
+        "Payout transaction receipt identity or principal does not match.",
+      );
+    else
+      expect(await s.adopt()).toMatchObject({
+        status: "held",
+        reason:
+          kind === "pending"
+            ? "return_pending"
+            : "currency_allocation_required",
+      });
+    expect(
+      await s.t.run((ctx) => ctx.db.query("payoutReleaseClaims").collect()),
+    ).toEqual([]);
+    expect(
+      await s.t.run((ctx) => ctx.db.query("payoutSourceAllocations").collect()),
+    ).toEqual([]);
+    expect(s.provider.payouts.create).not.toHaveBeenCalled();
+  },
+);