@sap/cds-dk 8.4.2 → 8.5.1

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

@@ -1,9 +1,9 @@
 const fs = require('fs')
 const path = require('path')
 const cds = require('../../../cds')
-const to_hdbmigration = require('./2migration')
+const { compileToHdbMigration, getJournalEntities, getMigrationTableName } = require('./2migration')
 const InternalBuildPlugin = require('../internalBuildPlugin')
-const { BuildError, relativePaths, BuildMessage, getWorkspaces, hasOptionValue, getFiles } = require('../../util')
+const { BuildError, relativePaths, BuildMessage, hasOptionValue, getFiles, getWorkspacePaths } = require('../../util')
 const { OUTPUT_MODE_NONE, OUTPUT_MODE, CONTENT_PACKAGE_JSON, CONTENT_HDBTABLEDATA, CSV_FILE_DETECTION,
     CONTENT_ENV, CONTENT_DEFAULT_ENV_JSON, CONTENT_NODE_MODULES, OUTPUT_MODE_RESULT, CONTINUE_UNRESOLVED_SCHEMA_CHANGES,
     CSV_FILE_TARGET, OPTION_WS } = require('../../constants')
@@ -38,14 +38,15 @@ class HanaBuildPlugin extends InternalBuildPlugin {
         if (!model) {
             return
         }
-        let workspaceFiles
-        if (cds.cli.options?.[OPTION_WS] || hasOptionValue(this.task.options[OPTION_WS], true)) {
-            workspaceFiles = await this._getWorkspaceFiles()
+        let wsPaths = []
+        if(getJournalEntities(model).length || cds.cli.options?.[OPTION_WS] || hasOptionValue(this.task.options[OPTION_WS], true)) {
+            // workspace paths don't include the current project root
+            wsPaths = await getWorkspacePaths()
         }
 
         // the order of 1 and 2 is important
         // 1. compile
-        const hdiPlugins = await this._compileToHana(model, workspaceFiles)
+        const hdiPlugins = await this._compileToHana(model, wsPaths)
 
         if (!this.hasBuildOption(OUTPUT_MODE, OUTPUT_MODE_NONE)) {
             // 2. copy resources
@@ -54,16 +55,6 @@ class HanaBuildPlugin extends InternalBuildPlugin {
             } else {
                 await this._copyResourcesExt(src, dest, model)
             }
-            // copy native hana artifacts from workspaces
-            if (workspaceFiles) {
-                const dest = path.join(this.task.dest, this.isStagingBuild() ? 'src' : 'src/gen')
-                await Promise.all(
-                    workspaceFiles.map((src) => {
-                        const { dir, filePath } = src
-                        return this.copy(path.join(dir, filePath)).to(path.join(dest, filePath))
-                    })
-                )
-            }
 
             // create additional stuff in dest
             await this._writeHdiConfig(hdiPlugins)
@@ -78,6 +69,28 @@ class HanaBuildPlugin extends InternalBuildPlugin {
             if (!this.hasBuildOption(CONTENT_PACKAGE_JSON, false)) {
                 await this._writePackageJson()
             }
+
+            // copy native hana artifacts from other workspaces including .hdbmigrationtable files defined for 
+            // common model artifacts that are not part of the current project
+            if (wsPaths.length || cds.cli.options?.[OPTION_WS] || hasOptionValue(this.task.options[OPTION_WS], true)) {
+                // first is winning, e.g. a .hdiconfig file might exist in multiple workspaces
+                const wsFiles = (await this._getWorkspaceFiles(wsPaths)).reduce((acc, src) => {
+                    const { filePath } = src;
+                    if (!acc.some(file => file.filePath === filePath)) {
+                        acc.push(src);
+                    }
+                    return acc;
+                }, []);
+
+                // copy artifacts to the src/gen folder in inplace mode
+                const dest = path.join(this.task.dest, this.isStagingBuild() ? 'src' : 'src/gen')
+                await Promise.all(
+                    wsFiles.map((src) => {
+                        const { dir, filePath } = src
+                        return this.copy(path.join(dir, filePath)).to(path.join(dest, filePath))
+                    })
+                )
+            }
         }
         return this._result
     }
@@ -264,20 +277,18 @@ class HanaBuildPlugin extends InternalBuildPlugin {
      *
      * @param {object} model The compiled csn model
      */
-    async _compileToHana(model, workspaceFiles) {
+    async _compileToHana(model, wsPaths) {
         // compile to old format (.hdbcds) or new format (.hdbtable / .hdbview)
         const format = this.getBuildOption(DEPLOY_FORMAT) || cds.env.requires.db?.[DEPLOY_FORMAT] || cds.env.hana?.[DEPLOY_FORMAT]
         if (!cds.compile.to[format]) {
             return Promise.reject(new Error(`Invalid deploy-format defined: ${format}`))
         }
 
-        if (cds.env.features.journal === false
-            || format === 'hdbcds'
-            || (!cds.compile.to.hana && Object.values(model.definitions).every(def => !def['@cds.persistence.journal']))) {
+        if (cds.env.features.journal === false || format === 'hdbcds') {
             // compatibility with existing cds.compile.to.hdbtable plugins cds < 8.0.0
             return await this._compileToHdb(model, format)
         } else {
-            return await this._compileToHdbmigration(model, format, workspaceFiles)
+            return await this._compileToHdbmigration(model, format, wsPaths)
         }
     }
 
@@ -313,7 +324,7 @@ class HanaBuildPlugin extends InternalBuildPlugin {
         return hdiPlugins
     }
 
-    async _compileToHdbmigration(model, format, workspaceFiles) {
+    async _compileToHdbmigration(model, format, wsPaths) {
         const hdiPlugins = new Set()
         const relDestDir = path.relative(this.task.dest, this.task.options.compileDest)
         const relDbDestDir = path.relative(cds.root, this.task.options.compileDest)
@@ -328,19 +339,30 @@ class HanaBuildPlugin extends InternalBuildPlugin {
         if (fs.existsSync(lastDevCsnDir)) {
             lastDev = JSON.parse((await fs.promises.readFile(lastDevCsnDir, 'utf-8')).toString())
         }
+
         // enforces sqlNames option for compiler in tests, pass options from cds env, ensures that the correct format is taken
         const options = { ...this.options(), messages: this.messages, sql_mapping: cds.env.sql.names, "deploy-format": format }
-
-        const { definitions, afterImage } = await to_hdbmigration(model, lastDev, dbSrcDir, options)
+        const { definitions, afterImage } = await compileToHdbMigration(model, lastDev, dbSrcDir, options)
         let validationError
 
+        // determine the migration tables originating from a different workspaces
+        const journalEntities = getJournalEntities(model)
+        const wsMigrationTables = new Set()
+        if (journalEntities.length) {
+            for (const entity of journalEntities) {
+                if (entity['$location']?.file && wsPaths.some(wsPath => path.resolve(cds.root, entity['$location'].file).startsWith(wsPath))) {
+                    wsMigrationTables.add(getMigrationTableName(entity, model))
+                }
+            }
+        }
+
         for (const { name, suffix, content, changed } of definitions) {
             hdiPlugins.add(suffix)
             const fileName = name + suffix
             if (suffix === FILE_EXT_HDBMIGRATIONTABLE) {
-                // Skip the .hdbmigrationtable file if its origin is a different workspace.
-                // The workspace build copies artifacts located in 'db/src/**' workspace folders.
-                if (!workspaceFiles?.find(wsFile => wsFile.fileName === fileName)) {
+                // do not create .hdbmigrationtable files originating from a different workspace
+                // the --ws build option will copy these artifacts to either gen/db/src or db/src/gen
+                if (!wsMigrationTables.has(name)) {
                     migrationTableFiles.push(path.join(relDbSrcDir, fileName))
                     if (changed) {
                         if (this.hasBuildOption(OUTPUT_MODE, OUTPUT_MODE_RESULT)) {
@@ -350,6 +372,8 @@ class HanaBuildPlugin extends InternalBuildPlugin {
                     } else {
                         DEBUG?.(`no change, keep existing ${fileName}`)
                     }
+                } else {
+                    DEBUG?.(`skip generation of migration table [${fileName}] as it originates from a different workspace`)
                 }
             } else {
                 if (this.hasBuildOption(OUTPUT_MODE, OUTPUT_MODE_RESULT)) {
@@ -547,21 +571,26 @@ class HanaBuildPlugin extends InternalBuildPlugin {
 
     /**
      * Returns all hana native artifacts located in db/src/** workspace folders.
+     * @param {Array} workspacePaths Array of workspace paths, 'cds.root' is excluded from the list
      * @returns {Array} Array of workspace files, each entry contains the db src directory, 
      * the relative file path and the file name.
      */
-    async _getWorkspaceFiles() {
+    async _getWorkspaceFiles(workspacePaths) {
+        if (!workspacePaths || !workspacePaths.length) {
+            return []
+        }
         const dbPaths = new Set()
-        const workspaces = await getWorkspaces()
-
-        workspaces.forEach(workspace => {
-            const dbSrc = path.join(cds.root, workspace, 'db/src')
-            const dbCfg = path.join(cds.root, workspace, 'db/cfg')
-            if (fs.existsSync(dbSrc)) {
-                dbPaths.add(dbSrc)
-            }
-            if (fs.existsSync(dbCfg)) {
-                dbPaths.add(dbCfg)
+        workspacePaths.forEach(workspacePath => {
+            // skip workspace matching the current project if cds build is executed in a workspace folder
+            if (cds.root !== workspacePath) {
+                const dbSrc = path.join(workspacePath, 'db/src')
+                const dbCfg = path.join(workspacePath, 'db/cfg')
+                if (fs.existsSync(dbSrc)) {
+                    dbPaths.add(dbSrc)
+                }
+                if (fs.existsSync(dbCfg)) {
+                    dbPaths.add(dbCfg)
+                }
             }
         })
         const workspaceFiles = [...dbPaths].reduce((acc, src) => {
@@ -572,11 +601,15 @@ class HanaBuildPlugin extends InternalBuildPlugin {
                 }
                 return true
             })
-            files.forEach(file => acc.add({ dir: src, filePath: path.relative(src, file), fileName: path.basename(file) }))
+            files.forEach(file => acc.push({ dir: src, filePath: path.relative(src, file), fileName: path.basename(file) }))
             return acc
-        }, new Set())
+        }, [])
+
+        return workspaceFiles
+    }
 
-        return [...workspaceFiles]
+    _hasJournalDefinitions(model) {
+        return Object.values(model.definitions).some(def => def['@cds.persistence.journal'])
     }
 
     static async _readTemplateAsJson(template) {

package/lib/build/provider/internalBuildTaskProvider.js

@@ -167,7 +167,7 @@ class InternalBuildTaskProvider extends BuildTaskProvider {
                 if (!sidecarEnv.requires["cds.xt.ModelProviderService"]?._in_sidecar) {
                     if (sidecarEnv.profiles?.includes('mtx-sidecar')) {
                         // profile has been set, but cannot be resolved
-                        throw new BuildError("MTX configuration cannot be resolved. Use the 'npm install' command to install up-to-date versions of @sap/cds-mtxs and @sap/cds.")
+                        throw new BuildError("MTX configuration cannot be resolved. Run the 'npm install' command to install up-to-date versions of @sap/cds-mtxs and @sap/cds.")
                     }
                     throw new BuildError(`Invalid MTX sidecar configuration - profile 'mtx-sidecar' not set.`)
                 }

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

@@ -85,13 +85,13 @@ class MtxExtensionBuildPlugin extends InternalBuildPlugin {
         // existence already checked
         await this.copy(path.join(cds.root, 'package.json')).to(path.join(destExt, 'package.json'))
 
-        // copy handlers
-        const folders = [path.join(cds.root, cds.env.folders.srv, 'handlers')]
+        // copy handlers from srv folder
+        const folder = path.join(cds.root, cds.env.folders.srv).replace(/[/\\]$/, '')
         await this.copyNativeContent(cds.root, destExt, res => {
             if (fs.statSync(res).isDirectory()) {
-                return folders.some(folder => folder.startsWith(res))
+                return res.startsWith(folder)
             }
-            if (folders.includes(path.dirname(res)) && /\.js$/.test(res)) {
+            if (path.dirname(res).startsWith(folder) && /\.js$/.test(res)) {
                 return true
             }
         })

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

@@ -118,7 +118,7 @@ class MtxSidecarBuildPlugin extends NodejsBuildPlugin {
             const modelFilePaths = cds.resolve(modelPaths)
 
             if (!modelFilePaths || modelFilePaths.length === 0) {
-                throw new BuildError("No CDS models found in MTX sidecar. Make sure up-to-date versions of the required npm modules are installed.")
+                throw new BuildError("No CDS models found in MTX sidecar. Run the 'npm install' command to install up-to-date versions of the required packages.")
             }
             DEBUG?.(`sidecar model: ${relativePaths(cds.root, modelFilePaths).join(", ")}`)
 
@@ -126,7 +126,7 @@ class MtxSidecarBuildPlugin extends NodejsBuildPlugin {
             const unresolved = resolveRequiredSapModels(modelPaths)
             if (unresolved.length > 0) {
                 // log error, but don't fail
-                this.pushMessage(`CDS models [${unresolved.join(', ')}] required by MTX sidecar cannot be resolved. Make sure up-to-date versions of the missing npm modules are installed.`, ERROR)
+                this.pushMessage(`CDS models [${unresolved.join(', ')}] required by MTX sidecar cannot be resolved. Run the 'npm install' command to install up-to-date versions of the required packages.`, ERROR)
             }
 
             // using synchronous compilation as cds.root and cds.env have been switched to mtx/sidecar

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

@@ -3,7 +3,7 @@ const path = require('path')
 const cds = require('../../../cds')
 const cmd = require('../../../util/command');
 const EdmxBuildPlugin = require('../edmxBuildPlugin')
-const { BuildError, getWorkspaces } = require('../../util')
+const { BuildError, getWorkspaces, findWorkspaceRoot } = require('../../util')
 const { OUTPUT_MODE, OUTPUT_MODE_FILESYSTEM, ODATA_VERSION_V2, FOLDER_GEN, CONTENT_EDMX, CONTENT_PACKAGELOCK_JSON,
     CONTENT_NPMRC, CONTENT_CDSRC_JSON, CONTENT_ENV, CONTENT_DEFAULT_ENV_JSON, FLAVOR_LOCALIZED_EDMX,
     OPTION_WS_PACK} = require('../../constants')
@@ -160,14 +160,14 @@ class NodejsBuildPlugin extends EdmxBuildPlugin {
     }
 
     async _packWorkspaceDependencies(dest) {
-        const wsRoot = NodejsBuildPlugin._findWorkspaceRoot(cds.root)
+        const wsRoot = findWorkspaceRoot(cds.root)
         const appPkg = require(path.join(dest, 'package.json'))
         let workspaces
         if (this.task.options.workspaces) {
             workspaces = Array.isArray(this.task.options.workspaces) ? this.task.options.workspaces : [this.task.options.workspaces]
         } else {
             // devDependencies are not considered
-            workspaces = await getWorkspaces(true, false, wsRoot);
+            workspaces = await getWorkspaces(wsRoot, true, false);
         }
         if (workspaces.length) {
             let pkgDescriptors
@@ -197,22 +197,6 @@ class NodejsBuildPlugin extends EdmxBuildPlugin {
         }
     }
 
-    static _findWorkspaceRoot(dir) {
-        try {
-            if (require(path.join(dir, 'package.json')).workspaces) {
-                return dir
-            }
-        } catch (err) {
-            // ignore
-        }
-        if (fs.existsSync(path.join(dir, '.gitmodules'))) {
-            return // project root reached
-        }
-        if (path.dirname(dir) !== dir) {
-            return this._findWorkspaceRoot(path.dirname(dir))
-        }
-    }
-
     static async _execNpmPack(dest, wsRoot, workspaces) {
         const args = ['pack', '-ws', '--json', `--pack-destination=${dest}`]
         workspaces.forEach(w => args.push(`-w=${w}`))

package/lib/build/util.js

@@ -7,6 +7,7 @@ const IS_WIN = require('os').platform() === 'win32'
 const { SEVERITY_ERROR, FILE_EXT_CDS } = require('./constants');
 const DEBUG = cds.debug('cli|build')
 const SECRETS = /(passw)|(cert)|(ca)|(secret)|(key)/i
+const WS_MAX_DEPTH = 2
 
 function getProperty(src, segments) {
     segments = Array.isArray(segments) ? segments : segments.split('.')
@@ -98,13 +99,13 @@ 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
+        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
 }
-  
+
 /**
  * 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.
@@ -173,28 +174,30 @@ async function pathExists(path) {
     return fs.promises.access(path).then(() => true).catch(() => false);
 }
 
+async function getWorkspacePaths() {
+    const wsRoot = findWorkspaceRoot(cds.root)
+    if (!wsRoot) {
+        return []
+    }
+    return (await getWorkspaces(wsRoot)).filter(ws => cds.root !== path.join(wsRoot, ws)).map(ws => path.join(wsRoot, ws))
+}
+
 /**
  * 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 'cds.root'.
+ * @returns the paths are relative to 'wsRoot'.
  */
-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
+async function getWorkspaces(wsRoot, resolve = false, devDependencies = true) {
+    wsRoot ??= findWorkspaceRoot(cds.root)
+    if (!wsRoot) {
+        return []
     }
-
-    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'))
     }
+    const workspaces = []
     if (pgkJsonWsRoot.workspaces) {
         if (resolve) {
             _validateWsDependencies(wsRoot, pgkJson.dependencies, devDependencies ? pgkJson.devDependencies : {})
@@ -215,6 +218,25 @@ async function getWorkspaces(resolve = false, devDependencies = true, wsRoot = c
     return workspaces
 }
 
+function findWorkspaceRoot(currentPath, depth = 0) {
+    if (depth > WS_MAX_DEPTH) {
+        DEBUG?.(`No workspaces exist, max depth of ${WS_MAX_DEPTH} reached`)
+        return
+    }
+    const packageJson = path.join(currentPath, 'package.json')
+    if (fs.existsSync(packageJson)) {
+        if (require(path.join(currentPath, 'package.json')).workspaces) {
+            return currentPath
+        }
+    }
+    if (fs.existsSync(path.join(currentPath, '.gitmodules'))) {
+        return // project root reached
+    }
+    if (path.dirname(currentPath) !== currentPath) {
+        return findWorkspaceRoot(path.dirname(currentPath), depth + 1)
+    }
+}
+
 /**
  * This JavaScript function filterFeaturePaths is used to filter and categorize file paths 
  * from a given model into two categories: base and features.
@@ -452,7 +474,9 @@ module.exports = {
     getI18nDefaultFolder,
     normalizePath,
     pathExists,
+    getWorkspacePaths,
     getWorkspaces,
+    findWorkspaceRoot,
     filterFeaturePaths,
     getFiles,
     BuildMessage,

package/lib/cds.js

@@ -6,11 +6,19 @@ module.exports = Object.defineProperties (cds, {
   // for internal use in cds-dk only
   _log: { value: _local ('../bin/util/log'), configurable: true },
   _local: { value: _local, configurable: true },
+  _localOrGlobal: { value: id => _local(id, _npmRoot()), configurable: true },
 })
 
-function _local (id) {
+function _local (id, ...morePaths) {
   return require(require.resolve (id, {paths:[
     process.cwd(), // project-local module is preferred
-    __dirname      // otherwise from our own dependencies
+    __dirname,      // otherwise from our own dependencies
+    ...morePaths
   ]}))
 }
+
+function _npmRoot() {
+  try {
+    return require ('child_process').execSync('npm root -g').toString().trim()
+  } catch  { return '' }
+}

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

@@ -1,5 +1,4 @@
 const path = require('path');
-const util = require('util');
 const { bold } = require('../../util/term');
 
 const HDI_DEPLOY_LIB = '@sap/hdi-deploy';
@@ -40,15 +39,20 @@ module.exports = new class HdiDeployUtil {
         if (options.use_hdb === false) options.use_hdb = undefined
         deployerEnv.HDI_DEPLOY_OPTIONS = JSON.stringify(options)
 
-        const asyncDeploy = util.promisify(deploy);
-        const { exitCode, signal } = await asyncDeploy(dbDir, deployerEnv);
-        if (exitCode) {
-            let message = `HDI deployment failed with exit code ${exitCode}`;
-            if (signal) {
-                message += `. ${signal}`;
-            }
-            throw new Error(message);
-        }
+        return await new Promise((resolve, reject) => {
+            deploy(dbDir, deployerEnv, (error, response) => {
+                if (error) return reject(error)
+                if (response?.exitCode) {
+                    let message = `HDI deployment failed with exit code ${response.exitCode}.`
+                    if (response.signal) message += `. ${response.signal}`
+                    return reject(new Error(message))
+                }
+                return resolve()
+            }, {
+              stderrCB: buffer => console.error(buffer.toString()),
+              stdoutCB: buffer => console.log(buffer.toString())
+          })
+        })
     }
 
     _loadHdiDeployLib(cwd) {

package/lib/import/message.js

@@ -28,7 +28,7 @@ const messages = {
 	BOUND_ACTION_COLLISION: 'The combination of Action name and binding parameter type must be unique for Bound Action ',
 	STREAM_NO_COLLECTION: `'Edm.Stream' cannot be of Collection type.`,
 	UNSUPPORTED_PROPERTY_TYPE: 'Property cannot be of EntityType. Check the type: ',
-  UNRESOLVED_SCHEMA_NAMESPACE: `Could not resolve the schema `,
+	UNRESOLVED_SCHEMA_NAMESPACE: `Could not resolve the schema `,
 	INVALID_DATATYPE: `Invalid Data Type `,
 	ELEMENT_NAME_COLLISION: 'Collision between EntityContainer Element Name and Schema Element Name is currently not supported. Please check the element name: ',
 	NO_DEFAULT_FOR_COLLECTIONS: 'WARNING: Collection type cannot have a Default value.',
@@ -38,6 +38,7 @@ const messages = {
 	NULLABLE_KEY: 'WARNING: Key element cannot be Nullable.',
 	COLLISION_DETECTED: `INFO: Element name collision detected. Adding suffix to affected type category.`,
 	SPECIFY_CONFIG: 'For --config option, please specify correct JSON Object.',
+	INVALID_ANNOTATION: 'Annotation element must have a Term attribute',
 };
 
 function getMessages() {

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

@@ -1,4 +1,6 @@
 'use strict';
+
+const message = require("../../message").getMessages();
  
 const vocabulariesMap = new Map([
     ['org.odata.core.v1', () => require('../vocabularies/Org.OData.Core.V1.json')],
@@ -1754,6 +1756,9 @@ class AnnotationExpression extends Expression {
     annotate(result) { super.annotate(this.getTargetPropertyName(), this.getTarget(), result); }
     interpret() {
         const element = this.getElement();
+        if(!Object.hasOwn(element, "attributes") || !Object.hasOwn(element.attributes, "Term")) {
+            throw new Error(message.INVALID_ANNOTATION);
+        }
         let name = element.attributes.Term;
         if (element.attributes.Qualifier) name += '#' + element.attributes.Qualifier;
         name = '@' + name;

package/lib/import/odata/v4parser.js

@@ -4,10 +4,10 @@
  */
 
 "use strict";
-let messages = require("../message").getMessages();
-let common = require("../common");
-let versionInfo = require("../../../package.json").version;
-let Multimap = require("./util/MultiMap");
+const messages = require("../message").getMessages();
+const common = require("../common");
+const versionInfo = require("../../../package.json").version;
+const Multimap = require("./util/MultiMap");
 const ignoreObjects = ["$Reference"]; // add all the objects that needs to be ignored for parsing.
 const { warn, info } = require("../../util/term");
 const MetadataConverterFactory = require("./metadataconverter/MetadataConverterFactory");
@@ -428,6 +428,11 @@ function _parseAnnotationTerms(annotationTerm, annotationTermObject, csnDefsTarg
 function _validateAnnotationNamespace(annotationTerm, vocabNamespaceToAlias) {
     let aliasOrNamespace = annotationTerm.substring(1, annotationTerm.lastIndexOf('.'));
 
+    // This check is for ignoring the @cds annotations given for special cases, e.g. @cds.validate = false for collided action/function
+    if (aliasOrNamespace === "cds") {
+        return
+    }
+    
     for (let alias of Object.values(known_vocabularies)) {
         if (alias === aliasOrNamespace) {
             return;
@@ -1358,29 +1363,6 @@ function _parseEntityContainer(csnDefs, entityContainerElements, parserContext)
     return csnDefs;
 }
 
-/**
- * @param {List<Object>} dataObjList, action/function object list
- * @returns unique parameter list
- */
-function _collectAllParameters(dataObjList) {
-    let uniqueParams = [], paramNames = [], params;
-
-    for (let dataObj of dataObjList) {
-        params = dataObj.$Parameter;
-
-        if (params) {
-            for (let i = 0; i < params.length; i++) {
-                if (!paramNames.includes(params[i].$Name)) {
-                    paramNames.push(params[i].$Name);
-                    uniqueParams.push(params[i]);
-                }
-            }
-        }
-    }
-
-    return uniqueParams;
-}
-
 /**
  * @param {Boolean} isAction, to identify action/function
  * @param {String} fqName, fully qualified name
@@ -1389,7 +1371,7 @@ function _collectAllParameters(dataObjList) {
  *
  * Scenarios:
  * 1. Unbound Actions can't have collision. Action name must be unique.
- * 2. Unbound Functions can have collision; capture the max number of parameters.
+ * 2. Unbound Functions can have collision; we will parse only one function with the same name having no paramter and a generic String return type.
  */
 function _populateUnboundActionFunction(isAction, fqName, schemaDataList, parserContext) {
     let [schemaName, actFunName] = _extractSchemaNameAndElementName(fqName);
@@ -1409,8 +1391,12 @@ function _populateUnboundActionFunction(isAction, fqName, schemaDataList, parser
     }
     else {
         if (dataList.length > 1) {
-            actionFunctionObject['$Parameter'] = _collectAllParameters(dataList);
+            actionFunctionObject['$Parameter'] = [];
             parserContext.unboundFunctions[fqName] = actionFunctionObject;
+            parserContext.unboundFunctions[fqName]["@cds.validate"] = false;
+            if(parserContext.unboundFunctions[fqName].$ReturnType){
+                parserContext.unboundFunctions[fqName].$ReturnType.$Type = "Edm.String";
+            }
         }
         else {
             parserContext.unboundFunctions[fqName] = actionFunctionObject;
@@ -1439,12 +1425,11 @@ function _collectUnboundActionFunction(schemaDataList, parserContext) {
  * @param {Object} parserContext
  *
  * Scenarios for bound actions, functions:
- * 1. Actions with same name and binding parameter type can't have collision.
- * 2. Functions can have collision and we will capture the max number of parameters.
+ * 1. Actions with same name and binding parameter type can have collision and we will parse only one action with that name having no paramter and a genric String return type.
+ * 2. Functions can have collision and we will parse only one function with that name having no paramter and a genric String return type.
  * Special scenario is when same function name is bound to different entity as well.
  */
 function _collectBoundActionFunction(isAction, currNamespace, elementName, elementDataList, parserContext) {
-    let functionObjList; // list to collect all the collision obj for function
 
     for (let i = 0; i < elementDataList.length; i++) {
         let dataObj = elementDataList[i];
@@ -1480,7 +1465,12 @@ function _collectBoundActionFunction(isAction, currNamespace, elementName, eleme
                 parserContext.entityToBoundActions[boundEntityName][elementName] = dataObj;
             }
             else {
-                throw new Error(messages.BOUND_ACTION_COLLISION + `${elementName} in entity ${entityName} of schema ${currNamespace}.`);
+                parserContext.entityToBoundActions[boundEntityName][elementName]["@cds.validate"] = false;
+                parserContext.entityToBoundActions[boundEntityName][elementName]["$Parameter"] = [];
+                if (!parserContext.entityToBoundActions[boundEntityName][elementName].$ReturnType) {
+                    parserContext.entityToBoundActions[boundEntityName][elementName].$ReturnType = {};
+                }
+                parserContext.entityToBoundActions[boundEntityName][elementName].$ReturnType.$Type = "Edm.String";
             }
         }
         else {
@@ -1488,18 +1478,12 @@ function _collectBoundActionFunction(isAction, currNamespace, elementName, eleme
                 if (!parserContext.entityToBoundFunctions[boundEntityName]) {
                     parserContext.entityToBoundFunctions[boundEntityName] = {};
                 }
-                if (!functionObjList || !parserContext.entityToBoundFunctions[boundEntityName][elementName]) {
-                    functionObjList = [];
-                }
                 parserContext.entityToBoundFunctions[boundEntityName][elementName] = dataObj;
-                functionObjList.push(dataObj);
             }
             else {
-                functionObjList.push(dataObj);
-                let functionObject = functionObjList[0];
-                functionObject['$Parameter'] = _collectAllParameters(functionObjList);
-                functionObjList = [functionObject]; // reset the function object list with recently formed object
-                parserContext.entityToBoundFunctions[boundEntityName][elementName] = functionObject;
+                parserContext.entityToBoundFunctions[boundEntityName][elementName]["@cds.validate"] = false;
+                parserContext.entityToBoundFunctions[boundEntityName][elementName]["$Parameter"] = [];
+                parserContext.entityToBoundFunctions[boundEntityName][elementName].$ReturnType.$Type = "Edm.String";
             }
             // throw error if the return type is missing
             if (!parserContext.entityToBoundFunctions[boundEntityName][elementName].$ReturnType) {
@@ -1688,7 +1672,12 @@ function _generateEDMX2JSON(edmx, name_space) {
                 if (missingReferencedDocuments?.length > 0) {
                     console.log(missingReferencedDocuments);  
                 }
-                resolve(json);
+
+                if (error) {
+                    reject(error);
+                } else {
+                    resolve(json);
+                }
             });
         } catch (err) {
             reject(err);