@sap/cds-compiler 2.11.4 → 2.13.8

package/lib/base/optionProcessorHelper.js

@@ -1,27 +1,31 @@
 'use strict'
 
-// Create a command line option processor and define valid commands, options and parameters.
-// In order to understand a command line like this:
-//   $ node cdsc.js -x 1 --foo toXyz -y --bar-wiz bla arg1 arg2
-//
-// The following definitions should be made
-//
-//   const optionProcessor = createOptionProcessor();
-//   optionProcessor
-//     .help(`General help text`);
-//     .option('-x, --x-in-long-form <i>')
-//     .option('    --foo')
-//   optionProcessor.command('toXyz')
-//     .help(`Help text for command "toXyz")
-//     .option('-y  --y-in-long-form')
-//     .option('    --bar-wiz <w>', ['bla', 'foo'])
-//
-// Options *must* have a long form, can have at most one <param>, and optionally
-// an array of valid param values as strings. Commands and param values must not
-// start with '--'. The whole processor and each command may carry a help text.
-// To actually parse a command line, use
-//   optionProcessor.processCmdLine(process.argv);
-// (see below)
+/**
+ * Create a command line option processor and define valid commands, options and parameters.
+ * In order to understand a command line like this:
+ *   $ node cdsc.js -x 1 --foo toXyz -y --bar-wiz bla arg1 arg2
+ *
+ * The following definitions should be made:
+ *
+ * ```js
+ *   const optionProcessor = createOptionProcessor();
+ *   optionProcessor
+ *     .help(`General help text`);
+ *     .option('-x, --long-form <i>')
+ *     .option('    --foo')
+ *   optionProcessor.command('toXyz')
+ *     .help(`Help text for command "toXyz")
+ *     .option('-y  --y-in-long-form')
+ *     .option('    --bar-wiz <w>', ['bla', 'foo'])
+ * ```
+ *
+ * Options *must* have a long form, can have at most one <param>, and optionally
+ * an array of valid param values as strings.  Commands and param values must not
+ * start with '-'. The whole processor and each command may carry a help text.
+ * To actually parse a command line, use
+ *   const cli = optionProcessor.processCmdLine(process.argv);
+ * (see below)
+ */
 function createOptionProcessor() {
   const optionProcessor = {
     commands: {},
@@ -32,13 +36,14 @@ function createOptionProcessor() {
     command,
     positionalArgument: (argumentDefinition) => {
       // Default positional arguments; may be overwritten by commands.
-      _positionalArguments(argumentDefinition);
+      _setPositionalArguments(argumentDefinition);
       return optionProcessor;
     },
     help,
     processCmdLine,
     verifyOptions,
     camelOptionsForCommand,
+    // TODO: Why exported?
     _parseCommandString,
     _parseOptionString,
   }
@@ -48,9 +53,10 @@ function createOptionProcessor() {
    * 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`
    */
-  function option(optString, validValues) {
-    return _addOption(optionProcessor, optString, validValues);
+  function option(optString, validValues, options) {
+    return _addOption(optionProcessor, optString, validValues, options);
   }
 
   /**
@@ -64,43 +70,43 @@ function createOptionProcessor() {
 
   /**
    * API: Define a command
-   * @param {string} cmdString Command name, e.g. 'S, toSql'
+   * @param {string} cmdString Command name, short and long form, e.g. 'S, toSql'
    */
   function command(cmdString) {
     /** @type {object} */
-    const command = {
+    const cmd = {
       options: {},
       positionalArguments: [],
-      option,
+      option: commandOption,
       positionalArgument: (argumentDefinition) => {
-        _positionalArguments(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;
 
-    // API: Define a command option
-    function option(optString, validValues) {
-      return _addOption(command, optString, validValues);
+    // Command API: Define a command option
+    function commandOption(optString, validValues, options) {
+      return _addOption(cmd, optString, validValues, options);
     }
 
-    // API: Define the command help text
-    function help(text) {
-      command.helpText = text;
-      return command;
+    // Command API: Define the command help text
+    function commandHelp(text) {
+      cmd.helpText = text;
+      return cmd;
     }
   }
 
@@ -112,8 +118,9 @@ function createOptionProcessor() {
    *
    * @param {string}   argumentDefinition Positional arguments, e.g. '<input> <output>' or '<files...>'
    * @param {object[]} argList            Array, to which the parsed arguments will be added.  Default is global scope.
+   * @private
    */
-  function _positionalArguments(argumentDefinition, argList = optionProcessor.positionalArguments) {
+  function _setPositionalArguments(argumentDefinition, argList = optionProcessor.positionalArguments) {
     if (argList.find((arg) => arg.isDynamic)) {
       throw new Error(`Can't add positional arguments after a dynamic one`);
     }
@@ -149,31 +156,33 @@ function createOptionProcessor() {
    * @private
    * @see option()
    */
-  function _addOption(command, optString, validValues) {
+  function _addOption(cmd, optString, validValues, options) {
     const opt = _parseOptionString(optString, validValues);
-    if (command.options[opt.longName]) {
+    Object.assign(opt, options);
+
+    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
@@ -217,7 +226,6 @@ function createOptionProcessor() {
     let longName;
     let shortName;
     let param;
-    let camelName;
 
     // split at spaces (with optional preceding comma)
     const tokens = optString.trim().split(/,? +/);
@@ -261,26 +269,16 @@ function createOptionProcessor() {
           throw new Error(`Valid values must be of type string: ${optString}`);
       });
     }
-    camelName = _camelify(longName);
+
     return {
       longName,
       shortName,
-      camelName,
+      camelName: camelifyLongOption(longName),
       param,
       validValues
     }
   }
 
-  // Return a camelCase name "fooBar" for a long option "--foo-bar"
-  function _camelify(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 _unCamelify(opt) {
-    return `--${opt.replace(/[A-Z]/g, s => '-' + s.toLowerCase())}`;
-  }
-
   // API: Let the option processor digest a command line 'argv'
   // The expectation is to get a commandline like this:
   //       $ node cdsc.js -x 1 --foo toXyz -y --bar-wiz bla arg1 arg2
@@ -336,52 +334,15 @@ function createOptionProcessor() {
         argv = [ ...argv.slice(0, i), ...arg.split('='), ...argv.slice(i + 1)];
         arg = argv[i];
       }
-      if (!seenDashDash && arg.startsWith('-') && arg !== '--') {
-        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}"`);
-          }
-        }
-      }
-      else if (arg === '--') {
+
+      if (arg === '--') {
         // No more options after '--'
         seenDashDash = true;
-      } else {
+      }
+      else if (!seenDashDash && arg.startsWith('-')) {
+        i += processOption(i);
+      }
+      else {
         // Command or arg
         if (result.command === undefined) {
           if (optionProcessor.commands[arg]) {
@@ -407,7 +368,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;
@@ -420,8 +385,7 @@ function createOptionProcessor() {
      */
     function getCurrentPositionArguments() {
       const cmd = optionProcessor.commands[result.command];
-      const args = ( cmd && cmd.positionalArguments && cmd.positionalArguments.length ) ? cmd.positionalArguments : optionProcessor.positionalArguments;
-      return args;
+      return ( cmd && cmd.positionalArguments && cmd.positionalArguments.length ) ? cmd.positionalArguments : optionProcessor.positionalArguments;
     }
 
     function processPositionalArgument(argumentValue) {
@@ -449,57 +413,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 (opt.validValues && !opt.validValues.includes(value)) {
-                result.cmdErrors.push(`Invalid value "${value}" for option "${shortOption}${opt.longName}" - use one of [${opt.validValues}]`);
-              }
-            }
-          } else {
-            result.options[opt.camelName] = value;
-            if (opt.validValues && !opt.validValues.some( validValue => validValue.toLowerCase() === value.toLowerCase() ) ) {
-              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;
     }
   }
 
@@ -507,16 +541,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'*/
@@ -529,13 +563,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 = {};
@@ -545,16 +579,16 @@ function createOptionProcessor() {
     }
     // Look at each supplied option
     for (const camelName in options) {
-      const opt = opts[_unCamelify(camelName)];
+      const opt = opts[uncamelifyLongOption(camelName)];
       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);
@@ -570,7 +604,7 @@ function createOptionProcessor() {
         // Parameter is required for this option
         if (typeof param === 'boolean') {
           return `Missing value for option "${prefix}${opt.camelName}"`;
-        } else if (opt.validValues && !opt.validValues.includes(String(param))) {
+        } else if (!isValidOptionValue(opt, param)) {
           return `Invalid value "${param}" for option "${prefix}${opt.camelName}" - use one of [${opt.validValues}]`;
         }
         return false;
@@ -585,36 +619,65 @@ function createOptionProcessor() {
     }
   }
 
+  function isValidOptionValue(opt, value) {
+    // Explicitly convert to string, input 'value' may be boolean
+    value = String(value);
+    if (!opt.validValues || !opt.validValues.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(command) {
-    if (command && optionProcessor.commands[command]) {
-      const cmd = optionProcessor.commands[command];
-      return [... new Set(
-        Object.keys(cmd.options).map(optName => cmd.options[optName].camelName)
-      )];
-    } else {
-      return [];
-    }
+  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)];
   }
 }
 
-// Check if 'opt' looks like a "-f" short option
+/**
+ * Return a camelCase name "fooBar" for a long option "--foo-bar"
+ */
+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) {
+  return `--${opt.replace(/[A-Z]/g, s => '-' + s.toLowerCase())}`;
+}
+
+/**
+ * Check if 'opt' looks like a "-f" short option
+ */
 function isShortOption(opt) {
   return /^-[a-zA-Z?]$/.test(opt);
 }
 
-// Check if 'opt' looks like a "--foo-bar" long option
+/**
+ * Check if 'opt' looks like a "--foo-bar" long option
+ */
 function isLongOption(opt) {
   return /^--[a-zA-Z0-9-]+$/.test(opt);
 }
 
-// Check if 'opt' looks like a "<foobar>" parameter
+/**
+ * Check if 'opt' looks like a "<foobar>" parameter
+ */
 function isParam(opt) {
   return /^<[a-zA-Z-]+>$/.test(opt);
 }
 
-// Check if 'arg' looks like "<foobar...>"
+/**
+ * Check if 'arg' looks like "<foobar...>"
+ */
 function isDynamicPositionalArgument(arg) {
   return /^<[a-zA-Z-]+[.]{3}>$/.test(arg);
 }

package/lib/checks/.eslintrc.json

@@ -12,6 +12,8 @@
     "jsdoc/no-undefined-types": 0,
     // eslint-plugin-jsdoc warning
     "jsdoc/require-property": 0,
+    // most of the main functions have the normal forEachArtifact/Member signature anyway
+    "jsdoc/require-param-description": 0,
     // =airbnb, >eslint:
     "max-len": [ "error", {
       "code": 110,

package/lib/checks/actionsFunctions.js

@@ -110,7 +110,8 @@ function checkActionOrFunction(art, artName, prop, path) {
    * @param {CSN.Path} currPath The current path
    */
   function checkUserDefinedType(type, typeName, currPath) {
-    if (!isBuiltinType(type) && type.kind && type.kind !== 'type') {
+    // TODO: isBuiltinType does not resolve any type-chains.
+    if (!isBuiltinType(type.type) && type.kind && type.kind !== 'type') {
       const serviceOfType = this.csnUtils.getServiceName(typeName);
       if (serviceName && serviceName !== serviceOfType) {
         // if (!(isMultiSchema && serviceOfType)) {

package/lib/checks/annotationsOData.js

@@ -82,7 +82,7 @@ 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');
 }