@sap/cds-dk 4.6.4 → 4.8.0

package/lib/import/v4parser.js

@@ -24,6 +24,8 @@ let functionImportToFunctionMap = new Multimap();
 let validEdmDatatypes = ['Edm.DateTimeOffset'];
 let jsonEntityContainerName;
 const ignoreObjects = ['$Reference']; // add all the objects that needs to be ignored for parsing.
+const { warn } = require('@sap/cds/bin/utils/term');
+
 const MetadataConverterFactory = require('../import/utils/MetadataConverterFactory');
 const edmxncdsdatatype = {
     'Edm.String': 'cds.LargeString',
@@ -32,7 +34,7 @@ const edmxncdsdatatype = {
     'Edm.Int32': 'cds.Integer',
     'Edm.Int64': 'cds.Integer64',
     'Edm.Decimal': 'cds.DecimalFloat',
-    'Edm.DateTimeOffset': 'cds.Timestamp',
+    'Edm.DateTimeOffset': 'cds.DateTime',
     'Edm.TimeOfDay': 'cds.Time',
     'Edm.Date': 'cds.Date',
     'Edm.Binary': 'cds.LargeBinary',
@@ -40,16 +42,18 @@ const edmxncdsdatatype = {
     'Edm.Byte': 'cds.Integer',
     'Edm.SByte': 'cds.Integer',
     'Edm.Double': 'cds.Double',
-    'Edm.Single': 'cds.DecimalFloat',
     // Special handling of data types
     'Edm.String_m': 'cds.String', // Max length
     'Edm.Decimal_p': 'cds.Decimal', // Precision, scale
-    'Edm.DateTime_f': 'cds.Date', // sap:display-format="Date"
-    'Edm.DateTimeOffset_f': 'cds.Date', // sap:display-format="Date"
+    //'Edm.DateTime_f': 'cds.Date', // sap:display-format="Date"
+    //'Edm.DateTimeOffset_f': 'cds.Date', // sap:display-format="Date"
     'Edm.Binary_m': 'cds.Binary', // Max Length
     'Edm.Byte_m': 'cds.Integer', // Max Length
-    'Edm.Double_p': 'cds.Double' // Precision, scale
-
+    'Edm.Double_p': 'cds.Double', // Precision, scale
+    // Special handling with annotations
+	"Edm.Single_a": "cds.Double",
+	"Edm.Stream_a" : "cds.LargeBinary",
+	"Edm.DateTimeOffset_a" : "cds.Timestamp"
 };
 
 function _isJson(edmx) {
@@ -117,12 +121,19 @@ function _validateJSON(jsonObj) {
 }
 
 function _includeExternalNamespaceAnnotation(source,target){
-    Object.entries(source).forEach(element =>{
-        if(element[0].startsWith('@')){
+    Object.entries(source).forEach(element => {
+        if (element[0].startsWith('@')) {
             target[element[0]] = element[1];
-            }
+        }
     });
 }
+
+function _propertyWithItems(property) {
+    let items = {};
+    items["items"] = property;
+    return items;
+}
+
 function generatePropertyCsn(propertyType, isPrimaryKey) {
     let property = {};
     if (isPrimaryKey) {
@@ -137,6 +148,15 @@ function generatePropertyCsn(propertyType, isPrimaryKey) {
             property.type = 'cds.String'; // if type is missing, then it is String type
         }
         property.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;
+        } else {
+            property.type = edmxncdsdatatype[propertyType.$Type];
+            property["@odata.precision"] = 0;
+        }
     } else if (propertyType.$Precision && !_isValidDataType(propertyType.$Type)) {
         property.type = edmxncdsdatatype[propertyType.$Type + '_p'];
         property.precision = propertyType.$Precision;
@@ -146,23 +166,40 @@ function generatePropertyCsn(propertyType, isPrimaryKey) {
         } else {
             property.scale = propertyType.$Scale;
         }
+    } else if (edmxncdsdatatype[propertyType.$Type + "_a"]) {
+        property.type = edmxncdsdatatype[propertyType.$Type + "_a"];
     } else if (propertyType.$Type) {
         property.type = edmxncdsdatatype[propertyType.$Type];
     } else{
         property.type = 'cds.LargeString'; // if type is missing, then it is String type
     }
+
+    if (edmxncdsdatatype[propertyType.$Type + '_a']) {
+        property["@odata.type"] = propertyType.$Type;
+    }
+
+    if (propertyType.$Collection == true) {
+        return _propertyWithItems(property);
+    }
+
     return property;
 }
 
 function _generateComplexTypePropertyCsn(propertyType) {
     let property = {};
     property.type = propertyType.$Type;
+    if (propertyType.$Collection == true) {
+        return _propertyWithItems(property);
+    }
     return property;
 }
 
 function _generateTypeDefinitionPropertyCsn(propertyType) {
     let property = {};
     property.type = propertyType.$Type;
+    if (propertyType.$Collection == true) {
+        return _propertyWithItems(property);
+    }
     return property;
 }
 
@@ -175,7 +212,8 @@ function _parseAssociationProperty(foreignReference, associationNode, mockServer
     let data;
     let ref;
     associationProperty.type = 'cds.Association';
-    associationProperty.doc = 'Please add an ON condition\n';
+    // annotation for ON condition
+    associationProperty["@cds.ambiguous"] = 'missing on condition?';
     // associationProperty.target = associationNode.$Type;
     if (mockServerUc && entitySetToEntityTypeMap && entitySetToEntityTypeMap.get(associationNode.$Type)) {
         if (entitySetToEntityTypeMap.get(associationNode.$Type).length > 1) {
@@ -267,7 +305,7 @@ function _generateCSNForEntityType(entityTypes, ignorePersistenceSkip, mockServe
                             for (j = 0; j < curKey.length; j++) {
                                 keySet.push(curKey[j]);
                             }
-                        } else if (!element[key][property].$Type || edmxncdsdatatype[element[key][property].$Type]) {
+                        } else if (!element[key][property].$Type || edmxncdsdatatype[element[key][property].$Type] || edmxncdsdatatype[element[key][property].$Type + "_a"]) {
                             propertyType = element[key][property];
                             if (keySet.includes(property)) {
                                 entityCsn[key].elements[property] = generatePropertyCsn(propertyType, true);
@@ -291,6 +329,9 @@ function _generateCSNForEntityType(entityTypes, ignorePersistenceSkip, mockServe
                             // for TypeDefinitions
                             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));
                         }
                     }
                 }
@@ -346,10 +387,18 @@ function _parseEntityType(schemaDataList, ignorePersistenceSkip, mockServerUc) {
         schemaData = schemaDataList[i];
         _generateEntityType(entityTypes, schemaData, mockServerUc);
     }
-    // parse it
     return _generateCSNForEntityType(entityTypes, ignorePersistenceSkip, mockServerUc);
 }
-
+function _parseEntityContainer(entityCSN, schemaData){
+    Object.entries(schemaData[0]['EntityContainer']).forEach(entry => {
+        if(entityCSN[namespace + '.' + entry[0]])
+            _includeExternalNamespaceAnnotation(entry[1],entityCSN[namespace + '.' + entry[0]]);
+        if(entry[0].startsWith('@')){
+            entityCSN[namespace][entry[0]]= entry[1];
+        }
+    });
+    return entityCSN;
+}
 function _generateEnumType(schemaData) {
     let enumTypeDict = {};
     let temp;
@@ -500,53 +549,56 @@ function _parseBounded(csnDefs, flag) {
                                 let paramType ={};
                                 _includeExternalNamespaceAnnotation(paramObj,paramType);
                                 //check if the parameter type is pre-defined, undefined or custom defined
-                                if (edmxncdsdatatype[paramObj.$Type])
+                                if (edmxncdsdatatype[paramObj.$Type] || edmxncdsdatatype[paramObj.$Type + "_a"])
                                     paramType = generatePropertyCsn(paramObj, false);
                                 else {
                                     let type = _getDatatype(paramObj.$Type);
                                     if(type) paramType["type"] = type;
                                 }
-                                if (paramType) {
+                                if (paramType.type || paramType.items.type) {
                                     // check if parameter type is a collection
-                                    if (paramObj.$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 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 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={};
+                        // 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);
+                            if(type) returnType["type"] = type ;
                         }
-                        // add returns
-                        if (obj[j].$ReturnType) {
-                            let returnType={};
-                            // check if the return type is pre-defined, undefined or custom defined
-                            if (edmxncdsdatatype[obj[j].$ReturnType.$Type])
-                                returnType = generatePropertyCsn(obj[j].$ReturnType, false);
-                            else {
-                                let type = _getDatatype(obj[j].$ReturnType.$Type);
-                                _includeExternalNamespaceAnnotation(obj[j].$ReturnType,returnType);
-                                if(type) returnType["type"] = type ;
-                            }
-                            if (returnType) {
-                                csnDefs[boundedEntityName].actions[name].returns = {};
-                                // check if return type is a collection
-                                if (obj[j].$ReturnType.$Collection)
-                                    csnDefs[boundedEntityName].actions[name].returns.items = returnType;
-                                else
-                                    csnDefs[boundedEntityName].actions[name].returns = returnType;
-                            }
+                        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));
                         }
                     }
                 }
             }
-        );
+        });
     }
 }
 
