@sap/cds-compiler 6.7.3 → 6.9.0

package/CHANGELOG.md

@@ -13,6 +13,76 @@ 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.9.0 - 2026-04-21
+
+### Features
+
+- **compiler:**
+  + add support for extending views/projections with several SQL clauses:
+    `where`, `group by`, `having`, `order by`, `limit`
+  + allow extending derived enum types/elements by adding enum symbols
+  + inside `extend … with enum {…}`, it is now possible to use `extend existingEnumSymbol with @Anno`,
+    like it is already possible inside `extend … with {…}`
+  + when the new options `v7KeyPropagation` is set, the propagation of the `key` property in queries is simplified,
+    and the `key` property is not propagated when including structures into types
+- **odata:** set `meta.compilerCsnFlavor` in the OData transformed CSN
+- **seal**: set `meta.compilerCsnFlavor` in the SEAL transformed CSN
+- **effective:** set `meta.compilerCsnFlavor` in the effective CSN
+- **sql:**
+  + set `meta.compilerCsnFlavor` in SQL transformed CSN
+  + allow single-leafed structures within a `list` on the left-hand side of the `IN` operator.
+    For example `(author, struct) in (...)` becomes `(author_ID, struct_leaf) in (...)`.
+  + support `cds.Vector` on Postgres and H2
+
+### Bug Fixes
+
+- **compiler:**
+  + don't introduce a strange `cast` property in the CSN for a column with an expand on a to-many association
+  + while crawling tokens for LSP, allow extensions without name
+- **effective:** don't absolutify paths in filters in annotations
+- **sql:** properly resolve references in annotation values and `on` conditions for a column inside an expand without base reference
+
+### Improvements
+
+- **compiler:**
+  + add `compilerVersion` to CSN meta
+  + issue a warning if a structure in an annotation value would have the same CSN representation as an expression
+  + issue warnings for extends on built-in types
+  + warn on duplicate members from includes via extend
+- **odata:**
+  + update OData vocabularies: Common, Core, UI
+  + using `@readonly` with an expression value on entities or aspects is no longer silently accepted and now produces an error
+
+
+
+## Version 6.8.0 - 2026-03-05
+
+### Features
+
+- **api:** basic experimental support for code completion in `cds repl`
+- **compiler:**
+  + retain original meta property in CSN
+  + add compilerCsnFlavor to meta property
+- **sql:**
+  + Add support for `cds.Vector`
+  + Allow migration from cds.String to cds.LargeString
+  + Fiori Tree Views in the database backend
+  + For postgres: warning for identifiers that exceed the databases length limit
+
+### Bug Fixes
+
+- **sql:**
+  + do not report validation errors on entities marked as `@cds.persistence.skip`
+  + normalize named arguments for portable functions
+  + properly flatten associations for temporal unique constraints
+
+### Improvements
+
+- **compiler:**
+  + improve warning in case of invalid type for key
+  + simplify syntax error text when expecting Comparison and Operator tokens
+  + improve support for code completion with `case` expressions, queries, and subqueries
+
 ## Version 6.7.3 - 2026-02-11
 
 ### Fixed

package/README.md

@@ -1,6 +1,7 @@
 # Getting started
 
 
+
 ## Installation and Usage
 
 Install with npm:
@@ -20,16 +21,19 @@ Or maintain your package.json dependencies as follows:
 If your project already has a dependency to `@sap/cds`, nothing has to be done.
 
 
