@sap/cds-compiler 6.1.0 → 6.3.0

package/lib/transform/forOdata.js

@@ -2,16 +2,17 @@
 
 const { isBetaEnabled } = require('../base/model');
 const transformUtils = require('./transformUtils');
-const { forEachDefinition,
-        forEachMemberRecursively,
-        applyTransformationsOnNonDictionary,
-        getArtifactDatabaseNameOf,
-        getElementDatabaseNameOf,
-        getServiceNames,
-        forEachGeneric,
-        cardinality2str,
-        getUtils
-      } = require('../model/csnUtils');
+const {
+  forEachDefinition,
+  forEachMemberRecursively,
+  applyTransformationsOnNonDictionary,
+  getArtifactDatabaseNameOf,
+  getElementDatabaseNameOf,
+  getServiceNames,
+  forEachGeneric,
+  cardinality2str,
+  getUtils,
+} = require('../model/csnUtils');
 const { checkCSNVersion } = require('../json/csnVersion');
 const validate = require('../checks/validator');
 const { isArtifactInSomeService, isLocalizedArtifactInService } = require('./odata/utils');
@@ -20,7 +21,7 @@ const { timetrace } = require('../utils/timetrace');
 const enrichUniversalCsn = require('./universalCsn/universalCsnEnricher');
 const flattening = require('./odata/flattening');
 const createForeignKeyElements = require('./odata/createForeignKeys');
-const associations = require('./db/associations')
+const associations = require('./db/associations');
 const expansion = require('./db/expansion');
 const generateDrafts = require('./draft/odata');
 
@@ -29,6 +30,7 @@ const { addLocalizationViews } = require('./localized');
 const { cloneFullCsn } = require('../model/cloneCsn');
 const { csnRefs } = require('../model/csnRefs');
 const replaceForeignKeyRefsInExpressionAnnotations = require('./odata/foreignKeyRefsInXprAnnos');
+const { isAnnotationExpression, xprInAnnoProperties } = require('../base/builtins');
 
 // Transformation for ODATA. Expects a CSN 'inputModel', processes it for ODATA.
 // The result should be suitable for consumption by EDMX processors (annotations and metadata)
@@ -79,7 +81,9 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   const csn = cloneFullCsn(inputModel, options);
   messageFunctions.setModel(csn);
 
-  const { message, error, warning, info, throwWithAnyError } = messageFunctions;
+  const {
+    message, error, warning, info, throwWithAnyError,
+  } = messageFunctions;
   throwWithAnyError();
 
   // the new transformer works only with new CSN
@@ -115,9 +119,7 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   // @ts-ignore
   const externalServices = services.filter(serviceName => csn.definitions[serviceName]['@cds.external']);
   // @ts-ignore
-  const isExternalServiceMember = (art, name) => {
-    return !!(externalServices.includes(getServiceName(name)) ||  (art && art['@cds.external']))
-  }
+  const isExternalServiceMember = (art, name) => !!(externalServices.includes(getServiceName(name)) || (art && art['@cds.external']));
 
   if (options.csnFlavor === 'universal' && isBetaEnabled(options, 'enableUniversalCsn'))
     enrichUniversalCsn(csn, options);
@@ -140,13 +142,25 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   // replace all type refs to builtin types with direct type
   transformUtils.rewriteBuiltinTypeRef(csn);
 
-    // Rewrite paths in annotations only if beta modes are set
+  // Rewrite paths in annotations only if beta modes are set
 
   options.enrichAnnotations = true;
   const cleanup = validate.forOdata(csn, {
-    message, error, warning, info, inspectRef, effectiveType, getFinalTypeInfo, artifactRef,
-    options, csnUtils, services, isExternalServiceMember, recurseElements,
-    checkMultipleAssignments, csn,
+    message,
+    error,
+    warning,
+    info,
+    inspectRef,
+    effectiveType,
+    getFinalTypeInfo,
+    artifactRef,
+    options,
+    csnUtils,
+    services,
+    isExternalServiceMember,
+    recurseElements,
+    checkMultipleAssignments,
+    csn,
   });
 
 
@@ -154,19 +168,22 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   throwWithAnyError();
 
   // TODO: Refactor out the following logic
