@blamejs/blamejs-shop 0.3.46 → 0.3.47

package/CHANGELOG.md

@@ -8,6 +8,8 @@ upgrading across more than a few patches at a time.
 
 ## v0.3.x
 
+- v0.3.47 (2026-06-01) — **Admin product detail, collections list, and order shipment panels load with fewer database round trips.** Three admin-console screens re-derived data with one database query per item: the product-detail screen ran a query per variant per currency for current and historical prices, the collections list pulled up to 200 member rows for each collection just to count them, and the order-detail shipment panel hydrated each shipment and its labels sequentially. These now read in batched or parallel queries. The displayed data is unchanged, with one correctness improvement: a manual collection with more than 200 members now shows its true product count instead of a number capped at 200. **Changed:** *Batched admin product-detail price hydration* — The admin product-detail screen now loads every variant's current and historical prices across all currencies in a single batched query instead of one query per variant per currency. The screen renders identically. · *Collections list counts without pulling member rows* — The admin collections list now counts a manual collection's members with a COUNT query instead of fetching up to 200 member rows per collection. A manual collection with more than 200 members now shows its true count (previously the displayed count was capped at 200); rule-based collections keep their existing bounded preview count. · *Parallel shipment hydration on order detail* — The order-detail shipment panel now hydrates each shipment and its labels in parallel rather than one after another, so an order with several shipments opens faster.
+
 - v0.3.46 (2026-06-01) — **Storefront pages render in far fewer database round trips, and the search collection filter is consistent across cache tiers.** The dynamically rendered storefront (the path that serves returning, signed-in, or non-default-currency shoppers) re-derived product data with one database query per item — a home or search page could issue dozens to hundreds of round trips, where the cached edge already did the same work in a single batched query. The home grid, search results, product page, related-products rail, and cart now read product, variant, price, inventory, and media data in batched queries that mirror the edge exactly, so those pages render with far fewer round trips and identical output. As part of this, the search 'collection' filter now reflects manual collection membership consistently whether a page is served from the cache or rendered dynamically. **Changed:** *Batched product reads on storefront pages* — The home grid, search results, product detail, related-products rail, and cart now load product/variant/price/inventory/media data in batched database queries instead of one query per item. On a cache miss, a signed-in session, or a non-default currency the dynamic render path previously issued a query per product (and per variant); these pages now match the single-query shape the cached edge already used. Rendered pages are unchanged. · *Consistent search collection filter across cache tiers* — The 'collection' filter on the search page now reflects manual collection membership on both the cached and the dynamically rendered paths. Previously the dynamic path could additionally surface smart-collection rule matches in that filter, so a shopper could see different collection filter options depending on which path served the page. If you relied on smart (rule-based) collections appearing as search filters, they now appear only where a product is an explicit member; this aligns the two render paths.
 
 - v0.3.45 (2026-06-01) — **Tax, VAT, bulk price changes, and customer emails now compute money in exact integer arithmetic.** Several money calculations were performed with floating-point intermediates. On a large order subtotal the sales-tax math could lose a minor unit, and the customer-facing wishlist emails formatted prices by dividing by 100 — which is wrong for zero-decimal currencies like JPY (¥1,050 rendered as 10.5) and three-decimal currencies like BHD, and dropped trailing zeros ($10.00 shown as 10). All of these now run through the framework's exact BigInt money primitive: sales-tax and VAT/GST extraction, the per-rate owed figure on a tax filing, the admin bulk price-adjust, the wishlist price-drop and digest emails, and subscription monthly-revenue normalization. Prices in customer emails are now rendered with the correct currency exponent and symbol for every currency. **Changed:** *Bulk price-adjust rounds to even on exact half-unit ties* — The admin bulk price-adjust now rounds a price that lands exactly halfway between two minor units to the nearest even unit, matching the rounding used everywhere else in the money surface, instead of always rounding the half up. This only changes the result on an exact tie and by at most one minor unit (for example a price computed as 200.5 now becomes 200 rather than 201). If a pricing regime requires rounding halves up, that is a one-line option change. **Fixed:** *Exact sales-tax and VAT computation* — Sales tax, VAT-inclusive extraction, and VAT-exclusive addition are computed in exact integer arithmetic rather than with a floating-point intermediate, so the tax on a large order total is no longer off by a minor unit. The per-rate owed figure on a tax filing is likewise computed exactly, which matters when a filing window aggregates a very large taxable total. · *Currency-correct prices in wishlist emails* — Price-drop alert emails and the wishlist digest now format prices with each currency's own decimal places and symbol. Zero-decimal currencies (such as JPY) and three-decimal currencies (such as BHD) render correctly, and whole amounts keep their trailing zeros — for example $10.00 instead of 10. · *Exact subscription monthly-revenue normalization* — Normalizing a weekly or annual plan to a monthly figure for revenue reporting now uses exact rational arithmetic instead of a floating-point cadence factor, so the dashboard total is stable and does not drift by a cent between refreshes.

