@sap/cds-compiler 6.3.6 → 6.4.6

package/lib/transform/odata/foreignKeyRefsInXprAnnos.js

@@ -1,15 +1,20 @@
 'use strict';
 
-const { applyTransformations, transformAnnotationExpression } = require('../../model/csnUtils');
-const { isBuiltinType } = require('../../base/builtins');
+const { applyTransformations, transformAnnotationExpression, implicitAs } = require('../../model/csnUtils');
 
 
-function replaceForeignKeyRefsInExpressionAnnotations(csn, options, messageFunctions, csnUtils, iterateOptions = {}) {
+/**
+ * If a path in an annotation expression can be interpreted as accessing a local foreign key, then
+ * the foreign key reference is replaced with the foreign key itself.
+ * Exception is when the association path step has a filter.
+ *
+ * @param {CSN} csn
+ * @param {Object} csnUtils
+ * @param {Object} iterateOptions
+ */
+function replaceForeignKeyRefsInExpressionAnnotations(csn, csnUtils, iterateOptions = {}) {
   const transformers = {
-    elements: processRef,
-    params: processRef,
-    actions: processRef,
-    // '@': processRef
+    '@': processRef,
   };
   applyTransformations(csn, transformers, [ processRef ], iterateOptions);
 
@@ -17,29 +22,27 @@ function replaceForeignKeyRefsInExpressionAnnotations(csn, options, messageFunct
     transformAnnotationExpression(parent, prop, {
       ref: (parent, _prop, ref, path, _p, _ppn, ctx) => {
         const { art, links }
-          = (parent._art && parent._links)
+          = parent._art && parent._links
             ? { art: parent._art, links: parent._links }
             : csnUtils.inspectRef(path);
+
         // if a reference points to a structure(managed assoc or structured element), then we do not process
         // as we can't guess which specific foreign key is targeted
-        if (!art || csnUtils.isManagedAssociation(art) || csnUtils.isStructured(art))
+        if (
+          !art ||
+          csnUtils.isManagedAssociation(art) ||
+          csnUtils.isStructured(art)
+        )
           return;
 
-        const allMngAssocsInRef = links.filter(link => csnUtils.isManagedAssociation(link.art));
-        if (!allMngAssocsInRef.length)
-          return;
-        let firstAssocToProcess = allMngAssocsInRef[0];
+        const modifiedRef = replaceRefsWithFKs(ref, links, art);
 
-        const mngAssocsWithFilter = allMngAssocsInRef.filter(assoc => typeof ref[assoc.idx] !== 'string');
-        if (mngAssocsWithFilter.length) {
-          const refTail = links.slice(mngAssocsWithFilter.at(-1).idx + 1);
-          firstAssocToProcess = refTail.find(link => csnUtils.isManagedAssociation(link.art));
-        }
-
-        const match = findMatchingForeignKeyForAssoc(firstAssocToProcess, art, ref, links);
-        if (match) {
-          const refHead = ref.slice(0, match.idx);
-          parent.ref = [ ...refHead, match.fkName ];
+        // update the ref and string token to true if there was FK replacement
+        if (
+          modifiedRef.length !== ref.length ||
+          !modifiedRef.every((val, index) => val === ref[index])
+        ) {
+          parent.ref = modifiedRef;
           if (ctx?.annoExpr?.['='])
             ctx.annoExpr['='] = true;
         }
@@ -48,50 +51,73 @@ function replaceForeignKeyRefsInExpressionAnnotations(csn, options, messageFunct
                                   path);
   }
 
-  function findMatchingForeignKeyForAssoc(assoc, refArt, ref, links) {
-    if (!assoc)
-      return undefined;
-
-    const expectedFkName = findExpectedFkName(assoc, ref, links);
-    const gfks = assoc.art?.$generatedForeignKeys;
-    if (!gfks)
-      return undefined;
-    const matchedFk = gfks.find(fk => fk.source === refArt && fk.name === expectedFkName);
-    if (matchedFk)
-      return { fkName: matchedFk.name, idx: assoc.idx };
-
-    // try to find FK substitution in the next assoc in the ref (if there is such assoc)
-    const refTail = links.slice(assoc.idx + 1);
-    const nextAssoc = refTail.find(link => csnUtils.isManagedAssociation(link.art));
-    return findMatchingForeignKeyForAssoc(nextAssoc, refArt, ref, links);
-
-
-    function findExpectedFkName(assoc, ref, links) {
-      let expectedFkName = ref[assoc.idx];
-      const refAliasMapping = assoc.art.keys.reduce( (acc, key) => {
-        acc[key.ref.join('_')] = key.as;
-        return acc;
-      }, {});
-      let bufferRef = [];
-      for (let i = assoc.idx + 1; i < links.length; i++) {
-        const link = links[i];
-        bufferRef.push(ref[i]);
-        if (csnUtils.isManagedAssociation(link.art)) {
-          const subFkName = findExpectedFkName(link, ref, links);
-          if (!subFkName)
-            return undefined;
-          expectedFkName += bufferRef.length > 1
-            ? `_${ bufferRef.slice(0, -1).join('_') }_${ subFkName }`
-            : `_${ subFkName }`;
-          break;
+  // Replace references to foreign keys
+  function replaceRefsWithFKs(originalRef, links, expectedFkArt) {
+    let result = [ ...originalRef ];
+    // stringify the tail of the ref for finding the potential foreign key
+    const refTail = [ originalRef[originalRef.length - 1] ];
+
+    for (let i = originalRef.length - 2; i >= 0; i--) {
+      const currentRef = originalRef[i];
+      const currentLink = links[i].art;
+
+      // skip processing if the current reference is a filter
+      if (typeof currentRef !== 'string')
+        return result;
+
+      // check if the current link is a managed association
+      if (csnUtils.isManagedAssociation(currentLink)) {
+        const matchedForeignKey = findMatchingForeignKeyForAssoc(currentLink, currentRef, refTail, expectedFkArt);
+
+        if (matchedForeignKey) {
+          // update the result and refTailAsStr with the matched foreign key
+          result = [ ...result.slice(0, i), matchedForeignKey.name ];
+          refTail.unshift(currentRef);
         }
-        else if (isBuiltinType(link.art.type)) {
-          expectedFkName += `_${ refAliasMapping[bufferRef.join('_')] || ref[i] }`;
-          bufferRef = [];
+        else {
+          return result; // return if no matching foreign key is found
         }
       }
-      return expectedFkName;
+      else {
+        // update refTail for non-association links
+        refTail.unshift(currentRef);
+      }
+    }
+    return result;
+  }
+
+  // Lookup the foreign key in the association's generated foreign keys
+  function findMatchingForeignKeyForAssoc(assoc, assocName, refTail, expectedFkArt) {
+    const expectedFkName = getExpectedForeignKeyName(assoc, assocName, refTail);
+    const matchedFk = assoc.$generatedForeignKeys?.find(fk => fk.source === expectedFkArt && fk.name === expectedFkName);
+    return matchedFk;
+  }
+
+  // Generate the expected foreign key name, considering aliases, tuple expansion name changes, etc.
+  function getExpectedForeignKeyName(assoc, assocName, refTail) {
+    const refAliasMapping = assoc.keys.reduce( (acc, key) => {
+      acc[key.ref.join('_')] = key.as || implicitAs(key.ref);
+      return acc;
+    }, {});
+    // generate the string representation of the reference tail
+    const refTailAsStr = replaceRefsIfAliased(refTail, refAliasMapping) || refTail.join('_');
+    return `${ assocName }_${ refTailAsStr }`;
+  }
+
+  // Check if any prefix of refTail matches an alias in refAliasMapping and replace it
+  function replaceRefsIfAliased(refTail, refAliasMapping) {
+    // loop through refTail and try to find a match in the refAliasMapping
+    // no need to look for the longest match as it is not allowed to declare
+    // duplicate key references in one FKs scope
+    let candidate = '';
+    for (let idx = 0; idx < refTail.length; idx++) {
+      candidate = candidate ? `${ candidate }_${ refTail[idx] }` : refTail[idx];
+      if (refAliasMapping[candidate]) {
+        refTail.splice(0, idx + 1, refAliasMapping[candidate]);
+        return refTail.join('_');
+      }
     }
+    return undefined;
   }
 }
 

package/lib/transform/transformUtils.js

@@ -54,7 +54,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
     extractValidFromToKeyElement,
     checkMultipleAssignments,
     checkAssignment,
-    recurseElements,
+    recurseElements, // standalone-function
     renameAnnotation,
     setAnnotation,
     resetAnnotation,
@@ -808,26 +808,6 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
     }
   }
 
-  /**
-   * Calls `callback` for each element in `elements` property of `artifact` recursively.
-   *
-   * @param {CSN.Artifact} artifact the artifact
-   * @param {CSN.Path} path path to get to `artifact` (mainly used for error messages)
-   * @param {(art: CSN.Artifact, path: CSN.Path) => any} callback Function called for each element recursively.
-   */
-  function recurseElements(artifact, path, callback) {
-    callback(artifact, path);
-    const { elements } = artifact;
-    if (elements) {
-      path.push('elements', null);
-      forEach(elements, (name, obj) => {
-        path[path.length - 1] = name;
-        recurseElements(obj, path, callback);
-      });
-      // reset path for subsequent usages
-      path.length -= 2; // equivalent to 2x pop()
-    }
-  }
 
   // Rename annotation 'fromName' in 'node' to 'toName' (both names including '@')
   function renameAnnotation(node, fromName, toName) {
@@ -920,8 +900,30 @@ function rewriteBuiltinTypeRef(csn) {
   });
 }
 
+/**
+ * Calls `callback` for each element in `elements` property of `artifact` recursively.
+ *
+ * @param {CSN.Artifact} artifact the artifact
+ * @param {CSN.Path} path path to get to `artifact` (mainly used for error messages)
+ * @param {(art: CSN.Artifact, path: CSN.Path) => any} callback Function called for each element recursively.
+ */
+function recurseElements(artifact, path, callback) {
+  callback(artifact, path);
+  const { elements } = artifact;
+  if (elements) {
+    path.push('elements', null);
+    forEach(elements, (name, obj) => {
+      path[path.length - 1] = name;
+      recurseElements(obj, path, callback);
+    });
+    // reset path for subsequent usages
+    path.length -= 2; // equivalent to 2x pop()
+  }
+}
+
 module.exports = {
   // This function retrieves the actual exports
   getTransformers,
   rewriteBuiltinTypeRef,
+  recurseElements,
 };

package/lib/transform/translateAssocsToJoins.js

@@ -487,10 +487,12 @@ function translateAssocsToJoins(model, inputOptions = {}) {
       // create a new toplevel AND op otherwise
       const onCond = (Array.isArray(node.on) ? node.on[0] : node.on);
 
-      if (onCond.op.val === 'and')
-        onCond.args.push(parenthesise(filter));
-      else
-        node.on = parenthesise({ op: { val: 'and' }, args: [ parenthesise(onCond), parenthesise(filter) ] });
+      if (filter.args?.length !== 0) {
+        if (onCond.op.val === 'and')
+          onCond.args.push(parenthesise(filter));
+        else
+          node.on = parenthesise({ op: { val: 'and' }, args: [ parenthesise(onCond), parenthesise(filter) ] });
+      }
     }
     return node;
 
@@ -1496,7 +1498,7 @@ function translateAssocsToJoins(model, inputOptions = {}) {
       */
       let qatName = pathStep.id;
 
-      if (pathStep.where)
+      if (pathStep.where && pathStep.where?.args?.length !== 0)
         qatName += JSON.stringify(compactExpr(pathStep.where));
 
       if (pathStep.args) {

package/lib/transform/tupleExpansion.js

@@ -14,7 +14,7 @@ const { cloneCsnNonDict } = require('../model/cloneCsn');
  *
  * @type {string[]}
  */
-const RelationalOperators = [ '=', '<>', '==', '!=', 'is', 'is not' /* , 'like' */ ];
+const RelationalOperators = [ '=', '<>', '==', '!=', 'is', 'is not' ];
 
 /**
  * Operators that to be used to combine expanded expressions by keeping logical relations.
@@ -64,6 +64,11 @@ function tupleExpansion(csn, csnUtils, msgFunctions) {
       having: expandExpr,
       where: expandExpr,
       xpr: expandExpr,
+      list: (parent, name, args, path) => {
+        // Don't iterate `group by (foo, bar)`
+        if (path.at(-2) !== 'groupBy' && path.at(-2) !== 'orderBy')
+          expandExpr(parent, name, args, path);
+      },
       args: (parent, name, args, path) => {
         if (!parent.id && !parent.func)
           return; // ensure we're not in JOIN
@@ -262,6 +267,10 @@ function tupleExpansion(csn, csnUtils, msgFunctions) {
     }
   }
 
+  /**
+   * @param expr
+   * @param {CSN.Path} location
+   */
   function rejectAnyDirectStructureReference(expr, location) {
     if (expr[0] === 'exists') {
       // we ignore WHERE EXISTS clauses; they are not relevant for OData,
@@ -318,11 +327,15 @@ function tupleExpansion(csn, csnUtils, msgFunctions) {
    * `{ _art: <leaf_artifact>, ref: [...] }`
    * with `_art` identifying `ref[ref.length-1]`
    *
-   * A produced path has the form `{ _art: <ref>, ref: [ <id> (, <id>)* ] }`
+   * A produced path has the form `{ _art: <ref>, ref: [ <id> (, <id>)* ], comparisonRef: [ <id> (, <id>)* ] }`
    *
    * Flattening stops on all non-structured elements, if followMgdAssoc=false.
    *
-   * If fullRef is true, a path step is produced as `{ id: <id>, _art: <link> }`
+   * If fullRef is true, a path step is produced as `{ id: <id>, _art: <link> }`.
+   *
+   * The returned paths will have a property 'comparisonRef', that may differ from 'ref'
+   * for managed associations (as it uses the foreign key name).
+   * The caller may need to delete that property.
    */
   function flattenPath(path, fullRef = false, followMgdAssoc = false) {
     let art = path._art;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "6.3.6",
+  "version": "6.4.6",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",
@@ -33,8 +33,8 @@
     "deployHdbcdsGitDiffs": "CDS_COMPILER_DEPLOY_HANA=1 mocha --reporter-option maxDiffSize=0 --extensions .hdbcds test3/test.deploy.git-diffs.js",
     "deployHdiGitDiffs": "CDS_COMPILER_DEPLOY_HANA=1 mocha --reporter-option maxDiffSize=0 --extensions .hdi test3/test.deploy.git-diffs.js",
     "gentest3": "cross-env MAKEREFS=${MAKEREFS:-'true'} mocha --reporter-option maxDiffSize=0 test3/testRefFiles.js",
-    "coverage": "cross-env nyc mocha --reporter-option maxDiffSize=0 test/ test3/testRefFiles.js && nyc report --reporter=lcov",
-    "coverage:piper": "cross-env nyc mocha --reporter test/TestMochaReporter.js --reporter-options mochaFile=./coverage/TEST-results.xml --reporter-option maxDiffSize=0 --timeout 10000 test/ test3/ && nyc report --reporter=cobertura && nyc report --reporter=lcov",
+    "coverage": "cross-env npx nyc mocha --reporter-option maxDiffSize=0 test/ test3/testRefFiles.js && npx nyc report --reporter=lcov",
+    "coverage:piper": "cross-env npx nyc mocha --reporter test/TestMochaReporter.js --reporter-options mochaFile=./coverage/TEST-results.xml --reporter-option maxDiffSize=0 --timeout 10000 test/ test3/ && npx nyc report --reporter=cobertura && npx nyc report --reporter=lcov",
     "lint": "eslint bin/ benchmark/ lib/ test/ test3/ scripts/ && node scripts/linter/lintConstants.js && node scripts/linter/lintGrammar.js && node scripts/linter/lintTests.js test3/ && node scripts/linter/lintMessages.js && node scripts/linter/lintMessageIdCoverage.js lib/ && markdownlint README.md CHANGELOG.md doc/ internalDoc/ && cd share/messages && markdownlint . && cd ../../ && node scripts/check-changelog.js",
     "lint:edmx": "node scripts/odata/lint-edmx-v4.js",
     "tslint": "tsc --pretty -p .",

package/doc/DeprecatedOptions_v2.md

@@ -1,150 +0,0 @@
-# Deprecated Options and How to Avoid Them
-
-__Important__: With compiler v3, these deprecated options were removed!
-
-To ease the migration to CDS Compiler Version 2,
-the compiler can be called with an option `deprecated`
-which makes the compiler behave more like Compiler Version 1 for certain features.
-
-As the name suggest, this option should be used only for a limited time.
-The support for certain v1 features might also be dropped after a while
-(without an increase of the compiler major version).
-
-__When the `deprecated` option is set, the `beta` option is ignored,
-and several new features are not available.__
-
-The value of the option `deprecated` is a dictionary
-mapping v1 feature names to (usually boolean) values.
-This document lists all those features,
-and describes what you can do instead of setting these features.
-
-
-## Deprecated features influencing the name of generated entities
-
-The `compile()` function generates entities in the following cases:
-
-1. When an element in an entity is specified to be `localized`,
-   it creates a __texts entity__ for that entity.
-2. For managed composition of aspects,
-   it creates a __target entity__ based on the provided target aspect.
-3. A projection in a service is automatically generated
-   for correspondingly tagged entities in the model (which is then “__auto-exposed__”)
-   if an association/composition to the model entity is to be _implicitly redirected_
-   to an exposed entity in the service and no such entity exists yet.
-
-As a short example for 1 and 3 (2 is similar to 1):
-
-```
-entity my.Model.Base {
-  key id: UUID;
-  text: localized String;
-}
-service our.Service {
-  entity Proj as projection on my.Model.Base;
-}
-```
-
-The compiled model contains the following generated entities:
-
-* the text entity `my.Model.Base.texts`,
-  which is a composition target of the generated element `my.Model.Base:texts`
-* the auto-exposed projection `our.Service.Proj.texts`
-  which is a composition target of `our.Service.Proj:texts`
-
-For the following subsections (and in general), it is important to understand that
-you can define all auto-exposed entities yourself (well, they are not
-_auto_-exposed anymore)
-_without_ any difference in the compiled model
-except for the sequence of entities in `‹csn›.definitions`.  
-That means, you can append the following line to the above example:
-
-```
-@cds.autoexposed entity our.Service.Proj.texts as projection on my.Model.Base.texts;
-```
-
-The annotation `@cds.autoexposed` ensures that this self-exposed entity
-really behaves exactly like an auto-exposed entity:
-
-* it is only used as a direct redirection target, not as an indirect one
-  (a detailed explanation of this topic is out-of-scope for this document),
-* runtimes also attach a runtime semantics to the annotation `@cds.autoexposed`.
-
-Thus, if you do not like the name of the generated auto-exposed entity,
-you can simply __expose the model entity__ yourself and choose the name you like.
-__Never ever__ define a projection on the auto-exposed entity,
-which has worked in v1 versions and in the v2.1.x versions in certain situations.
-
-
-### Deprecated `generatedEntityNameWithUnderscore`
-
-With compiler v1,
-the generated entities had no suffix starting with a `.` like `.texts` for texts entities,
-but a suffix starting with a `_`.
-
-If you have a reference to a generated entity in your model,
-you now have to change the model accordingly.  
-For example, if you had for v1
-
-```
-using { my.Model.Base, my.Model.Base_texts } from './myModel';
-entity Root {
-  key ID: UUID;
-  base:   Association to Base;
-  texts:  Association to Base_texts;
-}
-```
-
-you now have to write for v2 (you see that it is usually actually simpler now)
-
-```
-using { my.Model.Base } from './myModel';
-entity Root {
-  key ID: UUID;
-  base:   Association to Base;
-  texts:  Association to Base.texts;
-}
-```
-
-If you are a CSN consumer and analyse the compiled model, you might need
-to adopt your code for the name change from `my.Model.Base_texts` to `my.Model.Base.texts`.
-
-In the following areas, nothing will change:
-
-* In the OData backend,
-  the “new” `.`s are replaced by `_`s to make the names conform to the OData naming rules.  
-  In other words, the EDMX (for the generated entities) looks the same as with v1.
-* In the SQL/Hana backends,
-  the “new” `.`s are also replaced by `_`s to adopt to HANA CDS naming restrictions
-  (with the standard naming mode `plain`, all `.`s are replaced by `_`s anyway).  
-  In other words, no texts table migration will take place.
-
-But anyway, you might temporarily want to keep the v1 behavior
-by setting the option `deprecated.generatedEntityNameWithUnderscore`.
-If you do so, scoped definitions are not possible (like they aren't in v1).
-
-### Deprecated `shortAutoexposed`
-
-In compiler v1 without an option
-(especially the v1 option `dependentAutoexposed` which basically leads the v2 default behavior),
-the name for auto-exposed entities were constructed by
-adding the name part after the last `.` to the service name.
-
-That is, for the above example,
-the auto-exposed projection on `my.Model.Base_texts` (in v1) is named
-`our.Service.Base_texts` in v1.
-
-You can temporarily enable that behavior in v2 by setting the options
-`deprecated.generatedEntityNameWithUnderscore` and `deprecated.shortAutoexposed`.
-
-If you just set `deprecated.shortAutoexposed`, you get `our.Service.Base.texts`.
-
-If you really need that name (instead of the v2 name `our.Service.Proj.texts`),
-you can expose the texts entity manually instead of setting the deprecated option:
-
-```
-@cds.autoexposed entity our.Service.Base.texts as projection on my.Model.Base.texts;
-```
-
-Again, never define a projection on the auto-exposed entity –
-you get an error for that starting with compiler v2.2.0
-(and earlier for certain definition sequences anyway, actually in v1 also).