@sap/cds-compiler 3.4.4 → 3.5.2

package/lib/edm/edmPreprocessor.js

@@ -18,7 +18,7 @@ const NavResAnno = '@Capabilities.NavigationRestrictions.RestrictedProperties';
 const capabilities = Object.keys(require('../gen/Dictionary.json').
   types['Capabilities.NavigationPropertyRestriction'].Properties).
   filter(c => !['NavigationProperty', 'Navigability'].includes(c)).
-  map(c => `@Capabilities.`+c);
+  map(c => '@Capabilities.'+c);
 
 /**
  *  edmPreprocessor warms up the model so that it can be converted into an EDM document and
@@ -128,6 +128,10 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       },
       linkAssociationTarget
     ]);
+    forEachGeneric(csn, 'vocabularies', (term, termName) => {
+      const mySchemaName = whatsMySchemaName(termName);
+      mySchemaName && setProp(term, '$mySchemaName', mySchemaName);
+    });
     // initialize requested services
     const skip = { skipArtifact: (_def, defName) => !isMyServiceRequested(defName) };
     forEachDefinition({ definitions: serviceRoots }, initService, skip);
@@ -161,7 +165,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     if(options.isV4())
       forEachDefinition(reqDefs, [
         initEdmNavPropBindingTargets,
-        rewriteContainmentAnnotations,
+        pullupCapabilitiesAnnotations,
         annotateOptionalActFuncParams
       ]);
 
@@ -172,7 +176,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     forEachDefinition(reqDefs, [
       initEdmKeyRefPaths,
       initEdmNavPropBindingPaths,
-      initEdmTypesAndDescription
+      finalize
     ]);
   }
   return [
@@ -275,36 +279,42 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       }
     });
     // rename type refs to new type names
-    forEachDefinition(csn, def => {
-      forEachMemberRecursively(def, member => {
-        member = member.items || member;
-        if(member.type && dotTypeNameMap[member.type]) {
-          member.type = dotTypeNameMap[member.type];
+    const rewrite = (def) => {
+      const applyOnNode = (node) => {
+        node = node.items || node;
+        if(node.type && dotTypeNameMap[node.type]) {
+          node.type = dotTypeNameMap[node.type];
         }
-        if(member.target && dotEntityNameMap[member.target]) {
-          member.target = dotEntityNameMap[member.target];
+        if(node.target && dotEntityNameMap[node.target]) {
+          node.target = dotEntityNameMap[node.target];
         }
-        if(member.$path && dotEntityNameMap[member.$path[1]]) {
-          member.$path[1] = dotEntityNameMap[member.$path[1]]
+        if(node.$path && dotEntityNameMap[node.$path[1]]) {
+          node.$path[1] = dotEntityNameMap[node.$path[1]]
         }
-        _rewriteReferencesInActions(member);
-      });
-      // handle unbound action/function and params in views
-      _rewriteReferencesInActions(def);
-    });
+        rewriteReferencesInActions(node);
+      }
 
-    function _rewriteReferencesInActions(act) {
-      act.params && Object.values(act.params).forEach(param => {
-        param = param.items || param;
-        if(param.type && (dotEntityNameMap[param.type] || dotTypeNameMap[param.type]))
-          param.type = dotEntityNameMap[param.type] || dotTypeNameMap[param.type];
-      });
-      if(act.returns){
-        const returnsObj = act.returns.items || act.returns;
-        if (returnsObj.type && dotEntityNameMap[returnsObj.type] || dotTypeNameMap[returnsObj.type])
-          returnsObj.type = dotEntityNameMap[returnsObj.type] || dotTypeNameMap[returnsObj.type];
+      const rewriteReferencesInActions = (act) => {
+        act.params && Object.values(act.params).forEach(param => {
+          param = param.items || param;
+          if(param.type && (dotEntityNameMap[param.type] || dotTypeNameMap[param.type]))
+            param.type = dotEntityNameMap[param.type] || dotTypeNameMap[param.type];
+        });
+        if(act.returns){
+          const returnsObj = act.returns.items || act.returns;
+          if (returnsObj.type && dotEntityNameMap[returnsObj.type] || dotTypeNameMap[returnsObj.type])
+            returnsObj.type = dotEntityNameMap[returnsObj.type] || dotTypeNameMap[returnsObj.type];
+        }
       }
-    }
+
+      forEachMemberRecursively(def, applyOnNode);
+      applyOnNode(def);
+      // handle unbound action/function and params in views
+      rewriteReferencesInActions(def);
+    };
+
+    forEachDefinition(csn, rewrite);
+    forEachGeneric(csn, 'vocabularies', rewrite);
   }
 
   /*
@@ -366,7 +376,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
           }
         }
         else {
-          error(null, subpath, { target: element.target }, "Target $(TARGET) can't be found in the model");
+          error(null, subpath, { target: element.target }, 'Target $(TARGET) can\'t be found in the model');
         }
       }
       // in V4 tag all compositions to be containments
@@ -892,14 +902,14 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
             if(serviceRootNames.includes(targetSchemaName)) {
             // remove all definitions starting with < fqSchemaName >. and add a schema reference
               Object.keys(csn.definitions).forEach(dn => {
-                if(dn.startsWith(fqSchemaName)) {// this includes the fqSchemaName context
+                if(dn.startsWith(fqSchemaName)) {
                   delete csn.definitions[dn];
                   delete reqDefs.definitions[dn];
                 }
               });
               if(!schemas[fqSchemaName])
                 schemaNames.push(fqSchemaName);
-              schemas[fqSchemaName] = createSchemaRef(targetSchemaName);
+              schemas[fqSchemaName] = edmUtils.createSchemaRef(serviceRoots, targetSchemaName);
             }
           }
         });
@@ -1036,7 +1046,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     function createSchemaRefFor(targetSchemaName) {
       let ref = csn.definitions[globalSchemaPrefix + '.' + targetSchemaName];
       if(!ref) {
-        ref = createSchemaRef(targetSchemaName);
+        ref = edmUtils.createSchemaRef(serviceRoots, targetSchemaName);
       }
 
       return ref;
@@ -1794,27 +1804,33 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     }
   }
 
-  function initEdmTypesAndDescription(def) {
+  function finalize(def, defName) {
     // 1. let all doc props become @Core.Descriptions
     // 2. mark a member that will become a collection
     // 3. assign the edm primitive type to elements, to be used in the rendering later
+    // 4. assign @Validation.AllowedValues to enums
+    const path = ['definitions', defName];
     edmUtils.assignAnnotation(def, '@Core.Description', def.doc);
     markCollection(def);
     mapCdsToEdmProp(def);
+    annotateAllowedValues(def, path);
     if (def.returns)  {
       markCollection(def.returns);
       mapCdsToEdmProp(def.returns);
+      annotateAllowedValues(def.returns, [...path, 'returns']);
     }
-    forEachMemberRecursively(def,member => {
+    forEachMemberRecursively(def, (member, _memberName, _prop, path) => {
       edmUtils.assignAnnotation(member, '@Core.Description', member.doc);
       markCollection(member);
       mapCdsToEdmProp(member);
+      annotateAllowedValues(member, path);
       ComputedDefaultValue(member);
       if (member.returns) {
         markCollection(member.returns);
         mapCdsToEdmProp(member.returns);
+        annotateAllowedValues(member.returns, [...path, 'returns']);
       }
-    });
+    }, path);
     // mark members that need to be rendered as collections
     function markCollection(obj) {
       const items = obj.items || csn.definitions[obj.type] && csn.definitions[obj.type].items;
@@ -1823,6 +1839,56 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
         edmUtils.assignProp(obj, '_isCollection', true);
       }
     }
+
+    /*
+    Add @Validation.AllowedValues annotation for all enum types
+    A 'Value' is added if the enum symbol:
+    - has a valid value other than 'null'
+    - has no value but the base type is cds.String, use the
+      symbol as value
+    */
+    function annotateAllowedValues(node, path) {
+      let typeDef = node;
+      if(!node.enum && node.type && !isBuiltinType(node.type))
+        typeDef = csn.definitions[node.type];
+      if(typeDef?.enum) {
+        const enumValue = [];
+        for(const enumSymbol in typeDef.enum) {
+          let enumSymbolDef = typeDef.enum[enumSymbol];
+          const result = { '@Core.SymbolicName': enumSymbol };
+          if(enumSymbolDef['#'])
+            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;
+              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 {
+            // '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;
+          if (desc)
+            result['@Core.Description'] = desc;
+        }
+        if(enumValue.length > 0)
+          edmUtils.assignAnnotation(node, '@Validation.AllowedValues', enumValue);
+      }
+    }
+
   }
 
   // If containment in V4 is active, annotations that would be assigned to the containees
