@sap/cds-compiler 3.4.2 → 3.5.0

package/lib/edm/edm.js

@@ -2,7 +2,7 @@
 
 const edmUtils = require('./edmUtils.js');
 const { isBuiltinType } = require('../model/csnUtils.js');
-const { forEach } = require("../utils/objectUtils");
+const { forEach } = require('../utils/objectUtils');
 const { isBetaEnabled } = require('../base/model.js');
 
 // facet definitions, optional could either be true or array of edm types
@@ -722,8 +722,8 @@ function getEdm(options, messageFunctions) {
         }
       }
 
-      // Set the collection property if this is either an element or a parameter
-      this._isCollection = (csn.kind === undefined) ? csn._isCollection : false;
+      // Set the collection property if this is either an element, parameter or a term def
+      this._isCollection = (csn.kind === undefined || csn.kind === 'annotation') ? csn._isCollection : false;
 
       if(options.whatsMySchemaName && this._edmAttributes[typeName]) {
         let schemaName = options.whatsMySchemaName(this._edmAttributes[typeName]);
@@ -834,6 +834,18 @@ function getEdm(options, messageFunctions) {
     }
   }
 
+  class Term extends TypeBase
+    {
+    constructor(v, attributes, csn)
+      {
+      super(v, attributes, csn);
+      const appliesTo = csn['@odata.term.AppliesTo'];
+      if(appliesTo) {
+        this.setEdmAttribute('AppliesTo', Array.isArray(appliesTo) ? appliesTo.map(v=>v['=']||v).join(' ') : appliesTo['='] || appliesTo);
+      }
+    }
+    }
+
   class TypeDefinition extends TypeBase
   {
     constructor(v, attributes, csn)
@@ -1639,6 +1651,8 @@ function getEdm(options, messageFunctions) {
     EntityContainer,
     EntitySet,
     Singleton,
+    TypeBase,
+    Term,
     TypeDefinition,
     EnumType,
     ComplexType,

package/lib/edm/edmAnnoPreprocessor.js

@@ -108,8 +108,8 @@ function applyAppSpecificLateCsnTransformationOnElement(options, element, struct
       let CommonAttributes = element[prop];
       if(!Array.isArray(CommonAttributes)) {
         error(null, ['definitions', struct.name, 'elements', element.name],
-          { anno: '@Common.attribute', code: JSON.stringify(CommonAttributes) },
-          `Expect array value for $(ANNOTATION): $(CODE)`);
+          { anno: '@Common.Attributes', code: JSON.stringify(CommonAttributes) },
+          'Expecting array value for $(ANNO): $(CODE)');
         return;
       }
 
@@ -125,7 +125,7 @@ function applyAppSpecificLateCsnTransformationOnElement(options, element, struct
       if(!Array.isArray(ContextDefiningProperties)) {
         error(null, ['definitions', struct.name, 'elements', element.name],
           { anno: '@Aggregation.ContextDefiningProperties', code: JSON.stringify(ContextDefiningProperties) },
-          `Expect array value for $(ANNOTATION): $(CODE)`);
+          'Expecting array value for $(ANNO): $(CODE)');
         return;
       }
       if(ContextDefiningProperties.length > 0)
@@ -198,7 +198,7 @@ function applyAppSpecificLateCsnTransformationOnStructure(options, struct, error
         error(null, ['definitions', struct.name ],
           { anno: '@Capabilities.FilterRestrictions.FilterExpressionRestrictions',
             code: JSON.stringify(filterRestrictions) },
-          `Expect array value for $(ANNOTATION): $(CODE)`);
+          'Expected array value for $(ANNO): $(CODE)');
         return;
       }
       filterRestrictions.forEach(v => {
@@ -215,7 +215,7 @@ function applyAppSpecificLateCsnTransformationOnStructure(options, struct, error
         error(null, ['definitions', struct.name],
           { anno: '@Capabilities.FilterRestrictions.RequiredProperties',
             code: JSON.stringify(requiredProperties) },
-          `Expect array value for $(ANNOTATION): $(CODE)`);
+          'Expecting array value for $(ANNO): $(CODE)');
         return;
       }
 
@@ -346,4 +346,4 @@ module.exports = {
   setSAPSpecificV2AnnotationsToEntityContainer,
   setSAPSpecificV2AnnotationsToEntitySet,
   setSAPSpecificV2AnnotationsToAssociation
-};
+};

package/lib/edm/edmInboundChecks.js

@@ -24,11 +24,11 @@ function resolveForeignKeyRefs(csn) {
 function inboundQualificationChecks(csn, options, messageFunctions, 
   serviceRootNames, requestedServiceNames, isMyServiceRequested, whatsMyServiceRootName) {
   const csnUtils = getUtils(csn);
-  const { message, throwWithAnyError } = messageFunctions;
+  const { message, throwWithError } = messageFunctions;
 
   forEachDefinition(csn, [ attach$path, checkChainedArray ]);
   checkNestedContextsAndServices();
-  throwWithAnyError();
+  throwWithError();
 
     // attach $path to all
   function attach$path(def, defName) {

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 [
@@ -264,7 +268,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
           const art = csn.definitions[newDefName];
           if(art !== undefined) {
             error(null, [ 'definitions', defName ], { name: newDefName },
-            `Artifact name containing dots can't be mapped to an OData compliant name because it conflicts with existing definition $(NAME)`);
+            'Artifact name containing dots can\'t be mapped to an OData compliant name because it conflicts with existing definition $(NAME)');
           }
           else {
             csn.definitions[newDefName] = def;
@@ -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)
@@ -205,7 +205,7 @@ function resolveOnConditionAndPrepareConstraints(csn, assocCsn, messageFunctions
     function fillConstraints(arg, pos)
     {
       if(arg.xpr)
-        arg.xpr.map(fillConstraints);
+        getExpressionArguments(arg.xpr);
       else if(pos > 0 && pos < expr.length)
       {
         let lhs = expr[pos-1];
@@ -485,7 +485,7 @@ function mapCdsToEdmType(csn, messageFunctions, isV2=false, isMediaType=false, l
   const { error } = messageFunctions || { error: ()=>true };
   let cdsType = csn.type;
   if(cdsType === undefined) {
-    error(null, location, `no type found`);
+    error(null, location, 'no type found');
     return '<NOTYPE>';
   }
   if(!isBuiltinType(cdsType))
@@ -544,7 +544,7 @@ function mapCdsToEdmType(csn, messageFunctions, isV2=false, isMediaType=false, l
     */
   }[cdsType];
   if (edmType == undefined) {
-    error(null, location, { type: cdsType }, `No EDM type available for $(TYPE)`);
+    error(null, location, { type: cdsType }, 'No EDM type available for $(TYPE)');
   }
   if(isV2)
   {
@@ -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,