@sap/cds-compiler 2.13.8 → 2.15.6

package/lib/edm/annotations/genericTranslation.js

@@ -4,15 +4,16 @@ const edmUtils = require('../edmUtils.js');
 const preprocessAnnotations = require('./preprocessAnnotations.js');
 const oDataDictionary = require('../../gen/Dictionary.json');
 const { forEachDefinition } = require('../../model/csnUtils');
+const { forEach } = require("../../utils/objectUtils");
 
 
-/* Vocabulary overview as of January 2020:
-
+/*
    OASIS: https://github.com/oasis-tcs/odata-vocabularies/tree/master/vocabularies
    Aggregation (published)
    Authorization (published)
    Capabilities (published)
    Core (published)
+   JSON (published)
    Measures (published)
    Repeatability (published)
    Temporal (not published, not yet finalized)
@@ -23,8 +24,9 @@ const { forEachDefinition } = require('../../model/csnUtils');
    CodeList (published)
    Common (pubished)
    Communication (published)
+   DataIntegration (published)
    Graph (published, experimental)
-   Hierarchy (not published, still experimental)
+   Hierarchy (published, experimental)
    HTML5 (published, experimental)
    ODM (published, experimental)
    PersonalData (published)
@@ -73,16 +75,31 @@ const vocabularyDefinitions = {
     'inc': { Alias: 'Core', Namespace: 'Org.OData.Core.V1' },
     'int': { filename: 'Core.xml' }
   },
+  'DataIntegration': {
+    'ref': { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/DataIntegration.xml' },
+    'inc': { Alias: 'DataIntegration', Namespace: 'com.sap.vocabularies.DataIntegration.v1' },
+    'int': { filename: 'DataIntegration.xml' }
+  },
   'Graph': {
     'ref': { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/Graph.xml' },
     'inc': { Alias: 'Graph', Namespace: 'com.sap.vocabularies.Graph.v1' },
     'int': { filename: 'Graph.xml' }
   },
+  'Hierarchy': {
+    'ref': { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/Hierarchy.xml' },
+    'inc': { Alias: 'Hierarchy', Namespace: 'com.sap.vocabularies.Hierarchy.v1' },
+    'int': { filename: 'Hierarchy.xml' }
+  },
   'HTML5': {
     'ref': { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/HTML5.xml' },
     'inc': { Alias: 'HTML5', Namespace: 'com.sap.vocabularies.HTML5.v1' },
     'int': { filename: 'HTML5.xml' }
   },
+  'JSON': {
+    'ref': { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.JSON.V1.xml' },
+    'inc': { Alias: 'JSON', Namespace: 'Org.OData.JSON.V1' },
+    'int': { filename: 'JSON.xml' }
+  },
   'Measures': {
     'ref': { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.Measures.V1.xml' },
     'inc': { Alias: 'Measures', Namespace: 'Org.OData.Measures.V1' },
@@ -316,7 +333,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
   function handleNestedElements(objname, baseElemName, elementsObj) {
     if(!elementsObj) return;
     Object.entries(elementsObj).forEach(([elemName, element]) => {
-      if (Object.keys(element).filter( x => x.substr(0,1) === '@' ).filter(filterKnownVocabularies).length > 0) {
+      if (Object.keys(element).filter( x => x[0] === '@' ).filter(filterKnownVocabularies).length > 0) {
         message(warning, null, `annotations at nested elements are not yet supported, object ${objname}, element ${baseElemName}.${elemName}`);
       }
 
@@ -414,17 +431,23 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
     // do nothing
 
     if(!isEdmPropertyRendered(carrier, options) ||
-      (isV2() && (edmUtils.isDerivedType(carrier) || carrier['@Core.MediaType']))) {
+      (isV2() && (edmUtils.isDerivedType(carrier)))) {
       return;
     }
 
     // Filter unknown toplevel annotations
     // Final filtering of all annotations is done in handleTerm
-    const annoNames = Object.keys(carrier).filter( x => x.substr(0,1) === '@' );
+    
+    let annoNames = Object.keys(carrier).filter( x => x[0] === '@' );
     const nullWhitelist = [ '@Core.OperationAvailable' ];
-    const knownAnnos = annoNames.filter(filterKnownVocabularies).filter(x => carrier[x] !== null || nullWhitelist.includes(x));
+    let knownAnnos = annoNames.filter(filterKnownVocabularies).filter(x => carrier[x] !== null || nullWhitelist.includes(x));
     if (knownAnnos.length === 0) return;
 
+    if(rewriteInnerAnnotations()) {
+      annoNames = Object.keys(carrier).filter( x => x[0] === '@' );
+      knownAnnos = annoNames.filter(filterKnownVocabularies).filter(x => carrier[x] !== null || nullWhitelist.includes(x));
+      if (knownAnnos.length === 0) return;
+    }
     const prefixTree = createPrefixTree();
 
     // usually, for a given carrier there is one target
@@ -593,6 +616,51 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
       */
     }
 
