@blamejs/blamejs-shop 0.3.45 → 0.3.47

package/lib/catalog.js

@@ -171,6 +171,23 @@ function _contentType(s) {
 function _genId() { return b.uuid.v7(); }
 function _now()   { return Date.now(); }
 
+// Build the LIKE pattern for a single term — lowercased + the
+// `\`-first metacharacter neutralisation so a term containing `%` /
+// `_` matches only the literal character (otherwise `100%` would
+// match every row). The `\\` substitution MUST run first, before the
+// `%` / `_` passes, so the `\` we insert in front of a wildcard
+// isn't itself re-escaped on the next pass and the wildcard survives
+// un-neutralised. `products.search` and `batch.searchDecorate` both
+// compose this so the escape can't drift between the two surfaces;
+// it mirrors the edge `_likePattern` (worker/data/catalog.js).
+function _likePattern(term) {
+  var escaped = String(term).toLowerCase()
+    .replace(/\\/g, "\\\\")
+    .replace(/%/g, "\\%")
+    .replace(/_/g, "\\_");
+  return "%" + escaped + "%";
+}
+
 // ---- factory -------------------------------------------------------------
 
 function create(opts) {
@@ -206,6 +223,13 @@ function create(opts) {
   // failure never rolls back the stock op that triggered it.
   var inventory = _inventoryModule(query, { onStockChange: opts.onStockChange || null });
   var media     = _mediaModule(query);
+  // Batched read helpers — one or a few `IN (...)` / window-function
+  // queries that replace the per-item loops the container storefront
+  // ran (N+1 over the D1 bridge). Each is ported from the named edge
+  // function in worker/data/catalog.js with the SAME SQL shape +
+  // output field names, so the dual-rendered HTML stays byte-identical
+  // across the edge + container substrates.
+  var batch     = _batchModule(query);
 
   return {
     products:  products,
@@ -213,6 +237,7 @@ function create(opts) {
     prices:    prices,
     inventory: inventory,
     media:     media,
+    batch:     batch,
   };
 }
 
@@ -381,17 +406,12 @@ function _productsModule(query, cursorSecret) {
       if (qTrim.length === 0) {
         return { rows: [], next_cursor: null };
       }
-      var qLower = qTrim.toLowerCase();
       // Neutralize LIKE metacharacters so a search containing `%`
       // or `_` matches only the literal character (otherwise `100%`
-      // would match every row). `\` is the escape character; it has
-      // to be escaped first so we don't double-escape the
-      // `\` we insert in front of `%` / `_`.
-      var qEscaped = qLower
-        .replace(/\\/g, "\\\\")
-        .replace(/%/g, "\\%")
-        .replace(/_/g, "\\_");
-      var pattern = "%" + qEscaped + "%";
+      // would match every row). The shared `_likePattern` lowercases
+      // and escapes `\` first so the wildcard neutralisation can't be
+      // re-escaped — the same helper `batch.searchDecorate` composes.
+      var pattern = _likePattern(qTrim);
       var cursorVals = null;
       if (opts.cursor != null) {
         if (typeof opts.cursor !== "string") {
@@ -851,6 +871,548 @@ function _mediaModule(query) {
   };
 }
 
+// ---- batch (N+1-collapsing read helpers) ---------------------------------
+//
+// These mirror worker/data/catalog.js — the edge worker already
+// produces, in one or a few `IN (...)` / window-function queries, what
+// the container storefront re-derived with per-item loops (each a
+// full D1-bridge hop). Porting the edge SQL verbatim keeps the two
+// substrates in lockstep: the field names + row shapes below are the
+// ones the storefront renderers already accept, so the rendered HTML /
+// JSON-LD is unchanged.
+//
+// Every helper composes the module's `query(sql, params)` closure +
+// the existing validators. Each is missing-table-resilient (catch
+// `/no such table/i` → empty) to match the edge + the never-500-the-
+// page stance, EXCEPT entry-point validation (a malformed id throws
+// TypeError, which the route catches → 404/empty). The IN(...) lists
+// use positional placeholders generated from array length, values
+// bound positionally — never interpolated.
+
+// First-variant / first-media decorated SELECT — ported verbatim from
+// the edge `DECORATED_SELECT` (worker/data/catalog.js). Window
+// functions pick the first variant (position ASC, created_at ASC) +
+// first media per product in one round trip; the price is joined off
+// the hero variant for the requested currency. `?1` is the currency.
+var _DECORATED_SELECT =
+  "SELECT p.*, " +
+  "       v.id        AS hero_variant_id, " +
+  "       pr.amount_minor AS starting_price_minor, " +
+  "       pr.currency     AS starting_price_currency, " +
+  "       m.r2_key    AS hero_r2_key, " +
+  "       m.alt_text  AS hero_alt_text " +
+  "FROM products p " +
+  "LEFT JOIN ( " +
+  "  SELECT iv.*, " +
+  "         ROW_NUMBER() OVER (PARTITION BY iv.product_id ORDER BY iv.position ASC, iv.created_at ASC) AS rn " +
+  "  FROM variants iv " +
+  ") v ON v.product_id = p.id AND v.rn = 1 " +
+  "LEFT JOIN prices pr ON pr.variant_id = v.id AND pr.currency = ?1 AND pr.effective_until IS NULL " +
+  "LEFT JOIN ( " +
+  "  SELECT im.*, " +
+  "         ROW_NUMBER() OVER (PARTITION BY im.product_id ORDER BY im.position ASC, im.created_at ASC) AS rn " +
+  "  FROM media im " +
+  "  WHERE im.product_id IS NOT NULL " +
+  ") m ON m.product_id = p.id AND m.rn = 1 ";
+
+// Shape a decorated row to the exact output `_shapeDecoratedRow`
+// produces at the edge (worker/data/catalog.js): the product columns
+// plus `starting_price_minor` / `starting_price_currency` /
+// `hero_media`. No arithmetic — `starting_price_minor` is the raw
+// integer minor-unit amount passed through.
+function _shapeDecoratedRow(r) {
+  var hero = (r.hero_r2_key != null)
+    ? { r2_key: r.hero_r2_key, alt_text: r.hero_alt_text || "" }
+    : null;
+  return {
+    id:                      r.id,
+    slug:                    r.slug,
+    title:                   r.title,
+    description:             r.description,
+    status:                  r.status,
+    created_at:              r.created_at,
+    updated_at:              r.updated_at,
+    starting_price_minor:    r.starting_price_minor != null ? r.starting_price_minor : null,
+    starting_price_currency: r.starting_price_currency || "USD",
+    hero_media:              hero,
+  };
+}
+
+function _batchModule(query) {
+  // Default to USD when an unset / wrong-shape currency reaches a
+  // helper, matching the edge's `(len === 3) ? cur : "USD"` guard.
+  function _ccy(c) {
+    return (typeof c === "string" && c.length === 3) ? c : "USD";
+  }
+
+  return {
+    // Decorate a set of product ids in one query (backs PERF-5 home
+    // grid + PERF-1 related). Returns `{ rows, byId }`: `rows` carries
+    // one decorated row per matching id in `created_at`-stable order
+    // and `byId` maps id → row so the caller can re-impose its own
+    // order. Mirrors the edge `DECORATED_SELECT` + `_shapeDecoratedRow`.
+    decoratedProducts: async function (productIds, currency) {
+      if (!Array.isArray(productIds) || productIds.length === 0) return { rows: [], byId: {} };
+      var ids = productIds.map(function (id) { return _id(id, "product id"); });
+      var cur = _ccy(currency);
+      var placeholders = ids.map(function (_v, n) { return "?" + (n + 2); }).join(", ");
+      var params = [cur].concat(ids);
+      var r = await query(
+        _DECORATED_SELECT +
+        "WHERE p.id IN (" + placeholders + ") " +
+        "ORDER BY p.created_at ASC, p.id ASC",
+        params,
+      );
+      var rows = [];
+      var byId = {};
+      for (var i = 0; i < r.rows.length; i += 1) {
+        var shaped = _shapeDecoratedRow(r.rows[i]);
+        rows.push(shaped);
+        byId[shaped.id] = shaped;
+      }
+      return { rows: rows, byId: byId };
+    },
+
+    // Active products decorated in one query (backs PERF-5 / UX-8 home
+    // grid). Mirrors the edge `listActiveProducts`: status='active',
+    // ORDER BY updated_at DESC, id DESC, LIMIT/OFFSET. Returns
+    // `{ rows }`.
+    decoratedActive: async function (opts) {
+      opts = opts || {};
+      var cur = _ccy(opts.currency);
+      var limit  = opts.limit  == null ? 24 : opts.limit;
+      var offset = opts.offset == null ? 0  : opts.offset;
+      _positiveInt(limit, "limit");
+      _nonNegInt(offset, "offset");
+      var r = await query(
+        _DECORATED_SELECT +
+        "WHERE p.status = 'active' " +
+        "ORDER BY p.updated_at DESC, p.id DESC " +
+        "LIMIT ?2 OFFSET ?3",
+        [cur, limit, offset],
+      );
+      var rows = [];
+      for (var i = 0; i < r.rows.length; i += 1) rows.push(_shapeDecoratedRow(r.rows[i]));
+      return { rows: rows };
+    },
+
+    // Variants + their current price for a product in one query (backs
+    // PERF-3 PDP). Mirrors the edge `listVariantsWithPrices`: LEFT JOIN
+    // the active price (effective_until IS NULL) for `currency`,
+    // ordered position ASC, created_at ASC. Returns `{ rows, prices }`:
+    //   - `rows`   — the variant rows shaped like `variants.listForProduct`
+    //                (options_json parsed to `options`), price columns dropped
+    //                so the shape is byte-identical to the per-item path.
+    //   - `prices` — { variantId: priceRow } for variants that HAVE a
+    //                price in `currency`, each priceRow shaped like
+    //                `prices.current` output.
+    variantsWithPrices: async function (productId, currency) {
+      _id(productId, "product_id");
+      var cur = _ccy(currency);
+      var r = await query(
+        "SELECT v.*, " +
+        "       pr.id              AS price_id, " +
+        "       pr.amount_minor    AS price_amount_minor, " +
+        "       pr.currency        AS price_currency, " +
+        "       pr.effective_from  AS price_effective_from, " +
+        "       pr.effective_until AS price_effective_until, " +
+        "       pr.created_at      AS price_created_at " +
+        "FROM variants v " +
+        "LEFT JOIN prices pr ON pr.variant_id = v.id AND pr.currency = ?1 AND pr.effective_until IS NULL " +
+        "WHERE v.product_id = ?2 " +
+        "ORDER BY v.position ASC, v.created_at ASC",
+        [cur, productId],
+      );
+      var rows = [];
+      var prices = {};
+      for (var i = 0; i < r.rows.length; i += 1) {
+        var raw = r.rows[i];
+        // Lift the joined price into the per-variant prices map, shaped
+        // exactly like `prices.current` output (only when a price for
+        // `currency` exists), then strip the joined price columns off
+        // the variant row so the row shape is byte-identical to
+        // `variants.listForProduct` (the variant columns + parsed
+        // `options`). Deleting the extra keys in place preserves the
+        // row's identity/prototype so the two paths deep-equal.
+        if (raw.price_amount_minor != null) {
+          prices[raw.id] = {
+            id:              raw.price_id,
+            variant_id:      raw.id,
+            currency:        raw.price_currency,
+            amount_minor:    raw.price_amount_minor,
+            effective_from:  raw.price_effective_from,
+            effective_until: raw.price_effective_until,
+            created_at:      raw.price_created_at,
+          };
+        }
+        delete raw.price_id;
+        delete raw.price_amount_minor;
+        delete raw.price_currency;
+        delete raw.price_effective_from;
+        delete raw.price_effective_until;
+        delete raw.price_created_at;
+        raw.options = JSON.parse(raw.options_json);
+        rows.push(raw);
+      }
+      return { rows: rows, prices: prices };
+    },
+
+    // Inventory rows for a set of SKUs in one query, keyed by SKU
+    // (backs PERF-6 cart-line stock). Mirrors the edge
+    // `listInventoryForSkus`: the trimmed `{ stock_on_hand, stock_held }`
+    // shape — sufficient for the cart, which derives its low-stock band
+    // from an operator config value, not the per-SKU column. A SKU with
+    // no inventory row is absent from the map (the renderer treats
+    // absence as available). Missing-table-resilient → {}.
+    inventoryForSkus: async function (skus) {
+      if (!Array.isArray(skus) || skus.length === 0) return {};
+      var out = {};
+      try {
+        var placeholders = skus.map(function (_s, i) { return "?" + (i + 1); }).join(", ");
+        var r = await query(
+          "SELECT sku, stock_on_hand, stock_held FROM inventory WHERE sku IN (" + placeholders + ")",
+          skus,
+        );
+        for (var i = 0; i < r.rows.length; i += 1) {
+          out[r.rows[i].sku] = { stock_on_hand: r.rows[i].stock_on_hand, stock_held: r.rows[i].stock_held };
+        }
+      } catch (e) {
+        if (e && /no such table/i.test(e.message || "")) return {};
+        throw e;
+      }
+      return out;
+    },
+
+    // Full inventory rows for a set of SKUs in one query, keyed by SKU
+    // (backs PERF-3 PDP availability). Returns the SAME full-row shape
+    // `inventory.get` does (`SELECT *` → sku, stock_on_hand, stock_held,
+    // low_stock_threshold, updated_at), keeping the PDP's per-SKU
+    // inventory map byte-identical to the prior per-variant
+    // `inventory.get` loop. The PDP's availability resolver reads
+    // `low_stock_threshold` to surface the "Only N left" nudge, so the
+    // PDP needs the full row — the trimmed `inventoryForSkus` above is
+    // for the cart, which doesn't. A SKU with no inventory row is absent
+    // (renderer treats absence as available). Missing-table-resilient
+    // → {}.
+    inventoryRowsForSkus: async function (skus) {
+      if (!Array.isArray(skus) || skus.length === 0) return {};
+      var out = {};
+      try {
+        var placeholders = skus.map(function (_s, i) { return "?" + (i + 1); }).join(", ");
+        var r = await query(
+          "SELECT * FROM inventory WHERE sku IN (" + placeholders + ")",
+          skus,
+        );
+        for (var i = 0; i < r.rows.length; i += 1) {
+          out[r.rows[i].sku] = r.rows[i];
+        }
+      } catch (e) {
+        if (e && /no such table/i.test(e.message || "")) return {};
+        throw e;
+      }
+      return out;
+    },
+
+    // The facetable product universe for a set of search terms (backs
+    // PERF-2). Ported from the edge `searchFacetableProducts`: one
+    // decorated SELECT with an OR-of-LIKE term clause, then a
+    // collection_members `IN` (MANUAL membership only — see PD-1) +
+    // a grouped-inventory `IN`. Terms are deduped case-insensitively.
+    // Returns `{ rows }` where each row is the decorated shape PLUS
+    // `collection` (array of slugs), `price_minor` (int|null), and
+    // `in_stock` (bool) — the shape the faceting walker + search-card
+    // renderer consume. The collection + inventory reads are
+    // missing-table-resilient (a partially-migrated deploy degrades to
+    // the fields it has rather than 500ing search).
+    searchDecorate: async function (opts) {
+      opts = opts || {};
+      var terms = Array.isArray(opts.terms) ? opts.terms : [];
+      var dedup = {};
+      var cleaned = [];
+      for (var ti = 0; ti < terms.length; ti += 1) {
+        var term = typeof terms[ti] === "string" ? terms[ti].trim() : "";
+        if (!term.length || dedup[term.toLowerCase()]) continue;
+        dedup[term.toLowerCase()] = true;
+        cleaned.push(term);
+      }
+      if (!cleaned.length) return { rows: [] };
+      var cur = _ccy(opts.currency);
+      // Cap the candidate universe wider than the page so facet counts
+      // reflect the full match set. MAX_LIMIT keeps the in-memory facet
+      // walk bounded — matches the edge's MAX_LIMIT (100) cap.
+      var universeLimit = 100;
+
+      // One OR-of-LIKE clause per term. Positional params: ?1 is the
+      // price currency, ?2 the universe limit; term patterns start at ?3.
+      var likeClauses = [];
+      var params = [cur, universeLimit];
+      var ph = 3;
+      for (var c = 0; c < cleaned.length; c += 1) {
+        var pat = _likePattern(cleaned[c]);
+        likeClauses.push("lower(p.title) LIKE ?" + ph + " ESCAPE '\\'");
+        params.push(pat);
+        ph += 1;
+        likeClauses.push("lower(p.description) LIKE ?" + ph + " ESCAPE '\\'");
+        params.push(pat);
+        ph += 1;
+      }
+      var r = await query(
+        _DECORATED_SELECT +
+        "WHERE p.status = 'active' AND (" + likeClauses.join(" OR ") + ") " +
+        "ORDER BY p.updated_at DESC, p.id DESC LIMIT ?2",
+        params,
+      );
+      var raw = r.rows;
+      if (!raw.length) return { rows: [] };
+
+      var ids = raw.map(function (row) { return row.id; });
+      var byId = {};
+      var rows = [];
+      for (var i = 0; i < raw.length; i += 1) {
+        var shaped = _shapeDecoratedRow(raw[i]);
+        shaped.collection = [];
+        shaped.price_minor = shaped.starting_price_minor != null ? shaped.starting_price_minor : null;
+        shaped.in_stock = false;
+        byId[shaped.id] = shaped;
+        rows.push(shaped);
+      }
+
+      var placeholders = ids.map(function (_v, n) { return "?" + (n + 1); }).join(", ");
+
+      // Collection memberships — categorical facet field `collection`.
+      // MANUAL membership only (collection_members joined to a live
+      // collection), matching the edge. Smart-collection rule matches
+      // are intentionally NOT included (PD-1 convergence).
+      try {
+        var cmRes = await query(
+          "SELECT cm.product_id AS pid, cm.collection_slug AS slug " +
+          "FROM collection_members cm " +
+          "JOIN collections col ON col.slug = cm.collection_slug AND col.archived_at IS NULL " +
+          "WHERE cm.product_id IN (" + placeholders + ")",
+          ids,
+        );
+        for (var cm = 0; cm < cmRes.rows.length; cm += 1) {
+          var pr1 = byId[cmRes.rows[cm].pid];
+          if (pr1 && cmRes.rows[cm].slug) pr1.collection.push(cmRes.rows[cm].slug);
+        }
+      } catch (e) {
+        if (!(e && /no such table/i.test(e.message || ""))) throw e;
+      }
+
+      // In-stock — true when any variant SKU has available stock
+      // (stock_on_hand > stock_held). Boolean facet field `in_stock`.
+      try {
+        var invRes = await query(
+          "SELECT v.product_id AS pid, " +
+          "       MAX(CASE WHEN (inv.stock_on_hand - inv.stock_held) > 0 THEN 1 ELSE 0 END) AS any_stock " +
+          "FROM variants v " +
+          "JOIN inventory inv ON inv.sku = v.sku " +
+          "WHERE v.product_id IN (" + placeholders + ") " +
+          "GROUP BY v.product_id",
+          ids,
+        );
+        for (var iv = 0; iv < invRes.rows.length; iv += 1) {
+          var pr2 = byId[invRes.rows[iv].pid];
+          if (pr2) pr2.in_stock = Number(invRes.rows[iv].any_stock) === 1;
+        }
+      } catch (e2) {
+        if (!(e2 && /no such table/i.test(e2.message || ""))) throw e2;
+      }
+
+      return { rows: rows };
+    },
+
+    // "You may also like" siblings for a product, decorated in one
+    // query (backs PERF-1). Ported from the edge `listRelatedProducts`
+    // sibling SELECT: the other active members of `collectionSlug`
+    // (self excluded), ordered membership position ASC then product id
+    // ASC, capped at `limit`, each carrying its first variant's current
+    // price + first media row. Returns the exact
+    // `{ slug, title, hero_r2_key, hero_alt_text, price_minor,
+    // price_currency }` shape the rail renderer consumes. NOTE: this is
+    // ONLY the sibling decoration — the primary-collection lookup stays
+    // in the caller (it already has it).
+    relatedSiblings: async function (collectionSlug, excludeProductId, currency, limit) {
+      _slug(collectionSlug);
+      _id(excludeProductId, "product_id");
+      var cur = _ccy(currency);
+      var n = (Number.isInteger(limit) && limit > 0) ? limit : 4;
+      var r = await query(
+        "SELECT p.id AS id, p.slug AS slug, p.title AS title, " +
+        "       pr.amount_minor AS price_amount_minor, " +
+        "       pr.currency     AS price_currency, " +
+        "       m.r2_key        AS hero_r2_key, " +
+        "       m.alt_text      AS hero_alt_text " +
+        "FROM collection_members cm " +
+        "JOIN products p ON p.id = cm.product_id " +
+        "LEFT JOIN ( " +
+        "  SELECT iv.*, " +
+        "         ROW_NUMBER() OVER (PARTITION BY iv.product_id ORDER BY iv.position ASC, iv.created_at ASC) AS rn " +
+        "  FROM variants iv " +
+        ") v ON v.product_id = p.id AND v.rn = 1 " +
+        "LEFT JOIN prices pr ON pr.variant_id = v.id AND pr.currency = ?1 AND pr.effective_until IS NULL " +
+        "LEFT JOIN ( " +
+        "  SELECT im.*, " +
+        "         ROW_NUMBER() OVER (PARTITION BY im.product_id ORDER BY im.position ASC, im.created_at ASC) AS rn " +
+        "  FROM media im " +
+        "  WHERE im.product_id IS NOT NULL " +
+        ") m ON m.product_id = p.id AND m.rn = 1 " +
+        "WHERE cm.collection_slug = ?2 AND cm.product_id != ?3 AND p.status = 'active' " +
+        "ORDER BY cm.position ASC, cm.product_id ASC LIMIT ?4",
+        [cur, collectionSlug, excludeProductId, n],
+      );
+      return r.rows.map(function (row) {
+        return {
+          slug:           row.slug,
+          title:          row.title,
+          hero_r2_key:    row.hero_r2_key != null ? row.hero_r2_key : null,
+          hero_alt_text:  row.hero_r2_key != null ? (row.hero_alt_text || row.title) : null,
+          price_minor:    row.price_amount_minor != null ? row.price_amount_minor : null,
+          price_currency: row.price_currency || "USD",
+        };
+      });
+    },
+
+    // Variants for a set of SKUs in one query, keyed by SKU (backs
+    // PERF-9 bundle member-title batching). Returns a map sku → variant
+    // row shaped like `variants.bySku` output (options_json parsed to
+    // `options`). Used to collect every bundle member's owning product
+    // id in one hop instead of a per-member `variants.bySku`.
+    variantsBySkus: async function (skus) {
+      if (!Array.isArray(skus) || skus.length === 0) return {};
+      var unique = [];
+      var seen = Object.create(null);
+      for (var s = 0; s < skus.length; s += 1) {
+        var sk = skus[s];
+        if (typeof sk !== "string" || seen[sk]) continue;
+        seen[sk] = true;
+        unique.push(sk);
+      }
+      if (!unique.length) return {};
+      var placeholders = unique.map(function (_v, n) { return "?" + (n + 1); }).join(", ");
+      var r = await query(
+        "SELECT * FROM variants WHERE sku IN (" + placeholders + ")",
+        unique,
+      );
+      var out = {};
+      for (var i = 0; i < r.rows.length; i += 1) {
+        var row = r.rows[i];
+        row.options = JSON.parse(row.options_json);
+        out[row.sku] = row;
+      }
+      return out;
+    },
+
+    // Variants for a set of variant ids in one query, keyed by id
+    // (backs PERF-6 cart reprice). Returns a map id → variant row
+    // shaped like `variants.get` output (options_json parsed to
+    // `options`) — the same value the prior per-line `variants.get`
+    // returned, keyed by the stable variant_id the cart line carries.
+    variantsByIds: 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 || seen[vid]) continue;
+        seen[vid] = true;
+        unique.push(_id(vid, "variant id"));
+      }
+      if (!unique.length) return {};
+      var placeholders = unique.map(function (_v, i) { return "?" + (i + 1); }).join(", ");
+      var r = await query(
+        "SELECT * FROM variants WHERE id IN (" + placeholders + ")",
+        unique,
+      );
+      var out = {};
+      for (var i = 0; i < r.rows.length; i += 1) {
+        var row = r.rows[i];
+        row.options = JSON.parse(row.options_json);
+        out[row.id] = row;
+      }
+      return out;
+    },
+
+    // Products for a set of ids in one query, keyed by id (backs PERF-9
+    // bundle member-title batching). Returns a map id → product row.
+    productsByIds: async function (productIds) {
+      if (!Array.isArray(productIds) || productIds.length === 0) return {};
+      var ids = productIds.map(function (id) { return _id(id, "product id"); });
+      var placeholders = ids.map(function (_v, n) { return "?" + (n + 1); }).join(", ");
+      var r = await query(
+        "SELECT * FROM products WHERE id IN (" + placeholders + ")",
+        ids,
+      );
+      var out = {};
+      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;
+    },
+  };
+}
+
 module.exports = {
   create: create,
 };

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,
   };