@sap/cds-dk 6.0.2 → 6.1.1

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 = {};
@@ -883,7 +904,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 +913,7 @@ function _replaceSpecialCharacters(text) {
     return text.replace(/(?:\\[rn]|[\r\n]+)+/gm, "\n").replace(/\s+/g, ' ').replace(/"/g, """).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 +924,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);
         }
-    } else if (annotation[0].indexOf('(') === -1 && !(annotation[0].indexOf('/') === -1)) {
+        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)) {
         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 +1044,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.25.0';
+const MAVEN_ARCHETYPE_VERSION = '1.27.0';
 
 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,290 @@
+// 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: '^/extend/(.*)'
+    }, {
+        property: 'destination',
+        isEqualTo: 'mtx-api',
+    }, {
+        property: 'target',
+        isEqualTo: '$1',
+    }, {
+        property: 'authenticationType',
+        isEqualTo: 'none',
+    }]
+}
+
+const approuterExtensibilityJava = {
+    ref: 'approuter-extensibility-java',
+    in: 'routes',
+    where: [{
+        property: 'source',
+        isEqualTo: '^/extend/(.*)'
+    }, {
+        property: 'destination',
+        isEqualTo: 'mtx-api',
+    }, {
+        property: 'target',
+        isEqualTo: '$1',
+    }, {
+        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/index.js

@@ -1,4 +1,3 @@
-const fs = require('fs')
 const { join } = require('path')
 const TemplateBase = require('../templateBase')
 const ProjectReader = require('../../util/projectReader')
@@ -9,7 +8,7 @@ const {
     requiredMtxAPI, requiredJavaApprouterAPI, providedJavaApprouterAPI, // APIs
     requiredAppAPI, providedAppAPI,
     approuterExtensibility, approuterExtensibilityJava // xs-app.json config
-} = require('../_merging/existences')
+} = require('../_merging/registry-mta')
 
 module.exports = class ApprouterTemplate extends TemplateBase {
 
@@ -24,50 +23,41 @@ module.exports = class ApprouterTemplate extends TemplateBase {
 
     async runDependentMerging() {
         const projectDescriptor = await this.projectReader.read(this.options)
-        const mtaYAMLPath = join(this.projectPath, 'mta.yaml')
-        const { isNodejs, isJava, isMultitenant } = projectDescriptor.cap
-        if (fs.existsSync(mtaYAMLPath)) {
+        const { isNodejs, isJava, isExtensible, isMultitenant, hasMtaDeployment } = projectDescriptor.cap
+
+        if (hasMtaDeployment) {
             const srv = isNodejs ? srvNode : srvJava
             const apis = isJava ? [requiredJavaApprouterAPI, providedJavaApprouterAPI] : []
             if (isNodejs && isMultitenant) apis.push(requiredMtxAPI, requiredAppAPI, providedAppAPI)
             if (isJava && isMultitenant) apis.push(requiredMtxAPI)
-            const existences = [srv, approuter, xsuaa, ...apis]
-            await this.templateUtil.mergeYAML(
-                mtaYAMLPath,
-                `${__dirname}/files/mta.yaml.hbs`,
-                projectDescriptor,
-                {
-                    existences,
-                    relationships: [{
-                        in: srv,
-                        inKeyPath: ["requires"],
-                        into: "name",
-                        existences: [xsuaa],
-                        existenceKeyPath: ["name"],
-                    }, {
-                        in: approuter,
-                        inKeyPath: ["requires"],
-                        into: "name",
-                        existences: [xsuaa],
-                        existenceKeyPath: ["name"],
-                    }],
-                }
-            )
+            const additions = [srv, approuter, xsuaa, ...apis]
+            const mtaYAMLPath = join(this.projectPath, 'mta.yaml')
+            await this.templateUtil.mergeYAML(mtaYAMLPath, `${__dirname}/files/mta.yaml.hbs`, projectDescriptor, {
+                additions,
+                relationships: [{
+                    insert: [xsuaa, 'name'],
+                    into: [srv, 'requires', 'name']
+                }, {
+                    insert: [xsuaa, 'name'],
+                    into: [approuter, 'requires', 'name']
+                }],
+            })
         }
 
         const appPath = join(this.projectPath, projectDescriptor.ui.appPath || 'app')
-        const existences = isMultitenant && isJava ? [approuterExtensibilityJava] :
-                           isMultitenant && isNodejs ? [approuterExtensibility] : []
+        const additions = isExtensible && isJava ? [approuterExtensibilityJava] :
+                          isExtensible && isNodejs ? [approuterExtensibility] : []
         await this.templateUtil.mergeJSON(
             `${appPath}/xs-app.json`,
             `${__dirname}/files/xs-app.json.hbs`,
             projectDescriptor,
-            { existences }
+            { additions }
         )
     }
 
     async run() {
         const projectDescriptor = await this.projectReader.read(this.options)
+        const { for: forProfile } = projectDescriptor.cap
         const appPath = join(this.projectPath, projectDescriptor.ui.appPath || 'app')
         const appPackageJSONPath = join(appPath, 'package.json')
 
@@ -83,14 +73,14 @@ module.exports = class ApprouterTemplate extends TemplateBase {
         switch (projectType) {
             case PROJECT_TYPE.java: {
                 const cdsrcJSONPath = join(this.projectPath, '.cdsrc.json')
-                const cdsTemplateFile = projectDescriptor.cap.for ? 'cds.cdsrc.json.hbs' : 'cds.cdsrc.json'
+                const cdsTemplateFile = forProfile ? 'cds.cdsrc.json.hbs' : 'cds.cdsrc.json'
                 const cdsPackageJSONPath = join(__dirname, 'files', cdsTemplateFile)
                 await this.templateUtil.mergeJSON(cdsrcJSONPath, cdsPackageJSONPath, projectDescriptor)
                 break
             }
             case PROJECT_TYPE.nodejs: {
                 const packageJSONPath = join(this.projectPath, 'package.json')
-                const cdsTemplateFile = projectDescriptor.cap.for ? 'cds.package.json.hbs' : 'cds.package.json'
+                const cdsTemplateFile = forProfile ? 'cds.package.json.hbs' : 'cds.package.json'
                 const cdsPackageJSONPath = join(__dirname, 'files', cdsTemplateFile)
                 await this.templateUtil.mergeJSON(packageJSONPath, cdsPackageJSONPath, projectDescriptor)
                 break

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

@@ -2,7 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const TemplateBase = require('../templateBase');
 const ProjectReader = require('../../util/projectReader');
-const { srvNode, srvJava, auditlog } = require('../_merging/existences');
+const { srvNode, srvJava, auditlog } = require('../_merging/registry-mta');
 
 module.exports = class AuditlogTemplate extends TemplateBase {
     constructor(projectPath, generator) {
@@ -12,22 +12,20 @@ module.exports = class AuditlogTemplate extends TemplateBase {
 
     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 = projectDescriptor.cap.isNodejs ? srvNode : srvJava
+        const srv = isNodejs ? srvNode : srvJava
         await this.templateUtil.mergeYAML(
             mtaYAMLPath,
             `${__dirname}/files/mta.yaml.hbs`,
             projectDescriptor,
             {
-                existences: [srv, auditlog],
+                additions: [srv, auditlog],
                 relationships: [{
-                    in: srv,
-                    inKeyPath: ["requires"],
-                    into: "name",
-                    existences: [auditlog],
-                    existenceKeyPath: ["name"],
-                }],
+                    insert: [auditlog, 'name'],
+                    into: [srv, 'requires', 'name']
+                }]
             }
         );
     }

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

@@ -0,0 +1,7 @@
+{
+  "cds": {
+    "requires": {
+      "extensibility": true
+    }
+  }
+}