@fantastic.dev/better-stripe 0.28.2 → 0.28.3

package/src/component/_generated/component.ts

@@ -3639,8 +3639,10 @@ export type ComponentApi<Name extends string | undefined = string | undefined> =
               amount: number;
               confirmedFees: number;
               currency: string;
+              holdDeadline?: number;
               independentLiabilities: number;
               matureUnpaid: number;
+              minimumWaived?: boolean;
               observedAt: number;
               pendingCredits: number;
               providerAvailable: number;

package/src/component/payoutRelease/deadline.ts

@@ -0,0 +1,24 @@
+/** One operational day to retry final payouts before the country holding deadline. */
+export const finalAttemptWindowMs = 86400000;
+type Policy = { holdDeadline?: number } | null;
+export function finalAttemptStartsAt(policy: Policy): number | undefined {
+  return policy?.holdDeadline === undefined
+    ? undefined
+    : policy.holdDeadline - finalAttemptWindowMs;
+}
+export function waiveApplicationMinimum(policy: Policy, now: number): boolean {
+  const start = finalAttemptStartsAt(policy);
+  return start !== undefined && now >= start && now < policy!.holdDeadline!;
+}
+export function nextPayoutAttempt(
+  policy: Policy,
+  now: number,
+  cadence: number,
+) {
+  const start = finalAttemptStartsAt(policy);
+  if (waiveApplicationMinimum(policy, now))
+    return now + Math.min(cadence, 300000);
+  return start !== undefined && start > now
+    ? Math.min(now + cadence, start)
+    : now + cadence;
+}

package/src/component/payoutRelease/planning.ts

@@ -5,6 +5,7 @@ import type { observation } from "./observation.js";
 import { checkSnapshot, sourceById } from "./helpers.js";
 import { readFees } from "./fees.js";
 import { planRecipientPayout, type PayoutFundingSource } from "./allocation.js";
+import { waiveApplicationMinimum } from "./deadline.js";
 import { assertAllocationTotals } from "./allocationTotals.js";
 export async function readPayoutPlan(
   ctx: MutationCtx | QueryCtx,
@@ -45,13 +46,15 @@ export async function readPayoutPlan(
   }
   const fees = await readFees(ctx, args);
   await assertAllocationTotals(ctx, args, sources);
+  const minimumWaived = waiveApplicationMinimum(policy, Date.now());
   const plan = planRecipientPayout({
     currency: args.currency,
-    threshold: minimum.amount,
+    // One minor unit is the positive-money guard, not an asserted provider floor.
+    threshold: minimumWaived ? 1 : minimum.amount,
     providerAvailable: args.providerAvailable,
     independentLiabilities: args.independentLiabilities,
     confirmedFees: fees?.amount ?? 0,
     sources,
   });
-  return { plan, sources, fees, threshold: minimum.amount };
+  return { plan, sources, fees, threshold: minimum.amount, minimumWaived };
 }

package/src/component/payoutRelease/preview.ts

