@sap/cds-compiler 3.7.2 → 3.8.2

package/lib/edm/annotations/genericTranslation.js

@@ -5,7 +5,7 @@ const oDataDictionary = require('../../gen/Dictionary.json');
 const preprocessAnnotations = require('./preprocessAnnotations.js');
 const { forEachDefinition } = require('../../model/csnUtils');
 const { forEach } = require('../../utils/objectUtils');
-const { isBetaEnabled } = require('../../base/model.js');
+const { isBetaEnabled, setProp } = require('../../base/model.js');
 
 /*
    OASIS: https://github.com/oasis-tcs/odata-vocabularies/tree/master/vocabularies
@@ -147,10 +147,23 @@ const vocabularyDefinitions = {
     'inc': { Alias: 'Validation', Namespace: 'Org.OData.Validation.V1' },
     'int': { filename: 'Validation.xml' }
   },
+  /* unvalidated vocabularies below here:
+     A vocabulary is unvalidated if it doesn't have an int.filename property as this indicates that
+     the vocabulary is added to the validation dictionary
+     Example:
+  'Org.Snafu.V1': {
+    'ref': { Uri: 'https://snafu.org/snafu.xml' },
+    'inc': { Alias: 'Snafu', Namespace: 'Org.Snafu.V1' },
+  },
+  */
 };
 
-const knownVocabularies = Object.keys(vocabularyDefinitions);
-
+/* create inverted voc definitions list to allow addressing full qualified vocabularies
+Object.entries(vocabularyDefinitions).forEach(([n, v]) => {
+  if(!vocabularyDefinitions[v.inc.Namespace])
+    vocabularyDefinitions[v.inc.Namespace] = vocabularyDefinitions[n];
+});
+*/
 /**************************************************************************************************
  * csn2annotationEdm
  *
@@ -158,24 +171,16 @@ 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(reqDefs, csnVocabularies, serviceName, Edm = undefined, options=undefined, messageFunctions=undefined) {
+function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
+  Edm = undefined, options=undefined, messageFunctions=undefined, mergedVocDefs=vocabularyDefinitions) {
   // global variable where we store all the generated annotations
   const g_annosArray = [];
 
   const { message } = messageFunctions;
 
-  const [ adhocDictionary, allKnownVocabularies ] = createAdhocDictionary();
+  const [ userDefinedTermDict, allKnownVocabularies ] = createUserDefinedTermDictionary();
 
-  /*
-    allKnownVocabularies is the union of knownVocabularies & adhoc $mySchemaName annotation definition
-    this allows to identify namespace prefixes of arbitrary length.
-
-    If in the future, the full Oasis vocabulary names shall be made usable for assignments
-    eg. @com.sap.vocabularies.Common.v1.Label, all that needs to be done is to x-link the
-    vocabulary dictionary whith the full ns as key:
-    vocabularyDefinitions['@com.sap.vocabularies.Common.v1'] = vocabularyDefinitions['Common']
-  */
-  allKnownVocabularies.push(...knownVocabularies);
+  allKnownVocabularies.push(...Object.keys(mergedVocDefs));
   allKnownVocabularies.sort((a,b) => b.length-a.length);
   const whatsMyTermNamespace = function(anno) {
     return allKnownVocabularies.reduce((rc, ns) => !rc && anno && anno.startsWith('@' + ns + '.') ? ns : rc, undefined);
@@ -189,13 +194,21 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName, Edm = undefine
 
   // we take note of which vocabularies are actually used in a service in order to avoid
   // producing useless references; reset everything to "unused"
-  knownVocabularies.forEach(n => {
-    vocabularyDefinitions[n].used = false;
-  });
+  for(const n in mergedVocDefs) {
+    mergedVocDefs[n].used = false;
+    delete mergedVocDefs[n].$ignore;
+  }
 
   // These vocabularies are always added for the runtimes
-  vocabularyDefinitions['Common'].used = true;
-  vocabularyDefinitions['Core'].used = true;
+  mergedVocDefs['Common'].used = true;
+  mergedVocDefs['Core'].used = true;
+
+  const vocDef = mergedVocDefs[serviceName];
+  if(vocDef && vocDef.$optVocRef) {
+    setProp(vocDef, '$ignore', true);
+    message('odata-anno-vocref', null,
+                { name: serviceName, '#': 'service' } );
+  }
 
   // provide functions for dictionary lookup
   //   use closure to avoid making "dict" and "experimental" global variables
@@ -210,15 +223,16 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName, Edm = undefine
       //                - issue a warning if the term is flagged as "experimental"
       getDictTerm: function(termName, msg) {
         const dictTerm = (dict.terms[termName] ||
-          adhocDictionary.terms[serviceName + '.' + termName] ||
-          adhocDictionary.terms[termName]);
+          userDefinedTermDict.terms[serviceName + '.' + termName] ||
+          userDefinedTermDict.terms[termName]);
         // register vocabulary usage if possible
         const vocName = termName.slice(0, termName.indexOf('.'));
-        if(vocabularyDefinitions[vocName])
-          vocabularyDefinitions[vocName].used = true;
+        const vocDef = mergedVocDefs[vocName];
+        if(vocDef && !vocDef.$ignore)
+          vocDef.used = true;
         else if(dictTerm?.$myServiceRoot &&
-          adhocDictionary.xrefs[dictTerm?.$myServiceRoot])
-          adhocDictionary.xrefs[dictTerm.$myServiceRoot].used = true;
+          userDefinedTermDict.xrefs[dictTerm?.$myServiceRoot])
+          userDefinedTermDict.xrefs[dictTerm.$myServiceRoot].used = true;
         if (dictTerm) {
           // issue message for usage of experimental Terms, but only once per Term
           if (dictTerm['$experimental'] && !experimental[termName]) {
@@ -237,13 +251,14 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName, Edm = undefine
       //   in addition, note usage of the respective vocabulary
       getDictType: function (typeName) {
         let dictType = (dict.types[typeName] ||
-          adhocDictionary.types[serviceName + '.' + typeName] ||
-          adhocDictionary.types[typeName]);
+          userDefinedTermDict.types[serviceName + '.' + typeName] ||
+          userDefinedTermDict.types[typeName]);
         if (dictType) {
           // register usage of vocabulary
-          const voc = vocabularyDefinitions[typeName.slice(0, typeName.indexOf('.'))];
-          if(voc)
-            voc.used = true;
+          const vocName = typeName.slice(0, typeName.indexOf('.'));
+          const vocDef = mergedVocDefs[vocName];
+          if(vocDef && !vocDef.$ignore)
+            vocDef.used = true;
         }
         return dictType;
       }
@@ -275,12 +290,13 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName, Edm = undefine
     }
   });
 
+
   // filter out empty <Annotations...> elements
   // add references for the used vocabularies
   return {
     annos: g_annosArray,
-    usedVocabularies: Object.values(vocabularyDefinitions).filter(v => v.used),
-    xrefs: Object.values(adhocDictionary.xrefs).filter(v => v.used).map(v => v.$myServiceRoot)
+    usedVocabularies: Object.values(mergedVocDefs).filter(v => v.used),
+    xrefs: Object.values(userDefinedTermDict.xrefs).filter(v => v.used).map(v => v.$myServiceRoot)
   };
 
 //-------------------------------------------------------------------------------------------------
@@ -503,10 +519,14 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName, Edm = undefine
     function filterKnownAnnotations() {
       const annoNames = Object.keys(carrier).filter( x => x[0] === '@' );
       const nullWhitelist = [ '@Core.OperationAvailable' ];
-      const knownAnnos = annoNames.filter(whatsMyTermNamespace).filter(x => carrier[x] !== null || nullWhitelist.includes(x));
+      const knownAnnos = annoNames.filter(n => {
+        const tns = whatsMyTermNamespace(n);
+        return tns &&
+          (mergedVocDefs[tns] && !mergedVocDefs[tns].$ignore ||
+           !mergedVocDefs[tns]);
+      }).filter(x => carrier[x] !== null || nullWhitelist.includes(x));
       if(isBetaEnabled(options, 'odataTerms')) {
         // Extend knownAnnos with the in-service term definitions
-        const adhoc = [];
         annoNames.forEach(an => {
           const paths = an.slice(1).split('.');
           const hasNSPrefix = paths[0] === serviceName;
@@ -530,10 +550,9 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName, Edm = undefine
               carrier[fqName] = carrier[an];
               delete carrier[an];
             }
-            adhoc.push(fqName);
+            knownAnnos.push(fqName);
           }
         });
-        knownAnnos.push(...adhoc);
       }
       return knownAnnos;
     }
@@ -868,17 +887,20 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName, Edm = undefine
         newAnno.setEdmAttribute('Term', termNameWithoutQualifiers);
         newAnno.setEdmAttribute('Qualifier', qualifier);
       }
-    // get the type of the term from the dictionary
+      // get the type of the term from the dictionary
       let termTypeName = null;
       const dictTerm = getDictTerm(termNameWithoutQualifiers, msg);
       if (dictTerm) {
         termTypeName = dictTerm.Type;
       }
       else {
-        message('odata-anno-def', msg.location,{ anno: termNameWithoutQualifiers });
+        // message if term is completely unknown or if vocabulary is unchecked
+        const vocDef = mergedVocDefs[whatsMyTermNamespace('@'+termNameWithoutQualifiers)];
+        if((vocDef?.int && vocDef?.int?.filename) || !vocDef)
+          message('odata-anno-def', msg.location,{ anno: termNameWithoutQualifiers });
       }
 
-    // handle the annotation value and put the result into the <Annotation ...> tag just created above
+      // handle the annotation value and put the result into the <Annotation ...> tag just created above
       handleValue(annoValue, newAnno, termNameWithoutQualifiers, termTypeName, msg);
     }
     return newAnno;
@@ -1240,7 +1262,7 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName, Edm = undefine
     if (dTypeName && !isComplexType(dTypeName)) {
       if (!getDictType(dTypeName) && !isPrimitiveType(dTypeName) && !isCollection(dTypeName))
         message('odata-anno-dict', msg.location,
-        { anno: msg.anno(), type: dTypeName, '#': 'std' });
+        { anno: msg.anno(), type: dTypeName });
       else
         message('odata-anno-value', msg.location,
         { anno: msg.anno(), str: 'structured', type: dTypeName, '#': 'struct' });
@@ -1280,7 +1302,7 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName, Edm = undefine
         // Dictionary Type, render in XML only for backward compatibility
         newRecord.setXml( { Type: actualTypeName });
         const vocName = actualTypeName.slice(0, actualTypeName.indexOf('.'));
-        const vocDef = vocabularyDefinitions[vocName];
+        const vocDef = mergedVocDefs[vocName];
         // Set full qualified type in JSON
         // TODO: Adhoc type x-ref URIs (only if abstract types are allowed in CDS)
         if(vocDef)
@@ -1552,7 +1574,7 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName, Edm = undefine
   }
 
   /**
-   * translate vocabulary definitions into an adhoc dictionary
+   * translate vocabulary definitions into a userDefinedTermDict
    * with the same structure as the global jsonDictionary that
    * contains all official term and type definitions.
    *
@@ -1561,7 +1583,7 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName, Edm = undefine
    *
    * @returns [object, Array<object>]
    */
-  function createAdhocDictionary() {
+  function createUserDefinedTermDictionary() {
     const allKnownVocabularies = [];
     const dict = { terms: {}, types: {}, xrefs: {} };
 
@@ -1572,7 +1594,7 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName, Edm = undefine
       let dictDef = oDataDictionary.terms[termName];
       if(dictDef) {
         message('odata-anno-dict', ['vocabularies', termName],
-        { anno: termName, '#': 'redefinition' } );
+        { anno: termName, string: 'annotation', '#': 'redefinition' } );
       }
       else if(!dictDef) {
         const annoDef = csnVocabularies[termName];
@@ -1799,8 +1821,64 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName, Edm = undefine
 
 }
 
+function mergeVocRefs(options, message) {
+  /*  Merge options.odataVocRefs into vocabularyDefinitions and
+      create a csn2edm stack local dictionary.
+      odataVocRefs is an object, each property is the
+      annotation prefix (as in mergedVocDefs), the value
+      is an object { Alias, Namespace, Uri }, this way
+      the definitions are unique and duplicate entries to address
+      the annotation via alias and namespace is possible (see
+      inverted index of mergedVocDefs above)
+  */
+  const mergedVocDefs = Object.assign({}, vocabularyDefinitions);
+  const reqProps = ['Alias', 'Namespace', 'Uri'];
+  if(options.odataVocRefs) {
+    const vocRefs = options.odataVocRefs;
+    if (typeof vocRefs === 'object' && !Array.isArray(vocRefs)) {
+      Object.entries(vocRefs).forEach(([id, def]) => {
+        let defOk = true;
+        reqProps.forEach(name => {
+          if(!def[name] || typeof def[name] !== 'string') {
+            message('odata-anno-vocref', null,
+              { id, name, '#': 'malformed' } );
+            defOk = false;
+          }
+          else if(name === 'Alias' && !edmUtils.isODataSimpleIdentifier(def[name])) {
+            message('odata-spec-violation-id', null, { id:name, value: def[name], '#': 'vocrefalias' });
+            defOk = false;
+          }
+        });
+        if(defOk) {
+          const vocDef = mergedVocDefs[id];
+          if(vocDef && !vocDef.$optVocRef) {
+            message('odata-anno-vocref', null,
+              { id, type: mergedVocDefs[id].inc.Namespace, '#': 'redef' } );
+          }
+          else {
+            if(id !== def.Alias) {
+              message('odata-anno-vocref', null,
+                { id, name: def.Alias } );
+            }
+            else {
+              // no int.filename => no validation
+              const vocDef = {
+                ref: { Uri: def.Uri },
+                inc: { Alias: def.Alias, Namespace: def.Namespace }
+              };
+              setProp(vocDef, '$optVocRef', true);
+              mergedVocDefs[id] = vocDef;
+            }
+          }
+        }
+      });
+    }
+  }
+  return mergedVocDefs;
+}
+
 //-------------------------------------------------------------------------------------------------
 //-------------------------------------------------------------------------------------------------
 //-------------------------------------------------------------------------------------------------
 
-module.exports = { knownVocabularies, vocabularyDefinitions, csn2annotationEdm };
+module.exports = { vocabularyDefinitions, csn2annotationEdm, mergeVocRefs };

package/lib/edm/csn2edm.js

@@ -51,6 +51,8 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
     whatsMyServiceRootName,
     fallBackSchemaName,
     options ] = initializeModel(csn, _options, messageFunctions, serviceNames);
