@sap/cds-dk 6.1.5 → 6.2.0

package/lib/import/odata/v2parser.js

@@ -394,6 +394,9 @@ function _getServiceEntityProperty(
 	let hasInvalidPrecision = false;
 	let propertyJson = '';
 	if (length && length > 0) {
+		if(dataType == "Edm.Binary" && length >= 5000){
+			console.log(warn("MaxLength for type Edm.Binary should not exceed 5000"));
+		}
 		cdsDataType = edmxncdsdatatype[dataType + "_m"];
 	} else if (precision && precision > 0) {
 		cdsDataType = edmxncdsdatatype[dataType + "_p"];
@@ -429,6 +432,9 @@ function _getServiceEntityProperty(
 	} else if (!cdsDataType && parserContext.allEntitySetMap[_extractEntityFromNamespace(dataType)]) {
 		cdsDataType = dataType;
 	}
+	else if (!cdsDataType && parserContext.allEntities.includes(_extractEntityFromNamespace(dataType))) {
+		cdsDataType = dataType;
+	}
 
 	//if the cdsDataType is undefined/ not supported
 	if (cdsDataType === undefined) {
@@ -458,8 +464,9 @@ function _getServiceEntityProperty(
 
 		//adding precision in case of DateTime datatypes
 		if ((dataType === "Edm.DateTimeOffset" || dataType === "Edm.DateTime") && cdsDataType != "cds.Date") {
-			if (!precision || precision === -1) precision = 0;
-			propertyJson = propertyJson + '"@odata.Precision": ' + precision + ',\n';
+			if (precision && precision > 0){
+				propertyJson = propertyJson + '"@odata.Precision": ' + precision + ',\n';
+			}
 		}
 
 		propertyJson = propertyJson + '"items": { \n'
@@ -500,8 +507,9 @@ function _getServiceEntityProperty(
 
 		//adding precision in case of DateTime datatypes
 		if ((dataType === "Edm.DateTimeOffset" || dataType === "Edm.DateTime") && cdsDataType != "cds.Date") {
-			if (!precision || precision === -1) precision = 0;
-			propertyJson = propertyJson + ',\n"@odata.Precision": ' + precision;
+			if (precision && precision > 0){
+				propertyJson = propertyJson + ',\n"@odata.Precision": ' + precision;
+			}
 		}
 	}
 
@@ -945,12 +953,18 @@ function _generateCSNEntityProperties(entityKeysList, entityPropertiesMap, parse
 	return csnEntity;
 }
 
-function _getAssociatedEntity(associationEnds, toRole, mockServerUc, parserContext) {
+function _getAssociatedEntity(associationEnds, toRole, isAssociationSetMissing, mockServerUc, parserContext) {
 	let entityName;
 	let entitySetName;
+	let entityTypeName;
 	Object.keys(associationEnds).forEach((i) => {
 		if (toRole === associationEnds[i]._attributes.Role) {
-			entitySetName = associationEnds[i]._attributes.EntitySet;
+			if (isAssociationSetMissing) {
+				entityTypeName = associationEnds[i]._attributes.Type;
+				entitySetName = parserContext.allEntitySetMapMC[entityTypeName][0];
+			} else  {
+				entitySetName = associationEnds[i]._attributes.EntitySet;
+			}
 			if (mockServerUc) {
 				entityName = parserContext.serviceNamespace + "." + entitySetName;
 			} else {
@@ -1167,13 +1181,20 @@ function _getCSNAssociatedEntitySet(
 	parserContext
 ) {
 	let associationSet = parserContext.allAssociationSets[relationshipName];
+	let associationName = relationshipName.replace(parserContext.serviceNamespace + '.', '');
+	let association = parserContext.allAssociations[associationName];
+	let isAssociationSetMissing = false;
+	
+	// if association set is missing, use association to extract the informations
 	if (associationSet === undefined) {
-		throw new Error(messages.MISSING_ASSOCIATION_SETS);
+		isAssociationSetMissing = true;
 	}
-	let associationName = associationSet.Name;
+
+	let associationEnd = associationSet ? associationSet.End : association.End;
 	let entityName = _getAssociatedEntity(
-		associationSet.End,
+		associationEnd,
 		toRole,
+		isAssociationSetMissing,
 		mockServerUc,
 		parserContext
 	);
@@ -1189,7 +1210,7 @@ function _getCSNAssociatedEntitySet(
 			differentAssociationNames = parserContext.allAssociations[array[array.length - 1]];
 		}
 	} else {
-		differentAssociationNames = parserContext.allAssociations[associationName];
+		differentAssociationNames = association;
 	}
 	return _getCSNAssociatedRefrenentialConstraints(
 		differentAssociationNames,
@@ -1203,7 +1224,10 @@ function _getCSNAssociatedEntitySet(
 
 function _findAssociationType(relationshipName, fromRole, parserContext) {
 	const associationName = relationshipName.replace(parserContext.serviceNamespace + '.', '');
-	const associationEnds = parserContext.allAssociations[associationName].End;
+	const association = parserContext.allAssociations[associationName];
+	if (association === undefined)	throw new Error(`'${associationName}' ` + messages.MISSING_ASSOCIATION);
+	
+	const associationEnds = association.End;
 	let associationType;
 
 	for (let i = 0; i < associationEnds.length; i++) {
@@ -1249,6 +1273,7 @@ function _getServiceEntityNavigationProperty(navPropAttributes, mockServerUc, pa
 	// if documentation exists for navigation property
 	if (navPropDoc)
 		csn = csn + '"doc":' + ` "${navPropDoc}",\n`;
+	// this function call can throw error if the association is missing in the edmx file
 	csn = csn + _findAssociationType(relationshipName, fromRole, parserContext);
 	csn = csn +
 		_getCSNAssociatedEntitySet(
@@ -1520,6 +1545,7 @@ function _getEntitesWithNamesFromEntityTypes(entityJson, parserContext) {
 				entity: entityJson[i],
 				name: [entity]
 			});
+			parserContext.allEntities.push(entity);
 		}
 	}
 
@@ -1619,6 +1645,12 @@ function _generateEDMXJSON2CSN(jsonObj, ignorePersistenceSkip, mockServerUc, par
 		definitions.push(def);
 	}
 
+	if (entityJson) {
+		definitions.push(
+			_getServiceEntitites(entityJson, ignorePersistenceSkip, mockServerUc, parserContext)
+		);
+	}
+
 	// If complex type exists
 	if (complexTypes) {
 		definitions.push(_getServiceComplexTypes(parserContext));
@@ -1632,12 +1664,6 @@ function _generateEDMXJSON2CSN(jsonObj, ignorePersistenceSkip, mockServerUc, par
 		);
 	}
 
-	if (entityJson) {
-		definitions.push(
-			_getServiceEntitites(entityJson, ignorePersistenceSkip, mockServerUc, parserContext)
-		);
-	}
-
 	try {
 		csn.definitions = JSON.parse(`{${definitions.join(",")}}`);
 		return JSON.stringify(csn, null, 4);

package/lib/import/odata/v4parser.js

@@ -13,6 +13,7 @@ const ignoreObjects = ["$Reference"]; // add all the objects that needs to be ig
 const validEdmDatatypes = ["Edm.DateTimeOffset"];
 const { warn } = require("../../util/term");
 const MetadataConverterFactory = require("./metadataconverter/MetadataConverterFactory");
+const cds = require('../../cds');
 
 const edmxncdsdatatype = {
     "Edm.String": "cds.LargeString",
@@ -51,7 +52,7 @@ const known_vocabularies = {
     'Org.OData.Validation.V1': 'Validation',
     'Org.OData.Measures.V1': 'Measures',
     'Org.OData.Repeatability.V1': 'Repeatability',
-  
+
     'com.sap.vocabularies.Analytics.v1': 'Analytics',
     'com.sap.vocabularies.CodeList.v1': 'CodeList',
     'com.sap.vocabularies.Common.v1': 'Common',
@@ -112,7 +113,7 @@ function _isValidJSON(jsonObj, parserContext) {
 }
 
 function _hasEntityContainer(jsonObj, parserContext) {
-    if (jsonObj[parserContext.namespace][parserContext.jsonEntityContainerName] && 
+    if (jsonObj[parserContext.namespace][parserContext.jsonEntityContainerName] &&
         jsonObj[parserContext.namespace][parserContext.jsonEntityContainerName] instanceof Object
     ) {
         return true;
@@ -140,7 +141,7 @@ function _typeWithCollections(property, type, isCollection) {
     if (isCollection === true) {
         let typeKeys = Object.keys(type);
         for (let i = 0; i < typeKeys.length; i++) {
-            if(typeKeys[i].startsWith("@")){
+            if (typeKeys[i].startsWith("@")) {
                 property[typeKeys[i]] = type[typeKeys[i]];
                 delete type[typeKeys[i]];
             }
@@ -164,6 +165,9 @@ function generatePropertyCsn(propertyType, isPrimaryKey) {
     // conditions have to be made
     if (propertyType.$MaxLength) {
         if (propertyType.$Type) {
+            if (propertyType.$Type == "Edm.Binary" && propertyType.$MaxLength >= 5000) {
+                console.log(warn("MaxLength for type Edm.Binary should not exceed 5000"));
+            }
             typeProperties.type = edmxncdsdatatype[propertyType.$Type + '_m'];
         } else {
             typeProperties.type = 'cds.String'; // if type is missing, then it is String type
@@ -175,7 +179,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'];
@@ -186,7 +190,12 @@ function generatePropertyCsn(propertyType, isPrimaryKey) {
     } else if (edmxncdsdatatype[propertyType.$Type + "_a"]) {
         typeProperties.type = edmxncdsdatatype[propertyType.$Type + "_a"];
     } else if (propertyType.$Type) {
-        typeProperties.type = edmxncdsdatatype[propertyType.$Type];
+        if (edmxncdsdatatype[propertyType.$Type]) {
+            typeProperties.type = edmxncdsdatatype[propertyType.$Type];
+        }
+        else {
+            typeProperties.type = propertyType.$Type;
+        }
     } else {
         typeProperties.type = 'cds.LargeString'; // if type is missing, then it is String type
     }
@@ -240,7 +249,7 @@ function _parseAssociationProperty(foreignReference, associationNode, mockServer
             for (let j = 0; j < parserContext.entitySetToEntityTypeMap.get(associationNode.$Type).length; j++) {
                 if (parserContext.entitySetToEntityTypeMap.get(associationNode.$Type)[j] === foreignReference) {
                     associationProperty.target = parserContext.namespace + '.' +
-                    parserContext.entitySetToEntityTypeMap.get(associationNode.$Type)[j];
+                        parserContext.entitySetToEntityTypeMap.get(associationNode.$Type)[j];
                 }
             }
         } else {
@@ -323,6 +332,12 @@ function _generateCSNForEntityType(ignorePersistenceSkip, mockServerUc, parserCo
             if (!ignorePersistenceSkip) {
                 entityCsn[key]['@cds.persistence.skip'] = true;
             }
+            if (element[key].$Singleton) {
+                entityCsn[key]['@odata.singleton'] = true;
+            }
+            if (element[key].$SingletonNullable) {
+                entityCsn[key]['@odata.singleton.nullable'] = true;
+            }
             _includeExternalNamespaceAnnotation(element[key], entityCsn[key]);
             // inheritance
             if (baseType) {
@@ -358,7 +373,7 @@ function _generateCSNForEntityType(ignorePersistenceSkip, mockServerUc, parserCo
                                 entityCsn[key].elements[property] = generatePropertyCsn(propertyType, false);
                             }
                         } else if (!element[key][property].$Type || parserContext.enumTypes[element[key][property].$Type]) {
-                            enumType.$Type = parserContext.enumTypes[element[key][property].$Type].$UnderlyingType;
+                            enumType = element[key][property];
                             if (keySet.includes(property)) {
                                 entityCsn[key].elements[property] = generatePropertyCsn(enumType, true);
                             } else {
@@ -402,13 +417,24 @@ function _generateEntityType(schemaData, mockServerUc, parserContext) {
                             let entity1 = {};
                             for (let i = 0; i < parserContext.entitySetToEntityTypeMap.get(entityTypeName).length; i++) {
                                 entity1 = {};
+                                let entityDetails = {};
                                 let temp1 = parserContext.namespace + '.' + parserContext.entitySetToEntityTypeMap.get(entityTypeName)[i];
-                                entity1[temp1] = schemaData[entityType];
+                                entity1[temp1] = Object.assign({}, schemaData[entityType]);
+                                entityDetails = schemaData[parserContext.jsonEntityContainerName][parserContext.entitySetToEntityTypeMap.get(entityTypeName)[i]];
+                                if (entityDetails.$Singleton)
+                                    entity1[temp1].$Singleton = entityDetails.$Singleton;
+                                if (entityDetails.$SingletonNullable)
+                                    entity1[temp1].$SingletonNullable = entityDetails.$SingletonNullable;
                                 parserContext.entityTypes.push(entity1);
                             }
                         } else {
                             temp = parserContext.namespace + '.' + parserContext.entitySetToEntityTypeMap.get(entityTypeName);
                             entity[temp] = schemaData[entityType];
+                            let entityDetails = schemaData[parserContext.jsonEntityContainerName][parserContext.entitySetToEntityTypeMap.get(entityTypeName)];
+                            if (entityDetails.$Singleton)
+                                entity[temp].$Singleton = entityDetails.$Singleton;
+                            if (entityDetails.$SingletonNullable)
+                                entity[temp].$SingletonNullable = entityDetails.$SingletonNullable;
                             parserContext.entityTypes.push(entity);
                         }
                     } else {
@@ -469,6 +495,29 @@ function _collectEnumType(schemaDataList, parserContext) {
         schemaData = schemaDataList[i];
         parserContext.enumTypes = _generateEnumType(schemaData, parserContext);
     }
+    return parserContext.enumTypes;
+}
+
+function _generateCSNForEnumType(schemaData, parserContext) {
+    let enumCsn = {};
+    let eTypes;
+    eTypes = _collectEnumType(schemaData, parserContext);
+    Object.keys(eTypes).forEach(element => {
+        enumCsn[element] = {};
+        enumCsn[element].enum = {};
+        enumCsn[element].type = eTypes[element].$Type != null ? edmxncdsdatatype[eTypes[element].$Type] : 'cds.LargeString';
+        Object.keys(eTypes[element]).forEach(property => {
+            if (property != "$Kind" && property != "$Type") {
+                if (enumCsn[element].type == 'cds.LargeString') {
+                    enumCsn[element].enum[property] = cds.parse.expr(`'${(eTypes[element][property])}'`);
+                }
+                else {
+                    enumCsn[element].enum[property] = cds.parse.expr(`${(eTypes[element][property])}`);
+                }
+            }
+        });
+    });
+    return enumCsn;
 }
 
 function _generateTypeDefinition(schemaData, parserContext) {
@@ -505,8 +554,8 @@ function _generateBounded(schemaData, flag, parserContext) {
         kindString = 'Action';
     }
     Object.keys(schemaData).forEach(curFunction => {
-        if (schemaData[curFunction] instanceof Array && 
-            schemaData[curFunction][0].$Kind === kindString && 
+        if (schemaData[curFunction] instanceof Array &&
+            schemaData[curFunction][0].$Kind === kindString &&
             schemaData[curFunction][0].$IsBound === true
         ) {
             boundedFunction = [];
@@ -698,6 +747,7 @@ function _generateCSNForComplexType(schemaData, parserContext) {
     let cTypes;
     let propertyType;
     let baseType;
+    let enumType;
     cTypes = _collectComplexType(schemaData, parserContext);
     Object.keys(cTypes).forEach(element => {
         complexCsn[element] = {};
@@ -711,8 +761,8 @@ function _generateCSNForComplexType(schemaData, parserContext) {
         }
         Object.keys(cTypes[element]).forEach(property => { // cTypes[element][property].$Type.startsWith('Edm.')
             if (cTypes[element][property] instanceof Object) {
-                if (!cTypes[element][property].$Type || 
-                    edmxncdsdatatype[cTypes[element][property].$Type] || 
+                if (!cTypes[element][property].$Type ||
+                    edmxncdsdatatype[cTypes[element][property].$Type] ||
                     edmxncdsdatatype[cTypes[element][property].$Type + "_a"]
                 ) {
                     propertyType = cTypes[element][property];
@@ -720,6 +770,9 @@ function _generateCSNForComplexType(schemaData, parserContext) {
                 } else if (parserContext.complexTypes[cTypes[element][property].$Type]) {
                     propertyType = cTypes[element][property];
                     complexCsn[element].elements[property] = _generateComplexTypePropertyCsn(propertyType);
+                } else if (parserContext.enumTypes[cTypes[element][property].$Type]) {
+                    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));
@@ -738,7 +791,7 @@ function _parseTypeDefinition(parserContext) {
     Object.keys(parserContext.typeDefinitions).forEach(element => {
         typeDef[element] = {};
         typeDef[element].kind = 'type';
-        if (!parserContext.typeDefinitions[element].$Type || 
+        if (!parserContext.typeDefinitions[element].$Type ||
             edmxncdsdatatype[parserContext.typeDefinitions[element].$Type]
         ) {
             propertyType = parserContext.typeDefinitions[element];
@@ -873,7 +926,7 @@ function _generateCSN(edmxAsJson, ignorePersistenceSkip, mockServerUc, parserCon
         });
         Object.keys(entityContainer).forEach(data => {
             if (ignoreObjects.indexOf(data) === -1 && entityContainer[data] instanceof Object &&
-                entityContainer[data].$Type && entityContainer[data].$Collection) {
+                entityContainer[data].$Type && (entityContainer[data].$Collection || entityContainer[data].$Singleton)) {
                 parserContext.entitySetToEntityTypeMap.set(entityContainer[data].$Type, data);
             } else if (ignoreObjects.indexOf(data) === -1 && entityContainer[data] instanceof Object &&
                 entityContainer[data].$Action) {
@@ -905,12 +958,14 @@ function _generateCSN(edmxAsJson, ignorePersistenceSkip, mockServerUc, parserCon
     // Step 4: get all unbounded action & function
     csn.definitions = Object.assign(_parseUnbounded(schemaData, 0, parserContext), csn.definitions);
     csn.definitions = Object.assign(_parseUnbounded(schemaData, 1, parserContext), csn.definitions);
-    // Step 5: add entity container properties
+    // Step 5: get all enum types
+    csn.definitions = Object.assign(_generateCSNForEnumType(schemaData, parserContext), csn.definitions);
+    // Step 6: add entity container properties
     csn.definitions = Object.assign(_parseEntityContainer(csn.definitions, schemaData, parserContext, parserContext), csn.definitions);
-    // Step 6: get all bounded action & function
+    // Step 7: get all bounded action & function
     _parseBounded(csn.definitions, 0, parserContext);
     _parseBounded(csn.definitions, 1, parserContext);
-    // Step 7: get all annotations
+    // Step 8: get all annotations
     _generateDocumentation(edmxAsJson, schemaData, csn.definitions, parserContext);
 
     return JSON.stringify(csn, null, 4);
@@ -960,9 +1015,9 @@ function _checkAnnotationTarget(annotation, cdsDefs, str, no_of_terms, vocab, pa
             }
         }
         else if (annotation[0].includes("Container")) {
-            let path = annotation[0].substring(0,annotation[0].lastIndexOf('.'));
+            let path = annotation[0].substring(0, annotation[0].lastIndexOf('.'));
             let actualPath = checkEntitySetMap(path, parserContext);
-            _checkAnnotatationTerm(annotation, cdsDefs[actualPath], no_of_terms, str, vocab);  
+            _checkAnnotatationTerm(annotation, cdsDefs[actualPath], no_of_terms, str, vocab);
         }
     }
     else if (annotation[0].indexOf('(') === -1 && !(annotation[0].indexOf('/') === -1)) {
@@ -1058,7 +1113,7 @@ function _generateEDMX2JSON(edmx, name_space, parserContext) {
             // create converter
             const v4Conv = MetadataConverterFactory.createEdmxV40XmlToV40Json(name_space);
             v4Conv.execute(inputBuffer, (error, json, missingReferencedDocuments) => {
-                if (missingReferencedDocuments.length > 0) {
+                if (missingReferencedDocuments?.length > 0) {
                     console.log(missingReferencedDocuments); // eslint-disable-line no-console
                 }
                 if (_validateJSON(json, parserContext)) {
@@ -1075,7 +1130,7 @@ async function getEdmxv4CSN(edmx, ignorePersistenceSkip, mockServerUc, context)
     let csn;
     let edmjConverted;
     let name_space = []
-    
+
     const parserContext = {};
     _initialize(parserContext);
 
@@ -1083,7 +1138,7 @@ async function getEdmxv4CSN(edmx, ignorePersistenceSkip, mockServerUc, context)
         name_space.push(true);
     else
         name_space = context.namespaces;
-    
+
     if (_isJson(edmx)) {
         return new Promise(function getCsn(resolve, reject) {
             try {

package/lib/init/constants.js

@@ -1,6 +1,6 @@
 const os = require('os');
 
-const MAVEN_ARCHETYPE_VERSION = '1.27.1';
+const MAVEN_ARCHETYPE_VERSION = '1.28.0';
 
 const constants = {
     IS_WIN: (os.platform() === 'win32'),
@@ -14,12 +14,14 @@ const constants = {
     OPTION_JAVA: 'java',
     OPTION_HANA: 'hana',
     OPTION_XSUAA: 'xsuaa',
+    OPTION_DESTINATIONS: 'destinations',
     OPTION_MTA: 'mta',
     OPTION_MTX: 'mtx',
     OPTION_MULTITENANCY: 'multitenancy',
     OPTION_TOGGLES: 'toggles',
     OPTION_EXTENSIBILITY: 'extensibility',
     OPTION_AUDITLOG: 'auditlog',
+    OPTION_ENTERPRISE_MESSAGING: 'enterprise-messaging',
     OPTION_APPROUTER: 'approuter',
     OPTION_KIBANA_LOGGING: 'kibana-logging',
     OPTION_CF_MANIFEST: 'cf-manifest',
@@ -33,7 +35,6 @@ const constants = {
     OPTION_JAVA_PACKAGE: 'java:package',
     OPTION_JAVA_MVN: 'java:mvn',
     OPTION_HELM: 'helm',
-    OPTION_HELM_UPDATE: 'helm/update',
 
     // node enum
     PROJECT_TYPE: Object.freeze({ nodejs: 1, java: 2, unknown: 3 }),
@@ -78,7 +79,9 @@ constants.OPTIONS_PRIORITY = [
     constants.OPTION_XSUAA,
     constants.OPTION_HANA,
     constants.OPTION_AUDITLOG,
+    constants.OPTION_ENTERPRISE_MESSAGING,
     constants.OPTION_APPROUTER,
+    constants.OPTION_DESTINATIONS,
     constants.OPTION_SAMPLES,
     constants.OPTION_DATA,
     constants.OPTION_KIBANA_LOGGING,

package/lib/init/index.js

@@ -130,6 +130,8 @@ module.exports = class CDSGenerator {
         options._cmd = COMMAND_ADD;
         options.add = templates;
 
+        if (!templates) throw 'You must specify a facet to add to the project.'
+
         this._initialize(null, options);
         this._greetings(options._cmd);
 
@@ -231,13 +233,23 @@ module.exports = class CDSGenerator {
         this.logger.log();
     }
 
-    _createTemplate(clazz) {
+    async _createTemplate(filename) {
         try {
-            const TemplateClass = require(`./template/${clazz}`);
+            const TemplateClass = require(`./template/${filename}`);
             return new TemplateClass(this.projectPath, this);
         } catch (err) {
             if (err.code === 'MODULE_NOT_FOUND') {
-                throw new Error(`feature '${clazz}' not found. ${err}`);
+                const entries = (await this.fsUtil.readdir(path.join(__dirname, 'template')))
+                    .filter(entry =>
+                        !entry.startsWith('_') &&
+                        !entry.endsWith('.js') &&
+                        entry !== 'nodejs' &&
+                        entry !== 'java'
+                    );
+                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`);
+                process.exit(1);
             }
             throw err;
         }
@@ -247,7 +259,7 @@ module.exports = class CDSGenerator {
         const templates = new Map();
         for (const option of this.options.add) {
             if (!templates.has(option)) {
-                const template = this._createTemplate(option);
+                const template = await this._createTemplate(option);
 
                 if (await template.checkEnabled()) {
                     this.logger.debug(`Adding feature '${template.name}'`);

package/lib/init/template/_merging/registry-mta.js

@@ -54,6 +54,18 @@ const auditlog = {
     }]
 }
 
+const enterpriseMessaging = {
+    ref: 'enterprise-messaging-resource',
+    in: 'resources',
+    where: [{
+        property: 'type',
+        isEqualTo: 'org.cloudfoundry.managed-service',
+    }, {
+        property: 'parameters.service',
+        isEqualTo: 'enterprise-messaging',
+    }]
+}
+
 const kibanaLogging = {
     ref: 'cf-logging',
     in: 'resources',
@@ -264,6 +276,7 @@ module.exports = {
     approuter,
     xsuaa,
     auditlog,
+    enterpriseMessaging,
     hdbDeployer,
     hdiContainer,
     serviceManager,

package/lib/init/template/approuter/index.js

@@ -17,6 +17,15 @@ module.exports = class ApprouterTemplate extends TemplateBase {
         this.projectReader = new ProjectReader(this)
     }
 
+    async checkEnabled() {
+        const projectDescriptor = await this.projectReader.read(this.options)
+        const { hasMtaDeployment, hasHelmDeployment } = projectDescriptor.cap
+        if (hasHelmDeployment && !hasMtaDeployment) {
+            throw `'cds add approuter' is not available for Kyma yet`
+        }
+        return true
+    }
+
     async getDependencies() {
         return [OPTION_XSUAA]
     }

package/lib/init/template/auditlog/index.js

@@ -1,36 +1,55 @@
-const fs = require('fs');
-const path = require('path');
-const TemplateBase = require('../templateBase');
-const ProjectReader = require('../../util/projectReader');
-const { srvNode, srvJava, auditlog } = require('../_merging/registry-mta');
+const path = require('path')
+const TemplateBase = require('../templateBase')
+const ProjectReader = require('../../util/projectReader')
+const { srvNode, srvJava, auditlog } = require('../_merging/registry-mta')
+const cds = require('../../../cds'), { fs } = cds.utils
 
 module.exports = class AuditlogTemplate extends TemplateBase {
     constructor(projectPath, generator) {
-        super(projectPath, generator, __dirname);
-        this.projectReader = new ProjectReader(this);
-    }
-
-    async runDependentMerging() {
-        const projectDescriptor = await this.projectReader.read(this.options);
-        const { isNodejs } = projectDescriptor.cap;
-        const mtaYAMLPath = path.join(this.projectPath, 'mta.yaml');
-        if (!fs.existsSync(mtaYAMLPath)) return;
-        const srv = isNodejs ? srvNode : srvJava
-        await this.templateUtil.mergeYAML(
-            mtaYAMLPath,
-            `${__dirname}/files/mta.yaml.hbs`,
-            projectDescriptor,
-            {
-                additions: [srv, auditlog],
-                relationships: [{
-                    insert: [auditlog, 'name'],
-                    into: [srv, 'requires', 'name']
-                }]
-            }
-        );
+        super(projectPath, generator, __dirname)
+        this.projectReader = new ProjectReader(this)
     }
 
     async run() {
         await this.runDependentMerging()
     }
+
+    async runDependentMerging() {
+        const projectDescriptor = await this.projectReader.read(this.options)
+        const { isNodejs, hasMtaDeployment, hasHelmDeployment } = projectDescriptor.cap
+
+        if (hasMtaDeployment) {
+            const mtaYAMLPath = path.join(this.projectPath, 'mta.yaml')
+            const srv = isNodejs ? srvNode : srvJava
+            await this.templateUtil.mergeYAML(
+                mtaYAMLPath,
+                `${__dirname}/files/mta.yaml.hbs`,
+                projectDescriptor,
+                {
+                    additions: [srv, auditlog],
+                    relationships: [{
+                        insert: [auditlog, 'name'],
+                        into: [srv, 'requires', 'name']
+                    }]
+                }
+            )
+        }
+
+        if (hasHelmDeployment) {
+            await this.templateUtil.mergeYAML(
+                path.join(this.projectPath, 'chart', 'values.yaml'),
+                {
+                    srv: { bindings: {
+                        auditlog: { serviceInstanceName: 'auditlog' }
+                    }},
+                    auditlog: {
+                        serviceOfferingName: 'auditlog-api',
+                        servicePlanName: 'default'
+                    }
+                },
+                null, { forceOverwrite: true }
+            )
+            await fs.copy(path.join(__dirname, 'files', 'auditlog.yaml'), path.join(this.projectPath, 'chart', 'templates', 'auditlog.yaml'))
+        }
+    }
 }

package/lib/{k8s/connectivity/templates → init/template/connectivity/files}/connectivity-proxy-info.yaml

@@ -17,4 +17,4 @@ data:
   onpremise_proxy_rfc_port: "20001"
   onpremise_socks5_proxy_port: "20004"
   {{- end }}
-{{- end }}
+{{- end }}

package/lib/init/template/connectivity/files/connectivity.yaml

@@ -0,0 +1 @@
+{{- include "cap.service-instance" . }}

package/lib/init/template/connectivity/files/values.yaml.hbs

@@ -0,0 +1,26 @@
+---
+srv:
+  additionalVolumes:
+  - name: connectivity-secret
+    volumeMount:
+      mountPath: /bindings/connectivity
+      readOnly: true
+    projected:
+      sources:
+        - secret:
+            name: {{cap.appName}}-connectivity-binding
+            optional: false
+        - secret:
+            name: {{cap.appName}}-connectivity-binding
+            optional: false
+            items:
+              - key: token_service_url
+                path: url
+        - configMap:
+            name: {{cap.appName}}-connectivity-proxy-info
+            optional: false
+connectivity:
+  serviceOfferingName: connectivity
+  servicePlanName: connectivity_proxy
+  secretName: {{cap.appName}}-connectivity-binding
+  configMapName: {{cap.appName}}-connectivity-proxy-info