@sap/cds-compiler 5.8.2 → 5.9.2

package/lib/edm/annotations/genericTranslation.js

@@ -33,7 +33,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
 
   allKnownVocabularies.push(...Object.keys(mergedVocDefs));
   allKnownVocabularies.sort((a, b) => b.length - a.length);
-  const whatsMyTermNamespace = anno => allKnownVocabularies.reduce((rc, ns) => (!rc && anno && anno.startsWith(`@${ns}.`) ? ns : rc), undefined);
+  const whatsMyTermNamespace = anno => allKnownVocabularies.reduce((rc, ns) => (!rc && anno && anno.startsWith(`@${ ns }.`) ? ns : rc), undefined);
 
   // annotation preprocessing
   preprocessAnnotations.preprocessAnnotations(reqDefs, serviceName, options, messageFunctions);
@@ -57,7 +57,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
   }
 
   forEachDefinition(reqDefs, (def, defName) => {
-    if (defName.startsWith(`${serviceName}.`))
+    if (defName.startsWith(`${ serviceName }.`))
       assignParameterAnnotations(def);
   });
 
@@ -67,11 +67,11 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
   // Note: we assume that all objects lie flat in the service, i.e. objName always
   //       looks like <service name, can contain dots>.<id>
   forEachDefinition(reqDefs, (def, defName) => {
-    if (defName === serviceName || defName.startsWith(`${serviceName}.`)) {
+    if (defName === serviceName || defName.startsWith(`${ serviceName }.`)) {
       const location = [ 'definitions', defName ];
       // the <objName> is not the carrier name for <objName>Type
       // and sometimes the object.name doesn't have a service prefix
-      if (def.name && def.name.startsWith(`${serviceName}.`))
+      if (def.name && def.name.startsWith(`${ serviceName }.`))
         defName = def.name;
       if (def.kind === 'action' || def.kind === 'function')
         handleAction(defName, def, null, location);
@@ -161,15 +161,15 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
           const [ prefix, innerAnnotation ] = attr.split('.@');
           const ns = whatsMyTermNamespace(prefix);
           if (ns) {
-            const steps = prefix.replace(`@${ns}.`, '').split('.');
+            const steps = prefix.replace(`@${ ns }.`, '').split('.');
             const paramAnnoParts = steps[0].split('#$parameters');
-            const dictTerm = getDictTerm(`${ns}.${paramAnnoParts[0]}`, options);
+            const dictTerm = getDictTerm(`${ ns }.${ paramAnnoParts[0] }`, options);
             if (paramAnnoParts.length > 1 ||
                 [ 'Singleton', 'EntitySet' ].some(y => dictTerm?.AppliesTo?.includes(y))) {
-              steps[0] = `@${ns}.${paramAnnoParts.join('')}`;
+              steps[0] = `@${ ns }.${ paramAnnoParts.join('') }`;
               let newAnno = steps.join('.');
               if (innerAnnotation)
-                newAnno += `.@${innerAnnotation}`;
+                newAnno += `.@${ innerAnnotation }`;
               edmUtils.assignAnnotation(def, newAnno, def._origin[attr]);
               transformAnnotationExpression(def._origin, attr, scopeCheck, def._origin.$path);
               if (paramAnnoParts.length > 1)
@@ -227,7 +227,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
     // definition bound element annotations
     if (def.$elementsAnnoProxies) {
       Object.entries(def.$elementsAnnoProxies).forEach(([ elemPath, element ]) => {
-        const edmTargetName = `${defName}/${elemPath}`;
+        const edmTargetName = `${ defName }/${ elemPath }`;
         handleAnnotations(edmTargetName, element,
                           {
                             location: element.$path,
@@ -238,7 +238,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
     // element bound annotations
     if (def.elements) {
       Object.entries(def.elements).forEach(([ elemName, element ]) => {
-        const edmTargetName = `${defName}/${elemName}`;
+        const edmTargetName = `${ defName }/${ elemName }`;
         const eLocation = [ ...location, 'elements', elemName ];
         handleAnnotations(edmTargetName, element, { location: eLocation });
       });
@@ -267,7 +267,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
 
     Object.entries(cObject.actions).forEach(([ n, action ]) => {
       setProp(action, '$isBound', true);
-      const actionName = `${serviceName}.${isV2() ? `${entityName}_` : ''}${n}`;
+      const actionName = `${ serviceName }.${ isV2() ? `${ entityName }_` : '' }${ n }`;
       handleAction(actionName, action, cObjectname, [ ...location, 'actions', n ]);
     });
   }
@@ -283,7 +283,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
     if (isV2()) { // Replace up to last dot with <serviceName>.EntityContainer
       const lastDotIndex = actionName.lastIndexOf('.');
       if (lastDotIndex > -1)
-        actionName = `${serviceName}.EntityContainer/${actionName.substring(lastDotIndex + 1)}`;
+        actionName = `${ serviceName }.EntityContainer/${ actionName.substring(lastDotIndex + 1) }`;
     }
     else { // add parameter type list
       actionName += relParList();
@@ -296,7 +296,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
         Object.entries(cAction.$paramsAnnoProxies).forEach(([ paramPath, param ]) => {
           // skip explicit binding parameter in V2
           if (!(options.isV2() && param.type === '$self' && paramPath === cAction.$bindingParam?.name)) {
-            const edmTargetName = `${actionName}/${paramPath}`;
+            const edmTargetName = `${ actionName }/${ paramPath }`;
             handleAnnotations(edmTargetName, param,
                               {
                                 location: param.$path,
@@ -309,7 +309,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       // explicit binding parameter is removed from params in V2 during
       // createActionV2(), no need to check ;)
       Object.entries(cAction.params).forEach(([ n, p ]) => {
-        const edmTargetName = `${actionName}/${n}`;
+        const edmTargetName = `${ actionName }/${ n }`;
         handleAnnotations(edmTargetName, p,
                           {
                             action: true,
@@ -321,7 +321,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
     if (cAction.returns) {
       if (cAction.$returnsAnnoProxies) {
         Object.entries(cAction.$returnsAnnoProxies).forEach(([ returnsPath, returns ]) => {
-          const edmTargetName = `${actionName}/${returnsPath}`;
+          const edmTargetName = `${ actionName }/${ returnsPath }`;
           handleAnnotations(edmTargetName, returns,
                             {
                               location: returns.$path,
@@ -330,7 +330,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
                             });
         });
       }
-      const edmTargetName = `${actionName}/$ReturnType`;
+      const edmTargetName = `${ actionName }/$ReturnType`;
       setProp(cAction.returns, '$appliesToReturnType', true);
       handleAnnotations(edmTargetName, cAction.returns,
                         {
@@ -349,7 +349,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
             cAction.$bindingParam?.viaAnno) {
           params.push(
             cAction.$bindingParam.items
-              ? `Collection(${entityNameIfBound})`
+              ? `Collection(${ entityNameIfBound })`
               : entityNameIfBound
           );
         }
@@ -360,10 +360,10 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       if (cAction.kind === 'function' && cAction.params) {
         Object.values(cAction.params).forEach((p) => {
           const isArrayType = !p.type && p.items && p.items.type;
-          params.push(isArrayType ? `Collection(${mapType(p.items)})` : mapType(p));
+          params.push(isArrayType ? `Collection(${ mapType(p.items) })` : mapType(p));
         });
       }
-      return `(${params.join(',')})`;
+      return `(${ params.join(',') })`;
 
       function mapType( p ) {
         if (isBuiltinType(p.type)) {
@@ -373,7 +373,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
           const schemaName = options.whatsMySchemaName(p._edmType || p.type);
           // strip the service namespace of from a parameter type
           if (schemaName && schemaName !== options.serviceName)
-            return (p._edmType || p.type).replace(`${options.serviceName}.`, '');
+            return (p._edmType || p.type).replace(`${ options.serviceName }.`, '');
         }
         return p._edmType || p.type;
       }
@@ -571,7 +571,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
         alternativeEdmTargetNameP = carrier.$entitySetName || edmTargetName;
         const lastDotIndex = alternativeEdmTargetNameP.lastIndexOf('.');
         if (lastDotIndex > -1)
-          alternativeEdmTargetNameP = `${serviceName}.EntityContainer/${alternativeEdmTargetNameP.substring(lastDotIndex + 1)}`;
+          alternativeEdmTargetNameP = `${ serviceName }.EntityContainer/${ alternativeEdmTargetNameP.substring(lastDotIndex + 1) }`;
         hasAlternativeCarrierP = carrier.$hasEntitySet;
       }
       else if (carrier.kind === 'type') {
@@ -586,8 +586,8 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
           testToAlternativeEdmTargetP = (x => (x ? x.includes(container) && !carrier.$isBound : true));
           const lastDotIndex = carrier.name.lastIndexOf('.');
           alternativeEdmTargetNameP = lastDotIndex > -1
-            ? `${serviceName}.EntityContainer/${carrier.name.substring(lastDotIndex + 1)}`
-            : `${serviceName}.EntityContainer/${carrier.name}`;
+            ? `${ serviceName }.EntityContainer/${ carrier.name.substring(lastDotIndex + 1) }`
+            : `${ serviceName }.EntityContainer/${ carrier.name }`;
           hasAlternativeCarrierP = true;
         }
         if (options.isV2())
@@ -604,7 +604,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
         // or AppliesTo=[Schema, EntityContainer]
         (x.includes('Schema') && x.includes('EntityContainer')))
           : true) );
-        stdEdmTargetNameP = `${edmTargetName}.EntityContainer`;
+        stdEdmTargetNameP = `${ edmTargetName }.EntityContainer`;
         alternativeEdmTargetNameP = edmTargetName;
         hasAlternativeCarrierP = true; // EntityContainer is always available
       }
@@ -690,14 +690,14 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
         if (innerAnnotation) {
           // != null => also != undefined
           if (carrier[prefix] != null) {
-            const valPrefix = `${prefix}.$value`;
+            const valPrefix = `${ prefix }.$value`;
             carrier[valPrefix] = carrier[prefix];
             delete carrier[prefix];
             rc = true;
           }
-          const edmJsonPrefix = `${prefix}.$edmJson`;
+          const edmJsonPrefix = `${ prefix }.$edmJson`;
           if (carrier[edmJsonPrefix] != null) {
-            const valPrefix = `${prefix}.$value.$edmJson`;
+            const valPrefix = `${ prefix }.$value.$edmJson`;
             carrier[valPrefix] = carrier[edmJsonPrefix];
             delete carrier[edmJsonPrefix];
             rc = true;
@@ -726,7 +726,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       // takes care of assigning these annotations to the record members
         const [ prefix, innerAnnotation ] = a.split('.@');
         const ns = whatsMyTermNamespace(prefix);
-        const steps = prefix.replace(`@${ns}.`, '').split('.');
+        const steps = prefix.replace(`@${ ns }.`, '').split('.');
         steps.splice(0, 0, ns);
         let i = steps.lastIndexOf('$edmJson');
         if (i > -1) {
@@ -738,13 +738,13 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
           // A voc annotation has two steps (Namespace+Name),
           // any further steps need to be rendered separately
           if (innerAnnotation.startsWith('sap.')) {
-            steps.push(`@${innerAnnotation}`);
+            steps.push(`@${ innerAnnotation }`);
           }
           else {
             const innerAnnoSteps = innerAnnotation.split('.');
             const tailSteps = innerAnnoSteps.splice(2, innerAnnoSteps.length - 2);
             // prepend annotation prefix (path) to tail steps
-            tailSteps.splice(0, 0, `@${innerAnnoSteps.join('.')}`);
+            tailSteps.splice(0, 0, `@${ innerAnnoSteps.join('.') }`);
             steps.push(...tailSteps);
           }
         }
@@ -785,7 +785,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
           mergePathStepsIntoPrefixTree(tree[name], pathSteps, index + 1);
         }
         else if (typeof tree === 'object' ) {
-          tree[name] = carrier[`@${pathSteps.join('.')}`];
+          tree[name] = carrier[`@${ pathSteps.join('.') }`];
         }
       }
     }
@@ -802,13 +802,13 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
     // create an annotation tag <Annotation ...> for each term
     for (const voc of Object.keys(prefixTree)) {
       for (const term of Object.keys(prefixTree[voc])) {
-        const fullTermName = `${voc}.${term}`;
+        const fullTermName = `${ voc }.${ term }`;
 
         // msg is "semantic" location message used for messages
         const msg = {
           fullTermName,
           stack: [],
-          location: [ ...location, `@${fullTermName}` ],
+          location: [ ...location, `@${ fullTermName }` ],
         };
         msg.anno = () => msg.fullTermName + msg.stack.join('');
 
@@ -871,7 +871,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       }
       else {
         // message if term is completely unknown or if vocabulary is unchecked
-        const myVocDef = mergedVocDefs[whatsMyTermNamespace(`@${termNameWithoutQualifiers}`)];
+        const myVocDef = mergedVocDefs[whatsMyTermNamespace(`@${ termNameWithoutQualifiers }`)];
         if ((myVocDef?.int && myVocDef?.int?.filename) || !myVocDef)
           message('odata-anno-def', msg.location, { anno: termNameWithoutQualifiers });
       }
@@ -900,7 +900,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       if (isEnumType(dTypeName)) {
         // if we find an array although we expect an enum, this may be a "flag enum"
         checkMultiEnumValue();
-        oTarget.setJSON({ EnumMember: generateMultiEnumValue(false), 'EnumMember@odata.type': `#${dTypeName}` });
+        oTarget.setJSON({ EnumMember: generateMultiEnumValue(false), 'EnumMember@odata.type': `#${ dTypeName }` });
         oTarget.setXml( { EnumMember: generateMultiEnumValue(true) });
       }
       else {
@@ -931,8 +931,8 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
                       {
                         anno: msg.anno(),
                         type: dTypeName,
-                        value: `"#${enumSymbol}"`,
-                        rawvalues: Object.keys(typeDef.$Allowed.Symbols).map(m => `#${m}`),
+                        value: `"#${ enumSymbol }"`,
+                        rawvalues: Object.keys(typeDef.$Allowed.Symbols).map(m => `#${ m }`),
                         '#': 'enum',
                       });
             }
@@ -941,14 +941,14 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
             }
           }
           else if (checkEnumValue(enumSymbol)) {
-            oTarget.setXml( { EnumMember: `${dTypeName}/${enumSymbol}` });
+            oTarget.setXml( { EnumMember: `${ dTypeName }/${ enumSymbol }` });
           }
           else {
             oTarget.setXml( { String: enumSymbol });
           }
         }
         else {
-          oTarget.setXml( { EnumMember: `${oTermName}Type/${enumSymbol}` });
+          oTarget.setXml( { EnumMember: `${ oTermName }Type/${ enumSymbol }` });
         }
         oTarget.setJSON({ 'Edm.String': enumSymbol });
       }
@@ -1014,7 +1014,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
                 {
                   anno: msg.anno(),
                   type: dTypeName,
-                  value: `"#${value}"`,
+                  value: `"#${ value }"`,
                 });
         rc = false;
       }
@@ -1023,8 +1023,8 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
                 {
                   anno: msg.anno(),
                   type: dTypeName,
-                  value: `"#${value}"`,
-                  rawvalues: expectedType.Members.map(m => `#${m}`),
+                  value: `"#${ value }"`,
+                  rawvalues: expectedType.Members.map(m => `#${ m }`),
                   '#': 'enum',
                 });
       }
@@ -1049,7 +1049,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
 
       let index = 0;
       for (const value of cAnnoValue) {
-        msg.stack.push(`[${index}]`);
+        msg.stack.push(`[${ index }]`);
         index++;
         if (value['#']) {
           checkEnumValue(value['#']);
@@ -1060,7 +1060,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
                     anno: msg.anno(),
                     type: dTypeName,
                     value: value['='] || value,
-                    rawvalues: type.Members.map(m => `#${m}`),
+                    rawvalues: type.Members.map(m => `#${ m }`),
                     '#': 'enum',
                   });
         }
@@ -1072,7 +1072,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       // remove all invalid entries (warnining message has already been issued)
       // replace short enum name by the full name
       // concatenate all the enums to a string, separated by spaces
-      return cAnnoValue.filter( x => x['#']).map( x => (forXml ? `${dTypeName}/` : '') + x['#'] ).join(forXml ? ' ' : ',');
+      return cAnnoValue.filter( x => x['#']).map( x => (forXml ? `${ dTypeName }/` : '') + x['#'] ).join(forXml ? ' ' : ',');
     }
   }
 
@@ -1120,7 +1120,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
 
     if (isEnumType(resolvedType)) {
       const type = getDictType(resolvedType);
-      const expected = type.Members.map(m => `#${m}`);
+      const expected = type.Members.map(m => `#${ m }`);
       message('odata-anno-value', msg.location,
               {
                 anno: msg.anno(),
@@ -1334,7 +1334,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
         // Set full qualified type in JSON
         // TODO: Adhoc type x-ref URIs (only if abstract types are allowed in CDS)
         if (myVocDef)
-          newRecord.setJSON( { Type: `${myVocDef.ref.Uri}#${actualTypeName}` });
+          newRecord.setJSON( { Type: `${ myVocDef.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.
@@ -1372,7 +1372,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
 
     // loop over elements
     for (const name of Object.keys(obj)) {
-      msg.stack.push(`.${name}`);
+      msg.stack.push(`.${ name }`);
 
       if (name === '$Type') {
         // ignore, this is an "artificial" property used to indicate the type
@@ -1420,7 +1420,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
 
     let index = 0;
     for (const value of annoValue) {
-      msg.stack.push(`[${index}]`);
+      msg.stack.push(`[${ index }]`);
       index++;
 
       // for dealing with the single array entries we unfortunately cannot call handleValue(),
@@ -1514,7 +1514,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
 
           if ((annoDef.items?.enum || annoDef.enum) && isBuiltinType(annoDef.items?.type || annoDef.type)) {
             const enumType = createTypeDefWithAllowedValues(annoDef, annoDef, dictDef.Type, [ 'vocabularies', termName ]);
-            const tName = `${termName}_$$$EnumType$$$$`;
+            const tName = `${ termName }_$$$EnumType$$$$`;
             dict.types[tName] = enumType;
             dictDef.Type = tName;
           }
@@ -1531,7 +1531,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       // for type reuse in x-ref mode, the definition has already been
       // replaced by a reference object in edmPreprocessor.
       // Fall back to original type (the one of the other service).
-      const typeDef = reqDefs.definitions[typeName] || reqDefs.definitions[typeName.replace(`${serviceName}.`, '')];
+      const typeDef = reqDefs.definitions[typeName] || reqDefs.definitions[typeName.replace(`${ serviceName }.`, '')];
       if (typeDef) {
         let dictDef = { };
         const elements = typeDef.items?.elements || typeDef.elements;
@@ -1612,10 +1612,10 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
         if (!hasNSPrefix)
           paths.splice(0, 0, serviceName);
 
-        const fqName = `@${paths.join('.')}`;
+        const fqName = `@${ paths.join('.') }`;
         const i = paths[1].indexOf('#');
         const termNameWithoutQualifiers = i > 0 ? paths[1].substring(0, i) : paths[1];
-        const def = reqDefs.definitions[`${paths[0]}.${termNameWithoutQualifiers}`];
+        const def = reqDefs.definitions[`${ paths[0] }.${ termNameWithoutQualifiers }`];
         // if there is a term definition inside the service and the
         // annotation value is != null, then add the annotation to the list
         // of known annotations
@@ -1647,7 +1647,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
   function getDictTerm( termName, msg ) {
     const dict = options.dictReplacement || oDataDictionary; // tests can set different dictionary via options
     const dictTerm = (dict.terms[termName] ||
-          userDefinedTermDict.terms[`${serviceName}.${termName}`] ||
+          userDefinedTermDict.terms[`${ serviceName }.${ termName }`] ||
           userDefinedTermDict.terms[termName]);
     // register vocabulary usage if possible
     const vocName = termName.slice(0, termName.indexOf('.'));
@@ -1676,7 +1676,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
   function getDictType( typeName ) {
     const dict = options.dictReplacement || oDataDictionary; // tests can set different dictionary via options
     const dictType = (dict.types[typeName] ||
-          userDefinedTermDict.types[`${serviceName}.${typeName}`] ||
+          userDefinedTermDict.types[`${ serviceName }.${ typeName }`] ||
           userDefinedTermDict.types[typeName]);
     if (dictType) {
       // register usage of vocabulary

package/lib/edm/annotations/preprocessAnnotations.js

@@ -57,7 +57,7 @@ function preprocessAnnotations( csn, serviceName, options, messageFunctions ) {
   function resolveShortcuts() {
     forEachDefinition(csn, (artifact, artifactName) => {
       const location = [ 'definitions', artifactName ];
-      if (artifactName === serviceName || artifactName.startsWith(`${serviceName}.`)) {
+      if (artifactName === serviceName || artifactName.startsWith(`${ serviceName }.`)) {
         handleAnnotations(artifactName, artifactName, artifact, location);
         if (artifact.elements) {
           Object.entries(artifact.elements).forEach(([ elementName, element ]) => {
@@ -113,14 +113,14 @@ function preprocessAnnotations( csn, serviceName, options, messageFunctions ) {
           if (value === 'draftPrepare' || value === 'draftActivate' || value === 'draftEdit') {
             // mocha test has no whatsMySchemaName
             const schemaName = options.whatsMySchemaName && options.whatsMySchemaName(carrierName) || serviceName;
-            carrier[aName] = `${schemaName}.${value}`;
+            carrier[aName] = `${ schemaName }.${ value }`;
             value = carrier[aName];
           }
           // 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
           if (isV2()) {
             const entityNameShort = carrierName.split('.').pop();
-            carrier[aName] = value.replace(/(draft(Prepare|Activate|Edit))$/, (match, p1) => `EntityContainer/${entityNameShort}_${p1}`);
+            carrier[aName] = value.replace(/(draft(Prepare|Activate|Edit))$/, (match, p1) => `EntityContainer/${ entityNameShort }_${ p1 }`);
           }
         }
       }
@@ -186,7 +186,7 @@ function preprocessAnnotations( csn, serviceName, options, messageFunctions ) {
               // mocha test has no whatsMySchemaName
               const schemaName = options.whatsMySchemaName && options.whatsMySchemaName(defName) || serviceName;
               enameShort = annoVal['='] || annoVal;
-              enameFull = `${schemaName}.${enameShort}`;
+              enameFull = `${ schemaName }.${ enameShort }`;
             }
 
             const vlEntity = csn.definitions[enameFull]; // (object) value list entity
@@ -214,7 +214,7 @@ function preprocessAnnotations( csn, serviceName, options, messageFunctions ) {
             if (carrier['@cds.api.ignore']) {
               const assocName = carrier['@odata.foreignKey4'];
               if (assocName && options.isV4())
-                localDataProp = localDataProp.replace(assocName + fkSeparator, `${assocName}/`);
+                localDataProp = localDataProp.replace(assocName + fkSeparator, `${ assocName }/`);
             }
 
             // valueListProp: the (single) key field of the value list entity

package/lib/edm/csn2edm.js

@@ -170,7 +170,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
       -----------------------------------------------*/
     let LeadSchema;
     const fqSchemaXRef = [ serviceCsn.name ];
-    const whatsMySchemaName = n => fqSchemaXRef.reduce((acc, sn) => (!acc && n && n.startsWith(`${sn}.`) ? sn : acc), undefined);
+    const whatsMySchemaName = n => fqSchemaXRef.reduce((acc, sn) => (!acc && n && n.startsWith(`${ sn }.`) ? sn : acc), undefined);
 
     // tunnel schema xref and servicename in options to edm.Typebase to rectify
     // type references that are eventually also prefixed with the service schema name.
@@ -205,13 +205,13 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
       // Add additional schema containers as sub contexts to the service
       forEach(allSchemas, (fqName, art) => {
         if (serviceCsn.name === whatsMyServiceRootName(fqName) &&
-          fqName.startsWith(`${serviceCsn.name}.`)) {
+          fqName.startsWith(`${ serviceCsn.name }.`)) {
           if (art.kind === 'reference')
             fqSchemaXRef.push(fqName);
           if (art.kind === 'schema') {
             fqSchemaXRef.push(fqName);
             // Strip the toplevel service schema name (see comment above)
-            const name = fqName.replace(`${serviceCsn.name}.`, '');
+            const name = fqName.replace(`${ serviceCsn.name }.`, '');
             subSchemaDictionary[name] = {
               name,
               fqName,
@@ -298,8 +298,8 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
             - not a type clash (reported in type exposure),
             - a @cds.external service member but can't be rendered
         */
-        if (!typeName.startsWith(`${serviceCsn.name}.`))
-          iTypeName = `${serviceCsn.name}.${typeName}`;
+        if (!typeName.startsWith(`${ serviceCsn.name }.`))
+          iTypeName = `${ serviceCsn.name }.${ typeName }`;
         const def = reqDefs.definitions[iTypeName];
 
         const usages = UsedTypes[typeName].filter(u => !u.$NameClashReported);
@@ -355,9 +355,9 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
           // except if the schema name is the service name itself.
           // Proxy names are not prefixed, as they need to be reused.
           if (mySchemaName !== serviceCsn.name) {
-            art.name = fqName.replace(`${serviceCsn.name}.`, '');
+            art.name = fqName.replace(`${ serviceCsn.name }.`, '');
             fqName = art.name;
-            mySchemaName = mySchemaName.replace(`${serviceCsn.name}.`, '');
+            mySchemaName = mySchemaName.replace(`${ serviceCsn.name }.`, '');
           }
           schemas[mySchemaName].definitions[fqName] = art;
         }
@@ -422,7 +422,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
       const Schema = new Edm.Schema(v, schema.name, undefined /* unset alias */, schema._csn, /* annotations */ [], schema.container);
       const EntityContainer = Schema._ec || (LeadSchema && LeadSchema._ec);
       // now namespace and alias are used to create the fullQualified(name)
-      const schemaNamePrefix = `${schema.name}.`;
+      const schemaNamePrefix = `${ schema.name }.`;
       const schemaAliasPrefix = schemaNamePrefix;
       const schemaCsn = schema;
       const navigationProperties = [];
@@ -502,7 +502,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
 
       forEach(NamesInSchemaXRef, ( name, refs ) => {
         if (refs.length > 1) {
-          error(null, [ 'definitions', `${Schema._edmAttributes.Namespace}.${name}` ], { name: Schema._edmAttributes.Namespace },
+          error(null, [ 'definitions', `${ Schema._edmAttributes.Namespace }.${ name }` ], { name: Schema._edmAttributes.Namespace },
                 'Duplicate name in Schema $(NAME)');
         }
       });
@@ -516,7 +516,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
         const [ properties, hasStream ] = createProperties(entityCsn);
 
         const location = reqDefs.definitions[entityCsn.name] ? [ 'definitions', entityCsn.name ] : entityCsn.$path;
-        const type = `${schema.name}.${EntityTypeName}`;
+        const type = `${ schema.name }.${ EntityTypeName }`;
         if (properties.length === 0)
           warning(null, location, { type }, 'EDM EntityType $(TYPE) has no properties');
         // only if this entity has an entity set, it is required to have a key
@@ -900,7 +900,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
         if (entityCsn) {
           // Make bound function names always unique as per Ralf's recommendation
           functionImport.setXml( { 'sap:action-for': fullQualified(entityCsn.name) } );
-          const entityName = `${entityCsn.name.replace(schemaNamePrefix, '')}_${functionImport._edmAttributes.Name}`;
+          const entityName = `${ entityCsn.name.replace(schemaNamePrefix, '') }_${ functionImport._edmAttributes.Name }`;
           functionImport.setEdmAttribute('Name', entityName);
 
           // Binding Parameter: Primary Keys at first position in sequence, this is decisive!
@@ -915,7 +915,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
         // is this still required?
         forEach(actionCsn, ( key, val ) => {
           if (key.match(/^@sap\./))
-            functionImport.setXml( { [`sap:${key.slice(5).replace(/\./g, '-')}`]: val });
+            functionImport.setXml( { [`sap:${ key.slice(5).replace(/\./g, '-') }`]: val });
         });
         // then append all other parameters
         // V2 XML: Parameters that are not explicitly marked as Nullable or NotNullable in the CSN must become Nullable=true
@@ -982,7 +982,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
                 }
               }
               if (action.returns.$isCollection)
-                type = `Collection(${type})`;
+                type = `Collection(${ type })`;
             }
             else {
               // type is missing
@@ -1014,7 +1014,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
         let assocName = plainAssocName;
         let i = 1;
         while (NamesInSchemaXRef[assocName] !== undefined)
-          assocName = `${plainAssocName}_${i++}`;
+          assocName = `${ plainAssocName }_${ i++ }`;
 
 
         let fromRole = parentName;
@@ -1068,7 +1068,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
           assocName = plainAssocName;
           i = 1;
           while (NamesInSchemaXRef[assocName] !== undefined && !(NamesInSchemaXRef[assocName][0] instanceof Edm.Association))
-            assocName = `${plainAssocName}_${i++}`;
+            assocName = `${ plainAssocName }_${ i++ }`;
 
 
           navigationProperty.setEdmAttribute('Relationship', fullQualified(assocName));
@@ -1136,7 +1136,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
         if (targetSchema === undefined)
           targetSchema = serviceCsn.name;
         if (targetSchema !== serviceCsn.name) {
-          const newTarget = anno._edmAttributes.Target.replace(`${serviceCsn.name}.`, '');
+          const newTarget = anno._edmAttributes.Target.replace(`${ serviceCsn.name }.`, '');
           anno.setEdmAttribute('Target', newTarget);
         }
         edm._service._schemas[targetSchema]._annotations.push(anno);