@adobe/helix-config 2.14.0 → 2.15.1

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [2.15.1](https://github.com/adobe/helix-config/compare/v2.15.0...v2.15.1) (2024-05-07)
+
+
+### Bug Fixes
+
+* do not load org config in resolveConfig ([ccedbfd](https://github.com/adobe/helix-config/commit/ccedbfd4c7c465b842e25f9021fd5a06021e63d4))
+
+# [2.15.0](https://github.com/adobe/helix-config/compare/v2.14.0...v2.15.0) (2024-05-07)
+
+
+### Features
+
+* support profile for site ([#67](https://github.com/adobe/helix-config/issues/67)) ([55c09c9](https://github.com/adobe/helix-config/commit/55c09c95919ec06f047393335bdbcbcc2d187eb2))
+
 # [2.14.0](https://github.com/adobe/helix-config/compare/v2.13.1...v2.14.0) (2024-05-07)
 
 

package/package.json

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

package/src/config-merge.js

@@ -0,0 +1,143 @@
+/*
+ * Copyright 2023 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 */
+
+/**
+ * @typedef RootProperty
+ * @property {boolean} atomic whether the property should be overwritten atomically
+ * @property {boolean} isModified whether the property need special merging
+ */
+
+const ROOT_PROPERTIES = {
+  name: { atomic: true },
+  title: { atomic: true },
+  description: { atomic: true },
+  content: { atomic: true },
+  code: { atomic: true },
+  folders: {},
+  headers: { isModifier: true },
+  cdn: {},
+  access: {},
+  sidekick: {},
+  metadata: { isModifier: true },
+  robots: {},
+  extends: {},
+  tokens: {},
+};
+
+const FORCED_TYPES = {
+  '.cdn.prod.route': 'array',
+};
+
+/**
+ * Merges the `src` object into the `dst` object.
+ * - if the dst property is a scalar, it will be overwritten by the dst property
+ * - if the src property is an empty string, it will delete the dst property
+ * - if the dst property is an array, it will be expanded by the src property uniquely
+ * - some well known paths are forced to be arrays
+ * @param {object} dst
+ * @param {object} src
+ * @param {boolean} isModifier specifies that the objects are modifiers sheets and need special
+ *                             merging
+ */
+function merge(dst, src, path, isModifier) {
+  for (const [key, value] of Object.entries(src)) {
+    const itemPath = `${path}.${key}`;
+    if (value === '') {
+      // remove key if value is empty string (keep false, 0)
+      delete dst[key];
+    } else if (typeof value !== 'object') {
+      // handle non object
+      if (key in dst) {
+        let dstValue = dst[key];
+        if (!Array.isArray(dstValue) && FORCED_TYPES[itemPath] === 'array') {
+          dstValue = [dst[key]];
+          dst[key] = dstValue;
+        }
+        if (!Array.isArray(dstValue)) {
+          dst[key] = value;
+        } else if (!dstValue.includes(value)) {
+          // only add to array if not exist yet
+          dstValue.push(value);
+        }
+      } else {
+        dst[key] = value;
+      }
+    } else if (Array.isArray(value)) {
+      // handle array
+      if (key in dst) {
+        if (!Array.isArray(dst[key])) {
+          dst[key] = [dst[key]];
+        }
+      } else {
+        dst[key] = [];
+      }
+      const dstArray = dst[key];
+      for (const item of value) {
+        if (typeof item === 'object') {
+          // todo: handle arrays in arrays eventually
+          // special case for modifier sheets
+          if (isModifier && item.key) {
+            const idx = dstArray.findIndex((i) => i.key === item.key);
+            if (idx >= 0) {
+              dstArray.splice(idx, 1);
+            }
+            if (!item.value) {
+              // don't set empty modifier
+              continue;
+            }
+          }
+          const dstObj = Object.create(null);
+          dstArray.push(dstObj);
+          merge(dstObj, item, itemPath, isModifier);
+        } else if (!dstArray.includes(item)) {
+          dstArray.push(item);
+        }
+      }
+    } else {
+      // handle plain object
+      // eslint-disable-next-line no-use-before-define
+      mergeObject(dst, key, value, `${path}.${key}`, isModifier);
+    }
+  }
+}
+
+function mergeObject(dst, key, value, path, isModifier) {
+  const dstObj = dst[key] ?? Object.create(null);
+  if (!dst[key]) {
+    dst[key] = dstObj;
+  }
+  merge(dstObj, value, path, isModifier);
+}
+
+function mergeConfig(dst, src) {
+  Object.entries(ROOT_PROPERTIES).forEach(([key, { atomic, isModifier }]) => {
+    if (src[key]) {
+      if (atomic) {
+        dst[key] = src[key];
+      } else {
+        mergeObject(dst, key, src[key], `.${key}`, isModifier);
+      }
+    }
+  });
+}
+
+export function getMergedConfig(site, profile) {
+  if (!profile) {
+    return site;
+  }
+  const ret = Object.create(null);
+  ret.version = site.version;
+  mergeConfig(ret, profile);
+  mergeConfig(ret, site);
+  return ret;
+}

package/src/config-view.js

@@ -19,6 +19,7 @@ import {
   SCOPE_RAW,
 } from './ConfigContext.js';
 import { resolveLegacyConfig, fetchRobotsTxt, toArray } from './config-legacy.js';
+import { getMergedConfig } from './config-merge.js';
 
 /**
  * @typedef Config
@@ -81,7 +82,7 @@ export function getAccessConfig(config, partition) {
   // if an allow is defined but no apiKeyId, create a fake one so that auth is still
   // enforced. later we can remove the allow and the apiKeyId in favor of the tokenHash
   if (allow.length && !cfg.apiKeyId.length) {
-    cfg.apiKeyId.push('fake');
+    cfg.apiKeyId.push('dummy');
   }
   // if an apiKeyId is defined but no tokenHash, create a fake one so that auth is still
   // enforced.
@@ -167,7 +168,7 @@ function retainProperty(obj, prop) {
  */
 async function resolveConfig(ctx, rso, scope) {
   // try to load site config from config-bus
-  let key = `orgs/${rso.org}/sites/${rso.site}.json`;
+  const key = `orgs/${rso.org}/sites/${rso.site}.json`;
   let res = await ctx.loader.getObject(HELIX_CONFIG_BUS, key);
   if (!res.body) {
     if (scope !== SCOPE_ADMIN) {
@@ -176,7 +177,17 @@ async function resolveConfig(ctx, rso, scope) {
       return null;
     }
   }
-  const config = res.json();
+  const site = res.json();
+  let profile;
+
+  if (site.extends?.profile) {
+    const profileKey = `orgs/${rso.org}/profiles/${site.extends.profile}.json`;
+    res = await ctx.loader.getObject(HELIX_CONFIG_BUS, profileKey);
+    if (res.body) {
+      profile = res.json();
+    }
+  }
+  const config = getMergedConfig(site, profile);
   if (scope === SCOPE_PIPELINE) {
     config.metadata = {
       preview: await loadMetadata(ctx, config, 'preview'),
@@ -192,24 +203,25 @@ async function resolveConfig(ctx, rso, scope) {
   if (scope === SCOPE_PIPELINE || scope === SCOPE_DELIVERY) {
     config.head = await loadHeadHtml(ctx, config, rso.ref);
   }
-
-  // check for org config
-  key = `orgs/${rso.org}/config.json`;
-  res = await ctx.loader.getObject(HELIX_CONFIG_BUS, key);
-  if (res.body) {
-    const orgConfig = res.json();
-    if (orgConfig.tokens) {
-      config.tokens = orgConfig.tokens;
-    }
-  }
   return config;
 }
 
-async function getSurrogateKey(opts) {
+async function getSurrogateKey(opts, profile) {
   const { site, org } = opts;
-  const orgKey = await computeSurrogateKey(`${org}_config.json`);
-  const siteKey = await computeSurrogateKey(`${site}--${org}_config.json`);
-  return `${orgKey} ${siteKey}`;
+  const keys = [
+    await computeSurrogateKey(`${org}_config.json`),
+    await computeSurrogateKey(`${site}--${org}_config.json`),
+  ];
+  if (profile) {
+    keys.push(await computeSurrogateKey(`p:${profile}--${org}_config.json`));
+  }
+  return keys.join(' ');
+}
+
+async function loadOrgConfig(ctx, org) {
+  const key = `orgs/${org}/config.json`;
+  const res = await ctx.loader.getObject(HELIX_CONFIG_BUS, key);
+  return res.body ? res.json() : null;
 }
 
 export async function getConfigResponse(ctx, opts) {
@@ -219,7 +231,7 @@ export async function getConfigResponse(ctx, opts) {
   const rso = { ref, site, org };
   const config = await resolveConfig(ctx, rso, scope);
   const surrogateHeaders = {
-    'x-surrogate-key': await getSurrogateKey(opts),
+    'x-surrogate-key': await getSurrogateKey(opts, config?.extends?.profile),
   };
   if (!config) {
     return new PipelineResponse('', {
@@ -230,6 +242,14 @@ export async function getConfigResponse(ctx, opts) {
       },
     });
   }
+  if (config.extends && scope !== SCOPE_RAW) {
+    delete config.extends;
+  }
+
+  const orgConfig = await loadOrgConfig(ctx, org);
+  if (orgConfig?.tokens) {
+    config.tokens = orgConfig.tokens;
+  }
 
   if (config.access) {
     // normalize access config

package/src/schemas/site.schema.json

@@ -54,6 +54,12 @@
     },
     "robots": {
       "$ref": "https://ns.adobe.com/helix/config/robots"
+    },
+    "extends": {
+      "profile": {
+        "type": "string",
+        "pattern": "^[0-9a-zA-Z-_]+$"
+      }
     }
   },
   "required": [

package/src/storage/config-store.js

@@ -47,7 +47,10 @@ const FRAGMENTS_COMMON = {
 };
 
 const FRAGMENTS = {
-  sites: FRAGMENTS_COMMON,
+  sites: {
+    ...FRAGMENTS_COMMON,
+    extends: 'object',
+  },
   profiles: FRAGMENTS_COMMON,
   org: {
     tokens: {

package/types/site-config.d.ts

@@ -35,6 +35,9 @@ export interface HelixSiteConfig {
   sidekick?: SidekickConfig;
   metadata?: Metadata;
   robots?: Robots;
+  extends?: {
+    [k: string]: unknown;
+  };
 }
 /**
  * Defines the content bus location and source.