@sap/cds-compiler 5.2.0 → 5.3.0

package/lib/compiler/xpr-rewrite.js

@@ -174,7 +174,8 @@ function xprRewriteFns( model ) {
     resolvePath,
     navigationEnv,
     resolvePathRoot,
-    firstProjectionForPath,
+    cachedRedirectionChain,
+    findRewriteTarget,
   } = model.$functions;
 
   return {
@@ -393,21 +394,21 @@ function xprRewriteFns( model ) {
    */
   function rewriteGenericAnnoPath( expr, config, refCtx ) {
     const isAbsolute = isAnnoPathAbsolute( expr );
-    const rootIndex = isAbsolute ? 1 : 0;
+    const startIndex = isAbsolute ? 1 : 0;
 
     // We get the root environment now, even though below we resolve the root item
     // again if it was absolute (e.g. $self).  We do so, because for queries, we
     // want to respect the select item's corresponding table alias.
     const rootEnv = getRootEnv( expr, config );
 
-    // reset artifact link; we'll set it again
+    // reset artifact link; we'll set it again if there are no errors
     setArtifactLink( expr, null );
 
-    // Adapt root path, as it isn't rewritten in rewriteItem
-    const rootItem = expr.path[0];
     if (isAbsolute) {
-      delete rootItem._artifact;
-      delete rootItem._navigation;
+      // Adapt absolute root path, as it isn't rewritten in rewriteItem
+      // The path-prefix was already adapted in rewriteAnnoExpr().
+      delete expr.path[0]._artifact;
+      delete expr.path[0]._navigation;
       // TODO: What about `up_`? Shouldn't we set `_navigation` as well?
       // TODO: Can we handle `$self` of anonymous-composition-of-aspect?
       const root = resolvePathRoot( expr, refCtx, config.target );
@@ -415,23 +416,46 @@ function xprRewriteFns( model ) {
         return reportAnnoRewriteError( expr, config );
     }
 
+    // Store the original artifact, so that we can use it to
+    // calculate a redirection chain later on.
+    expr.path.forEach((item) => {
+      if (item._artifact)
+        setLink( item, '_originalArtifact', item._artifact );
+    });
+
     let env = rootEnv;
-    let art = rootItem._artifact;
-    for (let i = rootIndex; i < expr.path.length; ++i) {
+    let art = expr.path[0]._artifact;
+
+    for (let i = startIndex; i < expr.path.length; ++i) {
+      if (i > startIndex && art.target) {
+        // if the current artifact is an association, we need to respect the redirection
+        // chain from original target to new one.
+        // FIXME: Won't work with associations in projected structures.
+        const origTarget = expr.path[i - 1]?._originalArtifact?.target?._artifact;
+        const chain = cachedRedirectionChain( art, origTarget );
+        if (!chain)
+          return reportAnnoRewriteError( expr, config );
+        for (const alias of chain) {
+          art = rewriteItem( expr, config, alias, i );
+          if (!art)
+            return reportAnnoRewriteError( expr, config );
+        }
+      }
       art = rewriteItem( expr, config, env, i );
       if (!art)
         return reportAnnoRewriteError( expr, config );
+      // target, items, …
       env = navigationEnv( art, null, null, 'nav' );
     }
     setArtifactLink( expr, art );
 
-    if (rootIndex === 0 && rootItem.id.startsWith('$')) {
+    if (startIndex === 0 && expr.path[0].id.startsWith('$')) {
       if (config.isInFilter) {
         // In filters, we must not prepend `$self`, as that would change its meaning.
         // We must reject it. See #11775
         return reportAnnoRewriteError( expr, config );
       }
-      // After rewriting, an element starts with `$` -> add root prefix
+      // After rewriting, if an element starts with `$` -> add root prefix
       prependRootPath( config.origin, config.targetRoot, expr );
     }
 
@@ -640,63 +664,25 @@ function xprRewriteFns( model ) {
    * @returns {*|null}
    */
   function rewriteItem( expr, config, env, index ) {
-    const item = expr.path[index];
     const rewriteTarget = findRewriteTarget( expr, index, env, config.target );
-    const found = setArtifactLink( item, rewriteTarget[0] );
+    const found = setArtifactLink( expr.path[index], rewriteTarget[0] );
     if (!found)
       return null;
 
-    if (item.id !== found.name.id) {
-      // Path was rewritten; original token text string is no longer accurate
-      config.tokenExpr.$tokenTexts = true;
-      item.id = found.name.id;
-    }
-
-    if (rewriteTarget[1] > index)
+    if (rewriteTarget[1] > index) {
+      // we keep the last segment, in case it has non-enumerable properties
+      expr.path[index] = expr.path[rewriteTarget[1]];
       expr.path.splice(index + 1, rewriteTarget[1] - index);
-
-    return rewriteTarget[0];
-  }
-
-  function findRewriteTarget( expr, index, env, target ) {
-    if (env.kind === '$navElement' || env.kind === '$tableAlias') {
-      const r = firstProjectionForPath( expr.path, index, env, target );
-      return [ r.elem, r.index ];
     }
 
     const item = expr.path[index];
-    // If the artifact is already in the same definition, we must not check the query.
-    // Or if it is not a query -> no $navElement -> use `elements`
-    if (item._artifact._main === env || !env.query && env.kind !== 'select') {
-      if (env.elements?.[item.id])
-        return [ env.elements[item.id], index ];
-      return [ null, expr.path.length ];
-    }
-    const items = (env._leadingQuery || env)._combined?.[item.id];
-    const allNavs = !items || Array.isArray(items) ? items : [ items ];
-
-    // If the annotation target itself has a table alias, require projections of that
-    // table alias. Of course, that only works if we're talking about the same query.
-    const tableAlias = (target._main?._origin === item._artifact._main &&
-        target.value?.path[0]?._navigation?.kind === '$tableAlias')
-      ? target.value.path[0]._navigation : null;
-
-    // Look at all table aliase that could project `item` and only select
-    // those that have actual projections.
-    const navs = allNavs?.filter(p => p._origin === item._artifact &&
-      (!tableAlias || tableAlias === p._parent));
-    if (!navs || navs.length === 0)
-      return [ null, expr.path.length ];
-
-    // If there are multiple navigations for the element, just use the first that matches.
-    // In case of table aliases, it's just one.
-    for (const nav of navs) {
-      const r = firstProjectionForPath( expr.path, index, nav._parent, target );
-      if (r.elem)
-        return [ r.elem, r.index ];
+    if (item.id !== found.name.id || (rewriteTarget[1] - index) !== 0) {
+      // Path was rewritten; original token text string is no longer accurate
+      config.tokenExpr.$tokenTexts = true;
+      item.id = found.name.id;
     }
 
-    return [ null, expr.path.length ];
+    return setArtifactLink( expr.path[index], found );
   }
 }
 

package/lib/edm/annotations/genericTranslation.js

@@ -932,7 +932,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
                         anno: msg.anno(),
                         type: dTypeName,
                         value: `"#${enumSymbol}"`,
-                        rawvalues: Object.keys(typeDef.$Allowed.Symbols).map(m => `"#${m}"`),
+                        rawvalues: Object.keys(typeDef.$Allowed.Symbols).map(m => `#${m}`),
                         '#': 'enum',
                       });
             }
@@ -1024,7 +1024,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
                   anno: msg.anno(),
                   type: dTypeName,
                   value: `"#${value}"`,
-                  rawvalues: expectedType.Members.map(m => `"#${m}"`),
+                  rawvalues: expectedType.Members.map(m => `#${m}`),
                   '#': 'enum',
                 });
       }
@@ -1060,7 +1060,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
                     anno: msg.anno(),
                     type: dTypeName,
                     value: value['='] || value,
-                    rawvalues: type.Members.map(m => `"#${m}"`),
+                    rawvalues: type.Members.map(m => `#${m}`),
                     '#': 'enum',
                   });
         }