@@ -28,6 +28,8 @@ export const previewResult = v.union(
     currency: v.string(),
     amount: v.number(),
     threshold: v.number(),
+    minimumWaived: v.optional(v.boolean()),
+    holdDeadline: v.optional(v.number()),
     providerMinimum: v.null(),
     matureUnpaid: v.number(),
     pendingCredits: v.number(),
@@ -81,6 +83,7 @@ export async function previewPlan(
     sources: funding,
     fees,
     threshold,
+    minimumWaived,
   } = await readPayoutPlan(ctx, args, policy);
   const progress = summarizePayoutProgress(
     plan,
@@ -93,6 +96,8 @@ export async function previewPlan(
     currency: plan.currency,
     amount: plan.amount,
     threshold,
+    minimumWaived,
+    holdDeadline: policy.holdDeadline,
     providerMinimum: null,
     matureUnpaid: plan.matureUnpaid,
     pendingCredits: plan.pendingCredits,

package/src/component/payoutWorker/mutations.ts

@@ -1,5 +1,9 @@
 import { v } from "convex/values";
 import { mutation } from "../_generated/server.js";
+import {
+  finalAttemptStartsAt,
+  nextPayoutAttempt,
+} from "../payoutRelease/deadline.js";
 import { readPolicy } from "../payoutPolicy/helpers.js";
 import { claimByKey, add } from "../payoutRelease/helpers.js";
 import { balance as recoveryBalance } from "../affiliateRecovery/accounting.js";
@@ -38,7 +42,15 @@ export const begin = mutation({
         reason: "worker_busy",
         nextAttemptAt: job.leaseUntil,
       };
-    if (job && job.nextAttemptAt > now)
+    const finalStart = finalAttemptStartsAt(policy);
+    const enteringFinalWindow =
+      policy?.mode === "custom" &&
+      policy.status === "ready" &&
+      finalStart !== undefined &&
+      finalStart <= now &&
+      policy.holdDeadline! > now &&
+      (job?.lastAttemptAt ?? 0) < finalStart;
+    if (job && job.nextAttemptAt > now && !enteringFinalWindow)
       return {
         status: "held" as const,
         reason: "not_due",
@@ -65,7 +77,7 @@ export const begin = mutation({
           hasOperation: false,
           leaseUntil: undefined,
           lastReason: "policy_inactive",
-          nextAttemptAt: now + args.cadenceMs,
+          nextAttemptAt: nextPayoutAttempt(policy, now, args.cadenceMs),
         });
       return { status: "held" as const, reason: "policy_inactive" };
     }
@@ -95,7 +107,7 @@ export const begin = mutation({
           recovery.reservedRestoration > 0 ||
           recovery.activePayoutKey)
       ) {
-        const nextAttemptAt = now + args.cadenceMs;
+        const nextAttemptAt = nextPayoutAttempt(policy, now, args.cadenceMs);
         await ctx.db.patch("payoutWorkerJobs", job._id, {
           operationKey: undefined,
           hasOperation: false,
@@ -171,7 +183,11 @@ export const finish = mutation({
       operationKey: retain ? job.operationKey : undefined,
       hasOperation: retain,
       leaseUntil: undefined,
-      nextAttemptAt: Date.now() + job.cadenceMs,
+      nextAttemptAt: nextPayoutAttempt(
+        await readPolicy(ctx, args),
+        Date.now(),
+        job.cadenceMs,
+      ),
       lastReason: args.reason,
       completedGeneration: args.generation,
       completedOperationKey: args.operationKey,

package/src/react/workflows/PayoutProgress.test.tsx

@@ -241,3 +241,26 @@ it("does not display a former custom holding deadline for Stripe-managed payouts
   );
   expect(screen.queryByText(/Custom holding deadline:/)).toBeNull();
 });
+
+it("explains the deadline waiver without a minimum progress bar", () => {
+  render(
+    <PayoutProgress
+      policy={policy}
+      currency="usd"
+      preview={{
+        ...preview,
+        status: "qualified",
+        reason: undefined,
+        amount: 999,
+        minimumWaived: true,
+        holdDeadline: policy.holdDeadline,
+      }}
+    />,
+  );
+  expect(screen.getByRole("status").textContent).toContain("holding deadline");
+  expect(screen.getByRole("status").textContent).toContain(
+    "application minimum is waived",
+  );
+  expect(screen.queryByRole("progressbar")).toBeNull();
+  expect(screen.getByText("Combined payout minimum")).toBeTruthy();
+});

package/src/react/workflows/PayoutSettings.tsx

@@ -179,7 +179,10 @@ export function PayoutSettings(props: PayoutSettingsProps) {
           </label>
           <p>
             Store and affiliate earnings combine per currency. Below-minimum
-            funds remain owed. Other currency minimums are preserved.
+            funds remain owed. During the final day before the holding deadline,
+            the application minimum is waived for automatic payout attempts.
+            Stripe payout limits and balance checks still apply. Other currency
+            minimums are preserved.
           </p>
         </>
       )}

package/src/react/workflows/payout-progress-state.ts

@@ -123,24 +123,36 @@ export function payoutProgressState({
         if (
           preview.currency !== currency ||
           !configured ||
-          configured.amount !== preview.threshold
+          configured.amount !== preview.threshold ||
+          (preview.minimumWaived &&
+            preview.holdDeadline !== policy.holdDeadline)
         )
           throw new Error(
             "Payout progress currency or policy does not match the assessment.",
           );
         state.status = "assessed";
         state.reason = preview.reason ?? null;
-        state.message =
-          preview.status === "qualified"
+        state.message = preview.minimumWaived
+          ? "The holding deadline is approaching. The application minimum is waived for final automatic attempts; provider limits and all balance checks still apply. " +
+            (preview.status === "qualified"
+              ? "The worker will verify eligibility again before any payout."
+              : (reasons[preview.reason ?? ""] ??
+                "Automatic payout remains on hold. Contact support before the deadline."))
+          : preview.status === "qualified"
             ? "The combined balance qualified at the assessment time. The automatic worker will verify it again before any payout."
             : (reasons[preview.reason ?? ""] ??
               "Automatic payout is on hold. Refresh or contact support.");
         state.observedAt = preview.observedAt;
         state.accounting = preview.accounting;
-        state.progress = {
-          value: Math.max(0, Math.min(preview.threshold, preview.matureUnpaid)),
-          max: preview.threshold,
-        };
+        state.progress = preview.minimumWaived
+          ? null
+          : {
+              value: Math.max(
+                0,
+                Math.min(preview.threshold, preview.matureUnpaid),
+              ),
+              max: preview.threshold,
+            };
         const definitions = [
           ["qualifying", "Combined qualifying balance", preview.matureUnpaid],
           ["pending", "Pending settlement", preview.pendingCredits],