@sap/cds-compiler 2.10.4 → 2.11.0

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;
@@ -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/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(null, parent.$location, { id: tail, elemref: parent }, 'No configuration for magic variable was provided - path $(ELEMREF), step $(ID)');
   }
 }
 

package/lib/compiler/assert-consistency.js

@@ -98,6 +98,8 @@ function assertConsistency( model, stage ) {
         '$blocks',
         '$newfeatures',
         '$messageFunctions',
+        '$functions',
+        '$volatileFunctions',
       ],
     },
     ':parser': {                // top-level from parser
@@ -479,6 +481,7 @@ function assertConsistency( model, stage ) {
     },
     items: {
       kind: true,
+      also: [ 0 ],              // 0 for cyclic expansions
       requires: [ 'location' ],
       optional: [
         'enum',
@@ -588,6 +591,8 @@ function assertConsistency( model, stage ) {
     $sources: { parser: true, test: isArray( isString ) },
     $expected: { parser: true, test: isString },
     $messageFunctions: { test: TODO },
+    $functions: { test: TODO },
+    $volatileFunctions: { test: TODO },
   };
   let _noSyntaxErrors = null;
   assertProp( model, null, stageParser ? ':parser' : ':model', null, true );
@@ -659,6 +664,8 @@ function assertConsistency( model, stage ) {
   }
 
   function standard( node, parent, prop, spec, name ) {
+    if (spec.also && spec.also.includes( node ))
+      return;
     isObject( node, parent, prop, spec, name );
 
     const names = Object.getOwnPropertyNames( node );

package/lib/compiler/base.js

@@ -0,0 +1,65 @@
+// Base Definitions for the Core Compiler
+
+
+'use strict';
+
+const dictKinds = {
+  definitions: 'absolute',
+  elements: 'element',
+  enum: 'enum',
+  foreignKeys: 'key',
+  actions: 'action',
+  params: 'param',
+};
+
+const kindProperties = {
+  // TODO: also foreignKeys ?
+  namespace: { artifacts: true }, // on-the-fly context
+  context: { artifacts: true, normalized: 'namespace' },
+  service: { artifacts: true, normalized: 'namespace' },
+  entity: { elements: true, actions: true, params: () => false },
+  select: { normalized: 'select', elements: true },
+  $join: { normalized: 'select' },
+  $tableAlias: { normalized: 'alias' }, // table alias in select
+  $self: { normalized: 'alias' }, // table alias in select
+  $navElement: { normalized: 'element' },
+  $inline: { normalized: 'element' }, // column with inline property
+  event: { elements: true },
+  type: { elements: propExists, enum: propExists },
+  aspect: { elements: propExists },
+  annotation: { elements: propExists, enum: propExists },
+  enum: { normalized: 'element' },
+  element: { elements: propExists, enum: propExists, dict: 'elements' },
+  mixin: { normalized: 'alias' },
+  action: {
+    params: () => false, elements: () => false, enum: () => false, dict: 'actions',
+  }, // no extend params, only annotate
+  function: {
+    params: () => false, elements: () => false, enum: () => false, normalized: 'action',
+  }, // no extend params, only annotate
+  key: { normalized: 'element' },
+  param: { elements: () => false, enum: () => false, dict: 'params' },
+  source: { artifacts: true },  // TODO -> $source
+  using: {},
+  extend: {
+    isExtension: true,
+    noDep: 'special',
+    elements: true, /* only for parse-cdl */
+    actions: true,  /* only for parse-cdl */
+  },
+  annotate: {
+    isExtension: true, noDep: 'special', elements: true, enum: true, actions: true, params: true,
+  },
+  builtin: {},                  // = CURRENT_DATE, TODO: improve
+  $parameters: {},              // $parameters in query entities
+};
+
+function propExists( prop, parent ) {
+  const obj = parent.returns || parent;
+  return (obj.items || obj.targetAspect || obj)[prop];
+}
+
+module.exports = {
+  dictKinds,
+  kindProperties,
+};

package/lib/compiler/builtins.js

@@ -4,7 +4,7 @@
 
 const { forEachInDict } = require('../base/dictionaries');
 const { builtinLocation } = require('../base/location');
-const { setProp } = require('../base/model');
+const { setProp } = require('./utils');
 
 const core = {
   String: { parameters: [ 'length' ], category: 'string' },
@@ -167,6 +167,31 @@ function isRelationTypeName(typeName) {
   return typeCategories.relation.includes(typeName);
 }
 
+/**
+ * Checks whether the given absolute path is inside a reserved namespace.
+ *
+ * @param {string} absolute
+ * @returns {boolean}
+ */
+function isInReservedNamespace(absolute) {
+  return absolute.startsWith( 'cds.') &&
+    !absolute.match(/^cds\.foundation(\.|$)/) &&
+    !absolute.match(/^cds\.outbox(\.|$)/); // Requested by Node runtime
+}
+
+/**
+ * Tell if a type is (directly) a builtin type
+ * Note that in CSN builtins are not in the definition of the model, so we can only
+ * check against their absolute names.  Builtin types are "cds.<something>", i.e. they
+ * are directly in 'cds', but not for example in 'cds.foundation'.
+ *
+ * @param {string} type
+ * @returns {boolean}
+ */
+function isBuiltinType(type) {
+  return typeof type === 'string' && isInReservedNamespace(type);
+}
+
 /**
  * Add CDS builtins like the `cds` namespace with types like `cds.Integer` to
  * `definitions` of the XSN model as well as to `$builtins`.
@@ -269,6 +294,8 @@ module.exports = {
   functionsWithoutParens,
   specialFunctions,
   initBuiltins,
+  isInReservedNamespace,
+  isBuiltinType,
   isIntegerTypeName,
   isDecimalTypeName,
   isNumericTypeName,

package/lib/compiler/checks.js

@@ -632,8 +632,9 @@ function check( model ) {       // = XSN
    * @returns {void}
    */
   function checkTokenStreamExpression(xpr, allowAssocTail) {
+    const args = Array.isArray(xpr.args) ? xpr.args : Object.values(xpr.args || {});
     // Check for illegal argument usage within the expression
-    for (const arg of xpr.args || []) {
+    for (const arg of args) {
       if (isVirtualElement(arg))
         error(null, arg.location, 'Virtual elements can\'t be used in an expression');