@sap/cds-compiler 6.0.14 → 6.2.2

package/lib/gen/Dictionary.json

@@ -3231,13 +3231,6 @@
         "ValidationFunction": "Common.QualifiedName"
       }
     },
-    "Common.DraftUserAccessType": {
-      "$kind": "ComplexType",
-      "Properties": {
-        "UserAccessRole": "Edm.String",
-        "UserID": "Edm.String"
-      }
-    },
     "Common.EffectType": {
       "$deprecated": true,
       "$deprecationText": "All side effects are essentially value changes, differentiation not needed.",
@@ -3513,6 +3506,7 @@
         "Label": "Edm.String",
         "Parameters": "Collection(Common.ValueListParameter)",
         "PresentationVariantQualifier": "Core.SimpleIdentifier",
+        "RelativeCollectionPath": "Edm.NavigationPropertyPath",
         "SearchSupported": "Edm.Boolean",
         "SelectionVariantQualifier": "Core.SimpleIdentifier"
       }

package/lib/gen/cdlKeywords.json

@@ -0,0 +1,26 @@
+{
+  "reserved": [
+    "ALL",
+    "ANY",
+    "AS",
+    "BY",
+    "CASE",
+    "CAST",
+    "DISTINCT",
+    "EXISTS",
+    "FALSE",
+    "FROM",
+    "IN",
+    "KEY",
+    "NOT",
+    "NULL",
+    "OF",
+    "ON",
+    "SELECT",
+    "SOME",
+    "TRUE",
+    "WHEN",
+    "WHERE",
+    "WITH"
+  ]
+}

package/lib/inspect/inspectPropagation.js

