@sap/cds-compiler 2.15.8 → 3.1.0

package/lib/edm/csn2edm.js

@@ -7,7 +7,7 @@ const NAVPROP_TRENNER = '_';
 const VALUELIST_NAVPROP_PREFIX = '';
 
 const edmUtils = require('./edmUtils.js')
-const { initializeModel, assignAnnotation } = require('./edmPreprocessor.js');
+const { initializeModel } = require('./edmPreprocessor.js');
 const translate = require('./annotations/genericTranslation.js');
 const { setProp } = require('../base/model');
 const { cloneCsnNonDict, isEdmPropertyRendered, isBuiltinType } = require('../model/csnUtils');
@@ -326,15 +326,16 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
 
       /* create the entitytypes and sets
         Do not create an entity set if:
-            V4 containment: _containerEntity is set and not equal with the artifact name
+            V4 containment: $containerNames is set and not equal with the artifact name
             Entity starts with 'localserviceNameized.' or ends with '_localized'
       */
       edmUtils.foreach(schemaCsn.definitions,
-        a => edmUtils.isEntity(a) && !a.abstract && a.name.startsWith(schemaNamePrefix),
+        a => a.kind === 'entity' && !a.abstract && a.name.startsWith(schemaNamePrefix),
         createEntityTypeAndSet
       );
       // create unbound actions/functions
