@sap/cds-compiler 4.7.6 → 4.9.0

package/lib/transform/odata/typesExposure.js

@@ -8,8 +8,9 @@
 
 const { setProp, isBetaEnabled } = require('../../base/model');
 const { defNameWithoutServiceOrContextName, isArtifactInService } = require('./utils');
-const { getNamespace, copyAnnotations, isBuiltinType, findAnnotationExpression,
+const { getNamespace, copyAnnotations, findAnnotationExpression,
   forEachDefinition, forEachMember, forEachGeneric, isEdmPropertyRendered } = require('../../model/csnUtils');
+const { isBuiltinType } = require('../../base/builtins');
 const { CompilerAssertion } = require('../../base/error');
 const { cloneCsnNonDict } = require('../../model/cloneCsn');
 
@@ -76,18 +77,21 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
     if (serviceName && requestedServiceNames.includes(serviceName)) {
       if (def.kind === 'type' || def.kind === 'entity') {
         forEachMember(def, (element, elementName, propertyName, path) => {
-          if (propertyName === 'elements' || propertyName === 'params') {
+          if (propertyName === 'elements') {
             const newTypeName = getNewTypeName(element, elementName, defName, serviceName);
-            exposeTypeOf(element, element.key || propertyName === 'params', elementName, defName, serviceName, newTypeName, path);
+            exposeTypeOf(element, element.key, elementName, defName, serviceName, newTypeName, defName, path);
+          } else if (propertyName === 'params') {
+            const newTypeName = getNewTypeName(element, elementName, `ep_${defName.replace(/\./g, '_')}`, serviceName);
+            exposeTypeOf(element, true, elementName, defName, serviceName, newTypeName, defName, path);
           }
         }, path);
       }
 
       if (def.kind === 'action' || def.kind === 'function') {
-        exposeTypesOfAction(def, defName, defName, serviceName, path);
+        exposeTypesOfAction(def, defName, defName, serviceName, path, false);
       }
       def.actions && Object.entries(def.actions).forEach(([actionName, action]) => {
-        exposeTypesOfAction(action, `${defName}_${actionName}`, defName, serviceName, path.concat(['actions', actionName]));
+        exposeTypesOfAction(action, `${defName}_${actionName}`, defName, serviceName, path.concat(['actions', actionName]), true);
       });
     }
   });
@@ -105,7 +109,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
           csn.definitions[defName] = def;
           const artificialName = `term_${defName.replace(/\./g, '_')}`;//_${paramName}`;
           const newTypeName = getNewTypeName(undefined, undefined, artificialName, serviceName);
-          exposeTypeOf(def, false, defName, defName, serviceName, newTypeName, path.concat(['vocabularies', defName]), undefined, true);
+          exposeTypeOf(def, false, defName, defName, serviceName, newTypeName, defName, path.concat(['vocabularies', defName]), undefined, true);
         }
       }
     });
@@ -121,17 +125,17 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
    * @param {String} actionName
    * @param {String} serviceName
    */
