@sap/cds-compiler 2.10.2 → 2.11.4

package/lib/backends.js

@@ -14,7 +14,7 @@ const { csn2edm, csn2edmAll } = require('./edm/csn2edm');
 const { mergeOptions }  = require('./model/csnUtils');
 const { isBetaEnabled } = require('./base/model');
 const { optionProcessor } = require('./optionProcessor')
-const timetrace = require('./utils/timetrace');
+const { timetrace } = require('./utils/timetrace');
 const { makeMessageFunction } = require('./base/messages');
 const { forEachDefinition } = require('./model/csnUtils');
 
@@ -92,9 +92,9 @@ function toOdataWithCsn(csn, options) {
 // Generate edmx for given 'service' based on 'csn' (new-style compact, already prepared for OData)
 // using 'options'
 function preparedCsnToEdmx(csn, service, options) {
-  let edmx = csn2edm(csn, service, options).toXML('all');
+  const e = csn2edm(csn, service, options)
   return {
-    edmx,
+    edmx: (e ? e.toXML('all') : undefined)
   };
 }
 
@@ -115,9 +115,9 @@ function preparedCsnToEdmxAll(csn, options) {
 function preparedCsnToEdm(csn, service, options) {
   // Merge options; override OData version as edm json is always v4
   options = mergeOptions(options, { toOdata : { version : 'v4' }});
-  const edmj = csn2edm(csn, service, options).toJSON();
+  const e = csn2edm(csn, service, options);
   return {
-    edmj,
+    edmj: (e ? e.toJSON() : undefined)
   };
 }
 
@@ -303,9 +303,9 @@ function transformSQLOptions(model, options) {
     }
     // move the locale option(if provided) under user.locale
     if (options.locale) {
-      options.user
+      options.user = options.user
         ? Object.assign(options.user, { locale: options.locale })
-        : options.user = { locale: options.locale };
+        : { locale: options.locale };
       delete options.locale;
     }
   }
@@ -395,19 +395,14 @@ function toRenameWithCsn(csn, options) {
   });
 
   // Assemble result