@@ -592,9 +644,12 @@ function _generateCSNForComplexType(schemaData) {
         }
         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];
                     complexCsn[element].elements[property] = generatePropertyCsn(propertyType, false);
+                } else {
+                    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];
@@ -653,50 +708,55 @@ function _parseUnbounded(schemaData, flag) {
                         let typeProperties = {};
                         _includeExternalNamespaceAnnotation(objData.$Parameter[i],typeProperties);
                         // check if the parameter type is pre-defined, undefined or custom defined
-                        if (edmxncdsdatatype[objData.$Parameter[i].$Type]) {
+                        if (edmxncdsdatatype[objData.$Parameter[i].$Type] || edmxncdsdatatype[objData.$Parameter[i].$Type + "_a"]) {
                             const parameterProperties = generatePropertyCsn(objData.$Parameter[i], false);
                             ({type, ...typeProperties} = parameterProperties);
                         } else {
                             type = _getDatatype(objData.$Parameter[i].$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)
+                            if (objData.$Parameter[i].$Collection && !parameterObj.items) {
+                                obj[objType].params[objData.$Parameter[i].$Name] = {};
                                 obj[objType].params[objData.$Parameter[i].$Name].items = parameterObj;
-                            else
+                            } else
                                 obj[objType].params[objData.$Parameter[i].$Name] = parameterObj;
 
+                        } else {
+                            let message = '"' + objData.$Parameter[i].$Type + '" is not supported (in element:"' + temp + '")'; 
+                            console.log(warn(message));
                         }
                     }
                 }
                 //if parameters has no entries
