@sap/cds-compiler 3.5.2 → 3.6.0

package/lib/edm/annotations/genericTranslation.js

@@ -159,13 +159,6 @@ const knownVocabularies = Object.keys(vocabularyDefinitions);
  *   dictReplacement: for test purposes, replaces the standard oDataDictionary
  */
 function csn2annotationEdm(reqDefs, csnVocabularies, serviceName, Edm = undefined, options=undefined, messageFunctions=undefined) {
-  
-  if(!Edm)
-    throw new Error('Please debug me: csn2annotationsEdm must be invoked with Edm');
-  if(!options)
-    throw new Error('Please debug me: csn2annotationsEdm must be invoked with options');
-  if(!messageFunctions)
-    throw new Error('Please debug me: csn2annotationsEdm must be invoked with messageFunctions');
   // global variable where we store all the generated annotations
   const g_annosArray = [];
 
@@ -223,7 +216,7 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName, Edm = undefine
         const vocName = termName.slice(0, termName.indexOf('.'));
         if(vocabularyDefinitions[vocName])
           vocabularyDefinitions[vocName].used = true;
-        else if(dictTerm?.$myServiceRoot && 
+        else if(dictTerm?.$myServiceRoot &&
           adhocDictionary.xrefs[dictTerm?.$myServiceRoot])
           adhocDictionary.xrefs[dictTerm.$myServiceRoot].used = true;
         if (dictTerm) {
@@ -407,7 +400,7 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName, Edm = undefine
     function relParList() {
     // we rely on the order of params in the csn being the correct one
       const params = [];
-      if (entityNameIfBound) {
+      if (entityNameIfBound && !(cAction.kind === 'function' && cAction.$hasBindingParam)) {
         params.push(cAction['@cds.odata.bindingparameter.collection'] ? 'Collection(' + entityNameIfBound + ')' : entityNameIfBound);
       }
       if (cAction.kind === 'function') {
@@ -457,7 +450,7 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName, Edm = undefine
 
     // Filter unknown toplevel annotations
     // Final filtering of all annotations is done in handleTerm
-    
+
     let knownAnnos = filterKnownAnnotations();
     if (knownAnnos.length === 0) return;
 
@@ -815,8 +808,8 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName, Edm = undefine
         const fullTermName = voc + '.' + term;
 
         // msg is "semantic" location message used for messages
-        const msg = { 
-          fullTermName, 
+        const msg = {
+          fullTermName,
           stack: [],
           location: [ ...location, '@' + fullTermName ],
         };
@@ -832,7 +825,7 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName, Edm = undefine
           const dictTerm = getDictTerm(termName, msg); // message for unknown term was already issued in handleTerm
           if(!addAnnotationFunc(anno, dictTerm && dictTerm.AppliesTo)) {
             if(dictTerm && dictTerm.AppliesTo) {
-              message('odata-anno-def', location, 
+              message('odata-anno-def', location,
               { anno: termName, rawvalues: dictTerm.AppliesTo, '#': 'notapplied' });
             }
           }
@@ -1268,33 +1261,39 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName, Edm = undefine
         message('odata-anno-type', msg.location,
         { anno: msg.anno(), type: actualTypeName, '#': 'unknown' });
         // explicitly mentioned type, render in XML and JSON
-        newRecord.setEdmAttribute('Type', actualTypeName);
-      }
-      else if (isAbstractType(actualTypeName)) {
-        // this type is abstract
-        message('odata-anno-type', msg.location,
-        { anno: msg.anno(), type: actualTypeName, '#': 'abstract' });
-        if(dTypeName)
-          actualTypeName = dTypeName;
-        // set to definition name and render in XML and JSON
-        newRecord.setEdmAttribute('Type', actualTypeName);
-      }
-      else if (dTypeName && !isDerivedFrom(actualTypeName, dTypeName)) {
-        // this type doesn't fit the expected one
-        message('odata-anno-type', msg.location,
-          { anno: msg.anno(),
-            type: actualTypeName,
-            name: dTypeName,
-            code: '$Type',
-            '#': 'derived' });
-        actualTypeName = dTypeName;
-        // explicitly mentioned type, render in XML and JSON
-        newRecord.setEdmAttribute('Type', actualTypeName);
+        newRecord.setXml({ 'Type': actualTypeName});
+        // unknown dictionary type: can't fully qualify it
+        newRecord.setJSON({ 'Type': actualTypeName});
       }
       else {
-        // ok
+        if (isAbstractType(actualTypeName)) {
+          // this type is abstract
+          message('odata-anno-type', msg.location,
+          { anno: msg.anno(), type: actualTypeName, code: '$Type', '#': 'abstract' });
+          if(dTypeName)
+            actualTypeName = dTypeName;
+        }
+        else if (dTypeName && !isDerivedFrom(actualTypeName, dTypeName)) {
+          // this type doesn't fit the expected one
+          message('odata-anno-type', msg.location,
+            { anno: msg.anno(),
+              type: actualTypeName,
+              name: dTypeName,
+              code: '$Type',
+              '#': 'derived' });
+          actualTypeName = dTypeName;
+        }
         // Dictionary Type, render in XML only for backward compatibility
         newRecord.setXml( { Type: actualTypeName });
+        const vocName = actualTypeName.slice(0, actualTypeName.indexOf('.'));
+        const vocDef = vocabularyDefinitions[vocName];
+        // Set full qualified type in JSON
+        // TODO: Adhoc type x-ref URIs (only if abstract types are allowed in CDS)
+        if(vocDef)
+          newRecord.setJSON( { 'Type': `${vocDef.ref.Uri}#${actualTypeName}` });
+        // don't add short actualTypeName into JSON as this would be wrong for a resolved! type.
+        // A $Type w/o vocDef can only occur for adhoc type defs and these can't be abstract but
+        // are fully resolvable due to their term usage via schema x-ref.
       }
     }
     else if (dTypeName) { // there is an expected type name according to dictionary
@@ -1308,7 +1307,7 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName, Edm = undefine
       }
       if (isAbstractType(actualTypeName))
         message('odata-anno-type', msg.location,
-        { anno: msg.anno(), type: dTypeName, '#': 'abstract' });
+        { anno: msg.anno(), type: dTypeName, code: '$Type', '#': 'abstract' });
 
       // Dictionary Type, render in XML only for backward compatibility
       newRecord.setXml( { Type: actualTypeName });
@@ -1458,7 +1457,11 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName, Edm = undefine
           const props = Object.create(null);
           Object.entries(obj).forEach(([k, val]) => {
             if(k === '@type') {
-              edmNode.setEdmAttribute('Type', val);
+              edmNode.setJSON({ 'Type': val});
+              // try to shorten full qualified type URI to short type name
+              const parts = val.split('#');
+              const shortTypeName = parts[parts.length-1];
+              edmNode.setXml({ Type: shortTypeName });
             }
             else {
               let child = undefined;
@@ -1554,14 +1557,16 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName, Edm = undefine
     }
   }
 
-  /*
-    translate vocabulary definitions into an adhoc dictionary
-    with the same structure as the gobal jsonDictionary that
-    contains all official term and type definitions.
-
-    Return the dictionary and an array of schemas to which
-    the vocabulary definitions belong
-  */
+  /**
+   * translate vocabulary definitions into an adhoc dictionary
+   * with the same structure as the global jsonDictionary that
+   * contains all official term and type definitions.
+   *
+   * Return the dictionary and an array of schemas to which
+   * the vocabulary definitions belong
+   *
+   * @returns [object, Array<object>]
+   */
   function createAdhocDictionary() {
     const allKnownVocabularies = [];
     const dict = { terms: {}, types: {}, xrefs: {} };

package/lib/edm/annotations/preprocessAnnotations.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { makeMessageFunction } = require('../../base/messages.js');
-const { forEachDefinition } = require('../../model/csnUtils.js');
+const { forEachDefinition, forEachGeneric } = require('../../model/csnUtils.js');
 
 
 /**************************************************************************************************
@@ -34,10 +34,10 @@ function preprocessAnnotations(csn, serviceName, options) {
   // return value can be null is target has no key
   function getKeyOfTargetOfManagedAssoc(anno, assoc) {
     // assoc.target can be the name of the target or the object itself
-    let targetName = (typeof assoc.target === 'object') ? assoc.target.name : assoc.target;
-    let target     = (typeof assoc.target === 'object') ? assoc.target      : csn.definitions[assoc.target];
+    const targetName = (typeof assoc.target === 'object') ? assoc.target.name : assoc.target;
+    const target     = (typeof assoc.target === 'object') ? assoc.target      : csn.definitions[assoc.target];
 
-    let keyNames = Object.keys(target.elements).filter(x => target.elements[x].key && !target.elements[x].target);
+    const keyNames = Object.keys(target.elements).filter(x => target.elements[x].key && !target.elements[x].target);
     if (keyNames.length === 0) {
       keyNames.push('MISSING');
       message('odata-anno-preproc', null, { anno, name: targetName, '#': 'nokey' },
@@ -45,7 +45,7 @@ function preprocessAnnotations(csn, serviceName, options) {
     }
     else if (keyNames.length > 1)
       message('odata-anno-preproc', null, { anno, name: targetName, '#': 'multkeys' });
-    
+
     return keyNames[0];
   }
 
@@ -56,48 +56,45 @@ function preprocessAnnotations(csn, serviceName, options) {
 
   // resolve shortcuts
   function resolveShortcuts() {
-    let art = null;
-
     forEachDefinition(csn, (artifact, artifactName) => {
       const location = [ 'definitions', artifactName ];
       if(artifactName === serviceName || artifactName.startsWith(serviceName + '.')) {
-        art = artifactName;
-        handleAnnotations(artifactName, artifact, location);
+        handleAnnotations(artifactName, artifactName, artifact, location);
         artifact.elements && Object.entries(artifact.elements).forEach(([elementName, element]) => {
-          handleAnnotations(elementName, element, [ ...location, 'elements', elementName ]);
+          handleAnnotations(artifactName, elementName, element, [ ...location, 'elements', elementName ]);
         });
-        artifact.actions && Object.values(artifact.actions).forEach(action => {
+        forEachGeneric(artifact, 'actions', (action, actionName) => {
           action.params && Object.entries(action.params).forEach(([paramName, param]) => {
-            handleAnnotations(paramName, param, [ ...location, 'actions', action, 'params', paramName ]);
+            handleAnnotations(actionName, paramName, param, [ ...location, 'actions', actionName, 'params', paramName ]);
           });
         });
       }
     });
 
-    function handleAnnotations(carrierName, carrier, location) {
+    function handleAnnotations(defName, carrierName, carrier, location) {
 
       // collect the names of the carrier's annotation properties
-      let annoNames = Object.keys(carrier).filter( x => x[0] === '@')
+      const annoNames = Object.keys(carrier).filter( x => x[0] === '@')
 
-      for (let aName of annoNames) {
-        let aNameWithoutQualifier = aName.split('#')[0];
+      annoNames.forEach(aName => {
+        const aNameWithoutQualifier = aName.split('#')[0];
 
         // Always - draft annotations, value is action name
         //   - v2: prefix with entity name
         //   - prefix with service name
-        draftAnnotations(carrier, aName, aNameWithoutQualifier);
+        draftAnnotations(aName, aNameWithoutQualifier);
 
         // Always - FixedValueListShortcut
         //   expand shortcut form of ValueList annotation
-        fixedValueListShortCut(carrier, aNameWithoutQualifier);
+        fixedValueListShortCut(aNameWithoutQualifier);
 
         // Always - TextArrangementReordering
         //   convert @Common.TextArrangement annotation that is on same level as Text annotation into a nested annotation
-        textArrangementReordering(carrier, aName, aNameWithoutQualifier);
-      }
+        textArrangementReordering(aName, aNameWithoutQualifier);
+      });
 
       // inner functions
-      function draftAnnotations(carrier, aName, aNameWithoutQualifier) {
+      function draftAnnotations(aName, aNameWithoutQualifier) {
         if ((carrier.kind === 'entity') &&
             (aNameWithoutQualifier === '@Common.DraftRoot.PreparationAction' ||
               aNameWithoutQualifier === '@Common.DraftRoot.ActivationAction' ||
@@ -107,8 +104,9 @@ function preprocessAnnotations(csn, serviceName, options) {
           let value = carrier[aName];
           // prefix with service name, if not already done
           if (value === 'draftPrepare'  || value === 'draftActivate' || value === 'draftEdit') {
-            let serviceName = carrierName.replace(/.[^.]+$/, '');
-            value = carrier[aName] = serviceName + '.' + value;
+            // mocha test has no whatsMySchemaName
+            const schemaName = options.whatsMySchemaName && options.whatsMySchemaName(carrierName) || serviceName;
+            value = carrier[aName] = schemaName + '.' + value;
           }
           // for v2: function imports live inside EntityContainer -> path needs to contain "EntityContainer/"
           //         we decided to prefix names of bound action/functions with entity name -> needs to be reflected in path, too
@@ -119,7 +117,7 @@ function preprocessAnnotations(csn, serviceName, options) {
         }
       }
 
-      function fixedValueListShortCut(carrier, anno) {
+      function fixedValueListShortCut(anno) {
         if (anno === '@Common.ValueList.entity' ||
             anno === '@Common.ValueList.viaAssociation') {
 
@@ -146,12 +144,12 @@ function preprocessAnnotations(csn, serviceName, options) {
 
             if (anno === '@Common.ValueList.viaAssociation') {
               // value is expected to be an expression, namely the path to an association of the carrier entity
-              let assocName = carrier['@Common.ValueList.viaAssociation']['='];
+              const assocName = carrier['@Common.ValueList.viaAssociation']['='];
               if (!assocName) {
                 message('odata-anno-preproc', [...location, anno], { anno, '#': 'viaassoc' });
                 return false;
               }
-              let assoc = csn.definitions[art].elements[assocName];
+              const assoc = csn.definitions[defName].elements[assocName];
               if (!assoc || !assoc.target) {
                 message('odata-anno-preproc', [...location, anno], { anno, id: assocName, '#': 'noassoc' });
                 return false;
@@ -164,26 +162,25 @@ function preprocessAnnotations(csn, serviceName, options) {
               // if both annotations are present, ignore 'entity' and raise a message
               if (annoNames.map(x=>x.split('#')[0]).find(x=>(x==='@Common.ValueList.viaAssociation'))) {
                 message('odata-anno-preproc', [...location, anno],
-                  { 
-                    name: '@Common.ValueList.entity', anno: '@Common.ValueList', 
+                  {
+                    name: '@Common.ValueList.entity', anno: '@Common.ValueList',
                     value: 'entity', code: 'viaAssociation', '#': 'vallistignored'
                   });
                 return false;
               }
 
-              let annoVal = carrier['@Common.ValueList.entity']; // name of value list entity
+              const annoVal = carrier['@Common.ValueList.entity']; // name of value list entity
               if (annoVal['=']) {
                 message('odata-anno-preproc', [...location, anno], { anno, '#': 'notastring' },
                 );
               }
-
-              let nameprefix = art.replace(/.[^.]+$/, ''); // better way of getting the service name?
-
+              // mocha test has no whatsMySchemaName
+              const schemaName = options.whatsMySchemaName && options.whatsMySchemaName(defName) || serviceName
               enameShort = annoVal['='] || annoVal;
-              enameFull = nameprefix + '.' + enameShort;
+              enameFull = schemaName + '.' + enameShort;
             }
 
-            let vlEntity = csn.definitions[enameFull]; // (object) value list entity
+            const vlEntity = csn.definitions[enameFull]; // (object) value list entity
             if (!vlEntity) {
               message('odata-anno-preproc', [...location, anno ], { anno, id: enameFull, '#': 'notexist' });
               return false;
@@ -191,7 +188,7 @@ function preprocessAnnotations(csn, serviceName, options) {
 
             // label
             //   explicitly provided label wins
-            let label = carrier['@Common.ValueList.Label'] ||
+            const label = carrier['@Common.ValueList.Label'] ||
                         carrier['@Common.Label'] || vlEntity['@Common.Label'] || enameShort;
 
             // localDataProp
@@ -199,14 +196,14 @@ function preprocessAnnotations(csn, serviceName, options) {
             //   if this is a managed assoc, use fk field instead (if there is a single one)
             let localDataProp = carrierName.split('/').pop();
             if (carrier.target && carrier.on === undefined) {
-              localDataProp = localDataProp + fkSeparator + 
+              localDataProp = localDataProp + fkSeparator +
                 getKeyOfTargetOfManagedAssoc(anno, carrier);
             }
 
             // if this carrier is a generated foreign key field and the association is marked @cds.api.ignore
             // rename the localDataProp to be 'assocName/key'
             if(carrier['@cds.api.ignore']) {
-              let assocName = carrier['@odata.foreignKey4'];
+              const assocName = carrier['@odata.foreignKey4'];
               if(assocName && options.isV4()) {
                 localDataProp = localDataProp.replace(assocName+fkSeparator, assocName+'/');
               }
@@ -215,7 +212,7 @@ function preprocessAnnotations(csn, serviceName, options) {
             // valueListProp: the (single) key field of the value list entity
             //   if no key or multiple keys -> message
             let valueListProp = null;
-            let keys = Object.keys(vlEntity.elements).filter( x => vlEntity.elements[x].key && !vlEntity.elements[x].target );
+            const keys = Object.keys(vlEntity.elements).filter( x => vlEntity.elements[x].key && !vlEntity.elements[x].target );
             if (keys.length === 0) {
               message('odata-anno-preproc', [...location, anno], { anno, name: enameFull, '#': 'vhlnokey' });
               return false;
@@ -231,13 +228,13 @@ function preprocessAnnotations(csn, serviceName, options) {
             // OR
             //   the (single) non-key string field, if there is one
             let textField = null;
-            let Identification = vlEntity['@UI.Identification'];
+            const Identification = vlEntity['@UI.Identification'];
             if (Identification && Identification[0] && Identification[0]['=']) {
               textField = Identification[0]['='];
             } else if (Identification && Identification[0] && Identification[0]['Value'] && Identification[0]['Value']['=']) {
               textField = Identification[0]['Value']['='];
             } else {
-              let stringFields = Object.keys(vlEntity.elements).filter(
+              const stringFields = Object.keys(vlEntity.elements).filter(
                 x => !vlEntity.elements[x].key && vlEntity.elements[x].type === 'cds.String')
               if (stringFields.length === 1)
                 textField = stringFields[0];
@@ -259,7 +256,7 @@ function preprocessAnnotations(csn, serviceName, options) {
               }
             }
 
-            let newObj = Object.create( Object.getPrototypeOf(carrier) );
+            const newObj = Object.create( Object.getPrototypeOf(carrier) );
             Object.keys(carrier).forEach( e => {
               if (e === '@Common.ValueList.entity' || e === '@Common.ValueList.viaAssociation') {
                 newObj['@Common.ValueList.Label'] = label;
@@ -289,7 +286,7 @@ function preprocessAnnotations(csn, serviceName, options) {
         }
       }
 
-      function textArrangementReordering(carrier, aName, aNameWithoutQualifier) {
+      function textArrangementReordering(aName, aNameWithoutQualifier) {
         if (aNameWithoutQualifier === '@Common.TextArrangement') {
           let value = carrier[aName];
           let textAnno = carrier['@Common.Text'];

package/lib/edm/csn2edm.js

@@ -27,6 +27,7 @@ function csn2edm(_csn, serviceName, _options) {
 function csn2edmAll(_csn, _options, serviceNames=undefined) {
   // get us a fresh model copy that we can work with
   const csn = cloneCsnNonDict(_csn, _options);
+  const special$self = !csn?.definitions?.$self && '$self';
 
   // use original options for messages; cloned CSN for semantic location
   const messageFunctions = makeMessageFunction(csn, _options, 'to.edmx');
@@ -459,7 +460,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
 
           if(!edmUtils.isODataSimpleIdentifier(p._edmAttributes.Name))
             message('odata-spec-violation-id', pLoc, { id: p._edmAttributes.Name });
-          else if (options.isV2() && /^(_|[0-9])/.test(p._edmAttributes.Name)) {
+          else if (options.isV2() && /^(_|\d)/.test(p._edmAttributes.Name)) {
             // FIXME: Rewrite signalIllegalIdentifier function to be more flexible
             message('odata-spec-violation-id', pLoc,
             { prop: p._edmAttributes.Name[0], id: p._edmAttributes.Name, version: '2.0', '#': 'v2firstchar' });
@@ -662,19 +663,59 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         const actionNode = (iAmAnAction) ? new Edm.Action(v, attributes)
                                       : new Edm.FunctionDefinition(v, attributes);
 
+        const bpType = entityCsn ? fullQualified(entityCsn.name) : undefined;
+        /*
+        Check for binding $self parameter. If available, use this parameter
+        instead of artifically created binding parameter (hasBindingParameter).
+        The binding parameter remains in the CSN and is rendered as any other
+        parameter (including default value/not null/ etc) and acts as annotation carrier.
+        */
+        setProp(actionCsn, '$hasBindingParam', false);
+        if(actionCsn.params) {
+          const entries =  Object.entries(actionCsn.params);
+          const firstParam = entries[0][1];
+          const type = firstParam?.items?.type || firstParam?.type;
+          if(type === special$self) {
+            actionCsn.$hasBindingParam = true;
+            const bpName = entries[0][0];
+            if(bpType) {
+              if(firstParam.items?.type)
+                firstParam.items.type = bpType;
+              if(firstParam.type)
+                firstParam.type = bpType;
+            }
+            if(!edmUtils.isODataSimpleIdentifier(bpName))
+              message('odata-spec-violation-id', [ ...loc, 'params', bpName ], { id: bpName });
+          }
+        }
+
         // bpName is eventually used later for EntitySetPath
         const bpNameAnno = actionCsn['@cds.odata.bindingparameter.name'];
-        const bpName = bpNameAnno !== undefined ? (bpNameAnno['='] || bpNameAnno) : 'in';
-
+        let bpName = 'in';
+        if(bpNameAnno != null) {
+          if(typeof bpNameAnno === 'string')
+            bpName = bpNameAnno;
+          if(typeof bpNameAnno === 'object' && bpNameAnno['='])
+            bpName = bpNameAnno['='];
+        }
+        // No explicit binding parameter, check (user defined) annotation value)
+        if(!actionCsn.$hasBindingParam) {
+          if(!edmUtils.isODataSimpleIdentifier(bpName))
+            message('odata-spec-violation-id', [...loc, '@cds.odata.bindingparameter.name'], { id: bpName });
+          if(actionCsn.params && actionCsn.params[bpName]) {
+            error('duplicate-definition', [...loc, '@cds.odata.bindingparameter.name'], { '#': 'param', name: bpName });
+          }
+        }
         if(entityCsn != undefined)
         {
           actionNode.setEdmAttribute('IsBound', true);
-          const bpType = fullQualified(entityCsn.name);
-          // Binding Parameter: 'in' at first position in sequence, this is decisive!
-          if(actionCsn['@cds.odata.bindingparameter.collection'])
-            actionNode.append(new Edm.Parameter(v, { Name: bpName, Type: bpType, Collection:true } ));
-          else
+          if(!actionCsn.$hasBindingParam) {
+            // Binding Parameter: 'in' at first position in sequence, this is decisive!
+            if(actionCsn['@cds.odata.bindingparameter.collection'])
+              actionNode.append(new Edm.Parameter(v, { Name: bpName, Type: bpType, Collection:true/*, Nullable: false*/ } ));
+            else
             actionNode.append(new Edm.Parameter(v, { Name: bpName, Type: bpType } ));
+          }
         }
         else if(EntityContainer)// unbound => produce Action/FunctionImport
         {
@@ -788,25 +829,33 @@ 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
-        actionCsn.params && Object.entries(actionCsn.params).forEach(([parameterName, parameterCsn]) => {
-          const pLoc = [...loc, 'params', parameterName];
-          const param = new Edm.Parameter(v, { Name: parameterName }, parameterCsn, 'In' );
-          collectUsedType(parameterCsn);
-          edmTypeCompatibilityCheck(param, pLoc);
-          if(!edmUtils.isODataSimpleIdentifier(parameterName))
-            message('odata-spec-violation-id', pLoc, { id: parameterName });
+        actionCsn.params && Object.entries(actionCsn.params).forEach(([parameterName, parameterCsn], i) => {
+          const type = parameterCsn?.items?.type || parameterCsn?.type;
+          if(i === 0 && type === special$self) {
+            // skip and remove the first parameter if it is a $self binding parameter to
+            // omit annotation rendering later on
+            delete actionCsn.params[parameterName];
+          }
+          else {
+            const pLoc = [...loc, 'params', parameterName];
+            const param = new Edm.Parameter(v, { Name: parameterName }, parameterCsn, 'In' );
+            collectUsedType(parameterCsn);
+            edmTypeCompatibilityCheck(param, pLoc);
+            if(!edmUtils.isODataSimpleIdentifier(parameterName))
+              message('odata-spec-violation-id', pLoc, { id: parameterName });
 
           // only scalar or structured type in V2 (not entity)
-          if(param._type &&
+            if(param._type &&
             !param._type.startsWith('Edm.') &&
             csn.definitions[param._type] &&
             !edmUtils.isStructuredType(csn.definitions[param._type]))
-            message('odata-spec-violation-param', pLoc, { version: '2.0' });
+              message('odata-spec-violation-param', pLoc, { version: '2.0' });
 
-          if(param._isCollection)
-            message('odata-spec-violation-array', pLoc, { version: '2.0' });
+            if(param._isCollection)
+              message('odata-spec-violation-array', pLoc, { version: '2.0' });
 
-          functionImport.append(param);
+            functionImport.append(param);
+          }
         });
 
         if(EntityContainer)
@@ -995,7 +1044,6 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         }
         edm._service._schemas[targetSchema]._annotations.push(anno);
       });
-      annos = [];
 
       // create service cross reference and merge it into xServiceRefs
       xrefs.forEach(xr => {

package/lib/edm/edm.js

@@ -1380,8 +1380,8 @@ function getEdm(options, messageFunctions) {
   {
     toJSONattributes(json)
     {
-      if(this._edmAttributes.Type)
-        json['@type'] = this._edmAttributes.Type;
+      if(this._jsonOnlyAttributes.Type)
+        json['@type'] = this._jsonOnlyAttributes.Type;
       let keys = Object.keys(this._edmAttributes).filter(k => k !== 'Type');
       for(const key of keys)
         json['$'+key] = this._edmAttributes[key];

package/lib/edm/edmInboundChecks.js

@@ -1,13 +1,12 @@
 'use strict';
 
 const { setProp, isBetaEnabled } = require('../base/model');
-const { 
-  forEachDefinition, forEachMemberRecursively, getUtils,
+const {
+  forEachDefinition, forEachMemberRecursively,
 } = require('../model/csnUtils');
 
 // eslint-disable-next-line no-unused-vars
-function resolveForeignKeyRefs(csn) {
-  const csnUtils = getUtils(csn);
+function resolveForeignKeyRefs(csn, csnUtils) {
   forEachDefinition(csn, (def, defName) => {
     let currPath = ['definitions', defName ];
     forEachMemberRecursively(def, (construct, _constructName, _prop, path) => {
@@ -21,9 +20,8 @@ function resolveForeignKeyRefs(csn) {
 }
 
 
-function inboundQualificationChecks(csn, options, messageFunctions, 
-  serviceRootNames, requestedServiceNames, isMyServiceRequested, whatsMyServiceRootName) {
-  const csnUtils = getUtils(csn);
+function inboundQualificationChecks(csn, options, messageFunctions,
+  serviceRootNames, requestedServiceNames, isMyServiceRequested, whatsMyServiceRootName, csnUtils) {
   const { message, throwWithError } = messageFunctions;
 
   forEachDefinition(csn, [ attach$path, checkChainedArray ]);
@@ -82,4 +80,4 @@ function inboundQualificationChecks(csn, options, messageFunctions,
   }
 }
 
-module.exports = { inboundQualificationChecks }
+module.exports = { inboundQualificationChecks }