@blamejs/blamejs-shop 0.4.84 → 0.4.86

package/CHANGELOG.md

@@ -8,6 +8,10 @@ upgrading across more than a few patches at a time.
 
 ## v0.4.x
 
+- v0.4.86 (2026-06-22) — **Failed outbound webhook deliveries are now retried automatically on the backoff schedule, not only by a manual click.** Restores the automatic retry guarantee for outbound webhooks. When an order-lifecycle or low-stock delivery to a subscriber endpoint fails, the delivery already records its next retry time and walks a backoff schedule toward the dead-letter queue — but nothing was ever driving those retries, so a delivery only re-attempted when an operator hand-clicked retry in the admin console. A briefly-unreachable receiver (a deploy, a load-balancer reload) therefore lost every event in the gap. A scheduled tick now re-attempts every due delivery once a minute, so a failed delivery is retried automatically — at one minute, five minutes, thirty minutes, four hours, then a day — until it succeeds or lands in the dead-letter queue, with no manual intervention. The manual retry remains available as an immediate override. No configuration changes; upgrade to pick it up. **Fixed:** *Outbound webhook retries now run automatically* — A scheduled retry pass re-attempts every delivery whose backoff has come due, advancing it through the retry schedule to success or to the dead-letter queue without an operator click. Each delivery is claimed atomically before it is attempted, so two overlapping passes can never re-send the same delivery twice, and a receiver that recovers within the backoff window now receives the events it missed. An operator can still force an immediate retry from the admin console. **Security:** *Bundled framework refreshed to blamejs 0.15.16* — Picks up a broad fail-closed and resource-exhaustion hardening pass that rides inside the composed primitives: a present-but-unparseable timestamp on a credential or certificate verifier (DKIM, ARC, SAML NotBefore, FIDO/BIMI/S-MIME validity windows) now refuses the credential instead of silently skipping the check; DMARC refuses a record with no usable policy rather than defaulting a failing message to delivery; outbound clients enforce an overall wall-clock timeout (not only an idle timer) so a byte-trickling peer can no longer hold a request open indefinitely; DNS lookups gain a default deadline; and append-only log sinks refuse a symlinked path. No configuration changes.
+
+- v0.4.85 (2026-06-22) — **Stock-transfer reconciliation credits the destination exactly once, even when retried after a mid-operation failure.** Fixes an inventory-integrity bug in stock-transfer reconciliation. Reconciling a received transfer credits each line's received quantity to the destination shelf and then records the line's discrepancy. If that discrepancy write failed partway through the transfer, reconciliation rolled its own state back so the operator could retry — but the retry credited the already-credited lines a second time, inflating the destination shelf with stock that was never received and could then be oversold. The destination credit is now keyed and idempotent: a retry recognizes a line it has already credited and skips it, so the shelf is credited exactly once no matter how many times reconciliation runs. The release adds one additive, backward-compatible database migration; apply pending migrations on upgrade. **Fixed:** *Stock-transfer reconciliation no longer double-credits the destination on retry* — Reconciling a received transfer credited each line to the destination shelf before stamping the line's discrepancy. A failure between those two steps rolled the transfer back to 'received' for a clean retry, but the retry re-credited every line whose discrepancy had not yet been stamped — including lines already credited on the failed attempt — minting phantom inventory at the destination. The per-line destination credit is now idempotent and keyed to the transfer and line, so re-running reconciliation after any partial failure credits each line exactly once; the discrepancy stamp is no longer load-bearing for correctness. **Migration:** *inventory_adjustments gains a nullable idempotency key* — Adds a nullable idempotency_key column to inventory_adjustments and a unique index over it, so a keyed stock credit records that it has already been applied and a retry that re-presents the key credits nothing. The column is NULL for every existing row and for plain stock adjustments, which already apply atomically; only keyed credits set it. The change is additive and backward-compatible — apply pending D1 migrations on upgrade.
+
 - v0.4.84 (2026-06-22) — **Payment idempotency and analytics cache keys now use the framework's canonical-JSON encoder.** Internal consistency change with no configuration to apply. The Stripe idempotency replay-protection hash and the subscription-analytics cache key each carried their own copy of a sorted-key JSON serializer; both now compose the framework's canonical-JSON encoder, so a single serializer — with one set of key-ordering, string-escaping, and number-format rules — backs every replay and cache hash. Idempotency replays issued across the upgrade keep working: a request hash written by the prior release is still recognized for the row's lifetime, so a payment retried across the upgrade boundary replays its cached response rather than being refused as a mismatch. Upgrade to pick it up. **Changed:** *Replay and cache hashes share one canonical-JSON encoder* — Payment idempotency-key replay protection and the subscription-analytics cache key now build their hashes with the framework's canonical-JSON encoder instead of a locally maintained serializer. The encoder emits object members in one stable key order, so two requests — or two analytics queries — that differ only in member order resolve to the same hash, and the order is now stable even for integer-like keys, which the previous serializer reordered. Idempotency rows written by the prior release are still matched for their lifetime, so a payment retried across the upgrade boundary replays its cached response and is never refused as a false mismatch; the compatibility path expires with those rows.
 
 - v0.4.83 (2026-06-22) — **Downloading a subject-access export now requires the customer-write grant, not just read access.** Closes an access-control gap on the data-subject-request surface. Downloading a fulfilled subject-access export streams the customer's full personal-data bundle, but the download route was gated as a plain read, so a read-only operator (a viewer with no customers-write grant) could pull the entire PII bundle. The download now gates on the customers-write capability — the same grant fulfilling, dispatching, and erasing a request already require — so a read-only viewer is refused on the verb and the denial is recorded in the operator audit log, on both the API and browser paths. No configuration changes; upgrade to pick it up. **Security:** *Subject-access export download requires customers-write* — The DSR export-download route streams a customer's full PII bundle, so it is a customers-write-class capability like fulfilling, dispatching, or erasing a request — not a read. It now gates on customers-write on both the bearer-API and cookie/browser paths, so a read-only viewer can no longer download the bundle; the refused attempt is chained through the operator audit log like the other DSR write denials. Viewing the DSR queue (a read) is unchanged.

