@sap/cds-compiler 4.0.2 → 4.1.2

package/lib/compiler/tweak-assocs.js

@@ -14,11 +14,13 @@ const {
   setArtifactLink,
   linkToOrigin,
   copyExpr,
+  forEachUserArtifact,
+  forEachQueryExpr,
   traverseQueryPost,
   traverseQueryExtra,
   setExpandStatus,
-  traverseExpr,
 } = require('./utils');
+const { CsnLocation } = require('./classes');
 
 const $location = Symbol.for('cds.$location');
 const $inferred = Symbol.for('cds.$inferred');
@@ -30,9 +32,11 @@ function tweakAssocs( model ) {
     info, warning, error,
   } = model.$messageFunctions;
   const {
+    traverseExpr,
+    checkExpr,
+    checkOnCondition,
     effectiveType,
     getOrigin,
-    navigationEnv,
   } = model.$functions;
 
   // Phase 5: rewrite associations
@@ -40,6 +44,13 @@ function tweakAssocs( model ) {
   // Think hard whether an on condition rewrite can lead to a new cyclic
   // dependency.  If so, we need other messages anyway.  TODO: probably do
   // another cyclic check with testMode.js
+  forEachUserArtifact( model, 'definitions', function check( art ) {
+    checkOnCondition( art.on, (art.kind !== 'mixin' ? 'on' : 'mixin-on'), art );
+    checkExpr( art.value, (art.$syntax === 'calc' ? 'calc' : 'column'), art );
+
+    if (art.kind === 'select')
+      forEachQueryExpr( art, checkExpr );
+  } );
   return;
 
 
@@ -166,13 +177,9 @@ function tweakAssocs( model ) {
     }
     if (names.length) {
       const loc = otherAssoc.foreignKeys[$location] || dictLocation( otherAssoc.foreignKeys );
-      const location = loc && (!loc.endCol ? loc : {
-        file: loc.file,
-        line: loc.endLine,
-        col: loc.endCol - 1,
-        endLine: loc.endLine,
-        endCol: loc.endCol,
-      } );
+      const location = loc && (!loc.endCol
+        ? loc
+        : new CsnLocation( loc.file, loc.endLine, loc.endCol - 1, loc.endLine, loc.endCol ));
       const baseAssoc = assocWithExplicitSpec( thisAssoc );
       if (inferredForeignKeys( baseAssoc.foreignKeys )) { // still inferred = via target keys
         error( 'rewrite-key-not-covered-implicit', [ location, otherAssoc ],
@@ -482,8 +489,12 @@ function tweakAssocs( model ) {
         item.id = name;
       }
     }
-    const env = name && navigationEnv(elem);
+    let env = name && elem._effectiveType; //  should have been computed
+    // refs in ON cannot navigate along `items`, no need to consider `items` here
+    if (env?.target)
+      env = env.target._artifact?._effectiveType;
     elem = setArtifactLink( item, env?.elements?.[name] );
+
     if (elem && !Array.isArray(elem))
       return elem;
     // TODO: better (extra message), TODO: do it

package/lib/compiler/utils.js

@@ -6,12 +6,15 @@
 // Please do not add functions “for completeness”, this is not an API file for
 // others but only by the core compiler.
 
-// TODO: probably split this file into utils/….js
+// TODO: split this file into utils/….js, add some functions from lib/base/model.js
 
 'use strict';
 
 const { dictAdd, pushToDict, dictFirst } = require('../base/dictionaries');
 const { kindProperties } = require('./base');
+const { XsnName, XsnArtifact, CsnLocation } = require('./classes');
+
+const $inferred = Symbol.for('cds.$inferred');
 
 // for links, i.e., properties starting with an underscore '_':
 
@@ -108,15 +111,18 @@ function linkToOrigin( origin, name, parent, prop, location, silentDep ) {
 
 function proxyCopyMembers( art, dictProp, originDict, location, kind ) {
   art[dictProp] = Object.create( null );
+  // TODO: set $inferred ? for dict?
   for (const name in originDict) {
     const origin = originDict[name];
-    const member = linkToOrigin( origin, name, art, dictProp,
-                                 location || origin.location, true );
-    member.$inferred = 'expanded';
-    if (kind)
-      member.kind = kind;
-    if (kind && origin.masked)  // TODO: remove!
-      member.masked = Object.assign( { $inferred: 'nav' }, origin.masked );
+    if (origin !== undefined) {
+      const member = linkToOrigin( origin, name, art, dictProp,
+                                   location || origin.location, true );
+      member.$inferred = 'expanded';
+      if (kind)
+        member.kind = kind;
+      if (kind && origin.masked)  // TODO: remove!
+        member.masked = Object.assign( { $inferred: 'nav' }, origin.masked );
+    }
   }
 }
 
@@ -132,7 +138,7 @@ function setMemberParent( elem, name, parent, prop ) {
   if (prop) {              // extension or structure include
     // TODO: consider nested ARRAY OF and RETURNS, COMPOSITION OF type
     const p = parent.items || parent.targetAspect || parent;
-    if (!(prop in p))
+    if (p[prop] === undefined)
       p[prop] = Object.create(null);
     dictAdd( p[prop], name, elem );
   }
@@ -166,10 +172,12 @@ function setMemberParent( elem, name, parent, prop ) {
  * @param {XSN.Artifact} art
  * @param {XSN.Location} location
  */
-function dependsOn( user, art, location ) {
+function dependsOn( user, art, location, semanticLoc = undefined ) {
+  while (user._outer && !user.kind)
+    user = user._outer;
   if (!user._deps)
     setLink( user, '_deps', [] );
-  user._deps.push( { art, location } );
+  user._deps.push( { art, location, semanticLoc } );
 }
 
 /**
@@ -180,6 +188,8 @@ function dependsOn( user, art, location ) {
  * @param {XSN.Artifact} art
  */
 function dependsOnSilent( user, art ) {
+  while (user._outer && !user.kind)
+    user = user._outer;
   if (!user._deps)
     setLink( user, '_deps', [] );
   user._deps.push( { art } );
@@ -253,7 +263,9 @@ function copyExpr( expr, location, skipUnderscored, rewritePath ) {
     return expr.map( e => copyExpr( e, location, skipUnderscored, rewritePath ) );
 
   const proto = Object.getPrototypeOf( expr );
-  if (proto && proto !== Object.prototype) // do not copy object from special classes
+  if (proto && proto !== Object.prototype && proto !== XsnName.prototype &&
+      // do not copy object from special classes outside the compiler domain&&
+      proto !== XsnArtifact.prototype && proto !== CsnLocation.prototype)
     return expr;
   const r = Object.create( proto );
   for (const prop of Object.getOwnPropertyNames( expr )) {
@@ -299,7 +311,7 @@ function testExpr( expr, pathTest, queryTest, user ) {
       return expr.args.some( e => testExpr( e, pathTest, queryTest, user ) );
     // named args => dictionary
     for (const namedArg of Object.keys(expr.args)) {
-      if (testExpr(expr.args[namedArg], pathTest, queryTest, user))
+      if (testExpr( expr.args[namedArg], pathTest, queryTest, user ))
         return true;
     }
   }
@@ -314,6 +326,129 @@ function targetMaxNotOne( assoc, item ) {
   return cardinality && cardinality.targetMax && cardinality.targetMax.val !== 1;
 }
 
+/**
+ * Call function `callback(art)` for each user-defined main artifact and member
+ * `art` of the model reachable from the dictionary `model[prop]`.  User-defined
+ * artifacts are those with no or a falsy `art.$inferred` value, i.e. this
+ * function is useful for checks.
+ *
+ * The callback function is not called on the following artifacts:
+ * - `enum` symbol definitions (use forEachUserDict() yourself if needed)
+ * - the anonymous aspect in the `target`/`targetAspect` property (but the
+ *   callback function is called on its elements).
+ * - table aliases
+ *
+ * The callback function is also called on duplicates.  For example, if there are
+ * two entities named `E`, the callback function is called on both.
+ * It is also called on columns with `inline`.
+ *
+ * See also function forEachDefinition(), currently in lib/base/model.js.
+ */
+function forEachUserArtifact( model, prop, callback ) { // not enums
+  forEachUserDict( model, prop, function main( art ) {
+    callback( art );
+    forEachUserDict( art, 'params', function param( par ) {
+      callback( par );
+      forEachUserElementAndFKey( par, callback );
+    } );
+    if (art.$queries) {
+      for (const query of art.$queries) {
+        callback( query );
+        forEachUserDict( query, 'mixin', callback );
+        forEachUserElementAndFKey( query, callback );
+        if (query.$inlines)     // e.g. not with `entity V as projection on V;`
+          query.$inlines.forEach( callback );
+      }
+    }
+    else if (art.returns) {
+      callback( art.returns );
+      forEachUserElementAndFKey( art.returns, callback );
+    }
+    else {
+      forEachUserElementAndFKey( art, callback );
+    }
+    forEachUserArtifact( art, 'actions', callback );
+  } );
+}
+
+/**
+ * Call function `callback(art)` for each user-defined element and foreign key
+ * reachable from artifact `art`.  Do not (again) call the callback function on
+ * `art` itself, even if it is an element.
+ *
+ * Consider that we have (nested) `array of`/`many` types, but do not call the
+ * callback function on the array item itself (only on elements inside).
+ */
+function forEachUserElementAndFKey( art, callback ) {
+  while (art.items)
+    art = art.items;
+  if (art.target) {
+    forEachUserDict( art, 'foreignKeys', callback );
+    return;
+  }
+  if (art.targetAspect)
+    art = art.targetAspect;
+  forEachUserDict( art, 'elements', function element( elem ) {
+    callback( elem );
+    forEachUserElementAndFKey( elem, callback );
+  } );
+}
+
+function forEachUserDict( art, prop, callback ) {
+  const dict = art[prop];
+  if (!dict || dict[$inferred])
+    return;
+  for (const name in dict) {
+    const obj = dict[name];
+    if (obj.$inferred)
+      continue;
+    callback( obj, name, prop );
+    if (Array.isArray(obj.$duplicates)) // redefinitions
+      obj.$duplicates.forEach( o => callback( o, name, prop ) );
+  }
+}
+
+/**
+ * Call `callback( expr, exprCtx, query )` on all direct expressions `expr` of
+ * `query`, where `exprCtx` is the expression context used as key for the
+ * `referenceSemantics` in shared.js.
+ *
+ * Indirect expressions are not called, these are:
+ * - the `from` reference (expression of the table alias)
+ * - the ON-condition of mixins (expression of the mixin)
+ * - the expressions in columns (expression of the column/element)
+ */
+function forEachQueryExpr( query, callback ) { // see resolveQuery()
+  forEachJoinOn( query, query.from, callback );
+  // TODO: run over $inlines ?
+  if (query.where)
+    callback( query.where, 'where', query );
+  if (query.groupBy)
+    forEachExprArray( query, query.groupBy, 'groupBy', 'groupBy', callback );
+  if (query.having)
+    callback( query.having, 'having', query );
+  if (query.$orderBy)
+    forEachExprArray( query, query.$orderBy, 'orderBy-set-ref', 'orderBy-set-expr', callback );
+  if (query.orderBy)
+    forEachExprArray( query, query.orderBy, 'orderBy-ref', 'orderBy-expr', callback );
+}
+
+function forEachJoinOn( query, from, callback ) {
+  if (!from?.join)
+    return;                     // TODO: run over from.path here?
+  for (const tab of from.args)
+    forEachJoinOn( query, tab, callback );
+  if (from.on)
+    callback( from.on, 'join-on', query );
+}
+
+function forEachExprArray( query, array, refContext, exprContext, callback ) {
+  for (const expr of array ) {
+    if (expr)
+      callback( expr, (expr.path ? refContext : exprContext), query );
+  }
+}
+
 // Query tree post-order traversal - called for everything which contributes to the query
 // i.e. is necessary to calculate the elements of the query
 // except "real ones": operands of UNION etc, JOIN with ON, and sub queries in FROM
@@ -442,28 +577,6 @@ function isDirectComposition( art ) {
   return type && type[0] && type[0].id === 'cds.Composition';
 }
 
-function traverseExpr( expr, exprCtx, user, callback ) {
-  if (!expr || typeof expr === 'string') // parse error or keywords in {xpr:...}
-    return;
-
-  if (expr.path) {
-    callback( expr, exprCtx, user );
-    // TODO: move arguments and filter traversal to here
-    return;
-  }
-  else if (expr.type || expr.query) {
-    callback( expr, exprCtx, user );
-  }
-
-  if (expr.args) {
-    const args = Array.isArray(expr.args) ? expr.args : Object.values( expr.args );
-    // TODO: re-think $expected
-    args.forEach( e => traverseExpr( e, exprCtx, user, callback ) );
-  }
-  if (expr.suffix)              // fn( … ) OVER …
-    expr.suffix.forEach( e => traverseExpr( e, exprCtx, user, callback ) );
-}
-
 function userQuery( user ) {
   // TODO: we need _query links set by the definer
   while (user._main) {
@@ -474,6 +587,63 @@ function userQuery( user ) {
   return null;
 }
 
+function pathStartsWithSelf( ref ) {
+  const head = ref && !ref.scope && ref.path?.[0];
+  if (head?._navigation?.kind === '$self')
+    return true;
+  if (head?._artifact?.kind === 'builtin') // CDS variable
+    return false;
+  return undefined;
+}
+
+function columnRefStartsWithSelf( col ) {
+  for (; col; col = col._pathHead) {
+    const ref = col.value;
+    const head = ref && !ref.scope && ref.path?.[0];
+    if (head?._navigation?.kind === '$self')
+      return true;
+    if (head?._artifact?.kind === 'builtin') // CDS variable
+      return false;
+  }
+  return false;
+}
+
+// Remark: this function is based on an early check that no target element is
+// covered more than once by a foreign key: then…
+// we only need to check that all foreign key references are primary keys and
+// that the number of foreign and primary keys are the same.
+function isAssocToPrimaryKeys( assoc ) {
+  let fkeys = 0;
+  const { foreignKeys } = assoc;
+  if (!foreignKeys)
+    return undefined;
+  for (const name in foreignKeys) {
+    const fk = foreignKeys[name];
+    const elem = fk.targetElement._artifact;
+    if (!elem || fk.$duplicates)
+      return undefined;
+    if (!elem.key?.val)
+      return false;
+    ++fkeys;
+  }
+
+  const elements = assoc.target._artifact?.elements;
+  if (!elements)
+    return undefined;
+  for (const name in elements) {
+    if (elements[name].key?.val)
+      --fkeys;
+  }
+  return fkeys === 0;
+}
+
+// only if _effectiveType has been computed:
+function getUnderlyingBuiltinType( art ) {
+  while (art?._effectiveType && !art.builtin)
+    art = art._origin || art.type?._artifact;
+  return art;
+}
+
 function definedViaCdl( art ) {
   // return !!art._block?.artifacts;
   // TODO: the above code would work when _block links are correctly set on
@@ -483,6 +653,21 @@ function definedViaCdl( art ) {
   return $frontend !== 'json' && $frontend !== '$internal';
 }
 
+// For error messages: ----------------------------------------------------------
+
+// (To be) used for the location in error messages
+function artifactRefLocation( ref ) {
+  return (ref._artifact?._main)
+    ? ref.path[ref.path.length - 1].location
+    : ref.location;
+}
+
+function compositionTextVariant( art, composition, association = 'std' ) {
+  return (getUnderlyingBuiltinType( art )?.name.absolute === 'cds.Composition')
+    ? composition
+    : association;
+}
+
 module.exports = {
   pushLink,
   annotationVal,
@@ -505,13 +690,20 @@ module.exports = {
   copyExpr,
   testExpr,
   targetMaxNotOne,
+  forEachUserArtifact,
+  forEachQueryExpr,
   traverseQueryPost,
   traverseQueryExtra,
   viewFromPrimary,
   setExpandStatus,
   setExpandStatusAnnotate,
   isDirectComposition,
-  traverseExpr,
   userQuery,
+  pathStartsWithSelf,
+  columnRefStartsWithSelf,
+  isAssocToPrimaryKeys,
+  getUnderlyingBuiltinType,
   definedViaCdl,
+  artifactRefLocation,
+  compositionTextVariant,
 };

package/lib/edm/annotations/genericTranslation.js

@@ -1488,7 +1488,7 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
   function handleEdmJson(obj, msg, exprDef=undefined) {
 
     let edmNode = undefined;
-    if(obj === undefined || obj === null)
+    if(obj == null)
       return edmNode;
 
     const dynExprs = edmUtils.intersect(dynamicExpressionNames, Object.keys(obj));

package/lib/edm/edm.js

@@ -1220,13 +1220,16 @@ function getEdm(options, messageFunctions) {
     // V4 referential constraints!
     addReferentialConstraintNodes()
     {
+      // flip the constrains if this is a $self partner
       let _constraints = this._csn._constraints;
+      let [i,j] = [0,1];
       if(this._csn._constraints._partnerCsn) {
         _constraints = this._csn._constraints._partnerCsn._constraints;
+        [i,j] = [1,0];
       }
       _constraints.constraints && Object.values(_constraints.constraints).forEach(c =>
         this.append(new ReferentialConstraint(this._v,
-          { Property: c[0].join(options.pathDelimiter), ReferencedProperty: c[1].join(options.pathDelimiter) } ) )
+          { Property: c[i].join(options.pathDelimiter), ReferencedProperty: c[j].join(options.pathDelimiter) } ) )
       );
     }
   }

package/lib/edm/edmPreprocessor.js

@@ -94,7 +94,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     as a step in the OData transformer with the goal to have a protocol agnostic OData CSN.
   */
   if (csn.meta && csn.meta.options && csn.meta.options.odataVersion === 'v4' && options.isV2()) {
-    const { toFinalBaseType }= require('../transform/transformUtilsNew').getTransformers(csn, options);
+    const { toFinalBaseType }= require('../transform/transformUtils').getTransformers(csn, options);
     expandCSNToFinalBaseType(csn, { toFinalBaseType }, csnUtils, serviceRootNames, options);
   }
 
@@ -975,8 +975,8 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
           edmUtils.foreach(struct.elements,
             e =>
               e['@odata.foreignKey4'] === element.name,
-            e => e._ignore = true);
-          element._ignore = true;
+            e => e.$ignore = true);
+          element.$ignore = true;
           info(null, ['definitions', struct.name, 'elements', element.name]
             `${element.type.replace('cds.', '')} "${element.name}" excluded,
               target "${element._target.name}" is annotated '@cds.autoexpose: ${element._target['@cds.autoexpose']}'`
@@ -1588,7 +1588,8 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
             setProp(elt, '$visited', true);
             let newRefs = [];
             // if the foreign keys are explicitly requested, ignore associations and use the flat foreign key instead
-            if(!options.renderForeignKeys || (options.renderForeignKeys && !elt.target))
+            // ignore nested unmanaged associations
+            if((!options.renderForeignKeys || (options.renderForeignKeys && !elt.target)) && !(elt.target && elt.on))
               newRefs = produceKeyRefPaths(elt, prefix + options.pathDelimiter + eltName, path);
             if(newRefs.length) {
               keyPaths.push(...newRefs);

package/lib/edm/edmUtils.js

@@ -839,10 +839,8 @@ 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;
-  }
+      name !== undefined && name[0] === '@')
+    node[name] ??= value;
 }
 
 // Set non enumerable property if it doesn't exist yet

package/lib/gen/Dictionary.json

@@ -787,8 +787,7 @@
       ]
     },
     "Common.ValueListRelevantQualifiers": {
-      "Type": "Collection(Core.SimpleIdentifier)",
-      "$experimental": true
+      "Type": "Collection(Core.SimpleIdentifier)"
     },
     "Common.ValueListWithFixedValues": {
       "Type": "Core.Tag",
@@ -802,8 +801,7 @@
       "AppliesTo": [
         "Property",
         "Parameter"
-      ],
-      "$experimental": true
+      ]
     },
     "Common.ValueListReferences": {
       "Type": "Collection(Edm.String)",
@@ -1461,6 +1459,10 @@
         "Record"
       ]
     },
+    "HTML5.LinkTarget": {
+      "Type": "HTML5.LinkTargetType",
+      "$experimental": true
+    },
     "JSON.Schema": {
       "Type": "JSON.JSON",
       "AppliesTo": [
@@ -1561,15 +1563,13 @@
       "Type": "Edm.String",
       "AppliesTo": [
         "EntitySet"
-      ],
-      "$experimental": true
+      ]
     },
     "PersonalData.DataSubjectRoleDescription": {
       "Type": "Edm.String",
       "AppliesTo": [
         "EntitySet"
-      ],
-      "$experimental": true
+      ]
     },
     "PersonalData.FieldSemantics": {
       "Type": "PersonalData.FieldSemanticsType",
@@ -1834,8 +1834,7 @@
       "Type": "Edm.String",
       "AppliesTo": [
         "Property"
-      ],
-      "$experimental": true
+      ]
     },
     "UI.TextArrangement": {
       "Type": "UI.TextArrangementType",
@@ -3435,6 +3434,31 @@
         "width": "Edm.String"
       }
     },
+    "HTML5.LinkTargetType": {
+      "$kind": "TypeDefinition",
+      "UnderlyingType": "Edm.String",
+      "$Allowed": {
+        "Values": {
+          "_self": {
+            "Value": "_self",
+            "Type": "String"
+          },
+          "_blank": {
+            "Value": "_blank",
+            "Type": "String"
+          },
+          "_parent": {
+            "Value": "_parent",
+            "Type": "String"
+          },
+          "_top": {
+            "Value": "_top",
+            "Type": "String"
+          }
+        },
+        "Symbols": {}
+      }
+    },
     "JSON.JSON": {
       "$kind": "TypeDefinition",
       "UnderlyingType": "Edm.Stream"

package/lib/gen/language.checksum

@@ -1 +1 @@
-8c23b0ea94048e8e7a54d2ed4a4e4707
+2c5e5aa4e688aa88877916a4d40340bf