@sap/cds-compiler 2.7.0 → 2.11.2

package/lib/checks/unknownMagic.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const { getVariableReplacement } = require('../model/csnUtils');
+
+// We only care about the "wild" ones - $at is validated by the compiler
+const magicVariables = {
+  $user: [
+    'id',     // $user.id
+    'locale', // $user.locale
+  ],
+  $session: [
+    // no valid ways for this
+  ],
+};
+
+/**
+ * Check that the given ref does not use magic variables for which we don't have
+ * a valid way of rendering.
+ *
+ * Valid ways:
+ * - We know what to do -> $user.id on HANA
+ * - 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
+ * @param {Array} ref to check
+ */
+function unknownMagicVariable(parent, name, ref) {
+  if (parent.$scope && parent.$scope === '$magic') {
+    const [ head, ...rest ] = ref;
+    const tail = rest.join('.');
+    const magicVariable = magicVariables[head];
+    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)');
+  }
+}
+
+module.exports = {
+  ref: unknownMagicVariable,
+};

package/lib/checks/validator.js

@@ -23,13 +23,17 @@ const {
 // both
 const { validateOnCondition, validateMixinOnCondition } = require('./onConditions');
 const validateForeignKeys = require('./foreignKeys');
-const { checkTypeDefinitionHasType, checkElementTypeDefinitionHasType, checkTypeIsScalar } = require('./types');
+const {
+  checkTypeDefinitionHasType, checkElementTypeDefinitionHasType,
+  checkTypeIsScalar, checkDecimalScale,
+} = require('./types');
 const { checkPrimaryKey, checkVirtualElement, checkManagedAssoc } = require('./elements');
 const checkForInvalidTarget = require('./invalidTarget');
 const { validateAssociationsInItems } = require('./arrayOfs');
 const checkQueryForNoDBArtifacts = require('./queryNoDbArtifacts');
 const checkExplicitlyNullableKeys = require('./nullableKeys');
 const nonexpandableStructuredInExpression = require('./nonexpandableStructured');
+const unknownMagic = require('./unknownMagic');
 const managedWithoutKeys = require('./managedWithoutKeys');
 
 const forHanaMemberValidators
@@ -37,6 +41,7 @@ const forHanaMemberValidators
   // For HANA CDS specifically, reject any default parameter values, as these are not supported.
   rejectParamDefaultsInHanaCds,
   checkTypeIsScalar,
+  checkDecimalScale,
   checkExplicitlyNullableKeys,
   managedWithoutKeys,
   warnAboutDefaultOnAssociationForHanaCds,
@@ -50,7 +55,7 @@ const forHanaArtifactValidators
   checkForEmptyOrOnlyVirtual,
 ];
 
-const forHanaCsnValidators = [ nonexpandableStructuredInExpression ];
+const forHanaCsnValidators = [ nonexpandableStructuredInExpression, unknownMagic ];
 /**
  * @type {Array<(query: CSN.Query, path: CSN.Path) => void>}
  */

package/lib/compiler/assert-consistency.js

@@ -98,6 +98,8 @@ function assertConsistency( model, stage ) {
         '$blocks',
         '$newfeatures',
         '$messageFunctions',
+        '$functions',
+        '$volatileFunctions',
       ],
     },
     ':parser': {                // top-level from parser
@@ -246,7 +248,7 @@ function assertConsistency( model, stage ) {
         optional: [
           'name', '$parens', 'quantifier', 'mixin', 'excludingDict', 'columns', 'elements', '_deps',
           'where', 'groupBy', 'having', 'orderBy', '$orderBy', 'limit',
-          '_projections', '_block', '_parent', '_main', '_effectiveType',
+          '_projections', '_block', '_parent', '_main', '_effectiveType', '$expand',
           '$tableAliases', 'kind', '_$next', '_combined', '$inlines',
         ],
       },
@@ -324,7 +326,7 @@ function assertConsistency( model, stage ) {
       requires: [ 'location' ],
       optional: [
         'path', 'elements', '_outer',
-        'scope', '_artifact', '$inferred',
+        'scope', '_artifact', '$inferred', '$expand',
         '_effectiveType',           // by propagation
       ],
     },
@@ -351,6 +353,7 @@ function assertConsistency( model, stage ) {
     $delimited: { parser: true, test: isBoolean },
     scope: { test: isScope },
     func: { test: TODO },
+    suffix: { test: TODO },
     kind: {
       isRequired: !stageParser && (() => true),
       // required to be set by Core Compiler even with parse errors
@@ -398,6 +401,7 @@ function assertConsistency( model, stage ) {
         optional: [
           'args',
           'func',
+          'suffix',
           'quantifier',
           '$inferred',
           '$parens',
@@ -426,7 +430,7 @@ function assertConsistency( model, stage ) {
     struct: { inherits: 'val', test: isDictionary( definition ) }, // def because double @
     args: {
       inherits: 'value',
-      optional: [ 'name', '$duplicate', '$expected' ],
+      optional: [ 'name', '$duplicate', '$expected', 'args', 'suffix' ],
       test: args,
     },
     on: { kind: true, inherits: 'value', test: expression },
@@ -477,6 +481,7 @@ function assertConsistency( model, stage ) {
     },
     items: {
       kind: true,
+      also: [ 0 ],              // 0 for cyclic expansions
       requires: [ 'location' ],
       optional: [
         'enum',
@@ -533,7 +538,7 @@ function assertConsistency( model, stage ) {
       ],
       optional: [
         '_effectiveType', '$parens',
-        '_deps',
+        '_deps', '$expand',
         // query specific
         'where', 'columns', 'mixin', 'quantifier', 'offset',
         'orderBy', '$orderBy', 'groupBy', 'excludingDict', 'having',
@@ -574,7 +579,11 @@ function assertConsistency( model, stage ) {
     $duplicates: { parser: true, kind: true, test: TODO }, // array of arts or true
     $extension: { kind: true, test: TODO }, // TODO: introduce $applied instead or $status
     $inferred: { parser: true, kind: true, test: isString },
-    $expand: { kind: true, test: isString },
+
+    // Helper property for the XSN-to-CSN transformation, see function setExpandStatus():
+    // client, universal: render expanded elements?  gensrc: produce annotate statements?
+    $expand: { kind: true, test: isString }, // TODO: rename it to $elementsExpand ?
+
     $autoexpose: { kind: [ 'entity' ], test: isBoolean, also: [ null, 'Composition' ] },
     $a2j: { kind: true, enumerable: true, test: TODO },
     $extra: { parser: true, test: TODO },   // for unexpected properties in CSN
@@ -582,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 );
@@ -653,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' },
@@ -83,6 +83,8 @@ const specialFunctions = {
 const magicVariables = {
   $user: {
     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
@@ -165,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`.
@@ -267,6 +294,8 @@ module.exports = {
   functionsWithoutParens,
   specialFunctions,
   initBuiltins,
+  isInReservedNamespace,
+  isBuiltinType,
   isIntegerTypeName,
   isDecimalTypeName,
   isNumericTypeName,

package/lib/compiler/checks.js

@@ -15,7 +15,9 @@
 
 // const { hasArtifactTypeInformation } = require('../model/csnUtils')
 const builtins = require('../compiler/builtins');
-const { forEachGeneric, forEachDefinition, forEachMember } = require('../base/model');
+const {
+  forEachGeneric, forEachDefinition, forEachMember,
+} = require('../base/model');
 
 function check( model ) {       // = XSN
   const {
@@ -630,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');