@sap/cds-compiler 4.9.6 → 5.1.0

package/lib/optionProcessor.js

@@ -1,3 +1,11 @@
+// Compiler options
+
+// Remarks:
+// - The specification is client-tool centric (bin/cdsc.js):
+//   an option named `fooBar` is “produced” by `.option('  --foo-bar')`.
+// - Also list the option in the `help` text, used with `cdsc -h`.
+// - Specify valid values for non-boolean options in lib/api/validate.js.
+
 'use strict';
 
 const { createOptionProcessor } = require('./base/optionProcessorHelper');
@@ -15,6 +23,7 @@ optionProcessor
   .option('    --options <file>')
   .option('-w, --warning <level>', { valid: ['0', '1', '2', '3'] })
   .option('    --quiet')
+  .option('-i, --stdin')
   .option('    --show-message-id')
   .option('    --no-message-id')
   .option('    --no-message-context')
@@ -34,7 +43,7 @@ optionProcessor
   .option('    --beta <list>')
   .option('    --deprecated <list>')
   .option('    --direct-backend')
-  .option('    --fallback-parser <type>', { valid: ['cdl', 'csn', 'csn!'] })
+  .option('    --fallback-parser <type>', { valid: [ 'auto!', 'cdl', 'csn', 'csn!' ] })
   .option('    --shuffle <seed>') // 0 | 1..4294967296
   .option('    --test-mode')
   .option('    --test-sort-csn')
@@ -81,6 +90,7 @@ optionProcessor
        --cds-home <dir>     When set, modules starting with '@sap/cds/' are searched in <dir>
        --module-lookup-directories <list>  Comma separated list of directories to look
                             for CDS modules. Default is 'node_modules/'.
+   -i, --stdin              Read input from stdin.
        --                   Indicate the end of options (helpful if source names start with "-")
 
   Type options
@@ -117,9 +127,10 @@ optionProcessor
                               eagerPersistenceForGeneratedEntities
        --fallback-parser <type>  If the language cannot be deduced by the file's extensions, use this
                                  parser as a fallback. Valid values are:
-                                   cdl  : Use CDL parser
-                                   csn  : Use CSN parser
-                                   csn! : Use CSN parser even with extension cds, cdl, hdbcds and hdbdd
+                                   cdl   : Use CDL parser
+                                   csn   : Use CSN parser
+                                   csn!  : Use CSN parser even with extension cds, cdl, hdbcds and hdbdd
+                                   auto! : Ignore file extension; use CSN parser if file content starts with '{'
        --direct-backend     Do not compile the given CSN but directly pass it to the backend.
                             Can only be used with certain new CSN based backends. Combination with
                             other flags is limited, e.g. --test-mode will not run a consistency check.
@@ -161,6 +172,8 @@ optionProcessor
   Environment variables
     NO_COLOR                If set, compiler messages (/output) will not be colored.
                             Can be overwritten by '--color'
+    FORCE_COLOR             If set, compiler messages (/output) will be colored. Overrides NO_COLOR.
+                            Can be overwritten by '--color'
     CDSC_TRACE_TIME         If set, additional timing information is printed to stderr.
     CDSC_TRACE_API          If set, additional API calling information is printed to stderr.
 `);
@@ -318,9 +331,9 @@ optionProcessor.command('Q, toSql')
   .option('    --pre2134ReferentialConstraintNames')
   .option('    --disable-hana-comments')
   .option('    --generated-by-comment')
-  .option('    --better-sqlite-session-variables')
+  .option('    --better-sqlite-session-variables <bool>')
   .option('    --fewer-localized-views')
-  .option('    --without-hana-associations')
+  .option('    --with-hana-associations <bool>', { valid: [ 'true', 'false' ] })
   .help(`
   Usage: cdsc toSql [options] <files...>
 
