@sap/cds-compiler 4.9.6 → 5.1.0

package/lib/base/message-registry.js

@@ -41,7 +41,6 @@ const { createDict } = require('../utils/objectUtils');
  *  - true = can always be downgraded, we do not really care
  *  - [‹module›, …] = can be downgraded in compiler function ‹module›
  *  - 'deprecated' = severity can only be changed with deprecated.downgradableErrors
- *  - 'v4' = currently like true, but should be 'deprecated' in v5
  *
  * @type {Object<string, MessageConfig>}
  */
@@ -61,13 +60,13 @@ const centralMessages = {
   '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)
   'ext-undefined-element': { severity: 'Warning' },
+  'ext-undefined-key':     { severity: 'Warning' },
   'ext-undefined-param':   { severity: 'Warning' },
   'anno-unexpected-ellipsis': { severity: 'Error', configurableFor: 'deprecated' },
   'anno-unexpected-localized-skip': { severity: 'Error', configurableFor: true },
-  'anno-unexpected-mixin': { severity: 'Warning', errorFor: [ 'v5' ] },
 
   'name-invalid-dollar-alias': { severity: 'Error', configurableFor: true },
-  'name-deprecated-$self': { severity: 'Warning', errorFor: [ 'v5' ], configurableFor: true },
+  'name-deprecated-$self': { severity: 'Error', configurableFor: true },
 
   'type-invalid-items': { severity: 'Error' }, // not supported yet
   'assoc-as-type':  { severity: 'Error' }, // TODO: allow more, but not all
@@ -86,7 +85,7 @@ 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: 'Warning', configurableFor: true, errorFor: [ 'v5' ] },
+  'ref-deprecated-self-element': { severity: 'Error', configurableFor: true },
   'ref-invalid-type': { severity: 'Error' },
   'ref-unexpected-self': { severity: 'Error' },
   'ref-invalid-include': { severity: 'Error' },