+    function rewriteInnerAnnotations() {
+      let rc = false;
+      for (let a of knownAnnos) {
+        const [ prefix, innerAnnotation ] = a.split('.@');
+        /*
+          New inner annotation (de-)structuring of the core compiler to make
+          $value arrays extendable via ellipsis
+          @anno: { $value: [ ... ], @innerAnno: ... } is now cracked up by
+          the core compiler into:
+          @anno: [ ...]
+          @anno.@innerAnno: ...
+
+          Conflict handling if $value is present:
+          @anno
+          @anno.$value
+          @anno.@innerAnno
+
+          @anno has precedence (as it was before this change) but now
+          @anno.$value is overwritten with @anno and the inner annotations
+          are applied.
+
+          Trigger is always the inner annotation, if no inner annotation
+          is available, @anno has precedence.
+
+          Insert $value into $edmJson with inner annotation as well.
+        */
+        if(innerAnnotation) {
+          if(carrier[prefix]) {
+            const valPrefix = prefix + '.$value';
+            carrier[valPrefix] = carrier[prefix];
+            delete carrier[prefix];
+            rc = true;
+          }
+          const edmJsonPrefix = prefix + '.$edmJson';
+          if(carrier[edmJsonPrefix]) {
+            const valPrefix = prefix + '.$value.$edmJson';
+            carrier[valPrefix] = carrier[edmJsonPrefix];
+            delete carrier[edmJsonPrefix];
+            rc = true;
+          }
+        }
+      }
+      return rc;
+    }
+
     function createPrefixTree() {
       // in csn, all annotations are flattened
       // => values can be - primitive values (string, number)
@@ -602,6 +670,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
       //   by building a "prefix tree" for the annotations attached to the carrier
       //   see example at definition of function mergePathStepsIntoPrefixTree
       const prefixTree = {};
+
       for (let a of knownAnnos) {
       // remove leading @ and split at "."
       //   stop splitting at ".@" (used for nested annotations)
@@ -663,7 +732,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
           }
           mergePathStepsIntoPrefixTree(tree[name], pathSteps, index+1, carrier);
         }
-        else {
+        else if(typeof tree === 'object' ){
           tree[name] = carrier['@' + pathSteps.join('.')];
         }
       }
@@ -714,9 +783,10 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
      * @type {object}
      * */
     let newAnno = undefined;
-    const nullWhitelist = [ 'Core.OperationAvailable' ];
+    const omissions = { 'Aggregation.default':1 };
+    const nullList = { 'Core.OperationAvailable':1 };
     const voc = termName.slice(0, termName.indexOf('.'));
-    if(vocabularyDefinitions[voc] && annoValue !== null || nullWhitelist.includes(termName)) {
+    if(vocabularyDefinitions[voc] && annoValue !== null && !omissions[termName]|| nullList[termName]) {
       newAnno = new Edm.Annotation(v, termName);
 
     // termName may contain a qualifier: @UI.FieldGroup#shippingStatus
@@ -729,8 +799,8 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
           message(error, context,
                 `OData annotation qualifier "${ p[1] }" must start with a letter or underscore, followed by at most 127 letters, underscores or digits`);
         }
-        newAnno.Term = termNameWithoutQualifiers;
-        newAnno.Qualifier = p[1];
+        newAnno.setEdmAttribute('Term', termNameWithoutQualifiers);
+        newAnno.setEdmAttribute('Qualifier', p[1]);
       }
       if (p.length>2) {
         message(warning, context, `multiple qualifiers (${ p[1] },${ p[2] }${ p.length > 3 ? ',...' : '' })`);
@@ -827,7 +897,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
         // "pseudo-structure" used for embedding a piece of JSON that represents "OData CSDL, JSON Representation"
         oTarget.append(handleEdmJson(cAnnoValue['$edmJson'], context));
       }