+
 ## Documentation
 
 Please refer to the [official CDS documentation](https://cap.cloud.sap/docs/cds/).
 
 
+
 ## How to Obtain Support
 
 In case you find a bug, please report an [incident](https://cap.cloud.sap/docs/resources/#reporting-incidents) on SAP Support Portal.
 
 
+
 ## History and License
 
 The cds-compiler uses [Semantic Versioning](./doc/Versioning.md) for its version numbers.

package/bin/cdsc.js

@@ -25,9 +25,9 @@ const { toRename: _toRename } = require('../lib/render/toRename');
 const util = require('util');
 const fs = require('fs');
 const path = require('path');
-const { reveal } = require('../lib/model/revealInternalProperties');
-const enrichCsn = require('../lib/model/enrichCsn');
-const { optionProcessor } = require('../lib/optionProcessor');
+const { reveal } = require('../lib/tool-lib/revealInternalProperties');
+const enrichCsn = require('../lib/tool-lib/enrichCsn');
+const { optionProcessor } = require('../lib/base/optionProcessor');
 const {
   explainMessage, hasMessageExplanation, sortMessages,
   messageIdsWithExplanation, makeMessageFunction,
@@ -35,7 +35,7 @@ const {
 const { term } = require('../lib/utils/term');
 const { addLocalizationViews } = require('../lib/transform/localized');
 const { addTenantFields } = require('../lib/transform/addTenantFields');
-const { availableBetaFlags } = require('../lib/base/model');
+const { availableBetaFlags } = require('../lib/base/specialOptions');
 const { alterConstraintsWithCsn } = require('../lib/render/manageConstraints');
 const { tmpFilePath, readStream } = require('../lib/utils/file');
 
@@ -548,7 +548,7 @@ async function executeCommandLine( command, options, args ) {
   }
 
   function inspect( model ) {
-    const inspectModel = require('../lib/inspect');
+    const inspectModel = require('../lib/tool-lib');
 
     if (options.statistics) {
       const result = inspectModel.inspectModelStatistics(model, options);

package/bin/cdshi.js

@@ -32,6 +32,7 @@ const categoryChars = {         // default: first char of category name
   ExtService: 'S',          // highlight like service definition
   ExtContext: 'C',          // highlight like context definition
   // ExtElement: 'E',       // using the first letter is the default
+  ExtEnum: 'H',             // highlight like enum symbol definition
   ExtBoundAction: 'B',      // highlight like bound action definition
   ExtParam: 'P',            // highlight like entity/action parameter definition
   FromImplicit: 'W',

package/bin/cdsse.js

@@ -25,7 +25,7 @@ const path = require('path');
 const compiler = require('../lib/compiler');
 const main = require('../lib/main');
 const { locationString } = require('../lib/base/messages');
-const { availableBetaFlags: beta } = require('../lib/base/model');
+const { availableBetaFlags: beta } = require('../lib/base/specialOptions');
 
 const { argv } = process;
 const cmd = commands[argv[2]];

package/lib/api/main.js

@@ -2,10 +2,10 @@
 
 'use strict';
 
-const lazyload = require('../base/lazyload')( module );
+const lazyload = require('../utils/lazyload')( module );
 
 const prepareOptions = lazyload('./options');
-const baseModel = lazyload('../base/model');
+const specialOptions = lazyload('../base/specialOptions');
 const location = lazyload('../base/location');
 const messages = lazyload('../base/messages');
 const compiler = lazyload('../compiler/index');
@@ -27,8 +27,8 @@ const effective = lazyload('../transform/effective/main');
 const toHdbcds = lazyload('../render/toHdbcds');
 const baseError = lazyload('../base/error');
 const csnToEdm = lazyload('../edm/csn2edm');
-const trace = lazyload('./trace');
-const cloneCsn = lazyload('../model/cloneCsn');
+const trace = lazyload('../base/trace');
+const cloneCsn = lazyload('../base/cloneCsn');
 const objectUtils = lazyload('../utils/objectUtils');
 
 /**
@@ -56,6 +56,7 @@ const warnAboutMismatchOdata = [ 'odataVersion' ];
  * @param {string[]} relevantOptionNames Option names that are defining characteristics
  * @param {string[]} [optionalOptionNames] Option names that should be attached as a fyi
  */
+// TODO: move this function to some other place
 function attachTransformerCharacteristics( csn, transformation, options,
                                            relevantOptionNames, optionalOptionNames = [] ) {
   const relevant = {};
@@ -75,10 +76,10 @@ function attachTransformerCharacteristics( csn, transformation, options,
       relevant[name] = options[name];
   }
   if (!csn.meta)
-    baseModel.setProp(csn, 'meta', {});
+    objectUtils.setProp(csn, 'meta', {});
 
-  baseModel.setProp(csn.meta, 'options', relevant);
-  baseModel.setProp(csn.meta, 'transformation', transformation);
+  objectUtils.setProp(csn.meta, 'options', relevant);
+  objectUtils.setProp(csn.meta, 'transformation', transformation);
 }
 
 /**
@@ -306,7 +307,14 @@ function forEffectiveInternal( csn, options, internalOptions, messageFunctions )
 function forSeal( csn, options, messageFunctions ) {
   const internalOptions = prepareOptions.for.seal(options);
   internalOptions.transformation = 'effective';
-  return forEffectiveInternal(csn, options, internalOptions, messageFunctions);
+  const result = forEffectiveInternal(csn, options, internalOptions, messageFunctions);
+
+  if (!options.testMode) {
+    result.meta ??= {};
+    result.meta.compilerCsnFlavor = 'seal';
+  }
+
+  return result;
 }
 
 /**
@@ -1166,7 +1174,7 @@ function publishCsnProcessor( processor, _name ) {
     try {
       const messageFunctions = messages.makeMessageFunction(csn, options, _name);
       if (options.deprecated)
-        baseModel.checkRemovedDeprecatedFlags( options, messageFunctions );
+        specialOptions.checkRemovedDeprecatedFlags( options, messageFunctions );
 
       checkOutdatedOptions( options, messageFunctions );
       csn = ensureClientCsn( csn, options, messageFunctions, _name );

package/lib/api/options.js

@@ -1,8 +1,9 @@
 'use strict';
 
-// The options are specified in ../optionProcessor.js (and some other files).
+// The options are specified in ../base/optionProcessor.js (and some other files).
 // Some backends feel the need to "translate" option, which require to list
-// all options also here (as “public" or "private" option).
+// all options also here (as "public" or "private" option).
+// Parser and core compiler options might not have been listed here.
 
 const { validate, generateStringValidator } = require('./validate');
 const { makeMessageFunction } = require('../base/messages');
@@ -25,6 +26,7 @@ const publicOptionsNewAPI = [
   'defaultStringLength',
   'csnFlavor',
   'noDollarCalc',
+  'v7KeyPropagation',
   // DB
   'sqlDialect',
   'sqlMapping',
@@ -36,6 +38,7 @@ const publicOptionsNewAPI = [
   'pre2134ReferentialConstraintNames',
   'betterSqliteSessionVariables',
   'fewerLocalizedViews',
+  'sqliteRealAffinityForDecimal',
   'withHanaAssociations',
   'standardDatabaseFunctions',
   'booleanEquality',

package/lib/api/validate.js

@@ -1,6 +1,6 @@
 'use strict';
 
-// The options are specified in ../optionProcessor.js (and some other files).
+// The options are specified in ../base/optionProcessor.js (and some other files).
 // Options with non-boolean values must also be listed in this file.
 
 const { forEach } = require('../utils/objectUtils');

package/lib/base/builtins.js

@@ -89,29 +89,33 @@ function isMagicVariable( name ) {
 }
 
 /**
- * Properties that are required next to `=` to make an annotation value an actual expression
- * and not some foreign structure.
+ * Properties (without those from CSN v0.1.0) that make an annotation object value
+ * an actual expression and not some foreign structure.
  *
  * @type {string[]}
  */
-const xprInAnnoProperties = [
-  'ref', 'xpr', 'list', 'literal', 'val',
-  '#', 'func', 'args', 'SELECT', 'SET',
-  'cast',
+const primaryExprProperties = [
+  'ref', 'xpr', 'list', 'val', '#', 'func', 'SELECT', 'SET',
+];
+// only with 'ref'/'val'/'func'/misc:
+const exprProperties = [
+  ...primaryExprProperties,
+  'param', 'literal', 'args', 'cast',
 ];
-
 
 /**
  * Return whether JSON object `val` is a representation for an annotation expression
  */
 function isAnnotationExpression( val ) {
-  return val?.['='] !== undefined && xprInAnnoProperties.some( prop => val[prop] !== undefined );
+  return val?.['='] !== undefined && // TODO: truthy
+    primaryExprProperties.some( prop => val[prop] !== undefined );
 }
 
 module.exports = {
   propagationRules,
   acceptsExprValues,
-  xprInAnnoProperties,
+  primaryExprProperties,
+  exprProperties,
   isInReservedNamespace,
   isBuiltinType,
   isMagicVariable,

package/lib/{model → base}/csnRefs.js

@@ -784,14 +784,15 @@ function csnRefs( csn, universalReady ) {
         const target = assocTarget( parent, refCtx );
         return resolvePath( path, target.elements[head], target, 'target' );
       }
-      if (baseEnv) {               // ref-target (filter condition), expand, inline
-        if (semantics.dynamic !== 'query')
-          return resolvePath( path, baseEnv.elements[head], baseEnv, semantics.dynamic );
-        // in an ON condition of an association inside inner expand/inline:
+      if (semantics.dynamic === 'query') {
+        // in an anno, or an ON condition of an association inside inner expand/inline:
         const elemParent = getCache( parent, '_element' );
-        if (elemParent)         // expand in expand
+        if (elemParent?.elements) // expand in expand
           return resolvePath( path, elemParent.elements[head], null, 'query' );
       }
+      else if (baseEnv) {       // ref-target (filter condition), expand, inline
+        return resolvePath( path, baseEnv.elements[head], baseEnv, semantics.dynamic );
+      }
       if (!query) {                // outside queries - TODO: items?
         // refs in annos on foreign keys use fk name, not fk ref name:
         const dict = parent.elements ?? getCache( parent, '_keys' );
@@ -810,11 +811,9 @@ function csnRefs( csn, universalReady ) {
       if (!qcache)
         throw new CompilerAssertion( `For semantics '${ refCtx }', query not in cache at: ${ locationString(query.$location) }` );
 
-      if (semantics.dynamic === 'query') {
-        // TODO: for ON condition in expand, would need to use cached _element
-        // TODO: test and implement - Issue #11792!
+      if (semantics.dynamic === 'query')
         return resolvePath( path, qcache.elements[head], null, 'query' );
-      }
+
       for (const name in qcache.$aliases) {
         const alias = qcache.$aliases[name];
         const found = alias.elements[head];
@@ -1144,7 +1143,6 @@ function analyseCsnPath( csnPath, csn, resolve ) {
           baseEnv = resolve.expandInline( obj, baseCtx, main, query, parent, baseEnv );
         refCtx = prop;
       }
-      // TODO: for on condition in expand, also set an environment
       isName = prop;
     }
     else if (prop === 'on') {

package/lib/base/error.js

@@ -1,3 +1,5 @@
+// Special error classes for compiler
+
 'use strict';
 
 /**

package/lib/base/message-registry.js

@@ -36,7 +36,7 @@
 'use strict';
 
 const { CompilerAssertion } = require( './error' );
-const { isDeprecatedEnabled } = require( './model' );
+const { isDeprecatedEnabled } = require( './specialOptions' );
 
 const configurableForValidValues = {
   __proto__: null,
@@ -89,6 +89,7 @@ const centralMessages = {
   'anno-invalid-sql-kind': { severity: 'Error', configurableFor: true  },  // @sql.prepend/append - configurable for "I know what I'm doing"
   'anno-invalid-sql-view': { severity: 'Error', configurableFor: true  },  // @sql.prepend/append - configurable for "I know what I'm doing"
   'anno-invalid-sql-view-element': { severity: 'Error', configurableFor: true },  // @sql.prepend/append - configurable for "I know what I'm doing"
+  'ext-duplicate-include': { severity: 'Warning', errorFor: [ 'v7' ] },
   'ext-undefined-action':  { severity: 'Warning' },
   'ext-undefined-art':     { severity: 'Warning' }, // for annotate statement (for CDL path root)
   'ext-undefined-def':     { severity: 'Warning' }, // for annotate statement (for CSN or CDL path cont)
@@ -100,6 +101,7 @@ const centralMessages = {
   'ext-undefined-element-sec': { severity: 'Error', configurableFor: true }, // for security-relevant…
   'ext-undefined-action-sec': { severity: 'Error', configurableFor: true }, // for security-relevant…
   'ext-undefined-param-sec': { severity: 'Error', configurableFor: true }, // … annotate statement
+  'ext-unexpected-type-property': { severity: 'Warning', errorFor: [ 'v7' ] },
   'ext-unexpected-returns': { severity: 'Warning' },
   'ext-unexpected-returns-sec': { severity: 'Error', configurableFor: true }, // … annotate statement
   'anno-unexpected-ellipsis': { severity: 'Error', configurableFor: 'deprecated' },
@@ -125,8 +127,11 @@ const centralMessages = {
   'empty-type':   { severity: 'Info' }, // only still an error in old transformers
 
   'ref-deprecated-orderby': { severity: 'Error', configurableFor: true },
-  'ref-deprecated-self-element': { severity: 'Error', configurableFor: true },
+  'ref-deprecated-self-element': { severity: 'Error', configurableFor: 'v7' },
   'ref-deprecated-variable': { severity: 'Warning' },
+  'ref-deprecated-in-extend': { severity: 'Warning' },
+  'ref-special-in-extend': { severity: 'Warning' },
+  'ref-unexpected-in-extend': { severity: 'Error' },
   'ref-invalid-type': { severity: 'Error' },
   'ref-unexpected-self': { severity: 'Error' },
   'ref-invalid-include': { severity: 'Error' },
@@ -135,6 +140,7 @@ const centralMessages = {
   'type-ignoring-argument': { severity: 'Error', configurableFor: true },
   'type-expected-builtin': { severity: 'Error', configurableFor: true },
   'type-expecting-service-target': { severity: 'Error', configurableFor: true },
+  'type-invalid-for-key': { severity: 'Warning' },
   'ref-expecting-const': { severity: 'Error' },
   'ref-expecting-foreign-key': { severity: 'Error' },
   'ref-invalid-source': { severity: 'Error' },
@@ -154,6 +160,7 @@ const centralMessages = {
   'query-unexpected-structure-hdbcds': { severity: 'Error' },
   'query-ignoring-param-nullability': { severity: 'Info' },
   'query-expected-identifier': { severity: 'Error' },
+  'query-invalid-identifier': { severity: 'Warning' },
 
   'recalculated-localized': { severity: 'Info' }, // KEEP: Downgrade in lib/transform/translateAssocsToJoins.js
   'redirected-implicitly-ambiguous': { severity: 'Error', configurableFor: true }, // does not hurt us - TODO: ref-ambiguous-target
@@ -202,6 +209,8 @@ const centralMessages = {
   // remark: a hard syntax error in new parser for `null` together with `not null`
   'syntax-duplicate-equal-clause': { severity: 'Warning' },
   'syntax-invalid-name': { severity: 'Error' },
+  'syntax-invalid-anno-struct': { severity: 'Warning', errorFor: [ 'v7' ] },
+  'syntax-invalid-nested-proj': { severity: 'Warning', errorFor: [ 'v7' ] },
   'syntax-missing-as': { severity: 'Error', configurableFor: true },
   'syntax-missing-proj-semicolon': { severity: 'Warning' },
   'syntax-unexpected-after': { severity: 'Error' },
@@ -246,6 +255,7 @@ const centralMessages = {
   'odata-unexpected-nullable-key': { severity: 'Error', configurableFor: true },
   'odata-invalid-key-type': { severity: 'Warning' },
   'odata-invalid-property-name': { severity: 'Warning' },
+  'odata-unexpected-xpr-anno': { severity: 'Error', configurableFor: true },
   'odata-anno-preproc': { severity: 'Warning' },
   'odata-anno-dict': { severity: 'Warning' },
   'odata-anno-vocref': { severity: 'Warning' },
@@ -533,6 +543,10 @@ const centralMessageTexts = {
     dot: 'Use a $(NEWCODE), not a $(CODE) after the arguments or filter on an entity',
     colon: 'Use a $(NEWCODE), not a $(CODE) between the element names in a reference',
   },
+  'syntax-invalid-anno-struct': {
+    std: 'Most CSN processors interpret a structure with property $(PROP) as expression',
+    ref: 'Most CSN processors interpret a structure with property $(PROP) as reference',
+  },
   // 'syntax-ignoring-doc-comment' (Info)
   'syntax-unexpected-reserved-word': '$(CODE) is a reserved word - write $(DELIMITED) instead if you want to use it as name',
   'syntax-invalid-text-block': 'Missing newline in text block',
@@ -708,6 +722,14 @@ const centralMessageTexts = {
     type: 'Illegal recursive type definition to $(TYPE)',
   },
   'ref-deprecated-orderby': 'Replace source element reference $(ID) by $(NEWCODE); auto-corrected',
+  'ref-deprecated-in-extend': {
+    std: 'In an extension, do not use the table alias $(ID) to refer to source elements',
+    columns: 'In an added column, do not use the table alias $(ID) to refer to source elements',
+    where: 'In an added WHERE, do not use the table alias $(ID) to refer to source elements',
+    groupBy: 'In an added GROUP BY, do not use the table alias $(ID) to refer to source elements',
+    having: 'In an added HAVING, do not use the table alias $(ID) to refer to source elements',
+    orderBy: 'In an added ORDER BY, do not use the table alias $(ID) to refer to source elements',
+  },
   'ref-missing-self-counterpart' : {
     std: 'Expected to find a matching element in $self-comparison for foreign key $(PROP) of association $(NAME)',
     unmanaged: 'Expected to find a matching element in $self-comparison for $(PROP) of association $(NAME)',
@@ -728,6 +750,7 @@ const centralMessageTexts = {
   'ref-undefined-def': {
     std: 'Artifact $(ART) has not been found',
     // TODO: proposal 'No definition of $(NAME) found',
+    hint: 'Artifact $(ART) has not been found. Did you mean to write $(CODE)?',
     element: 'Artifact $(ART) has no element $(MEMBER)',
   },
   'ref-undefined-param': 'Entity $(ART) has no parameter $(ID)',
@@ -866,6 +889,7 @@ const centralMessageTexts = {
     std: 'Unexpected arguments in path $(ELEMREF)', // unused
     'on-condition': 'ON-conditions must not contain parameters, step $(ID) of path $(ELEMREF)',
     calc: 'Unexpected arguments in path $(ELEMREF) of stored calculated element; only simple paths can be used here',
+    vector_length: 'Unexpected length of vector $(ELEMREF). The length must be divisble by 4',
   },
   'ref-unsupported-type': {
     std: 'Type $(TYPE) is not supported',
@@ -955,6 +979,7 @@ const centralMessageTexts = {
     missing: 'Expecting service entity $(TARGET); it does not have the key element $(ID) of the provided model target',
     order: 'Expecting service entity $(TARGET); its key elements are in a different order than those of the provided model target',
   },
+  'type-invalid-for-key': 'Type $(TYPE) is not supported for key elements',
 
   'anno-builtin': 'Builtin types should not be annotated nor extended. Use custom type instead',
   'ext-undefined-def': 'Artifact $(ART) has not been found',
@@ -1025,7 +1050,6 @@ const centralMessageTexts = {
     std: '$(KEYWORD) is not supported here', // unused variant
     kind: '$(KEYWORD) is only supported for elements in an entity or an aspect',
     sub: '$(KEYWORD) is only supported for top-level elements',
-    type: '$(KEYWORD) is not supported for elements of type $(TYPE)',
   },
   'def-unexpected-localized': {
     std: 'Unexpected $(KEYWORD)',
@@ -1076,6 +1100,12 @@ const centralMessageTexts = {
 
   'def-expected-structured': 'Events must either be structured or be projections',
 
+  'ext-duplicate-include': {
+    std: 'Duplicate $(NAME) through multiple includes $(SORTED_ARTS)',
+    elements: 'Duplicate element $(NAME) through multiple includes $(SORTED_ARTS)',
+    actions: 'Duplicate action or function $(NAME) through multiple includes $(SORTED_ARTS)',
+  },
+
   'duplicate-definition': {
     std: 'Duplicate definition of $(NAME)',
     absolute: 'Duplicate definition of artifact $(NAME)',
@@ -1153,6 +1183,32 @@ const centralMessageTexts = {
     join: 'Artifact $(ART) can\'t be extended with columns, because it contains a JOIN',
     union: 'Artifact $(ART) can\'t be extended with columns, because it contains a UNION',
   },
+  'extend-where': {
+    std: 'Artifact $(ART) can\'t be extended with WHERE, only simple views/projections without JOINs and UNIONs can',
+    join: 'Artifact $(ART) can\'t be extended with WHERE, because it contains a JOIN',
+    union: 'Artifact $(ART) can\'t be extended with WHERE, because it contains a UNION',
+  },
+  'extend-groupby': {
+    std: 'Artifact $(ART) can\'t be extended with GROUP BY, only simple views/projections without JOINs and UNIONs can',
+    join: 'Artifact $(ART) can\'t be extended with GROUP BY, because it contains a JOIN',
+    union: 'Artifact $(ART) can\'t be extended with GROUP BY, because it contains a UNION',
+  },
+  'extend-having': {
+    std: 'Artifact $(ART) can\'t be extended with HAVING, only simple views/projections without JOINs and UNIONs can',
+    join: 'Artifact $(ART) can\'t be extended with HAVING, because it contains a JOIN',
+    union: 'Artifact $(ART) can\'t be extended with HAVING, because it contains a UNION',
+  },
+  'extend-orderby': {
+    std: 'Artifact $(ART) can\'t be extended with ORDER BY, only simple views/projections without JOINs and UNIONs can',
+    join: 'Artifact $(ART) can\'t be extended with ORDER BY, because it contains a JOIN',
+    union: 'Artifact $(ART) can\'t be extended with ORDER BY, because it contains a UNION',
+  },
+  'extend-limit': {
+    std: 'Artifact $(ART) can\'t be extended with LIMIT, only simple views/projections without JOINs and UNIONs can',
+    join: 'Artifact $(ART) can\'t be extended with LIMIT, because it contains a JOIN',
+    union: 'Artifact $(ART) can\'t be extended with LIMIT, because it contains a UNION',
+  },
+  'ext-unexpected-sql-clause': 'Artifact $(ART) can\'t be extended with a $(KEYWORD) clause, because it already exists',
   'extend-repeated-intralayer': 'Unstable element order due to repeated extensions in same layer',
   'extend-unexpected-include': 'Can\'t extend $(META) with includes',
 
@@ -1199,6 +1255,7 @@ const centralMessageTexts = {
     std: 'Expected identifier for select item',
     assoc: 'Expected identifier as the association\'s name',
   },
+  'query-invalid-identifier': 'Expected identifier for SQL dialect $(NAME) to not exceed $(NUMBER) characters',
   'query-unsupported-calc': {
     std: 'Using nested projections next to calculated elements is not supported, yet',
     inside: 'Using calculated elements in nested projections is not supported, yet',
@@ -1252,11 +1309,17 @@ const centralMessageTexts = {
   },
 
   'ref-special-in-extend': {
-    std: 'In an added column, $(ID) refers to the element of the projection source $(ART), not the table alias or mixin',
+    std: 'In an extension, $(ID) refers to the element of the projection source $(ART), not the table alias or mixin',
     alias: 'In an added column, $(ID) refers to the element of the projection source $(ART), not the table alias',
     mixin: 'In an added column, $(ID) refers to the element of the projection source $(ART), not the mixin',
   },
 
+  'ref-unexpected-in-extend': {
+    std: 'Unexpected $(ID) in an extension; it matches both a source element of $(ART) and the table alias or mixin',
+    alias: 'Unexpected $(ID) in an added $(KEYWORD); it matches both a source element of $(ART) and the table alias',
+    mixin: 'Unexpected $(ID) in an added $(KEYWORD); it matches both a source element of $(ART) and the mixin',
+  },
+
   'type-managed-composition': {
     std: 'Managed compositions can\'t be used in types', // yet
     sub: 'Managed compositions can\'t be used in sub elements',
@@ -1396,6 +1459,7 @@ const centralMessageTexts = {
     xpr: 'Ignoring unexpected expression as default value',
     colitem: 'Ignoring unexpected default value for a structured or collection like parameter',
   },
+  'odata-unexpected-xpr-anno': 'Annotation $(ANNO) with expression value is not allowed for kind $(KIND)',
   // -----------------------------------------------------------------------------------
   // All odata-anno MUST have a '$(ANNO)' parameter to indicate error location
   // -----------------------------------------------------------------------------------

package/lib/base/messages.js

@@ -6,7 +6,7 @@
 
 const { term } = require('../utils/term');
 const { Location, locationString } = require('./location');
-const { isBetaEnabled } = require('./model');
+const { isBetaEnabled } = require('./specialOptions');
 const {
   centralMessages,
   configurableForValidValues,
@@ -14,7 +14,7 @@ const {
   oldMessageIds,
 } = require('./message-registry');
 const _messageIdsWithExplanation = require('../../share/messages/message-explanations.json').messages;
-const { analyseCsnPath, traverseQuery } = require('../model/csnRefs');
+const { analyseCsnPath, traverseQuery } = require('../base/csnRefs');
 const { CompilerAssertion } = require('./error');
 const { getArtifactName } = require('../compiler/base');
 const { cdlNewLineRegEx } = require('../language/textUtils');
@@ -854,6 +854,8 @@ function value( val ) {
 const keywordRepresentations = {
   association: 'Association',
   composition: 'Composition',
+  groupby: 'group by',
+  orderby: 'order by',
 };
 function keyword( val ) {
   const v = val.toLowerCase();

package/lib/{optionProcessor.js → base/optionProcessor.js}

@@ -8,12 +8,12 @@
 // - Also list the option in the `help` text, used with `cdsc -h`.
 // - All options must also be added to ./api/options.js.
 // - Specify valid values for non-boolean options in ./api/validate.js.
-// - Beta and deprecated options are specified in ./base/model.js.
+// - Beta and deprecated options are specified in ./base/specialOptions.js.
 
 'use strict';
 
-const { createOptionProcessor } = require('./base/optionProcessorHelper');
-const { availableBetaFlags } = require('./base/model');
+const { createOptionProcessor } = require('../utils/optionProcessorHelper');
+const { availableBetaFlags } = require('./specialOptions');
 
 // This option processor is used both by the command line parser (to translate cmd line options
 // into an options object) and by the API functions (to verify options)
@@ -53,6 +53,7 @@ optionProcessor
   .option('    --test-sort-csn')
   .option('    --doc-comment')
   .option('    --propagate-doc-comments')
+  .option('    --v7-key-propagation')
   .option('    --add-texts-language-assoc')
   .option('    --localized-without-coalesce')
   .option('    --tenant-discriminator')
@@ -156,6 +157,7 @@ optionProcessor
                             option is implicitly enabled as well.
        --doc-comment        Preserve /** */ comments at annotation positions as doc property in CSN
        --propagate-doc-comments     Propagate doc comments ('--doc-comment')
+       --v7-key-propagation         Use simplified propagation of 'key' in query entities
        --add-texts-language-assoc   In generated texts entities, add association "language"
                                     to "sap.common.Languages" if it exists
        --localized-without-coalesce Omit coalesce in localized convenience views