@adobe/helix-config 5.6.5 → 5.6.6

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/helix-config",
-  "version": "5.6.5",
+  "version": "5.6.6",
   "description": "Helix Config",
   "main": "src/index.js",
   "types": "src/index.d.ts",

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/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 { ModifiersConfig } from '@adobe/helix-shared-config';
+import { flatJson2object } from './flatJson2Object.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(),
+  };
+}