@dylandepass/helix-product-pipeline 2.8.2 → 2.9.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [2.9.0](https://github.com/adobe-rnd/helix-product-pipeline/compare/v2.8.3...v2.9.0) (2026-05-08)
+
+
+### Features
+
+* add price-rules overrides ([#83](https://github.com/adobe-rnd/helix-product-pipeline/issues/83)) ([cbf9bd6](https://github.com/adobe-rnd/helix-product-pipeline/commit/cbf9bd613155176121f6148f1788d0b922192962))
+
+## [2.8.3](https://github.com/adobe-rnd/helix-product-pipeline/compare/v2.8.2...v2.8.3) (2026-04-15)
+
+
+### Bug Fixes
+
+* add cache key headers to index and sitemap responses ([#82](https://github.com/adobe-rnd/helix-product-pipeline/issues/82)) ([bce6e51](https://github.com/adobe-rnd/helix-product-pipeline/commit/bce6e510c1fd55b1c3d7f57b91edd1111e7d8f22))
+
 ## [2.8.2](https://github.com/adobe-rnd/helix-product-pipeline/compare/v2.8.1...v2.8.2) (2026-03-30)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dylandepass/helix-product-pipeline",
-  "version": "2.8.2",
+  "version": "2.9.0",
   "description": "Helix Product Pipeline",
   "main": "src/index.js",
   "types": "src/index.d.ts",
@@ -47,7 +47,7 @@
   "dependencies": {
     "@adobe/helix-html-pipeline": "6.27.9",
     "@adobe/helix-shared-utils": "3.0.2",
-    "@dylandepass/helix-product-shared": "1.6.0",
+    "@dylandepass/helix-product-shared": "1.8.4",
     "dayjs": "1.11.19",
     "github-slugger": "2.0.0",
     "hast-util-from-html": "^2.0.3",

package/src/global.d.ts

@@ -51,6 +51,8 @@ declare global {
     config: PipelineSiteConfig;
     info: PathInfo;
     content: PipelineContent;
+    catalogPriceRules?: SharedTypes.CatalogPriceRules;
+    stagePricing?: boolean;
   }
 
   export interface PipelineContent extends ImportedPipelineContent {

package/src/product-html-pipe.js

@@ -28,6 +28,8 @@ import fetch404 from './steps/fetch-404.js';
 import { setProductCacheHeaders } from './steps/set-cache-headers.js';
 import { getUnauthorizedBody } from './utils/http-response.js';
 import extractAuthoredMetadata from './steps/extract-authored-metadata.js';
+import { fetchCatalogPriceRules } from './steps/fetch-price-rules.js';
+import { applyProductPriceRule } from './steps/apply-price-rules.js';
 
 export async function productHTMLPipe(state, req) {
   const { log } = state;
@@ -101,6 +103,10 @@ export async function productHTMLPipe(state, req) {
     }
 
     transformImages(state);
+
+    await fetchCatalogPriceRules(state, req);
+    applyProductPriceRule(state, res);
+
     state.timer?.update('render');
     await html(state);
     await extractAuthoredMetadata(state);

package/src/product-index-pipe.js

@@ -16,8 +16,10 @@ import { validatePathInfo } from './utils/path.js';
 import initConfig from './steps/init-config.js';
 import fetchProductBusContent from './steps/fetch-productbus.js';
 import { setLastModified } from './utils/last-modified.js';
-import { set404CacheHeaders } from './steps/set-cache-headers.js';
+import { set404CacheHeaders, setIndexCacheHeaders } from './steps/set-cache-headers.js';
 import { getIncludes, getPaginationParams } from './steps/utils.js';
+import { fetchCatalogPriceRules } from './steps/fetch-price-rules.js';
+import { applyCatalogPriceRules } from './steps/apply-price-rules.js';
 
 /**
  * Returns index as spreadsheet with pagination support.
@@ -147,9 +149,10 @@ export async function productIndexPipe(state, req) {
       throw new PipelineStatusError(res.status, res.error);
     }
 
-    // TODO: set surrogate keys
-    // const keys = await computeJSONSurrogateKeys(state);
-    // setCachingHeaders(state, req, res, keys);
+    await setIndexCacheHeaders(state, req, res);
+
+    await fetchCatalogPriceRules(state, req);
+    applyCatalogPriceRules(state, res);
 
     setLastModified(state, res);
 

package/src/product-json-pipe.js

@@ -18,6 +18,8 @@ import fetchProductBusContent from './steps/fetch-productbus.js';
 import transformImages from './steps/transform-images.js';
 import { setLastModified } from './utils/last-modified.js';
 import { set404CacheHeaders, setProductCacheHeaders } from './steps/set-cache-headers.js';
+import { fetchCatalogPriceRules } from './steps/fetch-price-rules.js';
+import { applyProductPriceRule } from './steps/apply-price-rules.js';
 
 export async function productJSONPipe(state, req) {
   const { log, info } = state;
@@ -63,6 +65,9 @@ export async function productJSONPipe(state, req) {
 
     transformImages(state);
 
+    await fetchCatalogPriceRules(state, req);
+    applyProductPriceRule(state, res);
+
     // set surrogate keys
     await setProductCacheHeaders(state, req, res);
 

package/src/product-sitemap-pipe.js

@@ -18,7 +18,7 @@ import { validatePathInfo } from './utils/path.js';
 import initConfig from './steps/init-config.js';
 import fetchProductBusContent from './steps/fetch-productbus.js';
 import { setLastModified } from './utils/last-modified.js';
-import { set404CacheHeaders } from './steps/set-cache-headers.js';
+import { set404CacheHeaders, setSitemapCacheHeaders } from './steps/set-cache-headers.js';
 
 dayjs.extend(utc);
 
@@ -151,9 +151,7 @@ export async function productSitemapPipe(state, req) {
       throw new PipelineStatusError(res.status, res.error);
     }
 
-    // TODO: set surrogate keys
-    // const keys = await computeJSONSurrogateKeys(state);
-    // setCachingHeaders(state, req, res, keys);
+    await setSitemapCacheHeaders(state, req, res);
 
     setLastModified(state, res);
 

package/src/steps/apply-price-rules.js

@@ -0,0 +1,223 @@
+/*
+ * Copyright 2026 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+/* eslint-disable no-continue */
+
+import { recordLastModified } from '../utils/last-modified.js';
+
+/**
+ * @param {{ start?: string, end?: string }} rule
+ * @param {number} now
+ * @returns {boolean}
+ */
+function isActive(rule, now) {
+  if (rule.start && new Date(rule.start).getTime() > now) return false;
+  if (rule.end && new Date(rule.end).getTime() < now) return false;
+  return true;
+}
+
+/**
+ * Apply a catalog price rule to a product object.
+ * In product mode, mutates price.final. In index mode, mutates the flat price field.
+ * Variant rules are only applied in product mode (index entries are flat).
+ * In non-index mode, the product price is only written if the rule price is lower
+ * (a rule may be selected purely for variant benefit without improving the product price).
+ * @param {object} product
+ * @param {SharedTypes.CatalogPriceRule} rule
+ * @param {number} now
+ * @param {boolean} isIndex
+ */
+function applyRuleToProduct(product, rule, now, isIndex = false) {
+  if (rule.price != null) {
+    if (isIndex) {
+      product.price = rule.price;
+    } else if (product.price && parseFloat(rule.price) < parseFloat(product.price.final)) {
+      product.price.final = rule.price;
+    }
+  }
+
+  // Variants may be an array (product JSON) or an object keyed by SKU (stored index)
+  /** @type {SharedTypes.ProductBusVariant[]} */
+  let variantList;
+  if (Array.isArray(product.variants)) {
+    variantList = product.variants;
+  } else if (product.variants) {
+    variantList = Object.values(product.variants);
+  } else {
+    variantList = [];
+  }
+
+  for (const variant of variantList) {
+    const currentVariantPrice = isIndex ? variant.price : variant.price?.final;
+    const variantRule = rule.variants?.[variant.sku];
+    if (variantRule && isActive(variantRule, now)) {
+      if (variantRule.price != null
+        && parseFloat(variantRule.price) < parseFloat(currentVariantPrice)) {
+        if (isIndex) {
+          variant.price = variantRule.price;
+        } else if (variant.price) {
+          variant.price.final = variantRule.price;
+        }
+      }
+    } else if (rule.price != null && parseFloat(rule.price) < parseFloat(currentVariantPrice)) {
+      // inherit parent product price only if lower than variant's current price
+      if (isIndex) {
+        variant.price = rule.price;
+      } else if (variant.price) {
+        variant.price.final = rule.price;
+      }
+    }
+  }
+}
+
+/**
+ * Find the best active promotion rule for a product across all promotions.
+ * A rule qualifies if its price is lower than the product's current price OR if any of
+ * its active variant-specific prices are lower than the corresponding variant's current price.
+ * Among qualifying rules, the one with the lowest product-level price wins.
+ * @param {SharedTypes.CatalogPriceRules} catalogPriceRules
+ * @param {string} productPath
+ * @param {number} now
+ * @param {object} product - the product object (used to read current price and variant prices)
+ * @returns {SharedTypes.CatalogPriceRule | null}
+ */
+function findBestRule(catalogPriceRules, productPath, now, product) {
+  const currentPrice = parseFloat(product.price?.final ?? 'Infinity');
+
+  const variantCurrentPrices = new Map();
+  const variantList = Array.isArray(product.variants)
+    ? product.variants
+    : Object.values(product.variants ?? {});
+  for (const v of variantList) {
+    if (v.sku && v.price?.final != null) {
+      variantCurrentPrices.set(v.sku, parseFloat(v.price.final));
+    }
+  }
+
+  let bestRule = null;
+  let bestRuleProductPrice = Infinity;
+
+  for (const promotion of catalogPriceRules.promotions) {
+    for (const rule of promotion.rules) {
+      if (rule.path !== productPath) continue;
+      if (!isActive(rule, now)) continue;
+
+      const p = parseFloat(rule.price);
+      const lowersProductPrice = !Number.isNaN(p) && p < currentPrice;
+      const lowersVariantPrice = Object.entries(rule.variants ?? {}).some(([sku, vr]) => {
+        if (!isActive(vr, now) || vr.price == null) return false;
+        const currentVPrice = variantCurrentPrices.get(sku);
+        return currentVPrice !== undefined && parseFloat(vr.price) < currentVPrice;
+      });
+
+      if (!lowersProductPrice && !lowersVariantPrice) continue;
+
+      const ruleProductPrice = Number.isNaN(p) ? Infinity : p;
+      if (!bestRule || ruleProductPrice < bestRuleProductPrice) {
+        bestRuleProductPrice = ruleProductPrice;
+        bestRule = rule;
+      }
+    }
+  }
+
+  return bestRule;
+}
+
+/**
+ * Apply catalog price rules to state.content.data (single product request).
+ * Finds the lowest active promotion price for the product path and applies it only
+ * if it is less than the product's current price. Also records the most recently
+ * started active rule's start time as a last-modified source.
+ * @param {PipelineState} state
+ * @param {PipelineResponse} [res]
+ */
+export function applyProductPriceRule(state, res) {
+  const { catalogPriceRules, content, info } = state;
+  if (!catalogPriceRules?.promotions?.length || !content?.data) return;
+
+  const productPath = info.path.replace(/\.(json|html)$/, '');
+  const now = Date.now();
+  const rule = findBestRule(catalogPriceRules, productPath, now, content.data);
+  if (rule) applyRuleToProduct(content.data, rule, now, false);
+
+  if (res) {
+    let newestStartMs = 0;
+    for (const promotion of catalogPriceRules.promotions) {
+      for (const r of promotion.rules) {
+        if (r.path !== productPath || !isActive(r, now) || !r.start) continue;
+        const ms = new Date(r.start).getTime();
+        if (ms > newestStartMs) newestStartMs = ms;
+      }
+    }
+    if (newestStartMs) {
+      recordLastModified(state, res, 'price-rules', new Date(newestStartMs).toUTCString());
+    }
+  }
+}
+
+/**
+ * Apply catalog price rules to the stored index (index request).
+ * For each product, finds the lowest active promotion price and applies it only
+ * if it is less than the product's current price. Also records the most recently
+ * started active rule's start time (across all paths in the index) as a last-modified source.
+ * @param {PipelineState} state
+ * @param {PipelineResponse} [res]
+ */
+export function applyCatalogPriceRules(state, res) {
+  const { catalogPriceRules, content } = state;
+  if (!catalogPriceRules?.promotions?.length || !content?.data) return;
+
+  const now = Date.now();
+
+  // Build a path → best rule map and a path → newest start map across all promotions
+  /** @type {Map<string, SharedTypes.CatalogPriceRule>} */
+  const bestRuleByPath = new Map();
+  /** @type {Map<string, number>} */
+  const newestStartMsByPath = new Map();
+  for (const promotion of catalogPriceRules.promotions) {
+    for (const rule of promotion.rules) {
+      if (!isActive(rule, now)) continue;
+      const price = parseFloat(rule.price);
+      if (Number.isNaN(price)) continue;
+      const current = bestRuleByPath.get(rule.path);
+      if (!current || price < parseFloat(current.price)) {
+        bestRuleByPath.set(rule.path, rule);
+      }
+      if (rule.start) {
+        const startMs = new Date(rule.start).getTime();
+        if (startMs > (newestStartMsByPath.get(rule.path) ?? 0)) {
+          newestStartMsByPath.set(rule.path, startMs);
+        }
+      }
+    }
+  }
+
+  let newestStartMs = 0;
+  for (const entry of Object.values(content.data)) {
+    const product = entry?.data;
+    // eslint-disable-next-line no-continue
+    if (!product?.path) continue;
+    const rule = bestRuleByPath.get(product.path);
+    if (!rule) continue;
+    const rulePrice = parseFloat(rule.price);
+    const productPrice = parseFloat(product.price);
+    if (!Number.isNaN(productPrice) && rulePrice < productPrice) {
+      applyRuleToProduct(product, rule, now, true);
+    }
+    const startMs = newestStartMsByPath.get(product.path) ?? 0;
+    if (startMs > newestStartMs) newestStartMs = startMs;
+  }
+
+  if (newestStartMs && res) {
+    recordLastModified(state, res, 'price-rules', new Date(newestStartMs).toUTCString());
+  }
+}

package/src/steps/fetch-price-rules.js

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2026 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+const PRICING_BUCKET_ID = 'helix-commerce-pricing';
+const PRICING_BUCKET_DEV_ID = 'helix-commerce-pricing-dev';
+
+/**
+ * @param {string} org
+ * @param {string} site
+ * @returns {string}
+ */
+function catalogRulesKey(org, site) {
+  return `${org}/${site}/prices/catalog/rules.json`;
+}
+
+/** @returns {SharedTypes.CatalogPriceRules} */
+function emptyRules() {
+  return { promotions: [] };
+}
+
+/**
+ * Fetch all catalog price rules. Sets state.catalogPriceRules.
+ * When the request carries `x-env: stage`, fetches from the dev pricing bucket and sets
+ * state.stagePricing = true so cache headers can be suppressed downstream.
+ * Used for both single-product and index routes.
+ * @param {PipelineState} state
+ * @param {PipelineRequest} [req]
+ */
+export async function fetchCatalogPriceRules(state, req) {
+  const { org, site, s3Loader } = state;
+  const useStagePricing = req?.headers?.get('x-env') === 'stage';
+  const bucketId = useStagePricing
+    ? PRICING_BUCKET_DEV_ID
+    : PRICING_BUCKET_ID;
+  if (useStagePricing) {
+    state.log.info('fetching catalog price rules from dev bucket');
+    state.stagePricing = true;
+  }
+
+  /** @type {PipelineResponse} */
+  let res;
+  try {
+    res = await s3Loader.getObject(bucketId, catalogRulesKey(org, site));
+    if (res.status !== 200) {
+      state.catalogPriceRules = emptyRules();
+      return;
+    }
+
+    /** @type {SharedTypes.CatalogPriceRules} */
+    const rules = JSON.parse(res.body);
+    if (!rules || !Array.isArray(rules.promotions)) {
+      state.catalogPriceRules = emptyRules();
+      return;
+    }
+
+    const now = Date.now();
+
+    // Pre-filter rules whose end is already past; remove promotions with no remaining rules
+    state.catalogPriceRules = {
+      promotions: rules.promotions
+        .map((promotion) => ({
+          ...promotion,
+          rules: promotion.rules.filter((rule) => !rule.end || new Date(rule.end).getTime() > now),
+        }))
+        .filter((promotion) => promotion.rules.length > 0),
+    };
+  } catch (e) {
+    state.log.warn(`failed to fetch catalog price rules: ${res?.status ?? 'unknown error'}`, e);
+    state.catalogPriceRules = emptyRules();
+  }
+}

package/src/steps/set-cache-headers.js

@@ -16,8 +16,11 @@ import {
   computeProductPathKey,
   computeSiteKey,
   compute404Key,
+  computePriceRulesKey,
   computeAuthoredContentKey,
   computeProductKeys,
+  computeIndexKeys,
+  computeSitemapKeys,
 } from '@dylandepass/helix-product-shared';
 import { applyByoCdnHeaders } from '../utils/cache-headers.js';
 
@@ -105,4 +108,35 @@ export async function setProductCacheHeaders(state, req, resp) {
 
   const productKeys = await computeProductKeys(org, site, info.path, contentBusId);
   setCachingHeaders(req, resp, productKeys);
+  if (state.stagePricing) resp.headers.set('cache-control', 'no-store');
+}
+
+/**
+ * Sets the cache headers for an index.json resource
+ * @param {PipelineState} state
+ * @param {PipelineRequest} req
+ * @param {PipelineResponse} resp
+ * @returns {Promise<void>}
+ */
+export async function setIndexCacheHeaders(state, req, resp) {
+  const { org, site, info } = state;
+  const keys = await computeIndexKeys(org, site, info.path);
+  keys.push(computePriceRulesKey(org, site));
+  setCachingHeaders(req, resp, keys);
+  if (state.stagePricing) resp.headers.set('cache-control', 'no-store');
+}
+
+/**
+ * Sets the cache headers for a sitemap.xml resource
+ * @param {PipelineState} state
+ * @param {PipelineRequest} req
+ * @param {PipelineResponse} resp
+ * @returns {Promise<void>}
+ */
+export async function setSitemapCacheHeaders(state, req, resp) {
+  const { org, site, info } = state;
+  const keys = await computeSitemapKeys(org, site, info.path);
+  keys.push(computePriceRulesKey(org, site));
+  setCachingHeaders(req, resp, keys);
+  if (state.stagePricing) resp.headers.set('cache-control', 'no-store');
 }