@sap/cds-compiler 6.5.2 → 6.6.0

package/lib/transform/effective/types.js

@@ -7,6 +7,7 @@ const {
 } = require('../../model/csnUtils');
 const { forEachKey } = require('../../utils/objectUtils');
 const { cloneCsnDict, cloneCsnNonDict } = require('../../model/cloneCsn');
+const propertiesToSkipForCasts = { enum: true };
 
 /**
  * Resolve all references to structured types in entities to the underlying elements.
@@ -26,8 +27,14 @@ function resolveTypes( csn, csnUtils, transformers, options ) {
   const { flattenStructStepsInRef } = transformers;
   const later = [];
   applyTransformations(csn, {
+    cast: (parent, prop, cast, path, grandParent, grandParentProp) => {
+      if (cast.type && path.at(-2) !== 'columns' && typeof grandParentProp === 'number') // SQL cast - not happy with this :(
+        resolveType(csnUtils, cast, true);
+      else if (cast.type) // cdl style cast
+        resolveType(csnUtils, cast, false);
+    },
     type: (parent) => {
-      resolveType(csnUtils, parent);
+      resolveType(csnUtils, parent, false);
     },
   }, [ (definitions, artifactName, artifact) => {
     // In a non-flat model, replacing types with some $self inside causes issues for actions (bound or unbound)
@@ -36,7 +43,7 @@ function resolveTypes( csn, csnUtils, transformers, options ) {
       later.push([ { [artifactName]: artifact }, [ 'definitions' ] ]);
     else if (artifact.actions)
       later.push([ artifact.actions, [ 'definitions', artifactName, 'actions' ] ]);
-  } ], { skipStandard: { returns: true }, processAnnotations: true, skipDict: { actions: true } });
+  } ], { skipStandard: { returns: true, cast: true }, processAnnotations: true, skipDict: { actions: true } });
 
   // Type refs like E:struct.sub can not be resolved later, as struct will be flattened. So we rewrite it to E:struct_sub here.
   later.forEach(([ action, actionPath ]) => {
@@ -52,8 +59,8 @@ function resolveTypes( csn, csnUtils, transformers, options ) {
   return function resolveTypesInActions(refreshedCsnUtils) {
     later.forEach(([ action ]) => {
       applyTransformationsOnDictionary(action, {
-        type: (parent) => {
-          resolveType(refreshedCsnUtils, parent);
+        type: (parent, prop, type, path) => {
+          resolveType(refreshedCsnUtils, parent, path);
         },
       });
     });
@@ -70,7 +77,7 @@ function resolveTypes( csn, csnUtils, transformers, options ) {
    *
    * @param {object} parent Object with a .type property
    */
