@fantastic.dev/better-stripe 0.27.0 → 0.28.0

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

@@ -26,6 +26,12 @@ it("previews combined eligibility and source categories without creating or rese
     pendingCredits: 0,
     threshold: 1000,
     providerMinimum: null,
+    accounting: {
+      carriedForwardAmount: 0,
+      withheldAmount: 0,
+      reservedAmount: 0,
+      releasedAmount: 0,
+    },
     sources: [
       { role: "store", matureUnpaid: 600, pendingCredits: 0 },
       { role: "affiliate", matureUnpaid: 400, pendingCredits: 0 },
@@ -48,6 +54,12 @@ it("shows below-threshold carry forward and independent liabilities", async () =
     matureUnpaid: 899,
     amount: 0,
     independentLiabilities: 100,
+    accounting: {
+      carriedForwardAmount: 899,
+      withheldAmount: 100,
+      reservedAmount: 0,
+      releasedAmount: 0,
+    },
   });
   expect(s.provider.payouts.create).not.toHaveBeenCalled();
 });
@@ -71,6 +83,17 @@ it("subtracts a previously paid claim while verifying its current provider recei
     reason: "below_threshold",
     matureUnpaid: 0,
     amount: 0,
+    accounting: {
+      carriedForwardAmount: 0,
+      withheldAmount: 0,
+      reservedAmount: 0,
+      releasedAmount: 1000,
+    },
+    sources: [
+      { role: "store", releasedAmount: 600, reservedAmount: 0 },
+      { role: "affiliate", releasedAmount: 400, reservedAmount: 0 },
+      { role: "other", releasedAmount: 0, reservedAmount: 0 },
+    ],
   });
   expect(s.provider.payouts.create).toHaveBeenCalledTimes(1);
 });