@@ -98,6 +97,7 @@ const centralMessages = {
   'ref-expecting-foreign-key': { severity: 'Error' },
   'ref-invalid-source': { severity: 'Error' },
   'ref-invalid-target': { severity: 'Error' },
+  'ref-missing-self-counterpart': { severity: 'Error', configurableFor: true },
   'ref-sloppy-target': { severity: 'Error', configurableFor: 'v4' },
 
   'extend-repeated-intralayer': { severity: 'Warning' },
@@ -152,7 +152,7 @@ const centralMessages = {
   // 'syntax-duplicate-annotate' came late with v3 - make it configurable as
   // fallback, but then parse.cdl is not supposed to work correctly (it can
   // then either issue an error or produce a CSN missing some annotations):
-  'syntax-duplicate-annotate': { severity: 'Error', configurableFor: 'deprecated' },
+  'syntax-duplicate-annotate': { severity: 'Error' },
   'syntax-duplicate-clause': { severity: 'Error', configurableFor: true },
   'syntax-duplicate-equal-clause': { severity: 'Warning' },
   'syntax-invalid-name': { severity: 'Error', configurableFor: 'deprecated' },
@@ -162,36 +162,38 @@ const centralMessages = {
   'syntax-unknown-escape': { severity: 'Error', configurableFor: true },
   'syntax-unsupported-masked': { severity: 'Error', configurableFor: 'deprecated' },
   'syntax-unexpected-sql-clause': { severity: 'Error' }, // TODO: configurableFor:'tests'?
-  'syntax-ignoring-anno': { severity: 'Warning', errorFor: [ 'v5' ] },
+  'syntax-invalid-space': { severity: 'Error', configurableFor: 'test' },
+  'syntax-expecting-space': { severity: 'Error' },
+  'syntax-unexpected-anno': { severity: 'Error' },
 
   'type-unsupported-precision-change': { severity: 'Error' },
   'type-unsupported-key-change': { severity: 'Error', configurableFor: true },
-  'type-missing-enum-value': { severity: 'Warning', errorFor: [ 'v5' ] },
+  'type-missing-enum-value': { severity: 'Error', configurableFor: 'test' },
 
   'def-missing-element': { severity: 'Error' },
-  'def-expected-structured': { severity: 'Warning', configurableFor: true, errorFor: [ 'v5' ] },
+  'def-expected-structured': { severity: 'Error', configurableFor: true },
   'def-unsupported-calc-elem': { severity: 'Error', configurableFor: true },
 
   'def-invalid-key-cardinality': { severity: 'Error' },
   // Published! Used in @cap-js-community/odata-v2-adapter; if renamed, add to oldMessageIds
-  'odata-spec-violation-array': { severity: 'Warning', configurableFor: true, errorFor: ['v5'] }, // more than 30 chars
+  'odata-spec-violation-array': { severity: 'Warning' }, // more than 30 chars
   // Published! Used in @cap-js-community/odata-v2-adapter; if renamed, add to oldMessageIds
-  'odata-spec-violation-assoc': { severity: 'Warning', configurableFor: true, errorFor: ['v5'] }, // more than 30 chars
+  'odata-spec-violation-assoc': { severity: 'Warning' }, // more than 30 chars
   // Published! Used in @cap-js-community/odata-v2-adapter; if renamed, add to oldMessageIds
   'odata-spec-violation-constraints': { severity: 'Info' }, // more than 30 chars
   'odata-spec-violation-id': { severity: 'Error', configurableFor: true },
-  'odata-spec-violation-namespace': { severity: 'Warning', configurableFor: true, errorFor: ['v5'] }, // more than 30 chars
+  'odata-spec-violation-namespace': { severity: 'Warning' }, // more than 30 chars
   // Published! Used in @cap-js-community/odata-v2-adapter; if renamed, add to oldMessageIds
-  'odata-spec-violation-param': { severity: 'Warning', configurableFor: true, errorFor: ['v5'] }, // more than 30 chars
+  'odata-spec-violation-param': { severity: 'Warning' }, // more than 30 chars
   // Published! Used in @cap-js-community/odata-v2-adapter; if renamed, add to oldMessageIds
-  'odata-spec-violation-returns': { severity: 'Warning', configurableFor: true, errorFor: ['v5'] }, // more than 30 chars
+  'odata-spec-violation-returns': { severity: 'Warning' }, // more than 30 chars
   'odata-spec-violation-type': { severity: 'Error', configurableFor: true },
-  'odata-spec-violation-type-unknown': { severity: 'Warning', configurableFor: true, errorFor: ['v5'] },
-  'odata-spec-violation-no-key':  { severity: 'Warning', configurableFor: true, errorFor: ['v5'] },
+  'odata-spec-violation-type-unknown': { severity: 'Error', configurableFor: true },
+  'odata-spec-violation-no-key':  { severity: 'Error', configurableFor: true },
   'odata-spec-violation-key-array':  { severity: 'Error', configurableFor: true }, // more than 30 chars
   'odata-spec-violation-key-null': { severity: 'Error', configurableFor: true }, // more than 30 chars
-  'odata-spec-violation-key-type': { severity: 'Warning', configurableFor: true, errorFor: ['v5'] }, // more than 30 chars
-  'odata-spec-violation-property-name': { severity: 'Warning', configurableFor: true, errorFor: ['v5'] }, // more than 30 chars
+  'odata-spec-violation-key-type': { severity: 'Warning' }, // more than 30 chars
+  'odata-spec-violation-property-name': { severity: 'Warning' }, // more than 30 chars
   'odata-anno-preproc': { severity: 'Warning' },
   'odata-anno-dict': { severity: 'Warning' },
   'odata-anno-vocref': { severity: 'Warning' },
@@ -290,7 +292,6 @@ const centralMessageTexts = {
   'anno-unstable-array': 'Unstable order of array items due to repeated assignments for $(ANNO)',
   'anno-mismatched-ellipsis': 'An array with $(CODE) can only be used if there is an assignment below with an array value',
   'anno-unexpected-ellipsis': 'No base annotation available to apply $(CODE)',
-  'anno-unexpected-mixin': 'Unexpected annotation on mixin definition',
 
   'anno-unexpected-localized-skip': {
     std: 'Compiler generated entity $(NAME) must not be annotated with $(ANNO) if $(ART) is not skipped',
@@ -351,7 +352,7 @@ const centralMessageTexts = {
   'syntax-ignoring-decimal': {
     std: 'Ignoring decimal places, because an integer was expected'
   },
-  'syntax-ignoring-anno': {
+  'syntax-unexpected-anno': {
     std: 'Annotations can\'t be used in a column with $(CODE)',
     doc: 'Doc comments can\'t be used in a column with $(CODE)',
   },
@@ -435,7 +436,6 @@ const centralMessageTexts = {
     service: 'Annotations can\'t be defined inside services',
     context: 'Annotations can\'t be defined inside contexts',
   },
-  // 'syntax-unexpected-space' (TODO: also use for :param, #variant, @(…) and @Begin),
   // 'syntax-unexpected-alias' (is 'syntax-unexpected-property' in CSN)
   'syntax-unsupported-param': {
     std: 'Parameter not supported', // unused
@@ -557,6 +557,10 @@ const centralMessageTexts = {
   // Messages for erroneous references -----------------------------------------
   // location at erroneous reference (if possible)
   'ref-deprecated-orderby': 'Replace source element reference $(ID) by $(NEWCODE); auto-corrected',
+  '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)'
+  },
   'ref-unexpected-self': {
     std: 'Unexpected $(ID) reference; is valid only in ON-conditions of unmanaged associations',
     on: 'Unexpected $(ID) reference; is valid only if compared to be equal to an association of the target side',
@@ -642,6 +646,8 @@ const centralMessageTexts = {
     std: 'Unexpected reference to association $(NAME)', // "std" currently unused
     unmanaged: 'Unexpected reference to an unmanaged association',
     'self-unmanaged': 'Unexpected column reference starting with $(ALIAS) to an unmanaged association',
+    'with-filter': 'Unexpected reference to an association with filter',
+    'self-with-filter': 'Unexpected column reference starting with $(ALIAS) to an association with filter',
     self: 'A reference to an unmanaged association is only valid when compared via $(CODE)',
     expr: 'Associations can\'t be used as values in expressions',
     'expr-comp': 'Compositions can\'t be used as values in expressions',
@@ -683,6 +689,10 @@ const centralMessageTexts = {
     hdbcds:'Type $(TYPE) is not supported in HDBCDS',
     odata: 'Type $(TYPE) is not supported for OData'
   },
+  'ref-unexpected-var': {
+    std: 'Variable $(NAME) can\'t be used here',
+    'annotation': 'Variable $(NAME) can only be used in annotation values',
+  },
 
   // TODO: Better text ?
   'rewrite-not-supported': 'The ON-condition is not rewritten here - provide an explicit ON-condition',
@@ -746,6 +756,7 @@ const centralMessageTexts = {
     returns: 'Return value of $(ART) has no element $(NAME)',
     'enum-returns': 'Return value of $(ART) has no enum $(NAME)',
   },
+  '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)'
@@ -837,12 +848,6 @@ const centralMessageTexts = {
     'include-elements': 'Duplicate element $(NAME) through multiple includes $(SORTED_ARTS)',
     'include-actions': 'Duplicate action or function $(NAME) through multiple includes $(SORTED_ARTS)',
   },
-  // TODO: Remove in v5, use duplicate-definition (or another ID?)
-  'ref-duplicate-include-member': {
-    std: 'Duplicate member $(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)',
-  },
   'ref-invalid-element': {
     std: 'Invalid element reference',
     $tableAlias: 'Can\'t refer to source elements of table alias $(ID)',
@@ -859,6 +864,7 @@ const centralMessageTexts = {
     'old-not-target': 'Expected element $(NAME) not to be an association, because it overrides the included element from $(ART)',
   },
 
+  'ref-expecting-$self': 'Use $(NEWCODE) instead of $(CODE) here or remove $(CODE) altogether if possible; the compiler has rewritten it to $(NEWCODE) in CSN',
   'ref-expecting-assoc': 'Expecting path $(ELEMREF) following “EXISTS” predicate to end with association/composition, found $(TYPE)',
   'ref-expecting-const': 'A constant expression or variable is expected here',
   'ref-expecting-foreign-key': 'Expecting foreign key access after managed association $(NAME) in filter expression of $(ID), but found $(ALIAS)',
@@ -908,9 +914,7 @@ const centralMessageTexts = {
     'indirect': 'Type property $(PROP) can only be extended if directly provided at the definition',
     'new-prop': 'Type property $(PROP) can only be extended, not added',
     string: 'Only numerical properties can be extended, but found string for $(PROP)',
-    // eslint-disable-next-line max-len
     number: 'Value of type property $(PROP) must be $(NUMBER) or higher, it can\'t be smaller than originally provided',
-    // eslint-disable-next-line max-len
     scale: 'With the extension for type property $(OTHERPROP), the value of $(PROP) must be $(NUMBER) or higher',
   },
   'ext-missing-type-property': 'Type extension with property $(PROP) must also have property $(OTHERPROP) because $(ART) has both',
@@ -966,6 +970,15 @@ const centralMessageTexts = {
     'managed': 'Ignoring managed association $(NAME) that is published in a UNION',
     'std': 'Ignoring association $(NAME) that is published in a UNION'
   },
+  'query-missing-element': {
+    std: 'Element $(ID) is missing in specified elements',
+    enum: 'Enum $(ID) is missing in specified enum values',
+    foreignKeys: 'Foreign key $(ID) is missing in specified foreign keys',
+  },
+  'query-unspecified-element': {
+    std: 'Element $(ID) does not result from the query',
+    foreignKeys: 'Foreign key $(ID) does not result from the query',
+  },
 
   'ref-sloppy-target': 'An entity or an aspect (not type) is expected here',
 
@@ -1193,7 +1206,8 @@ const centralMessageTexts = {
     'notaneelement': 'EDM Parameter path $(ELEMREF) can\'t be used in $(ANNO) which is applied to a type entity',
     'notrendered': 'EDM Path step $(COUNT) of $(ELEMREF) in $(ANNO) refers to an unrendered property in the OData API',
     'magic': 'Unexpected magic variable $(ELEMREF) in $(ANNO)',
-    'bparam_v2': 'Unexpected explicit binding parameter path $(ELEMREF) for OData $(VERSION) in $(ANNO)',
+    'bparam_v2_expl': 'Unexpected explicit binding parameter path $(ELEMREF) for OData $(VERSION) in $(ANNO)',
+    'bparam_v2_impl': 'Unexpected implicit binding parameter path $(ELEMREF) for OData $(VERSION) in $(ANNO)',
   },
   // -----------------------------------------------------------------------------------
   // OData Message section ends here, no messages below this line

package/lib/base/messages.js

@@ -13,6 +13,7 @@ const { analyseCsnPath, traverseQuery } = require('../model/csnRefs');
 const { CompilerAssertion } = require('./error');
 const { getArtifactName } = require('../compiler/base');
 const { cdlNewLineRegEx } = require('../language/textUtils');
+const meta = require('./meta');
 
 const fs = require('fs');
 const path = require('path');
@@ -73,8 +74,8 @@ function isDowngradable( messageId, moduleName, options ) {
     return false;
   if (msg.severity !== 'Error')
     return true;
-  // v5 messages are downgradable (except if errorFor also contains the current module).
-  if (msg.errorFor && msg.errorFor.includes('v5'))
+  // v6 messages are downgradable (except if errorFor also contains the current module).
+  if (msg.errorFor && msg.errorFor.includes('v6'))
     return true;
   const { configurableFor } = msg;
   return (Array.isArray( configurableFor ))
@@ -91,9 +92,11 @@ function isDowngradable( messageId, moduleName, options ) {
 function severityChangeMarker(msg, config) {
   const severity = msg.severity || 'Error';
   if (config.moduleForMarker) {
-    if (severity === 'Error' && isDowngradable(msg.messageId, config.moduleForMarker, {}))
+    if (severity === 'Error' &&
+        isDowngradable( msg.messageId, config.moduleForMarker,
+                        { deprecated: { downgradableErrors: true } }))
       return '‹↓›';
-    if (msg.messageId && centralMessages[msg.messageId]?.errorFor?.includes('v5'))
+    if (msg.messageId && centralMessages[msg.messageId]?.errorFor?.includes('v6'))
       return '‹↑›';
   }
   return '';
@@ -107,12 +110,16 @@ function severityChangeMarker(msg, config) {
 class CompilationError extends Error {
   /**
    * @param {CompileMessage[]} messages
-   * @param {boolean} [dontSerializeMessages] If true, compiler messages are NOT part of the errors message text.
    * @param {XSN.Model} [model] the XSN model, only to be set with options.attachValidNames
    */
-  constructor(messages, model, dontSerializeMessages) {
-    const msg = !dontSerializeMessages && messages?.map( m => m.toString() ).join('\n') || '';
-    super( `CDS compilation failed\n${msg}` );
+  constructor(messages, model) {
+    // Because test frameworks such as mocha and jest to not call `toString()` on
+    // an unhandled CompilationError and instead use `e.stack` directly, there is
+    // no proper message about _what_ the root cause of the exception was.
+    // To mitigate that, we serialize the first error in the message as well.
+    const firstError = messages.find( m => m.severity === 'Error' )?.toString() || '';
+    super( `CDS compilation failed (@sap/cds-compiler v${ meta.version() })\n${firstError}` );
+
     /** @since v4.0.0 */
     this.code = 'ERR_CDS_COMPILATION_FAILURE';
     this.messages = [ ...messages ].sort(compareMessageSeverityAware);
@@ -240,7 +247,7 @@ function reclassifiedSeverity( msg, options, moduleName ) {
       if (errorFor.includes(moduleName))
         return 'Error';
 
-      if (errorFor.includes('v5') && isBetaEnabled(options, 'v5preview')) {
+      if (errorFor.includes('v6') && isBetaEnabled(options, 'v6preview')) {
         severity = 'Error';
         if (!isDowngradable(msg.messageId, moduleName, options))
           return severity;
@@ -555,8 +562,7 @@ function makeMessageFunction( model, options, moduleName = null ) {
 
   function throwWithError() {
     if (hasNewError) {
-      const dontSerializeMessages = isBetaEnabled(options, 'v5preview');
-      throw new CompilationError(messages, options.attachValidNames && model, dontSerializeMessages);
+      throw new CompilationError(messages, options.attachValidNames && model);
     }
   }
 
@@ -573,8 +579,7 @@ function makeMessageFunction( model, options, moduleName = null ) {
       return;
     const hasError = options.testMode ? hasNonDowngradableErrors : hasErrors;
     if (hasError( messages, moduleName, options )) {
-      const dontSerializeMessages = isBetaEnabled(options, 'v5preview');
-      throw new CompilationError(messages, options.attachValidNames && model, dontSerializeMessages);
+      throw new CompilationError(messages, options.attachValidNames && model);
     }
   }
 
@@ -1018,10 +1023,6 @@ function replaceInString( text, params ) {
  * @param {boolean} [config.noMessageId]
  *     If true, will _not_ show the message ID (+ explanation hint) in the output.
  *
- * @param {boolean} [config.idInBrackets]
- *     If true, the message ID (if there is one and noMessageId is falsey) will be put in brackets.
- *     This will be the default in cds-compiler v5.
- *
  * @param {boolean} [config.noHome]
  *     If true, will _not_ show message's semantic location.
  *
@@ -1049,11 +1050,7 @@ function messageString( err,  config ) {
   const downgradable = severityChangeMarker(err, config);
   // even with noHome, print err.home if the location is weak
   const home = !err.home || config.noHome && err.$location?.endLine ? '' : ` (in ${ err.home })`;
-
-  let msgId = ''; // TODO(v5): Use brackets only
-  if (err.messageId && !config.noMessageId)
-    msgId = (config.idInBrackets) ? `[${err.messageId}]` : ` ${err.messageId}`;
-
+  const msgId = (err.messageId && !config.noMessageId) ? `[${err.messageId}]` : '';
   return `${ location }${ severity }${ downgradable }${ msgId }: ${ err.message }${ home }`;
 }
 
@@ -1065,7 +1062,7 @@ function messageString( err,  config ) {
  * @returns {string} can be used to uniquely identify a message
  */
 function messageHash( msg ) {
-  // parser messages do not provide semantic location, therefore we need to use the file location
+  // parser messages do not provide semantic location, therefore$ we need to use the file location
   if (!msg.home)
     return messageString(msg);
   const copy = { ...msg };
@@ -1118,7 +1115,7 @@ function messageHash( msg ) {
  *     If true/'always', ANSI escape codes will be used for coloring the severity.  If false/'never',
  *     no coloring will be used.  If 'auto', we will decide based on certain factors such
  *     as whether the shell is a TTY and whether the environment variable `NO_COLOR` is
- *     unset.
+ *     unset or whether `FORCE_COLOR` is set.
  *
  * @returns {string}
  */
@@ -1285,7 +1282,7 @@ function _messageContext( err, config ) {
  * @param {boolean | 'auto'} [config.color] If true, ANSI escape codes will be used for coloring the `^`.  If false, no
  *                                          coloring will be used.  If 'auto', we will decide based on certain factors such
  *                                          as whether the shell is a TTY and whether the environment variable 'NO_COLOR' is
- *                                          unset.
+ *                                          unset or `FORCE_COLOR` is set.
  * @returns {string}
  *
  * @deprecated Use `messageStringMultiline()` with `config.sourceMap` and `config.sourceLineMap` instead!
@@ -1353,7 +1350,7 @@ function compareMessageSeverityAware( a, b ) {
 /**
  * Return sort-relevant part of semantic location (after the ':').
  * Messages without semantic locations are considered smaller (for syntax errors)
- * and (currently - should not happen in v5) larger for other messages.
+ * and (currently - should not happen in v6) larger for other messages.
  *
  * @param {CompileMessage} msg
  */

package/lib/base/meta.js

@@ -0,0 +1,10 @@
+'use strict';
+
+// Metadata, e.g. version.
+
+/** The compiler version (taken from package.json) */
+function version() {
+  return require('../../package.json').version;
+}
+
+module.exports = { version };

package/lib/base/model.js

@@ -31,11 +31,9 @@ const availableBetaFlags = {
   enableUniversalCsn: true,
   odataTerms: true,
   optionalActionFunctionParameters: true, // not supported by runtime, yet.
-  annotateForeignKeys: true,
   effectiveCsn: true,
   tenantVariable: true,
   calcAssoc: true,
-  v5preview: true,
   temporalRawProjection: true,
   // disabled by --beta-mode
   nestedServices: false,

package/lib/base/node-helpers.js

@@ -28,7 +28,6 @@ class PromiseAllError extends Error {
   }
 }
 
-
 module.exports = {
   promiseAllDoNotRejectImmediately,
 };

package/lib/base/optionProcessorHelper.js

@@ -42,6 +42,7 @@ function createOptionProcessor() {
     },
     help,
     processCmdLine,
+    makePositionalArgumentsOptional,
   };
   return optionProcessor;
 
@@ -291,6 +292,16 @@ function createOptionProcessor() {
     };
   }
 
+  function makePositionalArgumentsOptional() {
+    for (const arg of optionProcessor.positionalArguments || [])
+      arg.required = false;
+
+    for (const cmd in optionProcessor.commands) {
+      for (const arg of optionProcessor.commands[cmd].positionalArguments || [])
+        arg.required = false;
+    }
+  }
+
   // API: Let the option processor digest a command line 'argv'
   // The expectation is to get a commandline like this:
   //       $ node cdsc.js -x 1 --foo toXyz -y --bar-wiz bla arg1 arg2

package/lib/checks/dbFeatureFlags.js

@@ -2,6 +2,7 @@
 
 const { setProp } = require('../base/model');
 const { featureFlags } = require('../transform/db/featureFlags');
+const { isSqlService } = require('../transform/db/processSqlServices');
 
 /**
  *
@@ -25,4 +26,8 @@ module.exports = {
   value: setFeatureFlag('$calculatedElements'),
   expand: setFeatureFlag('$expandInline'),
   inline: setFeatureFlag('$expandInline'),
+  kind: function setFeatureFlagForSqlService( artifact ) {
+    if (isSqlService(artifact))
+      setFeatureFlag( '$sqlService' ).call(this);
+  },
 };

package/lib/checks/enricher.js

@@ -49,7 +49,6 @@ function enrichCsn( csn, options ) {
     dictionary( csn, 'definitions', csn.definitions );
   return { csn, cleanup };
 
-  // eslint-disable-next-line jsdoc/require-jsdoc
   function standard( parent, prop, node ) {
     if (!node || typeof node !== 'object' || !{}.propertyIsEnumerable.call( parent, prop ))
       return;
@@ -69,7 +68,7 @@ function enrichCsn( csn, options ) {
     }
     csnPath.pop();
   }
-  // eslint-disable-next-line jsdoc/require-jsdoc
+
   function dictionary( node, prop, dict ) {
     setProp(node, '$path', [ ...csnPath ]);
     cleanupCallbacks.push(() => delete node.$path);
@@ -115,7 +114,6 @@ function enrichCsn( csn, options ) {
     }
   }
 
-  // eslint-disable-next-line jsdoc/require-jsdoc
   function columns( parent, prop, node ) {
     // Establish the link relationships
     parent[prop].forEach((column) => {
@@ -130,7 +128,6 @@ function enrichCsn( csn, options ) {
     standard(parent, prop, node);
   }
 
-  // eslint-disable-next-line jsdoc/require-jsdoc
   function simpleRef( node, prop, ref ) {
     setProp(node, '$path', [ ...csnPath ]);
     cleanupCallbacks.push(() => delete node.$path);
@@ -158,7 +155,6 @@ function enrichCsn( csn, options ) {
     }
   }
 
-  // eslint-disable-next-line jsdoc/require-jsdoc
   function pathRef( node, prop, path ) {
     const {
       links, art, scope, $env,

package/lib/checks/structuredAnnoExpressions.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const { isBuiltinType } = require('../base/builtins');
+const { transformExpression, applyTransformationsOnNonDictionary } = require('../model/csnUtils');
+/**
+ *
+ * @param {object} member
+ */
+function checkAnnotationExpression( member, _memberName, _prop, path ) {
+  Object.keys(member).filter(pn => pn[0] === '@').forEach((anno) => {
+    applyTransformationsOnNonDictionary(member, anno, {
+      xpr: (parent, prop, _xpr, xprPath) => {
+        transformExpression(parent, prop, {
+          ref: (elemref, __prop, ref, refPath) => {
+            const { art, scope } = this.csnUtils.inspectRef(refPath);
+            if (scope !== '$magic' && art) {
+              const ft = this.csnUtils.getFinalTypeInfo(art.type);
+              if (!isBuiltinType(ft?.type))
+                this.error('odata-anno-xpr-ref', refPath, { anno, elemref, '#': 'flatten_builtin_type' });
+            }
+          },
+        }, xprPath);
+      },
+    }, {}, path);
+  });
+}
+
+module.exports = {
+  checkAnnotationExpression,
+};

package/lib/checks/validator.js

@@ -15,6 +15,7 @@ const navigationIntoMany = require('./manyNavigations');
 const checkUsedTypesForAnonymousAspectComposition = require('./managedInType');
 const validateHasPersistedElements = require('./hasPersistedElements');
 const checkForHanaTypes = require('./checkForTypes');
+const { checkAnnotationExpression } = require('./structuredAnnoExpressions');
 const checkForParams = require('./parameters');
 // forOdata
 const { validateDefaultValues } = require('./defaultValues');
@@ -210,6 +211,13 @@ function forRelationalDB( csn, that ) {
                         duplicate messages due to the forEachMemberRecursively.
                         TODO: check if this recursion can be factored out of the validator */
                        forEachMember(artifact, checkUsedTypesForAnonymousAspectComposition.bind(that));
+                     },
+                     (artifact, artifactName) => {
+                       if (that.options.transformation === 'effective') {
+                         forEachMemberRecursively(artifact, checkAnnotationExpression.bind(that), [ 'definitions', artifactName ], false, {
+                           skipArtifact: a => a.returns || (a.params && !a.query),
+                         });
+                       }
                      }
                    ),
                    forRelationalDBQueryValidators.concat(commonQueryValidators),

package/lib/compiler/assert-consistency.js

@@ -208,6 +208,7 @@ function assertConsistency( model, stage ) {
             'elements', '$autoElement', '$uncheckedElements', '_origin', '_extensions',
             '$requireElementAccess', '_effectiveType', '$effectiveSeqNo', '_deps',
             '$calcDepElement', '$filtered', '$enclosed', '_parent',
+            'deprecated', '$onlyInExprCtx',
           ],
           schema: {
             kind: { test: isString, enum: [ 'builtin' ] },
@@ -215,6 +216,8 @@ function assertConsistency( model, stage ) {
             $autoElement: { test: isString },
             $uncheckedElements: { test: isBoolean },
             $requireElementAccess: { test: isBoolean },
+            deprecated: { test: isBoolean },
+            $onlyInExprCtx: { test: TODO },
             // missing location for normal "elements"
             elements: { test: TODO },
           },
@@ -252,6 +255,7 @@ function assertConsistency( model, stage ) {
     elements: { kind: true, inherits: 'definitions', also: [ 0 ] }, // 0 for cyclic expansions
     // specified elements in query entities (TODO: introduce real "specified elements" instead):
     elements$: { kind: true, enumerable: false, test: TODO },
+    foreignKeys$: { kind: true, enumerable: false, test: TODO },
     enum$: { kind: true, enumerable: false, test: TODO },
     typeProps$: { kind: true, enumerable: false, test: TODO },
     // helper property for faster processing:
@@ -703,7 +707,7 @@ function assertConsistency( model, stage ) {
         'localized', // e.g. compiler-generated elements for localized: `text` assoc, etc.
         'localized-entity', // `.texts` entity
         'localized-origin', // `.texts` entity
-        'nav', // only used for MASKED, TODO(v5): Remove
+        'nav', // only used for MASKED, TODO(v6): Remove
         'none', // only used in ensureColumnName(): Used in object representing empty alias
         'query', // inferred query properties, e.g. `key`
         'rewrite', // on-conditions or FKeys are rewritten

package/lib/compiler/base.js

@@ -48,7 +48,7 @@ const kindProperties = {
     normalized: 'action',
     dict: 'actions',
   }, // no extend params, only annotate
-  key: { normalized: 'element' },
+  key: { normalized: 'element', dict: 'elements' }, // dict for annotate
   param: { elements: () => false, enum: () => false, dict: 'params' },
   source: { artifacts: true },  // TODO -> $source
   using: {},

package/lib/compiler/builtins.js

@@ -178,14 +178,15 @@ const magicVariables = {
     // Allow shortcut in CDL: `$user` becomes `$user.id` in CSN.
     $autoElement: 'id',
   },
-  $at: {
+  $at: { // $at is considered deprecated since cds-compiler v5
     elements: {
       from: {}, to: {},
     },
     // Require that elements are accessed, i.e. no $at, only $at.<element>.
     $requireElementAccess: true,
+    deprecated: true, // $at is deprecated; use $valid
   },
-  $valid: { // dito
+  $valid: {
     elements: {
       from: {}, to: {},
     },
@@ -200,6 +201,15 @@ const magicVariables = {
     $uncheckedElements: true,
     $requireElementAccess: true,
   },
+  $draft: {
+    elements: {
+      IsActiveEntity: {},
+    },
+    // Require that elements are accessed, i.e. no $draft, only $draft.<element>.
+    $requireElementAccess: true,
+    // See reference semantics in shared.js
+    $onlyInExprCtx: [ 'annotation', 'annoRewrite' ],
+  },
 };
 
 // see lib/render/renderUtil.js for DB-specific magic vars, specified in CAP CDS  via function
@@ -437,6 +447,10 @@ function initBuiltins( model ) {
         art.$uncheckedElements = magic.$uncheckedElements;
       if (magic.$requireElementAccess)
         art.$requireElementAccess = magic.$requireElementAccess;
+      if (magic.deprecated)
+        art.deprecated = magic.deprecated;
+      if (magic.$onlyInExprCtx)
+        art.$onlyInExprCtx = magic.$onlyInExprCtx;
 
       createMagicElements( art, magic.elements );
       if (options.variableReplacements?.[id])
@@ -461,6 +475,8 @@ function initBuiltins( model ) {
       // Propagate this property so that it is available for sub-elements.
       if (art.$uncheckedElements)
         magic.$uncheckedElements = art.$uncheckedElements;
+      if (art.$onlyInExprCtx)
+        magic.$onlyInExprCtx = art.$onlyInExprCtx;
       setProp( magic, '_parent', art );
       // setProp( magic, '_effectiveType', magic );
       if (elements[id] && typeof elements[id] === 'object')

package/lib/compiler/checks.js

@@ -54,9 +54,6 @@ function check( model ) {
   function checkEvent( def ) {
     // Ensure that events are structured. Up to compiler v4, we allowed non-structured events,
     // because when we introduced them, it was not fully specified what they are.
-    // TODO(v5):
-    //  - Make this a (configurable) error; move to acceptTypeOrElement
-    //  - require type/elements to be set in parser
     if (def.kind === 'event' && !def._effectiveType?.elements && !def._effectiveType?.projection)
       message( 'def-expected-structured', [ (def.type || def.name).location, def ] );
   }
@@ -862,8 +859,8 @@ function check( model ) {
       // Tree-ish expression from the compiler (not augmented)
       // eslint-disable-next-line max-len
       return (isAssociationOperand( xpr.args[0] ) && isDollarSelfOrProjectionOperand( xpr.args[2] ) ||
-      // eslint-disable-next-line max-len
-             isAssociationOperand( xpr.args[2] ) && isDollarSelfOrProjectionOperand( xpr.args[0] ));
+              // eslint-disable-next-line max-len
+              isAssociationOperand( xpr.args[2] ) && isDollarSelfOrProjectionOperand( xpr.args[0] ));
     }
 
     // Nothing else qualifies