+    
+  const mergedVocabularies = translate.mergeVocRefs(options, message);
 
   const Edm = getEdm(options, messageFunctions);
 
@@ -78,6 +80,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       services[serviceCsn.name] = createEdm(serviceCsn);
       return services; }, rc);
   }
+
   throwWithError();
   return rc;
 
@@ -423,6 +426,24 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         }
       });
 
+      /*
+        Remove EntityContainer if empty
+        V4 spec says:
+        Chapter 5 Element edm:Schema
+            It MAY contain elements [...], edm:EntityContainer, [...].
+        Chapter 13 Element edm:EntityContainer
+            The edm:EntityContainer MUST contain one or more edm:EntitySet, edm:Singleton, edm:ActionImport, or edm:FunctionImport elements.
+
+        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!
+      */
+      if(Schema._ec && Schema._ec._children.length === 0) {
+        Schema._children.splice(Schema._children.indexOf(Schema._ec), 1);
+      }
+
       Object.entries(NamesInSchemaXRef).forEach(([name, refs]) => {
         if(refs.length > 1) {
           error(null, ['definitions', `${Schema._edmAttributes.Namespace}.${name}`], { name: Schema._edmAttributes.Namespace },
@@ -1026,7 +1047,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
 
     // generate the Edm.Annotations tree and append it to the corresponding schema
     function addAnnotations(xServiceRefs) {
-      let { annos, usedVocabularies, xrefs } = translate.csn2annotationEdm(reqDefs, csn.vocabularies, serviceCsn.name, Edm, options, messageFunctions);
+      let { annos, usedVocabularies, xrefs } = translate.csn2annotationEdm(reqDefs, csn.vocabularies, serviceCsn.name, Edm, options, messageFunctions, mergedVocabularies);
       // distribute edm:Annotations into the schemas
       // Distribute each anno into Schema
       annos.forEach(anno => {

package/lib/edm/edmPreprocessor.js

@@ -820,8 +820,11 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
                (isContainerAssoc && !options.renderForeignKeys))
             edmUtils.assignAnnotation(element, '@cds.api.ignore', true);
           // Only in containment:
-          // If this element is a foreign key and if it is rendered, remove it from the key ref vector
-          else if(options.odataContainment && isContainerAssoc && options.renderForeignKeys) {
+          // If this element is a foreign key and if it is rendered, remove it from the key ref vector (if available)
+          else if(options.odataContainment &&
+                  isContainerAssoc &&
+                  options.renderForeignKeys &&
+                  struct.$keys) {
             delete struct.$keys[element.name];
           }
         }
@@ -830,8 +833,8 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
         if(options.odataContainment && element['@odata.containment.ignore']) {
           if(!options.renderForeignKeys)
             edmUtils.assignAnnotation(element, '@cds.api.ignore', true);
-          else
-            // If foreign keys shall be rendered, remove it from key ref vector
+          else if(struct.$keys)
+            // If foreign keys shall be rendered, remove it from key ref vector (if available)
             delete struct.$keys[element.name];
         }
       }
@@ -1560,7 +1563,10 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
         Object.entries(elements).forEach(([eltName, elt]) => {
           if(!elt.$visited) {
             setProp(elt, '$visited', true);
-            const newRefs = produceKeyRefPaths(elt, prefix + options.pathDelimiter + eltName, path);
+            let newRefs = [];
+            // if the foreign keys are explicitly requested, ignore associations and use the flat foreign key instead
+            if(!options.renderForeignKeys || (options.renderForeignKeys && !elt.target))
+              newRefs = produceKeyRefPaths(elt, prefix + options.pathDelimiter + eltName, path);
             if(newRefs.length) {
               keyPaths.push(...newRefs);
             // check path step key for spec violations
@@ -1855,33 +1861,47 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       if(typeDef?.enum) {
         const enumValue = [];
         for(const enumSymbol in typeDef.enum) {
-          let enumSymbolDef = typeDef.enum[enumSymbol];
           const result = { '@Core.SymbolicName': enumSymbol };
-          if(enumSymbolDef['#'])
+          let enumSymbolDef = typeDef.enum[enumSymbol];
+          while(enumSymbolDef && !enumSymbolDef.$visited && enumSymbolDef['#']) {
+            setProp(enumSymbolDef, '$visited', true);
             enumSymbolDef = typeDef.enum[enumSymbolDef['#']];
-          if(enumSymbolDef.val === undefined) {
-            if(typeDef.type === 'cds.String') {
-            // the symbol is used as value for type 'cds.String'
-              result.Value = enumSymbol;
+          }
+          // reset visited
+          for(const es in typeDef.enum)
+            delete typeDef.enum[es].$visited;
+            
+          if(enumSymbolDef) {
+            if(enumSymbolDef.val !== undefined) {
+              // 'null' value is represented spec conform as empty record in AllowedValues collection
+              result.Value = enumSymbolDef.val;
               enumValue.push(result);
             }
-            else if(node.kind !== 'annotation')
-              // omit the entry and warn
-              warning('odata-enum-missing-value', path,
+            else {
+              if(typeDef.type === 'cds.String') {
+              // the symbol is used as value for type 'cds.String'
+                result.Value = enumSymbol;
+                enumValue.push(result);
+              }
+              else if(node.kind !== 'annotation') {
+                // omit the entry and warn
+                warning('odata-enum-missing-value', path,
+                  { name: enumSymbol, anno: '@Valiation.AllowedValues', type: typeDef.type },
+                  'Expected enum element $(NAME) of type $(TYPE) to have a value, not added to $(ANNO)');
+              }
+            }
+          }
+          else { // enumSymbolDef not found
+            // omit the entry and warn
+            warning('odata-enum-missing-value', path,
               { name: enumSymbol, anno: '@Valiation.AllowedValues', type: typeDef.type },
               'Expected enum element $(NAME) of type $(TYPE) to have a value, not added to $(ANNO)');
           }
-          else {
-            // 'null' value is represented spec conform as empty record in AllowedValues collection
-          //if(enumSymbolDef.val !== null)
-            result.Value = enumSymbolDef.val;
-            enumValue.push(result);
-          }
 
           // Can't rely that @description has already been renamed to @Core.Description
           // Eval description according to precedence (doc comment must be considered already in Odata transformer
           // as in contrast to the other doc commments as it is used to annotate the @Validation.AllowedValues)
-          const desc = enumSymbolDef['@Core.Description'] || enumSymbolDef['@description'] || enumSymbolDef.doc;
+          const desc = enumSymbolDef ? enumSymbolDef['@Core.Description'] || enumSymbolDef['@description'] || enumSymbolDef.doc : undefined;
           if (desc)
             result['@Core.Description'] = desc;
         }

package/lib/gen/Dictionary.json

@@ -3540,6 +3540,10 @@
           "UserID": {
             "Value": "UserID",
             "Type": "String"
+          },
+          "EndOfPurposeDate": {
+            "Value": "EndOfPurposeDate",
+            "Type": "String"
           }
         },
         "Symbols": {}

package/lib/gen/language.checksum

@@ -1 +1 @@
-6c1cc14fd8155dcb48908afb59568b42
+7b8ead4c652cf564b5ba45f94d2c45af