@sap/cds-compiler 6.6.2 → 6.7.2

package/CHANGELOG.md

@@ -1,4 +1,4 @@
-# ChangeLog for cds compiler and backends
+# Changelog
 
 <!-- markdownlint-disable MD024 -->
 <!-- markdownlint-disable MD004 -->
@@ -13,6 +13,42 @@ 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.7.2 - 2026-02-04
+
+### Fixed
+
+- **compiler:** Just issue warning for `using` declaration referring to nothing
+  (fixes regression introduced with v6.7.0 if there is a file containing
+  a `namespace` declaration, but no definitions)
+- **effective:** clean up internal Symbols from meta section
+- **sql:** clean up internal Symbols from meta section
+
+## Version 6.7.1 - 2026-01-28
+
+### Fixed
+
+- compiler: Properly accept aspects as composition targets in an `extend`
+  (fixes regression introduced with v6.7.0)
+
+## Version 6.7.0 - 2026-01-23
+
+### Added
+
+- to.hdi: Support .hdbprojectionview for Data Product Production
+
+### Changed
+
+- compiler: Change internal processing sequence (extensions and entity generation) for
+    potentially upcoming compiler features; messages for erroneous models might differ slightly
+
+- for.odata/to.edm(x): Enhancements for Fiori Tree Views: support managed associations with explicit foreign keys,
+    raise messages when the `@hierarchy` annotation cannot be applied.
+
+### Fixed
+
+- to.sql: portable hana functions `*_between` with dates
+
+
 ## Version 6.6.2 - 2026-01-16
 
 ### Fixed

package/bin/cdsc.js

@@ -11,6 +11,8 @@
 // For recursive *.cds expansion, use
 //   cdsc $(find . -name '*.cds' -type f)
 
+// Remark: for LSP support output, use `node test/lsp/lsp.crawler.js FILE.cds`
+
 'use strict';
 
 /* eslint no-console:off */

package/bin/cdsse.js

@@ -126,7 +126,7 @@ function find( err, buf ) {
     const vn = messageAt( messages, 'validNames', off.col ) || Object.create(null);
     let art = vn[buf.substring( off.prefix, off.cursor )];
     while (art?._origin && art.$inferred && art._effectiveType ||
-           autoNavigateKinds[art.kind]?.( art ))
+           autoNavigateKinds[art?.kind]?.( art ))
       art = art._origin || art.extern._artifact;
     // TODO: set _origin in using proxies
     // TODO: why no _effectiveType for $navElement ?

package/lib/base/message-registry.js

