@dylandepass/helix-product-pipeline 2.0.2 → 2.2.0

package/CHANGELOG.md

@@ -1,3 +1,23 @@
+# [2.2.0](https://github.com/adobe-rnd/helix-product-pipeline/compare/v2.1.0...v2.2.0) (2026-02-04)
+
+
+### Features
+
+* Remove media pipe and move to helix-product-pipeline-worker ([645d2f5](https://github.com/adobe-rnd/helix-product-pipeline/commit/645d2f5850f0b4f5abfe25e6330c68e31508d812))
+
+# [2.1.0](https://github.com/adobe-rnd/helix-product-pipeline/compare/v2.0.2...v2.1.0) (2026-02-03)
+
+
+### Bug Fixes
+
+* support metadata from edge ([8a9c032](https://github.com/adobe-rnd/helix-product-pipeline/commit/8a9c032f2b5e55449a4677e4ce6f4adb62d9c9a2))
+* update tests ([f0cb051](https://github.com/adobe-rnd/helix-product-pipeline/commit/f0cb051da917b2b5c3d56e460f2c9b9284da9a0c))
+
+
+### Features
+
+* extract metadata from authored edge content and optimize cache keys ([0be7f2b](https://github.com/adobe-rnd/helix-product-pipeline/commit/0be7f2b90424216f3a29d8fd536ac19407281947))
+
 ## [2.0.2](https://github.com/adobe-rnd/helix-product-pipeline/compare/v2.0.1...v2.0.2) (2026-01-29)
 
 

package/README.md

@@ -34,6 +34,7 @@ Helix Product Pipeline is the shared rendering engine that powers both `helix-pr
 
 - Fetches product data from Product Bus storage
 - Optionally merges with authored content from Edge Delivery Services
+- Extracts metadata from authored content head and merges into product head
 - Generates responsive picture elements with multiple breakpoints (600px, 750px/2000px)
 - Creates schema.org JSON-LD structured data for rich search results
 - Adds heading IDs for navigation and anchor links
@@ -50,12 +51,13 @@ The HTML pipeline executes these processing steps in sequence:
 4. **make-html** - Create initial HTML structure
 5. **render-head** - Generate HTML head with meta tags
 6. **fetch-edge-product** - Optionally fetch authored content from Edge Delivery
-7. **render-body** - Render product content, images, and variants
-8. **render-jsonld** - Generate schema.org JSON-LD structured data
-9. **add-heading-ids** - Add IDs to headings for anchor navigation
-10. **create-pictures** - Generate responsive picture elements
-11. **stringify-response** - Serialize to HTML string
-12. **set-cache-headers** - Set CDN and browser cache headers with surrogate keys
+7. **extract-authored-metadata** - Extract metadata from authored content and merge into product head
+8. **render-body** - Render product content, images, and variants
+9. **render-jsonld** - Generate schema.org JSON-LD structured data
+10. **add-heading-ids** - Add IDs to headings for anchor navigation
+11. **create-pictures** - Generate responsive picture elements
+12. **stringify-response** - Serialize to HTML string
+13. **set-cache-headers** - Set CDN and browser cache headers with surrogate keys
 
 ### CDN Support
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dylandepass/helix-product-pipeline",
-  "version": "2.0.2",
+  "version": "2.2.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.3.2",
+    "@dylandepass/helix-product-shared": "1.5.2",
     "dayjs": "1.11.19",
     "github-slugger": "2.0.0",
     "hast-util-from-html": "^2.0.3",

package/src/global.d.ts

@@ -50,7 +50,8 @@ declare global {
   }
 
   export interface PipelineContent extends ImportedPipelineContent {
-    edge: string;
+    edge?: string;
+    edgeHast?: Root;
     data: ProductBusEntry;
   }
 

package/src/index.js

@@ -15,4 +15,4 @@ export { productHTMLPipe } from './product-html-pipe.js';
 export { productIndexPipe } from './product-index-pipe.js';
 export { productMerchantFeedPipe } from './product-merchant-feed-pipe.js';
 export { productSitemapPipe } from './product-sitemap-pipe.js';
-export { productMediaPipe } from './product-media-pipe.js';
+export { applyByoCdnHeaders } from './utils/cache-headers.js';

package/src/product-html-pipe.js

@@ -26,6 +26,7 @@ import tohtml from './steps/stringify-response.js';
 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';
 
 export async function productHTMLPipe(state, req) {
   const { log } = state;
@@ -72,9 +73,11 @@ export async function productHTMLPipe(state, req) {
 
     state.timer?.update('render');
     await html(state);
-    await renderHead(state);
 
     await fetchEdgeContent(state, req, res);
+    await extractAuthoredMetadata(state);
+
+    await renderHead(state);
     await renderBody(state, req, res);
     await renderJsonld(state, res);
     await addHeadingIds(state);

package/src/steps/extract-authored-metadata.js

@@ -0,0 +1,120 @@
+/*
+ * Copyright 2025 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.
+ */
+
+import { selectAll, select } from 'hast-util-select';
+import { fromHtml } from 'hast-util-from-html';
+
+/**
+ * Set of meta tag names to ignore when extracting authored metadata.
+ * These are standard meta tags that we don't want to override.
+ */
+const IGNORED_META_NAMES = new Set([
+  'viewport',
+]);
+
+/**
+ * Prefixes for meta tag names to ignore.
+ * og: and twitter: prefixes are standard social meta tags.
+ */
+const IGNORED_META_PREFIXES = ['og:', 'twitter:'];
+
+/**
+ * Check if a meta tag name should be ignored.
+ * @param {string} name - The meta tag name
+ * @returns {boolean} True if the name should be ignored
+ */
+function shouldIgnoreMetaName(name) {
+  if (!name) return true;
+  if (IGNORED_META_NAMES.has(name)) return true;
+  return IGNORED_META_PREFIXES.some((prefix) => name.startsWith(prefix));
+}
+
+/**
+ * Extract metadata from the head element of an HTML document.
+ * Only extracts meta tags with name attribute (not property).
+ * Ignores og:*, twitter:*, and viewport meta tags.
+ *
+ * @param {import('hast').Element} head - The head element
+ * @returns {Object} Extracted metadata key/value pairs
+ */
+function extractMetadataFromHead(head) {
+  const metadata = {};
+
+  /* c8 ignore next */
+  if (!head) return metadata;
+
+  // Select all meta tags with a name attribute
+  const metaTags = selectAll('meta[name]', head);
+
+  for (const meta of metaTags) {
+    const name = meta.properties?.name;
+    const content = meta.properties?.content;
+
+    // Only add if name is valid and content exists
+    if (typeof name === 'string' && !shouldIgnoreMetaName(name) && content !== undefined) {
+      metadata[name] = content;
+    }
+  }
+
+  return metadata;
+}
+
+/**
+ * Extract the main element's children as HAST nodes.
+ * @param {import('hast').Root} hast - The parsed HTML document
+ * @returns {import('hast').Root|undefined} HAST root with main's children,
+ * or undefined if not found
+ */
+function extractMainContent(hast) {
+  const main = select('main', hast);
+  if (!main || !main.children || main.children.length === 0) {
+    return undefined;
+  }
+
+  // Return main's children as a HAST root node
+  return { type: 'root', children: main.children };
+}
+
+/**
+ * Extract metadata and body content from authored HTML document.
+ *
+ * @param {PipelineState} state - Pipeline state object
+ * @returns {Promise<void>}
+ */
+export default async function extractAuthoredMetadata(state) {
+  const { content } = state;
+  const { edge, data } = content;
+
+  if (!edge) {
+    return;
+  }
+
+  const hast = fromHtml(edge, { fragment: false });
+  const head = select('head', hast);
+  const authoredMetadata = extractMetadataFromHead(head);
+
+  // If metadata was extracted, merge it with existing product metadata
+  if (Object.keys(authoredMetadata).length > 0) {
+    if (!data.metadata) {
+      data.metadata = {};
+    }
+
+    // Authored metadata takes precedence
+    Object.assign(data.metadata, authoredMetadata);
+  }
+
+  // Extract main content as HAST and store for render-body to use directly
+  const mainContent = extractMainContent(hast);
+  if (mainContent) {
+    content.edgeHast = mainContent;
+  }
+}

package/src/steps/fetch-edge-product.js

@@ -26,7 +26,7 @@ export default async function fetchEdgeContent(state, req, res) {
   } = state;
   const { originalPath } = info;
 
-  const contentUrl = `https://${ref}--${site}--${org}.aem.live${originalPath}.plain.html`;
+  const contentUrl = `https://${ref}--${site}--${org}.aem.live${originalPath}`;
   try {
     /** @type {Record<string, string>} */
     const headers = {};

package/src/steps/render-body.js

@@ -45,22 +45,54 @@ function renderMedia(media) {
 }
 
 /**
- * Rewrite image URLs in authored content to include /content-images/ prefix.
+ * Rewrite a single URL to include /content-images/ prefix for media files.
+ * @param {string} url - The URL to potentially rewrite
+ * @returns {string} The rewritten URL
+ */
+function rewriteMediaUrl(url) {
+  /* c8 ignore next */
+  if (!url) return url;
+  return url.replace(/\/(media_[a-f0-9]+\.\w+)/g, '/content-images/$1');
+}
+
+/**
+ * Recursively rewrite image URLs in HAST nodes to include /content-images/ prefix.
  * This allows the aem.network to route these images back to aem.live instead of the product media bus.
- * @param {string} html - HTML content containing image references
- * @returns {string} HTML with rewritten image URLs
+ * @param {import('hast').Root|import('hast').Element} node - HAST node to process
  */
-export function rewriteContentImageUrls(html) {
-  return html.replace(/\/(media_[a-f0-9]+\.\w+)/g, '/content-images/$1');
+export function rewriteContentImageUrls(node) {
+  /* c8 ignore next */
+  if (!node) return;
+
+  // Rewrite src and srcset attributes on img and source elements
+  if (node.type === 'element' && node.properties) {
+    if (node.tagName === 'img' || node.tagName === 'source') {
+      if (node.properties.src && typeof node.properties.src === 'string') {
+        node.properties.src = rewriteMediaUrl(node.properties.src);
+      }
+      if (node.properties.srcSet && typeof node.properties.srcSet === 'string') {
+        node.properties.srcSet = rewriteMediaUrl(node.properties.srcSet);
+      }
+    }
+  }
+
+  // Recursively process children
+  if (node.children) {
+    for (const child of node.children) {
+      if (child.type === 'element') {
+        rewriteContentImageUrls(child);
+      }
+    }
+  }
 }
 
 /**
  * Render the product content.
- * @param {string} edge
- * @param {string} description
+ * @param {import('hast').Root} edgeHast - HAST nodes from authored content
+ * @param {string} description - Product description (may be HTML or plain text)
  * @returns {import('hast').Element | import('hast').Root}
  */
-function renderProductContent(edge, description) {
+function renderProductContent(edgeHast, description) {
   const parts = [];
 
   // Add description first if it exists
@@ -74,11 +106,10 @@ function renderProductContent(edge, description) {
     }
   }
 
-  // Add edge content after if it exists
-  if (edge) {
-    const rewrittenEdge = rewriteContentImageUrls(edge);
-    const edgeFragment = fromHtml(rewrittenEdge, { fragment: true });
-    parts.push(...edgeFragment.children);
+  // Add edge content after if it exists (already HAST, just rewrite URLs)
+  if (edgeHast) {
+    rewriteContentImageUrls(edgeHast);
+    parts.push(...edgeHast.children);
   }
 
   // Return undefined if nothing to render
@@ -110,7 +141,7 @@ function variantDataAttrs(variant) {
  */
 export default async function render(state, req, res) {
   const { content } = state;
-  const { hast, edge } = content;
+  const { hast, edgeHast } = content;
 
   const {
     name,
@@ -120,7 +151,7 @@ export default async function render(state, req, res) {
     variants = [],
   } = content.data;
 
-  const productContent = renderProductContent(edge, description);
+  const productContent = renderProductContent(edgeHast, description);
 
   const main = select('main', hast);
   main.children = [

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

@@ -13,11 +13,13 @@
 /* eslint-disable camelcase */
 
 import {
-  computeProductPathKey, computeSiteKey, compute404Key, computeMediaKeys, computeAuthoredContentKey,
+  computeProductPathKey,
+  computeSiteKey,
+  compute404Key,
+  computeAuthoredContentKey,
+  computeProductKeys,
 } from '@dylandepass/helix-product-shared';
-
-export const isMediaRequest = (url) => /\/media_[0-9a-f]{40,}[/a-zA-Z0-9_-]*\.[0-9a-z]+$/.test(url.pathname);
-const BYO_CDN_TYPES = ['akamai', 'cloudflare', 'fastly', 'cloudfront'];
+import { applyByoCdnHeaders } from '../utils/cache-headers.js';
 
 /**
  * Sets the cache headers for a product
@@ -27,92 +29,29 @@ const BYO_CDN_TYPES = ['akamai', 'cloudflare', 'fastly', 'cloudfront'];
  * @returns {void}
  */
 export function setCachingHeaders(req, resp, cacheKeys) {
-  const url = new URL(req.url);
-
-  // determine BYO CDN type
-  let byo_cdn_type = req.headers.get('x-byo-cdn-type');
-  const via = req.headers.get('via') || '';
-  const cdn_loop = req.headers.get('cdn-loop') || '';
-  // FIXME: cloudflare seems to strip the CDN-Loop header, i.e. the worker can't see it...
-  if (!BYO_CDN_TYPES.includes(byo_cdn_type)) {
-    // sniff downstream cdn type
-    if (/[Aa]kamai/.test(via)) {
-      byo_cdn_type = 'akamai';
-    } else if (via.includes('varnish') || cdn_loop.startsWith('Fastly')) {
-      byo_cdn_type = 'fastly';
-    } else if (cdn_loop.includes('cloudflare') || req.headers.has('cf-worker')) {
-      byo_cdn_type = 'cloudflare';
-    } else if (via.includes('CloudFront')) {
-      byo_cdn_type = 'cloudfront';
-    } else {
-      // invalid/unsupported CDN type
-      byo_cdn_type = undefined;
-    }
-  }
-
   // cache instructions for BYO CDN and the browser
   const pushInvalidation = req.headers.get('x-push-invalidation') === 'enabled';
+
   // browser ttl & browser cache-control
   let browserTTL;
   if ([302, 400, 401].includes(resp.status)) {
     browserTTL = 0;
     resp.headers.set('cache-control', 'private; no-cache');
   } else {
-    if (isMediaRequest(url)) {
-      browserTTL = resp.status === 200 ? 2592000 : 3600;
-    } else {
-      browserTTL = 7200;
-    }
+    browserTTL = 7200;
     resp.headers.set('cache-control', `max-age=${browserTTL}, must-revalidate`);
   }
 
   // CDN ttl
   let cdnTTL;
   if ([400, 401].includes(resp.status)) {
-    // don't cache 400 & 401 repsonses in order to avoid potential downstream caching issues
+    // don't cache 400 & 401 responses in order to avoid potential downstream caching issues
     cdnTTL = 0;
-  } else if (isMediaRequest(url)) {
-    cdnTTL = resp.status === 200 ? 2592000 : 3600;
   } else {
     cdnTTL = pushInvalidation ? 172800 : 300;
   }
-  switch (byo_cdn_type) {
-    case 'cloudflare':
-      resp.headers.set('cdn-cache-control', `max-age=${cdnTTL}, must-revalidate`);
-      break;
-    case 'fastly':
-      resp.headers.set('surrogate-control', `max-age=${cdnTTL}, stale-while-revalidate=0`);
-      break;
-    case 'akamai':
-      resp.headers.set('edge-control', `!no-store,max-age=${cdnTTL}s,downstream-ttl=${browserTTL}s`);
-      break;
-    case 'cloudfront':
-      resp.headers.set('cache-control', `max-age=${browserTTL}, s-maxage=${cdnTTL}, must-revalidate`);
-      break;
-    default:
-      break;
-  }
 
-  // BYO CDN cache tags
-  // apply cache tags: transform Fastly Surrogate-Key to Cloudflare Cache-Tag
-  if (cacheKeys.length) {
-    switch (byo_cdn_type) {
-      case 'fastly':
-        resp.headers.set('surrogate-key', cacheKeys.join(' '));
-        break;
-      case 'akamai':
-        resp.headers.set('edge-cache-tag', cacheKeys.join(' '));
-        break;
-      case 'cloudflare':
-        resp.headers.set('cache-tag', `${cacheKeys.join(',')}`);
-        break;
-      case 'cloudfront':
-        // cloudfront doesn't support cache tags/keys ...
-        break;
-      default:
-        break;
-    }
-  }
+  applyByoCdnHeaders(resp, req, cacheKeys, browserTTL, cdnTTL);
 }
 
 /**
@@ -164,25 +103,6 @@ export async function setProductCacheHeaders(state, req, resp) {
     org, site, contentBusId, info,
   } = state;
 
-  const productKeys = [
-    await computeProductPathKey(org, site, info.path),
-    await computeSiteKey(org, site),
-  ];
-  const authoredContentKey = await computeAuthoredContentKey(contentBusId, info.originalPath);
-  setCachingHeaders(req, resp, [...productKeys, authoredContentKey]);
-}
-
-/**
- * Sets the cache headers for a product
- * @param {PipelineState} state
- * @param {PipelineRequest} req
- * @param {PipelineResponse} resp
- * @returns {Promise<void>}
- */
-export async function setMediaCacheHeaders(state, req, resp) {
-  const { org, site } = state;
-  const url = new URL(req.url);
-  const keys = await computeMediaKeys(org, site, url.pathname);
-
-  setCachingHeaders(req, resp, keys);
+  const productKeys = await computeProductKeys(org, site, info.path, contentBusId);
+  setCachingHeaders(req, resp, productKeys);
 }

package/src/utils/cache-headers.js

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2025 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 BYO_CDN_TYPES = ['akamai', 'cloudflare', 'fastly', 'cloudfront'];
+
+/**
+ * Detects the BYO CDN type from the request headers.
+ *
+ * @param {Request|object} req - The request object (must have headers)
+ * @returns {string|undefined} - The detected CDN type or undefined
+ */
+const detectByoCdnType = (req) => {
+  const { headers } = req;
+  let byoCdnType = headers.get('x-byo-cdn-type');
+  const via = headers.get('via') || '';
+  const cdnLoop = headers.get('cdn-loop') || '';
+
+  if (!BYO_CDN_TYPES.includes(byoCdnType)) {
+    if (/[Aa]kamai/.test(via)) {
+      byoCdnType = 'akamai';
+    } else if (via.includes('varnish') || cdnLoop.startsWith('Fastly')) {
+      byoCdnType = 'fastly';
+    } else if (cdnLoop.includes('cloudflare') || headers.has('cf-worker')) {
+      byoCdnType = 'cloudflare';
+    } else if (via.includes('CloudFront')) {
+      byoCdnType = 'cloudfront';
+    } else {
+      byoCdnType = undefined;
+    }
+  }
+
+  return BYO_CDN_TYPES.includes(byoCdnType) ? byoCdnType : undefined;
+};
+
+/**
+ * Applies BYO CDN specific cache headers to the response.
+ *
+ * @param {Response|object} resp - The response object
+ * @param {Request|object} req - The request object
+ * @param {string[]} cacheKeys - List of cache keys/tags
+ * @param {number} browserTTL - Browser TTL in seconds
+ * @param {number} cdnTTL - CDN TTL in seconds
+ */
+export const applyByoCdnHeaders = (resp, req, cacheKeys, browserTTL, cdnTTL) => {
+  const byoCdnType = detectByoCdnType(req);
+  const keys = cacheKeys && cacheKeys.length ? cacheKeys : [];
+
+  switch (byoCdnType) {
+    case 'cloudflare':
+      resp.headers.set('cdn-cache-control', `max-age=${cdnTTL}, must-revalidate`);
+      if (keys.length) resp.headers.set('cache-tag', keys.join(','));
+      break;
+    case 'fastly':
+      resp.headers.set('surrogate-control', `max-age=${cdnTTL}, stale-while-revalidate=0`);
+      if (keys.length) resp.headers.set('surrogate-key', keys.join(' '));
+      break;
+    case 'akamai':
+      resp.headers.set('edge-control', `!no-store,max-age=${cdnTTL}s,downstream-ttl=${browserTTL}s`);
+      if (keys.length) resp.headers.set('edge-cache-tag', keys.join(' '));
+      break;
+    case 'cloudfront':
+      resp.headers.set('cache-control', `max-age=${browserTTL}, s-maxage=${cdnTTL}, must-revalidate`);
+      break;
+    default:
+      break;
+  }
+};

package/src/product-media-pipe.js

@@ -1,64 +0,0 @@
-/*
- * Copyright 2025 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.
- */
-
-import { PipelineResponse, PipelineStatusError } from '@adobe/helix-html-pipeline';
-import { validatePathInfo } from './utils/path.js';
-import initConfig from './steps/init-config.js';
-import fetchMedia from './steps/fetch-media.js';
-import { setLastModified } from './utils/last-modified.js';
-import { setMediaCacheHeaders } from './steps/set-cache-headers.js';
-
-export async function productMediaPipe(state, req) {
-  state.type = 'media';
-
-  if (!validatePathInfo(state.info)) {
-    return new PipelineResponse('', {
-      status: 404,
-      headers: {
-        'x-error': 'invalid path',
-      },
-    });
-  }
-
-  const res = new PipelineResponse('');
-
-  try {
-    await initConfig(state, req, res);
-
-    state.timer?.update('content-fetch');
-    await fetchMedia(state, res);
-    if (res.status === 404) {
-      return new PipelineResponse('', {
-        status: 404,
-        headers: {
-          'x-error': 'not found',
-        },
-      });
-    } else if (res.error) {
-      if (res.status < 400) {
-        return res;
-      }
-      throw new PipelineStatusError(res.status, res.error);
-    }
-
-    setLastModified(state, res);
-
-    await setMediaCacheHeaders(state, req, res);
-
-    res.headers = state.content.headers;
-    res.body = state.content.data;
-  } catch (e) {
-    res.error = e.message;
-  }
-
-  return res;
-}

package/src/steps/fetch-media.js

@@ -1,41 +0,0 @@
-/*
- * Copyright 2022 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.
- */
-import { extractLastModified, recordLastModified } from '../utils/last-modified.js';
-
-/**
- * Loads the content from either the content-bus or code-bus and stores it in `state.content`
- * @param {PipelineState} state
- * @param {PipelineResponse} res
- * @returns {Promise<void>}
- */
-export default async function fetchMedia(state, res) {
-  const {
-    info, org, site,
-  } = state;
-  const bucketId = 'helix-product-bus';
-
-  const key = `${org}/${site}/media/${info.originalFilename}`;
-  const ret = await state.s3Loader.getObject(bucketId, key);
-
-  if (ret.status === 200) {
-    res.status = 200;
-    delete res.error;
-    state.content.data = ret.body;
-    state.content.headers = ret.headers;
-
-    recordLastModified(state, res, 'content', extractLastModified(ret.headers));
-  } else {
-    // keep 404, but propagate others as 502
-    res.status = ret.status === 404 ? 404 : 502;
-    res.error = `failed to load ${info.resourcePath} from product-bus: ${ret.status}`;
-  }
-}

package/src/steps/fetch-productbus-old.js

@@ -1,91 +0,0 @@
-/*
- * Copyright 2022 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 */
-// @ts-nocheck
-
-import { slugger } from '@dylandepass/helix-product-shared';
-import { extractLastModified, recordLastModified } from '../utils/last-modified.js';
-
-const INDEXER_URL_KEYS = ['index', 'merchant-center-feed', 'sitemap'];
-
-/**
- * Loads the content from either the content-bus or code-bus and stores it in `state.content`
- * @param {PipelineState} state
- * @param {PipelineRequest} req
- * @param {PipelineResponse} res
- * @returns {Promise<void>}
- */
-export default async function fetchContent(state, req, res) {
-  const {
-    info, owner, site, config,
-  } = state;
-  const bucketId = 'adobe-commerce-catalog';
-  const { route } = config;
-  const { storeCode, storeViewCode } = route;
-
-  let sku;
-
-  // if route params only contains the urlKey than we
-  // need to head first to get the sku
-
-  // conditioanlly strip .json and .xml off urlKey
-  let urlKey = route.params.urlKey?.replace(/\.json$/, '');
-  urlKey = urlKey?.replace(/\.xml$/, '');
-
-  if (Object.keys(route.params).length === 1 && urlKey && !INDEXER_URL_KEYS.includes(urlKey)) {
-    const headKey = `${owner}/${site}/${storeCode}/${storeViewCode}/urlkeys/${urlKey}`;
-
-    const headRes = await state.s3Loader.headObject(bucketId, headKey);
-
-    if (headRes.status === 200) {
-      sku = headRes.headers.get('sku');
-    } else {
-      res.status = headRes.status === 404 ? 404 : 502;
-      res.error = `HEAD: failed to load ${info.resourcePath} from product-bus: ${headRes.status}`;
-      return;
-    }
-  } else if (!INDEXER_URL_KEYS.includes(urlKey)) {
-    sku = route.params.sku?.replace(/\.json$/, '').replace(/\.xml$/, '');
-  }
-
-  /** @type {string} */
-  let key;
-  if ((!sku && !INDEXER_URL_KEYS.includes(urlKey)) || (sku && !INDEXER_URL_KEYS.includes(sku))) {
-    const slug = slugger(sku);
-    key = `${owner}/${site}/${storeCode}/${storeViewCode}/products/${slug}.json`;
-  } else if (urlKey === 'index' || sku === 'index' || urlKey === 'sitemap' || sku === 'sitemap') {
-    const id = req.params?.id ?? 'default';
-    key = `${owner}/${site}/${storeCode}/${storeViewCode}/index/${id}.json`;
-  } else if (urlKey === 'merchant-center-feed' || sku === 'merchant-center-feed') {
-    key = `${owner}/${site}/${storeCode}/${storeViewCode}/merchant-feed/default.json`;
-  }
-
-  const ret = await state.s3Loader.getObject(bucketId, key);
-
-  if (ret.status === 200) {
-    try {
-      res.status = 200;
-      delete res.error;
-      state.content.data = JSON.parse(ret.body);
-
-      recordLastModified(state, res, 'content', extractLastModified(ret.headers));
-    } catch (e) {
-      res.status = 400;
-      res.error = `failed to parse ${info.resourcePath} from product-bus: ${e.message}`;
-    }
-  } else {
-    // keep 404, but propagate others as 502
-    res.status = ret.status === 404 ? 404 : 502;
-    res.error = `failed to load ${urlKey === 'index' ? key : info.resourcePath} from product-bus: ${ret.status}`;
-  }
-}