package/lib/admin.js

@@ -660,21 +660,15 @@ function mount(router, deps) {
     var p = await catalog.products.get(id);
     if (!p) return null;
     var variants = await catalog.variants.listForProduct(id);
-    var pricesByVariant = {};
-    for (var i = 0; i < variants.length; i += 1) {
-      var v = variants[i];
-      var currencies = await catalog.prices.currencies(v.id);
-      var perCurrency = [];
-      for (var j = 0; j < currencies.length; j += 1) {
-        var cur = currencies[j];
-        perCurrency.push({
-          currency: cur,
-          current:  await catalog.prices.current(v.id, cur),
-          history:  await catalog.prices.history(v.id, cur),
-        });
-      }
-      pricesByVariant[v.id] = { currencies: perCurrency };
-    }
+    // Every variant's price-per-currency (current + history) in one read.
+    // batch.pricesForVariants returns `{ variantId: { currencies:
+    // [{ currency, current, history }] } }` byte-identical to the prior
+    // per-variant → per-currency (prices.current + prices.history) loop:
+    // currencies ASC, current = open row (effective_until IS NULL), history
+    // = rows DESC. Unpriced variants map to `{ currencies: [] }`.
+    var pricesByVariant = await catalog.batch.pricesForVariants(
+      variants.map(function (v) { return v.id; }),
+    );
     var media = await catalog.media.listForProduct(id);
     return { product: p, variants: variants, prices_by_variant: pricesByVariant, media: media };
   }
