@sap/cds-dk 6.5.1 → 6.6.0

package/lib/import/odata/v4parser.js

@@ -43,6 +43,26 @@ const edmxncdsdatatype = {
     "Edm.DateTimeOffset_a": "cds.Timestamp",
 };
 
+const extendedPrimitiveTypes = [
+    "Edm.Duration",
+	"Edm.Geography",
+	"Edm.GeographyPoint",
+	"Edm.GeographyLineString",
+	"Edm.GeographyPolygon",
+	"Edm.GeographyMultiPoint",
+	"Edm.GeographyMultiLineString",
+	"Edm.GeographyMultiPolygon",
+	"Edm.GeographyCollection",
+	"Edm.Geometry",
+	"Edm.GeometryPoint",
+	"Edm.GeometryLineString",
+	"Edm.GeometryPolygon",
+	"Edm.GeometryMultiPoint",
+	"Edm.GeometryMultiLineString",
+	"Edm.GeometryMultiPolygon",
+	"Edm.GeometryCollection"
+];
+
 const known_vocabularies = {
     'Org.OData.Authorization.V1': 'Authorization',
     'Org.OData.Aggregation.V1': 'Aggregation',
@@ -142,7 +162,7 @@ function _addNotNull(property, isCollection) {
 }
 
 function _typeWithCollections(property, type, isCollection) {
-    if (isCollection === true) {
+    if (isCollection) {
         let typeKeys = Object.keys(type);
         for (let i = 0; i < typeKeys.length; i++) {
             if (typeKeys[i].startsWith("@")) {
@@ -164,13 +184,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) {
+        if (propertyType.$Nullable) {
             console.log(warn("Expected key element to be not nullable"));
         }
         typeProperties["notNull"] = true;
     }
     else {
-        if ((propertyType.$Nullable !== true) && (propertyType.$Kind !== 'TypeDefinition')) {
+        if ((!propertyType.$Nullable) && (propertyType.$Kind !== 'TypeDefinition')) {
             typeProperties["notNull"] = true;
         }
     }
@@ -221,9 +241,13 @@ function generatePropertyCsn(propertyType, isPrimaryKey) {
             typeProperties["@odata.Type"] = propertyType.$Type;
         }
     }
-
     _typeWithCollections(property, typeProperties, propertyType.$Collection);
 
+    if (propertyType.$DefaultValue) {
+        if (propertyType.$Collection) console.log(warn("Type with Collection cannot have DefaultValue"));
+        _addDefaultValueObject(property, propertyType.$DefaultValue);
+    }
+
     return property;
 }
 
@@ -233,6 +257,10 @@ function _generateComplexTypePropertyCsn(propertyType) {
     _typeWithCollections(property, type, propertyType.$Collection);
     if (!propertyType.$Nullable) _addNotNull(property, propertyType.$Collection);
 
+    if (propertyType.$DefaultValue && !propertyType.$Collection) {
+        _addDefaultValueObject(property, propertyType.$DefaultValue);
+    }
+
     return property;
 }
 
@@ -243,6 +271,7 @@ function _generateTypeDefinitionPropertyCsn(propertyType) {
     _includeExternalNamespaceAnnotation(propertyType, property);
     _typeWithCollections(property, type, propertyType.$Collection);
     if (!propertyType.$Nullable) _addNotNull(property, propertyType.$Collection);
+    // Verify: Can DefaultValue be present here?
 
     return property;
 }
@@ -342,6 +371,10 @@ function _generateCSNForEntityType(ignorePersistenceSkip, mockServerUc, parserCo
     let j;
     let propertyType;
     let enumType = {};
+    const entityTypeNames = parserContext.entityTypes.map(elementObject => {
+        return Object.keys(elementObject)[0];
+    });
+
     parserContext.entityTypes.forEach(element => {
         let key = Object.keys(element)[0];
         let baseType = element[key].$BaseType;
@@ -364,13 +397,18 @@ function _generateCSNForEntityType(ignorePersistenceSkip, mockServerUc, parserCo
             // inheritance
             if (baseType) {
                 entityCsn[key].includes = [];
-                // if the baseType has a mapping to an entity set use that
-                if (parserContext.entitySetToEntityTypeMap && parserContext.entitySetToEntityTypeMap.get(baseType)) {
+                if (entityTypeNames.includes(baseType)) {
+                    entityCsn[key].includes.push(baseType);
+                }
+                else if (parserContext.entitySetToEntityTypeMap && parserContext.entitySetToEntityTypeMap.get(baseType)) {
                     baseType = _getBaseTypeEntityName(baseType, parserContext);
+                    entityCsn[key].includes.push(baseType);
+                } else {
+                    delete entityCsn[key].includes;
+                    throw new Error(messages.UNRESOLVED_TYPE + `'${baseType}' in element: '${element}'.`);
                 }
-                entityCsn[key].includes.push(baseType);
                 if (!parserContext.entityTypeOpenEntries.includes(baseType)) parserContext.entityTypeOpenEntries.push(baseType);
-            }
+            } 
             if ((isAbstract || isOpenType) && !parserContext.entityTypeOpenEntries.includes(key)) {
                 parserContext.entityTypeOpenEntries.push(key);
             }
@@ -412,8 +450,9 @@ function _generateCSNForEntityType(ignorePersistenceSkip, mockServerUc, parserCo
                             propertyType = element[key][property];
                             entityCsn[key].elements[property] = _generateTypeDefinitionPropertyCsn(propertyType);
                         } else {
-                            let message = '"' + element[key][property].$Type + '" is not supported (in element:"' + property + '")';
-                            console.log(warn(message));
+                            // let message = '"' + element[key][property].$Type + '" is not supported (in element:"' + property + '")';
+                            // console.log(warn(message));
+                            throw new Error(messages.UNRESOLVED_TYPE + `'${element[key][property].$Type}' in element: '${property}'.`);
                         }
                     }
                 }
@@ -718,72 +757,93 @@ function _parseBounded(csnDefs, flag, parserContext) {
                                         if (paramObj.$Collection && !paramType.items) {
                                             csnDefs[boundedEntityName].actions[name].params[paramName] = {};
                                             csnDefs[boundedEntityName].actions[name].params[paramName].items = paramType;
-                                            if(paramObj.$Nullable != true){
+                                            if (!paramObj.$Nullable) {
                                                 csnDefs[boundedEntityName].actions[name].params[paramName].items["notNull"] = true;
                                             }
                                         } else {
                                             csnDefs[boundedEntityName].actions[name].params[paramName] = paramType;
                                             if (!paramType.items) {
-                                                if(paramObj.$Nullable != true){
+                                                if (!paramObj.$Nullable) {
                                                     csnDefs[boundedEntityName].actions[name].params[paramName].notNull = true;
                                                 }
                                             }
+                                        }
                                     }
+                                    else {
+                                        // let message = '"' + paramObj.$Type + '" is not supported (in element:"' + name + '")';
+                                        // console.log(warn(message));
+                                        throw new Error(messages.UNRESOLVED_TYPE + `'${paramObj.$Type}' in element: '${name}'.`);
+                                    }
+                                    if (csnDefs[boundedEntityName].actions[name].params[paramName])
+                                        Object.assign(csnDefs[boundedEntityName].actions[name].params[paramName], annotations);
                                 }
-                                else {
-                                    let message = '"' + paramObj.$Type + '" is not supported (in element:"' + name + '")';
-                                    console.log(warn(message));
-                                }
-                                if (csnDefs[boundedEntityName].actions[name].params[paramName])
-                                    Object.assign(csnDefs[boundedEntityName].actions[name].params[paramName], annotations);
                             }
                         }
-                    }
-                    // 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;
-                    }
-                    // add returns
-                    if (obj[j].$ReturnType) {
-                        let returnType = {};
-                        let annotations = {};
-                        // check if the return type is pre-defined, undefined or custom defined
-                        if (edmxncdsdatatype[obj[j].$ReturnType.$Type] || edmxncdsdatatype[obj[j].$ReturnType.$Type + "_a"])
-                            returnType = generatePropertyCsn(obj[j].$ReturnType, false);
-                        else {
-                            let type = _getDatatype(obj[j].$ReturnType.$Type, parserContext);
-                            _includeExternalNamespaceAnnotation(obj[j].$ReturnType, annotations);
-                            if (type) returnType["type"] = type;
+                        // 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;
                         }
-                        if (Object.keys(returnType).length > 0) {
-                            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) {
-                                    csnDefs[boundedEntityName].actions[name].returns.items = returnType;
-                                    if(obj[j].$ReturnType.$Nullable != true){
-                                        csnDefs[boundedEntityName].actions[name].returns.items["notNull"] = true;
-                                    }
+                        // add returns
+                        if (obj[j].$ReturnType) {
+                            let returnType = {};
+                            let annotations = {};
+                            let hasCdsTypeMapping = false;
+                            // check if the return type is pre-defined, undefined or custom defined
+                            if (edmxncdsdatatype[obj[j].$ReturnType.$Type] || edmxncdsdatatype[obj[j].$ReturnType.$Type + "_a"] ||
+                                (!obj[j].$ReturnType.$Type && obj[j].$ReturnType.$MaxLength)
+                            )
+                                returnType = generatePropertyCsn(obj[j].$ReturnType, false);
+                            else {
+                                let type;
+                                if (extendedPrimitiveTypes.includes(obj[j].$ReturnType.$Type)) {
+                                    hasCdsTypeMapping = true;
                                 }
                                 else {
-                                    csnDefs[boundedEntityName].actions[name].returns = returnType;
-                                    if (!returnType.items) {
-                                        if(obj[j].$ReturnType.$Nullable != true){
-                                            csnDefs[boundedEntityName].actions[name].returns["notNull"] = true;
+                                    type = _getDatatype(obj[j].$ReturnType.$Type, parserContext);
+                                }
+                                _includeExternalNamespaceAnnotation(obj[j].$ReturnType, annotations);
+                                if (type) returnType["type"] = type;
+                                if (!type && !hasCdsTypeMapping) {
+                                    throw new Error(messages.UNRESOLVED_TYPE + `'${obj[j].$ReturnType.$Type}'`);
+                                }
+                            }
+                            if (Object.keys(returnType).length > 0) {
+                                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) {
+                                        csnDefs[boundedEntityName].actions[name].returns.items = returnType;
+                                        if (!obj[j].$ReturnType.$Nullable) {
+                                            csnDefs[boundedEntityName].actions[name].returns.items["notNull"] = true;
+                                        }
+                                    }
+                                    else {
+                                        csnDefs[boundedEntityName].actions[name].returns = returnType;
+                                        if (!returnType.items) {
+                                            if (!obj[j].$ReturnType.$Nullable){
+                                                csnDefs[boundedEntityName].actions[name].returns["notNull"] = true;
+                                            }
                                         }
                                     }
                                 }
+                            } else {
+                                csnDefs[boundedEntityName].actions[name].returns = {};
+                                if (obj[j].$ReturnType.$Collection && !returnType.items) {
+                                    csnDefs[boundedEntityName].actions[name].returns = { "@odata.Type": obj[j].$ReturnType.$Type };
+                                    csnDefs[boundedEntityName].actions[name].returns.items = { "type": "cds.String" };
+                                }
+                                else
+                                    csnDefs[boundedEntityName].actions[name].returns = { "type": "cds.String", "@odata.Type": obj[j].$ReturnType.$Type };
                             }
+                            if (csnDefs[boundedEntityName].actions[name].returns)
+                                Object.assign(csnDefs[boundedEntityName].actions[name].returns, annotations);
                         } else {
-                            let message = '"' + obj[j].$ReturnType.$Type + '" is not supported (in return type)';
-                            console.log(warn(message));
+                            if (obj[j].$Kind === 'Function')
+                                throw new Error(messages.NO_RETURN_TYPE + `'${name}'.`);
                         }
-                        if (csnDefs[boundedEntityName].actions[name].returns)
-                            Object.assign(csnDefs[boundedEntityName].actions[name].returns, annotations)
                     }
                 }
             }
-        }
         });
     }
 }
