@sap/cds-compiler 6.5.0 → 6.6.0

package/CHANGELOG.md

@@ -13,6 +13,40 @@ we might not list every change in its behavior here.
 Productive code should never require a `beta` flag to be set, and
 might use a deprecated flag only for a limited period of time.
 
+## Version 6.6.0 - 2025-12-12
+
+### Added
+
+- compiler:
+  + Support for upcoming ESlint rules (by other team) for Fiori elements annotations.
+  + Namespace `cds.dataproducts` is no longer reserved by the cds-compiler. It is used by the CAP @sap/cds-data-products plugin.
+- for.odata/to.edm(x):
+  + Enumeration symbols are now supported in annotation expression syntax.
+  + For projections and views, the `@hierarchy` annotation now triggers generation of
+    additional Fiori Tree View relevant annotations and fields.
+- for.effective: First non-beta release.
+
+### Changed
+
+- `to.sql`: Annotating a foreign key of an association in a view with a sql-snippet annotation (e.g. `@sql.append`)
+            now results in an error. This is the default behaviour for any element in a view.
+
+### Fixed
+
+- compiler:
+  + Minor fixes for auto-redirections and recompilation with localized data
+    in very rare situations when an aspect definition uses an entity as include.
+  + Don't let “namespaces” prevent the compiler to generate texts/target entities.
+- to.sql: Improve foreign key flattening for various edge cases.
+
+## Version 6.5.2 - 2025-12-02
+
+### Fixed
+
+- to.sql|hdi:
+  + Don't add superfluous (and actually wrong) parentheses around `UNION`s
+  + Don't dump with a specific column expressions in the query after a `UNION`
+
 ## Version 6.5.0 - 2025-11-21
 
 ### Added

package/bin/cdsc.js

