@sap/cds-compiler 3.6.2 → 3.7.2

package/lib/checks/onConditions.js

@@ -83,13 +83,16 @@ function validateOnCondition( member, memberName, property, path ) {
           if (_links[j].art.target && !((_links[j].art === member) || ref[j] === '$self' || ref[j] === '$projection' || (validDollarSelf && j === _links.length - 1))) {
             if (_links[j].art.on) {
               // It's an unmanaged association - traversal is always forbidden
-              this.error(null, csnPath, { id, elemref }, 'ON-conditions can\'t follow unmanaged associations, step $(ID) of path $(ELEMREF)');
+              this.error('ref-unexpected-navigation', csnPath, { '#': 'unmanaged', id, elemref });
             }
             else {
               // It's a managed association - access of the foreign keys is allowed
               const nextRef = ref[j + 1].id || ref[j + 1];
-              if (!_links[j].art.keys.some(r => r.ref[0] === nextRef))
-                this.error(null, csnPath, { id, elemref }, 'ON-conditions can only follow managed associations to the foreign keys of the managed association, step $(ID) of path $(ELEMREF)');
+              if (!_links[j].art.keys.some(r => r.ref[0] === nextRef)) {
+                this.error('ref-unexpected-navigation', csnPath, {
+                  '#': 'std', id, elemref, name: nextRef,
+                });
+              }
             }
           }
 
@@ -113,8 +116,8 @@ 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) &&
-             !( /* 1) */ (type.target && type.keys) && validStructuredElement ||
+            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

package/lib/checks/types.js

@@ -1,6 +1,7 @@
 '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!
 
@@ -51,7 +52,11 @@ function checkElementTypeDefinitionHasType( member, memberName, prop, path ) {
   // Computed elements, e.g. "1+1 as foo" in a view don't have a valid type and
   // are skipped here.  References to such columns are checked further below.
   const parent = this.csn.definitions[path[1]];
-  if (!parent.projection && !parent.query && !hasArtifactTypeInformation(member)) {
+
+  // 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')) &&
+      !parent.projection && !parent.query && !hasArtifactTypeInformation(member)) {
     errorAboutMissingType(this.error, path, memberName, true);
     return;
   }

package/lib/checks/validator.js

@@ -12,7 +12,7 @@ const { validateSelectItems } = require('./selectItems');
 const { rejectParamDefaultsInHanaCds, warnAboutDefaultOnAssociationForHanaCds } = require('./defaultValues');
 const validateCdsPersistenceAnnotation = require('./cdsPersistence');
 const checkUsedTypesForAnonymousAspectComposition = require('./managedInType');
-const checkForEmptyOrOnlyVirtual = require('./emptyOrOnlyVirtual');
+const validateHasPersistedElements = require('./hasPersistedElements');
 const checkForHanaTypes = require('./checkForTypes');
 const checkForParams = require('./parameters');
 // forOdata
@@ -30,7 +30,8 @@ const {
   checkTypeIsScalar, checkDecimalScale,
 } = require('./types');
 const {
-  checkPrimaryKey, checkVirtualElement, checkManagedAssoc, checkRecursiveTypeUsage,
+  checkPrimaryKey, checkVirtualElement, checkManagedAssoc,
+  checkRecursiveTypeUsage, rejectAnnotationsOnCalcElement,
 } = require('./elements');
 const checkForInvalidTarget = require('./invalidTarget');
 const { validateAssociationsInItems } = require('./arrayOfs');
@@ -54,6 +55,8 @@ const forRelationalDBMemberValidators
   warnAboutDefaultOnAssociationForHanaCds,
   // sql.prepend/append
   checkSqlAnnotationOnElement,
+  // no temporal annotations on calc elements
+  rejectAnnotationsOnCalcElement,
 ];
 
 const forRelationalDBArtifactValidators
@@ -61,7 +64,7 @@ const forRelationalDBArtifactValidators
   // @cds.persistence has no impact on odata
   validateCdsPersistenceAnnotation,
   // virtual items are not persisted on the db
-  checkForEmptyOrOnlyVirtual,
+  validateHasPersistedElements,
   // sql.prepend/append
   checkSqlAnnotationOnArtifact,
 ];
@@ -254,6 +257,7 @@ function forOdata( csn, that ) {
                        }
                      }
                    ),
