@sap/cds-compiler 4.0.2 → 4.2.2

package/lib/edm/edmAnnoPreprocessor.js

@@ -23,43 +23,34 @@ const { forEachGeneric } = require('../model/csnUtils');
 
 /* eslint max-statements-per-line:off */
 
-function mapAnnotationAssignment(artifact, parent, mappingDictionary)
-{
-  let props = edmUtils.intersect(Object.keys(mappingDictionary), Object.keys(artifact));
+function mapAnnotationAssignment( artifact, parent, mappingDictionary ) {
+  const 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)
-    {
+  props.forEach((prop) => {
+    const [ mapping, value, removeOriginal ] = mappingDictionary[prop];
+    if (mapping instanceof Function)
       mapping(artifact, parent, prop);
-    }
+
     else
-    {
       edmUtils.assignAnnotation(artifact, mapping, value || artifact[prop]['='] || artifact[prop]);
-    }
 
-    if(remove_original)
+
+    if (removeOriginal)
       delete artifact[prop];
   });
 }
 
-function addToSetAttr(carrier, propName, propValue, removeFromType=true) {
+function addToSetAttr( carrier, propName, propValue, removeFromType = true ) {
   edmUtils.assignProp(carrier, '_SetAttributes', Object.create(null));
   edmUtils.assignAnnotation(carrier._SetAttributes, propName, propValue);
-  if(removeFromType) {
+  if (removeFromType)
     delete carrier[propName];
-  }
 }
 
-function applyAppSpecificLateCsnTransformationOnElement(options, element, struct, error)
-{
-  if(options.isV2())
-  {
-    if(struct['@Aggregation.ApplySupported.PropertyRestrictions'])
-    {
-      mapAnnotationAssignment(element, struct, AnalyticalAnnotations());
-    }
-  }
+function applyAppSpecificLateCsnTransformationOnElement( options, element, struct, error ) {
+  if (options.isV2() && struct['@Aggregation.ApplySupported.PropertyRestrictions'])
+    mapAnnotationAssignment(element, struct, AnalyticalAnnotations());
+
 
   // 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
@@ -67,51 +58,45 @@ function applyAppSpecificLateCsnTransformationOnElement(options, element, struct
   // 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 (options.isV4() && (element['@odata.etag'] || element['@cds.etag'])) {
     // eslint-disable-next-line sonarjs/no-redundant-boolean
-    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)*/);
-    }
+    // 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) */);
   }
 
