@sap/cds-dk 6.2.3 → 6.3.0

package/lib/import/odata/v2parser.js

@@ -376,6 +376,7 @@ function _getServiceEntityProperty(
 	isKey,
 	documentation,
 	allowedNamespaceAttributes = -1,
+	nullable,
 	parserContext
 ) {
 	let isCollection = -1;
@@ -482,6 +483,12 @@ function _getServiceEntityProperty(
 				propertyJson = propertyJson + ',\n"scale":' + 0;
 			}
 		}
+		if (nullable == "false") {
+			propertyJson = propertyJson + ',\n"notNull": true';
+		}
+		else if(nullable=="true" || !nullable){
+			propertyJson = propertyJson + ',\n"notNull": false';
+		}
 		propertyJson = propertyJson + '\n}'
 	}
 	else{
@@ -521,6 +528,15 @@ function _getServiceEntityProperty(
 		propertyJson += _generateNamespaceAttributes(allowedNamespaceAttributes, true);
 	}
 
+	if(isCollection == -1) {
+		if (nullable === "false") {
+			propertyJson = propertyJson + ',\n"notNull": true';
+		}
+		else if(nullable=="true" || !nullable){
+			propertyJson = propertyJson + ',\n"notNull": false';
+		}
+	}
+
 	if (propertyName)
 		propertyJson = propertyJson + "\n}";
 	return propertyJson;
@@ -531,6 +547,7 @@ function _getServiceComplexType(complexTypeKey, complexType, parserContext) {
 	let complexTypeProperty;
 	let i;
 	complexTypeCSN = complexTypeCSN + '"kind": "type",\n';
+	complexTypeCSN = complexTypeCSN + '"@cds.external": true,\n';
 	if (parserContext.allComplexTypeNamespaces[complexTypeKey]) {
 		complexTypeCSN += _generateNamespaceAttributes(parserContext.allComplexTypeNamespaces[complexTypeKey], false);
 	}
@@ -558,6 +575,7 @@ function _getServiceComplexType(complexTypeKey, complexType, parserContext) {
 						false,
 						complexTypeProperty.doc,
 						complexTypePropertyNamespace,
+						complexTypeProperty.Nullable,
 						parserContext
 					);
 				complexTypeCSN = complexTypeCSN + complexProperty;
@@ -587,6 +605,7 @@ function _getServiceComplexType(complexTypeKey, complexType, parserContext) {
 					false,
 					complexTypeProperty.doc,
 					complexTypePropertyNamespace,
+					complexTypeProperty.Nullable,
 					parserContext
 				);
 		}
@@ -643,6 +662,7 @@ function _parseParameter(parameter, parserContext) {
 			false,
 			doc,
 			parameterNamespaceAttributes,
+			parameter["_attributes"].Nullable,
 			parserContext
 		);
 	return csn;
@@ -692,6 +712,7 @@ function _getFunctionImport(functionImport, isBounded, entityKeysList, parserCon
 	let csn = "";
 	csn = csn + '"' + functionImport[0] + '": { \n';
 	csn = csn + '"kind": "';
+
 	if (functionImport[1] === "GET") {
 		csn = csn + "function";
 	} else if (functionImport[1] === "POST") {
@@ -703,6 +724,8 @@ function _getFunctionImport(functionImport, isBounded, entityKeysList, parserCon
 		return "";
 	}
 	csn = csn + '"';
+	if (!isBounded) csn = csn + ',\n"@cds.external": true';
+
 	if (functionImport[3] !== -1) {
 		if (isBounded === 0 || (isBounded === 1 && functionImport[3] instanceof Array)) {
 			let parametersCsn = _parseParametersFunctionImport(functionImport[3], entityKeysList, parserContext);
@@ -716,7 +739,7 @@ function _getFunctionImport(functionImport, isBounded, entityKeysList, parserCon
 	}
 	if (functionImport[2] !== -1) {
 		let returnCsn = _getServiceEntityProperty(noValue, functionImport[2], noValue, noValue, noValue, 
-			noValue, noValue, noValue, -1, parserContext);
+			noValue, noValue, noValue, -1, noValue, parserContext);
 		if (returnCsn != "") {
 			csn = csn + ", \n";
 			csn = csn + '"returns": { \n';
@@ -826,6 +849,12 @@ function _getPropertyAttributes(propAttributes, parserContext) {
 		propOthers.push(-1);
 	}
 
+	if (propAttributes.Nullable) {
+		propOthers.push(propAttributes.Nullable);
+	} else {
+		propOthers.push("true");
+	}
+
 	return propOthers;
 }
 
@@ -883,6 +912,9 @@ function _generateCSNEntityKeys(entityKeysList, entityPropertiesMap, parserConte
 
 	for (let i = 0; i < entityKeysList.length; i++) {
 		propAttributes = entityPropertiesMap[entityKeysList[i]];
+		if (propAttributes[7] == "true") {
+			console.log(warn("Expected key element to be not nullable"));
+		}
 		let keyCsn =
 			_getServiceEntityProperty(
 				entityKeysList[i],
@@ -894,6 +926,7 @@ function _generateCSNEntityKeys(entityKeysList, entityPropertiesMap, parserConte
 				true,
 				propAttributes[5],
 				propAttributes[6],
+				"false",
 				parserContext
 			);
 		csnEntity = csnEntity + keyCsn;
@@ -935,6 +968,7 @@ function _generateCSNEntityProperties(entityKeysList, entityPropertiesMap, parse
 					false,
 					propAttributes[5],
 					propAttributes[6],
+					propAttributes[7],
 					parserContext
 				);
 			csnEntity = csnEntity + propertyString;
@@ -1357,9 +1391,11 @@ function _constructServiceEntity(
 	let csnProperties;
 	let hasProperties;
 	csnEntity = csnEntity + '"kind": "entity",\n';
+	csnEntity = csnEntity + '"@cds.external": true,\n'; 
 	if (ignorePersistenceSkip === false) {
 		csnEntity = csnEntity + '"@cds.persistence.skip": true,\n';
 	}
+
 	if (entityAttributes.Abstract && entityAttributes.Abstract.toUpperCase() === "TRUE") {
 		csnEntity = csnEntity + '"abstract": true,\n';
 	}

package/lib/import/odata/v4parser.js

@@ -160,6 +160,13 @@ function generatePropertyCsn(propertyType, isPrimaryKey) {
         // primary key cannot be of type Collection
         if (propertyType.$Collection)
             throw new Error(messages.COLLECTION_IN_KEY);
+        if (propertyType.$Nullable === true) {
+            console.log(warn("Expected key element to be not nullable"));
+        }
+        typeProperties["notNull"] = true;
+    }
+    else {
+        typeProperties["notNull"] = propertyType.$Nullable ? false : true;
     }
     _includeExternalNamespaceAnnotation(propertyType, property);
     // conditions have to be made
@@ -179,7 +186,7 @@ function generatePropertyCsn(propertyType, isPrimaryKey) {
             typeProperties["@odata.Precision"] = propertyType.$Precision;
         } else {
             typeProperties.type = edmxncdsdatatype[propertyType.$Type];
-            //typeProperties["@odata.Precision"] = 0;
+            // typeProperties["@odata.Precision"] = 0;
         }
     } else if (propertyType.$Precision && !_isValidDataType(propertyType.$Type)) {
         typeProperties.type = edmxncdsdatatype[propertyType.$Type + '_p'];
@@ -329,6 +336,7 @@ function _generateCSNForEntityType(ignorePersistenceSkip, mockServerUc, parserCo
         if (key) {
             entityCsn[key] = {};
             entityCsn[key].kind = 'entity';
+            entityCsn[key]['@cds.external'] = true;
             if (!ignorePersistenceSkip) {
                 entityCsn[key]['@cds.persistence.skip'] = true;
             }
@@ -465,10 +473,10 @@ function _parseEntityType(schemaDataList, ignorePersistenceSkip, mockServerUc, p
 function _parseEntityContainer(entityCSN, schemaData, parserContext) {
     Object.entries(schemaData[0][parserContext.jsonEntityContainerName]).forEach(entry => {
         if (entityCSN[parserContext.namespace + '.' + entry[0]])
-            //Captured the annotations at entity set and entity type name level
+            // Captured the annotations at entity set and entity type name level
             _includeExternalNamespaceAnnotation(entry[1], entityCSN[parserContext.namespace + '.' + entry[0]]);
         if (entry[0].startsWith('@')) {
-            //Captured the annotations at entity container name level
+            // Captured the annotations at entity container name level
             entityCSN[parserContext.namespace][entry[0]] = entry[1];
         }
     });
@@ -504,6 +512,8 @@ function _generateCSNForEnumType(schemaData, parserContext) {
     eTypes = _collectEnumType(schemaData, parserContext);
     Object.keys(eTypes).forEach(element => {
         enumCsn[element] = {};
+        enumCsn[element].kind = 'type';
+        enumCsn[element]['@cds.external'] = true;
         enumCsn[element].enum = {};
         enumCsn[element].type = eTypes[element].$Type != null ? edmxncdsdatatype[eTypes[element].$Type] : 'cds.LargeString';
         Object.keys(eTypes[element]).forEach(property => {
@@ -585,15 +595,15 @@ function _collectBounded(schemaDataList, flag, parserContext) {
 function _getDatatype(datatype, parserContext) {
     let type = undefined;
     if (datatype === undefined) {
-        type = "cds.LargeString"; //intentionally used LargeString
+        type = "cds.LargeString"; // intentionally used LargeString
     } else if (parserContext.entitySetToEntityTypeMap.get(datatype) && parserContext.entitySetToEntityTypeMap.get(datatype)[0]) {
-        //mapping to entity set if type is entity type
+        // mapping to entity set if type is entity type
         type = parserContext.namespace + "." + parserContext.entitySetToEntityTypeMap.get(datatype)[0];
     } else if (parserContext.complexTypes[datatype] || parserContext.typeDefinitions[datatype] || parserContext.enumTypes[datatype]) {
-        //if type is complex type, type definition or an enum type
+        // if type is complex type, type definition or an enum type
         type = datatype;
     } else {
-        //checking if type is an entity set
+        // checking if type is an entity set
         for (const element of parserContext.entitySetToEntityTypeMap.keys()) {
             if (parserContext.namespace + "." + parserContext.entitySetToEntityTypeMap.get(element) === datatype)
                 type = datatype;
@@ -604,7 +614,7 @@ function _getDatatype(datatype, parserContext) {
         })
     }
 
-    //will return undefined if type is not supported
+    // will return undefined if type is not supported
     return type;
 }
 
@@ -654,7 +664,7 @@ function _parseBounded(csnDefs, flag, parserContext) {
                                 let paramType = {};
                                 let annotations = {};
                                 _includeExternalNamespaceAnnotation(paramObj, annotations);
-                                //check if the parameter type is pre-defined, undefined or custom defined
+                                // check if the parameter type is pre-defined, undefined or custom defined
                                 if (edmxncdsdatatype[paramObj.$Type] || edmxncdsdatatype[paramObj.$Type + "_a"])
                                     paramType = generatePropertyCsn(paramObj, false);
                                 else {
@@ -667,8 +677,14 @@ function _parseBounded(csnDefs, flag, parserContext) {
                                         if (paramObj.$Collection && !paramType.items) {
                                             csnDefs[boundedEntityName].actions[name].params[paramName] = {};
                                             csnDefs[boundedEntityName].actions[name].params[paramName].items = paramType;
-                                        } else
+                                            csnDefs[boundedEntityName].actions[name].params[paramName].items["notNull"] = paramObj?.$Nullable ? false : true;
+
+                                        } else {
                                             csnDefs[boundedEntityName].actions[name].params[paramName] = paramType;
+                                            if (!paramType.items) {
+                                                csnDefs[boundedEntityName].actions[name].params[paramName].notNull = paramObj?.$Nullable ? false : true;
+                                            }
+                                        }
                                     }
                                 }
                                 else {
@@ -680,7 +696,7 @@ function _parseBounded(csnDefs, flag, parserContext) {
                             }
                         }
                     }
-                    //if parameters has no entries
+                    // if parameters has no entries
                     if (csnDefs[boundedEntityName].actions[name].params && Object.keys(csnDefs[boundedEntityName].actions[name].params).length === 0) {
                         delete csnDefs[boundedEntityName].actions[name].params;
                     }
@@ -700,10 +716,16 @@ function _parseBounded(csnDefs, flag, parserContext) {
                             if (returnType.type || returnType.items.type) {
                                 csnDefs[boundedEntityName].actions[name].returns = {};
                                 // check if return type is a collection
-                                if (obj[j].$ReturnType.$Collection && !returnType.items)
+                                if (obj[j].$ReturnType.$Collection && !returnType.items) {
                                     csnDefs[boundedEntityName].actions[name].returns.items = returnType;
-                                else
+                                    csnDefs[boundedEntityName].actions[name].returns.items["notNull"] = obj[j].$ReturnType?.$Nullable ? false : true
+                                }
+                                else {
                                     csnDefs[boundedEntityName].actions[name].returns = returnType;
+                                    if (!returnType.items) {
+                                        csnDefs[boundedEntityName].actions[name].returns["notNull"] = obj[j].$ReturnType?.$Nullable ? false : true
+                                    }
+                                }
                             }
                         } else {
                             let message = '"' + obj[j].$ReturnType.$Type + '" is not supported (in return type)';
@@ -752,6 +774,7 @@ function _generateCSNForComplexType(schemaData, parserContext) {
     Object.keys(cTypes).forEach(element => {
         complexCsn[element] = {};
         complexCsn[element].kind = 'type';
+        complexCsn[element]['@cds.external'] = true;
         complexCsn[element].elements = {};
         // inheritance handling
         baseType = cTypes[element].$BaseType;
@@ -791,6 +814,7 @@ function _parseTypeDefinition(parserContext) {
     Object.keys(parserContext.typeDefinitions).forEach(element => {
         typeDef[element] = {};
         typeDef[element].kind = 'type';
+        typeDef[element]['@cds.external'] = true;
         if (!parserContext.typeDefinitions[element].$Type ||
             edmxncdsdatatype[parserContext.typeDefinitions[element].$Type]
         ) {
@@ -824,6 +848,7 @@ function _parseUnbounded(schemaData, flag, parserContext) {
                 objData = schemaData[0][temp][0];
                 obj[objType] = {};
                 obj[objType].kind = unboundedCsnKind;
+                obj[objType]['@cds.external'] = true;
                 _includeExternalNamespaceAnnotation(objData, obj[objType]);
                 // add params
                 if (objData.$Parameter && objData.$Parameter.length > 0) {
@@ -845,8 +870,13 @@ function _parseUnbounded(schemaData, flag, parserContext) {
                                 if (objData.$Parameter[i].$Collection && !paramType.items) {
                                     obj[objType].params[objData.$Parameter[i].$Name] = {};
                                     obj[objType].params[objData.$Parameter[i].$Name].items = paramType;
-                                } else
+                                    obj[objType].params[objData.$Parameter[i].$Name].items["notNull"] = objData.$Parameter[i]?.$Nullable ? false : true;
+                                } else {
                                     obj[objType].params[objData.$Parameter[i].$Name] = paramType;
+                                    if (!paramType.items) {
+                                        obj[objType].params[objData.$Parameter[i].$Name]["notNull"] = objData.$Parameter[i]?.$Nullable ? false : true;
+                                    }
+                                }
                             }
                         } else {
                             let message = '"' + objData.$Parameter[i].$Type + '" is not supported (in element:"' + temp + '")';
@@ -856,7 +886,7 @@ function _parseUnbounded(schemaData, flag, parserContext) {
                             Object.assign(obj[objType].params[objData.$Parameter[i].$Name], annotations)
                     }
                 }
-                //if parameters has no entries
+                // if parameters has no entries
                 if (obj[objType].params && Object.keys(obj[objType].params).length === 0) {
                     delete obj[objType].params;
                 }
@@ -879,8 +909,13 @@ function _parseUnbounded(schemaData, flag, parserContext) {
                             if (objData.$ReturnType.$Collection && !returnValue.items) {
                                 obj[objType].returns.items = {};
                                 obj[objType].returns.items = returnValue;
-                            } else
+                                obj[objType].returns.items["notNull"] = objData.$ReturnType?.$Nullable ? false : true;
+                            } else {
                                 obj[objType].returns = returnValue;
+                                if (!returnValue.items) {
+                                    obj[objType].returns["notNull"] = objData.$ReturnType?.$Nullable ? false : true;
+                                }
+                            }
                         }
                     }
                     else {
@@ -994,9 +1029,9 @@ function _checkAnnotatationTerm(annotation, path, no_of_terms, targetString, voc
     }
 }
 
-function checkEntitySetMap(pathName, parserContext) {
+function checkEntitySetMap(pathName, parserContext, index = 0) {
     if (parserContext.entitySetToEntityTypeMap.get(pathName) != null) {
-        pathName = parserContext.namespace + '.' + parserContext.entitySetToEntityTypeMap.get(pathName)[0];
+        pathName = parserContext.namespace + '.' + parserContext.entitySetToEntityTypeMap.get(pathName)[index];
     }
     return pathName;
 }
@@ -1004,7 +1039,21 @@ function checkEntitySetMap(pathName, parserContext) {
 function _checkAnnotationTarget(annotation, cdsDefs, str, no_of_terms, vocab, parserContext) {
     if ((annotation[0].indexOf('/') === -1 && annotation[0].indexOf('(') === -1) || annotation[0].includes("Container")) {
         if (cdsDefs[annotation[0]]) {
-            _checkAnnotatationTerm(annotation, cdsDefs[annotation[0]], no_of_terms, str, vocab);
+            let path = annotation[0].split('/');
+            let pathFromEntityTypeMap = parserContext.entitySetToEntityTypeMap.get(path[0]);
+            if (pathFromEntityTypeMap != null) {
+                if (pathFromEntityTypeMap.length > 1) {
+                    for (let index = 0; index < pathFromEntityTypeMap.length; index++) {
+                        let path1 = checkEntitySetMap(path[0], parserContext, index);
+                        _checkAnnotatationTerm(annotation, cdsDefs[path1], no_of_terms, str, vocab);
+                    }
+                } else {
+                    _checkAnnotatationTerm(annotation, cdsDefs[annotation[0]], no_of_terms, str, vocab);
+                }
+            }
+            else {
+                _checkAnnotatationTerm(annotation, cdsDefs[annotation[0]], no_of_terms, str, vocab);
+            }
         }
         if (annotation[0].indexOf('/') > 0) {
             let path = annotation[0].split('/');
@@ -1019,14 +1068,43 @@ function _checkAnnotationTarget(annotation, cdsDefs, str, no_of_terms, vocab, pa
             let actualPath = checkEntitySetMap(path, parserContext);
             _checkAnnotatationTerm(annotation, cdsDefs[actualPath], no_of_terms, str, vocab);
         }
+        else if (annotation[0].indexOf('(') === -1 && (annotation[0].indexOf('/') === -1)) {
+            let path = annotation[0].split('/');
+            let pathFromEntityTypeMap = parserContext.entitySetToEntityTypeMap.get(path[0]);
+            if (pathFromEntityTypeMap != null) {
+                if (pathFromEntityTypeMap.length > 1) {
+                    for (let index = 0; index < pathFromEntityTypeMap.length; index++) {
+                        let path1 = checkEntitySetMap(path[0], parserContext, index);
+                        _checkAnnotatationTerm(annotation, cdsDefs[path1], no_of_terms, str, vocab);
+                    }
+                }
+            }
+        }
     }
     else if (annotation[0].indexOf('(') === -1 && !(annotation[0].indexOf('/') === -1)) {
         let path = annotation[0].split('/');
-        let path1 = checkEntitySetMap(path[0], parserContext);
-        if (cdsDefs[path1]) {
-            _checkAnnotatationTerm(annotation, cdsDefs[path1]["elements"][path[1]], no_of_terms, str, vocab);
+        let pathFromEntityTypeMap = parserContext.entitySetToEntityTypeMap.get(path[0]);
+        if (pathFromEntityTypeMap != null) {
+            if (pathFromEntityTypeMap.length > 1) {
+                for (let index = 0; index < pathFromEntityTypeMap.length; index++) {
+                    let path1 = checkEntitySetMap(path[0], parserContext, index);
+                    _checkAnnotatationTerm(annotation, cdsDefs[path1]["elements"][path[1]], no_of_terms, str, vocab);
+                }
+            }
+            else {
+                let path1 = checkEntitySetMap(path[0], parserContext);
+                if (cdsDefs[path1]) {
+                    _checkAnnotatationTerm(annotation, cdsDefs[path1]["elements"][path[1]], no_of_terms, str, vocab);
+                }
+            }
         }
-    } else {
+        else {
+            if (cdsDefs[path[0]]) {
+                _checkAnnotatationTerm(annotation, cdsDefs[path[0]]["elements"][path[1]], no_of_terms, str, vocab);
+            }
+        }
+    }
+    else {
         let path = annotation[0].split('(');
         let actualPath = checkEntitySetMap(path[0], parserContext);
         if (cdsDefs[actualPath] === undefined) {

package/lib/init/constants.js

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

package/lib/init/index.js

@@ -1,7 +1,5 @@
 const path = require('path');
 
-const { defaultLogger } = require('./util/logger');
-const FsUtil = require('./util/fsUtil');
 const term = require('../util/term');
 const Spinner = require('./util/spinner');
 
@@ -11,11 +9,12 @@ const { OPTIONS_PRIORITY, COMMAND_ADD, COMMAND_INIT,
     OPTION_NODEJS, OPTION_JAVA, OPTION_HELM,
     OPTION_PIPELINE, OPTION_SAMPLES, OPTION_CF_MANIFEST, PROJECT_FILES, REGEX_PROJECT_NAME } = require('./constants');
 
-module.exports = class CDSGenerator {
-    constructor(fsUtil, logger) {
-        this.fsUtil = fsUtil || new FsUtil();
-        this.logger = logger || defaultLogger;
+const cds = require('../cds'), { exists, readdir } = cds.utils
+const LOG = console
+const DEBUG = /\bcli\b/.test(process.env.DEBUG) && console.debug
 
+module.exports = class CDSGenerator {
+    constructor() {
         this.cwd = process.cwd();
 
         this.uiConfig = [
@@ -163,7 +162,7 @@ module.exports = class CDSGenerator {
 
     async _findProjectFile(projectPath) {
         for (const file of PROJECT_FILES) {
-            if (await this.fsUtil.pathExists(path.join(projectPath, file))) {
+            if (exists(path.join(projectPath, file))) {
                 return file;
             }
         }
@@ -174,7 +173,7 @@ module.exports = class CDSGenerator {
     _initialize(projectName, options = {}) {
         // deprecated, only for compatibility
         if (options.verbose) {
-            this.logger.warn(`Parameter 'verbose' is no longer supported. Use environment variable 'DEBUG=true' to obtain detailed output.`);
+            LOG.warn(`Parameter 'verbose' is no longer supported. Use environment variable 'DEBUG=true' to obtain detailed output.`);
         }
 
         this.cwd = options.cwd || process.cwd();
@@ -190,47 +189,42 @@ module.exports = class CDSGenerator {
             case COMMAND_INIT: {
                 const relativeProjectPath = path.relative(this.cwd, this.projectPath);
                 const folderName = (relativeProjectPath ? `.${path.sep}${relativeProjectPath}` : 'current folder');
-                this.logger.log(`Creating new cap project in ${folderName}`);
+                LOG.info(`Creating new cap project in ${folderName}`);
                 break;
             }
-
             case COMMAND_ADD:
-                this.logger.log(`Adding feature(s) to project in current folder`);
+                LOG.info(`Adding feature(s) to project in current folder`);
                 break;
-
-            default:
         }
 
         if (this.options.force) {
-            this.logger.log(`Using '--force' ... existing files will be overwritten...!`);
+            LOG.info(`Using '--force' ... existing files will be overwritten...!`);
         }
 
-        this.logger.log();
+        LOG.info();
     }
 
     async _process() {
-        this.logger.debug(`Project path: ${this.projectPath}`);
+        DEBUG && DEBUG(`Project path: ${this.projectPath}`);
 
         await this._validateOptions();
         await this._fillTemplateList();
 
         for (const template of this.templateList) {
             const msg = `Adding feature '${template.name}'...`;
-            if (template.dontAnnounce) {
-                await template.run();
-            } else if (this.logger.isDebug) {
-                this.logger.log(msg);
+            if (DEBUG) {
+                LOG.info(msg);
                 await template.run();
             } else {
-                const spinner = new Spinner(this.logger);
+                const spinner = new Spinner();
                 await spinner.run(msg, async () => { // NOSONAR
                     return template.run();
                 });
             }
         }
 
-        this.logger.log(`Done adding features`);
-        this.logger.log();
+        LOG.info(`Done adding features`);
+        LOG.info();
     }
 
     async _createTemplate(filename) {
@@ -239,7 +233,7 @@ module.exports = class CDSGenerator {
             return new TemplateClass(this.projectPath, this);
         } catch (err) {
             if (err.code === 'MODULE_NOT_FOUND') {
-                const entries = (await this.fsUtil.readdir(path.join(__dirname, 'template')))
+                const entries = (await readdir(path.join(__dirname, 'template')))
                     .filter(entry =>
                         !entry.startsWith('_') &&
                         !entry.endsWith('.js') &&
@@ -261,8 +255,8 @@ module.exports = class CDSGenerator {
             if (!templates.has(option)) {
                 const template = await this._createTemplate(option);
 
-                if (await template.checkEnabled()) {
-                    this.logger.debug(`Adding feature '${template.name}'`);
+                if (await template.canRun()) {
+                    DEBUG && DEBUG(`Adding feature '${template.name}'`);
 
                     templates.set(option, template);
                     const deps = await template.getDependencies();
@@ -278,30 +272,14 @@ module.exports = class CDSGenerator {
         }).map((entry) => entry[1]);
 
         // check debug to avoid lengthy computation when not in debug mode
-        this.logger.isDebug && this.logger.debug(`Features: ${this.templateList.map((obj) => {
-            return obj.name;
-        }).join(', ')}`);
+        DEBUG && DEBUG(`Features: ${this.templateList.map(({name}) => name).join(', ')}`);
     }
 
     async stepEnd() {
-        this.logger.isDebug && this._showFiles();
-
         for (const template of this.templateList) {
             await template.finalize();
         }
-
-        this.logger.log();
-    }
-
-    _showFiles() {
-        const files = this.fsUtil.getTouchedFiles();
-        if (files && files.length > 0) {
-            this.logger.log(`Added / changed files`);
-            for (const file of files) {
-                this.logger.log(file);
-            }
-            this.logger.log();
-        }
+        LOG.info();
     }
 
     _cleanupOptions() {
@@ -347,7 +325,7 @@ module.exports = class CDSGenerator {
             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(', ')}`);
+                    LOG.warn(`ignoring option ${key} since ${keySplit[0]} is not part of specified feature list: ${Array.from(this.options.add).join(', ')}`);
                 }
             }
         }