@@ -829,9 +889,14 @@ function _generateCSNForComplexType(schemaData, parserContext) {
         isAbstract = cTypes[element].$Abstract;
         isOpenType = cTypes[element].$OpenType;
         if (baseType) {
-            complexCsn[element].includes = [];
-            complexCsn[element].includes.push(baseType);
-            if (!parserContext.complexTypeOpenEntries.includes(baseType)) parserContext.complexTypeOpenEntries.push(baseType);
+            if (parserContext.complexTypes[baseType]) {
+                complexCsn[element].includes = [];
+                complexCsn[element].includes.push(baseType);
+                if (!parserContext.complexTypeOpenEntries.includes(baseType)) parserContext.complexTypeOpenEntries.push(baseType);
+            }
+            else {
+                throw new Error(messages.UNRESOLVED_TYPE + `'${baseType}' in element: '${element}'.`);
+            }
         }
         if ((isAbstract || isOpenType) && !parserContext.complexTypeOpenEntries.includes(element)) {
             parserContext.complexTypeOpenEntries.push(element);
@@ -854,8 +919,9 @@ function _generateCSNForComplexType(schemaData, parserContext) {
                     enumType = cTypes[element][property];
                     complexCsn[element].elements[property] = generatePropertyCsn(enumType, false);
                 } else {
-                    let message = '"' + cTypes[element][property].$Type + '" is not supported (in element:"' + property + '")';
-                    console.log(warn(message));
+                    // let message = '"' + cTypes[element][property].$Type + '" is not supported (in element:"' + property + '")';
+                    // console.log(warn(message));
+                    throw new Error(messages.UNRESOLVED_TYPE + `'${cTypes[element][property].$Type}' in element: '${property}'.`);
                 }
             } else if (property.startsWith("@")) {
                 complexCsn[element][property] = cTypes[element][property];
@@ -946,8 +1012,9 @@ function _parseUnbounded(schemaData, flag, parserContext) {
                                 }
                             }
                         } else {
-                            let message = '"' + objData.$Parameter[i].$Type + '" is not supported (in element:"' + temp + '")';
-                            console.log(warn(message));
+                            // let message = '"' + objData.$Parameter[i].$Type + '" is not supported (in element:"' + temp + '")';
+                            // console.log(warn(message));
+                            throw new Error(messages.UNRESOLVED_TYPE + `'${objData.$Parameter[i].$Type}' in element: '${temp}'.`);
                         }
                         if (obj[objType].params[objData.$Parameter[i].$Name])
                             Object.assign(obj[objType].params[objData.$Parameter[i].$Name], annotations)
