Files
zeekay 73b7290e7f square: one webhook route and one verifier; secrets come from the host's KMS
Square keeps an event's created_at across every retry, and the receiver
refused anything older than five minutes, so every retry of an event
first sent while cloud was down (Recreate, ten rollouts a day) was refused
until Square gave up. The verifier now lives in payment/providers/square
and needs only the key and the URL; thirdparty/square is the API client
and no longer registers itself or verifies anything, so every registry
holds one Square type.

Replay is stopped by the event id instead: each verified event is
recorded once for the whole deployment, keyed on the verifying processor
and the event id with an insert-if-absent swap, so a repeat is a
duplicate under any path or org. The path names the one processor that
verifies, and only one that holds its webhook secret may: an unknown name,
or a verifier that needs no secret, is refused rather than tried.
The books an event lands in are the verifying account's, else the
deployment's brand — never a header or session, which on a replay are the
replayer's. An effect that did not land (a store or the ledger did not
answer) leaves the delivery open with a 503, so the provider redelivers;
it used to be acknowledged and never retried. A settlement reads the
payment index before the org's books, because an in-session charge's
receipt is in the payer's org.

POST /v1/commerce/webhooks/:provider is declared once, in setupRoutes, so
standalone and embedded commerce serve the same address; the
/v1/billing/webhooks spelling is gone.

thirdparty/kms read /v1/kms/orgs/<org>/secrets/..., which cloud no longer
serves, and was off in production anyway, so per-org payment credentials
never loaded. It is deleted. secrets.Org reads orgs/<org>/<name> through
the host's reader, the caller re-pointed at that org with zip.ActingAs so
the KMS tenancy check admits it, and payment.Hydrate loads an org's
credentials where the org receives the money: storefront checkout,
storefront subscriptions and wire, and the brand's bank for the billing
wire rail. Hanzo's own billing no longer reads the paying org's
credentials; it charges the deployment's account, as it did. The
standalone binary reads through hanzoai/kms/sdk/go.
2026-10-19 09:12:56 -07:00

53 lines
1.7 KiB
Go

package square
import (
"context"
"github.com/hanzoai/commerce/log"
"github.com/hanzoai/commerce/models/order"
"github.com/hanzoai/commerce/models/organization"
"github.com/hanzoai/commerce/models/payment"
"github.com/hanzoai/commerce/models/types/currency"
"github.com/hanzoai/commerce/models/user"
"github.com/hanzoai/commerce/payment/processor"
squarelib "github.com/hanzoai/commerce/thirdparty/square"
)
func Authorize(org *organization.Organization, ord *order.Order, usr *user.User, pay *payment.Payment) error {
sqCfg := org.SquareConfig(org.TestMode())
proc := squarelib.NewProcessor(squarelib.Config{
AccessToken: sqCfg.AccessToken,
LocationID: sqCfg.LocationId,
Environment: org.SquareEnvironment(),
})
req := processor.PaymentRequest{
Amount: currency.Cents(pay.Amount),
Currency: pay.Currency,
Token: pay.Account.Number, // Card nonce from client
CustomerID: usr.Accounts.Square.CustomerId,
OrderID: ord.Id(),
Description: pay.Description,
}
result, err := proc.Authorize(context.Background(), req)
if err != nil {
log.Warn("Square authorize failed for payment '%s': %v", pay.Id(), err)
return err
}
// Update payment with Square response
pay.Account.Square.PaymentId = result.TransactionID
pay.Account.Square.LocationId = sqCfg.LocationId
// pay.Live must follow the SAME authority as the charge environment, so a
// sandbox authorization is never recorded as a live payment (and vice versa).
pay.Live = !org.TestMode()
// Update user's Square account
usr.Accounts.Square.CustomerId = req.CustomerID
log.Info("Square authorized payment '%s' → transaction '%s'", pay.Id(), result.TransactionID)
return nil
}