@@ -372,11 +385,17 @@ optionProcessor.command('Q, toSql')
    --pre2134ReferentialConstraintNames   Do not prefix the constraint identifier with "c__"
    --disable-hana-comments    Disable rendering of doc comments as SAP HANA comments.
    --generated-by-comment     Enable rendering of the initial SQL comment for HDI-based artifacts
-   --better-sqlite-session-variables    Enable better-sqlite compatible rendering of $user. Only
-                              active if sqlDialect is \`sqlite\`
+   --better-sqlite-session-variables <bool>
+                              Enable better-sqlite compatible rendering of $user. Only
+                              active if sqlDialect is \`sqlite\`:
+                                true  : (default) Render better-sqlite session_context(…)
+                                false : Render session variables as string literals, used e.g. with sqlite3 driver
    --fewer-localized-views    If set, the backends will not create localized convenience views for
                               those views, that only have an association to a localized entity/view.
-   --without-hana-associations   If set, the backend will not render a "WITH ASSOCIATIONS" for sqlDialect 'hana'
+   --with-hana-associations <bool>
+                              Enable and disable rendering of "WITH ASSOCIATIONS" for sqlDialect 'hana'.
+                                true  : (default) Render "WITH ASSOCIATIONS"
+                                false : Do not render "WITH ASSOCIATIONS"
 `);
 
 optionProcessor.command('toRename')
@@ -482,6 +501,7 @@ optionProcessor.command('toCsn')
 optionProcessor.command('parseCdl')
   .option('-h, --help')
   .positionalArgument('<file>')
+  .option('    --with-locations')
   .help(`
   Usage: cdsc parseCdl [options] <file>
 
@@ -489,6 +509,7 @@ optionProcessor.command('parseCdl')
   resolve imports, apply extensions or expand any queries.
 
   Options
+       --with-locations   Add $location to CSN artifacts.
    -h, --help             Show this help text
 `);
 

package/lib/render/manageConstraints.js