+  const hasProjection = new Set();
   forEachDefinition(csn, [
     (def) => {
       // Convert a projection into a query for internal processing will be re-converted
       // at the end of the OData processing
       // TODO: handle artifact.projection instead of artifact.query correctly in future V2
       if (def.kind === 'entity' && def.projection) {
+        hasProjection.add(def);
         def.query = { SELECT: def.projection };
+        delete def.projection;
         dropDefinitionCache(def);
         initDefinition(def);
       }
-    }],
-    { skipArtifact: isExternalServiceMember }
-  );
+    },
+  ],
+                    { skipArtifact: isExternalServiceMember });
 
   // All type refs must be resolved, including external APIs.
   // OData has no 'type of' so 'real' imported OData APIs marked @cds.external are safe.
@@ -180,13 +197,13 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   // and expand these structured elements. This tuple expansion allows all other
   // subsequent procession steps (especially a2j) to see plain paths in expressions.
   // If errors are detected, throwWithAnyError() will return from further processing
-  expandStructsInExpression(csn, { skipArtifact: isExternalServiceMember, drillRef: true });
+  expandStructsInExpression({ skipArtifact: isExternalServiceMember, drillRef: true });
 
   // do expansion before Fk creation because of messages reporting
   if (!structuredOData) {
     expansion.expandStructureReferences(csn, options, '_',
-      { error, info, throwWithAnyError }, csnUtils,
-      { skipArtifact: isExternalServiceMember, keepKeysOrigin: true });
+                                        { error, info, throwWithAnyError }, csnUtils,
+                                        { skipArtifact: isExternalServiceMember, keepKeysOrigin: true });
   }
 
   createForeignKeyElements(csn, options, messageFunctions, csnUtils, { skipArtifact: isExternalServiceMember });
@@ -201,34 +218,34 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
     const resolved = new WeakMap();
     const { inspectRef, effectiveType } = csnRefs(csn);
     const { getFinalTypeInfo } = getUtils(csn);