-  function resolveType( csnUtils, parent ) {
+  function resolveType( csnUtils, parent, isCast ) {
     // TODO: I assume there can be cases with a type ref but still having .elements already? Subelement anno?
     const final = csnUtils.getFinalTypeInfo(parent.type);
     if (final?.elements) {
@@ -86,7 +93,7 @@ function resolveTypes( csn, csnUtils, transformers, options ) {
     }
     else if (final?.type && (options.resolveSimpleTypes || parent.type.ref?.length > 1)) {
       forEachKey(final, (key) => { // copy `type` + properties (default, etc.)
-        if (parent[key] === undefined || key === 'type')
+        if ((parent[key] === undefined || key === 'type') && (isCast && !propertiesToSkipForCasts[key] || !isCast))
           parent[key] = final[key];
       });
     }
@@ -95,17 +102,31 @@ function resolveTypes( csn, csnUtils, transformers, options ) {
     const stack = [ ];
     if (parent.elements || parent.items)
       stack.push(parent);
+    const typeTransformer = getTypeTransformer(csnUtils, stack);
+    const typeInCastTransformer = getTypeTransformer(csnUtils, stack, true);
     while (stack.length > 0) {
       const obj = stack.pop();
       if (obj.elements) {
         applyTransformationsOnDictionary(obj.elements, {
-          type: getTypeTransformer(csnUtils, stack),
+          cast: (parent, prop, cast, path, grandParent, grandParentProp) => {
+            if (cast.type && path.at(-2) !== 'columns' && typeof grandParentProp === 'number')
+              typeInCastTransformer(cast, 'type', cast.type);
+            else if (cast.type)
+              typeTransformer(cast, 'type', cast.type);
+          },
+          type: typeTransformer,
         }, { skipDict: { actions: true } });
       }
       else if (obj.items) {
         applyTransformationsOnNonDictionary(obj, 'items', {
-          type: getTypeTransformer(csnUtils, stack),
-        }, { skipDict: { actions: true } });
+          cast: (parent, prop, cast, path, grandParent, grandParentProp) => {
+            if (cast.type && path.at(-2) !== 'columns' && typeof grandParentProp === 'number')
+              typeInCastTransformer(cast, 'type', cast.type);
+            else if (cast.type)
+              typeTransformer(cast, 'type', cast.type);
+          },
+          type: typeTransformer,
+        }, { skipDict: { actions: true }, skipStandard: { cast: true } });
       }
     }
   }
@@ -115,7 +136,7 @@ function resolveTypes( csn, csnUtils, transformers, options ) {
    * @param {object[]} stack
    * @returns {Function}
    */
-  function getTypeTransformer( csnUtils, stack ) {
+  function getTypeTransformer( csnUtils, stack, isCast ) {
     return function typeTransformer( _parent, _prop, _type ) {
       const finalSub = csnUtils.getFinalTypeInfo(_type);
 
@@ -132,8 +153,11 @@ function resolveTypes( csn, csnUtils, transformers, options ) {
         delete _parent.type;
         stack.push( _parent );
       }
-      else if (finalSub?.type) {
-        _parent.type = finalSub.type;
+      else if (finalSub?.type && (options.resolveSimpleTypes || _parent.type.ref?.length > 1)) {
+        forEachKey(finalSub, (key) => { // copy `type` + properties (default, etc.)
+          if ((_parent[key] === undefined || key === 'type') && (isCast && !propertiesToSkipForCasts[key] || !isCast))
+            _parent[key] = finalSub[key];
+        });
       }
     };
   }

package/lib/transform/forOdata.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { isBetaEnabled } = require('../base/model');
+const { isBuiltinType } = require('../base/builtins');
 const transformUtils = require('./transformUtils');
 const {
   forEachDefinition,
@@ -91,9 +92,10 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
 
   const transformers = transformUtils.getTransformers(csn, options, messageFunctions, '_');
   const {
-    addDefaultTypeFacets, checkMultipleAssignments,
-    recurseElements, setAnnotation, renameAnnotation,
-    expandStructsInExpression,
+    addDefaultTypeFacets, addElement,
+    checkMultipleAssignments, createScalarElement,
+    recurseElements, setAnnotation,
+    renameAnnotation, expandStructsInExpression,
     csnUtils,
   } = transformers;
 
@@ -293,6 +295,9 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
     // Resolve annotation shorthands for entities, types, annotations, ...
     renameShorthandAnnotations(def);
 
+    // Generate annotations and fields needed for the Fiori Tree Views out of the @hierarchy annotation
+    generateFioriTreeViewAnnotationsAndFields(def, defName);
+
     // Annotate artifacts with their DB names if requested.
     // Skip artifacts that have no DB equivalent anyway
     if (options.sqlMapping && !(def.kind in skipPersNameKinds))
@@ -360,6 +365,124 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   //--------------------------------------------------------------------
   // HELPER SECTION STARTS HERE
 
+  // =====================================================================
+  // Generate annotations and fields needed for the Fiori Tree Views out of the @hierarchy annotation
+  function generateFioriTreeViewAnnotationsAndFields(def, defName) {
+    const re = new RegExp('^@hierarchy#.+$');
+    if (Object.keys(def).some(key => re.test(key)))
+      error(null, [ 'definitions', defName ], {}, 'Assigning qualifier with the @hierarchy annotation is not supported');
+
+    if (!def['@hierarchy'])
+      return;
+    if (!(def.projection || def.query))
+      return;
+
+    const defKeys = [];
+    const assocs = [];
+    Object.entries(def.elements).forEach(([ name, elem ]) => {
+      if (elem.key)
+        defKeys.push([ name, elem ]);
+      if (isAssociation(elem) && elem.target === defName)
+        assocs.push([ name, elem ]);
+    });
+
+    // the definition must have exactly one scalar key field
+    if (defKeys.length !== 1 && !isBuiltinType(defKeys[0].type))
+      return;
+    const defKeyName = defKeys[0][0];
+
+    // if the @hierarchy annotation has a true value, we need to make sure the definition has exacly one
+    // association pointing to self and has the single key field as a foreign key
+    if (typeof def['@hierarchy'] === 'boolean' && def['@hierarchy'] === true) {
+      if (assocs.length !== 1)
+        return;
+      const assocName = assocs[0][0];
+      const assoc = assocs[0][1];
+      if (!isValidHierarchyAssociation(assoc, defKeyName))
+        return;
+      addHierarchyAnnotations(def, defName, defKeyName, assocName);
+      addHierarchyFields(def, defName);
+    }
+    else if (typeof def['@hierarchy'] === 'object' && def['@hierarchy']['=']) {
+      const assocName = def['@hierarchy']['='];
+      if (!isValidHierarchyAssociation(assocs.find(a => a[0] === assocName)[1], defKeyName))
+        return;
+      addHierarchyAnnotations(def, defName, defKeyName, assocName);
+      addHierarchyFields(def, defName);
+    }
+  }
+
+  // returns true if assoc has one key and that one key is the corresponding 'keyName'
+  function isValidHierarchyAssociation(assoc, keyName) {
+    return assoc.keys.length === 1 && assoc.keys[0].ref.join() === keyName;
+  }
+
+  function addHierarchyAnnotations(def, defName, defKeyName, assocName) {
+    const qualifier = `${ defName.split('.').pop() }Hierarchy`;
+
+    [ `@Aggregation.RecursiveHierarchy#${ qualifier }`,
+      `@Aggregation.RecursiveHierarchy#${ qualifier }.NodeProperty`,
+      `@Aggregation.RecursiveHierarchy#${ qualifier }.ParentNavigationProperty`,
+      `@Hierarchy.RecursiveHierarchy#${ qualifier }`,
+      `@Hierarchy.RecursiveHierarchy#${ qualifier }.LimitedDescendantCount`,
+      `@Hierarchy.RecursiveHierarchy#${ qualifier }.DistanceFromRoot`,
+      `@Hierarchy.RecursiveHierarchy#${ qualifier }.DrillState`,
+      `@Hierarchy.RecursiveHierarchy#${ qualifier }.LimitedRank` ].forEach(anno => checkAndReportErrorWhenAnnotationExists(def, defName, anno));
+
+    setAnnotation(def, `@Aggregation.RecursiveHierarchy#${ qualifier }.NodeProperty`, { '=': defKeyName });
+    setAnnotation(def, `@Aggregation.RecursiveHierarchy#${ qualifier }.ParentNavigationProperty`, { '=': assocName });
+    setAnnotation(def, `@Hierarchy.RecursiveHierarchy#${ qualifier }.LimitedDescendantCount`, { '=': 'LimitedDescendantCount' });
+    setAnnotation(def, `@Hierarchy.RecursiveHierarchy#${ qualifier }.DistanceFromRoot`, { '=': 'DistanceFromRoot' });
+    setAnnotation(def, `@Hierarchy.RecursiveHierarchy#${ qualifier }.DrillState`, { '=': 'DrillState' });
+    setAnnotation(def, `@Hierarchy.RecursiveHierarchy#${ qualifier }.LimitedRank`, { '=': 'LimitedRank' });
+
+    // if @Capabilities.FilterRestrictions.NonFilterableProperties or @Capabilities.SortRestrictions.NonSortableProperties
+    // are already defined, we append to the existing value the created elements
+    if (def['@Capabilities.FilterRestrictions.NonFilterableProperties'] && Array.isArray(def['@Capabilities.FilterRestrictions.NonFilterableProperties'])) {
+      def['@Capabilities.FilterRestrictions.NonFilterableProperties'].push('LimitedDescendantCount', 'DistanceFromRoot', 'DrillState', 'LimitedRank');
+    }
+    else {
+      setAnnotation(def, '@Capabilities.FilterRestrictions.NonFilterableProperties',
+                    [ 'LimitedDescendantCount', 'DistanceFromRoot', 'DrillState', 'LimitedRank' ]);
+    }
+
+    if (def['@Capabilities.SortRestrictions.NonSortableProperties'] && Array.isArray(def['@Capabilities.SortRestrictions.NonSortableProperties'])) {
+      def['@Capabilities.FilterRestrictions.NonFilterableProperties'].push('LimitedDescendantCount', 'DistanceFromRoot', 'DrillState', 'LimitedRank');
+    }
+    else {
+      setAnnotation(def, '@Capabilities.SortRestrictions.NonSortableProperties',
+                    [ 'LimitedDescendantCount', 'DistanceFromRoot', 'DrillState', 'LimitedRank' ]);
+    }
+  }
+
+  function addHierarchyFields(def, defName) {
+    const limitedDescendantCount = createScalarElement('LimitedDescendantCount', 'cds.Integer');
+    limitedDescendantCount.LimitedDescendantCount['@Core.Computed'] = true;
+    limitedDescendantCount.LimitedDescendantCount.$calc = { val: null };
+    addElement(limitedDescendantCount, def, defName);
+
+    const distanceFromRoot = createScalarElement('DistanceFromRoot', 'cds.Integer');
+    distanceFromRoot.DistanceFromRoot['@Core.Computed'] = true;
+    distanceFromRoot.DistanceFromRoot.$calc = { val: null };
+    addElement(distanceFromRoot, def, defName);
+
+    const drillState = createScalarElement('DrillState', 'cds.String');
+    drillState.DrillState['@Core.Computed'] = true;
+    drillState.DrillState.$calc = { val: null };
+    addElement(drillState, def, defName);
+
+    const limitedRank = createScalarElement('LimitedRank', 'cds.Integer');
+    limitedRank.LimitedRank['@Core.Computed'] = true;
+    limitedRank.LimitedRank.$calc = { val: null };
+    addElement(limitedRank, def, defName);
+  }
+
+  function checkAndReportErrorWhenAnnotationExists(def, defName, anno) {
+    if (def[anno])
+      error(null, [ 'definitions', defName ], { anno, name: defName }, 'Annotation $(ANNO) is already defined on the hierarchy entity $(NAME)');
+  }
+  // =====================================================================
+
   // Transform @readonly/@mandatory/@disabled into @Common.FieldControl annotation
   // with a when/then/else expression consisting of the input from the annotations.
   function processDynamicFieldControlAnnotations(node) {

package/lib/transform/forRelationalDB.js

@@ -81,6 +81,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   let expandStructsInExpression;
   let flattenStructuredElement;
   let flattenStructStepsInRef;
+  let expandManagedToFksInArray;
 
   bindCsnReference();
 
@@ -219,8 +220,6 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     }
   });
 
-  processCalculatedElementsInEntities(csn, options);
-
   timetrace.start('Transform CSN');
 
   // Rename primitive types, make UUID a String; replace `items` by cds.LargeString
@@ -255,6 +254,15 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     forEachDefinition(csn, flattenIndexes);
     // Managed associations get an on-condition - in views and entities
     associations.attachOnConditions(csn, csnUtils, pathDelimiter);
+
+    // Add the foreign keys also to the columns if the association itself was explicitly selected
+    // TODO: Extend the expansion to also expand managed to their foreign
+    // TODO: Remember where in .elements we had associations and do it then?
+    applyTransformations(csn, {
+      columns: expandManagedToFksInArray(),
+      groupBy: expandManagedToFksInArray(true),
+      orderBy: expandManagedToFksInArray(true),
+    }, [], { allowArtifact: artifact => artifact.query !== undefined || artifact.projection !== undefined });
   }
 
   {
@@ -265,11 +273,11 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     // To be done after handleAssociations, since then the foreign keys of the managed assocs
     // are part of the elements
     if (doA2J)
-      fns.push(associations.getFKAccessFinalizer(csn, options, csnUtils, pathDelimiter));
+      fns.push(associations.getFKAccessFinalizer(csn, options, csnUtils, pathDelimiter, true));
 
     forEachDefinition(csn, fns);
   }
-
+  processCalculatedElementsInEntities(csn, options);
   // Create convenience views for localized entities/views.
   // To be done after getFKAccessFinalizer because associations are
   // handled and before handleDBChecks which removes the localized attribute.
@@ -474,6 +482,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
       addDefaultTypeFacets,
       expandStructsInExpression,
       csnUtils,
+      expandManagedToFksInArray,
     } = transformUtils.getTransformers(csn, options, messageFunctions, pathDelimiter));
   }
 