@@ -58,7 +58,7 @@ function alterConstraintsWithCsn( csn, options, messageFunctions ) {
 // TODO: Remove / Move to api/options.js once alterConstraintsWithCsn is available outside bin/cdsc
 function _transformSqlOptions( csn, options ) {
   const { src } = options;
-  // eslint-disable-next-line global-require
+
   const prepareOptions = require('../api/options');
   options = prepareOptions.to.sql(options);
   options.src = src;

package/lib/render/toCdl.js

@@ -13,11 +13,11 @@ const { typeParameters, specialFunctions } = require('../compiler/builtins');
 const { isAnnotationExpression } = require('../base/builtins');
 const { forEach } = require('../utils/objectUtils');
 const {
-  generatedByCompilerVersion,
   getNormalizedQuery,
 } = require('../model/csnUtils');
 const { isBuiltinType } = require('../base/builtins');
 const { cloneFullCsn } = require('../model/cloneCsn');
+const { getKeysDict } = require('../model/csnRefs');
 
 const identifierRegex = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/;
 const specialFunctionKeywords = Object.create(null);
@@ -62,7 +62,7 @@ function csnToCdl( csn, options, msg ) {
   const hanaRequiresAbsolutePath = usings.available.includes('hana');
 
   const cdlResult = Object.create(null);
-  cdlResult.model = options.testMode ? '' : `// ${generatedByCompilerVersion()} \n`;
+  cdlResult.model = '';
 
   const subelementAnnotates = [];
 
@@ -676,7 +676,7 @@ function csnToCdl( csn, options, msg ) {
       artifact = artifact.items;
     }
 
-    if (!artifact.elements && !artifact.enum)
+    if (!artifact.elements && !artifact.enum && !artifact.keys)
       return null;
 
     const annotate = { annotate: env.path[1] };
@@ -712,15 +712,16 @@ function csnToCdl( csn, options, msg ) {
      */
     function collectAnnos( annotateObj, art ) {
       if (!Object.hasOwnProperty.call(art, 'elements') &&
-          !Object.hasOwnProperty.call(art, 'enum'))
+        !Object.hasOwnProperty.call(art, 'enum') &&
+        !Object.hasOwnProperty.call(art, 'keys'))
         return false;
 
-      const dictKey = art.elements ? 'elements' : 'enum';
-      // Use "elements" for both enums and elements. This is allowed in extensions.
+      const dict = art.enum || art.keys && getKeysDict(art) || art.elements;
+      // Use "elements" for all. This is allowed in extensions.
       const collected = { elements: Object.create(null) };
       let hasAnnotation = false;
 
-      forEach(art[dictKey], (elemName, element) => {
+      forEach(dict, (elemName, element) => {
         if (!collected.elements[elemName])
           collected.elements[elemName] = { };
 
@@ -1379,7 +1380,7 @@ function csnToCdl( csn, options, msg ) {
 
       // Foreign keys (if any, unless we also have an ON_condition (which means we have been transformed from managed to unmanaged)
       if (artifact.keys && !artifact.on)
-        result += ` { ${Object.keys(artifact.keys).map(name => renderForeignKey(artifact.keys[name], env.withSubPath([ 'keys', name ]))).join(', ')} }`;
+        result += ` ${ renderForeignKeys(artifact, env) }`;
 
       if (artifact.notNull !== undefined && !artifact.on) // unmanaged associations can't be followed by "not null"
         result += renderNullability(artifact);
@@ -1435,7 +1436,7 @@ function csnToCdl( csn, options, msg ) {
     if (art.on)
       result += ` on ${exprRenderer.renderExpr(art.on, env.withSubPath([ 'on' ]))}`;
     else if (art.keys)
-      result += ` { ${Object.keys(art.keys).map(name => renderForeignKey(art.keys[name], env.withSubPath([ 'keys', name ]))).join(', ')} }`;
+      result += ` ${ renderForeignKeys(art, env) }`;
     return result;
   }
 
@@ -1813,15 +1814,43 @@ function csnToCdl( csn, options, msg ) {
   }
 
   /**
-   * Render a foreign key (no trailing LF)
+   * Render foreign keys.
    *
-   * @param {object} fKey
+   * @param {object} art
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderForeignKey( fKey, env ) {
-    const alias = fKey.as ? renderAlias(fKey.as, env) : '';
-    return exprRenderer.renderExpr(fKey, env) + alias;
+  function renderForeignKeys( art, env ) {
+    const renderedKeys = [];
+    let hasAnnotations = false;
+    env = env.withSubPath([ 'keys', -1 ]);
+    env.increaseIndent();
+
+    for (let i = 0; i < art.keys.length; ++i) {
+      env.path[env.path.length - 1] = i;
+      const fKey = art.keys[i];
+
+      const annos = renderAnnotationAssignmentsAndDocComment(fKey, env).trim();
+      if (annos) {
+        hasAnnotations = true;
+        renderedKeys.push(annos);
+      }
+
+      const alias = fKey.as ? renderAlias(fKey.as, env) : '';
+      const key = exprRenderer.renderExpr(fKey, env);
+      renderedKeys.push(`${key}${alias},`);
+    }
+
+    if (hasAnnotations) {
+      const sep = `\n${env.indent}`;
+      env.decreaseIndent();
+      return `{${sep}${renderedKeys.join(sep)}\n${env.indent}}`;
+    }
+
+    let result = renderedKeys.join(' ');
+    if (result[result.length - 1] === ',') // remove trailing comma
+      result = result.slice(0, -1);
+    return `{ ${ result } }`;
   }
 
   /**
@@ -2427,6 +2456,7 @@ function isSimpleString( str ) {
   // <https://www.ecma-international.org/wp-content/uploads/ECMA-404_2nd_edition_december_2017.pdf>
   // On top, because (invalid) surrogate pairs need to be handled, we check for them as well.
   // v3: Not a simple string if ' (\u0027) is in string.
+  // eslint-disable-next-line no-control-regex
   return str === '' || (/^[^\u{0000}-\u{001F}\u2028\u2029]+$/u.test(str) &&
     !hasUnpairedUnicodeSurrogate(str));
 }

package/lib/render/toHdbcds.js

@@ -2,7 +2,7 @@
 
 const {
   getLastPartOf, getLastPartOfRef,
-  hasValidSkipOrExists, generatedByCompilerVersion, getNormalizedQuery,
+  hasValidSkipOrExists, getNormalizedQuery,
   getRootArtifactName, getResultingName, getNamespace, forEachMember, getVariableReplacement, hasAnnotationValue,
   pathName,
 } = require('../model/csnUtils');
@@ -167,7 +167,6 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
     if (sourceStr !== '') {
       const name = plainNames ? artifactName.replace(/\./g, '_').toUpperCase() : artifactName;
       hdbcds[name] = [
-        !options.testMode ? `// ${generatedByCompilerVersion()} \n` : '',
         renderNamespaceDeclaration(name, env),
         renderUsings(name, env),
         sourceStr,

package/lib/render/toSql.js

@@ -3,7 +3,7 @@
 
 const {
   getLastPartOf, getLastPartOfRef,
-  hasValidSkipOrExists, generatedByCompilerVersion, getNormalizedQuery,
+  hasValidSkipOrExists, getNormalizedQuery,
   forEachDefinition, getResultingName,
   getVariableReplacement, pathName,
 } = require('../model/csnUtils');
@@ -186,8 +186,11 @@ function toSqlDdl( csn, options, messageFunctions ) {
     deletions: Object.create(null),
     constraintDeletions: [],
     migrations: Object.create(null),
+    hdbrole: Object.create(null),
   };
 
+  const sqlServiceEntities = Object.create(null);
+
   // Registries for artifact and element names per CSN section
   const definitionsDuplicateChecker = new DuplicateChecker(options.sqlMapping);
   const deletionsDuplicateChecker = new DuplicateChecker();
@@ -252,6 +255,25 @@ function toSqlDdl( csn, options, messageFunctions ) {
     });
   }
 
+  // Can only happen for HDI based deployment
+  // .hdbrole documentation: https://help.sap.com/docs/SAP_HANA_PLATFORM/3823b0f33420468ba5f1cf7f59bd6bd9/625d7733c30b4666b4a522d7fa68a550.html
+  Object.keys(sqlServiceEntities).forEach((sqlServiceName) => {
+    const accessRole = {
+      role: {
+        name: renderArtifactNameWithoutQuotes(`${sqlServiceName }.access`),
+        object_privileges: Object.entries(sqlServiceEntities[sqlServiceName]).map(([ name, entity ]) => ({
+          name: renderArtifactNameWithoutQuotes(name),
+          type: entity.query || entity.projection ? 'VIEW' : 'TABLE',
+          privileges: [ 'SELECT' ],
+          privileges_with_grant_option: [],
+        })),
+      },
+    };
+
+    if (accessRole.role.object_privileges.length > 0)
+      mainResultObj.hdbrole[`${sqlServiceName }_access`] = JSON.stringify(accessRole, null, 2);
+  });
+
   // trigger artifact and element name checks
   definitionsDuplicateChecker.check(error, options);
   extensionsDuplicateChecker.check(error);
@@ -264,7 +286,6 @@ function toSqlDdl( csn, options, messageFunctions ) {
   // (relying on the order of dictionaries above)
   // FIXME: Should consider inter-view dependencies, too
   const sql = Object.create(null);
-  const sqlVersionLine = `-- ${generatedByCompilerVersion()}\n`;
 
   // Handle hdbKinds separately from alterTable case
   const {
@@ -278,10 +299,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
         // Hack: Other than in 'hdbtable' files, in HANA SQL COLUMN is not mandatory but default.
         if (options.sqlDialect === 'hana' && hdbKind === 'hdbtable' && sourceString.startsWith('COLUMN '))
           sourceString = sourceString.slice('COLUMN '.length);
-        sql[name] = `${options.testMode ? '' : sqlVersionLine}CREATE ${sourceString};`;
-      }
-      else if (!options.testMode && options.generatedByComment) {
-        mainResultObj[hdbKind][name] = sqlVersionLine + mainResultObj[hdbKind][name];
+        sql[name] = `CREATE ${sourceString};`;
       }
     }
     if (options.src === 'sql')
@@ -295,7 +313,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
 
     forEachKey(alterStmts, (constraintName) => {
       if (!csn.unchangedConstraints?.has(constraintName))
-        constraints[constraintName] = `${options.testMode ? '' : sqlVersionLine}${alterStmts[constraintName]}`;
+        constraints[constraintName] = `${alterStmts[constraintName]}`;
     });
     mainResultObj.constraints = constraints;
   }
@@ -304,7 +322,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
     mainResultObj.sql = sql;
 
   for (const name in deletions)
-    deletions[name] = `${options.testMode || !options.generatedByComment ? '' : sqlVersionLine}${deletions[name]}`;
+    deletions[name] = `${deletions[name]}`;
 
   timetrace.stop('SQL rendering');
   return mainResultObj;
@@ -325,6 +343,10 @@ function toSqlDdl( csn, options, messageFunctions ) {
 
     switch (art.kind) {
       case 'entity':
+        if (art.$sqlService) { // collect entities that are in a sql service so we can render the .hdbrole later
+          sqlServiceEntities[art.$sqlService] ??= Object.create(null);
+          sqlServiceEntities[art.$sqlService][artifactName] = art;
+        }
         if (art.query || art.projection) {
           const result = renderView(artifactName, art, env);
           if (result)
@@ -350,6 +372,20 @@ function toSqlDdl( csn, options, messageFunctions ) {
     }
   }
 
+  /**
+   * Render the given artifactName according to the sqlMapping, but
+   * - uppercased for plain
+   * - without enclosing " for quoted/hdbcds
+   *
+   * @param {string} artifactName
+   * @returns {string}
+   */
+  function renderArtifactNameWithoutQuotes( artifactName ) {
+    if (options.sqlMapping === 'plain')
+      return renderArtifactName(artifactName).toUpperCase();
+    return renderArtifactName(artifactName).slice(1, -1); // trim leading/trailing "
+  }
+
   /**
    * Render an artifact extension into the appropriate dictionary of 'resultObj'.
    * Only SAP HANA SQL is currently supported.
@@ -1645,6 +1681,7 @@ function renderStringForSql( str, sqlDialect ) {
     //  > Single quotation marks are used to delimit string literals.
     //  > A single quotation mark itself can be represented using two single quotation marks.
     str = str.replace(/'/g, '\'\'')
+      // eslint-disable-next-line no-control-regex
       .replace(/\u{0}/ug, '\' || CHAR(0) || \'');
   }
   else {

package/lib/render/utils/common.js

@@ -372,7 +372,7 @@ const variablesToSql = {
     '$valid.to': "current_setting('cap.valid_to')::timestamp",
     $now: 'current_timestamp',
   },
-  'better-sqlite': {
+  sqlite: {
     '$user.id': "session_context( '$user.id' )",
     '$user.locale': "session_context( '$user.locale' )",
     $tenant: "session_context( '$tenant' )",
@@ -382,7 +382,7 @@ const variablesToSql = {
     '$valid.to': "session_context( '$valid.to' )",
     $now: 'CURRENT_TIMESTAMP',
   },
-  sqlite: {
+  'old-sqlite': {
     // For sqlite, we render the string-format-time (strftime) function.
     // Because the format of `current_timestamp` is like that: '2021-05-14 09:17:19' whereas
     // the format for timestamps (at least in Node.js) is like that: '2021-01-01T00:00:00.000Z'
@@ -394,11 +394,14 @@ const variablesToSql = {
     '$valid.to': "strftime('%Y-%m-%dT%H:%M:%S.001Z', 'now')",
     $now: 'CURRENT_TIMESTAMP',
   },
-  plain: {
-    '$at.from': 'current_timestamp',
-    '$at.to': 'current_timestamp',
-    '$valid.from': 'current_timestamp',
-    '$valid.to': 'current_timestamp',
+  plain: { // better-sqlite defaults
+    '$user.id': "session_context( '$user.id' )",
+    '$user.locale': "session_context( '$user.locale' )",
+    $tenant: "session_context( '$tenant' )",
+    '$at.from': "session_context( '$valid.from' )",
+    '$at.to': "session_context( '$valid.to' )",
+    '$valid.from': "session_context( '$valid.from' )",
+    '$valid.to': "session_context( '$valid.to' )",
     $now: 'CURRENT_TIMESTAMP',
   },
   h2: {
@@ -423,8 +426,8 @@ const variablesToSql = {
  * @return {string|null} `null` if the variable could not be found for the given dialect and in the fallback values.
  */
 function variableForDialect( options, variable ) {
-  const dialect = options.sqlDialect === 'sqlite' && options.betterSqliteSessionVariables
-    ? 'better-sqlite'
+  const dialect = options.sqlDialect === 'sqlite' && options.betterSqliteSessionVariables === false
+    ? 'old-sqlite'
     : options.sqlDialect;
   return variablesToSql[dialect]?.[variable] || variablesToSql.fallback[variable] || null;
 }

package/lib/render/utils/stringEscapes.js

@@ -1,5 +1,6 @@
 'use strict';
 
+// eslint-disable-next-line no-control-regex
 const controlCharacters = /[\u{0000}-\u{001F}]/u;
 const highSurrogate = /[\u{D800}-\u{DBFF}]/u;
 const lowSurrogate = /[\u{DC00}-\u{DFFF}]/u;

package/lib/transform/db/applyTransformations.js

@@ -45,6 +45,7 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
   };
 
   const csnPath = [ ...path ];
+  const context = {};
   if (prop === 'definitions') {
     definitions( parent, 'definitions', parent.definitions );
   }
@@ -84,9 +85,9 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
       for (const name of Object.getOwnPropertyNames( node )) {
         const trans = transformers[name] || transformers[name.charAt(0)] || standard;
         if (customTransformers[name])
-          customTransformers[name](node, name, node[name], csnPath, _parent, _prop);
+          customTransformers[name](node, name, node[name], csnPath, _parent, _prop, context);
         else if (options.processAnnotations && customTransformers['@'] && name.charAt(0) === '@')
-          customTransformers['@'](node, name, node[name], csnPath, _parent, _prop);
+          customTransformers['@'](node, name, node[name], csnPath, _parent, _prop, context);
         trans( node, name, node[name], csnPath );
       }
     }
@@ -110,9 +111,9 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
     for (const name of Object.getOwnPropertyNames( node )) {
       const trans = transformers[name] || transformers[name.charAt(0)] || standard;
       if (customTransformers[name])
-        customTransformers[name](node, name, node[name], csnPath, dict);
+        customTransformers[name](node, name, node[name], csnPath, dict, null, context);
       else if (options.processAnnotations && customTransformers['@'] && name.charAt(0) === '@')
-        customTransformers['@'](node, name, node[name], csnPath, dict);
+        customTransformers['@'](node, name, node[name], csnPath, dict, null, context);
       trans( node, name, node[name], csnPath );
     }
     csnPath.pop();
@@ -130,12 +131,14 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
     if (options.skipDict?.[_prop] || dict == null) // with universal CSN, dictionaries might be null
       return;
     csnPath.push( _prop );
+    context[`$in_${_prop}`] = true;
     for (const name of Object.getOwnPropertyNames( dict ))
       dictEntry( dict, name, dict[name] );
 
     if (!Object.prototype.propertyIsEnumerable.call( node, _prop ))
       setProp(node, `$${_prop}`, dict);
     csnPath.pop();
+    context[`$in_${_prop}`] = undefined;
   }
 
   /**
@@ -148,6 +151,7 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
    */
   function annotation( _parent, _prop, node ) {
     if (options.processAnnotations) {
+      context.$annotation = { name: _prop, value: node };
       if (isAnnotationExpression(node)) {
         standard(_parent, _prop, node);
       }
@@ -164,6 +168,7 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
 
         csnPath.pop();
       }
+      context.$annotation = undefined;
     }
   }
 
@@ -359,18 +364,18 @@ function mergeTransformers( transformers, that ) {
         remapped[n] = [];
 
       if (Array.isArray(fns)) {
-        remapped[n].push((parent, name, prop, path, parentParent) => fns.forEach(
-          fn => fn.bind(that)(parent, name, prop, path, parentParent)
+        remapped[n].push((parent, name, prop, path, parentParent, opt, context) => fns.forEach(
+          fn => fn.bind(that)(parent, name, prop, path, parentParent, opt, context)
         ));
       }
       else {
-        remapped[n].push((parent, name, prop, path, parentParent) => fns.bind(that)(parent, name, prop, path, parentParent));
+        remapped[n].push((parent, name, prop, path, parentParent, opt, context) => fns.bind(that)(parent, name, prop, path, parentParent, opt, context));
       }
     }
   }
 
   for (const [ n, fns ] of Object.entries(remapped))
-    remapped[n] = (parent, name, prop, path, parentParent) => fns.forEach(fn => fn.bind(that)(parent, name, prop, path, parentParent));
+    remapped[n] = (parent, name, prop, path, parentParent, opt, context) => fns.forEach(fn => fn.bind(that)(parent, name, prop, path, parentParent, opt, context));
 
 
   return remapped;

package/lib/transform/db/associations.js

@@ -132,44 +132,8 @@ function getFKAccessFinalizer( csn, csnUtils, pathDelimiter, processOnInQueries
    * @param {string} artifactName Name of the artifact
    */
   function handleManagedAssocSteps( artifact, artifactName ) {
-    const transformer = {
-      ref: (refOwner, prop, ref, path) => {
-        // [<assoc base>.]<managed assoc>.<field>
-        if (ref.length > 1) {
-          const { links } = inspectRef(path);
-          if (links) {
-            let fkAlias = '';
-            // eslint-disable-next-line for-direction
-            for (let i = links.length - 1; i >= 0; i--) {
-              const link = links[i];
-              // We found the latest managed assoc path step
-              if (link.art && link.art.target && link.art.keys &&
-                    // Doesn't work when ref-target (filter condition) or similar is used
-                    !ref.slice(i).some(refElement => typeof refElement !== 'string')) {
-                const fkRef = ref[i + 1];
-                const fkName = (!fkAlias ? fkRef : `${fkRef}${pathDelimiter}${fkAlias}`);
-                const fks = link.art.keys.filter(key => key.ref[0] === fkName);
-
-                if (fks.length >= 1) { // after flattening, at most one FK will remain.
-                  // `.as` is set for SQL, but not for OData -> fall back to implicit alias
-                  fkAlias = fks[0].as || fks[0].ref[fks[0].ref.length - 1];
-                  const source = findSource(links, i - 1) || artifact;
-                  const managedAssocStepName = ref[i];
-                  const newFkName = `${managedAssocStepName}${pathDelimiter}${fkAlias}`;
-                  if (source?.elements[newFkName])
-                    refOwner.ref = [ ...ref.slice(0, i), newFkName ];
-                }
-              }
-              else {
-                fkAlias = '';
-                // Ignore last path step and unmanaged associations.
-                // Structures should have been already flattened.
-              }
-            }
-          }
-        }
-      },
-    };
+    const transformer = getTransformer();
+    const inColumnsTransformer = getTransformer(true);
     for (const elemName in artifact.elements) {
       const elem = artifact.elements[elemName];
       // The association is an unmanaged one
@@ -187,28 +151,72 @@ function getFKAccessFinalizer( csn, csnUtils, pathDelimiter, processOnInQueries
         where: transform,
         having: transform,
       };
-      if (processOnInQueries)
+      if (processOnInQueries) {
+        queryTransformers.columns = (parent, prop, columns, path) => {
+          for (let i = 0; i < columns.length; i++) {
+            const column = columns[i];
+            if (column.ref) {
+              inColumnsTransformer.ref(column, 'ref', column.ref, path.concat([ 'columns', i ]));
+              column.ref.forEach((step, index) => {
+                if (step.where)
+                  transform(step, 'where', step.where, path.concat([ 'columns', i, 'ref', index ]));
+              });
+            }
+          }
+        };
         queryTransformers.on = transform;
-      applyTransformationsOnNonDictionary(artifact, artifact.query ? 'query' : 'projection', queryTransformers, {}, [ 'definitions', artifactName ]);
+      }
+      applyTransformationsOnNonDictionary(artifact, artifact.query ? 'query' : 'projection', queryTransformers, { drillRef: true }, [ 'definitions', artifactName ]);
     }
 
-
     /**
-     * Find out where the managed association is
      *
-     * @param {Array} links
-     * @param {number} startIndex
-     * @returns {object | undefined} CSN definition of the source of the managed association
+     * @param {boolean} isColumns Whether the transformation is taking place on a column
+     * @returns {object}
      */
-    function findSource( links, startIndex ) {
-      for (let i = startIndex; i >= 0; i--) {
-        const link = links[i];
-        // We found the latest assoc step - now check where that points to
-        if (link.art && link.art.target)
-          return csn.definitions[link.art.target];
-      }
-
-      return undefined;
+    function getTransformer( isColumns = false ) {
+      return {
+        ref: (refOwner, prop, ref, path) => {
+          // [<assoc base>.]<managed assoc>.<field>
+          if (ref.length > 1) {
+            const { links } = inspectRef(path);
+            if (links) {
+              let fkAlias = '';
+              for (let i = links.length - 1; i >= 0; i--) {
+                const link = links[i];
+                // We found the latest managed assoc path step
+                if (link.art && link.art.target && link.art.keys &&
+                      // Doesn't work when ref-target (filter condition) or similar is used
+                      !ref.slice(i).some(refElement => typeof refElement !== 'string')) {
+                  const fkRef = ref[i + 1];
+                  const fkName = (!fkAlias ? fkRef : `${fkRef}${pathDelimiter}${fkAlias}`);
+                  const fks = link.art.keys.filter(key => key.ref[0] === fkName);
+
+                  if (fks.length >= 1) { // after flattening, at most one FK will remain.
+                    // `.as` is set for SQL, but not for OData -> fall back to implicit alias
+                    fkAlias = fks[0].as || fks[0].ref[fks[0].ref.length - 1];
+                    const managedAssocStepName = ref[i];
+                    const newFkName = `${managedAssocStepName}${pathDelimiter}${fkAlias}`;
+                    if (isColumns) {
+                      refOwner.ref = [ ...ref.slice(0, i), newFkName ];
+                      if (!refOwner.as)
+                        refOwner.as = implicitAs(ref);
+                    }
+                    else {
+                      refOwner.ref = [ ...ref.slice(0, i), newFkName ];
+                    }
+                  }
+                }
+                else {
+                  fkAlias = '';
+                  // Ignore last path step and unmanaged associations.
+                  // Structures should have been already flattened.
+                }
+              }
+            }
+          }
+        },
+      };
     }
   }
 }