@sap/cds-compiler 4.0.2 → 4.2.2

package/lib/edm/edmUtils.js

@@ -1,27 +1,28 @@
 'use strict';
+
 const { setProp } = require('../base/model');
-const { isBuiltinType, isEdmPropertyRendered, applyTransformations, cloneAnnotationValue } = require('../model/csnUtils');
+const {
+  isBuiltinType, isEdmPropertyRendered, applyTransformations, cloneAnnotationValue,
+} = require('../model/csnUtils');
 const { escapeString, hasControlCharacters, hasUnpairedUnicodeSurrogate } = require('../render/utils/stringEscapes');
-const {CompilerAssertion} = require('../base/error');
+const { CompilerAssertion } = require('../base/error');
 
 /* eslint max-statements-per-line:off */
-function validateOptions(_options)
-{
-  if(!_options.isV2 && !_options.isV4)
-  {
+function validateOptions( _options ) {
+  if (!_options.isV2 && !_options.isV4) {
     // csn2edm expects "odataVersion" to be a top-level property of options
     // set to 'v4' as default, override with value from incoming options
-    const options = Object.assign({ odataVersion: 'v4'}, _options);
+    const options = Object.assign({ odataVersion: 'v4' }, _options);
     // global flag that indicates whether or not FKs shall be rendered in general
     // V2/V4 flat: yes
     // V4/struct: depending on odataForeignKeys
-    options.renderForeignKeys =
-      options.odataVersion === 'v4' ? options.odataFormat === 'structured' &&  !!options.odataForeignKeys : true;
+    options.renderForeignKeys
+      = options.odataVersion === 'v4' ? options.odataFormat === 'structured' && !!options.odataForeignKeys : true;
 
     const v2 = options.odataVersion.match(/v2/i) !== null;
     const v4 = options.odataVersion.match(/v4/i) !== null;
 
-    options.v = [v2, v4];
+    options.v = [ v2, v4 ];
     options.isStructFormat = options.odataFormat && options.odataFormat === 'structured';
     options.isFlatFormat = !options.isStructFormat;
 
@@ -32,81 +33,80 @@ function validateOptions(_options)
 
     return options;
   }
-  else
-    return _options;
+  return _options;
 }
 
 // returns intersection of two arrays
-function intersect(a,b)
-{
-  return [...new Set(a)].filter(x => new Set(b).has(x));
+function intersect( a, b ) {
+  return [ ...new Set(a) ].filter(x => new Set(b).has(x));
 }
 
 // Call func(art, name) for each artifact 'art' with name 'name' in 'dictionary' that returns true for 'filter(art)'
-function foreach(dictionary, filter, func) {
-  dictionary && Object.entries(dictionary).forEach(([name, value]) => {
-    if (filter(value)) {
-      if(Array.isArray(func))
-        func.forEach(f=>f(value, name));
-      else
+function foreach( dictionary, filter, func ) {
+  if (dictionary) {
+    Object.entries(dictionary).forEach(([ name, value ]) => {
+      if (filter(value)) {
+        if (Array.isArray(func))
+          func.forEach(f => f(value, name));
+        else
           func(value, name);
-    }
-  });
+      }
+    });
+  }
 }
 
 // true if _containerEntity is unequal to artifact name (non-recursive containment association)
 //      or if artifact belongs to an artificial parameter entity
-function isContainee(artifact) {
+function isContainee( artifact ) {
   // if $containerNames is present, it is guaranteed that it has at least one entry
-  return (artifact.$containerNames && (artifact.$containerNames.length > 1 || artifact.$containerNames[0] != artifact.name));
+  return (artifact.$containerNames && (artifact.$containerNames.length > 1 || artifact.$containerNames[0] !== artifact.name));
 }
 
 // Return true if the association 'assoc' has cardinality 'to-many'
-function isToMany(assoc) {
-  if (!assoc.cardinality) {
+function isToMany( assoc ) {
+  if (!assoc.cardinality)
     return false;
-  }
+
   // Different representations possible: array or targetMax property
-  let targetMax = assoc.cardinality[1] ||assoc.cardinality.max;
-  if (!targetMax) {
+  const targetMax = assoc.cardinality[1] || assoc.cardinality.max;
+  if (!targetMax)
     return false;
-  }
+
   return targetMax === '*' || Number(targetMax) > 1;
 }
 
-function isNavigable(assoc) {
+function isNavigable( assoc ) {
   return (assoc.target && (assoc['@odata.navigable'] == null || assoc['@odata.navigable']));
 }
-function isSingleton(entityCsn) {
+function isSingleton( entityCsn ) {
   const singleton = entityCsn['@odata.singleton'];
   const hasNullable = entityCsn['@odata.singleton.nullable'] != null;
   return singleton || (singleton == null && hasNullable);
 }
 
-function isParameterizedEntity(artifact) {
+function isParameterizedEntity( artifact ) {
   return artifact.kind === 'entity' && artifact.params;
 }
 
 // Return true if 'artifact' is structured (i.e. has elements, like a structured type or an entity)
-function isStructuredArtifact(artifact) {
+function isStructuredArtifact( artifact ) {
   // FIXME: No derived types etc yet
   return (artifact.items && artifact.items.elements || artifact.elements);
 }
 
 // Return true if 'artifact' is a real structured type (not an entity)
-function isStructuredType(artifact) {
+function isStructuredType( artifact ) {
   return artifact.kind === 'type' && isStructuredArtifact(artifact);
 }
 
-function isDerivedType(artifact) {
+function isDerivedType( artifact ) {
   return artifact.kind === 'type' && !isStructuredArtifact(artifact);
 }
 
-function resolveOnConditionAndPrepareConstraints(csn, assocCsn, messageFunctions) {
+function resolveOnConditionAndPrepareConstraints( csn, assocCsn, messageFunctions ) {
   const { info, warning } = messageFunctions;
 
-  if(assocCsn.on)
-  {
+  if (assocCsn.on) {
     // fill constraint array with [prop, depProp]
     getExpressionArguments(assocCsn.on);
 
@@ -124,37 +124,36 @@ function resolveOnConditionAndPrepareConstraints(csn, assocCsn, messageFunctions
     ON Condition back.toE => parter=toE cannot be resolved in EParameters, _originalTarget 'E' is
     required for that
     */
-    assocCsn._constraints.selfs.filter(p => p).forEach(partnerPath => {
+    assocCsn._constraints.selfs.filter(p => p).forEach((partnerPath) => {
       // resolve partner path in target
       const originAssocCsn = resolveOriginAssoc(csn, (assocCsn._originalTarget || assocCsn._target), partnerPath);
       const parentName = assocCsn.$abspath[0];
       const parent = csn.definitions[parentName];
-      if(originAssocCsn && originAssocCsn.$abspath) {
+      if (originAssocCsn && originAssocCsn.$abspath) {
         const originParentName = originAssocCsn.$abspath[0];
-        if(parent.$mySchemaName && originAssocCsn._originalTarget !== parent && originAssocCsn._target !== parent) {
+        if (parent.$mySchemaName && originAssocCsn._originalTarget !== parent && originAssocCsn._target !== parent) {
           isBacklink = false;
           // Partnership is ambiguous
           setProp(originAssocCsn, '$noPartner', true);
-          info(null, ['definitions', parentName, 'elements', assocCsn.name],
-            `"${originParentName}:${partnerPath.join('.')}" with target "${originAssocCsn._target.name}" is compared with $self which represents "${parentName}"`);
+          info(null, [ 'definitions', parentName, 'elements', assocCsn.name ],
+               `"${originParentName}:${partnerPath.join('.')}" with target "${originAssocCsn._target.name}" is compared with $self which represents "${parentName}"`);
         }
-        if(originAssocCsn.target) {
+        if (originAssocCsn.target) {
           // Mark this association as backlink if $self appears exactly once
           // to suppress edm:Association generation in V2 mode
-          if(isBacklink) {
+          if (isBacklink) {
             // establish partnership with origin assoc but only if this association is the first one
-            if(originAssocCsn._selfReferences.length === 0) {
+            if (originAssocCsn._selfReferences.length === 0)
               assocCsn._constraints._partnerCsn = originAssocCsn;
-            }
-            else {
+
+            else
               isBacklink = false;
-            }
           }
           // store all backlinks at forward, required to calculate rendering of foreign keys
           // if the termCount != 1 or more than one $self compare this is not a backlink
-          if(parent.$mySchemaName && assocCsn._constraints.selfs.length === 1 && assocCsn._constraints.termCount === 1) {
+          if (parent.$mySchemaName && assocCsn._constraints.selfs.length === 1 && assocCsn._constraints.termCount === 1)
             originAssocCsn._selfReferences.push(assocCsn);
-          }
+
           assocCsn._constraints._origins.push(originAssocCsn);
         }
         else {
@@ -163,78 +162,72 @@ function resolveOnConditionAndPrepareConstraints(csn, assocCsn, messageFunctions
               key id : Integer;
               toMe: association to E on toMe.id = $self; };
             */
-          throw new CompilerAssertion('Backlink association element is not an association or composition: "' + originAssocCsn.name);
+          throw new CompilerAssertion(`Backlink association element is not an association or composition: "${originAssocCsn.name}`);
         }
       }
-      else
-      {
-        warning(null, ['definitions', parentName],
-        { partner: `${assocCsn._target.name}/${partnerPath}`, name: `${parentName}/${assocCsn.name}` },
-        'Can\'t resolve backlink to $(PARTNER) from $(NAME)');
+      else {
+        warning(null, [ 'definitions', parentName ],
+                { partner: `${assocCsn._target.name}/${partnerPath}`, name: `${parentName}/${assocCsn.name}` },
+                'Can\'t resolve backlink to $(PARTNER) from $(NAME)');
       }
     });
   }
 
   // nested functions
-  function getExpressionArguments(expr)
-  {
-    let allowedTokens = [ '=', 'and', '(', ')' ];
-    if(expr && Array.isArray(expr))
-      // if some returns true, this term is not usable as a constraint term
-      if(!expr.some(isNotAConstraintTerm))
-        expr.forEach(fillConstraints)
+  function getExpressionArguments( expr ) {
+    const allowedTokens = [ '=', 'and', '(', ')' ];
+    if (expr && Array.isArray(expr) && !expr.some(isNotAConstraintTerm))
+    // if some returns true, this term is not usable as a constraint term
+      expr.forEach(fillConstraints);
+
 
     // return true if token is not one of '=', 'and', '(', ')' or object
-    function isNotAConstraintTerm(tok)
-    {
-      if(tok.xpr)
+    function isNotAConstraintTerm( tok ) {
+      if (tok.xpr)
         return tok.xpr.some(isNotAConstraintTerm);
-      if(Array.isArray(tok))
+      if (Array.isArray(tok))
         return tok.some(isNotAConstraintTerm);
       return !(typeof tok === 'object' && tok != null || allowedTokens.includes(tok));
     }
 
     // fill constraints object with [dependent, principal] pairs and collect all forward assocs for $self terms
-    function fillConstraints(arg, pos)
-    {
-      if(arg.xpr)
+    function fillConstraints( arg, pos ) {
+      if (arg.xpr) {
         getExpressionArguments(arg.xpr);
-      else if(pos > 0 && pos < expr.length)
-      {
-        let lhs = expr[pos-1];
-        let rhs = expr[pos+1];
-        if(arg === '=')
-        {
+      }
+      else if (pos > 0 && pos < expr.length) {
+        let lhs = expr[pos - 1];
+        let rhs = expr[pos + 1];
+        if (arg === '=') {
           assocCsn._constraints.termCount++;
-          if(lhs.ref && rhs.ref) // ref is a path
-          {
+          if (lhs.ref && rhs.ref) { // ref is a path
             lhs = lhs.ref;
             rhs = rhs.ref;
             // if exactly one operand starts with the prefix then this is potentially a constraint
 
             // strip of prefix '$self's
-            if(lhs[0] === '$self' && lhs.length > 1)
+            if (lhs[0] === '$self' && lhs.length > 1)
               lhs = lhs.slice(1);
-            if(rhs[0] === '$self' && rhs.length > 1)
+            if (rhs[0] === '$self' && rhs.length > 1)
               rhs = rhs.slice(1);
 
-            if((lhs[0] === assocCsn.name && rhs[0] !== assocCsn.name) ||
-              (lhs[0] !== assocCsn.name && rhs[0] === assocCsn.name))
-            {
+            if ((lhs[0] === assocCsn.name && rhs[0] !== assocCsn.name) ||
+              (lhs[0] !== assocCsn.name && rhs[0] === assocCsn.name)) {
               // order is always [ property, referencedProperty ]
-              //backlink         [ self, assocName ]
+              // backlink         [ self, assocName ]
 
               let c;
-              if(lhs[0] === assocCsn.name)
-                c = [rhs, lhs.slice(1)];
+              if (lhs[0] === assocCsn.name)
+                c = [ rhs, lhs.slice(1) ];
               else
-                c = [lhs, rhs.slice(1)];
+                c = [ lhs, rhs.slice(1) ];
 
               // do we have a $self id?
               // if so, store partner in selfs array
-              if(c[0][0] === '$self' && c[0].length === 1) {
+              if (c[0][0] === '$self' && c[0].length === 1) {
                 assocCsn._constraints.selfs.push(c[1]);
-              } else {
+              }
+              else {
                 const key = c.join(',');
                 assocCsn._constraints.constraints[key] = c;
               }
@@ -246,8 +239,7 @@ function resolveOnConditionAndPrepareConstraints(csn, assocCsn, messageFunctions
   }
 }
 
-function finalizeReferentialConstraints(csn, assocCsn, options, info)
-{
+function finalizeReferentialConstraints( csn, assocCsn, options, info ) {
   if (assocCsn.on) {
     /* example for originalTarget:
     entity E (with parameters) {
@@ -260,15 +252,14 @@ function finalizeReferentialConstraints(csn, assocCsn, options, info)
     ON Condition back.toE => parter=toE cannot be resolved in EParameters, originalTarget 'E' is
     required for that
     */
-    assocCsn._constraints._origins.forEach(originAssocCsn => {
+    assocCsn._constraints._origins.forEach((originAssocCsn) => {
       // if the origin assoc is marked as primary key and if it's managed, add all its foreign keys as constraint
       // as they are also primary keys of the origin entity as well
-      if(!assocCsn._target.$isParamEntity && originAssocCsn.key && originAssocCsn.keys) {
-        for(let fk of originAssocCsn.keys) {
-          let realFk = originAssocCsn._parent.elements[fk.$generatedFieldName];
-          let pk = assocCsn._parent.elements[fk.ref[0]];
-          if(isConstraintCandidate(pk) && isConstraintCandidate(realFk))
-          {
+      if (!assocCsn._target.$isParamEntity && originAssocCsn.key && originAssocCsn.keys) {
+        for (const fk of originAssocCsn.keys) {
+          const realFk = originAssocCsn._parent.elements[fk.$generatedFieldName];
+          const pk = assocCsn._parent.elements[fk.ref[0]];
+          if (isConstraintCandidate(pk) && isConstraintCandidate(realFk)) {
             const c = [ [ fk.ref[0] ], [ fk.$generatedFieldName ] ];
             const key = c.join(',');
             assocCsn._constraints.constraints[key] = c;
@@ -277,87 +268,88 @@ function finalizeReferentialConstraints(csn, assocCsn, options, info)
       }
     });
 
-    if(!assocCsn._target.$isParamEntity) {
+    if (!assocCsn._target.$isParamEntity) {
       // Use $path to identify main artifact in case assocs parent was a nested type and deanonymized
       // Some (draft) associations don't have a $path, use _parent as last resort
       let dependentEntity = assocCsn.$path ? csn.definitions[assocCsn.$path[1]] : assocCsn._parent;
-      let localDepEntity  = assocCsn._parent;
+      let localDepEntity = assocCsn._parent;
       // _target must always be a main artifact
       let principalEntity = assocCsn._target;
-      if(assocCsn.type === 'cds.Composition') {
+      if (assocCsn.type === 'cds.Composition') {
       // Header is composed of Items => Cds.Composition: Header is principal => use header's primary keys
         principalEntity = dependentEntity;
         localDepEntity = undefined;
         dependentEntity = assocCsn._target;
         // Swap the constraint elements to be correct on Composition [principal, dependent] => [dependent, principal]
-        Object.keys(assocCsn._constraints.constraints).forEach(cn => {
-          assocCsn._constraints.constraints[cn] = [ assocCsn._constraints.constraints[cn][1], assocCsn._constraints.constraints[cn][0] ] } );
+        Object.keys(assocCsn._constraints.constraints).forEach((cn) => {
+          assocCsn._constraints.constraints[cn] = [ assocCsn._constraints.constraints[cn][1], assocCsn._constraints.constraints[cn][0] ];
+        } );
       }
       // Remove all target elements that are not key in the principal entity
       // and all elements that annotated with '@cds.api.ignore'
       const remainingPrincipalRefs = [];
       foreach(assocCsn._constraints.constraints,
-        c => {
-          // rc === true will remove the constraint (positive filter expression)
-          let rc = true;
-          // concatenate all paths in flat mode to identify the correct element
-          // in structured mode only resolve top level element (path rewriting is done elsewhere)
-          const depEltName = ( options.isFlatFormat ? c[0].join('_') : c[0][0] );
-          const principalEltName = ( options.isFlatFormat ? c[1].join('_') : c[1][0] );
-          const fk = (dependentEntity.kind === 'entity' && dependentEntity.elements[ depEltName ]) ||
-            (localDepEntity && localDepEntity.elements && localDepEntity.elements[ depEltName ]);
-          const pk = principalEntity.$keys && principalEntity.$keys[ principalEltName ];
-          if(isConstraintCandidate(fk) && isConstraintCandidate(pk)) {
-            if(options.isStructFormat) {
-              // In structured mode it might be the association has a new _parent due to
-              // type de-anonymization.
-              // There are three cases for dependent ON condition paths:
-              // 1) path is relative to assoc in same sub structure
-              // 2) path is absolute and ends up in a different environment
-              // 3) path is absolute and touches in assoc's environment
-
-              // => 1) if _parents are equal, fk path is relative to assoc
-              if(fk._parent === assocCsn._parent) {
-                rc = false;
-              }
-              // => 2) & 3) if path is not relative to assoc, remove main entity (pos=0) and assoc (pos=n-1)
-              // and check path identity: If absolute path touches assoc's _parent, add it
-              else if(!assocCsn.$abspath.slice(1, assocCsn.$abspath.length-1).some((p,i) => c[0][i] !== p)) {
-                // this was an absolute addressed path, remove environment prefix
-                c[0].splice(0, assocCsn.$abspath.length-2);
-                rc = false;
-              }
-            }
-            else {
-              // for flat mode isConstraintCandidate(fk) && isConstraintCandidate(pk) is sufficient
-              rc = false;
-            }
-          }
-          if(!rc)
-            remainingPrincipalRefs.push(principalEltName);
-          return rc;
-        },
-        (c, cn) => { delete assocCsn._constraints.constraints[cn]; }
-      );
+              (c) => {
+                // rc === true will remove the constraint (positive filter expression)
+                let rc = true;
+                // concatenate all paths in flat mode to identify the correct element
+                // in structured mode only resolve top level element (path rewriting is done elsewhere)
+                const depEltName = ( options.isFlatFormat ? c[0].join('_') : c[0][0] );
+                const principalEltName = ( options.isFlatFormat ? c[1].join('_') : c[1][0] );
+                const fk = (dependentEntity.kind === 'entity' && dependentEntity.elements[depEltName]) ||
+            (localDepEntity && localDepEntity.elements && localDepEntity.elements[depEltName]);
+                const pk = principalEntity.$keys && principalEntity.$keys[principalEltName];
+                if (isConstraintCandidate(fk) && isConstraintCandidate(pk)) {
+                  if (options.isStructFormat) {
+                    // In structured mode it might be the association has a new _parent due to
+                    // type de-anonymization.
+                    // There are three cases for dependent ON condition paths:
+                    // 1) path is relative to assoc in same sub structure
+                    // 2) path is absolute and ends up in a different environment
+                    // 3) path is absolute and touches in assoc's environment
+
+                    // => 1) if _parents are equal, fk path is relative to assoc
+                    if (fk._parent === assocCsn._parent) {
+                      rc = false;
+                    }
+                    // => 2) & 3) if path is not relative to assoc, remove main entity (pos=0) and assoc (pos=n-1)
+                    // and check path identity: If absolute path touches assoc's _parent, add it
+                    else if (!assocCsn.$abspath.slice(1, assocCsn.$abspath.length - 1).some((p, i) => c[0][i] !== p)) {
+                      // this was an absolute addressed path, remove environment prefix
+                      c[0].splice(0, assocCsn.$abspath.length - 2);
+                      rc = false;
+                    }
+                  }
+                  else {
+                    // for flat mode isConstraintCandidate(fk) && isConstraintCandidate(pk) is sufficient
+                    rc = false;
+                  }
+                }
+                if (!rc)
+                  remainingPrincipalRefs.push(principalEltName);
+                return rc;
+              },
+              (c, cn) => {
+                delete assocCsn._constraints.constraints[cn];
+              });
 
       // V2 check that ALL primary keys are constraints
-      if(principalEntity.$keys) {
-        const renderedKeys = Object.values(principalEntity.$keys).filter(isConstraintCandidate).map(v=>v.name);
-        if(options.isV2() && intersect(renderedKeys, remainingPrincipalRefs).length !== renderedKeys.length)
-          if(options.odataV2PartialConstr) {
+      if (principalEntity.$keys) {
+        const renderedKeys = Object.values(principalEntity.$keys).filter(isConstraintCandidate).map(v => v.name);
+        if (options.isV2() && intersect(renderedKeys, remainingPrincipalRefs).length !== renderedKeys.length) {
+          if (options.odataV2PartialConstr) {
             info('odata-spec-violation-constraints',
-                    ['definitions', assocCsn._parent.name, 'elements', assocCsn.name], { version: '2.0' });
+                 [ 'definitions', assocCsn._parent.name, 'elements', assocCsn.name ], { version: '2.0' });
           }
           else {
             assocCsn._constraints.constraints = {};
           }
+        }
       }
     }
-
   }
   // Handle managed association, a managed composition is treated as association
-  else
-  {
+  else if (!assocCsn._target.$isParamEntity && assocCsn.keys) {
     // If FK is key in target => constraint
     // Don't consider primary key associations (fks become keys on the source entity) as
     // this would impose a constraint against the target.
@@ -365,40 +357,36 @@ function finalizeReferentialConstraints(csn, assocCsn, options, info)
 
     // In structured format, foreign keys of managed associations are never rendered, so
     // there are no constraints for them.
-    if(!assocCsn._target.$isParamEntity && assocCsn.keys) {
-      const remainingPrincipalRefs = [];
-      for(let fk of assocCsn.keys) {
-        let realFk = assocCsn._parent.items ? assocCsn._parent.items.elements[fk.$generatedFieldName] : assocCsn._parent.elements[fk.$generatedFieldName];
-        let pk = assocCsn._target.elements[fk.ref[0]];
-        if(pk && pk.key && isConstraintCandidate(pk) && isConstraintCandidate(realFk))
-        {
-          remainingPrincipalRefs.push(fk.ref[0]);
-          const c = [ [ fk.$generatedFieldName ], [ fk.ref[0] ] ];
-          const key = c.join(',');
-          assocCsn._constraints.constraints[key] = c;
-        }
+    const remainingPrincipalRefs = [];
+    for (const fk of assocCsn.keys) {
+      const realFk = assocCsn._parent.items ? assocCsn._parent.items.elements[fk.$generatedFieldName] : assocCsn._parent.elements[fk.$generatedFieldName];
+      const pk = assocCsn._target.elements[fk.ref[0]];
+      if (pk && pk.key && isConstraintCandidate(pk) && isConstraintCandidate(realFk)) {
+        remainingPrincipalRefs.push(fk.ref[0]);
+        const c = [ [ fk.$generatedFieldName ], [ fk.ref[0] ] ];
+        const key = c.join(',');
+        assocCsn._constraints.constraints[key] = c;
       }
+    }
 
-      // V2 check that ALL primary keys are constraints
-      const renderedKeys = Object.values(assocCsn._target.$keys).filter(isConstraintCandidate).map(v=>v.name);
-      if(options.isV2() && intersect(renderedKeys, remainingPrincipalRefs).length !== renderedKeys.length) {
-        if(options.odataV2PartialConstr) {
-          info('odata-spec-violation-constraints',
-                  ['definitions', assocCsn._parent.name, 'elements', assocCsn.name], { version: '2.0' } );
-        }
-        else {
-          assocCsn._constraints.constraints = {};
-        }
+    // V2 check that ALL primary keys are constraints
+    const renderedKeys = Object.values(assocCsn._target.$keys).filter(isConstraintCandidate).map(v => v.name);
+    if (options.isV2() && intersect(renderedKeys, remainingPrincipalRefs).length !== renderedKeys.length) {
+      if (options.odataV2PartialConstr) {
+        info('odata-spec-violation-constraints',
+             [ 'definitions', assocCsn._parent.name, 'elements', assocCsn.name ], { version: '2.0' } );
+      }
+      else {
+        assocCsn._constraints.constraints = {};
       }
     }
   }
 
   // If this association points to a redirected Parameter EntityType, do not calculate any constraints,
   // continue with multiplicity
-  if(assocCsn._target.$isParamEntity)
-  {
+  if (assocCsn._target.$isParamEntity)
     assocCsn._constraints.constraints = Object.create(null);
-  }
+
   return assocCsn._constraints;
 
   /*
@@ -408,7 +396,7 @@ function finalizeReferentialConstraints(csn, assocCsn, options, info)
    * type definition (alias to a scalar type).
    * The element must never be an association or composition and be renderable.
    */
-  function isConstraintCandidate(elt) {
+  function isConstraintCandidate( elt ) {
     return (elt &&
             elt.type &&
             (!options.isFlatFormat || options.isFlatFormat && isBuiltinType(elt.type)) &&
@@ -417,8 +405,7 @@ function finalizeReferentialConstraints(csn, assocCsn, options, info)
   }
 }
 
-function determineMultiplicity(csn)
-{
+function determineMultiplicity( csn ) {
   /*
     =>  SRC Cardinality
     CDS   => EDM
@@ -450,67 +437,66 @@ function determineMultiplicity(csn)
   */
 
   const isAssoc = csn.type === 'cds.Association';
-  if(!csn.cardinality)
+  if (!csn.cardinality)
     csn.cardinality = Object.create(null);
 
-  if(!csn.cardinality.src)
+  if (!csn.cardinality.src)
     csn.cardinality.src = isAssoc ? '*' : '1';
-  if(!csn.cardinality.min)
+  if (!csn.cardinality.min)
     csn.cardinality.min = 0;
-  if(!csn.cardinality.max)
+  if (!csn.cardinality.max)
     csn.cardinality.max = 1;
 
-  const srcCardinality =
-    (csn.cardinality.src == 1)
-      ? (!isAssoc || csn.cardinality.srcmin == 1)
-          ? '1'
-          : '0..1'
+  const srcCardinality
+    = (csn.cardinality.src == 1) // eslint-disable-line eqeqeq
+      ? (!isAssoc || csn.cardinality.srcmin == 1) // eslint-disable-line eqeqeq
+        ? '1'
+        : '0..1'
       : '*';
-  const  tgtCardinality =
-    (csn.cardinality.max > 1 || csn.cardinality.max === '*')
+  const tgtCardinality
+    = (csn.cardinality.max > 1 || csn.cardinality.max === '*')
       ? '*'
-      : (csn.cardinality.min == 1)
+      : (csn.cardinality.min == 1) // eslint-disable-line eqeqeq
         ? '1'
         : '0..1';
 
-  return [srcCardinality, tgtCardinality];
+  return [ srcCardinality, tgtCardinality ];
 }
 
 // return effective target cardinality
 // If csn is a backlink, return the source cardinality (including srcmin/src) from
 // the forward association
 // This function works only after finalizeConstraints
-function getEffectiveTargetCardinality(csn) {
+function getEffectiveTargetCardinality( csn ) {
   const rc = { min: 0, max: 1 };
-  if(!csn._constraints || !csn._constraints.$finalized)
-    throw new CompilerAssertion('_constraints missing or not finalized: "' + csn.name);
+  if (!csn._constraints || !csn._constraints.$finalized)
+    throw new CompilerAssertion(`_constraints missing or not finalized: "${csn.name}`);
   // partner (forward) cardinality has precedence
-  if(csn._constraints._partnerCsn) {
-    if(csn._constraints._partnerCsn.cardinality?.srcmin)
+  if (csn._constraints._partnerCsn) {
+    if (csn._constraints._partnerCsn.cardinality?.srcmin)
       rc.min = csn._constraints._partnerCsn.cardinality.srcmin;
-    if(csn._constraints._partnerCsn.cardinality?.src)
+    if (csn._constraints._partnerCsn.cardinality?.src)
       rc.max = csn._constraints._partnerCsn.cardinality.src;
   }
-  else if(csn.cardinality) {
-    if(csn.cardinality.min)
+  else if (csn.cardinality) {
+    if (csn.cardinality.min)
       rc.min = csn.cardinality.min;
-    if(csn.cardinality.max)
-      rc.max = csn.cardinality.max
+    if (csn.cardinality.max)
+      rc.max = csn.cardinality.max;
   }
   return rc;
 }
 
-function mapCdsToEdmType(csn, messageFunctions, isV2=false, isMediaType=false, location=undefined)
-{
-  if(location === undefined)
+function mapCdsToEdmType( csn, messageFunctions, isV2 = false, isMediaType = false, location = undefined ) {
+  if (location === undefined)
     location = csn.$path;
-  const { error } = messageFunctions || { error: ()=>true };
-  let cdsType = csn.type;
-  if(cdsType === undefined) {
+  const { error } = messageFunctions || { error: () => true };
+  const cdsType = csn.type;
+  if (cdsType === undefined) {
     error(null, location, 'no type found');
     return '<NOTYPE>';
   }
-  if(!isBuiltinType(cdsType))
+  if (!isBuiltinType(cdsType))
     return cdsType;
 
   let edmType = {
@@ -565,29 +551,25 @@ function mapCdsToEdmType(csn, messageFunctions, isV2=false, isMediaType=false, l
     Edm.GeometryCollection
     */
   }[cdsType];
-  if (edmType == undefined) {
+  if (!edmType)
     error(null, location, { type: cdsType }, 'No EDM type available for $(TYPE)');
-  }
-  if(isV2)
-  {
+
+  if (isV2) {
     if (edmType === 'Edm.Date')
       edmType = 'Edm.DateTime';
     if (edmType === 'Edm.TimeOfDay')
       edmType = 'Edm.Time';
   }
-  else // isV4
-  {
-    // CDXCORE-CDXCORE-173
-    if(isMediaType)
-      edmType = 'Edm.Stream';
+  else if (isMediaType) { // isV4
+  // CDXCORE-CDXCORE-173
+    edmType = 'Edm.Stream';
   }
   return edmType;
 }
 
-function addTypeFacets(node, csn)
-{
+function addTypeFacets( node, csn ) {
   const isV2 = node.v2;
-  const decimalTypes = {'cds.Decimal':1, 'cds.DecimalFloat':1, 'cds.hana.SMALLDECIMAL':1};
+  const decimalTypes = { 'cds.Decimal': 1, 'cds.DecimalFloat': 1, 'cds.hana.SMALLDECIMAL': 1 };
   if (csn.length != null)
     node.setEdmAttribute('MaxLength', csn.length);
   if (csn.scale !== undefined)
@@ -601,32 +583,32 @@ function addTypeFacets(node, csn)
   //   node.Precision = 16;
   else if (csn.type === 'cds.Timestamp' && node._edmAttributes.Type === 'Edm.DateTimeOffset')
     node.setEdmAttribute('Precision', 7);
-  if(csn.type in decimalTypes) {
-    if(isV2) {
+  if (csn.type in decimalTypes) {
+    if (isV2) {
       // no prec/scale or scale is 'floating'/'variable'
-      if(!(csn.precision || csn.scale) || (csn.scale === 'floating' || csn.scale === 'variable')) {
+      if (!(csn.precision || csn.scale) || (csn.scale === 'floating' || csn.scale === 'variable')) {
         node.setXml( { 'sap:variable-scale': true } );
         node.removeEdmAttribute('Scale');
       }
     }
     else {
       // map both floating and variable to => variable
-      if(node._edmAttributes.Scale === 'floating')
+      if (node._edmAttributes.Scale === 'floating')
         node.setEdmAttribute('Scale', 'variable');
-      if(!csn.precision && !csn.scale)
+      if (csn.precision == null && csn.scale == null)
         // if Decimal has no p, s set scale 'variable'
         node.setXml( { Scale: 'variable' } ); // floating is V4.01
     }
   }
   // Unicode unused today
-  if(csn.unicode)
+  if (csn.unicode)
     node.setEdmAttribute('Unicode', csn.unicode);
-  if(csn.srid)
+  if (csn.srid)
     node.setEdmAttribute('SRID', csn.srid);
 }
 
 
-  /**
+/**
    * A simple identifier is a Unicode character sequence with the following restrictions:
    * - The first character MUST be the underscore character (U+005F) or any character in the Unicode category “Letter (L)” or “Letter number (Nl)”
    * - The remaining characters MUST be the underscore character (U+005F) or any character in the Unicode category:
@@ -641,9 +623,9 @@ function addTypeFacets(node, csn)
    *
    * @param {string} identifier
    */
-function isODataSimpleIdentifier(identifier){
+function isODataSimpleIdentifier( identifier ) {
   // this regular expression reflects the specification from above
-  const regex = /^[\p{Letter}\p{Nl}_][_\p{Letter}\p{Nl}\p{Nd}\p{Mn}\p{Mc}\p{Pc}\p{Cf}]{0,127}$/gu
+  const regex = /^[\p{Letter}\p{Nl}_][_\p{Letter}\p{Nl}\p{Nd}\p{Mn}\p{Mc}\p{Pc}\p{Cf}]{0,127}$/gu;
   return identifier && identifier.match(regex);
 }
 
@@ -669,7 +651,7 @@ function isODataSimpleIdentifier(identifier){
  * @param {string} str
  * @returns {string}
  */
-function escapeStringForAttributeValue(str) {
+function escapeStringForAttributeValue( str ) {
   if (typeof str !== 'string')
     return str;
 
@@ -718,7 +700,7 @@ function escapeStringForAttributeValue(str) {
  * @param {string} str
  * @returns {string}
  */
-function escapeStringForText(str) {
+function escapeStringForText( str ) {
   if (typeof str !== 'string')
     return str;
 
@@ -749,70 +731,70 @@ function escapeStringForText(str) {
  * @param {number} codePoint
  * @returns {string}
  */
-function encodeNonCharacters(codePoint) {
+function encodeNonCharacters( codePoint ) {
   const hex = codePoint.toString(16).toUpperCase();
   return `&#x${hex};`;
 }
 
 // return the path prefix of a given name or if no prefix available 'root'
-function getSchemaPrefix(name) {
+function getSchemaPrefix( name ) {
   const lastDotIdx = name.lastIndexOf('.');
   return (lastDotIdx > 0 ) ? name.substring(0, lastDotIdx) : 'root';
 }
 
 // get artifacts base name
-function getBaseName(name) {
+function getBaseName( name ) {
   const lastDotIdx = name.lastIndexOf('.');
-  return (lastDotIdx > 0 ) ? name.substring(lastDotIdx+1, name.length) : name;
+  return (lastDotIdx > 0 ) ? name.substring(lastDotIdx + 1, name.length) : name;
 }
 
 // This is a poor mans path resolver for $self partner paths only
-function resolveOriginAssoc(csn, env, path) {
-  for(const segment of path) {
-    let elements = (env.items && env.items.elements || env.elements);
-    if(elements)
-      env = env.elements[segment];
-    let type = (env.items && env.items.type || env.type);
-    if(type && !isBuiltinType(type) && !(env.items && env.items.elements || env.elements))
-      env = csn.definitions[env.type];
+function resolveOriginAssoc( csn, env, path ) {
+  for (const segment of path) {
+    const elements = (env?.items?.elements || env?.elements);
+    if (elements)
+      env = elements[segment];
+    const type = (env?.items?.type || env?.type);
+    if (type && !isBuiltinType(type) && !(env?.items?.elements || env?.elements))
+      env = csn.definitions[type];
   }
   return env;
 }
 
-function mergeIntoNavPropEntry(annoPrefix, navPropEntry, prefix, props) {
+function mergeIntoNavPropEntry( annoPrefix, navPropEntry, prefix, props ) {
   let newEntry = false;
 
   // Filter properties with prefix and reduce them into a new dictionary
-  const o = props.filter(p => p[0].startsWith(annoPrefix+'.')).reduce((a,c) => {
+  const o = props.filter(p => p[0].startsWith(`${annoPrefix}.`)).reduce((a, c) => {
     // clone the annotation value to avoid side effects with rewritten paths
-    a[c[0].replace(annoPrefix+'.', '')] = cloneAnnotationValue(c[1]);
+    a[c[0].replace(`${annoPrefix}.`, '')] = cloneAnnotationValue(c[1]);
     return a;
   }, { });
 
   // BEFORE merging found capabilities, prefix the paths
-  applyTransformations({ definitions: { o }}, {
+  applyTransformations({ definitions: { o } }, {
     '=': (parent, prop, value) => {
       parent[prop] = prefix.concat(value).join('.');
-    }
+    },
   });
   // don't overwrite existing restrictions
   const prop = annoPrefix.split('.')[1];
-  if(!navPropEntry[prop]) {
+  if (!navPropEntry[prop]) {
     // if dictionary has entries, add them to navPropEntry
-    if(Object.keys(o).length) {
+    if (Object.keys(o).length) {
       // ReadRestrictions may have sub type ReadByKeyRestrictions { Description, LongDescription }
       // chop annotations into dictionaries
-      if(annoPrefix === '@Capabilities.ReadRestrictions' &&
+      if (annoPrefix === '@Capabilities.ReadRestrictions' &&
                       Object.keys(o).some(k => k.startsWith('ReadByKeyRestrictions.'))) {
         const no = {};
-        Object.entries(o).forEach(([k,v]) => {
-          const [head, ...tail] = k.split('.');
-          if(head === 'ReadByKeyRestrictions' && tail.length) {
-            if(!no['ReadByKeyRestrictions'])
-              no['ReadByKeyRestrictions'] = {};
-                        // Don't try to add entry into non object
-            if(typeof no['ReadByKeyRestrictions'] === 'object')
-              no['ReadByKeyRestrictions'][tail.join('.')] = v;
+        Object.entries(o).forEach(([ k, v ]) => {
+          const [ head, ...tail ] = k.split('.');
+          if (head === 'ReadByKeyRestrictions' && tail.length) {
+            if (!no.ReadByKeyRestrictions)
+              no.ReadByKeyRestrictions = {};
+            // Don't try to add entry into non object
+            if (typeof no.ReadByKeyRestrictions === 'object')
+              no.ReadByKeyRestrictions[tail.join('.')] = v;
           }
           else {
             no[k] = v;
@@ -828,8 +810,8 @@ function mergeIntoNavPropEntry(annoPrefix, navPropEntry, prefix, props) {
   }
   else {
     // merge but don't overwrite into existing navprop
-    Object.entries(o).forEach(([k,v]) => {
-      if(!navPropEntry[prop][k])
+    Object.entries(o).forEach(([ k, v ]) => {
+      if (!navPropEntry[prop][k])
         navPropEntry[prop][k] = v;
     });
   }
@@ -837,57 +819,54 @@ function mergeIntoNavPropEntry(annoPrefix, navPropEntry, prefix, props) {
 }
 
 // Assign but not overwrite annotation
-function assignAnnotation(node, name, value) {
-  if(value !== undefined &&
-      name !== undefined && name[0] === '@' &&
-      (node[name] === undefined || node[name] === null)) {
-    node[name] = value;
-  }
+function assignAnnotation( node, name, value ) {
+  if (value !== undefined &&
+      name !== undefined && name[0] === '@')
+    node[name] ??= value;
 }
 
 // Set non enumerable property if it doesn't exist yet
-function assignProp(obj, prop, value) {
-  if(obj[prop] === undefined) {
+function assignProp( obj, prop, value ) {
+  if (obj[prop] === undefined)
     setProp(obj, prop, value);
-  }
 }
 
 //
-  // create Cross Schema Reference object
-  //
-function createSchemaRef(serviceRoots, targetSchemaName) {
-    // prepend as many path ups '..' as there are path steps in the service ref
-  let serviceRef = path4(serviceRoots[targetSchemaName]).split('/').filter(c=>c.length);
+// create Cross Schema Reference object
+//
+function createSchemaRef( serviceRoots, targetSchemaName ) {
+  // prepend as many path ups '..' as there are path steps in the service ref
+  const serviceRef = path4(serviceRoots[targetSchemaName]).split('/').filter(c => c.length);
   serviceRef.splice(0, 0, ...Array(serviceRef.length).fill('..'));
-    // uncomment this to make $metadata absolute
-    // if(serviceRef.length===0)
-    //   serviceRef.push('');
-  if(serviceRef[serviceRef.length-1] !== '$metadata')
+  // uncomment this to make $metadata absolute
+  // if(serviceRef.length===0)
+  //   serviceRef.push('');
+  if (serviceRef[serviceRef.length - 1] !== '$metadata')
     serviceRef.push('$metadata');
-  let sc = { kind: 'reference',
+  const sc = {
+    kind: 'reference',
     name: targetSchemaName,
     ref: { Uri: serviceRef.join('/') },
-    inc: { Namespace: targetSchemaName }
+    inc: { Namespace: targetSchemaName },
   };
   setProp(sc, '$mySchemaName', targetSchemaName);
   return sc;
 
-    /**
+  /**
      * Resolve a service endpoint path to mount it to as follows...
      * Use _path or def[@path] if given (and remove leading '/')
      * Otherwise, use the service definition name with stripped 'Service'
      */
-  function path4 (def, _path = def['@path']) {
+  function path4( def, _path = def['@path'] ) {
     if (_path)
       return _path.replace(/^\//, '');
-    else
-        return ( // generate one from the service's name
-          /[^.]+$/.exec(def.name)[0]  //> my.very.CatalogService --> CatalogService
-          .replace(/Service$/,'')     //> CatalogService --> Catalog
-          .replace(/([a-z0-9])([A-Z])/g, (_,c,C) => c+'-'+C.toLowerCase())  //> ODataFooBarX9 --> odata-foo-bar-x9
-          .replace(/_/g,'-')  //> foo_bar_baz --> foo-bar-baz
-          .toLowerCase()      //> FOO --> foo
-        )
+    return ( // generate one from the service's name
+      /[^.]+$/.exec(def.name)[0]  // > my.very.CatalogService --> CatalogService
+        .replace(/Service$/, '')     // > CatalogService --> Catalog
+        .replace(/([a-z0-9])([A-Z])/g, (_, c, C) => `${c}-${C.toLowerCase()}`)  // > ODataFooBarX9 --> odata-foo-bar-x9
+        .replace(/_/g, '-')  // > foo_bar_baz --> foo-bar-baz
+        .toLowerCase()      // > FOO --> foo
+    );
   }
 }
 
@@ -918,5 +897,5 @@ module.exports = {
   escapeStringForText,
   getSchemaPrefix,
   getBaseName,
-  mergeIntoNavPropEntry
-}
+  mergeIntoNavPropEntry,
+};