@sap/cds-dk 7.9.5 → 8.0.2

package/lib/build/provider/internalBuildTaskProvider.js

@@ -4,25 +4,14 @@ const cds = require('../../cds')
 const { hasJavaNature, getDefaultModelOptions, BuildError, hasOptionValue, normalizePath } = require('../util')
 const BuildTaskProvider = require('../buildTaskProvider')
 const { FILE_EXT_CDS, BUILD_TASK_HANA, BUILD_TASK_FIORI, BUILD_TASK_JAVA, BUILD_TASK_JAVA_CF, BUILD_TASK_NODEJS, BUILD_TASK_NODE_CF, BUILD_TASK_MTX,
-    BUILD_TASK_PREFIX, BUILD_TASKS, BUILD_TASK_MTX_SIDECAR, MTX_SIDECAR_FOLDER, BUILD_TASK_MTX_EXTENSION, NODEJS_MODEL_EXCLUDE_LIST,
+    BUILD_TASKS, BUILD_TASK_MTX_SIDECAR, MTX_SIDECAR_FOLDER, BUILD_TASK_MTX_EXTENSION, NODEJS_MODEL_EXCLUDE_LIST,
     IGNORE_DEFAULT_MODELS, CONTENT_WS } = require("../constants")
 const ResourcesTarBuilder = require('./mtx/resourcesTarBuilder')
 const DEBUG = cds.debug('cli|build')
 
 class InternalBuildTaskProvider extends BuildTaskProvider {
-    constructor() {
-        super()
-        // ensure that classic mtx is not used in combination with cds-dk@7
-        if (InternalBuildTaskProvider._isClassicMtx()) {
-            throw new BuildError(`@sap/cds-mtx is deprecated and not supported by @sap/cds-dk >= 7.
-Upgrade to @sap/cds-mtxs following the migration guide https://cap.cloud.sap/docs/guides/multitenancy/old-mtx-migration or install @sap/cds-dk version 6 instead.`)
-        }
-    }
-
     providesTask(key) {
-        return BUILD_TASKS.includes(key.for) || key.use && key.use.startsWith(BUILD_TASK_PREFIX)
-        // REVISIT: do not support different build task implementations of the same build task ID defined by 'for'
-        // return (BUILD_TASKS.includes(key.for) && !key.use) || (key.use && key.use.startsWith(BUILD_TASK_PREFIX))
+        return BUILD_TASKS.includes(key.for)
     }
 
     async lookupTasks(tasks, dependencies) {
@@ -30,10 +19,6 @@ Upgrade to @sap/cds-mtxs following the migration guide https://cap.cloud.sap/doc
     }
 
     async applyTaskDefaults(task) {
-        const taskFor = InternalBuildTaskProvider._getForValueFromTask(task)
-        task.for = task.for || taskFor
-        task.use = task.use || `${BUILD_TASK_PREFIX}/${taskFor}`
-
         // src folder needs to be initialized first
         InternalBuildTaskProvider._setDefaultSrcFolder(task)
 
@@ -41,7 +26,7 @@ Upgrade to @sap/cds-mtxs following the migration guide https://cap.cloud.sap/doc
     }
 
     getPlugin(task) {
-        return require(`./${InternalBuildTaskProvider._getForValueFromTask(task)}`)
+        return require(`./${task.for}`)
     }
 
     async _createTasks(tasks, dependencies) {
@@ -202,7 +187,7 @@ Upgrade to @sap/cds-mtxs following the migration guide https://cap.cloud.sap/doc
             }
 
             // mtxs nodejs app without sidecar
-            if (!InternalBuildTaskProvider._hasJavaNature(src)) {
+            if (!hasJavaNature()) {
                 DEBUG?.("MTX Nodejs app without sidecar")
                 return {
                     for: BUILD_TASK_MTX,
@@ -218,7 +203,7 @@ Upgrade to @sap/cds-mtxs following the migration guide https://cap.cloud.sap/doc
             return null
         }
         let task = null
-        if (InternalBuildTaskProvider._hasJavaNature(src)) {
+        if (hasJavaNature()) {
             task = this._createJavaTask(src, taskOptions)
         } else {
             task = this._createNodeTask(src, taskOptions)
@@ -243,6 +228,9 @@ Upgrade to @sap/cds-mtxs following the migration guide https://cap.cloud.sap/doc
 
     _createNodeTask(src, taskOptions) {
         DEBUG?.("found implementation technology Nodejs")
+        if (!fs.existsSync(path.join(cds.root, 'package.json'))) {
+            throw new BuildError(`No 'package.json' found in project root folder '${cds.root}'`)
+        }
         return {
             src: src,
             for: BUILD_TASK_NODEJS,
@@ -254,17 +242,6 @@ Upgrade to @sap/cds-mtxs following the migration guide https://cap.cloud.sap/doc
         return !!cds.env.extends
     }
 
-    static _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()
-    }
-
     /**
      * Distinguishes whether the Nodejs project is a Streamlined MTX (cds >=6) or an old MTX project.
      */
@@ -303,14 +280,14 @@ Upgrade to @sap/cds-mtxs following the migration guide https://cap.cloud.sap/doc
                 task.src ||= normalizePath(cds.env.folders.srv)
                 break
             default:
-                throw new Error(`Unknown build task '${task.use || task.for}'`)
+                throw new Error(`Unknown build task '${task.for}'`)
         }
     }
 
     static async _setDefaultModel(task) {
         const ws = hasOptionValue(task.options?.[CONTENT_WS], true) || cds.cli.options?.ws
         // REVISIT: filter nodejs bootstrap service models for Java - issues/12770#issuecomment-1805719
-        const filter = this._hasJavaNature() ? (m) => !NODEJS_MODEL_EXCLUDE_LIST.includes(m) : null
+        const filter = hasJavaNature() ? (m) => !NODEJS_MODEL_EXCLUDE_LIST.includes(m) : null
         let taskModelPaths = task.options?.model
         if (taskModelPaths && !Array.isArray(taskModelPaths)) {
             taskModelPaths = [taskModelPaths]
@@ -336,19 +313,6 @@ Upgrade to @sap/cds-mtxs following the migration guide https://cap.cloud.sap/doc
         }
     }
 
-    /**
-     * Returns whether this project is a java project or not.
-     * @param {string} srv - the folder name of the service module
-     */
-    static _hasJavaNature(srv = cds.env.folders.srv) {
-        srv = this._getModuleFolder(Array.isArray(srv) ? srv : [srv])
-        return hasJavaNature([cds.root, srv && path.join(cds.root, srv)])
-    }
-
-    static _getForValueFromTask(task) {
-        return task.for ? task.for : task.use && task.use.substring(BUILD_TASK_PREFIX.length + 1)
-    }
-
     /**
      * Determines the module folder from the given list that may represent files or folders w or w/o .cds file extension.
      * @param {Array} filesOrFolders

package/lib/build/provider/java/index.js

@@ -24,9 +24,8 @@ class JavaBuildPlugin extends EdmxBuildPlugin {
         await this._compileForJava(model, compileDest)
 
         if (!this.hasBuildOption(CONTENT_EDMX, false)) {
-            // generate edmx files containing all features
-            // REVISIT: localized edmx for backward compatibility
-            if (!this.hasBuildOption(CONTENT_LOCALIZED_EDMX, false)) {
+            // generate edmx files containing all features - localized edmx for backward compatibility
+            if (this.hasBuildOption(CONTENT_LOCALIZED_EDMX, true)) {
                 await this.compileToEdmx(model, compileDest, { [FLAVOR_LOCALIZED_EDMX]: true })
             }
             // non-localized edmx

package/lib/build/provider/mtx/index.js

@@ -1,4 +1,4 @@
-/* eslint-disable no-empty */
+ 
 const fs = require('fs')
 const path = require('path')
 const cds = require('../../../cds')
@@ -9,16 +9,17 @@ const { BuildError } = require('../../util')
 
 class MtxBuildPlugin extends EdmxBuildPlugin {
     get priority() {
-        // should be scheduled after 'hana' build tasks are finished
-        return EdmxBuildPlugin.PRIORITY_MIN_VALUE
+        // must run after 'hana' build task
+        return super.priority - 10
     }
+
     init() {
         super.init()
 
         // this build task only supports nodejs mtxs apps without sidecar
         if (cds.env['project-nature'] === 'java') {
             throw new BuildError(`@sap/cds-mtx is deprecated and not supported by @sap/cds-dk >= 7. This also applies to the 'mtx' build task in Java projects.
-Upgrade to @sap/cds-mtxs following the migration guide https://cap.cloud.sap/docs/guides/multitenancy/old-mtx-migration or install @sap/cds-dk version 6 instead.`)
+Upgrade to @sap/cds-mtxs following the migration guide https://cap.cloud.sap/docs/guides/multitenancy/old-mtx-migration.`)
         }
     }
 

package/lib/build/provider/mtx-extension/index.js

@@ -133,8 +133,11 @@ class MtxExtensionBuildPlugin extends InternalBuildPlugin {
     }
 
     static _getSaasPkgPath() {
+        if (!cds.env.extends) {
+            throw new BuildError(`Missing configuration 'cds.extends' in package.json`)
+        }
         // cds.env.extends holds the SaaS app package name, also if the extends field is defined on root level
-        let saasPkgPath = this._getWorkspacePath(cds.env.extends || '_base')
+        let saasPkgPath = this._getWorkspacePath(cds.env.extends)
         if (!saasPkgPath) {
             // older projects might not have a workspace definition
             saasPkgPath = this._getNodeModulesPath(saasPkgPath)
@@ -156,7 +159,7 @@ class MtxExtensionBuildPlugin extends InternalBuildPlugin {
     }
 
     static _getNodeModulesPath() {
-        const saasPkgPath = path.join(cds.root, 'node_modules', cds.env.extends || '_base')
+        const saasPkgPath = path.join(cds.root, 'node_modules', cds.env.extends)
         if (!fs.existsSync(saasPkgPath)) {
             throw new BuildError(`The SaaS application base model is missing. Did you execute 'cds pull' and 'npm install'?`)
         }

package/lib/build/provider/mtx-sidecar/index.js

@@ -12,8 +12,8 @@ const DEFAULT_MAIN_FOLDER = "_main"
 
 class MtxSidecarBuildPlugin extends NodejsBuildPlugin {
     get priority() {
-        // should be scheduled after 'hana' build tasks are finished
-        return NodejsBuildPlugin.PRIORITY_MIN_VALUE
+        // must run after 'hana' build task
+        return super.priority - 10
     }
     init() {
         super.init()

package/lib/build/util.js

@@ -28,18 +28,9 @@ function setProperty(src, segments, value) {
 
 /**
  * Returns whether this project is a java project or not.
- * @param {Array} dirs - the absolute path names to check.
 */
-function hasJavaNature(dirs) {
-    return dirs.flat().reduce((acc, dir) => {
-        if (dir) {
-            const file = path.join(dir, 'pom.xml')
-            if (fs.existsSync(file)) {
-                acc.push(file)
-            }
-        }
-        return acc
-    }, []).length > 0
+function hasJavaNature() {
+    return [cds.env.folders.srv, '.'].some(f => f && fs.existsSync(path.join(cds.root, f, 'pom.xml')))
 }
 
 /**
@@ -176,8 +167,18 @@ async function pathExists(path) {
  * @returns the paths are relative to 'cds.root'.
  */
 async function getWorkspaces(resolve = false, devDependencies = true, wsRoot = cds.root) {
+    let pgkJsonWsRoot
+    try {
+        pgkJsonWsRoot = require(path.join(wsRoot, 'package.json'))
+    } catch (e) {
+        if (e.code === 'MODULE_NOT_FOUND') {
+            DEBUG?.(`No package.json found in project '${wsRoot}', skipping workspace resolution.`)
+            return []
+        }
+        throw e
+    }
+
     const workspaces = []
-    const pgkJsonWsRoot = require(path.join(wsRoot, 'package.json'))
     let pgkJson = pgkJsonWsRoot
     if (wsRoot !== cds.root) {
         pgkJson = require(path.join(cds.root, 'package.json'))
@@ -201,6 +202,44 @@ async function getWorkspaces(resolve = false, devDependencies = true, wsRoot = c
     return workspaces
 }
 
+/**
+ * This JavaScript function filterFeaturePaths is used to filter and categorize file paths 
+ * from a given model into two categories: base and features.
+ * @param {*} model - represents a data model. It's expected to have a $sources property which is an array of file paths.
+ * @param {*} modelPaths - an array of file paths.
+ * @returns 
+ */
+function filterFeaturePaths(model, modelPaths) {
+    const ftsName = path.dirname(cds.env.features.folders || 'fts/*')
+    const regex = new RegExp(`[/|\\\\]+${ftsName}[/|\\\\]+(?<ftName>[^/|\\\\]*)`)
+    const sources = { base: [] }
+
+    // add ROOT source file paths for the base model
+    sources.base = cds.resolve(modelPaths).reduce((acc, file) => {
+        const match = file.match(regex)
+        if (!match) {
+            acc.push(file)
+        }
+        return acc
+    }, [])
+
+    // add source file paths for the features
+    sources.features = model['$sources'].reduce((acc, file) => {
+        const match = file.match(regex)
+        if (match) {
+            const { ftName } = match.groups
+            //feature
+            if (!acc[ftName]) {
+                acc[ftName] = []
+            }
+            acc[ftName].push(file)
+        }
+        return acc
+    }, {})
+
+    return sources
+}
+
 /**
  * Read installed npm workspaces using 'npm ls -ws --json'. 
  * @returns {Array} list of package paths, or an empty array if either 
@@ -280,6 +319,36 @@ function _filterModelPaths(modelPaths, filter) {
     return [...model].filter(m => filter ? filter(m) : true).map(m => normalizePath(m))
 }
 
+/**
+ * Returns a set of files found in the given directory and its subdirectories.
+ * @param {string} srcDir - the directory to search for files
+ * @param {Function} filter - the filter function to apply to the found files
+ * @param {Array} files - the set of files to add the found files to
+ * @returns {Array} files found in the given directory and its subdirectories
+ */
+function getFiles(srcDir, filter, files = []) {
+    function handleResource(entry, filter, files) {
+        if (!filter || filter.call(this, entry)) {
+            const stats = fs.lstatSync(entry)
+            if (stats.isDirectory()) {
+                getFiles(entry, filter, files)
+            } else if (stats.isFile() || stats.isSymbolicLink()) {
+                files.push(entry)
+            }
+        }
+    }
+    let entries = []
+    try {
+        entries = fs.readdirSync(srcDir)
+    } catch (e) {
+        // ignore if not existing
+    }
+    entries.map(subDirEntry => path.join(srcDir, subDirEntry)).forEach((entry) => {
+        handleResource(entry, filter, files)
+    })
+    return files
+}
+
 /**
  * Return gnu-style error string for location `loc`:
  *  - 'File:Line:Col' without `loc.end`
@@ -371,6 +440,8 @@ module.exports = {
     normalizePath,
     pathExists,
     getWorkspaces,
+    filterFeaturePaths,
+    getFiles,
     BuildMessage,
     BuildError
 }

package/lib/compile/to-mermaid.js

@@ -0,0 +1,108 @@
+const cds = require('../cds')
+
+module.exports = function to_mermaid (model, options={}) {
+  options = Object.assign({
+    assocnames: false,    // include association names
+    elements  : false,    // include all elements { falsy | 'all'|true | 'keys' }
+    min       : false,    // minify the model, i.e. remove unused definitions, available in CLI
+    namespaces: true,     // group entities by namespace/service
+    queries   : false,    // include relations for queries
+    service   : undefined // filter service by name, available in CLI
+  }, cds.env.mermaid ?? {}, options)
+
+  const elemOpts = options.elements === 'none' ? false : options.elements
+  if (options.min)  model = cds.minify(model)
+
+  model = cds.linked(model)
+  const allServices = model.all('service')
+
+  // filter by one service if its name is given or only one service is present
+  const srvFilter = options.service ?? (Object.keys(allServices).length === 1 ? allServices[0].name : undefined)
+  if (srvFilter && !model.definitions[srvFilter]) {
+    throw new Error(`Service "${srvFilter}" not found among ${model.all('service').map(s => s.name).sort()}`)
+  }
+
+  const seenEntities = new Set()
+  const namespaces = {}
+  const entityFilter = e => !e.name.startsWith('cds.') && !e.name.endsWith('.texts')
+
+  let diag = ''
+
+  // if requested, filter by one service
+  model.all('service')
+  .filter (srv => !srvFilter || srv.name === srvFilter)
+  .forEach(srv => {
+    namespaces[srv.name] = []
+    model.entities(srv)
+    .filter (entityFilter)
+    .forEach (e => {
+      namespaces[srv.name].push(e)
+      seenEntities.add(e.name)
+    })
+  })
+
+  // group other namespaces/services
+  if (options.namespaces) {
+    model.all('entity')
+    .filter (e => !seenEntities.has(e.name))
+    .filter (entityFilter)
+    .forEach (e => {
+      const ns = e.name.slice(0,e.name.lastIndexOf('.'))
+      if (!srvFilter || ns === srvFilter) {
+        namespaces[ns] = namespaces[ns] || []
+        namespaces[ns].push(e)
+        seenEntities.add(e.name)
+      }
+    })
+
+    // create namespace groups and classes
+    Object.keys(namespaces).forEach(ns => {
+      if (!diag.length)  diag = `classDiagram\n`
+      diag += `  namespace ${ns.replaceAll('.','_')} {\n`
+      namespaces[ns].forEach (e => {
+        const simpleName = e.name.slice(e.name.lastIndexOf('.')+1)
+        diag += `    class \`${e.name}\``
+        diag += `["${simpleName}"]` // simple name as label
+        if (elemOpts) {
+          diag += ` {\n`
+          e.elements.forEach (el => {
+            if ((elemOpts === 'all' || elemOpts === true) || (el.key && elemOpts == 'keys')) {
+              diag += `      +${el._type?.replace('cds.','')} ${el.name}`
+              diag += `\n`
+            }
+          })
+          diag += `    }`
+        }
+        diag += `\n`
+      })
+      diag += `  }\n`
+    })
+    diag += `\n`
+  }
+
+  // add associations, either from collected entities or all entities
+  const entities = seenEntities.size
+    ? Array.from(seenEntities).map(name => model.definitions[name])
+    : model.all('entity').filter (entityFilter) // if no grouping and no service filter is on
+  entities.forEach(e => {
+    if (!diag.length)  diag = `classDiagram\n`
+    e.elements.forEach (el => {
+      if (el instanceof cds.Association) {
+        if (el.target.endsWith('.texts'))  return
+        const type = el.type === 'cds.Composition' ? '*-->' : '-->'
+        const card = el.cardinality?.max === '*' ? '"*"' : ''
+        diag += `  \`${e.name}\` ${type} ${card} \`${el.target}\``
+        if (options.assocnames) {
+          diag += `: ${el.name}`
+        }
+        diag += `\n`
+      }
+    })
+    // add relations for queries
+    if (e.query && options.queries)  {
+      diag += `  \`${e.name}\` ..> \`${e.query.target.name}\`\n`
+    }
+  })
+
+  return diag.trim()
+}

package/lib/compile/to_asyncapi.js

@@ -0,0 +1,7 @@
+const { compile } = require('@cap-js/asyncapi')
+
+function cds_compile_to_asyncapi (csn, options) {
+  return compile(csn, options)
+}
+
+module.exports = cds_compile_to_asyncapi

package/lib/compile/to_openapi.js

@@ -0,0 +1,7 @@
+const { compile } = require('@cap-js/openapi')
+
+function cds_compile_to_openapi (csn, options) {
+  return compile(csn, options)
+}
+
+module.exports = cds_compile_to_openapi

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
   }
 }