@@ -1680,9 +1674,14 @@ function mount(router, deps) {
       if (orderTracking) {
         try {
           var shipRows = await orderTracking.listForOrder(o.id);
-          for (var si = 0; si < shipRows.length; si += 1) {
-            var full = await orderTracking.getShipment(shipRows[si].id);
-            var ship = full || shipRows[si];
+          // Hydrate every shipment + its labels in parallel — the set is
+          // bounded by shipments-per-order (a handful), so Promise.all
+          // collapses the sequential per-shipment getShipment +
+          // labelsForShipment round trips into one wait. Order is
+          // preserved (Promise.all keeps array position).
+          shipments = await Promise.all(shipRows.map(async function (sRow) {
+            var full = await orderTracking.getShipment(sRow.id);
+            var ship = full || sRow;
             // Carrier-label records for the shipment. Best-effort: the
             // shipping_labels table may be unmigrated, and the labels
             // primitive may not be wired — a read failure leaves the
@@ -1691,8 +1690,8 @@ function mount(router, deps) {
               try { ship.labels = await shippingLabels.labelsForShipment(ship.id); }
               catch (_le) { ship.labels = []; }
             }
-            shipments.push(ship);
-          }
+            return ship;
+          }));
         } catch (_e) { shipments = []; }
       }
       // Split-shipment plans for the order. Best-effort, same rationale
@@ -4658,15 +4657,16 @@ function mount(router, deps) {
 
     async function _listForBrowser(filter) {
       var rows = await collections.list(filter || {});
-      // Annotate each row with its current size: manual → member count,
-      // smart → matched-preview count. Both compose productsIn; the loop
-      // is bounded by the collection count (operators have tens, not
+      // Annotate each row with its current size via collections.countIn:
+      // manual → an exact COUNT(*) (one indexed aggregate, no row
+      // materialisation); smart → the bounded matched-preview count. The
+      // loop is bounded by the collection count (operators have tens, not
       // thousands), so this is not an N+1 over an unbounded set.
       for (var i = 0; i < rows.length; i += 1) {
         var count = null;
         try {
-          var p = await collections.productsIn({ slug: rows[i].slug, limit: 200 });
-          count = (p.rows || []).length;
+          var c = await collections.countIn(rows[i].slug);
+          count = c.exact != null ? c.exact : c.approx;
         } catch (_e) { count = null; }
         rows[i]._count = count;
       }

package/lib/asset-manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.3.46",
+  "version": "0.3.47",
   "assets": {
     "css/admin.css": {
       "integrity": "sha384-1SIn6oAf1DjECbRfKENZasdKHJiywGdXR58wn0hsFGcdVHzUmvfgMkEz5ANIAZJ3",

package/lib/catalog.js

@@ -1347,6 +1347,69 @@ function _batchModule(query) {
       for (var i = 0; i < r.rows.length; i += 1) out[r.rows[i].id] = r.rows[i];
       return out;
     },
+
+    // Every price row (current + history) for a set of variant ids in
+    // one query, grouped into the per-variant price model the admin
+    // product-detail screen builds (backs PERF-4). Replaces the admin's
+    // triple-nested per-variant → per-currency → (prices.current +
+    // prices.history) loop with a single read. Returns a map
+    //   { variantId: { currencies: [{ currency, current, history }] } }
+    // byte-identical to the per-item build:
+    //   - `currencies` is one entry per distinct currency, ordered ASC
+    //     (the order `prices.currencies` returns).
+    //   - `current` is the open price row (effective_until IS NULL) for
+    //     that currency, or null — matching `prices.current`.
+    //   - `history` is every row for that currency ordered effective_from
+    //     DESC — matching `prices.history`.
+    // EVERY input variant id is present in the map; a variant with no
+    // prices maps to `{ currencies: [] }` (the per-item path's empty
+    // build). Price rows are the raw `SELECT *` shape (no arithmetic —
+    // amount_minor is the integer minor-unit value passed through).
+    pricesForVariants: async function (variantIds) {
+      if (!Array.isArray(variantIds) || variantIds.length === 0) return {};
+      var unique = [];
+      var seen = Object.create(null);
+      for (var n = 0; n < variantIds.length; n += 1) {
+        var vid = variantIds[n];
+        if (typeof vid !== "string" || !vid.length) continue;
+        var canon = _id(vid, "variant id");
+        if (seen[canon]) continue;
+        seen[canon] = true;
+        unique.push(canon);
+      }
+      var out = {};
+      // Seed every requested variant so an unpriced variant still maps to
+      // an empty currencies list (the per-item loop's `{ currencies: [] }`).
+      for (var s = 0; s < unique.length; s += 1) out[unique[s]] = { currencies: [] };
+      if (!unique.length) return out;
+      var placeholders = unique.map(function (_v, i) { return "?" + (i + 1); }).join(", ");
+      // ORDER BY variant_id, currency ASC (matches prices.currencies'
+      // ASC ordering), then effective_from DESC (matches prices.history).
+      var r = await query(
+        "SELECT * FROM prices WHERE variant_id IN (" + placeholders + ") " +
+        "ORDER BY variant_id, currency, effective_from DESC",
+        unique,
+      );
+      // Group variant → currency. The currency-ASC ordering means the
+      // first time a (variant, currency) pair is seen drives its position
+      // in the `currencies` array, reproducing the per-currency loop order.
+      var byVariantCurrency = {};
+      for (var i = 0; i < r.rows.length; i += 1) {
+        var row = r.rows[i];
+        var bucket = out[row.variant_id];
+        if (!bucket) continue;   // a price for a variant outside the input set
+        var key = row.variant_id + "\u0000" + row.currency;
+        var entry = byVariantCurrency[key];
+        if (!entry) {
+          entry = { currency: row.currency, current: null, history: [] };
+          byVariantCurrency[key] = entry;
+          bucket.currencies.push(entry);
+        }
+        entry.history.push(row);
+        if (row.effective_until == null && entry.current == null) entry.current = row;
+      }
+      return out;
+    },
   };
 }
 

package/lib/collections.js

@@ -891,6 +891,39 @@ function create(opts) {
     return out;
   }
 
+  // ---- countIn -----------------------------------------------------------
+
+  // The current size of a collection, cheaply. For a MANUAL collection
+  // this is an exact `COUNT(*)` over `collection_members` — one indexed
+  // aggregate, no row materialisation (the admin list previously pulled
+  // up to 200 member rows just to `.length` them). For a SMART collection
+  // there is no cheap SQL count (membership is rule-evaluated against the
+  // catalog application-side), so the bounded preview is kept: it walks
+  // the same matched set `productsIn` does, capped at MAX_LIMIT, and the
+  // result is labelled a preview.
+  //
+  // Returns `{ exact: n }` for manual (a true total) and `{ approx: n }`
+  // for smart (the bounded preview, ≤ MAX_LIMIT). The caller reads
+  // whichever key is present; the number shown is unchanged from the
+  // previous `productsIn(...).rows.length` for both flavours.
+  async function countIn(slug) {
+    _slug(slug);
+    var row = await _row(slug);
+    if (!row) throw new TypeError("collections.countIn: collection " + JSON.stringify(slug) + " not found");
+    if (row.type === "manual") {
+      var r = await query(
+        "SELECT COUNT(*) AS n FROM collection_members WHERE collection_slug = ?1",
+        [slug],
+      );
+      var n = r.rows[0] && r.rows[0].n;
+      return { exact: Number(n == null ? 0 : n) };
+    }
+    // Smart: the bounded preview — same matched set productsIn returns,
+    // capped at MAX_LIMIT (the cap the admin list already used).
+    var preview = await productsIn({ slug: slug, limit: MAX_LIMIT });
+    return { approx: (preview.rows || []).length };
+  }
+
   return {
     defineManual:           defineManual,
     defineSmart:            defineSmart,
@@ -902,6 +935,7 @@ function create(opts) {
     removeProduct:          removeProduct,
     reorderProducts:        reorderProducts,
     productsIn:             productsIn,
+    countIn:                countIn,
     collectionsForProduct:  collectionsForProduct,
     evaluateRules:          _evaluateRules,
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/blamejs-shop",
-  "version": "0.3.46",
+  "version": "0.3.47",
   "description": "Open-source framework built on blamejs. Vendored stack, zero npm runtime deps, PQC-first crypto, security-on by default.",
   "main": "lib/index.js",
   "scripts": {