@sap/cds 5.7.3 → 5.8.1

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

@@ -1,90 +1,118 @@
-
-const {fse} = require('@sap/cds-foss');
+const cp = require('child_process');
 const os = require('os');
 const path = require('path');
+const util = require('util');
+
+const { fse } = require('@sap/cds-foss');
 
 const { BuildTaskEngine, BuildTaskFactory } = require('../../build');
 const buildConstants = require('../../build/constants');
+
 const cds = require('../../../lib');
+const LOG = cds.log ? cds.log('deploy') : console;
+
 const cfUtil = require('./cfUtil');
-const { defaultLogger, nullLogger } = require('./logger');
 const hdiDeployUtil = require('./hdiDeployUtil');
+const gitUtil = require('./gitUtil');
 const mtaUtil = require('../../build/mtaUtil');
-const runCommand = require('./runCommand');
-const { bold, info } = require('../../utils/term');
 
+const { bold, info } = require('../../utils/term');
 
 const IS_WIN = (os.platform() === 'win32');
 const UTF_8 = 'utf-8';
 
 
-const DEBUG = process.env.DEBUG;
-
 class HanaDeployer {
 
-  async deploy(model, serviceName, noSave, tunnelAddress, buildTaskOptions, vcapFile, undeployWhitelist, hdiOptions = {}, logger = defaultLogger) { // NOSONAR
+  constructor() {
+    this.execAsync = util.promisify(cp.exec);
+    this.spawnSync = cp.spawnSync;
+  }
+
+
+  async deploy(model, serviceName, noSave, tunnelAddress, buildTaskOptions, vcapFile, undeployWhitelist, hdiOptions, bindCallback, logger = LOG) { // NOSONAR
+    hdiOptions = hdiOptions || {}
+    this.logger = logger;
 
-    logger.log(`[cds.deploy] - ${bold('Starting deploy to SAP HANA ...')}`);
-    logger.log();
+    this.logger.log(`${bold('Starting deploy to SAP HANA ...')}`);
+    if (bindCallback) {
+      this.logger.log('Using advanced mode');
+    }
+    this.logger.log();
 
     const projectPath = path.resolve(process.env._TEST_CWD || process.cwd());
 
-    const { buildResults } = await this._build(buildTaskOptions, model, logger);
+    const { buildResults } = await this._build(buildTaskOptions, model);
 
     let vcapServices;
     if (vcapFile) {
-      logger.log();
-      logger.log(`[cds.deploy] - Using vcap file ${vcapFile} (beta feature).`);
+      this.logger.log();
+      this.logger.log(`Using vcap file ${vcapFile} (beta feature).`);
       vcapServices = await this._loadVCAPServices(vcapFile);
     }
 
     for (const buildResult of buildResults) {
+      let serviceKeyName;
       const currentModelFolder = buildResult.result.dest;
 
       if (undeployWhitelist) {
-        logger.log('[cds.deploy] - Writing undeploy.json');
+        this.logger.log('Writing undeploy.json');
         await fse.writeJSON(path.join(currentModelFolder, 'undeploy.json'), undeployWhitelist);
       }
 
       if (vcapFile) {
         await fse.mkdirp(currentModelFolder);
       } else {
-        const { cfServiceInstanceName, serviceKey } =
-          await this._getOrCreateCFService(projectPath, currentModelFolder, serviceName, tunnelAddress, logger);
+        const { cfServiceInstanceName, cfServiceInstanceKeyName, serviceKey } =
+          await this._getOrCreateCFService(projectPath, currentModelFolder, serviceName, tunnelAddress);
+        serviceKeyName = cfServiceInstanceKeyName;
+        serviceName = serviceName || cfServiceInstanceName;
 
         vcapServices = this._getVCAPServicesEntry(cfServiceInstanceName, serviceKey);
 
-        if (!noSave) {
-          await this._addInstanceToDefaultEnvJson([currentModelFolder, projectPath], cfServiceInstanceName, serviceKey, logger);
+        if (!noSave && !bindCallback) {
+          await this._addInstanceToDefaultEnvJson([currentModelFolder, projectPath], cfServiceInstanceName, serviceKey);
         }
       }
 
       // Check if deployer is already installed, otherwise only install this one, not the rest of dependencies.
-      if (!await hdiDeployUtil.findHdiDeployLib(currentModelFolder, logger)) {
-        const { deployerName, deployerVersionSpec } = hdiDeployUtil
-        logger.log(`[cds.deploy] - installing ${deployerName}`);
-        await runCommand('npm', ['install', `${deployerName}@${deployerVersionSpec}`,
-          (noSave ? '--no-save' : '--save-dev')], logger, {
+      if (!await hdiDeployUtil.findHdiDeployLib(currentModelFolder)) {
+        const { deployerName, deployerVersionSpec } = hdiDeployUtil;
+        this.logger.log(`Installing ${deployerName}`);
+
+        // spawn has not callback and cannot be promisified, using sync instead
+        this.spawnSync(`npm`, [`install`, `${deployerName}@${deployerVersionSpec}`, (noSave ? '--no-save' : '--save-dev')], {
           cwd: currentModelFolder,
           shell: IS_WIN,
           stdio: 'inherit',
-          env: { NODE_ENV: 'development' }  // for 'install --save-dev' to work, there must be no 'production' set
+          env: {
+            ...process.env,
+            NODE_ENV: 'development' // for 'install --save-dev' to work, there must be no 'production' set
+          }
         });
       }
 
-      await hdiDeployUtil.deploy(currentModelFolder, vcapServices, hdiOptions, logger);
+      await hdiDeployUtil.deploy(currentModelFolder, vcapServices, hdiOptions);
+
+      if (bindCallback) {
+        const args = [path.relative(projectPath, buildResult.task.src)];
+        const options = { to: `${serviceName}:${serviceKeyName}`, kind: buildResult.task.for }
+        await bindCallback(args, options, LOG);
+      }
     }
 
-    await this._addToGitignore(projectPath, 'default-env.json', logger);
+    if (!bindCallback) {
+      await gitUtil.ensureFileIsGitignored('default-env.json', projectPath);
+    }
 
-    logger.log(`[cds.deploy] - If not already done, use ${info('cds add hana')} to configure the project for SAP HANA.\n`);
-    logger.log(`[cds.deploy] - Done.`);
+    this.logger.log(`If not already done, use ${info('cds add hana')} to configure the project for SAP HANA.\n`);
+    this.logger.log(`Done.`);
 
     return { buildResults };
   }
 
 
-  async _getOrCreateCFService(projectPath, currentModelFolder, serviceName, tunnelAddress, logger) {
+  async _getOrCreateCFService(projectPath, currentModelFolder, serviceName, tunnelAddress) {
     const modelName = path.basename(currentModelFolder);
 
     // get from param
@@ -93,77 +121,75 @@ class HanaDeployer {
     if (serviceName) {
       cfServiceInstanceName = serviceName;
     } else {
-      const cfServiceDescriptor = await mtaUtil.getHanaDbModuleDescriptor(projectPath, modelName, logger);
+      const cfServiceDescriptor = await mtaUtil.getHanaDbModuleDescriptor(projectPath, modelName, this.logger);
       cfServiceInstanceName = cfServiceDescriptor.hdiServiceName;
       cfServiceInstanceMta = cfServiceDescriptor.hdiService
     }
 
-    logger.log();
+    this.logger.log();
     this._validateServiceInstanceName(cfServiceInstanceName);
-    logger.log(`[cds.deploy] - Using container ${bold(cfServiceInstanceName)}`);
+    this.logger.log(`Using container ${bold(cfServiceInstanceName)}`);
 
     let cfConfig = cfServiceInstanceMta && cfServiceInstanceMta.parameters && cfServiceInstanceMta.parameters.config;
-    await this.createHanaService(cfServiceInstanceName, cfConfig, logger);
+    const serviceInstance = await this.createHanaService(cfServiceInstanceName, cfConfig);
 
     const cfServiceInstanceKeyName = `${cfServiceInstanceName}-key`;
-    let serviceKey = await cfUtil.getServiceKey(cfServiceInstanceName, cfServiceInstanceKeyName);
-    if (!serviceKey) {
-      serviceKey = await cfUtil.createServiceKey(cfServiceInstanceName, cfServiceInstanceKeyName, logger);
-    }
+    let serviceKey = await cfUtil.getOrCreateServiceKey(serviceInstance, cfServiceInstanceKeyName);
     this._validateServiceKey(serviceKey, cfServiceInstanceKeyName);
 
     if (tunnelAddress) {
-      logger.log(`[cds.deploy] - Using tunnel address ${bold(tunnelAddress)} (beta feature)`);
+      this.logger.log(`Using tunnel address ${bold(tunnelAddress)} (beta feature)`);
       serviceKey = this._injectTunnelAddress(serviceKey, tunnelAddress)
     }
 
-    return { cfServiceInstanceName, serviceKey }
+    return { cfServiceInstanceName, cfServiceInstanceKeyName, serviceKey, serviceInstance }
   }
 
-  async createHanaService(instanceName, cfConfig, logger) {
+
+  async createHanaService(instanceName, cfConfig) {
     // hana or hanatrial, error if neither found
     try {
-      return await cfUtil.createService('hana', 'hdi-shared', instanceName, cfConfig, logger);
+      return await cfUtil.getOrCreateService('hana', 'hdi-shared', instanceName, cfConfig);
     } catch (error) {
       if (error.command && /offering .* not found/i.test(error.command.stderr)) {
-        logger.log(`[cds.deploy] - Falling back to 'hanatrial'`);
-        return await cfUtil.createService('hanatrial', 'hdi-shared', instanceName, cfConfig, logger);
+        this.logger.log(`Falling back to 'hanatrial'`);
+        return await cfUtil.getOrCreateService('hanatrial', 'hdi-shared', instanceName, cfConfig);
       }
       else if (error.command && /no database/i.test(error.command.stderr)) {
-        logger.log(`[cds.deploy] - No database connected to 'hana' service. Falling back to 'hanatrial'`);
-        return await cfUtil.createService('hanatrial', 'hdi-shared', instanceName, cfConfig, logger);
+        this.logger.log(`No database connected to 'hana' service. Falling back to 'hanatrial'`);
+        return await cfUtil.getOrCreateService('hanatrial', 'hdi-shared', instanceName, cfConfig);
       }
       throw error;
     }
   }
 
 
-
   _validateServiceKey(serviceKey, cfServiceInstanceKey) {
     if (!serviceKey) {
-      throw new Error(`[cds.deploy] - Could not create service key ${bold(cfServiceInstanceKey)}.`);
+      throw new Error(`Could not create service key ${bold(cfServiceInstanceKey)}.`);
     }
 
     const fields = ['schema', 'user', 'password', 'url'];
     for (const field of fields) {
       if (!serviceKey[field]) {
-        throw new Error(`[cds.deploy] - Service key is missing mandatory field '${field}'. Make sure you are ${bold('not')} using a managed service.`);
+        throw new Error(`Service key is missing mandatory field '${field}'. Make sure you are ${bold('not')} using a managed service.`);
       }
     }
   }
 
 
-  async _build(buildTaskOptions, model, logger) {
+  async _build(buildTaskOptions, model) {
     buildTaskOptions = buildTaskOptions || {
-      root: process.env._TEST_CWD || process.cwd()
+      root: process.env._TEST_CWD || process.cwd(),
+      cli: true
     };
 
     if (typeof model === 'string') {
       model = [model];
     }
 
-    logger.log(`[cds.deploy] - Creating build tasks`);
-    const buildTaskFactory = new BuildTaskFactory((DEBUG ? logger : nullLogger), cds);
+    this.logger.log(`Creating build tasks`);
+    const buildTaskFactory = new BuildTaskFactory(null, cds);
     const allTasks = await buildTaskFactory.getTasks(buildTaskOptions);
 
     const hanaTasks = allTasks.filter((task => {
@@ -185,9 +211,9 @@ class HanaDeployer {
       });
     }
 
-    logger.log(`[cds.deploy] - Running build`);
+    this.logger.log(`Running build`);
 
-    const buildResults = await new BuildTaskEngine((DEBUG ? logger : nullLogger)).processTasks(hanaTasks, buildTaskOptions);
+    const buildResults = await new BuildTaskEngine().processTasks(hanaTasks, buildTaskOptions);
     return { buildResults, allTasks }
   }
 
@@ -206,7 +232,7 @@ class HanaDeployer {
   }
 
 
-  async _addInstanceToDefaultEnvJson(currentFolders, serviceInstanceName, serviceKey, logger) {
+  async _addInstanceToDefaultEnvJson(currentFolders, serviceInstanceName, serviceKey) {
     for (const currentFolder of currentFolders) {
       let defaultEnvJson = {};
       const defaultEnvJsonPath = path.join(currentFolder, 'default-env.json');
@@ -230,7 +256,7 @@ class HanaDeployer {
         ...hanaEntry
       }
 
-      logger.log(`[cds.deploy] - Writing ${defaultEnvJsonPath}`);
+      this.logger.log(`Writing ${defaultEnvJsonPath}`);
       await fse.outputJSON(defaultEnvJsonPath, defaultEnvJson, {
         spaces: 2
       });
@@ -238,42 +264,6 @@ class HanaDeployer {
   }
 
 
-  async _addToGitignore(currentFolder, entry, logger) {
-    const gitIgnorePath = path.join(currentFolder, '.gitignore');
-    let entryMustBeAdded = true;
-    try {
-      const gitCheckCmd = await runCommand('git', ['check-ignore', entry], nullLogger);
-      if (gitCheckCmd.code === 0) {
-        // git verifies the chain of gitignore files, code === 0 file is ignored
-        entryMustBeAdded = false;
-      }
-    } catch (err) {
-      // git command not available or some problem occurred
-      logger.warn(`[cds.deploy] - Error while calling git: ${err}`);
-    }
-
-    if (entryMustBeAdded) {
-      let gitIgnore = '';
-      try {
-        gitIgnore = await fse.readFile(gitIgnorePath, UTF_8);
-        if (gitIgnore.indexOf(entry) >= 0) {
-          // entry exists in file
-          return;
-        }
-      } catch (err) {
-        // ignore file not found
-      }
-
-      logger.log(`[cds.deploy] - Adding ${entry} to ${gitIgnorePath}`);
-      gitIgnore = `${gitIgnore.trim()}
-
-# added by cds deploy
-${entry}
-`;
-      await fse.outputFile(gitIgnorePath, gitIgnore);
-    }
-  }
-
   _getVCAPServicesEntry(serviceInstanceName, serviceKey) {
     return {
       hana: [
@@ -290,10 +280,11 @@ ${entry}
   _validateServiceInstanceName(serviceInstanceName) {
     // valid service name chars: alpha-numeric, hyphens, and underscores
     if (/[^\w-_]+/g.exec(serviceInstanceName)) {
-      throw new Error(`[cds.deploy] - Service name ${serviceInstanceName} must only contain alpha-numeric, hyphens, and underscores.`);
+      throw new Error(`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'`)
@@ -308,6 +299,14 @@ ${entry}
     return serviceKey
   }
 
+
+  async readFileSafely(file) {
+    try {
+      return await fse.readFile(file, 'utf8');
+    } catch (err) {
+      return '';
+    }
+  }
 }
 
 module.exports = new HanaDeployer();

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

@@ -4,7 +4,9 @@ const util = require('util');
 
 const execAsync = util.promisify(cp.exec);
 
-const { nullLogger } = require('./logger');
+const cds = require('../../../lib');
+const { SILENT } = cds.log.levels;
+const LOG = cds.log ? cds.log('deploy') : console;
 
 class HdiDeployUtil {
 
@@ -14,41 +16,49 @@ class HdiDeployUtil {
         this.deployerVersionSpec = '^4'
     }
 
-    async deploy(dbDir, vcapServices, options = {}, logger = nullLogger) {
-        logger.log();
-        logger.log(`[cds.deploy] - Deploying to HANA from ${dbDir}`);
+    async deploy(dbDir, vcapServices, options = {}) {
+        LOG.log();
+        LOG.log(`Deploying to HANA from ${dbDir}`);
 
-        let deployerEnv = JSON.parse(JSON.stringify(process.env)); // deep copy
-        const hdiDeployLib = await this._getHdiDeployLib(dbDir, logger);
-        if (hdiDeployLib.clean_env) {
+        const hdiDeployLib = await this._getHdiDeployLib(dbDir);
+
+        let 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);
         }
 
         deployerEnv.VCAP_SERVICES = JSON.stringify(vcapServices);
 
         if (options.autoUndeploy) {
-            logger.log(`[cds.deploy] - Hdi deployer automatically undeploys deleted resources using --auto-undeploy.`);
-            deployerEnv.HDI_DEPLOY_OPTIONS = JSON.stringify({
-                'auto_undeploy': true
-            });
+            LOG.log(`Hdi deployer automatically undeploys deleted resources using --auto-undeploy.`);
+            hdiDeployOptions.auto_undeploy = true;
+        }
+
+        if (Object.entries(hdiDeployOptions).length > 0) {
+            deployerEnv.HDI_DEPLOY_OPTIONS = JSON.stringify(hdiDeployOptions);
         }
 
-        await this._executeDeploy(dbDir, deployerEnv, logger);
+        await this._executeDeploy(dbDir, deployerEnv);
     }
 
+
     async findHdiDeployLib(cwd) {
         const searchPaths = await this._npmSearchPaths(cwd)
         try {
-            return require.resolve(path.join(this.deployerName, 'library'), {paths: searchPaths});
+            return require.resolve(path.join(this.deployerName, 'library'), { paths: searchPaths });
         } catch (err) {
             // no luck
         }
     }
 
-    async _getHdiDeployLib(dbDir, logger) {
+
+    async _getHdiDeployLib(dbDir) {
         let hdiDeployLib = this.hdiDeployLibs.get(dbDir)
         if (!hdiDeployLib) {
-            hdiDeployLib = await this._loadHdiDeployLib(dbDir, logger);
+            hdiDeployLib = await this._loadHdiDeployLib(dbDir);
             this.hdiDeployLibs.set(dbDir, hdiDeployLib);
         }
 
@@ -56,46 +66,51 @@ class HdiDeployUtil {
     }
 
 
-    async _loadHdiDeployLib(cwd, logger = nullLogger) {
+    async _loadHdiDeployLib(cwd) {
         const libPath = await this.findHdiDeployLib(cwd)
         if (!libPath) {
             const searchPaths = await this._npmSearchPaths(cwd)
-            throw new Error(`[cds.deploy] - Required library '${this.deployerName}' not found in
+            throw new Error(`Required library '${this.deployerName}' not found in
     ${searchPaths.join('\n    ')}
 Add it either as a devDependency using 'npm install -D ${this.deployerName}' or install it globally using 'npm install -g ${this.deployerName}'.`);
         }
 
-        logger.log(`[cds.deploy] - Using HDI deployer from ${libPath}`)
+        LOG.log(`Using HDI deployer from ${libPath}`)
 
         // let any error go through and abort deploy
         return require(libPath);
     }
 
 
-    async _npmSearchPaths (cwd) {
+    async _npmSearchPaths(cwd) {
         const npmRootCall = await execAsync('npm root -g');
         const globalNodeModules = npmRootCall.stdout.toString().trim();
         return [cwd, globalNodeModules]
     }
 
 
-    async _executeDeploy(dbDir, env, logger = nullLogger) {
-        const hdiDeployLib = await this._getHdiDeployLib(dbDir, logger);
+    async _executeDeploy(dbDir, env) {
+        const hdiDeployLib = await this._getHdiDeployLib(dbDir);
         return new Promise((resolve, reject) => {
+            const callbacks = {
+                stderrCB: error => LOG.error(error.toString())
+            }
+            if (LOG.level !== SILENT) {
+                callbacks.stdoutCB = (data) => console.log(data.toString());
+            }
+
             hdiDeployLib.deploy(dbDir, env, (error, response) => {
                 if (error) {
                     return reject(error);
                 }
                 if (response && response.exitCode && response.exitCode !== 0) {
-                    let message = `[cds.deploy] - HDI deployment failed with exit code ${response.exitCode}`
-                    if (response.signal)  message += `. ${response.signal}`
+                    let message = `HDI deployment failed with exit code ${response.exitCode}`
+                    if (response.signal) message += `. ${response.signal}`
                     return reject(new Error(message));
                 }
                 return resolve();
-            }, {
-                    stdoutCB: data => logger.debug(data.toString()),
-                    stderrCB: error => logger.error(error.toString())
-                });
+            }, callbacks
+            );
         });
     }
 }

package/bin/deploy/to-hana/index.js

@@ -1,15 +1,16 @@
-exports.deploy =  (_model, _dbSpecificParameter, {
-    'no-save':no_save,
-    'auto-undeploy': autoUndeploy = false,
-    'tunnel-address': tunnelAddress,
-    'vcap-file': vcapFile
-  }) => {
-    const hanaDeployer = require('./hana');
+exports.deploy = (_model, _dbSpecificParameter, {
+  'no-save': no_save,
+  'auto-undeploy': autoUndeploy = false,
+  'tunnel-address': tunnelAddress,
+  'vcap-file': vcapFile,
+}, bindCallback) => {
+  const hanaDeployer = require('./hana');
 
-    return hanaDeployer.deploy (
-        _model,  _dbSpecificParameter,
-        no_save, tunnelAddress,
-        null, vcapFile, null,
-        { autoUndeploy }
-    )
+  return hanaDeployer.deploy(
+    _model, _dbSpecificParameter,
+    no_save, tunnelAddress,
+    null, vcapFile, null,
+    { autoUndeploy },
+    bindCallback
+  )
 }

package/bin/mtx/in-cds.js

@@ -2,6 +2,7 @@ const cds = require('../build/cds')
 if (cds.requires.multitenancy) try {
     const mtx = module.exports = require ('@sap/cds-mtx')()
     mtx.inject (cds)
+    cds.on('served', () => cds.emit('mtx'))
 } catch(e) {
    if (e.code === 'MODULE_NOT_FOUND') throw new Error('Error serving MTX APIs: @sap/cds-mtx is not installed')
    else throw e

package/bin/serve.js

@@ -194,7 +194,7 @@ function _local_server_js() {
   if (server_js) {
     log && log ('Loading server from', { file: local(server_js) })
     const fn = require (server_js)
-    return typeof fn === 'function' ? fn : cds.error `${local(server_js)} must export a function`
+    return typeof fn === 'function' ? fn : cds.server
   }
 }
 

package/bin/version.js

@@ -54,6 +54,7 @@ function info(o) {
   const main = _findPackage (require.main.filename)
   return {
     ..._versions4(main, {}, true),  // usually sap/cds-dk or sap/cds
+    ..._versions4('@sap/cds-dk', {}, null, o),  // make sure cds-dk is there, cds-maven-plugin uses it
     ..._versions4('@sap/eslint-plugin-cds', {}, null, o),
     ..._versions4(process.cwd(), {}, null, o),
     ..._versions4('..', {}, null, o),

package/lib/compile/cdsc.js

@@ -3,12 +3,6 @@ const constraints = {
   assertIntegrity: features.assert_integrity,
   assertIntegrityType: features.assert_integrity_type
 }
-// REVISIT: remove with compiler ^2.11
-const { assertIntegrity: ai, assertIntegrityType: ait } = constraints
-if ((typeof ai === 'string' && ai.match(/individual/i)) || (ait && ait.match(/db/i))) {
-  cdsc.beta = cdsc.beta || {}
-  cdsc.beta.foreignKeyConstraints = true
-}
 const compile = require ('@sap/cds-compiler')
 const _4cdsc = Symbol('_4cdsc')
 

package/lib/compile/minify.js

@@ -35,7 +35,7 @@ module.exports = function cds_minify (csn, _roots = global.cds.env.features.skip
       if (d.startsWith('cds.')) return
       else d = all[d]
     } else if (d.ref) return d.ref.reduce((p,n) => {
-      let d = p.elements[n.id || n] // > n.id -> view with parameters
+      let d = (p.elements || csn.definitions[p.target].elements)[n.id || n] // > n.id -> view with parameters
       _visit(d)
       return d
     },{elements:all})

package/lib/compile/resolve.js

@@ -27,7 +27,7 @@ module.exports = exports = function cds_resolve (model, o={}) { // NOSONAR
   if (id in cached && !o.skipModelCache)  return cached[id]
 
   // expand @sap/cds by cds.home
-  if (id.startsWith('@sap/cds')) id = global.cds.home +'/'+ id.slice(8)
+  if (id.startsWith('@sap/cds/')) id = global.cds.home + id.slice(8)
 
   // fetch file with .cds/.csn suffix as is
   if (/\.(csn|cds)$/.test(id)) try {

package/lib/compile/to/srvinfo.js

@@ -37,7 +37,7 @@ module.exports = (model, options={}) => {
   function _makeNode(service) {
     return {
       name: service.name,
-      urlPath: _url4 (cds.serve.path4(service)),
+      urlPath: _url4 (cds.service.path4(service)),
       destination: 'srv-api', // the name to register in xs-app.json
       runtime: 'Node.js',
       location: service.$location

package/lib/core/classes.js

@@ -23,7 +23,27 @@ class any {
 class type extends any {}
 class action extends any {}
 class context extends any {}
-class service extends context {}
+
+class service extends context {
+
+  get path() { return super.path = service.path4(this) }
+
+  /**
+   * Resolve a service endpoint path to mount it to as follows...
+   * Use _path or def[@path] if given with leading '/' prepended if necessary.
+   * Otherwise, use the service definition name with stripped 'Service'
+   */
+  static path4 (srv, _path = (srv.definition || srv)['@path']) {
+    if (_path) return _path.startsWith('/') ? _path : '/'+_path
+    else return '/' + ( // return a sluggified variant of the service's name
+      /[^.]+$/.exec(srv.name)[0]  //> my.very.CatalogService --> CatalogService
+      .replace(/Service$/,'')     //> CatalogService --> Catalog
+      .replace(/_/g,'-')          //> foo_bar_baz --> foo-bar-baz
+      .replace(/([a-z0-9])([A-Z])/g, (_,c,C) => c+'-'+C)  //> ODataFooBarX9 --> OData-Foo-Bar-X9
+      .toLowerCase()      //> FOO --> foo
+    )
+  }
+}
 
 class array extends type { is(kind) { return kind === 'array' || super.is(kind) }}
 class aspect extends type { is(kind) { return kind === 'aspect' || super.is(kind) }}

package/lib/env/index.js

@@ -338,7 +338,8 @@ function _merge (dst, src, _profiles, _cloned, _profiles_only = false) {
     const v = pd.value
     if (typeof v === 'object' && !Array.isArray(v)) {
       if (!dst[p]) dst[p] = {}; else if (_cloned)  dst[p] = _cloned(dst[p])
-      _merge (dst[p], v, _profiles, _cloned, _profiles_only)
+      if (typeof dst[p] !== 'object') dst[p] = v
+      else _merge (dst[p], v, _profiles, _cloned, _profiles_only)
       continue
     }
 
@@ -453,7 +454,7 @@ function _readJson (file) {
 }
 
 function _determineProfilesFrom (env = process.env) {
-  if (env.NODE_ENV !== 'production' && !/\bdevelopment\b/.test(env.CDS_ENV)) {
+  if (env.NODE_ENV !== 'production' && !/\b(development|production)\b/.test(env.CDS_ENV)) {
     if (env.CDS_ENV)  env.CDS_ENV += ',development'
     else  env.CDS_ENV = 'development'
   }

package/lib/env/requires.js

@@ -31,6 +31,9 @@ module.exports = {
   "xsuaa-auth": {
     strategy: 'xsuaa',
   },
+  "dwc-auth": {
+    strategy: 'dwc',
+  },
   destinations: {
     vcap: {
       label: 'destination'
@@ -93,6 +96,7 @@ module.exports = {
   },
   "enterprise-messaging-http": {
     outbox: {},
+    deployForProvider: true,
     impl: `${_runtime}/messaging/enterprise-messaging.js`,
     vcap: { label: "enterprise-messaging" },
   },