-      edmUtils.foreach(schemaCsn.definitions, a => edmUtils.isActionOrFunction(a) && a.name.startsWith(schemaNamePrefix),
+      edmUtils.foreach(schemaCsn.definitions, 
+        a => (a.kind === 'action' || a.kind === 'function') && a.name.startsWith(schemaNamePrefix),
         (options.isV4()) ? createActionV4 : createActionV2);
 
     // create the complex types
@@ -346,7 +347,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       {
         edmUtils.foreach(schemaCsn.definitions,
         artifact => edmUtils.isDerivedType(artifact) &&
-        !edmUtils.isAssociationOrComposition(artifact) &&
+        !artifact.target &&
         artifact.name.startsWith(schemaNamePrefix),
           createTypeDefinition);
       }
@@ -395,14 +396,14 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       {
         const EntityTypeName = entityCsn.name.replace(schemaNamePrefix, '');
         const EntitySetName = edmUtils.getBaseName(entityCsn.$entitySetName || entityCsn.name);
-
+        const isSingleton = edmUtils.isSingleton(entityCsn) && options.isV4();
         const [ properties, hasStream ] = createProperties(entityCsn);
 
         const loc = ['definitions', entityCsn.name];
         const type = `${schema.name}.${EntityTypeName}`;
         if(properties.length === 0)
           warning(null, loc, { type }, 'EDM EntityType $(TYPE) has no properties');
-        else if(entityCsn.$edmKeyPaths.length === 0)
+        else if(entityCsn.$edmKeyPaths.length === 0 && !isSingleton)
           message('odata-spec-violation-no-key', loc);
 
         if(!edmUtils.isODataSimpleIdentifier(EntityTypeName))
@@ -414,7 +415,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
           if(p._edmAttributes.Name === EntityTypeName)
             warning('odata-spec-violation-property-name', pLoc, { kind: entityCsn.kind });
 
-          if(options.isV2() && p._isCollection && !edmUtils.isAssociationOrComposition(p._csn))
+          if(options.isV2() && p._isCollection && !p._csn.target)
             warning('odata-spec-violation-array', pLoc, { version: '2.0' });
 
           if(!edmUtils.isODataSimpleIdentifier(p._edmAttributes.Name))
@@ -432,7 +433,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         // CDXCORE-CDXCORE-173
         if(options.isV2() && hasStream) {
           attributes['m:HasStream'] = true;
-          assignAnnotation(entityCsn, '@Core.MediaType', hasStream);
+          edmUtils.assignAnnotation(entityCsn, '@Core.MediaType', hasStream);
         }
 
         Schema.append(new Edm.EntityType(v, attributes, properties, entityCsn));
@@ -461,7 +462,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         }
 
         // put actions behind entity types in Schema/EntityContainer
-        edmUtils.forAll(entityCsn.actions, (a, n) => {
+        entityCsn.actions && Object.entries(entityCsn.actions).forEach(([ n, a ]) => {
           (options.isV4()) ? createActionV4(a, n, entityCsn)
                           : createActionV2(a, n, entityCsn)
         });
@@ -522,7 +523,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         }
 
         // Parameter Nodes
-        edmUtils.forAll(actionCsn.params, (parameterCsn, parameterName) => {
+        actionCsn.params && Object.entries(actionCsn.params).forEach(([parameterName, parameterCsn]) => {
           const p = new Edm.Parameter(v, { Name: parameterName }, parameterCsn );
           const pLoc = [ ...loc, 'params', p._edmAttributes.Name ];
           if(!edmUtils.isODataSimpleIdentifier(parameterName))
@@ -573,7 +574,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         if(rt) // add EntitySet attribute only if return type is an entity
         {
           const defintion = schemaCsn.definitions[rt];
-          if(defintion && edmUtils.isEntity(defintion))
+          if(defintion && defintion.kind === 'entity')
           {
             functionImport.setEdmAttribute('EntitySet', rt.replace(schemaNamePrefix, ''));
           }
@@ -597,7 +598,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
           // Binding Parameter: Primary Keys at first position in sequence, this is decisive!
           // V2 XML: Nullable=false is set because we reuse the primary key property for the parameter
           edmUtils.foreach(entityCsn.elements,
-            elementCsn => elementCsn.key && !edmUtils.isAssociationOrComposition(elementCsn),
+            elementCsn => elementCsn.key && !elementCsn.target,
             (elementCsn, elementName) => {
               functionImport.append(new Edm.Parameter(v, { Name: elementName }, elementCsn, 'In' ));
             }
@@ -605,7 +606,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         }
 
         // is this still required?
-        edmUtils.forAll(actionCsn, (v, p) => {
+        Object.entries(actionCsn).forEach(([p, v]) => {
           if (p.match(/^@sap\./))
             functionImport.setXml( { ['sap:' + p.slice(5).replace(/\./g, '-')] : v });
         });
@@ -613,7 +614,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         // V2 XML: Parameters that are not explicitly marked as Nullable or NotNullable in the CSN must become Nullable=true
         // V2 XML spec does only mention default Nullable=true for Properties not for Parameters so omitting Nullable=true let
         // the client assume that Nullable is false.... Correct Nullable Handling is done inside Parameter constructor
-        edmUtils.forAll(actionCsn.params, (parameterCsn, parameterName) => {
+        actionCsn.params && Object.entries(actionCsn.params).forEach(([parameterName, parameterCsn]) => {
           const pLoc = [...loc, 'params', parameterName];
           const param = new Edm.Parameter(v, { Name: parameterName }, parameterCsn, 'In' );
           edmTypeCompatibilityCheck(param, pLoc);
@@ -683,14 +684,12 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         let hasStream = false;
         const streamProps = [];
 
-        edmUtils.forAll(elementsCsn.elements, (elementCsn, elementName) =>
+        elementsCsn.elements && Object.entries(elementsCsn.elements).forEach(([elementName, elementCsn]) =>
         {
           if(elementCsn._edmParentCsn == undefined)
             setProp(elementCsn, '_edmParentCsn', edmParentCsn);
 
-          if(!elementCsn._ignore) {
-            if(edmUtils.isAssociationOrComposition(elementCsn))
-            {
+          if(elementCsn.target) {
               // Foreign keys are part of the generic elementCsn.elements property creation
 
               // This is the V4 edmx:NavigationProperty
@@ -698,36 +697,35 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
 
               // suppress navprop creation only if @odata.navigable:false is not annotated.
               // (undefined !== false) still evaluates to true
-              if (!elementCsn._target.abstract && elementCsn['@odata.navigable'] !== false)
+            if (!elementCsn._target.abstract && elementCsn['@odata.navigable'] !== false)
               {
-                const navProp = new Edm.NavigationProperty(v, {
-                  Name: elementName,
-                  Type: elementCsn._target.name
-                }, elementCsn);
-                props.push(navProp);
+              const navProp = new Edm.NavigationProperty(v, {
+                Name: elementName,
+                Type: elementCsn._target.name
+              }, elementCsn);
+              props.push(navProp);
                 // save the navProp in the global array for late constraint building
-                navigationProperties.push(navProp);
-              }
+              navigationProperties.push(navProp);
             }
+          }
             // render ordinary property if element is NOT ...
             // 1) ... annotated @cds.api.ignore
             // 2) ... annotated @odata.foreignKey4 and odataFormat: structured
 
-            else if(isEdmPropertyRendered(elementCsn, options))
+          else if(isEdmPropertyRendered(elementCsn, options))
             {
               // CDXCORE-CDXCORE-173
               // V2: filter  @Core.MediaType
-              if ( options.isV2() && elementCsn['@Core.MediaType']) {
-                hasStream = elementCsn['@Core.MediaType'];
-                delete elementCsn['@Core.MediaType'];
+            if ( options.isV2() && elementCsn['@Core.MediaType']) {
+              hasStream = elementCsn['@Core.MediaType'];
+              delete elementCsn['@Core.MediaType'];
                 // CDXCORE-CDXCORE-177:
                 // V2: don't render element but add attribute 'm:HasStream="true' to EntityType
                 // V4: render property type 'Edm.Stream'
-                streamProps.push(elementName);
+              streamProps.push(elementName);
 
-              } else {
-                props.push(new Edm.Property(v, { Name: elementName }, elementCsn));
-              }
+            } else {
+              props.push(new Edm.Property(v, { Name: elementName }, elementCsn));
             }
           }
 
@@ -772,10 +770,10 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
             message('odata-spec-violation-id', pLoc, { id: p._edmAttributes.Name });
 
           if(options.isV2()) {
-            if(p._isCollection && !edmUtils.isAssociationOrComposition(p._csn))
+            if(p._isCollection && !p._csn.target)
               warning('odata-spec-violation-array', pLoc, { version: '2.0' });
 
-            if(edmUtils.isAssociationOrComposition(p._csn))
+            if(p._csn.target)
               warning('odata-spec-violation-assoc', pLoc, { version: '2.0' });
           }
         });

package/lib/edm/edm.js

@@ -3,6 +3,7 @@
 const edmUtils = require('./edmUtils.js');
 const { isBuiltinType } = require('../model/csnUtils.js');
 const { forEach } = require("../utils/objectUtils");
+const { isBetaEnabled } = require('../base/model.js');
 
 // facet definitions, optional could either be true or array of edm types
 // remove indicates wether or not the canonic facet shall be removed when applying @odata.Type
@@ -239,7 +240,7 @@ function getEdm(options, messageFunctions) {
       if(csn)
       {
         const attr = (useSetAttributes ? csn._SetAttributes : csn);
-        edmUtils.forAll(attr, (v, p) => {
+        attr && Object.entries(attr).forEach(([p, v]) => {
           if (p.match(/^@sap./))
             this.setXml( { ['sap:' + p.slice(5).replace(/\./g, '-')] : v } );
         });
@@ -332,7 +333,7 @@ function getEdm(options, messageFunctions) {
       if(what==='metadata' || what==='all')
       {
         xml += super.innerXML(indent);
-        edmUtils.forAll(this._actions, actionArray => {
+        this._actions && Object.values(this._actions).forEach(actionArray => {
           actionArray.forEach(action => {
             xml += action.toXML(indent, what) + '\n'; });
         });
@@ -350,7 +351,7 @@ function getEdm(options, messageFunctions) {
     // no $Namespace
     toJSONattributes(json)
     {
-      edmUtils.forAll(this._edmAttributes, (v,p) => {
+      this._edmAttributes && Object.entries(this._edmAttributes).forEach(([p, v]) => {
         if (p !== 'Name' && p !== 'Namespace')
           json[p[0] === '@' ? p : '$' + p] = v;
       });
@@ -371,7 +372,7 @@ function getEdm(options, messageFunctions) {
         if(Object.keys(json_Annotations).length)
           json['$Annotations'] = json_Annotations;
       }
-      edmUtils.forAll(this._actions, (actionArray, actionName) => {
+      this._actions && Object.entries(this._actions).forEach(([actionName, actionArray]) => {
         json[actionName] = [];
         actionArray.forEach(action => {
           json[actionName].push(action.toJSON());
@@ -737,7 +738,7 @@ function getEdm(options, messageFunctions) {
       if(this._type !== 'Edm.String' && this._type)   // Edm.String is default)
         json['$'+this._typeName] = this._type;
 
-      edmUtils.forAll(this._edmAttributes, (v,p) => {
+      this._edmAttributes && Object.entries(this._edmAttributes).forEach(([p, v]) => {
         if (p !== 'Name' && p !== this._typeName
           // remove this line if Nullable=true becomes default
           && !(p === 'Nullable' && v == false))
@@ -754,7 +755,14 @@ function getEdm(options, messageFunctions) {
     }
   }
 
-  class ComplexType extends TypeBase { }
+  class ComplexType extends TypeBase { 
+    constructor(v, details, csn) {
+      super(v, details, csn);
+      if(this.v4 && !!csn['@open'] && isBetaEnabled(options, 'odataOpenType')) {
+        this._edmAttributes['OpenType'] = true;
+      }
+    }
+  }
   class EntityType extends ComplexType
   {
     constructor(v, details, properties, csn)
@@ -840,8 +848,8 @@ function getEdm(options, messageFunctions) {
       super(v, attributes, csn);
 
       // array of enum not yet allowed
-      let enumValues = /*(csn.items && csn.items.enum) ||*/ csn.enum;
-      edmUtils.forAll(enumValues, (e, en) =>  {
+      const enumValues = /*(csn.items && csn.items.enum) ||*/ csn.enum;
+      enumValues && Object.entries(enumValues).forEach(([en, e]) =>  {
         this.append(new Member(v, { Name: en, Value: e.val } ));
       });
     }
@@ -1177,9 +1185,10 @@ function getEdm(options, messageFunctions) {
         _constraints = this._csn._constraints._partnerCsn._constraints;
         [i,j] = [1,0];
       }
-      edmUtils.forAll(_constraints.constraints,
-        c => this.append(new ReferentialConstraint(this._v,
-        { Property: c[i].join(options.pathDelimiter), ReferencedProperty: c[j].join(options.pathDelimiter) } ) ) );
+      _constraints.constraints && Object.values(_constraints.constraints).forEach(c =>
+        this.append(new ReferentialConstraint(this._v,
+          { Property: c[i].join(options.pathDelimiter), ReferencedProperty: c[j].join(options.pathDelimiter) } ) )
+      );
     }
   }
 
@@ -1502,7 +1511,7 @@ function getEdm(options, messageFunctions) {
     }
     toJSONattributes(json) {
       super.toJSONattributes(json);
-      edmUtils.forAll(this._jsonOnlyAttributes, (v,p) => {
+      this._jsonOnlyAttributes && Object.entries(this._jsonOnlyAttributes).forEach(([p, v]) => {
         json[p[0] === '@' ? p : '$' + p] = v;
       });
       return json;
@@ -1606,7 +1615,7 @@ function getEdm(options, messageFunctions) {
       node._d = new Dependent(v, { Role: from } );
       node._p = new Principal(v, { Role: to } );
 
-      edmUtils.forAll(c, cv => {
+      c && Object.values(c).forEach(cv => {
         node._d.append(new PropertyRef(v, cv[0].join(options.pathDelimiter)));
         node._p.append(new PropertyRef(v, cv[1].join(options.pathDelimiter)));
       });

package/lib/edm/edmAnnoPreprocessor.js

@@ -0,0 +1,349 @@
+'use strict';
+
+const edmUtils = require('./edmUtils.js');
+const { setProp } = require('../base/model');
+const { forEachGeneric } = require('../model/csnUtils');
+
+/*
+ * Late application specific transformations
+ *  At present there are two transformation targets: Structure and Element
+ *  These transformations are available today:
+ *
+ *  Analytical Scenario:
+ *    If a structure is annotated with @Aggregation.ApplySupported.PropertyRestrictions
+ *    then a number of annotation rewrites are done to this structure and to the
+ *    elements of this structure
+ *    Also the key properties of all structure elements are removed and a new
+ *    artificial key element 'key _ID : String' is inserted at first position of
+ *    the elements dictionary
+ *
+ * PDM (Personal Data Management)
+ *    Planned but not yet implemented annotation rewriting (pending to finalization)
+ */
+
+/* eslint max-statements-per-line:off */
+
+function mapAnnotationAssignment(artifact, parent, mappingDictionary)
+{
+  let props = edmUtils.intersect(Object.keys(mappingDictionary), Object.keys(artifact));
+  // now start the substitution
+  props.forEach(prop => {
+    let [ mapping, value, remove_original ] = mappingDictionary[prop];
+    if(mapping instanceof Function)
+    {
+      mapping(artifact, parent, prop);
+    }
+    else
+    {
+      edmUtils.assignAnnotation(artifact, mapping, value || artifact[prop]['='] || artifact[prop]);
+    }
+
+    if(remove_original)
+      delete artifact[prop];
+  });
+}
+
+function addToSetAttr(carrier, propName, propValue, removeFromType=true) {
+  edmUtils.assignProp(carrier, '_SetAttributes', Object.create(null));
+  edmUtils.assignAnnotation(carrier._SetAttributes, propName, propValue);
+  if(removeFromType) {
+    delete carrier[propName];
+  }
+}
+
+function applyAppSpecificLateCsnTransformationOnElement(options, element, struct, error)
+{
+  if(options.isV2())
+  {
+    if(struct['@Aggregation.ApplySupported.PropertyRestrictions'])
+    {
+      mapAnnotationAssignment(element, struct, AnalyticalAnnotations());
+    }
+    mapAnnotationAssignment(element, struct, PDMSemantics());
+  }
+
+  // etag requires Core.OptimisticConcurrency to be set in V4 (cap/issues#2641)
+  // Oliver Heinrich mentions in the issue that the Okra runtime must be set to a
+  // concurrent runtime mode by the caller, if the annotation is added this late,
+  // it doesn't appear in the forOData processed CSN, meaning that the
+  // runtime cannot set that okra flag (alternatively the runtime has to search
+  // for @[odata|cds].etag annotations...
+  if(options.isV4())
+  {
+    if(element['@odata.etag'] == true || element['@cds.etag'] == true) {
+      // don't put element name into collection as per advice from Ralf Handl, as
+      // no runtime is interested in the property itself, it is sufficient to mark
+      // the entity set.
+      edmUtils.assignAnnotation(struct, '@Core.OptimisticConcurrency',
+        (struct['@Core.OptimisticConcurrency'] || [])/*.push(element.name)*/);
+    }
+  }
+
+  // nested functions begin
+  function PDMSemantics()
+  {
+    /*
+    let dict = Object.create(null);
+
+    dict['@PDM.xxx1'] = [ '@sap.pdm-semantics' ];
+    dict['@PDM.xxx2'] = [ '@sap.pdm-propery' ];
+    dict['@PDM.xxx3'] = [ '@sap.pdm-display-sq-no' ];
+    dict['@PDM.xxx4'] = [ '@sap.pdm-record-identifier' ];
+    dict['@PDM.xxx5'] = [ '@sap.pdm-field-group' ];
+    dict['@PDM.xxx6'] = [ '@sap.pdm-mask-find-pattern' ];
+    dict['@PDM.xxx7'] = [ '@sap.pdm-mask-replacement-pattern' ];
+    dict['@PDM.xxx8'] = [ '@sap.deletable' ];
+    dict['@PDM.xxx8'] = [ '@sap.updatable' ];
+
+    // respect flattened annotation $value
+    Object.keys(dict).forEach(k => dict[k+'.$value'] = dict[k]);
+    */
+    return Object.create(null);
+  }
+
+  function AnalyticalAnnotations()
+  {
+    function mapCommonAttributes(element, struct, prop)
+    {
+      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)`);
+        return;
+      }
+
+      let targets = edmUtils.intersect(CommonAttributes, Object.keys(struct.elements));
+      targets.forEach(tgt => {
+        edmUtils.assignAnnotation(struct.elements[tgt], '@sap.attribute-for', element.name);
+      });
+    }
+
+    function mapContextDefiningProperties(element, struct, prop)
+    {
+      let ContextDefiningProperties = element[prop];
+      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)`);
+        return;
+      }
+      if(ContextDefiningProperties.length > 0)
+        edmUtils.assignAnnotation(element, '@sap.super-ordinate', ContextDefiningProperties[ContextDefiningProperties.length-1]);
+    }
+
+    let dict = Object.create(null);
+    //analytics term definition unknown, lower case
+    dict['@Analytics.Measure'] = [ '@sap.aggregation-role', 'measure' ];
+    dict['@Analytics.Dimension'] = [ '@sap.aggregation-role', 'dimension' ];
+    dict['@Semantics.currencyCode'] = [ '@sap.semantics', 'currency-code', true ];
+    dict['@Semantics.unitOfMeasure'] = [ '@sap.semantics', 'unit-of-measure', true ];
+
+    dict['@Measures.ISOCurrency'] = [ '@sap.unit' ];
+    dict['@Measures.Unit'] = [ '@sap.unit' ];
+
+    dict['@Common.Label'] = [ '@sap.label' ];
+    dict['@Common.Text'] = [ '@sap.text' ];
+    dict['@Aggregation.ContextDefiningProperties'] = [ mapContextDefiningProperties ];
+    dict['@Common.Attributes'] = [ mapCommonAttributes ];
+
+    // respect flattened annotation $value
+    Object.entries(dict).forEach(([k, v]) => dict[k+'.$value'] = v);
+    return dict;
+  }
+}
+
+function applyAppSpecificLateCsnTransformationOnStructure(options, struct, error)
+{
+  if(options.isV2())
+  {
+    if(struct['@Aggregation.ApplySupported.PropertyRestrictions'])
+    {
+      transformAnalyticalModel(struct);
+      mapAnnotationAssignment(struct, undefined, AnalyticalAnnotations());
+    }
+  }
+
+  // nested functions begin
+  function transformAnalyticalModel(struct)
+  {
+    let keyName = 'ID__';
+    if(struct == undefined || struct.elements == undefined || struct.elements[keyName] != undefined)
+      return;
+
+    // remove key prop from elements, add new key to elements
+    let elements = Object.create(null);
+    let key =  { name: keyName, key : true, type : 'cds.String', '@sap.sortable':false, '@sap.filterable':false, '@UI.Hidden': true };
+    elements[keyName] = key;
+    setProp(struct, '$keys',{ [keyName] : key } );
+    forEachGeneric(struct.items || struct, 'elements', (e,n) =>
+    {
+      if(e.key) delete e.key;
+      elements[n] = e;
+    });
+    struct.elements = elements;
+  }
+
+  function AnalyticalAnnotations()
+  {
+    function mapFilterRestrictions(struct, parent, prop)
+    {
+      let stringDict = Object.create(null);
+      stringDict['SingleValue'] = 'single-value';
+      stringDict['MultiValue'] = 'multi-value';
+      stringDict['SingleRange'] = 'interval';
+
+      let filterRestrictions = struct[prop];
+      if(!Array.isArray(filterRestrictions)) {
+        error(null, ['definitions', struct.name ],
+          { anno: '@Capabilities.FilterRestrictions.FilterExpressionRestrictions',
+            code: JSON.stringify(filterRestrictions) },
+          `Expect array value for $(ANNOTATION): $(CODE)`);
+        return;
+      }
+      filterRestrictions.forEach(v => {
+        let e = struct.elements[v.Property];
+        if(e)
+          edmUtils.assignAnnotation(e, '@sap.filter-restriction', stringDict[v.AllowedExpressions]);
+      });
+    }
+
+    function mapRequiredProperties(struct, parent, prop)
+    {
+      let requiredProperties = struct[prop];
+      if(!Array.isArray(requiredProperties)) {
+        error(null, ['definitions', struct.name],
+          { anno: '@Capabilities.FilterRestrictions.RequiredProperties',
+            code: JSON.stringify(requiredProperties) },
+          `Expect array value for $(ANNOTATION): $(CODE)`);
+        return;
+      }
+
+      let props = edmUtils.intersect(Object.keys(struct.elements), requiredProperties)
+      props.forEach(p => {
+        edmUtils.assignAnnotation(struct.elements[p], '@sap.required-in-filter', true);
+      });
+    }
+
+    function mapRequiresFilter(struct, parent, prop)
+    {
+      let requiresFilter = struct[prop];
+      if(requiresFilter)
+        edmUtils.assignAnnotation(struct._SetAttributes, '@sap.requires-filter', requiresFilter);
+    }
+
+      // Entity Props
+    let dict = Object.create(null);
+    dict['@Aggregation.ApplySupported.PropertyRestrictions'] = [ '@sap.semantics', 'aggregate' ];
+    dict['@Common.Label'] = [ '@sap.label' ];
+    dict['@Capabilities.FilterRestrictions.RequiresFilter'] = [ mapRequiresFilter ];
+    dict['@Capabilities.FilterRestrictions.RequiredProperties'] = [ mapRequiredProperties ];
+    dict['@Capabilities.FilterRestrictions.FilterExpressionRestrictions'] = [ mapFilterRestrictions ];
+
+    // respect flattened annotation $value
+    Object.keys(dict).forEach(k => dict[k+'.$value'] = dict[k]);
+
+    return dict;
+  }
+}
+
+function setSAPSpecificV2AnnotationsToEntityContainer(options, carrier) {
+  if(!options.isV2())
+    return;
+  // documented in https://wiki.scn.sap.com/wiki/display/EmTech/SAP+Annotations+for+OData+Version+2.0#SAPAnnotationsforODataVersion2.0-Elementedm:EntityContainer
+  const SetAttributes = {
+    // EntityContainer only
+    '@sap.supported.formats' : addToSetAttr,
+    '@sap.use.batch': addToSetAttr,
+    '@sap.message.scope.supported': addToSetAttr,
+  };
+
+  Object.entries(carrier).forEach(([p, v]) => {
+    (SetAttributes[p] || function() { /* no-op */ })(carrier, p, v);
+  });
+}
+
+function setSAPSpecificV2AnnotationsToEntitySet(options, carrier) {
+  if(!options.isV2())
+    return;
+  // documented in https://wiki.scn.sap.com/wiki/display/EmTech/SAP+Annotations+for+OData+Version+2.0#SAPAnnotationsforODataVersion2.0-Elementedm:EntitySet
+  const SetAttributes = {
+    // EntitySet, EntityType
+    '@sap.label' : (s,pn, pv) => { addToSetAttr(s, pn, pv, false); },
+    '@sap.semantics': checkSemantics,
+    // EntitySet only
+    '@sap.creatable' : addToSetAttr,
+    '@sap.updatable' : addToSetAttr,
+    '@sap.deletable': addToSetAttr,
+    '@sap.updatable.path': addToSetAttr,
+    '@sap.deletable.path': addToSetAttr,
+    '@sap.searchable' : addToSetAttr,
+    '@sap.pagable': addToSetAttr,
+    '@sap.topable': addToSetAttr,
+    '@sap.countable': addToSetAttr,
+    '@sap.addressable': addToSetAttr,
+    '@sap.requires.filter': addToSetAttr,
+    '@sap.change.tracking': addToSetAttr,
+    '@sap.maxpagesize': addToSetAttr,
+    '@sap.delta.link.validity': addToSetAttr,
+  };
+
+  Object.entries(carrier).forEach(([p, v]) => {
+    (SetAttributes[p] || function() { /* no-op */ })(carrier, p, v);
+  });
+
+  function checkSemantics(struct, propName, propValue) {
+    if(propValue === 'timeseries' || propValue === 'aggregate') {
+      // aggregate is forwarded to Set and must remain on Type
+      addToSetAttr(struct, propName, propValue, propValue !== 'aggregate');
+    }
+  }
+}
+
+function setSAPSpecificV2AnnotationsToAssociation(carrier) {
+  // documented in https://wiki.scn.sap.com/wiki/display/EmTech/SAP+Annotations+for+OData+Version+2.0
+  const SetAttributes = {
+    // Applicable to NavProp and foreign keys, add to AssociationSet
+    '@sap.creatable' : (c, pn, pv) => { addToAssociationSet(c, pn, pv, false); },
+    // Not applicable to NavProp, applicable to foreign keys, add to AssociationSet
+    '@sap.updatable' : addToAssociationSet,
+    // Not applicable to NavProp, not applicable to foreign key, add to AssociationSet
+    '@sap.deletable': (c, pn, pv) => {
+      addToAssociationSet(c, pn, pv);
+      removeFromForeignKey(c, pn);
+    },
+    // applicable to NavProp, not applicable to foreign keys, not applicable to AssociationSet
+    '@sap.creatable.path': removeFromForeignKey,
+    '@sap.filterable': removeFromForeignKey,
+  };
+
+  Object.entries(carrier).forEach(([p, v]) => {
+    (SetAttributes[p] || function() {/* no-op */})(carrier, p, v);
+  });
+
+  function addToAssociationSet(carrier, propName, propValue, removeFromType=true) {
+    if(carrier.target) {
+      edmUtils.assignProp(carrier, '_SetAttributes', Object.create(null));
+      edmUtils.assignAnnotation(carrier._SetAttributes, propName, propValue);
+      if(removeFromType) {
+        delete carrier[propName];
+      }
+    }
+  }
+
+  function removeFromForeignKey(carrier, propName) {
+    if(carrier['@odata.foreignKey4'] && carrier[propName] !== undefined) {
+      delete carrier[propName];
+    }
+  }
+}
+
+
+
+module.exports = {
+  applyAppSpecificLateCsnTransformationOnElement,
+  applyAppSpecificLateCsnTransformationOnStructure,
+  setSAPSpecificV2AnnotationsToEntityContainer,
+  setSAPSpecificV2AnnotationsToEntitySet,
+  setSAPSpecificV2AnnotationsToAssociation
+};