@sap/cds-dk 4.3.3 → 4.5.0

package/lib/import/v4parser.js

@@ -5,14 +5,21 @@
 
 'use strict';
 
-let getMessages = require('../import/message.js');
+let messages = require("./message").getMessages();
 let versionInfo = require('../../package.json').version;
 let namespace;
 let complexTypes = {};
 let enumTypes = {};
+let typeDefinitions = {};
+let unboundedActions = {};
+let boundedActions = {};
+let unboundedFunctions = {};
+let boundedFunctions = {};
 let errors = [];
 let Multimap = require('../import/utils/MultiMap.js');
 let entitySetToEntityTypeMap = new Multimap();
+let actionImportToActionMap = new Multimap();
+let functionImportToFunctionMap = new Multimap();
 let validEdmDatatypes = ['Edm.DateTimeOffset'];
 let jsonEntityContainerName;
 const ignoreObjects = ['$Reference']; // add all the objects that needs to be ignored for parsing.
@@ -72,7 +79,7 @@ function _isValidJSON(jsonObj) {
         return true;
     }
     else {
-        throw new Error(getMessages().INVALID_EDMX_METADATA);
+        throw new Error(messages.INVALID_EDMX_METADATA);
     }
 }
 
@@ -80,7 +87,7 @@ function _hasEntityContainer(jsonObj) {
     if (jsonObj[namespace][jsonEntityContainerName] && jsonObj[namespace][jsonEntityContainerName] instanceof Object) {
         return true;
     } else {
-        throw new Error(getMessages().MISSING_ENTITY_CONTAINER);
+        throw new Error(messages.MISSING_ENTITY_CONTAINER);
     }
 }
 
@@ -96,7 +103,7 @@ function _hasEntitySet(jsonObj) {
     });
 
     if (entitySetCount == 0) {
-        throw new Error(getMessages().MISSING_ENTITY_SETS);
+        throw new Error(messages.MISSING_ENTITY_SETS);
     }
     return true;
 }
@@ -145,6 +152,12 @@ function _generateComplexTypePropertyCsn(propertyType) {
     return property;
 }
 
+function _generateTypeDefinitionPropertyCsn(propertyType) {
+    let property = {};
+    property.type = propertyType.$Type;
+    return property;
+}
+
 function _parseAssociationProperty(foreignReference, associationNode, mockServerUc) {
     let associationProperty = {};
     let foreignKeys;
@@ -258,6 +271,10 @@ function _generateCSNForEntityType(entityTypes, ignorePersistenceSkip, mockServe
                         } else if (element[key][property].$Kind === 'NavigationProperty') {
                             entityCsn[key].elements[property] = _parseAssociationProperty(property,
                                 element[key][property], mockServerUc);
+                        } else if (typeDefinitions[element[key][property].$Type]){
+                            // for TypeDefinitions
+                            propertyType = element[key][property];
+                            entityCsn[key].elements[property] = _generateTypeDefinitionPropertyCsn(propertyType);
                         }
                     }
                 }