@@ -160,10 +160,12 @@ const centralMessages = {
   'type-ambiguous-target': { severity: 'Warning' },
 
   'ref-unexpected-autoexposed': { severity: 'Error' },
+  'ref-unexpected-many-expand': { severity: 'Error' },
   'ref-unexpected-many-navigation': { severity: 'Error' },
   // Published! Used in @sap/cds-lsp; if renamed, add to oldMessageIds and contact colleagues
   'ref-undefined-art':    { severity: 'Error' },
   'ref-undefined-def':    { severity: 'Error' },
+  'ref-undefined-using':  { severity: 'Warning' },
   'ref-undefined-var':    { severity: 'Error' },
   'ref-undefined-element': { severity: 'Error' },
   'anno-undefined-element': { severity: 'Error' },
@@ -207,6 +209,7 @@ const centralMessages = {
   'syntax-unexpected-many-one': { severity: 'Error' },
   'syntax-deprecated-ref-virtual': { severity: 'Error' },
   'syntax-unexpected-reserved-word': { severity: 'Error', configurableFor: true },
+  'syntax-unexpected-with-returns': { severity: 'Warning' },   // errorFor: [ 'v8' ] }, or v7?
   'syntax-unknown-escape': { severity: 'Error', configurableFor: true },
   'syntax-unsupported-masked': { severity: 'Error', configurableFor: 'deprecated' },
   'syntax-unexpected-sql-clause': { severity: 'Error' }, // TODO: configurableFor:'tests'?
@@ -737,6 +740,7 @@ const centralMessageTexts = {
     std: 'No artifact has been found with name $(ART)',
     localized: 'Can\'t extend localized definitions, only annotate them using an $(KEYWORD) statement',
   },
+  'ref-undefined-using': 'There is no definition in the model whose name starts with $(ART)',
   // TODO: proposal 'No definition found for $(NAME)',
   'ref-undefined-element': {
     std: 'Element $(ART) has not been found',
@@ -785,6 +789,10 @@ const centralMessageTexts = {
     std: '$(ART) can\'t be extended because it originates from an include',
     elements: '$(ART) can\'t be extended by elements/enums because it originates from an include',
   },
+  'ref-unexpected-many-expand': {
+    std: 'Unexpected expand with to-many association',
+    composition: 'Unexpected expand with to-many composition',
+  },
   'ref-unexpected-many-navigation': {
     std: 'Unexpected navigation into arrayed structure',
   },
@@ -914,9 +922,6 @@ const centralMessageTexts = {
     min: 'Expecting argument $(PROP) for type $(TYPE) to be greater than or equal to $(NUMBER)',
     'incorrect-type': 'Expected $(NAMES) for argument $(PROP), but found $(CODE)',
   },
-  'type-unexpected-foreign-keys': 'A managed aspect composition can\'t have a foreign keys specification. Use composition-of-entity or remove foreign keys',
-  'type-unexpected-on-condition': 'A managed aspect composition can\'t have a specified ON-condition. Use composition-of-entity or remove the ON-condition',
-
   'type-invalid-items': {
     std: 'Unexpected $(PROP)', // unused
     nested: 'Unexpected $(PROP) inside $(PROP)',
@@ -1060,10 +1065,9 @@ const centralMessageTexts = {
 
   'def-invalid-texts-aspect': {
     std: '$(ART) is not valid', // unused
-    'no-aspect': '$(ART) must be an aspect',
-    key: '$(ART) must be a key',
-    'no-key': '$(ART) must not be key',
-    missing: '$(ART) must have an element $(NAME)',
+    'no-aspect': '$(ART) must be an aspect with elements',
+    key: 'Element $(NAME) of $(ART) must be a key',
+    missing: '$(ART) must have a direct element $(NAME)',
   },
   'def-invalid-element-type': {
     std: 'Element $(ELEMREF) of $(ART) must be of type $(TYPE)',
@@ -1114,6 +1118,8 @@ const centralMessageTexts = {
   'ref-invalid-target': {
     std: 'Expecting an entity as target',
     composition: 'Expecting an entity or aspect as composition target',
+    on: 'Expecting an entity as composition target when followed by an ON-condition',
+    keys: 'Expecting an entity as composition target when followed by foreign keys',
     bare: 'Expecting the target aspect to have elements',
     aspect: 'Expecting an aspect in property $(PROP)', // `targetAspect` in CSN input
     redirected: 'Expecting an entity as target; a target aspect can\'t be specified for redirections',

package/lib/base/model.js

@@ -30,7 +30,6 @@ const availableBetaFlags = {
   v7preview: true,
   rewriteAnnotationExpressionsViaType: true,
   sqlServiceDummies: true,
-  projectionViews: true,
   // disabled by --beta-mode
   nestedServices: false,
 };
@@ -119,72 +118,6 @@ 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 );
-}
-
-/**
- * Apply function `callback` to all members of object `obj` (main artifact or
- * parent member).  Members are considered those in dictionaries `elements`,
- * `enum`, `actions` and `params` of `obj`, `elements` and `enums` are also
- * searched inside property `items` (array of).  See function `forEachGeneric`
- * for details.
- *
- * @param {XSN.Artifact} construct
- * @param {(member: XSN.Artifact, memberName: string, prop: string) => void} callback
- * @param {XSN.Artifact} [target]
- */
-function forEachMember( construct, callback, target ) {
-  let obj = construct;
-  while (obj.items)
-    obj = obj.items;
-  forEachGeneric( target || obj, 'elements', callback );
-  forEachGeneric( obj, 'enum', callback );
-  forEachGeneric( obj, 'foreignKeys', callback );
-  forEachGeneric( construct, 'actions', callback );
-  forEachGeneric( construct, 'params', callback );
-  if (construct.returns)
-    callback( construct.returns, '', 'params' );
-}
-
-/**
- * Same as forEachMember, but inside each member, calls itself recursively, i.e.
- * sub members are traversed as well.
- *
- * @param {XSN.Artifact} construct
- * @param {(member: XSN.Artifact, memberName: string, prop: string) => void} callback
- * @param {XSN.Artifact} [target]
- */
-function forEachMemberRecursively( construct, callback, target ) {
-  forEachMember( construct, ( member, memberName, prop ) => {
-    callback( member, memberName, prop );
-    // Descend into nested members, too
-    forEachMemberRecursively( member, callback );
-  }, target);
-}
-
-// Apply function `callback` to all objects in dictionary `dict`, including all
-// duplicates (found under the same name).  Function `callback` is called with
-// the following arguments: the object, the name, and - if it is a duplicate -
-// the array index and the array containing all duplicates.
-function forEachGeneric( obj, prop, callback ) {
-  const dict = obj[prop];
-  for (const name in dict) {
-    obj = dict[name];
-    const { $duplicates } = obj;
-    callback( obj, name, prop );
-    if (Array.isArray($duplicates)) // redefinitions
-      $duplicates.forEach( o => callback( o, name, prop ) );
-  }
-}
-
-const forEachInOrder = forEachGeneric;
-
 /**
  * Like `obj.prop = value`, but not contained in JSON / CSN
  * It's important to set enumerable explicitly to false (although 'false' is the default),
@@ -208,10 +141,5 @@ module.exports = {
   availableBetaFlags,
   isDeprecatedEnabled,
   checkRemovedDeprecatedFlags,
-  forEachDefinition,
-  forEachMember,
-  forEachMemberRecursively,
-  forEachGeneric,
-  forEachInOrder,
   setProp,
 };

package/lib/checks/elements.js

@@ -129,7 +129,7 @@ function checkManagedAssoc( member ) {
   // Special case for "--with-mocks" of the cds cli: For testing databases such as H2 and SQLite, we allow
   // associations with neither on-condition nor foreign keys if the CSN is mocked.
   // See #13916 for details.
-  const allowForMocked = this.csn._mocked && (this.options.sqlDialect === 'h2' || this.options.sqlDialect === 'sqlite');
+  const allowForMocked = this.csn._mocked && (this.options.sqlDialect in { sqlite: 1, h2: 1, plain: 1 });
 
   const isPersisted = !hasPersistenceSkipAnnotation(this.artifact) && !this.artifact['@cds.persistence.exists'];
   if (isPersisted && !allowForMocked && !member.keys && (targetMax === '*' || Number(targetMax) > 1) && this.options.transformation === 'sql') {

package/lib/checks/featureFlags.js

@@ -2,7 +2,7 @@
 
 const { setProp } = require('../base/model');
 const { featureFlags } = require('../transform/featureFlags');
-const { isSqlService, isDummyService, isDataProductService } = require('../transform/db/processSqlServices');
+const { isSqlService, isDummyService, isDataProductProductionService } = require('../transform/db/processSqlServices');
 
 /**
  *
@@ -33,7 +33,7 @@ module.exports = {
     if (isDummyService(artifact, this.options))
       setFeatureFlag( '$dummyService' ).call(this);
 
-    if (isDataProductService(artifact, this.options))
+    if (isDataProductProductionService(artifact, this.options))
       setFeatureFlag( '$dataProductService' ).call(this);
   },
 };

package/lib/checks/manyExpand.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const { applyTransformationsOnNonDictionary } = require('../model/csnUtils');
+
+/**
+ * Check for nested projections (expand) on to-many associations or compositions.
+ * Nested projections are only valid for to-one relationships.
+ *
+ * @param {object} parent Object with the expression as a property
+ * @param {string} propOnParent Name of the expression property on parent
+ * @param {Array} _e Expression to check (unused)
+ * @param {CSN.Path} path
+ */
+function expandToMany( parent, propOnParent, _e, path ) {
+  applyTransformationsOnNonDictionary(parent, propOnParent, {
+    expand: (_parent, _prop, _expand, _path) => {
+      const last = _parent._links?.at(-1).art;
+      if (last?.cardinality && last.cardinality.max !== 1) {
+        this.message('ref-unexpected-many-expand', _path,
+                     { '#': last.type === 'cds.Composition' ? 'composition' : 'std' });
+      }
+    },
+  }, null, path);
+}
+
+module.exports = {
+  columns: expandToMany,
+};

package/lib/checks/validator.js

@@ -12,6 +12,7 @@ const { validateSelectItems } = require('./selectItems');
 const { rejectParamDefaultsInHanaCds, warnAboutDefaultOnAssociationForHanaCds } = require('./defaultValues');
 const validateCdsPersistenceAnnotation = require('./cdsPersistence');
 const navigationIntoMany = require('./manyNavigations');
+const expandToMany = require('./manyExpand');
 const checkUsedTypesForAnonymousAspectComposition = require('./managedInType');
 const validateHasPersistedElements = require('./hasPersistedElements');
 const checkForHanaTypes = require('./checkForTypes');
@@ -91,6 +92,7 @@ const forRelationalDBCsnValidators = [
   existsMustNotStartWithDollarSelf,
   assertFilterOfExists,
   navigationIntoMany,
+  expandToMany,
   checkPathsInStoredCalcElement,
   featureFlags,
 ];

package/lib/compiler/assert-consistency.js

@@ -104,7 +104,7 @@ function assertConsistency( model, stage ) {
         '$internal',
         '$compositionTargets',
         '$collectedExtensions',
-        '_entities', '$entity',
+        '_entities',
         '$blocks',
         '$messageFunctions',
         '$functions',
@@ -407,9 +407,8 @@ function assertConsistency( model, stage ) {
     func: { test: TODO },
     suffix: { test: TODO },
     kind: {
-      isRequired: !stageParser && (() => true),
+      isRequired: () => true,   // required even with parse or other errors
       kind: true,
-      // required to be set by Core Compiler even with parse errors
       test: isString,
       enum: [
         'context', 'service', 'entity', 'type', 'aspect', 'annotation',
@@ -675,7 +674,6 @@ function assertConsistency( model, stage ) {
     _status: { kind: true, test: TODO },    // TODO: $status
     _projections: { kind: true, test: TODO },
     _complexProjections: { kind: true, test: TODO }, // for projected paths with filters
-    $entity: { kind: true, test: TODO },
     _entities: { test: TODO },
     $compositionTargets: { test: isDictionary( isBoolean ) },
     $collectedExtensions: { test: TODO },
@@ -684,6 +682,7 @@ function assertConsistency( model, stage ) {
     // for implicit redirection - direct and indirect query sources of simple
     // projections/views without @(cds.redirection.target: false):
     _ancestors: { kind: [ 'type', 'entity' ], test: isArray( TODO ) },
+    _entityIncludes: { kind: [ 'entity' ], test: isArray( TODO ) },
     // for implicit redirection - maps service name to simple projections/views
     // in that service which have the current artifact in _ancestors
     // (it can contain the artifact itself with no/failed autoexposure):

package/lib/compiler/base.js

@@ -134,8 +134,16 @@ function getMemberNameProp( elem, kind ) {
   throw new CompilerAssertion( `Member not found in parent properties ${ Object.keys( obj ).join( '+' ) }` );
 }
 
+/**
+ * Return true if an element's `value` is also a valid (recommended) enum value.
+ */
+function isValidEnumValue( value ) {
+  return !value || !value.stored && typeof value.val in { string: 1, number: 1 };
+}
+
 module.exports = {
   dictKinds,
   kindProperties,
   getArtifactName,
+  isValidEnumValue,
 };

package/lib/compiler/builtins.js

@@ -8,7 +8,7 @@
 'use strict';
 
 const { builtinLocation } = require('../base/location');
-const { setLink: setProp } = require('./utils');
+const { setLink } = require('./utils');
 const { isBetaEnabled } = require('../base/model');
 
 // TODO: make type parameters a dict
@@ -395,7 +395,7 @@ function initBuiltins( model ) {
       builtin,
       location: builtinLocation(),
     };
-    setProp( art, '_subArtifacts', Object.create( null ) );
+    setLink( art, '_subArtifacts', Object.create( null ) );
     return art;
   }
 
@@ -418,9 +418,8 @@ function initBuiltins( model ) {
       };
       if (parent)
         parent._subArtifacts[name] = art;
-      setProp( art, '_origin', '' );
-      setProp( art, '_effectiveType', art );
-      setProp( art, '_deps', [] );
+      setLink( art, '_origin', '' );
+      setLink( art, '_deps', [] );
       Object.assign( art, builtins[name] );
       if (!art.internal)
         artifacts[name] = art;
@@ -443,7 +442,7 @@ function initBuiltins( model ) {
         name: { id },
       };
       elements[id] = art;
-      setProp( art, '_parent', model.$magicVariables );
+      setLink( art, '_parent', model.$magicVariables );
 
       if (magic.$autoElement)
         art.$autoElement = magic.$autoElement;
@@ -459,7 +458,7 @@ function initBuiltins( model ) {
       createMagicElements( art, magic.elements );
       if (options.variableReplacements?.[id])
         createMagicElements( art, options.variableReplacements[id] );
-      // setProp( art, '_effectiveType', art );
+      // setLink( art, '_effectiveType', art );
     }
   }
 
@@ -481,8 +480,8 @@ function initBuiltins( model ) {
         magic.$uncheckedElements = art.$uncheckedElements;
       if (art.$restricted)
         magic.$restricted = art.$restricted;
-      setProp( magic, '_parent', art );
-      // setProp( magic, '_effectiveType', magic );
+      setLink( magic, '_parent', art );
+      // setLink( magic, '_effectiveType', magic );
       if (elements[id] && typeof elements[id] === 'object')
         createMagicElements( magic, elements[id] );
 

package/lib/compiler/checks.js

@@ -9,16 +9,15 @@
 
 'use strict';
 
+const { isDeprecatedEnabled } = require('../base/model');
+const { propagationRules, acceptsExprValues } = require('../base/builtins');
+const { typeParameters } = require('./builtins');
 const {
   forEachGeneric,
   forEachDefinition,
   forEachMember,
-  forEachMemberRecursively,
-  isDeprecatedEnabled,
-} = require('../base/model');
-const { typeParameters } = require('./builtins');
-const { propagationRules, acceptsExprValues } = require('../base/builtins');
-const { annotationVal } = require('./utils');
+  annotationVal,
+} = require('./utils');
 
 const $location = Symbol.for( 'cds.$location' );
 
@@ -50,6 +49,8 @@ function check( model ) {
     checkGenericConstruct( def );
     if (def.includes && def.elements)
       checkElementIncludeOverride( def );
+    while (def.items)
+      def = def.items;
     forEachMember( def, member => checkMember( member ) );
     if (def.$queries)
       def.$queries.forEach( checkQuery );
@@ -107,6 +108,8 @@ function check( model ) {
     if (member.kind === 'element')
       checkElement( member, parentProps );
 
+    while (member.items)
+      member = member.items;
     forEachMember( member, m => checkMember( m, parentProps ) );
   }
 
@@ -1419,4 +1422,22 @@ function isComplexView( art ) {
   return (!art.query.from?._artifact || art.query.from._artifact.kind === 'element');
 }
 
+/**
+ * Same as forEachMember, but inside each member, calls itself recursively, i.e.
+ * sub members are traversed as well.
+ *
+ * @param {XSN.Artifact} construct
+ * @param {(member: XSN.Artifact, memberName: string, prop: string) => void} callback
+ * @param {XSN.Artifact} [target]
+ */
+function forEachMemberRecursively( construct, callback ) {
+  while (construct.items)
+    construct = construct.items;
+  forEachMember( construct, ( member, memberName, prop ) => {
+    callback( member, memberName, prop );
+    // Descend into nested members, too
+    forEachMemberRecursively( member, callback );
+  } );
+}
+
 module.exports = check;

package/lib/compiler/cycle-detector.js

@@ -16,7 +16,7 @@
 
 'use strict';
 
-const { setLink: setProp } = require('./utils'); // check enum/non-enum
+const { setLink } = require('./utils'); // check enum/non-enum
 
 // Detect cyclic dependencies between all nodes reachable from `definitions`.
 // If such a dependency is found, call `reportCycle` with arguments `dep.art`
@@ -51,7 +51,7 @@ function detectCycles( definitions, reportCycle, cbScc ) {
     // console.log('CALL: ', v.kind,v.name)
     ++index;
     if (!v._scc) {
-      setProp( v, '_scc', {
+      setLink( v, '_scc', {
         index,
         lowlink: index,
         onStack: true,
@@ -61,14 +61,14 @@ function detectCycles( definitions, reportCycle, cbScc ) {
       // console.log('PUSH: ', v.kind,v.name)
     }
     if (!v._deps)               // builtins, otherwise forgotten (TODO: assert in --test-mode)
-      setProp( v, '_deps', [] );
+      setLink( v, '_deps', [] );
     // assert( v._scc.onStack );
 
     // Now consider successors of v (called w):
     while (v._scc.depIndex < v._deps.length) {
       const w = v._deps[v._scc.depIndex++].art;
       if (!w._scc) {            // node has not yet been visited
-        setProp( w, '_sccCaller', v );
+        setLink( w, '_sccCaller', v );
         // console.log('CALL: ', v._scc.depIndex )
         return w;               // recursive call with w in recursive algorithm
       }