@sap/cds-compiler 4.5.0 → 4.6.2

package/lib/api/options.js

@@ -67,6 +67,7 @@ const privateOptions = [
   'noRecompile',
   'internalMsg',
   'disableHanaComments',      // in case of issues with hana comment rendering
+  'tenantAsColumn',           // not published yet
   'localizedWithoutCoalesce', // deprecated version of 'localizedLanguageFallback', TODO(v5): Remove option
 ];
 
@@ -158,6 +159,13 @@ module.exports = {
       };
       return translateOptions(options, defaultOptions, hardOptions, undefined, [ 'valid-structured' ], 'to.edmx');
     },
+    odata: (options) => {
+      const hardOptions = { combined: true, toOdata: true };
+      const defaultOptions = {
+        odataVersion: 'v4', odataFormat: 'flat',
+      };
+      return translateOptions(options, defaultOptions, hardOptions, undefined, [ 'valid-structured' ], 'to.odata');
+    },
   },
   for: {   // TODO: Rename version to oDataVersion
     odata: (options) => {

package/lib/base/message-registry.js

@@ -122,7 +122,7 @@ const centralMessages = {
   'ref-undefined-var':    { severity: 'Error' },
   'ref-undefined-element': { severity: 'Error' },
   'anno-undefined-element': { severity: 'Error' },
-  'ref-unknown-var': { severity: 'Info', errorFor: [ 'to.hdbcds', 'to.sql', 'to.hdi', 'to.rename' ] },
+  'ref-unknown-var': { severity: 'Info' },
   'ref-obsolete-parameters': { severity: 'Error', configurableFor: 'v4' },
            // does not hurt us, but makes it tedious to detect parameter refs
   'ref-undefined-param': { severity: 'Error' },
@@ -254,6 +254,7 @@ const centralMessageTexts = {
     std: 'Unexpected option combination: $(OPTION) and $(PROP)', // unused
     'beta-no-test':'Option $(OPTION) was used. This option should not be used in productive scenarios!',
   },
+  'api-unexpected-option': 'Option $(OPTION) can\'t be used in backend $(MODULE)',
   'api-invalid-lookup-dir': {
     std: '',
     slash: 'Expected directory $(VALUE) in option $(OPTION) to end with $(OTHERVALUE)',
@@ -585,6 +586,7 @@ const centralMessageTexts = {
     std: 'Variable $(ID) has not been found',
     alias: 'Variable $(ID) has not been found. Use table alias $(ALIAS) to refer an element with the same name',
     self: 'Variable $(ID) has not been found. Use $(ALIAS) to refer an element with the same name',
+    value: 'No value found for variable $(ID). Use option $(OPTION) to specify a value for $(ID)',
   },
   'ref-unknown-var': {
     std: 'No replacement found for special variable $(ID)'
@@ -659,6 +661,12 @@ const centralMessageTexts = {
     'on-condition': 'ON-conditions must not contain parameters, step $(ID) of path $(ELEMREF)',
     calc: 'Unexpected arguments in path $(ELEMREF) of stored calculated element; only simple paths can be used here'
   },
+  'ref-unsupported-type': {
+    std: 'Type $(TYPE) is not supported',
+    hana: 'Type $(TYPE) is only supported for SQL dialect $(VALUE), not $(OTHERVALUE)',
+    hdbcds:'Type $(TYPE) is not supported in HDBCDS',
+    odata: 'Type $(TYPE) is not supported for OData'
+  },
 
   // TODO: Better text ?
   'rewrite-not-supported': 'The ON-condition is not rewritten here - provide an explicit ON-condition',
@@ -852,8 +860,10 @@ const centralMessageTexts = {
     param: 'A type, an element, or a service entity is expected here',
     event: 'A type, an element, an event, or a service entity is expected here',
   },
-  // TODO: text variant if the association does not start an entity
-  'ref-invalid-source': 'A query source must be an entity or an association',
+  'ref-invalid-source': {
+    std: 'A query source must be an entity or an association',
+    event: 'An event\'s projection source must be an entity, structured type, event or an association',
+  },
   'extend-columns': {
     std: 'Artifact $(ART) can\'t be extended with columns, only simple views/projections without JOINs and UNIONs can',
     join: 'Artifact $(ART) can\'t be extended with columns, because it contains a JOIN',
@@ -910,6 +920,7 @@ const centralMessageTexts = {
     std: 'Specified element $(NAME) differs from inferred element in property $(PROP)',
     type: 'Expected type of specified element $(NAME) to be the same as the inferred element\'s type',
     typeName: 'Expected type $(TYPE) of specified element $(NAME) to be the same as the inferred element\'s type $(OTHERTYPE)',
+    typeExtra: 'Element $(NAME) does not have an inferred type property, but an unexpected type $(TYPE) was specified',
     missing: 'Specified element $(NAME) differs from inferred element: it is missing property $(PROP)',
     extra: 'Specified element $(NAME) differs from inferred element: it has an additional property $(PROP)',
     target: 'Expected target $(TARGET) of specified element $(NAME) to be the same as the inferred element\'s target $(ART)',
@@ -958,7 +969,8 @@ const centralMessageTexts = {
     'to-structure': 'Can\'t cast to a structured type',
     'from-structure':  'Structured elements can\'t be cast to a different type',
     'expr-to-structure': 'Can\'t cast an expression to a structured type',
-    'val-to-structure': 'Can\'t cast $(VALUE) to a structured type'
+    'val-to-structure': 'Can\'t cast $(VALUE) to a structured type',
+    'from-assoc': 'Invalid type cast on an association'
   },
 
   // -----------------------------------------------------------------------------------
@@ -1096,6 +1108,7 @@ const centralMessageTexts = {
     'unknown': '$(TYPE) is not a known vocabulary type for $(ANNO)',
     'abstract': 'Unexpected abstract type $(TYPE) for $(ANNO), use $(CODE) to specify a concrete type',
     'derived': 'Expected specified $(TYPE) to be derived from $(NAME) for $(ANNO)',
+    'literal': 'Expected value $(RAWVALUE) of specified $(CODE) to be a string literal for $(ANNO)'
   },
   'odata-anno-def': {
     // All $(ANNO) w/o sub elements, term qualifiers and context stack

package/lib/base/messages.js

@@ -305,14 +305,14 @@ function makeMessageFunction( model, options, moduleName = null ) {
       throw new CompilerAssertion('makeMessageFunction() expects options.messages to exist in testMode!');
   }
 
-  const hasMessageArray = !!options.messages;
+  const hasMessageArray = Array.isArray(options.messages);
   /**
    * Array of collected compiler messages. Only use it for debugging. Will not
    * contain the messages created during a `callTransparently` call.
    *
    * @type {CompileMessage[]}
    */
-  let messages = options.messages || [];
+  let messages = hasMessageArray ? options.messages : [];
   /**
    * Whether an error was emitted in the module. Also includes reclassified errors.
    * @type {boolean}
@@ -332,6 +332,7 @@ function makeMessageFunction( model, options, moduleName = null ) {
     throwWithAnyError,
     callTransparently,
     moduleName,
+    setModel,
   };
 
   function _message( id, location, textOrArguments, severity, texts = null ) {
@@ -550,6 +551,16 @@ function makeMessageFunction( model, options, moduleName = null ) {
     messages = backup;
     return collected;
   }
+
+  /**
+   * Change the model used to calculate CSN locations.
+   * This is necessary if you change the model heavily and rely on $paths relative to the new model.
+   *
+   * @param {CSN.Model} _model
+   */
+  function setModel( _model ) {
+    model = _model;
+  }
 }
 
 /**
@@ -679,6 +690,7 @@ const paramsTransform = {
   meta: quote.angle,
   othermeta: quote.angle,
   keyword,
+  module: quote.single,
   // more complex convenience:
   names: transformManyWith( quoted ),
   number: quote.single,         // number cited from source or expected in source
@@ -1583,7 +1595,7 @@ function constructSemanticLocationFromCsnPath( model, options, csnPath ) {
     else if (step === 'targetAspect') {
       // skip
     }
-    else if (step === 'xpr' || step === 'ref' || step === 'as' || step === 'value') {
+    else if (step === 'xpr' || step === 'default' || step === 'ref' || step === 'as' || step === 'value') {
       break; // don't go into xprs, refs, aliases, values, etc.
     }
     else if (step === 'returns') {

package/lib/base/model.js

@@ -38,6 +38,7 @@ const availableBetaFlags = {
   effectiveCsn: true,
   tenantVariable: true,
   calcAssoc: true,
+  vectorType: true,
   // disabled by --beta-mode
   nestedServices: false,
 };

package/lib/base/optionProcessorHelper.js

@@ -16,7 +16,8 @@
  *   optionProcessor.command('toXyz')
  *     .help(`Help text for command "toXyz")
  *     .option('-y  --y-in-long-form')
- *     .option('    --bar-wiz <w>', ['bla', 'foo'])
+ *     .option('    --bar-wiz <w>', { valid: ['bla', 'foo'] })
+ *     .option('-z  --name-in-cdsc', { optionName: 'nameInOptions' })
  * ```
  *
  * Options *must* have a long form, can have at most one <param>, and optionally
@@ -34,29 +35,27 @@ function createOptionProcessor() {
     optionClashes: [],
     option,
     command,
-    positionalArgument: (argumentDefinition) => {
+    positionalArgument(argumentDefinition) {
       // Default positional arguments; may be overwritten by commands.
       _setPositionalArguments(argumentDefinition);
       return optionProcessor;
     },
     help,
     processCmdLine,
-    verifyOptions,
-    camelOptionsForCommand,
-    // TODO: Why exported?
-    _parseCommandString,
-    _parseOptionString,
   };
   return optionProcessor;
 
   /**
    * API: Define a general option.
    * @param {string} optString Option string describing the command line option.
-   * @param {string[]} [validValues] Array of valid values for the options.
-   * @param {object} [options] Further options such as `ignoreCase: true`
+   * @param {object} [options] Further options such as `ignoreCase: true` and `valid: []`.
+   * @param {string[]} [options.valid] Valid values for the option.
+   * @param {string[]} [options.ignoreCase] Ignore the case for "options.valid".
+   * @param {string[]} [options.optionName] Name of the option after parsing CLI arguments.
+   *                                        Defaults to the camelified name of the long name.
    */
-  function option( optString, validValues, options ) {
-    return _addOption(optionProcessor, optString, validValues, options);
+  function option( optString, options ) {
+    return _addOption(optionProcessor, optString, options);
   }
 
   /**
@@ -78,7 +77,7 @@ function createOptionProcessor() {
       options: {},
       positionalArguments: [],
       option: commandOption,
-      positionalArgument: (argumentDefinition) => {
+      positionalArgument(argumentDefinition) {
         _setPositionalArguments(argumentDefinition, cmd.positionalArguments);
         return cmd;
       },
@@ -99,8 +98,8 @@ function createOptionProcessor() {
     return cmd;
 
     // Command API: Define a command option
-    function commandOption( optString, validValues, options ) {
-      return _addOption(cmd, optString, validValues, options);
+    function commandOption( optString, options ) {
+      return _addOption(cmd, optString, options);
     }
 
     // Command API: Define the command help text
@@ -124,13 +123,15 @@ function createOptionProcessor() {
     if (argList.find(arg => arg.isDynamic))
       throw new Error('Can\'t add positional arguments after a dynamic one');
 
-
     const registeredNames = argList.map(arg => arg.name);
     const args = argumentDefinition.split(' ');
 
     for (const arg of args) {
       // Remove braces, dots and camelify.
-      const argName = arg.replace('<', '').replace('>', '').replace('...', '').replace(/[ -]./g, s => s.substring(1).toUpperCase());
+      const argName = arg.replace('<', '')
+        .replace('>', '')
+        .replace('...', '')
+        .replace(/[ -]./g, s => s.substring(1).toUpperCase());
 
       if (registeredNames.includes(argName))
         throw new Error(`Duplicate positional argument: ${ arg }`);
@@ -138,7 +139,6 @@ function createOptionProcessor() {
       if (!isParam(arg) && !isDynamicPositionalArgument(arg))
         throw new Error(`Unknown positional argument syntax: ${ arg }`);
 
-
       argList.push({
         name: argName,
         isDynamic: isDynamicPositionalArgument(arg),
@@ -157,65 +157,42 @@ function createOptionProcessor() {
    * @private
    * @see option()
    */
-  function _addOption( cmd, optString, validValues, options ) {
-    const cliOpt = _parseOptionString(optString, validValues);
+  function _addOption( cmd, optString, options ) {
+    const cliOpt = _parseOptionString(optString, options);
     Object.assign(cliOpt, options);
-    _addLongOption(cmd, cliOpt.longName, cliOpt);
-    _addShortOption(cmd, cliOpt.shortName, cliOpt);
+    _addOptionName(cmd, cliOpt.longName, cliOpt);
+    _addOptionName(cmd, cliOpt.shortName, cliOpt);
 
     for (const alias of cliOpt.aliases || []) {
       const aliasOpt = Object.assign({ }, cliOpt, { isAlias: true });
-      _addLongOption(cmd, alias, aliasOpt); // use same camelName, etc. for alias
+      _addOptionName(cmd, alias, aliasOpt); // use same optionName, etc. for alias
     }
 
     return cmd;
   }
 
   /**
-   * Internal: Add longName to the list of options.
-   * Throws if the option is already registered in the given command context.
-   * or in the given command.
-   * `longName` may differ from `opt.longName`, e.g. for aliases.
-   *
-   * @private
-   * @see _addOption()
-   */
-  function _addLongOption( cmd, longName, opt ) {
-    if (cmd.options[longName]) {
-      throw new Error(`Duplicate assignment for long option ${ longName }`);
-    }
-    else if (optionProcessor.options[longName]) {
-      // This path is only taken if optString is for commands
-      optionProcessor.optionClashes.push({
-        option: longName,
-        description: `Command '${ cmd.longName }' has option clash with general options for: ${ longName }`,
-      });
-    }
-    cmd.options[longName] = opt;
-  }
-  /**
-   * Internal: Add shortName to the list of options.
+   * Internal: Add a name to the list of options.
    * Throws if the option is already registered in the given command context.
    * or in the given command.
-   * `longName` may differ from `opt.longName`, e.g. for aliases.
    *
    * @private
    * @see _addOption()
    */
-  function _addShortOption( cmd, shortName, opt ) {
-    if (!shortName)
+  function _addOptionName( cmd, name, opt ) {
+    if (!name)
       return;
-    if (cmd.options[shortName]) {
-      throw new Error(`Duplicate assignment for short option ${ shortName }`);
+    if (cmd.options[name]) {
+      throw new Error(`Duplicate assignment for option ${ name }`);
     }
-    else if (optionProcessor.options[shortName]) {
+    else if (optionProcessor.options[name]) {
       // This path is only taken if optString is for commands
       optionProcessor.optionClashes.push({
-        option: shortName,
-        description: `Command '${ cmd.longName }' has option clash with general options for: ${ shortName }`,
+        option: name,
+        description: `Command '${ cmd.longName }' has option clash with general options for: ${ name }`,
       });
     }
-    cmd.options[shortName] = opt;
+    cmd.options[name] = opt;
   }
 
   // Internal: Parse one command string like "F, toFoo". Return an object like this
@@ -251,11 +228,11 @@ function createOptionProcessor() {
   // {
   //   longName: '--foo-bar',
   //   shortName: '-f',
-  //   camelName: 'fooBar',
+  //   optionName: 'fooBar', // or options.optionName if provided
   //   param: '<p>'
-  //   validValues
+  //   valid
   // }
-  function _parseOptionString( optString, validValues ) {
+  function _parseOptionString( optString, options ) {
     let longName;
     let shortName;
     let param;
@@ -294,11 +271,11 @@ function createOptionProcessor() {
     if (!longName)
       throw new Error(`Invalid option description, missing long name: ${ optString }`);
 
-    if (!param && validValues)
+    if (!param && options?.valid)
       throw new Error(`Option description has valid values but no param: ${ optString }`);
 
-    if (validValues) {
-      validValues.forEach((value) => {
+    if (options?.valid) {
+      options.valid.forEach((value) => {
         if (typeof value !== 'string')
           throw new Error(`Valid values must be of type string: ${ optString }`);
       });
@@ -307,9 +284,9 @@ function createOptionProcessor() {
     return {
       longName,
       shortName,
-      camelName: camelifyLongOption(longName),
+      optionName: options?.option ?? camelifyLongOption(longName),
       param,
-      validValues,
+      valid: options?.valid,
       isAlias: false, // default
     };
   }
@@ -520,10 +497,10 @@ function createOptionProcessor() {
         if (currentCommand) {
           if (!result.options[currentCommand])
             result.options[currentCommand] = {};
-          result.options[currentCommand][currentOption.camelName] = val;
+          result.options[currentCommand][currentOption.optionName] = val;
         }
         else {
-          result.options[currentOption.camelName] = val;
+          result.options[currentOption.optionName] = val;
         }
       }
 
@@ -542,7 +519,7 @@ function createOptionProcessor() {
       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 }]`);
+        errors.push(`Invalid value "${ value }" for option "${ shortOption }${ opt.longName }" - use one of [${ opt.valid }]`);
       }
 
       /**
@@ -580,114 +557,14 @@ function createOptionProcessor() {
     }
   }
 
-  // Assuming that 'options' came from this option processor, verify options therein.
-  // If 'command' is supplied, check only 'options.command', otherwise check
-  // only top-level options
-  // Return an array of complaints (possibly empty)
-  function verifyOptions( options, commandName = undefined, silent = false ) {
-    const result = [];
-    let opts;
-
-    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) {
-      [
-        'defaultBinaryLength', 'defaultStringLength',
-        /* 'length', 'precision', 'scale' */
-      ].forEach((facet) => {
-        if (options[facet] && isNaN(options[facet]))
-          result.push(`Invalid value "${ options[facet] }" for option "--${ facet }" - not an Integer`);
-        else
-          options[facet] = parseInt(options[facet]);
-      });
-    }
-
-    if (commandName) {
-      const cmd = optionProcessor.commands[commandName];
-      if (!cmd)
-        throw new Error(`Expected existing command: "${ cmd }"`);
-
-      opts = cmd.options;
-      options = options[cmd] || {};
-      if (typeof options === 'boolean') {
-        // Special case: command without options
-        options = {};
-      }
-    }
-    else {
-      opts = optionProcessor.options;
-    }
-    // Look at each supplied option
-    for (const camelName in options) {
-      const opt = opts[uncamelifyLongOption(camelName)];
-      let error;
-      if (!opt) {
-        // Don't report commands in top-level options
-        if ((commandName || !optionProcessor.commands[camelName]) && !silent) {
-          const prefix = commandName ? `${commandName}.` : '';
-          error = `Unknown option "${prefix}${camelName}"`;
-        }
-      }
-      else {
-        const param = options[camelName];
-        error = verifyOptionParam(param, opt, commandName ? `${ commandName }.` : '');
-      }
-      if (error)
-        result.push(error);
-    }
-    // hard-coded option dependencies (they disappear with command)
-    return result;
-
-    /**
-     * Verify parameter value 'param' against option definition 'opt'. Return an error
-     * string or false for an accepted param. Use 'prefix' when mentioning the option name.
-     *
-     * @param param
-     * @param opt
-     * @param prefix
-     * @return {string|boolean}
-     */
-    function verifyOptionParam( param, opt, prefix ) {
-      if (opt.param) {
-        // Parameter is required for this option
-        if (typeof param === 'boolean')
-          return `Missing value for option "${ prefix }${ opt.camelName }"`;
-        else if (!isValidOptionValue(opt, param))
-          return `Invalid value "${ param }" for option "${ prefix }${ opt.camelName }" - use one of [${ opt.validValues }]`;
-
-        return false;
-      }
-      // Option does not expect a parameter
-      if (typeof param !== 'boolean') {
-        // FIXME: Might be a bit too strict in case of internal sub-options like 'forHana' etc...
-        return `Expecting boolean value for option "${ prefix }${ opt.camelName }"`;
-      }
-
-      return false;
-    }
-  }
-
   function isValidOptionValue( opt, value ) {
     // Explicitly convert to string, input 'value' may be boolean
     value = String(value);
-    if (!opt.validValues || !opt.validValues.length)
+    if (!opt.valid?.length)
       return true;
     if (opt.ignoreCase)
-      return opt.validValues.some( valid => valid.toLowerCase() === value.toLowerCase() );
-    return opt.validValues.includes(value);
-  }
-
-  // Return an array of unique camelNames of the options for the specified command
-  // If invalid command -> an empty array
-  function camelOptionsForCommand( cmd ) {
-    if (!cmd || !optionProcessor.commands[cmd])
-      return [];
-    cmd = optionProcessor.commands[cmd];
-    const names = Object.keys(cmd.options).map(name => cmd.options[name].camelName);
-    return [ ...new Set(names) ];
+      return opt.valid.some( valid => valid.toLowerCase() === value.toLowerCase() );
+    return opt.valid.includes(value);
   }
 }
 
@@ -713,14 +590,6 @@ function camelifyLongOption( opt ) {
   return opt.substring(2).replace(/-./g, s => s.substring(1).toUpperCase());
 }
 
-/**
- * Return a long option name like "--foo-bar" for a camel-case name "fooBar"
- */
-function uncamelifyLongOption( opt ) {
-  const longForm = opt.replace(/[A-Z]/g, s => `-${ s.toLowerCase() }`);
-  return `--${ longForm }`;
-}
-
 /**
  * Check if 'opt' looks like a "-f" short option
  */

package/lib/checks/elements.js

@@ -112,45 +112,43 @@ function checkVirtualElement( member ) {
  * Checks whether managed associations
  * with cardinality 'to many' have an on-condition.
  *
- * @param {CSN.Artifact} art The artifact
- * @todo this is a member validator, is it not?
+ * @param {CSN.Artifact} member The member (e.g. element artifact)
  */
-function checkManagedAssoc( art ) {
-  forEachMemberRecursively(art, (member) => {
-    if (this.csnUtils.isAssocOrComposition(member) &&
-        !isManagedComposition.bind(this)(member)) {
-      // Implementation note:  Imported services (i.e. external ones) may contain to-many associations
-      // with an empty foreign key list.  If the user (in this case importer) explicitly sets an empty
-      // foreign key array, we won't emit a warning to avoid spamming the user.
-      const max = member.cardinality?.max ? member.cardinality.max : 1;
-      if (max !== 1 && !member.on && (!member.keys || member.keys.length > 0)) {
-        const isNoDb = art['@cds.persistence.skip'] || art['@cds.persistence.exists'];
-        this.warning(isNoDb ? 'to-many-no-on-noDB' : 'to-many-no-on', member.cardinality ? member.cardinality.$path : member.$path, {
-          value: cardinality2str(member, false),
-          '#': this.csnUtils.isComposition(member) ? 'comp' : 'std',
-        }, {
-          std: 'Expected association with target cardinality $(VALUE) to have an ON-condition',
-          comp: 'Expected composition with target cardinality $(VALUE) to have an ON-condition',
-        });
-      }
-    }
-  });
+function checkManagedAssoc( member ) {
+  if (!member.target || isManagedComposition.bind(this)(member))
+    return;
 
-  /**
-   *
-   * @param {CSN.Element} member The member
-   * @returns {boolean} Whether the member is managed composition
-   */
-  function isManagedComposition( member ) {
-    if (member.targetAspect)
-      return true;
-    if (!member.target)
-      return false;
-    const target = typeof member.target === 'object' ? member.target : this.csnUtils.getCsnDef(member.target);
-    return target.kind !== 'entity';
+  // Implementation note:  Imported services (i.e. external ones) may contain to-many associations
+  // with an empty foreign key list.  If the user (in this case importer) explicitly sets an empty
+  // foreign key array, we won't emit a warning to avoid spamming the user.
+  const max = member.cardinality?.max ? member.cardinality.max : 1;
+  if (max !== 1 && !member.on && (!member.keys || member.keys.length > 0)) {
+    const isNoDb = this.artifact['@cds.persistence.skip'] || this.artifact['@cds.persistence.exists'];
+    this.warning(isNoDb ? 'to-many-no-on-noDB' : 'to-many-no-on', member.cardinality ? member.cardinality.$path : member.$path, {
+      value: cardinality2str(member, false),
+      '#': this.csnUtils.isComposition(member) ? 'comp' : 'std',
+    }, {
+      std: 'Expected association with target cardinality $(VALUE) to have an ON-condition',
+      comp: 'Expected composition with target cardinality $(VALUE) to have an ON-condition',
+    });
   }
 }
 
+/**
+ *
+ * @param {CSN.Element} member The member
+ * @returns {boolean} Whether the member is managed composition
+ */
+function isManagedComposition( member ) {
+  if (member.targetAspect)
+    return true;
+  if (!member.target)
+    return false;
+  const target = typeof member.target === 'object' ? member.target : this.csnUtils.getCsnDef(member.target);
+  return target.kind !== 'entity';
+}
+
+
 /**
  * All DB  & OData flat mode must reject recursive type usages in entities
  * 'items' break recursion as 'items' will turn into an NCLOB and the path