@sap/cds-compiler 4.4.4 → 4.6.0

package/lib/transform/addTenantFields.js

@@ -0,0 +1,228 @@
+// Add tenant field MANDT to entities
+
+// Prerequisites:
+
+// - the input CSN is a `client` style CSN from the Core Compiler
+// - using structure types with unmanaged associations is not supported by the
+//   Core Compiler (due to missing ON-rewrite)
+
+// TODO entities without MANDT:
+
+// - cache whether structure type contains (managed) association to entity with MANDT
+// - disallow use of such a type in entity without MANDT
+
+// Implementation remark:
+
+// - the functions `forEachDefinition` & friends in csnUtils.js have become quite
+//   (too) general and are probably slow → not used here
+
+'use strict';
+
+const { createMessageFunctions } = require( '../base/messages' );
+const { traverseQuery } = require( '../model/csnRefs' );
+
+const fieldName = 'tenant';
+const fieldDef = {
+  key: true,
+  type: 'cds.String',
+  length: 36,
+  '@cds.api.ignore': true, // and/or $generated: 'tenant' for the full Universal CSN?
+};
+
+function addTenantFields( csn, options ) {
+  const { definitions } = csn;
+  if (!definitions)
+    return csn;
+  const { error, throwWithError } = createMessageFunctions( options, 'tenant', csn );
+
+  const csnPath = [ 'definitions', '' ];
+  let projection;
+
+  for (const name in definitions) {
+    const art = definitions[name];
+    if (art?.kind !== 'entity')
+      continue;
+    csnPath[1] = name;
+
+    if (art['@cds.tenant.independent'] != null) {
+      error( null, csnPath, { anno: '@cds.tenant.independent' },
+             'Can\'t yet add annotation $(ANNO) to an entity' );
+    }
+    if (!handleElements( art ))
+      continue;
+    projection = art.query || art.projection && art;
+    if (projection)
+      traverseQuery( projection, null, null, handleQuery );
+  }
+
+  (csn.extensions || []).forEach( (ext, idx) => {
+    const tenant = ext.elements?.[fieldName];
+    const name = ext.annotate || ext.extend; // extend should not happen
+    if (tenant && definitions[name]?.kind === 'entity') { // TODO: ok for tenant-independent
+      error( null, [ 'extensions', idx, 'elements', 'tenant' ],
+             { name: fieldName },
+             'Can\'t annotate element $(NAME) of a tenant-dependent entity' );
+    }
+  } );
+
+  throwWithError();
+  return csn;                   // input CSN changed by side effect
+
+  function handleElements( art ) {
+    const { elements } = art;
+    if (elements[fieldName]) {
+      error( null, [ ...csnPath, 'elements', fieldName ], { name: fieldName },
+             'Can\'t add tenant field to entity having an element $(NAME)' );
+      return false;
+    }
+    if (!Object.values( elements ).some( e => e.key )) {
+      error( null, csnPath, {},
+             'There must be a key in a tenant-dependent entity' );
+      return false;
+    }
+    handleAssociations( art );
+    art.elements = { [fieldName]: { ...fieldDef }, ...elements };
+    return true;
+  }
+
+  function handleQuery( query ) {
+    // TODO: errors are temporary: start with simple projections only = no better
+    // message $location necessary yet
+    if (!projection)            // error already reported
+      return;
+    if (query.ref) {
+      if ((query.as || implicitAs( query.ref )) === fieldName) {
+        error( null, csnPath, { name: fieldName },
+               'Can\'t have a table alias named $(NAME) in a tenant-dependent entity' );
+      }
+      return;
+    }
+
+    const select = query.SELECT || query.projection;
+    if (query.SET || query !== projection || !select?.from?.ref) {
+      error( null, csnPath, {},
+             'Can\'t add tenant columns to non-simple query entities' );
+      projection = null;
+      return;
+    }
+
+    if (query.projection)
+      csnPath.push( 'projection' );
+    else
+      csnPath.push( 'query', 'SELECT' );
+
+    if (select.mixin)
+      handleMixins( select.mixin );
+    if (select.excluding)
+      checkExcluding( select.excluding );
+    if (select.columns)
+      handleColumns( select.columns );
+    // TODO: for subqueries, we might need to adapt the inferred elements
+    // TODO: where exists ref -
+    // TODO: select and query clauses, especially with aggregation functions
+    handleGroupBy( select );
+    csnPath.length = 2;
+  }
+
+  function handleMixins( mixin ) {
+    csnPath.push( 'mixin', '' );
+    for (const name in mixin) {
+      csnPath[csnPath.length - 1] = name;
+      if (name !== fieldName) {
+        addToCondition( mixin[name], name );
+      }
+      else {
+        error( null, csnPath, { name },
+               'Can\'t define a mixin named $(NAME) in a tenant-dependent entity' );
+      }
+    }
+    csnPath.length -= 2;
+  }
+
+  function checkExcluding( excludeList ) {
+    if (excludeList.includes( fieldName )) {
+      error( null, csnPath, { name: fieldName },
+             'Can\'t exclude $(NAME) from query source' );
+    }
+  }
+
+  function handleGroupBy( select ) {
+    // TODO: in the future, we allow model-wise keyless views when using
+    // aggregation function, and add a GROUP BY for MANDT in this case.  Now, also
+    // views with agg functions need to have a key element → it very likely
+    // already contains a GROUP BY. And anyway: if we miss to add GROUP BY MANDT,
+    // the database will complain → no safetly risk.
+    if (select.groupBy)
+      select.groupBy.unshift( { ref: [ fieldName ] } );
+  }
+
+  function handleColumns( columns ) {
+    let specifiedKey = false;
+    csnPath.push( 'columns', -1 );
+    for (const col of columns) {
+      ++csnPath[csnPath.length - 1];
+      if (col.expand || col.inline) {
+        error( null, csnPath, {},
+               'Can\'t use expand/inline in a tenant-dependent entity' );
+      }
+      if (col.key != null)      // yes, also with key: false
+        specifiedKey = true;
+      if (col.cast?.on) // REDIRECTED TO with explicit ON - TODO (low prio): less $self
+        addToCondition( col.cast, col.as || implicitAs( col.ref ) );
+    }
+    csnPath.length -= 2;
+    columns.unshift( specifiedKey
+      ? { key: true, ref: [ fieldName ] }
+      : { ref: [ fieldName ] } );
+  }
+
+  function handleAssociations( elem ) {
+    const { elements } = elem;
+    if (elements) {
+      csnPath.push( 'elements', '' );
+      for (const name in elements) {
+        csnPath[csnPath.length - 1] = name;
+        handleAssociations( elements[name] );
+      }
+      csnPath.length -= 2;
+    }
+    else if (elem.target) {
+      if (elem.on) {
+        addToCondition( elem, csnPath[csnPath.length - 1] );
+      }
+      else {
+        error( null, csnPath, {},
+               'Can\'t yet use managed associations in a tenant-dependent entity' );
+      }
+    }
+    else if (elem.items) {
+      csnPath.push( 'items' );
+      handleAssociations( elem.items );
+      --csnPath.length;
+    }
+  }
+
+  function addToCondition( elem, assoc ) {
+    if (!elem.on)
+      return;
+    const withSelf = csnPath.length > 4;
+    elem.on = [
+      { ref: [ assoc, fieldName ] }, // TODO: consider assoc name starting with '$'
+      '=',
+      { ref: (withSelf) ? [ '$self', fieldName ] : [ fieldName ] },
+      'and',
+      // TODO: avoid (...) for standard AND-ed EQ-comparisons ?
+      { xpr: elem.on },
+    ];
+  }
+}
+
+function implicitAs( ref ) {
+  const item = ref[ref.length - 1];
+  const id = (typeof item === 'string') ? item : item.id;
+  return id.substring( id.lastIndexOf('.') + 1 );
+}
+
+module.exports = {
+  addTenantFields,
+};