package/lib/asset-manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.4.84",
+  "version": "0.4.86",
   "assets": {
     "css/admin.css": {
       "integrity": "sha384-imfe0otYErcB8rr2h6KLSGTtStirysptpXETSPY4zLv3bZoIT75Lo1dOvkOav+xL",

package/lib/inventory-locations.js

@@ -79,6 +79,7 @@ var CODE_RE      = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
 var SKU_RE       = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 var NAME_RE      = /^[\S\s]{1,128}$/;
 var MAX_REASON   = 256;
+var MAX_IDEMPOTENCY_KEY = 256;
 var MAX_LINES    = 1000;
 var TYPES        = Object.freeze(["warehouse", "retail", "dropship"]);
 var STRATEGIES   = Object.freeze([
@@ -674,6 +675,91 @@ function create(opts) {
       return { sku: input.sku, location_code: input.location_code, quantity: nextQty, delta: input.delta };
     },
 
+    // Idempotent keyed credit. For a positive credit that is one step of a
+    // larger non-transactional flow (e.g. stock-transfer reconciliation),
+    // adjustStock alone is not safe to retry: a crash between the stock upsert
+    // and the next step lets a re-run credit the shelf a SECOND time, minting
+    // phantom inventory. creditOnce makes a retry safe by making the audit
+    // row's idempotency_key the claim: the first call with a given key inserts
+    // the row (winning the claim) and applies the credit; any later call with
+    // the same key finds it present and is a no-op. A credit never breaches the
+    // zero/holds floor, so this path is positive-delta only.
+    //
+    // Why claim-first rather than a single atomic write: the truly atomic form
+    // would be an AFTER INSERT trigger crediting the shelf in the same INSERT,
+    // but `wrangler d1 migrations apply` ships each statement to the D1 HTTP
+    // API without its trailing `;`, and D1 rejects a trigger body that way
+    // ("incomplete input"), so a trigger cannot be applied through the project's
+    // migration tool. Claim-first is therefore the design. D1 has no
+    // interactive transactions, so a single-statement gap is unavoidable; the
+    // claim (audit row) is written BEFORE the stock upsert and the compensating
+    // delete below covers the upsert throwing. The only residual is the host
+    // process dying (a container crash / deploy roll — this runs in the
+    // persistent container, not a per-request isolate) between the two
+    // statements: the key is durable but the stock was not credited, so a retry
+    // no-ops and the shelf is UNDER-credited until an operator recount, never
+    // double-credited. Under-credit is the safe direction (a recoverable
+    // shortfall, not oversellable phantom stock) and matches every other
+    // claim-first transition in the codebase.
+    creditOnce: async function (input) {
+      if (!input || typeof input !== "object") {
+        throw new TypeError("inventory-locations.creditOnce: input object required");
+      }
+      _sku(input.sku);
+      _code(input.location_code, "location_code");
+      _int(input.delta, "delta");
+      if (input.delta <= 0) {
+        throw new TypeError("inventory-locations.creditOnce: delta must be a positive credit");
+      }
+      var key = input.idempotency_key;
+      if (typeof key !== "string" || !key.length || key.length > MAX_IDEMPOTENCY_KEY) {
+        throw new TypeError("inventory-locations.creditOnce: idempotency_key must be a non-empty string ≤ " +
+          MAX_IDEMPOTENCY_KEY + " chars");
+      }
+      var loc = await _getLocationRow(input.location_code);
+      if (!loc) {
+        throw new TypeError("inventory-locations.creditOnce: location_code " +
+          JSON.stringify(input.location_code) + " not found");
+      }
+      var ts = _now();
+      // Claim: insert the keyed audit row. ON CONFLICT DO NOTHING means a
+      // replay (same key) lands zero rows and the credit is skipped entirely.
+      var claim = await query(
+        "INSERT INTO inventory_adjustments " +
+        "(id, sku, location_code, delta, reason, occurred_at, idempotency_key) " +
+        "VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7) ON CONFLICT(idempotency_key) DO NOTHING",
+        [b.uuid.v7(), input.sku, input.location_code, input.delta, _reason(input.reason), ts, key],
+      );
+      var changes = claim && (claim.rowCount != null ? claim.rowCount
+        : (claim.meta && claim.meta.changes != null ? claim.meta.changes : claim.changes));
+      if (Number(changes || 0) === 0) {
+        var existing = await _getStockRow(input.sku, input.location_code);
+        return {
+          sku: input.sku, location_code: input.location_code,
+          quantity: existing ? existing.quantity : 0, delta: 0, applied: false,
+        };
+      }
+      // Won the claim — apply the credit. If the upsert fails, roll the claim
+      // back so a retry re-attempts rather than stranding the credit at zero.
+      try {
+        await query(
+          "INSERT INTO inventory_stock (sku, location_code, quantity, updated_at) " +
+          "VALUES (?1, ?2, ?3, ?4) " +
+          "ON CONFLICT(sku, location_code) DO UPDATE SET " +
+          "quantity = quantity + ?3, updated_at = ?4",
+          [input.sku, input.location_code, input.delta, ts],
+        );
+      } catch (e) {
+        await query("DELETE FROM inventory_adjustments WHERE idempotency_key = ?1", [key]);
+        throw e;
+      }
+      var creditedRow = await _getStockRow(input.sku, input.location_code);
+      return {
+        sku: input.sku, location_code: input.location_code,
+        quantity: creditedRow ? creditedRow.quantity : 0, delta: input.delta, applied: true,
+      };
+    },
+
     // Atomic two-row move. Reads the source quantity; if
     // insufficient, refuses the whole transfer before mutating
     // anything (no money created, no row half-committed). Writes

package/lib/order.js

@@ -802,8 +802,10 @@ function create(opts) {
       // outbound HTTP, or a slow / unreachable endpoint would block the
       // transition for seconds (the HTTP client's idle timeout plus
       // retry). send() persists a delivery row per subscriber and attempts
-      // delivery in the background; a failure lives in
-      // `webhook_deliveries.last_error` for retry from the admin console.
+      // delivery in the background; a failure stamps `next_retry_at` and is
+      // re-attempted automatically on the backoff schedule by the
+      // /_/webhook-retry-tick cron (an operator can also force an immediate
+      // retry from the admin console), walking toward success or the DLQ.
       // The promise is detached with a swallowing .catch so a rejection —
       // or a synchronous throw from send() — never becomes an
       // unhandledRejection and never touches the transition's latency.

package/lib/security-middleware.js

@@ -111,6 +111,7 @@ var INTERNAL_BRIDGE_PATHS = [
   "/_/customer-portal-expire",
   "/_/stale-order-reap",
   "/_/quote-expiry-tick",
+  "/_/webhook-retry-tick",
 ];
 
 // Public well-known paths fetched by third-party verification crawlers

package/lib/stock-transfers.js

@@ -261,15 +261,18 @@ function _now() { return Date.now(); }
 function create(opts) {
   opts = opts || {};
   // The inventoryLocations primitive is the sole owner of
-  // `inventory_stock` mutations. This primitive composes its
-  // adjustStock verb to debit origin / credit destination — refusing
-  // to wire one through fails loud at boot rather than at first call.
+  // `inventory_stock` mutations. This primitive composes its adjustStock
+  // verb to debit origin and its creditOnce verb to credit the destination
+  // idempotently during reconcile — refusing to wire one through fails loud
+  // at boot rather than at first call (a stub missing creditOnce would
+  // otherwise boot fine and only break mid-reconcile, after the status claim).
   if (!opts.inventoryLocations ||
       typeof opts.inventoryLocations.adjustStock !== "function" ||
+      typeof opts.inventoryLocations.creditOnce !== "function" ||
       typeof opts.inventoryLocations.getLocation !== "function" ||
       typeof opts.inventoryLocations.stockForSku !== "function") {
     throw new TypeError("stock-transfers.create: opts.inventoryLocations with " +
-      "adjustStock + getLocation + stockForSku is required");
+      "adjustStock + creditOnce + getLocation + stockForSku is required");
   }
   var locations = opts.inventoryLocations;
   var query = opts.query;
@@ -669,25 +672,29 @@ function create(opts) {
           " is no longer received (already reconciled by a concurrent call) — refusing to double-credit");
       }
       var discrepancies = [];
-      // Credit the destination one line at a time. The claim above flipped the
-      // status, so a concurrent call can't reach this loop for the same
-      // transfer. Each line is skipped once its discrepancy column is stamped,
-      // so a retry (after the compensation below rolls the claim back) re-credits
-      // ONLY the lines that hadn't landed yet — no double-credit on the lines
-      // that already succeeded. If any line throws, the terminal claim is rolled
-      // back to 'received' so the transfer stays eligible for another reconcile
-      // that finishes the remaining credits, rather than stranding it.
+      // Credit the destination one line at a time. The status claim above
+      // serializes concurrent reconciles, but the exactly-once guarantee on the
+      // destination credit is the KEYED credit itself: creditOnce stamps a
+      // per-line idempotency key (stock-transfer:reconcile:<transfer>:<line>),
+      // so even if a line is credited and the loop then throws BEFORE the
+      // discrepancy column is stamped — rolling the status claim back to
+      // 'received' and re-enabling a full re-run — the re-credit finds the key
+      // present and is a no-op. The discrepancy skip-guard is a redundant
+      // fast-path, not the safety gate. If any line throws, the terminal claim
+      // is rolled back so the transfer stays eligible for another reconcile that
+      // finishes the remaining credits rather than stranding it.
       try {
         for (var i = 0; i < transfer.lines.length; i += 1) {
           var line = transfer.lines[i];
-          if (line.discrepancy != null) continue;   // already credited on a prior attempt
+          if (line.discrepancy != null) continue;   // already credited + stamped on a prior attempt
           var rx   = line.quantity_received == null ? 0 : line.quantity_received;
           if (rx > 0) {
-            await locations.adjustStock({
+            await locations.creditOnce({
               sku: line.sku,
               location_code: transfer.to_location,
               delta: rx,
               reason: "stock-transfer:reconcile:" + id,
+              idempotency_key: "stock-transfer:reconcile:" + id + ":" + line.id,
             });
           }
           var diff = line.quantity_shipped - rx;