@sap/cds-compiler 2.7.0 → 2.11.2

package/lib/edm/annotations/genericTranslation.js

@@ -3,7 +3,6 @@ const { isEdmPropertyRendered, isBuiltinType } = require('../../model/csnUtils')
 const edmUtils = require('../edmUtils.js');
 const preprocessAnnotations = require('./preprocessAnnotations.js');
 const oDataDictionary = require('../../gen/Dictionary.json');
-const { makeMessageFunction } = require('../../base/messages');
 const { forEachDefinition } = require('../../model/csnUtils');
 
 
@@ -131,16 +130,19 @@ const knownVocabularies = Object.keys(vocabularyDefinitions);
  *   v - array with two boolean entries, first is for v2, second is for v4
  *   dictReplacement: for test purposes, replaces the standard oDataDictionary
  */
-function csn2annotationEdm(csn, edm, serviceName, options=undefined) {
+function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined, messageFunctions=undefined) {
 
+  if(!Edm)
+    throw new Error('Please debug me: csn2annotationsEdm must be invoked with Edm');
   if(!options)
     throw new Error('Please debug me: csn2annotationsEdm must be invoked with options');
+  if(!messageFunctions)
+    throw new Error('Please debug me: csn2annotationsEdm must be invoked with messageFunctions');
+  // global variable where we store all the generated annotations
+  const g_annosArray = [];
 
-  const messageFunctions = makeMessageFunction(csn, options);
   const { info, warning, error } = messageFunctions;
 
-  const Edm = require('../edm.js')(options, error);
-
   // Static dynamic expression dictionary, loaded with Edm creators
   const [ dynamicExpressions, dynamicExpressionNames ] = initEdmJson();
 
@@ -197,10 +199,7 @@ function csn2annotationEdm(csn, edm, serviceName, options=undefined) {
     }
   }();
 
-  let v = options.v;
-
-  // global variable where we store all the generated annotations
-  let g_annosArray = [];
+  const v = options.v;
 
   // Crawl over the csn and trigger the annotation translation for all kinds
   //   of annotated things.
@@ -224,40 +223,10 @@ function csn2annotationEdm(csn, edm, serviceName, options=undefined) {
   });
 
   // filter out empty <Annotations...> elements
-  g_annosArray = g_annosArray.filter(x => x._children.length > 0 || x.kind !== 'Annotations');
-
-  // edm is undefined in testODataAnnotations.js
-  if(edm !== undefined) {
-    // distribute edm:Annotations into the schemas
-    // Create list of full qualified schema names (ServiceName[.subschema])
-    // Sort in reverse order for longest match
-    const fqSchemaNames = Object.keys(edm._service._schemas).sort((a,b) => b.length-a.length);
-    // Distribute each anno into Schema
-    g_annosArray.forEach(annos => {
-      const carrierName = annos.Target;
-      let targetSchema = fqSchemaNames.reduce((rc, sn) => !rc && carrierName && carrierName.startsWith(sn + '.') ? sn : rc, undefined);
-      // if no target schema has been found, it's a service annotation that applies to the service schema
-      if(targetSchema === undefined)
-        targetSchema = serviceName;
-      if(targetSchema) {
-        if(targetSchema !== serviceName) {
-          annos.Target = annos.Target.replace(serviceName + '.', '');
-        }
-        edm._service._schemas[targetSchema]._annotations.push(annos);
-      }
-    });
-
-    // add references for the used vocabularies
-    knownVocabularies.forEach(n => {
-      if(vocabularyDefinitions[n].used) {
-        let r = new Edm.Reference(v, vocabularyDefinitions[n].ref);
-        r.append(new Edm.Include(v, vocabularyDefinitions[n].inc))
-        edm._defaultRefs.push(r);
-      }
-    })
-  }
-
-  return g_annosArray;
+  // add references for the used vocabularies
+  return {
+    annos: g_annosArray, usedVocabularies: Object.values(vocabularyDefinitions).filter(v => v.used)
+  };
 
 //-------------------------------------------------------------------------------------------------
 //-------------------------------------------------------------------------------------------------
