@sap/cds-dk 4.7.3 → 4.8.2

package/lib/import/v4parser.js

@@ -121,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) {
@@ -167,23 +174,32 @@ function generatePropertyCsn(propertyType, isPrimaryKey) {
         property.type = 'cds.LargeString'; // if type is missing, then it is String type
     }
 
-    if(edmxncdsdatatype[propertyType.$Type + '_a'])
-    {
+    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;
 }
 
@@ -371,10 +387,20 @@ 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][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];
+        }
+    });
+    return entityCSN;
+}
 function _generateEnumType(schemaData) {
     let enumTypeDict = {};
     let temp;
@@ -531,9 +557,9 @@ function _parseBounded(csnDefs, flag) {
                                     let type = _getDatatype(paramObj.$Type);
                                     if(type) paramType["type"] = type;
                                 }
-                                if (paramType.type) {
+                                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
@@ -542,42 +568,39 @@ function _parseBounded(csnDefs, flag) {
                                     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] || 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 ;
-                            }
-                            if (returnType.type) {
-                                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;
-                            } else {
-                                let message = '"' + obj[j].$ReturnType.$Type + '" is not supported (in return type)'; 
-                                console.log(warn(message));
-                            }
+                        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));
                         }
                     }
                 }
             }
-        );
+        });
     }
 }
 