-    const { adaptRefs, transformer: refFlattener } =
-      flattening.getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, options, resolved, '_');
+    const { adaptRefs, transformer: refFlattener }
+      = flattening.getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, options, resolved, '_');
 
     const allMgdAssocDefs = flattening.allInOneFlattening(csn, refFlattener, adaptRefs,
-      inspectRef, getFinalTypeInfo, isExternalServiceMember, error, csnUtils, options);
+                                                          inspectRef, getFinalTypeInfo, isExternalServiceMember, error, csnUtils, options);
     flattening.flattenAllStructStepsInRefs(csn, refFlattener, adaptRefs,
-        inspectRef, effectiveType, csnUtils, error, options,
-      { //skip: ['action', 'aspect', 'event', 'function', 'type'],
-        skipArtifact: isExternalServiceMember,
-      });
+                                           inspectRef, effectiveType, csnUtils, error, options,
+                                           { // skip: ['action', 'aspect', 'event', 'function', 'type'],
+                                             skipArtifact: isExternalServiceMember,
+                                           });
     flattening.replaceManagedAssocsAsKeys(allMgdAssocDefs, csnUtils);
 
     // replace structured with flat dictionaries that contain
     // rewritten path expressions
     forEachDefinition(csn, (def) => {
-      ['elements', 'params'].forEach(dictName => {
-        if(def[`$flat${dictName}`])
-          def[dictName] = def[`$flat${dictName}`];
-      })
-      if(def.$flatAnnotations) {
-        Object.entries(def.$flatAnnotations).forEach(([an, av]) => {
+      [ 'elements', 'params' ].forEach((dictName) => {
+        if (def[`$flat${ dictName }`])
+          def[dictName] = def[`$flat${ dictName }`];
+      });
+      if (def.$flatAnnotations) {
+        Object.entries(def.$flatAnnotations).forEach(([ an, av ]) => {
           def[an] = av;
-        })
+        });
       }
-      if(def.actions) {
+      if (def.actions) {
         Object.values(def.actions).forEach((action) => {
-          if(action.$flatAnnotations) {
-            Object.entries(action.$flatAnnotations).forEach(([an, av]) => {
+          if (action.$flatAnnotations) {
+            Object.entries(action.$flatAnnotations).forEach(([ an, av ]) => {
               action[an] = av;
             });
           }
@@ -242,9 +259,9 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   // Allow using managed associations as steps in on-conditions to access their fks
   // To be done after handleManagedAssociationsAndCreateForeignKeys,
   // since then the foreign keys of the managed assocs are part of the elements
-  if(!structuredOData) {
-    forEachDefinition(csn, associations.getFKAccessFinalizer(csn, csnUtils, '_'));
-  }
+  if (!structuredOData)
+    forEachDefinition(csn, associations.getFKAccessFinalizer(csn, options, csnUtils, '_'));
+
 
   // structure flattener reports errors, further processing is not safe -> throw exception in case of errors
   throwWithAnyError();
@@ -269,7 +286,9 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   // - Perform checks for exposed non-abstract entities and views - check media type and key-ness
 
   // Deal with all kind of annotations manipulations here
-  const skipPersNameKinds = {'service':1, 'context':1, 'namespace':1, 'annotation':1, 'action':1, 'function':1};
+  const skipPersNameKinds = {
+    service: 1, context: 1, namespace: 1, annotation: 1, action: 1, function: 1,
+  };
   forEachDefinition(csn, (def, defName) => {
     // Resolve annotation shorthands for entities, types, annotations, ...
     renameShorthandAnnotations(def);
@@ -277,7 +296,7 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
     // Annotate artifacts with their DB names if requested.
     // Skip artifacts that have no DB equivalent anyway
     if (options.sqlMapping && !(def.kind in skipPersNameKinds))
-       // hana to allow naming mode "hdbcds"
+    // hana to allow naming mode "hdbcds"
       def['@cds.persistence.name'] = getArtifactDatabaseNameOf(defName, options.sqlMapping, csn, 'hana');
 
     forEachMemberRecursively(def, (member, memberName, propertyName) => {
@@ -289,10 +308,12 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
           !(propertyName === 'enum' || propertyName === 'returns') &&
           (!member.virtual || def.query)) {
         // If we have a 'preserved dotted name' (i.e. we are a result of flattening), use that for the @cds.persistence.name annotation
-        member['@cds.persistence.name'] = getElementDatabaseNameOf((!member['@odata.foreignKey4'] && member.$defPath?.slice(1).join('.'))
-                                                                    || memberName, options.sqlMapping, 'hana'); // hana to allow "hdbcds"
+        member['@cds.persistence.name'] = getElementDatabaseNameOf((!member['@odata.foreignKey4'] && member.$defPath?.slice(1).join('.')) ||
+                                                                    memberName, options.sqlMapping, 'hana'); // hana to allow "hdbcds"
       }
 
+      processDynamicFieldControlAnnotations(member);
+
       // Mark fields with @odata.on.insert/update as @Core.Computed
       annotateCoreComputed(member);
 
@@ -316,18 +337,19 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
         // to the foreign keys is done very late in edmPreprocessor.initializeAssociation()
         addCommonValueListviaAssociation(member, memberName);
       }
-    }, ['definitions', defName]);
+    }, [ 'definitions', defName ]);
 
     // Convert a query back into a projection for CSN compliance as
     // the very last conversion step of the OData transformation
-    if (def.kind === 'entity' && def.query && def.projection) {
+    if (def.kind === 'entity' && hasProjection.has(def)) {
+      def.projection = def.query.SELECT;
       delete def.query;
     }
-  }, { skipArtifact: isExternalServiceMember })
+  }, { skipArtifact: isExternalServiceMember });
 
-  if(isBetaEnabled(options, 'odataTerms')) {
+  if (isBetaEnabled(options, 'odataTerms'))
     forEachGeneric(csn, 'vocabularies', renameShorthandAnnotations);
-  }
+
 
   cleanup();
   // Throw exception in case of errors
@@ -338,14 +360,101 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   //--------------------------------------------------------------------
   // HELPER SECTION STARTS HERE
 
+  // Transform @readonly/@mandatory/@disabled into @Common.FieldControl annotation
+  // with a when/then/else expression consisting of the input from the annotations.
+  function processDynamicFieldControlAnnotations(node) {
+    if (node['@Common.FieldControl'])
+      return;
+    // TODO (SO): factor this out into a constant so we don't create a fresh array all the time?
+    if ([ '@readonly', '@mandatory', '@disabled' ].some(key => typeof node[key] === 'boolean'))
+      return;
+
+
+    const definedAnnotations = [ '@disabled', '@readonly', '@mandatory' ]
+      .filter(key => node[key] && isAnnotationExpression(node[key]));
+
+    if (definedAnnotations.length === 0)
+      return;
+
+    const values = {
+      '@disabled': { val: 0 },
+      '@readonly': { val: 1 },
+      '@mandatory': { val: 7 },
+    };
+
+    const fieldControl = {
+      '=': true,
+      xpr: createFieldControlExpression(definedAnnotations),
+    };
+
+    setAnnotation(node, '@Common.FieldControl', fieldControl);
+
+    function createFieldControlExpression(annotations) {
+      let nestedExpression = null;
+
+      for (let i = annotations.length - 1; i >= 0; i--) {
+        const annotation = annotations[i];
+        const xprInAnnoValue = getXprFromAnno(node[annotation]);
+        const annotationVal = values[annotation];
+
+        // Build the current annotation's expression
+        const currentExpression = [
+          'case',
+          'when',
+          ...(Array.isArray(xprInAnnoValue) ? xprInAnnoValue : [ xprInAnnoValue ]),
+          'then',
+          annotationVal,
+          'else',
+          // Use the previous nested expression or default value. Note that annotations
+          // are looped backwards
+          nestedExpression ? { xpr: nestedExpression } : { val: 3 },
+          'end',
+        ];
+
+        // Update the nested expression
+        nestedExpression = currentExpression;
+      }
+      return nestedExpression;
+    }
+
+    function getXprFromAnno(anno) {
+      const xprProp = xprInAnnoProperties.find(prop => anno[prop] !== undefined);
+      const constructResult = {
+        ref: () => {
+          const result = { ref: anno.ref };
+          if (anno.cast)
+            result.cast = anno.cast;
+          return result;
+        },
+        xpr: () => anno.xpr,
+        list: () => ({ list: anno.list }),
+        literal: () => constructResult.val(),
+        val: () => {
+          const result = { val: anno.val };
+          if (anno.literal)
+            result.literal = anno.literal;
+          return result;
+        },
+        '#': () => ({ '#': anno['#'] }),
+        func: () => ({ func: anno.func }),
+        args: () => ({ args: anno.args }),
+        SELECT: () => ({ SELECT: anno.SELECT }),
+        SET: () => ({ SET: anno.SET }),
+        cast: () => constructResult.ref(),
+      };
+      return constructResult[xprProp]();
+    }
+  }
+
   // Mark elements that are annotated with @odata.on.insert/update with the annotation @Core.Computed.
   function annotateCoreComputed(node) {
     // If @Core.Computed is explicitly set, don't overwrite it!
-    if (node['@Core.Computed'] !== undefined) return;
+    if (node['@Core.Computed'] !== undefined)
+      return;
 
     // For @odata.on.insert/update,  also add @Core.Computed
     // @odata.on is deprecated, use @cds.on {update|insert} instead
-    if(['@odata.on.insert', '@odata.on.update', '@cds.on.insert', '@cds.on.update'].some(a => node[a]))
+    if ([ '@odata.on.insert', '@odata.on.update', '@cds.on.insert', '@cds.on.update' ].some(a => node[a]))
       node['@Core.Computed'] = true;
   }
 
@@ -358,37 +467,36 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
     };
     const renameMappings = {
       '@ValueList.entity': { val: '@Common.ValueList', op: 'entity' },
-      '@ValueList.type':  { val: '@Common.ValueList', op: 'type' },
+      '@ValueList.type': { val: '@Common.ValueList', op: 'type' },
       '@Capabilities.Deletable': { val: '@Capabilities.DeleteRestrictions', op: 'Deletable' },
       '@Capabilities.Insertable': { val: '@Capabilities.InsertRestrictions', op: 'Insertable' },
       '@Capabilities.Updatable': { val: '@Capabilities.UpdateRestrictions', op: 'Updatable' },
-      '@Capabilities.Readable': { val: '@Capabilities.ReadRestrictions', op: 'Readable' }
+      '@Capabilities.Readable': { val: '@Capabilities.ReadRestrictions', op: 'Readable' },
     };
 
     const setShortCuts = Object.keys(setMappings);
     const renameShortCuts = Object.keys(renameMappings);
 
     // Capabilities shortcuts have precedence over @readonly/@insertonly
-    Object.keys(node).forEach( name => {
+    Object.keys(node).forEach( (name) => {
       if (!name.startsWith('@'))
         return;
       // Rename according to map above
       const renamePrefix = (name in renameMappings)
         ? name
-        : renameShortCuts.find(p => name.startsWith(p + '.'));
-      if(renamePrefix) {
+        : renameShortCuts.find(p => name.startsWith(`${ p }.`));
+      if (renamePrefix) {
         const mapping = renameMappings[renamePrefix];
-        renameAnnotation(node, name, name.replace(renamePrefix, `${mapping.val}.${mapping.op}`));
+        renameAnnotation(node, name, name.replace(renamePrefix, `${ mapping.val }.${ mapping.op }`));
       }
       else {
         // The two mappings have no overlap, so no need to check for second map if first matched.
         // Rename according to map above
         const setPrefix = (name in setMappings)
           ? name
-          : setShortCuts.find(p => name.startsWith(p + '.') || name.startsWith(p + '#'));
-        if(setPrefix) {
+          : setShortCuts.find(p => name.startsWith(`${ p }.`) || name.startsWith(`${ p }#`));
+        if (setPrefix)
           setAnnotation(node, name.replace(setPrefix, setMappings[setPrefix]), node[name]);
-        }
       }
     });
 
@@ -396,14 +504,17 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
     // but '@Core.Computed' for everything else.
 
     // only if not both readonly/insertonly are true do the mapping
-    if(!(node['@readonly'] && node['@insertonly'])) {
-      if(node['@readonly']) {
+    if (!(node['@readonly'] && node['@insertonly'])) {
+      if (node['@readonly']) {
         const setRO = (qualifier) => {
           if (node.kind === 'entity' || node.kind === 'aspect') {
-            setAnnotation(node, `@Capabilities.DeleteRestrictions${ qualifier ? '#' + qualifier : ''}.Deletable`, false);
-            setAnnotation(node, `@Capabilities.InsertRestrictions${ qualifier ? '#' + qualifier : ''}.Insertable`, false);
-            setAnnotation(node, `@Capabilities.UpdateRestrictions${ qualifier ? '#' + qualifier : ''}.Updatable`, false);
-          } else {
+            const qualifierStr = qualifier ? `#${ qualifier }` : '';
+            setAnnotation(node, `@Capabilities.DeleteRestrictions${ qualifierStr }.Deletable`, false);
+            setAnnotation(node, `@Capabilities.InsertRestrictions${ qualifierStr }.Insertable`, false);
+            setAnnotation(node, `@Capabilities.UpdateRestrictions${ qualifierStr }.Updatable`, false);
+          }
+          else if (!isAnnotationExpression(node['@readonly'])) {
+            // add @Core.Computed only for non-xpr values of @readonly
             setAnnotation(node, '@Core.Computed', true);
           }
         };
@@ -412,10 +523,11 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
       // @insertonly is effective on entities/queries only
       if (node['@insertonly'] && (node.kind === 'entity' || node.kind === 'aspect')) {
         const setIO = (qualifier) => {
-          setAnnotation(node, `@Capabilities.DeleteRestrictions${ qualifier ? '#' + qualifier : ''}.Deletable`, false);
-          setAnnotation(node, `@Capabilities.ReadRestrictions${ qualifier ? '#' + qualifier : ''}.Readable`, false);
-          setAnnotation(node, `@Capabilities.UpdateRestrictions${ qualifier ? '#' + qualifier : ''}.Updatable`, false);
-        }
+          const qualifierStr = qualifier ? `#${ qualifier }` : '';
+          setAnnotation(node, `@Capabilities.DeleteRestrictions${ qualifierStr }.Deletable`, false);
+          setAnnotation(node, `@Capabilities.ReadRestrictions${ qualifierStr }.Readable`, false);
+          setAnnotation(node, `@Capabilities.UpdateRestrictions${ qualifierStr }.Updatable`, false);
+        };
         setIO(undefined);
       }
     }
@@ -425,10 +537,11 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
       setAnnotation(node, '@Validation.Pattern', node['@assert.format']);
 
     // Only on element level
-    if(node.kind == null) {
-      if (node['@mandatory'] && !Object.entries(node).some(([k,v]) => k === '@Common.FieldControl' || k.startsWith('@Common.FieldControl.') && v != null)) {
+    if (node.kind == null) {
+      if (node['@mandatory'] && !isAnnotationExpression(node['@mandatory']) &&
+          !Object.entries(node).some(([ k, v ]) => k === '@Common.FieldControl' || k.startsWith('@Common.FieldControl.') && v != null))
         setAnnotation(node, '@Common.FieldControl', { '#': 'Mandatory' });
-      }
+
       if (node['@assert.range'] != null)
         setAssertRangeAnnotation(node);
     }
@@ -438,7 +551,7 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   function setAssertRangeAnnotation(node) {
     const range = node['@assert.range'];
     if (!Array.isArray(range) || range.length !== 2)
-    return; // TODO: Warning for wrong format?
+      return; // TODO: Warning for wrong format?
 
     const min = range[0];
     const max = range[1];
@@ -450,7 +563,7 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
     // via `@assert.range: [ _, _ ]`.
     // For `_`, minVal is an object and this function returns false, which is ok,
     // since we don't render the annotation for "infinite" values.
-    const shouldSet = (val) => (typeof val !== 'object' && val !== undefined && val !== null);
+    const shouldSet = val => (typeof val !== 'object' && val !== undefined && val !== null);
 
     if (shouldSet(minVal)) {
       setAnnotation(node, '@Validation.Minimum', minVal);
@@ -462,7 +575,6 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
       if (max['='] !== undefined)
         setAnnotation(node, '@Validation.Maximum.@Validation.Exclusive', true);
     }
-
   }
 
   // If an association was modelled as not null, like so:
@@ -489,30 +601,30 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   // Apply default type facets to each type definition and every member
   // But do not apply default string length (as in DB)
   function setDefaultTypeFacets(def) {
-    addDefaultTypeFacets(def.items || def, null)
-    forEachMemberRecursively(def,  m=>addDefaultTypeFacets(m.items || m, null));
-    if(def.returns)
+    addDefaultTypeFacets(def.items || def, null);
+    forEachMemberRecursively(def, m => addDefaultTypeFacets(m.items || m, null));
+    if (def.returns)
       addDefaultTypeFacets(def.returns.items || def.returns, null);
   }
 
   // Handles on-conditions in unmanaged associations
   function processOnCond(def) {
     forEachMemberRecursively(def, (member) => {
-      if (member.on && isAssocOrComposition(member)) {
+      if (member.on && isAssocOrComposition(member))
         removeLeadingDollarSelfInOnCondition(member);
-      }
     });
 
     // removes leading $self in on-conditions's references
     function removeLeadingDollarSelfInOnCondition(assoc) {
-      if (!assoc.on) return; // nothing to do
+      if (!assoc.on)
+        return; // nothing to do
       // TODO: Shouldn't this only run on the on-condition and not the whole assoc-node?
       applyTransformationsOnNonDictionary({ assoc }, 'assoc', {
         ref: (node, prop, ref) => {
           // remove leading $self when at the beginning of a ref
           if (ref.length > 1 && ref[0] === '$self')
             node.ref.splice(0, 1);
-        }
+        },
       });
     }
   }
@@ -527,9 +639,8 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
     if (isAssociation(member)) {
       const navigable = member['@odata.navigable'] !== false; // navigable disabled only if explicitly set to false
       const targetDef = getCsnDef(member.target);
-      if (navigable && targetDef['@cds.odata.valuelist'] && !member[vlAnno]) {
+      if (navigable && targetDef['@cds.odata.valuelist'] && !member[vlAnno])
         setAnnotation(member, vlAnno, { '=': memberName });
-      }
     }
   }
 
@@ -538,6 +649,4 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
     const csnRefApi = csnRefs(csn);
     Object.assign(csnUtils, csnRefApi);
   }
-
-
 } // transform4odataWithCsn