@sap/cds-compiler 2.10.4 → 2.12.0

package/lib/compiler/assert-consistency.js

@@ -98,6 +98,8 @@ function assertConsistency( model, stage ) {
         '$blocks',
         '$newfeatures',
         '$messageFunctions',
+        '$functions',
+        '$volatileFunctions',
       ],
     },
     ':parser': {                // top-level from parser
@@ -247,7 +249,7 @@ function assertConsistency( model, stage ) {
           'name', '$parens', 'quantifier', 'mixin', 'excludingDict', 'columns', 'elements', '_deps',
           'where', 'groupBy', 'having', 'orderBy', '$orderBy', 'limit',
           '_projections', '_block', '_parent', '_main', '_effectiveType', '$expand',
-          '$tableAliases', 'kind', '_$next', '_combined', '$inlines',
+          '$tableAliases', 'kind', '_$next', '_combined', '$inlines', '_status',
         ],
       },
       none: { optional: () => true }, // parse error
@@ -422,9 +424,12 @@ function assertConsistency( model, stage ) {
     val: {
       test: isVal,              // the following for array/struct value
       requires: [ 'location' ],
-      optional: [ 'literal', 'val', 'sym', 'struct', 'variant', 'path', 'name', '$duplicate' ],
+      optional: [
+        'literal', 'val', 'sym', 'struct', 'variant', 'path', 'name', '$duplicate', 'upTo',
+      ],
       // TODO: restrict path to #simplePath
     },
+    upTo: { test: TODO },
     struct: { inherits: 'val', test: isDictionary( definition ) }, // def because double @
     args: {
       inherits: 'value',
@@ -479,6 +484,7 @@ function assertConsistency( model, stage ) {
     },
     items: {
       kind: true,
+      also: [ 0 ],              // 0 for cyclic expansions
       requires: [ 'location' ],
       optional: [
         'enum',
@@ -539,7 +545,7 @@ function assertConsistency( model, stage ) {
         // query specific
         'where', 'columns', 'mixin', 'quantifier', 'offset',
         'orderBy', '$orderBy', 'groupBy', 'excludingDict', 'having',
-        'limit',
+        'limit', '_status',
       ],
     },
     _leadingQuery: { kind: true, test: TODO },
@@ -588,6 +594,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 +667,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 );
@@ -785,8 +795,7 @@ function assertConsistency( model, stage ) {
   }
 
   function at( nodes, prop, name ) {
-    // eslint-disable-next-line no-nested-ternary
-    const n = name ? (typeof name === 'number' ? ` for index ${ name }` : ` for "${ name }"`) : '';
+    const n = name && (typeof name === 'number' ? ` for index ${ name }` : ` for "${ name }"`) || '';
     const loc = nodes.find( o => o && typeof o === 'object' && (o.location || o.start) );
     const f = (prop) ? `${ n } in property '${ prop }'` : n;
     const l = locationString( loc && loc.location || loc || model.location );

package/lib/compiler/base.js

@@ -0,0 +1,64 @@
+// 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

@@ -2,9 +2,8 @@
 
 'use strict';
 
-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' },
@@ -82,18 +81,19 @@ const specialFunctions = {
  */
 const magicVariables = {
   $user: {
+    // id and locale are always available
     elements: { id: {}, locale: {} },
     // Allow $user.<any>
     $uncheckedElements: true,
     // Allow shortcut in CDL: `$user` becomes `$user.id` in CSN.
     $autoElement: 'id',
-  },                  // CDS-specific, not part of SQL
-  $at: {
+  },
+  $at: { // CDS-specific, not part of SQL
     elements: {
       from: {}, to: {},
     },
   },
-  $now: {},                   // Dito
+  $now: {}, // Dito
   $session: {
     // In ABAP CDS session variables are accessed in a generic way via
     // the pseudo variable $session.
@@ -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`.
@@ -174,6 +199,7 @@ function isRelationTypeName(typeName) {
  * @param {XSN.Model} model XSN model without CDS builtins
  */
 function initBuiltins( model ) {
+  const { options } = model;
   setMagicVariables( magicVariables );
   // namespace:"cds" stores the builtins ---
   const cds = createNamespace( 'cds', 'reserved' );
@@ -241,27 +267,45 @@ function initBuiltins( model ) {
     for (const name in builtins) {
       const magic = builtins[name];
       // TODO: rename to $builtinFunction
-      const art = { kind: 'builtin', name: { id: name, element: name } };
+      const art = { kind: 'builtin', name: { element: name, id: name } };
       artifacts[name] = art;
-      if (magic.elements)
-        art.elements = forEachInDict( magic.elements, (e, n) => magicElement( e, n, art ));
+
       if (magic.$autoElement)
         art.$autoElement = magic.$autoElement;
       if (magic.$uncheckedElements)
         art.$uncheckedElements = magic.$uncheckedElements;
+
+      createMagicElements( art, magic.elements );
+      if (options.variableReplacements)
+        createMagicElements( art, options.variableReplacements[name] );
       // setProp( art, '_effectiveType', art );
     }
     model.$magicVariables = { kind: '$magicVariables', artifacts };
   }
 
-  function magicElement( spec, name, parent ) {
-    const magic = {
-      kind: 'builtin',
-      name: { id: name, element: `${ parent.name.element }.${ name }` },
-    };
-    setProp( magic, '_parent', parent );
-    // setProp( magic, '_effectiveType', magic );
-    return magic;
+  function createMagicElements( art, elements ) {
+    if (!elements)
+      return;
+
+    const names = Object.keys(elements);
+    if (names.length > 0 && !art.elements)
+      art.elements = Object.create(null);
+
+    for (const n of names) {
+      const magic = {
+        kind: 'builtin',
+        name: { id: n, element: `${ art.name.element }.${ n }` },
+      };
+      // Propagate this property so that it is available for sub-elements.
+      if (art.$uncheckedElements)
+        magic.$uncheckedElements = art.$uncheckedElements;
+      setProp( magic, '_parent', art );
+      // setProp( magic, '_effectiveType', magic );
+      if (elements[n] && typeof elements[n] === 'object')
+        createMagicElements(magic, elements[n]);
+
+      art.elements[n] = magic;
+    }
   }
 }
 
@@ -269,6 +313,8 @@ module.exports = {
   functionsWithoutParens,
   specialFunctions,
   initBuiltins,
+  isInReservedNamespace,
+  isBuiltinType,
   isIntegerTypeName,
   isDecimalTypeName,
   isNumericTypeName,

package/lib/compiler/checks.js

@@ -87,6 +87,17 @@ function check( model ) {       // = XSN
                 'Keyword “localized” may only be used in combination with string types');
       }
     }
+    // "key" keyword at localized element in SELECT list.
+    // TODO: This check should be moved to localized.js
+    if (elem.key && elem.key.val && elem._main && elem._main.query) {
+      // original element is localized but not key, as that would have
+      // already resulted in a warning
+      if (elem._origin && elem._origin.localized && elem._origin.localized.val &&
+        ( !elem._origin.key || !elem._origin.key.val)) {
+        warning('localized-key', [ elem.key.location, elem ], { keyword: 'localized' },
+                'Keyword $(KEYWORD) is ignored for primary keys');
+      }
+    }
   }
 
   function checkQuery( query ) {
@@ -334,11 +345,17 @@ function check( model ) {       // = XSN
     // Max cardinalities must be a positive number or '*'
     for (const prop of [ 'sourceMax', 'targetMax' ]) {
       if (elem.cardinality[prop]) {
-        if (!(elem.cardinality[prop].literal === 'number' && elem.cardinality[prop].val > 0 ||
-              elem.cardinality[prop].literal === 'string' && elem.cardinality[prop].val === '*')) {
-          error(null, [ elem.cardinality[prop].location, elem ],
-                { code: elem.cardinality[prop].val },
-                'Illegal value $(CODE) for max cardinality (must be a positive number or "*")');
+        const { literal, val, location } = elem.cardinality[prop];
+        if (!(literal === 'number' && val > 0 ||
+              literal === 'string' && val === '*')) {
+          error('invalid-cardinality', [ location, elem ], { '#': prop, code: val }, {
+            // eslint-disable-next-line max-len
+            std: 'Value $(CODE) is invalid for maximum cardinality, expecting a positive number or ‘*’',
+            // eslint-disable-next-line max-len
+            sourceMax: 'Value $(CODE) is invalid for maximum source cardinality, expecting a positive number or ‘*’',
+            // eslint-disable-next-line max-len
+            targetMax: 'Value $(CODE) is invalid for maximum target cardinality, expecting a positive number or ‘*’',
+          });
         }
       }
     }
@@ -348,10 +365,16 @@ function check( model ) {       // = XSN
     //       from-csn.json (expected non-negative number)
     for (const prop of [ 'sourceMin', 'targetMin' ]) {
       if (elem.cardinality[prop]) {
-        if (!(elem.cardinality[prop].literal === 'number' && elem.cardinality[prop].val >= 0)) {
-          error(null, [ elem.cardinality[prop].location, elem ],
-                { code: elem.cardinality[prop].val },
-                'Illegal value $(CODE) for min cardinality (must be a non-negative number)');
+        const { literal, val, location } = elem.cardinality[prop];
+        if (!(literal === 'number' && val >= 0)) {
+          error('invalid-cardinality', [ location, elem ], { '#': prop, code: val }, {
+            // eslint-disable-next-line max-len
+            std: 'Value $(CODE) is invalid for minimum cardinality, expecting a non-negative number',
+            // eslint-disable-next-line max-len
+            targetMin: 'Value $(CODE) is invalid for minimum target cardinality, expecting a non-negative number',
+            // eslint-disable-next-line max-len
+            sourceMin: 'Value $(CODE) is invalid for minimum source cardinality, expecting a non-negative number',
+          });
         }
       }
     }
@@ -632,8 +655,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');