@teleporthq/teleport-plugin-next-data-source 0.43.62 → 0.43.64

package/src/transformations/blog-post.ts

@@ -1,13 +1,25 @@
+import type { UIDLEcommerceCategory } from '@teleporthq/teleport-types'
+import { generateCategoryTaxonomyCode } from './category-taxonomy'
+
+/** What the blog-post transform bakes in at export time beyond the row itself. */
+export interface BlogPostTransformOptions {
+  /** Category taxonomy — lives only in the UIDL, there is no DB table for it. */
+  categories?: UIDLEcommerceCategory[]
+}
+
 /**
  * Generates JavaScript code for blog post data transformation.
  * Transforms raw snake_case database records into the camelCase shape
  * that UIDL components expect.
  */
-export const generateBlogPostTransformationCode = (): string => {
+export const generateBlogPostTransformationCode = (
+  options: BlogPostTransformOptions = {}
+): string => {
   return `
 // ============================================================
 // Blog Post Transformation
 // ============================================================
+${generateCategoryTaxonomyCode('BLOG_CATEGORIES_BY_ID', options.categories)}
 
 function buildBlogPost(record, options) {
   if (!record || typeof record !== 'object') return record
@@ -24,6 +36,20 @@ function buildBlogPost(record, options) {
   var content = resolveI18nField(record, 'content', 'content', currentLang, mainLang) || ''
   var excerpt = resolveI18nField(record, 'excerpt', 'excerpt', currentLang, mainLang) || ''
   var category = resolveI18nField(record, 'category', 'category', currentLang, mainLang) || null
+
+  // Assigned category ids -> resolved {id,name,slug} objects for the post-details
+  // BREADCRUMBS (and anything else mapping over them). The taxonomy itself is not
+  // in the DB (categories are authored in the GUI and live only in
+  // blogSettings.categories); resolved against BLOG_CATEGORIES_BY_ID, baked in at
+  // export time. Unknown/stale ids are silently dropped. \`category\` above stays
+  // the denormalized PRIMARY name.
+  var categories = resolveAssignedCategories(
+    record.category_ids,
+    BLOG_CATEGORIES_BY_ID,
+    currentLang,
+    mainLang,
+    category
+  )
   var metaTitle = resolveI18nField(record, 'meta_title', 'metaTitle', currentLang, mainLang) || null
   var metaDescription = resolveI18nField(record, 'meta_description', 'metaDescription', currentLang, mainLang) || null
   var featuredImageAlt = resolveI18nField(record, 'featured_image_alt', 'featuredImageAlt', currentLang, mainLang) || null
@@ -145,6 +171,7 @@ function buildBlogPost(record, options) {
     excerpt: excerpt,
     status: status,
     category: category,
+    categories: categories,
     tags: tags,
     relatedPostIds: relatedPostIds,
     relatedPosts: relatedPosts,
@@ -179,14 +206,6 @@ function transformBlogPosts(records, options) {
   return records.map(function(record) { return buildBlogPost(record, options) })
 }
 
-// Trims a per-post SEO URL cell; blank/non-string values (including columns
-// that don't exist yet on tables provisioned before the feature) become null.
-function normalizeSeoUrlField(value) {
-  if (typeof value !== 'string') return null
-  var trimmed = value.trim()
-  return trimmed.length > 0 ? trimmed : null
-}
-
 // Batched fetch of the post rows a set of posts reference as "related", keyed by
 // id. Best-effort in the same way as the product side: a table provisioned
 // before the column yields no ids (the read is of an absent property, not of a

package/src/transformations/category-taxonomy.ts

@@ -0,0 +1,107 @@
+import type { UIDLEcommerceCategory } from '@teleporthq/teleport-types'
+
+/**
+ * The category-taxonomy half of the entity transforms, shared by products and
+ * blog posts.
+ *
+ * A taxonomy has no DB table — it lives only in the UIDL
+ * (`ecommerceSettings.categories` / `blogSettings.categories`, baked at export
+ * time), so each generated fetcher carries its own flattened copy and resolves
+ * the row's `category_ids` against it with no runtime lookup.
+ */
+
+/** What the runtime map holds per category id. */
+export interface BakedCategoryInfo {
+  name: string
+  slug: string
+  translations?: UIDLEcommerceCategory['translations']
+}
+
+/**
+ * Flattens the nested category tree into an `id -> {name, slug, translations}`
+ * lookup map. `translations` is carried through UNRESOLVED (a per-language
+ * `{name, description}` map) so the transform can resolve it against the SAME
+ * per-request `currentLanguage`/`mainLanguage` used for every other i18n field —
+ * `slug` is never localized (it is the language-neutral join key). Tolerant of a
+ * missing/malformed tree.
+ */
+export const flattenCategoriesById = (
+  categories: UIDLEcommerceCategory[] | undefined
+): Record<string, BakedCategoryInfo> => {
+  const byId: Record<string, BakedCategoryInfo> = {}
+  const visit = (nodes: UIDLEcommerceCategory[] | undefined): void => {
+    if (!Array.isArray(nodes)) {
+      return
+    }
+    for (const node of nodes) {
+      if (node && typeof node.id === 'string') {
+        byId[node.id] = {
+          name: node.name || '',
+          slug: node.slug || '',
+          translations: node.translations,
+        }
+        visit(node.children)
+      }
+    }
+  }
+  visit(categories)
+  return byId
+}
+
+/**
+ * The baked map plus the `resolveCategoryName` helper the transforms call.
+ * Emitted once per fetcher file — the two entity transforms are never
+ * concatenated into the same file (`getTransformationCode` picks one per table),
+ * so the helper name is unambiguous.
+ */
+export const generateCategoryTaxonomyCode = (
+  mapVarName: string,
+  categories: UIDLEcommerceCategory[] | undefined
+): string => `
+// Category taxonomy (id -> {name, slug, translations}), baked in at export
+// time — see flattenCategoriesById in category-taxonomy.ts. Empty when the
+// project has no taxonomy, or the row's category_ids simply resolve to nothing.
+var ${mapVarName} = ${JSON.stringify(flattenCategoriesById(categories))}
+
+// Resolve a baked category's name to currentLang/mainLang from its
+// translations map (same per-request locale as every other i18n field via
+// resolveI18nField), falling back to the main-language name.
+function resolveCategoryName(categoryInfo, currentLang, mainLang) {
+  if (currentLang && mainLang && currentLang !== mainLang && categoryInfo.translations) {
+    var override = categoryInfo.translations[currentLang]
+    if (override && override.name) return override.name
+  }
+  return categoryInfo.name
+}
+
+// The row's assigned category ids -> resolved {id, name, slug} objects, in the
+// order they were assigned. Ids that resolve to nothing (a deleted category) are
+// silently dropped. MUST mirror resolveAssignedCategories in the editor
+// (teleport-gui features/shared/taxonomy/category-tree.ts), which is what the
+// canvas renders from.
+function resolveAssignedCategories(categoryIdsRaw, byId, currentLang, mainLang, legacyName) {
+  var ids = parseJsonArray(categoryIdsRaw)
+  var out = []
+  for (var ci = 0; ci < ids.length; ci++) {
+    var info = byId[ids[ci]]
+    if (!info) continue
+    out.push({
+      id: ids[ci],
+      name: resolveCategoryName(info, currentLang, mainLang),
+      slug: info.slug,
+    })
+  }
+  // A row that predates the id column, or one imported with only a name, still
+  // shows what it carries — with an EMPTY id, so a filter link built from it
+  // carries no value and every listing reads that as "no filter".
+  if (out.length === 0 && typeof legacyName === 'string' && legacyName.trim()) {
+    var trimmed = legacyName.trim()
+    out.push({
+      id: '',
+      name: trimmed,
+      slug: trimmed.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'category',
+    })
+  }
+  return out
+}
+`

package/src/transformations/custom-page.ts

@@ -0,0 +1,83 @@
+/**
+ * Generates JavaScript code for the `teleport_pages` row transformation — the
+ * rows the Custom Pages feature stores from its admin panel.
+ *
+ * The raw row is kept whole (every column, snake_case) and the SEO fields are
+ * normalised beside it under camelCase names, the same way the blog post
+ * transform exposes its per-post overrides. That is what lets the page's
+ * `<Head>` bind `metaTitle` / `robotsContent` / `canonicalUrl` / the Open Graph
+ * fields with plain `??` fallbacks, and lets getStaticProps answer the row's
+ * own redirect — without a single table-specific branch in the head or the
+ * static-props generators.
+ *
+ * `metaTitle` falls back to `title`: the column is nullable so an author who
+ * never filled it in still gets a real `<title>`, and `ogTitle`/`ogDescription`
+ * fall back to the meta pair for the same reason.
+ */
+export const generateCustomPageTransformationCode = (): string => {
+  return `
+// ============================================================
+// Custom Page Transformation
+// ============================================================
+
+function buildCustomPage(record, options) {
+  if (!record || typeof record !== 'object') return record
+  options = options || {}
+  var assetMap = options.assetMap || {}
+
+  // Every stored column travels through untouched — the blocks column above
+  // all, which the page's array mapper parses — and the normalised SEO fields
+  // are added beside them.
+  var out = {}
+  for (var key in record) {
+    if (Object.prototype.hasOwnProperty.call(record, key)) out[key] = record[key]
+  }
+
+  var title = typeof record.title === 'string' ? record.title : ''
+  var metaTitle = normalizeSeoTextField(pickFirst(record.meta_title, record.metaTitle)) || title || null
+  var metaDescription = normalizeSeoTextField(pickFirst(record.meta_description, record.metaDescription))
+
+  var noIndex = coerceBoolean(pickFirst(record.no_index, record.noIndex), false)
+  var canonicalUrl = normalizeSeoUrlField(pickFirst(record.canonical_url, record.canonicalUrl))
+  var redirectUrl = normalizeSeoUrlField(pickFirst(record.redirect_url, record.redirectUrl))
+  var rawRedirectType = pickFirst(record.redirect_type, record.redirectType)
+  var redirectType =
+    redirectUrl && (rawRedirectType === '301' || rawRedirectType === '302')
+      ? rawRedirectType
+      : null
+  // null — never '' or false — for unset rows, so the page-level fallback (the
+  // \`??\` in the generated Head) can take over.
+  var robotsContent = noIndex ? 'noindex' : null
+
+  var ogTitle = normalizeSeoTextField(pickFirst(record.og_title, record.ogTitle)) || metaTitle
+  var ogDescription =
+    normalizeSeoTextField(pickFirst(record.og_description, record.ogDescription)) || metaDescription
+  var rawOgImage = normalizeSeoUrlField(pickFirst(record.og_image, record.ogImage))
+  var ogImage = rawOgImage ? resolveAssetUrl(rawOgImage, assetMap) || rawOgImage : null
+
+  out.metaTitle = metaTitle
+  out.metaDescription = metaDescription
+  out.noIndex = noIndex
+  out.canonicalUrl = canonicalUrl
+  out.redirectUrl = redirectUrl
+  out.redirectType = redirectType
+  out.robotsContent = robotsContent
+  out.ogTitle = ogTitle
+  out.ogDescription = ogDescription
+  out.ogImage = ogImage
+  return out
+}
+
+function transformCustomPages(records, options) {
+  if (!Array.isArray(records)) return []
+  return records.map(function(record) { return buildCustomPage(record, options) })
+}
+
+// Trims a free-text SEO cell; blank/non-string values become null.
+function normalizeSeoTextField(value) {
+  if (typeof value !== 'string') return null
+  var trimmed = value.trim()
+  return trimmed.length > 0 ? trimmed : null
+}
+`
+}

package/src/transformations/ecommerce-product.ts

@@ -1,5 +1,6 @@
 import type { UIDLEcommerceCategory } from '@teleporthq/teleport-types'
-import { ProductDiscounts, StorefrontTax } from '@teleporthq/teleport-shared'
+import { ProductDiscounts, ProductRatings, StorefrontTax } from '@teleporthq/teleport-shared'
+import { generateCategoryTaxonomyCode } from './category-taxonomy'
 
 /**
  * Everything the product transform needs baked in at export time, beyond the
@@ -28,47 +29,6 @@ export interface EcommerceProductTransformOptions {
   allowBackorders?: boolean
 }
 
-/**
- * Flattens the nested category tree (`ecommerceSettings.categories`, baked at
- * export time) into an `id -> {name, slug, translations}` lookup map,
- * JSON-embedded into the generated transform below so a product's
- * `category_ids` can be resolved to display names with no runtime DB lookup
- * (there is no DB table for the taxonomy — it lives only in the UIDL).
- * `translations` is carried through unresolved (a per-language `{name,
- * description}` map) so `buildEcommerceProduct` can resolve it against the
- * SAME per-request `currentLanguage`/`mainLanguage` used for every other i18n
- * field — `slug` is never localized (it's the language-neutral join key).
- * Tolerant of a missing/malformed tree.
- */
-const flattenCategoriesById = (
-  categories: UIDLEcommerceCategory[] | undefined
-): Record<
-  string,
-  { name: string; slug: string; translations?: UIDLEcommerceCategory['translations'] }
-> => {
-  const byId: Record<
-    string,
-    { name: string; slug: string; translations?: UIDLEcommerceCategory['translations'] }
-  > = {}
-  const visit = (nodes: UIDLEcommerceCategory[] | undefined): void => {
-    if (!Array.isArray(nodes)) {
-      return
-    }
-    for (const node of nodes) {
-      if (node && typeof node.id === 'string') {
-        byId[node.id] = {
-          name: node.name || '',
-          slug: node.slug || '',
-          translations: node.translations,
-        }
-        visit(node.children)
-      }
-    }
-  }
-  visit(categories)
-  return byId
-}
-
 /**
  * Generates JavaScript code for e-commerce product data transformation.
  * Transforms raw snake_case database records into the camelCase shape
@@ -77,7 +37,6 @@ const flattenCategoriesById = (
 export const generateEcommerceProductTransformationCode = (
   options: EcommerceProductTransformOptions = {}
 ): string => {
-  const categoriesByIdJson = JSON.stringify(flattenCategoriesById(options.categories))
   const taxHelperCode = StorefrontTax.generateStorefrontTaxHelperCode(
     options.storefrontTaxRate ?? 0
   )
@@ -86,29 +45,14 @@ export const generateEcommerceProductTransformationCode = (
   return `
 ${taxHelperCode}
 ${ProductDiscounts.generateProductDiscountHelperCode()}
+${ProductRatings.generateProductRatingHelperCode()}
 
 // Baked from the merchant's stock settings: TRUE when stock never blocks a
 // purchase (stock management off OR backorders allowed). Regenerating the
 // project refreshes it — do not hand-edit. See EcommerceProductTransformOptions.
 var ALLOW_BACKORDERS = ${allowBackordersLiteral}
 
-// Category taxonomy (id -> {name, slug, translations}), baked in at export
-// time — see flattenCategoriesById in ecommerce-product.ts. Empty when the
-// store has no category taxonomy, or products.category_ids simply resolves
-// to nothing.
-var PRODUCT_CATEGORIES_BY_ID = ${categoriesByIdJson}
-
-// Resolve a baked category's name to currentLang/mainLang from its
-// translations map (same per-request locale as every other i18n field via
-// resolveI18nField), falling back to the main-language name.
-function resolveCategoryName(categoryInfo, currentLang, mainLang) {
-  if (currentLang && mainLang && currentLang !== mainLang && categoryInfo.translations) {
-    var override = categoryInfo.translations[currentLang]
-    if (override && override.name) return override.name
-  }
-  return categoryInfo.name
-}
-
+${generateCategoryTaxonomyCode('PRODUCT_CATEGORIES_BY_ID', options.categories)}
 // The merchant's "Show 3D model by default" toggle, as every backend may hand
 // it back: a real boolean, 1/0, 'true'/'false'/'t'/'f' strings — and NULL /
 // absent / '' as ON, because a product that has a model shows it unless the
@@ -251,24 +195,17 @@ function buildEcommerceProduct(record, options) {
     visibleProperties.push(classifyProductProperty(propKey, propValue))
   })
 
-  // Assigned category ids -> resolved {id,name,slug} objects for the
-  // storefront category pills mapper. The taxonomy itself is not in the DB
-  // (categories are authored in the GUI and live only in
-  // ecommerceSettings.categories); resolved here against PRODUCT_CATEGORIES_BY_ID,
-  // baked in at export time (see flattenCategoriesById). Unknown/stale ids
-  // (a deleted category) are silently dropped.
-  var categoryIds = parseJsonArray(record.category_ids)
-  var categories = []
-  for (var ci = 0; ci < categoryIds.length; ci++) {
-    var categoryInfo = PRODUCT_CATEGORIES_BY_ID[categoryIds[ci]]
-    if (categoryInfo) {
-      categories.push({
-        id: categoryIds[ci],
-        name: resolveCategoryName(categoryInfo, currentLang, mainLang),
-        slug: categoryInfo.slug,
-      })
-    }
-  }
+  // Assigned category ids -> resolved {id,name,slug} objects for the storefront
+  // category pills mapper and the product-details breadcrumbs. The taxonomy
+  // itself is not in the DB (categories are authored in the GUI and live only in
+  // ecommerceSettings.categories); resolved against PRODUCT_CATEGORIES_BY_ID,
+  // baked in at export time. Unknown/stale ids are silently dropped.
+  var categories = resolveAssignedCategories(
+    record.category_ids,
+    PRODUCT_CATEGORIES_BY_ID,
+    currentLang,
+    mainLang
+  )
 
   // Purchasable variant COMBINATIONS for this product ({id, options map, price,
   // stock, image}). Empty for flat products. Fetched in ONE batched query by
@@ -323,6 +260,9 @@ function buildEcommerceProduct(record, options) {
       // card's picker. The batched query includes the related ids for exactly
       // this reason (see getTransformWrapperCode).
       variantsByProductId: options.variantsByProductId,
+      // Same reason: a related card draws its own star row, and the batched
+      // aggregate already covered its id.
+      ratingsByProductId: options.ratingsByProductId,
     }
     for (var rp = 0; rp < relatedProductIds.length; rp++) {
       var relatedId = relatedProductIds[rp]
@@ -531,6 +471,31 @@ function buildEcommerceProduct(record, options) {
     (requiresVariantSelection !== 'true' || !variantsResolved || hasInStockCombination)
       ? 'true'
       : 'false'
+  // Aggregate review rating, from ONE batched COUNT/AVG over approved reviews
+  // that transformRecords runs for every product on the page (keyed by product
+  // id in options.ratingsByProductId).
+  //
+  // ⛔ An ABSENT entry and a NULL map both mean "no rating to show", never "0
+  // stars": a product nobody has reviewed and a product whose rating query
+  // failed must both render with no stars at all. "0.0 out of 5" is the single
+  // worst thing a storefront can say about a product by accident.
+  //
+  // MUST mirror buildProductRatingFields in the GUI's
+  // features/e-commerce/utils/product-ratings.ts.
+  var ratingsByProductId = options.ratingsByProductId || {}
+  var ratingFields = __prBuildRatingFields(id != null ? ratingsByProductId[id] : null)
+
+  // The individual reviews behind those stars, for the product page's JSON-LD.
+  // Fetched ONLY for a single-product request (see getTransformWrapperCode), so
+  // this is an empty array on every listing — which is correct: a listing emits
+  // no Product markup to put them in.
+  //
+  // Not rendered anywhere. That is why there is no canvas mirror for it: the
+  // three-mirror rule exists for fields the editor DRAWS, and structured data
+  // is a publish-time concern the canvas has no equivalent of.
+  var reviewsByProductId = options.reviewsByProductId || {}
+  var reviews = (id != null && reviewsByProductId[id]) || []
+
   // Stringified companions: a data-* attr bound to an ARRAY renders
   // '[object Object]', so the picker's on-mount/click workflows read the
   // combinations + axes from these JSON strings via getAttribute.
@@ -598,6 +563,22 @@ function buildEcommerceProduct(record, options) {
     originalDisplayPrice: originalDisplayPrice,
     originalDefaultVariantDisplayPrice: originalDefaultVariantDisplayPrice,
     hasPurchasableVariant: hasPurchasableVariant,
+    // Aggregate review rating — see the ratingFields block above.
+    ratingAverage: ratingFields.ratingAverage,
+    ratingCount: ratingFields.ratingCount,
+    ratingAverageLabel: ratingFields.ratingAverageLabel,
+    ratingCountLabel: ratingFields.ratingCountLabel,
+    hasRatings: ratingFields.hasRatings,
+    ratingStar1: ratingFields.ratingStar1,
+    ratingStar2: ratingFields.ratingStar2,
+    ratingStar3: ratingFields.ratingStar3,
+    ratingStar4: ratingFields.ratingStar4,
+    ratingStar5: ratingFields.ratingStar5,
+    // Domain-shaped, not schema.org-shaped: the head-config plugin's
+    // 'reviewList' computed kind does the vocabulary. NO BACKTICKS ANYWHERE IN
+    // THIS FILE — it is one template literal, and a backtick in a comment ends
+    // the string.
+    reviews: reviews,
   }
 }
 
@@ -871,6 +852,124 @@ async function getRelatedProductsMap(getClientFn, records) {
   return map
 }
 
+// Aggregate review rating for every product on the page, keyed by product id,
+// so a card can draw its star row without a query per product.
+//
+// APPROVED ONLY, and 'approved' is a fixed literal rather than a bound value
+// because nothing may ever widen it: a pending review is one the merchant has
+// not agreed to publish, and a rejected one is a review they actively removed.
+//
+// Unlike getVariantsMap this returns an EMPTY MAP on failure rather than null.
+// The two "unknown" answers differ because the consequences differ: an unknown
+// variant map must stay permissive (never make a catalogue unbuyable), whereas
+// an unknown rating has exactly one safe rendering — no stars — which is also
+// what a product with no reviews shows. Collapsing both onto {} means every
+// caller has one case to handle instead of two.
+async function getRatingsMap(getClientFn, productIds) {
+  var map = {}
+  if (!Array.isArray(productIds) || productIds.length === 0) return map
+  var uniqueIds = []
+  var seenIds = {}
+  for (var u = 0; u < productIds.length; u++) {
+    var pid0 = productIds[u]
+    if (pid0 != null && !seenIds[pid0]) { seenIds[pid0] = true; uniqueIds.push(pid0) }
+  }
+  if (uniqueIds.length === 0) return map
+  var client
+  try {
+    client = getClientFn()
+    await client.connect()
+    var result = await client.query(
+      "SELECT product_id, AVG(rating)::float AS average, COUNT(*)::int AS count " +
+        'FROM teleport_product_reviews ' +
+        "WHERE status = 'approved' AND rating IS NOT NULL AND product_id = ANY($1) " +
+        'GROUP BY product_id',
+      [uniqueIds]
+    )
+    if (result && result.rows) {
+      for (var r = 0; r < result.rows.length; r++) {
+        var row = result.rows[r]
+        if (row && row.product_id != null) {
+          map[row.product_id] = { average: row.average, count: row.count }
+        }
+      }
+    }
+  } catch (e) {
+    // teleport_product_reviews may not exist (reviews were never enabled), or
+    // the query may have failed. Either way there is no rating to show, which
+    // is exactly what an empty map produces.
+    map = {}
+  } finally {
+    if (client) {
+      try { await client.end() } catch (e) { /* ignore */ }
+    }
+  }
+  return map
+}
+
+// The most recent APPROVED reviews for a product, for the product page's
+// structured data. Keyed by product id like every other batched lookup, though
+// in practice it is only ever called with one id.
+//
+// Three filters, and each one exists because of what the output is used for:
+//  - APPROVED only, as a fixed literal, for the same reason the aggregate is:
+//    a pending review is one the merchant has not agreed to publish.
+//  - A NON-EMPTY reviewer name. Google requires author.name on a review
+//    snippet, and an anonymous row would produce a Review object it rejects —
+//    taking the whole Product block down with it on some validators.
+//  - A CAP. The reviews are inlined into the page's props and then into its
+//    HTML twice over (once as data, once as JSON-LD); a product with four
+//    hundred reviews would otherwise put all of them in both.
+async function getProductReviewsMap(getClientFn, productIds, perProduct) {
+  var map = {}
+  if (!Array.isArray(productIds) || productIds.length === 0) return map
+  var uniqueIds = []
+  var seenIds = {}
+  for (var u = 0; u < productIds.length; u++) {
+    var pid0 = productIds[u]
+    if (pid0 != null && !seenIds[pid0]) { seenIds[pid0] = true; uniqueIds.push(pid0) }
+  }
+  if (uniqueIds.length === 0) return map
+  var client
+  try {
+    client = getClientFn()
+    await client.connect()
+    var result = await client.query(
+      'SELECT product_id, reviewer_name, rating, content, created_at ' +
+        'FROM teleport_product_reviews ' +
+        "WHERE status = 'approved' AND rating IS NOT NULL " +
+        "AND reviewer_name IS NOT NULL AND btrim(reviewer_name) <> '' " +
+        'AND product_id = ANY($1) ' +
+        'ORDER BY created_at DESC',
+      [uniqueIds]
+    )
+    var cap = typeof perProduct === 'number' && perProduct > 0 ? perProduct : 5
+    if (result && result.rows) {
+      for (var r = 0; r < result.rows.length; r++) {
+        var row = result.rows[r]
+        if (!row || row.product_id == null) continue
+        var bucket = map[row.product_id] || (map[row.product_id] = [])
+        if (bucket.length >= cap) continue
+        bucket.push({
+          author: String(row.reviewer_name).trim(),
+          rating: Number(row.rating),
+          body: row.content == null ? '' : String(row.content),
+          datePublished: row.created_at ? new Date(row.created_at).toISOString() : null,
+        })
+      }
+    }
+  } catch (e) {
+    // The reviews table may not exist (reviews were never enabled). No reviews
+    // to show is both the empty answer and the safe one.
+    map = {}
+  } finally {
+    if (client) {
+      try { await client.end() } catch (e) { /* ignore */ }
+    }
+  }
+  return map
+}
+
 // Combinations for every product on the page, keyed by product id. Returns NULL
 // when the lookup could not run, which the transform reads as "unknown" and
 // stays permissive with; an empty map means the query ran and this catalogue