@sap/cds-dk 10.0.6 → 10.1.0

package/node_modules/@sap/cds-compiler/lib/render/utils/standardDatabaseFunctions.js

@@ -1,11 +1,24 @@
 'use strict';
 
+/**
+ * @typedef {object} FunctionRendererContext
+ * @property {Function} renderArgs - Renders a function argument node to SQL string.
+ * @property {Function} error - Compiler error reporting function.
+ * @property {string[]} path - Current CSN path for error reporting.
+ * @property {{ embeddingDefaultModel: string, embeddingHanaDefaultRemoteSource: string }} vector - Vector embedding options.
+ */
+
+/**
+ * @typedef {(this: FunctionRendererContext, signature: object) => string} DbFunction
+ */
+
 /**
  * List of functions for which we provide a mapping to the respective SQL dialect.
  * All functions are lowercase, the caller may treat the function name case-insensitive.
  *
  * The `this` context within the functions hold the `renderArgs` function.
  */
+/** @type {Record<string, Record<string, DbFunction>>} */
 const oDataFunctions = {
   // https://www.sqlite.org/lang_corefunc.html
   sqlite: {
@@ -116,7 +129,7 @@ const oDataFunctions = {
     //   let x = this.renderArgs({ ...signature, args: [ args[0] ] });
     //   const isNegative = x.startsWith("'-"); // Check for leading '-'
     //   x = isNegative ? x.replace('-', '') : x; // remove for easier processing
-    //   const sql = `((cast(substr(${x},2,instr(${x},'DT') - 2) as Integer) + (julianday('-4713-11-25T' || replace(replace(replace(substr(${x},instr(${x},'DT') + 2),'H',':'),'M',':'),'S','Z')) - 0.5)) * 86400)`;
+    //   const sql = `((cast(substr(${ x },2,instr(${ x },'DT') - 2) as Integer) + (julianday('-4713-11-25T' || replace(replace(replace(substr(${ x },instr(${ x },'DT') + 2),'H',':'),'M',':'),'S','Z')) - 0.5)) * 86400)`;
     //   return isNegative ? `-(${sql})` : sql;
     // },
   },
@@ -260,7 +273,7 @@ const oDataFunctions = {
     },
     matchespattern(signature) {
       // case … when only works as column expression (not in where)
-      // in the where clause, only "${x} LIKE_REGEXPR ${y}" works
+      // in the where clause, only "${ x } LIKE_REGEXPR ${ y }" works
       const args = getArgs(signature);
       checkArgs.call(this, 'matchespattern', args, 2);
       const x = this.renderArgs({ ...signature, args: [ args[0] ] });
@@ -556,6 +569,7 @@ const oDataFunctions = {
   },
 };
 
+/** @type {Record<string, Record<string, DbFunction>>} */
 const hanaFunctions = {
   sqlite: {
     /**
@@ -659,6 +673,11 @@ const hanaFunctions = {
       checkArgs.call(this, 'years_between', args, 2);
       return `floor((${ hanaFunctions.sqlite.months_between.call(this, signature) }) / 12)`;
     },
+
+    //
+    // Note: Vector functions for SQLite (cosine_similarity, l2distance, l2normalize and vector_embedding) have the
+    // same parameters as on HANA because we provide them via UDFs
+    //
   },
   postgres: {
     nano100_between(signature) {
@@ -697,6 +716,33 @@ const hanaFunctions = {
       checkArgs.call(this, 'years_between', args, 2);
       return `floor((${ hanaFunctions.postgres.months_between.call(this, signature) }) / 12)::INTEGER`;
     },
+
+    //
+    // Vector functions for postgres vector support based on the https://github.com/pgvector/pgvector
+    //
+    cosine_similarity(signature) {
+      const args = getArgs(signature);
+      checkArgs.call(this, 'cosine_similarity', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+
+      return `1 - cosine_distance(${ x },${ y })`;
+    },
+    l2distance(signature) {
+      const args = getArgs(signature);
+      checkArgs.call(this, 'l2distance', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+
+      return `l2_distance(${ x },${ y })`;
+    },
+    l2normalize(signature) {
+      const args = getArgs(signature);
+      checkArgs.call(this, 'l2normalize', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+
+      return `l2_normalize(${ x })`;
+    },
   },
   h2: {
     nano100_between(signature) {
@@ -757,8 +803,18 @@ const hanaFunctions = {
       checkArgs.call(this, 'years_between', args, 2);
       return `floor((${ hanaFunctions.h2.months_between.call(this, signature) }) / 12)`;
     },
+
+    //
+    // Note: Vector functions for H2 (cosine_similarity, l2distance, l2normalize, and vector_embedding) have the
+    // same parameters as on HANA because we provide them via UDFs
+    //
+  },
+  common: {
+    vector_embedding(signature) {
+      /** @type {FunctionRendererContext} */ const ctx = /** @type {any} */ (this);
+      return vectorEmbedding.call(ctx, signature);
+    },
   },
-  common: {},
   // identity functions + argument check
   hana: {
     nano100_between(signature) {
@@ -797,8 +853,67 @@ const hanaFunctions = {
       checkArgs.call(this, 'years_between', args, 2);
       return `years_between(${ this.renderArgs({ ...signature, args }) })`;
     },
+
+    //
+    // Vector functions - only identity check
+    //
+    cosine_similarity(signature) {
+      const args = getArgs(signature);
+      checkArgs.call(this, 'cosine_similarity', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+
+      return `cosine_similarity(${ x },${ y })`;
+    },
+    l2distance(signature) {
+      const args = getArgs(signature);
+      checkArgs.call(this, 'l2distance', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+
+      return `l2distance(${ x },${ y })`;
+    },
+    l2normalize(signature) {
+      const args = getArgs(signature);
+      checkArgs.call(this, 'l2normalize', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+
+      return `l2normalize(${ x })`;
+    },
+    vector_embedding(signature) {
+      /** @type {FunctionRendererContext} */ const ctx = /** @type {any} */ (this);
+      const sql = vectorEmbedding.call(ctx, signature);
+      if (sql.match('SAP.'))
+        return sql;
+      // If the model does not start with SAP an additional fourth parameter
+      // is necessary specifying the remote source behind which SAP AI Core lies on HANA
+      return `${ sql.substring(0, sql.length - 1) }, ${ this.vector.embeddingHanaDefaultRemoteSource })`;
+    },
   },
 };
+/**
+ * Arguments:
+ * 1. (mandatory) property for which to generate a vector
+ * 2. (optional) DOCUMENT / QUERY kind for embedding function. If not provided we default to 'DOCUMENT'
+ * 3. (optional) model. If not provided we default to a compiler setting or else the SAP NXY model
+ * @this {FunctionRendererContext}
+ * @param {object} signature
+ * @returns {string}
+ */
+function vectorEmbedding( signature ) {
+  const args = getArgs(signature);
+  // Default to kind DOCUMENT if no kind is specified
+  if (args.length === 1)
+    args.push('DOCUMENT');
+  // Default to the compiler option vectorEmbeddingDefaultModel if no model is specified
+  if (args.length === 2)
+    args.push(this.vector.embeddingDefaultModel);
+  checkArgs.call(this, 'vector_embedding', args, 3);
+  const field = this.renderArgs({ ...signature, args: [ args[0] ] });
+  const kind = this.renderArgs({ ...signature, args: [ args[1] ] });
+  const model = this.renderArgs({ ...signature, args: [ args[2] ] });
+  return `vector_embedding(${ field }, ${ kind }, ${ model })`;
+}
 
 /**
  * Normalizes `signature.args` to a positional array, handling both
@@ -808,6 +923,13 @@ function getArgs( signature ) {
   return Array.isArray(signature.args) ? signature.args : Object.values(signature.args);
 }
 
+/**
+ * @this {FunctionRendererContext}
+ * @param {string} funcName
+ * @param {any[]} receivedArgs
+ * @param {number} expectedLength
+ * @param {number | null} alternativeLength
+ */
 function checkArgs( funcName, receivedArgs, expectedLength, alternativeLength = null ) {
   const expectedMismatch = receivedArgs.length < expectedLength;
   const alternativeMismatch

package/node_modules/@sap/cds-compiler/lib/tool-lib/revealInternalProperties.js

@@ -15,6 +15,7 @@
 
 const msg = require('../base/messages');
 const { CompilerAssertion } = require('../base/error');
+const { isLeadingQuery } = require('../compiler/utils');
 
 const $inferred = Symbol.for('cds.$inferred');
 const $location = Symbol.for('cds.$location');
@@ -206,7 +207,7 @@ function revealInternalProperties( model, nameOrPath ) {
 
   function elements( dict, parent ) {
     // do not display elements of leading query as they are the same as the view elements:
-    return (parent._main && parent._main._leadingQuery === parent)
+    return (isLeadingQuery( parent ))
       ? '{ ... }'
       : dictionary( dict );
   }

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

@@ -41,6 +41,7 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
     mixin: dictionary,
     ref: pathRef,
     $origin: () => {}, // no-op
+    $backlink: () => undefined,
     '@': annotation,
   };
 
@@ -68,6 +69,8 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
    * @param {object} node The value of node[_prop]
    */
   function standard( _parent, _prop, node ) {
+    if (_prop === '$backlink')  // above line in transformers doesn't seem to help...
+      return;                   // ...in the OData backend
     if (!node || typeof node !== 'object' ||
         !{}.propertyIsEnumerable.call( _parent, _prop ) ||
         (options.skipIgnore && node.$ignore) ||

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

@@ -136,7 +136,9 @@ function getFKAccessFinalizer( csn, options, csnUtils, pathDelimiter, processOnI
         if (obj[anno].ref)
           transformer.ref(obj[anno], 'ref', obj[anno].ref, path.concat(anno));
         const annoAfter = JSON.stringify(obj[anno]);
-        if (annoBefore !== annoAfter && (options.transformation !== 'effective' || obj[anno]['=']))
+        if (annoBefore !== annoAfter &&
+            (options.transformation !== 'effective' || obj[anno]['=']) &&
+            !(obj[anno].ref && obj[anno].ref.every(s => typeof s === 'string')))
           obj[anno]['='] = true;
       });
   }
@@ -219,7 +221,7 @@ function getFKAccessFinalizer( csn, options, csnUtils, pathDelimiter, processOnI
      */
     function getTransformer() {
       return {
-        ref: (refOwner, prop, ref, path, grandParent) => {
+        ref: (refOwner, prop, ref, path, grandParent, _opt, ctx) => {
           // [<assoc base>.]<managed assoc>.<field>
           if (ref.length > 1) {
             const { links } = inspectRef(path);
@@ -249,6 +251,10 @@ 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')
+                        ? refOwner.ref.join('.')
+                        : true;
                   }
                 }
                 else {

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

@@ -175,12 +175,14 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
    * @returns {Array} New on-condition
    */
   function transformDollarSelfComparison( assocOp, assoc, assocName, elem, elemName, art, artifactName, path ) {
-    // Check: The forward link <assocOp> must point back to this artifact
+    // Check: The forward link <assocOp> must point back to this artifact.
+    // Skip when `$backlink` is present: the core compiler already validated the (possibly
+    // redirected/included) target and provided the redirected keys/on
     // FIXME: Unfortunately, we can currently only check this for non-views (because when a view selects
     // a backlink association element from an entity, the forward link will point to the entity,
     // not to the view).
     // FIXME: This also means that corresponding key fields should be in the select list etc ...
-    if (!art.query && !art.projection && assoc.target && assoc.target !== artifactName) {
+    if (!elem.$backlink && !art.query && !art.projection && assoc.target && assoc.target !== artifactName) {
       messageFunctions.error( null, path, { id: '$self', name: artifactName, target: assoc.target },
                               'Expected association using $(ID) to point back to $(NAME) but found $(TARGET)' );
     }
@@ -199,6 +201,16 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
       return [];
     }
 
+    // Prefer the `$backlink` helper (renaming-aware, target redirected to this artifact)
+    // over the backlink's own keys/on, so renamings are considered. Absent for
+    // same-entity backlinks, where the plain keys/on below are already correct.
+    const backlink = elem.$backlink;
+
+    if (Array.isArray(backlink))
+      return transformDollarSelfComparisonWithUnmanagedAssoc(assocOp, assoc, assocName, elemName, art, path, backlink);
+    if (backlink?.keys?.length)
+      return transformDollarSelfComparisonWithManagedAssoc(assocOp, assoc, assocName, elemName, art, path, backlink);
+
     if (assoc.keys) {
       // Transform comparison of $self to managed association into AND-combined foreign key comparisons
       if (assoc.keys.length > 0)
@@ -230,16 +242,19 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
    * @param {string} elemName
    * @param {CSN.Artifact} art
    * @param {CSN.Path} path
+   * @param {object} [backlink] renaming-aware `elem.$backlink` (`{ keys }`) to use instead of `assoc.keys`
    * @returns {Array} New on-condition
    */
-  function transformDollarSelfComparisonWithManagedAssoc( assocOp, assoc, originalAssocName, elemName, art, path) {
+  function transformDollarSelfComparisonWithManagedAssoc( assocOp, assoc, originalAssocName, elemName, art, path, backlink ) {
     const conditions = [];
     // if the element was structured then it was flattened => change of the delimiter from '.' to '_'
     // this is done in the flattening, but as we do not alter the onCond itself there should be done here as well
     const assocName = originalAssocName.replace(/\./g, pathDelimiter);
     elemName = elemName.replace(/\./g, pathDelimiter);
 
-    assoc.keys.forEach((k) => {
+    const keys = backlink?.keys ?? assoc.keys;
+
+    keys.forEach((k) => {
       // Depending on naming conventions, the foreign key may two path steps (hdbcds) or be a single path step with a flattened name (plain, quoted)
       // With to.hdbcds in conjunction with hdbcds naming, we need to NOT use the alias - else we get deployment errors
       const keyName = k.as && doA2J ? [ k.as ] : k.ref;
@@ -282,15 +297,16 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
    * @param {string} elemName
    * @param {CSN.Artifact} art
    * @param {CSN.Path} path
+   * @param {Array} [backlink] renaming-aware `elem.$backlink` ON-condition to use instead of `assoc.on`
    * @returns {Array} New on-condition
    */
-  function transformDollarSelfComparisonWithUnmanagedAssoc( assocOp, assoc, originalAssocName, elemName, art, path ) {
+  function transformDollarSelfComparisonWithUnmanagedAssoc( assocOp, assoc, originalAssocName, elemName, art, path, backlink ) {
     // if the element was structured then it may have been flattened => change of the delimiter from '.' to '_'
     // this is done in the flattening, but as we do not alter the onCond itself there should be done here as well
     elemName = elemName.replace(/\./g, pathDelimiter);
     const assocName = originalAssocName.replace(/\./g, pathDelimiter);
     // clone the onCond for later use in the path transformation
-    const newOnCond = cloneCsnNonDict(assoc.on, options);
+    const newOnCond = cloneCsnNonDict(backlink ?? assoc.on, options);
     applyTransformationsOnNonDictionary({ on: newOnCond }, 'on', {
       ref: (parent, prop, ref) => {
         let sourceSide = false;

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

@@ -592,6 +592,67 @@ function createReferentialConstraints( csn, options ) {
   }
 }
 
+/**
+ * Add an `ON DELETE CASCADE` referential constraint on the `DraftAdministrativeData_DraftUUID`
+ * foreign key of each draft shadow table, so deleting a draft's `DRAFT.DraftAdministrativeData`
+ * row removes all its shadow rows.
+ *
+ * Runs after the draft shadow entities exist (they don't during `createReferentialConstraints`).
+ * Their `DraftAdministrativeData` association is unmanaged and points at the service view, so the
+ * regular pass skips it; this pass references the `DRAFT.DraftAdministrativeData` table directly.
+ *
+ * Opt-in via the `draftAdminDataConstraints` option and independent of the global
+ * `assertIntegrity` / `assertIntegrityType` switches.
+ *
+ * @param {CSN.Model} csn
+ * @param {CSN.Options} options
+ */
+function createDraftAdminDataConstraints( csn, options ) {
+  if (options.draftAdminDataConstraints !== true)
+    return;
+
+  const draftAdminData = 'DRAFT.DraftAdministrativeData';
+  if (!csn.definitions[draftAdminData])
+    return;
+
+  const delimiter = options.sqlMapping === 'hdbcds' ? '.' : '_';
+  const foreignKeyName = `DraftAdministrativeData${ delimiter }DraftUUID`;
+
+  const validated = !options.integrityNotValidated;
+  const enforced = !options.integrityNotEnforced;
+
+  forEach(csn.definitions, ( artifactName, artifact ) => {
+    if (artifact.kind !== 'entity' || artifact.query || artifact.projection)
+      return;
+    const foreignKey = artifact.elements?.[foreignKeyName];
+    const assoc = artifact.elements?.DraftAdministrativeData;
+    // only draft shadow tables have both the association and its flattened foreign key
+    if (!foreignKey || !assoc || assoc.type !== ASSOCIATION)
+      return;
+
+    const identifierPrefix = options.pre2134ReferentialConstraintNames ? '' : 'c__';
+    const identifier = `${ identifierPrefix }${ getResultingName(csn, options.sqlMapping, artifactName) }_DraftAdministrativeData`;
+    const mapKey = `${ getResultingName(csn, 'quoted', artifactName) }_DraftAdministrativeData`;
+
+    if (!('$tableConstraints' in artifact))
+      artifact.$tableConstraints = Object.create(null);
+    if (!artifact.$tableConstraints.referential)
+      artifact.$tableConstraints.referential = Object.create(null);
+
+    artifact.$tableConstraints.referential[mapKey] = {
+      identifier,
+      foreignKey: [ foreignKeyName ],
+      parentKey: [ 'DraftUUID' ],
+      dependentTable: artifactName,
+      parentTable: draftAdminData,
+      onDelete: 'CASCADE',
+      onDeleteRemark: options.testMode ? 'Draft shadow entries are deleted when their DraftAdministrativeData entry is deleted' : null,
+      validated,
+      enforced,
+    };
+  });
+}
+
 /**
  * If the artifact has both, unique- and foreign key constraints, it is possible that the constraints have the same identifier.
  * This would end in table which can't be activated.
@@ -616,4 +677,4 @@ function assertConstraintIdentifierUniqueness( artifact, artifactName, path, err
   });
 }
 
-module.exports = { createReferentialConstraints, assertConstraintIdentifierUniqueness };
+module.exports = { createReferentialConstraints, createDraftAdminDataConstraints, assertConstraintIdentifierUniqueness };

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

@@ -1,6 +1,8 @@
 'use strict';
 
 const { CompilerAssertion } = require('../../base/error');
+const { transformAnnotationExpression } = require('../../model/csnUtils');
+const { expressionToCdlString } = require('../../render/toCdl');
 const { forEach } = require('../../utils/objectUtils');
 
 const directMappings = {
@@ -283,6 +285,43 @@ function sealAnnoMagic(csn) {
   };
 }
 
+/**
+ * Replace all annotation expression nodes with their CDL-like string representation.
+ *
+ * @param {CSN.Model} _csn
+ * @param {CSN.Options} options
+ * @param {object} messageFunctions
+ * @returns {object} Transformer object for applyTransformations
+ */
+function stringifyAnnotationExpressions( _csn, options, messageFunctions ) {
+  // exclude '#' so enum-symbol annotation values are kept as is
+  const expressionTransformers = {
+    ref: stringifyExpression,
+    xpr: stringifyExpression,
+    list: stringifyExpression,
+    val: stringifyExpression,
+    func: stringifyExpression,
+    SELECT: stringifyExpression,
+    SET: stringifyExpression,
+  };
+
+  return {
+    '@': (parent, prop, _anno, path) => transformAnnotationExpression(parent, prop, expressionTransformers, path),
+  };
+
+  function stringifyExpression( expressionNode, _prop, _value, _path, parent, parentProp ) {
+    // Keep unchecked refs that already have textual representation.
+    if (expressionNode.ref && typeof expressionNode['='] === 'string') {
+      delete expressionNode.ref;
+      delete expressionNode.param;
+      delete expressionNode.cast;
+      return;
+    }
+
+    parent[parentProp] = expressionToCdlString(expressionNode, options, messageFunctions);
+  }
+}
+
 function isPartOfINAService(csn, artifactName) {
   const parts = artifactName.split('.');
   if (parts.length === 1)
@@ -339,4 +378,5 @@ function getOnConditionAsComparisonTuples(on, assocName) {
 module.exports = {
   remapODataAnnotations,
   sealAnnoMagic,
+  stringifyAnnotationExpressions,
 };

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

@@ -113,6 +113,7 @@ function effectiveCsn( model, options, messageFunctions ) {
     options.remapOdataAnnotations ? annotations.remapODataAnnotations(csn) : {},
     misc.removeDefinitionsAndProperties(csn, options),
     options.deriveAnalyticalAnnotations ? annotations.sealAnnoMagic(csn) : {},
+    options.stringifyAnnoXpr ? annotations.stringifyAnnotationExpressions(csn, options, messageFunctions) : {},
   ], null);
 
   if (options.addCdsPersistenceName) {

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

@@ -17,7 +17,7 @@ const validate = require('../checks/validator');
 const { addTenantFields } = require('../transform/addTenantFields');
 const { addLocalizationViewsWithJoins } = require('../transform/localized');
 const { timetrace } = require('../utils/timetrace');
-const { createReferentialConstraints, assertConstraintIdentifierUniqueness } = require('./db/constraints');
+const { createReferentialConstraints, createDraftAdminDataConstraints, assertConstraintIdentifierUniqueness } = require('./db/constraints');
 const { setProp, forEach } = require('../utils/objectUtils');
 const handleExists = require('./db/assocsToQueries/transformExists');
 const { rewriteCalculatedElementsInViews, processCalculatedElementsInEntities } = require('./db/rewriteCalculatedElements');
@@ -340,6 +340,11 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   // no constraints for drafts
   generateDrafts(csn, options, pathDelimiter, messageFunctions);
 
+  // the DraftAdministrativeData_DraftUUID foreign key still gets a cascade constraint;
+  // must run after generateDrafts, as the shadow tables don't exist before
+  if (options.sqlDialect !== 'plain' && options.sqlDialect !== 'h2')
+    createDraftAdminDataConstraints(csn, options);
+
   // Set the final constraint paths and produce hana tc indexes if required
   // See function comment for extensive information.
   assertUnique.rewrite(csn, options, pathDelimiter);

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

@@ -24,6 +24,9 @@ function translateAssocsToJoinsCSN(csn, options) {
   const compileOptions = { ...options, $skipNameCheck: true };
   delete compileOptions.csnFlavor;
 
+  // DO NOT DELETE the `require('fs').writeFileSync(...)` lines in this function!
+  // Uncomment them to see the CSN input and output for A2J
+  // require('fs').writeFileSync('./a2j_in.csn', JSON.stringify(csn,null,2))
   const model = recompileX(csn, compileOptions);
   timetrace.stop('A2J: Recompiling model');
   timetrace.start('A2J: Translating associations to joins');
@@ -49,7 +52,9 @@ function translateAssocsToJoinsCSN(csn, options) {
     deduplicateMessages( options.messages );
   }
 
-  return compactModel(model, compileOptions);
+  const newCsn = compactModel(model, compileOptions);
+  // require('fs').writeFileSync('./a2j_out.csn', JSON.stringify(newCsn,null,2))
+  return newCsn;
 }
 
 function translateAssocsToJoins(model, inputOptions = {}) {
@@ -610,8 +615,7 @@ function translateAssocsToJoins(model, inputOptions = {}) {
               constructPathNode( [ tgtAlias, assoc.$flatTgtFKs[i] ] ) ],
           });
         }
-        // TODO: why inner "parenthesise" - comparison in `and`?
-        return parenthesise((args.length > 1 ? { op: { val: 'and' }, args: [ ...args.map(parenthesise) ] } : args[0] ));
+        return parenthesise((args.length > 1 ? { op: { val: 'and' }, args } : args[0] ));
       }
       else if (assoc.on) {
         if (env.assocStack === undefined) {
@@ -707,7 +711,7 @@ function translateAssocsToJoins(model, inputOptions = {}) {
 
       function cloneOnCondExprStream(expr) {
         const { args } = expr;
-        const result = { op: { val: expr.op.val }, args: [ ] };
+        const result = { op: { val: expr.op.val }, args: [ ], $parens: expr.$parens };
         for (let i = 0; i < args.length; i++) {
           const op = args[i].op?.val;
           if (op === 'xpr' || op === 'ixpr' || op === 'nary') {
@@ -727,7 +731,7 @@ function translateAssocsToJoins(model, inputOptions = {}) {
                 args[i + 2].$check = false;
               }
               else {
-                result.args.push(createOnCondition(fwdAssoc, ...swapTableAliasesForFwdAssoc(fwdAssoc, srcAlias, tgtAlias)));
+                result.args.push(createOnCondition(backlinkOf(assoc, fwdAssoc), ...swapTableAliasesForFwdAssoc(fwdAssoc, srcAlias, tgtAlias)));
               }
               i += 2; // skip next two tokens and continue with loop
               continue;
@@ -764,7 +768,7 @@ function translateAssocsToJoins(model, inputOptions = {}) {
             return expr;
           }
 
-          return createOnCondition(fwdAssoc, ...swapTableAliasesForFwdAssoc(fwdAssoc, srcAlias, tgtAlias));
+          return createOnCondition(backlinkOf(assoc, fwdAssoc), ...swapTableAliasesForFwdAssoc(fwdAssoc, srcAlias, tgtAlias));
         }
 
         // If this is an ordinary expression, clone it and mangle its arguments
@@ -1050,6 +1054,13 @@ function translateAssocsToJoins(model, inputOptions = {}) {
         }
         return undefined;
       }
+
+      // Build the backlink ON from the renaming-aware `$backlink` rather than the
+      // forward assoc's base-entity keys/on, if it is available.
+      function backlinkOf( backlinkAssoc, fwdAssoc ) {
+        const backlink = backlinkAssoc.$backlink;
+        return backlink && (backlink.foreignKeys || backlink.on) ? backlink : fwdAssoc;
+      }
     } // createOnCondition
   } // createJoinQA
 
@@ -1706,9 +1717,9 @@ function translateAssocsToJoins(model, inputOptions = {}) {
     return newObj;
   }
 
+  // to-csn now auto-wraps AND args that are OR-terms (see json/to-csn.js `case 'and'`),
+  // so A2J no longer needs to pre-wrap sub-expressions to preserve SQL precedence.
   function parenthesise(expr) {
-    if (typeof expr === 'object' && expr.op && expr.args)
-      setProp(expr, '$parens', [ expr.$location ]);
     return expr;
   }
 }

package/node_modules/@sap/cds-compiler/package.json

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

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

@@ -6,6 +6,57 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/).
 
+## Version 4.0.3 - 2026-08-21
+
+### Added
+
+- `cds-mtx subscribe`, `unsubscribe`, and `upgrade` now take more than one tenant at once, e.g. `cds-mtx upgrade t1 t2` or `cds-mtx upgrade t1,t2`.
+
+### Changed
+
+- Login endpoints renamed to `/-/cds/login/grant` and `/-/cds/login/grant-metadata` with redirects from former paths.
+
+### Fixed
+
+- HANA credential health-check now detects the available driver via `require.resolve()` instead of reading `package.json`, fixing `MODULE_NOT_FOUND` for apps that follow the "Plug & Play" guidance and don't declare `hdb` or `@sap/hana-client` directly.
+- Tenant upgrade now reports a clear per-tenant `422` error when a stored extension is incompatible with the changed base model, instead of aborting with an uncaught compilation error.
+
+## Version 4.0.2 - 2026-08-07
+
+### Fixed
+
+- `PUT /-/cds/extensibility/Extensions/<id>` with a status that is not active (0 or 1), now returns the correct entry.
+- Extensions table is now resolved properly again when `cds.sql.names = quoted` is set.
+
+### Changed
+- When updating from `@sap/cds-mtxs@<3.6.0`, you now need to upgrade your tenant database before you can add new extensions.
+
+## Version 4.0.1 - 2026-06-23
+
+### Changed
+
+- Migration from `@sap/cds-mtx` has been removed.
+- Annotation `@Common.FieldControl` is now also blocked for extensions.
+- Annotations `@Capabilities.*` are now also blocked for extensions.
+- The MTX sidecar now logs a warning if `cds.sql` is configured differently in both the project root and the sidecar. By setting `cds.env.requires['cds.xt.ModelProviderService']['use-root-sql-config'] === true`,
+you can enforce the configuration of the project root.
+
+### Fixed
+
+- Default value 3 for `cds.requires.multitenancy.jobs.clusterSize` is now effective for upgrade. When using HANA TMS v2, the default for `clusterSize` is set to 1.
+
+## Version 3.9.6 - 2026-08-07
+
+### Fixed
+
+- Parallel single-tenant upgrades no longer fail with `tar: Cannot open: File exists` when extensibility is disabled.
+- Deployment to tenant containers is more stable with a large number of service bindings provided via `VCAP_SERVICES_FILE_PATH`.
+- More robust error handling for HDI deployment logs on read-only file system on Kyma.
+- Configuration `cds.requires.multitenancy.retries` is now effective.
+- Reading tenants no longer logs a spurious `Failed to parse metadata to JSON` error for tenants without metadata.
+- A tenant's HANA connection pool now reliably recovers once valid credentials are restored, as cache-bypassing Service Manager lookups no longer overwrite the shared bindings cache with transiently invalid credentials.
+- More robust handling of Service Manager errors.
+
 ## Version 3.9.5 - 2026-07-01
 
 ### Changed