@@ -441,10 +410,11 @@ function csn2annotationEdm(csn, edm, serviceName, options=undefined) {
 
     // if the carier 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
 
     if(!isEdmPropertyRendered(carrier, options) ||
-      (edmUtils.isDerivedType(carrier) && options.isV2())) {
+      (isV2() && (edmUtils.isDerivedType(carrier) || carrier['@Core.MediaType']))) {
       return;
     }
 
@@ -455,72 +425,95 @@ function csn2annotationEdm(csn, edm, serviceName, options=undefined) {
     const knownAnnos = annoNames.filter(filterKnownVocabularies).filter(x => carrier[x] !== null || nullWhitelist.includes(x));
     if (knownAnnos.length === 0) return;
 
-    // in csn, all annotations are flattened
-    // => values can be - primitive values (string, number)
-    //                  - pseudo-records with "#" or "="
-    //                  - arrays
-    // in OData, there are "structured" annotations -> we first need to regroup the cds annotations
-    //   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)
-      // Inline JSON EDM allows to add annotations to record members
-      // by prefixing the annotation with the record member 'foo@Common.Label'
-      // The splitter should leave such annotations alone, handleEdmJson
-      // takes care of assigning these annotations to the record members
-      const [ prefix, innerAnnotation ] = a.split('.@');
-      const steps = prefix.slice(1).split('.');
-      let i = steps.lastIndexOf('$edmJson');
-      if(i > -1) {
-        i = steps.findIndex(s => s.includes('@'), i+1);
-        if(i > -1) {
-          steps.splice(i, steps.length-i, steps.slice(i).join('.'));
-        }
-      }
-      if (innerAnnotation) {
-        // A voc annotation has two steps (Namespace+Name),
-        // any furter steps need to be rendered separately
-        const innerAnnoSteps = innerAnnotation.split('.');
-        const tailSteps = innerAnnoSteps.splice(2, innerAnnoSteps.length-2);
-        // prepend annotation prefix (path) to tail steps
-        tailSteps.splice(0, 0, '@' + innerAnnoSteps.join('.'));
-        steps.push(...tailSteps);
-      }
-      mergePathStepsIntoPrefixTree(prefixTree, steps, 0, carrier);
+    const prefixTree = createPrefixTree();
+
+    // usually, for a given carrier there is one target
+    // for some carriers (service, entity), there can be an alternative target (usually the EntitySet)
+    //    alternativeEdmTargetName: name of alternative target
+    // which one to choose depends on the "AppliesTo" info of the single annotations, so we have
+    //   to defer this decision; this is why we here construct a function that can make the decision
+    //   later when looking at single annotations
+
+    const [
+        stdEdmTargetName,           // either the schema path or the EntityContainer itself
+        hasAlternativeCarrier,      // is the alternative annotation target available in the EDM?
+        alternativeEdmTargetName,   // EntitySet path name
+        testToStandardEdmTarget,    // if true, assign to standard Edm Target
+        testToAlternativeEdmTarget, // if true, assign to alternative Edm Target
+      ] = initCarrierControlVars();
+
+    // collect produced Edm.Annotation nodes for various carriers
+    const serviceAnnotations = [];
+    const stdAnnotations = [];
+    const alternativeAnnotations = [];
+
+    // now create annotation objects for all the annotations of carrier
+    handleAnno2(addAnnotation, edmTargetName /*used for messages*/, prefixTree);
+
+    // Produce Edm.Annotations and attach collected Edm.Annotation(s) to the
+    // envelope (or directly to the Schema)
+    if(serviceAnnotations.length) {
+      g_annosArray.push(...serviceAnnotations.filter(a=>a));
     }
+    if(stdAnnotations.length) {
+      const annotations = new Edm.Annotations(v, stdEdmTargetName); // used in closure
+      annotations.append(...stdAnnotations);
+      g_annosArray.push(annotations);
+    }
+    if(alternativeAnnotations.length) {
+      const annotations = new Edm.Annotations(v, alternativeEdmTargetName);
+      annotations.append(...alternativeAnnotations);
+      g_annosArray.push(annotations);
+    }
+
     // construct a function that is used to add an <Annotation ...> to the
-    //   respective <Annotations ...> element
+    //   respective collector array
     // this function is specific to the actual carrier, following the mapping rules given above
-    let addAnnotation = function() {
-      // usually, for a given carrier there is one target
-      //   stdName: name of this target
-      //   newAnnosStd: the corresponding <Annotations ...> tag
-      // for some carriers (service, entity), there can be an alternative target (usually the EntitySet)
-      //    alternativeEdmTargetName: name of alternative target
-      //    newAnnosAlt: the corresponding <Annotations ...> tag
-      // which one to choose depends on the "AppliesTo" info of the single annotations, so we have
-      //   to defer this decision; this is why we here construct a function that can make the decision
-      //   later when looking at single annotations
+    function addAnnotation(annotation, appliesTo) {
+      let rc=false;
+      if (testToAlternativeEdmTarget && appliesTo && testToAlternativeEdmTarget(appliesTo)) {
+        if (carrier.kind === 'service') {
+          if (isV2()) {
+            // there is no enclosing <Annotations ...>, so for v2 the namespace needs to be mentioned here
+            annotation.setXml( { xmlns: 'http://docs.oasis-open.org/odata/ns/edm' } );
+          }
+          serviceAnnotations.push(annotation); // for target Schema: no <Annotations> element
+        }
+        else if(hasAlternativeCarrier) {
+          alternativeAnnotations.push(annotation);
+        }
+        rc=true;
+      }
+      if(testToStandardEdmTarget(appliesTo)) {
+        stdAnnotations.push(annotation);
+        rc=true;
+      }
+      // Another crazy hack due to this crazy function:
+      // If carrier is a managed association (has keys) and rc is false (annotation was not applicable)
+      // return true to NOT trigger 'unapplicable' info message
+      if(rc === false && carrier.target && carrier.keys && appliesTo.includes('Property'))
+        rc = true;
+      return rc;
+    }
 
-      let testToAlternativeEdmTarget = null; // if true, assign to alternative Edm Target
-      // eslint-disable-next-line no-unused-vars
-      let testToStandardEdmTarget = (val) => true; // if true, assign to standard Edm Target
-      let stdName = edmTargetName;
+    function initCarrierControlVars() {
+    // eslint-disable-next-line no-unused-vars
+      let testToStandardEdmTarget = () => true; // if true, assign to standard Edm Target
+      let stdEdmTargetName = edmTargetName;
       let alternativeEdmTargetName = null;
       let hasAlternativeCarrier = false; // is the alternative annotation target available in the EDM?
+      let testToAlternativeEdmTarget = null; // if true, assign to alternative Edm Target
 
       if (carrier.kind === 'entity' || carrier.kind === 'view') {
-        // If AppliesTo=[EntitySet/Singleton, EntityType], EntitySet/Singleton has precedence
+      // If AppliesTo=[EntitySet/Singleton, EntityType], EntitySet/Singleton has precedence
         testToAlternativeEdmTarget = (x => x.includes('EntitySet') || x.includes('Singleton'));
         testToStandardEdmTarget = (x => x ? x.includes('EntityType') : true);
-        // if carrier has an alternate 'entitySetName' use this instead of EdmTargetName
-        // (see edmPreprocessor.initializeParameterizedEntityOrView(), where parameterized artifacts
-        // are split into *Parameter and *Type entities and their respective EntitySets are eventually
-        // renamed.
-        // (which is the definition key in the CSN and usually the name of the EntityType)
-        // Replace up to last dot with <serviceName>.EntityContainer/
+      // if carrier has an alternate 'entitySetName' use this instead of EdmTargetName
+      // (see edmPreprocessor.initializeParameterizedEntityOrView(), where parameterized artifacts
+      // are split into *Parameter and *Type entities and their respective EntitySets are eventually
+      // renamed.
+      // (which is the definition key in the CSN and usually the name of the EntityType)
+      // Replace up to last dot with <serviceName>.EntityContainer/
         alternativeEdmTargetName = carrier.$entitySetName || edmTargetName
         const lastDotIndex = alternativeEdmTargetName.lastIndexOf('.');
         if (lastDotIndex > -1)
@@ -528,32 +521,37 @@ function csn2annotationEdm(csn, edm, serviceName, options=undefined) {
         hasAlternativeCarrier = carrier.$hasEntitySet;
       }
       else if (carrier.kind === 'service') {
-        // if annotated object is a service, annotation goes to EntityContainer,
-        //   except if AppliesTo contains Schema but not EntityContainer, then annotation goes to Schema
+      // if annotated object is a service, annotation goes to EntityContainer,
+      //   except if AppliesTo contains Schema but not EntityContainer, then annotation goes to Schema
         testToAlternativeEdmTarget = (x => x.includes('Schema') && !x.includes('EntityContainer'));
         testToStandardEdmTarget = ( x => x ? (
-          // either only AppliesTo=[EntityContainer]
-          (!x.includes('Schema') && x.includes('EntityContainer')) ||
-          // or AppliesTo=[Schema, EntityContainer]
-          (x.includes('Schema') && x.includes('EntityContainer')))
-           : true );
-        stdName = edmTargetName + '.EntityContainer';
+        // either only AppliesTo=[EntityContainer]
+        (!x.includes('Schema') && x.includes('EntityContainer')) ||
+        // or AppliesTo=[Schema, EntityContainer]
+        (x.includes('Schema') && x.includes('EntityContainer')))
+          : true );
+        stdEdmTargetName = edmTargetName + '.EntityContainer';
         alternativeEdmTargetName = edmTargetName;
         hasAlternativeCarrier = true; // EntityContainer is always available
       }
-      //element => decide if navprop or normal property
+    //element => decide if navprop or normal property
       else if(!carrier.kind) {
-        // if appliesTo is undefined, return true
+      // if appliesTo is undefined, return true
         if(carrier.target) {
           testToStandardEdmTarget = (x=> x ? x.includes('NavigationProperty') : 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)): true);
         }
       }
-
-
+      return [
+        stdEdmTargetName,
+        hasAlternativeCarrier,
+        alternativeEdmTargetName,
+        testToStandardEdmTarget,
+        testToAlternativeEdmTarget
+      ];
       /* all AppliesTo entries:
         "Action",
         "ActionImport",
@@ -578,88 +576,86 @@ function csn2annotationEdm(csn, edm, serviceName, options=undefined) {
         "Term",
         "TypeDefinition"
       */
+    }
 