@@ -36,7 +36,7 @@ function inspectPropagation( xsn, options, artifactName ) {
 
   if (!artifactXsn) {
     error(null, null, { name: artifactName },
-          // eslint-disable-next-line @stylistic/js/max-len
+          // eslint-disable-next-line @stylistic/max-len
           'Artifact $(NAME) not found, only top-level artifacts and their elements are supported for now');
     return null;
   }

package/lib/json/from-csn.js

@@ -137,7 +137,7 @@ const typeProperties = [
   // do not include CSN v0.1.0 properties here:
   'target', 'elements', 'enum', 'items',
   'cardinality', // for association publishing in views
-  'type', 'length', 'precision', 'scale', 'srid', 'localized', 'notNull',
+  'type', 'length', 'precision', 'scale', 'srid', 'localized', 'notNull', 'default',
   'keys', 'on',                 // only with 'target'
 ];
 const exprProperties = [
@@ -1142,7 +1142,7 @@ function elementsDict( def, spec, xsn ) {
     return elements;
   warning( 'syntax-expecting-returns', elements[$location],
            { prop: 'elements', parentprop: 'returns' },
-           // eslint-disable-next-line @stylistic/js/max-len
+           // eslint-disable-next-line @stylistic/max-len
            'Expecting property $(PROP) to be put into an object for property $(PARENTPROP) when annotating action return structures' );
   xsn.returns = { kind: 'annotate', elements, location: elements[$location] };
   return undefined;

package/lib/json/to-csn.js

@@ -201,7 +201,7 @@ const propertyOrder = (function orderPositions() {
 const typeProperties = [
   'target', 'elements', 'enum', 'items',
   'cardinality', // for association publishing in views
-  'type', 'length', 'precision', 'scale', 'srid', 'localized', 'notNull',
+  'type', 'length', 'precision', 'scale', 'srid', 'localized', 'notNull', 'default',
   'foreignKeys', 'on',      // for explicit ON/keys with REDIRECTED
   '$typeArgs', // for unresolved type arguments, e.g. through parseCql
 ];
@@ -1319,11 +1319,15 @@ function flattenInternalXpr( array, xprOp ) {
 function ternaryOperator( node ) {
   const rargs = [
     'case',
-    'when', exprInternal(node.args[0]),
-    'then', exprInternal(node.args[2]),
-    'else', exprInternal(node.args[4]),
-    'end',
+    'when', exprInternal( node.args[0] ),
+    'then', exprInternal( node.args[2] ),
   ];
+  let right = node.args[4];
+  for (; right.op?.val === '?:' && !right.$parens?.length; right = right.args[4]) {
+    rargs.push( 'when', exprInternal( right.args[0] ),
+                'then', exprInternal( right.args[2] ) );
+  }
+  rargs.push( 'else', exprInternal( right ), 'end' );
 
   if (node.$parens?.length)
     return { xpr: flattenInternalXpr( rargs, 'xpr' ) };

package/lib/language/multiLineStringParser.js

@@ -77,7 +77,7 @@ class MultiLineStringParser {
     this.str = token.text; // Copy because .text is a getter
 
     if (this.str[0] !== '`' || this.str[this.str.length - 1] !== '`')
-      // eslint-disable-next-line @stylistic/js/max-len
+      // eslint-disable-next-line @stylistic/max-len
       throw new CompilerAssertion('Invalid multi-line string sequence: Require string to be surrounded by back-ticks!');
 
     this.output = [];

package/lib/main.d.ts

@@ -158,6 +158,16 @@ declare namespace compiler {
      * @since v4.2.0
      */
     moduleLookupDirectories?: string[]
+    /**
+     * An [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal)
+     * that can be used to abort the compilation.
+     * Used for any `async` task, i.e. at the moment for reading/parsing files.
+     *
+     * Note that this flag has no effect on _synchronous_ compilation functions.
+     *
+     * @since v6.1
+     */
+    abortSignal?: AbortSignal
     /**
      * Option for {@link compileSources}.  If set, all objects inside the
      * provided sources dictionary are interpreted as XSN structures instead
@@ -1558,8 +1568,6 @@ declare namespace compiler {
     constructor(location: Location, msg: string, severity?: MessageSeverity, id?: string | null, home?: string | null, moduleName?: string | null);
     /**
      * Optional ID of the message.  Can be used to reclassify messages.
-     *
-     * @note This property is non-enumerable as message IDs are not finalized, yet.
      */
     messageId?: string
 

package/lib/model/cloneCsn.js

@@ -39,6 +39,7 @@ const internalCsnProps = {
   $notNull: shallowCopy, // used for HANA CSN migrations
   $sqlService: shallowCopy,
   $dummyService: shallowCopy,
+  $dataProductService: shallowCopy,
 };
 const internalEnumerableCsnProps = {
   __proto__: null,

package/lib/optionProcessor.js

@@ -1,6 +1,6 @@
 // Compiler options
 
-/* eslint @stylistic/js/max-len: 0 */
+/* eslint @stylistic/max-len: 0 */
 
 // Remarks:
 // - The specification is client-tool centric (bin/cdsc.js):
@@ -169,7 +169,8 @@ optionProcessor
     Q, toSql [options] <files...>               Generate SQL DDL statements
     J, forJava [options] <files...>             Generate CSN for the Java Runtime
        toCsn [options] <files...>               (default) Generate original model as CSN
-       parseCdl [options] <file>                Generate a CSN that is close to the CDL source.
+       parse [options] <file>                   Parse the input file. For CDL input, generate a CSN that is
+                                                close to the CDL source.
        explain <message-id>                     Explain a compiler message.
        parseOnly [options] <files...>           (internal)  Stop compilation after parsing, write messages to <stderr>,
                                                 per default no output.
@@ -263,6 +264,8 @@ optionProcessor.command('O, toOdata')
   .option('    --odata-v2-partial-constr')
   .option('    --odata-vocabularies <list>')
   .option('    --odata-no-creator')
+  .option('    --draft-messages')
+  .option('    --add-annotation-AddressViaNavigationPath')
   .option('-c, --csn')
   .option('-f, --odata-format <format>', { valid: [ 'flat', 'structured' ] })
   .option('-n, --sql-mapping <style>', { valid: [ 'plain', 'quoted', 'hdbcds' ], aliases: [ '--names' ] })
@@ -297,7 +300,10 @@ optionProcessor.command('O, toOdata')
        --odata-vocabularies <list> JSON array of adhoc vocabulary definitions
                                    { prefix: { alias, ns, uri }, ... }
        --odata-no-creator          Omit creator identification in API
-   -n, --sql-mapping <style> Annotate artifacts and elements with "@cds.persistence.name", which is
+       --draft-messages            Add draft messages as part of the draft creation
+       --add-annotation-AddressViaNavigationPath Add annotation "@Common.AddressViaNavigationPath" to the services
+                                                 containing draft enabled entitties
+       -n, --sql-mapping <style> Annotate artifacts and elements with "@cds.persistence.name", which is
                              the corresponding database name (see "--sql-mapping" for "toSql")
                                plain   : (default) Names in uppercase and flattened with underscores
                                quoted  : Names in original case as in CDL. Entity names with dots,
@@ -529,15 +535,15 @@ optionProcessor.command('toCsn')
        --with-localized   Add localized convenience views to the CSN output.
 `);
 
-optionProcessor.command('parseCdl')
+optionProcessor.command('parse', { aliases: [ 'parseCdl' ] })
   .option('-h, --help')
   .positionalArgument('<file>')
   .option('    --with-locations')
   .help(`
-  Usage: cdsc parseCdl [options] <file>
+  Usage: cdsc parse [options] <file>
 
-  Only parse the CDL and output a CSN that is close to the source. Does not
-  resolve imports, apply extensions or expand any queries.
+  Only parse the input file. For CDL input, output a CSN that is close to the source.
+  Does not resolve imports, apply extensions or expand any queries.
 
   Options
        --with-locations   Add $location to CSN artifacts.

package/lib/parsers/AstBuildingParser.js

@@ -47,7 +47,11 @@ const extensionsCode = {
 const PRECEDENCE_OF_EQUAL = 10;
 
 class AstBuildingParser extends BaseParser {
-  leanConditions = { afterBrace: true, atRightParen: true, fail: true };
+  leanConditions = {
+    afterBrace: true,
+    atRightParen: true,
+    fail: true,
+  };
 
   constructor( lexer, keywords, table, options, messageFunctions ) {
     super( lexer, keywords, table ); // lexer has file
@@ -115,13 +119,16 @@ class AstBuildingParser extends BaseParser {
 
   // Guards, Prepare Commands and Lookahead Methods -----------------------------
 
-  tableWithoutAs() {            // not used in <guard=…>, only called by other guard
-    // TODO TOOL: if the tool properly creates `default: this.giR()`, this
-    // condition method is most likely not necessary
-    const { keyword } = this.la();
-    // TODO: if necessary, we could allow some keywords, and just make sure that
-    // all JOIN variants are still possible
-    return keyword && this.keywords[keyword] != null;
+  queryOnLeftSloppyAlias( _arg, mode ) {
+    if (mode === 'M' || this.isNoKeywordInRuleFollow( _arg, mode ))
+      return true;
+    // TODO TOOL: have a base parser method for the test
+    if (this.conditionTokenIdx === this.tokenIdx &&        // tested on same
+        this.conditionStackLength == null)                 // after error recovery
+      return false;
+    if (this.constructor.tracingParser)
+      this._traceSubPush( 'queryOnLeft' );
+    return this.queryOnLeft( 'table', mode );
   }
 
   /**
@@ -134,15 +141,9 @@ class AstBuildingParser extends BaseParser {
    * - <guard=queryOnLeft> tests whether the expression on the left is a query
    * - <guard=queryOnLeft, arg=‹SomeVal›>: tests whether the expression on the
    *   left is a query, then make the current context to be not a query anymore
-   * - <guard=queryOnLeft, arg=tableWithoutAs>: …after having checked
-   *   whether the next token is no (reserved or unreserved) keyword
    */
   queryOnLeft( arg, test ) {
-    if (arg === 'tableWithoutAs') {
-      if (this.tableWithoutAs())
-        return true;
-    }
-    else if (!arg && !test) {
+    if (!arg && !test) {
       // provide new dynamic parentheses context, except with direct
       // recursive call:
       if (this.inSameRule_( this.s, this.stack.at( -1 ).followState ))
@@ -570,7 +571,7 @@ class AstBuildingParser extends BaseParser {
     if (this.l() === ':') {
       this.warning( 'syntax-missing-parens', name,
                     { code: '@‹anno›', op: ':', newcode: '@(‹anno›…)' },
-                    // eslint-disable-next-line @stylistic/js/max-len
+                    // eslint-disable-next-line @stylistic/max-len
                     'When $(CODE) is followed by $(OP), use $(NEWCODE) for annotation assignments at this position' );
     }
   }
@@ -582,7 +583,7 @@ class AstBuildingParser extends BaseParser {
         // do not report error if the '@' is not correct:
         this.s !== null && this.tokenIdx > this.recoverTokenIdx) {
       this.warning( 'syntax-missing-semicolon', next, { code: ';' },
-                    // eslint-disable-next-line @stylistic/js/max-len
+                    // eslint-disable-next-line @stylistic/max-len
                     'Add a $(CODE) and/or newline before the annotation assignment to indicate that it belongs to the next statement' );
     }
   }
@@ -737,7 +738,7 @@ class AstBuildingParser extends BaseParser {
       }
       else if (text.charAt(0) !== '!') {
         this.message( 'syntax-deprecated-ident', location, { delimited: id },
-                      // eslint-disable-next-line @stylistic/js/max-len
+                      // eslint-disable-next-line @stylistic/max-len
                       'Deprecated delimited identifier syntax, use $(DELIMITED) - strings are delimited by single quotes' );
       }
     }
@@ -948,7 +949,7 @@ class AstBuildingParser extends BaseParser {
                     {
                       std: 'Annotation number $(RAWVALUE) is put as $(VALUE) into the CSN',
                       rounded: 'Annotation number $(RAWVALUE) is rounded to $(VALUE)',
-                      // eslint-disable-next-line @stylistic/js/max-len
+                      // eslint-disable-next-line @stylistic/max-len
                       infinite: 'Annotation value $(RAWVALUE) is infinite as number and put as string into the CSN',
                     } );
     }
@@ -1000,7 +1001,7 @@ class AstBuildingParser extends BaseParser {
 
   // TODO: can we remove `;`/EOF from the expected-set for `annotate Foo with ⎀`?
   checkWith( keyword ) {
-    if (this.lb() !== keyword)
+    if (this.lb() !== keyword || ![ ';', '}', 'EOF' ].includes( this.l() ))
       return;
     const tok = this.la();
     const docTokenIndex = this.docCommentIndex &&
@@ -1012,7 +1013,7 @@ class AstBuildingParser extends BaseParser {
     const expecting = this.expectingArray().filter( t => t !== '<EOF>' && t !== '\'}\'' );
     const msg = this.warning( 'syntax-unexpected-semicolon', tok,
                               { offending: this.antlrName( tok ), expecting, keyword: 'with' },
-                              // eslint-disable-next-line @stylistic/js/max-len
+                              // eslint-disable-next-line @stylistic/max-len
                               'Unexpected $(OFFENDING), expecting $(EXPECTING) - ignored previous $(KEYWORD)' );
     msg.expectedTokens = expecting;
   }
@@ -1523,6 +1524,8 @@ class AstBuildingParser extends BaseParser {
   }
 }
 
+AstBuildingParser.prototype.queryOnLeftSloppyAlias.afterError = true;
+
 function addOneForDefinition( count, ext ) {
   return (ext.kind === 'extend') ? count : count + 1;
 }

package/lib/parsers/identifiers.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const cdlKeywords = require('../gen/cdlKeywords.json').reserved;
+
 /** RegEx identifying undelimited identifiers in CDL */
 const undelimitedIdentifierRegex = /^[$_\p{ID_Start}][$\p{ID_Continue}\u200C\u200D]*$/u;
 
@@ -13,36 +15,6 @@ const functionsWithoutParentheses = [
   'CURRENT_USER', 'SESSION_USER', 'SYSTEM_USER',
 ];
 
-// CDL reserved keywords, used for automatic quoting in 'toCdl' renderer
-// TODO: Use `parser.keywords` from our generated CdlParser.js (#13856)
-const cdlKeywords = [
-  'ALL',
-  'ANY',
-  'AS',
-  'BY',
-  'CASE',
-  'CAST',
-  'DISTINCT',
-  'EXISTS',
-  'EXTRACT',
-  'FALSE', // boolean
-  'FROM',
-  'IN',
-  'KEY',
-  'NEW',
-  'NOT',
-  'NULL',
-  'OF',
-  'ON',
-  'SELECT',
-  'SOME',
-  'TRIM',
-  'TRUE', // boolean
-  'WHEN',
-  'WHERE',
-  'WITH',
-];
-
 function isSimpleCdlIdentifier( id ) {
   if (undelimitedIdentifierRegex.test(id))
     return true;

package/lib/render/toCdl.js

@@ -1439,7 +1439,7 @@ class CsnToCdl {
       if (col.cast.target && !col.cast.type)
         result += ` : ${ this.renderRedirectedTo(col.cast, env) }`;
       else
-        result += ` : ${ this.renderTypeReferenceAndProps(col.cast, env, { typeRefOnly: true, noAnnoCollect: true }) }`;
+        result += ` : ${ this.renderTypeReferenceAndProps(col.cast, env, { noAnnoCollect: true }) }`;
       env.path.length -= 1;
     }
     return result;
@@ -1869,9 +1869,12 @@ class CsnToCdl {
       if (artifact.on)
         result += ` on ${ this.exprRenderer.renderExpr(artifact.on, env.withSubPath([ 'on' ])) }`;
 
-      // Foreign keys (if any, unless we also have an ON_condition (which means we have been transformed from managed to unmanaged)
-      if (artifact.keys && !artifact.on)
-        result += ` ${ this.renderForeignKeys(artifact, env) }`;
+      // Foreign keys (if any, unless we also have an ON-condition (which means we have been transformed from managed to unmanaged)
+      if (artifact.keys && !artifact.on) {
+        const keys = this.renderForeignKeys(artifact, env, false);
+        if (keys)
+          result += ` ${ keys }`;
+      }
 
       if (!artifact.on) {
         // unmanaged associations can't be followed by "not null" or "default"
@@ -1923,10 +1926,14 @@ class CsnToCdl {
    */
   renderRedirectedTo( art, env ) {
     let result = `redirected to ${ this.renderDefinitionReference(art.target, env) }`;
-    if (art.on)
+    if (art.on) {
       result += ` on ${ this.exprRenderer.renderExpr(art.on, env.withSubPath([ 'on' ])) }`;
-    else if (art.keys)
-      result += ` ${ this.renderForeignKeys(art, env) }`;
+    }
+    else if (art.keys) {
+      const keys = this.renderForeignKeys(art, env, true);
+      if (keys)
+        result += ` ${ keys }`;
+    }
     return result;
   }
 
@@ -2274,13 +2281,16 @@ class CsnToCdl {
   }
 
   /**
-   * Render foreign keys.
+   * Render foreign keys.  We only render foreign keys if necessary or if we can't say for sure
+   * that the foreign keys would match the implicitly generated ones.
    *
    * @param {object} art
    * @param {CdlRenderEnvironment} env
+   * @param {boolean} alwaysRenderForeignKeys
+   *     If false, only render foreign keys if necessary (i.e. can't be inferred by compiler again).
    * @return {string}
    */
-  renderForeignKeys( art, env ) {
+  renderForeignKeys( art, env, alwaysRenderForeignKeys = false ) {
     const renderedKeys = [];
     let hasAnnotations = false;
     env = env.withSubPath([ 'keys', -1 ]);
@@ -2301,18 +2311,62 @@ class CsnToCdl {
       renderedKeys.push(`${ key }${ alias },`);
     }
 
+    // Annotations on foreign keys always require rendering of explicit keys.
+    // Otherwise, we'd have to use annotate statements here.
     if (hasAnnotations) {
       const sep = `\n${ env.indent }`;
       env.decreaseIndent();
       return `{${ sep }${ renderedKeys.join(sep) }\n${ env.indent }}`;
     }
 
+    if (!alwaysRenderForeignKeys && this.foreignKeysMatchImplicitOnes( art ))
+      return '';
+
     let result = renderedKeys.join(' ');
     if (result[result.length - 1] === ',') // remove trailing comma
       result = result.slice(0, -1);
     return `{ ${ result } }`;
   }
 
+  /**
+   * Returns true, if `to.cdl()` could leave out explicit foreign keys in the rendered output
+   * without changing recompilation.  We do so, because explicit foreign keys are not promoted
+   * on CAPire.
+   *
+   * @param {CSN.Artifact} art
+   * @returns {boolean}
+   */
+  foreignKeysMatchImplicitOnes( art ) {
+    if (art.cardinality && art.cardinality.max !== 1)
+      return false; // e.g. to-many assocs
+
+    const target = this.csn.definitions[art.target];
+    if (!art.keys?.length || !art.target || !target?.elements)
+      return false;
+
+    // We could improve to.cdl() to properly check if keys match, but then we'd have to look
+    // at sub-elements, structures, etc.;  for now, we only check “simple” foreign keys that
+    // don't have any alias.
+    const hasComplexKeys = art.keys.some(key => key.ref?.length !== 1 || key.as !== undefined);
+    if (hasComplexKeys)
+      return false;
+
+    const targetKeys = Object.keys(target.elements).filter(name => target.elements[name]?.key);
+    if (targetKeys.length === 0)
+      return false; // always require explicit keys if there are no target side keys
+
+    const foreignKeys = art.keys.map(key => key.ref[0]);
+    if (foreignKeys.length !== targetKeys.length)
+      return false;
+
+    // We require the _same_ order! Otherwise, recompilation would change the generated foreign key order!
+    for (let i = 0; i < foreignKeys.length; ++i) {
+      if (foreignKeys[i] !== targetKeys[i])
+        return false;
+    }
+    return true;
+  }
+
   /**
    * Render an explicit alias, e.g. for columns.
    *