package/lib/transform/db/applyTransformations.js

@@ -13,7 +13,7 @@
 
 
 const { setProp } = require('../../base/model');
-const { xprInAnnoProperties } = require('../../compiler/builtins');
+const { isAnnotationExpression } = require('../../compiler/builtins');
 
 
 /**
@@ -85,6 +85,8 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
         const trans = transformers[name] || transformers[name.charAt(0)] || standard;
         if (customTransformers[name])
           customTransformers[name](node, name, node[name], csnPath, _parent, _prop);
+        else if (options.processAnnotations && customTransformers['@'] && name.charAt(0) === '@')
+          customTransformers['@'](node, name, node[name], csnPath, _parent, _prop);
         trans( node, name, node[name], csnPath );
       }
     }
@@ -109,6 +111,8 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
       const trans = transformers[name] || transformers[name.charAt(0)] || standard;
       if (customTransformers[name])
         customTransformers[name](node, name, node[name], csnPath, dict);
+      else if (options.processAnnotations && customTransformers['@'] && name.charAt(0) === '@')
+        customTransformers['@'](node, name, node[name], csnPath, dict);
       trans( node, name, node[name], csnPath );
     }
     csnPath.pop();
@@ -144,14 +148,19 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
    */
   function annotation( _parent, _prop, node ) {
     if (options.processAnnotations) {
-      if (node?.['='] !== undefined && xprInAnnoProperties.some(xProp => node[xProp] !== undefined)) {
+      if (isAnnotationExpression(node)) {
         standard(_parent, _prop, node);
       }
       else if (node && typeof node === 'object') {
         csnPath.push(_prop);
 
-        for (const name of Object.getOwnPropertyNames( node ))
-          annotation( node, name, node[name] );
+        if (Array.isArray(node)) {
+          node.forEach( (n, i) => annotation( node, i, n ) );
+        }
+        else {
+          for (const name of Object.getOwnPropertyNames( node ))
+            annotation( node, name, node[name] );
+        }
 
         csnPath.pop();
       }
@@ -287,7 +296,51 @@ function applyTransformationsOnDictionary( dictionary, customTransformers = {},
   return applyTransformationsInternal(dictionary, null, customTransformers, [], { directDict: true, ...options }, path);
 }
 
+/**
+ * transformExpression is a lightweight version of applyTransformations
+ * used primarily to transform annotation expressions.
+ * If propName is undefined, all properties of parent are transformed.
+ * @param {object} parent Start node
+ * @param {string} propName Start at specific property of parent
+ * @param {object} transformers Map of callback functions
+ * @param {CSN.Path} path Path to parent
+ * @returns {object} transformed node
+ */
+function transformExpression( parent, propName, transformers, path = [] ) {
+  if (propName != null) {
+    const child = parent[propName];
+    if (!child || typeof child !== 'object' ||
+        !{}.propertyIsEnumerable.call( parent, propName ))
+      return parent;
+
+    path = [ ...path, propName ];
+    if (Array.isArray(child)) {
+      child.forEach( (n, i) => transformExpression( child, i, transformers, path ) );
+    }
+    else {
+      for (const cpn of Object.getOwnPropertyNames( child )) {
+        const ct = transformers[cpn];
+        if (ct) {
+          const ppn = propName;
+          if (Array.isArray(ct))
+            ct.forEach(cti => cti(child, cpn, child[cpn], path, parent, ppn));
+
+          else
+            ct(child, cpn, child[cpn], path, parent, ppn);
+        }
+        transformExpression(child, cpn, transformers, path);
+      }
+    }
+  }
+  else {
+    for (propName of Object.getOwnPropertyNames( parent ))
+      transformExpression( parent, propName, transformers, path );
+  }
+  return parent;
+}
+
 module.exports = {
+  transformExpression,
   applyTransformations,
   applyTransformationsOnNonDictionary,
   applyTransformationsOnDictionary,

package/lib/transform/db/assertUnique.js

@@ -16,12 +16,12 @@ const { pathName } = require('../../compiler/utils');
  *
  * @param {CSN.Model} csn Overall CSN model
  * @param {CSN.Options} options Options
- * @param {Function} error Message function for errors
- * @param {Function} info Message function for info
+ * @param {object} messageFunctions Message functions (error(), info(), …)
  * @returns {Function} forEachDefinition callback
  */
-function processAssertUnique( csn, options, error, info ) {
-  const { resolvePath, flattenPath } = getTransformers(csn, options);
+function processAssertUnique( csn, options, messageFunctions ) {
+  const { resolvePath, flattenPath } = getTransformers(csn, options, messageFunctions);
+  const { error, info } = messageFunctions;
 
   return handleAssertUnique;
   /**

package/lib/transform/db/backlinks.js

@@ -18,6 +18,7 @@ const { forEach } = require('../../utils/objectUtils');
  * @returns {import('../../model/csnUtils').genericCallback} callback for forEachDefinition
  */
 function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimiter, doA2J = true ) {
+  let prepend$self = false;
   return transformSelfInBacklinks;
   /**
    * @param {CSN.Artifact} artifact
@@ -26,12 +27,15 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
    * @param {CSN.Path} path
    */
   function transformSelfInBacklinks( artifact, artifactName, dummy, path ) {
+    prepend$self = false;
     // Fixme: For toHana mixins must be transformed, for toSql -d hana
     // mixin elements must be transformed, why can't toSql also use mixins?
     if (options.transformation === 'effective' && artifact.elements || artifact.kind === 'entity' || artifact.query || (options.forHana && options.sqlMapping === 'hdbcds' && artifact.kind === 'type'))
       processDict(artifact.elements, path.concat([ 'elements' ]));
-    if (artifact.query?.SELECT?.mixin)
+    if (artifact.query?.SELECT?.mixin) {
+      prepend$self = options.transformation === 'effective';
       processDict(artifact.query.SELECT.mixin, path.concat([ 'query', 'SELECT', 'mixin' ]));
+    }
 
     /**
      * Loop over the dict and start the processing.
@@ -237,6 +241,10 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
         { ref: k.ref },
       ];
 
+      if (prepend$self)
+        a[1].ref = [ '$self', ...a[1].ref ];
+
+
       conditions.push([ a[0], '=', a[1] ]);
     });
 
@@ -273,11 +281,15 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
         // we are in the "path" from the forwarding assoc => need to remove the first part of the path
         if (ref[0] === assocName) {
           ref.shift();
+          if (prepend$self)
+            ref.unshift('$self');
         }
         else if (ref.length > 1 && ref[0] === '$self' && ref[1] === assocName) {
           // We could also have a $self in front of the assoc name - so we would need to shift twice
           ref.shift();
           ref.shift();
+          if (prepend$self)
+            ref.unshift('$self');
         }
         else { // we are in the backlink assoc "path" => need to push at the beginning the association's id
           ref.unshift(elemName);

package/lib/transform/db/cdsPersistence.js

@@ -106,7 +106,7 @@ function getPersistenceTableProcessor( csn, options, messageFunctions ) {
   const { error } = messageFunctions;
   const {
     recurseElements,
-  } = transformUtils.getTransformers(csn, options, '_');
+  } = transformUtils.getTransformers(csn, options, messageFunctions, '_');
 
   return handleQueryish;
 

package/lib/transform/db/expansion.js

@@ -10,6 +10,7 @@ const {
 const { implicitAs, columnAlias, pathId } = require('../../model/csnRefs');
 const { setProp } = require('../../base/model');
 const { forEach } = require('../../utils/objectUtils');
+const { killNonrequiredAnno } = require('./killAnnotations');
 
 /**
  * For keys, columns, groupBy and orderBy, expand structured things.
@@ -27,7 +28,7 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
 
   rewriteExpandInline();
 
-  applyTransformations(csn, {
+  const transformers = {
     keys: (parent, name, keys, path) => {
       parent.keys = expand(keys, path.concat('keys'), true);
     },
@@ -53,7 +54,13 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
     orderBy: (parent, name, orderBy, path) => {
       parent.orderBy = expand(orderBy, path.concat('orderBy'));
     },
-  }, [], iterateOptions);
+  };
+
+  // To not have a whole model loop for such a "small" thing, we kill all non-sql-backend relevant annotations here
+  if (options.transformation === 'sql' || options.transformation === 'hdbcds')
+    transformers['@'] = killNonrequiredAnno;
+
+  applyTransformations(csn, transformers, [], iterateOptions);
 
   /**
    * Turn .expand/.inline into normal refs. @cds.persistence.skip .expand with to-many (and all transitive views).
@@ -529,7 +536,7 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
         else
           newThing.push(col);
       }
-      else if (col.ref && col.$scope === '$magic' && ( col.ref[0] === '$user' || col.ref[0] === '$session' ) && !col.as) {
+      else if (col.ref && col.$scope === '$magic' && ( col.ref[0] === '$user' || col.ref[0] === '$tenant' || col.ref[0] === '$session' ) && !col.as) {
         col.as = implicitAs(col.ref);
         newThing.push(col);
       }
@@ -618,6 +625,20 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
           setProp(obj, '$implicitAlias', true);
       }
 
+      // If our column/thing was cast to a structured type, we need to keep the "cast" insync with the
+      // flattened out leaf elements that we turn the ref into
+      if (obj.cast?.type) {
+        const addedRef = currentRef.slice(root.ref.length);
+        if (addedRef.length > 0) {
+          // Decouple from other leafs
+          obj.cast = { ...obj.cast };
+          if (!obj.cast.type.ref)
+            obj.cast.type = { ref: [ obj.cast.type ] };
+
+          obj.cast.type.ref = [ ...obj.cast.type.ref, ...addedRef ];
+        }
+      }
+
       // The Java runtime, as of 2023-09-13, assumes that for _simple projections_, all references
       // are relative to the query source.  To avoid breaking that assumption unless necessary,
       // we only add the table alias if: