@sap/cds-compiler 5.1.2 → 5.3.0

package/lib/compiler/utils.js

@@ -212,9 +212,11 @@ function storeExtension( elem, name, prop, parent, block ) {
 /** @type {(a: any, b: any) => boolean} */
 const testFunctionPlaceholder = () => true;
 
-// Return path step if the path navigates along an association whose final type
-// satisfies function `test`; "navigates along" = last path item not considered
-// without truthy optional argument `alsoTestLast`.
+/**
+ * Return path step if the path navigates along an association whose final type
+ * satisfies function `test`; "navigates along" = last path item not considered
+ * without truthy optional argument `alsoTestLast`.
+ */
 function withAssociation( ref, test = testFunctionPlaceholder, alsoTestLast = false ) {
   for (const item of ref.path || []) {
     const art = item && item._artifact; // item can be null with parse error
@@ -435,7 +437,7 @@ function forEachJoinOn( query, from, callback ) {
 }
 
 function forEachExprArray( query, array, refContext, exprContext, callback ) {
-  for (const expr of array ) {
+  for (const expr of array) {
     if (expr)
       callback( expr, (expr.path ? refContext : exprContext), query );
   }
@@ -512,8 +514,10 @@ function traverseQueryExtra( main, callback ) {
   }
 }
 
-// Returns what was available at view._from[0] before:
-// (think first whether to really use this function)
+/**
+ * Returns what was available at view._from[0] before:
+ * (think first whether to really use this function)
+ */
 function viewFromPrimary( view ) {
   let query = view.$queries?.[0];
   while (query?._origin?.kind === 'select') // sub query in from
@@ -521,24 +525,26 @@ function viewFromPrimary( view ) {
   return dictFirst( query?.$tableAliases );
 }
 
-// About Helper property $expand for faster the XSN-to-CSN transformation
-// - null/undefined: artifact, member, items does not contain expanded members
-// - 'origin': all expanded (sub) elements have no new target/on and no new annotations
-//             that value is only on elements, types, and params -> no other members
-//             when set, only on elem/art with expanded elements
-// - 'target': all expanded (sub) elements might only have new target/on, but
-//             no individual annotations on any (sub) member
-//             when set, traverse all parents where the value has been 'origin' before
-// - 'annotate': at least one inferred (sub) member has an individual annotation,
-//               not counting propagated ones; set up to the definition (main artifact)
-//               (only set with anno on $inferred elem), annotate “beats” target
-// Usage according to CSN flavor:
-// - gensrc: do not render inferred elements (including expanded elements),
-//           collect annotate statements with value 'annotate'
-// - client: do not render expanded sub elements if artifact/member is no type, has a type,
-//           has $expand = 'origin', and all its _origin also have $expand = 'origin'
-//           (might sometimes render the elements unnecessarily, which is not wrong)
-// - universal: do not render expanded sub elements if $expand = 'origin'
+/**
+ * About Helper property $expand for faster the XSN-to-CSN transformation
+ * - null/undefined: artifact, member, items does not contain expanded members
+ * - 'origin': all expanded (sub) elements have no new target/on and no new annotations
+ *             that value is only on elements, types, and params -> no other members
+ *             when set, only on elem/art with expanded elements
+ * - 'target': all expanded (sub) elements might only have new target/on, but
+ *             no individual annotations on any (sub) member
+ *             when set, traverse all parents where the value has been 'origin' before
+ * - 'annotate': at least one inferred (sub) member has an individual annotation,
+ *               not counting propagated ones; set up to the definition (main artifact)
+ *               (only set with anno on $inferred elem), annotate “beats” target
+ * Usage according to CSN flavor:
+ * - gensrc: do not render inferred elements (including expanded elements),
+ *           collect annotate statements with value 'annotate'
+ * - client: do not render expanded sub elements if artifact/member is no type, has a type,
+ *           has $expand = 'origin', and all its _origin also have $expand = 'origin'
+ *           (might sometimes render the elements unnecessarily, which is not wrong)
+ * - universal: do not render expanded sub elements if $expand = 'origin'
+ */
 function setExpandStatus( elem, status ) {
   // set on element
   while (elem._main) {
@@ -607,7 +613,7 @@ function pathStartsWithSelf( ref ) {
 }
 
 function columnRefStartsWithSelf( col ) {
-  for (; col; col = col._pathHead) {
+  for (; col; col = col._columnParent) {
     const ref = col.value;
     const head = ref && !ref.scope && ref.path?.[0];
     if (head?._navigation?.kind === '$self')
@@ -618,12 +624,14 @@ function columnRefStartsWithSelf( col ) {
   return false;
 }
 
-// Remark: this function is based on an early check that no target element is
-// covered more than once by a foreign key: then…
-// we only need to check that all foreign key references are primary keys and
-// that the number of foreign and primary keys are the same.
+/**
+ * Remark: this function is based on an early check that no target element is
+ * covered more than once by a foreign key: then…
+ * we only need to check that all foreign key references are primary keys and
+ * that the number of foreign and primary keys are the same.
+ */
 function isAssocToPrimaryKeys( assoc ) {
-  let fkeys = 0;
+  let keyCount = 0;
   const { foreignKeys } = assoc;
   if (!foreignKeys)
     return undefined;
@@ -634,7 +642,7 @@ function isAssocToPrimaryKeys( assoc ) {
       return undefined;
     if (!elem.key?.val)
       return false;
-    ++fkeys;
+    ++keyCount;
   }
 
   const elements = assoc.target._artifact?.elements;
@@ -642,9 +650,9 @@ function isAssocToPrimaryKeys( assoc ) {
     return undefined;
   for (const name in elements) {
     if (elements[name].key?.val)
-      --fkeys;
+      --keyCount;
   }
-  return fkeys === 0;
+  return keyCount === 0;
 }
 
 // only if _effectiveType has been computed:

package/lib/compiler/xpr-rewrite.js

@@ -174,7 +174,8 @@ function xprRewriteFns( model ) {
     resolvePath,
     navigationEnv,
     resolvePathRoot,
-    firstProjectionForPath,
+    cachedRedirectionChain,
+    findRewriteTarget,
   } = model.$functions;
 
   return {
@@ -355,7 +356,7 @@ function xprRewriteFns( model ) {
     // On select items, use navigation elements or table alias
     // TODO: Expand/inline paths don't have a `_navigation` property on their last
     //       path step, yet.  We need to implement expand/inline.
-    const isSimpleSelectItem = target.value?.path && target._main?.query && !target._pathHead;
+    const isSimpleSelectItem = target.value?.path && target._main?.query && !target._columnParent;
     if (isSimpleSelectItem) {
       const isSelfPath = (expr.path[0]?._navigation?.kind === '$self');
       if (isSelfPath) {
@@ -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,62 +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];
-    // Not a query -> no $navElement -> use `elements`
-    if (!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

@@ -1,6 +1,6 @@
 'use strict';
 
-const { isEdmPropertyRendered, transformExpression } = require('../../model/csnUtils');
+const { isEdmPropertyRendered, transformAnnotationExpression } = require('../../model/csnUtils');
 const { isBuiltinType, isMagicVariable } = require('../../base/builtins');
 const edmUtils = require('../edmUtils.js');
 const oDataDictionary = require('../../gen/Dictionary.json');
@@ -131,7 +131,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
           const knownAnnos = filterKnownAnnotations(carrier);
           knownAnnos.forEach((pn) => {
             scopeCheck.anno = pn;
-            transformExpression(carrier, pn, scopeCheck, carrier.$path);
+            transformAnnotationExpression(carrier, pn, scopeCheck, carrier.$path);
           });
         });
       }
@@ -141,7 +141,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       const knownAnnos = filterKnownAnnotations(obj);
       knownAnnos.forEach((pn) => {
         scopeCheck.anno = pn;
-        transformExpression(obj, pn, scopeCheck, obj.$path);
+        transformAnnotationExpression(obj, pn, scopeCheck, obj.$path);
       });
     };
     if (def.$isParamEntity && def._origin) {
@@ -171,7 +171,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
               if (innerAnnotation)
                 newAnno += `.@${innerAnnotation}`;
               edmUtils.assignAnnotation(def, newAnno, def._origin[attr]);
-              transformExpression(def._origin, attr, scopeCheck, def._origin.$path);
+              transformAnnotationExpression(def._origin, attr, scopeCheck, def._origin.$path);
               if (paramAnnoParts.length > 1)
                 delete def._origin[attr];
             }
@@ -419,7 +419,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
 
     knownAnnos.forEach((knownAnno) => {
       if (knownAnno.search(/\.\$edmJson\./g) < 0) {
-        transformExpression(carrier, knownAnno, {
+        transformAnnotationExpression(carrier, knownAnno, {
           ref: (elemref, prop, xpr, csnPath) => {
             if (options.isV2() && elemref.$bparam) {
               error('odata-anno-xpr-ref', ctx.location, {
@@ -842,8 +842,8 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
      * */
     let newAnno;
     const omissions = { 'Aggregation.default': 1 };
-    const nullList = { 'Core.OperationAvailable': 1 };
-    if (annoValue !== null && !omissions[termName] || nullList[termName]) {
+    const nullList = { 'Core.OperationAvailable': 1, 'Core.OptionalParameter': 1 };
+    if (annoValue != null && !omissions[termName] || nullList[termName]) {
     // termName may contain a qualifier: @UI.FieldGroup#shippingStatus
     // -> remove qualifier from termName and set Qualifier attribute in newAnno
       const i = termName.indexOf('#');
@@ -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',
                       });
             }
@@ -989,6 +989,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
     else {
       const res = handleSimpleValue(cAnnoValue, dTypeName, msg);
       if (((oTermName === 'Core.OperationAvailable' && dTypeName === 'Edm.Boolean') ||
+        (oTermName === 'Core.OptionalParameter' && dTypeName === 'Edm.String') ||
         (oTermName === 'Validation.AllowedValues' && dTypeName === 'Edm.PrimitiveType')) &&
         cAnnoValue === null) {
         oTarget.append(new Edm.ValueThing(v, 'Null'));
@@ -1023,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',
                 });
       }
@@ -1059,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',
                   });
         }
@@ -1119,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(),
@@ -1230,7 +1231,10 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       }
     }
     else if (value === null) {
-      if ((resolvedType == null || resolvedType === 'Edm.PrimitiveType') && typeName === 'String') {
+      if ((resolvedType == null ||
+           resolvedType === 'Edm.PrimitiveType' ||
+           resolvedType === 'Edm.String') &&
+           typeName === 'String') {
         resolvedType = 'Edm.String';
       }
       else {
@@ -1589,7 +1593,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
 
   function filterKnownAnnotations( carrier ) {
     const annoNames = Object.keys(carrier).filter( x => x[0] === '@' );
-    const nullWhitelist = [ '@Core.OperationAvailable' ];
+    const nullWhitelist = [ '@Core.OperationAvailable', '@Core.OptionalParameter.DefaultValue' ];
     const knownAnnosP = annoNames.filter((n) => {
       const tns = whatsMyTermNamespace(n);
       return tns &&

package/lib/edm/csn2edm.js

@@ -266,8 +266,19 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
         });
       }
     });
+    if (!options.odataNoCreator) {
+      // remove unqualified @Core.Links and #CAP
+      Object.keys(serviceCsn).forEach((key) => {
+        if (key === '@Core.Links' || key.startsWith('@Core.Links.') ||
+            key === '@Core.Links#CAP' || key.startsWith('@Core.Links#CAP.'))
+          delete serviceCsn[key];
+      });
+    }
+
     // Create annotations and distribute into Schemas, merge vocabulary cross refs into xServiceRefs
-    addAnnotations2XServiceRefs();
+    addAnnotationsAndXServiceRefs();
+    if (!options.odataNoCreator)
+      LeadSchema.prepend(waterMark());
 
     // Finally add cross service references into the EDM and extract the targetSchemaNames
     // for the type cross check
@@ -308,6 +319,18 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
 
     return edm;
 
+    function waterMark() {
+      const rel = new Edm.PropertyValue(v, 'rel');
+      rel._xmlOnlyAttributes.String = 'author';
+      rel._jsonOnlyAttributes['Edm.String'] = 'author';
+      const href = new Edm.PropertyValue(v, 'href');
+      href._xmlOnlyAttributes.String = 'https://cap.cloud.sap';
+      href._jsonOnlyAttributes['Edm.String'] = 'https://cap.cloud.sap';
+      const watermark = new Edm.Annotation(v, 'Core.Links', new Edm.Collection(v, new Edm.Record(v, rel, href)));
+      // watermark._edmAttributes['Qualifier'] = 'CAP';
+      return watermark;
+    }
+
     // Sort definitions into their schema container
     function populateSchemas( schemas ) {
       forEach(reqDefs.definitions, ( fqName, art ) => {
@@ -713,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;
         /*
@@ -1099,8 +1122,9 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
     }
 
     // generate the Edm.Annotations tree and append it to the corresponding schema
-    function addAnnotations2XServiceRefs( ) {
+    function addAnnotationsAndXServiceRefs( ) {
       options.getFinalTypeInfo = csnUtils.getFinalTypeInfo;
+
       const { annos, usedVocabularies, xrefs } = translate.csn2annotationEdm(reqDefs, csnUtils, csn.vocabularies, serviceCsn.name, Edm, options, messageFunctions, mergedVocabularies);
       // distribute edm:Annotations into the schemas
       // Distribute each anno into Schema