@@ -698,9 +721,10 @@ function _parseUnbounded(schemaData, flag) {
                             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 {
@@ -710,8 +734,7 @@ function _parseUnbounded(schemaData, flag) {
                     }
                 }
                 //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
@@ -725,10 +748,10 @@ function _parseUnbounded(schemaData, flag) {
                         _includeExternalNamespaceAnnotation(objData.$ReturnType,returnValue);
                         if(type) returnValue["type"] = type;
                     }
-                    if (returnValue.type) {
+                    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
@@ -810,10 +833,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);

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.1';
 
 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',
@@ -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

@@ -7,7 +7,8 @@ const Spinner = require('./util/spinner');
 
 const { OPTIONS_PRIORITY, COMMAND_ADD, COMMAND_INIT,
     // eslint-disable-next-line no-unused-vars
-    OPTION_HANA, OPTION_JAVA, OPTION_MTA, OPTION_MTX, OPTION_NODEJS,
+    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 {
@@ -100,6 +101,7 @@ module.exports = class CDSGenerator {
                 choices: [
                     OPTION_JAVA,
                     OPTION_HANA,
+                    OPTION_XSUAA,
                     OPTION_PIPELINE,
                     OPTION_CF_MANIFEST,
                     OPTION_MTA,
@@ -180,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() {
@@ -203,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();
@@ -215,7 +219,7 @@ module.exports = class CDSGenerator {
             }
         }
 
-        this.logger.log(`done.`);
+        this.logger.log(`Done adding features`);
         this.logger.log();
     }
 
@@ -265,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
+}

package/lib/init/template/approuter/files/default-env.json

@@ -0,0 +1,9 @@
+{
+  "destinations": [
+    {
+      "name": "srv-api",
+      "url": "http://localhost:4004",
+      "forwardAuthToken": true
+    }
+  ]
+}

package/lib/init/template/approuter/files/mta.yaml.hbs

@@ -0,0 +1,48 @@
+---
+modules:
+  - name: {{cap.appName}}-srv
+    type: {{cap.pLanguage}}
+    requires:
+      - name: {{cap.appName}}-uaa
+
+  - name: {{cap.appName}}
+    type: approuter.nodejs
+    path: {{& ui.appPath}} # from cds.env.folders. Consider also cds.env.build.target --> gen/app
+    parameters:
+      keep-existing-routes: true
+      disk-quota: 256M
+      memory: 256M
+      # hosts: # additional tenant specific hostnames (only for Canary)
+      ## the developer will do this via an extension descriptor:
+      # - <paas-subdomain >${tenant-delimiter}${host}
+      # - <saas-subdomain1>${tenant-delimiter}${host}
+      # - ...
+    {{#cap.isMultitenant}}
+    properties:
+      TENANT_HOST_PATTERN: "^(.*)-${default-uri}"
+    {{/cap.isMultitenant}}
+    requires:
+    - name: srv-api
+      group: destinations
+      properties:
+        name: srv-api # this is a name which must be used in xs-app.json as well
+        url: ~{srv-url}
+        forwardAuthToken: true
+    {{#cap.isMultitenant}}
+    - name: mtx-api # in here always, but really used only if mtx client is used (our recommendation is that they contact cds-mtx via the approuter)
+      group: destinations
+      properties:
+        name: mtx-api # this is a name which must be used in xs-app.json as well
+        url: ~{mtx-url}
+    {{/cap.isMultitenant}}
+
+resources:
+ - name: {{cap.appName}}-uaa{{#cap.isMultitenant}}-mt{{/cap.isMultitenant}}
+   type: org.cloudfoundry.managed-service
+   parameters:
+     service: xsuaa
+     service-plan: application
+     path: ./xs-security.json
+     config:
+       xsappname: {{cap.appName}}-${org}-${space}
+       tenant-mode: {{#cap.isMultitenant}}shared{{/cap.isMultitenant}}{{^cap.isMultitenant}}dedicated{{/cap.isMultitenant}}

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

@@ -0,0 +1,9 @@
+{
+  "name": "approuter",
+  "dependencies": {
+    "@sap/approuter": "^10"
+  },
+  "scripts": {
+    "start": "node node_modules/@sap/approuter/approuter.js"
+  }
+}

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

@@ -0,0 +1,8 @@
+{
+  "routes": [
+    {
+      "source": "^.*$",
+      "destination": "srv-api"
+    }
+  ]
+}

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

@@ -0,0 +1,66 @@
+const TemplateBase = require('../templateBase');
+const ProjectReader = require('../../util/projectReader');
+const { fse } = require('@sap/cds-foss');
+const path = require('path');
+const { OPTION_XSUAA } = require('../../constants');
+const { srvNode, srvJava, approuter, xsuaa } = require('../_merging/existences');
+
+module.exports = class ApprouterTemplate extends TemplateBase {
+    constructor(projectPath, generator) {
+        super(projectPath, generator, __dirname);
+        this.projectReader = new ProjectReader(this);
+    }
+
+    async getDependencies() {
+        return [OPTION_XSUAA];
+    }
+
+    async runMTAMerging() {
+        const projectDescriptor = await this.projectReader.read(this.options);
+        const mtaYAMLPath = path.join(this.projectPath, 'mta.yaml');
+        if (!fse.existsSync(mtaYAMLPath)) return;
+        const srv = projectDescriptor.cap.isNodejs ? srvNode : srvJava
+        await this.templateUtil.mergeYAML(
+            mtaYAMLPath,
+            `${__dirname}/files/mta.yaml.hbs`,
+            projectDescriptor,
+            {
+                existences: [srv, approuter, xsuaa],
+                relationships: [{
+                    in: srv.ref,
+                    inKeyPath: ["requires"],
+                    into: "name",
+                    existences: [xsuaa.ref],
+                    existenceKeyPath: ["name"],
+                }, {
+                    in: approuter.ref,
+                    inKeyPath: ["requires"],
+                    into: "name",
+                    existences: [xsuaa.ref],
+                    existenceKeyPath: ["name"],
+                }],
+            }
+        );
+    }
+
+    async run() {
+        const projectDescriptor = await this.projectReader.read(this.options);
+        const appPath = path.join(this.projectPath, projectDescriptor.ui.appPath)
+
+        await this.templateUtil.mergeJSON(
+            `${appPath}/package.json`,
+            `${__dirname}/files/package.json`
+        );
+
+        await this.templateUtil.mergeJSON(
+            `${appPath}/xs-app.json`,
+            `${__dirname}/files/xs-app.json`
+        );
+
+        await this.templateUtil.mergeJSON(
+            `${appPath}/default-env.json`,
+            `${__dirname}/files/default-env.json`
+        );
+        await this.runMTAMerging()
+    }
+}

package/lib/init/template/auditlog/files/dependencies.package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+      "@sap/audit-logging": "^5"
+  }
+}

package/lib/init/template/auditlog/files/mta.yaml.hbs

@@ -0,0 +1,13 @@
+---
+modules:
+ - name: {{cap.appName}}-srv
+   type: {{cap.pLanguage}}
+   requires:
+    - name: {{cap.appName}}-auditlog
+
+resources:
+  - name: {{cap.appName}}-auditlog
+    type: org.cloudfoundry.managed-service
+    parameters:
+      service: auditlog-api
+      service-plan: default