-      // result objects that holds all the annotation objects to be created
-      let newAnnosStd = new Edm.Annotations(v, stdName); // used in closure
-      g_annosArray.push(newAnnosStd);
-      let newAnnosAlternative = null; // create only on demand
-
-      return function(annotation, appliesTo) {
-        let rc=false;
-        if (testToAlternativeEdmTarget && appliesTo && testToAlternativeEdmTarget(appliesTo)) {
-          if (carrier.kind === 'service') {
-            if (isV2()) {
-              // there is no enclosing <Annotations ...>, so for v2 the namespace needs to be mentioned here
-              annotation.setXml( { xmlns: 'http://docs.oasis-open.org/odata/ns/edm' } );
-            }
-            g_annosArray.push(annotation); // for target Schema: no <Annotations> element
+    function createPrefixTree() {
+      // in csn, all annotations are flattened
+      // => values can be - primitive values (string, number)
+      //                  - pseudo-records with "#" or "="
+      //                  - arrays
+      // in OData, there are "structured" annotations -> we first need to regroup the cds annotations
+      //   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)
+      // Inline JSON EDM allows to add annotations to record members
+      // by prefixing the annotation with the record member 'foo@Common.Label'
+      // The splitter should leave such annotations alone, handleEdmJson
+      // takes care of assigning these annotations to the record members
+        const [ prefix, innerAnnotation ] = a.split('.@');
+        const steps = prefix.slice(1).split('.');
+        let i = steps.lastIndexOf('$edmJson');
+        if(i > -1) {
+          i = steps.findIndex(s => s.includes('@'), i+1);
+          if(i > -1) {
+            steps.splice(i, steps.length-i, steps.slice(i).join('.'));
           }
-          // Add <Annotations> to existing carrier only
-          else if(hasAlternativeCarrier) {
-            if (!newAnnosAlternative) { // only create upon insertion of first anno
-              newAnnosAlternative = new Edm.Annotations(v, alternativeEdmTargetName);
-              g_annosArray.push(newAnnosAlternative);
-            }
-            newAnnosAlternative.append(annotation);
+        }
+        if (innerAnnotation) {
+        // A voc annotation has two steps (Namespace+Name),
+        // any furter steps need to be rendered separately
+          const innerAnnoSteps = innerAnnotation.split('.');
+          const tailSteps = innerAnnoSteps.splice(2, innerAnnoSteps.length-2);
+        // prepend annotation prefix (path) to tail steps
+          tailSteps.splice(0, 0, '@' + innerAnnoSteps.join('.'));
+          steps.push(...tailSteps);
+        }
+        mergePathStepsIntoPrefixTree(prefixTree, steps, 0, carrier);
+      }
+      return prefixTree;
+
+      // tree: object where to put the next level of names
+      // path: the parts of the annotation name
+      // index: index into that array pointing to the next name to be processed
+      //   0  : vocabulary
+      //   1  : term
+      //   2+ : record properties
+      //
+      // example:
+      //   @v.t1
+      //   @v.t2.p1
+      //   @v.t2.p2
+      //   @v.t3#x.q1
+      //   @v.t3#x.q2
+      //   @v.t3#y.q1
+      //   @v.t3#y.q2
+      //
+      //   { v : { t1 : ...,
+      //           t2 : { p1 : ...,
+      //                  p2 : ...   },
+      //           t3#x : { q1 : ...,
+      //                    q2 : ... }
+      //           t3#y : { q1 : ...,
+      //                    q2 : ... } } }
+      function mergePathStepsIntoPrefixTree(tree, pathSteps, index, carrier) {
+      // TODO check nesting level > 3
+        let name = pathSteps[index];
+        if (index+1 < pathSteps.length ) {
+          if (!tree[name]) {
+            tree[name] = {};
           }
-          rc=true;
+          mergePathStepsIntoPrefixTree(tree[name], pathSteps, index+1, carrier);
         }
-        if(testToStandardEdmTarget(appliesTo)) {
-          newAnnosStd.append(annotation);
-          rc=true;
+        else {
+          tree[name] = carrier['@' + pathSteps.join('.')];
         }
-        // Another crazy hack due to this crazy function:
-        // If carrier is a managed association (has keys) and rc is false (annotation was not applicable)
-        // return true to NOT trigger 'unapplicable' info message
-        if(rc === false && carrier.target && carrier.keys && appliesTo.includes('Property'))
-          rc = true;
-        return rc;
       }
-    }();
-
-    // now create annotation objects for all the annotations of carrier
-    //   and put them into the elements property of the result object
-    handleAnno2(addAnnotation, edmTargetName /*used for messages*/, prefixTree);
-  }
-
-
-  // tree: object where to put the next level of names
-  // path: the parts of the annotation name
-  // index: index into that array pointing to the next name to be processed
-  //   0  : vocabulary
-  //   1  : term
-  //   2+ : record properties
-  //
-  // example:
-  //   @v.t1
-  //   @v.t2.p1
-  //   @v.t2.p2
-  //   @v.t3#x.q1
-  //   @v.t3#x.q2
-  //   @v.t3#y.q1
-  //   @v.t3#y.q2
-  //
-  //   { v : { t1 : ...,
-  //           t2 : { p1 : ...,
-  //                  p2 : ...   },
-  //           t3#x : { q1 : ...,
-  //                    q2 : ... }
-  //           t3#y : { q1 : ...,
-  //                    q2 : ... } } }
-  function mergePathStepsIntoPrefixTree(tree, pathSteps, index, carrier) {
-    // TODO check nesting level > 3
-    let name = pathSteps[index];
-    if (index+1 < pathSteps.length ) {
-      if (!tree[name]) {
-        tree[name] = {};
-      }
-      mergePathStepsIntoPrefixTree(tree[name], pathSteps, index+1, carrier);
-    }
-    else {
-      tree[name] = carrier['@' + pathSteps.join('.')];
     }
   }
 
+
   // handle all the annotations for a given carrier
   // addAnnotationFunc: a function that adds the <Annotation ...> tags created here into the
   //                    correct parent tag (see handleAnnotations())
@@ -1123,7 +1119,7 @@ function csn2annotationEdm(csn, edm, serviceName, options=undefined) {
         let dictPropertyTypeName = null;
         if (dictProperties) {
           dictPropertyTypeName = dictProperties[i];
-          if (!dictPropertyTypeName){
+          if (!dictPropertyTypeName && !getDictType(actualTypeName).OpenType){
             message(warning, context, `record type '${ actualTypeName }' doesn't have a property '${ i }'`);
           }
         }