package/lib/transform/transformUtils.js

@@ -7,7 +7,7 @@
 const { setProp } = require('../base/model');
 
 const { copyAnnotations, applyTransformations, isDeepEqual } = require('../model/csnUtils');
-const { getUtils } = require('../model/csnUtils');
+const { getUtils, implicitAs } = require('../model/csnUtils');
 const { typeParameters } = require('../compiler/builtins');
 const { isBuiltinType } = require('../base/builtins');
 const { ModelError, CompilerAssertion } = require('../base/error');
@@ -60,6 +60,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
     resetAnnotation,
     expandStructsInExpression: tuples.expandStructsInExpression,
     flattenPath: tuples.flattenPath,
+    expandManagedToFksInArray,
   };
 
   /**
@@ -876,6 +877,55 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
     }
     return wasOverwritten;
   }
+
+  /**
+   * Expand managed associations in an array and insert them in-place
+   *
+   * If requested, leave out the assocs themselves
+   *
+   * @param {boolean} [killAssoc=false]
+   * @returns {Function} applyTransformationsCallback
+   */
+  function expandManagedToFksInArray( killAssoc = false ) {
+    return function expand(parent, prop, array, path) {
+      const newColumns = [];
+      for (let i = 0; i < array.length; i++) {
+        const col = array[i];
+        const element = csnUtils.getElement(col) || col.ref && csnUtils.inspectRef(path.concat(prop, i)).art;
+        if (!killAssoc || !element?.keys)
+          newColumns.push(col);
+        if (element?.keys)
+          element.keys.forEach(fk => addForeignKeyToColumns(fk, newColumns, col, options));
+      }
+      parent[prop] = newColumns;
+    };
+  }
+
+  /**
+   * FKs need to be added to the .columns
+   * @todo stolen from lib/transform/db/views.js
+   * @todo Can we maybe do this during expansion already?
+   * @param {object} foreignKey
+   * @param {object[]} columns
+   * @param {CSN.Column} associationColumn
+   * @param {CSN.Options} options
+   */
+  function addForeignKeyToColumns( foreignKey, columns, associationColumn, options ) {
+    const ref = cloneCsnNonDict(associationColumn.ref, options);
+    ref[ref.length - 1] = [ ref.at(-1).id || ref.at(-1) ].concat(foreignKey.as || foreignKey.ref).join(pathDelimiter);
+    const result = {
+      ref,
+    };
+    if (associationColumn.as) {
+      const columnName = `${ associationColumn.as }${ pathDelimiter }${ foreignKey.as || implicitAs(foreignKey.ref) }`;
+      result.as = columnName;
+    }
+
+    if (associationColumn.key)
+      result.key = true;
+
+    columns.push(result);
+  }
 }
 
 /**

package/lib/transform/translateAssocsToJoins.js

@@ -152,7 +152,7 @@ function translateAssocsToJoins(model, inputOptions = {}) {
     //    (same rewrite as (injected) assoc ON cond paths but with different table alias).
     // 5) Prepend table alias to all remaining paths
     env.walkover = {
-      from: false, onCondFrom: true, select: true, filter: false,
+      from: false, onCondFrom: true, select: true, filter: false, virtual: true,
     };
     env.callback = substituteDollarSelf;
     forEachQuery(walkQuery, env);
@@ -340,19 +340,38 @@ function translateAssocsToJoins(model, inputOptions = {}) {
           // if the assoc is not join relevant, we should have found the foreign key
           if (tail[i]._navigation.$njr && !fk)
             throw new CompilerAssertion('Debug me: No FK found for FK rewriting');
-
-          if (fk && fk.name.id !== tail[i + 1].id)
-            tail[i + 1].id = fk.name.id; // fk renamed
         }
       }
-      tail = [
-        {
-          id: tail.map(p => p.id).join(pathDelimiter),
-          _artifact: tail[tail.length - 1]._artifact,
-        },
-      ];
-      replaceNodeContent(pathNode,
-                         constructPathNode([ constructTableAliasPathStep(QA), ...tail ]));
+      // leave virtual paths as is
+      if ( tail.at(-1)._artifact.virtual?.val === true ) {
+        replaceNodeContent(pathNode, constructPathNode([ constructTableAliasPathStep(QA), ...tail ]));
+      }
+      else {
+        const newTail = [];
+        // construct the tail (segment after last join relevant navigation) and preserve association steps
+        // each association may have a structured prefix
+        // `struct.foo.bar.assoc. otherStruct.baz.otherAssoc.fk`
+        // --> `[otherStruct_baz_otherAssoc, fk]
+        for (let i = 0; i < tail.length; i++) {
+          if (tail[i]._navigation) {
+            const nextNavigation = tail.slice(i + 1).findIndex(ps => ps._navigation);
+            if (nextNavigation >= 0) {
+              newTail.push({
+                id: tail.slice(i, i + 1 + nextNavigation).map(ps => ps.id).join(pathDelimiter),
+                _artifact: tail[i + nextNavigation]._artifact,
+              });
+            }
+            else {
+              newTail.push({
+                id: tail.slice(i).map(ps => ps.id).join(pathDelimiter),
+                _artifact: tail.at(-1)._artifact,
+              });
+            }
+          }
+        }
+        replaceNodeContent(pathNode,
+                           constructPathNode([ constructTableAliasPathStep(QA), ...newTail ]));
+      }
     }
 
     function findForeignKey(assoc, fk) {
@@ -777,13 +796,18 @@ function translateAssocsToJoins(model, inputOptions = {}) {
         // points to the signature of the current view and ensures that the ON cond is
         // resolvable) make sure that the original assoc target is contained in the local
         // query source
-        if (assoc.kind === 'mixin' && i > 0 && fwdOrigin.kind !== 'mixin') {
+        const fwdTarget = fwdOrigin.target._artifact;
+        const assocSource = assoc._main;
+        if (assoc.kind === 'mixin' && (i > 0 || fwdTarget !== assocSource) && fwdOrigin.kind !== 'mixin') {
           const tas = Object.values(env.lead.$tableAliases);
-          const i = tas.findIndex(ta => ta._artifact === fwdOrigin.target._artifact);
-          if (i >= 0 && tas[i].$QA) {
-            newTgtAlias.id = tas[i].$QA.name.id;
-            newTgtAlias._artifact = tas[i]._effectiveType;
-            newTgtAlias._navigation = tas[i].$QA.path[0]._navigation;
+          const j = tas.findIndex(ta => ta._artifact === fwdOrigin.target._artifact);
+          if (j >= 0 && tas[j].$QA) {
+            newTgtAlias.id = tas[j].$QA.name.id;
+            newTgtAlias._artifact = tas[j]._effectiveType;
+            newTgtAlias._navigation = tas[j].$QA.path[0]._navigation;
+          }
+          else if (i === 0 && fwdTarget !== assocSource) {
+            newTgtAlias = Object.assign(newTgtAlias, srcAlias);
           }
           else {
             error(null, [ assocQAT._origin.location, assocQAT._origin ], { name: fwdOrigin.target._artifact.name.id, art: assoc.name.id },
@@ -1823,7 +1847,7 @@ function walkPath(node, env) {
   const art = path?.length && path[path.length - 1]._artifact;
 
   // regardless of the position in the query, ignore paths that have virtual path steps
-  if (art && path.some(ps => ps._artifact?.virtual?.val))
+  if (art && path.some(ps => ps._artifact?.virtual?.val) && !env.walkover.virtual)
     return path;
   if (art && !internalArtifactKinds.includes(art.kind) && node.scope !== 'param') {
     if (env.callback) {

package/package.json

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