Skip to content

feat(customerpayment): reject zero + non-finite cpayAmount at the schema layer#172

Merged
CryptoJones merged 1 commit into
masterfrom
feat/customerpayment-reject-zero-and-infinite-amount
May 19, 2026
Merged

feat(customerpayment): reject zero + non-finite cpayAmount at the schema layer#172
CryptoJones merged 1 commit into
masterfrom
feat/customerpayment-reject-zero-and-infinite-amount

Conversation

@CryptoJones
Copy link
Copy Markdown
Owner

Closes #171.

Summary

cpayAmount was typed z.coerce.number(), which accepted three values
that have no business meaning:

  • 0 — a "$0 payment" recorded against a customer ledger
  • Infinity and -Infinity — zod rejects NaN by default but not the
    infinities; the DOUBLE column happily stores them, then any consumer
    doing arithmetic (totals, aging, CSV) gets contaminated

Negative values are intentionally still accepted — some operators
model refunds as negative payments and there's no separate refund flow.

Refactored into a shared cpayAmountField so create and update bodies
share one validator instead of drifting.

Test plan

  • npm run lint clean
  • npm test — 617 → 620 (+3 tests)
  • POST with cpayAmount: 0 → 400 (new)
  • POST with cpayAmount: -50 → not 400 (refund flow preserved, new)
  • PATCH with cpayAmount: 0 → 400 (new)

Proudly Made in Nebraska. Go Big Red! 🌽 https://xkcd.com/2347/

…ema layer

`cpayAmount` was typed `z.coerce.number()` — which accepts:

- **0**: a "\$0 payment" against a customer ledger has no business
  meaning. It's operator error every time, and the API was happily
  recording it.
- **Infinity / -Infinity**: zod's `.number()` rejects NaN by default
  but lets the infinities through. A DOUBLE column will store them
  fine, then any consumer doing arithmetic (totals, aging buckets,
  CSV exports) gets contaminated.

Negative values still pass — some operators model refunds as
negative payments, and there's no separate refund flow on this API
yet. Pin both that and the zero/infinity rejection in tests so the
boundary is observable.

Extracted the validator to a named `cpayAmountField` so the create
and update bodies share one definition instead of drifting.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
@CryptoJones CryptoJones merged commit 5e254c2 into master May 19, 2026
3 checks passed
@CryptoJones CryptoJones deleted the feat/customerpayment-reject-zero-and-infinite-amount branch May 19, 2026 08:29
CryptoJones added a commit that referenced this pull request May 19, 2026
)

`injbAmount` was typed `z.coerce.number()`, which accepts every
value `Number()` produces — including `Infinity` and `-Infinity`.
zod's `.number()` rejects `NaN` by default but lets the infinities
slip through. JSON has no literal for Infinity, but
`z.coerce.number()` happily turns the string `"Infinity"` into the
float, and the underlying Sequelize `DOUBLE` column will store it
as `inf`. Any downstream consumer doing arithmetic on the column
(invoice totals, aging buckets, CSV exports) then gets contaminated.

Pin `.finite()` at the boundary so non-finite values get a clean
400 instead of corrupting the ledger.

Zero and negative values still pass — both are real accounting cases
on invoice lines (reference/courtesy $0 lines; credit/discount
negative lines). This is intentionally looser than cpayAmount's
non-zero refinement from the customer-payment side: a $0 payment is
operator error, a $0 invoice line is normal.

Extracted the validator to a named `injbAmountField` so create and
update bodies share one definition (mirrors the `cpayAmountField`
pattern from #172).

Co-authored-by: Aaron K. Clark <akclark@thenetwerk.net>
Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
CryptoJones added a commit that referenced this pull request May 19, 2026
…chema layer (#194)

Both `polQty` and `polPrice` were typed as bare `z.coerce.number()`,
which accepts `Infinity` and `-Infinity` (zod's `.number()` rejects
NaN by default but not the infinities). The coerce path also turns
the string `"Infinity"` into the float, so even via JSON — which
has no literal for Infinity — a client can land non-finite values
in either column.

Both columns are Sequelize `DOUBLE` and will happily store `inf`.
An `inf` on a PO line silently corrupts every downstream
calculation: PO totals, inventory valuation, GL reconciliation.

Fix: extract `polQtyField` + `polPriceField` chained through
`.finite()`, share between create and update bodies. Same pattern
as the `cpayAmountField` (#172) and `injbAmountField` (#180)
validators.

Zero and negative values still pass — a $0 line is a real "freebie
included with order" case, and a negative line is a valid inline
credit/discount entry.

Pinned in `tests/api/purchaseorderline.test.js` with 5 new tests
covering: non-finite polQty rejection, non-finite polPrice
rejection on POST and PATCH, and that zero + negative values still
pass through (preserving the freebie / inline-discount use cases).

Co-authored-by: Aaron K. Clark <akclark@thenetwerk.net>
Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
CryptoJones added a commit that referenced this pull request May 19, 2026
…#206)

`btHourlyRate` was typed `z.coerce.number().nonnegative()`.
`.nonnegative()` correctly blocks negative rates (a -\$50/hr rate
is operator error), but it does NOT block `Infinity` — `Infinity
>= 0` is `true` so the refinement lets it through. The coerce
path also turns the string `"Infinity"` into the float, so a
client without an Infinity literal in JSON can still land `inf`
in the underlying DOUBLE column.

An `inf` in `btHourlyRate` silently contaminates every downstream
total: invoice line totals, time-entry rate math, billing
reports, anything that multiplies hours by this rate. The
arithmetic doesn't fail — it just yields `inf` (or `NaN` from
`0 * inf`) in the result.

Fix: chain `.finite()` ahead of `.nonnegative()` in a shared
`btHourlyRateField` validator. Mirrors `cpayAmountField` (#172),
`injbAmountField` (#180), `polPriceField` (#194). Zero remains a
valid rate (pro-bono engagements, internal-only billing entries).

Pinned in `tests/api/billingtype.test.js` with 4 new tests:
- POST non-finite → 400
- POST negative → 400 (existing nonnegative gate, pinned so a
  refactor can't accidentally relax it)
- POST zero → not 400 (preserves pro-bono use case)
- PATCH non-finite → 400

Co-authored-by: Aaron K. Clark <akclark@thenetwerk.net>
Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

customerpayment: cpayAmount accepts 0 and Infinity — both operator/data-quality bugs

1 participant