@sap/cds-dk 7.6.0 → 7.7.0

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

@@ -1,15 +1,14 @@
-const cp = require('child_process');
 const path = require('path');
-const util = require('util');
 
 const fs = require('fs').promises;
 
 const cds = require('../../../lib/cds');
+const { exists, read } = cds.utils;
 
 const { build } = require('../../build');
 const buildConstants = require('../../build/constants');
 
-const hdiDeployUtil = require('./hdiDeployUtil');
+const hdi = require('./hdiDeployUtil');
 const cfUtil = require('../../util/cf');
 const gitUtil = require('../../util/git');
 const mtaUtil = require('./mtaUtil');
@@ -18,15 +17,9 @@ const { bold, info } = require('../../util/term');
 
 const { bind } = require('../../bind');
 
-const UTF_8 = 'utf-8';
+const DEBUG = cds.debug('deploy');
 
-
-class HanaDeployer {
-
-  constructor() {
-    this.execAsync = util.promisify(cp.exec);
-    this.spawnSync = cp.spawnSync;
-  }
+module.exports = new class HanaDeployer {
 
   getFromEnv(...varNames) {
     const result = {}
@@ -42,11 +35,8 @@ class HanaDeployer {
     return result;
   }
 
-  // arg object
-  // async deploy(model, serviceName, tunnelAddress, buildTaskOptions, vcapFile, undeployWhitelist, hdiOptions, bindCallback) { // NOSONAR
-  async deploy(options = {}) { // NOSONAR
-    let { model, serviceName, tunnelAddress, vcapFile, undeployWhitelist, hdiOptions, dry } = options;
-
+  async deploy(options = {}) {
+    let { model, serviceName, tunnelAddress, vcapFile, undeployWhitelist, hdiOptions = {}, dry, storeCredentials } = options;
     if (model) {
       throw `Specifying a CDS model for HANA deployment is not supported.
 'cds deploy --to hana' performs 'cds build --for hana' which in turn uses the configured HANA build task.
@@ -65,15 +55,16 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
 
     const buildResults = await this._build();
 
-    let globalVcapEnv = vcapFile ? await this._loadEnvFile(vcapFile) : {};
-    globalVcapEnv = { ...globalVcapEnv, ...this.getFromEnv('VCAP_SERVICES', 'SERVICE_REPLACEMENTS') };
+    const fromFile = vcapFile && exists(vcapFile) ? await read(vcapFile) : {};
+    const fromEnv = this.getFromEnv('VCAP_SERVICES', 'SERVICE_REPLACEMENTS');
+    let vcapEnv = { ...fromFile, ...fromEnv };
     if (process.env.TARGET_CONTAINER) {
-      globalVcapEnv.TARGET_CONTAINER = process.env.TARGET_CONTAINER;
+      vcapEnv.TARGET_CONTAINER = process.env.TARGET_CONTAINER;
     }
 
     if (dry) {
-      for (const buildResult of buildResults) {
-        const model = await cds.load(buildResult.task.src);
+      for (const { task } of buildResults) {
+        const model = await cds.load(task.src);
         const data = cds.compile.to.hdbtable(model);
         for (const [src, { file }] of data) {
           console.log(`-- ${file}`);
@@ -82,49 +73,47 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
         }
       }
     } else {
-      for (const buildResult of buildResults) {
-        let vcapEnv = globalVcapEnv;
-        let serviceKeyName;
-        const currentModelFolder = buildResult.task.dest;
+      for (const { task } of buildResults) {
+        const dest = task.dest;
 
         if (undeployWhitelist) {
           console.log('Writing undeploy.json');
-          await fs.write(path.join(currentModelFolder, 'undeploy.json'), JSON.stringify(undeployWhitelist, null, 2));
+          await fs.write(path.join(dest, 'undeploy.json'), JSON.stringify(undeployWhitelist, null, 2));
         }
 
         const hasVCAPEnv = Object.keys(vcapEnv).length > 0;
         if (!serviceName && hasVCAPEnv) {
-          await fs.mkdir(currentModelFolder, { recursive: true });
-        } else {
-          const { cfServiceInstanceName, cfServiceInstanceKeyName, serviceKey } =
-            await this._getOrCreateCFService(projectPath, currentModelFolder, serviceName, tunnelAddress);
-          serviceKeyName = cfServiceInstanceKeyName;
-          serviceName = serviceName || cfServiceInstanceName;
+          await fs.mkdir(dest, { recursive: true });
+        }
+        const { cfServiceInstanceName, cfServiceInstanceKeyName, serviceKey } =
+            await this._getOrCreateCFService(projectPath, dest, serviceName, tunnelAddress);
 
-          vcapEnv = this._getVCAPServicesEntry(cfServiceInstanceName, serviceKey);
+        serviceName ??= cfServiceInstanceName;
+        if (!vcapEnv.VCAP_SERVICES || serviceName) {
+          vcapEnv.VCAP_SERVICES = this._getVCAPServicesEntry(cfServiceInstanceName, serviceKey);
+        }
 
-          if (options.storeCredentials) {
-            await this._addInstanceToDefaultEnvJson([currentModelFolder, projectPath], cfServiceInstanceName, serviceKey);
-          }
+        if (storeCredentials) {
+          await this._addInstanceToDefaultEnvJson([dest, projectPath], cfServiceInstanceName, serviceKey);
         }
 
         console.log(`${bold('Starting deployment to SAP HANA ...')}`);
 
-        hdiOptions = hdiOptions || {}
-        await hdiDeployUtil.deploy(currentModelFolder, vcapEnv, hdiOptions);
+        DEBUG?.({ dest, vcapEnv, hdiOptions })
+        await hdi.deploy(dest, vcapEnv, hdiOptions);
 
         if (!hasVCAPEnv) {
           const bindOptions = {
             ...options,
-            to: `${serviceName}:${serviceKeyName}`,
+            to: `${serviceName}:${cfServiceInstanceKeyName}`,
             for: options.for,
-            kind: buildResult.task.for
+            kind: task.for
           }
           await bind(bindOptions);
         }
       }
 
-      if (options.storeCredentials) {
+      if (storeCredentials) {
         await gitUtil.ensureFileIsGitignored('default-env.json', projectPath);
       }
 
@@ -155,7 +144,7 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
     this._validateServiceInstanceName(cfServiceInstanceName);
     console.log(`Using container ${bold(cfServiceInstanceName)}`);
 
-    let cfConfig = cfServiceInstanceMta && cfServiceInstanceMta.parameters && cfServiceInstanceMta.parameters.config;
+    const cfConfig = cfServiceInstanceMta?.parameters?.config;
     const serviceInstance = await this.createHanaService(cfServiceInstanceName, cfConfig);
 
     const cfServiceInstanceKeyName = `${cfServiceInstanceName}-key`;
@@ -191,13 +180,17 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
 
   _validateServiceKey(serviceKey, cfServiceInstanceKey) {
     if (!serviceKey) {
-      throw new Error(`Could not create service key ${bold(cfServiceInstanceKey)}.`);
+      throw `Could not create service key ${bold(cfServiceInstanceKey)}.`;
+    }
+
+    if (serviceKey['sm_url']) {
+      throw `Service key credentials are matching to a Service Manager instance of a multitenant environment. Make sure there is no conflict with ${cfServiceInstanceKey}.`;
     }
 
     const fields = ['schema', 'user', 'password', 'url'];
     for (const field of fields) {
       if (!serviceKey[field]) {
-        throw new Error(`Service key is missing mandatory field '${field}'. Make sure you are ${bold('not')} using a managed service.`);
+        throw `Service key is missing mandatory field '${field}'. Make sure you are ${bold('not')} using a managed service.`;
       }
     }
   }
@@ -209,40 +202,21 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
     }
 
     console.log(`Running build`);
-    const buildResults = await build(buildTaskOptions);
-    return buildResults;
+    return build(buildTaskOptions);
   }
 
-  async _loadEnvFile(defaultEnvFile) {
-    try {
-      const content = await fs.readFile(defaultEnvFile);
-      return JSON.parse(content);
-    } catch (err) {
-      throw new Error(`Error reading default env file: ${err.message}`);
-    }
-  }
-
-
   async _addInstanceToDefaultEnvJson(currentFolders, serviceInstanceName, serviceKey) {
     for (const currentFolder of currentFolders) {
-      let defaultEnvJson = {};
       const defaultEnvJsonPath = path.join(currentFolder, 'default-env.json');
+      const defaultEnvJson = exists(defaultEnvJsonPath) ? await read(defaultEnvJsonPath) : {};
 
-      try {
-        defaultEnvJson = JSON.parse(await fs.readFile(defaultEnvJsonPath, UTF_8));
-      } catch (err) {
-        // ignore any errors
-      }
-
-      defaultEnvJson.VCAP_SERVICES = defaultEnvJson.VCAP_SERVICES || {};
-      for (const serviceKey of Object.keys(defaultEnvJson.VCAP_SERVICES)) {
-        defaultEnvJson.VCAP_SERVICES[serviceKey] = defaultEnvJson.VCAP_SERVICES[serviceKey].filter((service) => {
-          return (service.name !== serviceInstanceName);
-        });
+      defaultEnvJson.VCAP_SERVICES ??= {};
+      for (const [serviceKey, services] of Object.entries(defaultEnvJson.VCAP_SERVICES)) {
+        defaultEnvJson.VCAP_SERVICES[serviceKey] = services.filter(service => service.name !== serviceInstanceName);
       }
 
       const hanaEntry = this._getVCAPServicesEntry(serviceInstanceName, serviceKey)
-      Object.assign(defaultEnvJson, hanaEntry);
+      Object.assign(defaultEnvJson.VCAP_SERVICES, hanaEntry);
 
       console.log(`Writing ${defaultEnvJsonPath}`);
       await fs.mkdir(path.dirname(defaultEnvJsonPath), { recursive: true })
@@ -253,15 +227,13 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
 
   _getVCAPServicesEntry(serviceInstanceName, serviceKey) {
     return {
-      VCAP_SERVICES: {
         hana: [
           {
             name: serviceInstanceName,
             tags: ['hana'],
             credentials: serviceKey
           }
-        ]
-      }
+      ]
     };
   }
 
@@ -269,14 +241,14 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
   _validateServiceInstanceName(serviceInstanceName) {
     // valid service name chars: alpha-numeric, hyphens, and underscores
     if (/[^\w-_]+/g.exec(serviceInstanceName)) {
-      throw new Error(`Service name ${serviceInstanceName} must only contain alpha-numeric, hyphens, and underscores.`);
+      throw `Service name ${serviceInstanceName} must only contain alpha-numeric, hyphens, and underscores.`;
     }
   }
 
 
   _injectTunnelAddress(serviceKey, tunnelAddress) {
     if (!/\w+:\d+/.test(tunnelAddress)) {
-      throw new Error(`Invalid tunnel address '${tunnelAddress}' - must be in form 'host:port'`)
+      throw `Invalid tunnel address '${tunnelAddress}' - must be in form 'host:port'`;
     }
     const [tunnelHost, tunnelPort] = tunnelAddress.split(':')
     const { host, port } = serviceKey
@@ -288,5 +260,3 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
     return serviceKey
   }
 }
-
-module.exports = new HanaDeployer();

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

@@ -1,22 +1,21 @@
 const path = require('path');
 const util = require('util');
+const { bold } = require('../../util/term');
 
 const HDI_DEPLOY_LIB = '@sap/hdi-deploy';
 
-class HdiDeployUtil {
+module.exports = new class HdiDeployUtil {
 
-    async deploy(dbDir, vcapEnv = {}, options = {}) {
+    async deploy(dbDir, vcapEnv = {}, { autoUndeploy } = {}) {
         console.log(`Deploying to HANA from ${dbDir}`);
 
-        const hdiDeployLib = await this._loadHdiDeployLib(dbDir);
+        const { clean_env, deploy } = this._loadHdiDeployLib(dbDir);
 
-        let deployerEnv = JSON.parse(JSON.stringify(process.env));
+        const deployerEnv = JSON.parse(JSON.stringify(process.env));
         const hdiDeployOptions = deployerEnv.HDI_DEPLOY_OPTIONS ? JSON.parse(deployerEnv.HDI_DEPLOY_OPTIONS) : {};
         delete hdiDeployOptions.root;
 
-        if (typeof hdiDeployLib.clean_env === 'function') {
-            deployerEnv = hdiDeployLib.clean_env(deployerEnv);
-        }
+        clean_env?.(deployerEnv);
 
         if (vcapEnv.VCAP_SERVICES) {
             deployerEnv.VCAP_SERVICES = JSON.stringify(vcapEnv.VCAP_SERVICES);
@@ -28,8 +27,8 @@ class HdiDeployUtil {
             deployerEnv.TARGET_CONTAINER = vcapEnv.TARGET_CONTAINER;
         }
 
-        if (options.autoUndeploy) {
-            console.log(`Hdi deployer automatically undeploys deleted resources using --auto-undeploy.`);
+        if (autoUndeploy) {
+            console.log(`HDI deployer automatically undeploys deleted resources using --auto-undeploy.`);
             hdiDeployOptions.auto_undeploy = true;
         }
 
@@ -37,12 +36,12 @@ class HdiDeployUtil {
             deployerEnv.HDI_DEPLOY_OPTIONS = JSON.stringify(hdiDeployOptions);
         }
 
-        const asyncDeploy = util.promisify(hdiDeployLib.deploy);
-        const response = await asyncDeploy(dbDir, deployerEnv);
-        if (response?.exitCode) {
-            let message = `HDI deployment failed with exit code ${response.exitCode}`;
-            if (response.signal) {
-                message += `. ${response.signal}`;
+        const asyncDeploy = util.promisify(deploy);
+        const { exitCode, signal } = await asyncDeploy(dbDir, deployerEnv);
+        if (exitCode) {
+            let message = `HDI deployment failed with exit code ${exitCode}`;
+            if (signal) {
+                message += `. ${signal}`;
             }
             throw new Error(message);
         }
@@ -55,7 +54,7 @@ class HdiDeployUtil {
         if (!libPath) {
             throw new Error(`Required library '${HDI_DEPLOY_LIB}' not found in
     ${searchPaths.join('\n    ')}
-Add it either as a devDependency using 'npm install -D ${HDI_DEPLOY_LIB}' or install it globally using 'npm install -g ${HDI_DEPLOY_LIB}'.`);
+    Add it either to ${bold('devDependencies')} using 'npm install -D ${HDI_DEPLOY_LIB}' or install it globally using 'npm install -g ${HDI_DEPLOY_LIB}'.`);
         }
 
         console.log(`Using HDI deployer from ${libPath}`)
@@ -64,5 +63,3 @@ Add it either as a devDependency using 'npm install -D ${HDI_DEPLOY_LIB}' or ins
         return require(libPath);
     }
 }
-
-module.exports = new HdiDeployUtil();

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

@@ -98,7 +98,7 @@ async function _getProjectInfo(projectPath, mta) {
 }
 
 async function _getMta(projectPath) {
-    // yaml.parse  oesn't like null
+    // yaml.parse doesn't like null
     const mtaFilePath = path.join(projectPath, MTA_YAML)
 
     const existsMtaYaml = existsSync(mtaFilePath)

package/lib/env/schema.js

@@ -65,6 +65,7 @@ _robustRequire.resolve = function (id, options = {}) {
 }
 
 function mergePluginSchema(pluginSchema) {
+    // contribution points also appear in schema file ./schemas/cds-rc.js
     return {
         into: async (targetSchema) => {
             if (pluginSchema.buildTaskType) {

package/lib/env/schemas/cds-rc.js

@@ -5,6 +5,59 @@ module.exports = {
     $defs: {
         cdsRoot: {
             properties: {
+                // declaration for schema node for cds plugins contributing cds configuration
+                schema: {
+                    type: "object",
+                    description: "Schema declaration for cds plugins contributing cds configuration",
+                    additionalProperties: false,
+                    properties: {
+                        cds: {
+                            type: "object",
+                            description: "Containing json schema declarations for root level entries under cds node.",
+                            patternProperties: {
+                                // new keyword must start with word character or opening brackets
+                                "^[\\[\\(\\w].*": {
+                                    $ref: "https://json-schema.org/draft/2020-12/schema"
+                                }
+                            }
+                        },
+
+                        buildTaskType: {
+                            type: "object",
+                            additionalProperties: false,
+                            required: ["name"],
+                            properties: {
+                                name: {
+                                    type: "string",
+                                    minLength: 1,
+                                    description: "The name of the build task type."
+                                },
+                                description: {
+                                    type: "string",
+                                    description: "The description of the build task type."
+                                }
+                            }
+                        },
+
+                        databaseType: {
+                            type: "object",
+                            additionalProperties: false,
+                            required: ["name"],
+                            properties: {
+                                name: {
+                                    type: "string",
+                                    minLength: 1,
+                                    description: "The name of the database type."
+                                },
+                                description: {
+                                    type: "string",
+                                    description: "The description of the database type."
+                                }
+                            }
+                        }
+                    }
+                },
+
                 // build specific schema
                 build: {
                     type: "object",
@@ -115,4 +168,4 @@ module.exports = {
             ]
         }
     }
-}
+}

package/lib/import/asyncapi/parserContext.js

@@ -319,6 +319,12 @@ module.exports = class ParserContext {
      */
     getPropertyObject(propertyContent) {
         const property = {};
+        if ('$ref' in propertyContent) {
+            const refPathParts = propertyContent['$ref'].split('/');
+            const propertyName = refPathParts[refPathParts.length - 1];
+            property['type'] = { 'ref': [refPathParts[3], propertyName] };
+            return property;
+        }
         const inputType = this.getTypeFromArray(propertyContent.type);
         const cdsType = this.getDataType(inputType, propertyContent.format);
 

package/lib/import/common.js

@@ -148,30 +148,11 @@ async function _copyToSrvExternal(file, dst, cwd) {
     return file;
 }
 
-async function isValidJsonObject(options){
-    let config;
-    try {
-        if (options.config) {
-            config = JSON.parse(options.config);
-            return config;
-        }
-    } catch (error) {
-        throw new Error(messages.SPECIFY_CONFIG);
-    }
-} 
-
 async function preProcess(file, options, cwd) {
     let srcFilePath = await isValidInputFile(path.resolve(cwd, file));
     if (options.as && !_supportedAsFormats().includes(options.as))
         throw new Error(messages.INVALID_AS_OPTION);
-
-    const external = path.resolve(cwd, 'srv/external');
-    const destFilePath = path.join(external, path.basename(srcFilePath));
-
-    if (!options.dry && !options.no_copy)
-        srcFilePath = await _copyToSrvExternal(srcFilePath, destFilePath, cwd);
-
-    return [srcFilePath, destFilePath];
+    return srcFilePath;
 }
 
 async function processOptions(cliOptions, odataOptions) {
@@ -359,14 +340,28 @@ async function _updatePackageJson(dest, services, kind, cwd, config) {
     }
 }
 
+function _parseValidJsonConfig(config) {
+    try {
+        if (config) {
+            return JSON.parse(config);
+        }
+    } catch (error) {
+        throw new Error(messages.SPECIFY_CONFIG);
+    }
+}
+
 async function postProcess(filePath, options, csn, cwd) {
     const services = _getServiceNames(csn);
-    let config = await isValidJsonObject(options);
-    if (options.out) options.out = _validateAndComputeOutputFilePath(options.out, options.as, filePath);
+    let config = _parseValidJsonConfig(options.config);
+    const external = path.resolve(cwd, 'srv/external');
+    const destFilePath = path.join(external, path.basename(filePath));
+    if (options.out) options.out = _validateAndComputeOutputFilePath(options.out, options.as, destFilePath);
     const kind = options.inputFileKind;
-    const result = await _getResult(csn, options.as, options.out || filePath.replace(/\.[^.]+$/, ''), options.force, kind);
+    const result = await _getResult(csn, options.as, options.out || destFilePath.replace(/\.[^.]+$/, ''), options.force, kind);
     const written = options.dry || await _write(result, services, cwd);
     const registered = options.dry || options.no_save || await _updatePackageJson(result[1].replace(/\.[^.]+$/, ''), services, kind, cwd, config);
+    if (!options.dry && !options.no_copy)
+        await _copyToSrvExternal(filePath, destFilePath, cwd);
     if (options.dry) return console.log(result[0]);
     return Promise.all([written, registered]);
 }

package/lib/import/odata/metadataconverter/MetadataConverter.js

@@ -1025,7 +1025,6 @@ MetadataConverter.Context = Context;
 * @param {Object} result The metadata abstract syntax tree of the depended metadata document
 */
 
-
 /**
 * This callback is displayed as part of the DefaultXmlStrategy class.
 * This factory is called when the converter can not find a needed type within the current metadata document.
@@ -1073,7 +1072,6 @@ The result must be returned via 'return' statement.
 * @returns {Expression} The expression to interpret the current element node
 */
 
-
 /**
 * This callback is displayed as part of the DefaultXmlStrategy class.
 * This callback is called on finishing a strategy.
@@ -1083,7 +1081,6 @@ The result must be returned via 'return' statement.
 * @param {Any} result The output of the Strategy
 */
 
-
 class DefaultXmlStrategy extends Strategy {
     constructor(options) {
         super(undefined, options);
@@ -1243,7 +1240,6 @@ class DefaultXmlStrategy extends Strategy {
 }
 MetadataConverter.DefaultXmlStrategy = DefaultXmlStrategy;
 
-
 class EdmxRootExpression extends Expression {
     constructor(element, expression, context) { super(element, expression, context); }
     interpret() {
@@ -1441,7 +1437,6 @@ class AbstractLogicalExpression extends Expression {
     }
 }
 
-
 class AndExpression extends AbstractLogicalExpression {
     constructor(element, expression, context) { super(element, expression, context, '$And'); }
 }
@@ -1671,8 +1666,18 @@ class PropertyValueExpression extends Expression {
         this.setTarget(target);
         this.buildTypeCollectionAndFacets('$Type');
 
+        /**
+         * We can have instances of EDMX where we see value for a particular attribute as:
+         * AnnotationPath="part/icipants/@UI.LineItem" or Path="SAP__Messages/random”, etc
+         * 
+         * In such cases we need to replace '/' with '.' and only then the CSN generated will
+         * be treated correctly in the later steps.
+         * * For now this is only done for AnnotationPath value in #1680 to resolve an issue
+         * * TODO: In future we might have to do it for many such value.
+         */
         if (element.attributes.Path) target[name] = { "=": element.attributes.Path };
         if (element.attributes.PropertyPath) target[name] = { "=": element.attributes.PropertyPath };
+        if (element.attributes.AnnotationPath) target[name] = { "=": (element.attributes.AnnotationPath).replaceAll('/', '.') };
         if (element.attributes.EnumMember) target[name] = { "#": element.attributes.EnumMember.substring(element.attributes.EnumMember.lastIndexOf('/') + 1) };
         if (element.attributes.NavigationPropertyPath) target[name] = { "=": element.attributes.NavigationPropertyPath };
         if (element.attributes.String) target[name] = element.attributes.String;
@@ -1684,8 +1689,8 @@ class PropertyValueExpression extends Expression {
         if (element.attributes.Bool) target[name] = element.attributes.Bool === 'true';
         /**
          * If the property valus is of type `Date`, import it as a string itself
-         * <PropertyValue Property="Date" Date="2021-08-24" />
-         * We might have to have a strict check in the futore.. 'YYYY-MM_DD`
+         * <PropertyValue Property="Date" Date="2021-08-24"/>
+         * We might have to have a strict check in the future.. 'YYYY-MM_DD`
          */
         if (element.attributes.Date) target[name] = element.attributes.Date;
 
@@ -2411,7 +2416,6 @@ class OnDeleteExpression extends Expression {
 
 }
 
-
 MetadataConverter.createOdataV4MetadataXmlToOdataV4CsdlStrategy = (name_space) => {
     MetadataConverter.custom_namespace = name_space;
     return new MetadataConverter.DefaultXmlStrategy()