@sap/cds-compiler 2.7.0 → 2.11.2

package/lib/api/validate.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { makeMessageFunction, handleMessages } = require('../base/messages');
+const { makeMessageFunction } = require('../base/messages');
 
 /* eslint-disable arrow-body-style */
 const booleanValidator = {
@@ -70,6 +70,14 @@ const validators = {
       return val === null ? val : `type ${ typeof val }`;
     },
   },
+  // TODO: Maybe do a deep validation of the whole object with leafs?
+  variableReplacements: {
+    validate: val => val !== null && typeof val === 'object' && !Array.isArray(val),
+    expected: () => 'type object',
+    found: (val) => {
+      return val === null ? val : `type ${ typeof val }`;
+    },
+  },
   messages: {
     validate: val => Array.isArray(val),
     expected: () => 'type array',
@@ -89,14 +97,32 @@ const validators = {
     expected: () => 'type array of string',
     found: val => `type ${ typeof val }`,
   },
+  defaultBinaryLength: {
+    validate: val => !Number.isNaN(Number(val)) && Number.isInteger(Number.parseFloat(val)),
+
+    expected: () => 'Integer literal',
+    found: val => `${ (!Number.isNaN(Number(val)) ? val : 'Not a Number') }`,
+  },
   defaultStringLength: {
-    validate: val => Number.isInteger(val),
+    validate: val => !Number.isNaN(Number(val)) && Number.isInteger(Number.parseFloat(val)),
+
     expected: () => 'Integer literal',
+    found: val => `${ (!Number.isNaN(Number(val)) ? val : 'Not a Number') }`,
+  },
+  csnFlavor: {
+    validate: val => typeof val === 'string',
+    expected: () => 'type string',
     found: val => `type ${ typeof val }`,
   },
   dictionaryPrototype: {
     validate: () => true,
   },
+  assertIntegrity: {
+    validate: val => typeof val === 'string' && val === 'individual' || typeof val === 'boolean',
+    expected: () => 'a boolean or a string with value \'individual\'',
+    found: val => (typeof val === 'string' ? val : `type ${ typeof val }`),
+  },
+  assertIntegrityType: generateStringValidator([ 'DB', 'RT' ]),
 };
 
 const allCombinationValidators = {
@@ -122,16 +148,17 @@ const allCombinationValidators = {
  * Use a custom validator or "default" custom validator, fallback to Boolean validator.
  *
  * @param {object} options Flat options object to validate
+ * @param {string} moduleName The called module, e.g. 'for.odata', 'to.hdi'. Needed to initialize the message functions
  * @param {object} [customValidators] Map of custom validators to use
  * @param {string[]} [combinationValidators] Validate option combinations
  * @returns {void}
  * @throws {CompilationError} Throws in case of invalid option usage
  */
-function validate(options, customValidators = {}, combinationValidators = []) {
+function validate(options, moduleName, customValidators = {}, combinationValidators = []) {
   // TODO: issuing messages in this function looks very strange...
   {
     const messageCollector = { messages: [] };
-    const { error, throwWithError } = makeMessageFunction(null, messageCollector);
+    const { error, throwWithError } = makeMessageFunction(null, messageCollector, moduleName);
 
     for (const optionName of Object.keys(options)) {
       const optionValue = options[optionName];
@@ -143,7 +170,7 @@ function validate(options, customValidators = {}, combinationValidators = []) {
     throwWithError();
   }
 
-  const message = makeMessageFunction(null, options);
+  const message = makeMessageFunction(null, options, moduleName);
 
   for (const combinationValidatorName of combinationValidators.concat([ 'beta-no-test' ])) {
     const combinationValidator = allCombinationValidators[combinationValidatorName];
@@ -151,10 +178,7 @@ function validate(options, customValidators = {}, combinationValidators = []) {
       message[combinationValidator.severity]('invalid-option-combination', null, {}, combinationValidator.getMessage(options));
   }
 
-  // TODO: Replace with message.throwWithError():
-  // But be aware that it only throws with non-configurable errors and that this
-  // will lead to issues in test3. See #6037
-  handleMessages(undefined, options);
+  message.throwWithError();
 }
 /* eslint-enable jsdoc/no-undefined-types */
 

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)
   };
 }
 
@@ -405,9 +405,6 @@ function toRenameWithCsn(csn, options) {
 
 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 +417,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

@@ -194,7 +194,7 @@ module.exports = {
     'OTHERS',
     'TIES',
   ],
-  // HANA keywords, used to warn in 'toSql' renderer with dialect 'hana' or in 'toHana' renderer (both with 'plain' names only)
+  // HANA keywords, used for smart quoting in to-hdi.plain
   // Taken from https://help.sap.com/viewer/7c78579ce9b14a669c1f3295b0d8ca16/Cloud/en-US/28bcd6af3eb6437892719f7c27a8a285.html
   // Better use keywords in ptime/query/parser/syntax/qp_keyword.cc minus those
   // in rule unreserved_keyword_column (=…_common - "CONSTRAINT") in
@@ -673,5 +673,35 @@ module.exports = {
     'WITHIN',
     'XMLTABLE',
     'YEAR'
-  ]  
+  ],
+  // HANA CDS keywords, used for smart quoting in to-hdbcds.plain
+  hdbcds: [
+    'ALL',                'ALTER',             'AS',
+    'BEFORE',             'BEGIN',             'BOTH',
+    'CASE',               'CHAR',              'CONDITION',
+    'CONNECT',            'CROSS',             'CUBE',
+    'CURRENT_CONNECTION', 'CURRENT_DATE',      'CURRENT_SCHEMA',
+    'CURRENT_TIME',       'CURRENT_TIMESTAMP', 'CURRENT_USER',
+    'CURRENT_UTCDATE',    'CURRENT_UTCTIME',   'CURRENT_UTCTIMESTAMP',
+    'CURRVAL',            'CURSOR',            'DECLARE',
+    'DISTINCT',           'ELSE',              'ELSEIF',
+    'ELSIF',              'END',               'EXCEPT',
+    'EXCEPTION',          'EXEC',              'FOR',
+    'FROM',               'FULL',              'GROUP',
+    'HAVING',             'IF',                'IN',
+    'INNER',              'INOUT',             'INTERSECT',
+    'INTO',               'IS',                'JOIN',
+    'LEADING',            'LEFT',              'LIMIT',
+    'LOOP',               'MINUS',             'NATURAL',
+    'NEXTVAL',            'NULL',              'ON',
+    'ORDER',              'OUT',               'OUTER',
+    'PRIOR',              'RETURN',            'RETURNS',
+    'REVERSE',            'RIGHT',             'ROLLUP',
+    'ROWID',              'SELECT',            'SET',
+    'SQL',                'START',             'SYSDATE',
+    'SYSTIME',            'SYSTIMESTAMP',      'SYSUUID',
+    'TOP',                'TRAILING',          'UNION',
+    'USING',              'VALUES',            'WHEN',
+    'WHERE',              'WHILE',             'WITH'
+  ]
 }

package/lib/base/message-registry.js

@@ -118,6 +118,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
@@ -132,6 +133,11 @@ const centralMessages = {
   '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
   'odata-spec-violation-property-name': { severity: 'Warning' }, // more than 30 chars
   'odata-spec-violation-namespace-name': { severity: 'Warning' }, // more than 30 chars
 };
@@ -156,6 +162,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',
@@ -199,13 +210,13 @@ const centralMessageTexts = {
   '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
@@ -246,6 +257,19 @@ const centralMessageTexts = {
   'odata-spec-violation-assoc': 'Unexpected association in structured type for $(API)',
   'odata-spec-violation-constraints': 'Partial referential constraints produced for $(API)',
   // version independent messages
+  'odata-spec-violation-key-array': {
+    std: 'Unexpected array type for element $(NAME)',
+    scalar: 'Unexpected array type'
+  },
+  'odata-spec-violation-key-null': {
+    std: 'Expected key element $(NAME) to be not nullable', // structured
+    scalar: 'Expected key element to be not nullable' // flat
+  },
+  'odata-spec-violation-key-type': {
+    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
 
@@ -649,6 +651,8 @@ const paramsTransform = {
   // more complex convenience:
   names: transformManyWith( quoted ),
   number: n => n,
+  line: l => l,
+  col: c => c,
   literal: l => l,
   art: transformArg,
   service: transformArg,
@@ -851,19 +855,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);
@@ -876,7 +887,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) {
@@ -884,8 +895,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;
 }
 
 /**
@@ -899,9 +909,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;
@@ -953,7 +969,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

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,
@@ -54,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;
@@ -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/onConditions.js

@@ -59,6 +59,11 @@ function otherSideIsValidDollarSelf(on, startIndex) {
  */
 function validateOnCondition(member, memberName, property, path) {
   if (member && member.on) {
+    // complain about nullability constraint on managed composition
+    if (member.targetAspect && {}.hasOwnProperty.call(member, 'notNull')) {
+      this.warning(null, path.concat([ 'on' ]),
+                   'Unexpected nullability constraint defined on managed composition');
+    }
     for (let i = 0; i < member.on.length; i++) {
       if (member.on[i].ref) {
         const { ref } = member.on[i];

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

@@ -1,9 +1,28 @@
 'use strict';
 
-const { getUtils, isBuiltinType } = require('../model/csnUtils');
+const { getUtils, isBuiltinType, hasAnnotationValue } = require('../model/csnUtils');
 
 // Only to be used with validator.js - a correct this value needs to be provided!
 
+/**
+ * Scale must not be 'variable' or 'floating'
+ *
+ * scale property is always propagated
+ *
+ * @param {CSN.Element} member the element to be checked
+ * @param {string} memberName the elements name
+ * @param {string} prop which kind of member are we looking at -> only prop "elements"
+ * @param {CSN.Path} path the path to the member
+ */
+function checkDecimalScale(member, memberName, prop, path) {
+  if (hasAnnotationValue(this.artifact, '@cds.persistence.exists') ||
+     // skip is already filtered in validator, here for completeness
+     hasAnnotationValue(this.artifact, '@cds.persistence.skip'))
+    return;
+  if (member.scale && [ 'variable', 'floating' ].includes(member.scale))
+    this.error(null, path, { name: member.scale }, 'Unexpected scale $(NAME)');
+}
+
 /**
  * View parameter for hana must be of scalar type
  *
@@ -165,4 +184,9 @@ function hasArtifactTypeInformation(artifact) {
     artifact.type;     // => `type A : [type of] Integer`
 }
 
-module.exports = { checkTypeDefinitionHasType, checkElementTypeDefinitionHasType, checkTypeIsScalar };
+module.exports = {
+  checkTypeDefinitionHasType,
+  checkElementTypeDefinitionHasType,
+  checkTypeIsScalar,
+  checkDecimalScale,
+};