@@ -309,8 +326,7 @@ function _parseEntityType(schemaDataList, ignorePersistenceSkip, mockServerUc) {
     // collect entity types
     let entityTypes = [];
     let schemaData;
-    let i = 0;
-    for (i = 0; i < schemaDataList.length; i++) {
+    for (let i = 0; i < schemaDataList.length; i++) {
         schemaData = schemaDataList[i];
         _generateEntityType(entityTypes, schemaData, mockServerUc);
     }
@@ -333,16 +349,167 @@ function _generateEnumType(schemaData) {
 }
 
 function _collectEnumType(schemaDataList) {
-    // collect complex types
     let schemaData;
-    let i = 0;
-    for (i = 0; i < schemaDataList.length; i++) {
+    for (let i = 0; i < schemaDataList.length; i++) {
         schemaData = schemaDataList[i];
         enumTypes = _generateEnumType(schemaData);
     }
     return enumTypes;
 }
 
+function _generateTypeDefinition(schemaData) {
+    let typeDefDict = {};
+    let temp;
+    Object.keys(schemaData).forEach(curTypeDef => {
+        if (schemaData[curTypeDef] instanceof Object) {
+            if (schemaData[curTypeDef].$Kind && schemaData[curTypeDef].$Kind === 'TypeDefinition') {
+                temp = namespace + '.' + curTypeDef;
+                typeDefDict[temp] = schemaData[curTypeDef];
+            }
+        }
+    });
+    return typeDefDict;
+}
+
+function _collectTypeDefinition(schemaDataList) {
+    let schemaData;
+    for (let i = 0; i < schemaDataList.length; i++) {
+        schemaData = schemaDataList[i];
+        typeDefinitions = _generateTypeDefinition(schemaData);
+    }
+}
+
+function _generateBounded(schemaData, flag) {
+    let bFunction = {};
+    let boundedFunction = [];
+    let temp;
+    let kindString;
+    if (flag == 1) {
+        kindString = 'Function'; 
+    }
+    else {
+        kindString = 'Action';
+    }
+    Object.keys(schemaData).forEach(curFunction => {
+        if (schemaData[curFunction] instanceof Array && schemaData[curFunction][0].$Kind === kindString && schemaData[curFunction][0].$IsBound === true) {
+            boundedFunction = [];
+            temp = namespace + '.' + curFunction;
+            for (let i = 0; i < schemaData[curFunction].length; i++) {
+                boundedFunction.push(schemaData[curFunction][i]);
+                bFunction[temp] = boundedFunction;
+            }
+        }
+    });
+    return bFunction;
+}
+
+function _collectBounded(schemaDataList , flag) {
+    let schemaData;
+    for (let i = 0; i < schemaDataList.length; i++) {
+        schemaData = schemaDataList[i];
+        if (flag == 0) {
+            boundedActions = _generateBounded(schemaData, 0);
+        }
+        else {
+            boundedFunctions = _generateBounded(schemaData, 1);
+        }    
+    }
+}
+
+function _parseBounded(csnDefs, flag) {
+    let boundedEdmxKind, boundedObj, boundedCsnKind, boundedEntityName, obj, paramType, paramName, paramObj, name, returnType;
+    if (flag == 0) {
+        boundedEdmxKind = "Action";
+        boundedCsnKind = "action";
+        boundedObj = boundedActions;
+    }
+    else {
+        boundedEdmxKind = "Function";
+        boundedCsnKind = "function";
+        boundedObj = boundedFunctions;
+    }
+    if (Object.keys(boundedObj).length > 0) {
+        Object.keys(boundedObj).forEach(b => {
+            for (let j = 0; j < boundedObj[b].length; j++) {
+                if (boundedObj[b][j].$Kind === boundedEdmxKind) {
+                    name = b.substring(b.lastIndexOf(".") + 1);
+                    obj = boundedObj[b];
+                    boundedEntityName = obj[j].$Parameter[0].$Type;
+                    if (csnDefs[boundedEntityName] === undefined) {
+                        boundedEntityName = namespace + "." + entitySetToEntityTypeMap.get(boundedEntityName)[0];
+                    }
+                    if (csnDefs[boundedEntityName]) {
+                        if (csnDefs[boundedEntityName].actions === undefined)
+                            csnDefs[boundedEntityName].actions = {};
+                        csnDefs[boundedEntityName].actions[name] = {};
+                        csnDefs[boundedEntityName].actions[name].kind = boundedCsnKind;
+                        // add params
+                        if (obj[j].$Parameter && obj[j].$Parameter.length >= 2) {
+                            /** 
+                             * 1. Considering length >= 2 because we need to consider from the 2nd
+                             *    parameter onwards. 1st parameter only tells which entity is this
+                             *    action/function bounded to and that parameter is no where used 
+                             *    to retrieve any data during service runtime. So skipping it and
+                             *    the details of 1st parameter will not be preserved in the csn.
+                             * 2. The 1st parameter will be reflected back as parameter name  "in" 
+                             *    during csn to edmx conversion by the compiler.
+                             * */
+                            csnDefs[boundedEntityName].actions[name].params = {};
+                            for (let i = 1; i < obj[j].$Parameter.length; i++) {
+                                paramObj = obj[j].$Parameter[i];
+                                paramName = obj[j].$Parameter[i].$Name;
+                                // check if the parameter type is pre-defined, undefined or custom defined
+                                if (edmxncdsdatatype[paramObj.$Type])
+                                    paramType = generatePropertyCsn(paramObj, false);
+                                else if (paramObj.$Type === undefined)
+                                    paramType = { "type": "cds.LargeString" }; // intentionally used LargeString
+                                else {
+                                    if (entitySetToEntityTypeMap.get(obj[j].$Parameter[i].$Type)) {
+                                        let type = namespace + "." + entitySetToEntityTypeMap.get(obj[j].$Parameter[i].$Type)[0];
+                                        paramType = { "type": type };
+                                    }
+                                    else {
+                                        paramType = { "type": obj[j].$Parameter[i].$Type };
+                                    }
+                                }
+                                // check if parameter type is a collection
+                                if (paramObj.$Collection) {
+                                    csnDefs[boundedEntityName].actions[name].params[paramName] = {};
+                                    csnDefs[boundedEntityName].actions[name].params[paramName].items = paramType;
+                                } else
+                                    csnDefs[boundedEntityName].actions[name].params[paramName] = paramType;
+                            }
+                        }
+                        // add returns
+                        if (obj[j].$ReturnType) {
+                            csnDefs[boundedEntityName].actions[name].returns = {};
+                            // check if the return type is pre-defined, undefined or custom defined
+                            if (edmxncdsdatatype[obj[j].$ReturnType.$Type])
+                                returnType = generatePropertyCsn(obj[j].$ReturnType, false);
+                            else if (obj[j].$ReturnType.$Type === undefined)
+                                returnType = { "type": "cds.LargeString" }; // intentionally used LargeString
+                            else {
+                                if (entitySetToEntityTypeMap.get(obj[j].$ReturnType.$Type) && entitySetToEntityTypeMap.get(obj[j].$ReturnType.$Type)[0]) {
+                                    let type = namespace + "." + entitySetToEntityTypeMap.get(obj[j].$ReturnType.$Type)[0];
+                                    returnType = { "type": type };
+                                }
+                                else {
+                                    returnType = { "type": obj[j].$ReturnType.$Type };
+                                }
+                            }
+                            // check if return type is a collection
+                            if (obj[j].$ReturnType.$Collection)
+                                csnDefs[boundedEntityName].actions[name].returns.items = returnType;
+                            else
+                                csnDefs[boundedEntityName].actions[name].returns = returnType;
+                        }
+                    }
+                }
+            }
+        });
+    }
+}
+
 function _generateComplexType(schemaData) {
     let complexTypeDict = {};
     let temp;
@@ -360,8 +527,7 @@ function _generateComplexType(schemaData) {
 function _collectComplexType(schemaDataList) {
     // collect complex types
     let schemaData;
-    let i = 0;
-    for (i = 0; i < schemaDataList.length; i++) {
+    for (let i = 0; i < schemaDataList.length; i++) {
         schemaData = schemaDataList[i];
         complexTypes = _generateComplexType(schemaData);
     }
@@ -399,10 +565,110 @@ function _generateCSNForComplexType(schemaData) {
     return complexCsn;
 }
 
+function _parseTypeDefinition() {
+    let typeDef = {};
+    let propertyType;
+    Object.keys(typeDefinitions).forEach(element => {
+        typeDef[element] = {};
+        typeDef[element].kind = 'type';
+        if (!typeDefinitions[element].$Type || edmxncdsdatatype[typeDefinitions[element].$Type]) {
+            propertyType = typeDefinitions[element];
+            typeDef[element] = Object.assign(typeDef[element], generatePropertyCsn(propertyType, false));
+        }
+    });
+    return typeDef;
+}
+
+function _parseUnbounded(schemaData, flag) {
+    let unboundedObj = {}, unbounded, unboundedCsnKind;
+    let importToMap = new Multimap();
+    if (flag == 0) {
+        unbounded = unboundedActions;
+        importToMap = actionImportToActionMap;
+        unboundedCsnKind = "action";
+    }
+    else {
+        unbounded = unboundedFunctions;
+        importToMap = functionImportToFunctionMap;
+        unboundedCsnKind = "function";
+    }
+    if (Object.keys(unbounded).length > 0) {
+        Object.keys(unbounded).forEach(ub => {
+            let obj = {};
+            let objType = {}, objData = {}, temp;
+            if (importToMap && importToMap.get(ub)) {
+                temp = importToMap.get(ub)[0];
+                objType = namespace + "." + temp;
+                objData = schemaData[0][temp][0];
+                obj[objType] = {};
+                obj[objType].kind = unboundedCsnKind;
+                // add params
+                if (objData.$Parameter && objData.$Parameter.length > 0) {
+                    obj[objType].params = {};
+                    let type;
+                    for (let i = 0; i < objData.$Parameter.length; i++) {
+                        obj[objType].params[objData.$Parameter[i].$Name] = {};
+                        // check if the parameter type is pre-defined, undefined or custom defined
+                        if (edmxncdsdatatype[objData.$Parameter[i].$Type]) {
+                            type = (generatePropertyCsn(objData.$Parameter[i], false)).type;
+                        }
+                        else if (objData.$Parameter[i].$Type === undefined) {
+                            type = "cds.LargeString"; // intentionally used LargeString
+                        }
+                        else {
+                            if (entitySetToEntityTypeMap.get(objData.$Parameter[i].$Type))
+                                type = namespace + "." + entitySetToEntityTypeMap.get(objData.$Parameter[i].$Type)[0];
+                            else
+                                type = objData.$Parameter[i].$Type;
+                        }
+                        // check if parameter type is a collection
+                        if (objData.$Parameter[i].$Collection)
+                            obj[objType].params[objData.$Parameter[i].$Name].items = { "type": type };
+                        else
+                            obj[objType].params[objData.$Parameter[i].$Name] = { "type": type };
+                    }
+                }
+                // add returns
+                if (objData.$ReturnType && Object.keys(objData.$ReturnType).length > 0 && obj) {
+                    obj[objType].returns = {};
+                    let returnValue;
+                    // check if the return type is pre-defined, undefined or custom defined
+                    if (edmxncdsdatatype[objData.$ReturnType.$Type]) {
+                        returnValue = generatePropertyCsn(objData.$ReturnType, false);
+                    }
+                    else if (objData.$ReturnType.$Type === undefined) {
+                        returnValue = { "type": "cds.LargeString" }; // intentionally used LargeString
+                    }                         
+                    else {
+                        if (entitySetToEntityTypeMap.get(objData.$ReturnType.$Type) && entitySetToEntityTypeMap.get(objData.$ReturnType.$Type)[0]) {
+                            let type = namespace + "." + entitySetToEntityTypeMap.get(objData.$ReturnType.$Type)[0];
+                            returnValue = { "type": type };
+                        }
+                        else
+                            returnValue = { "type": objData.$ReturnType.$Type };
+                    }
+                    // check if return type is a collection
+                    if (objData.$ReturnType.$Collection) {
+                        obj[objType].returns.items = {};
+                        obj[objType].returns.items = returnValue;
+                    } else
+                        obj[objType].returns = returnValue;
+                }
+            }
+            unboundedObj = Object.assign(unboundedObj, obj);
+        });
+    }
+    return unboundedObj;
+}
+
 function _generateCSN(edmxAsJson, ignorePersistenceSkip, mockServerUc) {
     let schemaCounter = 0;
     let csn = {};
     let schemaData = [];
+    unboundedActions = {};
+    boundedActions = {};
+    unboundedFunctions = {};
+    boundedFunctions = {};
     csn.meta = {};
     csn.meta.creator = 'cds-dk ' + versionInfo;
     csn.$version = '2.0';
@@ -421,6 +687,14 @@ function _generateCSN(edmxAsJson, ignorePersistenceSkip, mockServerUc) {
             if (ignoreObjects.indexOf(data) === -1 && entityContainer[data] instanceof Object &&
                 entityContainer[data].$Type && entityContainer[data].$Collection) {
                 entitySetToEntityTypeMap.set(entityContainer[data].$Type, data);
+            } else if (ignoreObjects.indexOf(data) === -1 && entityContainer[data] instanceof Object &&
+                entityContainer[data].$Action) {
+                actionImportToActionMap.set(entityContainer[data].$Action, data);
+                unboundedActions[entityContainer[data].$Action] = entitySetData[data];
+            } else if (ignoreObjects.indexOf(data) === -1 && entityContainer[data] instanceof Object &&
+                entityContainer[data].$Function) {
+                functionImportToFunctionMap.set(entityContainer[data].$Function, data);
+                unboundedFunctions[entityContainer[data].$Function] = entitySetData[data];
             }
         });
     }
@@ -433,78 +707,94 @@ function _generateCSN(edmxAsJson, ignorePersistenceSkip, mockServerUc) {
 
     // Multiple schema found and currently we don't support
     if (schemaCounter > 1) {
-        let errorMsg = getMessages().MULTIPLE_SCHEMA_FOUND;
+        let errorMsg = messages().MULTIPLE_SCHEMA_FOUND;
         errors.push(errorMsg);
         // throw errorMsg;
     }
-    // Step 1: get all complex types.
+
     csn.definitions[namespace] = {};
     csn.definitions[namespace].kind = 'service';
+
     _collectEnumType(schemaData);
+    _collectTypeDefinition(schemaData);
+    _collectBounded(schemaData,0);
+    _collectBounded(schemaData,1);
+
+    // Step 1: get all complex types.
     csn.definitions = Object.assign(_generateCSNForComplexType(schemaData), csn.definitions);
-    // Step 2: Parsing entity type
+    // Step 2: get all type definition
+    csn.definitions = Object.assign(_parseTypeDefinition(), csn.definitions);
+    // Step 3: get all unbounded action & function
+    csn.definitions = Object.assign(_parseUnbounded(schemaData, 0), csn.definitions);
+    csn.definitions = Object.assign(_parseUnbounded(schemaData , 1), csn.definitions);
+    // Step 4: get all entity type
     csn.definitions = Object.assign(_parseEntityType(schemaData, ignorePersistenceSkip, mockServerUc), csn.definitions);
-    _generateDocumentation(schemaData,csn.definitions);
+    // Step 5: get all bounded action & function
+    _parseBounded(csn.definitions, 0 );
+    _parseBounded(csn.definitions, 1 );
+    // Step 6: get all annotations
+    _generateDocumentation(schemaData, csn.definitions);
+
     return JSON.stringify(csn, null, 4);
 }
 
-function _generateDocumentation(schemaData,cdsDefs){
-    
-    Object.entries(schemaData[0].$Annotations).map(annotation => {
-        let flag;
-        // eslint-disable-next-line no-prototype-builtins
-        if (annotation[1].hasOwnProperty('@Core.Description')) {
-            flag = true;
-            if(annotation[0].indexOf('/') === -1){
-                if(annotation[0].endsWith(".EntityContainer")){
-                    let path = annotation[0].split(".")[0];
-                    cdsDefs[path].doc = annotation[1]["@Core.Description"];
-                }
-                if(cdsDefs[annotation[0]]){
-                    cdsDefs[annotation[0]].doc = annotation[1]["@Core.Description"];
+function _generateDocumentation(schemaData, cdsDefs) {
+    if (schemaData[0].$Annotations) {
+        Object.entries(schemaData[0].$Annotations).map(annotation => {
+            let flag;
+            // eslint-disable-next-line no-prototype-builtins
+            if (annotation[1].hasOwnProperty('@Core.Description')) {
+                flag = true;
+                if (annotation[0].indexOf('/') === -1) {
+                    if (annotation[0].endsWith(".EntityContainer")) {
+                        let path = annotation[0].split(".")[0];
+                        cdsDefs[path].doc = annotation[1]["@Core.Description"];
+                    }
+                    if (cdsDefs[annotation[0]]) {
+                        cdsDefs[annotation[0]].doc = annotation[1]["@Core.Description"];
+                    }
+                } else {
+                    let path = annotation[0].split('/');
+                    if (cdsDefs[path[0]]["elements"][path[1]]) {
+                        cdsDefs[path[0]]["elements"][path[1]].doc = annotation[1]["@Core.Description"];
+                    }          
                 }
-            }else{
-                let path = annotation[0].split('/');
-                if(cdsDefs[path[0]]["elements"][path[1]]){
-                    cdsDefs[path[0]]["elements"][path[1]].doc = annotation[1]["@Core.Description"];
-                }          
-            }}
-               // eslint-disable-next-line no-prototype-builtins
-            if (annotation[1].hasOwnProperty('@Core.LongDescription') ) {
-                if(annotation[0].indexOf('/') === -1){
-                    if(annotation[0].endsWith(".EntityContainer")){
+            }
+            // eslint-disable-next-line no-prototype-builtins
+            if (annotation[1].hasOwnProperty('@Core.LongDescription')) {
+                if (annotation[0].indexOf('/') === -1) {
+                    if (annotation[0].endsWith(".EntityContainer")) {
                         let path = annotation[0].split(".")[0];
-                        if(flag === true){
-                            cdsDefs[path].doc += "\n\n ";
+                        if (flag === true) {
+                            cdsDefs[path].doc += "\n\n";
                         } else {
                             cdsDefs[path].doc = "";
                         }
                         cdsDefs[path].doc += annotation[1]["@Core.LongDescription"];
                     }
-                    if(cdsDefs[annotation[0]]){
-                        if(flag === true){
-                            cdsDefs[annotation[0]].doc += "\n\n ";
+                    if (cdsDefs[annotation[0]]) {
+                        if (flag === true) {
+                            cdsDefs[annotation[0]].doc += "\n\n";
                         } else {
                             cdsDefs[annotation[0]].doc = "";
                         }
                         cdsDefs[annotation[0]].doc += annotation[1]["Core.LongDescription"];
                     }
-                }else{
+                } else {
                     let path = annotation[0].split('/');
-                    if(cdsDefs[path[0]]["elements"][path[1]]){
-                        if(flag === true){
-                            cdsDefs[path[0]]["elements"][path[1]].doc += "\n\n ";
+                    if (cdsDefs[path[0]]["elements"][path[1]]) {
+                        if (flag === true) {
+                            cdsDefs[path[0]]["elements"][path[1]].doc += "\n\n";
                         } else {
                             cdsDefs[path[0]]["elements"][path[1]].doc = "";
                         }
                         cdsDefs[path[0]]["elements"][path[1]].doc += annotation[1]["Core.LongDescription"];
-                    }          
-         }}
-    })}
-    
-                    
-            
-                    
+                    }
+                }  
+            }
+        });
+    }
+}
 
 function _generateEDMX2JSON(edmx) {
     return new Promise(function getJson(resolve, reject) {
@@ -513,13 +803,10 @@ function _generateEDMX2JSON(edmx) {
             // create converter
             const v4Conv = MetadataConverterFactory.createEdmxV40XmlToV40Json();
             v4Conv.execute(inputBuffer, (error, json, missingReferencedDocuments) => {
-                if (error) {
-                    throw error;
-                }
                 if (missingReferencedDocuments.length > 0) {
                     console.log(missingReferencedDocuments); // eslint-disable-line no-console
                 }
-    
+
                 if (_validateJSON(json)) {
                     resolve(json);
                 }

package/lib/init/constants.js

@@ -1,6 +1,6 @@
 const os = require('os');
 
-const MAVEN_ARCHETYPE_VERSION = '1.16.3';
+const MAVEN_ARCHETYPE_VERSION = '1.18.1';
 
 const constants = {
     IS_WIN: (os.platform() === 'win32'),

package/lib/init/index.js

@@ -6,7 +6,7 @@ const term = require('../util/term');
 const Spinner = require('./util/spinner');
 
 const { OPTIONS_PRIORITY, COMMAND_ADD, COMMAND_INIT,
-    OPTION_HANA, OPTION_JAVA, OPTION_MTA, OPTION_MTX, OPTION_NODEJS, OPTION_LINT, OPTION_LINT_GLOBAL, OPTION_LINT_DEV,
+    OPTION_HANA, OPTION_JAVA, OPTION_MTA, OPTION_MTX, OPTION_NODEJS,
     OPTION_PIPELINE, OPTION_SAMPLES, OPTION_CF_MANIFEST, PROJECT_FILES, REGEX_PROJECT_NAME } = require('./constants');
 
 module.exports = class CDSGenerator {
@@ -23,7 +23,7 @@ module.exports = class CDSGenerator {
                 validate: async (value) => {
                     try {
                         await this._validateProjectName(value);
-                        await this._validateProjectFolder(path.join(process.cwd(), value), process.cwd());
+                        await this._validateProjectFolder(path.join(this.cwd, value), this.cwd);
 
                         return true;
                     } catch (err) {
@@ -279,7 +279,7 @@ module.exports = class CDSGenerator {
         let tokens = [];
 
         if (typeof this.options.add === 'string') {
-            tokens = this.options.add.split(/\s*,\s*/g);
+            tokens = this.options.add.split(/[,\s+]/g);
 
         } else if (Array.isArray(this.options.add)) {
             tokens = this.options.add
@@ -310,15 +310,18 @@ module.exports = class CDSGenerator {
             this.options.add.add(OPTION_NODEJS);
         }
 
-        if (this.options._cmd === COMMAND_INIT && !this.options.add.has(OPTION_LINT)) {
-            this.options.add.add(OPTION_LINT);
-            if (this.options['lint']) {
-                this.options['lint'].add(OPTION_LINT_GLOBAL)
-            } else {
-                this.options['lint'] = new Set([OPTION_LINT_GLOBAL]);
+        this._checkAdditionalOptions();
+    }
+
+    _checkAdditionalOptions() {
+        for (const [key] of Object.entries(this.options)) {
+            const keySplit = key.split(/:/);
+            if (keySplit.length === 2) {
+                if (!this.options.add.has(keySplit[0])) {
+                    this.logger.warn(`ignoring option ${key} since ${keySplit[0]} is not part of specified feature list: ${Array.from(this.options.add).join(', ')}`);
+                }
             }
         }
-
     }
 
     async _validateOptions() {