-      else if ( Object.keys(cAnnoValue).filter( x => x.substr(0,1) !== '@' ).length === 0) {
+      else if ( Object.keys(cAnnoValue).filter( x => x[0] !== '@' ).length === 0) {
         // object consists only of properties starting with "@"
         message(warning, context, 'nested annotations without corresponding base annotation');
       }
@@ -934,6 +1004,8 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
   //      Edm.Decimal -> Decimal
   //      integer tpye -> Int
   function handleSimpleValue(val, dTypeName, context) {
+    // these types must be represented as "String" values in XML:
+    const castToXmlString = [ 'Edm.PrimitiveType', 'Edm.Stream', 'Edm.Untyped' ];
     // caller already made sure that val is neither object nor array
     dTypeName = resolveType(dTypeName);
 
@@ -971,12 +1043,12 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
         message(warning, context, `found String, but expected enum type ${ dTypeName }`);
         typeName = 'EnumMember';
       }
-      else if (dTypeName && dTypeName.startsWith('Edm.') && dTypeName !== 'Edm.PrimitiveType') {
+      else if (dTypeName && dTypeName.startsWith('Edm.') && !castToXmlString.includes(dTypeName)) {
         // this covers also all paths
         typeName = dTypeName.substring(4);
       }
       else {
-        if(dTypeName == undefined || dTypeName === 'Edm.PrimitiveType')
+        if(dTypeName == undefined || castToXmlString.some(t => t === dTypeName))
           dTypeName = 'Edm.String';
         // TODO
         //message(warning, context, "type is not yet handled: found String, expected type: " + dTypeName);
@@ -1072,7 +1144,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
         // this type doesn't exist
         message(warning, context, `explicitly specified type '${ actualTypeName }' not found in vocabulary`);
         // explicitly mentioned type, render in XML and JSON
-        newRecord.Type = actualTypeName;
+        newRecord.setEdmAttribute('Type', actualTypeName);
       }
       else if (dTypeName && !isDerivedFrom(actualTypeName, dTypeName)) {
         // this type doesn't fit the expected one
@@ -1080,7 +1152,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
         }' is not derived from expected type '${ dTypeName }'`);
         actualTypeName = dTypeName;
         // explicitly mentioned type, render in XML and JSON
-        newRecord.Type = actualTypeName;
+        newRecord.setEdmAttribute('Type', actualTypeName);
       }
       else if (isAbstractType(actualTypeName)) {
         // this type is abstract
@@ -1088,7 +1160,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
         if(dTypeName)
           actualTypeName = dTypeName;
         // set to definition name and render in XML and JSON
-        newRecord.Type = actualTypeName;
+        newRecord.setEdmAttribute('Type', actualTypeName);
       }
       else {
         // ok
@@ -1251,7 +1323,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
           const props = Object.create(null);
           Object.entries(obj).forEach(([k, val]) => {
             if(k === '@type') {
-              edmNode.Type = val;
+              edmNode.setEdmAttribute('Type', val);
             }
             else {
               let child = undefined;
@@ -1297,14 +1369,14 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
       edmNode = exprDef.create(obj);
 
       // iterate over each obj.property and translate expression into EDM
-      Object.entries(obj).forEach(([name, val]) => {
+      forEach(obj, (name, val) => {
         if(exprDef) {
           if(exprDef.anno && name[0] === '@') {
             edmNode.append(handleTerm(name.slice(1), val, context));
           }
           else if (exprDef.attr && exprDef.attr.includes(name)) {
             if (name[0] === '$') {
-              edmNode[name.slice(1)] = val;
+              edmNode.setEdmAttribute(name.slice(1), val);
             }
           }
           else if (exprDef.jsonAttr && exprDef.jsonAttr.includes(name)) {