@@ -1120,7 +1120,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
 
     if (isEnumType(resolvedType)) {
       const type = getDictType(resolvedType);
-      const expected = type.Members.map(m => `"#${m}"`);
+      const expected = type.Members.map(m => `#${m}`);
       message('odata-anno-value', msg.location,
               {
                 anno: msg.anno(),

package/lib/edm/csn2edm.js

@@ -736,8 +736,8 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
           attributes.IsComposable = false;
 
         /** @type {object} */
-        const actionNode = (iAmAnAction) ? new Edm.Action(v, attributes)
-          : new Edm.FunctionDefinition(v, attributes);
+        const actionNode = (iAmAnAction) ? new Edm.Action(v, attributes, actionCsn)
+          : new Edm.FunctionDefinition(v, attributes, actionCsn);
 
         const bpType = entityCsn ? fullQualified(entityCsn.name) : undefined;
         /*

package/lib/edm/edm.js

@@ -31,6 +31,7 @@ function getEdm( options, messageFunctions ) {
       this._edmAttributes = Object.assign(Object.create(null), attributes);
       this._xmlOnlyAttributes = Object.create(null);
       this._jsonOnlyAttributes = Object.create(null);
+      this._openApiHints = Object.create(null);
 
       this._children = [];
       this._ignoreChildren = false;
@@ -38,6 +39,8 @@ function getEdm( options, messageFunctions ) {
 
       if (this.v2)
         this.setSapVocabularyAsAttributes(csn);
+
+      this.setOpenApiHints(csn);
     }
 
     get v2() {
@@ -103,6 +106,17 @@ function getEdm( options, messageFunctions ) {
       return this;
     }
 
+    setOpenApiHints(csn) {
+      if (csn && options.odataOpenapiHints) {
+        const jsonAttr = Object.create(null);
+        Object.entries(csn).filter(([ k, _v ] ) => k.startsWith('@OpenAPI.')).forEach(([ k, v ]) => {
+          jsonAttr[k] = v;
+        });
+        Object.assign(this._openApiHints, jsonAttr);
+      }
+      return this._openApiHints;
+    }
+
     // virtual
     toJSON() {
       const json = Object.create(null);
@@ -110,16 +124,24 @@ function getEdm( options, messageFunctions ) {
       if (!(this.kind in Node.noJsonKinds))
         json.$Kind = this.kind;
 
-      this.toJSONattributes(json);
-      return this.toJSONchildren(json);
+      return this.toJSONchildren(this.toJSONattributes(json));
     }
 
     // virtual
-    toJSONattributes(json) {
+    toJSONattributes(json, withHints = true) {
       forEach(this._edmAttributes, (p, v) => {
         if (p !== 'Name')
           json[p[0] === '@' ? p : `$${p}`] = v;
       });
+      return (withHints ? this.toOpenApiHints(json) : json);
+    }
+
+    toOpenApiHints(json) {
+      if (options.odataOpenapiHints && this._openApiHints) {
+        Object.entries(this._openApiHints).forEach(([ p, v ]) => {
+          json[p[0] === '@' ? p : `$${p}`] = v;
+        });
+      }
       return json;
     }
 
@@ -243,6 +265,10 @@ function getEdm( options, messageFunctions ) {
       super.setSapVocabularyAsAttributes(csn, true);
     }
 
+    toJSONattributes(json) {
+      return super.toJSONattributes(json, false);
+    }
+
     register(entry) {
       if (!this._registry[entry._edmAttributes.Name])
         this._registry[entry._edmAttributes.Name] = [ entry ];
@@ -258,6 +284,7 @@ function getEdm( options, messageFunctions ) {
       if (alias !== undefined)
         props.Alias = alias;
       super(version, props);
+      this.setOpenApiHints(serviceCsn);
       this._annotations = annotations;
       this._actions = Object.create(null);
       this.setXml( { xmlns: (this.v2) ? 'http://schemas.microsoft.com/ado/2008/09/edm' : 'http://docs.oasis-open.org/odata/ns/edm' } );
@@ -321,6 +348,7 @@ function getEdm( options, messageFunctions ) {
             json[p[0] === '@' ? p : `$${p}`] = v;
         });
       }
+      return this.toOpenApiHints(json);
     }
 
     toJSONchildren(json) {
@@ -550,8 +578,8 @@ function getEdm( options, messageFunctions ) {
   */
 
   class ActionFunctionBase extends Node {
-    constructor(version, details) {
-      super(version, details);
+    constructor(version, details, csn) {
+      super(version, details, csn);
       this._returnType = undefined;
     }
 
@@ -702,7 +730,7 @@ function getEdm( options, messageFunctions ) {
       if (this.$isCollection)
         json.$Collection = this.$isCollection;
 
-      return json;
+      return this.toOpenApiHints(json);
     }
   }
 
@@ -753,11 +781,11 @@ function getEdm( options, messageFunctions ) {
       else
         this._keys = undefined;
 
-      if (options.odataOpenapiHints) {
+      if (this._openApiHints) {
         if (csn['@cds.autoexpose'])
-          this.setJSON({ '@cds.autoexpose': true });
+          this._openApiHints['@cds.autoexpose'] = true;
         if (csn['@cds.autoexposed'])
-          this.setJSON({ '@cds.autoexposed': true });
+          this._openApiHints['@cds.autoexposed'] = true;
       }
     }
 
@@ -806,7 +834,7 @@ function getEdm( options, messageFunctions ) {
   class Member extends Node {
     toJSONattributes(json) {
       json[this._edmAttributes.Name] = this._edmAttributes.Value;
-      return json;
+      return super.toOpenApiHints(json);
     }
   }
 
@@ -823,11 +851,6 @@ function getEdm( options, messageFunctions ) {
       }
     }
 
-    toJSONattributes(json) {
-      super.toJSONattributes(json);
-      return json;
-    }
-
     toJSONchildren(json) {
       this._children.forEach(c => c.toJSONattributes(json));
       return json;
@@ -1161,6 +1184,10 @@ function getEdm( options, messageFunctions ) {
       return this.toJSONchildren(json);
     }
 
+    toJSONattributes(json) {
+      return super.toJSONattributes(json, false);
+    }
+
     getConstantExpressionValue() {
       // short form: key: value
       const inlineConstExpr
@@ -1290,6 +1317,7 @@ function getEdm( options, messageFunctions ) {
       const keys = Object.keys(this._edmAttributes).filter(k => k !== 'Type');
       for (const key of keys)
         json[`$${key}`] = this._edmAttributes[key];
+      return json;
     }
 
     toJSONchildren(json) {
@@ -1397,8 +1425,7 @@ function getEdm( options, messageFunctions ) {
     toJSON() {
       const json = this.mergeJSONAnnotations();
       json[`$${this.kind}`] = this._children.filter(c => c.kind !== 'Annotation').map(c => c.toJSON());
-      this.toJSONattributes(json);
-      return json;
+      return this.toJSONattributes(json);
     }
   }
   class Cast extends AnnotationBase {
@@ -1417,8 +1444,7 @@ function getEdm( options, messageFunctions ) {
       // first expression only, if any
       const children = this._children.filter(child => child.kind !== 'Annotation');
       json[`$${this.kind}`] = children.length ? children[0].toJSON() : {};
-      this.toJSONattributes(json);
-      return json;
+      return this.toJSONattributes(json);
     }
     toJSONattributes(json) {
       super.toJSONattributes(json);
@@ -1445,8 +1471,7 @@ function getEdm( options, messageFunctions ) {
       // first expression only, if any
       const children = this._children.filter(child => child.kind !== 'Annotation');
       json[`$${this.kind}`] = children.length ? children[0].toJSON() : '';
-      this.toJSONattributes(json);
-      return json;
+      return this.toJSONattributes(json);
     }
 
     toJSONattributes(json) { // including Name

package/lib/edm/edmInboundChecks.js

@@ -59,7 +59,6 @@ function inboundQualificationChecks( csn, options, messageFunctions,
         markBindingParamPaths(action, aLoc);
         forEachMemberRecursively(action, checkIfItemsOfItems, aLoc);
         checkIfItemsOfItems(action.returns, undefined, undefined, aLoc.concat('returns'));
-        markBindingParamPaths(action, aLoc);
       });
     }
 

package/lib/edm/edmPreprocessor.js

@@ -160,6 +160,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
     forEachDefinition(reqDefs, [
       exposeTargetsAsProxiesOrSchemaRefs,
       determineEntitySet,
+      annotateOptionalActFuncParams,
     ]);
     // finalize proxy creation
     mergeProxiesIntoModel();
@@ -170,7 +171,6 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
       forEachDefinition(reqDefs, [
         initEdmNavPropBindingTargets,
         pullupCapabilitiesAnnotations,
-        annotateOptionalActFuncParams,
       ]);
     }
 
@@ -685,8 +685,8 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
       return;
 
     let keys = Object.create(null);
-    const validFrom = []; const
-      validKey = [];
+    const validFrom = [];
+    const validKey = [];
 
     // Iterate all struct elements
     forEachMemberRecursively(def.items || def, (element, elementName, prop, _path, construct) => {
@@ -796,7 +796,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
     Do not render (ignore) elements as properties
     In V4:
     1) If this is a foreign key of an association to a container which *is* used
-       to establish the containment via composition and $self comparison.
+       to establish the relation via composition and $self comparison.
        The $self comparison can only be evaluated after the ON conditions have been
        parsed in prepareConstraints().
     2) For all other foreign keys let isEdmPropertyRendered() decide.
@@ -2095,45 +2095,58 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
 
     function iterateParams( action, location ) {
       let optPns = [];
+      const isBP = p => (p.items?.type || p.type) === special$self;
+
       if (action.params) {
         Object.entries(action.params).forEach(([ pn, p ]) => {
-        // user assigned annotation, don't touch it
+          // user assigned annotation, don't touch it
           const defT = reqDefs.definitions[p.items?.type || p.type];
           const isStructType = !!(defT?.items?.elements || defT?.elements);
           const isItems = !!(p.items || defT?.items);
 
-          if (Object.keys(p).some(a => a.startsWith('@Core.OptionalParameter') && p[a] !== null)) {
-            optPns.push(p);
+          if (Object.keys(p).some(a => a.startsWith('@Core.OptionalParameter') && p[a] != null)) {
+            // expand short cut annotation for unspecified default value
+            if (typeof p['@Core.OptionalParameter'] === 'boolean') {
+              if (p['@Core.OptionalParameter'] && !isBP(p) && !options.isV2()) {
+                if (p.default?.val !== undefined) {
+                  if (p.default.val !== null && (isStructType || isItems))
+                    warning('odata-ignoring-param-default', location.concat(pn), { '#': 'colitem' });
+                  else
+                    p['@Core.OptionalParameter'] = { DefaultValue: p.default.val };
+                }
+                else {
+                  p['@Core.OptionalParameter'] = { $Type: '' };
+                }
+                optPns.push(p);
+              }
+              else { // reset falsy annotation, param is NOT optional
+                p['@Core.OptionalParameter'] = null;
+              }
+            }
+            else {
+              optPns.push(p);
+            }
           }
-          // default value automatically makes param optional
-          else if (isBetaEnabled(options, 'optionalActionFunctionParameters')) {
+          else if (!isBP(p) && !options.isV2()) {
+            // default value automatically makes param optional
             if (p.default?.val !== undefined) {
-              if (p.default.val !== null && (isStructType || isItems)) {
+              if (p.default.val !== null && (isStructType || isItems))
                 warning('odata-ignoring-param-default', location.concat(pn), { '#': 'colitem' });
-              }
-              else {
+              else
                 edmUtils.assignAnnotation(p, '@Core.OptionalParameter.DefaultValue', p.default.val);
-                optPns.push(p);
-              }
+              optPns.push(p);
             }
-            // if no default is available, nullable makes param optional
-            else if (!p.notNull) {
-              edmUtils.assignAnnotation(p, '@Core.OptionalParameter.$Type', '');
+            // nullable action params are optional (implicit default null)
+            else if (!p.notNull && action.kind === 'action') {
               optPns.push(p);
             }
-            else {
-            // this is a mandatory parameter, warn about all previously collected optional parameters
-              optPns.forEach((op) => {
-                const type = op.items?.type || op.type;
-                if (type !== special$self)
-                  error('odata-parameter-order', location.concat(op.name));
-              });
+            else if (action.kind === 'function') {
+              // this is a mandatory parameter, warn about all previously collected optional parameters
+              if (optPns.filter(op => (op.items?.type || op.type) !== special$self).length)
+                error('odata-parameter-order', location.concat(pn));
               optPns = [];
             }
           }
-          else if (p.default) {
-            warning('odata-ignoring-param-default', location.concat(pn));
-          }
         });
       }
     }

package/lib/edm/edmUtils.js

@@ -386,7 +386,7 @@ function finalizeReferentialConstraints( csn, assocCsn, options, info ) {
   // If this association points to a redirected Parameter EntityType, do not calculate any constraints,
   // continue with multiplicity
   if (assocCsn._target.$isParamEntity)
-    assocCsn._constraints.constraints = Object.create(null);
+    assocCsn._constraints.constraints = {};
 
   return assocCsn._constraints;