@sap/cds-compiler 3.9.2 → 4.0.0

package/lib/compiler/tweak-assocs.js

@@ -17,6 +17,7 @@ const {
   traverseQueryPost,
   traverseQueryExtra,
   setExpandStatus,
+  traverseExpr,
 } = require('./utils');
 
 const $location = Symbol.for('cds.$location');
@@ -31,13 +32,12 @@ function tweakAssocs( model ) {
   const {
     effectiveType,
     getOrigin,
-    resolveExpr,
+    navigationEnv,
   } = model.$functions;
-  const { environment } = model.$volatileFunctions;
 
   // Phase 5: rewrite associations
   model._entities.forEach( rewriteArtifact );
-  // Think hard whether an on condition rewrite can lead to a new cylcic
+  // Think hard whether an on condition rewrite can lead to a new cyclic
   // dependency.  If so, we need other messages anyway.  TODO: probably do
   // another cyclic check with testMode.js
   return;
@@ -313,7 +313,8 @@ function tweakAssocs( model ) {
       return;
     }
     if (!nav.tableAlias || nav.tableAlias.path) {
-      resolveExpr( cond, rewriteExpr, elem, nav.tableAlias );
+      traverseExpr( cond, 'rewrite-on', elem,
+                    expr => rewriteExpr( expr, elem, nav.tableAlias ) );
     }
     else {
       // TODO: support that, now that the ON condition is rewritten in the right order
@@ -452,6 +453,7 @@ function tweakAssocs( model ) {
   function rewriteItem( elem, item, name, assoc, forKeys ) {
     // TODO: for rewriting ON conditions of explicitly provided model targets,
     // we need to only rewrite the current element, not all sibling elements
+    // TODO: this will be different in v4
     if (!elem._redirected)
       return true;
     for (const alias of elem._redirected) {
@@ -480,8 +482,8 @@ function tweakAssocs( model ) {
         item.id = name;
       }
     }
-    const env = name && environment(elem);
-    elem = setArtifactLink( item, env && env[name] );
+    const env = name && navigationEnv(elem);
+    elem = setArtifactLink( item, env?.elements?.[name] );
     if (elem && !Array.isArray(elem))
       return elem;
     // TODO: better (extra message), TODO: do it

package/lib/compiler/utils.js

@@ -442,6 +442,47 @@ function isDirectComposition( art ) {
   return type && type[0] && type[0].id === 'cds.Composition';
 }
 
+function traverseExpr( expr, exprCtx, user, callback ) {
+  if (!expr || typeof expr === 'string') // parse error or keywords in {xpr:...}
+    return;
+
+  if (expr.path) {
+    callback( expr, exprCtx, user );
+    // TODO: move arguments and filter traversal to here
+    return;
+  }
+  else if (expr.type || expr.query) {
+    callback( expr, exprCtx, user );
+  }
+
+  if (expr.args) {
+    const args = Array.isArray(expr.args) ? expr.args : Object.values( expr.args );
+    // TODO: re-think $expected
+    args.forEach( e => traverseExpr( e, exprCtx, user, callback ) );
+  }
+  if (expr.suffix)              // fn( … ) OVER …
+    expr.suffix.forEach( e => traverseExpr( e, exprCtx, user, callback ) );
+}
+
+function userQuery( user ) {
+  // TODO: we need _query links set by the definer
+  while (user._main) {
+    if (user.kind === 'select' || user.kind === '$join')
+      return user;
+    user = user._parent;
+  }
+  return null;
+}
+
+function definedViaCdl( art ) {
+  // return !!art._block?.artifacts;
+  // TODO: the above code would work when _block links are correctly set on
+  // members of duplicate extensions, see test3/Extensions/DuplicateExtend/.  The
+  // following is a workaround to make at least ref to builtins work:
+  const { $frontend } = art._block || art;
+  return $frontend !== 'json' && $frontend !== '$internal';
+}
+
 module.exports = {
   pushLink,
   annotationVal,
@@ -470,4 +511,7 @@ module.exports = {
   setExpandStatus,
   setExpandStatusAnnotate,
   isDirectComposition,
+  traverseExpr,
+  userQuery,
+  definedViaCdl,
 };

package/lib/edm/annotations/genericTranslation.js

@@ -412,13 +412,29 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
         handleAnnotations(edmTargetName, p, [ ...location, 'params', n ]);
       });
     }
+    if(cAction.returns) {
+      const edmTargetName = actionName + '/$ReturnType';
+      setProp(cAction.returns, '$appliesToReturnType', true);
+      handleAnnotations(edmTargetName, cAction.returns, [ ...location, 'returns' ]);
+      delete cAction.returns['$appliesToReturnType'];
+    }
 
     function relParList() {
     // we rely on the order of params in the csn being the correct one
       const params = [];
-      if (entityNameIfBound && !(cAction.kind === 'function' && cAction.$hasBindingParam)) {
-        params.push(cAction['@cds.odata.bindingparameter.collection'] ? 'Collection(' + entityNameIfBound + ')' : entityNameIfBound);
+      if (entityNameIfBound) {
+        // If this is an action and has an explicit binding parameter add it here
+        if(cAction.$bindingParam && cAction.kind === 'action') {
+          params.push(cAction.$bindingParam.items ? 'Collection(' + entityNameIfBound + ')' : entityNameIfBound);
+        }
+        // If action/function has no explicit binding parameter add it here
+        else if (!cAction.$bindingParam) {
+          params.push(cAction['@cds.odata.bindingparameter.collection'] ? 'Collection(' + entityNameIfBound + ')' : entityNameIfBound);
+        }
       }
+      // In case this is a function the explicit binding parameter is part of
+      // the functions params dictionary. Only for functions all parameters must
+      // be listed in the annotation target
       if (cAction.kind === 'function') {
         if(cAction.params) {
           cAction.params && Object.values(cAction.params).forEach(p => {
@@ -454,7 +470,7 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
     // keep only those annotations that - start with a known vocabulary name
     //                                  - have a value other than null
 
-    // if the carier is an element that is not rendered or
+    // if the carrier is an element that is not rendered or
     // if the carrier is a derived type of a primitive type which is not rendered in V2
     // if the carrier is a media stream element in V2
     // do nothing
@@ -646,8 +662,10 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
               carrier.cardinality && carrier.cardinality.max === '*' && x.includes('Collection')
             : true);
         }
+        else if(carrier.$appliesToReturnType)
+          testToStandardEdmTarget = (x => x ? x.includes('ReturnType') : true);
         else {
-        // this might be more precise if handleAnnotation would know more about the carrier
+          // this might be more precise if handleAnnotation would know more about the carrier
           testToStandardEdmTarget = (x => x
             ? ['Parameter', 'Property'].some(y => x.includes(y) ||
               carrier._isCollection && x.includes('Collection'))
@@ -1106,11 +1124,11 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
 
   // found a simple value "val"
   //  expected type is dTypeName
-  //  mappping rule for values:
+  //  mapping rule for values:
   //    if expected type is ... the expression to be generated is ...
   //      floating point type except Edm.Decimal -> Float
   //      Edm.Decimal -> Decimal
-  //      integer tpye -> Int
+  //      integer type -> Int
   function handleSimpleValue(value, dTypeName, msg) {
     // these types must be represented as "String" values in XML:
     const castToXmlString = [ 'Edm.PrimitiveType', 'Edm.Stream', 'Edm.Untyped' ];

package/lib/edm/csn2edm.js

@@ -51,7 +51,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
     whatsMyServiceRootName,
     fallBackSchemaName,
     options ] = initializeModel(csn, _options, messageFunctions, serviceNames);
-    
+
   const mergedVocabularies = translate.mergeOdataVocabularies(options, message);
 
   const Edm = getEdm(options, messageFunctions);
@@ -404,7 +404,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       createTerm);
       }
 
-      // fetch all exising children names in a map
+      // fetch all existing children names in a map
       const NamesInSchemaXRef = Schema._children.reduce((acc, cur) => {
         const name = cur._edmAttributes.Name;
         if(acc[name] === undefined) {
@@ -436,7 +436,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
 
         The first sentence in chapter 13 is:
           Each metadata document used to describe an OData service MUST define exactly one entity container.
-        
+
         This sentence expresses that an OData SERVICE must contain an entity container, but an EDMX is not required to have a container.
         Therefore it is absolutely legal and necessary to remove an empty container from the IR!
       */
@@ -683,18 +683,19 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         const bpType = entityCsn ? fullQualified(entityCsn.name) : undefined;
         /*
         Check for binding $self parameter. If available, use this parameter
-        instead of artifically created binding parameter (hasBindingParameter).
+        instead of artificially created binding parameter (hasBindingParameter).
         The binding parameter remains in the CSN and is rendered as any other
         parameter (including default value/not null/ etc) and acts as annotation carrier.
         */
-        setProp(actionCsn, '$hasBindingParam', false);
+
+        let bpName = 'in';
         if(actionCsn.params) {
           const entries =  Object.entries(actionCsn.params);
           const firstParam = entries[0][1];
           const type = firstParam?.items?.type || firstParam?.type;
           if(type === special$self) {
-            actionCsn.$hasBindingParam = true;
-            const bpName = entries[0][0];
+            bpName = entries[0][0];
+            setProp(actionCsn, '$bindingParam', firstParam);
             if(bpType) {
               if(firstParam.items?.type)
                 firstParam.items.type = bpType;
@@ -707,16 +708,15 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         }
 
         // bpName is eventually used later for EntitySetPath
-        const bpNameAnno = actionCsn['@cds.odata.bindingparameter.name'];
-        let bpName = 'in';
-        if(bpNameAnno != null) {
-          if(typeof bpNameAnno === 'string')
-            bpName = bpNameAnno;
-          if(typeof bpNameAnno === 'object' && bpNameAnno['='])
-            bpName = bpNameAnno['='];
-        }
         // No explicit binding parameter, check (user defined) annotation value)
-        if(!actionCsn.$hasBindingParam) {
+        if(!actionCsn.$bindingParam) {
+          const bpNameAnno = actionCsn['@cds.odata.bindingparameter.name'];
+          if(bpNameAnno != null) {
+            if(typeof bpNameAnno === 'string')
+              bpName = bpNameAnno;
+            if(typeof bpNameAnno === 'object' && bpNameAnno['='])
+              bpName = bpNameAnno['='];
+          }
           if(!edmUtils.isODataSimpleIdentifier(bpName))
             message('odata-spec-violation-id', [...loc, '@cds.odata.bindingparameter.name'], { id: bpName });
           if(actionCsn.params && actionCsn.params[bpName]) {
@@ -726,7 +726,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         if(entityCsn != undefined)
         {
           actionNode.setEdmAttribute('IsBound', true);
-          if(!actionCsn.$hasBindingParam) {
+          if(!actionCsn.$bindingParam) {
             // Binding Parameter: 'in' at first position in sequence, this is decisive!
             if(actionCsn['@cds.odata.bindingparameter.collection'])
               actionNode.append(new Edm.Parameter(v, { Name: bpName, Type: bpType, Collection:true/*, Nullable: false*/ } ));
@@ -805,8 +805,8 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         const rt = actionCsn.returns && ((actionCsn.returns.items && actionCsn.returns.items.type) || actionCsn.returns.type);
         if(rt) // add EntitySet attribute only if return type is an entity
         {
-          const defintion = schemaCsn.definitions[rt];
-          if(defintion && defintion.kind === 'entity')
+          const definition = schemaCsn.definitions[rt];
+          if(definition && definition.kind === 'entity')
           {
             functionImport.setEdmAttribute('EntitySet', rt.replace(schemaNamePrefix, ''));
           }
@@ -883,31 +883,34 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
           // it is safe to assume that either type or items.type are set
           const returnsLoc = [ ...loc, 'returns'];
           const returns = action.returns.items || action.returns;
-          let type = returns.type;
-          if (type) {
-            collectUsedType(action.returns);
-            if (!isBuiltinType(type) && csn.definitions[type].kind !== 'entity' && csn.definitions[type].kind !== 'type') {
-              message('odata-spec-violation-returns', returnsLoc, { kind: action.kind, version: '2.0' });
-            }
-            else if(isBuiltinType(type)) {
-              type = edmUtils.mapCdsToEdmType(returns, messageFunctions, true);
-              if(type) {
-                const td = EdmPrimitiveTypeMap[type];
-                if(td && !td.v2) {
-                  message('odata-spec-violation-type', returnsLoc,
+          let type = returns['@odata.Type'];
+          if(!type) {
+            type = returns.type;
+            if (type) {
+              collectUsedType(action.returns);
+              if (!isBuiltinType(type) && csn.definitions[type].kind !== 'entity' && csn.definitions[type].kind !== 'type') {
+                message('odata-spec-violation-returns', returnsLoc, { kind: action.kind, version: '2.0' });
+              }
+              else if(isBuiltinType(type)) {
+                type = edmUtils.mapCdsToEdmType(returns, messageFunctions, true);
+                if(type) {
+                  const td = EdmPrimitiveTypeMap[type];
+                  if(td && !td.v2) {
+                    message('odata-spec-violation-type', returnsLoc,
                     { type, version: '2.0', '#': 'incompatible' });
+                  }
+                }
+                else {
+                  message('odata-spec-violation-type-unknown', returnsLoc, { type });
                 }
               }
-              else {
-                message('odata-spec-violation-type-unknown', returnsLoc, { type });
-              }
+              if(action.returns._isCollection)
+                type = `Collection(${type})`
+            }
+            else {
+              // type is missing
+              message('odata-spec-violation-type', returnsLoc);
             }
-            if(action.returns._isCollection)
-              type = `Collection(${type})`
-          }
-          else {
-            // type is missing
-            message('odata-spec-violation-type', returnsLoc);
           }
           return type;
         }
@@ -916,7 +919,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       /*
         addAssociation() constructs a V2 association.
         In V4 all this has been simplified very much, the only thing actually left over is
-        <ReferentialConstriant> that is then a sub element to <NavigationProperty>.
+        <ReferentialConstraint> that is then a sub element to <NavigationProperty>.
         However, referential constraints are substantially different to its V2 counterpart,
         so it is better to reimplement proper V4 construction of<NavigationProperty> in a separate
         function.
@@ -1086,7 +1089,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
           // Only the unknown type warning may be triggered by an unknown @odata.Type override.
           if(td.v2 !== p.v2 && td.v4 !== p.v4)
             message('odata-spec-violation-type', pLoc,
-            { type:edmType, version: (p.v4 ? '4.0' : '2.0'), '#': 'incompatible' });
+            { type: edmType, version: (p.v4 ? '4.0' : '2.0'), '#': 'incompatible' });
           EdmTypeFacetNames.forEach(name => {
             const facet = EdmTypeFacetMap[name];
             const optional =
@@ -1101,13 +1104,12 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
             // node and facet version match
             if(!p._edmAttributes[name] && td[name] && !optional && (p.v2 === facet.v2 || p.v4 === facet.v4)) {
               message('odata-spec-violation-type', pLoc,
-                { type:edmType, name, version: (p.v4 ? '4.0' : '2.0'), '#': 'facet' });
+                { type: edmType, name, version: (p.v4 ? '4.0' : '2.0'), '#': 'facet' });
             }
           });
         }
         else {
-          message('odata-spec-violation-type-unknown', pLoc,
-          { type:edmType });
+          message('odata-spec-violation-type-unknown', pLoc, { type: edmType });
         }
       }
     }

package/lib/edm/edm.js

@@ -683,41 +683,44 @@ function getEdm(options, messageFunctions) {
             if(!(this._edmAttributes[typeName] === 'Edm.Stream' &&
                !( /*scalarType.type === 'cds.String' ||*/ this._scalarType.type === 'cds.Binary')))
               edmUtils.addTypeFacets(this, this._scalarType);
-            // CDXCORE-245:
-            // map type to @odata.Type
-            // optionally add @odata { MaxLength, Precision, Scale, SRID } but only in combination with @odata.Type
-            const odataType = csn['@odata.Type'];
-            if(odataType)
-            {
-              const td = EdmPrimitiveTypeMap[odataType];
-              // If type is known, it must be available in the current version
-              // Reason: EDMX Importer may set `@odata.Type: 'Edm.DateTime'` on imported V2 services
-              // Not filtering out this incompatible type here in case of a V4 rendering would
-              // produce an unrecoverable error.
-              if(td && (td.v2 === this.v2 || td.v4 === this.v4)) {
-                this.setEdmAttribute(typeName, odataType);
-                EdmTypeFacetNames.forEach(facetName => {
-                  const facet = EdmTypeFacetMap[facetName];
-                  if(facet.remove) {
-                    this.removeEdmAttribute(facetName);
-                    this.removeEdmAttribute(facet.extra);
-                  }
-                  if(td[facetName] !== undefined &&
+          }
+          else {
+            this._edmAttributes[typeName] = typecsn.type;
+          }
+        }
+        // CDXCORE-245:
+        // map type to @odata.Type
+        // optionally add @odata { MaxLength, Precision, Scale, SRID }
+        // but only in combination with @odata.Type
+        // Allow to override type only on scalar and undefined types
+        if((this._scalarType || typecsn.type == null) && !csn.elements) {
+          const odataType = csn['@odata.Type'];
+          if(odataType) {
+            const td = EdmPrimitiveTypeMap[odataType];
+            // If type is known, it must be available in the current version
+            // Reason: EDMX Importer may set `@odata.Type: 'Edm.DateTime'` on imported V2 services
+            // Not filtering out this incompatible type here in case of a V4 rendering would
+            // produce an unrecoverable error.
+            if(td && (td.v2 === this.v2 || td.v4 === this.v4)) {
+              this.setEdmAttribute(typeName, odataType);
+              EdmTypeFacetNames.forEach(facetName => {
+                const facet = EdmTypeFacetMap[facetName];
+                if(facet.remove) {
+                  this.removeEdmAttribute(facetName);
+                  this.removeEdmAttribute(facet.extra);
+                }
+                if(td[facetName] !== undefined &&
                       (facet.v2 === this.v2 ||
                       facet.v4 === this.v4))
                   {
-                    if(this.v2 && facetName === 'Scale' && csn['@odata.'+facetName] === 'variable')
-                      this.setXml({ [facet.extra]: true });
-                    else
+                  if(this.v2 && facetName === 'Scale' && csn['@odata.'+facetName] === 'variable')
+                    this.setXml({ [facet.extra]: true });
+                  else
                       this.setEdmAttribute(facetName, csn['@odata.'+facetName]);
-                  }
-                });
-              }
+                }
+              });
             }
           }
-          else {
-            this._edmAttributes[typeName] = typecsn.type;
-          }
         }
       }
 
@@ -734,7 +737,7 @@ function getEdm(options, messageFunctions) {
       // store undecorated type for JSON
       this._type = this._edmAttributes[typeName];
       // decorate for XML (not for Complex/EntityType)
-      if(this._isCollection)
+      if(this._isCollection && this._edmAttributes[typeName])
         this._edmAttributes[typeName] = `Collection(${this._edmAttributes[typeName]})`
     }
 
@@ -1127,7 +1130,7 @@ function getEdm(options, messageFunctions) {
           and if the csn.containsTarget for this NavigationProperty is true,
           then this is the generated 'Results' association to the underlying entityType.
           Only this special association may have an explicit ContainsTarget attribute.
-          See csn2edm.createParmeterizedEntityTypeAndSet() for details
+          See csn2edm.createEntityTypeAndSet() for details
           2) ContainsTarget stems from the @odata.contained annotation
         */
         // eslint-disable-next-line sonarjs/no-redundant-boolean

package/lib/edm/edmAnnoPreprocessor.js

@@ -59,7 +59,6 @@ function applyAppSpecificLateCsnTransformationOnElement(options, element, struct
     {
       mapAnnotationAssignment(element, struct, AnalyticalAnnotations());
     }
-    mapAnnotationAssignment(element, struct, PDMSemantics());
   }
 
   // etag requires Core.OptimisticConcurrency to be set in V4 (cap/issues#2641)
@@ -80,28 +79,6 @@ function applyAppSpecificLateCsnTransformationOnElement(options, element, struct
     }
   }
 
-  // nested functions begin
-  function PDMSemantics()
-  {
-    /*
-    let dict = Object.create(null);
-
-    dict['@PDM.xxx1'] = [ '@sap.pdm-semantics' ];
-    dict['@PDM.xxx2'] = [ '@sap.pdm-propery' ];
-    dict['@PDM.xxx3'] = [ '@sap.pdm-display-sq-no' ];
-    dict['@PDM.xxx4'] = [ '@sap.pdm-record-identifier' ];
-    dict['@PDM.xxx5'] = [ '@sap.pdm-field-group' ];
-    dict['@PDM.xxx6'] = [ '@sap.pdm-mask-find-pattern' ];
-    dict['@PDM.xxx7'] = [ '@sap.pdm-mask-replacement-pattern' ];
-    dict['@PDM.xxx8'] = [ '@sap.deletable' ];
-    dict['@PDM.xxx8'] = [ '@sap.updatable' ];
-
-    // respect flattened annotation $value
-    Object.keys(dict).forEach(k => dict[k+'.$value'] = dict[k]);
-    */
-    return Object.create(null);
-  }
-
   function AnalyticalAnnotations()
   {
     function mapCommonAttributes(element, struct, prop)

package/lib/edm/edmInboundChecks.js

@@ -24,7 +24,7 @@ function inboundQualificationChecks(csn, options, messageFunctions,
   serviceRootNames, requestedServiceNames, isMyServiceRequested, whatsMyServiceRootName, csnUtils) {
   const { message, throwWithError } = messageFunctions;
 
-  forEachDefinition(csn, [ attach$path, checkChainedArray ]);
+  forEachDefinition(csn, [ attach$path, checkProperArrayUsage ]);
   checkNestedContextsAndServices();
   throwWithError();
 
@@ -37,7 +37,7 @@ function inboundQualificationChecks(csn, options, messageFunctions,
         }, [ 'definitions', defName ]);
   }
 
-  function checkChainedArray(def, defName) {
+  function checkProperArrayUsage(def, defName) {
     if (!isMyServiceRequested(defName))
       return;
     let currPath = ['definitions', defName];
@@ -47,6 +47,11 @@ function inboundQualificationChecks(csn, options, messageFunctions,
     function checkIfItemsOfItems(construct, _constructName, _prop, path) {
       const constructType = csnUtils.effectiveType(construct);
       if (constructType.items) {
+        if(constructType.items.target) {
+          const isComp = constructType.items.type === 'cds.Composition';
+          message('type-invalid-items', path, { '#': isComp ? 'comp' : 'assoc', prop: 'items' });
+          return;
+        }
         if (constructType.items.items) {
           message('chained-array-of', path);
           return;