@sap/cds-compiler 5.2.0 → 5.3.2

package/lib/render/toCdl.js

@@ -1331,6 +1331,9 @@ function csnToCdl( csn, options, msg ) {
     if (artifact.localized) // works even for type definitions
       result += 'localized ';
 
+    // Some properties are always "top-level", even for "many", e.g. "default" or
+    // "not null". Keep a reference to the outer artifact.
+    const origArtifact = artifact;
     if (!artifact.type && artifact.items) {
       checkArrayedArtifact(artifact, env);
       result += 'many '; // alternative: 'array of'; but not used
@@ -1342,11 +1345,14 @@ function csnToCdl( csn, options, msg ) {
 
     if (!type && artifact.elements) {
       result += renderElements(artifact, env);
-      result += renderNullability(artifact);
+      result += renderNullability(artifact.notNull);
       // structured default not possible at the moment
       return result;
     }
 
+    const defaultValue = origArtifact.default ? origArtifact.default : artifact.default;
+    const notNull = origArtifact.notNull ? origArtifact.notNull : artifact.notNull;
+
     // Association type
     if (isDirectAssocOrComp(type)) {
       const isComp = type === 'cds.Composition';
@@ -1378,11 +1384,11 @@ function csnToCdl( csn, options, msg ) {
       if (artifact.keys && !artifact.on)
         result += ` ${ renderForeignKeys(artifact, env) }`;
 
-      if (artifact.notNull !== undefined && !artifact.on) // unmanaged associations can't be followed by "not null"
-        result += renderNullability(artifact);
-
-      if (artifact.default && !artifact.on)
-        result += renderDefaultExpr(artifact, env);
+      if (!artifact.on) {
+        // unmanaged associations can't be followed by "not null" or "default"
+        result += renderNullability(notNull);
+        result += renderDefaultExpr(defaultValue, env.withSubPath([ 'default' ]));
+      }
       return result;
     }
 
@@ -1409,13 +1415,12 @@ function csnToCdl( csn, options, msg ) {
 
     if (artifact.enum && !typeRefOnly)
       result += renderEnum(artifact.enum, env);
-    if (artifact.notNull !== undefined)
-      result += renderNullability(artifact);
 
+    result += renderNullability(notNull);
     // If there is a default value, and it's a calculated element, do not
     // render the default (because it's not supported for calc elements).
-    if (artifact.default !== undefined && !artifact.value)
-      result += renderDefaultExpr(artifact, env);
+    if (defaultValue !== undefined && !artifact.value)
+      result += renderDefaultExpr(defaultValue, env.withSubPath([ 'default' ]));
 
     return result;
   }
@@ -1789,24 +1794,24 @@ function csnToCdl( csn, options, msg ) {
     return result;
   }
 
-  function renderDefaultExpr( art, env ) {
-    if (!art.default)
+  function renderDefaultExpr( defaultValue, env ) {
+    if (!defaultValue)
       return '';
     let result = ' default ';
-    if ( art.default.xpr && xprContainsCondition( art.default.xpr))
-      result += exprRenderer.renderSubExpr(withoutCast( art.default), env.withSubPath([ 'default' ]));
+    if (defaultValue.xpr && xprContainsCondition( defaultValue.xpr))
+      result += exprRenderer.renderSubExpr(withoutCast(defaultValue), env);
     else
-      result += exprRenderer.renderExpr(withoutCast( art.default), env.withSubPath([ 'default' ]));
+      result += exprRenderer.renderExpr(withoutCast(defaultValue), env);
     return result;
   }
 
   // Render the nullability of an element or parameter (can be unset, true, or false)
-  function renderNullability( obj /* , env */) {
-    if (obj.notNull === undefined) {
+  function renderNullability( notNull /* , env */) {
+    if (notNull === undefined) {
       // Attribute not set at all
       return '';
     }
-    return obj.notNull ? ' not null' : ' null';
+    return notNull ? ' not null' : ' null';
   }
 
   /**

package/lib/transform/addTenantFields.js

@@ -78,7 +78,7 @@ function addTenantFields( csn, options, messageFunctions ) {
     else if (!independent && independent != null) {
       error( 'tenant-invalid-anno-value', msgLocations( csnPath ),
              { anno: annoTenantIndep, value: independent },
-             // eslint-disable-next-line max-len
+             // eslint-disable-next-line @stylistic/js/max-len
              'Can\'t add $(ANNO) with value $(VALUE) to a non-entity, which is always tenant-independent' );
     }
     else if (art.includes) {
@@ -119,9 +119,9 @@ function addTenantFields( csn, options, messageFunctions ) {
       .filter( name => isTenantDepEntity( csn.definitions[name] ) );
     if (names.length) {
       error( 'tenant-invalid-include', msgLocations( csnPath ), { names }, {
-        // eslint-disable-next-line max-len
+        // eslint-disable-next-line @stylistic/js/max-len
         std: 'Can\'t include the tenant-dependent entities $(NAMES) into a tenant-independent definition',
-        // eslint-disable-next-line max-len
+        // eslint-disable-next-line @stylistic/js/max-len
         one: 'Can\'t include the tenant-dependent entity $(NAMES) into a tenant-independent definition',
       } );
     }
@@ -206,7 +206,7 @@ function addTenantFields( csn, options, messageFunctions ) {
     if (art[annoTenantIndep]) {
       error( 'tenant-expecting-tenant-source', msgLocations( csnPath ), { art: query },
              // TODO: better the final entity name of assoc navigation in FROM
-             // eslint-disable-next-line max-len
+             // eslint-disable-next-line @stylistic/js/max-len
              'Expecting the query source $(ART) to be tenant-dependent for a tenant-dependent query entity' );
     }
     return true;

package/lib/transform/db/rewriteCalculatedElements.js

@@ -660,11 +660,12 @@ function rewriteCalculatedElementsInViews( csn, options, csnUtils, pathDelimiter
 
 /**
  * @param {CSN.Model} csn
+ * @param {CSN.Options} options
  */
-function processCalculatedElementsInEntities( csn ) {
+function processCalculatedElementsInEntities( csn, options ) {
   forEachDefinition(csn, (artifact, definitionName) => {
     if (artifact.kind === 'entity' && !(artifact.query || artifact.projection))
-      removeDummyValueInEntity(artifact, [ 'definitions', definitionName ]);
+      removeDummyValueInEntity(artifact, [ 'definitions', definitionName ], options);
   });
 }
 
@@ -674,14 +675,19 @@ function processCalculatedElementsInEntities( csn ) {
  *
  * @param {CSN.Artifact} artifact
  * @param {CSN.Path} path
+ * @param {CSN.Options} options
  * @todo calculated elements that "live" on the database?
  * @todo error when artifact is empty afterwards? Probably better as a CSN check!
  */
-function removeDummyValueInEntity( artifact, path ) {
+function removeDummyValueInEntity( artifact, path, options ) {
   applyTransformationsOnDictionary(artifact.elements, {
     value: (parent, prop, value, p, elements) => {
-      if (!value.stored)
-        delete elements[p[p.length - 1]];
+      if (!value.stored) {
+        if (options.transformation === 'effective' && parent.on)
+          delete parent.value;
+        else
+          delete elements[p.at(-1)];
+      }
     },
   }, {}, path.concat( 'elements' ));
 }

package/lib/transform/db/transformExists.js

@@ -409,6 +409,7 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
   }
 
   /**
+   *
    * Translate an `EXISTS <unmanaged assoc>` into a part of a WHERE condition.
    *
    * A valid $self-backlink is handled in translateDollarSelfToWhere.
@@ -428,53 +429,77 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
    */
   function translateUnmanagedAssocToWhere( root, target, isPrefixedWithTableAlias, base, current ) {
     const whereExtension = [];
-    for (let j = 0; j < root.on.length; j++) {
-      const part = root.on[j];
+
+    for (let j = 0; j < root.on.length; j++)
+      j = processExpressionPart(root.on, root.$path.concat('on'), j, whereExtension);
+
+    return whereExtension;
+
+    /**
+     * Process the given expression and apply the steps described above.
+     *
+     * @param {Array} expression Expression we are processing
+     * @param {CSN.Path} path Path to the expression
+     * @param {number} expressionIndex Index in the current expression, imporant for paths and stuff
+     * @param {Array} collector Array to collect the processed expressionparts into
+     * @returns {number} How far along expression we have processed - so the main loop can jump ahead
+     */
+    function processExpressionPart(expression, path, expressionIndex, collector) {
+      const part = expression[expressionIndex];
+
+      if (part?.xpr) {
+        const xpr = { xpr: [] };
+        for (let i = 0; i < part.xpr.length; i++)
+          i = processExpressionPart(part.xpr, path.concat(expressionIndex, 'xpr'), i, xpr.xpr);
+
+        collector.push(xpr);
+        return expressionIndex;
+      }
 
       // we can only resolve stuff on refs - skip literals like =
       // but also keep along stuff like null and undefined, so compiler
       // can have a chance to complain/ we can fail later nicely maybe
       if (!(part && part.ref)) {
-        whereExtension.push(part);
-        continue;
+        collector.push(part);
+        return expressionIndex;
       }
 
       // root.$path should be safe - we can only reference things in exists that exist when we enrich
       // so all of them should have a $path.
-      const { art, links } = inspectRef(root.$path.concat([ 'on', j ]));
+      const { art, links } = inspectRef(path.concat(expressionIndex));
       // Dollar Self Backlink
-      if (isValidDollarSelf(root.on[j], root.$path.concat([ 'on', j ]), root.on[j + 1], root.on[j + 2], root.$path.concat([ 'on', j + 2 ]))) {
-        if (root.on[j].ref[0] === '$self' && root.on[j].ref.length === 1)
-          whereExtension.push(...translateDollarSelfToWhere(base, target, root.on[j + 2], root.$path.concat([ 'on', j + 2 ])));
+      if (isValidDollarSelf(expression[expressionIndex], path.concat(expressionIndex), expression[expressionIndex + 1], expression[expressionIndex + 2], path.concat(expressionIndex + 2 ))) {
+        if (expression[expressionIndex].ref[0] === '$self' && expression[expressionIndex].ref.length === 1)
+          collector.push(...translateDollarSelfToWhere(base, target, expression[expressionIndex + 2], path.concat(expressionIndex + 2 )));
         else
-          whereExtension.push(...translateDollarSelfToWhere(base, target, root.on[j], root.$path.concat([ 'on', j ])));
+          collector.push(...translateDollarSelfToWhere(base, target, expression[expressionIndex], path.concat(expressionIndex)));
 
-        j += 2;
+        return expressionIndex + 2;
       }
       else if (links && links[0].art === root) { // target side
-        whereExtension.push({ ref: [ target, ...part.ref.slice(1) ] });
+        collector.push({ ref: [ target, ...part.ref.slice(1) ] });
       }
       else if (part.$scope === '$self') { // source side - "absolute" scope
         const column = part._art._column;
         if (column && column.as) { // Replace with the "original" expression (the .ref, .xpr etc.)
-          whereExtension.push(translateToSourceSide(column));
+          collector.push(translateToSourceSide(column));
         }
         else {
-          whereExtension.push(assignAndDeleteAs({}, part, { ref: [ base, ...part.ref.slice(1) ] }));
+          collector.push(assignAndDeleteAs({}, part, { ref: [ base, ...part.ref.slice(1) ] }));
         }
       }
       else if (art) { // source side - with local scope
         if (isPrefixedWithTableAlias || part.$scope === 'alias')
-          whereExtension.push({ ref: [ ...current.ref.slice(0, -1), ...part.ref ] });
+          collector.push({ ref: [ ...current.ref.slice(0, -1), ...part.ref ] });
         else
-          whereExtension.push({ ref: [ base, ...current.ref.slice(0, -1), ...part.ref ] });
+          collector.push({ ref: [ base, ...current.ref.slice(0, -1), ...part.ref ] });
       }
       else { // operator - or any other leftover
-        whereExtension.push(part);
+        collector.push(part);
       }
-    }
 
-    return whereExtension;
+      return expressionIndex;
+    }
 
 
     /**

package/lib/transform/effective/main.js

@@ -75,7 +75,7 @@ function effectiveCsn( model, options, messageFunctions ) {
   // ensure getElement works on flattened struct_assoc columns
   csnUtils = getUtils(csn, 'init-all');
 
-  processCalculatedElementsInEntities(csn);
+  processCalculatedElementsInEntities(csn, options);
   associations.managedToUnmanaged(csn, options, csnUtils, messageFunctions);
   associations.transformBacklinks(csn, options, csnUtils, messageFunctions);
   const transformers = mergeTransformers([ options.addCdsPersistenceName ? misc.attachPersistenceName(csn, options, csnUtils) : {}, options.remapOdataAnnotations ? annotations.remapODataAnnotations(csn) : {}, misc.removeDefinitionsAndProperties(csn, options) ], null);

package/lib/transform/forRelationalDB.js

@@ -248,7 +248,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     }
   });
 
-  processCalculatedElementsInEntities(csn);
+  processCalculatedElementsInEntities(csn, options);
 
   timetrace.start('Transform CSN')
 
@@ -817,16 +817,17 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   function checkTypeParameters(artifact, artifactName) {
     forEachMemberRecursively(artifact, (member, memberName, prop, path) => {
       // Check type parameters (length, precision, scale ...)
-      if (!member.$ignore && member.type)
-        _check(member, memberName, csn, path);
-
-      if (!member.$ignore && member.items && member.items.type)
-        _check(member.items, memberName, csn, path.concat([ 'items' ]));
+      if (!member.$ignore) {
+        if (member.type)
+          _check(member, memberName, csn, path);
+        if (member.items?.type)
+          _check(member.items, memberName, csn, path.concat([ 'items' ]));
+      }
     }, [ 'definitions', artifactName ]);
 
     // Check that required actual parameters on 'node.type' are set, that their values are in the correct range etc.
     function _check(node, nodeName, model, path) {
-      if (node.type) {
+      if (node.type && !node.virtual) {
         const absolute = node.type;
         switch (absolute) {
           case 'cds.String':

package/lib/utils/moduleResolve.js

@@ -579,7 +579,7 @@ function checkFileCase( dep, realpath, nativeRealpath, { warning } ) {
   }
   for (const using of dep.usingFroms) {
     warning('file-unexpected-case-mismatch', [ using.location, using ], {},
-            // eslint-disable-next-line max-len
+            // eslint-disable-next-line @stylistic/js/max-len
             'The imported filename differs on the filesystem; ensure that capitalization matches the actual file\'s name');
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "5.2.0",
+  "version": "5.3.2",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",

package/share/messages/redirected-to-complex.md

@@ -53,9 +53,12 @@ CrossJoin
 
 ## How to Fix
 
-Ensure that the redirected association points to an entity that is a reasonable
-redirection target.  That means, the redirection target shouldn't accidentally
-make it a to-many association.
+First, ensure that the redirected association points to an entity that is
+a reasonable redirection target.  That means, the redirection target shouldn't
+accidentally make it a to-many association.
+
+Then add an explicit ON-condition or explicit foreign keys to the redirected
+association.  That will silence the compiler message.
 
 ## Related Messages