@sap/cds-compiler 4.9.2 → 5.0.6

package/lib/render/toCdl.js

@@ -1379,7 +1379,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 +1435,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 +1813,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 +2455,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/toSql.js

@@ -1645,6 +1645,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.
+                }
+              }
+            }
+          }
+        },
+      };
     }
   }
 }

package/lib/transform/db/constraints.js

@@ -203,28 +203,28 @@ function createReferentialConstraints( csn, options ) {
       // in contrast to foreign keys which stem from managed associations,
       // a tenant foreign key column may have multiple parent keys as partners
       const tenantForeignKey = isTenant && dependentKeyValuePair[0] === 'tenant';
-      if ($foreignKeyConstraint && (!tenantForeignKey || $foreignKeyConstraint.upLinkFor)) {
+      if ($foreignKeyConstraint && (!tenantForeignKey || $foreignKeyConstraint.upLinkFor))
         return;
-      }
-      else if ($foreignKeyConstraint && tenantForeignKey) {
-        parentKeys.pop();
-        $foreignKeyConstraint.sourceAssociation.push(sourceAssociation);
+
+      const parentKeyValuePair = parentKeys.pop();
+      const parentKeyName = parentKeyValuePair[0];
+
+      const constraint = {
+        parentKey: parentKeyName,
+        parentTable,
+        upLinkFor,
+        sourceAssociation,
+        onDelete: upLinkFor ? 'CASCADE' : 'RESTRICT',
+        validated,
+        enforced,
+      };
+      if (tenantForeignKey) {
+        const dontOverwriteUp = dependentKey.$foreignKeyConstraint && dependentKey.$foreignKeyConstraint.some(c => c.sourceAssociation === sourceAssociation && c.parentTable === parentTable);
+        const dontOverwriteTexts = dependentKey.$foreignKeyConstraint && dependentKey.$foreignKeyConstraint.some(c => c.sourceAssociation === 'texts' && c.upLinkFor.texts);
+        if (!dontOverwriteUp && !dontOverwriteTexts)
+          dependentKey.$foreignKeyConstraint = dependentKey.$foreignKeyConstraint ? [ ...dependentKey.$foreignKeyConstraint, constraint ] : [ constraint ];
       }
       else {
-        const parentKeyValuePair = parentKeys.pop();
-        const parentKeyName = parentKeyValuePair[0];
-
-        const constraint = {
-          parentKey: parentKeyName,
-          parentTable,
-          upLinkFor,
-          sourceAssociation: tenantForeignKey
-            ? [ sourceAssociation ]
-            : sourceAssociation,
-          onDelete: upLinkFor ? 'CASCADE' : 'RESTRICT',
-          validated,
-          enforced,
-        };
         dependentKey.$foreignKeyConstraint = constraint;
       }
     }
@@ -509,13 +509,11 @@ function createReferentialConstraints( csn, options ) {
     if (isTenant && artifact.elements?.tenant) {
       const element = artifact.elements.tenant;
       if (element.$foreignKeyConstraint) {
-        const $foreignKeyConstraint = Object.assign({}, element.$foreignKeyConstraint);
+        const tenantConstraints = element.$foreignKeyConstraint;
         delete element.$foreignKeyConstraint;
-        // create a foreign key constraint for the tenant column with each association in the dependent entity
-        $foreignKeyConstraint.sourceAssociation.forEach((sourceAssociation) => {
-          const copy = Object.assign({}, $foreignKeyConstraint);
-          copy.sourceAssociation = sourceAssociation;
-          createReferentialConstraints(copy, 'tenant');
+        // create (multiple) foreign key constraint(s) for the tenant column with each association in the dependent entity
+        tenantConstraints.forEach((c) => {
+          createReferentialConstraints(c, 'tenant');
         });
       }
     }

package/lib/transform/db/expansion.js

@@ -47,7 +47,7 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
         const isComplexQuery = parent.from.join !== undefined;
         if (!options.toOdata)
           parent.columns = replaceStar(root, columns, parent.excluding, isComplexQuery);
-        // FIXME(v5): Remove argument "isComplexOrNestedQuery"; we use path.length > 4 to check
+        // FIXME(v6): Remove argument "isComplexOrNestedQuery"; we use path.length > 4 to check
         // if we're inside the outermost "columns". If so, always prepend a table alias. See #11662
         parent.columns = expand(parent.columns, path.concat('columns'), true, isComplexQuery || path.length > 4);
       }
@@ -622,11 +622,6 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
     return _expandStructCol(art, columnAlias(root), root.ref, ( currentRef, currentAlias) => {
       const obj = { ...root, ref: currentRef };
       if (withAlias) {
-        // TODO: Remove this line in case foreign key annotations should
-        //       be addressed via full path into target instead of using alias
-        //       names. See flattening.js::flattenAllStructStepsInRefs()
-        //       apply transformations on `ref` counterpart comment.
-        setProp(obj, '$structRef', currentAlias);
         obj.as = currentAlias.join(pathDelimiter);
         // alias was implicit - to later distinguish expanded s -> s.a from explicitly written s.a
         if (root.as === undefined)