@@ -961,13 +1028,24 @@ function _parseUnbounded(schemaData, flag, parserContext) {
                 if (objData.$ReturnType && Object.keys(objData.$ReturnType).length > 0 && obj) {
                     let returnValue = {};
                     let annotations = {};
+                    let hasCdsTypeMapping = false; 
                     // check if the return type is pre-defined, undefined or custom defined
-                    if (edmxncdsdatatype[objData.$ReturnType.$Type] || edmxncdsdatatype[objData.$ReturnType.$Type + "_a"]) {
+                    if (edmxncdsdatatype[objData.$ReturnType.$Type] || edmxncdsdatatype[objData.$ReturnType.$Type + "_a"] ||
+                        (!objData.$ReturnType.$Type && objData.$ReturnType.$MaxLength)
+                    ){
                         returnValue = generatePropertyCsn(objData.$ReturnType, false);
                     } else {
-                        let type = _getDatatype(objData.$ReturnType.$Type, parserContext);
+                        let type;
+                        if (extendedPrimitiveTypes.includes(objData.$ReturnType.$Type)) {
+                            hasCdsTypeMapping = true;
+                        } else {
+                            type = _getDatatype(objData.$ReturnType.$Type, parserContext);
+                        }
                         _includeExternalNamespaceAnnotation(objData.$ReturnType, annotations);
                         if (type) returnValue["type"] = type;
+                        if (!type && !hasCdsTypeMapping) {
+                            throw new Error(messages.UNRESOLVED_TYPE + `'${objData.$ReturnType.$Type}'`);
+                        }
                     }
                     if (Object.keys(returnValue).length > 0) {
                         if (returnValue.type || returnValue.items.type) {
@@ -976,25 +1054,34 @@ function _parseUnbounded(schemaData, flag, parserContext) {
                             if (objData.$ReturnType.$Collection && !returnValue.items) {
                                 obj[objType].returns.items = {};
                                 obj[objType].returns.items = returnValue;
-                                if(objData.$ReturnType.$Nullable != true){
+                                if (!objData.$ReturnType.$Nullable) {
                                     obj[objType].returns.items["notNull"] = true;
                                 }
                             } else {
                                 obj[objType].returns = returnValue;
                                 if (!returnValue.items) {
-                                    if(objData.$ReturnType.$Nullable != true){
-                                    obj[objType].returns["notNull"] = true;
-                                }
+                                    if (!objData.$ReturnType.$Nullable) {
+                                        obj[objType].returns["notNull"] = true;
+                                    }
                                 }
                             }
                         }
                     }
                     else {
-                        let message = '"' + objData.$ReturnType.$Type + '" is not supported (in return type of' + temp + ')';
-                        console.log(warn(message));
+                        obj[objType].returns = {};
+                        // check if return type is a collection
+                        if ((objData.$ReturnType.$Collection && !returnValue.items)) {
+                            obj[objType].returns = { "@odata.Type":objData.$ReturnType.$Type };
+                            obj[objType].returns.items = {};
+                            obj[objType].returns.items = { "type": "cds.String" };
+                        } else
+                            obj[objType].returns = { "type": "cds.String", "@odata.Type": objData.$ReturnType.$Type };
                     }
                     if (obj[objType].returns)
                         Object.assign(obj[objType].returns, annotations);
+                } else {
+                    if (objData.$Kind === 'Function')
+                        throw new Error(messages.NO_RETURN_TYPE + `'${ub}'.`);
                 }
             }
             unboundedObj = Object.assign(unboundedObj, obj);
@@ -1097,7 +1184,12 @@ function _checkAnnotatationTerm(annotation, path, no_of_terms, targetString, voc
         }
         else if (vocab) { 
             if (vocab.includes(targetString.substring(targetString.indexOf('@') + 1, targetString.lastIndexOf('.')))) {
-                path[targetString] = annotation[1][targetString] === null ? true : annotation[1][targetString];
+                if (annotation[1][targetString]?.$Cast) {
+                    path[targetString] = Number(annotation[1][targetString].$Cast);
+                }
+                else {
+                    path[targetString] = annotation[1][targetString] === null ? true : annotation[1][targetString];
+                }
             }
         }
     }

package/lib/import/openapi/importOpenAPI.js

@@ -129,32 +129,32 @@ function operations(context, csn, input) {
                 if (param.description) cdsParam["@description"] = param.description;
                 cdsParam["@openapi.in"] = param.in;
 
+                // only add the annotation "@openapi.explode" for true scenario
+                if (param.explode || param.style === "form")
+                    cdsParam["@openapi.explode"] = true;
+                if (!param.explode)
+                    delete cdsParam["@openapi.explode"];
+
                 if ((param.in === "path" && param.style && param.style !== "simple") ||
                     (param.in === "query" && param.style && param.style !== "form")
                 )
                     cdsParam["@openapi.style"] = param.style;
-
-                if (param.explode && param.style !== "form")
-                    cdsParam["@openapi.explode"] = true;
-
-                if (param.explode === false &&
-                    (param.style === "form" || (!param.style && param.in === "query"))
-                )
-                    cdsParam["@openapi.explode"] = false;
-
-                if (param.in === "query" && param.collectionFormat === "csv")
-                    cdsParam["@openapi.explode"] = false;
                 if (param.in === "query" && param.collectionFormat === "ssv")
                     cdsParam["@openapi.style"] = "spaceDelimited";
                 if (param.in === "query" && param.collectionFormat === "pipes")
                     cdsParam["@openapi.style"] = "pipeDelimited";
+
                 if (param.in === "query" && param.allowReserved === true)
                     cdsParam["@openapi.allowReserved"] = true;
+
                 if (param.required && param.in !== "path")
                     cdsParam["@openapi.required"] = true;
-                if (!param.required)
-                    delete cdsParam.notNull;
 
+                if (!param.required) {
+                    delete param.notNull;
+                    if (param.default !== undefined)
+                        cdsParam["default"] = { "val": param.default };
+                }
                 const name = cdsName(param.name);
                 if (name !== param.name) cdsParam["@openapi.name"] = param.name;
                 cdsOperation.params[name] = cdsParam;
@@ -382,8 +382,8 @@ function cdsType(
 }
 
 function addDefault(type, schema, forParameter) {
+    if (schema.default !== undefined) type.default = { val: schema.default };
     if (forParameter) return;
-    if (schema.default) type.default = { val: schema.default };
 }
 
 function addPrimitiveExample(type, schema) {

package/lib/init/constants.js

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

package/lib/init/index.js

@@ -133,7 +133,7 @@ module.exports = class CDSGenerator {
         this._initialize(null, options);
         this._greetings(options._cmd);
 
-        if (!(await this._findProjectFile(this.projectPath))) {
+        if (!PROJECT_FILES.find(exists)) {
             throw new Error(`The current folder doesn't seem to contain a project. None of the following files found: ${PROJECT_FILES.join(', ')}.`);
         }
 
@@ -159,16 +159,6 @@ module.exports = class CDSGenerator {
         await this._process();
     }
 
-    async _findProjectFile(projectPath) {
-        for (const file of PROJECT_FILES) {
-            if (exists(path.join(projectPath, file))) {
-                return file;
-            }
-        }
-
-        return null;
-    }
-
     _initialize(projectName, options = {}) {
         // deprecated, only for compatibility
         if (options.verbose) {
@@ -176,8 +166,8 @@ module.exports = class CDSGenerator {
         }
 
         this.cwd = options.cwd || process.cwd();
-        this.projectPath = path.resolve(this.cwd, projectName || '.');
-        this.projectName = path.basename(this.projectPath);
+        cds.root = path.resolve(this.cwd, projectName || '.');
+        this.projectName = path.basename(cds.root);
 
         this.options = options;
         this._cleanupOptions();
@@ -186,7 +176,7 @@ module.exports = class CDSGenerator {
     _greetings(cmd) {
         switch (cmd) {
             case COMMAND_INIT: {
-                const relativeProjectPath = path.relative(this.cwd, this.projectPath);
+                const relativeProjectPath = path.relative(this.cwd, cds.root);
                 const folderName = (relativeProjectPath ? `.${path.sep}${relativeProjectPath}` : 'current folder');
                 LOG.info(`Creating new cap project in ${folderName}`);
                 break;
@@ -204,7 +194,7 @@ module.exports = class CDSGenerator {
     }
 
     async _process() {
-        DEBUG && DEBUG(`Project path: ${this.projectPath}`);
+        DEBUG && DEBUG(`Project path: ${cds.root}`);
 
         await this._validateOptions();
         await this._fillTemplateList();
@@ -222,7 +212,7 @@ module.exports = class CDSGenerator {
     async _createTemplate(filename) {
         try {
             const TemplateClass = require(`./template/${filename}`);
-            return new TemplateClass(this.projectPath, this);
+            return new TemplateClass(this);
         } catch (err) {
             if (err.code === 'MODULE_NOT_FOUND') {
                 const entries = (await readdir(path.join(__dirname, 'template')))
@@ -234,7 +224,7 @@ module.exports = class CDSGenerator {
                     );
                 const fuzzySearch = require('../../bin/util/fuzzySearch');
                 const [bestMatch] = fuzzySearch(filename, entries);
-                console.log(`Unknown facet '${term.bold(filename)}'. Did you mean ${term.bold(`cds add ${bestMatch}`)}?\n\nHaven't found the proper facet yet? Here are all supported facets:\n\n  ${term.bold(entries.join('\n  '))}\n`);
+                LOG.info(`Unknown facet '${term.bold(filename)}'. Did you mean ${term.bold(`cds add ${bestMatch}`)}?\n\nHaven't found the proper facet yet? Here are all supported facets:\n\n  ${term.bold(entries.join('\n  '))}\n`);
                 process.exit(1);
             }
             throw err;
@@ -330,7 +320,7 @@ module.exports = class CDSGenerator {
 
         if (this.options._cmd === COMMAND_INIT) {
             await this._validateProjectName(this.projectName);
-            await this._validateProjectFolder(this.projectPath, this.cwd);
+            await this._validateProjectFolder(this.cwd);
         }
     }
 
@@ -351,11 +341,11 @@ module.exports = class CDSGenerator {
         }
     }
 
-    async _validateProjectFolder(projectPath, cwd) {
-        const existingProjectFile = await this._findProjectFile(projectPath);
+    async _validateProjectFolder(cwd) {
+        const existingProjectFile = PROJECT_FILES.find(exists)
         if (existingProjectFile) {
             let message;
-            if (cwd === projectPath) {
+            if (cwd === cds.root) {
                 message = `You seem to be working in a project which is already initialized. Use ${term.bold('cds add')} to add more features.`;
             } else {
                 message = `You seem to be trying to initialize an existing project. Use a different project name instead.`;