@sap/cds-compiler 5.5.2 → 5.6.0

package/lib/gen/Dictionary.json

@@ -1114,6 +1114,13 @@
       ],
       "$experimental": true
     },
+    "Common.WebSocketChannel": {
+      "Type": "Edm.String",
+      "AppliesTo": [
+        "EntityContainer"
+      ],
+      "$experimental": true
+    },
     "Communication.Contact": {
       "Type": "Communication.ContactType",
       "AppliesTo": [
@@ -1463,6 +1470,61 @@
         "EntitySet"
       ]
     },
+    "EntityRelationship.entityType": {
+      "Type": "Edm.String",
+      "AppliesTo": [
+        "EntityType"
+      ],
+      "$experimental": true
+    },
+    "EntityRelationship.propertyType": {
+      "Type": "Edm.String",
+      "AppliesTo": [
+        "Property"
+      ],
+      "$experimental": true
+    },
+    "EntityRelationship.entityIds": {
+      "Type": "Collection(EntityRelationship.entityId)",
+      "AppliesTo": [
+        "EntityType"
+      ],
+      "$experimental": true
+    },
+    "EntityRelationship.reference": {
+      "Type": "EntityRelationship.singleReference",
+      "AppliesTo": [
+        "Property"
+      ]
+    },
+    "EntityRelationship.compositeReferences": {
+      "Type": "Collection(EntityRelationship.compositeReference)",
+      "AppliesTo": [
+        "EntityType"
+      ],
+      "$experimental": true
+    },
+    "EntityRelationship.temporalIds": {
+      "Type": "Collection(EntityRelationship.temporalId)",
+      "AppliesTo": [
+        "EntityType"
+      ],
+      "$experimental": true
+    },
+    "EntityRelationship.temporalReferences": {
+      "Type": "Collection(EntityRelationship.temporalReference)",
+      "AppliesTo": [
+        "EntityType"
+      ],
+      "$experimental": true
+    },
+    "EntityRelationship.referencesWithConstantIds": {
+      "Type": "Collection(EntityRelationship.referencesWithConstantId)",
+      "AppliesTo": [
+        "EntityType"
+      ],
+      "$experimental": true
+    },
     "Graph.traceId": {
       "Type": "Edm.String",
       "$experimental": true
@@ -1719,6 +1781,7 @@
         "EntityType",
         "Action",
         "Function",
+        "ActionImport",
         "FunctionImport"
       ]
     },
@@ -1783,7 +1846,8 @@
       "Type": "Collection(UI.CriticalityLabelType)",
       "AppliesTo": [
         "Property",
-        "EntityType"
+        "EntityType",
+        "TypeDefinition"
       ],
       "$experimental": true
     },
@@ -1823,6 +1887,16 @@
         "EntityType"
       ]
     },
+    "UI.OperationParameterFacets": {
+      "Type": "Collection(UI.ReferenceFacet)",
+      "AppliesTo": [
+        "Action",
+        "Function",
+        "ActionImport",
+        "FunctionImport"
+      ],
+      "$experimental": true
+    },
     "UI.SelectionPresentationVariant": {
       "Type": "UI.SelectionPresentationVariantType",
       "AppliesTo": [
@@ -1878,14 +1952,16 @@
       "Type": "Core.Tag",
       "AppliesTo": [
         "Property",
-        "Term"
+        "Term",
+        "TypeDefinition"
       ]
     },
     "UI.IsImage": {
       "Type": "Core.Tag",
       "AppliesTo": [
         "Property",
-        "EntityType"
+        "EntityType",
+        "TypeDefinition"
       ],
       "$experimental": true
     },
@@ -1894,7 +1970,8 @@
       "AppliesTo": [
         "Property",
         "PropertyValue",
-        "Parameter"
+        "Parameter",
+        "TypeDefinition"
       ]
     },
     "UI.Placeholder": {
@@ -2070,7 +2147,8 @@
       "Type": "UI.RecommendationListType",
       "AppliesTo": [
         "Property",
-        "Parameter"
+        "Parameter",
+        "TypeDefinition"
       ]
     },
     "UI.Recommendations": {
@@ -2089,7 +2167,8 @@
     "UI.DoNotCheckScaleOfMeasuredQuantity": {
       "Type": "Edm.Boolean",
       "AppliesTo": [
-        "Property"
+        "Property",
+        "TypeDefinition"
       ],
       "$experimental": true
     },
@@ -3301,6 +3380,7 @@
       "Properties": {
         "SourceProperties": "Collection(Edm.PropertyPath)",
         "SourceEntities": "Collection(Edm.NavigationPropertyPath)",
+        "SourceEvents": "Collection(Edm.String)",
         "TargetProperties": "Collection(Edm.String)",
         "TargetEntities": "Collection(Edm.NavigationPropertyPath)",
         "EffectTypes": "Common.EffectType",
@@ -3777,6 +3857,105 @@
         "DELETE"
       ]
     },