@@ -145,6 +168,12 @@ it("deducts confirmed payout costs without attributing shared costs to a source
     reason: "below_threshold",
     matureUnpaid: 950,
     confirmedFees: 150,
+    accounting: {
+      carriedForwardAmount: 950,
+      withheldAmount: 150,
+      reservedAmount: 0,
+      releasedAmount: 0,
+    },
     sources: [
       { role: "store", matureUnpaid: 700 },
       { role: "affiliate", matureUnpaid: 400 },
@@ -259,6 +288,12 @@ it("preserves negative affiliate entitlement when a paid commission is refunded"
     reason: "below_threshold",
     amount: 0,
     matureUnpaid: -100,
+    accounting: {
+      carriedForwardAmount: 0,
+      withheldAmount: 0,
+      reservedAmount: 0,
+      releasedAmount: 1000,
+    },
     sources: [
       { role: "store", matureUnpaid: 0 },
       { role: "affiliate", matureUnpaid: -100 },
@@ -267,3 +302,113 @@ it("preserves negative affiliate entitlement when a paid commission is refunded"
   });
   expect(s.provider.payouts.create).toHaveBeenCalledTimes(1);
 });
+it("caps actual withholding at mature unpaid funds when obligations exceed them", async () => {
+  const s = await preview([60, 40]);
+  expect(await s.preview({ independentLiabilities: 1000 })).toMatchObject({
+    matureUnpaid: -900,
+    accounting: {
+      carriedForwardAmount: 0,
+      withheldAmount: 100,
+      reservedAmount: 0,
+      releasedAmount: 0,
+    },
+  });
+});
+it("reports unpaid funds outside the supported-rail cap as carried forward", async () => {
+  const s = await preview([1000, 500]);
+  s.provider.balance.retrieve.mockResolvedValue({
+    available: [
+      { currency: "usd", amount: 1500, source_types: { card: 1000 } },
+    ],
+    pending: [],
+  });
+  expect(await s.preview()).toMatchObject({
+    status: "qualified",
+    amount: 1000,
+    matureUnpaid: 1500,
+    accounting: {
+      carriedForwardAmount: 500,
+      withheldAmount: 0,
+      reservedAmount: 0,
+      releasedAmount: 0,
+    },
+  });
+});
+it("refuses paid allocation totals without corresponding payout claims", async () => {
+  const s = await preview();
+  await s.t.run((ctx) =>
+    ctx.db.insert("payoutSourceAllocations", {
+      accountId: scope.accountId,
+      ownerKey: scope.ownerKey,
+      currency: "usd",
+      stripeTransferId: "tr_0",
+      paidAmount: 600,
+      reservedAmount: 0,
+    }),
+  );
+  await expect(s.preview()).rejects.toThrow(/allocation totals/i);
+  expect(s.provider.payouts.create).not.toHaveBeenCalled();
+});
+it("keeps a submitted payout reserved until Stripe verifies it as paid", async () => {
+  const s = await preview();
+  const create = s.provider.payouts.create.getMockImplementation()!;
+  s.provider.payouts.create.mockImplementation(async (args) => {
+    const payout = await create(args);
+    payout.status = "pending";
+    return payout;
+  });
+  expect(await s.run()).toMatchObject({
+    status: "updated",
+    claim: { status: "submitted" },
+  });
+  expect(await s.preview()).toMatchObject({
+    matureUnpaid: 0,
+    accounting: {
+      releasedAmount: 0,
+      reservedAmount: 1000,
+      carriedForwardAmount: 0,
+      withheldAmount: 0,
+    },
+    sources: [
+      { role: "store", releasedAmount: 0, reservedAmount: 600 },
+      { role: "affiliate", releasedAmount: 0, reservedAmount: 400 },
+      { role: "other", releasedAmount: 0, reservedAmount: 0 },
+    ],
+  });
+  (await s.provider.payouts.retrieve())!.status = "paid";
+  expect(await s.preview()).toMatchObject({
+    accounting: { releasedAmount: 1000, reservedAmount: 0 },
+  });
+  expect(s.provider.payouts.create).toHaveBeenCalledTimes(1);
+});
+it("removes a verified returned payout from released totals without forfeiting the funds", async () => {
+  const s = await preview();
+  await s.run();
+  Object.assign((await s.provider.payouts.retrieve())!, {
+    status: "failed",
+    failure_balance_transaction: "txn_return",
+  });
+  s.setTransactions([
+    {
+      ...s.transactions()[0],
+      id: "txn_return",
+      source: "po_one",
+      amount: 1000,
+      net: 1000,
+      type: "payout_failure",
+    },
+    ...s.transactions(),
+  ]);
+  expect(await s.preview()).toMatchObject({
+    status: "qualified",
+    amount: 1000,
+    matureUnpaid: 1000,
+    accounting: {
+      releasedAmount: 0,
+      reservedAmount: 0,
+      carriedForwardAmount: 0,
+      withheldAmount: 0,
+    },
+  });
+  expect(s.provider.payouts.create).toHaveBeenCalledTimes(1);
+});

package/src/component/_generated/api.ts

@@ -52,12 +52,14 @@ import type * as payoutPolicy_mutations from "../payoutPolicy/mutations.js";
 import type * as payoutPolicy_queries from "../payoutPolicy/queries.js";
 import type * as payoutRelease_adoption from "../payoutRelease/adoption.js";
 import type * as payoutRelease_allocation from "../payoutRelease/allocation.js";
+import type * as payoutRelease_allocationTotals from "../payoutRelease/allocationTotals.js";
 import type * as payoutRelease_fees from "../payoutRelease/fees.js";
 import type * as payoutRelease_helpers from "../payoutRelease/helpers.js";
 import type * as payoutRelease_mutations from "../payoutRelease/mutations.js";
 import type * as payoutRelease_observation from "../payoutRelease/observation.js";
 import type * as payoutRelease_planning from "../payoutRelease/planning.js";
 import type * as payoutRelease_preview from "../payoutRelease/preview.js";
+import type * as payoutRelease_progress from "../payoutRelease/progress.js";
 import type * as payoutRelease_queries from "../payoutRelease/queries.js";
 import type * as payoutSnapshots_localState from "../payoutSnapshots/localState.js";
 import type * as payoutSnapshots_mutations from "../payoutSnapshots/mutations.js";
@@ -134,12 +136,14 @@ const fullApi: ApiFromModules<{
   "payoutPolicy/queries": typeof payoutPolicy_queries;
   "payoutRelease/adoption": typeof payoutRelease_adoption;
   "payoutRelease/allocation": typeof payoutRelease_allocation;
+  "payoutRelease/allocationTotals": typeof payoutRelease_allocationTotals;
   "payoutRelease/fees": typeof payoutRelease_fees;
   "payoutRelease/helpers": typeof payoutRelease_helpers;
   "payoutRelease/mutations": typeof payoutRelease_mutations;
   "payoutRelease/observation": typeof payoutRelease_observation;
   "payoutRelease/planning": typeof payoutRelease_planning;
   "payoutRelease/preview": typeof payoutRelease_preview;
+  "payoutRelease/progress": typeof payoutRelease_progress;
   "payoutRelease/queries": typeof payoutRelease_queries;
   "payoutSnapshots/localState": typeof payoutSnapshots_localState;
   "payoutSnapshots/mutations": typeof payoutSnapshots_mutations;

package/src/component/_generated/component.ts

@@ -3630,6 +3630,12 @@ export type ComponentApi<Name extends string | undefined = string | undefined> =
           },
           | { amount: 0; reason: string; status: "held" }
           | {
+              accounting?: {
+                carriedForwardAmount: number;
+                releasedAmount: number;
+                reservedAmount: number;
+                withheldAmount: number;
+              };
               amount: number;
               confirmedFees: number;
               currency: string;
@@ -3643,6 +3649,8 @@ export type ComponentApi<Name extends string | undefined = string | undefined> =
               sources: Array<{
                 matureUnpaid: number;
                 pendingCredits: number;
+                releasedAmount?: number;
+                reservedAmount?: number;
                 role: "store" | "affiliate" | "other";
               }>;
               status: "held" | "qualified";

package/src/component/payoutRelease/allocationTotals.ts

@@ -0,0 +1,56 @@
+import type { QueryCtx, MutationCtx } from "../_generated/server.js";
+import type { PayoutFundingSource } from "./allocation.js";
+import { add } from "./helpers.js";
+/** Match the maintained source rollups to all persisted claims before using them as financial facts. */
+export async function assertAllocationTotals(
+  ctx: QueryCtx | MutationCtx,
+  scope: { accountId: string; ownerKey: string },
+  sources: PayoutFundingSource[],
+) {
+  const claims = await ctx.db
+    .query("payoutReleaseClaims")
+    .withIndex("by_account_status", (q) => q.eq("accountId", scope.accountId))
+    .take(101);
+  if (claims.length > 100)
+    throw new Error("Payout claim snapshot is incomplete.");
+  const totals = new Map(
+    sources.map((source) => [
+      source.stripeTransferId,
+      { source, paid: 0, reserved: 0 },
+    ]),
+  );
+  for (const claim of claims) {
+    if (claim.ownerKey !== scope.ownerKey)
+      throw new Error("Payout claim owner does not match.");
+    let allocated = 0;
+    const seen = new Set<string>();
+    for (const allocation of claim.allocations) {
+      const total = totals.get(allocation.stripeTransferId);
+      if (
+        !total ||
+        total.source.currency !== claim.currency ||
+        seen.has(allocation.stripeTransferId) ||
+        !Number.isSafeInteger(allocation.amount) ||
+        allocation.amount <= 0
+      )
+        throw new Error("Payout claim allocation provenance is invalid.");
+      seen.add(allocation.stripeTransferId);
+      allocated = add(allocated, allocation.amount);
+      if (claim.status === "paid")
+        total.paid = add(total.paid, allocation.amount);
+      if (claim.status === "reserved" || claim.status === "submitted")
+        total.reserved = add(total.reserved, allocation.amount);
+    }
+    if (
+      !Number.isSafeInteger(claim.amount) ||
+      claim.amount <= 0 ||
+      allocated !== claim.amount
+    )
+      throw new Error("Payout claim allocation principal does not match.");
+  }
+  for (const { source, paid, reserved } of totals.values())
+    if (source.paidAmount !== paid || source.reservedAmount !== reserved)
+      throw new Error(
+        "Payout allocation totals do not match persisted claims.",
+      );
+}

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 { assertAllocationTotals } from "./allocationTotals.js";
 export async function readPayoutPlan(
   ctx: MutationCtx | QueryCtx,
   args: {
@@ -43,6 +44,7 @@ export async function readPayoutPlan(
     });
   }
   const fees = await readFees(ctx, args);
+  await assertAllocationTotals(ctx, args, sources);
   const plan = planRecipientPayout({
     currency: args.currency,
     threshold: minimum.amount,

package/src/component/payoutRelease/preview.ts

@@ -6,6 +6,7 @@ import { observation } from "./observation.js";
 import { readyPolicy, add } from "./helpers.js";
 import { readPayoutPlan } from "./planning.js";
 import { balance } from "../affiliateRecovery/accounting.js";
+import { progressAccounting, summarizePayoutProgress } from "./progress.js";
 export const previewFields = {
   ...scopeFields,
   expectedRevision: v.number(),
@@ -34,6 +35,7 @@ export const previewResult = v.union(
     independentLiabilities: v.number(),
     providerAvailable: v.number(),
     observedAt: v.number(),
+    accounting: v.optional(progressAccounting),
     sources: v.array(
       v.object({
         role: v.union(
@@ -43,6 +45,8 @@ export const previewResult = v.union(
         ),
         matureUnpaid: v.number(),
         pendingCredits: v.number(),
+        releasedAmount: v.optional(v.number()),
+        reservedAmount: v.optional(v.number()),
       }),
     ),
   }),
@@ -78,25 +82,11 @@ export async function previewPlan(
     fees,
     threshold,
   } = await readPayoutPlan(ctx, args, policy);
-  const sources = (["store", "affiliate", "other"] as const).map((role) => {
-    let matureUnpaid = 0,
-      pendingCredits = 0;
-    for (const source of funding)
-      if (
-        source.currency === args.currency &&
-        (source.role ?? "other") === role
-      ) {
-        matureUnpaid = add(
-          matureUnpaid,
-          add(
-            add(source.matureNet, -source.paidAmount),
-            -source.reservedAmount,
-          ),
-        );
-        pendingCredits = add(pendingCredits, source.pendingCredits);
-      }
-    return { role, matureUnpaid, pendingCredits };
-  });
+  const progress = summarizePayoutProgress(
+    plan,
+    funding,
+    add(fees?.amount ?? 0, args.independentLiabilities),
+  );
   return {
     status: plan.status,
     ...(plan.status === "held" ? { reason: plan.reason } : {}),
@@ -113,6 +103,6 @@ export async function previewPlan(
       Date.now(),
       ...args.observations.map((o) => o.observedAt),
     ),
-    sources,
+    ...progress,
   };
 }

package/src/component/payoutRelease/progress.test.ts

@@ -0,0 +1,63 @@
+import { expect, it } from "vitest";
+import { planRecipientPayout } from "./allocation.js";
+import { summarizePayoutProgress } from "./progress.js";
+it("keeps paid, reserved, mature and pending amounts in their own currency", () => {
+  const sources = [
+    {
+      stripeTransferId: "tr_usd",
+      currency: "usd",
+      role: "store" as const,
+      matureNet: 1000,
+      paidAmount: 0,
+      reservedAmount: 0,
+      pendingCredits: 0,
+    },
+    {
+      stripeTransferId: "tr_eur",
+      currency: "eur",
+      role: "affiliate" as const,
+      matureNet: 7000,
+      paidAmount: 2000,
+      reservedAmount: 500,
+      pendingCredits: 999,
+    },
+  ];
+  const plan = planRecipientPayout({
+    currency: "usd",
+    threshold: 1000,
+    providerAvailable: 1000,
+    independentLiabilities: 0,
+    sources,
+  });
+  expect(summarizePayoutProgress(plan, sources, 0)).toEqual({
+    accounting: {
+      carriedForwardAmount: 0,
+      withheldAmount: 0,
+      releasedAmount: 0,
+      reservedAmount: 0,
+    },
+    sources: [
+      {
+        role: "store",
+        matureUnpaid: 1000,
+        pendingCredits: 0,
+        releasedAmount: 0,
+        reservedAmount: 0,
+      },
+      {
+        role: "affiliate",
+        matureUnpaid: 0,
+        pendingCredits: 0,
+        releasedAmount: 0,
+        reservedAmount: 0,
+      },
+      {
+        role: "other",
+        matureUnpaid: 0,
+        pendingCredits: 0,
+        releasedAmount: 0,
+        reservedAmount: 0,
+      },
+    ],
+  });
+});

package/src/component/payoutRelease/progress.ts

@@ -0,0 +1,56 @@
+import { v } from "convex/values";
+import type { PayoutFundingSource, RecipientPayoutPlan } from "./allocation.js";
+import { add } from "./helpers.js";
+export const progressAccounting = v.object({
+  carriedForwardAmount: v.number(),
+  withheldAmount: v.number(),
+  reservedAmount: v.number(),
+  releasedAmount: v.number(),
+});
+/** Inputs have passed allocation validation. Shared costs are never attributed to a source category. */
+export function summarizePayoutProgress(
+  plan: RecipientPayoutPlan,
+  funding: PayoutFundingSource[],
+  costs: number,
+) {
+  const sources = (["store", "affiliate", "other"] as const).map((role) => {
+    let matureUnpaid = 0,
+      pendingCredits = 0,
+      releasedAmount = 0,
+      reservedAmount = 0;
+    for (const source of funding)
+      if (
+        source.currency === plan.currency &&
+        (source.role ?? "other") === role
+      ) {
+        matureUnpaid = add(
+          matureUnpaid,
+          add(
+            add(source.matureNet, -source.paidAmount),
+            -source.reservedAmount,
+          ),
+        );
+        pendingCredits = add(pendingCredits, source.pendingCredits);
+        releasedAmount = add(releasedAmount, source.paidAmount);
+        reservedAmount = add(reservedAmount, source.reservedAmount);
+      }
+    return {
+      role,
+      matureUnpaid,
+      pendingCredits,
+      releasedAmount,
+      reservedAmount,
+    };
+  });
+  const total = (field: "matureUnpaid" | "releasedAmount" | "reservedAmount") =>
+    sources.reduce((sum, source) => add(sum, source[field]), 0);
+  return {
+    sources,
+    accounting: {
+      carriedForwardAmount: Math.max(0, add(plan.matureUnpaid, -plan.amount)),
+      withheldAmount: Math.min(Math.max(0, total("matureUnpaid")), costs),
+      reservedAmount: total("reservedAmount"),
+      releasedAmount: total("releasedAmount"),
+    },
+  };
+}

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

@@ -57,6 +57,45 @@ it("does not invent zero balances or progress for an unavailable assessment", ()
   expect(screen.queryByRole("progressbar")).toBeNull();
   expect(screen.queryByText("$0.00")).toBeNull();
 });
+it("shows verified carry forward, withholding, in-flight and paid totals separately", () => {
+  render(
+    <PayoutProgress
+      policy={policy}
+      currency="usd"
+      preview={{
+        ...preview,
+        matureUnpaid: 899,
+        independentLiabilities: 100,
+        accounting: {
+          carriedForwardAmount: 899,
+          withheldAmount: 100,
+          reservedAmount: 200,
+          releasedAmount: 1000,
+        },
+        sources: [
+          { ...preview.sources[0], reservedAmount: 100, releasedAmount: 600 },
+          { ...preview.sources[1], reservedAmount: 100, releasedAmount: 400 },
+          { ...preview.sources[2], reservedAmount: 0, releasedAmount: 0 },
+        ],
+      }}
+    />,
+  );
+  for (const [label, value] of [
+    ["Carried forward", "$8.99"],
+    ["Withheld for costs", "$1.00"],
+    ["Payouts in progress", "$2.00"],
+    ["Paid out, net of returns", "$10.00"],
+  ])
+    expect(screen.getByText(label).nextElementSibling?.textContent).toBe(value);
+  expect(screen.getByRole("columnheader", { name: "Paid out" })).toBeTruthy();
+  expect(screen.getByRole("columnheader", { name: "In flight" })).toBeTruthy();
+});
+it("does not invent new accounting totals for a legacy assessment", () => {
+  render(<PayoutProgress policy={policy} preview={preview} currency="usd" />);
+  expect(screen.queryByText("Carried forward")).toBeNull();
+  expect(screen.queryByText("Paid out, net of returns")).toBeNull();
+  expect(screen.queryByRole("columnheader", { name: "Paid out" })).toBeNull();
+});
 it("keeps Stripe-managed defaults distinct from a custom application minimum", () => {
   render(<PayoutProgress policy={null} currency="usd" />);
   expect(screen.getByRole("status").textContent).toContain("Stripe manages");

package/src/react/workflows/PayoutProgress.tsx

@@ -59,6 +59,8 @@ export function PayoutProgress(props: PayoutProgressProps) {
                 <th scope="col">Source</th>
                 <th scope="col">Mature unpaid</th>
                 <th scope="col">Pending settlement</th>
+                {state.accounting && <th scope="col">In flight</th>}
+                {state.accounting && <th scope="col">Paid out</th>}
               </tr>
             </thead>
             <tbody>
@@ -73,12 +75,24 @@ export function PayoutProgress(props: PayoutProgressProps) {
                   </th>
                   <td>{source.matureLabel}</td>
                   <td>{source.pendingLabel}</td>
+                  {state.accounting && (
+                    <td>{source.reservedLabel ?? "Not assessed"}</td>
+                  )}
+                  {state.accounting && (
+                    <td>{source.releasedLabel ?? "Not assessed"}</td>
+                  )}
                 </tr>
               ))}
             </tbody>
           </table>
         </>
       )}
+      {state.accounting && (
+        <p>
+          Carried-forward funds remain owed. In-flight payouts are separate from
+          completed payouts. Paid-out amounts exclude returned payouts.
+        </p>
+      )}
       {state.nextAttemptAt !== null && (
         <p>
           Next automatic attempt: {date(state.nextAttemptAt)}. This is not a

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

@@ -3,7 +3,16 @@ import type { PayoutPolicy, PayoutPreview } from "../../client/payoutPolicy.js";
 import { formatPrice } from "../lib/price-helpers.js";
 export type PayoutProgressMetric = {
   key:
-    "qualifying" | "pending" | "minimum" | "eligible" | "fees" | "liabilities";
+    | "qualifying"
+    | "pending"
+    | "minimum"
+    | "eligible"
+    | "fees"
+    | "liabilities"
+    | "carried"
+    | "withheld"
+    | "reserved"
+    | "released";
   label: string;
   amount: number;
   formattedValue: string;
@@ -15,12 +24,19 @@ export type PayoutProgressState = {
   reason: string | null;
   message: string;
   metrics: PayoutProgressMetric[];
+  accounting?: NonNullable<
+    Extract<PayoutPreview, { currency: string }>["accounting"]
+  >;
   sources: {
     role: "store" | "affiliate" | "other";
     matureUnpaid: number;
     pendingCredits: number;
     matureLabel: string;
     pendingLabel: string;
+    releasedAmount?: number;
+    reservedAmount?: number;
+    releasedLabel?: string;
+    reservedLabel?: string;
   }[];
   progress: { value: number; max: number } | null;
   nextAttemptAt: number | null;
@@ -118,6 +134,7 @@ export function payoutProgressState({
             : (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,
@@ -127,6 +144,30 @@ export function payoutProgressState({
           ["pending", "Pending settlement", preview.pendingCredits],
           ["minimum", "Combined payout minimum", preview.threshold],
           ["eligible", "Eligible at assessment", preview.amount],
+          ...(preview.accounting
+            ? ([
+                [
+                  "carried",
+                  "Carried forward",
+                  preview.accounting.carriedForwardAmount,
+                ],
+                [
+                  "withheld",
+                  "Withheld for costs",
+                  preview.accounting.withheldAmount,
+                ],
+                [
+                  "reserved",
+                  "Payouts in progress",
+                  preview.accounting.reservedAmount,
+                ],
+                [
+                  "released",
+                  "Paid out, net of returns",
+                  preview.accounting.releasedAmount,
+                ],
+              ] as const)
+            : []),
           ["fees", "Confirmed payout costs", preview.confirmedFees],
           [
             "liabilities",
@@ -144,6 +185,12 @@ export function payoutProgressState({
           ...source,
           matureLabel: amount(source.matureUnpaid),
           pendingLabel: amount(source.pendingCredits),
+          ...(source.releasedAmount === undefined
+            ? {}
+            : { releasedLabel: amount(source.releasedAmount) }),
+          ...(source.reservedAmount === undefined
+            ? {}
+            : { reservedLabel: amount(source.reservedAmount) }),
         }));
       }
     }