@sap/cds-compiler 2.10.4 → 2.12.0

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: {},
@@ -30,11 +34,16 @@ function createOptionProcessor() {
     optionClashes: [],
     option,
     command,
-    positionalArgument,
+    positionalArgument: (argumentDefinition) => {
+      // Default positional arguments; may be overwritten by commands.
+      _setPositionalArguments(argumentDefinition);
+      return optionProcessor;
+    },
     help,
     processCmdLine,
     verifyOptions,
     camelOptionsForCommand,
+    // TODO: Why exported?
     _parseCommandString,
     _parseOptionString,
   }
@@ -44,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);
   }
 
   /**
@@ -60,13 +70,18 @@ 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 = {
       options: {},
+      positionalArguments: [],
       option,
+      positionalArgument: (argumentDefinition) => {
+        _setPositionalArguments(argumentDefinition, command.positionalArguments);
+        return command;
+      },
       help,
       ..._parseCommandString(cmdString)
     };
@@ -83,12 +98,12 @@ function createOptionProcessor() {
     }
     return command;
 
-    // API: Define a command option
-    function option(optString, validValues) {
-      return _addOption(command, optString, validValues);
+    // Command API: Define a command option
+    function option(optString, validValues, options) {
+      return _addOption(command, optString, validValues, options);
     }
 
-    // API: Define the command help text
+    // Command API: Define the command help text
     function help(text) {
       command.helpText = text;
       return command;
@@ -96,28 +111,35 @@ function createOptionProcessor() {
   }
 
   /**
-   * Adds positional arguments to the command line processor. Instructs the processor
-   * to either require N positional arguments or a dynamic number (but at least one)
-   * @param {string} positionalArgumentDefinition Positional arguments, e.g. '<input> <output>' or '<files...>'
+   * Set the positional arguments to the command line processor. Instructs the processor
+   * to either require N positional arguments or a dynamic number (but at least one).
+   * Note that you can only call this function once.  Only the last invocation sets
+   * the positional arguments.
+   *
+   * @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 positionalArgument(positionalArgumentDefinition) {
-    if (optionProcessor.positionalArguments.find((arg) => arg.isDynamic)) {
+  function _setPositionalArguments(argumentDefinition, argList = optionProcessor.positionalArguments) {
+    if (argList.find((arg) => arg.isDynamic)) {
       throw new Error(`Can't add positional arguments after a dynamic one`);
     }
 
-    const registeredNames = optionProcessor.positionalArguments.map((arg) => arg.name);
-    const args = positionalArgumentDefinition.split(' ');
+    const registeredNames = argList.map((arg) => arg.name);
+    const args = argumentDefinition.split(' ');
 
     for (const arg of args) {
-      const argName = arg.replace('<', '').replace('>', '').replace('...', '');
+      // Remove braces, dots and camelify.
+      const argName = arg.replace('<', '').replace('>', '').replace('...', '').replace(/[ -]./g, s => s.substring(1).toUpperCase());
+
       if (registeredNames.includes(argName)) {
-        throw new Error(`Duplicate positional argument ${arg}`);
+        throw new Error(`Duplicate positional argument: ${arg}`);
       }
       if (!isParam(arg) && !isDynamicPositionalArgument(arg)) {
         throw new Error(`Unknown positional argument syntax: ${arg}`)
       }
 
-      optionProcessor.positionalArguments.push({
+      argList.push({
         name: argName,
         isDynamic: isDynamicPositionalArgument(arg),
         required: true
@@ -125,7 +147,6 @@ function createOptionProcessor() {
 
       registeredNames.push(argName);
     }
-    return optionProcessor;
   }
 
   /**
@@ -135,8 +156,10 @@ function createOptionProcessor() {
    * @private
    * @see option()
    */
