@sap/cds-compiler 2.12.0 → 2.15.2

package/lib/base/optionProcessorHelper.js

@@ -74,39 +74,39 @@ function createOptionProcessor() {
    */
   function command(cmdString) {
     /** @type {object} */
-    const command = {
+    const cmd = {
       options: {},
       positionalArguments: [],
-      option,
+      option: commandOption,
       positionalArgument: (argumentDefinition) => {
-        _setPositionalArguments(argumentDefinition, command.positionalArguments);
-        return command;
+        _setPositionalArguments(argumentDefinition, cmd.positionalArguments);
+        return cmd;
       },
-      help,
+      help: commandHelp,
       ..._parseCommandString(cmdString)
     };
-    if (optionProcessor.commands[command.longName]) {
-      throw new Error(`Duplicate assignment for long command ${command.longName}`);
+    if (optionProcessor.commands[cmd.longName]) {
+      throw new Error(`Duplicate assignment for long command ${cmd.longName}`);
     }
-    optionProcessor.commands[command.longName] = command;
+    optionProcessor.commands[cmd.longName] = cmd;
 
-    if (command.shortName) {
-      if (optionProcessor.commands[command.shortName]) {
-        throw new Error(`Duplicate assignment for short command ${command.shortName}`);
+    if (cmd.shortName) {
+      if (optionProcessor.commands[cmd.shortName]) {
+        throw new Error(`Duplicate assignment for short command ${cmd.shortName}`);
       }
-      optionProcessor.commands[command.shortName] = command;
+      optionProcessor.commands[cmd.shortName] = cmd;
     }
-    return command;
+    return cmd;
 
     // Command API: Define a command option
-    function option(optString, validValues, options) {
-      return _addOption(command, optString, validValues, options);
+    function commandOption(optString, validValues, options) {
+      return _addOption(cmd, optString, validValues, options);
     }
 
     // Command API: Define the command help text
-    function help(text) {
-      command.helpText = text;
-      return command;
+    function commandHelp(text) {
+      cmd.helpText = text;
+      return cmd;
     }
   }
 
@@ -156,33 +156,33 @@ function createOptionProcessor() {
    * @private
    * @see option()
    */
-  function _addOption(command, optString, validValues, options) {
+  function _addOption(cmd, optString, validValues, options) {
     const opt = _parseOptionString(optString, validValues);
     Object.assign(opt, options);
 
-    if (command.options[opt.longName]) {
+    if (cmd.options[opt.longName]) {
       throw new Error(`Duplicate assignment for long option ${opt.longName}`);
     } else if (optionProcessor.options[opt.longName]) {
       // This path is only taken if optString is for commands
       optionProcessor.optionClashes.push({
         option: opt.longName,
-        description: `Command '${command.longName}' has option clash with general options for: ${opt.longName}`
+        description: `Command '${cmd.longName}' has option clash with general options for: ${opt.longName}`
       });
     }
-    command.options[opt.longName] = opt;
+    cmd.options[opt.longName] = opt;
     if (opt.shortName) {
-      if (command.options[opt.shortName]) {
+      if (cmd.options[opt.shortName]) {
         throw new Error(`Duplicate assignment for short option ${opt.shortName}`);
       } else if (optionProcessor.options[opt.shortName]) {
         // This path is only taken if optString is for commands
         optionProcessor.optionClashes.push({
           option: opt.shortName,
-          description: `Command '${command.longName}' has option clash with general options for: ${opt.shortName}`
+          description: `Command '${cmd.longName}' has option clash with general options for: ${opt.shortName}`
         });
       }
-      command.options[opt.shortName] = opt;
+      cmd.options[opt.shortName] = opt;
     }
-    return command;
+    return cmd;
   }
 
   // Internal: Parse one command string like "F, toFoo". Return an object like this
@@ -339,47 +339,12 @@ function createOptionProcessor() {
         // No more options after '--'
         seenDashDash = true;
       }
+      else if (!seenDashDash && arg.startsWith('--')) {
+        i += processOption(i);
+      }
       else if (!seenDashDash && arg.startsWith('-')) {
-        if (result.command) {
-          // We already have a command
-          const opt = optionProcessor.commands[result.command].options[arg];
-          if (opt) {
-            // Found as a command option
-            i += processOption(i, opt, result.command);
-          } else {
-            // No command option, try general options as fallback
-            const opt = optionProcessor.options[arg];
-            if (opt) {
-              i += processOption(i, opt, false);
-            } else {
-              // Not found at all, put into unknownOptions if it is an option
-              // for another cdsc command.
-              // We dig into the other cdsc commands in order to check if
-              // the option expects a parameter and if so to take the next argument as a value
-              if (Object.keys(optionProcessor.commands).some(cmd => optionProcessor.commands[cmd].options[arg])) {
-                const cmd = optionProcessor.commands[
-                  Object.keys(optionProcessor.commands).find(cmd => optionProcessor.commands[cmd].options[arg])
-                ];
-                i += processOption(i, cmd.options[arg], optionProcessor.commands[result.command], true);
-              } else { // still add it to the unknownOptions
-                result.unknownOptions.push(`Unknown option "${arg}" for the command "${result.command}"`);
-                // if the next argument looks like an argument for this unknown option => skip it
-                if ((i + 1) < argv.length && !argv[i + 1].match('(^[.-])|[.](csn|cds|json)$'))
-                  i++;
-              }
-            }
-          }
-        } else {
-          // We don't have a command
-          const opt = optionProcessor.options[arg];
-          if (opt) {
-            // Found as a general option
-            i += processOption(i, opt, false);
-          } else {
-            // Not found, complain
-            result.unknownOptions.push(`Unknown option "${arg}"`);
-          }
-        }
+        splitSingleLetterOption(argv, i); // `-ab` -> `-a -b`
+        i += processOption(i);
       }
       else {
         // Command or arg
@@ -407,7 +372,11 @@ function createOptionProcessor() {
     const missingArg = getCurrentPositionArguments().find((arg) => arg.required && !result.args[arg.name]);
     if (missingArg) {
       const forCommand = result.command ? ` for '${ result.command }'` : '';
-      result.errors.push(`Missing positional argument${forCommand}: <${missingArg.name}${missingArg.isDynamic ? '...' : ''}>`)
+      const errorMsg = `Missing positional argument${forCommand}: <${missingArg.name}${missingArg.isDynamic ? '...' : ''}>`;
+      if (forCommand)
+        result.cmdErrors.push(errorMsg)
+      else
+        result.errors.push(errorMsg)
     }
 
     return result;
@@ -448,57 +417,127 @@ function createOptionProcessor() {
 
     // (Note that this works on 'argv' and 'result' from above).
     // Process 'argv[i]' as an option.
-    // Check the option definition in 'opt' to see if a parameter is expected.
+    // Check the option definition to see if a parameter is expected.
     // If so, take it (complain if one is found in 'argv').
     // Populate 'result.options' with the result. Return the number params found (0 or 1).
-    function processOption(i, opt, command, unknownOption = false) {
-      // Does this option expect a parameter?
-      if (opt.param) {
-        if (i + 1 >= argv.length || argv[i + 1].startsWith('-')) {
-          // There should be a param but isn't - complain
-          let error = `Missing param "${opt.param}" for option "${opt.shortName ? opt.shortName + ', ': ''}${opt.longName}"`;
-          if (command && unknownOption) {
-            result.unknownOptions.push(`Unknown option "${argv[i]}" for the command "${command.longName}"`);
-          } else if (command) {
-            error = `${error} of command "${command}"`;
-            result.cmdErrors.push(error);
-          } else {
-            result.errors.push(error);
+    function processOption(i) {
+      const arg = argv[i];
+      let currentCommand = result.command;
+
+      // First check top-level options
+      let currentOption = optionProcessor.options[arg];
+      if (currentCommand) {
+        // If there is a command and it has an option that overrides it, use it instead.
+        const cmdOpt = optionProcessor.commands[currentCommand].options[arg];
+        if (cmdOpt)
+          currentOption = cmdOpt;
+        else if (currentOption)
+          // Otherwise, if there exist a top-level option, set 'command' to null.
+          currentCommand = null;
+      }
+
+      if (!currentOption)
+        return reportUnknown();
+
+      if (!currentOption.param) {
+        setCurrentOption(true);
+        return 0;
+      }
+
+      const param = paramForOption(currentOption);
+      if (param === null)
+        return 0;
+      setCurrentOption(param);
+      return 1;
+
+      /**
+       * Report that an option is unknown. If the option exists for other
+       * commands or if the next argument looks like a param, return 1,
+       * otherwise 0, indicating how many argv fields have been consumed.
+       *
+       * @returns {number}
+       */
+      function reportUnknown() {
+        if (currentCommand)
+          result.unknownOptions.push(`Unknown option "${arg}" for the command "${currentCommand}"`);
+        else
+          result.unknownOptions.push(`Unknown option "${arg}"`);
+
+        if (currentCommand) {
+          // Not found at all.  We dig into the other cdsc commands in order to check if
+          // the option expects a parameter and if so to take the next argument as a value
+          const otherCmd = Object.keys(optionProcessor.commands).find(cmd => optionProcessor.commands[cmd].options[arg]);
+          const otherCmdOpt = otherCmd && optionProcessor.commands[otherCmd].options[arg];
+          if (otherCmdOpt && hasParamForUnknown(otherCmdOpt)) {
+            return 1
           }
-          return 0;
         }
-        else {
-          // Take the option with the parameter
-          const value = argv[i + 1];
-          const shortOption = opt.shortName ? `${opt.shortName}, ` : ''
-          if (command) {
-            // if an unknown option for a command => add it to the array and warn about
-            if (unknownOption) {
-              result.unknownOptions.push(`Unknown option "${argv[i]}" for the command "${command.longName}"`);
-            } else {
-              result.options[command][opt.camelName] = value;
-              if (!isValidOptionValue(opt, value)) {
-                result.cmdErrors.push(`Invalid value "${value}" for option "${shortOption}${opt.longName}" - use one of [${opt.validValues}]`);
-              }
-            }
-          } else {
-            result.options[opt.camelName] = value;
-            if (!isValidOptionValue(opt, value)) {
-              result.errors.push(`Invalid value "${value}" for option "${shortOption}${opt.longName}" - use one of [${opt.validValues}]`);
-            }
-          }
+
+        if (hasParamForUnknown(null))
           return 1;
+
+        return 0;
+      }
+
+      function setCurrentOption(val) {
+        if (currentCommand) {
+          if (!result.options[currentCommand])
+            result.options[currentCommand] = {};
+          result.options[currentCommand][currentOption.camelName] = val;
+        }
+        else {
+          result.options[currentOption.camelName] = val;
         }
       }
-      // No parameter, take option as bool
-      if (command) {
-        unknownOption
-          ? result.unknownOptions.push(`Unknown option "${argv[i]}" for the command "${command.longName}"`)
-          : result.options[command][opt.camelName] = true;
-      } else {
-        result.options[opt.camelName] = true;
+
+      function reportMissingParam(opt) {
+        let error = `Missing param "${opt.param}" for option "${opt.shortName ? opt.shortName + ', ': ''}${opt.longName}"`;
+        if (currentCommand) {
+          error = `${error} of command "${currentCommand}"`;
+          result.cmdErrors.push(error);
+        } else {
+          result.errors.push(error);
+        }
+      }
+
+      function reportInvalidValue(opt, value) {
+        const shortOption = opt.shortName ? `${opt.shortName}, ` : ''
+        const errors = currentCommand ? result.cmdErrors : result.errors;
+        errors.push(`Invalid value "${value}" for option "${shortOption}${opt.longName}" - use one of [${opt.validValues}]`);
+      }
+
+      /**
+       * Get the value for the option's parameter. If the option does not require one,
+       * returns `null`. Reports missing parameters and invalid values.
+       *
+       * @returns {null|*}
+       */
+      function paramForOption(opt, reportMissing = true) {
+        if (i + 1 >= argv.length || argv[i + 1].startsWith('-')) {
+          if (reportMissing)
+            reportMissingParam(opt)
+          return null;
+        }
+
+        const value = argv[i + 1];
+        if (!isValidOptionValue(opt, value) && reportMissing) {
+          reportInvalidValue(opt, value);
+        }
+        return value;
+      }
+
+      /**
+       * Returns true if:
+       *  - we didn't find an option (opt === null) _or_
+       *  - we found an option and it requires a param
+       * _and_ if the next arg looks like an argument.
+       *
+       * @param {object|null} opt
+       * @returns {boolean}
+       */
+      function hasParamForUnknown(opt) {
+        return ((!opt || opt.param) && (i + 1) < argv.length && !argv[i + 1].match('(^[.-])|[.](csn|cdl|cds|json)$'));
       }
-      return 0;
     }
   }
 
@@ -506,16 +545,16 @@ function createOptionProcessor() {
   // If 'command' is supplied, check only 'options.command', otherwise check
   // only top-level options
   // Return an array of complaints (possibly empty)
-  function verifyOptions(options, command = undefined, silent = false) {
+  function verifyOptions(options, commandName = undefined, silent = false) {
     const result = [];
     let opts;
 
-    if((options.betaMode || options.beta) && !options.testMode && !silent) {
+    if ((options.betaMode || options.beta) && !options.testMode && !silent) {
       const mode = options.beta ? 'beta' : 'beta-mode';
       result.push(`Option --${mode} was used. This option should not be used in productive scenarios!`)
     }
 
-    if(options) {
+    if (options) {
       [
         'defaultBinaryLength', 'defaultStringLength',
         /*'length', 'precision', 'scale'*/
@@ -528,13 +567,13 @@ function createOptionProcessor() {
       });
     }
 
-    if (command) {
-      const cmd = optionProcessor.commands[command];
+    if (commandName) {
+      const cmd = optionProcessor.commands[commandName];
       if (!cmd) {
-        throw new Error(`Expected existing command: "${command}"`);
+        throw new Error(`Expected existing command: "${cmd}"`);
       }
       opts = cmd.options;
-      options = options[command] || {};
+      options = options[cmd] || {};
       if (typeof options === 'boolean') {
         // Special case: command without options
         options = {};
@@ -548,12 +587,12 @@ function createOptionProcessor() {
       let error;
       if (!opt) {
         // Don't report commands in top-level options
-        if ((command || !optionProcessor.commands[camelName]) && !silent) {
-          error = `Unknown option "${command ? command + '.' : ''}${camelName}"`;
+        if ((commandName || !optionProcessor.commands[camelName]) && !silent) {
+          error = `Unknown option "${commandName ? commandName + '.' : ''}${camelName}"`;
         }
       } else {
         const param = options[camelName];
-        error = verifyOptionParam(param, opt, command ? command + '.' : '');
+        error = verifyOptionParam(param, opt, commandName ? commandName + '.' : '');
       }
       if (error) {
         result.push(error);
@@ -596,15 +635,30 @@ function createOptionProcessor() {
 
   // Return an array of unique camelNames of the options for the specified command
   // If invalid command -> an empty array
-  function camelOptionsForCommand(command) {
-    if (!command || !optionProcessor.commands[command])
+  function camelOptionsForCommand(cmd) {
+    if (!cmd || !optionProcessor.commands[cmd])
       return []
-    const cmd = optionProcessor.commands[command];
+    cmd = optionProcessor.commands[cmd];
     const names = Object.keys(cmd.options).map(name => cmd.options[name].camelName);
     return [...new Set(names)];
   }
 }
 
+/**
+ * Splits `-abc` into `-a -b -c`. Does this in-place on argv.
+ *
+ * @param {string[]} argv Argument array
+ * @param {number} i Current option index.
+ */
+function splitSingleLetterOption(argv, i) {
+  const arg = argv[i];
+  if (arg.length > 2) { // must be at least `-ab`.
+    const rest = argv.slice(i + 1);
+    argv.length = i; // trim array
+    argv.push(...arg.split('').slice(1).map(a => `-${a}`), ...rest);
+  }
+}
+
 /**
  * Return a camelCase name "fooBar" for a long option "--foo-bar"
  */

package/lib/checks/annotationsOData.js

@@ -13,42 +13,22 @@
  * @param {CSN.Element} member Member to be checked
  */
 function checkCoreMediaTypeAllowence(member) {
-  const allowedCoreMediaTypes = [
-    'cds.String',
-    'cds.LargeString',
-    'cds.hana.VARCHAR',
-    'cds.hana.CHAR',
-    'cds.Binary',
-    'cds.LargeBinary',
-    'cds.hana.CLOB',
-    'cds.hana.BINARY',
-  ];
-  if (member['@Core.MediaType'] && member.type && !allowedCoreMediaTypes.includes(member.type)) {
+  const allowedCoreMediaTypes = {
+    'cds.String': 1,
+    'cds.LargeString': 1,
+    'cds.hana.VARCHAR': 1,
+    'cds.hana.CHAR': 1,
+    'cds.Binary': 1,
+    'cds.LargeBinary': 1,
+    'cds.hana.CLOB': 1,
+    'cds.hana.BINARY': 1,
+  };
+  if (member['@Core.MediaType'] && member.type && !(this.csnUtils.getFinalBaseType(member.type) in allowedCoreMediaTypes)) {
     this.warning(null, member.$path, { names: [ 'Edm.String', 'Edm.Binary' ] },
                  'Element annotated with “@Core.MediaType” should be of a type mapped to $(NAMES)');
   }
 }
 
-/**
- * Make sure only one element in a definition is annotated with `@Core.MediaType`
- * This is only OData V2 relevant.
- *
- * @param {CSN.Artifact} artifact Definition to be checked
- * @param {string} artifactName The name of the artifact
- */
-function checkForMultipleCoreMediaTypes(artifact, artifactName) {
-  if (!this.csnUtils.getServiceName(artifactName))
-    return;
-  if (this.options.toOdata && this.options.toOdata.version === 'v2' && artifact.elements) {
-    const mediaTypeElementsNames = Object.keys(artifact.elements)
-      .filter(elementName => artifact.elements[elementName]['@Core.MediaType']);
-    if (mediaTypeElementsNames.length > 1) {
-      this.error(null, artifact.$path, { names: mediaTypeElementsNames },
-                 `Multiple elements $(NAMES) annotated with “@Core.MediaType”, OData V2 allows only one`);
-    }
-  }
-}
-
 /**
  * Check if `@Aggregation.default` is assigned together with `@Analytics.Measure`
  *
@@ -82,13 +62,12 @@ function checkAtSapAnnotations(node) {
 function checkReadOnlyAndInsertOnly(artifact, artifactName) {
   if (!this.csnUtils.getServiceName(artifactName))
     return;
-  if (artifact.kind && [ 'entity', 'view' ].includes(artifact.kind) && artifact['@readonly'] && artifact['@insertonly'])
+  if (artifact.kind === 'entity' && artifact['@readonly'] && artifact['@insertonly'])
     this.warning(null, artifact.$path, 'Annotations “@readonly” and “@insertonly” can\'t be assigned in combination');
 }
 
 module.exports = {
   checkCoreMediaTypeAllowence,
-  checkForMultipleCoreMediaTypes,
   checkAnalytics,
   checkAtSapAnnotations,
   checkReadOnlyAndInsertOnly,

package/lib/checks/arrayOfs.js

@@ -1,7 +1,5 @@
 'use strict';
 
-const { forEachMemberRecursively } = require('../model/csnUtils');
-
 // Only to be used with validator.js - a correct `this` value needs to be provided!
 
 /**
@@ -43,35 +41,4 @@ function validateAssociationsInItems(member) {
   }
 }
 
-/**
- * Check that there are no .items containing .items.
- *
- * @param {CSN.Artifact} art Artifact
- * @param {string} artName Name of the artifact
- */
-function checkChainedArray(art, artName) {
-  if (!this.csnUtils.getServiceName(artName))
-    return;
-  checkIfItemsOfItems.bind(this)(art);
-  forEachMemberRecursively(art, checkIfItemsOfItems.bind(this));
-
-  /**
-   *
-   * @param {object} construct the construct to be checked
-   */
-  function checkIfItemsOfItems(construct) {
-    const constructType = this.csnUtils.effectiveType(construct);
-    if (constructType.items) {
-      if (constructType.items.items) {
-        this.error('chained-array-of', construct.$path, '"Array of"/"many" must not be chained with another "array of"/"many" inside a service');
-        return;
-      }
-
-      const itemsType = this.csnUtils.effectiveType(constructType.items);
-      if (itemsType.items)
-        this.error('chained-array-of', construct.$path, '"Array of"/"many" must not be chained with another "array of"/"many" inside a service');
-    }
-  }
-}
-
-module.exports = { validateAssociationsInItems, checkChainedArray };
+module.exports = { validateAssociationsInItems };

package/lib/checks/cdsPersistence.js

@@ -13,7 +13,8 @@
 function validateCdsPersistenceAnnotation(artifact, artifactName, prop, path) {
   if (artifact.kind === 'entity') {
     // filter for 'table', 'udf', 'calcview' === true
-    const TableUdfCv = Object.keys(artifact).filter(p => [ '@cds.persistence.table', '@cds.persistence.udf', '@cds.persistence.calcview' ].includes(p) && artifact[p]);
+    const persistenceAnnos = [ '@cds.persistence.table', '@cds.persistence.udf', '@cds.persistence.calcview' ];
+    const TableUdfCv = Object.keys(artifact).filter(p => persistenceAnnos.includes(p) && artifact[p]);
     if (TableUdfCv.length > 1)
       this.error(null, path, `Annotations ${ TableUdfCv.join(', ') } can't be used in combination`);
   }

package/lib/checks/enricher.js

@@ -30,6 +30,7 @@ function enrichCsn( csn ) {
     type: simpleRef,
     target: simpleRef,
     includes: simpleRef,
+    columns,
     // Annotations are ignored.
     '@': () => { /* ignore annotations */ },
   };
@@ -40,7 +41,7 @@ function enrichCsn( csn ) {
     cleanupCallbacks = [];
   };
 
-  const { inspectRef, artifactRef } = csnRefs( csn );
+  const { inspectRef, artifactRef, getElement } = csnRefs( csn );
   const csnPath = [];
   if (csn.definitions)
     dictionary( csn, 'definitions', csn.definitions );
@@ -82,6 +83,21 @@ function enrichCsn( csn ) {
     csnPath.pop();
   }
 
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  function columns( parent, prop, node ) {
+    // Establish the link relationships
+    parent[prop].forEach((column) => {
+      const element = getElement(column);
+      if (element) {
+        setProp(column, '_element', element);
+        cleanupCallbacks.push(() => delete column._element);
+        setProp(element, '_column', column);
+        cleanupCallbacks.push(() => delete element._column);
+      }
+    });
+    standard(parent, prop, node);
+  }
+
   // eslint-disable-next-line jsdoc/require-jsdoc
   function simpleRef( node, prop ) {
     setProp(node, '$path', [ ...csnPath ]);

package/lib/checks/invalidTarget.js

@@ -2,6 +2,8 @@
 
 // Only to be used with validator.js - a correct this value needs to be provided!
 
+const { ModelError } = require('../base/error');
+
 /**
  * Assert that targets of associations and compositions are entities.
  *
@@ -22,7 +24,7 @@ function invalidTarget(member) {
     if (mem.target) {
       const target = this.csn.definitions[mem.target];
       if (!target)
-        throw new Error(`Expected target ${ mem.target }`);
+        throw new ModelError(`Expected target ${ mem.target }`);
       if (target.kind !== 'entity') {
         const isAssoc = this.csnUtils.getFinalBaseType(member.type) !== 'cds.Composition';
         this.error(

package/lib/checks/managedWithoutKeys.js

@@ -1,6 +1,8 @@
 'use strict';
 
 
+const { ModelError } = require('../base/error');
+
 /**
  * Trigger a recompilation in case of an association without .keys and without .on
  *
@@ -10,7 +12,7 @@
  */
 function managedWithoutKeys(member, memberName, prop) {
   if (prop === 'elements' && member.target && !member.keys && !member.on) { // trigger recompilation
-    throw new Error('Expected association to have either an on-condition or foreign keys.');
+    throw new ModelError('Expected association to have either an on-condition or foreign keys.');
   }
 }
 

package/lib/checks/selectItems.js

@@ -29,7 +29,7 @@ function validateSelectItems(query) {
     }
   });
   // .call() with 'this' to ensure we have access to the options
-  rejectManagedAssociationsAndStructuresForHdbcsNames.call(this, SELECT, SELECT.$path);
+  rejectManagedAssociationsAndStructuresForHdbcdsNames.call(this, SELECT, SELECT.$path);
 }
 
 
@@ -41,10 +41,10 @@ function validateSelectItems(query) {
  * @param {CSN.Artifact} queryArtifact the query artifact which should be checked
  * @param {CSN.Path} artifactPath the path to that artifact
  */
-function rejectManagedAssociationsAndStructuresForHdbcsNames(queryArtifact, artifactPath) {
+function rejectManagedAssociationsAndStructuresForHdbcdsNames(queryArtifact, artifactPath) {
   if (this.options.transformation === 'hdbcds' && this.options.sqlMapping === 'hdbcds') {
     forEachGeneric(queryArtifact, 'elements', (selectItem, elemName, prop, elementPath) => {
-      if (this.csnUtils.isManagedAssociationElement(selectItem))
+      if (this.csnUtils.isManagedAssociation(selectItem))
         this.error('query-unexpected-assoc-hdbcds', elementPath);
       if (this.csnUtils.isStructured(selectItem))
         this.error('query-unexpected-structure-hdbcds', elementPath);
@@ -52,4 +52,4 @@ function rejectManagedAssociationsAndStructuresForHdbcsNames(queryArtifact, arti
   }
 }
 
-module.exports = { validateSelectItems, rejectManagedAssociationsAndStructuresForHdbcsNames };
+module.exports = { validateSelectItems, rejectManagedAssociationsAndStructuresForHdbcdsNames };