-  let result = {
+  return {
     rename : toRenameDdl(forHanaCsn, options),
     options
   };
-
-  return result;
 }
 
 function alterConstraintsWithCsn(csn, options) {
   const { error } = makeMessageFunction(csn, options, 'manageConstraints');
-  // Requires beta mode
-  if (!isBetaEnabled(options, 'foreignKeyConstraints'))
-    error(null, null, 'ALTER TABLE statements for adding/modifying referential constraints are only available in beta mode');
 
   const {
     drop, alter, names, src, violations
@@ -420,6 +415,10 @@ function alterConstraintsWithCsn(csn, options) {
     dialect: 'hana',
     names: names || 'plain'
   }
+
+  // Of course we want the database constraints
+  options.assertIntegrityType = 'DB';
+
   const transformedOptions = transformSQLOptions(csn, options);
   const mergedOptions = mergeOptions(transformedOptions.options, { forHana : transformedOptions.forHanaOptions });
   const forSqlCsn = transformForHanaWithCsn(csn, mergedOptions, 'to.sql');

package/lib/base/dictionaries.js

@@ -28,6 +28,7 @@ function dictAdd( dict, name, entry, duplicateCallback ) {
 }
 
 function dictForEach( dict, callback ) {
+  // TODO: probably define an extra dictForEachArray()
   for (const name in dict) {
     const entry = dict[name];
     if (Array.isArray(entry)) {
@@ -35,7 +36,7 @@ function dictForEach( dict, callback ) {
     }
     else {
       callback( entry );
-      if (Array.isArray(entry.$duplicates))
+      if (Array.isArray( entry.$duplicates ))
         entry.$duplicates.forEach( callback );
     }
   }

package/lib/base/keywords.js

@@ -11,7 +11,7 @@ module.exports = {
     'DISTINCT',
     'EXISTS',
     'EXTRACT',
-    'FALSE',
+    'FALSE', // boolean
     'FROM',
     'IN',
     'KEY',
@@ -22,8 +22,9 @@ module.exports = {
     'ON',
     'SELECT',
     'SOME',
+    'WHEN',
     'TRIM',
-    'TRUE',
+    'TRUE', // boolean
     'WHERE',
     'WITH',
   ],

package/lib/base/message-registry.js

@@ -47,6 +47,7 @@ const centralMessages = {
   'anno-undefined-def':     { severity: 'Info' }, // for annotate statement (for CSN or CDL path cont)
   'anno-undefined-element': { severity: 'Info' },
   'anno-undefined-param':   { severity: 'Info' },
+  'anno-unstable-hdbcds':   { severity: 'Warning' },
 
   'args-expected-named':  { severity: 'Error', configurableFor: 'deprecated' }, // future --sloppy
   'args-no-params':       { severity: 'Error', configurableFor: 'deprecated' }, // future --sloppy
@@ -60,7 +61,6 @@ const centralMessages = {
 
   'expr-no-filter': { severity: 'Error', configurableFor: 'deprecated' },
 
-  'empty-entity': { severity: 'Info', errorFor: [ 'to.hdbcds', 'to.sql', 'to.rename' ] },
   'empty-type':   { severity: 'Info' }, // only still an error in old transformers
 
   // Structured types were warned about but made CSN un-recompilable.
@@ -69,7 +69,7 @@ const centralMessages = {
   // TODO: rename to ref-expected-XYZ
   'expected-type': { severity: 'Error' },
   'ref-sloppy-type': { severity: 'Error' },
-  'ref-invalid-typeof': { severity: 'Error', configurableFor: 'deprecated' }, // TODO: make it non-config
+  'type-unexpected-typeof': { severity: 'Error', configurableFor: 'deprecated' }, // TODO: make it non-config
   'expected-actionparam-type': { severity: 'Error' },
   'ref-sloppy-actionparam-type': { severity: 'Error' },
   'expected-event-type': { severity: 'Error' },
@@ -89,6 +89,7 @@ const centralMessages = {
   'query-undefined-element': { severity: 'Error' },
   'query-unexpected-assoc-hdbcds': { severity: 'Error' },
   'query-unexpected-structure-hdbcds': { severity: 'Error' },
+  'query-ignoring-param-nullability': { severity: 'Info' },
 
   'recalculated-localized': { severity: 'Info' }, // KEEP: Downgrade in lib/transform/translateAssocsToJoins.js
   'redirected-implicitly-ambiguous': { severity: 'Error', configurableFor: true }, // does not hurt us - TODO: ref-ambiguous-target
@@ -99,6 +100,7 @@ const centralMessages = {
   'ref-undefined-def':    { severity: 'Error' },
   'ref-undefined-var':    { severity: 'Error' },
   'ref-undefined-element': { severity: 'Error' },
+  'ref-unknown-var': { severity: 'Info' },
   'ref-obsolete-parameters': { severity: 'Error', configurableFor: true }, // does not hurt us
   'ref-undefined-param': { severity: 'Error' },
   'ref-rejected-on': { severity: 'Error' },
@@ -118,6 +120,7 @@ const centralMessages = {
   'syntax-anno-after-params': { severity: 'Error', configurableFor: true }, // does not hurt
   'syntax-anno-after-struct': { severity: 'Error', configurableFor: true }, // does not hurt
   'syntax-csn-expected-cardinality': { severity: 'Error' }, // TODO: more than 30 chars
+  'syntax-csn-expected-length': { severity: 'Error' },
   'syntax-csn-expected-translation': { severity: 'Error' }, // TODO: more than 30 chars
   'syntax-csn-required-subproperty': { severity: 'Error' }, // TODO: more than 30 chars
   'syntax-csn-unexpected-property': { severity: 'Error', configurableFor: true }, // is the removed
@@ -127,12 +130,15 @@ const centralMessages = {
 
   'type-managed-composition': { severity: 'Error', configurableFor: 'deprecated' }, // TODO: non-config
 
+  'def-missing-element': { severity: 'Error' },
+
   'unexpected-keys-for-composition': { severity: 'Error' }, // TODO: more than 30 chars
   'unmanaged-as-key': { severity: 'Error', configurableFor: 'deprecated' }, // is confusing
   'composition-as-key': { severity: 'Error', configurableFor: 'deprecated' }, // is confusing and not supported
   'odata-spec-violation-array':  { severity: 'Warning' }, // more than 30 chars
   'odata-spec-violation-constraints': { severity: 'Info' }, // more than 30 chars
   'odata-spec-violation-type': { severity: 'Error', configurableFor: [ 'to.edmx' ] },
+  'odata-spec-violation-no-key':  { severity: 'Warning' },
   'odata-spec-violation-key-array':  { severity: 'Error' }, // more than 30 chars
   'odata-spec-violation-key-null': { severity: 'Error' }, // more than 30 chars
   'odata-spec-violation-key-type': { severity: 'Warning' }, // more than 30 chars
@@ -160,6 +166,11 @@ const centralMessageTexts = {
     $tableImplicit: 'The resulting table alias starts with $(NAME) and might shadow a special variable - specify another name with $(KEYWORD)',
     mixin: 'A mixin name starting with $(NAME) might shadow a special variable - replace by another name' ,
   },
+  'syntax-csn-expected-length': {
+    std: 'Expected array in $(PROP) to have at least $(N) items',
+    one: 'Expected array in $(PROP) to have at least one item',
+    suffix: 'With sibling property $(OTHERPROP), expected array in $(PROP) to have at least one item',
+  },
   'ref-undefined-def': {
     std: 'Artifact $(ART) has not been found',
     // TODO: proposal 'No definition of $(NAME) found',
@@ -171,17 +182,20 @@ const centralMessageTexts = {
     std: 'Element $(ART) has not been found',
     element: 'Artifact $(ART) has no element $(MEMBER)'
   },
+  'ref-unknown-var': {
+    std: 'Replacement $(ID) not found'
+  },
   'ref-rejected-on': {
     std: 'Do not refer to a artefact like $(ID) in the explicit ON of a redirection', // Not used
     mixin: 'Do not refer to a mixin like $(ID) in the explicit ON of a redirection',
     alias: 'Do not refer to a source element (via table alias $(ID)) in the explicit ON of a redirection',
   },
-  'ref-invalid-typeof': {
-    std: 'Do not use $(KEYWORD) for the type reference here',
-    type: 'Do not use $(KEYWORD) for the type of a type',
-    event: 'Do not use $(KEYWORD) for the type of an event',
-    param: 'Do not use $(KEYWORD) for the type of a parameter',
-    select: 'Do not use $(KEYWORD) for type references in queries',
+  'type-unexpected-typeof': {
+    std: 'Unexpected $(KEYWORD) for the type reference here',
+    type: 'Unexpected $(KEYWORD) in type of a type definition',
+    event: 'Unexpected $(KEYWORD) for the type of an event',
+    param: 'Unexpected $(KEYWORD) for the type of a parameter definition',
+    select: 'Unexpected $(KEYWORD) for type references in queries',
   },
   'anno-builtin': 'Builtin types should not be annotated. Use custom type instead',
   'anno-undefined-def': 'Artifact $(ART) has not been found',
@@ -200,16 +214,21 @@ const centralMessageTexts = {
     param: 'Artifact $(ART) has no parameter $(MEMBER)'
   },
 
+  'def-missing-element': {
+    std: 'Expecting entity to have at least one non-virtual element',
+    view: 'Expecting view to have at least one non-virtual element'
+  },
+
   'duplicate-definition': {
     std: 'Duplicate definition of $(NAME)',
     absolute: 'Duplicate definition of artifact $(NAME)',
-    namespace: 'Other definition blocks $(NAME) for namespace name',
+    annotation: 'Duplicate definition of annotation vocabulary $(NAME)',
     element: 'Duplicate definition of element $(NAME)',
     enum: 'Duplicate definition of enum $(NAME)',
     key: 'Duplicate definition of key $(NAME)',
     action: 'Duplicate definition of action or function $(NAME)',
     param: 'Duplicate definition of parameter $(NAME)',
-    $tableAlias: 'Duplicate definition of table alias or mixin $(NAME)',
+    alias: 'Duplicate definition of table alias or mixin $(NAME)',
   },
 
   // TODO: rename to ref-expected-XYZ
@@ -228,6 +247,10 @@ const centralMessageTexts = {
 
   'query-unexpected-assoc-hdbcds': 'Publishing a managed association in a view is not possible for “hdbcds” naming mode',
   'query-unexpected-structure-hdbcds': 'Publishing a structured element in a view is not possible for “hdbcds” naming mode',
+  'query-ignoring-param-nullability': {
+    std: 'Ignoring nullability constraint on parameter when generating SAP HANA CDS view',
+    sql: 'Ignoring nullability constraint on parameter when generating SQL view'
+  },
 
   'ref-sloppy-type': 'A type or an element is expected here',
   'ref-sloppy-actionparam-type': 'A type, an element, or a service entity is expected here',
@@ -262,6 +285,7 @@ const centralMessageTexts = {
     std: 'Unexpected $(TYPE) mapped to $(ID) as type for key element $(NAME)', // structured
     scalar: 'Unexpected $(TYPE) mapped to $(ID) as type for key element' // flat
   },
+  'odata-spec-violation-no-key': 'Expected entity to have a primary key',
   'odata-spec-violation-type': 'Expected element to have a type',
   'odata-spec-violation-property-name': 'Expected element name to be different from declaring $(KIND)',
   'odata-spec-violation-namespace': 'Expected service name not to be one of the reserved names $(NAMES)',

package/lib/base/messages.js

@@ -4,7 +4,7 @@
 
 'use strict';
 
-const term = require('../utils/term');
+const { term } = require('../utils/term');
 const { locationString } = require('./location');
 const { isDeprecatedEnabled } = require('./model');
 const { centralMessages, centralMessageTexts } = require('./message-registry');
@@ -15,6 +15,8 @@ const { analyseCsnPath, traverseQuery } = require('../model/csnRefs');
 const fs = require('fs');
 const path = require('path');
 
+// term instance for messages
+const colorTerm = term();
 
 // Functions ensuring message consistency during runtime with --test-mode
 
@@ -670,13 +672,16 @@ function ignoreTextTransform() {
 
 function transformManyWith( t, sorted ) {
   return function transformMany( many, r, args, texts ) {
-    const prop = ['none','one'][ many.length ];
-    if (!prop || !texts[prop] || args['#'] ) {
-      const names = many.map(t);
-      return (sorted ? names.sort() : names).join(', ');
-    }
+    const prop = ['none','one','two'][ many.length ];
+    const names = many.map(t);
+    if (sorted)
+      names.sort();
+    if (!prop || !texts[prop] || args['#'] )
+      return names.join(', ');
     r['#'] = prop;              // text variant
-    return many.length && t( many[0] );
+    if (many.length === 2)
+      r.second = names[1];
+    return many.length && names[0];
   };
 }
 
@@ -791,7 +796,7 @@ function replaceInString( text, params ) {
     start = pattern.lastIndex;
   }
   parts.push( text.substring( start ) );
-  let remain = ('#' in params) ? [] : Object.keys( params ).filter( n => params[n] );
+  let remain = (params['#']) ? [] : Object.keys( params ).filter( n => params[n] );
   return (remain.length)
          ? parts.join('') + '; ' +
            remain.map( n => n.toUpperCase() + ' = ' + params[n] ).join(', ')
@@ -843,7 +848,10 @@ function messageHash(msg) {
   if(!msg.home)
     return messageString(msg);
   const copy = {...msg};
-  copy.$location = undefined;
+  // Note: This is a hack. deduplicateMessages() would otherwise remove
+  //       all but one message about duplicated artifacts.
+  if (!msg.messageId || !msg.messageId.includes('duplicate'))
+    copy.$location = undefined;
   return messageString(copy);
 }
 
@@ -853,19 +861,26 @@ function messageHash(msg) {
  *
  * Example:
  * ```txt
- * Error[message-id]: Can't find type `nu` in this scope (in entity:“E”/element:“e”)
+ * Error[message-id]: Can't find type `nu` in this scope
  *    |
- *   <source>.cds:3:11, at entity:“E”
+ *   <source>.cds:3:11, at entity:“E”/element:“e”
  * ```
+ *
  * @param {CSN.Message} err
  * @param {object} [config = {}]
  * @param {boolean} [config.normalizeFilename] Replace windows `\` with forward slashes `/`.
  * @param {boolean} [config.noMessageId]
  * @param {boolean} [config.hintExplanation] If true, messages with explanations will get a "…" marker.
- * @param {boolean} [config.withLineSpacer] If true, an additional line (with `|`) will be inserted between message and location.
+ * @param {boolean} [config.withLineSpacer]  If true, an additional line (with `|`) will be inserted between message and location.
+ * @param {boolean | 'auto'} [config.color]  If true, ANSI escape codes will be used for coloring the severity.  If false, no
+ *                                           coloring will be used.  If 'auto', we will decide based on certain factors such
+ *                                           as whether the shell is a TTY and whether the environment variable 'NO_COLOR' is
+ *                                           unset.
  * @returns {string}
  */
 function messageStringMultiline( err, config = {} ) {
+  colorTerm.changeColorMode(config ? config.color : 'auto');
+
   const explainHelp = (config.hintExplanation && hasMessageExplanation(err.messageId)) ? '…' : '';
   const msgId = (err.messageId && !config.noMessageId) ? `[${ err.messageId }${ explainHelp }]` : '';
   const home = !err.home ? '' : ('at ' + err.home);
@@ -878,7 +893,7 @@ function messageStringMultiline( err, config = {} ) {
       location += ', '
   }
   else if (!home)
-    return term.asSeverity(severity, severity + msgId) + ' ' + err.message;
+    return colorTerm.severity(severity, severity + msgId) + ' ' + err.message;
 
   let lineSpacer = '';
   if (config.withLineSpacer) {
@@ -886,8 +901,7 @@ function messageStringMultiline( err, config = {} ) {
     lineSpacer = `\n  ${ ' '.repeat( additionalIndent ) }|`;
   }
 
-  // TODO: use ':' before text
-  return term.asSeverity(severity, severity + msgId) + ': ' + err.message + lineSpacer + '\n  ' + location + home;
+  return colorTerm.severity(severity, severity + msgId) + ': ' + err.message + lineSpacer + '\n  ' + location + home;
 }
 
 /**
@@ -901,9 +915,15 @@ function messageStringMultiline( err, config = {} ) {
  * @param {string[]} sourceLines The source code split up into lines, e.g. by `splitLines(src)`
  *                               from `lib/utils/file.js`
  * @param {CSN.Message} err Error object containing all details like line, message, etc.
+ * @param {object} [config = {}]
+ * @param {boolean | 'auto'} [config.color] If true, ANSI escape codes will be used for coloring the `^`.  If false, no
+ *                                          coloring will be used.  If 'auto', we will decide based on certain factors such
+ *                                          as whether the shell is a TTY and whether the environment variable 'NO_COLOR' is
+ *                                          unset.
  * @returns {string}
  */
-function messageContext(sourceLines, err) {
+function messageContext(sourceLines, err, config) {
+  colorTerm.changeColorMode(config ? config.color : 'auto');
   const MAX_COL_LENGTH = 100;
 
   const loc = err.$location;
@@ -955,7 +975,7 @@ function messageContext(sourceLines, err) {
     // Indicate that the error is further to the right.
     if (endColumn === MAX_COL_LENGTH)
       highlighter = highlighter.replace('  ^', '..^');
-    msg += indent + '| ' + term.asSeverity(severity, highlighter);
+    msg += indent + '| ' + colorTerm.severity(severity, highlighter);
 
   } else if (maxLine !== endLine) {
     // error spans more lines which we don't print
@@ -1068,7 +1088,7 @@ function deduplicateMessages( messages ) {
 
 function shortArtName( art ) {
   const { name } = art;
-  if ([ 'select', 'action', 'alias', 'param' ].every( n => name[n] == null ) &&
+  if ([ 'select', 'action', 'alias', 'param' ].every( n => name[n] == null || name[n] === 1 ) &&
       !name.absolute.includes(':'))
     return quote.name( name.element ? `${ name.absolute }:${ name.element }` : name.absolute );
   return artName( art );

package/lib/base/model.js

@@ -19,7 +19,6 @@ const queryOps = {
  */
 const availableBetaFlags = {
   // enabled by --beta-mode
-  foreignKeyConstraints: true,
   toRename: true,
   addTextsLanguageAssoc: true,
   assocsWithParams: true,
@@ -28,7 +27,6 @@ const availableBetaFlags = {
   ignoreAssocPublishingInUnion: true,
   nestedProjections: true,
   enableUniversalCsn: true,
-  windowFunctions: true,
   // disabled by --beta-mode
   nestedServices: false,
 };
@@ -55,15 +53,18 @@ function isBetaEnabled( options, feature ) {
 /**
  * Test for deprecated feature, stored in option `deprecated`.
  * With that, the value of `deprecated` is a dictionary of feature=>Boolean.
+ * If no `feature` is provided, checks if any deprecated option is set.
  *
  * Please do not move this function to the "option processor" code.
  *
  * @param {object} options Options
- * @param {string} feature Feature to check for
+ * @param {string} [feature] Feature to check for
  * @returns {boolean}
  */
-function isDeprecatedEnabled( options, feature ) {
+function isDeprecatedEnabled( options, feature = null ) {
   const { deprecated } = options;
+  if(!feature)
+    return !!deprecated;
   return deprecated && typeof deprecated === 'object' && deprecated[feature];
 }
 

package/lib/base/optionProcessorHelper.js

@@ -30,7 +30,11 @@ function createOptionProcessor() {
     optionClashes: [],
     option,
     command,
-    positionalArgument,
+    positionalArgument: (argumentDefinition) => {
+      // Default positional arguments; may be overwritten by commands.
+      _positionalArguments(argumentDefinition);
+      return optionProcessor;
+    },
     help,
     processCmdLine,
     verifyOptions,
@@ -66,7 +70,12 @@ function createOptionProcessor() {
     /** @type {object} */
     const command = {
       options: {},
+      positionalArguments: [],
       option,
+      positionalArgument: (argumentDefinition) => {
+        _positionalArguments(argumentDefinition, command.positionalArguments);
+        return command;
+      },
       help,
       ..._parseCommandString(cmdString)
     };
@@ -96,28 +105,34 @@ 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.
    */
-  function positionalArgument(positionalArgumentDefinition) {
-    if (optionProcessor.positionalArguments.find((arg) => arg.isDynamic)) {
+  function _positionalArguments(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 +140,6 @@ function createOptionProcessor() {
 
       registeredNames.push(argName);
     }
-    return optionProcessor;
   }
 
   /**
@@ -390,21 +404,38 @@ 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];
+      const args = ( cmd && cmd.positionalArguments && cmd.positionalArguments.length ) ? cmd.positionalArguments : optionProcessor.positionalArguments;
+      return args;
+    }
+
     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;
@@ -453,7 +484,7 @@ function createOptionProcessor() {
             }
           } else {
             result.options[opt.camelName] = value;
-            if (opt.validValues && !opt.validValues.includes(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}]`);
             }
           }
@@ -486,7 +517,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 {
@@ -577,12 +611,12 @@ function isLongOption(opt) {
 
 // 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...>"
 function isDynamicPositionalArgument(arg) {
-  return /^<[a-zA-Z]+[.]{3}>$/.test(arg);
+  return /^<[a-zA-Z-]+[.]{3}>$/.test(arg);
 }
 
 module.exports = {

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