@sap/cds-dk 8.4.1 → 8.5.0

package/lib/build/provider/nodejs/index.js

@@ -3,7 +3,7 @@ const path = require('path')
 const cds = require('../../../cds')
 const cmd = require('../../../util/command');
 const EdmxBuildPlugin = require('../edmxBuildPlugin')
-const { BuildError, getWorkspaces } = require('../../util')
+const { BuildError, getWorkspaces, findWorkspaceRoot } = require('../../util')
 const { OUTPUT_MODE, OUTPUT_MODE_FILESYSTEM, ODATA_VERSION_V2, FOLDER_GEN, CONTENT_EDMX, CONTENT_PACKAGELOCK_JSON,
     CONTENT_NPMRC, CONTENT_CDSRC_JSON, CONTENT_ENV, CONTENT_DEFAULT_ENV_JSON, FLAVOR_LOCALIZED_EDMX,
     OPTION_WS_PACK} = require('../../constants')
@@ -160,14 +160,14 @@ class NodejsBuildPlugin extends EdmxBuildPlugin {
     }
 
     async _packWorkspaceDependencies(dest) {
-        const wsRoot = NodejsBuildPlugin._findWorkspaceRoot(cds.root)
+        const wsRoot = findWorkspaceRoot(cds.root)
         const appPkg = require(path.join(dest, 'package.json'))
         let workspaces
         if (this.task.options.workspaces) {
             workspaces = Array.isArray(this.task.options.workspaces) ? this.task.options.workspaces : [this.task.options.workspaces]
         } else {
             // devDependencies are not considered
-            workspaces = await getWorkspaces(true, false, wsRoot);
+            workspaces = await getWorkspaces(wsRoot, true, false);
         }
         if (workspaces.length) {
             let pkgDescriptors
@@ -197,22 +197,6 @@ class NodejsBuildPlugin extends EdmxBuildPlugin {
         }
     }
 
-    static _findWorkspaceRoot(dir) {
-        try {
-            if (require(path.join(dir, 'package.json')).workspaces) {
-                return dir
-            }
-        } catch (err) {
-            // ignore
-        }
-        if (fs.existsSync(path.join(dir, '.gitmodules'))) {
-            return // project root reached
-        }
-        if (path.dirname(dir) !== dir) {
-            return this._findWorkspaceRoot(path.dirname(dir))
-        }
-    }
-
     static async _execNpmPack(dest, wsRoot, workspaces) {
         const args = ['pack', '-ws', '--json', `--pack-destination=${dest}`]
         workspaces.forEach(w => args.push(`-w=${w}`))

package/lib/build/util.js

@@ -7,6 +7,7 @@ const IS_WIN = require('os').platform() === 'win32'
 const { SEVERITY_ERROR, FILE_EXT_CDS } = require('./constants');
 const DEBUG = cds.debug('cli|build')
 const SECRETS = /(passw)|(cert)|(ca)|(secret)|(key)/i
+const WS_MAX_DEPTH = 2
 
 function getProperty(src, segments) {
     segments = Array.isArray(segments) ? segments : segments.split('.')
@@ -98,13 +99,13 @@ function _redacted(cred) {
     if (!cred) return cred
     if (Array.isArray(cred)) return cred.map(c => typeof c === 'string' ? '...' : _redacted(c))
     if (typeof cred === 'object') {
-      const newCred = Object.assign({}, cred)
-      Object.keys(newCred).forEach(k => (typeof newCred[k] === 'string' && SECRETS.test(k)) ? (newCred[k] = '...') : (newCred[k] = _redacted(newCred[k])))
-      return newCred
+        const newCred = Object.assign({}, cred)
+        Object.keys(newCred).forEach(k => (typeof newCred[k] === 'string' && SECRETS.test(k)) ? (newCred[k] = '...') : (newCred[k] = _redacted(newCred[k])))
+        return newCred
     }
     return cred
 }
-  
+
 /**
  * Returns a list of fully qualified model names belonging to the '@sap' namespace that cannot be resolved.
  * E.g. the module might NOT have been installed.
@@ -173,28 +174,30 @@ async function pathExists(path) {
     return fs.promises.access(path).then(() => true).catch(() => false);
 }
 
+async function getWorkspacePaths() {
+    const wsRoot = findWorkspaceRoot(cds.root)
+    if (!wsRoot) {
+        return []
+    }
+    return (await getWorkspaces(wsRoot)).filter(ws => cds.root !== path.join(wsRoot, ws)).map(ws => path.join(wsRoot, ws))
+}
+
 /**
  * Returns the list of workspaces defined for the current project. A workspace dependency
  * needs to be defined resulting in a corresponding sym-link.
- * @returns the paths are relative to 'cds.root'.
+ * @returns the paths are relative to 'wsRoot'.
  */
-async function getWorkspaces(resolve = false, devDependencies = true, wsRoot = cds.root) {
-    let pgkJsonWsRoot
-    try {
-        pgkJsonWsRoot = require(path.join(wsRoot, 'package.json'))
-    } catch (e) {
-        if (e.code === 'MODULE_NOT_FOUND') {
-            DEBUG?.(`No package.json found in project '${wsRoot}', skipping workspace resolution.`)
-            return []
-        }
-        throw e
+async function getWorkspaces(wsRoot, resolve = false, devDependencies = true) {
+    wsRoot ??= findWorkspaceRoot(cds.root)
+    if (!wsRoot) {
+        return []
     }
-
-    const workspaces = []
+    const pgkJsonWsRoot = require(path.join(wsRoot, 'package.json'))
     let pgkJson = pgkJsonWsRoot
     if (wsRoot !== cds.root) {
         pgkJson = require(path.join(cds.root, 'package.json'))
     }
+    const workspaces = []
     if (pgkJsonWsRoot.workspaces) {
         if (resolve) {
             _validateWsDependencies(wsRoot, pgkJson.dependencies, devDependencies ? pgkJson.devDependencies : {})
@@ -215,6 +218,25 @@ async function getWorkspaces(resolve = false, devDependencies = true, wsRoot = c
     return workspaces
 }
 
+function findWorkspaceRoot(currentPath, depth = 0) {
+    if (depth > WS_MAX_DEPTH) {
+        DEBUG?.(`No workspaces exist, max depth of ${WS_MAX_DEPTH} reached`)
+        return
+    }
+    const packageJson = path.join(currentPath, 'package.json')
+    if (fs.existsSync(packageJson)) {
+        if (require(path.join(currentPath, 'package.json')).workspaces) {
+            return currentPath
+        }
+    }
+    if (fs.existsSync(path.join(currentPath, '.gitmodules'))) {
+        return // project root reached
+    }
+    if (path.dirname(currentPath) !== currentPath) {
+        return findWorkspaceRoot(path.dirname(currentPath), depth + 1)
+    }
+}
+
 /**
  * This JavaScript function filterFeaturePaths is used to filter and categorize file paths 
  * from a given model into two categories: base and features.
@@ -452,7 +474,9 @@ module.exports = {
     getI18nDefaultFolder,
     normalizePath,
     pathExists,
+    getWorkspacePaths,
     getWorkspaces,
+    findWorkspaceRoot,
     filterFeaturePaths,
     getFiles,
     BuildMessage,

package/lib/deploy/to-hana/hdiDeployUtil.js

@@ -1,5 +1,4 @@
 const path = require('path');
-const util = require('util');
 const { bold } = require('../../util/term');
 
 const HDI_DEPLOY_LIB = '@sap/hdi-deploy';
@@ -40,15 +39,20 @@ module.exports = new class HdiDeployUtil {
         if (options.use_hdb === false) options.use_hdb = undefined
         deployerEnv.HDI_DEPLOY_OPTIONS = JSON.stringify(options)
 
-        const asyncDeploy = util.promisify(deploy);
-        const { exitCode, signal } = await asyncDeploy(dbDir, deployerEnv);
-        if (exitCode) {
-            let message = `HDI deployment failed with exit code ${exitCode}`;
-            if (signal) {
-                message += `. ${signal}`;
-            }
-            throw new Error(message);
-        }
+        return await new Promise((resolve, reject) => {
+            deploy(dbDir, deployerEnv, (error, response) => {
+                if (error) return reject(error)
+                if (response?.exitCode) {
+                    let message = `HDI deployment failed with exit code ${response.exitCode}.`
+                    if (response.signal) message += `. ${response.signal}`
+                    return reject(new Error(message))
+                }
+                return resolve()
+            }, {
+              stderrCB: buffer => console.error(buffer.toString()),
+              stdoutCB: buffer => console.log(buffer.toString())
+          })
+        })
     }
 
     _loadHdiDeployLib(cwd) {

package/lib/import/message.js

@@ -28,7 +28,7 @@ const messages = {
 	BOUND_ACTION_COLLISION: 'The combination of Action name and binding parameter type must be unique for Bound Action ',
 	STREAM_NO_COLLECTION: `'Edm.Stream' cannot be of Collection type.`,
 	UNSUPPORTED_PROPERTY_TYPE: 'Property cannot be of EntityType. Check the type: ',
-  UNRESOLVED_SCHEMA_NAMESPACE: `Could not resolve the schema `,
+	UNRESOLVED_SCHEMA_NAMESPACE: `Could not resolve the schema `,
 	INVALID_DATATYPE: `Invalid Data Type `,
 	ELEMENT_NAME_COLLISION: 'Collision between EntityContainer Element Name and Schema Element Name is currently not supported. Please check the element name: ',
 	NO_DEFAULT_FOR_COLLECTIONS: 'WARNING: Collection type cannot have a Default value.',
@@ -38,6 +38,7 @@ const messages = {
 	NULLABLE_KEY: 'WARNING: Key element cannot be Nullable.',
 	COLLISION_DETECTED: `INFO: Element name collision detected. Adding suffix to affected type category.`,
 	SPECIFY_CONFIG: 'For --config option, please specify correct JSON Object.',
+	INVALID_ANNOTATION: 'Annotation element must have a Term attribute',
 };
 
 function getMessages() {

package/lib/import/odata/metadataconverter/MetadataConverter.js

@@ -1,4 +1,6 @@
 'use strict';
+
+const message = require("../../message").getMessages();
  
 const vocabulariesMap = new Map([
     ['org.odata.core.v1', () => require('../vocabularies/Org.OData.Core.V1.json')],
@@ -1754,6 +1756,9 @@ class AnnotationExpression extends Expression {
     annotate(result) { super.annotate(this.getTargetPropertyName(), this.getTarget(), result); }
     interpret() {
         const element = this.getElement();
+        if(!Object.hasOwn(element, "attributes") || !Object.hasOwn(element.attributes, "Term")) {
+            throw new Error(message.INVALID_ANNOTATION);
+        }
         let name = element.attributes.Term;
         if (element.attributes.Qualifier) name += '#' + element.attributes.Qualifier;
         name = '@' + name;

package/lib/import/odata/v4parser.js

@@ -4,10 +4,10 @@
  */
 
 "use strict";
-let messages = require("../message").getMessages();
-let common = require("../common");
-let versionInfo = require("../../../package.json").version;
-let Multimap = require("./util/MultiMap");
+const messages = require("../message").getMessages();
+const common = require("../common");
+const versionInfo = require("../../../package.json").version;
+const Multimap = require("./util/MultiMap");
 const ignoreObjects = ["$Reference"]; // add all the objects that needs to be ignored for parsing.
 const { warn, info } = require("../../util/term");
 const MetadataConverterFactory = require("./metadataconverter/MetadataConverterFactory");
@@ -428,6 +428,11 @@ function _parseAnnotationTerms(annotationTerm, annotationTermObject, csnDefsTarg
 function _validateAnnotationNamespace(annotationTerm, vocabNamespaceToAlias) {
     let aliasOrNamespace = annotationTerm.substring(1, annotationTerm.lastIndexOf('.'));
 
+    // This check is for ignoring the @cds annotations given for special cases, e.g. @cds.validate = false for collided action/function
+    if (aliasOrNamespace === "cds") {
+        return
+    }
+    
     for (let alias of Object.values(known_vocabularies)) {
         if (alias === aliasOrNamespace) {
             return;
@@ -1358,29 +1363,6 @@ function _parseEntityContainer(csnDefs, entityContainerElements, parserContext)
     return csnDefs;
 }
 
-/**
- * @param {List<Object>} dataObjList, action/function object list
- * @returns unique parameter list
- */
-function _collectAllParameters(dataObjList) {
-    let uniqueParams = [], paramNames = [], params;
-
-    for (let dataObj of dataObjList) {
-        params = dataObj.$Parameter;
-
-        if (params) {
-            for (let i = 0; i < params.length; i++) {
-                if (!paramNames.includes(params[i].$Name)) {
-                    paramNames.push(params[i].$Name);
-                    uniqueParams.push(params[i]);
-                }
-            }
-        }
-    }
-
-    return uniqueParams;
-}
-
 /**
  * @param {Boolean} isAction, to identify action/function
  * @param {String} fqName, fully qualified name
@@ -1389,7 +1371,7 @@ function _collectAllParameters(dataObjList) {
  *
  * Scenarios:
  * 1. Unbound Actions can't have collision. Action name must be unique.
- * 2. Unbound Functions can have collision; capture the max number of parameters.
+ * 2. Unbound Functions can have collision; we will parse only one function with the same name having no paramter and a generic String return type.
  */
 function _populateUnboundActionFunction(isAction, fqName, schemaDataList, parserContext) {
     let [schemaName, actFunName] = _extractSchemaNameAndElementName(fqName);
@@ -1409,8 +1391,12 @@ function _populateUnboundActionFunction(isAction, fqName, schemaDataList, parser
     }
     else {
         if (dataList.length > 1) {
-            actionFunctionObject['$Parameter'] = _collectAllParameters(dataList);
+            actionFunctionObject['$Parameter'] = [];
             parserContext.unboundFunctions[fqName] = actionFunctionObject;
+            parserContext.unboundFunctions[fqName]["@cds.validate"] = false;
+            if(parserContext.unboundFunctions[fqName].$ReturnType){
+                parserContext.unboundFunctions[fqName].$ReturnType.$Type = "Edm.String";
+            }
         }
         else {
             parserContext.unboundFunctions[fqName] = actionFunctionObject;
@@ -1439,12 +1425,11 @@ function _collectUnboundActionFunction(schemaDataList, parserContext) {
  * @param {Object} parserContext
  *
  * Scenarios for bound actions, functions:
- * 1. Actions with same name and binding parameter type can't have collision.
- * 2. Functions can have collision and we will capture the max number of parameters.
+ * 1. Actions with same name and binding parameter type can have collision and we will parse only one action with that name having no paramter and a genric String return type.
+ * 2. Functions can have collision and we will parse only one function with that name having no paramter and a genric String return type.
  * Special scenario is when same function name is bound to different entity as well.
  */
 function _collectBoundActionFunction(isAction, currNamespace, elementName, elementDataList, parserContext) {
-    let functionObjList; // list to collect all the collision obj for function
 
     for (let i = 0; i < elementDataList.length; i++) {
         let dataObj = elementDataList[i];
@@ -1480,7 +1465,12 @@ function _collectBoundActionFunction(isAction, currNamespace, elementName, eleme
                 parserContext.entityToBoundActions[boundEntityName][elementName] = dataObj;
             }
             else {
-                throw new Error(messages.BOUND_ACTION_COLLISION + `${elementName} in entity ${entityName} of schema ${currNamespace}.`);
+                parserContext.entityToBoundActions[boundEntityName][elementName]["@cds.validate"] = false;
+                parserContext.entityToBoundActions[boundEntityName][elementName]["$Parameter"] = [];
+                if (!parserContext.entityToBoundActions[boundEntityName][elementName].$ReturnType) {
+                    parserContext.entityToBoundActions[boundEntityName][elementName].$ReturnType = {};
+                }
+                parserContext.entityToBoundActions[boundEntityName][elementName].$ReturnType.$Type = "Edm.String";
             }
         }
         else {
@@ -1488,18 +1478,12 @@ function _collectBoundActionFunction(isAction, currNamespace, elementName, eleme
                 if (!parserContext.entityToBoundFunctions[boundEntityName]) {
                     parserContext.entityToBoundFunctions[boundEntityName] = {};
                 }
-                if (!functionObjList || !parserContext.entityToBoundFunctions[boundEntityName][elementName]) {
-                    functionObjList = [];
-                }
                 parserContext.entityToBoundFunctions[boundEntityName][elementName] = dataObj;
-                functionObjList.push(dataObj);
             }
             else {
-                functionObjList.push(dataObj);
-                let functionObject = functionObjList[0];
-                functionObject['$Parameter'] = _collectAllParameters(functionObjList);
-                functionObjList = [functionObject]; // reset the function object list with recently formed object
-                parserContext.entityToBoundFunctions[boundEntityName][elementName] = functionObject;
+                parserContext.entityToBoundFunctions[boundEntityName][elementName]["@cds.validate"] = false;
+                parserContext.entityToBoundFunctions[boundEntityName][elementName]["$Parameter"] = [];
+                parserContext.entityToBoundFunctions[boundEntityName][elementName].$ReturnType.$Type = "Edm.String";
             }
             // throw error if the return type is missing
             if (!parserContext.entityToBoundFunctions[boundEntityName][elementName].$ReturnType) {
@@ -1688,7 +1672,12 @@ function _generateEDMX2JSON(edmx, name_space) {
                 if (missingReferencedDocuments?.length > 0) {
                     console.log(missingReferencedDocuments);  
                 }
-                resolve(json);
+
+                if (error) {
+                    reject(error);
+                } else {
+                    resolve(json);
+                }
             });
         } catch (err) {
             reject(err);

package/lib/index.js

@@ -35,6 +35,20 @@ class CdsDk {
   }
 }
 
+const REQUIRED_CDS_MAJOR = 7, REQUIRED_CDS_MINOR = 2
+const [major, minor] = cds.version.split('.').map(Number)
+if (major < REQUIRED_CDS_MAJOR || major === REQUIRED_CDS_MAJOR && minor < REQUIRED_CDS_MINOR) {
+  const [dkVersion] = require('../package.json').version.split('.')
+
+  console.error(`
+  This application uses '@sap/cds' version ${major}.${minor}, which is not compatible with the installed '@sap/cds-dk' version ${dkVersion}.
+  You can either:
+  - update '@sap/cds' to the latest version (recommended)
+  - downgrade '@sap/cds-dk' to version ${REQUIRED_CDS_MAJOR}
+`)
+  process.exit(1)
+}
+
 cds.extend (cds.constructor) .with (CdsDk)
 
 class CdsDkAdd {
@@ -49,20 +63,6 @@ if (process.argv[2] in { add:1, init:1, help:1 }) {
   cds.extend (cds.constructor) .with (CdsDkBuild)
 }
 
-const REQUIRED_CDS_MAJOR = 7, REQUIRED_CDS_MINOR = 2
-const [major, minor] = cds.version.split('.').map(Number)
-if (major < REQUIRED_CDS_MAJOR || major === REQUIRED_CDS_MAJOR && minor < REQUIRED_CDS_MINOR) {
-  const [dkVersion] = require('../package.json').version.split('.')
-   
-  console.error(`
-  This application uses '@sap/cds' version ${major}.${minor}, which is not compatible with the installed '@sap/cds-dk' version ${dkVersion}.
-  You can either:
-  - update '@sap/cds' to the latest version (recommended)
-  - downgrade '@sap/cds-dk' to version ${REQUIRED_CDS_MAJOR}
-`)
-  process.exit(1)
-}
-
 function _local (id) {
   return require.resolve (id, {paths:[
     process.cwd(), // project-local module is preferred

package/lib/init/add.js

@@ -15,5 +15,31 @@ module.exports = {
   register: (name, plugin) => {
     registered.set(name, plugin)
   },
+  filterStringAsRegex,
   registered
 }
+
+/**
+ * Turns a filter string with optional meta characters into a regular expression.
+ * If no meta characters are found, the string is treated as an include pattern.
+ *
+ * @param {string} spec the filter string
+ * @returns {RegExp} the regular expression
+ */
+function filterStringAsRegex(spec) {
+  if (typeof spec === 'string') {
+    try {
+      if (spec.match(/[\^$|*]/)) {
+        spec = spec.replace(/^\*/, '.*')  // * at start would be invalid, so make it a .*
+        return new RegExp(spec, 'i')
+      }
+      else { // no meta chars -> include semantics
+        spec = spec.replace(/\./g, '\\.') // escape literal dot
+        return new RegExp(spec, 'i')
+      }
+    } catch (err) {
+      throw err.message // user error, so cut off stack trace
+    }
+  }
+  return /.*/
+}

package/lib/init/constants.js

@@ -5,7 +5,7 @@ module.exports = {
     COMMAND_ADD: 'add',
 
     JAVA_LTS_VERSIONS: [17, 21],
-    MAVEN_ARCHETYPE_VERSION: '3.4.0',
+    MAVEN_ARCHETYPE_VERSION: '3.4.1',
 
     OPTIONS: Object.freeze({
         COMPLETION: 'completion',
@@ -13,9 +13,13 @@ module.exports = {
         JAVA_MVN: 'java:mvn',
         JAVA_PACKAGE: 'java:package',
         NODEJS: 'nodejs',
+        ESM: 'esm',
         SAMPLES: 'samples', // deprecated
         TINY_SAMPLE: 'tiny-sample',
         SAMPLE: 'sample',
+        TYPER: 'typer',
+        TYPESCRIPT: 'typescript',
+        HANDLER: 'handler', // influenced by esm, typer and typescript
         MTA: 'mta',
         CF_MANIFEST: 'cf-manifest',
         HELM: 'helm',
@@ -57,8 +61,6 @@ module.exports = {
         LINT_GLOBAL: 'lint:global',
         LINT_DEV: 'lint:dev',
         PIPELINE: 'pipeline',
-        TYPER: 'typer',
-        TYPESCRIPT: 'typescript'
     }),
 
     REGEX_JAVA_PACKAGE: /^[a-z_][a-z0-9_]*(\.[a-z_][a-z0-9_]*)*$/g,
@@ -71,9 +73,6 @@ module.exports = {
         CAPIRE: 'https://cap.cloud.sap',
         MAVEN_ARCHETYPE_HELP: `https://cap.cloud.sap/docs/java/developing-applications/building#the-maven-archetype`,
         MAVEN_INSTALL_HELP: `https://maven.apache.org/install.html`,
-        CAP_JS_COMMUNITY_ODATA_V2: 'https://github.com/cap-js-community/odata-v2-adapter',
-        CAP_JS_COMMUNITY_EVENT_QUEUE: 'https://github.com/cap-js-community/event-queue',
-        CAP_JS_COMMUNITY_WEBSOCKET: 'https://github.com/cap-js-community/websocket',
         CF_CLI: 'https://github.com/cloudfoundry/cli'
     }),
 

package/lib/init/index.js

@@ -12,17 +12,13 @@ const DEBUG = /\b(y|all|cli)\b/.test(process.env.DEBUG) ? console.debug : undefi
 
 module.exports = class CDSGenerator {
 
-    /** @returns {string[]} */
-    static #findPlugins(excluded) {
-        // actually needs to be sync to be usable in module.exports of dk/bin/init.js
-        const fromDk = readdirSync(join(__dirname, 'template'))
-        const fromPlugins = Object.keys(Object.fromEntries(require('./add').registered))
-        return [...fromDk, ...fromPlugins]
-            .filter(plugin => !excluded?.includes(plugin))
+    constructor() {
+        this.cwd = process.cwd()
+        this.uiConfig = require('./bas') // Used by CAP Generator
     }
 
     static help({ exclude = [] } = {}) {
-        if (!cds.add) return // use case shell completion: cds.add is undefined and not needed
+        if (!cds.add) return // shell completion: cds.add is undefined and not needed
 
         const plugins = this.readPlugins(exclude)
         const nameFixedLength = Math.max(...plugins.map(plugin => plugin.name.length))
@@ -35,10 +31,14 @@ module.exports = class CDSGenerator {
     }
 
     /**
+     * @param excluded {string[]}
      * @returns {{name: string, module: import('module')}[]}
      */
     static readPlugins(excluded = []) {
-        const plugins = this.#findPlugins(excluded)
+        const fromDk = readdirSync(join(__dirname, 'template'))
+        const fromPlugins = Object.keys(Object.fromEntries(require('./add').registered))
+        const all = [...fromDk, ...fromPlugins]
+            .filter(plugin => !excluded?.includes(plugin))
             .map(plugin => ({
                 name: plugin,
                 module: cds.add.registered.get(plugin) ?? require('./template/' + plugin)
@@ -51,12 +51,7 @@ module.exports = class CDSGenerator {
             if (b === -1) return -1
             return a - b
         }
-        return plugins.sort(byPriority)
-    }
-
-    constructor() {
-        this.cwd = process.cwd()
-        this.uiConfig = require('./bas') // Used by CAP Generator
+        return all.sort(byPriority)
     }
 
     /**
@@ -216,15 +211,14 @@ module.exports = class CDSGenerator {
         }
 
         const cmds = Object.values(OPTIONS)
-        this.templateList = Array.from(templates.entries())
-            .sort(([lhs], [rhs]) => {
-                const a = cmds.indexOf(lhs), b = cmds.indexOf(rhs)
-                if (a === -1 && b === -1) return 0
-                if (a === -1) return 1
-                if (b === -1) return -1
+        const priorities = new Map(cmds.map((cmd, i) => [cmd, i]))
+        this.templateList = Array.from(templates.keys())
+            .sort((lhs, rhs) => {
+                const a = priorities.get(lhs) ?? Infinity
+                const b = priorities.get(rhs) ?? Infinity
                 return a - b
             })
-            .map((entry) => entry[1])
+            .map(key => templates.get(key))
 
         DEBUG?.(`Features: ${this.templateList.map(({ name }) => name).join(', ')}`);
     }
@@ -240,11 +234,9 @@ module.exports = class CDSGenerator {
 
         const { options } = cds.cli
         if (typeof options.add === 'string') {
-            tokens = options.add.split(/[,\s+]/g);
-
+            tokens = options.add.split(/[,\s+]/g)
         } else if (Array.isArray(options.add)) {
             tokens = options.add
-
         } else if (options.add instanceof Set) {
             tokens = [...options.add];
         }

package/lib/init/merge.js

@@ -6,11 +6,8 @@ const { readYAML, writeYAML, readJSON } = require('../util/fs')
 const { detectIndent } = require('./indent')
 const { colors } = require('../util/term')
 
-function _isObject(item) {
-  return item && typeof item === 'object' && !Array.isArray(item)
-}
-
 function _mergeObject(target, source) {
+  const _isObject = item => item && typeof item === 'object' && !Array.isArray(item)
   const unique = array => [...new Set(array.map(JSON.stringify))].map(JSON.parse)
   if (_isObject(target) && _isObject(source)) {
       for (const key in source) {