@sap/cds-dk 7.7.1 → 7.8.0

package/lib/build/util.js

@@ -118,6 +118,7 @@ function resolveRequiredSapModels(modelPaths) {
 }
 
 async function getDefaultModelOptions(ws = false) {
+    // Note: requires.toggles holds the actual kind representation and not the value 'true'
     const wildcards = cds.env.requires.toggles && cds.env.features.folders ? ['*', cds.env.features.folders] : '*'
     let paths = _filterModelPaths(cds.resolve(wildcards, false))
 
@@ -165,17 +166,6 @@ function getI18nDefaultFolder() {
     return cds.env.i18n.folders[0] ?? 'i18n'
 }
 
-function isClassicMtx() {
-    function _hasMtxDependency() {
-        try {
-            return !!require(path.join(cds.root, 'package.json'))?.dependencies?.['@sap/cds-mtx']
-        } catch (e) {
-            return false
-        }
-    }
-    return /true/i.test(process.env.OLD_MTX) || _hasMtxDependency()
-}
-
 async function pathExists(path) {
     return fs.promises.access(path).then(() => true).catch(() => false);
 }
@@ -378,7 +368,6 @@ module.exports = {
     getDefaultModelOptions,
     flatten,
     getI18nDefaultFolder,
-    isClassicMtx,
     normalizePath,
     pathExists,
     getWorkspaces,

package/lib/compile/openapi/index.js

@@ -3,7 +3,8 @@ const cds = require('../../cds')
 
 module.exports = function processor(csn, options = {}) {
     const edmOptions = Object.assign({
-        odataOpenapiHints: true, // hint to compiler
+        odataOpenapiHints: true, // hint to cds-compiler
+        edm4OpenAPI: true, // downgrades certain OData errors to warnings in cds-compiler
         to: 'openapi' // hint to cds.compile.to.edm (usually set by CLI, but also do this in programmatic usages)
     }, options)
 

package/lib/deploy/to-hana/hana.js

@@ -57,7 +57,7 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
 
     const fromFile = vcapFile && exists(vcapFile) ? await read(vcapFile) : {};
     const fromEnv = this.getFromEnv('VCAP_SERVICES', 'SERVICE_REPLACEMENTS');
-    let vcapEnv = { ...fromFile, ...fromEnv };
+    let vcapEnv = { ...fromEnv, ...fromFile };
     if (process.env.TARGET_CONTAINER) {
       vcapEnv.TARGET_CONTAINER = process.env.TARGET_CONTAINER;
     }
@@ -82,30 +82,32 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
         }
 
         const hasVCAPEnv = Object.keys(vcapEnv).length > 0;
+        let serviceKeyName
         if (!serviceName && hasVCAPEnv) {
           await fs.mkdir(dest, { recursive: true });
-        }
-        const { cfServiceInstanceName, cfServiceInstanceKeyName, serviceKey } =
+        } else {
+          const { cfServiceInstanceName, cfServiceInstanceKeyName, serviceKey } =
             await this._getOrCreateCFService(projectPath, dest, serviceName, tunnelAddress);
 
-        serviceName ??= cfServiceInstanceName;
-        if (!vcapEnv.VCAP_SERVICES || serviceName) {
-          vcapEnv.VCAP_SERVICES = this._getVCAPServicesEntry(cfServiceInstanceName, serviceKey);
-        }
+          serviceName ??= cfServiceInstanceName;
+          serviceKeyName ??= cfServiceInstanceKeyName
+          if (!vcapEnv.VCAP_SERVICES || serviceName) {
+            vcapEnv.VCAP_SERVICES = this._getVCAPServicesEntry(cfServiceInstanceName, serviceKey);
+          }
 
-        if (storeCredentials) {
-          await this._addInstanceToDefaultEnvJson([dest, projectPath], cfServiceInstanceName, serviceKey);
+          if (storeCredentials) {
+            await this._addInstanceToDefaultEnvJson([dest, projectPath], cfServiceInstanceName, serviceKey);
+          }
         }
 
         console.log(`${bold('Starting deployment to SAP HANA ...')}`);
-
         DEBUG?.({ dest, vcapEnv, hdiOptions })
         await hdi.deploy(dest, vcapEnv, hdiOptions);
 
         if (!hasVCAPEnv) {
           const bindOptions = {
             ...options,
-            to: `${serviceName}:${cfServiceInstanceKeyName}`,
+            to: `${serviceName}:${serviceKeyName}`,
             for: options.for,
             kind: task.for
           }
@@ -227,12 +229,12 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
 
   _getVCAPServicesEntry(serviceInstanceName, serviceKey) {
     return {
-        hana: [
-          {
-            name: serviceInstanceName,
-            tags: ['hana'],
-            credentials: serviceKey
-          }
+      hana: [
+        {
+          name: serviceInstanceName,
+          tags: ['hana'],
+          credentials: serviceKey
+        }
       ]
     };
   }

package/lib/import/common.js

@@ -16,7 +16,7 @@ let optionsMapping = {
     'no-save': 'no_save'
 };
 
-let apiOptions = ['includeNamespaces', 'keepNamespace'];
+let apiOptions = ['includeNamespaces', 'keepNamespace', 'beta'];
 let commonOptions = ['no_copy', 'no_save', 'out', 'dry', 'as', 'from', 'force', 'config'];
 
 async function generateEDMX2JSON(edmx) {

package/lib/import/importapi.js

@@ -64,7 +64,7 @@ async function cds_import_from_edmx(filepath, options = { keepNamespace: false }
     filepath = await common.isValidInputFile(path.resolve(process.cwd(), filepath));
     const src = await common.getContentFromFile(filepath);
     // takes the api specific options and reads it from env
-    let odataOptions = { include_namespaces: options.includeNamespaces, keep_namespace: options.keepNamespace };
+    let odataOptions = { include_namespaces: options.includeNamespaces, keep_namespace: options.keepNamespace, beta: options.beta};
     if (cds.env.import) {
         common.readEnvVariables(odataOptions, false);
     }

package/lib/import/odata/v4parser.js

@@ -82,7 +82,7 @@ const known_vocabularies = {
     'com.sap.vocabularies.UI.v1': 'UI',
 };
 
-function _initialize(parserContext, mockServerUc) {
+function _initialize(parserContext) {
     parserContext.unboundedActions = {};
     parserContext.unboundedFunctions = {};
     parserContext.entityTypes = [];
@@ -103,7 +103,8 @@ function _initialize(parserContext, mockServerUc) {
     parserContext.entityToBoundedActions = {};
     parserContext.entityToBoundedFunctions = {};
     parserContext.entityContainerAnnotations = {};
-    parserContext.mockServerUc = mockServerUc;
+    parserContext.mockServerUc = true;
+    parserContext.beta = false;
 }
 function _isJson(edmx) {
     let isJson = false;
@@ -290,7 +291,7 @@ function _replaceSpecialCharacters(text) {
     return text.replace(/(?:\\[rn]|[\r\n]+)+/gm, "\n").replace(/\s+/g, ' ').replace(/"/g, """).trim();
 }
 
-function _resolveCoreTerm(annotationTerm, annotationTermObject, csnDefsTargetObject) {
+function _resolveCoreTerm(annotationTerm, annotationTermObject, csnDefsTargetObject, parserContext) {
     if (annotationTerm === "@Core.Description" || annotationTerm === "@Core.LongDescription") {
         // we don't capture `null` value for doc
         if (annotationTermObject === null)  return;
@@ -313,9 +314,10 @@ function _resolveCoreTerm(annotationTerm, annotationTermObject, csnDefsTargetObj
     if (annotationTermObject === null) annotationTermObject = true;
 
     if (annotationTerm === "@Core.OptionalParameter") {
-        _updateElementObjectForDefaultValue(csnDefsTargetObject, annotationTermObject.DefaultValue);
-    }
-    else {
+        if (parserContext.beta) {
+            _updateElementObjectForDefaultValue(csnDefsTargetObject, annotationTermObject.DefaultValue);
+        }
+    } else {
         _captureAnnotationInCSN(annotationTerm, annotationTermObject, csnDefsTargetObject);
     }
 }
@@ -403,13 +405,13 @@ function _parseValidationTerm(annotationTerm, annotationTermObject, csnDefsTarge
     _captureAnnotationInCSN(annotationTerm, annotationTermObject, csnDefsTargetObject);
 }
 
-function _parseAnnotationTerms(annotationTerm, annotationTermObject, csnDefsTargetObject) {
+function _parseAnnotationTerms(annotationTerm, annotationTermObject, csnDefsTargetObject, parserContext) {
     const term = annotationTerm.split('.');
     const vocabAlias = term[0];
 
     switch (vocabAlias) {
         case "@Core":
-            _resolveCoreTerm(annotationTerm, annotationTermObject, csnDefsTargetObject);
+            _resolveCoreTerm(annotationTerm, annotationTermObject, csnDefsTargetObject, parserContext);
             break;
         case "@Capabilities":
             _parseCapabilitiesTerm(annotationTerm, annotationTermObject, csnDefsTargetObject);
@@ -458,7 +460,7 @@ function _captureAnnotationWithinElement(sourceObject, targetObject, parserConte
     Object.keys(sourceObject).forEach(key => {
         if (key.startsWith('@')) {
             element = _resolveAnotationTerm(JSON.stringify(key), parserContext);
-            _parseAnnotationTerms(element, sourceObject[key], targetObject);
+            _parseAnnotationTerms(element, sourceObject[key], targetObject, parserContext);
         }
     });
 }
@@ -1210,7 +1212,7 @@ function _parseAnnotations(schemaAnnotations, csnDefs, parserContext) {
             let annotationTerms = schemaAnnotations[annotationTargetPath];
             Object.keys(annotationTerms).forEach(annotationTerm => {
                 let annotationTermObject = schemaAnnotations[annotationTargetPath][annotationTerm];
-                _parseAnnotationTerms(annotationTerm, annotationTermObject, csnDefsTargetObject);
+                _parseAnnotationTerms(annotationTerm, annotationTermObject, csnDefsTargetObject, parserContext);
             });
         }
     });
@@ -1684,7 +1686,12 @@ async function getEdmxv4CSN(edmx, ignorePersistenceSkip, mockServerUc, importerC
     let name_space = [];
 
     const parserContext = {};
-    _initialize(parserContext, mockServerUc);
+    _initialize(parserContext);
+    parserContext.mockServerUc = mockServerUc;
+
+    if (importerContext.beta) {
+        parserContext.beta = importerContext.beta
+    }
 
     if (importerContext.include_all_namespaces) {
         name_space.push(true);

package/lib/index.js

@@ -46,9 +46,9 @@ class CdsDkAdd {
 class CdsDkBuild {
   get build() { return super.build = require('./build') }
 }
-if (process.argv[2] in { 'add':1, 'init':1 }) {
+if (process.argv[2] in { add:1, init:1, help:1 }) {
   cds.extend (cds.constructor) .with (CdsDkAdd)
-} else if (process.argv[2] in { 'build':1, 'deploy':1, 'push':1 }) {
+} else if (process.argv[2] in { build:1, deploy:1, push:1 }) {
   cds.extend (cds.constructor) .with (CdsDkBuild)
 }
 

package/lib/init/constants.js

@@ -4,7 +4,7 @@ module.exports = {
     COMMAND_INIT: 'init',
     COMMAND_ADD: 'add',
 
-    MAVEN_ARCHETYPE_VERSION: '2.7.0',
+    MAVEN_ARCHETYPE_VERSION: '2.7.1',
 
     OPTIONS: Object.freeze({
         JAVA: 'java',
@@ -35,6 +35,7 @@ module.exports = {
         ENTERPRISE_MESSAGING: 'enterprise-messaging',
         ENTERPRISE_MESSAGING_SHARED: 'enterprise-messaging-shared',
         REDIS_MESSAGING: 'redis-messaging',
+        KAFKA: 'kafka',
         APPROUTER: 'approuter',
         DESTINATION: 'destination',
         DATA: 'data',

package/lib/init/index.js

@@ -100,11 +100,11 @@ module.exports = class CDSGenerator {
     }
 
     /**
-     * @param {string} facets, comma separated list of templates, no blanks
+     * @param {string} facets, comma separated list of facets
      * @param {any} options, additional options
      */
-    async addCmd(facets) {
-        if (!facets) throw 'You must specify a facet to add to the project.'
+    async add(facets) {
+        if (!facets?.length) throw 'You must specify a facet to add to the project.'
 
         this._initialize(null);
         this._greetings();
@@ -113,7 +113,7 @@ module.exports = class CDSGenerator {
             throw `The current folder doesn't seem to contain a project. None of the following files found: ${PROJECT_FILES.join(', ')}.`
         }
 
-        await this._process();
+        await this._process(facets);
         await this.stepEnd();
     }
 
@@ -170,11 +170,11 @@ module.exports = class CDSGenerator {
         }
     }
 
-    async _process() {
+    async _process(facets) {
         DEBUG?.(`Project path: ${cds.root}`);
 
         await this._validateOptions();
-        await this._fillTemplateList();
+        await this._fillTemplateList(facets);
 
         for (const template of this.templateList) {
             console.log(`Adding feature '${template.name}'...`);
@@ -216,11 +216,11 @@ module.exports = class CDSGenerator {
         }
     }
 
-    async _fillTemplateList() {
+    async _fillTemplateList(facets) {
         const templates = new Map
-        const { command, options, argv } = cds.cli
+        const { command, options } = cds.cli
 
-        const plugins = command === COMMAND_INIT ? options.add : new Set(argv[0].split(','))
+        const plugins = command === COMMAND_INIT ? options.add : new Set(facets)
 
         for (let plugin of plugins) {
             // Compat
@@ -299,20 +299,6 @@ module.exports = class CDSGenerator {
         if (cds.cli.command === COMMAND_INIT && !options.add.has(JAVA)) {
             options.add.add(NODEJS);
         }
-
-        this._checkAdditionalOptions();
-    }
-
-    _checkAdditionalOptions() {
-        const { options } = cds.cli
-        for (const [key] of Object.entries(options)) {
-            const keySplit = key.split(/:/)
-            if (keySplit.length === 2) {
-                if (!options.add.has(keySplit[0])) {
-                    console.log(`ignoring option ${key} since ${keySplit[0]} is not part of specified feature list: ${Array.from(options.add).join(', ')}`)
-                }
-            }
-        }
     }
 
     async _validateOptions() {

package/lib/init/mvn.js

@@ -1,5 +1,5 @@
 
-const { URLS, MAVEN_ARCHETYPE_VERSION, OPTIONS: { JAVA_MVN, JAVA_PACKAGE, SAMPLES, HANA }, REGEX_JAVA_PACKAGE } = require('./constants');
+const { URLS, MAVEN_ARCHETYPE_VERSION, OPTIONS: { JAVA_MVN, JAVA_PACKAGE, HANA }, REGEX_JAVA_PACKAGE } = require('./constants');
 
 const cp = require('child_process');
 const util = require('util');
@@ -143,10 +143,6 @@ class MvnArchetypeUtil {
             params.set(`-DtargetPlatform`, `cloudfoundry`);
         }
 
-        const hasSamples = !!(options.add && options.add.has(SAMPLES));
-        params.set(`-DincludeModel`, hasSamples);
-        params.set(`-DincludeIntegrationTest`, hasSamples);
-
         if (options[JAVA_MVN]) {
             this._scanMvnParams(options[JAVA_MVN], params);
         }

package/lib/init/plugin.js

@@ -10,6 +10,14 @@ module.exports = class Plugin {
         this.name = this.constructor.name.replace(/template/i, '').replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase()
     }
 
+    /**
+     * Provides command-line options for the plugin.
+     * @returns {Array.<{option: string, flag: string, shortcut?: string, help: string}>}
+     */
+    options() {
+        return []
+    }
+
     /**
      * Gets the required templates.
      * @returns {string[]} An array of strings representing required plugins.

package/lib/init/registries/mta.js

@@ -32,6 +32,11 @@ const enterpriseMessaging = {
     where: { type: 'org.cloudfoundry.managed-service', 'parameters.service': 'enterprise-messaging' }
 }
 
+const kafkaMessaging = {
+    in: 'resources',
+    where: { type: 'org.cloudfoundry.managed-service', 'parameters.service': 'kafka' }
+}
+
 const applicationLogging = {
     in: 'resources',
     where: { type: 'org.cloudfoundry.managed-service', 'parameters.service': 'application-logs' }
@@ -144,6 +149,7 @@ module.exports = {
     destination,
     connectivity,
     enterpriseMessaging,
+    kafkaMessaging,
     hdbDeployer,
     hdiContainer,
     notificationTypesDeployer,

package/lib/init/template/data/as-csv.js

@@ -0,0 +1,60 @@
+// const cds = require('../../../cds')
+
+module.exports = async (data={}, csn, { headerOnly=false, queries=false, separator=',' }={}) => {
+  if (!queries) { // remove all projection-like entities
+    Object.keys(data)
+      .map(name => csn.definitions[name])
+      .filter (entity => entity.query)
+      .forEach(entity => { delete data[entity.name] })
+  }
+
+  // We might need multiple passes if data for associations/compositions is created on the fly.
+  // So loop as long as there is some non-string data left.
+  while (Object.values(data).some(d => typeof d === 'object')) {
+    Object.entries(data)
+    .filter(([_, value]) => typeof value === 'object')
+    .map(([name]) => csn.definitions[name])
+    .forEach(entity => {
+      const entityData = data[entity.name]
+      const header = []
+      const records = []
+      for (let i = 0; i < entityData.length; i++) {
+        let record = []
+        for (const element of Object.values(entity.elements).sort(keyFirstSorter)) {
+          const name = element.name
+          let value = entityData[i][name]
+          if (value === undefined)
+            continue
+          if (element._type === 'cds.Composition') {
+            data[element.target] = value // Add object for a new entity. Next pass will process it.
+          }
+          else if (element._type === 'cds.Association') {
+            if (i === 0) {
+              header.push(...Object.keys(value).map(foreignKey => name + '_' + foreignKey))
+            }
+            record.push(...Object.values(value))
+          }
+          else {
+            if (i === 0)  header.push(name)
+            if (typeof value === 'string' && (value.includes('"') || value.includes(separator)))
+              value = `"${value.replace(/"/g, '""')}"` // escape double quotes, then quote the value
+            record.push(value)
+          }
+        }
+        records.push(record.join(separator))
+      }
+      let res = header.join(separator)
+      if (!headerOnly)
+        res += '\n' + records.join('\n')
+
+      data[entity.name] = res
+    })
+  }
+  return data
+}
+
+function keyFirstSorter(e1, e2) {
+  if (e1.key && !e2.key) return -1
+  if (!e1.key && e2.key) return 1
+  return 0 // preserve original order otherwise
+}