+                   // eslint-disable-next-line sonarjs/no-empty-collection
                    forOdataQueryValidators.concat(commonQueryValidators),
                    {
                      skipArtifact: this.isExternalServiceMember,

package/lib/compiler/assert-consistency.js

@@ -72,7 +72,7 @@ const { locationString, hasErrors } = require('../base/messages');
 // Properties that can appear where a type can have type arguments.
 const typeProperties = [
   'type', '$typeArgs', 'length', 'precision', 'scale', 'srid',
-  '_effectiveType',
+  '_effectiveType', '$effectiveSeqNo',
 ];
 
 class InternalConsistencyError extends Error {
@@ -191,8 +191,8 @@ function assertConsistency( model, stage ) {
           test: isDictionary( definition ),
           requires: [ 'kind', 'name' ],
           optional: [
-            'elements', '$autoElement', '$uncheckedElements',
-            '$requireElementAccess', '_effectiveType', '_deps',
+            'elements', '$autoElement', '$uncheckedElements', '_origin',
+            '$requireElementAccess', '_effectiveType', '$effectiveSeqNo', '_deps',
           ],
           schema: {
             kind: { test: isString, enum: [ 'builtin' ] },
@@ -250,18 +250,17 @@ function assertConsistency( model, stage ) {
         schema: { args: { inherits: 'query', test: isArray( query ) } },
         requires: [ 'op', 'location', 'args' ],
         optional: [
-          'quantifier', 'orderBy', 'limit', '_leadingQuery',
-          'name', '$parens', 'kind', '_parent', '_main', '_effectiveType', // in FROM
+          'quantifier', 'orderBy', 'limit', 'name', '$parens', 'kind',
+          '_parent', '_main', '_leadingQuery', '_effectiveType', '$effectiveSeqNo', // in FROM
         ],
       },
       select: {                   // sub query
         requires: [ 'op', 'location', 'from' ],
         optional: [
           'name', '$parens', 'quantifier', 'mixin', 'excludingDict', 'columns', 'elements', '_deps',
-          'where', 'groupBy', 'having', 'orderBy', '$orderBy', 'limit',
-          '_projections', '_block', '_parent', '_main', '_effectiveType', '$expand',
+          'where', 'groupBy', 'having', 'orderBy', '$orderBy', 'limit', '_origin', '_block',
+          '_projections', '_parent', '_main', '_effectiveType', '$effectiveSeqNo', '$expand',
           '$tableAliases', 'kind', '_$next', '_combined', '$inlines', '_status',
-          '_extension', // for unapplied extensions
         ],
       },
       none: { optional: () => true }, // parse error
@@ -285,7 +284,7 @@ function assertConsistency( model, stage ) {
           'elements', '_origin', '_joinParent', '$joinArgsIndex', '$syntax',
           '$parens', '_status', // TODO: only in from
           'scope', '_artifact', '$inferred', 'kind',
-          '_effectiveType',         // TODO:check this
+          '_effectiveType', '$effectiveSeqNo',         // TODO:check this
           '$duplicates', // In JOIN if both sides are the same.
         ],
       },
@@ -293,8 +292,8 @@ function assertConsistency( model, stage ) {
         requires: [ 'query', 'location' ],
         optional: [
           '$parens',
-          'kind', 'name', '_block', '_parent', '_main',
-          '_effectiveType', 'elements', '_origin', '_joinParent', '$joinArgsIndex',
+          'kind', 'name', '_block', '_parent', '_main', 'elements',
+          '_effectiveType', '$effectiveSeqNo', '_origin', '_joinParent', '$joinArgsIndex',
           '$duplicates', // duplicate query in FROM clause
         ],
       },
@@ -340,7 +339,7 @@ function assertConsistency( model, stage ) {
       optional: [
         'path', 'elements', '_outer', '_parent', '_main', '_block', 'kind',
         'scope', '_artifact', '$inferred', '$expand', '$inCycle', '$tableAliases', '_$next',
-        '_effectiveType',           // by propagation
+        '_origin', '_effectiveType', '$effectiveSeqNo',
       ],
     },
     target: {
@@ -373,7 +372,7 @@ function assertConsistency( model, stage ) {
       // required to be set by Core Compiler even with parse errors
       test: isString,
       enum: [
-        'context', 'service', 'entity', 'type', 'aspect', 'const', 'annotation',
+        'context', 'service', 'entity', 'type', 'aspect', 'annotation',
         'element', 'enum', 'action', 'function', 'param', 'key', 'event',
         'annotate', 'extend', '$column',
         'select', '$join', 'mixin',
@@ -393,10 +392,8 @@ function assertConsistency( model, stage ) {
       optional: [
         'location', '$inferred', 'sort', 'nulls',
         'param', 'scope', // for dynamic parameter '?'
-        // through cast() with enum through CSN->XSN
-        // TODO: re-check #9225, this should be directly in the query element,
-        // not inside value, no `enum` inside `cast`!
-        'elements', 'items', 'enum', '$expand', 'target',
+        // A2J wrongly propagates the following into a CAST of the CSN passed to compileX:
+        'elements', 'items', 'enum',
       ],
 
       kind: true,
@@ -515,7 +512,7 @@ function assertConsistency( model, stage ) {
       optional: [
         'enum',
         'elements', 'cardinality', 'target', 'on', 'foreignKeys', 'items',
-        '_outer', '_effectiveType', 'notNull', '_parent',
+        '_outer', '_effectiveType', '$effectiveSeqNo', 'notNull', '_parent',
         '_origin', '_block', '$inferred', '$expand', '$inCycle', '_deps',
         '$syntax',
         '_status', '_redirected',
@@ -550,6 +547,7 @@ function assertConsistency( model, stage ) {
     _artifact: { test: TODO },
     _navigation: { test: TODO },
     _effectiveType: { kind: true, test: TODO },
+    $effectiveSeqNo: { kind: true, test: isNumber },
     _joinParent: { test: TODO },
     $joinArgsIndex: { test: isNumber },
     _outer: { test: TODO },              // for returns/items
@@ -565,20 +563,19 @@ function assertConsistency( model, stage ) {
         '$tableAliases', '$inlines',
       ],
       optional: [
-        '_effectiveType', '$parens',
+        '_effectiveType', '$effectiveSeqNo', '$parens',
         '_deps', '$expand',
         // query specific
         'where', 'columns', 'mixin', 'quantifier', 'offset',
         'orderBy', '$orderBy', 'groupBy', 'excludingDict', 'having',
-        'limit', '_status',
-        '_extension', // for unapplied extensions
+        'limit', '_status', '_origin', '_effectiveType', '$effectiveSeqNo',
       ],
     },
     _leadingQuery: { kind: true, test: TODO },
     $replacement: { kind: true, test: TODO }, // for smart * in queries
-    _origin: { kind: [ 'entity' ], test: TODO },
+    _origin: { kind: true, test: TODO },
     _pathHead: { kind: [ 'element', undefined ], test: TODO }, // column or * (wildcard)
-    _from: { kind: true, test: TODO }, // all table refs necessary to compute elements
+    _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

package/lib/compiler/base.js

@@ -43,14 +43,13 @@ const kindProperties = {
   source: { artifacts: true },  // TODO -> $source
   using: {},
   extend: {
-    isExtension: true,
     noDep: 'special',
     elements: true, /* only for parse-cdl */
     actions: true,  /* only for parse-cdl */
     enum: true,     /* only for parse-cdl */
   },
   annotate: {
-    isExtension: true, noDep: 'special', elements: true, enum: true, actions: true, params: true,
+    noDep: 'special', elements: true, enum: true, actions: true, params: true,
   },
   builtin: {},                  // = CURRENT_DATE, TODO: improve
   $parameters: {},              // $parameters in query entities

package/lib/compiler/builtins.js

@@ -447,11 +447,11 @@ function initBuiltins( model ) {
       const absolute = prefix + name;
       // TODO: reconsider whether to set a type to itself - looks wrong
       const art = {
-        kind: 'type', builtin: true, name: { absolute }, type: { path: [ { id: absolute } ] },
+        kind: 'type', builtin: true, name: { absolute },
       };
-      setProp( art.type, '_artifact', art );
       if (parent)
         parent._subArtifacts[name] = art;
+      setProp( art, '_origin', '' );
       setProp( art, '_effectiveType', art );
       setProp( art, '_deps', [] );
       Object.assign( art, builtins[name] );