@sap/cds-dk 4.8.0 → 4.9.0

package/lib/import/v4parser.js

@@ -23,6 +23,7 @@ let actionImportToActionMap = new Multimap();
 let functionImportToFunctionMap = new Multimap();
 let validEdmDatatypes = ['Edm.DateTimeOffset'];
 let jsonEntityContainerName;
+let entityTypes = [];
 const ignoreObjects = ['$Reference']; // add all the objects that needs to be ignored for parsing.
 const { warn } = require('@sap/cds/bin/utils/term');
 
@@ -56,6 +57,20 @@ const edmxncdsdatatype = {
 	"Edm.DateTimeOffset_a" : "cds.Timestamp"
 };
 
+function _initialize() {
+    unboundedActions = {};
+    boundedActions = {};
+    unboundedFunctions = {};
+    boundedFunctions = {};
+    entityTypes = [];
+    namespace = "";
+    complexTypes = {};
+    enumTypes = {};
+    typeDefinitions = {};
+    jsonEntityContainerName = "";
+
+}
+
 function _isJson(edmx) {
     let isJson = false;
     try {
@@ -128,78 +143,82 @@ function _includeExternalNamespaceAnnotation(source,target){
     });
 }
 
-function _propertyWithItems(property) {
-    let items = {};
-    items["items"] = property;
-    return items;
+function _typeWithCollections(property, type, isCollection) {
+  if (isCollection === true) {
+    property.items = type;
+  } else {
+    Object.assign(property, type);
+  }
 }
 
 function generatePropertyCsn(propertyType, isPrimaryKey) {
     let property = {};
+    let typeProperties = {};
     if (isPrimaryKey) {
         property.key = true;
+        // primary key cannot be of type Collection
+        if (propertyType.$Collection)
+            throw new Error(messages.COLLECTION_IN_KEY);
     }
     _includeExternalNamespaceAnnotation(propertyType,property);
     // conditions have to be made
     if (propertyType.$MaxLength) {
         if (propertyType.$Type) {
-            property.type = edmxncdsdatatype[propertyType.$Type + '_m'];
+            typeProperties.type = edmxncdsdatatype[propertyType.$Type + '_m'];
         } else {
-            property.type = 'cds.String'; // if type is missing, then it is String type
+            typeProperties.type = 'cds.String'; // if type is missing, then it is String type
         }
-        property.length = propertyType.$MaxLength;
+        typeProperties.length = propertyType.$MaxLength;
     } else if(_isValidDataType(propertyType.$Type)) {
         if(propertyType.$Precision && propertyType.$Precision > 0)
         {
-            property.type = edmxncdsdatatype[propertyType.$Type + '_a'];
-            property["@odata.precision"] = propertyType.$Precision;
+            typeProperties.type = edmxncdsdatatype[propertyType.$Type + '_a'];
+            typeProperties["@odata.precision"] = propertyType.$Precision;
         } else {
-            property.type = edmxncdsdatatype[propertyType.$Type];
-            property["@odata.precision"] = 0;
+            typeProperties.type = edmxncdsdatatype[propertyType.$Type];
+            typeProperties["@odata.precision"] = 0;
         }
     } else if (propertyType.$Precision && !_isValidDataType(propertyType.$Type)) {
-        property.type = edmxncdsdatatype[propertyType.$Type + '_p'];
-        property.precision = propertyType.$Precision;
+        typeProperties.type = edmxncdsdatatype[propertyType.$Type + '_p'];
+        typeProperties.precision = propertyType.$Precision;
         if (propertyType.$Scale && propertyType.$Scale == 'variable') {
-            property.scale = propertyType.$Precision;
-            property.precision = propertyType.$Precision * 2;
+            typeProperties.scale = propertyType.$Precision;
+            typeProperties.precision = propertyType.$Precision * 2;
         } else {
-            property.scale = propertyType.$Scale;
+            typeProperties.scale = propertyType.$Scale;
         }
     } else if (edmxncdsdatatype[propertyType.$Type + "_a"]) {
-        property.type = edmxncdsdatatype[propertyType.$Type + "_a"];
+        typeProperties.type = edmxncdsdatatype[propertyType.$Type + "_a"];
     } else if (propertyType.$Type) {
-        property.type = edmxncdsdatatype[propertyType.$Type];
+        typeProperties.type = edmxncdsdatatype[propertyType.$Type];
     } else{
-        property.type = 'cds.LargeString'; // if type is missing, then it is String type
+        typeProperties.type = 'cds.LargeString'; // if type is missing, then it is String type
     }
 
     if (edmxncdsdatatype[propertyType.$Type + '_a']) {
-        property["@odata.type"] = propertyType.$Type;
+        typeProperties["@odata.type"] = propertyType.$Type;
     }
 
-    if (propertyType.$Collection == true) {
-        return _propertyWithItems(property);
-    }
+    _typeWithCollections(property, typeProperties, propertyType.$Collection);
 
     return property;
 }
 
 function _generateComplexTypePropertyCsn(propertyType) {
     let property = {};
-    property.type = propertyType.$Type;
-    if (propertyType.$Collection == true) {
-        return _propertyWithItems(property);
-    }
+    let type = {type : propertyType.$Type}
+    _typeWithCollections(property, type, propertyType.$Collection);
+    
     return property;
 }
 
 function _generateTypeDefinitionPropertyCsn(propertyType) {
     let property = {};
-    property.type = propertyType.$Type;
-    if (propertyType.$Collection == true) {
-        return _propertyWithItems(property);
-    }
+    let type = {type : propertyType.$Type}
+    
+    _includeExternalNamespaceAnnotation(propertyType,property);
+    _typeWithCollections(property, type, propertyType.$Collection);
+
     return property;
 }
 
@@ -267,7 +286,17 @@ function _parseAssociationProperty(foreignReference, associationNode, mockServer
     return associationProperty;
 }
 
-function _generateCSNForEntityType(entityTypes, ignorePersistenceSkip, mockServerUc) {
+function _getBaseTypeEntityName(baseType) {
+    const mappedResult = entitySetToEntityTypeMap.get(baseType);
+    // if one entity type has mapping to multiple entity sets, use the first entity set
+    if (mappedResult.length > 1) {
+        return namespace + '.' + mappedResult[0];
+    } else {
+        return namespace + '.' + mappedResult;
+    }
+}
+
+function _generateCSNForEntityType(ignorePersistenceSkip, mockServerUc) {
     let entityCsn = {};
     let keySet;
     let curKey;
@@ -288,6 +317,10 @@ function _generateCSNForEntityType(entityTypes, ignorePersistenceSkip, mockServe
             // inheritance
             if (baseType) {
                 entityCsn[key].includes = [];
+                // if the baseType has a mapping to an entity set use that
+                if (entitySetToEntityTypeMap && entitySetToEntityTypeMap.get(baseType)) {
+                    baseType = _getBaseTypeEntityName(baseType);
+                }
                 entityCsn[key].includes.push(baseType);
             }
             if (isAbstract) {
@@ -341,7 +374,7 @@ function _generateCSNForEntityType(entityTypes, ignorePersistenceSkip, mockServe
     return entityCsn;
 }
 
-function _generateEntityType(entityTypes, schemaData, mockServerUc) {
+function _generateEntityType(schemaData, mockServerUc) {
     let entity = {};
     let temp;
     Object.keys(schemaData).forEach(entityType => {
@@ -381,19 +414,20 @@ function _generateEntityType(entityTypes, schemaData, mockServerUc) {
 
 function _parseEntityType(schemaDataList, ignorePersistenceSkip, mockServerUc) {
     // collect entity types
-    let entityTypes = [];
     let schemaData;
     for (let i = 0; i < schemaDataList.length; i++) {
         schemaData = schemaDataList[i];
-        _generateEntityType(entityTypes, schemaData, mockServerUc);
+        _generateEntityType(schemaData, mockServerUc);
     }
-    return _generateCSNForEntityType(entityTypes, ignorePersistenceSkip, mockServerUc);
+    return _generateCSNForEntityType(ignorePersistenceSkip, mockServerUc);
 }
 function _parseEntityContainer(entityCSN, schemaData){
-    Object.entries(schemaData[0]['EntityContainer']).forEach(entry => {
+    Object.entries(schemaData[0][jsonEntityContainerName]).forEach(entry => {
         if(entityCSN[namespace + '.' + entry[0]])
+            //Captured the annotations at entity set and entity type name level
             _includeExternalNamespaceAnnotation(entry[1],entityCSN[namespace + '.' + entry[0]]);
         if(entry[0].startsWith('@')){
+            //Captured the annotations at entity container name level
             entityCSN[namespace][entry[0]]= entry[1];
         }
     });
@@ -497,6 +531,10 @@ function _getDatatype(datatype) {
             if (namespace + "." + entitySetToEntityTypeMap.get(element) === datatype)
                 type = datatype;
         }
+        entityTypes.forEach(entity =>{
+            if(entity[datatype])
+                type = datatype;
+        })
     }
 
     //will return undefined if type is not supported
@@ -546,8 +584,9 @@ function _parseBounded(csnDefs, flag) {
                             for (let i = 1; i < obj[j].$Parameter.length; i++) {
                                 paramObj = obj[j].$Parameter[i];
                                 paramName = obj[j].$Parameter[i].$Name;
-                                let paramType ={};
-                                _includeExternalNamespaceAnnotation(paramObj,paramType);
+                                let paramType = {};
+                                let annotations = {};
+                                _includeExternalNamespaceAnnotation(paramObj,annotations);
                                 //check if the parameter type is pre-defined, undefined or custom defined
                                 if (edmxncdsdatatype[paramObj.$Type] || edmxncdsdatatype[paramObj.$Type + "_a"])
                                     paramType = generatePropertyCsn(paramObj, false);
@@ -555,17 +594,23 @@ function _parseBounded(csnDefs, flag) {
                                     let type = _getDatatype(paramObj.$Type);
                                     if(type) paramType["type"] = type;
                                 }
-                                if (paramType.type || paramType.items.type) {
-                                    // check if parameter type is a collection
-                                    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] = paramType;
-                                } else {
+                                if(Object.keys(paramType).length > 0) 
+                                {
+                                    if (paramType.type || paramType.items.type) {
+                                        // check if parameter type is a collection
+                                        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] = paramType;
+                                    } 
+                                }
+                                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);
                             }                             
                         }
                     }
@@ -575,26 +620,31 @@ function _parseBounded(csnDefs, flag) {
                     }
                     // add returns
                     if (obj[j].$ReturnType) {
-                        let 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);
-                            _includeExternalNamespaceAnnotation(obj[j].$ReturnType,returnType);
+                            _includeExternalNamespaceAnnotation(obj[j].$ReturnType,annotations);
                             if(type) returnType["type"] = type ;
                         }
-                        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;
-                            else
-                                csnDefs[boundedEntityName].actions[name].returns = returnType;
-                        } else {
+                        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;
+                                else
+                                    csnDefs[boundedEntityName].actions[name].returns = returnType;
+                            } 
+                        }   else {
                             let message = '"' + obj[j].$ReturnType.$Type + '" is not supported (in return type)'; 
                             console.log(warn(message));
                         }
+                        if(csnDefs[boundedEntityName].actions[name].returns)
+                            Object.assign(csnDefs[boundedEntityName].actions[name].returns, annotations)
                     }
                 }
             }
@@ -647,14 +697,14 @@ function _generateCSNForComplexType(schemaData) {
                 if (!cTypes[element][property].$Type || edmxncdsdatatype[cTypes[element][property].$Type] || edmxncdsdatatype[cTypes[element][property].$Type + "_a"]) {
                     propertyType = cTypes[element][property];
                     complexCsn[element].elements[property] = generatePropertyCsn(propertyType, false);
+                } else if (complexTypes[cTypes[element][property].$Type]) {
+                    propertyType = cTypes[element][property];
+                    complexCsn[element].elements[property] = _generateComplexTypePropertyCsn(propertyType);
                 } else {
-                    let message = '"' + cTypes[element][property].$Type + '" is not supported (in element:"' + property + '")'; 
+                    let message = '"' + cTypes[element][property].$Type + '" is not supported (in element:"' + property + '")';
                     console.log(warn(message));
                 }
-            } else if (complexTypes[cTypes[element][property].$Type]) {
-                propertyType = cTypes[element][property];
-                complexCsn[element].elements[property] = _generateComplexTypePropertyCsn(propertyType);
-            } else if(property.startsWith("@")){
+            } else if (property.startsWith("@")) {
                 complexCsn[element][property] = cTypes[element][property];
             }
         });
@@ -702,33 +752,33 @@ function _parseUnbounded(schemaData, flag) {
                 _includeExternalNamespaceAnnotation(objData,obj[objType]);
                 // add params
                 if (objData.$Parameter && objData.$Parameter.length > 0) {
-                    obj[objType].params = {};
-                    let type = {};   
+                    obj[objType].params = {};   
                     for (let i = 0; i < objData.$Parameter.length; i++) {
-                        let typeProperties = {};
-                        _includeExternalNamespaceAnnotation(objData.$Parameter[i],typeProperties);
+                        let paramType = {};
+                        let annotations = {};
+                        _includeExternalNamespaceAnnotation(objData.$Parameter[i], annotations);
                         // check if the parameter type is pre-defined, undefined or custom defined
                         if (edmxncdsdatatype[objData.$Parameter[i].$Type] || edmxncdsdatatype[objData.$Parameter[i].$Type + "_a"]) {
-                            const parameterProperties = generatePropertyCsn(objData.$Parameter[i], false);
-                            ({type, ...typeProperties} = parameterProperties);
+                            paramType = generatePropertyCsn(objData.$Parameter[i],false)
                         } else {
-                            type = _getDatatype(objData.$Parameter[i].$Type);
+                            let type = _getDatatype(objData.$Parameter[i].$Type);
+                            if(type) paramType["type"] = type;
                         }
-                        if (type) {
-                            // Adds type properties like scale, precision, etc if any
-                            const parameterObj = Object.keys(typeProperties).length > 0 ? { type, ...typeProperties } : { type };
-
-                            // check if parameter type is a collection
-                            if (objData.$Parameter[i].$Collection && !parameterObj.items) {
-                                obj[objType].params[objData.$Parameter[i].$Name] = {};
-                                obj[objType].params[objData.$Parameter[i].$Name].items = parameterObj;
-                            } else
-                                obj[objType].params[objData.$Parameter[i].$Name] = parameterObj;
-
-                        } else {
+                        if(Object.keys(paramType).length > 0){
+                            if (paramType.type || paramType.items.type) {
+                                // check if parameter type is a collection
+                                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] = paramType;
+                            } 
+                        }else {
                             let message = '"' + objData.$Parameter[i].$Type + '" is not supported (in element:"' + temp + '")'; 
                             console.log(warn(message));
                         }
+                        if(obj[objType].params[objData.$Parameter[i].$Name])
+                            Object.assign(obj[objType].params[objData.$Parameter[i].$Name], annotations)
                     }
                 }
                 //if parameters has no entries
@@ -738,26 +788,32 @@ function _parseUnbounded(schemaData, flag) {
                 // add returns
                 if (objData.$ReturnType && Object.keys(objData.$ReturnType).length > 0 && obj) {
                     let returnValue = {};
+                    let annotations = {};
                     // check if the return type is pre-defined, undefined or custom defined
                     if (edmxncdsdatatype[objData.$ReturnType.$Type] || edmxncdsdatatype[objData.$ReturnType.$Type + "_a"]) {
                         returnValue = generatePropertyCsn(objData.$ReturnType, false);
                     } else {
                         let type = _getDatatype(objData.$ReturnType.$Type);
-                        _includeExternalNamespaceAnnotation(objData.$ReturnType,returnValue);
+                        _includeExternalNamespaceAnnotation(objData.$ReturnType,annotations);
                         if(type) returnValue["type"] = type;
                     }
-                    if (returnValue.type || returnValue.items.type) {
-                        obj[objType].returns = {};
-                        // check if return type is a collection
-                        if (objData.$ReturnType.$Collection && !returnValue.items) {
-                            obj[objType].returns.items = {};
-                            obj[objType].returns.items = returnValue;
-                        } else
-                            obj[objType].returns = returnValue;
-                    } else {
+                    if(Object.keys(returnValue).length > 0){
+                        if (returnValue.type || returnValue.items.type) {
+                            obj[objType].returns = {};
+                            // check if return type is a collection
+                            if (objData.$ReturnType.$Collection && !returnValue.items) {
+                                obj[objType].returns.items = {};
+                                obj[objType].returns.items = returnValue;
+                            } else
+                                obj[objType].returns = returnValue;
+                        }
+                    } 
+                    else {
                         let message = '"' + objData.$ReturnType.$Type + '" is not supported (in return type of' + temp + ')'; 
                         console.log(warn(message));
                     }
+                    if(obj[objType].returns)
+                        Object.assign(obj[objType].returns, annotations);
                 }
             }
             unboundedObj = Object.assign(unboundedObj, obj);
@@ -769,10 +825,6 @@ function _parseUnbounded(schemaData, flag) {
 function _generateCSN(edmxAsJson, ignorePersistenceSkip, mockServerUc) {
     let csn = {};
     let schemaData = [];
-    unboundedActions = {};
-    boundedActions = {};
-    unboundedFunctions = {};
-    boundedFunctions = {};
     csn.meta = {};
     csn.meta.creator = 'cds-dk ' + versionInfo;
     csn.$version = '2.0';
@@ -825,12 +877,12 @@ function _generateCSN(edmxAsJson, ignorePersistenceSkip, mockServerUc) {
     // Step 1: get all complex types.
     csn.definitions = Object.assign(_generateCSNForComplexType(schemaData), csn.definitions);
     // Step 2: get all type definition
-    csn.definitions = Object.assign(_parseTypeDefinition(), csn.definitions);
-    // Step 3: get all unbounded action & function
+    csn.definitions = Object.assign(_parseTypeDefinition(), csn.definitions); 
+    // Step 3: get all entity type
+    csn.definitions = Object.assign(_parseEntityType(schemaData, ignorePersistenceSkip, mockServerUc), csn.definitions);
+    // Step 4: get all unbounded action & function
     csn.definitions = Object.assign(_parseUnbounded(schemaData, 0), csn.definitions);
     csn.definitions = Object.assign(_parseUnbounded(schemaData , 1), csn.definitions);
-    // Step 4: get all entity type
-    csn.definitions = Object.assign(_parseEntityType(schemaData, ignorePersistenceSkip, mockServerUc), csn.definitions);
     // Step 5: add entity container properties
     csn.definitions = Object.assign(_parseEntityContainer(csn.definitions,schemaData),csn.definitions);
     // Step 6: get all bounded action & function
@@ -948,6 +1000,7 @@ function getEdmxv4CSN(edmx, ignorePersistenceSkip, mockServerUc, context) {
     let csn;
     let edmjConverted;
     let name_space = []
+    _initialize();
     if(context.include_all_namespaces === true)
     {
         name_space.push(true);

package/lib/init/constants.js

@@ -1,6 +1,6 @@
 const os = require('os');
 
-const MAVEN_ARCHETYPE_VERSION = '1.21.0';
+const MAVEN_ARCHETYPE_VERSION = '1.22.2';
 
 const constants = {
     IS_WIN: (os.platform() === 'win32'),
@@ -18,6 +18,7 @@ const constants = {
     OPTION_MTX: 'mtx',
     OPTION_AUDITLOG: 'auditlog',
     OPTION_APPROUTER: 'approuter',
+    OPTION_KIBANA_LOGGING: 'kibana-logging',
     OPTION_CF_MANIFEST: 'cf-manifest',
     OPTION_PIPELINE: 'pipeline',
     OPTION_SAMPLES: 'samples',
@@ -53,7 +54,9 @@ const constants = {
     PROJECT_FILES: ['package.json', 'pom.xml', '.cdsrc.json'],
 
     KIND_SQL: 'sql',
-    KIND_HANA: 'hana'
+    KIND_HANA: 'hana',
+    KIND_HANA_CLOUD: 'hana-cloud',
+    KIND_HANA_MT: 'hana-mt'
 }
 
 constants.OPTIONS_PRIORITY = [
@@ -68,6 +71,7 @@ constants.OPTIONS_PRIORITY = [
     constants.OPTION_AUDITLOG,
     constants.OPTION_APPROUTER,
     constants.OPTION_SAMPLES,
+    constants.OPTION_KIBANA_LOGGING,
     constants.OPTION_NOTEBOOK,
     constants.OPTION_LINT,
     constants.OPTION_LINT_CUSTOM,

package/lib/init/index.js

@@ -7,7 +7,7 @@ const Spinner = require('./util/spinner');
 
 const { OPTIONS_PRIORITY, COMMAND_ADD, COMMAND_INIT,
     // eslint-disable-next-line no-unused-vars
-    OPTION_XSUAA, OPTION_AUDITLOG, OPTION_HANA, OPTION_MTA, OPTION_MTX, OPTION_APPROUTER,
+    OPTION_XSUAA, OPTION_AUDITLOG, OPTION_HANA, OPTION_MTA, OPTION_MTX, OPTION_APPROUTER, OPTION_KIBANA_LOGGING,
     OPTION_NODEJS, OPTION_JAVA,
     OPTION_PIPELINE, OPTION_SAMPLES, OPTION_CF_MANIFEST, PROJECT_FILES, REGEX_PROJECT_NAME } = require('./constants');
 
@@ -105,7 +105,8 @@ module.exports = class CDSGenerator {
                     OPTION_PIPELINE,
                     OPTION_CF_MANIFEST,
                     OPTION_MTA,
-                    OPTION_SAMPLES
+                    OPTION_SAMPLES,
+                    OPTION_KIBANA_LOGGING
                 ],
                 multiple: true,
                 promptOrder: 10 // used to identify ui prompts

package/lib/init/template/_merging/existences.js

@@ -60,6 +60,22 @@ const auditlog = {
     spaceBefore: true
 }
 
+const kibanaLogging = {
+    ref: "cf-logging",
+    keyPath: ["resources"],
+    constraints: [{
+        comparisonKeyPath: ["type"],
+        value: "org.cloudfoundry.managed-service",
+    }, {
+        comparisonKeyPath: ["parameters", "service"],
+        value: "application-logs",
+    }, {
+        comparisonKeyPath: ["parameters", "service-plan"],
+        value: "lite",
+    }],
+    spaceBefore: true
+}
+
 const hdbDeployer = {
     ref: "deployer",
     keyPath: ["modules"],
@@ -71,7 +87,7 @@ const hdbDeployer = {
 }
 
 const hdiContainer = {
-    ref: "db-resource",
+    ref: "hdi-container-resource",
     keyPath: ["resources"],
     constraints: [{
         comparisonKeyPath: ["type"],
@@ -81,7 +97,7 @@ const hdiContainer = {
 }
 
 const serviceManager = {
-    ref: "db-resource",
+    ref: "service-manager-resource",
     keyPath: ["resources"],
     constraints: [{
         comparisonKeyPath: ["type"],
@@ -131,9 +147,10 @@ const mtxSidecar = {
         comparisonKeyPath: ["type"],
         value: `nodejs`
     }],
+    spaceBefore: true
 }
 
-const mtxAPI = {
+const providedMtxAPI = {
     ref: "provided-mtx-api",
     keyPath: ["provides"],
     constraints: [{
@@ -145,6 +162,59 @@ const mtxAPI = {
     }]
 }
 
+const requiredMtxAPI = {
+    ref: "required-mtx-api",
+    in: approuter,
+    keyPath: ["requires"],
+    constraints: [{
+        comparisonKeyPath: ["properties", "name"],
+        value: "mtx-api"
+    }, {
+        comparisonKeyPath: ["properties", "url"],
+        value: "~{mtx-url}"
+    }]
+}
+
+const providedMtxSidecarAPI = {
+    ref: "provided-mtx-sidecar-api",
+    in: mtxSidecar,
+    keyPath: ["requires"],
+    constraints: [{
+        comparisonKeyPath: ["properties", "url"],
+        value: "${default-url}"
+    }]
+}
+
+const requiredMtxSidecarAPI = {
+    ref: "required-mtx-sidecar-api",
+    in: srvJava,
+    keyPath: ["requires"],
+    constraints: [{
+        comparisonKeyPath: ["properties", "CDS_MULTITENANCY_SIDECAR_URL"],
+        value: "~{url}"
+    }]
+}
+
+const requiredJavaApprouterAPI = {
+    ref: "required-java-approuter-api",
+    in: srvJava,
+    keyPath: ["requires"],
+    constraints: [{
+        comparisonKeyPath: ["properties", "CDS_MULTITENANCY_APPUI_URL"],
+        value: "~{url}"
+    }]
+}
+
+const providedJavaApprouterAPI = {
+    ref: "provided-java-approuter-api",
+    in: approuter,
+    keyPath: ["requires"],
+    constraints: [{
+        comparisonKeyPath: ["properties", "url"],
+        value: "${default-url}"
+    }]
+}
+
 module.exports = {
     srvNode,
     srvJava,
@@ -157,5 +227,11 @@ module.exports = {
     saasRegistry,
     srvAPI,
     mtxSidecar,
-    mtxAPI
+    providedMtxAPI,
+    requiredMtxAPI,
+    providedMtxSidecarAPI,
+    requiredMtxSidecarAPI,
+    requiredJavaApprouterAPI,
+    providedJavaApprouterAPI,
+    kibanaLogging
 }

package/lib/init/template/approuter/files/cds.cdsrc.json

@@ -0,0 +1,7 @@
+{
+  "requires": {
+    "approuter": {
+      "kind": "cloudfoundry"
+    }
+  }
+}

package/lib/init/template/approuter/files/cds.cdsrc.json.hbs

@@ -0,0 +1,9 @@
+{
+  "requires": {
+    "[{{cap.for}}]": {
+      "approuter": {
+        "kind": "cloudfoundry"
+      }
+    }
+  }
+}

package/lib/init/template/approuter/files/cds.package.json

@@ -0,0 +1,9 @@
+{
+  "cds": {
+    "requires": {
+      "approuter": {
+        "kind": "cloudfoundry"
+      }
+    }
+  }
+}