@sap/cds-dk 8.9.4 → 9.0.4

package/lib/build/util.js

@@ -1,3 +1,4 @@
+// @ts-check
 const fs = require('fs')
 const path = require('path')
 const cds = require('../cds')
@@ -6,23 +7,33 @@ const execAsync = require('util').promisify(cp.exec)
 const IS_WIN = require('os').platform() === 'win32'
 const { SEVERITY_ERROR, FILE_EXT_CDS, NODEJS_MODEL_EXCLUDE_LIST } = require('./constants');
 const DEBUG = cds.debug('cli|build')
-const SECRETS = /(passw)|(cert)|(ca)|(secret)|(key)/i
 const WS_MAX_DEPTH = 2
 
+/** @typedef {{col?: number, endCol?: number, line?: number, endLine?: number, file: string}} SourceLocation */
+/** @typedef {object[] | object} Credentials */
+/** @typedef {(string | NestedStringArray)[]} NestedStringArray */
+
+/**
+ * @param {object} src - object to get property from
+ * @param {string | string[]} segments - property path
+ */
 function getProperty(src, segments) {
     segments = Array.isArray(segments) ? segments : segments.split('.')
     return segments.reduce((p, n) => p && p[n], src)
 }
 
+/**
+ * @param {object} src - object to set property on
+ * @param {string | string[]} segments - property path
+ * @param {unknown} value - value to set
+ */
 function setProperty(src, segments, value) {
     segments = Array.isArray(segments) ? segments : segments.split('.')
     segments.reduce((p, n, idx) => {
         if (segments.length === idx + 1) {
             p[n] = value
-        } else {
-            if (p[n] === undefined) {
-                p[n] = {}
-            }
+        } else if (p[n] === undefined) {
+            p[n] = {}
         }
         return p[n]
     }, src)
@@ -37,8 +48,9 @@ function hasJavaNature() {
 
 /**
  * Determines whether the both values are identical.
- * @param {*} actual
- * @param {*} expected
+ * @template {number | boolean} T
+ * @param {T} actual
+ * @param {T} expected
  */
 function hasOptionValue(actual, expected) {
     if (typeof expected === 'undefined') {
@@ -52,65 +64,29 @@ function hasOptionValue(actual, expected) {
             return String(expected) === actual
         }
     }
-    if (typeof expected === 'number') {
+    if (typeof expected === 'number' && typeof actual === 'number') {
         return (actual & expected) !== 0
     }
     return actual === expected
 }
 
-// Returning the project relative path representation of the given path(s),
-function relativePaths(root, qualifiedPaths) {
-    qualifiedPaths = typeof qualifiedPaths === "string" ? [qualifiedPaths] : qualifiedPaths
-    if (Array.isArray(qualifiedPaths)) {
-        return qualifiedPaths.map(qualifiedPath => {
-            const relPath = path.relative(root, qualifiedPath)
-            return relPath || "."
-        })
-    }
-    return qualifiedPaths
-}
-
-function redactCredentials(config) {
-    if (typeof config !== 'object' || config === null) {
-        return config;
-    }
-
-    if (Array.isArray(config)) {
-        return config.map(item => redactCredentials(item));
-    } else {
-        const newConfig = Object.assign({}, config);
-        for (let key in newConfig) {
-            if (key === 'credentials') {
-                newConfig[key] = _redacted(newConfig[key]);
-            } else {
-                newConfig[key] = redactCredentials(newConfig[key]);
-            }
-        }
-        return newConfig;
-    }
-}
-
 /**
- * Masks password-like strings, also reducing clutter in output
- * @param {any} cred - object or array with credentials
- * @returns {any}
+ * Returning the project relative path representation of the given path(s),
+ * @param {string} root - project root
+ * @param {string | string[]} qualifiedPaths - fully qualified path(s)
  */
-function _redacted(cred) {
-    if (!cred) return cred
-    if (Array.isArray(cred)) return cred.map(c => typeof c === 'string' ? '...' : _redacted(c))
-    if (typeof cred === 'object') {
-        const newCred = Object.assign({}, cred)
-        Object.keys(newCred).forEach(k => (typeof newCred[k] === 'string' && SECRETS.test(k)) ? (newCred[k] = '...') : (newCred[k] = _redacted(newCred[k])))
-        return newCred
-    }
-    return cred
+function relativePaths(root, qualifiedPaths) {
+    qualifiedPaths = typeof qualifiedPaths === "string" ? [qualifiedPaths] : qualifiedPaths
+    return Array.isArray(qualifiedPaths)
+        ? qualifiedPaths.map(qualifiedPath => path.relative(root, qualifiedPath) ?? ".")
+        : qualifiedPaths
 }
 
 /**
  * Returns a list of fully qualified model names belonging to the '@sap' namespace that cannot be resolved.
  * E.g. the module might NOT have been installed.
- * @param {Array} modelPaths
- * @returns {Array}
+ * @param {string[]} modelPaths
+ * @returns {string[]}
  */
 function resolveRequiredSapModels(modelPaths) {
     return Array.isArray(modelPaths) && modelPaths.filter(p => {
@@ -121,13 +97,19 @@ function resolveRequiredSapModels(modelPaths) {
     })
 }
 
-async function getDefaultModelOptions(ws = false, filter) {
+/**
+ * Returns the default model options for the given workspace.
+ * @param {boolean} ws - whether to include workspace models
+ * @param {Function | undefined} filter - filter function for model paths
+ */
+async function getDefaultModelOptions(ws = false, filter = undefined) {
     // Note: requires.toggles holds the actual kind representation and not the value 'true'
     const wildcards = cds.env.requires.toggles && cds.env.features.folders ? ['*', cds.env.features.folders] : '*'
     let paths = _filterModelPaths(cds.resolve(wildcards, false), filter)
 
     if (ws) {
-        const workspaces = await getWorkspaces()
+        const workspaces = (await getWorkspaces())
+          .map(ws => ws.workspace)
         const env = cds.env
         const root = cds.root
         try {
@@ -141,28 +123,44 @@ async function getDefaultModelOptions(ws = false, filter) {
             cds.env = env
         }
         // exclude redundant built-in models starting with workspace path, e.g. 'books/@sap/cds-mtxs/srv/bootstrap'
-        paths = paths.filter(p => NODEJS_MODEL_EXCLUDE_LIST.includes(p) || !NODEJS_MODEL_EXCLUDE_LIST.some(ex => p.endsWith(ex)))
+        paths = paths
+            .filter(p => typeof(p) === 'string' && (NODEJS_MODEL_EXCLUDE_LIST.includes(p) || !NODEJS_MODEL_EXCLUDE_LIST.some(ex => p.endsWith(ex))))
     }
     return paths
 }
 
+/**
+ * @overload
+ * @param {string} dir
+ * @returns {string}
+ */
+/**
+ * @overload
+ * @param {unknown} dir
+ * @returns {unknown} 
+ */
 /**
  * For valid paths replace '\\' with '/' and remove trailing '/'. Otherwise return as is
- * @param {*} dir
+ * @param {string | unknown} dir
+ * @returns {string | unknown}
  */
 function normalizePath(dir) {
     return typeof dir === "string" ? dir.replace(/\\/g, '/').replace(/\/$/, '') : dir
 }
 
+/**
+ * @param {NestedStringArray} modelPaths
+ */
 function flatten(modelPaths) {
-    return modelPaths.reduce((acc, m) => {
+    // TODO: I guess this could be modelPaths.flat(Infinity) in the future
+    return /** @type{string[]}*/(modelPaths.reduce((/** @type {string[]}*/acc, m) => {
         if (Array.isArray(m)) {
             acc = acc.concat(flatten(m))
         } else if (m) {
             acc.push(m)
         }
         return acc
-    }, [])
+    }, []))
 }
 
 function getI18nDefaultFolder() {
@@ -181,43 +179,103 @@ async function getWorkspacePaths() {
     if (!wsRoot) {
         return []
     }
-    return (await getWorkspaces(wsRoot)).filter(ws => cds.root !== path.join(wsRoot, ws)).map(ws => path.join(wsRoot, ws))
+    return (await getWorkspaces(wsRoot))
+        .map(ws => ws.workspace)
+        .filter(ws => cds.root !== path.join(wsRoot, ws))
+        .map(ws => path.join(wsRoot, ws))
+}
+
+/**
+ * @typedef {{
+ *   path: string,
+ *   workspace: string,
+ *   packageName: string
+ * }} Workspace
+ *
+ * Returns a map of workspaces from a root project, with their paths and workspace names,
+ * I.e. for a monorepo setup this command finds all workspaces defined therein.
+ * @param {string} root - the root directory to search for workspaces
+ * @returns {Promise<Record<string, Workspace>>} - a map of workspaces with their paths and workspace names
+ */
+async function getWorkspacesDeclarations (root) {
+    const rootPackageJson = path.join(root, 'package.json')
+    if (!fs.existsSync(rootPackageJson)) return {}
+    const pkg = require(rootPackageJson)
+    if (!pkg?.workspaces) return {}
+
+    const workspaces = []
+    for (const workspace of pkg.workspaces) {
+        if (/[*?[\]]/.test(workspace)) {
+            // contains globs
+            const { glob } = require('../util/glob')
+            for await (const file of glob(workspace, { cwd: root })) {
+                try {
+                    const projectPath = path.join(root, file)
+                    const projectName = require(path.join(projectPath, 'package.json')).name
+                    workspaces.push([projectName, {
+                        packageName: projectName,
+                        path: projectPath,
+                        workspace: file
+                    }])
+                } catch {
+                    // not a directory or doesn't contain a package.json -> not a workspace -> skip
+                }
+            }
+        } else {
+            // no glob, just a path literal
+            const projectPath = path.join(root, workspace)
+            try {
+                const projectName = require(path.join(projectPath, 'package.json')).name
+                workspaces.push([projectName, { path: projectPath, workspace }])
+            } catch {
+                // not a directory or doesn't contain a package.json -> not a workspace -> skip
+            }
+        }
+    }
+    return Object.fromEntries(workspaces)
 }
 
 /**
  * Returns the list of workspaces defined for the current project. A workspace dependency
- * needs to be defined resulting in a corresponding sym-link.
- * @returns the paths are relative to 'wsRoot'.
+ * needs to be defined resulting in a corresponding symlink.
+ * @returns {Promise<Workspace[]>} the paths are relative to 'wsRoot'.
  */
-async function getWorkspaces(wsRoot, resolve = false, devDependencies = true) {
+async function getWorkspaces(wsRoot, resolve = false, devDependencies = true, visited = new Set()) {
     wsRoot ??= findWorkspaceRoot(cds.root)
     if (!wsRoot) {
         return []
     }
-    const pgkJsonWsRoot = require(path.join(wsRoot, 'package.json'))
-    let pgkJson = pgkJsonWsRoot
+    const pkgJsonWsRoot = require(path.join(wsRoot, 'package.json'))
+    let pkgJson = pkgJsonWsRoot
     if (wsRoot !== cds.root) {
-        pgkJson = require(path.join(cds.root, 'package.json'))
+        pkgJson = require(path.join(cds.root, 'package.json'))
     }
-    const workspaces = []
-    if (pgkJsonWsRoot.workspaces) {
+    const workspaceDependencies = []
+    if (pkgJsonWsRoot.workspaces) {
         if (resolve) {
-            _validateWsDependencies(wsRoot, pgkJson.dependencies, devDependencies ? pgkJson.devDependencies : {})
+            _validateWsDependencies(wsRoot, pkgJson.dependencies, devDependencies ? pkgJson.devDependencies : {})
         }
         // read npm workspaces
+        const workspaces = await getWorkspacesDeclarations(wsRoot)
         const pkgs = await _execNpmWs(wsRoot)
-        pkgs.forEach(pkg => {
+        for (const pkg of pkgs) {
             // only create tarball archives for dependencies with version '*'
-            if (!resolve || devDependencies && pgkJson.devDependencies?.[pkg] === '*' || pgkJson.dependencies?.[pkg] === '*') {
-                const workspace = _getWorkspace(wsRoot, pkg)
-                if (workspace) {
-                    workspaces.push(workspace)
+            if (!resolve || devDependencies && pkgJson.devDependencies?.[pkg] === '*' || pkgJson.dependencies?.[pkg] === '*') {
+                const subproject = workspaces[pkg]
+                if (subproject && !visited.has(pkg)) {
+                    visited.add(pkg)
+                    workspaceDependencies.push(subproject)
+                    // temporarily set cds.root to the dependency to resolve transitive deps thereof
+                    const cdsr = cds.root
+                    cds.root = subproject.path
+                    workspaceDependencies.push(...(await getWorkspaces(wsRoot, resolve, devDependencies, visited)))
+                    cds.root = cdsr
                 }
             }
-        })
+        }
     }
-    DEBUG?.(`Found ${workspaces.length} workspaces ${workspaces.join(', ')}`)
-    return workspaces
+    DEBUG?.(`Found ${workspaceDependencies.length} workspace dependencies ${workspaceDependencies.join(', ')}`)
+    return workspaceDependencies
 }
 
 function findWorkspaceRoot(currentPath, depth = 0) {
@@ -279,39 +337,33 @@ function filterFeaturePaths(model, modelPaths) {
 
 /**
  * Read installed npm workspaces using 'npm ls -ws --json'.
- * @returns {Array} list of package paths, or an empty array if either
+ * There is currently no easier way for this, as workspaces
+ * could contain globs. Glob resolution will be supported
+ * natively in the future (fs.glob is in experimental state as of Node23).
+ * @param {import('fs').PathLike} wsRoot - the root directory of the workspace
+ * @returns {Promise<string[]>} list of package paths, or an empty array if either
  * no workspaces are defined or have not been installed.
  */
 async function _execNpmWs(wsRoot) {
     try {
         const cmdLine = 'npm ls -ws --json'
         DEBUG?.(`execute ${cmdLine}`)
-        let result = await execAsync(cmdLine, { shell: IS_WIN, stdio: ['inherit', 'pipe', 'inherit'], cwd: wsRoot })
+        // @ts-expect-error - TODO: shell should be a string. But can probably be removed altogether?
+        const result = await execAsync(cmdLine, { shell: IS_WIN, stdio: ['inherit', 'pipe', 'inherit'], cwd: wsRoot })
         // DEBUG?.(result.stdout)
-        result = JSON.parse(result.stdout)
-        if (result.dependencies) {
-            return Object.keys(result.dependencies)
-        } else if (result.name) {
-            return [result.name]
+        const jsonResult = JSON.parse(result.stdout)
+        if (jsonResult.dependencies) {
+            return Object.keys(jsonResult.dependencies)
+        } else if (jsonResult.name) {
+            return [jsonResult.name]
         }
-    } catch (e) {
+    } catch (/** @type {{stderr: string}} */e) {
         e.stderr = e.stderr?.replace(/npm ERR! /g, '')
         throw e
     }
     return []
 }
 
-function _getWorkspace(wsRoot, pkg) {
-    try {
-        const pkgPath = require.resolve(path.join(pkg, 'package.json'), { paths: [wsRoot] })
-        if (!pkgPath.match(/(\/|\\)node_modules(\/|\\)?/) && pkgPath.startsWith(wsRoot)) {
-            return path.relative(wsRoot, path.dirname(pkgPath))
-        }
-    } catch (e) {
-        // ignore - workspace dependencies have already been validated
-    }
-}
-
 function _validateWsDependencies(wsRoot, dependencies, devDependencies) {
     const allDependencies = { ...dependencies, ...devDependencies }
     for (const name in allDependencies) {
@@ -330,22 +382,22 @@ function _validateWsDependencies(wsRoot, dependencies, devDependencies) {
 
 /**
  * Returns a flat array of existing files and folders, trailing '/' or '\\' characters have been removed.
- * @param  {Array} modelPaths array of files and folders - optionally nested
- * @returns
+ * @param  {NestedStringArray} modelPaths array of files and folders - optionally nested
+ * @param  {((m: string) => boolean) | undefined} filter filter function to apply to the found files
+ * @returns 
  */
-function _filterModelPaths(modelPaths, filter) {
-    const model = new Set()
+function _filterModelPaths(modelPaths, filter = undefined) {
+    const model = /** @type {Set<string>}*/(new Set())
     // may contain nested arrays
-    modelPaths = flatten(modelPaths)
+    const flatModelPaths = flatten(modelPaths)
     const { roots } = cds.env
-    modelPaths.forEach(m => {
+    flatModelPaths.forEach(m => {
         if (m && !model.has(m) && !model.has(m + "/")) {
             // filter roots and absolute model paths that do not exist
             if (roots.includes(m)) {
                 const dir = path.resolve(cds.root, m)
-                if (fs.existsSync(dir)) {
-                    model.add(m)
-                } else if (fs.existsSync(dir + FILE_EXT_CDS)) { //might be cds file name, compatibility to old build configs
+                // dir + FILE_EXT_CDS: might be cds file name, compatibility to old build configs
+                if (fs.existsSync(dir) || fs.existsSync(dir + FILE_EXT_CDS)) {
                     model.add(m)
                 }
             } else {
@@ -353,21 +405,23 @@ function _filterModelPaths(modelPaths, filter) {
             }
         }
     })
-    return [...model].filter(m => filter ? filter(m) : true).map(m => normalizePath(m))
+    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
+ * @param {(file: string) => boolean} [filter] - the filter function to apply to the found files
+ * @param {string[]} files - the set of files to add the found files to
+ * @returns {string[]} files found in the given directory and its subdirectories
  */
 function getFiles(srcDir, filter, files = []) {
-    function handleResource(entry, filter, files) {
+    function handleResource(/** @type {string} entry */ entry) {
         if (!filter || filter.call(this, entry)) {
             const stats = fs.lstatSync(entry)
-            if (stats.isDirectory()) {
+            if (cds.utils.isdir(entry)) {
                 getFiles(entry, filter, files)
             } else if (stats.isFile() || stats.isSymbolicLink()) {
                 files.push(entry)
@@ -377,11 +431,11 @@ function getFiles(srcDir, filter, files = []) {
     let entries = []
     try {
         entries = fs.readdirSync(srcDir)
-    } catch (e) {
+    } catch {
         // ignore if not existing
     }
     entries.map(subDirEntry => path.join(srcDir, subDirEntry)).forEach((entry) => {
-        handleResource(entry, filter, files)
+        handleResource(entry)
     })
     return files
 }
@@ -392,7 +446,8 @@ function getFiles(srcDir, filter, files = []) {
  *  - 'File:Line:StartCol-EndCol' if Line = start.line = end.line
  *  - 'File:StartLine.StartCol-EndLine.EndCol' otherwise
  *
- * @param {CSN.Location|CSN.Location} location
+ * @param {SourceLocation | undefined} loc
+ * @private
  */
 function _locationString(loc) {
     if (!loc)
@@ -415,22 +470,24 @@ function _locationString(loc) {
 
 /**
  * Class for individual build message.
- *
- * @class BuildMessage
  */
 class BuildMessage {
     /**
      * Creates an instance of BuildMessage.
      * @param {string} message The message text
-     * @param {string} [severity='Error'] Severity: Debug, Info, Warning, Error
-     * @param {any} location Location of the message
-     *
+     * @param {import('./constants').Severity} [severity='Error'] severity - severity of the message
+     * @param {SourceLocation | undefined} location Location of the message
+     * 
      * @memberOf BuildMessage
      */
-    constructor(message, severity = SEVERITY_ERROR, location) {
+    constructor(message, severity = SEVERITY_ERROR, location = undefined) {
+        /** @type {string} */
         this.message = message
+        /** @type {string} */
         this.name = "BuildMessage"
+        /** @type {import('./constants').Severity} */
         this.severity = severity
+        /** @type {SourceLocation} */
         this.$location = location
     }
     toString() {
@@ -441,11 +498,16 @@ class BuildMessage {
 /**
  * Class for combined build and compiler errors.
  * Additional members:
- *   messages: array of detailed build messages
- * @class BuildError
- * @extends {Error}
+ *   messages: vector of detailed build messages
  */
 class BuildError extends Error {
+    /** @type {string[] | {message: string}[]} */
+    messages
+
+    /** 
+     * @param {string} message
+     * @param {string | string[]} messages
+     */
     constructor(message, messages = []) {
         super(message)
         this.name = "BuildError"
@@ -466,7 +528,6 @@ module.exports = {
     getProperty,
     setProperty,
     hasJavaNature,
-    redactCredentials,
     hasOptionValue,
     relativePaths,
     resolveRequiredSapModels,

package/lib/deploy/index.js

@@ -0,0 +1,5 @@
+module.exports = {
+    options:  /** @type{const} */(['--to', '--for', '--out', '--on', '--tunnel-address', '--vcap-file', '--delta-from']),
+    flags:  /** @type{const} */(['--no-save', '--auto-undeploy', '--dry', '--xdry', '--with-mocks', '--store-credentials', '--no-build', '--model-only', '--script', '--with-auto-schema-evolution']),
+    shortcuts: ['-2', '-4', '-o', '-n']
+}

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

@@ -1,7 +1,5 @@
 const path = require('path');
 
-const fs = require('fs').promises;
-
 const cds = require('../../../lib/cds');
 const { exists, read, write, mkdirp } = cds.utils;
 
@@ -9,7 +7,6 @@ const { build } = require('../../build');
 
 const hdi = require('./hdiDeployUtil');
 const cfUtil = require('../../util/cf');
-const gitUtil = require('../../util/git');
 const mtaUtil = require('./mtaUtil');
 
 const { bold, info, warn } = require('../../util/term');
@@ -17,8 +14,24 @@ const { bold, info, warn } = require('../../util/term');
 const { bind, storeBindings } = require('../../bind/shared');
 const { BUILD_TASK_HANA, OUTPUT_MODE, OUTPUT_MODE_FILESYSTEM, OUTPUT_MODE_RESULT } = require('../../build/constants');
 
+const { options, flags } = require('../index');
+const allOptions = [...options, ...flags];
+
 const DEBUG = cds.debug('cli');
 
+/** @type { (typeof allOptions[number])[] } */
+const allowList = [
+  '--auto-undeploy',
+  '--dry',
+  '--for',
+  '--on',
+  '--store-credentials',
+  '--to',
+  '--tunnel-address',
+  '--vcap-file',
+  '--with-mocks'
+]
+
 module.exports = new class HanaDeployer {
 
   getFromEnv(...varNames) {
@@ -36,7 +49,15 @@ module.exports = new class HanaDeployer {
   }
 
   async deploy(options = {}) {
-    let { model, serviceName: pServiceName, tunnelAddress, vcapFile, undeployWhitelist, hdiOptions = {}, dry, storeCredentials } = options;
+    let unknownOptions = Object.keys(options)
+      .map(key => `--${key.replace(/([A-Z])/g, '-$1').toLowerCase()}`)
+      .filter(key => allOptions.includes(key) && !allowList.includes(key));
+
+    if (unknownOptions.length > 0) {
+      throw `One or more options are not supported by cds deploy to hana: ${unknownOptions.join(', ')}`;
+    }
+
+    let { model, serviceName: pServiceName, tunnelAddress, vcapFile, undeployWhitelist, hdiOptions = {}, dry } = options;
 
     options.for ??= 'hybrid';
 
@@ -89,7 +110,7 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
       }
     } else {
       // the primary database is always built and deployed
-      const dest = path.join(cds.env.build.target, cds.env.folders.db);
+      const dest = buildResult.dest // path.join(cds.env.build.target, cds.env.folders.db);
 
       if (undeployWhitelist) {
         console.log('Writing undeploy.json');
@@ -167,9 +188,6 @@ spec:
             vcapEnv.VCAP_SERVICES = this._getVCAPServicesEntry(cfServiceInstanceName, serviceKey);
           }
 
-          if (storeCredentials) {
-            await this._addInstanceToDefaultEnvJson([dest, cds.root], cfServiceInstanceName, serviceKey);
-          }
           if (!hasVCAPEnv) {
             bindOptions = {
               ...options,
@@ -185,10 +203,6 @@ spec:
       DEBUG?.({ dest, vcapEnv, hdiOptions })
       await hdi.deploy(dest, vcapEnv, hdiOptions);
 
-      if (storeCredentials) {
-        await gitUtil.ensureFileIsGitignored('default-env.json', cds.root);
-      }
-
       if (!hasVCAPEnv) {
         const services = await bind(bindOptions)
         await storeBindings(services, bindOptions)
@@ -269,7 +283,7 @@ spec:
   async _build() {
     const buildTaskOptions = {
       for: BUILD_TASK_HANA,
-      src: cds.env.folders.db,
+      // src: cds.env.folders.db,
       [OUTPUT_MODE]: OUTPUT_MODE_FILESYSTEM | OUTPUT_MODE_RESULT
     }
 
@@ -278,26 +292,6 @@ spec:
     return buildResult[0].result;
   }
 
-  async _addInstanceToDefaultEnvJson(currentFolders, serviceInstanceName, serviceKey) {
-    for (const currentFolder of currentFolders) {
-      const defaultEnvJsonPath = path.join(currentFolder, 'default-env.json');
-      const defaultEnvJson = exists(defaultEnvJsonPath) ? await read(defaultEnvJsonPath) : {};
-
-      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.VCAP_SERVICES, hanaEntry);
-
-      console.log(`Writing ${defaultEnvJsonPath}`);
-      await fs.mkdir(path.dirname(defaultEnvJsonPath), { recursive: true })
-      await fs.writeFile(defaultEnvJsonPath, JSON.stringify(defaultEnvJson, null, 2));
-    }
-  }
-
-
   _getVCAPServicesEntry(serviceInstanceName, serviceKey) {
     return {
       hana: [

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

@@ -5,13 +5,13 @@ const HDI_DEPLOY_LIB = '@sap/hdi-deploy';
 
 module.exports = new class HdiDeployUtil {
 
-    async deploy(dbDir, vcapEnv = {}, { autoUndeploy } = {}) {
+    async deploy(dbDir, vcapEnv = {}, { autoUndeploy, parameter={} } = {}) {
         console.log(`Deploying to HANA from ${dbDir}`);
 
         const { clean_env, deploy } = this._loadHdiDeployLib(dbDir);
 
         const deployerEnv = JSON.parse(JSON.stringify(process.env));
-        const options = deployerEnv.HDI_DEPLOY_OPTIONS ? JSON.parse(deployerEnv.HDI_DEPLOY_OPTIONS) : {};
+        const options = deployerEnv.HDI_DEPLOY_OPTIONS ? JSON.parse(deployerEnv.HDI_DEPLOY_OPTIONS) : { parameter };
         delete options.root;
 
         clean_env?.(deployerEnv);