@sap/cds-dk 7.9.6 → 8.0.3

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

@@ -36,7 +36,7 @@ module.exports = new class HanaDeployer {
   }
 
   async deploy(options = {}) {
-    let { model, serviceName, tunnelAddress, vcapFile, undeployWhitelist, hdiOptions = {}, dry, storeCredentials } = options;
+    let { model, serviceName: pServiceName, tunnelAddress, vcapFile, undeployWhitelist, hdiOptions = {}, dry, storeCredentials } = options;
 
     options.for = options.for || 'hybrid';
 
@@ -51,7 +51,7 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
     }
 
     if (vcapFile) {
-      console.log(`Using VCAP_SERVICES from file ${vcapFile} (beta feature).`);
+      console.log(`Using VCAP_SERVICES from file ${vcapFile}.`);
     }
 
     const fromFile = vcapFile && exists(vcapFile) ? await read(vcapFile) : {};
@@ -59,23 +59,22 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
     const vcapEnv = { ...fromEnv, ...fromFile };
 
     const warnings = [];
-    if (serviceName && vcapEnv.VCAP_SERVICES?.hana?.[0].name !== serviceName) {
+    if (pServiceName && vcapEnv.VCAP_SERVICES?.hana?.[0].name !== pServiceName) {
       if (vcapFile) {
-        warnings.push(`The specified service name '${serviceName}' was used; the information coming from --vcap-service file was ignored.`);
+        warnings.push(`The specified service name '${pServiceName}' was used; the information coming from --vcap-service file was ignored.`);
       } else if (Object.keys(fromEnv).length > 0) {
-        warnings.push(`The specified service name '${serviceName}' was used; the information coming from environment variable VCAP_SERVICES was ignored.`);
+        warnings.push(`The specified service name '${pServiceName}' was used; the information coming from environment variable VCAP_SERVICES was ignored.`);
       }
     }
 
-    const projectPath = cds.root;
     const buildResults = await this._build();
 
     if (process.env.TARGET_CONTAINER) {
       vcapEnv.TARGET_CONTAINER = process.env.TARGET_CONTAINER;
     }
 
-    if (dry) {
-      for (const { task } of buildResults) {
+    for (const { task } of buildResults) {
+      if (dry) {
         const model = await cds.load(task.src);
         const data = cds.compile.to.hdbtable(model);
         for (const [src, { file }] of data) {
@@ -83,23 +82,27 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
           console.log(src);
           console.log();
         }
-      }
-    } else {
-      for (const { task } of buildResults) {
+      } else {
         const dest = task.dest;
 
+        let serviceName = pServiceName;
+        let serviceKeyName;
+        if (!serviceName && cds.env.requires.db?.binding?.instance) {
+          serviceName = cds.env.requires.db.binding.instance;
+          serviceKeyName = cds.env.requires.db.binding.key;
+        }
+
         if (undeployWhitelist) {
           console.log('Writing undeploy.json');
           await fs.write(path.join(dest, 'undeploy.json'), JSON.stringify(undeployWhitelist, null, 2));
         }
 
         const hasVCAPEnv = Object.keys(vcapEnv).length > 0;
-        let serviceKeyName
         if (!serviceName && hasVCAPEnv) {
           await fs.mkdir(dest, { recursive: true });
         } else {
           const { cfServiceInstanceName, cfServiceInstanceKeyName, serviceKey } =
-            await this._getOrCreateCFService(projectPath, dest, serviceName, tunnelAddress);
+            await this._getOrCreateCFService(dest, serviceName, serviceKeyName, tunnelAddress);
 
           serviceName ??= cfServiceInstanceName;
           serviceKeyName ??= cfServiceInstanceKeyName
@@ -108,7 +111,7 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
           }
 
           if (storeCredentials) {
-            await this._addInstanceToDefaultEnvJson([dest, projectPath], cfServiceInstanceName, serviceKey);
+            await this._addInstanceToDefaultEnvJson([dest, cds.root], cfServiceInstanceName, serviceKey);
           }
         }
 
@@ -129,7 +132,7 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
       }
 
       if (storeCredentials) {
-        await gitUtil.ensureFileIsGitignored('default-env.json', projectPath);
+        await gitUtil.ensureFileIsGitignored('default-env.json', cds.root);
       }
 
       console.log(`If not already done, use ${info('cds add hana')} to configure the project for SAP HANA.\n`);
@@ -146,7 +149,7 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
   }
 
 
-  async _getOrCreateCFService(projectPath, currentModelFolder, serviceName, tunnelAddress) {
+  async _getOrCreateCFService(currentModelFolder, serviceName, serviceKeyName, tunnelAddress) {
     const modelName = path.basename(currentModelFolder);
 
     // get from param
@@ -155,7 +158,7 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
     if (serviceName) {
       cfServiceInstanceName = serviceName;
     } else {
-      const cfServiceDescriptor = await mtaUtil.getHanaDbModuleDescriptor(projectPath, modelName);
+      const cfServiceDescriptor = await mtaUtil.getHanaDbModuleDescriptor(cds.root, modelName);
       cfServiceInstanceName = cfServiceDescriptor.hdiServiceName;
       cfServiceInstanceMta = cfServiceDescriptor.hdiService
     }
@@ -167,16 +170,16 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
     const cfConfig = cfServiceInstanceMta?.parameters?.config;
     const serviceInstance = await this.createHanaService(cfServiceInstanceName, cfConfig);
 
-    const cfServiceInstanceKeyName = `${cfServiceInstanceName}-key`;
-    let serviceKey = await cfUtil.getOrCreateServiceKey(serviceInstance, cfServiceInstanceKeyName, { permissions: 'development' });
-    this._validateServiceKey(serviceKey, cfServiceInstanceKeyName);
+    const cfServiceInstanceKeyName = serviceKeyName ?? `${cfServiceInstanceName}-key`;
+    let credentials = await cfUtil.getOrCreateServiceKey(serviceInstance, cfServiceInstanceKeyName, { permissions: 'development' });
+    this._validateCredentials(credentials, cfServiceInstanceKeyName);
 
     if (tunnelAddress) {
       console.log(`Using tunnel address ${bold(tunnelAddress)} (beta feature)`);
-      serviceKey = this._injectTunnelAddress(serviceKey, tunnelAddress)
+      credentials = this._injectTunnelAddress(credentials, tunnelAddress)
     }
 
-    return { cfServiceInstanceName, cfServiceInstanceKeyName, serviceKey, serviceInstance }
+    return { cfServiceInstanceName, cfServiceInstanceKeyName, serviceKey: credentials, serviceInstance }
   }
 
 
@@ -198,18 +201,18 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
   }
 
 
-  _validateServiceKey(serviceKey, cfServiceInstanceKey) {
-    if (!serviceKey) {
+  _validateCredentials(credentials, cfServiceInstanceKey) {
+    if (!credentials) {
       throw `Could not create service key ${bold(cfServiceInstanceKey)}.`;
     }
 
-    if (serviceKey['sm_url']) {
+    if (credentials['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]) {
+      if (!credentials[field]) {
         throw `Service key is missing mandatory field '${field}'. Make sure you are ${bold('not')} using a managed service.`;
       }
     }
@@ -266,17 +269,17 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
   }
 
 
-  _injectTunnelAddress(serviceKey, tunnelAddress) {
+  _injectTunnelAddress(credentials, tunnelAddress) {
     if (!/\w+:\d+/.test(tunnelAddress)) {
       throw `Invalid tunnel address '${tunnelAddress}' - must be in form 'host:port'`;
     }
     const [tunnelHost, tunnelPort] = tunnelAddress.split(':')
-    const { host, port } = serviceKey
-    serviceKey.host = tunnelHost
-    serviceKey.port = tunnelPort
-    serviceKey.url = serviceKey.url.replace(`${host}:${port}`, tunnelAddress)
-    serviceKey.hostname_in_certificate = host  // make cert. verification happy, see xs2/hdideploy.js#527
-    serviceKey.url = serviceKey.url + (serviceKey.url.includes('?') ? '&' : '?') + 'hostNameInCertificate=' + host
-    return serviceKey
+    const { host, port } = credentials
+    credentials.host = tunnelHost
+    credentials.port = tunnelPort
+    credentials.url = credentials.url.replace(`${host}:${port}`, tunnelAddress)
+    credentials.hostname_in_certificate = host  // make cert. verification happy, see xs2/hdideploy.js#527
+    credentials.url = credentials.url + (credentials.url.includes('?') ? '&' : '?') + 'hostNameInCertificate=' + host
+    return credentials
   }
 }

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

@@ -12,8 +12,8 @@ module.exports = new class HdiDeployUtil {
         const { clean_env, deploy } = this._loadHdiDeployLib(dbDir);
 
         const deployerEnv = JSON.parse(JSON.stringify(process.env));
-        const hdiDeployOptions = deployerEnv.HDI_DEPLOY_OPTIONS ? JSON.parse(deployerEnv.HDI_DEPLOY_OPTIONS) : {};
-        delete hdiDeployOptions.root;
+        const options = deployerEnv.HDI_DEPLOY_OPTIONS ? JSON.parse(deployerEnv.HDI_DEPLOY_OPTIONS) : {};
+        delete options.root;
 
         clean_env?.(deployerEnv);
 
@@ -29,12 +29,15 @@ module.exports = new class HdiDeployUtil {
 
         if (autoUndeploy) {
             console.log(`HDI deployer automatically undeploys deleted resources using --auto-undeploy.`);
-            hdiDeployOptions.auto_undeploy = true;
+            options.auto_undeploy = true;
         }
 
-        if (Object.entries(hdiDeployOptions).length > 0) {
-            deployerEnv.HDI_DEPLOY_OPTIONS = JSON.stringify(hdiDeployOptions);
+        try { require.resolve('hdb') } catch (e) {
+          if (e.code === 'MODULE_NOT_FOUND') options.use_hdb = false
+          else throw e
         }
+        if (options.use_hdb !== false) options.use_hdb = true
+        deployerEnv.HDI_DEPLOY_OPTIONS = JSON.stringify(options)
 
         const asyncDeploy = util.promisify(deploy);
         const { exitCode, signal } = await asyncDeploy(dbDir, deployerEnv);
@@ -47,7 +50,6 @@ module.exports = new class HdiDeployUtil {
         }
     }
 
-
     _loadHdiDeployLib(cwd) {
         const searchPaths = [cwd, __dirname];
         const libPath = require.resolve(path.join(HDI_DEPLOY_LIB, 'library'), { paths: searchPaths });

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

@@ -106,7 +106,7 @@ module.exports = {
                                     },
                                     src: {
                                         type: "string",
-                                        description: "Optional: Prefer defining 'cds.folders'. Use 'src' if you want it only to be valid for this specific build task, which excludes, for example, 'cds watch'.",
+                                        description: "Optional: Prefer defining 'cds.env.folders'. Use 'src' if you want it only to be valid for this specific build task, which excludes, for example, 'cds watch'.",
                                         format: "uri-reference"
                                     },
                                     for: {

package/lib/import/common.js

@@ -75,10 +75,10 @@ async function getVersion(fileInputStream){
 
 function checkForEmptyKeys(element, oDataVersion) {
     if (oDataVersion === "V2") {
-        return (element.includes(["cds.Association"]) && !element.includes(['"on":']));
+        return (element.includes("cds.Association") || element.includes("cds.Composition") && !element.includes(['"on":']));
     }
     else {
-        return (['cds.Association'].includes(element.type)) && !element.on && !element.keys;
+        return (['cds.Association', 'cds.Composition'].includes(element.type)) && !element.on && !element.keys;
     }
 }
 

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

@@ -1,5 +1,5 @@
 'use strict';
-/* eslint-disable global-require */
+ 
 const vocabulariesMap = new Map([
     ['org.odata.core.v1', () => require('../vocabularies/Org.OData.Core.V1.json')],
     ['org.odata.aggregation.v1', () => require('../vocabularies/Org.OData.Aggregation.V1.json')],
@@ -771,21 +771,21 @@ class DefaultValueConverter {
 
         if (currentDefaultValue == null) return null;
         if (target.$Type.startsWith('Edm.')) {
-            // eslint-disable-next-line no-param-reassign
+             
             target.$DefaultValue = Expression.convertDefaultValue(target.$Type, currentDefaultValue);
             return null;
         }
         context.on('pre finalize', (callback) => {
             context.resolveType(target.$Type).then((edmType) => {
                 if (edmType instanceof TypeDefinition) {
-                    // eslint-disable-next-line no-param-reassign
+                     
                     target.$DefaultValue = Expression.convertDefaultValue(
                         edmType.getType().toString(), currentDefaultValue
                     );
                     return callback();
                 }
                 if (edmType instanceof EnumType) {
-                    // eslint-disable-next-line no-param-reassign
+                     
                     target.$DefaultValue = Expression.convertDefaultValue(
                         'EnumType', currentDefaultValue
                     );