-  function _addOption(command, optString, validValues) {
+  function _addOption(command, optString, validValues, options) {
     const opt = _parseOptionString(optString, validValues);
+    Object.assign(opt, options);
+
     if (command.options[opt.longName]) {
       throw new Error(`Duplicate assignment for long option ${opt.longName}`);
     } else if (optionProcessor.options[opt.longName]) {
@@ -203,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(/,? +/);
@@ -247,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
@@ -322,7 +334,12 @@ function createOptionProcessor() {
         argv = [ ...argv.slice(0, i), ...arg.split('='), ...argv.slice(i + 1)];
         arg = argv[i];
       }
-      if (!seenDashDash && arg.startsWith('-') && arg !== '--') {
+
+      if (arg === '--') {
+        // No more options after '--'
+        seenDashDash = true;
+      }
+      else if (!seenDashDash && arg.startsWith('-')) {
         if (result.command) {
           // We already have a command
           const opt = optionProcessor.commands[result.command].options[arg];
@@ -364,10 +381,7 @@ function createOptionProcessor() {
           }
         }
       }
-      else if (arg === '--') {
-        // No more options after '--'
-        seenDashDash = true;
-      } else {
+      else {
         // Command or arg
         if (result.command === undefined) {
           if (optionProcessor.commands[arg]) {
@@ -390,21 +404,37 @@ function createOptionProcessor() {
     }
 
     // Complain about first missing positional arguments
-    const missingArg = optionProcessor.positionalArguments.find((arg) => arg.required && !result.args[arg.name]);
+    const missingArg = getCurrentPositionArguments().find((arg) => arg.required && !result.args[arg.name]);
     if (missingArg) {
-      result.errors.push(`Missing positional argument: <${missingArg.name}${missingArg.isDynamic ? '...' : ''}>`)
+      const forCommand = result.command ? ` for '${ result.command }'` : '';
+      result.errors.push(`Missing positional argument${forCommand}: <${missingArg.name}${missingArg.isDynamic ? '...' : ''}>`)
     }
 
     return result;
 
+    /**
+     * Specific commands may have custom positional arguments.
+     * If the current one does, use it instead of the defaults.
+     *
+     * @returns {object[]} Array of positional argument configurations.
+     */
+    function getCurrentPositionArguments() {
+      const cmd = optionProcessor.commands[result.command];
+      return ( cmd && cmd.positionalArguments && cmd.positionalArguments.length ) ? cmd.positionalArguments : optionProcessor.positionalArguments;
+    }
+
     function processPositionalArgument(argumentValue) {
-      if ( result.args.length === 0 && optionProcessor.positionalArguments.length === 0 )
+      const argList = getCurrentPositionArguments();
+      if ( result.args.length === 0 && argList.length === 0 )
         return;
-      const inBounds = result.args.length < optionProcessor.positionalArguments.length;
-      const lastIndex = inBounds ? result.args.length : optionProcessor.positionalArguments.length - 1;
-      const nextUnsetArgument = optionProcessor.positionalArguments[lastIndex];
+      const inBounds = result.args.length < argList.length;
+      const lastIndex = inBounds ? result.args.length : argList.length - 1;
+      const nextUnsetArgument = argList[lastIndex];
       if (!inBounds && !nextUnsetArgument.isDynamic) {
-        result.errors.push(`Too many arguments. Expected ${optionProcessor.positionalArguments.length}`);
+        if (result.command)
+          result.errors.push(`Too many arguments. '${result.command}' expects ${argList.length}`);
+        else
+          result.errors.push(`Too many arguments. Expected ${argList.length}`);
         return;
       }
       result.args.length += 1;
@@ -447,13 +477,13 @@ function createOptionProcessor() {
               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)) {
+              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 (opt.validValues && !opt.validValues.includes(value)) {
+            if (!isValidOptionValue(opt, value)) {
               result.errors.push(`Invalid value "${value}" for option "${shortOption}${opt.longName}" - use one of [${opt.validValues}]`);
             }
           }
@@ -486,7 +516,10 @@ function createOptionProcessor() {
     }
 
     if(options) {
-      ['defaultStringLength', /*'length', 'precision', 'scale'*/].forEach(facet => {
+      [
+        '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 {
@@ -511,7 +544,7 @@ 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
@@ -536,7 +569,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;
@@ -551,38 +584,67 @@ 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 [];
-    }
+    if (!command || !optionProcessor.commands[command])
+      return []
+    const cmd = optionProcessor.commands[command];
+    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);
+  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);
+  return /^<[a-zA-Z-]+[.]{3}>$/.test(arg);
 }
 
 module.exports = {

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/emptyOrOnlyVirtual.js

@@ -12,9 +12,9 @@ const { isPersistedOnDatabase } = require('../model/csnUtils.js');
  * @param {CSN.Path} path Path to the artifact
  */
 function validateEmptyOrOnlyVirtual(artifact, artifactName, prop, path) {
-  if (artifact.kind === 'entity' && !artifact.query && isPersistedOnDatabase(artifact)) {
+  if (artifact.kind === 'entity' && isPersistedOnDatabase(artifact)) {
     if (!artifact.elements || !hasRealElements(artifact.elements))
-      this.error(null, path, "Artifacts containing only virtual or empty elements can't be deployed");
+      this.error('def-missing-element', path, { '#': artifact.query ? 'view' : 'std' });
   }
 }
 

package/lib/checks/foreignKeys.js

@@ -18,12 +18,12 @@ function validateForeignKeys(member) {
 
   // Declared as arrow-function to keep scope the same (this value)
   const handleAssociation = (mem) => {
-    for (let i = 0; i < mem.keys.length; i++) {
-      if (mem.keys[i].ref) {
-        if (!mem.keys[i]._art)
+    for (const key of mem.keys) {
+      if (key.ref) {
+        if (!key._art)
           continue;
         // eslint-disable-next-line no-use-before-define
-        checkForItems(mem.keys[i]._art);
+        checkForItems(key._art);
       }
     }
   };

package/lib/checks/managedInType.js

@@ -13,11 +13,11 @@
 function checkUsedTypesForAnonymousAspectComposition(member) {
   // Declared as arrow-function to keep scope the same (this value)
   const handleAssociation = (mem, fn) => {
-    for (let i = 0; i < mem.keys.length; i++) {
-      if (mem.keys[i].ref) {
-        if (!mem.keys[i]._art)
+    for (const key of mem.keys) {
+      if (key.ref) {
+        if (!key._art)
           continue;
-        fn(mem.keys[i]._art);
+        fn(key._art);
       }
     }
   };

package/lib/checks/queryNoDbArtifacts.js

@@ -124,10 +124,8 @@ function checkQueryForNoDBArtifacts(query) {
     for (const prop of generalQueryProperties) {
       const queryPart = (query.SELECT || query.SET)[prop];
       if (Array.isArray(queryPart)) {
-        for (let i = 0; i < queryPart.length; i++) {
-          const part = queryPart[i];
+        for (const part of queryPart)
           checkRef(part, prop === 'columns');
-        }
       }
       else if (typeof queryPart === 'object') {
         checkRef(queryPart, prop === 'columns');

package/lib/checks/selectItems.js

@@ -23,6 +23,10 @@ function validateSelectItems(query) {
                    'Select items starting with $(NAME) must not contain path steps of type $(TYPE)');
       }
     }
+    else if (this.options.transformation === 'hdbcds' && selectItem.xpr && selectItem.func) {
+      this.error(null, selectItem.$path,
+                 'Window functions are not supported by SAP HANA CDS');
+    }
   });
   // .call() with 'this' to ensure we have access to the options
   rejectManagedAssociationsAndStructuresForHdbcsNames.call(this, SELECT, SELECT.$path);

package/lib/checks/sql-snippets.js

@@ -0,0 +1,93 @@
+'use strict';
+
+const { isBetaEnabled } = require('../base/model');
+
+// Only to be used with validator.js - a correct this value needs to be provided!
+
+/**
+ * Check that @sql.prepend annotation is not used on any elements and @sql.append is not used on elements in views.
+ *
+ * @param {CSN.Element} member
+ * @param {string} memberName
+ * @param {string} prop
+ * @param {CSN.Path} path
+ * @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.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);
+    }
+  }
+}
+
+/**
+ * @param {object} carrier element which has the annotation
+ * @param {string} annotation
+ * @param {CSN.Path} path
+ * @param {Function} error
+ * @param {CSN.Options} options
+ */
+function checkValidAnnoValue(carrier, annotation, path, error, options) {
+  if (carrier[annotation] !== undefined && carrier[annotation] !== null) {
+    if (typeof carrier[annotation] !== 'string')
+      error(null, path, { anno: annotation.slice(1), type: typeof carrier[annotation] }, `Annotation $(ANNO) must be a string, found $(TYPE)` );
+    else if (options.transformation === 'sql') // HDI and HDBCDS do their own checks
+      guardAgainstInjection(annotation, carrier[annotation], path, error);
+  }
+}
+
+/**
+ * Check that @sql.prepend is not used on views - only supported for entities (tables)
+ *
+ * @param {CSN.Artifact} artifact
+ * @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['@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.
+const invalidInSnippet = [ ';', '--', '/*', '*/' ];
+
+/**
+ * Check that the common characters used to terminate the current statement and start a fresh one are not used.
+ *
+ * @param {string} annoName
+ * @param {string} annoValue
+ * @param {CSN.Path} path
+ * @param {Function} error
+ */
+function guardAgainstInjection(annoName, annoValue, path, error) {
+  for (const invalid of invalidInSnippet) {
+    if (annoValue.indexOf(invalid) !== -1) // These should probably not be configurable, right?
+      error(null, path, { name: annoName, prop: invalid }, 'Annotation $(NAME) must not contain $(PROP)');
+  }
+}
+
+module.exports = {
+  checkSqlAnnotationOnArtifact,
+  checkSqlAnnotationOnElement,
+};

package/lib/checks/unknownMagic.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { getVariableReplacement } = require('../model/csnUtils');
+
 // We only care about the "wild" ones - $at is validated by the compiler
 const magicVariables = {
   $user: [
@@ -17,7 +19,7 @@ const magicVariables = {
  *
  * Valid ways:
  * - We know what to do -> $user.id on HANA
- * - The user tells us what to do -> options.magicVars
+ * - The user tells us what to do -> options.variableReplacements
  *
  * @param {object} parent Object with the ref as a property
  * @param {string} name Name of the ref property on parent
@@ -28,8 +30,9 @@ function unknownMagicVariable(parent, name, ref) {
     const [ head, ...rest ] = ref;
     const tail = rest.join('.');
     const magicVariable = magicVariables[head];
-    if (magicVariable && magicVariable.indexOf(tail) === -1)
-      this.error(null, parent.$location, { id: tail, elemref: parent }, 'Magic variable is not supported - path $(ELEMREF), step $(ID)');
+    if (magicVariable && magicVariable.indexOf(tail) === -1 &&
+          getVariableReplacement(ref, this.options) === null)
+      this.error('ref-missing-replacement', parent.$location, { elemref: parent }, 'Missing replacement for variable $(ELEMREF)');
   }
 }
 

package/lib/checks/validator.js

@@ -35,6 +35,10 @@ const checkExplicitlyNullableKeys = require('./nullableKeys');
 const nonexpandableStructuredInExpression = require('./nonexpandableStructured');
 const unknownMagic = require('./unknownMagic');
 const managedWithoutKeys = require('./managedWithoutKeys');
+const {
+  checkSqlAnnotationOnArtifact,
+  checkSqlAnnotationOnElement,
+} = require('./sql-snippets');
 
 const forHanaMemberValidators
 = [
@@ -45,6 +49,8 @@ const forHanaMemberValidators
   checkExplicitlyNullableKeys,
   managedWithoutKeys,
   warnAboutDefaultOnAssociationForHanaCds,
+  // sql.prepend/append
+  checkSqlAnnotationOnElement,
 ];
 
 const forHanaArtifactValidators
@@ -53,6 +59,8 @@ const forHanaArtifactValidators
   validateCdsPersistenceAnnotation,
   // virtual items are not persisted on the db
   checkForEmptyOrOnlyVirtual,
+  // sql.prepend/append
+  checkSqlAnnotationOnArtifact,
 ];
 
 const forHanaCsnValidators = [ nonexpandableStructuredInExpression, unknownMagic ];