+    "EntityRelationship.singleReference": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "name": "Edm.String",
+        "referencedEntityType": "EntityRelationship.entityTypeID",
+        "referencedPropertyType": "EntityRelationship.propertyTypeID"
+      }
+    },
+    "EntityRelationship.entityId": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "name": "Edm.String",
+        "description": "Edm.String",
+        "propertyTypes": "Collection(EntityRelationship.propertyTypeID)"
+      }
+    },
+    "EntityRelationship.compositeReference": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "name": "Edm.String",
+        "referencedEntityType": "EntityRelationship.entityTypeID",
+        "referencedPropertyType": "Collection(EntityRelationship.referencedPropertyType)"
+      }
+    },
+    "EntityRelationship.referencedPropertyType": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "referencedPropertyType": "EntityRelationship.propertyTypeID",
+        "localPropertyName": "Edm.PropertyPath"
+      }
+    },
+    "EntityRelationship.temporalId": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "name": "Edm.String",
+        "description": "Edm.String",
+        "propertyTypes": "Collection(EntityRelationship.propertyTypeID)",
+        "temporalIntervalType": "EntityRelationship.temporalIntervalTypeEnum",
+        "temporalType": "EntityRelationship.temporalTypeEnum",
+        "temporalIntervalStartProperty": "Edm.PropertyPath",
+        "temporalIntervalEndProperty": "Edm.PropertyPath"
+      }
+    },
+    "EntityRelationship.temporalReference": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "name": "Edm.String",
+        "referencedEntityType": "EntityRelationship.entityTypeID",
+        "referencedPropertyType": "Collection(EntityRelationship.referencedPropertyType)",
+        "category": "EntityRelationship.temporalCategoryEnum",
+        "selectionDateProperty": "Edm.PropertyPath"
+      }
+    },
+    "EntityRelationship.referenceWithConstantId": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "name": "Edm.String",
+        "referencedEntityType": "EntityRelationship.entityTypeID",
+        "referencedPropertyType": "Collection(EntityRelationship.referencedPropertyTypeWithConstantId)"
+      }
+    },
+    "EntityRelationship.referencedPropertyTypeWithConstantId": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "referencedPropertyType": "EntityRelationship.propertyTypeID",
+        "localPropertyName": "Edm.PropertyPath",
+        "constantValue": "Edm.String"
+      }
+    },
+    "EntityRelationship.temporalIntervalTypeEnum": {
+      "$kind": "EnumType",
+      "Members": [
+        "CLOSED_CLOSED",
+        "OPEN_OPEN",
+        "OPEN_CLOSED",
+        "CLOSED_OPEN"
+      ]
+    },
+    "EntityRelationship.temporalTypeEnum": {
+      "$kind": "EnumType",
+      "Members": [
+        "DATE",
+        "DATETIME"
+      ]
+    },
+    "EntityRelationship.temporalCategoryEnum": {
+      "$kind": "EnumType",
+      "Members": [
+        "TEMPORAL_DATE"
+      ]
+    },
+    "EntityRelationship.propertyTypeID": {
+      "$kind": "TypeDefinition",
+      "UnderlyingType": "Edm.String"
+    },
+    "EntityRelationship.entityTypeID": {
+      "$kind": "TypeDefinition",
+      "UnderlyingType": "Edm.String"
+    },
     "Graph.DetailsType": {
       "$kind": "ComplexType",
       "Properties": {

package/lib/parsers/AstBuildingParser.js

@@ -40,6 +40,8 @@ const PRECEDENCE_OF_IN_PREDICATE = 10;
 const PRECEDENCE_OF_EQUAL = 10;
 
 class AstBuildingParser extends BaseParser {
+  leanConditions = { afterBrace: true };
+
   constructor( lexer, keywords, table, options, messageFunctions ) {
     super( lexer, keywords, table ); // lexer has file
     this.options = options;
@@ -212,6 +214,16 @@ class AstBuildingParser extends BaseParser {
     return next !== '*' && next !== '{';
   }
 
+  notAfterEntityArgOrFilter( mode ) {
+    if (mode !== 'M')
+      return true;
+    const { type } = this.lb();
+    if (type !== ')' && type !== ']')
+      return true;
+    const { followState } = this.stack.at( -1 );
+    return !this.table[followState][':'];
+  }
+
   // <prec=10, postfix=once> + test that the next token is not `null`; TODO: code
   // completion for `… default 3 not ~;` → currently just `null` but hey
   isNegatedRelation( _test, prec ) {
@@ -253,6 +265,23 @@ class AstBuildingParser extends BaseParser {
     return !this.dynamic_.inBlock;
   }
 
+  /**
+   * Restrictions according to the expression of a select column.
+   * Currently only to restrict it to a single `Id` for published associations.
+   */
+  columnExpr( mode, arg ) {
+    if (mode)
+      return this.columnExpr$;
+    // TODO: should we use (text of) syntax-unexpected-assoc somewhere ?
+    if (arg)
+      this.columnExpr$ = this.tokenIdx;
+    else if (this.columnExpr$ !== this.tokenIdx - 1 ||
+             this.lb().type !== 'Id' ||
+             [ 'true', 'false', 'null' ].includes( this.lb().keyword ) )
+      this.columnExpr$ = null;
+    return null;
+  }
+
   /**
    * Prepare element restrictions and check validility of final anno assignments.
    *
@@ -321,13 +350,36 @@ class AstBuildingParser extends BaseParser {
     return true;
   }
 
+  noRepeatedCardinality( mode ) {
+    if (this.tokens[this.tokenIdx - 2]?.type !== ']')
+      return true;
+    if (mode === 'M')
+      return false;
+    // currently just warning if same cardinality provided twice
+    const same = { one: '1', many: '*' }[this.la().keyword];
+    return this.tokens[this.tokenIdx - 3]?.text === same;
+  }
+
   /**
    * `;` between statements is optional only after a `}` (ex braces of structure
-   * values for annotations).
+   * values for annotations and foreign key specifications).
+   *
+   * Beware: mentioned in leanConditions, i.e. executed in predictions!
    */
   afterBrace( test ) {
     if (!test)
       this.afterBrace$ = this.tokenIdx;
+    // TODO TOOL: the following test belongs to the BaseParser.js:
+    if (this.conditionTokenIdx === this.tokenIdx &&        // tested on same
+        this.conditionStackLength == null && // after error recover
+        test !== 'M')
+      return true;
+    // Strange optional `;` after PROJECTION ON source: the rule exit prediction
+    // for fromRefWithOptAlias etc now checks C(afterBrace):
+    if (test === 'E' && this.afterBrace$ > 0 &&
+        this.tokens[this.afterBrace$ - 1]?.keyword === 'projection' &&
+        this.tokens[this.afterBrace$].keyword === 'on')
+      return true;
     return this.afterBrace$ === this.tokenIdx;
   }
 
@@ -838,7 +890,7 @@ class AstBuildingParser extends BaseParser {
     // TODO: `literal` needed?
     if (art.cardinality) {
       this.reportDuplicateClause( 'cardinality', targetMax, art.cardinality.targetMax,
-                                  card.keyword, true );
+                                  card.keyword );
     }
     else {
       art.cardinality = { targetMax, location: targetMax.location };
@@ -846,9 +898,9 @@ class AstBuildingParser extends BaseParser {
     return target;
   }
 
+  // TODO: as condition
   reportExpandInline( column, isInline ) {
     // called before matching `{`
-    const { name } = column;
     if (column.value && !column.value.path) {
       // improve error location when using "inline" `.{…}` after ref (arguments and
       // filters not covered, not worth the effort); after an expression where
@@ -864,18 +916,9 @@ class AstBuildingParser extends BaseParser {
       // - no errors for refs inside expand/inline, but for refs in sibling expr
       // - think about: reference to these (sub) elements from other view
     }
-    if (isInline && name) {
-      const alias = this.tokens[this.tokenIdx - 2];
-      const location = (isInline === true)
-        ? alias.location
-        : this.combineLocation( isInline, alias );
-      this.error( 'syntax-unexpected-alias', location, { code: '.{ ‹inline› }' },
-                  'Unexpected alias name before $(CODE)' );
-      // continuation semantics: ignore AS
-    }
   }
 
-  reportDuplicateClause( prop, erroneous, chosen, code, literalValIfNotEq ) {
+  reportDuplicateClause( prop, erroneous, chosen, code ) {
     // probably easier for message linters not to use (?:) for the message id...?
     const args = {
       '#': prop,
@@ -887,11 +930,7 @@ class AstBuildingParser extends BaseParser {
       // TODO v6: duplicate clause = error, independently whether it is the same
       this.warning( 'syntax-duplicate-equal-clause', erroneous.location, args );
     }
-    else if (prop !== 'notNull') { // already via guard in grammar
-      if (literalValIfNotEq)
-        args.code = chosen.val;
-      this.message( 'syntax-duplicate-clause', erroneous.location, args );
-    }
+    // TODO extra msg text 'syntax-duplicate-clause' for noRepeatedCardinality()
   }
 
   setTypeFacet( art, name, value ) {
@@ -1090,20 +1129,16 @@ class AstBuildingParser extends BaseParser {
     };
   }
 
+  // TODO: as condition
   associationInSelectItem( art ) {
+    if (art.name)
+      return;
     this.classifyImplicitName( 'ItemAssoc', art.value );
     const path = art.value?.path;
-    // we cannot compare "just one token before `:`" because there might be annos
-    if (path && path.length === 1 && !art.name && !art.expand && !art.inline) {
-      const name = path[0];
-      if (path.length === 1 && !name.args && !name.cardinality && !name.where) {
-        art.name = name;
-        delete art.value;
-        return;
-      }
+    if (path?.length) {
+      art.name = path.at( -1 ); // usually length 1, but make it also work during error recovery
+      delete art.value;
     }
-    this.error( 'syntax-unexpected-assoc', this.la(), {},
-                'Unexpected association definition in select item' );
   }
 
   // must be in action directly after having parsed '{', '(`, or a keyword before

package/lib/parsers/CdlGrammar.g4

@@ -507,7 +507,8 @@ mixinElementDef[ outer ] locals[ art = new XsnArtifact() ]
     ( assoc=ASSOCIATION cardinality[ $art ]? TO
     | assoc=COMPOSITION cardinality[ $art ]? OF
     )
-    card=ONE/MANY? target=simplePath
+    ( <cond=noRepeatedCardinality> card=ONE/MANY )?
+    target=simplePath
     { this.setAssocAndComposition( $art, $assoc, $card, $target ); }
     ON expr=condition { $art.on = $expr; }
   ;
@@ -866,11 +867,13 @@ typeExpression[ art ]
     typeProperties[ $art ]?
   |
     assoc=ASSOCIATION <prepare=elementRestriction, arg=calc>
-    cardinality[ $art ]? TO card=ONE/MANY?
+    cardinality[ $art ]? TO
+    ( <cond=noRepeatedCardinality> card=ONE/MANY )?
     typeAssocProperties[ $art, $assoc, $card ]
   |
     assoc=COMPOSITION <prepare=elementRestriction, arg=calc>
-    cardinality[ $art ]? OF card=ONE/MANY?
+    cardinality[ $art ]? OF
+    ( <cond=noRepeatedCardinality> card=ONE/MANY )?
     ( typeAssocProperties[ $art, $assoc, $card ]
     | elementsBlock[ this.setAssocAndComposition( $art, $assoc, $card ) ]
       { $art.target.location = $art.target.elements[Symbol.for('cds.$location')]; }
@@ -989,6 +992,7 @@ typeNamedArgsList[ art ]
 
 typeNamedArg[ art ]
   :
+    // TODO: or keywords with guards for better code completion?
     name=Id['typeparamname']
     ':'
     ( Number
@@ -1055,12 +1059,11 @@ projectionSpec returns[ default query = {} ]
 @finally{ this.attachLocation($query); }
   :
     // TODO, currently just with simple ref
-    PROJECTION { $query = { op: this.valueWithLocation( 'SELECT' ) }; }
+    PROJECTION <prepare=afterBrace> // v6: remove <prepare>
+    { $query = { op: this.valueWithLocation( 'SELECT' ) }; }
     ON
-    tab=fromRefWithOptAlias
+    tab=fromRefWithOptAlias <prepare=afterBrace>
     // TODO: this <prepare=afterBrace> is extremely strange... v6 forbid.
-    // Deliberately set this via action (→ interpreter will not accept this)
-    { this.afterBrace(); }<always>
     { $query.from = tab; }
     selectItemsList[ $query ]?
     excludingClause[ $query ]?
@@ -1225,8 +1228,7 @@ fromRefWithOptAlias returns[ default expr = {} ]
     (
       AS Id['FromAlias'] { $expr.name = this.identAst(); }
     |
-      <cond=tableWithoutAs>
-      // TODO: probably not necessary, TOOL already uses `default: this.giR()`
+      // <cond=tableWithoutAs> not necessary, tool uses `default: this.giR()`
       Id_restricted['FromAlias']
       { $expr.name = this.fragileAlias(); }
     |
@@ -1241,6 +1243,7 @@ fromPath[ table, category ] locals[ pathItem ]
     Id[ $category ] { $table.path.push( $pathItem = this.identAst() ); }
     ( fromArgumentsAndFilter[ $pathItem ] { $pathItem = null; } )?
     (
+      <cond=notAfterEntityArgOrFilter> // TODO TOOL: allow <hide=method>
       '.' { if (!$pathItem && !$table.scope) {
         $table.scope = $table.path.length; $category = 'ref';
         this.warning( 'syntax-invalid-path-separator', this.lb(),
@@ -1356,24 +1359,24 @@ selectItemDef[ columns ] locals[ art = new XsnArtifact(), alias ]
     { $columns.push( $art ); }  // TODO: probably too early
     { this.docComment( $art ); } annoAssignCol[ $art ]*
     ( <cond=modifierRestriction> VIRTUAL
-      { $art.virtual = this.valueWithLocation( true ); } )?
+      { $art.virtual = this.valueWithLocation( true ); }
+    )?
+    {;} <prepare=columnExpr, arg=key>    // TOOL TODO: disappears without {;}
     ( <cond=modifierRestriction> KEY
-      { $art.key = this.valueWithLocation( true ); } )?
+      { $art.key = this.valueWithLocation( true ); }
+    )?
     (
       expr=expression { $art.value = $expr; }
       ( as=AS Id['ItemAlias'] { $art.name = this.identAst(); }
       | Id_restricted['ItemAlias'] { $art.name = this.fragileAlias( true ); }
       | { $alias = this.classifyImplicitName( 'ItemImplicit', $expr ); }
-      )
-      // TODO: <cond> instead `reportExpandInline` for "expand/inline only w/ ref"
-      (
-        { this.reportExpandInline( $art, false ); }
-        nestedSelectItemsList[ $art, 'expand' ]
-        excludingClause[ $art ]?
       |
+        // TODO: guard for ref-only expression can probably replace reportExpandInline
         '.'
         { this.reportUnexpectedSpace( this.lb(), this.la().location, true ); } // TODO: no ERR
         { this.reportExpandInline( $art, $as || true ); }
+        // no extra 'syntax-unexpected-alias' anymore,
+        // 'syntax-unexpected-anno' reported in define.js
         { if ($alias) $alias.token.parsedAs = $alias.parsedAs; }
         (
           nestedSelectItemsList[ $art, 'inline' ]
@@ -1381,13 +1384,21 @@ selectItemDef[ columns ] locals[ art = new XsnArtifact(), alias ]
         |
           '*' { $art.inline = [ this.valueWithLocation() ]; }
         )
+        <exitRule>
+      )
+      // TODO: <cond> instead `reportExpandInline` for "expand/inline only w/ ref"
+      (
+        // TODO: guard for ref-only expression can probably replace:
+        { this.reportExpandInline( $art, false ); }
+        nestedSelectItemsList[ $art, 'expand' ]
+        excludingClause[ $art ]?
       )?
     |
       nestedSelectItemsList[ $art, 'expand' ]
       excludingClause[ $art ]?
       AS Id['ItemAlias'] { $art.name = this.identAst(); }
     )
-    { this.docComment( $art ); } annoAssignMid[ $art ]*
+    { this.docComment( $art ); } <prepare=columnExpr> annoAssignMid[ $art ]*
     (
       ':'
       (
@@ -1396,18 +1407,21 @@ selectItemDef[ columns ] locals[ art = new XsnArtifact(), alias ]
           typeRefOptArgs[ $art ]
         )
       |
+        // TODO: guard for ref-only expression ?
         REDIRECTED TO target=simplePath { $art.target = $target; }
         ( ON cond=condition { $art.on = $cond; }
         | foreignKeysBlock[ $art ]
         )?
       |
-        // TODO: condition for this
-        ( assoc=ASSOCIATION { this.associationInSelectItem( $art ); }
+        ( <cond=columnExpr>     // arg=singleId
+          assoc=ASSOCIATION { this.associationInSelectItem( $art ); }
           cardinality[ $art ]? TO
-        | assoc=COMPOSITION { this.associationInSelectItem( $art ); }
+        | <cond=columnExpr>     // arg=singleId
+          assoc=COMPOSITION { this.associationInSelectItem( $art ); }
           cardinality[ $art ]? OF
         )
-        card=ONE/MANY? target=simplePath
+        ( <cond=noRepeatedCardinality> card=ONE/MANY )?
+        target=simplePath
         { this.setAssocAndComposition( $art, $assoc, $card, $target ); }
         ON expr=condition { $art.on = $expr; }
       )

package/lib/transform/db/expansion.js

@@ -652,6 +652,9 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
       if (typeof root.$env === 'string' && (isComplexOrNestedQuery || options.transformation !== 'odata' || root.$env === pathId(obj.ref[0])))
         obj.ref = [ root.$env, ...obj.ref ];
 
+      if (iterateOptions.keepKeysOrigin)
+        setProp(obj, '$originalKeyRef', { ref: root.ref, as: root.as });
+
       return obj;
     });
   }

package/lib/transform/forOdata.js

@@ -188,7 +188,7 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   if (!structuredOData) {
     expansion.expandStructureReferences(csn, options, '_',
       { error, info, throwWithAnyError }, csnUtils,
-      { skipArtifact: isExternalServiceMember });
+      { skipArtifact: isExternalServiceMember, keepKeysOrigin: true });
   }
 
   createForeignKeyElements(csn, options, messageFunctions, csnUtils, { skipArtifact: isExternalServiceMember });