@sap/cds-compiler 3.7.2 → 3.8.0

package/lib/base/messages.js

@@ -11,6 +11,7 @@ const { centralMessages, centralMessageTexts, oldMessageIds } = require('./messa
 const _messageIdsWithExplanation = require('../../share/messages/message-explanations.json').messages;
 const { analyseCsnPath, traverseQuery } = require('../model/csnRefs');
 const { CompilerAssertion } = require('./error');
+const { getArtifactName } = require('../compiler/base');
 
 const fs = require('fs');
 const path = require('path');
@@ -841,6 +842,7 @@ const nameProp = {
   function: 'action',
 };
 
+// TODO: very likely delete this function
 function searchName( art, id, variant ) {
   if (!variant) {
     // used to mention the "effective" type in the message, not the
@@ -1186,7 +1188,7 @@ function deduplicateMessages( messages ) {
 }
 
 function shortArtName( art ) {
-  const { name } = art;
+  const name = getArtifactName( art );
   if ([ 'select', 'action', 'alias', 'param' ].every( n => name[n] == null || name[n] === 1 ) &&
       !name.absolute.includes(':'))
     return quote.double( name.element ? `${ name.absolute }:${ name.element }` : name.absolute );
@@ -1194,13 +1196,13 @@ function shortArtName( art ) {
 }
 
 function artName( art, omit ) {
-  const { name } = art;
+  const name = getArtifactName( art );
   const r = (name.absolute) ? [ quoted( name.absolute ) ] : [];
   if (name.select && name.select > 1 || name.select != null && art.kind !== 'element') // Yes, omit select:1 for element - TODO: re-check
     r.push( (art.kind === 'extend' ? 'block:' : 'query:') + name.select ); // TODO: rename to 'select:1' and consider whether there are more selects
   if (name.action && omit !== 'action')
     r.push( `${ memberActionName(art) }:${ quoted( name.action ) }` );
-  if (name.alias && art.kind !== '$self')
+  if (name.alias && art.kind !== '$self' && name.$inferred !== '$internal')
     r.push( (art.kind === 'mixin' ? 'mixin:' : 'alias:') + quoted( name.alias ) );
   if (name.param != null && omit !== 'param')
     r.push( name.param ? `param:${ quoted( name.param ) }` : 'returns' ); // TODO: join
@@ -1231,7 +1233,7 @@ function memberActionName( art ) {
 function homeName( art, absoluteOnly ) {
   if (!art)
     return art;
-  if (art._outer)               // in returns / items property
+  if (art._outer)               // in items property
     return homeName( art._outer, absoluteOnly );
   else if (art.kind === 'source' || !art.name) // error reported in parser or on source level
     return null;
@@ -1251,7 +1253,10 @@ function homeName( art, absoluteOnly ) {
 
 // The "home" for extensions is handled differently because `_artifact` is not
 // set for unknown extensions, and we could have nested extensions.
+// TODO: delete this function, just set correct name/_parent for extensions
 function homeNameForExtend( art ) {
+  if (!art.name.absolute && art._main)       // new-style member name
+    return `${ art._main.kind }:${ artName( art ) }`;
   const kind = art.kind || 'extend';
   // TODO: fix the following - do like in collectArtifactExtensions() or
   //       basically resolveUncheckedPath()
@@ -1590,11 +1595,11 @@ function queryDepthForMessage( csnPath, model, view ) {
   if (!targetQuery)
     return 0;
   const rootQuery = view.query || { SELECT: view.projection };
-  let depth = 1;
+  let depth = 0;
   let totalDepth = 0;
   let isFound = false;
-  traverseQuery(rootQuery, null, null, (q, querySelect) => {
-    if (querySelect) {
+  traverseQuery(rootQuery, null, null, (q) => {
+    if (q.SELECT) {
       totalDepth += 1;
       if (!isFound)
         depth += 1;

package/lib/base/model.js

@@ -21,7 +21,6 @@ const queryOps = {
  */
 const availableBetaFlags = {
   // enabled by --beta-mode
-  calculatedElements: true,
   annotationExpressions: true,
   toRename: true,
   assocsWithParams: true,
@@ -36,6 +35,7 @@ const availableBetaFlags = {
   optionalActionFunctionParameters: true,
   // disabled by --beta-mode
   nestedServices: false,
+  v4preview: false,
 };
 
 const availableDeprecatedFlags = {
@@ -111,7 +111,7 @@ function isDeprecatedEnabled( options, feature = null ) {
  * to change their code, emit an error if one of such removed flags was used.
  *
  * @param {CSN.Options} options
- * @param error Error message function returned by makeMessageFunctions().
+ * @param error Error message function returned by makeMessageFunction().
  */
 function checkRemovedDeprecatedFlags( options, { error } ) {
   // Assume that we emitted these errors once if a message with this ID was found.
@@ -128,6 +128,7 @@ function checkRemovedDeprecatedFlags( options, { error } ) {
 
 // Apply function `callback` to all artifacts in dictionary
 // `model.definitions`.  See function `forEachGeneric` for details.
+// TODO: should we skip "namespaces" already here?
 function forEachDefinition( model, callback ) {
   forEachGeneric( model, 'definitions', callback );
 }

package/lib/checks/arrayOfs.js

@@ -32,7 +32,7 @@ function validateAssociationsInItems( member ) {
       }
     }
   };
-  if (this.artifact && ( this.artifact.kind === 'entity' || this.artifact.query ) && member && member.items && member.$path[2] === 'elements') {
+  if (this.artifact && this.artifact.kind === 'entity' && member && member.items && member.$path[2] === 'elements') {
     if (member.items.type) {
       const type = member.items.type.ref
         ? this.artifactRef(member.items.type)

package/lib/checks/defaultValues.js

@@ -53,7 +53,7 @@ function rejectParamDefaultsInHanaCds( member, memberName, prop, path ) {
  */
 function warnAboutDefaultOnAssociationForHanaCds( member, memberName, prop, path ) {
   const art = this.csn.definitions[path[1]];
-  if (!art.query && this.options.transformation === 'hdbcds' && member.target && member.default) {
+  if (!art.query && !art.projection && this.options.transformation === 'hdbcds' && member.target && member.default) {
     this.warning(null, path, { '#': member._type.type === 'cds.Association' ? 'std' : 'comp' },
                  {
                    std: 'Unexpected default defined on association',

package/lib/checks/hasPersistedElements.js

@@ -17,7 +17,7 @@ function validateHasPersistedElements( artifact, artifactName, prop, path ) {
   if (artifact.kind === 'entity' && isPersistedOnDatabase(artifact)) {
     if (!artifact.elements || !hasRealElements(artifact.elements))
       // TODO: Maybe check if there are only calc elements and adapt the message?
-      this.error('def-missing-element', path, { '#': artifact.query ? 'view' : 'std' });
+      this.error('def-missing-element', path, { '#': ( artifact.query || artifact.projection ) ? 'view' : 'std' });
   }
 }
 

package/lib/checks/invalidTarget.js

@@ -55,7 +55,7 @@ function invalidTarget( member ) {
 
   if (
     this.artifact &&
-    (this.artifact.kind === 'entity' || this.artifact.query) &&
+    this.artifact.kind === 'entity' &&
     member.$path[2] === 'elements'
   )
     checkForInvalidTarget(member);

package/lib/checks/onConditions.js

@@ -95,7 +95,6 @@ function validateOnCondition( member, memberName, property, path ) {
               }
             }
           }
-
           if (_links[j].art.virtual)
             this.error(null, csnPath, { id, elemref }, 'Virtual elements can\'t be used in ON-conditions, step $(ID) of path $(ELEMREF)');
 
@@ -116,11 +115,11 @@ function validateOnCondition( member, memberName, property, path ) {
             // 2) Path ends on an association (managed or unmanaged) and the other operand is a '$self'
 
             // If this path ends structured or on an association, perform the check:
-            if ((type.target || type.elements) &&
-             !( /* 1) */ (type.target && type.keys || type.elements) && validStructuredElement ||
-             /* 2) */ (type.target && validDollarSelf)) &&
-             !type.virtual) {
-            // Do nothing - handled by lib/checks/nonexpandableStructured.js
+            if (
+              ((type.target && type.keys || type.elements) && validStructuredElement ||
+              (type.target && validDollarSelf)) && !type.virtual
+            ) {
+              // Do nothing - handled by lib/checks/nonexpandableStructured.js
             }
             else if (type.items && !type.virtual) {
               this.error(null, onPath, { elemref: { ref } },
@@ -130,6 +129,10 @@ function validateOnCondition( member, memberName, property, path ) {
               this.error(null, onPath, { elemref: { ref } },
                          'Virtual elements can\'t be used in ON-conditions, path $(ELEMREF)');
             }
+            else if (type.on) {
+              // Path leaf is an unmanaged association, can't use an unmanaged assoc as operand
+              this.error('ref-unexpected-navigation', onPath, { '#': 'unmanagedleaf', id: logReady(ref[ref.length - 1]), elemref: { ref } });
+            }
           }
         }
       }

package/lib/checks/sql-snippets.js

@@ -18,7 +18,7 @@ function checkSqlAnnotationOnElement( member, memberName, prop, path ) {
     this.message('anno-invalid-sql-element', path, { anno: 'sql.prepend' }, 'Annotation $(ANNO) can\'t be used on elements' );
 
   if (member['@sql.append']) {
-    if (this.artifact.query)
+    if (this.artifact.query || this.artifact.projection)
       this.message('anno-invalid-sql-view-element', path, { anno: 'sql.append' }, 'Annotation $(ANNO) can\'t be used on elements in views' );
     else if (this.csnUtils.isStructured(member))
       this.message('anno-invalid-sql-struct', path, { anno: 'sql.append' }, 'Annotation $(ANNO) can\'t be used on structured elements' );
@@ -57,7 +57,7 @@ function checkSqlAnnotationOnArtifact( artifact, artifactName ) {
       this.message('anno-invalid-sql-kind', [ 'definitions', artifactName ], { name: '@sql.append', kind: artifact.kind }, 'Annotation $(NAME) can\'t be used on an artifact of kind $(KIND)' );
   }
   else if (artifact['@sql.prepend']) {
-    if (artifact.query)
+    if (artifact.query || artifact.projection)
       this.message('anno-invalid-sql-view', [ 'definitions', artifactName ], { name: '@sql.prepend' }, 'Annotation $(NAME) can\'t be used on views' );
     else
       checkValidAnnoValue(artifact, '@sql.prepend', [ 'definitions', artifactName ], this.error, this.options);

package/lib/checks/types.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const { hasAnnotationValue } = require('../model/csnUtils');
-const { isBetaEnabled } = require('../base/model');
 
 // Only to be used with validator.js - a correct this value needs to be provided!
 
@@ -55,7 +54,7 @@ function checkElementTypeDefinitionHasType( member, memberName, prop, path ) {
 
   // should only happen with csn input, not in cdl
   // calculated elements may not have a .type (requires beta flag)
-  if ((!member.value || !isBetaEnabled(this.options, 'calculatedElements')) &&
+  if (!member.value &&
       !parent.projection && !parent.query && !hasArtifactTypeInformation(member)) {
     errorAboutMissingType(this.error, path, memberName, true);
     return;

package/lib/compiler/assert-consistency.js

@@ -191,7 +191,7 @@ function assertConsistency( model, stage ) {
           test: isDictionary( definition ),
           requires: [ 'kind', 'name' ],
           optional: [
-            'elements', '$autoElement', '$uncheckedElements', '_origin',
+            'elements', '$autoElement', '$uncheckedElements', '_origin', '_extensions',
             '$requireElementAccess', '_effectiveType', '$effectiveSeqNo', '_deps',
           ],
           schema: {
@@ -295,6 +295,7 @@ function assertConsistency( model, stage ) {
           'kind', 'name', '_block', '_parent', '_main', 'elements',
           '_effectiveType', '$effectiveSeqNo', '_origin', '_joinParent', '$joinArgsIndex',
           '$duplicates', // duplicate query in FROM clause
+          '$inferred', // table alias with $inferred: '$internal'
         ],
       },
       none: { optional: () => true }, // parse error
@@ -339,7 +340,7 @@ function assertConsistency( model, stage ) {
       optional: [
         'path', 'elements', '_outer', '_parent', '_main', '_block', 'kind',
         'scope', '_artifact', '$inferred', '$expand', '$inCycle', '$tableAliases', '_$next',
-        '_origin', '_effectiveType', '$effectiveSeqNo',
+        '_origin', '_effectiveType', '$effectiveSeqNo', '_extensions',
       ],
     },
     target: {
@@ -388,12 +389,18 @@ function assertConsistency( model, stage ) {
       kind: [ 'entity', 'view', 'type', 'aspect' ],
       test: isString,            // CSN parser should check for 'entity', 'view', 'projection'
     },
+    $tokenTexts: {
+      parser: true,
+      test: isString,
+    },
     value: {
       optional: [
         'location', '$inferred', 'sort', 'nulls',
         'param', 'scope', // for dynamic parameter '?'
         // A2J wrongly propagates the following into a CAST of the CSN passed to compileX:
         'elements', 'items', 'enum',
+        // CSN parser may let these properties slip through to XSN, even if input is invalid.
+        'args', 'op', 'func', 'suffix',
       ],
 
       kind: true,
@@ -443,6 +450,8 @@ function assertConsistency( model, stage ) {
       requires: [ 'location' ],
       optional: [
         'literal', 'val', 'sym', 'struct', 'variant', 'path', 'name', '$duplicates', 'upTo',
+        // expressions as annotation values
+        '$tokenTexts', 'op', 'args', 'func',
       ],
       // TODO: restrict path to #simplePath
     },
@@ -470,7 +479,13 @@ function assertConsistency( model, stage ) {
     '@': {
       kind: true,
       inherits: 'value',
-      optional: [ 'name', '_block', '$priority', '$inferred', '$duplicates', '$errorReported' ],
+      optional: [
+        'name', '_block', '$priority', '$inferred', '$duplicates', '$errorReported',
+        // annotation values
+        '$tokenTexts',
+        // CSN parser may let these properties slip through to XSN, even if input is invalid.
+        'args', 'op', 'func', 'suffix',
+      ],
       // TODO: name requires if not in parser?
     },
     $priority: { test: isOneOf([ undefined, false, 'extend', 'annotate' ]) },
@@ -494,7 +509,7 @@ function assertConsistency( model, stage ) {
     action: { test: isString },
     param: { test: TODO },
     alias: { test: isString },
-    expectedKind: { kind: [ 'extend' ], inherits: 'kind' },
+    expectedKind: { kind: [ 'extend' ], test: locationVal( isString ) },
     virtual: { kind: true, test: locationVal() },
     key: { kind: true, test: locationVal(), also: [ null, undefined ] },
     masked: { kind: true, test: locationVal() },
@@ -514,7 +529,7 @@ function assertConsistency( model, stage ) {
         'elements', 'cardinality', 'target', 'on', 'foreignKeys', 'items',
         '_outer', '_effectiveType', '$effectiveSeqNo', 'notNull', '_parent',
         '_origin', '_block', '$inferred', '$expand', '$inCycle', '_deps',
-        '$syntax',
+        '$syntax', '_extensions',
         '_status', '_redirected',
         ...typeProperties,
       ],
@@ -574,12 +589,14 @@ function assertConsistency( model, stage ) {
     _leadingQuery: { kind: true, test: TODO },
     $replacement: { kind: true, test: TODO }, // for smart * in queries
     _origin: { kind: true, test: TODO },
+    _calcOrigin: { kind: true, test: TODO },
     _pathHead: { kind: [ 'element', undefined ], test: TODO }, // column or * (wildcard)
     _from: { kind: true, test: TODO }, // TODO: not necessary anymore ?
     // array of $tableAlias (or includes) for explicit and implicit redirection:
     _redirected: { kind: true, test: TODO },
     // ...array of table aliases for targets from orig to new
     _$next: { kind: true, test: TODO }, // next lexical search environment for values
+    _extensions: { kind: true, test: TODO }, // for collecting extend/annotate on artifact
     _extend: { kind: true, test: TODO }, // for collecting extend/annotate on artifact
     _annotate: { kind: true, test: TODO }, // for collecting extend/annotate on artifact
     _extension: { kind: true, test: TODO }, // on artifact to its "super extend/annotate" statement
@@ -609,6 +626,7 @@ function assertConsistency( model, stage ) {
       parser: true,
       kind: true,
       test: isOneOf([
+        '',                     // constructed “super annotate” statement
         // Uppercase values are used in logic, lowercase value are "just for us", i.e.
         // debugging or to add properties such as $generated in Universal CSN.
         // However, that is no longer true. For example, `autoexposed` is used in populate.js
@@ -620,6 +638,7 @@ function assertConsistency( model, stage ) {
 
         '$autoElement', // for magicVars: $user is automatically changed to $user.id
         '$generated', // compiler generated annotations, e.g. @Core.Computed
+        '$internal', // compiler internal; must not reach CSN output
         '*', // inferred from query wildcard
         'as', // query alias name
         'aspect-composition',

package/lib/compiler/base.js

@@ -29,14 +29,18 @@ const kindProperties = {
   type: { elements: propExists, enum: propExists, include: true },
   aspect: { elements: propExists, actions: true, include: true },
   annotation: { elements: propExists, enum: propExists },
-  enum: { normalized: 'element' },
+  enum: { normalized: 'element', dict: 'enum' },
   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',
+    params: () => false,
+    elements: () => false,
+    enum: () => false,
+    normalized: 'action',
+    dict: 'actions',
   }, // no extend params, only annotate
   key: { normalized: 'element' },
   param: { elements: () => false, enum: () => false, dict: 'params' },
@@ -60,7 +64,50 @@ function propExists( prop, parent ) {
   return (obj.items || obj.targetAspect || obj)[prop];
 }
 
+// Return the "old style" name structure with `absolute`, `action`, `param`,
+// `element`. Later we also need to add `select` and `alias`.
+// (Currently not needed, as only used for extend and annotate statements.)
+function getArtifactName( art ) {
+  if (!art.name || art.name.absolute)
+    return art.name;
+  // extend and annotate statement already have "sparse" names → calculate old one
+  const link = art.name._artifact;
+  const namePath = [];
+  while (art._main && !art.name.absolute) { // until we hit an old-style name or the main artifact
+    namePath.push( art );
+    art = art._parent;
+  }
+  namePath.reverse();
+  const name = { ...art.name };
+  for (const np of namePath) {
+    const prop = getMemberNameProp( np, np.kind );
+    name[prop] = (name[prop]) ? `${ name[prop] }.${ np.name.id }` : np.name.id;
+    name.id = np.name.id;
+    name.location = np.name.location;
+  }
+  if (link !== undefined)
+    Object.defineProperty( name, '_artifact', { value: link, configurable: true, writable: true } );
+  return name;
+}
+
+// TODO: probably store this prop in name
+function getMemberNameProp( elem, kind ) {
+  if (kind !== 'annotate' && kind !== 'extend')
+    return kindProperties[kind]?.normalized || kind;
+  let obj = elem._parent;
+  if (obj.params || obj.returns)
+    return 'param';
+  if (obj.actions)
+    return 'action';
+  while (obj.items)
+    obj = obj.items;
+  if (obj.elements || obj.enum)
+    return 'element';
+  return 'id';
+}
+
 module.exports = {
   dictKinds,
   kindProperties,
+  getArtifactName,
 };

package/lib/compiler/builtins.js

@@ -10,6 +10,7 @@
 const { builtinLocation } = require('../base/location');
 const { setLink: setProp } = require('./utils');
 
+// TODO: make type parameters a dict
 const core = {
   String: { parameters: [ 'length' ], category: 'string' },
   LargeString: { category: 'string' },
@@ -199,7 +200,16 @@ const magicVariables = {
   },
 };
 
-// see lib/render/renderUtil.js for DB-specific magic vars, specified in CAP Cds via function
+// see lib/render/renderUtil.js for DB-specific magic vars, specified in CAP CDS  via function
+
+const dateRegEx = /^(-?\d{4})-(\d{1,2})-(\d{1,2})$/;
+//                      YYYY -     MM  -   dd
+const timeRegEx = /^T?(\d{1,2}):(\d{1,2})(?::(\d{1,2}))?(?:Z|[+-]\d{2}(?::\d{2})?)?$/;
+//                  T     HH   :    mm      :    ss         TZD
+// eslint-disable-next-line max-len
+const timestampRegEx = /^(-?\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2})(\.\d{1,7})?)?(?:Z|[+-]\d{2}(?::\d{2})?)?$/;
+//                          YYYY  -  MM   -  dd    T    HH   :   mm     :  ss     . fraction     TZD
+const numberRegEx = /^[ \t]*[-+]?(\d+(\.\d*)?|\.\d+)(e[-+]\d+)?[ \t]*$/i;
 
 /**
  * Patterns for literal token tests and creation.  The value is a map from the
@@ -227,7 +237,7 @@ const quotedLiteralPatterns = {
     test_variant: 'time',
     test_fn: (x) => {
       // Leading `T` allowed in ISO 8601.
-      const match = x.match( /^T?(\d{1,2}):(\d{1,2})(?::(\d{1,2}))?$/ );
+      const match = x.match( timeRegEx );
       return match !== null && checkTime( match[1], match[2], match[3] );
     },
     json_type: 'string',
@@ -235,7 +245,7 @@ const quotedLiteralPatterns = {
   date: {
     test_variant: 'date',
     test_fn: (x) => {
-      const match = x.match( /^(-?\d{4})-(\d{1,2})-(\d{1,2})$/ );
+      const match = x.match( dateRegEx );
       return match !== null && checkDate( match[1], match[2], match[3] );
     },
     json_type: 'string',
@@ -243,8 +253,7 @@ const quotedLiteralPatterns = {
   timestamp: {
     test_variant: 'timestamp',
     test_fn: (x) => {
-      // eslint-disable-next-line max-len
-      const match = x.match( /^(-?\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2})(\.\d{1,7})?)?$/ );
+      const match = x.match( timestampRegEx );
       return match !== null && checkDate( match[1], match[2], match[3] ) &&
         checkTime( match[4], match[5], match[6] );
     },
@@ -259,7 +268,7 @@ const quotedLiteralPatterns = {
   },
   number: {
     test_variant: 'number',
-    test_fn: (x => /^[ \t]*[-+]?(\d+(\.\d*)?|\.\d+)(e[-+]\d+)?[ \t]*$/i.test( x )),
+    test_fn: (x => numberRegEx.test( x )),
     json_type: 'number',
     secondary_json_type: 'string',
   },

package/lib/compiler/checks.js

@@ -777,12 +777,12 @@ function check( model ) {       // = XSN
     // Must have literal or path unless it is a boolean
     if (!anno.literal && !anno.path && getFinalTypeNameOf(elementDecl) !== 'cds.Boolean') {
       if (elementDecl.type && elementDecl.type._artifact.name.absolute) {
-        warning(null, anno.location || anno.name.location, { type: elementDecl.type._artifact },
-                'Expecting a value of type $(TYPE) for the annotation');
+        warning('anno-expecting-value', anno.location || anno.name.location,
+                { '#': 'type', type: elementDecl.type._artifact });
       }
       else {
-        warning(null, anno.location || anno.name.location, {},
-                'Expecting a value for the annotation');
+        warning('anno-expecting-value', anno.location || anno.name.location,
+                { '#': 'std', anno: anno.name.absolute });
       }
 
       return;