@sap/cds-dk 10.1.0 → 10.1.1

package/node_modules/@cap-js/db-service/lib/infer/index.js

@@ -5,15 +5,19 @@ const cds = require('@sap/cds')
 const JoinTree = require('./join-tree')
 const { pseudos } = require('./pseudos')
 const { isCalculatedOnRead, getImplicitAlias, getModelUtils, defineProperty, hasOwnSkip, isRuntimeView } = require('../utils')
+const { depthGuarded, guardEntry } = require('../recursion-guard')
 const cdsTypes = cds.builtin.types
 /**
  * @param {import('@sap/cds/apis/cqn').Query|string} originalQuery
  * @param {import('@sap/cds/apis/csn').CSN} [model]
  * @returns {import('./cqn').Query} = q with .target and .elements
  */
-function infer(originalQuery, model, useTechnicalAlias = true) {
+function _infer(originalQuery, model, useTechnicalAlias = true) {
   if (!model) throw new Error('Please specify a model')
   const inferred = originalQuery
+  // guard func args / lists / xpr / exists nesting
+  // eslint-disable-next-line no-func-assign
+  inferArg = depthGuarded(inferArg)
 
   const { getDefinition } = getModelUtils(model, originalQuery)
 
@@ -291,19 +295,23 @@ function infer(originalQuery, model, useTechnicalAlias = true) {
      */
     function walkTokenStream(tokenStream, inXpr = false) {
       let skipJoins
-      const processToken = t => {
-        if (t === 'exists') {
-          // no joins for infix filters along `exists <path>`
-          skipJoins = true
-        } else if (t.xpr) {
-          // don't miss an exists within an expression
-          t.xpr.forEach(processToken)
-        } else {
-          inferArg(t, queryElements, null, { inExists: skipJoins, inXpr, inQueryModifier: true })
-          skipJoins = false
+      const processToken = depthGuarded(walker())
+      tokenStream.forEach(processToken)
+
+      function walker() {
+        return t => {
+          if (t === 'exists') {
+            // no joins for infix filters along `exists <path>`
+            skipJoins = true
+          } else if (t.xpr) {
+            // don't miss an exists within an expression
+            t.xpr.forEach(processToken)
+          } else {
+            inferArg(t, queryElements, null, { inExists: skipJoins, inXpr, inQueryModifier: true })
+            skipJoins = false
+          }
         }
       }
-      tokenStream.forEach(processToken)
     }
     /**
      * Processes references starting with `$self`, which are intended to target other query elements.
@@ -631,7 +639,7 @@ function infer(originalQuery, model, useTechnicalAlias = true) {
         } else if (arg.inline && queryElements) {
           const elements = resolveInline(arg)
           for (const elName in elements) {
-            if (queryElements[elName] !== undefined) rejectDuplicatedElement(elName)  
+            if (queryElements[elName] !== undefined) rejectDuplicatedElement(elName)
           }
           Object.assign(queryElements, elements)
         } else {
@@ -667,7 +675,7 @@ function infer(originalQuery, model, useTechnicalAlias = true) {
     // ignore whole expand if target of assoc along path has ”@cds.persistence.skip”
     if (arg.expand) {
       const { $refLinks } = arg
-      
+
       const skip = $refLinks.some(link => {
         const def = getDefinition(link.definition.target)
         return hasOwnSkip(def) && !isRuntimeView(def)
@@ -1095,7 +1103,7 @@ function infer(originalQuery, model, useTechnicalAlias = true) {
       for (const k in elements) {
         if (!exclude(k)) {
           const element = elements[k]
-          if (element.type !== 'cds.LargeBinary') {
+          if (element.type !== 'cds.LargeBinary' && element.type !== 'cds.Vector') {
             queryElements[k] = element
           }
           // only relevant if we actually select the calculated element
@@ -1115,7 +1123,7 @@ function infer(originalQuery, model, useTechnicalAlias = true) {
       }
       if (exclude(name) || name in queryElements) return true
       const element = tableAliases[0].tableAlias.elements[name]
-      if (element.type !== 'cds.LargeBinary') queryElements[name] = element
+      if (element.type !== 'cds.LargeBinary' && element.type !== 'cds.Vector') queryElements[name] = element
       if (isCalculatedOnRead(element)) {
         linkCalculatedElement(element)
       }
@@ -1287,4 +1295,7 @@ function getMainAlias (query) {
   return mainAlias
 }
 
+// guardEntry bounds nested-subquery re-entry (expand, from, set)
+const infer = guardEntry(_infer)
+
 module.exports = infer

package/node_modules/@cap-js/db-service/lib/recursion-guard.js

@@ -0,0 +1,40 @@
+'use strict'
+
+const cds = require('@sap/cds')
+
+// shared across cqn4sql and infer to guard against stack overflow from user-controlled nesting depth
+const MAX_RECURSION_DEPTH = 100
+
+let recursionDepth = 0
+
+function enterRecursion() {
+  if (++recursionDepth > MAX_RECURSION_DEPTH) throw cds.error(400, `Query exceeds the maximum nesting depth of ${MAX_RECURSION_DEPTH}`)
+}
+
+function depthGuarded(fn) {
+  return function (...args) {
+    enterRecursion()
+    try {
+      return fn.apply(this, args)
+    } finally {
+      recursionDepth--
+    }
+  }
+}
+
+// entry points (infer / cqn4sql): outermost call resets the counter, so a thrown
+// depth error can't leave it polluted for the next request
+function guardEntry(fn) {
+  return function (...args) {
+    const outermost = recursionDepth === 0
+    enterRecursion()
+    try {
+      return fn.apply(this, args)
+    } finally {
+      if (outermost) recursionDepth = 0
+      else recursionDepth--
+    }
+  }
+}
+
+module.exports = { depthGuarded, guardEntry }

package/node_modules/@cap-js/db-service/lib/search.js

@@ -166,7 +166,7 @@ const computeColumnsToBeSearched = (cqn, entity = { __searchableColumns: [] }) =
         if (
           cqn.SELECT.columns.length === 1 &&
           column.func === 'count' &&
-          (column.as === '_counted_' || column.as === '$count')
+          column.as === '$count'
         ) {
           return
         }

package/node_modules/@cap-js/db-service/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/db-service",
-  "version": "3.0.1",
+  "version": "3.1.0",
   "description": "CDS base database service",
   "homepage": "https://github.com/cap-js/cds-dbs/tree/main/db-service#cds-base-database-service",
   "repository": {

package/node_modules/@cap-js/sqlite/CHANGELOG.md

@@ -4,6 +4,25 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [3.1.0](https://github.com/cap-js/cds-dbs/compare/sqlite-v3.0.2...sqlite-v3.1.0) (2026-09-07)
+
+
+### Added
+
+* Add support for `cds.Vector` on SQLite and Postgres ([#1676](https://github.com/cap-js/cds-dbs/issues/1676)) ([f0d2203](https://github.com/cap-js/cds-dbs/commit/f0d220324e8a1c7489966545000476bfd33f6b17))
+
+
+### Fixed
+
+* INSERT.from(SELECT) used non-existent `value`  ([#1565](https://github.com/cap-js/cds-dbs/issues/1565)) ([fd98844](https://github.com/cap-js/cds-dbs/commit/fd98844c83a78d6cf2b0b71344d3ee1d88528106))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @cap-js/db-service bumped from ^3.0.1 to ^3.1.0
+
 ## [3.0.2](https://github.com/cap-js/cds-dbs/compare/sqlite-v3.0.1...sqlite-v3.0.2) (2026-07-01)
 
 

package/node_modules/@cap-js/sqlite/lib/SQLiteService.js

@@ -14,16 +14,6 @@ const sqliteKeywords = keywords.reduce((prev, curr) => {
   return prev
 }, {})
 
-// define date and time functions in js to allow for throwing errors
-const isTime = /^\d{1,2}:\d{1,2}:\d{1,2}$/
-const hasTimezone = /([+-]\d{1,2}:?\d{0,2}|Z)$/
-const toDate = (d, allowTime = false) => {
-  const date = new Date(allowTime && isTime.test(d) ? `1970-01-01T${d}Z` : hasTimezone.test(d) ? d : d + 'Z')
-  if (Number.isNaN(date.getTime())) throw new Error(`Value does not contain a valid ${allowTime ? 'time' : 'date'} "${d}"`)
-  return date
-}
-
-
 class SQLiteService extends SQLService {
 
   get factory() {
@@ -46,6 +36,10 @@ class SQLiteService extends SQLService {
           dbc.function('hour', deterministic, d => d === null ? null : toDate(d, true).getUTCHours())
           dbc.function('minute', deterministic, d => d === null ? null : toDate(d, true).getUTCMinutes())
           dbc.function('second', deterministic, d => d === null ? null : toDate(d, true).getUTCSeconds())
+          dbc.function('COSINE_SIMILARITY', deterministic, (a, b) => cosineSimilarity(toFloatArray(a), toFloatArray(b)))
+          dbc.function('L2DISTANCE', deterministic, (a, b) => l2Distance(toFloatArray(a), toFloatArray(b)))
+          dbc.function('L2NORMALIZE', deterministic, v => v == null ? null : fromFloatArray(l2Normalize(toFloatArray(v)), v))
+          dbc.function('VECTOR_EMBEDDING', deterministic, (input, text_type, model_and_version) => input == null ? null : JSON.stringify(hashEmbedding(String(input))))
           if (database !== ':memory:') dbc.pragma?.('journal_mode = WAL') || dbc.exec('PRAGMA journal_mode = WAL')
           return dbc
         } catch (err) {
@@ -184,7 +178,7 @@ class SQLiteService extends SQLService {
     let ps = await this.prepare(sql)
     const vals = await this._prepareStreams(values)
     const { changes } = await ps.run(vals)
-    return this._return_affected (changes)
+    return this._return_affected(changes)
   }
 
   onPlainSQL({ query, data }, next) {
@@ -273,9 +267,9 @@ class SQLiteService extends SQLService {
       // Reading decimal as string to not loose precision
       Decimal: cds.env.features.ieee754compatible
         ? (expr, elem) =>
-            elem?.scale
-              ? `CASE WHEN ${expr} IS NULL THEN NULL ELSE format('%.${elem.scale}f', ${expr}) END`
-              : `CASE WHEN ${expr} IS NULL THEN NULL ELSE rtrim(rtrim(format('%.999f', ${expr}), '0'), '.') END`
+          elem?.scale
+            ? `CASE WHEN ${expr} IS NULL THEN NULL ELSE format('%.${elem.scale}f', ${expr}) END`
+            : `CASE WHEN ${expr} IS NULL THEN NULL ELSE rtrim(rtrim(format('%.999f', ${expr}), '0'), '.') END`
         : undefined,
       // Binary is not allowed in json objects
       Binary: expr => `${expr} || ''`,
@@ -321,4 +315,106 @@ function loadSQLite(driver) {
   }
 }
 
+// define date and time functions in js to allow for throwing errors
+const isTime = d => /^\d{1,2}:\d{1,2}:\d{1,2}$/.test(d)
+const hasTimezone = d => /([+-]\d{1,2}:?\d{0,2}|Z)$/.test(d)
+const toDate = (d, allowTime = false) => {
+  const date = new Date(allowTime && isTime(d) ? `1970-01-01T${d}Z` : hasTimezone(d) ? d : d + 'Z')
+  if (Number.isNaN(date.getTime())) throw new Error(`Value does not contain a valid ${allowTime ? 'time' : 'date'} "${d}"`)
+  return date
+}
+
+// Vector functions implemented in JavaScript for SQLite (registered as custom SQL functions)
+function cosineSimilarity(a, b) {
+  if (a == null || b == null) return null
+  let dot = 0, normA = 0, normB = 0
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i]
+    normA += a[i] * a[i]
+    normB += b[i] * b[i]
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB)
+  return denom === 0 ? 0 : dot / denom
+}
+
+function l2Distance(a, b) {
+  if (a == null || b == null) return null
+  let sum = 0
+  for (let i = 0; i < a.length; i++) {
+    const diff = a[i] - b[i]
+    sum += diff * diff
+  }
+  return Math.sqrt(sum)
+}
+
+function l2Normalize(v) {
+  if (v == null) return null
+  let norm = 0
+  for (let i = 0; i < v.length; i++) norm += v[i] * v[i]
+  if (norm === 0) return v
+  norm = Math.sqrt(norm)
+  for (let i = 0; i < v.length; i++) v[i] /= norm
+  return v
+}
+
+/**
+ * Deterministic synchronous hash-based embedding function for SQLite.
+ * NOTE: If a synchronous embedding library becomes available for Node.js,
+ * it can be integrated here to replace the hash-based implementation.
+ */
+function hashEmbedding(text, dimensions = 384) {
+  if (text == null) return null
+  const vector = new Float32Array(dimensions)
+  const normalized = text.toLowerCase()
+  const ngramSize = 3
+
+  if (normalized.length >= ngramSize) {
+    for (let i = 0; i <= normalized.length - ngramSize; i++)
+      project(ngramHash(normalized, i, ngramSize), vector, dimensions)
+  } else {
+    for (let i = 0; i < normalized.length; i++)
+      project(normalized.charCodeAt(i), vector, dimensions)
+  }
+  return Array.from(l2Normalize(vector))
+}
+
+function ngramHash(text, start, len) {
+  let hash = 0x811c9dc5
+  for (let i = start; i < start + len; i++) {
+    hash ^= text.charCodeAt(i)
+    hash = Math.imul(hash, 0x01000193)
+  }
+  return hash
+}
+
+function project(hash, vector, dimensions) {
+  for (let band = 0; band < 4; band++) {
+    const h = rehash(hash, band)
+    vector[Math.abs(h % dimensions)] += ((h >>> 16) & 1) === 0 ? 1.0 : -1.0
+  }
+}
+
+function rehash(hash, band) {
+  let h = hash ^ Math.imul(band, 0x9e3779b9)
+  h ^= h >>> 16
+  h = Math.imul(h, 0x45d9f3b)
+  h ^= h >>> 16
+  return h
+}
+
+// Vector type conversion helpers for SQLite - handle various input formats (Buffer, string, array, typed arrays)
+function toFloatArray(vector) {
+  if (vector == null) return null
+  if (vector instanceof Float32Array) return Array.from(vector)
+  if (Buffer.isBuffer(vector)) return JSON.parse(vector.toString('utf8'))
+  if (vector instanceof Uint8Array) return JSON.parse(Buffer.from(vector).toString('utf8'))
+  if (typeof vector === 'string') return JSON.parse(vector)
+  if (Array.isArray(vector)) return vector
+  throw new Error(`Unsupported vector type: ${typeof vector}`)
+}
+
+function fromFloatArray(arr, original) {
+  return original instanceof Float32Array ? new Float32Array(arr) : JSON.stringify(arr)
+}
+
 module.exports = SQLiteService

package/node_modules/@cap-js/sqlite/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/sqlite",
-  "version": "3.0.2",
+  "version": "3.1.0",
   "description": "CDS database service for SQLite",
   "homepage": "https://github.com/cap-js/cds-dbs/tree/main/sqlite#cds-database-service-for-sqlite",
   "repository": {
@@ -26,12 +26,12 @@
     "test": "cds-test"
   },
   "dependencies": {
-    "@cap-js/db-service": "^3.0.1"
+    "@cap-js/db-service": "^3.1.0"
   },
   "peerDependencies": {
     "@sap/cds": "^10",
     "sql.js": "^1.13.0",
-    "better-sqlite3": "^12.0.0"
+    "better-sqlite3": "^12.0.0 || ^13.0.0"
   },
   "peerDependenciesMeta": {
     "sql.js": {

package/node_modules/@sap/cds-compiler/CHANGELOG.md

@@ -15,6 +15,21 @@ might use a deprecated flag only for a limited period of time.
 
 
 
+## Version 7.1.1 - 2026-09-08
+
+### Bug Fixes
+
+- **effective:**
+  + Fix dump in flattening for actions with entity parameters.
+  + Ensure consistent handling of reference-like annotation expressions during flattening.
+- **sql:**
+  + Add missing `@hierarchy` columns to localized convenience views.
+  + Avoid crash on mixin backlink with renamed target element.
+  + The generated SQL for a reference `assoc.elem` where `assoc` is an association defined with duplicate backlink comparisons with `$self` is now more likely
+    to be correct. Usually, there is an error for the definition of such an `assoc`, but the corresponding message can be downgraded to a warning.
+
+
+
 ## Version 7.1.0 - 2026-08-27
 
 ### Features

package/node_modules/@sap/cds-compiler/lib/compiler/resolve.js

@@ -1189,9 +1189,13 @@ function resolve( model ) {
       const backlinkPath = itemIsPath ? item : right;
       const last = backlinkPath.path[backlinkPath.path.length - 1];
       if (assoc.$backlink) {
-        const location = combinedLocation( item.path[0], right.path[right.path.length - 1] );
-        message( 'ref-duplicate-self-comparison', [ location, assoc ], { id: '$self' },
-                 'Duplicate comparison with a bare $(ID) reference in an ON-condition' );
+        if (!assoc.on.$inferred) {
+          const location = combinedLocation( item.path[0], right.path[right.path.length - 1] );
+          message( 'ref-duplicate-self-comparison', [ location, assoc ], { id: '$self' },
+                   'Duplicate comparison with a bare $(ID) reference in an ON-condition' );
+        }
+        if (last?._artifact !== assoc.$backlink._origin)
+          setLink( assoc.$backlink, '_origin', null );
         return;
       }
       const backlinkRef = last?._artifact;

package/node_modules/@sap/cds-compiler/lib/model/csnUtils.js

@@ -8,6 +8,7 @@ const {
   applyTransformationsOnNonDictionary,
   applyTransformationsOnDictionary,
   mergeTransformers,
+  isSimpleAnnoExprRef,
 } = require('../transform/db/applyTransformations');
 const { isBuiltinType, isAnnotationExpression, primaryExprProperties } = require('../base/builtins');
 const { ModelError, CompilerAssertion } = require('../base/error');
@@ -1512,6 +1513,7 @@ module.exports = {
   applyTransformationsOnNonDictionary,
   applyTransformationsOnDictionary,
   mergeTransformers,
+  isSimpleAnnoExprRef,
   setDependencies,
   isPersistedOnDatabase,
   isPersistedAsView,

package/node_modules/@sap/cds-compiler/lib/transform/db/applyTransformations.js

@@ -423,6 +423,17 @@ function mergeTransformers( transformers, that ) {
   return remapped;
 }
 
+/**
+ * Return true if the annotation expression ref node is a simple reference:
+ * all ref steps are plain strings, and the node has neither `param` nor `cast`.
+ *
+ * @param {object} annotation An annotation expression node (has `ref`, optionally `param`, `cast`)
+ * @returns {boolean}
+ */
+function isSimpleAnnoExprRef(annotation) {
+  return annotation.ref && annotation.ref.every(s => typeof s === 'string') && !annotation.param && !annotation.cast;
+}
+
 module.exports = {
   mergeTransformers,
   transformExpression,
@@ -430,6 +441,7 @@ module.exports = {
   applyTransformations,
   applyTransformationsOnNonDictionary,
   applyTransformationsOnDictionary,
+  isSimpleAnnoExprRef,
 };
 
 

package/node_modules/@sap/cds-compiler/lib/transform/db/associations.js

@@ -5,6 +5,7 @@ const {
   applyTransformationsOnNonDictionary,
   applyTransformations,
   implicitAs,
+  isSimpleAnnoExprRef,
 } = require('../../model/csnUtils');
 
 /**
@@ -138,7 +139,7 @@ function getFKAccessFinalizer( csn, options, csnUtils, pathDelimiter, processOnI
         const annoAfter = JSON.stringify(obj[anno]);
         if (annoBefore !== annoAfter &&
             (options.transformation !== 'effective' || obj[anno]['=']) &&
-            !(obj[anno].ref && obj[anno].ref.every(s => typeof s === 'string')))
+            !(obj[anno].ref && isSimpleAnnoExprRef(obj[anno])))
           obj[anno]['='] = true;
       });
   }
@@ -251,10 +252,11 @@ function getFKAccessFinalizer( csn, options, csnUtils, pathDelimiter, processOnI
                     else {
                       refOwner.ref = [ ...ref.slice(0, i), newFkName ];
                     }
-                    if (ctx?.annoExpr === refOwner)
-                      ctx.annoExpr['='] = refOwner.ref.every(s => typeof s === 'string')
+                    if (ctx?.annoExpr === refOwner) {
+                      ctx.annoExpr['='] = isSimpleAnnoExprRef(refOwner)
                         ? refOwner.ref.join('.')
                         : true;
+                    }
                   }
                 }
                 else {

package/node_modules/@sap/cds-compiler/lib/transform/db/flattening.js

@@ -11,7 +11,7 @@ const { isBuiltinType, isMagicVariable } = require('../../base/builtins');
 const transformUtils = require('../transformUtils');
 const { csnRefs } = require('../../base/csnRefs');
 const { setProp, forEach } = require('../../utils/objectUtils');
-const { transformExpression } = require('./applyTransformations');
+const { transformExpression, isSimpleAnnoExprRef } = require('./applyTransformations');
 const { cloneCsnNonDict } = require('../../base/cloneCsn');
 const { EdmTypeFacetNames } = require('../../edm/EdmPrimitiveTypeDefinitions');
 const { adaptAnnotationsRefs } = require('../odata/adaptAnnotationRefs');
@@ -246,7 +246,8 @@ function getStructStepsFlattener( csn, options, messageFunctions, resolved, path
         adaptRefs.push((...args) => {
           const refChanged = fn(...args);
           if (refChanged && annotation['='])
-            annotation['='] = true;
+            // For simple refs (all-string steps, no param/cast), = contains the string representation of the ref.
+            annotation['='] = isSimpleAnnoExprRef(annotation) ? annotation.ref.join('.') : true;
         });
       }
       else {
@@ -664,7 +665,7 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, messageFun
         }
 
         if (options.transformation === 'effective') {
-          adaptAnnotationsRefs(fks, csnUtils, messageFunctions, eltPath);
+          adaptAnnotationsRefs(fks, csnUtils, messageFunctions, eltPath, options);
           const validAnnoNames = Object.keys(element).filter(pn => pn[0] === '@' && findAnnotationExpression(element, pn));
           fks.forEach(fk => copyAnnotations(element, fk[1], false, {}, validAnnoNames));
         }

package/node_modules/@sap/cds-compiler/lib/transform/effective/flattening.js

@@ -53,6 +53,18 @@ function flattenRefs(csn, options, csnUtils, messageFunctions) {
   const refFlattener = getStructStepsFlattener(csn, options, messageFunctions, resolved, '_', adaptRefs);
 
   forEachDefinition(csn, (def, defName) => {
+    // Unbound actions/functions/events: only flatten annotation expressions, not params.
+    // Their params may carry $self on-conditions that cannot be resolved without a query context.
+    if (def.kind === 'action' || def.kind === 'function' || def.kind === 'event') {
+      forEachMemberRecursively(def, (member, memberName, prop, path) => {
+        Object.keys(member).filter(pn => pn.startsWith('@') && member[pn]).forEach((pn) => {
+          transformAnnotationExpression(member, pn, [ refFlattener ], path);
+          adaptRefs.forEach(fn => fn());
+          adaptRefs.length = 0;
+        });
+      }, [ 'definitions', defName ]);
+      return;
+    }
     applyTransformationsOnNonDictionary(csn.definitions, defName, refFlattener, { processAnnotations: true, skipDict: { actions: 1 } }, [ 'definitions' ]);
 
     adaptRefs.forEach(fn => fn());
@@ -97,8 +109,12 @@ function flattenRefs(csn, options, csnUtils, messageFunctions) {
   });
 
   cleanup.forEach((obj) => {
-    if (obj.ref && obj.ref[0] === '$self')
+    // strip leading $self from ref array and (if it is a string) from '='
+    if (obj.ref && obj.ref[0] === '$self') {
       obj.ref.shift();
+      if (typeof obj['='] === 'string' && obj['='].startsWith('$self.'))
+        obj['='] = obj['='].slice('$self.'.length);
+    }
   });
 }
 

package/node_modules/@sap/cds-compiler/lib/transform/effective/main.js

@@ -103,6 +103,25 @@ function effectiveCsn( model, options, messageFunctions ) {
 
   resolveTypesInActionsAfterFlattening(csnUtils);
 
+  // Rewrite association keys in unbound action/function params to use flattened names.
+  // Not needed for bound actions: their params are reached via the parent entity and handled by flattenFKs in managedToUnmanaged.
+  forEachDefinition(csn, (def) => {
+    if (def.kind !== 'action' && def.kind !== 'function')
+      return;
+    if (!def.params)
+      return;
+    for (const param of Object.values(def.params)) {
+      if (!param.elements)
+        continue;
+      for (const element of Object.values(param.elements)) {
+        if (element.keys)
+          element.keys.forEach((key) => {
+            key.ref = [ key.ref.join('_') ];
+          });
+      }
+    }
+  });
+
   processCalculatedElementsInEntities(csn, options);
   // invalidate csnRef caches after flattening
   transformerUtils.csnUtils = getUtils(csn, 'init-all');

package/node_modules/@sap/cds-compiler/lib/transform/fioriTreeViews.js

@@ -16,7 +16,7 @@ const { isBuiltinType } = require('../base/builtins');
  *  - the foreign key is of scalar type
  * Otherwise, appropriate warnings/errors are raised.
  */
-function generateFioriTreeViewAnnotationsAndFields(def, defName, messageFunctions, csnUtils, transformers, options) {
+function generateFioriTreeViewAnnotationsAndFields(def, defName, messageFunctions, csnUtils, transformers, options, csn) {
   const { error, warning } = messageFunctions;
   const { isAssociation } = csnUtils;
   const { setAnnotation, addElement, createScalarElement } = transformers;
@@ -157,6 +157,17 @@ function generateFioriTreeViewAnnotationsAndFields(def, defName, messageFunction
   }
 
   function addHierarchyFields(def, defName) {
+    addHierarchyFieldsTo(def, defName);
+
+    // The localized convenience view is a stand-in for the annotated view at
+    // runtime, so it must carry the same hierarchy columns. It is generated
+    // before this transform runs, hence it is augmented here explicitly.
+    const localizedView = csn?.definitions?.[`localized.${ defName }`];
+    if (localizedView)
+      addHierarchyFieldsTo(localizedView, `localized.${ defName }`);
+  }
+
+  function addHierarchyFieldsTo(def, defName) {
     // add elements in elements dictionary
     const limitedDescendantCount = createScalarElement('LimitedDescendantCount', 'cds.Integer');
     limitedDescendantCount.LimitedDescendantCount['@Core.Computed'] = true;

package/node_modules/@sap/cds-compiler/lib/transform/forRelationalDB.js

@@ -367,7 +367,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     findAndMarkSqlServiceArtifacts(artifact, artifactName);
     if (artifact.$dummyService)
       createServiceDummy(artifact, artifactName, csn, messageFunctions);
-    generateFioriTreeViews(artifact, artifactName, messageFunctions, csnUtils, { setAnnotation, addElement, createScalarElement }, options);
+    generateFioriTreeViews(artifact, artifactName, messageFunctions, csnUtils, { setAnnotation, addElement, createScalarElement }, options, csn);
   }, transformViews ]);
 
   // TODO: Could we maybe merge this with the final applyTransformations?

package/node_modules/@sap/cds-compiler/lib/transform/odata/adaptAnnotationRefs.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { transformAnnotationExpression, implicitAs } = require('../../model/csnUtils');
+const { transformAnnotationExpression, implicitAs, isSimpleAnnoExprRef } = require('../../model/csnUtils');
 
 /**
  * Used during annotating of foreign keys.
@@ -13,10 +13,10 @@ const { transformAnnotationExpression, implicitAs } = require('../../model/csnUt
  * @param {object} messageFunctions
  * @param {CSN.Path} elementPath
  */
-function adaptAnnotationsRefs(generatedForeignKeys, csnUtils, { error }, elementPath) {
+function adaptAnnotationsRefs(generatedForeignKeys, csnUtils, { error }, elementPath, options) {
   if (Array.isArray(generatedForeignKeys?.[0])) {
     // ensure we are always called with an array of objects. TODO: Cleanup fk creation in for.effective to create array of objects
-    adaptAnnotationsRefs(remapToArrayOfObjects(generatedForeignKeys), csnUtils, { error }, elementPath);
+    adaptAnnotationsRefs(remapToArrayOfObjects(generatedForeignKeys), csnUtils, { error }, elementPath, options);
   }
   else {
     const reportedErrorsForAnnoPath = {};
@@ -49,8 +49,14 @@ function adaptAnnotationsRefs(generatedForeignKeys, csnUtils, { error }, element
               if (gfkForRef.length === 1) {
                 ref[0] = gfkForRef[0].prefix;
 
-                if (ctx?.annoExpr?.['='])
-                  ctx.annoExpr['='] = true;
+                if (ctx?.annoExpr?.['=']) {
+                  // TODO: Apply the same fix for OData once the OData behavior is aligned;
+                  //       when done, the `options` parameter can be removed from this function.
+                  if (options?.transformation === 'effective')
+                    ctx.annoExpr['='] = isSimpleAnnoExprRef(ctx.annoExpr) ? ctx.annoExpr.ref.join('.') : true;
+                  else
+                    ctx.annoExpr['='] = true;
+                }
               }
               else {
                 // check if the annotation reference points to a structure that has been expanded,