@@ -153,7 +153,7 @@ function cdscMain() {
   // Internally, parseCdl/parseOnly are options, so we map the command to it.
   if (cmdLine.command === 'parse') {
     cmdLine.command = 'toCsn';
-    cmdLine.options.toCsn = cmdLine.options.parseCdl;
+    cmdLine.options.toCsn = cmdLine.options.parse || cmdLine.options.parseCdl;
     cmdLine.options.parseCdl = true;
     cmdLine.args.files = [ cmdLine.args.file ];
   }

package/lib/api/main.js

@@ -321,9 +321,6 @@ function forSeal( csn, options, messageFunctions ) {
 function forEffective( csn, options, messageFunctions ) {
   const internalOptions = prepareOptions.for.effective(options);
   internalOptions.transformation = 'effective';
-  // for.effective is still beta mode
-  if (!baseModel.isBetaEnabled(options, 'effectiveCsn'))
-    throw new baseError.CompilerAssertion('effective CSN is only supported with beta flag `effectiveCsn`!');
 
   return forEffectiveInternal(csn, options, internalOptions, messageFunctions);
 }

package/lib/base/builtins.js

@@ -50,7 +50,8 @@ function isInReservedNamespace( absolute ) {
     !absolute.match( /^cds\.foundation(\.|$)/ ) &&
     !absolute.match( /^cds\.outbox(\.|$)/ ) && // Requested by Node runtime
     !absolute.match( /^cds\.core(\.|$)/ ) && // Requested by Node runtime
-    !absolute.match( /^cds\.xt(\.|$)/ ); // Requested by Mtx
+    !absolute.match( /^cds\.xt(\.|$)/ ) && // Requested by Mtx
+    !absolute.match( /^cds\.dataproducts(\.|$)/ ); // Requested by @sap/cds-data-products
 }
 
 /**

package/lib/base/message-registry.js

@@ -735,7 +735,6 @@ const centralMessageTexts = {
   },
   'ref-undefined-art': {
     std: 'No artifact has been found with name $(ART)',
-    namespace: 'No artifact has been found with name $(ART) which can be extended with annotations',
     localized: 'Can\'t extend localized definitions, only annotate them using an $(KEYWORD) statement',
   },
   // TODO: proposal 'No definition found for $(NAME)',
@@ -959,28 +958,28 @@ const centralMessageTexts = {
   'ext-undefined-art-sec': 'No artifact has been found with name $(ART)',
   'ext-undefined-element': {
     std: 'Element $(NAME) has not been found',
-    element: 'Artifact $(ART) has no element $(NAME)',
-    enum: 'Artifact $(ART) has no enum $(NAME)',
-    returns: 'Return value of $(ART) has no element $(NAME)',
-    'enum-returns': 'Return value of $(ART) has no enum $(NAME)',
+    enum: 'Enum symbol $(NAME) has not been found',
+    returns: 'The return value has no element $(NAME)',
+    'enum-returns': 'The return value has no enum $(NAME)',
+  },
+  'ext-undefined-element-sec': {
+    std: 'Element $(NAME) has not been found',
+    enum: 'Enum symbol $(NAME) has not been found',
+    returns: 'The return value has no element $(NAME)',
+    'enum-returns': 'The return value has no enum $(NAME)',
   },
-  'ext-undefined-element-sec': 'Element $(NAME) has not been found',
   'ext-undefined-key': 'Foreign key $(NAME) has not been found',
   'ext-undefined-action': {
-    std: 'Action $(ART) has not been found',
-    action: 'Artifact $(ART) has no action $(NAME)',
+    std: 'Action $(NAME) has not been found',
   },
   'ext-undefined-action-sec': {
-    std: 'Action $(ART) has not been found',
-    action: 'Artifact $(ART) has no action $(NAME)',
+    std: 'Action $(NAME) has not been found',
   },
   'ext-undefined-param': {
-    std: 'Parameter $(ART) has not been found',
-    param: 'Artifact $(ART) has no parameter $(NAME)',
+    std: 'Parameter $(NAME) has not been found',
   },
   'ext-undefined-param-sec': {
-    std: 'Parameter $(ART) has not been found',
-    param: 'Artifact $(ART) has no parameter $(NAME)',
+    std: 'Parameter $(NAME) has not been found',
   },
 
   // annotation checks against their definition

package/lib/base/model.js

@@ -24,7 +24,6 @@ const availableBetaFlags = {
   mapAssocToJoinCardinality: true, // only SAP HANA HEX engine supports it
   enableUniversalCsn: true,
   odataTerms: true,
-  effectiveCsn: true,
   tenantVariable: true,
   calcAssoc: true,
   temporalRawProjection: true,

package/lib/checks/sql-snippets.js

@@ -38,6 +38,14 @@ function checkSqlAnnotationOnElement( member, memberName, prop, path ) {
       checkValidAnnoValue(member, '@sql.append', path, this.error, this.options);
     }
   }
+
+  // recursive check for keys
+  if (member.keys) {
+    for (const keyName of Object.keys(member.keys)) {
+      const key = member.keys[keyName];
+      checkSqlAnnotationOnElement.call(this, key, keyName, prop, path.concat([ 'keys', keyName ]));
+    }
+  }
 }
 
 /**

package/lib/checks/validator.js

@@ -93,7 +93,6 @@ const forRelationalDBCsnValidators = [
   navigationIntoMany,
   checkPathsInStoredCalcElement,
   featureFlags,
-  checkAndRemoveEnums,
 ];
 /**
  * @type {Array<(query: CSN.Query, path: CSN.Path) => void>}
@@ -200,8 +199,11 @@ function _validate( csn, that,
 function getDBCsnValidators( options ) {
   const validations = [ ...forRelationalDBCsnValidators ];
 
-  if (options.transformation !== 'effective')
+  if (options.transformation !== 'effective') {
+    validations.push(checkAndRemoveEnums);
     validations.push(checkForParams.csnValidator);
+  }
+
   if (options.sqlDialect === 'h2' || options.sqlDialect === 'postgres')
     validations.push(checkForHanaTypes);
 

package/lib/compiler/define.js

@@ -140,7 +140,6 @@ const {
   initDollarSelf,
   initDollarParameters,
   initBoundSelfParam,
-  storeExtension,
   dependsOnSilent,
   pathName,
   targetCantBeAspect,
@@ -178,7 +177,7 @@ function define( model ) {
   Object.assign( model.$functions, {
     shuffleDict,
     shuffleArray,
-    initArtifact,
+    initMainArtifact,
     initMembers,                // for finalize-parser-cdl.js
     targetIsTargetAspect,
     checkRedefinition,
@@ -213,7 +212,7 @@ function define( model ) {
     // Phase 2:
     for (const name of sourceNames)
       initNamespaceAndUsing( model.sources[name] );
-    dictForEach( model.definitions, initArtifact );
+    dictForEach( model.definitions, initMainArtifact );
     dictForEach( model.vocabularies, initVocabulary );
     dictForEach( model.$collectedExtensions, e => e._extensions.forEach( initExtension ) );
 
@@ -254,7 +253,7 @@ function define( model ) {
     if (src.$frontend !== 'json') { // CDL input
       // TODO: set _block to builtin
       if (src.artifacts) {
-        // addArtifact() adds usings to src.artifacts: shuffleDict must be assigned first
+        // addBlockArtifact() adds usings to src.artifacts: shuffleDict must be assigned first
         src.artifacts = shuffleDict( src.artifacts );
         addPathPrefixes( src.artifacts, prefix ); // before addUsing
       }
@@ -265,14 +264,14 @@ function define( model ) {
         shuffleArray( src.usings ).forEach( u => addUsing( u, src ) );
       if (namespace?.id)        // successfully set a full name for namespace
         addNamespace( namespace, src );
-      if (src.artifacts) {      // addArtifact needs usings for context extensions
+      if (src.artifacts) {      // addBlockArtifact needs usings for context extensions
         src.artifacts = shuffleDict( src.artifacts );
-        dictForEach( src.artifacts, a => addArtifact( a, src, prefix ) );
+        dictForEach( src.artifacts, a => addBlockArtifact( a, src, prefix ) );
       }
     }
     else if (src.definitions) {      // CSN input
       prefix = '';                   // also for addVocabulary() below
-      dictForEach( shuffleDict( src.definitions ), def => addDefinition( def, src, prefix ) );
+      dictForEach( shuffleDict( src.definitions ), def => addMainArtifact( def, src, prefix ) );
     }
     if (src.vocabularies) {
       if (!model.vocabularies)
@@ -284,7 +283,7 @@ function define( model ) {
     }
   }
 
-  function addDefinition( art, block, prefix ) {
+  function addMainArtifact( art, block, prefix ) {
     setLink( art, '_block', block );
     initExprAnnoBlock( art, block );
     art.name.id ??= prefix + pathName( art.name.path );
@@ -384,15 +383,15 @@ function define( model ) {
       $inferred: 'namespace',
     };
   }
-  function addArtifact( art, block, prefix ) {
+  function addBlockArtifact( art, block, prefix ) {
     if (art.kind === 'using')
       return;
-    addDefinition( art, block, prefix );
+    addMainArtifact( art, block, prefix );
     if (art.artifacts) {
       const p = `${ art.name.id }.`;
       // path prefixes (usings) must be added before extensions in artifacts:
       addPathPrefixes( art.artifacts, p );
-      dictForEach( art.artifacts, a => addArtifact( a, art, p ) );
+      dictForEach( art.artifacts, a => addBlockArtifact( a, art, p ) );
     }
     if (art.extensions) {       // requires using to be known!
       art.extensions.forEach( e => e.name && addExtension( e, art ) );
@@ -426,7 +425,7 @@ function define( model ) {
     // eslint-disable-next-line no-multi-assign
     ext.$effectiveSeqNo = model.$blocks[absolute] = (model.$blocks[absolute] || 0) + 1;
     const prefix = `${ absolute }.`;
-    dictForEach( ext.artifacts, a => addArtifact( a, ext, prefix ) );
+    dictForEach( ext.artifacts, a => addBlockArtifact( a, ext, prefix ) );
   }
 
   function addVocabulary( vocab, block, prefix ) {
@@ -484,7 +483,7 @@ function define( model ) {
   }
 
   // Phase 2 ("init"), top-level & main -----------------------------------------
-  // Functions called from top-level: initNamespaceAndUsing(), initArtifact(),
+  // Functions called from top-level: initNamespaceAndUsing(), initMainArtifact(),
   // initVocabulary(), initExtension()
 
   function initNamespaceAndUsing( src ) {
@@ -525,11 +524,11 @@ function define( model ) {
     }
   }
 
-  function initArtifact( art, reInit = false ) {
+  function initMainArtifact( art, reInit = false ) {
     if (!reInit)                // not for auto-exposed entity
       initArtifactParentLink( art, model.definitions );
     checkRedefinition( art );
-    initDollarSelf( art );      // $self
+    initDollarSelf( art );      // $self, TODO: also for 'namespace'?
     initMembers( art );
     if (art.params)
       initDollarParameters( art ); // $parameters
@@ -608,7 +607,7 @@ function define( model ) {
   }
 
   // TODO: message ids
-  // Called by initArtifact() and initVocabulary() and for members
+  // Called by initMainArtifact() and initVocabulary() and for members
   function checkRedefinition( art ) {
     if (art.kind === 'annotate' || art.kind === 'extend') // move this check to call in extend.js?
       return; // extensions are merged into a super-annotate; $duplicates are only kept for LSP
@@ -983,9 +982,10 @@ function define( model ) {
           initExprForQuery( col.value, parent );
         if (col.expand || col.inline)
           initSelectItems( col, null, user ); // TODO: use col, remove 3rd param?
-      }
 
-      initCdlTypeCast( col, parent );
+        initMembers( col );      // with #13933, TODO: only for enums
+        checkCdlTypeCast( col );
+      }
     }
 
     if (hasItems && !wildcard && parent.excludingDict && !options.$recompile) {
@@ -1038,13 +1038,7 @@ function define( model ) {
     return col.name.id;
   }
 
-  function initCdlTypeCast( col, parent ) {
-    if (col.val)
-      return; // e.g. '*' column
-
-    setMemberParent( col, col.name, parent );
-    initMembers( col );
-
+  function checkCdlTypeCast( col ) { // with #13933:
     // We don't allow CDL-style casts to anonymous structures.  We reject it already here
     // and not in checks.js to ensure that it's rejected in parseCdl.
     // TODO: via <guard> in CdlGrammar.g4
@@ -1052,7 +1046,7 @@ function define( model ) {
       error( 'type-invalid-cast', [ (col.elements[$location] ?? col.location), col ],
              { '#': 'to-inline-structure' } );
     }
-    else if (col.expand && (col.type || col.elements || col.items)) {
+    else if (col.expand && (col.type || col.items)) {
       const loc = (col.type?.location || col.elements?.[$location] ||
                    col.items?.location || col.location);
       error( 'type-invalid-cast', [ loc, col ], { '#': 'expand' } );
@@ -1068,7 +1062,7 @@ function define( model ) {
    *
    * Param `initExtensions` is for parse.cdl - TODO delete
    */
-  function initMembers( parent, initExtensions = false ) {
+  function initMembers( parent ) {
     const block = parent._block;
     let obj = initItemsLinks( parent, block );
     initExprAnnoBlock( parent, block );
@@ -1086,109 +1080,102 @@ function define( model ) {
         error( 'type-unexpected-on-condition', [ obj.on.location, parent ] );
         delete obj.on;          // continuation semantics: not specified
       }
-      if (targetAspect.elements)
-        initAnonymousAspect();
+      if (targetAspect.elements) // eslint-disable-next-line no-multi-assign
+        parent = obj = initAnonymousAspect( parent, obj, targetAspect );
     }
-    forEachInOrder( obj, 'elements', init );
-    forEachGeneric( obj, 'enum', init );
-    forEachInOrder( obj, 'foreignKeys', init );
-    forEachGeneric( parent, 'actions', init );
-    forEachInOrder( parent, 'params', init );
+    forEachInOrder( obj, 'elements', (...args) => initArtifact( parent, ...args ) );
+    forEachGeneric( obj, 'enum', (...args) => initArtifact( parent, ...args ) );
+    forEachInOrder( obj, 'foreignKeys', (...args) => initArtifact( parent, ...args ) );
+    forEachGeneric( parent, 'actions', (...args) => initArtifact( parent, ...args ) );
+    forEachInOrder( parent, 'params', (...args) => initArtifact( parent, ...args ) );
 
     const { returns } = parent;
     if (returns) {
       const { kind } = parent;
       returns.kind = (kind === 'extend' || kind === 'annotate') ? kind : 'param';
-      init( returns, '' );      // '' is special name for returns parameter
+      initArtifact( parent, returns, '' ); // '' is special name for returns parameter
     }
-    return;
-
-    function initAnonymousAspect() {
-      // TODO: main?
-      const inEntity = parent._main?.kind === 'entity';
-      // TODO: also allow indirectly (component in component in entity)?
-      setLink( targetAspect, '_outer', obj );
-      setLink( targetAspect, '_parent', parent._parent );
-      setLink( targetAspect, '_main', null ); // for name resolution
-
-      parent = targetAspect;
-      targetAspect.kind = 'aspect';   // TODO: probably '$aspect' to detect
-      setLink( targetAspect, '_block', block );
-      initDollarSelf( targetAspect );
-      // allow ref of up_ in anonymous aspect inside entity
-      // (TODO: complain if used and the managed composition is included into
-      // another entity - might induce auto-redirection):
-      if (inEntity && !targetAspect.elements.up_) {
-        const up = {
-          name: { id: 'up_' },
-          kind: '$navElement',
-          location: obj.location,
-        };
-        setLink( up, '_parent', targetAspect );
-        setLink( up, '_main', targetAspect ); // used on main artifact
-        // recompilation case: both target and targetAspect → allow up_ in that case, too:
-        const name = obj.target && resolveUncheckedPath( obj.target, 'target', obj );
-        const entity = name && model.definitions[name];
-        if (entity && entity.elements)
-          setLink( up, '_origin', entity.elements.up_ );
-        // processAspectComposition/expand() sets _origin to element of
-        // generated target entity
-        targetAspect.$tableAliases.up_ = up;
-      }
-      obj = targetAspect;
+  }
+
+  function initAnonymousAspect( parent, obj, targetAspect ) {
+    // TODO: main?
+    const inEntity = parent._main?.kind === 'entity';
+    // TODO: also allow indirectly (component in component in entity)?
+    setLink( targetAspect, '_outer', obj );
+    setLink( targetAspect, '_parent', parent._parent );
+    setLink( targetAspect, '_main', null ); // for name resolution
+
+    targetAspect.kind = 'aspect';   // TODO: probably '$aspect' to detect
+    setLink( targetAspect, '_block', parent._block );
+    initDollarSelf( targetAspect );
+    // allow ref of up_ in anonymous aspect inside entity
+    // (TODO: complain if used and the managed composition is included into
+    // another entity - might induce auto-redirection):
+    if (inEntity && !targetAspect.elements.up_) {
+      const up = {
+        name: { id: 'up_' },
+        kind: '$navElement',
+        location: obj.location,
+      };
+      setLink( up, '_parent', targetAspect );
+      setLink( up, '_main', targetAspect ); // used on main artifact
+      // recompilation case: both target and targetAspect → allow up_ in that case, too:
+      const name = obj.target && resolveUncheckedPath( obj.target, 'target', obj );
+      const entity = name && model.definitions[name];
+      if (entity && entity.elements)
+        setLink( up, '_origin', entity.elements.up_ );
+      // processAspectComposition/expand() sets _origin to element of
+      // generated target entity
+      targetAspect.$tableAliases.up_ = up;
     }
+    return targetAspect;
+  }
 
-    function init( elem, name, prop ) {
-      if (!elem.kind)           // wrong CSN input
-        elem.kind = dictKinds[prop];
-      if (!elem.name && !elem._outer) {
-        const ref = elem.targetElement || elem.kind === 'element' && elem.value;
-        if (ref && ref.path) {
-          elem.name = Object.assign( { $inferred: 'as' },
-                                     ref.path[ref.path.length - 1] );
-        }
-        else {                  // RETURNS, parser robustness
-          elem.name = { id: name, location: elem.location };
-        }
+  function initArtifact( parent, elem, name, prop ) {
+    if (!elem.kind)           // wrong CSN input
+      elem.kind = dictKinds[prop];
+    if (!elem.name && !elem._outer) {
+      const ref = elem.targetElement || elem.kind === 'element' && elem.value;
+      if (ref && ref.path) {
+        elem.name = Object.assign( { $inferred: 'as' },
+                                   ref.path[ref.path.length - 1] );
       }
-      // if (!kindProperties[ elem.kind ]) console.log(elem.kind,elem.name)
-      if ((elem.kind === 'extend' || elem.kind === 'annotate') && !initExtensions) {
-        storeExtension( elem, name, prop, parent, block );
-        return;
+      else {                  // RETURNS, parser robustness
+        elem.name = { id: name, location: elem.location };
       }
+    }
 
-      const bl = elem._block || block;
-      setLink( elem, '_block', bl );
+    if (!elem._block)
+      setLink( elem, '_block', parent._block );
 
-      // don't dump with `entity T {}; extend T with { extend e {}; e {}; e {} };`:
-      setMemberParent( elem, name, parent );
-      checkRedefinition( elem );
-      initMembers( elem, initExtensions );
-      if (elem.kind === 'action' || elem.kind === 'function')
-        initBoundSelfParam( elem.params, elem._main );
+    // don't dump with `entity T {}; extend T with { extend e {}; e {}; e {} };`:
+    setMemberParent( elem, name, parent );
+    checkRedefinition( elem );
+    initMembers( elem );
+    if (elem.kind === 'action' || elem.kind === 'function')
+      initBoundSelfParam( elem.params, elem._main );
 
-      // for a correct home path, setMemberParent needed to be called
+    // for a correct home path, setMemberParent needed to be called
 
-      if (!elem.value || elem.kind !== 'element' ||
-          elem.$syntax === 'enum' && parent.kind === 'extend') // ambiguous in parse-cdl
-        return;
-      // -> it's a calculated element
-      if (!elem.type && elem.value.type) {  // top-level CAST( expr AS type )
-        if (!elem.target)
-          elem.type = { ...elem.value.type, $inferred: 'cast' };
-      }
-      elem.$syntax = 'calc';
-      // TODO: it is not just "syntax" - maybe better test for `$calcDepElement`?
-      createAndLinkCalcDepElement( elem );
-
-      // Special case (hack) for calculated elements that use composition+filter:
-      // See "Notes on `$enclosed`" in `ExposingAssocWithFilter.md` for details.
-      // TODO: hm, only for inferred type - then just do not infer it in that case
-      if (elem.target && elem.value.path?.[elem.value.path.length - 1]?.where) {
-        delete elem.type;
-        delete elem.on;
-        delete elem.target;
-      }
+    if (!elem.value || elem.kind !== 'element' ||
+        elem.$syntax === 'enum' && parent.kind === 'extend') // ambiguous in parse-cdl
+      return;
+    // -> it's a calculated element
+    if (!elem.type && elem.value.type) {  // top-level CAST( expr AS type )
+      if (!elem.target)
+        elem.type = { ...elem.value.type, $inferred: 'cast' };
+    }
+    elem.$syntax = 'calc';
+    // TODO: it is not just "syntax" - maybe better test for `$calcDepElement`?
+    createAndLinkCalcDepElement( elem );
+
+    // Special case (hack) for calculated elements that use composition+filter:
+    // See "Notes on `$enclosed`" in `ExposingAssocWithFilter.md` for details.
+    // TODO: hm, only for inferred type - then just do not infer it in that case
+    if (elem.target && elem.value.path?.[elem.value.path.length - 1]?.where) {
+      delete elem.type;
+      delete elem.on;
+      delete elem.target;
     }
   }