@sap/cds-compiler 4.5.0 → 4.6.2

package/lib/transform/effective/associations.js

@@ -17,14 +17,12 @@ const backlinks = require('../db/backlinks');
  * @param {CSN.Model} csn Input CSN - will not be transformed
  * @param {CSN.Options} options
  * @param {object} csnUtils
- * @param {object} messageFunctions
- * @param {Function} messageFunctions.error
- * @param {Function} messageFunctions.warning
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @todo Remove .keys afterwards
  * @todo Add created foreign keys into .columns in case of a query?
  * @returns {CSN.Model}
  */
-function turnAssociationsIntoUnmanaged( csn, options, csnUtils, { error, warning } ) {
+function turnAssociationsIntoUnmanaged( csn, options, csnUtils, messageFunctions ) {
   // TODO: Do we really need this?
   forEachDefinition(csn, (artifact, artifactName) => {
     setProp(artifact, '$path', [ 'definitions', artifactName ]);
@@ -33,7 +31,7 @@ function turnAssociationsIntoUnmanaged( csn, options, csnUtils, { error, warning
     }, [ 'definitions', artifactName ]);
   });
   // Flatten out the fks and create the corresponding elements
-  flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, error, warning, '_', true, csnUtils, { allowArtifact: () => true, skipDict: {} });
+  flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, messageFunctions, '_', true, csnUtils, { allowArtifact: () => true, skipDict: {} });
 
   // 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

package/lib/transform/effective/main.js

@@ -2,7 +2,6 @@
 
 const { isBetaEnabled } = require('../../base/model');
 const { CompilerAssertion } = require('../../base/error');
-const { makeMessageFunction } = require('../../base/messages');
 const { cloneCsnNonDict, getUtils, isAspect } = require('../../model/csnUtils');
 const transformUtils = require('../transformUtils');
 const flattening = require('../db/flattening');
@@ -26,21 +25,21 @@ const { rewriteCalculatedElementsInViews, processCalculatedElementsInEntities }
  * @private
  * @param {CSN.Model} model Input CSN - will not be transformed
  * @param {CSN.Options} options
+ * @param {object} messageFunctions
  * @returns {CSN.Model}
  */
