@sap/cds-compiler 6.3.4 → 6.4.2

package/lib/transform/localized.js

@@ -156,14 +156,14 @@ function _addLocalizationViews(csn, options, config) {
 
   /**
    * Add a localized convenience view for the given artifact.
-   * Can either be an entity or view.  `textElements` are the elements which
+   * Can either be an entity or view.  `localizedElements` are the elements which
    * are needed for creating a horizontal convenience view, i.e. only required
    * for entities.
    *
    * @param {string} artName
-   * @param {string[]} [textElements=[]]
+   * @param {string[]} [localizedElements=[]]
    */
-  function addLocalizedView( artName, textElements = [] ) {
+  function addLocalizedView( artName, localizedElements = [] ) {
     const art = csn.definitions[artName];
     const artPath = [ 'definitions', artName ];
     const viewName = `localized.${ artName }`;
@@ -183,32 +183,32 @@ function _addLocalizationViews(csn, options, config) {
     if (art.query || art.projection)
       view = createLocalizedViewForView(art, viewName);
     else
-      view = createLocalizedViewForEntity(art, artName, viewName, textElements);
+      view = createLocalizedViewForEntity(art, artName, viewName, localizedElements);
 
     copyPersistenceAnnotations(view, art);
     csn.definitions[viewName] = view;
   }
 
   /**
-   * Create a localized data view for the given entity `art` with `textElements`.
+   * Create a localized data view for the given entity `art` with `localizedElements`.
    * In JOIN mode the FROM query is rewritten to remove associations and the
    * columns are expanded.
    *
    * @param {CSN.Definition} entity
    * @param {string} entityName
    * @param {string} viewName Name of the localized view.
-   * @param {string[]} [textElements]
+   * @param {string[]} [localizedElements]
    * @returns {CSN.View}
    */
-  function createLocalizedViewForEntity( entity, entityName, viewName, textElements = [] ) {
+  function createLocalizedViewForEntity( entity, entityName, viewName, localizedElements = [] ) {
     // Only use joins if requested and text elements are provided.
-    const shouldUseJoin = useJoins && !!textElements.length;
+    const shouldUseJoin = useJoins && !!localizedElements.length;
     const columns = [ ];
 
     const convenienceView = {
       '@odata.draft.enabled': false,
       kind: 'entity',
-      query: { // TODO: Use projection
+      query: {
         SELECT: {
           from: createFromClauseForEntity(),
           columns,
@@ -222,20 +222,12 @@ function _addLocalizationViews(csn, options, config) {
 
     if (shouldUseJoin)
       // Expand elements; (variant 1)
-      columns.push( ...columnsForEntityWithExcludeList( entity, 'L_0', textElements ) );
+      columns.push( ...columnsForEntityWithExcludeList( entity, 'L_0', localizedElements ) );
     else
       columns.push( '*' ); // (variant 2)
 
-    for (const originalElement of textElements) {
-      const elem = entity.elements[originalElement];
-      // Note: $key is used by forRelationalDB.js to indicate that this element was a key in the original,
-      //      user's entity.  Keys may have been changed by the backends (e.g. by `@cds.valid.key`)
-      if (!elem.key && !elem.$key)
-        columns.push( createColumnLocalizedElement( originalElement, shouldUseJoin ) );
-      else if (shouldUseJoin)
-        // In JOIN mode we also want to add keys.
-        columns.push( createColumnRef( [ 'L_0', originalElement ] ));
-
+    for (const originalElement of localizedElements) {
+      columns.push( createColumnLocalizedElement( originalElement, shouldUseJoin ) );
       addCoreComputedIfNecessary(convenienceView.elements, originalElement);
     }
 
@@ -254,22 +246,43 @@ function _addLocalizationViews(csn, options, config) {
         on: [],
       };
 
-      for (const originalElement of textElements) {
-        const elem = entity.elements[originalElement];
-        if (elem.key || elem.$key) {
-          from.on.push( createColumnRef( [ 'localized_1', originalElement ] ));
-          from.on.push( '=' );
-          from.on.push( createColumnRef( [ 'L_0', originalElement ] ));
-          from.on.push( 'and' );
-        }
-      }
-
-      from.on.push( createColumnRef( [ 'localized_1', 'locale' ] ) );
-      from.on.push( '=' );
-      from.on.push( createColumnRef( [ '$user', 'locale' ] ) );
+      from.on.push(...createJoinConditionFromLocaleElement());
 
       return from;
     }
+
+    function createJoinConditionFromLocaleElement() {
+      return adaptExpr(entity.elements.localized.on);
+
+      function adaptExpr(expr) {
+        // We only support a few specific ON-conditions, not generic expressions.
+        // In case of unsupported ON-conditions, we emit an error.
+        return expr.map((x) => {
+          if (!x || typeof x === 'string')
+            return x;
+          if (x.xpr)
+            return { xpr: adaptExpr(x.xpr) };
+          if (x.ref && !x.ref.some(ref => ref.args || ref.where))
+            return adaptRef(x);
+
+          messageFunctions.error(
+            'def-invalid-localized',
+            [ 'definitions', entityName, 'elements', 'localized', 'on' ],
+            { name: 'localized', alias: entityName },
+            'Element $(NAME) of entity $(ALIAS) does not have a supported ON-condition'
+          );
+          return x;
+        });
+      }
+
+      function adaptRef(expr) {
+        if (expr.ref[0].charAt(0) === '$') // variable
+          return { ref: [ ...expr.ref ] };
+        if (expr.ref[0] === 'localized') // target side
+          return { ref: [ 'localized_1', ...expr.ref.slice(1) ] };
+        return { ref: [ 'L_0', ...expr.ref ] }; // source side
+      }
+    }
   }
 
   /**
@@ -316,7 +329,6 @@ function _addLocalizationViews(csn, options, config) {
     if (noCoalesce)
       return createColumnRef( [ ...localizedNames, elementName ], elementName );
 
-
     return {
       func: 'coalesce',
       args: [
@@ -357,8 +369,8 @@ function _addLocalizationViews(csn, options, config) {
 
   /**
    * Returns all text element names for a definition `<artName>` if its texts entity
-   * exists and `<artName>` has localized fields.  Otherwise `null` is returned.
-   * Text elements are localized elements as well as keys.
+   * exists and `<artName>` has localized fields.  Otherwise, `null` is returned.
+   * Text elements are non-key localized elements.
    *
    * @param {string} artName Artifact name
    * @return {string[] | null}
@@ -367,49 +379,31 @@ function _addLocalizationViews(csn, options, config) {
     const art = csn.definitions[artName];
     const artPath = [ 'definitions', artName ];
 
-    let keyCount = 0;
-    let textElements = [];
+    const localizedElements = [];
 
     forEachGeneric(art, 'elements', (elem, elemName, _prop) => {
       if (elem.$ignore) // from SAP HANA backend
         return;
-
-      if (elem.key || elem.$key)
-        keyCount += 1;
-
-      if (elem.key || elem.$key || elem.localized)
-        textElements.push( elemName );
+      if (elem.localized && !elem.key && !elem.$key)
+        localizedElements.push( elemName );
     }, artPath);
 
-    if (textElements.length <= keyCount || keyCount <= 0)
+    if (!localizedElements.length) {
       // Nothing to do: no localized fields or all localized fields are keys
       return null;
-
-    if (!isEntityPreprocessed( art )) {
-      messageFunctions.info(
-        null, artPath, { name: artName },
-        'Skipped creation of convenience view for $(NAME) because the artifact is missing localization elements'
-      );
+    }
+    if (!art.elements.localized) {
+      messageFunctions.info('def-expected-localized', artPath, { '#': 'missing', name: artName, alias: 'localized' });
+      return null;
+    }
+    if (!art.elements.localized.target) {
+      messageFunctions.info('def-expected-localized', artPath, { '#': 'non-assoc', name: artName, alias: 'localized' });
       return null;
     }
 
     const textsName = textsEntityName( artName );
     const textsEntity = csn.definitions[textsName];
 
-    if (!textsEntity) {
-      messageFunctions.info(
-        null, artPath, { name: artName },
-        'Skipped creation of convenience view for $(NAME) because its texts entity could not be found'
-      );
-      return null;
-    }
-    if (!isValidTextsEntity( textsEntity )) {
-      messageFunctions.info(
-        null, [ 'definitions', textsName ], { name: artName },
-        'Skipped creation of convenience view for $(NAME) because its texts entity does not appear to be valid'
-      );
-      return null;
-    }
     if (!art[annoPersistenceSkip] && textsEntity[annoPersistenceSkip]) {
       messageFunctions.message(
         'anno-unexpected-localized-skip', artPath,
@@ -418,22 +412,10 @@ function _addLocalizationViews(csn, options, config) {
       return null;
     }
 
-    // There may be keys in the original artifact that were added by the core compiler,
-    // for example elements that are marked @cds.valid.from.
-    // These keys are not present in the texts entity generated by the compiler.
-    // So if we don't filter them out, we may generate invalid SQL.
-    textElements = textElements.filter((elemName) => {
-      const hasElement = !!textsEntity.elements[elemName];
-      if (!hasElement && (art.elements[elemName].key || art.elements[elemName].$key))
-        keyCount--;
-      return hasElement;
-    });
-
-    if (textElements.length <= keyCount || keyCount <= 0)
-      // Repeat the check already used above as the number of keys may have changed.
-      return null;
-
-    return textElements;
+    // Due to recompilation / flattening, properties may have been propagated from "type-of".
+    // That means we have localized elements with no corresponding element in the texts-entity.
+    // Hence, we simply filter here.
+    return localizedElements.filter(elemName => textsEntity.elements[elemName]);
   }
 
   /**
@@ -646,8 +628,8 @@ function _addLocalizationViews(csn, options, config) {
    * @param {string} artName
    */
   function textsEntityName(artName) {
-    // We can assume that the element exists.  This is checked in isEntityPreprocessed().
-    return csn.definitions[artName].elements.texts.target;
+    // We can assume that the element exists.
+    return csn.definitions[artName].elements.localized.target;
   }
 
   /**
@@ -808,33 +790,6 @@ function checkExistingLocalizationViews(csn, options, messageFunctions) {
   return hasExistingViews || hasNonViews;
 }
 
-/**
- * Returns true if the given entity appears to be a valid texts entity.
- *
- * @param {CSN.Artifact} entity
- */
-function isValidTextsEntity(entity) {
-  if (!entity)
-    return false;
-  const requiredTextsProps = [ 'locale' ];
-  return requiredTextsProps.some( prop => !!entity.elements[prop]);
-}
-
-/**
- * Returns true if the localized entity has elements that are generated by
- * the core-compiler.  If elements are missing but the entity is localized
- * then the pre-processing by the core-compiler was not done.
- *
- * @param {CSN.Artifact} entity
- */
-function isEntityPreprocessed(entity) {
-  if (!entity)
-    return false;
-  if (!entity.elements.localized)
-    return false;
-  return entity.elements.texts && entity.elements.texts.target;
-}
-
 /**
  * @param {string} name
  * @returns {boolean}

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.4",
+  "version": "6.4.2",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",