-                if(obj[objType].params && Object.keys(obj[objType].params).length === 0)
-                {
+                if (obj[objType].params && Object.keys(obj[objType].params).length === 0) {
                     delete obj[objType].params;
                 }
                 // add returns
                 if (objData.$ReturnType && Object.keys(objData.$ReturnType).length > 0 && obj) {
                     let returnValue = {};
                     // check if the return type is pre-defined, undefined or custom defined
-                    if (edmxncdsdatatype[objData.$ReturnType.$Type]) {
+                    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);
                         if(type) returnValue["type"] = type;
                     }
-                    if (returnValue) {
+                    if (returnValue.type || returnValue.items.type) {
                         obj[objType].returns = {};
                         // check if return type is a collection
-                        if (objData.$ReturnType.$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));
                     }
                 }
             }
@@ -771,10 +831,12 @@ function _generateCSN(edmxAsJson, ignorePersistenceSkip, mockServerUc) {
     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: get all bounded action & function
+    // Step 5: add entity container properties
+    csn.definitions = Object.assign(_parseEntityContainer(csn.definitions,schemaData),csn.definitions);
+    // Step 6: get all bounded action & function
     _parseBounded(csn.definitions, 0);
     _parseBounded(csn.definitions, 1);
-    // Step 6: get all annotations
+    // Step 7: get all annotations
     _generateDocumentation(schemaData, csn.definitions);
 
     return JSON.stringify(csn, null, 4);
@@ -826,7 +888,7 @@ function _checkAnnotationTarget(annotation, cdsDefs , str, no_of_terms){
             _checkAnnotatationTerm(annotation,cdsDefs[path[0]],no_of_terms,str);   
             } else{
                 let path1 = path[1].split('/');
-                if(cdsDefs[path[0]]){
+                if(cdsDefs[path[0]] && cdsDefs[path[0]]["params"]){
                     _checkAnnotatationTerm(annotation,cdsDefs[path[0]]["params"][path1[1]],no_of_terms,str);
                 }
             }    

package/lib/index.js

@@ -1,5 +1,5 @@
 const cds = require ('@sap/cds')
-const get_compile = Reflect.getOwnPropertyDescriptor(cds,'compile').get
+const compile_desc = Reflect.getOwnPropertyDescriptor(cds,'compile')
 
 // extending cds to lazy-load additional submodules provided by cds-dk
 module.exports = Object.defineProperties (cds, {
@@ -9,10 +9,11 @@ module.exports = Object.defineProperties (cds, {
   compile: {enumerable:true, get:()=> {
     // lazy-extending cds.compile.to only when cds.compile getter is invoked
     // otherwise we might cause cds.env being invoked too early.
-    const compile = get_compile.call(cds)
-    Object.defineProperties (compile.to, {
-      openapi: {enumerable:true, get:()=> require('./compile/openapi')}
-    })
+    const compile = compile_desc.value || compile_desc.get.call(cds)
+    if (!Reflect.getOwnPropertyDescriptor(compile.to, 'openapi'))
+      Object.defineProperties (compile.to, {
+        openapi: {enumerable:true, get:()=> require('./compile/openapi')}
+      })
     return compile
   }},
 })

package/lib/init/constants.js

@@ -1,6 +1,6 @@
 const os = require('os');
 
-const MAVEN_ARCHETYPE_VERSION = '1.20.3';
+const MAVEN_ARCHETYPE_VERSION = '1.21.0';
 
 const constants = {
     IS_WIN: (os.platform() === 'win32'),
@@ -13,8 +13,11 @@ const constants = {
     OPTION_NODEJS: 'nodejs',
     OPTION_JAVA: 'java',
     OPTION_HANA: 'hana',
+    OPTION_XSUAA: 'xsuaa',
     OPTION_MTA: 'mta',
     OPTION_MTX: 'mtx',
+    OPTION_AUDITLOG: 'auditlog',
+    OPTION_APPROUTER: 'approuter',
     OPTION_CF_MANIFEST: 'cf-manifest',
     OPTION_PIPELINE: 'pipeline',
     OPTION_SAMPLES: 'samples',
@@ -41,7 +44,7 @@ const constants = {
         MAVEN_ARCHETYPE_HELP: `https://cap.cloud.sap/docs/java/development/#the-maven-archetype`,
         MAVEN_INSTALL_HELP: `https://maven.apache.org/install.html`,
         PYTHON: 'https://www.python.org/downloads/',
-        PYTHON_PIP: 'https://packaging.python.org/guides/',
+        PYTHON_PIP: 'https://packaging.python.org/en/latest/guides/',
         VSCODE: 'https://code.visualstudio.com/',
         VSCODE_NBVIEWER: 'https://marketplace.visualstudio.com/items?itemName=ms-python.python',
         VSCODE_ESLINT: 'https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint'
@@ -56,11 +59,14 @@ const constants = {
 constants.OPTIONS_PRIORITY = [
     constants.OPTION_JAVA,
     constants.OPTION_NODEJS,
-    constants.OPTION_HANA,
     constants.OPTION_PIPELINE,
-    constants.OPTION_MTX,
-    constants.OPTION_CF_MANIFEST,
     constants.OPTION_MTA,
+    constants.OPTION_CF_MANIFEST,
+    constants.OPTION_HANA,
+    constants.OPTION_XSUAA,
+    constants.OPTION_MTX,
+    constants.OPTION_AUDITLOG,
+    constants.OPTION_APPROUTER,
     constants.OPTION_SAMPLES,
     constants.OPTION_NOTEBOOK,
     constants.OPTION_LINT,

package/lib/init/index.js

@@ -6,7 +6,9 @@ const term = require('../util/term');
 const Spinner = require('./util/spinner');
 
 const { OPTIONS_PRIORITY, COMMAND_ADD, COMMAND_INIT,
-    OPTION_HANA, OPTION_JAVA, OPTION_MTA, OPTION_MTX, OPTION_NODEJS,
+    // eslint-disable-next-line no-unused-vars
+    OPTION_XSUAA, OPTION_AUDITLOG, OPTION_HANA, OPTION_MTA, OPTION_MTX, OPTION_APPROUTER,
+    OPTION_NODEJS, OPTION_JAVA,
     OPTION_PIPELINE, OPTION_SAMPLES, OPTION_CF_MANIFEST, PROJECT_FILES, REGEX_PROJECT_NAME } = require('./constants');
 
 module.exports = class CDSGenerator {
@@ -99,6 +101,7 @@ module.exports = class CDSGenerator {
                 choices: [
                     OPTION_JAVA,
                     OPTION_HANA,
+                    OPTION_XSUAA,
                     OPTION_PIPELINE,
                     OPTION_CF_MANIFEST,
                     OPTION_MTA,
@@ -179,20 +182,22 @@ module.exports = class CDSGenerator {
             case COMMAND_INIT: {
                 const relativeProjectPath = path.relative(this.cwd, this.projectPath);
                 const folderName = (relativeProjectPath ? `.${path.sep}${relativeProjectPath}` : 'current folder');
-                this.logger.log(`creating new project in ${folderName}`);
+                this.logger.log(`Creating new cap project in ${folderName}`);
                 break;
             }
 
             case COMMAND_ADD:
-                this.logger.log(`adding feature(s) to project in current folder`);
+                this.logger.log(`Adding feature(s) to project in current folder`);
                 break;
 
             default:
         }
 
         if (this.options.force) {
-            this.logger.log(`using '--force' ... existing files will be overwritten...!`);
+            this.logger.log(`Using '--force' ... existing files will be overwritten...!`);
         }
+
+        this.logger.log();
     }
 
     async _process() {
@@ -202,7 +207,7 @@ module.exports = class CDSGenerator {
         await this._fillTemplateList();
 
         for (const template of this.templateList) {
-            const msg = `adding feature '${template.name}'...`;
+            const msg = `Adding feature '${template.name}'...`;
             if (this.logger.isDebug) {
                 this.logger.log(msg);
                 await template.run();
@@ -214,7 +219,7 @@ module.exports = class CDSGenerator {
             }
         }
 
-        this.logger.log(`done.`);
+        this.logger.log(`Done adding features`);
         this.logger.log();
     }
 
@@ -264,12 +269,14 @@ module.exports = class CDSGenerator {
         for (const template of this.templateList) {
             await template.finalize();
         }
+
+        this.logger.log();
     }
 
     _showFiles() {
         const files = this.fsUtil.getTouchedFiles();
         if (files && files.length > 0) {
-            this.logger.log(`added / changed files`);
+            this.logger.log(`Added / changed files`);
             for (const file of files) {
                 this.logger.log(file);
             }

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

@@ -0,0 +1,161 @@
+// This file describes so-called "modules" and "resources" commonly
+// found in mta.yaml files.
+// The following matchers contain the *required* constraints to
+// identify a YAML node as a semantic equivalent of the matcher.
+
+const srvNode = {
+    ref: "srv",
+    keyPath: ["modules"],
+    constraints: [{
+        comparisonKeyPath: ["type"],
+        value: "nodejs"
+    }],
+}
+
+const srvJava = {
+    ref: "srv",
+    keyPath: ["modules"],
+    constraints: [{
+        comparisonKeyPath: ["type"],
+        value: "java"
+    }],
+}
+
+const approuter = {
+    ref: "approuter",
+    keyPath: ["modules"],
+    constraints: [{
+        comparisonKeyPath: ["type"],
+        value: "approuter.nodejs"
+    }],
+    spaceBefore: true
+}
+
+const xsuaa = {
+    ref: "uaa-resource",
+    keyPath: ["resources"],
+    constraints: [{
+        comparisonKeyPath: ["type"],
+        value: "org.cloudfoundry.managed-service",
+    }, {
+        comparisonKeyPath: ["parameters", "service"],
+        value: "xsuaa",
+    }, {
+        comparisonKeyPath: ["parameters", "service-plan"],
+        value: "application"
+    }],
+    spaceBefore: true
+}
+
+const auditlog = {
+    ref: "auditlog-resource",
+    keyPath: ["resources"],
+    constraints: [{
+        comparisonKeyPath: ["type"],
+        value: "org.cloudfoundry.managed-service",
+    }, {
+        comparisonKeyPath: ["parameters", "service"],
+        value: "auditlog-api",
+    }],
+    spaceBefore: true
+}
+
+const hdbDeployer = {
+    ref: "deployer",
+    keyPath: ["modules"],
+    constraints: [{
+        comparisonKeyPath: ["type"],
+        value: "hdb"
+    }],
+    spaceBefore: true
+}
+
+const hdiContainer = {
+    ref: "db-resource",
+    keyPath: ["resources"],
+    constraints: [{
+        comparisonKeyPath: ["type"],
+        value: "com.sap.xs.hdi-container",
+    }],
+    spaceBefore: true
+}
+
+const serviceManager = {
+    ref: "db-resource",
+    keyPath: ["resources"],
+    constraints: [{
+        comparisonKeyPath: ["type"],
+        value: "org.cloudfoundry.managed-service",
+    }, {
+        comparisonKeyPath: ["parameters", "service"],
+        value: "service-manager",
+    }, {
+        comparisonKeyPath: ["parameters", "service-plan"],
+        value: "container"
+    }],
+    spaceBefore: true
+}
+
+const saasRegistry = {
+    ref: "registry-resource",
+    keyPath: ["resources"],
+    constraints: [{
+        comparisonKeyPath: ["type"],
+        value: "org.cloudfoundry.managed-service",
+    }, {
+        comparisonKeyPath: ["parameters", "service"],
+        value: "saas-registry",
+    }, {
+        comparisonKeyPath: ["parameters", "service-plan"],
+        value: "application"
+    }],
+    spaceBefore: true
+}
+
+const srvAPI = {
+    ref: "srvAPI",
+    keyPath: ["provides"],
+    constraints: [{
+        comparisonKeyPath: ["name"],
+        value: "srv-api"
+    }, {
+        comparisonKeyPath: ["properties", "srv-url"],
+        value: "${default-url}"
+    }]
+}
+
+const mtxSidecar = {
+    ref: "sidecar",
+    keyPath: ["modules"],
+    constraints: [{
+        comparisonKeyPath: ["type"],
+        value: `nodejs`
+    }],
+}
+
+const mtxAPI = {
+    ref: "provided-mtx-api",
+    keyPath: ["provides"],
+    constraints: [{
+        comparisonKeyPath: ["name"],
+        value: "mtx-api"
+    }, {
+        comparisonKeyPath: ["properties", "mtx-url"],
+        value: "${default-url}"
+    }]
+}
+
+module.exports = {
+    srvNode,
+    srvJava,
+    approuter,
+    xsuaa,
+    auditlog,
+    hdbDeployer,
+    hdiContainer,
+    serviceManager,
+    saasRegistry,
+    srvAPI,
+    mtxSidecar,
+    mtxAPI
+}