@@ -1830,8 +1896,10 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
   // the containment navigation property.
   // Today only Capabilities.*Restrictions are known to be remapped as there exists a CDS
   // short cut annotation @readonly that gets expanded and can be safely remapped.
-  function rewriteContainmentAnnotations(rootContainer) {
+  function pullupCapabilitiesAnnotations(rootContainer) {
 
+    if(!options.odataCapabilitiesPullup)
+      return;
     // meaningless for non-entities and proxies
     if(rootContainer.kind !== 'entity' || rootContainer.$proxy)
       return;
@@ -1867,7 +1935,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
                npe.NavigationProperty['='] &&
                typeof npe.NavigationProperty['='] === 'string') {
               applyTransformations({ definitions: { npe }}, {
-                "=": (parent, prop, value) => {
+                '=': (parent, prop, value) => {
                   parent[prop] = prefix.concat(value).join('.');
                 }
               });
@@ -1975,45 +2043,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
   // Helper section starts here
   //
 
-  //
-  // create Cross Schema Reference object
-  //
-  function createSchemaRef(targetSchemaName) {
-    // prepend as many path ups '..' as there are path steps in the service ref
-    let serviceRef = path4(serviceRoots[targetSchemaName]).split('/').filter(c=>c.length);
-    serviceRef.splice(0, 0, ...Array(serviceRef.length).fill('..'));
-    // uncomment this to make $metadata absolute
-    // if(serviceRef.length===0)
-    //   serviceRef.push('');
-    if(serviceRef[serviceRef.length-1] !== '$metadata')
-      serviceRef.push('$metadata');
-    let sc = { kind: 'reference',
-      name: targetSchemaName,
-      ref: { Uri: serviceRef.join('/') },
-      inc: { Namespace: targetSchemaName }
-    };
-    setProp(sc, '$mySchemaName', targetSchemaName);
-    return sc;
-
-    /**
-     * Resolve a service endpoint path to mount it to as follows...
-     * Use _path or def[@path] if given (and remove leading '/')
-     * Otherwise, use the service definition name with stripped 'Service'
-     */
-    function path4 (def, _path = def['@path']) {
-      if (_path)
-        return _path.replace(/^\//, "");
-      else
-        return ( // generate one from the service's name
-          /[^.]+$/.exec(def.name)[0]  //> my.very.CatalogService --> CatalogService
-          .replace(/Service$/,'')     //> CatalogService --> Catalog
-          .replace(/([a-z0-9])([A-Z])/g, (_,c,C) => c+'-'+C.toLowerCase())  //> ODataFooBarX9 --> odata-foo-bar-x9
-          .replace(/_/g,'-')  //> foo_bar_baz --> foo-bar-baz
-          .toLowerCase()      //> FOO --> foo
-        )
-    }
-  }
-
+  
   function mapCdsToEdmProp(obj) {
     if (obj.type && isBuiltinType(obj.type) && !obj.target && !obj.targetAspect) {
       let edmType = edmUtils.mapCdsToEdmType(obj, messageFunctions, _options.odataVersion === 'v2', obj['@Core.MediaType']);

package/lib/edm/edmUtils.js

@@ -1,7 +1,7 @@
 'use strict';
 const { setProp } = require('../base/model');
 const { isBuiltinType, isEdmPropertyRendered, applyTransformations, cloneAnnotationValue } = require('../model/csnUtils');
-const { escapeString, hasControlCharacters, hasUnpairedUnicodeSurrogate } = require("../render/utils/stringEscapes");
+const { escapeString, hasControlCharacters, hasUnpairedUnicodeSurrogate } = require('../render/utils/stringEscapes');
 
 /* eslint max-statements-per-line:off */
 function validateOptions(_options)
@@ -769,7 +769,7 @@ function mergeIntoNavPropEntry(annoPrefix, navPropEntry, prefix, props) {
 
   // BEFORE merging found capabilities, prefix the paths
   applyTransformations({ definitions: { o }}, {
-    "=": (parent, prop, value) => {
+    '=': (parent, prop, value) => {
       parent[prop] = prefix.concat(value).join('.');
     }
   });
@@ -830,11 +830,50 @@ function assignProp(obj, prop, value) {
   }
 }
 
+//
+  // create Cross Schema Reference object
+  //
+function createSchemaRef(serviceRoots, targetSchemaName) {
+    // prepend as many path ups '..' as there are path steps in the service ref
+  let serviceRef = path4(serviceRoots[targetSchemaName]).split('/').filter(c=>c.length);
+  serviceRef.splice(0, 0, ...Array(serviceRef.length).fill('..'));
+    // uncomment this to make $metadata absolute
+    // if(serviceRef.length===0)
+    //   serviceRef.push('');
+  if(serviceRef[serviceRef.length-1] !== '$metadata')
+    serviceRef.push('$metadata');
+  let sc = { kind: 'reference',
+    name: targetSchemaName,
+    ref: { Uri: serviceRef.join('/') },
+    inc: { Namespace: targetSchemaName }
+  };
+  setProp(sc, '$mySchemaName', targetSchemaName);
+  return sc;
+
+    /**
+     * Resolve a service endpoint path to mount it to as follows...
+     * Use _path or def[@path] if given (and remove leading '/')
+     * Otherwise, use the service definition name with stripped 'Service'
+     */
+  function path4 (def, _path = def['@path']) {
+    if (_path)
+      return _path.replace(/^\//, '');
+    else
+        return ( // generate one from the service's name
+          /[^.]+$/.exec(def.name)[0]  //> my.very.CatalogService --> CatalogService
+          .replace(/Service$/,'')     //> CatalogService --> Catalog
+          .replace(/([a-z0-9])([A-Z])/g, (_,c,C) => c+'-'+C.toLowerCase())  //> ODataFooBarX9 --> odata-foo-bar-x9
+          .replace(/_/g,'-')  //> foo_bar_baz --> foo-bar-baz
+          .toLowerCase()      //> FOO --> foo
+        )
+  }
+}
 
 
 module.exports = {
   assignAnnotation,
   assignProp,
+  createSchemaRef,
   validateOptions,
   intersect,
   foreach,

package/lib/gen/Dictionary.json

@@ -1499,6 +1499,23 @@
       ],
       "$experimental": true
     },
+    "Offline.ClientOnly": {
+      "Type": "Core.Tag",
+      "AppliesTo": [
+        "EntityType",
+        "EntitySet",
+        "EnumType",
+        "ComplexType",
+        "TypeDefinition"
+      ],
+      "$experimental": true
+    },
+    "PDF.Features": {
+      "Type": "PDF.FeaturesType",
+      "AppliesTo": [
+        "EntityContainer"
+      ]
+    },
     "PersonalData.EntitySemantics": {
       "Type": "PersonalData.EntitySemanticsType",
       "AppliesTo": [
@@ -3357,6 +3374,23 @@
         "Symbols": {}
       }
     },
+    "PDF.FeaturesType": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "DocumentDescriptionReference": "Edm.String",
+        "DocumentDescriptionCollection": "Edm.String",
+        "ArchiveFormat": "Edm.Boolean",
+        "Signature": "Edm.Boolean",
+        "CoverPage": "Edm.Boolean",
+        "FontName": "Edm.Boolean",
+        "FontSize": "Edm.Boolean",
+        "Margin": "Edm.Boolean",
+        "Border": "Edm.Boolean",
+        "FitToPage": "Edm.Boolean",
+        "ResultSizeDefault": "Edm.Int32",
+        "ResultSizeMaximum": "Edm.Int32"
+      }
+    },
     "PersonalData.EntitySemanticsType": {
       "$kind": "TypeDefinition",
       "UnderlyingType": "Edm.String",

package/lib/gen/language.checksum

@@ -1 +1 @@
-1afc5561b6e2c0af3e294a6781ba278c
+bdbb2e738b68d13dc2f0f03c0caf5fc0