@adobe/helix-config 5.6.5 → 5.6.7

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [5.6.7](https://github.com/adobe/helix-config/compare/v5.6.6...v5.6.7) (2025-09-29)
+
+
+### Bug Fixes
+
+* ensure no node dependencies ([#320](https://github.com/adobe/helix-config/issues/320)) ([d1dec47](https://github.com/adobe/helix-config/commit/d1dec472f67bae6ebfb92105e4e1324c6fb37056))
+
+## [5.6.6](https://github.com/adobe/helix-config/compare/v5.6.5...v5.6.6) (2025-09-25)
+
+
+### Bug Fixes
+
+* legacy config w/o config-all ([#255](https://github.com/adobe/helix-config/issues/255)) ([0251471](https://github.com/adobe/helix-config/commit/0251471209439df447fb93bbe3cb327d8be98c12))
+
 ## [5.6.5](https://github.com/adobe/helix-config/compare/v5.6.4...v5.6.5) (2025-09-18)
 
 

package/eslint.config.js

@@ -18,10 +18,6 @@ export default defineConfig([
     'coverage/*',
   ]),
   {
-    rules: {
-      // see https://github.com/import-js/eslint-plugin-import/issues/1868
-      'import/no-unresolved': ['error', { ignore: ['@adobe/helix-shared-config/modifiers'] }]
-    },
     plugins: {
       import: recommended.plugins.import,
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/helix-config",
-  "version": "5.6.5",
+  "version": "5.6.7",
   "description": "Helix Config",
   "main": "src/index.js",
   "types": "src/index.d.ts",
@@ -55,7 +55,6 @@
     "*.cjs": "eslint"
   },
   "dependencies": {
-    "@adobe/helix-shared-config": "11.1.10",
     "@adobe/helix-shared-server-timing": "1.0.0",
     "@adobe/helix-shared-utils": "3.0.2"
   }

package/src/ModifiersConfig.js

@@ -0,0 +1,177 @@
+/*
+ * 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.
+ */
+
+/**
+ * Converts all non-valid characters to `-`.
+ * @param {string} text input text
+ * @returns {string} the meta name
+ */
+function toMetaName(text) {
+  return text
+    .toLowerCase()
+    .replace(/[^0-9a-z:_]/gi, '-');
+}
+
+/**
+ * The modifiers class help manage the metadata and headers modifiers.
+ */
+export class ModifiersConfig {
+  /**
+   * Converts a globbing expression to regexp. Note that only `*` and `**` are supported yet.
+   * @param {string} glob
+   * @returns {RegExp}
+   */
+  static globToRegExp(glob) {
+    const reString = glob
+      .replaceAll('**', '|')
+      .replaceAll('*', '[^/]*')
+      .replaceAll('|', '.*');
+    return new RegExp(`^${reString}$`);
+  }
+
+  /**
+   * Converts all keys in a row object to lowercase
+   * @param {Object} obj A row of data from a sheet
+   * @returns {Object} A row with all keys converted to lowercase
+   */
+  static toLowerKeys(obj) {
+    return Object.keys(obj).reduce((prev, key) => {
+      // eslint-disable-next-line no-param-reassign
+      prev[key.toLowerCase()] = obj[key];
+      return prev;
+    }, Object.create(null));
+  }
+
+  /**
+   * Empty modifiers
+   * @type {ModifiersConfig}
+   */
+  static EMPTY = new ModifiersConfig({});
+
+  /**
+   * Parses a sheet that is in a modifier format into a list of key/value pairs
+   *
+   * @example
+   *
+   * | url   | key | value | Title   | Description    |
+   * |-------|-----|-------|---------|----------------|
+   * | "/*"  | "A" | "B"   | ""      | ""             |
+   * | "/*"  | "C" | "D"   | ""      | ""             |
+   * | "/f"  | ""  | ""    | "Hero"  | "Once upon..." |
+   *
+   * becomes:
+   *
+   * {
+   *   "/*": [
+   *     { "key": "A", "value": "B" },
+   *     { "key": "C", "value": "D" },
+   *   ],
+   *   "/f": [
+   *     { "key": "title", "value": "Hero" },
+   *     { "key": "description", "value": "Once upon..." },
+   *   ]
+   * }
+   *
+   *
+   * @param {object[]} sheet The sheet to parse
+   * @param {ModifierKeyFilter} keyFilter filter to apply on keys
+   * @returns {ModifierMap} An object containing an array of key/value pairs for every glob
+   */
+  static parseModifierSheet(sheet, keyFilter = () => true) {
+    /** @type ModifierMap */
+    const res = Object.create(null);
+    for (let row of sheet) {
+      row = ModifiersConfig.toLowerKeys(row);
+      const {
+        url, key, value, ...rest
+      } = row;
+      if (url) {
+        const put = (k, v) => {
+          if (keyFilter(k)) {
+            let entry = res[url];
+            if (!entry) {
+              entry = Object.create(null);
+              res[url] = entry;
+            }
+            entry[k] = v;
+          }
+        };
+
+        // note that all values are strings, i.e. never another falsy value
+        if ('key' in row && 'value' in row && key && value) {
+          put(key.toLowerCase(), value);
+        } else {
+          Object.entries(rest).forEach(([k, v]) => {
+            if (k && v) {
+              put(k, v);
+            }
+          });
+        }
+      }
+    }
+    // convert res back to key/value pairs
+    for (const [url, mods] of Object.entries(res)) {
+      res[url] = Object.entries(mods).map(([key, value]) => ({ key, value }));
+    }
+    return res;
+  }
+
+  /**
+   * Creates a new `ModifiersConfig` from the given sheet.
+   *
+   * @see ModifiersConfig.parseModifierSheet
+   * @param {object[]} sheet The sheet to parse
+   * @param {ModifierKeyFilter} keyFilter filter to apply on keys
+   * @returns {ModifiersConfig} A ModifiersConfig instance.
+   */
+  static fromModifierSheet(sheet, keyFilter) {
+    return new ModifiersConfig(ModifiersConfig.parseModifierSheet(sheet, keyFilter));
+  }
+
+  /**
+   * Creates a new ModifiersConfig class.
+   * @param {ModifierMap} [map] The modifier map.
+   * @param {ModifierKeyFilter} keyFilter filter to apply on modifier keys
+   */
+  constructor(map, keyFilter = () => true) {
+    if (!map) {
+      return;
+    }
+    this.modifiers = Object.entries(map).map(([url, mods]) => {
+      const pat = url.indexOf('*') >= 0 ? ModifiersConfig.globToRegExp(url) : url;
+      return {
+        pat,
+        mods: mods.filter(({ key }) => keyFilter(key)),
+      };
+    });
+  }
+
+  /**
+   * Returns the modifier object for the given path.
+   * @param {string} path
+   * @return {object} the modifiers
+   */
+  getModifiers(path) {
+    if (!this.modifiers) {
+      return Object.create(null);
+    }
+    const modifiers = Object.create(null);
+    for (const { pat, mods } of this.modifiers) {
+      if (pat === path || (pat instanceof RegExp && pat.test(path))) {
+        for (const { key, value } of mods) {
+          modifiers[toMetaName(key)] = value;
+        }
+      }
+    }
+    return modifiers;
+  }
+}

package/src/config-legacy.js

@@ -13,11 +13,11 @@ import {
   SCOPE_ADMIN, SCOPE_DELIVERY, SCOPE_PIPELINE, SCOPE_RAW,
 } from './ConfigContext.js';
 import { ConfigObject } from './config-object.js';
+import { contentConfigMerge } from './legacy-config-merge.js';
+import { prune } from './utils.js';
 
 const HELIX_CODE_BUS = 'helix-code-bus';
 
-const HELIX_CONTENT_BUS = 'helix-content-bus';
-
 export function toArray(v) {
   if (!v) {
     return [];
@@ -62,23 +62,6 @@ async function fetchHelixConfig(ctx, rso) {
   return cfg;
 }
 
-/**
- * Retrieves the project config from the underlying storage
- * and stores it in the context as projectConfig.
- * @param {ConfigContext} ctx the context
- * @param {string} contentBusId
- * @param {string} partition
- * @returns {Promise<ConfigAll|null>} the project configuration
- */
-async function fetchConfigAll(ctx, contentBusId, partition) {
-  const key = `${contentBusId}/${partition}/.helix/config-all.json`;
-  const res = await ctx.loader.getObject(HELIX_CONTENT_BUS, key);
-  if (!res.body) {
-    return null;
-  }
-  return res.json();
-}
-
 /**
  * Retrieves the robots.txt from the code-bus
  * @param {ConfigContext} ctx the context
@@ -170,8 +153,10 @@ export async function resolveLegacyConfig(ctx, rso, scope) {
   };
   cfg.data = config;
   ctx.timer?.update('legacy-config-all');
-  const configAllPreview = await fetchConfigAll(ctx, config.content.contentBusId, 'preview');
-  const configAllLive = await fetchConfigAll(ctx, config.content.contentBusId, 'live');
+  const {
+    preview: configAllPreview,
+    live: configAllLive,
+  } = await contentConfigMerge(ctx, config.content.contentBusId, rso);
   const { access, admin } = configAllPreview?.config?.data || {};
   if (access) {
     config.access = {
@@ -204,9 +189,9 @@ export async function resolveLegacyConfig(ctx, rso, scope) {
   if (scope === SCOPE_PIPELINE) {
     config.metadata = {};
     if (configAllPreview) {
-      config.metadata.preview = configAllPreview.metadata ?? {};
+      config.metadata.preview = configAllPreview.metadata;
     }
-    if (configAllLive?.metadata) {
+    if (configAllLive) {
       config.metadata.live = configAllLive.metadata;
     }
     ctx.timer?.update('robots-txt');
@@ -222,5 +207,5 @@ export async function resolveLegacyConfig(ctx, rso, scope) {
     config.metadata.source = configAllPreview?.config?.data?.metadata;
   }
 
-  return cfg;
+  return prune(cfg);
 }

package/src/config-view.js

@@ -9,7 +9,6 @@
  * OF ANY KIND, either express or implied. See the License for the specific language
  * governing permissions and limitations under the License.
  */
-import { ModifiersConfig } from '@adobe/helix-shared-config/modifiers';
 import { computeSurrogateKey } from '@adobe/helix-shared-utils';
 // eslint-disable-next-line import/no-unresolved
 import { PipelineResponse } from './PipelineResponse.js';
@@ -22,6 +21,7 @@ import {
 import { resolveLegacyConfig, fetchRobotsTxt, toArray } from './config-legacy.js';
 import { deepGetOrCreate, prune } from './utils.js';
 import { ConfigObject } from './config-object.js';
+import { ModifiersConfig } from './ModifiersConfig.js';
 
 /**
  * @typedef Config

package/src/flatJson2Object.js

@@ -0,0 +1,104 @@
+/*
+ * 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.
+ */
+
+/**
+ * Converts a config row-based name/value pair array with dotted key notation to an object.
+ *
+ * example:
+ *
+ * ```
+ * host: www.adobe.com
+ * document.level: 42,
+ * document.title: hello
+ * document.body.status: 200
+ * acl.allow: /foo
+ * acl.allow: /bar
+ * cnd.0.type: fastly
+ * cnd.0.host: www.adobe.com
+ * cnd.1.type: cloudflare
+ * ```
+ *
+ * becomes:
+ *
+ * ```
+ * {
+ *   host: 'www.adobe.com',
+ *   document: {
+ *     level: 42,
+ *     title: 'hello',
+ *     body: {
+ *       status: 200,
+ *     }
+ *   },
+ *   acl: {
+ *     allow: ['/foo', '/bar],
+ *   }
+ *   cnd: [
+ *     { type: 'fastly', host: 'www.adobe.com' },
+ *     { type: 'cloudflare' },
+ *   ]
+ * }
+ * ```
+ *
+ * @param {object[]} rows array of columns
+ * @param {string} [keyName = 'key'] name of the key column.
+ * @param {string} [valueName = 'value'] name of the value column.
+ */
+export function flatJson2object(rows, keyName = 'key', valueName = 'value') {
+  const arrays = [];
+  const update = (o, segs, value) => {
+    const seg = segs.shift();
+    if (segs.length) {
+      if (seg in o) {
+        update(o[seg], segs, value);
+        return o;
+      }
+      const n = Number.parseInt(segs[0], 10);
+      if (Number.isNaN(n)) {
+        // eslint-disable-next-line no-param-reassign
+        o[seg] = update(Object.create(null), segs, value);
+      } else {
+        // eslint-disable-next-line no-param-reassign
+        o[seg] = update([], segs, value);
+        arrays.push(o[seg]);
+      }
+      return o;
+    }
+    if (!(seg in o)) {
+      // eslint-disable-next-line no-param-reassign
+      o[seg] = value;
+    } else if (Array.isArray(o[seg])) {
+      // eslint-disable-next-line no-param-reassign
+      o[seg].push(value);
+    } else {
+      // eslint-disable-next-line no-param-reassign
+      o[seg] = [o[seg], value];
+    }
+    return o;
+  };
+
+  const obj = Object.create(null);
+  rows.forEach((row) => {
+    update(obj, String(row[keyName]).trim().split('.'), String(row[valueName]).trim());
+  });
+
+  // compact arrays
+  arrays.forEach((a) => {
+    for (let i = 0; i < a.length; i += 1) {
+      if (!(i in a)) {
+        a.splice(i, 1);
+        i -= 1;
+      }
+    }
+  });
+  return obj;
+}

package/src/legacy-config-merge.js

@@ -0,0 +1,236 @@
+/*
+ * 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 no-continue,no-param-reassign */
+import { logLevelForStatusCode, propagateStatusCode } from '@adobe/helix-shared-utils';
+import { flatJson2object } from './flatJson2Object.js';
+import { ModifiersConfig } from './ModifiersConfig.js';
+
+export const CONFIG_JSON_PATH = '/.helix/config.json';
+
+export const HEADERS_JSON_PATH = '/.helix/headers.json';
+
+export const METADATA_JSON_PATH = '/metadata.json';
+
+/**
+ * Coerces the given value to an array. if the value is null or undefined, an empty array is
+ * returned.
+ * @param {*} value
+ * @param {boolean} [unique = false] if true, the resulting array will contain only unique values
+ * @return {[]}
+ */
+export function coerceArray(value, unique = false) {
+  if (value === null || value === undefined) {
+    return [];
+  }
+  const array = Array.isArray(value) ? value : [value];
+  if (unique) {
+    return Array.from(new Set(array));
+  }
+  return array;
+}
+
+/**
+ * From a JSON response, retrieves the `data` sheet if this is a single sheet,
+ * or it returns the first existing sheet given by a list of names, if it is a
+ * multisheet.
+ * Returns `null` if there is neither.
+ *
+ * @param {any} json JSON object
+ * @param {String[]} names names to check in a multi sheet
+ */
+export function getSheetData(json, names) {
+  /* c8 ignore next 3 */
+  if (Array.isArray(json.data)) {
+    return json.data;
+  }
+  let sheet;
+
+  const match = names.find((name) => !!json[name]);
+  if (match) {
+    sheet = json[match];
+  }
+  if (Array.isArray(sheet?.data)) {
+    return sheet.data;
+  }
+  return null;
+}
+
+/**
+ * Helper class to load and generate the aggregate configs
+ */
+export class ConfigMerger {
+  constructor(log, contentBusId, partition) {
+    Object.assign(this, {
+      log,
+      contentBusId,
+      partition,
+      lastModifiedTime: null,
+      lastModified: null,
+      all: {
+        version: 1,
+      },
+    });
+  }
+
+  toJSON() {
+    return this.all;
+  }
+
+  /**
+   * Loads a file from the content bus
+   * @param {ConfigContext} ctx
+   * @param {string} opts.path
+   * @param {string} opts.property
+   * @param {function} opts.mapping
+   * @returns {Promise<>}
+   */
+  async loadFile(ctx, opts) {
+    const key = `${this.contentBusId}/${this.partition}${opts.path}`;
+    const fileResponse = await ctx.loader.getObject('helix-content-bus', key);
+    const fileText = fileResponse.body;
+
+    let data;
+    if (fileResponse.status === 200) {
+      try {
+        data = getSheetData(JSON.parse(fileText), ['default']);
+        // eslint-disable-next-line no-empty
+      } catch {
+      }
+      if (!data) {
+        this.log.info(`[config-all] Error loading ${key}: empty or invalid json.`);
+      } else {
+        this.log.info(`[config-all] loaded: ${key}`);
+      }
+    } else if (fileResponse.status === 404) {
+      this.log.info(`[config-all] Error loading ${key}: no such object`);
+    } else {
+      this.log[logLevelForStatusCode(fileResponse.status)](`Invalid response (${fileResponse.status}) when loading json from ${key}`);
+      const err = new Error(`Unable to fetch json: ${fileResponse.status} ${fileText}`);
+      err.status = propagateStatusCode(fileResponse.status);
+      throw err;
+    }
+    if (data) {
+      // get the config property for this file
+      let config = this.all[opts.property];
+      if (!config) {
+        config = {};
+        this.all[opts.property] = config;
+      }
+      // update the data of the config
+      config.data = opts.mapping(data, config);
+      this.updateLastModified(config, fileResponse.headers);
+    }
+  }
+
+  /**
+   * Update the last modified in the config object and tracks the most recent one
+   * @param {object} obj
+   * @param {Map} headers
+   */
+  updateLastModified(obj, headers) {
+    const httpDate = headers.get('x-source-last-modified') ?? headers.get('last-modified');
+    /* c8 ignore next 3 */
+    if (!httpDate) {
+      return;
+    }
+    const time = new Date(httpDate).getTime();
+    /* c8 ignore next 4 */
+    if (Number.isNaN(time)) {
+      this.log.warn(`[config-all] updateLastModified date is invalid: ${httpDate}`);
+      return;
+    }
+    obj.lastModified = httpDate;
+    if (time > (this.lastModifiedTime ?? 0)) {
+      this.lastModifiedTime = time;
+      this.lastModified = httpDate;
+    }
+  }
+
+  clone(partition) {
+    const c = new ConfigMerger(this.log, this.contentBusId, partition);
+    c.lastModified = this.lastModified;
+    c.lastModifiedTime = this.lastModifiedTime;
+    // copy .helix/config.json and .helix/headers.json since it's the same for both partitions
+    c.all.config = this.all.config;
+    if (this.all.headers) {
+      c.all.headers = this.all.headers;
+    }
+    return c;
+  }
+}
+
+/**
+ * Handles merging content bus configuration files. The metadata and headers are specific to
+ * their partition, whereas the config is always loaded from preview.
+ *
+ * this means that config-all is always updated in both partitions
+ *
+ * @param {ConfigContext} ctx the universal context
+ * @param {string} contentBusId the content bus id
+ * @param {Response} res the response of the preceding content bus operation (preview/publish)
+ * @returns {Promise<void>}
+ * @implements ResponseHook
+ */
+export async function contentConfigMerge(ctx, contentBusId) {
+  const { log } = ctx;
+
+  // load config always from preview
+  const cfgPreview = new ConfigMerger(log, contentBusId, 'preview');
+  await cfgPreview.loadFile(ctx, {
+    path: CONFIG_JSON_PATH,
+    property: 'config',
+    mapping: (data) => flatJson2object(data),
+  });
+
+  // load headers always from preview
+  await cfgPreview.loadFile(ctx, {
+    path: HEADERS_JSON_PATH,
+    property: 'headers',
+    mapping: (data) => ModifiersConfig.parseModifierSheet(data),
+  });
+
+  const cfgLive = cfgPreview.clone('live');
+  const updates = [cfgPreview, cfgLive];
+
+  // generate preview and live versions
+  await Promise.all(updates.map((async (cfg) => {
+    // generate the metadata-all.json first
+    const metadataPaths = coerceArray(cfg.all.config?.data?.metadata || [METADATA_JSON_PATH], true);
+    for (const path of metadataPaths) {
+      const loadOpts = {
+        path,
+        property: 'metadata',
+        mapping: (data, metadata) => {
+          if (!Array.isArray(metadata.data)) {
+            metadata.data = [];
+          }
+          metadata.data.push(...data);
+          return metadata.data;
+        },
+      };
+      // eslint-disable-next-line no-await-in-loop
+      await cfg.loadFile(ctx, loadOpts);
+    }
+
+    // convert to modifiers map
+    if (cfg.all.metadata?.data) {
+      cfg.all.metadata.data = ModifiersConfig.parseModifierSheet(cfg.all.metadata.data);
+    } else {
+      cfg.all.metadata = {};
+    }
+  })));
+
+  return {
+    preview: cfgPreview.toJSON(),
+    live: cfgLive.toJSON(),
+  };
+}