@adobe/aio-cli-lib-app-config 1.0.1-pre.2023-07-14.sha-628de670 → 1.1.0

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@adobe/aio-cli-lib-app-config",
-  "version": "1.0.1-pre.2023-07-14.sha-628de670",
+  "version": "1.1.0",
   "description": "node lib to provide a consistent interface to various config files that make up Adobe Developer App Builder applications and extensions",
   "repository": "https://github.com/adobe/aio-cli-lib-app-config/",
   "license": "Apache-2.0",
   "main": "src/index.js",
   "files": [
-    "src",
-    "schema"
+    "src"
   ],
   "scripts": {
     "test": "npm run lint && npm run unit-tests",
@@ -19,10 +18,8 @@
   },
   "dependencies": {
     "@adobe/aio-lib-core-config": "^3.0.0",
-    "@adobe/aio-lib-core-logging": "next",
+    "@adobe/aio-lib-core-logging": "^2.0.0",
     "@adobe/aio-lib-env": "^2.0.0",
-    "ajv": "^8.12.0",
-    "ajv-formats": "^2.1.1",
     "fs-extra": "^9.0.1",
     "js-yaml": "^3.14.0",
     "lodash.clonedeep": "^4.5.0"
@@ -34,9 +31,9 @@
     "eslint": "^8",
     "eslint-config-standard": "^17",
     "eslint-plugin-import": "^2.25.3",
-    "eslint-plugin-jest": "^23",
-    "eslint-plugin-jsdoc": "^37",
-    "eslint-plugin-n": "^15",
+    "eslint-plugin-jest": "^27",
+    "eslint-plugin-jsdoc": "^42",
+    "eslint-plugin-n": "^16",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-promise": "^6",
     "eslint-plugin-standard": "^4.0.0",
@@ -74,6 +71,5 @@
     "setupFilesAfterEnv": [
       "./test/jest.setup.js"
     ]
-  },
-  "prereleaseSha": "628de6708a25f55af14bf772b3a6e4d16d353ac4"
-}
+  }
+}

package/src/index.js

@@ -15,11 +15,6 @@ const yaml = require('js-yaml')
 const fs = require('fs-extra')
 const aioConfigLoader = require('@adobe/aio-lib-core-config')
 const aioLogger = require('@adobe/aio-lib-core-logging')('@adobe/aio-cli-lib-app-config', { provider: 'debug' })
-const Ajv = require('ajv')
-const ajvAddFormats = require('ajv-formats')
-
-// eslint-disable-next-line node/no-unpublished-require
-const schema = require('../schema/app.config.yaml.schema.json')
 
 // give or take daylight savings, and leap seconds ...
 const AboutAWeekInSeconds = '604800'
@@ -57,19 +52,6 @@ const HookKeys = [
   'serve-static'
 ]
 