-  function exposeTypesOfAction(action, actionName, defName, serviceName, path) {
+  function exposeTypesOfAction(action, actionName, defName, serviceName, path, isBound) {
     if (action.returns) {
       const artificialName = `return_${actionName.replace(/\./g, '_')}`;
       const newTypeName = getNewTypeName(action.returns, undefined, artificialName, serviceName);
-      exposeTypeOf(action.returns, false, actionName, defName, serviceName, newTypeName, path.concat(['returns']));
+      exposeTypeOf(action.returns, false, actionName, defName, serviceName, newTypeName, defName, path.concat(['returns']));
     }
 
     action.params && Object.entries(action.params).forEach(([paramName, param]) => {
-      const artificialName = `param_${actionName.replace(/\./g, '_')}`;//_${paramName}`;
+      const artificialName = `${isBound ? 'bap' : 'ap'}_${actionName.replace(/\./g, '_')}`;//_${paramName}`;
       const newTypeName = getNewTypeName(param, paramName, artificialName, serviceName);
-      exposeTypeOf(param, false, actionName, defName, serviceName, newTypeName, path.concat(['params', paramName]));
+      exposeTypeOf(param, false, actionName, defName, serviceName, newTypeName, defName, path.concat(['params', paramName]));
     });
   }
 
@@ -144,7 +148,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
    * @param {String} serviceName
    * @param {String} newTypeName
    */
-  function exposeTypeOf(node, isKey, memberName, defName, serviceName, newTypeName, path, parentName, isTermDef=false, ignoreInAPI=false) {
+  function exposeTypeOf(node, isKey, memberName, defName, serviceName, newTypeName, lastNonAnonymousFQDefName, path, parentName, isTermDef=false, ignoreInAPI=false) {
     const { isExposable, typeDef, typeName, elements, isAnonymous } = isTypeExposable();
     if (isExposable) {
       // this is the name used to register the new type in csn.definitions
@@ -164,6 +168,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
         // expose the type as a new one not changing the original definition.
         if(elements && !!node['@open'] !== !!typeDef['@open'])
           fullQualifiedNewTypeName += node['@open'] ? '_open' : '_closed';
+        lastNonAnonymousFQDefName = fullQualifiedNewTypeName;
       }
       // check if that type is already defined
       let newType = csn.definitions[fullQualifiedNewTypeName];
@@ -197,10 +202,12 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
           newType.elements && Object.entries(newType.elements).forEach(([elemName, newElem]) => {
             if (node.elements && node.elements[elemName].$location)
               setProp(newElem, '$location', node.elements[elemName].$location);
+            if (newElem.$path)
+              newElem.$path[1] = lastNonAnonymousFQDefName;
             defName = typeDef.kind === 'type' ? typeName : defName;
             {
               const { isExposable, typeDef, typeName } = exposeTypeOf(newElem, isKey, elemName, defName, serviceName,
-                            getNewTypeName(newElem, elemName, newTypeName, serviceName), path, fullQualifiedNewTypeName, isTermDef, ignoreInAPI);
+                            getNewTypeName(newElem, elemName, newTypeName, serviceName), lastNonAnonymousFQDefName, path, fullQualifiedNewTypeName, isTermDef, ignoreInAPI);
               // if the type for the newElem was not exposed it may be a scalar type def from an external service that hasn't
               // been caught by expandToFinalBaseType() (forODataNew must not modify external imported services)
               if(!isExposable && isBuiltinType(typeName) && !isBuiltinType((newElem.items?.type || newElem.type))) {
@@ -222,14 +229,23 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
             }
           });
 
-          // expression annos and their sub annotations are not propagated to type
-          let [ xprANames, nxprANames ] = Object.keys(typeDef).reduce((acc, pn) => {
-            if (pn[0] === '@')
-              acc[findAnnotationExpression(typeDef, pn) ? 0 : 1].push(pn);
-            return acc;
-          }, [ [], [] ]);
-          nxprANames = nxprANames.filter(an => !xprANames.some(ean => an.startsWith(`${ean}.`)));
-          copyAnnotations(typeDef, newType, false, {}, nxprANames);
+          // TODO: remove the this if and the else clause for the V5 release
+          if (isBetaEnabled(options, 'v5preview')) {
+            // We need this check, as we only need to copy the annotions if the type
+            // is user defined structured type outside of the service
+            if (!isAnonymous) {
+              copyAnnotations(typeDef, newType);
+            }
+          } else {
+            // expression annos and their sub annotations are not propagated to type
+            let [ xprANames, nxprANames ] = Object.keys(typeDef).reduce((acc, pn) => {
+              if (pn[0] === '@')
+                acc[findAnnotationExpression(typeDef, pn) ? 0 : 1].push(pn);
+              return acc;
+            }, [ [], [] ]);
+            nxprANames = nxprANames.filter(an => !xprANames.some(ean => an.startsWith(`${ean}.`)));
+            copyAnnotations(typeDef, newType, false, {}, nxprANames);
+          }
 
           // if the origin type had items, add items to exposed type
           if(typeDef.kind === 'type') {
@@ -241,7 +257,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
         }
         else if(isTermDef) {
           newType = Object.create(null);
-          for(let n in typeDef) {
+          for(const n in typeDef) {
             newType[n] = typeDef[n];
           }
           newType.kind = 'type';
@@ -280,7 +296,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
     function isTypeExposable() {
       let typeName = undefined;
       let typeDef = node;
-      let elements = (node.items?.elements || node.elements)
+      const elements = (node.items?.elements || node.elements)
       // anonymous structured type
       if(elements)
         return { isExposable: true, typeDef, typeName, elements, isAnonymous: true };
@@ -302,7 +318,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
                 typeName = (type.ref && csnUtils.artifactRef(type)) || type;
               }
               else {
-                throw new CompilerAssertion(`Please debug me: ${typeName} not found`);
+                throw new CompilerAssertion(`Debug me: ${typeName} not found`);
               }
             }
           }
@@ -359,7 +375,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
      * @param {string} parentName name of the parent def holding the element
      */
     function getAnonymousTypeNameInMultiSchema(typeName, parentName) {
-      let currPrefix = parentName.substring(0, parentName.lastIndexOf('.'));
+      const currPrefix = parentName.substring(0, parentName.lastIndexOf('.'));
       const newSchemaName = currPrefix || fallBackSchemaName;
       // new type name without any prefixes
       const typePlainName = defNameWithoutServiceOrContextName(typeName, newSchemaName);
@@ -390,7 +406,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
 
       // Duplicate elements
       Object.entries(elements).forEach(([elemName, element]) => {
-        let cloned = cloneCsnNonDict(element, options);
+        const cloned = cloneCsnNonDict(element, options);
         // if this was an anonymous sub element of a key, mark it as not nullable
         if(isAnonymous && isKey && !cloned.key) {
           if(cloned.target) {

package/lib/transform/parseExpr.js

@@ -2,9 +2,6 @@
 
 'use strict'
 
-// const funkyfuncs = Object.keys(require('../compiler/builtins.js').
-//   specialFunctions).filter(n => n.length).map(n=>n.toLowerCase());
-
 /**
  * parseExpr() accepts any JSON object and tries to convert a token stream expression
  * array into an AST like expression with CDL operator precedence.
@@ -61,7 +58,7 @@ function parseExpr(xpr, state = { array: true, nary: false }) {
           return { 'cast': [ xpr.cast, { [castKeys[0]]: xpr[castKeys[0]] } ] };
         }
         else {
-          for(let n in xpr) {
+          for(const n in xpr) {
             // xpr could be an array with polluted prototype
             if (Object.hasOwnProperty.call(xpr, n))
               xpr[n] = Cast(xpr[n], state)
@@ -217,7 +214,7 @@ function parseExpr(xpr, state = { array: true, nary: false }) {
       while(i < e && xpr[i] !== 'and') i++;
       const a = i < e ? i : -1;
       if(b >= 0) {
-        let token = [ 'between' ];
+        const token = [ 'between' ];
         not = (xpr[b-1] === 'not');
         if(not)
           token.splice(0,0, 'not');
@@ -315,7 +312,7 @@ function parseExpr(xpr, state = { array: true, nary: false }) {
     if (typeof xpr === 'object') {
       // if(xpr?.func && funkyfuncs.includes(xpr?.func))
       //   return xpr;
-      for(let n in xpr) {
+      for(const n in xpr) {
         // xpr could be an array with polluted prototype
         if (!Object.hasOwnProperty.call(xpr, n))
           continue;
@@ -352,7 +349,7 @@ function parseExpr(xpr, state = { array: true, nary: false }) {
         s = p+tl;
         [tl, p] = findToken(s, e);
         while(p >= 0) {
-          let rhs = next(xpr, s, p, state);
+          const rhs = next(xpr, s, p, state);
           naryExpr.push(...op, rhs);
           if(state.array)
             lhs = [ lhs, ...op, rhs ];

package/lib/transform/transformUtils.js

@@ -8,10 +8,12 @@ const { setProp } = require('../base/model');
 
 const { copyAnnotations, applyTransformations, isDollarSelfOrProjectionOperand } = require('../model/csnUtils');
 const { getUtils } = require('../model/csnUtils');
-const { typeParameters, isBuiltinType } = require('../compiler/builtins');
+const { typeParameters } = require('../compiler/builtins');
+const { isBuiltinType } = require('../base/builtins');
 const { ModelError, CompilerAssertion} = require('../base/error');
 const { forEach } = require('../utils/objectUtils');
 const { cloneCsnNonDict, cloneCsnDict } = require('../model/cloneCsn');
+const { addTenantFieldToArt } = require('./addTenantFields');
 
 const RestrictedOperators = ['<', '>', '>=', '<='];
 const RelationalOperators = ['=', '!=', '<>', 'is' /*, 'like'*/,...RestrictedOperators];
@@ -160,14 +162,14 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
   // Note that this must happen after struct flattening(flattenStructuredElement) - both fot elements and foreign keys.
   // Return the newly generated foreign key element.
   function createForeignKeyElement(assoc, assocName, foreignKey, artifact, artifactName, path) {
-    let result = {};
+    const result = {};
 
     // FIXME: Duplicate code (postfix is added herein, can this be optimized?)
     // Assemble foreign key element name from assoc name, '_' and foreign key name/alias
-    let foreignKeyElementName = `${assocName.replace(/\./g, pathDelimiter)}${pathDelimiter}${foreignKey.as || foreignKey.ref.join(pathDelimiter)}`;
+    const foreignKeyElementName = `${assocName.replace(/\./g, pathDelimiter)}${pathDelimiter}${foreignKey.as || foreignKey.ref.join(pathDelimiter)}`;
 
 
-    let fkArtifact = inspectRef(path).art;
+    const fkArtifact = inspectRef(path).art;
     newForeignKey(fkArtifact, foreignKeyElementName);
 
     function processAssociationOrComposition(fkArtifact,foreignKeyElementName) {
@@ -186,7 +188,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
         return;
       }
 
-      let foreignKeyElement = createRealFK(fkArtifact, assoc, assocName, foreignKey, path, foreignKeyElementName);
+      const foreignKeyElement = createRealFK(fkArtifact, assoc, assocName, foreignKey, path, foreignKeyElementName);
 
       // FIXME: must this code go into createRealFK?
       // Not present in getForeignKeyArtifact
@@ -227,7 +229,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
   //          length: 42 },
   // }
   function flattenStructuredElement(elem, elemName, parentElementPath=[], pathInCsn=[]) {
-    let elementPath=parentElementPath.concat(elemName); // elementPath contains only element names without the csn structure node names
+    const elementPath=parentElementPath.concat(elemName); // elementPath contains only element names without the csn structure node names
     // in case the element is of user defined type => take the definition of the type
     // for type of 'x' -> elem.type is an object, not a string -> use directly
     let elemType;
@@ -239,7 +241,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
     // Collect all child elements (recursively) into 'result'
     // TODO: Do not report collisions in the generated elements here, but instead
     //       leave that work to the receiver of this result
-    let result = Object.create(null);
+    const result = Object.create(null);
     const addGeneratedFlattenedElement = (e, eName) => {
       if (result[eName])
         error('name-duplicate-element', pathInCsn, { '#': 'flatten-element-gen', name: eName })
@@ -249,10 +251,10 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
     forEach(struct, (childName, childElem) => {
       if (isStructured(childElem)) {
         // Descend recursively into structured children
-        let grandChildElems = flattenStructuredElement(childElem, childName, elementPath, pathInCsn.concat('elements',childName));
-        for (let grandChildName in grandChildElems) {
-          let flatElemName = elemName + pathDelimiter + grandChildName;
-          let flatElem = grandChildElems[grandChildName];
+        const grandChildElems = flattenStructuredElement(childElem, childName, elementPath, pathInCsn.concat('elements',childName));
+        for (const grandChildName in grandChildElems) {
+          const flatElemName = elemName + pathDelimiter + grandChildName;
+          const flatElem = grandChildElems[grandChildName];
           addGeneratedFlattenedElement(flatElem, flatElemName);
           // TODO: check with values. In CSN such elements have only "@Core.Computed": true
           // If the original element had a value, construct one for the flattened element
@@ -263,8 +265,8 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
         }
       } else {
         // Primitive child - clone it and restore its cross references
-        let flatElemName = elemName + pathDelimiter + childName;
-        let flatElem = cloneCsnNonDict(childElem, { ...options, hiddenPropertiesToClone: [ '$structRef', '$fkExtensions' ] } );
+        const flatElemName = elemName + pathDelimiter + childName;
+        const flatElem = cloneCsnNonDict(childElem, { ...options, hiddenPropertiesToClone: [ '$structRef', '$fkExtensions' ] } );
         // Don't take over notNull from leaf elements
         delete flatElem.notNull;
         setProp(flatElem, '_flatElementNameWithDots', elementPath.concat(childName).join('.'));
@@ -300,7 +302,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
       // 'localized' is needed for OData
       if(options.toOdata)
         props.push('localized');
-      for (let p of props) {
+      for (const p of props) {
         if (elem[p]) {
           flatElem[p] = elem[p];
         }
@@ -321,10 +323,12 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
    * @param {object[]} [links] Pre-resolved links for the given ref - if not provided, will be calculated JIT
    * @param {string} [scope] Pre-resolved scope for the given ref - if not provided, will be calculated JIT
    * @param {WeakMap} [resolvedLinkTypes=new WeakMap()] A WeakMap with already resolved types for each link-step - safes an `artifactRef` call
-   * @param {bool} [refParentIsItems] relative ref has an items root (suspend flattening by caller)
+   * @param {bool} [suspend] suspend flattening by caller until association path step
+   * @param {int} [suspendPos] suspend if starting pos is lower or equal to suspendPos and suspend is true
+   * @param {bool} [revokeAtSuspendPos] revoke suspension after suspendPos (binding parameter path use case)
    * @returns {string[]}
    */
-  function flattenStructStepsInRef(ref, path, links, scope, resolvedLinkTypes=new WeakMap(), refParentIsItems=false) {
+  function flattenStructStepsInRef(ref, path, links, scope, resolvedLinkTypes=new WeakMap(), suspend=false, suspendPos=0, revokeAtSuspendPos=false) {
     // Refs of length 1 cannot contain steps - no need to check
     if (ref.length < 2 || (scope === '$self' && ref.length === 2)) {
       return ref;
@@ -350,10 +354,10 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
      (resolvedLinkTypes.get(links[i])||{})[propName]);
 
     let flattenStep = false;
-    let nextIsItems = !!art('items') || (refParentIsItems && i === 0);
+    suspend = !!art('items') || (suspend && i <= suspendPos);
     for(; i < links.length; i++) {
 
-      if (flattenStep && !nextIsItems) {
+      if (flattenStep && !suspend) {
         result[result.length - 1] += pathDelimiter + (ref[i].id ? ref[i].id : ref[i]);
         // if we had a filter or args, we had an assoc so this step is done
         // we then keep along the filter/args by updating the id of the current ref
@@ -362,14 +366,15 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
           result[result.length-1] = ref[i];
         }
         // suspend flattening if the next path step has some 'items'
-        nextIsItems = !!art('items');
+        suspend = !!art('items');
       }
       else {
         result.push(ref[i]);
+        suspend ||= !!art('items');
       }
       // revoke items suspension for next assoc step
-      if(nextIsItems && art('target'))
-        nextIsItems = false;
+      if(suspend && art('target') || (revokeAtSuspendPos && i === suspendPos))
+        suspend = false;
 
       flattenStep = !links[i].art?.kind &&
         !links[i].art?.SELECT &&
@@ -469,11 +474,11 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
   // Add the created projection to the model and complain if artifact already exists.
   // Used by Draft generation
   function createExposingProjection(art, artName, projectionId, service) {
-    let projectionAbsoluteName = `${service}.${projectionId}`;
+    const projectionAbsoluteName = `${service}.${projectionId}`;
     // Create elements matching the artifact's elements
-    let elements = Object.create(null);
+    const elements = Object.create(null);
     art.elements && Object.entries(art.elements).forEach(([elemName, artElem]) => {
-      let elem = Object.assign({}, artElem);
+      const elem = Object.assign({}, artElem);
       // Transfer xrefs, that are redirected to the projection
       // TODO: shall we remove the transferred elements from the original?
       // if (artElem._xref) {
@@ -483,7 +488,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
       elements[elemName] = elem;
     });
 
-    let query = {
+    const query = {
       'SELECT': {
         'from': {
           'ref': [
@@ -493,13 +498,13 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
       }
     };
     // Assemble the projection itself and add it into the model
-    let projection = {
+    const projection = {
       'kind': 'entity',
       projection: query.SELECT, // it is important that projection and query refer to the same object!
       elements
     };
     // copy annotations from art to projection
-    for (let a of Object.keys(art).filter(x => x.startsWith('@'))) {
+    for (const a of Object.keys(art).filter(x => x.startsWith('@'))) {
       projection[a] = art[a];
     }
     model.definitions[projectionAbsoluteName] = projection;
@@ -522,6 +527,8 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
     if (!draftAdminDataEntity) {
       draftAdminDataEntity = createAndAddDraftAdminDataEntity();
       model.definitions['DRAFT.DraftAdministrativeData'] = draftAdminDataEntity;
+      if(options.tenantDiscriminator && options.transformation !== 'odata')
+        addTenantFieldToArt(model.definitions['DRAFT.DraftAdministrativeData'], options);
     }
 
     // Create a projection within this service
@@ -602,7 +609,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
     if (!isBuiltinType(typeName) && !model.definitions[typeName]) {
       throw new ModelError('Expecting valid type name: ' + typeName);
     }
-    let result = {
+    const result = {
       [elemName]: {
         type: typeName
       }
@@ -630,16 +637,16 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
   //     keys: [{ ref: ['id'] }]
   // } }
   function createAssociationElement(elemName, target, isManaged = false) {
-    let elem = createScalarElement(elemName, 'cds.Association', false, undefined);
-    let assoc = elem[elemName];
+    const elem = createScalarElement(elemName, 'cds.Association', false, undefined);
+    const assoc = elem[elemName];
     assoc.target = target;
 
     if (isManaged) {
       assoc.keys = [];
-      let targetArt = getCsnDef(target);
+      const targetArt = getCsnDef(target);
       targetArt.elements && Object.entries(targetArt.elements).forEach(([keyElemName, keyElem]) => {
         if (keyElem.key) {
-          let foreignKey = createForeignKey(keyElemName, keyElem);
+          const foreignKey = createForeignKey(keyElemName, keyElem);
           addForeignKey(foreignKey, assoc);
         }
       });
@@ -696,7 +703,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
     if (!artifact.elements) {
       throw new ModelError('Expecting artifact with elements: ' + JSON.stringify(artifact));
     }
-    let elemName = Object.keys(elem)[0];
+    const elemName = Object.keys(elem)[0];
     // Element must not exist
     if (artifact.elements[elemName]) {
       let path = null;
@@ -733,7 +740,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
       error(null, path, { name: elementName }, 'Generated element $(NAME) conflicts with existing element');
     }
 
-    let result = Object.create(null);
+    const result = Object.create(null);
     result[elementName] = {};
     elem && Object.entries(elem).forEach(([prop, value]) => {
       result[elementName][prop] = value;
@@ -746,13 +753,13 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
   // of type name 'paramTypeName'
   function createAction(actionName, returnTypeName = undefined, paramName = undefined, paramTypeName = undefined) {
     // Assemble the action
-    let result = {
+    const result = {
       [actionName]: {
         kind: 'action'
       }
     };
 
-    let action = result[actionName];
+    const action = result[actionName];
 
     if (returnTypeName) {
       if (!isBuiltinType(returnTypeName) && !model.definitions[returnTypeName])
@@ -787,7 +794,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
       artifact.actions = Object.create(null);
     }
 
-    let actionName = Object.keys(action)[0];
+    const actionName = Object.keys(action)[0];
     // Element must not exist
     if (!artifact.actions[actionName]) {
       // Add the action
@@ -804,7 +811,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
    *                    second field if it has @cds.valid.to. Default value is [] for each field.
    */
   function extractValidFromToKeyElement(element, path) {
-    let validFroms = [], validTos = [], validKeys = [];
+    const validFroms = [], validTos = [], validKeys = [];
     if (hasAnnotationValue(element, '@cds.valid.from')) {
       validFroms.push({ element, path: [...path] });
     }
@@ -874,7 +881,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
    */
   function recurseElements(artifact, path, callback) {
     callback(artifact, path);
-    let elements = artifact.elements;
+    const elements = artifact.elements;
     if (elements) {
       path.push('elements', null);
       forEach(elements, (name, obj) => {
@@ -888,7 +895,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
 
   // Rename annotation 'fromName' in 'node' to 'toName' (both names including '@')
   function renameAnnotation(node, fromName, toName) {
-    let annotation = node && node[fromName];
+    const annotation = node && node[fromName];
     // Sanity checks
     if (!fromName.startsWith('@')) {
       throw new CompilerAssertion('Annotation name should start with "@": ' + fromName);
@@ -1035,7 +1042,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
     if(art) {
       if(art && !((art.items && art.items.elements) || art.elements)) {
         if(followMgdAssoc && art.target && art.keys) {
-          let rc = [];
+          const rc = [];
           for(const k of art.keys) {
             const nps = { ref: k.ref.map(p => fullRef ? { id: p } : p ) };
             setProp(nps, '_art', k._art);
@@ -1053,7 +1060,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
       }
       const elements = art.items && art.items.elements || art.elements;
       if(elements) {
-        let rc = []
+        const rc = []
         Object.entries(elements).forEach(([en, elt]) => {
           const nps = { ref: [ (fullRef ? { id: en, _art: elt } : en )] };
           setProp(nps, '_art', elt);
@@ -1102,7 +1109,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
       Flattening stops on all non-structured types.
     */
     function expand(expr, location) {
-      let rc = [];
+      const rc = [];
       for(let i = 0; i < expr.length; i++)
       {
         if(Array.isArray(expr[i]))