@sap/cds-compiler 2.12.0 → 2.13.6

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
@@ -340,46 +340,7 @@ function createOptionProcessor() {
         seenDashDash = true;
       }
       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}"`);
-          }
-        }
+        i += processOption(i);
       }
       else {
         // Command or 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;
@@ -448,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 (!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 +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'*/
@@ -528,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 = {};
@@ -548,12 +583,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,10 +631,10 @@ 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)];
   }

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');
 }
 

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 };

package/lib/checks/sql-snippets.js

@@ -1,7 +1,5 @@
 'use strict';
 
-const { isBetaEnabled } = require('../base/model');
-
 // Only to be used with validator.js - a correct this value needs to be provided!
 
 /**
@@ -14,20 +12,18 @@ const { isBetaEnabled } = require('../base/model');
  * @returns {void}
  */
 function checkSqlAnnotationOnElement(member, memberName, prop, path) {
-  if (isBetaEnabled(this.options, 'sqlSnippets')) {
-    if (member['@sql.replace'])
-      this.error(null, path, { anno: 'sql.replace' }, `Annotation $(ANNO) is reserved and must not be used`);
-    if (member['@sql.prepend'])
-      this.error('anno-invalid-sql-element', path, { anno: 'sql.prepend' }, `Annotation $(ANNO) can't be used on elements` );
+  if (member['@sql.replace'])
+    this.error(null, path, { anno: 'sql.replace' }, `Annotation $(ANNO) is reserved and must not be used`);
+  if (member['@sql.prepend'])
+    this.message('anno-invalid-sql-element', path, { anno: 'sql.prepend' }, `Annotation $(ANNO) can't be used on elements` );
 
-    if (member['@sql.append']) {
-      if (this.artifact.query)
-        this.error('anno-invalid-sql-view-element', path, { anno: 'sql.append' }, `Annotation $(ANNO) can't be used on elements in views` );
-      else if (this.csnUtils.isStructured(member))
-        this.error('anno-invalid-sql-struct', path, { anno: 'sql.append' }, `Annotation $(ANNO) can't be used on structured elements` );
-      else
-        checkValidAnnoValue(member, '@sql.append', path, this.error, this.options);
-    }
+  if (member['@sql.append']) {
+    if (this.artifact.query)
+      this.message('anno-invalid-sql-view-element', path, { anno: 'sql.append' }, `Annotation $(ANNO) can't be used on elements in views` );
+    else if (this.csnUtils.isStructured(member))
+      this.message('anno-invalid-sql-struct', path, { anno: 'sql.append' }, `Annotation $(ANNO) can't be used on structured elements` );
+    else
+      checkValidAnnoValue(member, '@sql.append', path, this.error, this.options);
   }
 }
 
@@ -54,19 +50,24 @@ function checkValidAnnoValue(carrier, annotation, path, error, options) {
  * @param {string} artifactName
  */
 function checkSqlAnnotationOnArtifact(artifact, artifactName) {
-  if (isBetaEnabled(this.options, 'sqlSnippets')) {
-    if (artifact['@sql.prepend']) {
-      if (artifact.query)
-        this.error('anno-invalid-sql-view', [ 'definitions', artifactName ], { name: '@sql.prepend' }, `Annotation $(NAME) can't be used on views` );
-      else
-        checkValidAnnoValue(artifact, '@sql.prepend', [ 'definitions', artifactName ], this.error, this.options);
-    }
+  if (artifact.kind !== 'entity') {
+    if (artifact['@sql.prepend'])
+      this.message('anno-invalid-sql-kind', [ 'definitions', artifactName ], { name: '@sql.prepend', kind: artifact.kind }, `Annotation $(NAME) can't be used on an artifact of kind $(KIND)` );
+    if (artifact['@sql.append'])
+      this.message('anno-invalid-sql-kind', [ 'definitions', artifactName ], { name: '@sql.append', kind: artifact.kind }, `Annotation $(NAME) can't be used on an artifact of kind $(KIND)` );
+  }
+  else if (artifact['@sql.prepend']) {
+    if (artifact.query)
+      this.message('anno-invalid-sql-view', [ 'definitions', artifactName ], { name: '@sql.prepend' }, `Annotation $(NAME) can't be used on views` );
+    else
+      checkValidAnnoValue(artifact, '@sql.prepend', [ 'definitions', artifactName ], this.error, this.options);
+  }
 
-    if (artifact['@sql.replace'])
-      this.error(null, [ 'definitions', artifactName ], { anno: 'sql.replace' }, `Annotation $(ANNO) is reserved and must not be used`);
 
-    checkValidAnnoValue(artifact, '@sql.append', [ 'definitions', artifactName ], this.error, this.options);
-  }
+  if (artifact['@sql.replace'])
+    this.error(null, [ 'definitions', artifactName ], { anno: 'sql.replace' }, `Annotation $(ANNO) is reserved and must not be used`);
+
+  checkValidAnnoValue(artifact, '@sql.append', [ 'definitions', artifactName ], this.error, this.options);
 }
 
 // Anything that could terminate the "old" statement and start a new one basically.

package/lib/checks/types.js

@@ -19,7 +19,7 @@ function checkDecimalScale(member, memberName, prop, path) {
      // skip is already filtered in validator, here for completeness
      hasAnnotationValue(this.artifact, '@cds.persistence.skip'))
     return;
-  if (member.scale && [ 'variable', 'floating' ].includes(member.scale))
+  if (member.scale && (member.scale === 'variable' || member.scale === 'floating'))
     this.error(null, path, { name: member.scale }, 'Unexpected scale $(NAME)');
 }
 

package/lib/checks/validator.js

@@ -129,7 +129,7 @@ function _validate(csn, that,
                    iterateOptions = {}) {
   const { cleanup } = enrich(csn);
 
-  applyTransformations(csn, mergeCsnValidators(csnValidators, that), [], true, { drillRef: true });
+  applyTransformations(csn, mergeCsnValidators(csnValidators, that), [], { drillRef: true });
 
   forEachDefinition(csn, (artifact, artifactName, prop, path) => {
     artifactValidators.forEach((artifactValidator) => {
@@ -204,12 +204,9 @@ function forHana(csn, that) {
                    ),
                    forHanaQueryValidators.concat(commonQueryValidators),
                    {
-                     skipArtifact: artifact => artifact.abstract || hasAnnotationValue(artifact, '@cds.persistence.skip'),
-                     skip: [
-                       'action',
-                       'function',
-                       'event',
-                     ],
+                     skipArtifact: artifact => artifact.abstract ||
+                                                hasAnnotationValue(artifact, '@cds.persistence.skip') ||
+                                                [ 'action', 'function', 'event' ].includes(artifact.kind),
                    });
 }