@sap/cds-compiler 2.5.2 → 2.11.0

package/lib/edm/edmUtils.js

@@ -1,4 +1,5 @@
 'use strict';
+const { setProp } = require('../base/model');
 const { isBuiltinType, isEdmPropertyRendered } = require('../model/csnUtils');
 
 /* eslint max-statements-per-line:off */
@@ -114,6 +115,12 @@ function isToMany(assoc) {
   return targetMax === '*' || Number(targetMax) > 1;
 }
 
+function isSingleton(entityCsn, v) {
+  const singleton = entityCsn['@odata.singleton'];
+  const hasNullable = entityCsn['@odata.singleton.nullable'] !== undefined && entityCsn['@odata.singleton.nullable'] !== null;
+  return v && singleton || ((singleton === undefined || singleton === null) && hasNullable);
+}
+
 function isEntity(artifact)
 {
   return ['entity'].includes(artifact.kind);
@@ -142,7 +149,7 @@ function isActionOrFunction(artifact) {
   return ['action', 'function'].includes(artifact.kind);
 }
 
-function resolveOnConditionAndPrepareConstraints(assocCsn, messageFunctions) {
+function resolveOnConditionAndPrepareConstraints(csn, assocCsn, messageFunctions) {
   if(!assocCsn._constraints)
     throw Error('Please debug me: need _constraints');
 
@@ -154,7 +161,7 @@ function resolveOnConditionAndPrepareConstraints(assocCsn, messageFunctions) {
     getExpressionArguments(assocCsn.on);
 
     // for all $self conditions, fill constraints of partner (if any)
-    let isBacklink = assocCsn._constraints.selfs.length == 1 && assocCsn._constraints.termCount == 1;
+    let isBacklink = assocCsn._constraints.selfs.length === 1 && assocCsn._constraints.termCount === 1;
 
     /* example for _originalTarget:
     entity E (with parameters) {
@@ -167,27 +174,35 @@ function resolveOnConditionAndPrepareConstraints(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(partner => {
-      const originAssocCsn = (assocCsn._originalTarget || assocCsn._target).elements[partner];
-      const parentArtifactName = assocCsn._parent.name;
+    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) {
-        if(originAssocCsn._originalTarget !== assocCsn._parent && originAssocCsn._target !== assocCsn._parent) {
+        const originParentName = originAssocCsn.$abspath[0];
+        if(parent.$mySchemaName && originAssocCsn._originalTarget !== parent && originAssocCsn._target !== parent) {
           isBacklink = false;
-          info(null, ['definitions', parentArtifactName, 'elements', assocCsn.name],
-            `"${originAssocCsn._parent.name}:${partner}" with target "${originAssocCsn._target.name}" is compared with $self which represents "${parentArtifactName}"`);
+          // 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}"`);
         }
         if(isAssociationOrComposition(originAssocCsn)) {
           // Mark this association as backlink if $self appears exactly once
           // to surpress edm:Association generation in V2 mode
           if(isBacklink) {
-            // use first backlink as partner
+            // establish partnership with origin assoc but only if this association is the first one
             if(originAssocCsn._selfReferences.length === 0) {
               assocCsn._constraints._partnerCsn = originAssocCsn;
             }
             else {
               isBacklink = false;
             }
-            // collect all backlinks at forward association
+          }
+          // 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) {
             originAssocCsn._selfReferences.push(assocCsn);
           }
           assocCsn._constraints._origins.push(originAssocCsn);
@@ -203,8 +218,8 @@ function resolveOnConditionAndPrepareConstraints(assocCsn, messageFunctions) {
       }
       else
       {
-        warning(null, ['definitions', parentArtifactName],
-        { partner: `${assocCsn._target.name}/${partner}`, name: `${parentArtifactName}/${assocCsn.name}` },
+        warning(null, ['definitions', parentName],
+        { partner: `${assocCsn._target.name}/${partnerPath}`, name: `${parentName}/${assocCsn.name}` },
         'Can\'t resolve backlink to $(PARTNER) from $(NAME)');
       }
     });
@@ -268,7 +283,7 @@ function resolveOnConditionAndPrepareConstraints(assocCsn, messageFunctions) {
               // do we have a $self id?
               // if so, store partner in selfs array
               if(c[0][0] === '$self' && c[0].length === 1) {
-                assocCsn._constraints.selfs.push(c[1][0]);
+                assocCsn._constraints.selfs.push(c[1]);
               } else {
                 const key = c.join(',');
                 assocCsn._constraints.constraints[key] = c;
@@ -281,7 +296,7 @@ function resolveOnConditionAndPrepareConstraints(assocCsn, messageFunctions) {
   }
 }
 
-function finalizeReferentialConstraints(assocCsn, options, warning)
+function finalizeReferentialConstraints(csn, assocCsn, options, info)
 {
   if(!assocCsn._constraints)
     throw Error('Please debug me: need _constraints');
@@ -317,11 +332,16 @@ function finalizeReferentialConstraints(assocCsn, options, warning)
     });
 
     if(!assocCsn._target.$isParamEntity) {
-      // Header is composed of Items => Cds.Composition: Header is principal => use header's primary keys
-      let dependentEntity = assocCsn._parent;
+      // 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;
+      // _target must always be a main artifact
       let principalEntity = assocCsn._target;
       if(assocCsn.type === 'cds.Composition') {
-        principalEntity = assocCsn._parent;
+      // 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 => {
@@ -332,14 +352,44 @@ function finalizeReferentialConstraints(assocCsn, options, warning)
       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 fk = dependentEntity.elements[ ( options.isFlatFormat ? c[0].join('_') : c[0][0] )];
-          const principalEltRef = ( options.isFlatFormat ? c[1].join('_') : c[1][0] );
-          const pk = principalEntity.$keys && principalEntity.$keys[ principalEltRef ];
-          if(isConstraintCandidate(fk) && isConstraintCandidate(pk))
-            remainingPrincipalRefs.push(principalEltRef);
-          return !(isConstraintCandidate(fk) && isConstraintCandidate(pk));
+          const depEltName = ( options.isFlatFormat ? c[0].join('_') : c[0][0] );
+          const principalEltName = ( options.isFlatFormat ? c[1].join('_') : c[1][0] );
+          const fk = (isEntity(dependentEntity) && 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]; }
       );
@@ -349,8 +399,8 @@ function finalizeReferentialConstraints(assocCsn, options, warning)
         const renderedKeys = Object.values(principalEntity.$keys).filter(isConstraintCandidate).map(v=>v.name);
         if(options.isV2() && intersect(renderedKeys, remainingPrincipalRefs).length !== renderedKeys.length)
           if(options.odataV2PartialConstr) {
-            warning('odata-spec-violation-constraints', ['definitions', assocCsn._parent.name, 'elements', assocCsn.name],
-          'Partial referential constraints (not spec compliant) produced based on user setting');
+            info('odata-spec-violation-constraints',
+                    ['definitions', assocCsn._parent.name, 'elements', assocCsn.name], { api: 'OData V2' });
           }
           else {
             assocCsn._constraints.constraints = {};
@@ -387,8 +437,8 @@ function finalizeReferentialConstraints(assocCsn, options, warning)
       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) {
-          warning('odata-spec-violation-constraints', ['definitions', assocCsn._parent.name, 'elements', assocCsn.name],
-          'Partial referential constraints (not spec compliant) produced based on user setting');
+          info('odata-spec-violation-constraints',
+                  ['definitions', assocCsn._parent.name, 'elements', assocCsn.name], { api: 'OData V2' } );
         }
         else {
           assocCsn._constraints.constraints = {};
@@ -474,7 +524,7 @@ function determineMultiplicity(csn)
 
 function mapCdsToEdmType(csn, messageFunctions, isV2=false, isMediaType=false)
 {
-  const { warning, error } = messageFunctions;
+  const { error } = messageFunctions || { error: ()=>true };
   let cdsType = csn.type;
   if(cdsType === undefined) {
     error(null, csn.$location, `no type found`);
@@ -543,8 +593,6 @@ function mapCdsToEdmType(csn, messageFunctions, isV2=false, isMediaType=false)
     if(['cds.hana.ST_POINT', 'cds.hana.ST_GEOMETRY'].includes(cdsType)) {
       error(null, csn.$path, { type: cdsType }, `OData V2 does not support Geometry data types, $(TYPE) can't be mapped`);
     }
-    if(cdsType === 'cds.DecimalFloat' || cdsType === 'cds.hana.SMALLDECIMAL')
-      warning(null, csn.$path, { type: cdsType }, `OData V2 does not support $(TYPE)`);
   }
   else // isV4
   {
@@ -571,13 +619,21 @@ function addTypeFacets(node, csn)
   //   node.Precision = 16;
   else if (csn.type === 'cds.Timestamp' && node.Type === 'Edm.DateTimeOffset')
     node.Precision = 7;
-  else if([ 'cds.Decimal', 'cds.DecimalFloat', 'cds.hana.SMALLDECIMAL' ].includes(csn.type) && !csn.precision && !csn.scale) {
+  if([ 'cds.Decimal', 'cds.DecimalFloat', 'cds.hana.SMALLDECIMAL' ].includes(csn.type)) {
     if(isV2) {
-      node.setXml( { 'sap:variable-scale': true } );
+      // no prec/scale or scale is 'floating'/'variable'
+      if(!(csn.precision || csn.scale) || ['floating', 'variable'].includes(csn.scale)) {
+        node.setXml( { 'sap:variable-scale': true } );
+        delete node.Scale;
+      }
     }
     else {
-      // if Decimal has no p, s set scale 'variable'
-      node.setXml( { Scale: 'variable' } ); // floating is V4.01
+      // map both floating and variable to => variable
+      if(node.Scale === 'floating')
+        node.Scale = 'variable';
+      if(!csn.precision && !csn.scale)
+        // if Decimal has no p, s set scale 'variable'
+        node.setXml( { Scale: 'variable' } ); // floating is V4.01
     }
   }
   // Unicode unused today
@@ -636,6 +692,19 @@ function getBaseName(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(let i = 0; i < path.length; i++) {
+    let elements = (env.items && env.items.elements || env.elements);
+    if(elements)
+      env = env.elements[path[i]];
+    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];
+  }
+  return env;
+}
+
 module.exports = {
   validateOptions,
   intersect,
@@ -647,6 +716,7 @@ module.exports = {
   isComposition,
   isAssociationOrComposition,
   isToMany,
+  isSingleton,
   isEntity,
   isStructuredType,
   isStructuredArtifact,

package/lib/gen/Dictionary.json

@@ -729,6 +729,13 @@
       ],
       "$experimental": true
     },
+    "Common.Composition": {
+      "Type": "Core.Tag",
+      "AppliesTo": [
+        "NavigationProperty"
+      ],
+      "$experimental": true
+    },
     "Common.SAPObjectNodeTypeReference": {
       "Type": "Edm.String",
       "AppliesTo": [
@@ -1345,6 +1352,9 @@
     "Core.SymbolicName": {
       "Type": "Core.SimpleIdentifier"
     },
+    "Core.GeometryFeature": {
+      "Type": "Core.GeometryFeatureType"
+    },
     "Graph.links": {
       "Type": "Collection(Graph.link)",
       "AppliesTo": [
@@ -3018,6 +3028,14 @@
         "DefaultValue": "Edm.String"
       }
     },
+    "Core.GeometryFeatureType": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "geometry": "Edm.Geometry",
+        "properties": "Core.Dictionary",
+        "id": "Edm.String"
+      }
+    },
     "Core.RevisionKind": {
       "$kind": "EnumType",
       "Members": [
@@ -3066,6 +3084,10 @@
       "$kind": "TypeDefinition",
       "UnderlyingType": "Edm.String"
     },
+    "Core.QualifiedActionName": {
+      "$kind": "TypeDefinition",
+      "UnderlyingType": "Edm.String"
+    },
     "Core.LocalDateTime": {
       "$kind": "TypeDefinition",
       "UnderlyingType": "Edm.String"

package/lib/gen/language.checksum

@@ -1 +1 @@
-30c3c4af0d829a94ab568af3036f12a9
+e80280336eed20b6633835d33df8ec76