-function effectiveCsn( model, options ) {
+function effectiveCsn( model, options, messageFunctions ) {
   if (!isBetaEnabled(options, 'effectiveCsn'))
     throw new CompilerAssertion('effective CSN is only supported with beta flag `effectiveCsn`!');
 
   const csn = cloneCsnNonDict(model, options);
-
   delete csn.vocabularies; // must not be set for effective CSN
+  messageFunctions.setModel(csn);
 
-  const { expandStructsInExpression } = transformUtils.getTransformers(csn, options, '_');
+  const { expandStructsInExpression } = transformUtils.getTransformers(csn, options, messageFunctions, '_');
   queries.projectionToSELECTAndAddColumns(csn);
 
   let csnUtils = getUtils(csn, 'init-all');
-  const messageFunctions = makeMessageFunction(csn, options, 'for.effective');
 
   // Run validations on CSN - each validator function has access to the message functions and the inspect ref via this
   const cleanup = validate.forRelationalDB(csn, {
@@ -65,13 +64,11 @@ function effectiveCsn( model, options ) {
 
   const resolveTypesInActionsAfterFlattening = types.resolve(csn, csnUtils);
 
-  csnUtils = getUtils(csn, 'init-all');
-
   // Remove properties attached by validator - they do not "grow" as the model grows.
   cleanup();
 
-  flattening.flattenAllStructStepsInRefs(csn, options, new WeakMap(), '_');
-  flattening.flattenElements(csn, options, '_', messageFunctions.error);
+  flattening.flattenAllStructStepsInRefs(csn, options, messageFunctions, new WeakMap(), '_');
+  flattening.flattenElements(csn, options, messageFunctions, '_');
 
   resolveTypesInActionsAfterFlattening();
 

package/lib/transform/forOdata.js

@@ -1,6 +1,5 @@
 'use strict';
 
-const { makeMessageFunction } = require('../base/messages');
 const { isDeprecatedEnabled, isBetaEnabled } = require('../base/model');
 const transformUtils = require('./transformUtils');
 const { cloneCsnNonDict,
@@ -24,6 +23,7 @@ const associations = require('./db/associations')
 const expansion = require('./db/expansion');
 const generateDrafts = require('./draft/odata');
 
+const { addTenantFields } = require('./addTenantFields');
 const { addLocalizationViews } = require('./localized');
 
 // Transformation for ODATA. Expects a CSN 'inputModel', processes it for ODATA.
@@ -68,19 +68,20 @@ const { addLocalizationViews } = require('./localized');
 //     (Linter check candidate)
 module.exports = { transform4odataWithCsn };
 
-function transform4odataWithCsn(inputModel, options) {
+function transform4odataWithCsn(inputModel, options, messageFunctions) {
   timetrace.start('OData transformation');
 
   // copy the model as we don't want to change the input model
   let csn = cloneCsnNonDict(inputModel, options);
+  messageFunctions.setModel(csn);
 
-  const { message, error, warning, info, throwWithAnyError } = makeMessageFunction(csn, options, 'for.odata');
+  const { message, error, warning, info, throwWithAnyError } = messageFunctions;
   throwWithAnyError();
 
   // the new transformer works only with new CSN
   checkCSNVersion(csn, options);
 
-  const transformers = transformUtils.getTransformers(csn, options, '_');
+  const transformers = transformUtils.getTransformers(csn, options, messageFunctions, '_');
   const {
     addDefaultTypeFacets, checkMultipleAssignments,
     recurseElements, setAnnotation, renameAnnotation,
@@ -117,6 +118,9 @@ function transform4odataWithCsn(inputModel, options) {
   if (options.csnFlavor === 'universal' && isBetaEnabled(options, 'enableUniversalCsn'))
     enrichUniversalCsn(csn, options);
 
+  if (options.tenantAsColumn)
+    addTenantFields(csn, options);
+
   const keepLocalizedViews = isDeprecatedEnabled(options, '_createLocalizedViews');
 
   function acceptLocalizedView(_name, parent) {
@@ -178,15 +182,15 @@ function transform4odataWithCsn(inputModel, options) {
     const resolved = new WeakMap();
     // No refs with struct-steps exist anymore
 
-    flattening.flattenAllStructStepsInRefs(csn, options, resolved, '_', { skipArtifact: isExternalServiceMember });
+    flattening.flattenAllStructStepsInRefs(csn, options, messageFunctions, resolved, '_', { skipArtifact: isExternalServiceMember });
     // No type references exist anymore
     // Needs to happen exactly between flattenAllStructStepsInRefs and flattenElements to keep model resolvable.
     // OData doesn't resolve type chains after the first 'items'
-    flattening.resolveTypeReferences(csn, options, resolved, '_',
+    flattening.resolveTypeReferences(csn, options, messageFunctions, resolved, '_',
       { skip: [ 'action', 'aspect', 'event', 'function', 'type'],
         skipArtifact: isExternalServiceMember, skipStandard: { items: true } });
     // No structured elements exists anymore
-    flattening.flattenElements(csn, options, '_', error,
+    flattening.flattenElements(csn, options, messageFunctions, '_',
       { skip: ['action', 'aspect', 'event', 'function', 'type'],
         skipArtifact: isExternalServiceMember,
         skipStandard: { items: true },  // don't drill further into .items
@@ -195,7 +199,7 @@ function transform4odataWithCsn(inputModel, options) {
 
   // TODO: add the generated foreign keys to the columns when we are in a view
   // see db/views.js::addForeignKeysToColumns
-  flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, error, warning, '_', !structuredOData, csnUtils,{ skipArtifact: isExternalServiceMember });
+  flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, messageFunctions, '_', !structuredOData, csnUtils,{ skipArtifact: isExternalServiceMember });
 
   // Allow using managed associations as steps in on-conditions to access their fks
   // To be done after handleManagedAssociationsAndCreateForeignKeys,
@@ -321,7 +325,7 @@ function transform4odataWithCsn(inputModel, options) {
         return;
       // Rename according to map above
       const renamePrefix = (name in renameMappings)
-        ? name 
+        ? name
         : renameShortCuts.find(p => name.startsWith(p + '.'));
       if(renamePrefix) {
         const mapping = renameMappings[renamePrefix];

package/lib/transform/forRelationalDB.js

@@ -6,13 +6,13 @@ const { cloneCsnNonDict,
         getArtifactDatabaseNameOf, getElementDatabaseNameOf, isBuiltinType, applyTransformations,
         isAspect, walkCsnPath, isPersistedOnDatabase
       } = require('../model/csnUtils');
-const { makeMessageFunction } = require('../base/messages');
 const transformUtils = require('./transformUtils');
 const { translateAssocsToJoinsCSN } = require('./translateAssocsToJoins');
 const { csnRefs, pathId, traverseQuery, columnAlias} = require('../model/csnRefs');
 const { checkCSNVersion } = require('../json/csnVersion');
 const validate = require('../checks/validator');
 const { rejectManagedAssociationsAndStructuresForHdbcdsNames } = require('../checks/selectItems');
+const { addTenantFields } = require('../transform/addTenantFields');
 const { addLocalizationViewsWithJoins, addLocalizationViews } = require('../transform/localized');
 const { timetrace } = require('../utils/timetrace');
 const { createReferentialConstraints, assertConstraintIdentifierUniqueness } = require('./db/constraints');
@@ -100,9 +100,9 @@ function forEachDefinition(csn, cb) {
  *
  * @param {CSN.Model}   csn
  * @param {CSN.Options} options
- * @param {string}      moduleName The calling compiler module name, e.g. `to.hdi` or `to.hdbcds`.
+ * @param {object}      messageFunctions Message functions such as `error()`, `info()`, …
  */
-function transformForRelationalDBWithCsn(csn, options, moduleName) {
+function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   // copy the model as we don't want to change the input model
   timetrace.start('HANA transformation');
 
@@ -111,6 +111,9 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
   csn = cloneCsnNonDict(csn, options);
   timetrace.stop('Clone CSN');
 
+  if (options.tenantAsColumn)
+    addTenantFields(csn, options);
+
   checkCSNVersion(csn, options);
 
   const pathDelimiter = (options.sqlMapping === 'hdbcds') ? '.' : '_';
@@ -120,12 +123,11 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
   /** @type {object} */
   let csnUtils;
   /** @type {object} */
-  let messageFunctions;
-  let message, error, warning, info; // message functions
+  let message, error, warning; // message functions
   /** @type {() => void} */
   let throwWithAnyError;
   // transformUtils
-  let addDefaultTypeFacets, 
+  let addDefaultTypeFacets,
     expandStructsInExpression,
     flattenStructuredElement,
     flattenStructStepsInRef;
@@ -180,7 +182,7 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
     //       assoc2join eventually rewrites the table aliases
     temporal.getViewDecorator(csn, messageFunctions, csnUtils),
     // check unique constraints - further processing is done in rewriteUniqueConstraints
-    assertUnique.prepare(csn, options, error, info)
+    assertUnique.prepare(csn, options, messageFunctions)
   ]);
 
   if(doA2J) {
@@ -204,15 +206,15 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
   if(doA2J) {
     const resolved = new WeakMap();
     // No refs with struct-steps exist anymore
-    flattening.flattenAllStructStepsInRefs(csn, options, resolved, pathDelimiter);
+    flattening.flattenAllStructStepsInRefs(csn, options, messageFunctions, resolved, pathDelimiter);
     // No type references exist anymore
     // Needs to happen exactly between flattenAllStructStepsInRefs and flattenElements to keep model resolvable.
-    flattening.resolveTypeReferences(csn, options, resolved, pathDelimiter);
+    flattening.resolveTypeReferences(csn, options, messageFunctions, resolved, pathDelimiter);
     // No structured elements exists anymore
-    flattening.flattenElements(csn, options, pathDelimiter, error);
+    flattening.flattenElements(csn, options, messageFunctions, pathDelimiter);
   } else {
     // For to.hdbcds with naming mode hdbcds we also need to resolve the types
-    flattening.resolveTypeReferences(csn, options, new WeakMap(), pathDelimiter);
+    flattening.resolveTypeReferences(csn, options, messageFunctions, new WeakMap(), pathDelimiter);
   }
 
   // With flattening errors, it makes little sense to continue.
@@ -285,7 +287,7 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
   ]);
 
   // eliminate the doA2J in the functions 'handleManagedAssociationFKs' and 'createForeignKeyElements'
-  doA2J && flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, error, warning, pathDelimiter, true, csnUtils, { skipDict: { actions: true }, allowArtifact: artifact => (artifact.kind === 'entity') });
+  doA2J && flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, messageFunctions, pathDelimiter, true, csnUtils, { skipDict: { actions: true }, allowArtifact: artifact => (artifact.kind === 'entity') });
 
   doA2J && forEachDefinition(csn, flattenIndexes);
   // Managed associations get an on-condition - in views and entities
@@ -358,6 +360,9 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
   // Associations that point to things marked with @cds.persistence.skip are removed
   forEachDefinition(csn, cdsPersistence.getAssocToSkippedIgnorer(csn, options, messageFunctions, csnUtils));
 
+  // some errors can't be handled in the subsequent processing steps for e.g. HDBCDS
+  messageFunctions.throwWithError();
+
   // Apply view-specific transformations
   // (160) Projections now finally become views
   // Replace managed association in group/order by with foreign keys
@@ -449,15 +454,15 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
   /* ----------------------------------- Functions start here -----------------------------------------------*/
 
   function bindCsnReference(){
-    messageFunctions = makeMessageFunction(csn, options, moduleName);
-    ({ error, warning, info, message, throwWithAnyError } = messageFunctions);
+    messageFunctions.setModel(csn);
+    ({ error, warning, message, throwWithAnyError } = messageFunctions);
 
     ({ flattenStructuredElement,
       flattenStructStepsInRef,
       addDefaultTypeFacets,
       expandStructsInExpression,
       csnUtils
-    } = transformUtils.getTransformers(csn, options, pathDelimiter));
+    } = transformUtils.getTransformers(csn, options, messageFunctions, pathDelimiter));
   }
 
   function bindCsnReferenceOnly(){
@@ -614,10 +619,10 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
       // (100 a) Ignore the property 'masked' itself (but not its effect on projections)
       if (member.masked)
         delete member.masked;
-      // For HANA: Report an error on
+      // Report an error on
       // - view with parameters that has an element of type association/composition
       // - association that points to entity with parameters
-      if (options.sqlDialect === 'hana' && member.target && csnUtils.isAssocOrComposition(member) && !isBetaEnabled(options, 'assocsWithParams')) {
+      if (member.target && csnUtils.isAssocOrComposition(member) && !isBetaEnabled(options, 'assocsWithParams')) {
         if (artifact.params) {
           // HANA does not allow 'WITH ASSOCIATIONS' on something with parameters:
           // SAP DBTech JDBC: [7]: feature not supported: parameterized sql view cannot support association: line 1 col 1 (at pos 0)
@@ -862,6 +867,20 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
             checkTypeParamValue(node, 'srid', { max: Number.MAX_SAFE_INTEGER }, path);
             break;
           }
+          case 'cds.Vector': {
+            if (options.sqlDialect !== 'hana') {
+              error('ref-unsupported-type', path, {
+                '#': 'hana', type: node.type, value: 'hana',
+                othervalue: options.sqlDialect
+              });
+            }
+            else if (options.transformation === 'hdbcds') {
+              error('ref-unsupported-type', path, {
+                '#': 'hdbcds', type: node.type, value: options.sqlDialect
+              });
+            }
+            break;
+          }
         }
       }
 

package/lib/transform/odata/toFinalBaseType.js

@@ -7,7 +7,7 @@ const {
 } = require('../../model/csnUtils');
 const { isArtifactInSomeService, isArtifactInService } = require('./utils');
 
-function expandToFinalBaseType(csn, transformers, csnUtils, services, options, isExternalServiceMember) {
+function expandToFinalBaseType(csn, transformers, csnUtils, services, options) {
   const isV4 = options.odataVersion === 'v4';
   const special$self = !csn?.definitions?.$self && '$self';
   forEachDefinition(csn, (def, defName) => {
@@ -63,7 +63,7 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
     if (def.kind === 'type' && def.items && isArtifactInSomeService(defName, services)) {
       expandFirstLevelOfArrayed(def);
     }
-  }, { skipArtifact: isExternalServiceMember });
+  });
 
   if(isBetaEnabled(options, 'odataTerms')) {
     forEachGeneric(csn, 'vocabularies', (def, defName) => {
@@ -75,7 +75,7 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
 
       expandToFinalBaseType(def, defName);
       expandToFinalBaseType(def.items, defName);
-    }, [], { skipArtifact: isExternalServiceMember });
+    }, []);
   }
   // In case we have in the model something like:
   // type Foo: array of Bar; type Bar: { qux: Integer };

package/lib/transform/odata/typesExposure.js

@@ -6,11 +6,11 @@
  * @module typesExposure
  */
 
-const { setProp } = require('../../base/model');
+const { setProp, isBetaEnabled } = require('../../base/model');
 const { defNameWithoutServiceOrContextName, isArtifactInService } = require('./utils');
-const { cloneCsnNonDict, isBuiltinType, forEachDefinition, forEachMember, forEachGeneric } = require('../../model/csnUtils');
-const { copyAnnotations, getNamespace } = require('../../model/csnUtils');
-const { isBetaEnabled } = require('../../base/model.js');
+const { getNamespace, copyAnnotations, cloneCsnNonDict,
+  isBuiltinType, isAnnotationExpression, 
+  forEachDefinition, forEachMember, forEachGeneric } = require('../../model/csnUtils');
 const { CompilerAssertion } = require('../../base/error');
 
 /**
@@ -219,7 +219,16 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
               }
             }
           });
-          copyAnnotations(typeDef, newType);
+
+          // expression annos and their sub annotations are not propagated to type
+          let [ xprANames, nxprANames ] = Object.keys(typeDef).reduce((acc, pn) => {
+            if (pn[0] === '@')
+              acc[isAnnotationExpression(typeDef[pn]) ? 0 : 1].push(pn);
+            return acc;
+          }, [ [], [] ]);
+          nxprANames = nxprANames.filter(an => !xprANames.some(ean => an.startsWith(`${ean}.`)));
+          copyAnnotations(typeDef, newType, false, {}, nxprANames);
+
           // if the origin type had items, add items to exposed type
           if(typeDef.kind === 'type') {
             if(typeDef.items) {

package/lib/transform/transformUtils.js

@@ -4,7 +4,6 @@
 // different backends.
 // The sibling of model/transform/TransformUtil.js which works with compacted new CSN.
 
-const { makeMessageFunction } = require('../base/messages');
 const { setProp } = require('../base/model');
 
 const { copyAnnotations, applyTransformations, isDollarSelfOrProjectionOperand } = require('../model/csnUtils');
@@ -20,8 +19,8 @@ const RelationalOperators = ['=', '!=', '<>', 'is' /*, 'like'*/,...RestrictedOpe
 // 'model' is compacted new style CSN
 // TODO: Error and warnings handling with compacted CSN? - currently just throw new ModelError for everything
 // TODO: check the situation with assocs with values. In compacted CSN such elements have only "@Core.Computed": true
-function getTransformers(model, options, pathDelimiter = '_') {
-  const { message, error, warning, info } = makeMessageFunction(model, options);
+function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
+  const { message, error, warning, info } = msgFunctions;
   const csnUtils = getUtils(model);
   const {
     getCsnDef,
@@ -321,48 +320,62 @@ function getTransformers(model, options, pathDelimiter = '_') {
    * @param {object[]} [links] Pre-resolved links for the given ref - if not provided, will be calculated JIT
    * @param {string} [scope] Pre-resolved scope for the given ref - if not provided, will be calculated JIT
    * @param {WeakMap} [resolvedLinkTypes=new WeakMap()] A WeakMap with already resolved types for each link-step - safes an `artifactRef` call
+   * @param {bool} [refParentIsItems] relative ref has an items root (suspend flattening by caller)
    * @returns {string[]}
    */
-  function flattenStructStepsInRef(ref, path, links, scope, resolvedLinkTypes=new WeakMap()) {
+  function flattenStructStepsInRef(ref, path, links, scope, resolvedLinkTypes=new WeakMap(), refParentIsItems=false) {
     // Refs of length 1 cannot contain steps - no need to check
     if (ref.length < 2 || (scope === '$self' && ref.length === 2)) {
       return ref;
     }
 
-    return flatten(ref, path);
+    const result = scope === '$self' ? [ref[0]] : [];
+    //let stack = []; // IDs of path steps not yet processed or part of a struct traversal
+    if(!links && !scope) { // calculate JIT if not supplied
+      const res = inspectRef(path);
+      links = res.links;
+      scope = res.scope;
+    }
+    if (scope === '$magic')
+      return ref;
 
-    function flatten(ref, path) {
-      let result = scope === '$self' ? [ref[0]] : [];
-      //let stack = []; // IDs of path steps not yet processed or part of a struct traversal
-      if(!links && !scope) { // calculate JIT if not supplied
-        const res = inspectRef(path);
-        links = res.links;
-        scope = res.scope;
-      }
-      if (scope === '$magic')
-        return ref;
-      // Don't process a leading $self - it will a .art with .elements!
-      const startIndex = scope === '$self' ? 1 : 0;
-      let flattenStep = false;
-      for(let i = startIndex; i < links.length; i++) {
-        const value = links[i];
-        if (flattenStep) {
-          result[result.length - 1] += pathDelimiter + (ref[i].id ? ref[i].id : ref[i]);
-          // if we had a filter or args, we had an assoc so this step is done
-          // we then keep along the filter/args by updating the id of the current ref
-          if(ref[i].id) {
-            ref[i].id = result[result.length-1];
-            result[result.length-1] = ref[i];
-          }
-        }
-        else {
-          result.push(ref[i]);
+    // Don't process a leading $self - it will a .art with .elements!
+    let i = scope === '$self' ? 1 : 0;
+  
+    // read property from resolved path link
+    const art = (propName) =>
+    (links[i].art?.[propName] ||
+     effectiveType(links[i].art)[propName] ||
+     (resolvedLinkTypes.get(links[i])||{})[propName]);
+  
+    let flattenStep = false;
+    let nextIsItems = !!art('items') || (refParentIsItems && i === 0);
+    for(; i < links.length; i++) {
+
+      if (flattenStep && !nextIsItems) {
+        result[result.length - 1] += pathDelimiter + (ref[i].id ? ref[i].id : ref[i]);
+        // if we had a filter or args, we had an assoc so this step is done
+        // we then keep along the filter/args by updating the id of the current ref
+        if(ref[i].id) {
+          ref[i].id = result[result.length-1];
+          result[result.length-1] = ref[i];
         }
-        flattenStep = value.art && !value.art.kind && !value.art.SELECT && !value.art.from && (value.art.elements || effectiveType(value.art).elements || (resolvedLinkTypes.get(value)||{}).elements);
+        // suspend flattening if the next path step has some 'items'
+        nextIsItems = !!art('items');
       }
-
-      return result;
+      else {
+        result.push(ref[i]);
+      }
+      // revoke items suspension for next assoc step
+      if(nextIsItems && art('target'))
+        nextIsItems = false;
+
+      flattenStep = !links[i].art?.kind && 
+        !links[i].art?.SELECT &&
+        !links[i].art?.from &&
+        art('elements');
     }
+    return result;
   }
 
   /**

package/lib/transform/translateAssocsToJoins.js

@@ -47,8 +47,6 @@ function translateAssocsToJoinsCSN(csn, options){
     deduplicateMessages( options.messages );
   }
 
-  // If A2J reports error - end! Continuing with a broken CSN makes no sense
-  makeMessageFunction(model, options).throwWithAnyError();
   // FIXME: Move this somewhere more appropriate
   const newCsn = compactModel(model, compileOptions);
   //require('fs').writeFileSync('./csnoutput_a2j.json', JSON.stringify(newCsn, null,2))
@@ -57,7 +55,7 @@ function translateAssocsToJoinsCSN(csn, options){
 
 function translateAssocsToJoins(model, inputOptions = {})
 {
-  const { error, warning } = makeMessageFunction(model, inputOptions);
+  const { error, warning, throwWithError } = makeMessageFunction(model, inputOptions);
 
   const options = model.options || inputOptions;
 
@@ -70,6 +68,9 @@ function translateAssocsToJoins(model, inputOptions = {})
   forEachDefinition(model, prepareAssociations);
   forEachDefinition(model, transformQueries);
 
+  // If A2J reports error - end! Continuing with a broken model makes no sense
+  throwWithError();
+
   return model;
 
   function prepareAssociations(art)
@@ -316,7 +317,7 @@ function translateAssocsToJoins(model, inputOptions = {})
       // Paths without _navigation in ORDER BY are select item aliases, they must
       // be rendered verbatim
       let [head, ...tail] = pathNode.path;
-      if((env.location === 'OrderBy' && !head._navigation)|| 
+      if((env.location === 'OrderBy' && !head._navigation)||
          env.location === 'UnionOuterOrderBy' && (!head._navigation || ['$self', '$projection'].includes(head.id)))
         return;
 
@@ -494,7 +495,7 @@ function translateAssocsToJoins(model, inputOptions = {})
     let srcTableAlias = constructTableAliasPathStep(assocSourceQA);
     let tgtTableAlias = constructTableAliasPathStep(assocQAT.$QA);
 
-    node.on = createOnCondition(assoc, srcTableAlias, tgtTableAlias);
+    node.on = createOnCondition(assoc, srcTableAlias, tgtTableAlias, options.tenantAsColumn);
 
     if(assocQAT._filter)
     {
@@ -564,7 +565,7 @@ function translateAssocsToJoins(model, inputOptions = {})
       return xsnCard;
     }
     // produce the ON condition for a given association
-    function createOnCondition(assoc, srcAlias, tgtAlias)
+    function createOnCondition(assoc, srcAlias, tgtAlias, compareTenants)
     {
       let prefixes = [ assoc.name.id ];
       /* This is no art and can be removed once ON cond for published
@@ -599,7 +600,7 @@ function translateAssocsToJoins(model, inputOptions = {})
           Put all src/tgt path siblings into the EQ term and create the proper path objects
           with the src/tgt table alias path steps in front.
         */
-        let args = [];
+        let args = [];          // TODO: tenant comparison?
         for(let i = 0; i < assoc.$flatSrcFKs.length; i++)
         {
           args.push({op: {val: '=' },
@@ -660,7 +661,25 @@ function translateAssocsToJoins(model, inputOptions = {})
         env.assocStack.push(assoc);
         const onCond = cloneOnCondition(assoc.on);
         env.assocStack.pop();
-        return onCond;
+        return compareTenants ? addTenantComparison(assoc, onCond) : onCond;
+      }
+
+      // Add tenant comparison
+      function addTenantComparison(assoc, cond) {
+        // It is enough to test whether the target is tenant-dependent.  If it is,
+        // the current query must also be (check in addTenantFields).  If we allow
+        // assocs from tenant-independent entities to tenant-dependent ones, we
+        // also need to use the current query = `env.lead`.
+        if(annotationVal(assoc.target._artifact['@cds.tenant.independent']))
+          return cond;
+
+        const args = [ constructPathNode([ srcAlias ]), constructPathNode([ tgtAlias ]) ];
+        args[0].path.push({ id: 'tenant' }); // no need for _artifact
+        args[1].path.push({ id: 'tenant' }); // no need for _artifact
+        const comparison = { op: {val: '=' }, args };
+        if (!cond)              // for managed assoc
+          return comparison;
+        return { op: { val: 'and' }, args: [ comparison, parenthesise(cond) ] };
       }
 
       // make foreign key absolute to its main entity
@@ -1047,6 +1066,7 @@ function translateAssocsToJoins(model, inputOptions = {})
     return node;
   }
 
+  // Remark CW: why boolean and not just truthy/falsy as usual?  See annotationVal() below
   function isBooleanAnnotation(prop, val=true) {
     return prop && prop.val !== undefined && prop.val === val && prop.literal === 'boolean';
   }
@@ -1905,4 +1925,9 @@ function walkPath(node, env)
   return path;
 }
 
+function annotationVal( anno ) {
+  // XSN TODO: also set `val:true` but no location for anno short form
+  return anno && (anno.val === undefined || anno.val);
+}
+
 module.exports = { translateAssocsToJoinsCSN };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "4.5.0",
+  "version": "4.6.2",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",
@@ -27,7 +27,7 @@
     "deployGitDiffs": "CDS_COMPILER_DEPLOY_HANA=1 mocha --reporter-option maxDiffSize=0 test3/test.deploy.git-diffs.js",
     "gentest3": "cross-env MAKEREFS=${MAKEREFS:-'true'} mocha --reporter-option maxDiffSize=0 test3/testRefFiles.js",
     "coverage": "cross-env nyc mocha --reporter-option maxDiffSize=0 test/ test3/testRefFiles.js && nyc report --reporter=lcov",
-    "coverage:piper": "cross-env nyc mocha --reporter mocha-junit-reporter --reporter-options mochaFile=./coverage/TEST-results.xml --reporter-option maxDiffSize=0 --timeout 10000 test/ test3/ && nyc report --reporter=cobertura && nyc report --reporter=lcov",
+    "coverage:piper": "cross-env nyc mocha --reporter test/TestMochaReporter.js --reporter-options mochaFile=./coverage/TEST-results.xml --reporter-option maxDiffSize=0 --timeout 10000 test/ test3/ && nyc report --reporter=cobertura && nyc report --reporter=lcov",
     "lint": "eslint bin/ benchmark/ lib/ test/ test3/ scripts/ types/ && node scripts/linter/lintGrammar.js && node scripts/linter/lintTests.js test3/ && node scripts/linter/lintMessages.js && node scripts/linter/lintMessageIdCoverage.js lib/ && markdownlint README.md CHANGELOG.md doc/ internalDoc/ && cd share/messages && markdownlint .",
     "tslint": "tsc --pretty -p .",
     "updateVocs": "node scripts/odataAnnotations/generateDictMain.js && npm run generateAllRefs",