@sap/cds-dk 6.0.3 → 6.1.2

package/lib/import/odata/v2parser.js

@@ -448,38 +448,63 @@ function _getServiceEntityProperty(
 		propertyJson = propertyJson + '"key": true,\n';
 	}
 	if (isCollection === 1) {
-		propertyJson = propertyJson + '"items": { \n'
-	}
-	propertyJson = propertyJson + '"type":"' + cdsDataType + '"';
+		//if annotations to be added
+		if (edmxncdsdatatype[dataType + "_a"] && cdsDataType != "cds.Date") {
+			if (dataType === 'Edm.Stream') 
+				propertyJson = propertyJson + '"@Core.MediaType": "application/octet-stream",\n';
+			else 
+				propertyJson = propertyJson + '"@odata.Type": "' + dataType + '",\n';
+		}
 
-	//if annotations to be added
-	if (edmxncdsdatatype[dataType + "_a"] && cdsDataType != "cds.Date") {
-		if (dataType === 'Edm.Stream') 
-			propertyJson = propertyJson + ',\n"@Core.MediaType": "application/octet-stream"';
-		else 
-			propertyJson = propertyJson + ',\n"@odata.Type": "' + dataType + '"';
-	}
+		//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 (length && length > 0) {
-		propertyJson = propertyJson + ',\n"length":' + length;
-	} else if (precision && precision > 0 && hasInvalidPrecision === false) {
-		propertyJson = propertyJson + ',\n"precision":' + precision;
-		if (scale && scale > 0) {
-			propertyJson = propertyJson + ',\n"scale":' + scale;
-		} else {
-			propertyJson = propertyJson + ',\n"scale":' + 0;
+		propertyJson = propertyJson + '"items": { \n'
+		propertyJson = propertyJson + '"type":"' + cdsDataType + '"';
+		
+		if (length && length > 0) {
+			propertyJson = propertyJson + ',\n"length":' + length;
+		} else if (precision && precision > 0 && hasInvalidPrecision === false) {
+			propertyJson = propertyJson + ',\n"precision":' + precision;
+			if (scale && scale > 0) {
+				propertyJson = propertyJson + ',\n"scale":' + scale;
+			} else {
+				propertyJson = propertyJson + ',\n"scale":' + 0;
+			}
 		}
+		propertyJson = propertyJson + '\n}'
 	}
+	else{
+		propertyJson = propertyJson + '"type":"' + cdsDataType + '"';
+			//if annotations to be added
+		if (edmxncdsdatatype[dataType + "_a"] && cdsDataType != "cds.Date") {
+			if (dataType === 'Edm.Stream') 
+				propertyJson = propertyJson + ',\n"@Core.MediaType": "application/octet-stream"';
+			else 
+				propertyJson = propertyJson + ',\n"@odata.Type": "' + dataType + '"';
+		}
 
-	//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 (length && length > 0) {
+			propertyJson = propertyJson + ',\n"length":' + length;
+		} else if (precision && precision > 0 && hasInvalidPrecision === false) {
+			propertyJson = propertyJson + ',\n"precision":' + precision;
+			if (scale && scale > 0) {
+				propertyJson = propertyJson + ',\n"scale":' + scale;
+			} else {
+				propertyJson = propertyJson + ',\n"scale":' + 0;
+			}
+		}
 
-	if (isCollection === 1) {
-		propertyJson = propertyJson + '\n}'
+		//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 (documentation != -1 && documentation) {
 		propertyJson = propertyJson + ',\n"doc":"' + documentation + '"';
 	}
@@ -1143,7 +1168,6 @@ function _getCSNAssociatedEntitySet(
 ) {
 	let associationSet = parserContext.allAssociationSets[relationshipName];
 	if (associationSet === undefined) {
-		console.log(relationshipName + " " + parserContext.serviceNamespace);
 		throw new Error(messages.MISSING_ASSOCIATION_SETS);
 	}
 	let associationName = associationSet.Name;

package/lib/import/odata/v4parser.js

@@ -43,6 +43,27 @@ const edmxncdsdatatype = {
     "Edm.DateTimeOffset_a": "cds.Timestamp",
 };
 
+const known_vocabularies = {
+    'Org.OData.Authorization.V1': 'Authorization',
+    'Org.OData.Aggregation.V1': 'Aggregation',
+    'Org.OData.Core.V1': 'Core',
+    'Org.OData.Capabilities.V1': 'Capabilities',
+    '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',
+    'com.sap.vocabularies.Communication.v1': 'Communication',
+    'com.sap.vocabularies.Graph.v1': 'Graph',
+    'com.sap.vocabularies.HTML5.v1': 'HTML5',
+    'com.sap.vocabularies.ODM.v1': 'ODM',
+    'com.sap.vocabularies.PersonalData.v1': 'PersonalData',
+    'com.sap.vocabularies.Session.v1': 'Session',
+    'com.sap.vocabularies.UI.v1': 'UI',
+};
+
 function _initialize(parserContext) {
     parserContext.unboundedActions = {};
     parserContext.boundedActions = {};
@@ -117,6 +138,13 @@ function _includeExternalNamespaceAnnotation(source, target) {
 
 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("@")){
+                property[typeKeys[i]] = type[typeKeys[i]];
+                delete type[typeKeys[i]];
+            }
+        }
         property.items = type;
     } else {
         Object.assign(property, type);
@@ -883,7 +911,7 @@ function _generateCSN(edmxAsJson, ignorePersistenceSkip, mockServerUc, parserCon
     _parseBounded(csn.definitions, 0, parserContext);
     _parseBounded(csn.definitions, 1, parserContext);
     // Step 7: get all annotations
-    _generateDocumentation(schemaData, csn.definitions);
+    _generateDocumentation(edmxAsJson, schemaData, csn.definitions, parserContext);
 
     return JSON.stringify(csn, null, 4);
 }
@@ -892,7 +920,7 @@ function _replaceSpecialCharacters(text) {
     return text.replace(/(?:\\[rn]|[\r\n]+)+/gm, "\n").replace(/\s+/g, ' ').replace(/"/g, "&quot;").trim();
 }
 
-function _checkAnnotatationTerm(annotation, path, no_of_terms, targetString) {
+function _checkAnnotatationTerm(annotation, path, no_of_terms, targetString, vocab) {
     if (path) {
         if (targetString === "@Core.Description" && annotation[1]["@Core.Description"]) {
             if (path.doc === undefined)
@@ -903,60 +931,114 @@ function _checkAnnotatationTerm(annotation, path, no_of_terms, targetString) {
         else if (targetString === "@Core.LongDescription" && annotation[1]["@Core.LongDescription"]) {
             _generateLongDescription(annotation, path, no_of_terms);
         }
+        else if (vocab) {
+            if (vocab.includes(targetString.substring(targetString.indexOf('@') + 1, targetString.lastIndexOf('.')))) {
+                path[targetString] = annotation[1][targetString];
+            }
+        }
     }
 }
-function _checkAnnotationTarget(annotation, cdsDefs, str, no_of_terms) {
-    if (annotation[0].indexOf('/') === -1 && annotation[0].indexOf('(') === -1) {
-        if (annotation[0].endsWith(".EntityContainer")) {
-            let path = annotation[0].split(".")[0];
 
-            _checkAnnotatationTerm(annotation, cdsDefs[path], no_of_terms, str);
-        }
+function checkEntitySetMap(pathName, parserContext) {
+    if (parserContext.entitySetToEntityTypeMap.get(pathName) != null) {
+        pathName = parserContext.namespace + '.' + parserContext.entitySetToEntityTypeMap.get(pathName)[0];
+    }
+    return pathName;
+}
+
+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);
+            _checkAnnotatationTerm(annotation, cdsDefs[annotation[0]], no_of_terms, str, vocab);
+        }
+        if (annotation[0].indexOf('/') > 0) {
+            let path = annotation[0].split('/');
+            let temp = parserContext.namespace + '.' + path[1];
+            let path1 = checkEntitySetMap(temp, parserContext);
+            if (cdsDefs[path1]) {
+                _checkAnnotatationTerm(annotation, cdsDefs[path1], no_of_terms, str, vocab);
+            }
+        }
+        else if (annotation[0].includes("Container")) {
+            let path = annotation[0].substring(0,annotation[0].lastIndexOf('.'));
+            let actualPath = checkEntitySetMap(path, parserContext);
+            _checkAnnotatationTerm(annotation, cdsDefs[actualPath], no_of_terms, str, vocab);  
         }
-    } else if (annotation[0].indexOf('(') === -1 && !(annotation[0].indexOf('/') === -1)) {
+    }
+    else if (annotation[0].indexOf('(') === -1 && !(annotation[0].indexOf('/') === -1)) {
         let path = annotation[0].split('/');
-        if (cdsDefs[path[0]]) {
-            _checkAnnotatationTerm(annotation, cdsDefs[path[0]]["elements"][path[1]], no_of_terms, str);
+        let path1 = checkEntitySetMap(path[0], parserContext);
+        if (cdsDefs[path1]) {
+            _checkAnnotatationTerm(annotation, cdsDefs[path1]["elements"][path[1]], no_of_terms, str, vocab);
         }
     } else {
         let path = annotation[0].split('(');
-        if (cdsDefs[path[0]] == undefined) {
+        let actualPath = checkEntitySetMap(path[0], parserContext);
+        if (cdsDefs[actualPath] === undefined) {
             let temp = path[1].split(')');
             let path1 = temp[0].split(',');
             let path2 = path[0].split('.');
             if (cdsDefs[path1[0]]) {
-                _checkAnnotatationTerm(annotation, cdsDefs[path1[0]]["actions"][path2[1]], no_of_terms, str);
+                _checkAnnotatationTerm(annotation, cdsDefs[path1[0]]["actions"][path2[1]], no_of_terms, str, vocab);
             }
         } else {
             if (path[1].indexOf('/') === -1) {
-                _checkAnnotatationTerm(annotation, cdsDefs[path[0]], no_of_terms, str);
+                _checkAnnotatationTerm(annotation, cdsDefs[path[0]], no_of_terms, str, vocab);
             } else {
                 let path1 = path[1].split('/');
                 if (cdsDefs[path[0]] && cdsDefs[path[0]]["params"]) {
-                    _checkAnnotatationTerm(annotation, cdsDefs[path[0]]["params"][path1[1]], no_of_terms, str);
+                    _checkAnnotatationTerm(annotation, cdsDefs[path[0]]["params"][path1[1]], no_of_terms, str, vocab);
                 }
             }
         }
     }
 }
 
-function _generateDocumentation(schemaData, cdsDefs) {
+function _replaceSchemaDataAnnotation(vocabAlias, vocabNamespce, schemaDataAnnotation) {
+    for (let v in vocabAlias) {
+        if (schemaDataAnnotation.includes(vocabAlias[v])) {
+            schemaDataAnnotation = schemaDataAnnotation.split(vocabAlias[v]).join(known_vocabularies[vocabNamespce[v]]);
+        }
+        if (schemaDataAnnotation.includes(vocabNamespce[v])) {
+            schemaDataAnnotation = schemaDataAnnotation.split(vocabNamespce[v]).join(known_vocabularies[vocabNamespce[v]]);
+        }
+    }
+    return JSON.parse(schemaDataAnnotation);
+}
+
+function _generateDocumentation(edmxAsJson, schemaData, cdsDefs, parserContext) {
+    let vocabAlias = [];
+    let vocab = [];
+    let vocabNamespce = [];
     if (schemaData[0].$Annotations) {
-        Object.entries(schemaData[0].$Annotations).map(annotation => {
-            let no_of_terms;
-            // eslint-disable-next-line no-prototype-builtins
-            if (annotation[1].hasOwnProperty('@Core.Description')) {
+        if (edmxAsJson.$Reference) {
+            Object.entries(edmxAsJson.$Reference).forEach(a => {
+                if (known_vocabularies.hasOwnProperty(a[1].$Include[0].$Namespace)) {
+                    vocabAlias.push(a[1].$Include[0].$Alias);
+                    vocabNamespce.push(a[1].$Include[0].$Namespace);
+                    vocab.push(known_vocabularies[a[1].$Include[0].$Namespace])
+                }
+            });
+        }
 
-                no_of_terms = true;
-                _checkAnnotationTarget(annotation, cdsDefs, "@Core.Description", no_of_terms);
-            }
-            // eslint-disable-next-line no-prototype-builtins
-            if (annotation[1].hasOwnProperty('@Core.LongDescription')) {
-                _checkAnnotationTarget(annotation, cdsDefs, "@Core.LongDescription", no_of_terms);
+        schemaData[0].$Annotations = _replaceSchemaDataAnnotation(vocabAlias, vocabNamespce, JSON.stringify(schemaData[0].$Annotations));
 
-            }
+        Object.entries(schemaData[0].$Annotations).map(annotation => {
+            let no_of_terms;
+            Object.entries(annotation[1]).forEach(anno => {
+                if (vocab.includes(anno[0].substring(anno[0].indexOf('@') + 1, anno[0].lastIndexOf('.')))) {
+                    if (annotation[1].hasOwnProperty('@Core.Description')) {
+                        no_of_terms = true;
+                    }
+                    if (annotation[1].hasOwnProperty('@Common.FieldControl')) {
+                        annotation[1]["@Common.FieldControl"] = { "#": annotation[1]["@Common.FieldControl"] }
+                    }
+                    if (annotation[1].hasOwnProperty('@Common.IsUpperCase')) {
+                        annotation[1]["@Common.IsUpperCase"] = true;
+                    }
+                    _checkAnnotationTarget(annotation, cdsDefs, anno[0], no_of_terms, vocab, parserContext);
+                }
+            });
         });
     }
 }
@@ -969,7 +1051,6 @@ function _generateLongDescription(annotation, path, no_of_terms) {
     }
 }
 
-
 function _generateEDMX2JSON(edmx, name_space, parserContext) {
     return new Promise(function getJson(resolve, reject) {
         try {

package/lib/import/openapi/importOpenAPI.js

@@ -136,7 +136,7 @@ function operations(context, csn, input) {
 
                 if (param.explode && param.style !== "form")
                     cdsParam["@openapi.explode"] = true;
-                
+
                 if (param.explode === false &&
                     (param.style === "form" || (!param.style && param.in === "query"))
                 )
@@ -369,11 +369,11 @@ function cdsType(
                 if (arrayItem && jsonSchema !== "{}") {
                     type = anonymousType(context, {
                         type: "common.JSON",
-                        "@openapi.schema": jsonSchema,
+                        "@JSON.Schema": jsonSchema,
                     });
                 } else {
                     type.type = "common.JSON";
-                    if (jsonSchema !== "{}") type["@openapi.schema"] = jsonSchema;
+                    if (jsonSchema !== "{}") type["@JSON.Schema"] = jsonSchema;
                 }
             }
             break;

package/lib/init/constants.js

@@ -1,6 +1,6 @@
 const os = require('os');
 
-const MAVEN_ARCHETYPE_VERSION = '1.26.0';
+const MAVEN_ARCHETYPE_VERSION = '1.27.1';
 
 const constants = {
     IS_WIN: (os.platform() === 'win32'),
@@ -16,6 +16,9 @@ const constants = {
     OPTION_XSUAA: 'xsuaa',
     OPTION_MTA: 'mta',
     OPTION_MTX: 'mtx',
+    OPTION_MULTITENANCY: 'multitenancy',
+    OPTION_TOGGLES: 'toggles',
+    OPTION_EXTENSIBILITY: 'extensibility',
     OPTION_AUDITLOG: 'auditlog',
     OPTION_APPROUTER: 'approuter',
     OPTION_KIBANA_LOGGING: 'kibana-logging',
@@ -68,9 +71,12 @@ constants.OPTIONS_PRIORITY = [
     constants.OPTION_PIPELINE,
     constants.OPTION_MTA,
     constants.OPTION_CF_MANIFEST,
-    constants.OPTION_HANA,
-    constants.OPTION_XSUAA,
     constants.OPTION_MTX,
+    constants.OPTION_MULTITENANCY,
+    constants.OPTION_TOGGLES,
+    constants.OPTION_EXTENSIBILITY,
+    constants.OPTION_XSUAA,
+    constants.OPTION_HANA,
     constants.OPTION_AUDITLOG,
     constants.OPTION_APPROUTER,
     constants.OPTION_SAMPLES,

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

@@ -0,0 +1,284 @@
+// Registry of sequence matchers in mta.yaml files
+
+const srvNode = {
+    ref: 'srv',
+    in: 'modules',
+    where: [{
+        property: 'type',
+        isEqualTo: 'nodejs'
+    }],
+}
+
+const srvJava = {
+    ref: 'srv',
+    in: 'modules',
+    where: [{
+        property: 'type',
+        isEqualTo: 'java'
+    }],
+}
+
+const approuter = {
+    ref: 'approuter',
+    in: 'modules',
+    where: [{
+        property: 'type',
+        isEqualTo: 'approuter.nodejs'
+    }]
+}
+
+const xsuaa = {
+    ref: 'uaa-resource',
+    in: 'resources',
+    where: [{
+        property: 'type',
+        isEqualTo: 'org.cloudfoundry.managed-service',
+    }, {
+        property: 'parameters.service',
+        isEqualTo: 'xsuaa',
+    }, {
+        property: 'parameters.service-plan',
+        isEqualTo: 'application'
+    }]
+}
+
+const auditlog = {
+    ref: 'auditlog-resource',
+    in: 'resources',
+    where: [{
+        property: 'type',
+        isEqualTo: 'org.cloudfoundry.managed-service',
+    }, {
+        property: 'parameters.service',
+        isEqualTo: 'auditlog-api',
+    }]
+}
+
+const kibanaLogging = {
+    ref: 'cf-logging',
+    in: 'resources',
+    where: [{
+        property: 'type',
+        isEqualTo: 'org.cloudfoundry.managed-service',
+    }, {
+        property: 'parameters.service',
+        isEqualTo: 'application-logs',
+    }, {
+        property: 'parameters.service-plan',
+        isEqualTo: 'lite',
+    }]
+}
+
+const hdbDeployer = {
+    ref: 'deployer',
+    in: 'modules',
+    where: [{
+        property: 'type',
+        isEqualTo: 'hdb'
+    }]
+}
+
+const hdiContainer = {
+    ref: 'hdi-container-resource',
+    in: 'resources',
+    where: [{
+        property: 'type',
+        isEqualTo: 'com.sap.xs.hdi-container',
+    }]
+}
+
+const serviceManager = {
+    ref: 'service-manager-resource',
+    in: 'resources',
+    where: [{
+        property: 'type',
+        isEqualTo: 'org.cloudfoundry.managed-service',
+    }, {
+        property: 'parameters.service',
+        isEqualTo: 'service-manager',
+    }, {
+        property: 'parameters.service-plan',
+        isEqualTo: 'container'
+    }]
+}
+
+const saasRegistry = {
+    ref: 'registry-resource',
+    in: 'resources',
+    where: [{
+        property: 'type',
+        isEqualTo: 'org.cloudfoundry.managed-service',
+    }, {
+        property: 'parameters.service',
+        isEqualTo: 'saas-registry',
+    }, {
+        property: 'parameters.service-plan',
+        isEqualTo: 'application'
+    }]
+}
+
+const srvAPI = {
+    ref: 'srvAPI',
+    in: 'provides',
+    where: [{
+        property: 'name',
+        isEqualTo: 'srv-api'
+    }, {
+        property: 'properties.srv-url',
+        isEqualTo: '${default-url}'
+    }]
+}
+
+const mtxSidecar = {
+    ref: 'sidecar',
+    in: 'modules',
+    where: [{
+        property: 'type',
+        isEqualTo: `nodejs`
+    }, {
+        property: 'path',
+        isEqualTo: `mtx/sidecar`
+    }]
+}
+
+const providedMtxAPI = {
+    ref: 'provided-mtx-api',
+    in: 'provides',
+    where: [{
+        property: 'name',
+        isEqualTo: 'mtx-api'
+    }, {
+        property: 'properties.mtx-url',
+        isEqualTo: '${default-url}'
+    }]
+}
+
+const requiredMtxAPI = {
+    ref: 'required-mtx-api',
+    in: [approuter, 'requires'],
+    where: [{
+        property: 'properties.name',
+        isEqualTo: 'mtx-api'
+    }, {
+        property: 'properties.url',
+        isEqualTo: '~{mtx-url}'
+    }]
+}
+
+const providedAppAPI = {
+    ref: 'provided-app-api',
+    in: [approuter, 'provides'],
+    where: [{
+        property: 'name',
+        isEqualTo: 'app-api'
+    }, {
+        property: 'properties.app-protocol',
+        isEqualTo: '${protocol}'
+    }, {
+        property: 'properties.app-uri',
+        isEqualTo: '${default-uri}'
+    }],
+}
+
+const requiredAppAPI = {
+    ref: 'required-app-api',
+    in: [srvNode, 'requires'],
+    where: [{
+        property: 'name',
+        isEqualTo: 'app-api'
+    }, {
+        property: 'properties.SUBSCRIPTION_URL',
+        isEqualTo: '~{app-protocol}://\\${tenant_subdomain}-~{app-uri}'
+    }]
+}
+
+const providedMtxSidecarAPI = {
+    ref: 'provided-mtx-sidecar-api',
+    in: [mtxSidecar, 'provides'],
+    where: [{
+        property: 'properties.url',
+        isEqualTo: '${default-url}'
+    }]
+}
+
+const requiredMtxSidecarAPI = {
+    ref: 'required-mtx-sidecar-api',
+    in: [srvJava, 'requires'],
+    where: [{
+        property: 'properties.CDS_MULTITENANCY_SIDECAR_URL',
+        isEqualTo: '~{url}'
+    }]
+}
+
+const requiredJavaApprouterAPI = {
+    ref: 'required-java-approuter-api',
+    in: [srvJava, 'requires'],
+    where: [{
+        property: 'properties.CDS_MULTITENANCY_APPUI_URL',
+        isEqualTo: '~{url}'
+    }]
+}
+
+const providedJavaApprouterAPI = {
+    ref: 'provided-java-approuter-api',
+    in: [approuter, 'requires'],
+    where: [{
+        property: 'properties.url',
+        isEqualTo: '${default-url}'
+    }]
+}
+
+const approuterExtensibility = {
+    ref: 'approuter-extensibility',
+    in: 'routes',
+    where: [{
+        property: 'source',
+        isEqualTo: '^/-/cds/.*'
+    }, {
+        property: 'destination',
+        isEqualTo: 'mtx-api',
+    }, {
+        property: 'authenticationType',
+        isEqualTo: 'none',
+    }]
+}
+
+const approuterExtensibilityJava = {
+    ref: 'approuter-extensibility-java',
+    in: 'routes',
+    where: [{
+        property: 'source',
+        isEqualTo: '^/-/cds/.*'
+    }, {
+        property: 'destination',
+        isEqualTo: 'mtx-api',
+    }, {
+        property: 'authenticationType',
+        isEqualTo: 'none',
+    }]
+}
+
+module.exports = {
+    srvNode,
+    srvJava,
+    approuter,
+    xsuaa,
+    auditlog,
+    hdbDeployer,
+    hdiContainer,
+    serviceManager,
+    saasRegistry,
+    srvAPI,
+    mtxSidecar,
+    providedMtxAPI,
+    requiredMtxAPI,
+    providedMtxSidecarAPI,
+    requiredMtxSidecarAPI,
+    providedAppAPI,
+    requiredAppAPI,
+    requiredJavaApprouterAPI,
+    providedJavaApprouterAPI,
+    kibanaLogging,
+    approuterExtensibility,
+    approuterExtensibilityJava
+}

package/lib/init/template/approuter/files/xs-app.json.hbs

@@ -1,6 +1,13 @@
 {
   "authenticationMethod": "route",
   "routes": [
+    {{#cap.isMultitenant}}
+    {
+      "source": "^/-/cds/.*",
+      "destination": "mtx-api",
+      "authenticationType": "none"
+    },
+    {{/cap.isMultitenant}}
     {
       "source": "^/app/(.*)$",
       "target": "$1",
@@ -14,13 +21,6 @@
       "destination": "srv-api",
       "authenticationType": "xsuaa",
       "csrfProtection": true
-    }{{#cap.isMultitenant}},
-    {
-      "source": "^/extend/(.*)",
-      "destination": "mtx-api",
-      "target": "$1",
-      "authenticationType": "none"
     }
-    {{/cap.isMultitenant}}
   ]
 }