-// please add any key that points to a path here
-// if they are defined in an included file, those need to be rewritten to be relative to the root folder
-const PATH_KEYS = [
-  /^(application|extensions\.[^.]+)\.web$/,
-  /^(application|extensions\.[^.]+)\.web\.src$/,
-  /^(application|extensions\.[^.]+)\.actions$/,
-  /^(application|extensions\.[^.]+)\.unitTest$/,
-  /^(application|extensions\.[^.]+)\.e2eTest$/,
-  /^(application|extensions\.[^.]+)\.dist$/,
-  /^(application|extensions\.[^.]+)\.runtimeManifest\.packages\.[^.]+\.actions\.[^.]+\.function$/,
-  /^(application|extensions\.[^.]+)\.runtimeManifest\.packages\.[^.]+\.actions\.[^.]+\.include\.\d+\.0$/
-]
-
 const {
   getCliEnv, /* function */
   STAGE_ENV /* string */
@@ -77,15 +59,10 @@ const {
 const cloneDeep = require('lodash.clonedeep')
 
 /**
- * Loads app builder configuration in the current working directory.
- *
  * loading config returns following object (this config is internal, not user facing):
  *  {
- *    configSchema: { app.config.yaml configSchema field }
  *    aio: {...aioConfig...},
  *    packagejson: {...package.json...},
- *    configSchema: {...app.config.yaml configSchema field as is},
- *    productDependencies: {...app.config.yaml productDependencies field as is},
  *    all: {
  *      OPTIONAL:'application': {
  *        app: {
@@ -124,8 +101,7 @@ const cloneDeep = require('lodash.clonedeep')
  *          dist,
  *          remote,
  *          urls
- *        },
- *        events: {}
+ *        }
  *      }
  *    },
  *    OPTIONAL:'dx/asset-compute/worker/1': {
@@ -136,51 +112,30 @@ const cloneDeep = require('lodash.clonedeep')
  *    },
  *  }
  *
- * @param {object} options options to load Config
+ * @param {object} options options to loadConfig
  * @param {boolean} options.allowNoImpl do not throw if there is no implementation
- * @param {boolean} options.ignoreAioConfig do not load .aio config via aio-lib-core-config, which is loaded synchronously and blocks the main thread.
  * @returns {object} the config
  */
-async function load (options = {}) {
-  const allowNoImpl = options.allowNoImpl === undefined ? false : options.allowNoImpl
-  const ignoreAioConfig = options.ignoreAioConfig === undefined ? false : options.ignoreAioConfig
-  // *NOTE* it would be nice to support an appFolder option to load config from a different folder.
-  // However, this requires to update aio-lib-core-config to support loading
-  // from a different folder aswell (or enforcing ignore).
-
-  // I. load common config
+function loadConfig (options = { allowNoImpl: false }) {
   // configuration that is shared for application and each extension config
   // holds things like ow credentials, packagejson and aioConfig
-  const commonConfig = await loadCommonConfig({ ignoreAioConfig })
-  // checkCommonConfig(commonConfig)
-
-  // II. load app.config.yaml & validate + load/merge legacy configuration if any
-  // support backward compatibility, include legacy application configuration
-  const legacyAppConfigWithIndex = await legacyToAppConfig(commonConfig)
-  let { config: appConfig, includeIndex } = legacyAppConfigWithIndex
-  // no validation on the legacy configuration, which will be deprecated eventually
-
-  if (await fs.exists(defaults.USER_CONFIG_FILE)) {
-    // this will resolve $include directives and output the app config into a single object
-    // paths config values in $included files will be rewritten
-    const appConfigWithIndex = await coalesce(defaults.USER_CONFIG_FILE, { absolutePaths: true })
-    await validate(appConfigWithIndex.config, { throws: true })
-    const mergedAppConfig = await mergeLegacyAppConfig(appConfigWithIndex, legacyAppConfigWithIndex)
-
-    appConfig = mergedAppConfig.config
-    includeIndex = mergedAppConfig.includeIndex
-  }
+  const commonConfig = loadCommonConfig()
+  checkCommonConfig(commonConfig)
+
+  // user configuration is specified in app.config.yaml and holds both standalone app and extension configuration
+  // note that `$includes` directive will be resolved here
+  // also this will load and merge the standalone legacy configuration system if any
+  const { config: userConfig, includeIndex } = loadUserConfig(commonConfig)
+
+  // load the full standalone application and extension configurations
+  const all = buildAllConfigs(userConfig, commonConfig, includeIndex)
 
-  // III. build output object
-  // full standalone application and extension configurations
-  const all = await buildAllConfigs(appConfig, commonConfig, includeIndex)
   const impl = Object.keys(all).sort() // sort for predictable configuration
-  if (!allowNoImpl && impl.length <= 0) {
+  if (!options.allowNoImpl && impl.length <= 0) {
     throw new Error(`Couldn't find configuration in '${process.cwd()}', make sure to add at least one extension or a standalone app`)
   }
+
   return {
-    configSchema: appConfig?.configSchema || [],
-    productDependencies: appConfig?.productDependencies || [],
     all,
     implements: impl, // e.g. 'dx/excshell/1', 'application'
     // includeIndex keeps a map from config keys to files that includes them and the relative key in the file.
@@ -192,43 +147,13 @@ async function load (options = {}) {
   }
 }
 
-/**
- * Validates the app configuration.
- * To validate an app.config.yaml file, use `await validate(await coalesce('app.config.yaml'))`
- *
- * @param {object} coalescedAppConfigObj the resolved app config object.
- * @param {object} options options
- * @param {boolean} options.throws defaults to false, if true throws on validation error instead of returning the error
- * @throws if not valid
- */
-async function validate (coalescedAppConfigObj, options = {}) {
-  const throws = options.throws === undefined ? false : options.throws
-  /* eslint-disable-next-line node/no-unpublished-require */
-  const ajv = new Ajv({
-    allErrors: true,
-    allowUnionTypes: true
-  })
-  ajvAddFormats(ajv)
-  const validate = ajv.compile(schema)
-
-  const valid = validate(coalescedAppConfigObj)
-  const errors = validate.errors
-  if (!valid && throws) {
-    throw new Error(`Missing or invalid keys in ${defaults.USER_CONFIG_FILE}: ${JSON.stringify(errors, null, 2)}`)
-  }
-  return { valid, errors }
-}
-
 /** @private */
-async function loadCommonConfig (/* istanbul ignore next */options = {}) {
-  let aioConfig = {}
-  if (!options.ignoreAioConfig) {
-    // load aio config (mostly runtime and console config)
-    aioConfigLoader.reload()
-    aioConfig = aioConfigLoader.get() || {}
-  }
+function loadCommonConfig () {
+  // load aio config (mostly runtime and console config)
+  aioConfigLoader.reload()
+  const aioConfig = aioConfigLoader.get() || {}
 
-  const packagejson = await fs.readJson('package.json', { throws: true })
+  const packagejson = fs.readJsonSync('package.json', { throws: true })
 
   // defaults
   // remove scoped name to use this for open whisk entities
@@ -243,7 +168,7 @@ async function loadCommonConfig (/* istanbul ignore next */options = {}) {
   owConfig.defaultApihost = defaults.defaultOwApihost
   owConfig.apihost = owConfig.apihost || defaults.defaultOwApihost // set by user
   owConfig.apiversion = owConfig.apiversion || 'v1'
-  // default package name for replacing the legacy __APP_PACKAGE__ placeholder
+  // default package name replacing __APP_PACKAGE__ placeholder
   owConfig.package = `${packagejson.name}-${packagejson.version}`
 
   return {
@@ -256,57 +181,57 @@ async function loadCommonConfig (/* istanbul ignore next */options = {}) {
 }
 
 /** @private */
-// function checkCommonConfig (commonConfig) {
-//   // todo this depends on the commands, expose a throwOnMissingConsoleInfo ?
-//   // if (!commonConfig.aio.project || !commonConfig.ow.auth) {
-//   //   throw new Error('Missing project configuration, import a valid Console configuration first via \'aio app use\'')
-//   // }
-// }
+function checkCommonConfig (commonConfig) {
+  // todo this depends on the commands, expose a throwOnMissingConsoleInfo ?
+  // if (!commonConfig.aio.project || !commonConfig.ow.auth) {
+  //   throw new Error('Missing project configuration, import a valid Console configuration first via \'aio app use\'')
+  // }
+}
 
-/**
- * Resolve all includes, update relative paths and return a coalesced app
- * configuration object.
- *
- * Returns the appConfig along with an index of config keys to config file. The
- * config file paths in the index are absolute.
- *
- * @param {string} appConfigFile path to the app.config.yaml
- * @param {object} options options
- * @param {object} options.absolutePaths boolean, true for rewriting
- *  configuration paths to absolute, false for relative to the appConfigFile
- *  directory. Defaults to false. Note, that config values will never be
- *  rewritten as relative to the cwd. But also note that
- *  this option doesn't have any effect on the includeIndex paths which stay
- *  relative to the cwd.
- * @returns {object} { config, includeIndex }
- */
-async function coalesce (appConfigFile, options = {}) {
-  // this code is traversing app.config.yaml recursively to resolve all $includes directives
+/** @private */
+function loadUserConfig (commonConfig) {
+  const { config: legacyConfig, includeIndex: legacyIncludeIndex } = loadUserConfigLegacy(commonConfig)
+  const { config, includeIndex } = loadUserConfigAppYaml()
 
-  const absolutePaths = options.absolutePaths === undefined ? false : options.absolutePaths
-  const appRoot = path.dirname(appConfigFile)
+  const ret = {}
+  // include legacy application configuration
+  ret.config = mergeLegacyUserConfig(config, legacyConfig)
+  // merge includeIndexes, new config index takes precedence
+  ret.includeIndex = { ...legacyIncludeIndex, ...includeIndex }
 
-  const config = yaml.safeLoad(await fs.readFile(appConfigFile, 'utf8'))
+  return ret
+}
+
+/** @private */
+function loadUserConfigAppYaml () {
+  if (!fs.existsSync(defaults.USER_CONFIG_FILE)) {
+    // no error, support for legacy configuration
+    return { config: {}, includeIndex: {} }
+  }
+
+  // this code is traversing app.config.yaml recursively to resolve all $includes directives
+
+  // SETUP
+  // the config with $includes to be resolved
+  const config = yaml.safeLoad(fs.readFileSync(defaults.USER_CONFIG_FILE, 'utf8'))
   // keep an index that will map keys like 'extensions.abc.runtimeManifest' to the config file where there are defined
   const includeIndex = {}
   // keep a cache for common included files - avoid to read a same file twice
   const configCache = {}
-
-  // stack entries to be iterated on
+  // stack entries to be added for new iterations
   /** @private */
   function buildStackEntries (obj, fullKeyParent, relativeFullKeyParent, includedFiles, filterKeys = null) {
     return Object.keys(obj || {})
       // include filtered keys only
       .filter(key => !filterKeys || filterKeys.includes(key))
-      // `parentObj` stores the parent config object
-      // `includedFiles` tracks already included files, is used for cycle detection and building the index key,
-      // `fullKey` store parents and used for building the index,
-      // `relativeFullKey` stores the key relative to the included file (e.g. actions are included  actions.
+      // parentObj will be filled with $includes files
+      // includedFiles keep track of already included files, for cycle detection and building the index
+      // key, if its $includes will be loaded, if array or object will be recursively followed
+      // fullKey keeps track of all parents, used for building the index, relativeFullKey keeps track of the key in the included file
       .map(key => ({ parentObj: obj, includedFiles, key, fullKey: fullKeyParent.concat(`.${key}`), relativeFullKey: relativeFullKeyParent.concat(`.${key}`) }))
   }
-
-  // initialize with top level config object, each key will be traversed and checked for $include directive
-  const traverseStack = buildStackEntries(config, '', '', [appConfigFile])
+  // start with top level object
+  const traverseStack = buildStackEntries(config, '', '', [defaults.USER_CONFIG_FILE])
 
   // ITERATIONS
   // iterate until there are no entries
@@ -316,8 +241,7 @@ async function coalesce (appConfigFile, options = {}) {
     const currConfigFile = includedFiles[includedFiles.length - 1]
 
     // add full key to the index, slice(1) to remove initial dot
-    const fullIndexKey = fullKey.slice(1)
-    includeIndex[fullIndexKey] = {
+    includeIndex[fullKey.slice(1)] = {
       file: currConfigFile,
       key: relativeFullKey.slice(1)
     }
@@ -325,7 +249,7 @@ async function coalesce (appConfigFile, options = {}) {
     const value = parentObj[key]
 
     if (typeof value === 'object') {
-      // if value is an object or an array, add new entries to be traversed
+      // if value is an object or an array, add entries for to stack
       traverseStack.push(...buildStackEntries(value, fullKey, relativeFullKey, includedFiles))
       continue
     }
@@ -333,24 +257,24 @@ async function coalesce (appConfigFile, options = {}) {
     if (key === defaults.INCLUDE_DIRECTIVE) {
       // $include: 'configFile', value is string pointing to config file
       // includes are relative to the current config file
-
       // config path in index always as unix path, it doesn't matter but makes it easier to generate testing mock data
       const incFile = path.join(path.dirname(currConfigFile), value)
       const configFile = incFile.split(path.sep).join(path.posix.sep)
+      // const configFile = upath.toUnix(path.join(path.dirname(currConfigFile), value))
 
       // 1. check for include cycles
       if (includedFiles.includes(configFile)) {
         throw new Error(`Detected '${defaults.INCLUDE_DIRECTIVE}' cycle: '${[...includedFiles, configFile].toString()}', please make sure that your configuration has no cycles.`)
       }
       // 2. check if file exists
-      if (!configCache[configFile] && !(await fs.exists(configFile))) {
+      if (!configCache[configFile] && !fs.existsSync(configFile)) {
         throw new Error(`'${defaults.INCLUDE_DIRECTIVE}: ${configFile}' cannot be resolved, please make sure the file exists.`)
       }
       // 3. delete the $include directive to be replaced
       delete parentObj[key]
       // 4. load the included file
-      // Note the included file can in turn also have includes, so we will have to traverse it as well
-      const loadedConfig = configCache[configFile] || yaml.safeLoad(await fs.readFile(configFile, 'utf8'))
+      // Note the included file can in turn also have includes
+      const loadedConfig = configCache[configFile] || yaml.safeLoad(fs.readFileSync(configFile, 'utf8'))
       if (Array.isArray(loadedConfig) || typeof loadedConfig !== 'object') {
         throw new Error(`'${defaults.INCLUDE_DIRECTIVE}: ${configFile}' does not resolve to an object. Including an array or primitive type config is not supported.`)
       }
@@ -368,14 +292,13 @@ async function coalesce (appConfigFile, options = {}) {
     // else primitive types: do nothing
   }
 
-  const appConfigWithIncludeIndex = { config, includeIndex }
-  rewritePathsInPlace(appConfigWithIncludeIndex, { absolutePaths, appRoot })
-
-  return appConfigWithIncludeIndex
+  // RETURN
+  // $includes are now resolved
+  return { config, includeIndex }
 }
 
 /** @private */
-async function legacyToAppConfig (commonConfig) {
+function loadUserConfigLegacy (commonConfig) {
   // load legacy user app config from manifest.yml, package.json, .aio.app
   const includeIndex = {}
   const legacyAppConfig = {}
@@ -395,8 +318,8 @@ async function legacyToAppConfig (commonConfig) {
   }
 
   // 2. load legacy manifest.yaml
-  if (await fs.exists(defaults.LEGACY_RUNTIME_MANIFEST)) {
-    const runtimeManifest = yaml.safeLoad(await fs.readFile(defaults.LEGACY_RUNTIME_MANIFEST, 'utf8'))
+  if (fs.existsSync(defaults.LEGACY_RUNTIME_MANIFEST)) {
+    const runtimeManifest = yaml.safeLoad(fs.readFileSync(defaults.LEGACY_RUNTIME_MANIFEST, 'utf8'))
     legacyAppConfig.runtimeManifest = runtimeManifest
     // populate index
     const baseKey = `${defaults.APPLICATION_CONFIG_KEY}.runtimeManifest`
@@ -442,126 +365,83 @@ async function legacyToAppConfig (commonConfig) {
     }
   }
 
-  const appConfigWithIncludeIndex = { includeIndex, config: { [defaults.APPLICATION_CONFIG_KEY]: legacyAppConfig } }
-  if (Object.keys(includeIndex).length <= 0) {
-    // no legacy configuration return now
-    // todo return undefined here and for normal config, rewrite load and merge logic
-    return appConfigWithIncludeIndex
+  if (Object.keys(includeIndex).length > 0) {
+    // add the top key
+    includeIndex[`${defaults.APPLICATION_CONFIG_KEY}`] = { file: '.aio', key: 'app' }
   }
 
-  // add the top key
-  includeIndex[`${defaults.APPLICATION_CONFIG_KEY}`] = { file: '.aio', key: 'app' }
-
-  /* always absolute paths for now. Note that if we were interested in relative
-  paths there would be no need to rewrite, as all paths are
-  defined in the app root folder for legacy apps */
-  rewritePathsInPlace(appConfigWithIncludeIndex, { absolutePaths: true })
-
-  return appConfigWithIncludeIndex
+  return { includeIndex, config: { [defaults.APPLICATION_CONFIG_KEY]: legacyAppConfig } }
 }
 
 /** @private */
-function rewritePathsInPlace (appConfigWithIncludeIndex, options) {
-  const { config: appConfig, includeIndex } = appConfigWithIncludeIndex
+function mergeLegacyUserConfig (userConfig, legacyUserConfig) {
+  // NOTE: here we do a simplified merge, deep merge with copy might be wanted in future
 
-  const buildStackEntries = (currObj, currFullKey) => Object.keys(currObj || {} /* cover for null */).map(k => {
-    const fullKey = currFullKey ? currFullKey + '.' + k : k
-    const includedFromConfigFile = includeIndex[fullKey].file
-    return { fullKey, includedFromConfigFile, key: k, parentObj: currObj }
-  })
-  const stack = buildStackEntries(appConfig)
-
-  while (stack.length > 0) {
-    const { fullKey, includedFromConfigFile, key, parentObj } = stack.pop()
-    const value = parentObj[key]
-
-    if (typeof value === 'string' && PATH_KEYS.filter(reg => fullKey.match(reg)).length) {
-      // rewrite path value to be relative to the root instead of being relative to the config file that includes it
-      parentObj[key] = resolveToRoot(value, includedFromConfigFile, options)
-    }
-    if (typeof value === 'object') {
-      // object or Array
-      stack.push(...buildStackEntries(value, fullKey))
-    }
-  }
-}
-
-/** @private */
-async function mergeLegacyAppConfig (appConfigWithIncludeIndex, legacyAppConfigWithIncludeIndex) {
-  // NOTE: here we do a simplified merge, deep merge with copy might be wanted
-
-  // only need to merge application configs as legacy config system does not work with extensions
-  const application = appConfigWithIncludeIndex.config[defaults.APPLICATION_CONFIG_KEY]
-  const legacyApplication = legacyAppConfigWithIncludeIndex.config[defaults.APPLICATION_CONFIG_KEY]
+  // only need to merge application configs as legacy config system only works for standalone apps
+  const userConfigApp = userConfig[defaults.APPLICATION_CONFIG_KEY]
+  const legacyUserConfigApp = legacyUserConfig[defaults.APPLICATION_CONFIG_KEY]
 
   // merge 1 level config fields, such as 'actions': 'path/to/actions', precedence for new config
-  const mergedApplication = { ...legacyApplication, ...application }
+  const mergedApp = { ...legacyUserConfigApp, ...userConfigApp }
 
   // special cases if both are defined
-  if (application && legacyApplication) {
+  if (legacyUserConfigApp && userConfigApp) {
     // for simplicity runtimeManifest is not merged, it's one or the other
-    if (legacyApplication.runtimeManifest && application.runtimeManifest) {
+    if (legacyUserConfigApp.runtimeManifest && userConfigApp.runtimeManifest) {
       aioLogger.warn('\'manifest.yml\' is ignored in favor of key \'runtimeManifest\' in \'app.config.yaml\'.')
     }
     // hooks are merged
-    if (legacyApplication.hooks && application.hooks) {
-      mergedApplication.hooks = { ...legacyApplication.hooks, ...application.hooks }
+    if (legacyUserConfigApp.hooks && userConfigApp.hooks) {
+      mergedApp.hooks = { ...legacyUserConfigApp.hooks, ...userConfigApp.hooks }
     }
   }
 
   return {
-    config: {
-      ...appConfigWithIncludeIndex.config,
-      [defaults.APPLICATION_CONFIG_KEY]: mergedApplication
-    },
-    // new configuration index takes precedence
-    includeIndex: { ...legacyAppConfigWithIncludeIndex.includeIndex, ...appConfigWithIncludeIndex.includeIndex }
+    ...userConfig,
+    [defaults.APPLICATION_CONFIG_KEY]: mergedApp
   }
 }
 
 /** @private */
-async function buildAllConfigs (userConfig, commonConfig, includeIndex) {
+function buildAllConfigs (userConfig, commonConfig, includeIndex) {
   return {
-    ...(await buildAppConfig(userConfig, commonConfig, includeIndex)),
-    ...(await buildExtConfigs(userConfig, commonConfig, includeIndex))
+    ...buildAppConfig(userConfig, commonConfig, includeIndex),
+    ...buildExtConfigs(userConfig, commonConfig, includeIndex)
   }
 }
 
 /** @private */
-async function buildExtConfigs (userConfig, commonConfig, includeIndex) {
+function buildExtConfigs (userConfig, commonConfig, includeIndex) {
   const configs = {}
   if (userConfig[defaults.EXTENSIONS_CONFIG_KEY]) {
-    const entries = Object.entries(userConfig[defaults.EXTENSIONS_CONFIG_KEY])
-    for (const [extName, singleUserConfig] of entries) {
-      configs[extName] = await buildSingleConfig(extName, singleUserConfig, commonConfig, includeIndex)
+    Object.entries(userConfig[defaults.EXTENSIONS_CONFIG_KEY]).forEach(([extName, singleUserConfig]) => {
+      configs[extName] = buildSingleConfig(extName, singleUserConfig, commonConfig, includeIndex)
       // extensions have an extra operations field
       configs[extName].operations = singleUserConfig.operations
-      // this is checked by the schema validation
-      // if (!configs[extName].operations) {
-      //   throw new Error(`Missing 'operations' config field for extension point ${extName}`)
-      // }
-    }
+      if (!configs[extName].operations) {
+        throw new Error(`Missing 'operations' config field for extension point ${extName}`)
+      }
+    })
   }
   return configs
 }
 
 /** @private */
-async function buildAppConfig (userConfig, commonConfig, includeIndex) {
-  const fullAppConfig = await buildSingleConfig(defaults.APPLICATION_CONFIG_KEY,
+function buildAppConfig (userConfig, commonConfig, includeIndex) {
+  const fullAppConfig = buildSingleConfig(defaults.APPLICATION_CONFIG_KEY,
     userConfig[defaults.APPLICATION_CONFIG_KEY],
     commonConfig,
     includeIndex)
 
-  // todo: this needs to be updated; an app doesn't exist if there is no config.
   if (!fullAppConfig.app.hasBackend && !fullAppConfig.app.hasFrontend) {
-    // only set application config if there is an actual app, meaning either some backend or frontend
+    // only set application config if there is an actuall app, meaning either some backend or frontend
     return {}
   }
   return { [defaults.APPLICATION_CONFIG_KEY]: fullAppConfig }
 }
 
 /** @private */
-async function buildSingleConfig (configName, singleUserConfig, commonConfig, includeIndex) {
+function buildSingleConfig (configName, singleUserConfig, commonConfig, includeIndex) {
   // used as subfolder folder in dist, converts to a single dir, e.g. dx/excshell/1 =>
   // dx-excshell-1 and dist/dx-excshell-1/actions/action-xyz.zip
   const subFolderName = configName.replace(/\//g, '-')
@@ -585,32 +465,28 @@ async function buildSingleConfig (configName, singleUserConfig, commonConfig, in
     return config
   }
 
-  // Default paths are relative to the folder holding the config file.
+  const otherKeyInObject = Object.keys(singleUserConfig)[0]
+  // The default action and web path are relative to the folder holding the config file.
   // Let's search the config path that defines a key in the same config object level as 'web' or
   // 'action'
-  const otherKeyInObject = Object.keys(singleUserConfig)[0]
-  const configFilePath = includeIndex[`${fullKeyPrefix}.${otherKeyInObject}`].file
-
-  const defaultActionPath = resolveToRoot('actions/', configFilePath)
-  const defaultWebPath = resolveToRoot('web-src/', configFilePath)
-  const defaultUnitTestPath = resolveToRoot('test/', configFilePath)
-  const defaultE2eTestPath = resolveToRoot('e2e/', configFilePath)
+  const defaultActionPath = pathConfigValueToAbs('actions/', `${fullKeyPrefix}.${otherKeyInObject}`, includeIndex)
+  const defaultWebPath = pathConfigValueToAbs('web-src/', `${fullKeyPrefix}.${otherKeyInObject}`, includeIndex)
+  const defaultUnitTestPath = pathConfigValueToAbs('test/', `${fullKeyPrefix}.${otherKeyInObject}`, includeIndex)
+  const defaultE2eTestPath = pathConfigValueToAbs('e2e/', `${fullKeyPrefix}.${otherKeyInObject}`, includeIndex)
   const defaultDistPath = 'dist/' // relative to root
 
   // absolute paths
-  const actions = singleUserConfig.actions || defaultActionPath
-  const unitTest = singleUserConfig.unitTest || defaultUnitTestPath
-  const e2eTest = singleUserConfig.e2eTest || defaultE2eTestPath
-  const dist = singleUserConfig.dist || defaultDistPath
+  const actions = pathConfigValueToAbs(singleUserConfig.actions, fullKeyPrefix + '.actions', includeIndex) || defaultActionPath
+  const unitTest = pathConfigValueToAbs(singleUserConfig.unitTest, fullKeyPrefix + '.web', includeIndex) || defaultUnitTestPath
+  const e2eTest = pathConfigValueToAbs(singleUserConfig.e2eTest, fullKeyPrefix + '.web', includeIndex) || defaultE2eTestPath
+  const dist = pathConfigValueToAbs(singleUserConfig.dist, fullKeyPrefix + '.dist', includeIndex) || defaultDistPath
 
-  // web src folder might be defined in 'web' key or 'web.src' key
   let web
-  if (typeof singleUserConfig.web === 'string') {
-    web = singleUserConfig.web
-  } else if (typeof singleUserConfig.web === 'object') {
-    web = singleUserConfig.web.src || defaultWebPath
+  if (!singleUserConfig.web || typeof singleUserConfig.web === 'string') {
+    // keep backward compatibility - web src is directly defined as string web: web-src
+    web = pathConfigValueToAbs(singleUserConfig.web, fullKeyPrefix + '.web', includeIndex) || defaultWebPath
   } else {
-    web = defaultWebPath
+    web = pathConfigValueToAbs(singleUserConfig.web.src, fullKeyPrefix + '.web', includeIndex) || defaultWebPath
   }
 
   config.tests.unit = path.resolve(unitTest)
@@ -619,7 +495,7 @@ async function buildSingleConfig (configName, singleUserConfig, commonConfig, in
   const manifest = singleUserConfig.runtimeManifest
 
   config.app.hasBackend = !!manifest
-  config.app.hasFrontend = await fs.exists(web)
+  config.app.hasFrontend = fs.existsSync(web)
   config.app.dist = path.resolve(dist, dist === defaultDistPath ? subFolderName : '')
 
   if (singleUserConfig.events) {
@@ -633,8 +509,8 @@ async function buildSingleConfig (configName, singleUserConfig, commonConfig, in
   config.actions.src = path.resolve(actions) // needed for app add first action
   if (config.app.hasBackend) {
     config.actions.dist = path.join(config.app.dist, 'actions')
-    config.manifest = { src: 'manifest.yml' } // even for non legacy config paths, it is required for runtime sync
-    config.manifest.full = cloneDeep(manifest)
+    config.manifest = { src: 'manifest.yml' } // even if a legacy config path, it is required for runtime sync
+    config.manifest.full = rewriteRuntimeManifestPathsToRelRoot(manifest, fullKeyPrefix + '.runtimeManifest', includeIndex)
     config.manifest.packagePlaceholder = '__APP_PACKAGE__'
     config.manifest.package = config.manifest.full.packages && config.manifest.full.packages[config.manifest.packagePlaceholder]
     if (config.manifest.package) {
@@ -689,27 +565,43 @@ async function buildSingleConfig (configName, singleUserConfig, commonConfig, in
   return config
 }
 
+/** @private */
+function rewriteRuntimeManifestPathsToRelRoot (manifestConfig, fullKeyToManifest, includeIndex) {
+  const manifestCopy = cloneDeep(manifestConfig)
+
+  Object.entries(manifestCopy.packages || {}).forEach(([pkgName, pkg]) => {
+    Object.entries(pkg.actions || {}).forEach(([actionName, action]) => {
+      const fullKeyToAction = `${fullKeyToManifest}.packages.${pkgName}.actions.${actionName}`
+      if (action.function) {
+        // absolut path
+        action.function = pathConfigValueToAbs(action.function, fullKeyToAction + '.function', includeIndex)
+      }
+      if (action.include) {
+        action.include.forEach((arr, i) => {
+          // absolut path
+          action.include[i][0] = pathConfigValueToAbs(action.include[i][0], fullKeyToAction + `.include.${i}.0`, includeIndex)
+        })
+      }
+    })
+  })
+
+  return manifestCopy
+}
+
 // Because of the $include directives, config paths (e.g actions: './path/to/actions') can
 // be relative to config files in any subfolder. Config keys that define path values are
 // identified and their value is rewritten relative to the root folder.
 /** @private */
-function resolveToRoot (pathValue, includedFromConfigPath, options = {}) {
-  // path.resolve => support both absolute pathValue and relative (relative joins with
-  // config dir and process.cwd, absolute returns pathValue)
-  if (options.absolutePaths) {
-    return path.resolve(path.dirname(includedFromConfigPath), pathValue)
-  }
-
-  // relative paths
-  if (options.appRoot) {
-    // make sure path is relative to appRoot and not cwd
-    includedFromConfigPath = path.relative(options.appRoot, includedFromConfigPath)
+function pathConfigValueToAbs (pathValue, fullKeyToPathValue, includeIndex) {
+  const configData = includeIndex[fullKeyToPathValue]
+  if (!pathValue || !configData) {
+    return undefined
   }
-  return path.join(path.dirname(includedFromConfigPath), pathValue).split(path.sep).join(path.posix.sep)
+  // if path value is defined and fullKeyToPathValyue is correct then index has an entry
+  const configPath = configData.file
+  // path.resolve => support both absolut pathValue and relative (relative joins with
+  // config dir and process.cwd, absolut returns pathValue)
+  return path.resolve(path.dirname(configPath), pathValue)
 }
 
-module.exports = {
-  load,
-  validate,
-  coalesce
-}
+module.exports = loadConfig

package/schema/app.config.yaml.schema.json

@@ -1,236 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "$id": "https://adobe.io/schemas/app-builder/app.config.yaml.json/v2",
-  "type": "object",
-  "properties": {
-    "application": { "$ref": "#/definitions/application" },
-    "extensions": { "$ref": "#/definitions/extensions" },
-    "configSchema": { "$ref": "#/definitions/configSchema"},
-    "productDependencies": { "$ref": "#/definitions/productDependencies"}
-  },
-  "anyOf": [
-    {
-      "required": ["application"]
-    },
-    {
-      "required": ["extensions"]
-    }
-  ],
-  "definitions": {
-    "extensions": {
-      "type": "object",
-      "patternProperties": {
-        "^[A-Za-z0-9-_/\\-]+$": {
-          "$ref": "#/definitions/application",
-          "type": "object",
-          "properties": {
-            "operations": {
-              "type": "object",
-              "patternProperties": {
-                "^[^\n]+$": {
-                  "type":"array",
-                  "items": {
-                    "type": "object",
-                    "properties": {
-                      "type": { "type": "string" },
-                      "impl": { "type": "string" }
-                    }
-                  },
-                  "minItems": 1
-                }
-              },
-              "minProperties": 1
-            }
-          },
-          "required": ["operations"]
-        }
-      },
-      "additionalProperties": false
-    },
-    "application": {
-      "type": "object",
-      "properties": {
-        "runtimeManifest": { "$ref": "#/definitions/runtimeManifest" },
-        "actions": { "type": "string" },
-        "unitTest": { "type": "string" },
-        "e2eTest": { "type": "string" },
-        "dist": { "type": "string" },
-        "tvmurl": { "type": "string" },
-        "awsaccesskeyid": { "type": "string" },
-        "awssecretaccesskey": { "type": "string" },
-        "s3bucket": { "type": "string" },
-        "events": { "$ref": "#/definitions/events" },
-        "hostname": { "type": "string" },
-        "htmlcacheduration": { "type": "number" },
-        "jscacheduration": { "type": "number" },
-        "csscacheduration": { "type": "number" },
-        "imagecacheduration": { "type": "number" },
-        "hooks": { "$ref": "#/definitions/hooks" },
-        "web": { "$ref": "#/definitions/web" }
-      },
-      "required": []
-    },
-    "web": {
-      "anyOf": [
-        {
-          "type": "string"
-        },
-        {
-          "type": "object",
-          "properties": {
-            "src": { "type": "string" },
-            "response-headers": {
-              "type": "object",
-              "patternProperties": {
-                "^[^\n]+$": {
-                  "type":"object",
-                  "patternProperties": { "^[^\n]+$": { "type":"string" } }
-                }
-              }
-            }
-          },
-          "additionalProperties": false
-        }
-      ]
-    },
-    "runtimeManifest": {
-      "type": "object",
-      "properties": {
-        "packages": { "$ref": "#/definitions/packages" }
-      },
-      "required": ["packages"]
-    },
-    "packages": {
-      "type": "object",
-      "patternProperties": {
-        "^[^\n]+$": {
-          "$ref": "#/definitions/package"
-        }
-      },
-      "additionalProperties": false
-    },
-    "package": {
-      "type": "object",
-      "properties": {
-        "license": { "type": "string" },
-        "actions": { "$ref": "#/definitions/actions" }
-      }
-    },
-    "actions": {
-      "type": "object",
-      "patternProperties": {
-        "^[^\n]+$": {
-          "$ref": "#/definitions/action"
-        }
-      },
-      "additionalProperties": false
-    },
-    "action": {
-      "type": "object",
-      "properties": {
-        "function": { "type": "string" },
-        "web": { "type": "string" },
-        "runtime": { "type": "string" },
-        "inputs": { "$ref": "#/definitions/inputs" },
-        "annotations": { "$ref": "#/definitions/annotations" }
-      },
-      "required": []
-    },
-    "inputs": {
-      "type": "object",
-      "patternProperties": {
-        "^[^\n]+$": {
-          "type": ["string", "boolean"]
-        }
-      },
-      "additionalProperties": false
-    },
-    "annotations": {
-      "type": "object",
-      "patternProperties": {
-        "^[^\n]+$": {
-          "type": ["string", "boolean"]
-        }
-      },
-      "additionalProperties": false
-    },
-    "hooks": {
-      "type": "object",
-      "properties": {
-        "pre-app-build": { "type": "string" },
-        "post-app-build": { "type": "string" },
-        "build-actions": { "type": "string" },
-        "build-static": { "type": "string" },
-        "pre-app-deploy": { "type": "string" },
-        "post-app-deploy": { "type": "string" },
-        "deploy-actions": { "type": "string" },
-        "deploy-static": { "type": "string" },
-        "pre-app-undeploy": { "type": "string" },
-        "post-app-undeploy": { "type": "string" },
-        "undeploy-actions": { "type": "string" },
-        "undeploy-static": { "type": "string" },
-        "pre-app-run": { "type": "string" },
-        "post-app-run": { "type": "string" },
-        "serve-static": { "type": "string" }
-      }
-    },
-    "events": {
-      "type": "object",
-      "properties": {
-        "registrations": {
-          "type": "object",
-          "patternProperties": {
-            "^[^\n]+$": {
-              "type": "object",
-              "properties": {
-                "description": { "type": "string" },
-                "events_of_interest": {
-                  "type": "array",
-                  "items": {
-                    "type": "object",
-                    "properties": {
-                      "provider_metadata": { "type": "string" },
-                      "event_codes": { "type": "array" }
-                    }
-                  }
-                },
-                "runtime_action": {"type": "string" }
-              }
-            }
-          }
-        }
-      }
-    },
-    "configSchema": {
-      "type": "array",
-      "maxItems": 50,
-      "items": {
-        "type": "object",
-        "properties": {
-          "type": { "type": "string", "enum": ["string", "boolean"] },
-          "title": { "type": "string", "maxLength": 200 },
-          "envKey": { "type": "string", "pattern": "[a-zA-Z_]{1,}[a-zA-Z0-9_]{0,}", "maxLength": 100 },
-          "enum": { "type": "array", "items": { "$ref": "#/definitions/configSchemaValue" }, "minItems": 1, "maxItems": 100 },
-          "default": { "$ref": "#/definitions/configSchemaValue" },
-          "secret": { "type": "boolean" }
-        },
-        "required": ["type", "envKey"],
-        "additionalProperties": false
-      }
-    },
-    "configSchemaValue": { "type": "string", "maxLength": 1000 },
-    "productDependencies": {
-      "type": "array",
-      "items": {
-        "type": "object",
-        "properties": {
-          "code": { "type": "string" },
-          "minVersion": { "type": "string", "pattern": "^[0-9]+.[0-9]+.[0-9]+$" },
-          "maxVersion": { "type": "string", "pattern": "^[0-9]+.[0-9]+.[0-9]+$" }
-        },
-        "required": ["code", "minVersion", "maxVersion"],
-        "additionalProperties": false
-      }
-    }
-  }
-}