-  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.Attributes', code: JSON.stringify(CommonAttributes) },
-          'Expecting array value for $(ANNO): $(CODE)');
+  function AnalyticalAnnotations() {
+    function mapCommonAttributes( elt, structure, prop ) {
+      const CommonAttributes = elt[prop];
+      if (!Array.isArray(CommonAttributes)) {
+        error(null, [ 'definitions', structure.name, 'elements', elt.name ],
+              { anno: '@Common.Attributes', code: JSON.stringify(CommonAttributes) },
+              'Expecting array value for $(ANNO): $(CODE)');
         return;
       }
 
-      let targets = edmUtils.intersect(CommonAttributes, Object.keys(struct.elements));
-      targets.forEach(tgt => {
-        edmUtils.assignAnnotation(struct.elements[tgt], '@sap.attribute-for', element.name);
+      const targets = edmUtils.intersect(CommonAttributes, Object.keys(structure.elements));
+      targets.forEach((tgt) => {
+        edmUtils.assignAnnotation(structure.elements[tgt], '@sap.attribute-for', elt.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) },
-          'Expecting array value for $(ANNO): $(CODE)');
+    function mapContextDefiningProperties( elt, structure, prop ) {
+      const ContextDefiningProperties = elt[prop];
+      if (!Array.isArray(ContextDefiningProperties)) {
+        error(null, [ 'definitions', structure.name, 'elements', elt.name ],
+              { anno: '@Aggregation.ContextDefiningProperties', code: JSON.stringify(ContextDefiningProperties) },
+              'Expecting array value for $(ANNO): $(CODE)');
         return;
       }
-      if(ContextDefiningProperties.length > 0)
-        edmUtils.assignAnnotation(element, '@sap.super-ordinate', ContextDefiningProperties[ContextDefiningProperties.length-1]);
+      if (ContextDefiningProperties.length > 0)
+        edmUtils.assignAnnotation(elt, '@sap.super-ordinate', ContextDefiningProperties[ContextDefiningProperties.length - 1]);
     }
 
-    let dict = Object.create(null);
-    //analytics term definition unknown, lower case
+    const 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 ];
@@ -126,92 +111,90 @@ function applyAppSpecificLateCsnTransformationOnElement(options, element, struct
     dict['@Common.Attributes'] = [ mapCommonAttributes ];
 
     // respect flattened annotation $value
-    Object.entries(dict).forEach(([k, v]) => dict[k+'.$value'] = v);
+    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());
-    }
+function applyAppSpecificLateCsnTransformationOnStructure( options, struct, error ) {
+  if (options.isV2() && 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)
+  function transformAnalyticalModel( structure ) {
+    const keyName = 'ID__';
+    if (!structure?.elements || structure.elements[keyName])
       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 };
+    const elements = Object.create(null);
+    const 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;
+    setProp(structure, '$keys', { [keyName]: key } );
+    forEachGeneric(structure.items || structure, 'elements', (e, n) => {
+      if (e.key)
+        delete e.key;
       elements[n] = e;
     });
-    struct.elements = elements;
+    structure.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) },
-          'Expected array value for $(ANNO): $(CODE)');
+  function AnalyticalAnnotations() {
+    function mapFilterRestrictions( structure, parent, prop ) {
+      const stringDict = Object.create(null);
+      stringDict.SingleValue = 'single-value';
+      stringDict.MultiValue = 'multi-value';
+      stringDict.SingleRange = 'interval';
+
+      const filterRestrictions = structure[prop];
+      if (!Array.isArray(filterRestrictions)) {
+        error(null, [ 'definitions', structure.name ],
+              {
+                anno: '@Capabilities.FilterRestrictions.FilterExpressionRestrictions',
+                code: JSON.stringify(filterRestrictions),
+              },
+              'Expected array value for $(ANNO): $(CODE)');
         return;
       }
-      filterRestrictions.forEach(v => {
-        let e = struct.elements[v.Property];
-        if(e)
+      filterRestrictions.forEach((v) => {
+        const e = structure.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) },
-          'Expecting array value for $(ANNO): $(CODE)');
+    function mapRequiredProperties( structure, parent, prop ) {
+      const requiredProperties = structure[prop];
+      if (!Array.isArray(requiredProperties)) {
+        error(null, [ 'definitions', structure.name ],
+              {
+                anno: '@Capabilities.FilterRestrictions.RequiredProperties',
+                code: JSON.stringify(requiredProperties),
+              },
+              'Expecting array value for $(ANNO): $(CODE)');
         return;
       }
 
-      let props = edmUtils.intersect(Object.keys(struct.elements), requiredProperties)
-      props.forEach(p => {
-        edmUtils.assignAnnotation(struct.elements[p], '@sap.required-in-filter', true);
+      const props = edmUtils.intersect(Object.keys(structure.elements), requiredProperties);
+      props.forEach((p) => {
+        edmUtils.assignAnnotation(structure.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);
+    function mapRequiresFilter( structure, parent, prop ) {
+      const requiresFilter = structure[prop];
+      if (requiresFilter)
+        edmUtils.assignAnnotation(structure._SetAttributes, '@sap.requires-filter', requiresFilter);
     }
 
-      // Entity Props
-    let dict = Object.create(null);
+    // Entity Props
+    const dict = Object.create(null);
     dict['@Aggregation.ApplySupported.PropertyRestrictions'] = [ '@sap.semantics', 'aggregate' ];
     dict['@Common.Label'] = [ '@sap.label' ];
     dict['@Capabilities.FilterRestrictions.RequiresFilter'] = [ mapRequiresFilter ];
@@ -219,43 +202,47 @@ function applyAppSpecificLateCsnTransformationOnStructure(options, struct, error
     dict['@Capabilities.FilterRestrictions.FilterExpressionRestrictions'] = [ mapFilterRestrictions ];
 
     // respect flattened annotation $value
-    Object.keys(dict).forEach(k => dict[k+'.$value'] = dict[k]);
+    Object.keys(dict).forEach((k) => {
+      dict[`${k}.$value`] = dict[k];
+    });
 
     return dict;
   }
 }
 
-function setSAPSpecificV2AnnotationsToEntityContainer(options, carrier) {
-  if(!options.isV2())
+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.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);
+  Object.entries(carrier).forEach(([ p, v ]) => {
+    (SetAttributes[p] || function () { /* no-op */ })(carrier, p, v); // eslint-disable-line func-names
   });
 }
 
-function setSAPSpecificV2AnnotationsToEntitySet(options, carrier) {
-  if(!options.isV2())
+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.label': (s, pn, pv) => {
+      addToSetAttr(s, pn, pv, false);
+    },
     '@sap.semantics': checkSemantics,
     // EntitySet only
-    '@sap.creatable' : addToSetAttr,
-    '@sap.updatable' : addToSetAttr,
+    '@sap.creatable': addToSetAttr,
+    '@sap.updatable': addToSetAttr,
     '@sap.deletable': addToSetAttr,
     '@sap.updatable.path': addToSetAttr,
     '@sap.deletable.path': addToSetAttr,
-    '@sap.searchable' : addToSetAttr,
+    '@sap.searchable': addToSetAttr,
     '@sap.pagable': addToSetAttr,
     '@sap.topable': addToSetAttr,
     '@sap.countable': addToSetAttr,
@@ -266,25 +253,27 @@ function setSAPSpecificV2AnnotationsToEntitySet(options, carrier) {
     '@sap.delta.link.validity': addToSetAttr,
   };
 
-  Object.entries(carrier).forEach(([p, v]) => {
-    (SetAttributes[p] || function() { /* no-op */ })(carrier, p, v);
+  Object.entries(carrier).forEach(([ p, v ]) => {
+    (SetAttributes[p] || function () { /* no-op */ })(carrier, p, v); // eslint-disable-line func-names
   });
 
-  function checkSemantics(struct, propName, propValue) {
-    if(propValue === 'timeseries' || propValue === 'aggregate') {
+  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) {
+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); },
+    '@sap.creatable': (c, pn, pv) => {
+      addToAssociationSet(c, pn, pv, false);
+    },
     // Not applicable to NavProp, applicable to foreign keys, add to AssociationSet
-    '@sap.updatable' : addToAssociationSet,
+    '@sap.updatable': addToAssociationSet,
     // Not applicable to NavProp, not applicable to foreign key, add to AssociationSet
     '@sap.deletable': (c, pn, pv) => {
       addToAssociationSet(c, pn, pv);
@@ -295,33 +284,30 @@ function setSAPSpecificV2AnnotationsToAssociation(carrier) {
     '@sap.filterable': removeFromForeignKey,
   };
 
-  Object.entries(carrier).forEach(([p, v]) => {
-    (SetAttributes[p] || function() {/* no-op */})(carrier, p, v);
+  Object.entries(carrier).forEach(([ p, v ]) => {
+    (SetAttributes[p] || function () { /* no-op */ })(carrier, p, v); // eslint-disable-line func-names
   });
 
-  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 addToAssociationSet( target, propName, propValue, removeFromType = true ) {
+    if (target.target) {
+      edmUtils.assignProp(target, '_SetAttributes', Object.create(null));
+      edmUtils.assignAnnotation(target._SetAttributes, propName, propValue);
+      if (removeFromType)
+        delete target[propName];
     }
   }
 
-  function removeFromForeignKey(carrier, propName) {
-    if(carrier['@odata.foreignKey4'] && carrier[propName] !== undefined) {
-      delete carrier[propName];
-    }
+  function removeFromForeignKey( target, propName ) {
+    if (target['@odata.foreignKey4'] && target[propName] !== undefined)
+      delete target[propName];
   }
 }
 
 
-
 module.exports = {
   applyAppSpecificLateCsnTransformationOnElement,
   applyAppSpecificLateCsnTransformationOnStructure,
   setSAPSpecificV2AnnotationsToEntityContainer,
   setSAPSpecificV2AnnotationsToEntitySet,
-  setSAPSpecificV2AnnotationsToAssociation
+  setSAPSpecificV2AnnotationsToAssociation,
 };

package/lib/edm/edmInboundChecks.js

@@ -6,13 +6,13 @@ const {
 } = require('../model/csnUtils');
 
 // eslint-disable-next-line no-unused-vars
-function resolveForeignKeyRefs(csn, csnUtils) {
+function resolveForeignKeyRefs( csn, csnUtils ) {
   forEachDefinition(csn, (def, defName) => {
-    let currPath = ['definitions', defName ];
+    const currPath = [ 'definitions', defName ];
     forEachMemberRecursively(def, (construct, _constructName, _prop, path) => {
-      if(construct.target && construct.keys) {
+      if (construct.target && construct.keys) {
         construct.keys.forEach((fk, i) => {
-          setProp(fk, '_artifact', csnUtils.inspectRef([...path, 'keys', i]).art);
+          setProp(fk, '_artifact', csnUtils.inspectRef([ ...path, 'keys', i ]).art);
         });
       }
     }, currPath, true, { elementsOnly: true });
@@ -20,34 +20,34 @@ function resolveForeignKeyRefs(csn, csnUtils) {
 }
 
 
-function inboundQualificationChecks(csn, options, messageFunctions,
-  serviceRootNames, requestedServiceNames, isMyServiceRequested, whatsMyServiceRootName, csnUtils) {
+function inboundQualificationChecks( csn, options, messageFunctions,
+                                     serviceRootNames, requestedServiceNames, isMyServiceRequested, whatsMyServiceRootName, csnUtils ) {
   const { message, throwWithError } = messageFunctions;
 
   forEachDefinition(csn, [ attach$path, checkProperArrayUsage ]);
   checkNestedContextsAndServices();
   throwWithError();
 
-    // attach $path to all
-  function attach$path(def, defName) {
+  // attach $path to all
+  function attach$path( def, defName ) {
     setProp(def, '$path', [ 'definitions', defName ]);
     forEachMemberRecursively(def,
-        (member, _memberName, _prop, path) => {
-          setProp(member, '$path', path);
-        }, [ 'definitions', defName ]);
+                             (member, _memberName, _prop, path) => {
+                               setProp(member, '$path', path);
+                             }, [ 'definitions', defName ]);
   }
 
-  function checkProperArrayUsage(def, defName) {
+  function checkProperArrayUsage( def, defName ) {
     if (!isMyServiceRequested(defName))
       return;
-    let currPath = ['definitions', defName];
+    const currPath = [ 'definitions', defName ];
     checkIfItemsOfItems(def, undefined, undefined, currPath);
     forEachMemberRecursively(def, checkIfItemsOfItems, currPath);
 
-    function checkIfItemsOfItems(construct, _constructName, _prop, path) {
+    function checkIfItemsOfItems( construct, _constructName, _prop, path ) {
       const constructType = csnUtils.effectiveType(construct);
       if (constructType.items) {
-        if(constructType.items.target) {
+        if (constructType.items.target) {
           const isComp = constructType.items.type === 'cds.Composition';
           message('type-invalid-items', path, { '#': isComp ? 'comp' : 'assoc', prop: 'items' });
           return;
@@ -65,24 +65,26 @@ function inboundQualificationChecks(csn, options, messageFunctions,
   }
 
   function checkNestedContextsAndServices() {
-    !isBetaEnabled(options, 'nestedServices') && serviceRootNames.forEach(sn => {
-      const parent = whatsMyServiceRootName(sn, false);
-      if(parent && requestedServiceNames.includes(parent) && parent !== sn) {
-        message( 'service-nested-service', [ 'definitions', sn ], { art: parent },
-               'A service can\'t be nested within a service $(ART)' );
-      }
-    });
+    if (!isBetaEnabled(options, 'nestedServices')) {
+      serviceRootNames.forEach((sn) => {
+        const parent = whatsMyServiceRootName(sn, false);
+        if (parent && requestedServiceNames.includes(parent) && parent !== sn) {
+          message( 'service-nested-service', [ 'definitions', sn ], { art: parent },
+                   'A service can\'t be nested within a service $(ART)' );
+        }
+      });
+    }
 
-    Object.entries(csn.definitions).forEach(([fqName, art]) => {
-      if(art.kind === 'context') {
+    Object.entries(csn.definitions).forEach(([ fqName, art ]) => {
+      if (art.kind === 'context') {
         const parent = whatsMyServiceRootName(fqName);
-        if(requestedServiceNames.includes(parent)) {
+        if (requestedServiceNames.includes(parent)) {
           message( 'service-nested-context', [ 'definitions', fqName ], { art: parent },
-               'A context can\'t be nested within a service $(ART)' );
+                   'A context can\'t be nested within a service $(ART)' );
         }
       }
     });
   }
 }
 
-module.exports = { inboundQualificationChecks }
+module.exports = { inboundQualificationChecks };