@sap/cds-compiler 3.6.2 → 3.7.2

package/lib/transform/forRelationalDB.js

@@ -18,6 +18,7 @@ const { timetrace } = require('../utils/timetrace');
 const { createReferentialConstraints, assertConstraintIdentifierUniqueness } = require('./db/constraints');
 const { createDict, forEach } = require('../utils/objectUtils');
 const handleExists = require('./db/transformExists');
+const { rewriteCalculatedElementsInViews, processCalculatedElementsInEntities } = require('./db/rewriteCalculatedElements');
 const replaceAssociationsInGroupByOrderBy = require('./db/groupByOrderBy');
 const _forEachDefinition = require('../model/csnUtils').forEachDefinition;
 const flattening = require('./db/flattening');
@@ -178,14 +179,15 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   const transformCsn = transformUtils.transformModel;
 
 
-  timetrace.start('temporal');
-  // (001) Add a temporal where condition to views where applicable before assoc2join
-  //       assoc2join eventually rewrites the table aliases
-  forEachDefinition(csn, temporal.getViewDecorator(csn, {info}, csnUtils));
-  timetrace.stop('temporal');
+  forEachDefinition(csn, [ 
+    // (001) Add a temporal where condition to views where applicable before assoc2join
+    //       assoc2join eventually rewrites the table aliases
+    temporal.getViewDecorator(csn, {info}, csnUtils),
+    // check unique constraints - further processing is done in rewriteUniqueConstraints
+    assertUnique.prepare(csn, options, error, info)
+  ]);
 
-  // check unique constraints - further processing is done in rewriteUniqueConstraints
-  assertUnique.prepare(csn, options, error, info);
+  rewriteCalculatedElementsInViews(csn, options, pathDelimiter, error);
 
   if(doA2J) {
     // Expand a structured thing in: keys, columns, order by, group by
@@ -199,6 +201,11 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   bindCsnReferenceOnly();
 
 
+  // TODO: Instead of 3 separate applyTransformations, we could have each of them just return the "listeners", merge them into
+  // one big listener that then gets passed into one single applyTransformations. Each listener would then have to return an array of callbacks to call.
+  // With that, we could still ensure the processing order (assuming we don't run into problems with scoping).
+  // To analyze: Increased memory vs. saved cycles
+  // Looked at it with AFC: This is only a small part of the overall processing time, enrich step of validator is just as expensive
   if(doA2J) {
     const resolved = new WeakMap();
     // No refs with struct-steps exist anymore
@@ -240,6 +247,8 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     }
   });
 
+  processCalculatedElementsInEntities(csn, options);
+
   timetrace.start('Transform CSN')
 
   // (000) Rename primitive types, make UUID a String
@@ -255,15 +264,15 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     },
   }, true);
 
-  // (040) Ignore entities and views that are abstract or implemented
-  // or carry the annotation cds.persistence.skip/exists
-  // These entities are not removed from the csn, but flagged as "to be ignored"
-  forEachDefinition(csn, cdsPersistence.getAnnoProcessor());
-
-
-  // (050) Check @cds.valid.from/to only on entity
-  //       Views are checked in (001), unbalanced valid.from/to's or mismatching origins
-  forEachDefinition(csn, temporal.getAnnotationHandler(csn, options, pathDelimiter, {error}));
+  forEachDefinition(csn, [
+    // (040) Ignore entities and views that are abstract or implemented
+    // or carry the annotation cds.persistence.skip/exists
+    // These entities are not removed from the csn, but flagged as "to be ignored"
+    cdsPersistence.getAnnoProcessor(),
+    // (050) Check @cds.valid.from/to only on entity
+    //       Views are checked in (001), unbalanced valid.from/to's or mismatching origins
+    temporal.getAnnotationHandler(csn, options, pathDelimiter, {error})
+  ]);
 
   // eliminate the doA2J in the functions 'handleManagedAssociationFKs' and 'createForeignKeyElements'
   doA2J && flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, error, pathDelimiter, true, csnUtils, { skipDict: { actions: true }, allowArtifact: artifact => (artifact.kind === 'entity') });
@@ -300,18 +309,19 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     }
   });
 
-  // For generating DB stuff:
-  // - table-entity with parameters: not allowed
-  // - view with parameters: ok on HANA, not allowed otherwise
-  // (don't complain about action/function with parameters)
-  forEachDefinition(csn, handleChecksForWithParameters);
-
-  // Remove .masked
-  // Check that keys are not explicitly nullable
-  // Check that Associations are not used in entities/views with parameters
-  // (150 b) Strip inheritance
-  // Note that this should happen after implicit redirection, because includes are required for that
-  forEachDefinition(csn, handleDBChecks);
+  forEachDefinition(csn, [
+    // For generating DB stuff:
+    // - table-entity with parameters: not allowed
+    // - view with parameters: ok on HANA, not allowed otherwise
+    // (don't complain about action/function with parameters)
+    handleChecksForWithParameters,
+    // Remove .masked
+    // Check that keys are not explicitly nullable
+    // Check that Associations are not used in entities/views with parameters
+    // (150 b) Strip inheritance
+    // Note that this should happen after implicit redirection, because includes are required for that
+    handleDBChecks,
+  ]);
 
   // (170) Transform '$self' in backlink associations to appropriate key comparisons
   // Must happen before draft processing because the artificial ON-conditions in generated

package/lib/transform/odata/typesExposure.js

@@ -13,21 +13,66 @@ const { copyAnnotations, getNamespace } = require('../../model/csnUtils');
 const { isBetaEnabled } = require('../../base/model.js');
 const { CompilerAssertion } = require('../../base/error');
 
+/**
+ * A given CDS model is a set of n definitions D = {v_1, ..., v_n } spanning a type dependency
+ * graph T(D) with vertices v_r, v_d (representing the referrer (using) and defining node of a type)
+ * and edges e(v_r, v_d).
+ *
+ * S may be a proper subset of D and is defined by v_s. Up to n S_i may exist.
+ * v is element of S_i, if name(v) starts with name(v_s). Therefore any v can only be member
+ * of exactly one S_i and v_s is always member of its own S_i.
+ *
+ * A complete service type dependency graph Tc(S) is defined as a set of vertices v_r, v_d
+ * and edges e(v_r, v_d) such that all v_r, v_d are elements of S (v_rs, v_ds) and with that
+ * all edges are { e(v_rs, v_ds) }.
+ *
+ * The input CSN may contain edges e(v_rs, v_dns) with v_r element of S_i (v_rs) and v_d not element 
+ * of S_i (v_dns).
+ *
+ * The aim of this algorithm is to produce Tc's for all requested S_i by 'filling' up the missing
+ * vertices v_ds and rewriting all e(v_rs, v_dns) to e(v_rs, v_ds).
+ *
+ * This can be done pretty easily by (recursively) iterating over all requested v_rs and
+ * follow e(v_r, v_d) until a v_dns is found. v_dns is cloned and added to S via
+ * name(v_ds) = name(v_s) + '.' + name(v_dns). If v_dns is an anonymous definition, an
+ * artificial name representing the path to that node is being used.
+ *
+ * The algorithm has a beneficial side effect: it creates new (sub) schemas on the fly
+ * which are required for the construction of the EDM intermediate representation later on.
+ *
+ * An OData service contains at least one schema. Only (OData) schemas may contain definitions.
+ * By default, the CDS service v_s represents the default (OData) schema.
+ * However, there are situations where { v_dns } must be partitioned into (sub) schemas in order to
+ * maintain their original name prefixes and to be compatible with later service definitions.
+ *
+ * If name(v_dns) is made up of segments separated by a dot '.', the first n-1 segments represent
+ * the sub schema: name(schema) = name(v_s) + '.' + concat(1,n-1, segments(name(v_dns)), '.')
+ *
+ * If name(v_dns) has no prefix segments, the fallback schema name is prepended instead:
+ * name(v_ds) = name(v_s) + '.' + fallbackschema + name(v_dns);
+ * 
+ * @param {CSN.Model} csn
+ * @param {function}  whatsMyServiceName
+ * @param {string[]}     requestedServiceNames
+ * @param {String}    fallBackSchemaName
+ * @param {Object}    options
+ * @param {Object}    csnUtils
+ * @param {Object}    message
+ * @returns {Object}  schemas dictionary of (sub) schemas for all requested services
+ */
 function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackSchemaName, options, csnUtils, message) {
   const { error } = message;
   const special$self = !csn?.definitions?.$self && '$self';
   // are we working with OData proxies or cross-service refs
   const isMultiSchema = options.odataVersion === 'v4' && (options.odataProxies || options.odataXServiceRefs);
-  // collect in this variable all the newly exposed types
+  // service sub schemas as return value
   const schemas = Object.create(null);
+  // exposed types register
   const exposedTypes = Object.create(null);
-  // walk through the definitions of the given CSN and expose types where needed
   forEachDefinition(csn, (def, defName, propertyName, path) => {
-    // we do expose types only for definition from inside services
     const serviceName = whatsMyServiceName(defName, false);
     // run type exposure only on requested services if not in multi schema mode
     // multi schema mode requires a proper type exposure for all services as a prerequisite
-    // for the proxy exposure
     if (serviceName && requestedServiceNames.includes(serviceName)) {
       if (def.kind === 'type' || def.kind === 'entity') {
         forEachMember(def, (element, elementName, propertyName, path) => {
@@ -38,13 +83,9 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
         }, path);
       }
 
-      // For exposed actions and functions that use non-exposed or anonymous structured types, create
-      // artificial exposing types.
-      // unbound actions
       if (def.kind === 'action' || def.kind === 'function') {
         exposeTypesOfAction(def, defName, defName, serviceName, path);
       }
-      // bound actions
       def.actions && Object.entries(def.actions).forEach(([actionName, action]) => {
         exposeTypesOfAction(action, `${defName}_${actionName}`, defName, serviceName, path.concat(['actions', actionName]));
       });
@@ -53,19 +94,13 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
 
   if(isBetaEnabled(options, 'odataTerms')) {
     forEachGeneric(csn, 'vocabularies', (def, defName, _propertyName, path) => {
-    // we do expose types only for definition from inside services
       const serviceName = whatsMyServiceName(defName, false);
-    // run type exposure only on requested services if not in multi schema mode
-    // multi schema mode requires a proper type exposure for all services as a prerequisite
-    // for the proxy exposure
       if (serviceName && requestedServiceNames.includes(serviceName)) {
         if(csn.definitions[defName]) {
-        // error, duplicate definitions not allowed!
-        // TODO: Use path as error location as soon as refs outside definitions are supported
           error('odata-definition-exists', ['vocabularies', defName], { anno: defName, '#':'anno' });
         }
         else {
-        // link def into definitions for later use
+          // link def into definitions for later use
           def.kind = 'annotation';
           csn.definitions[defName] = def;
           const artificialName = `term_${defName.replace(/\./g, '_')}`;//_${paramName}`;

package/lib/transform/parseExpr.js

@@ -19,7 +19,7 @@
  * Unary:                      'is [not] null', 'not'
  * Conditional:                'case [when then]+ [else]? end', 'and', 'or'
  *
- * Not yet implemented:        'new'
+ * stand-alone token:          'new'
  *
  * This is not an optimized LL(1) parser but a token 'sniffer'. A stream is
  * cracked up in sub streams and passed down to the next higher function.
@@ -33,8 +33,8 @@
  * This parser intentionally does no error handling. If a clause is malformed, it is accepted as is.
  *
  * @param {any} xpr A JSON object.
- * @param {Object} state Objet
- *  anno: Don't eliminate arrays with single entry in statetations as they are collections
+ * @param {Object} state Object
+ *  anno: Don't eliminate arrays with single entry in statetations (TODO?) as they are collections
  *  array: Bias AST representation.
  *  nary: return n-ary or binary tree
  */
@@ -42,7 +42,7 @@
 function parseExpr(xpr, state = { anno: 0, array: true, nary: false }) {
   // Notes:
   //  - Variables `s` and `e` are used as index variables into `xpr`s for start and end.
-  //  - xpr's are our CSN expressions, see <https://pages.github.tools.sap/cap/docs/cds/cxn>
+  //  - xpr's are our CSN expressions, see <https://cap.cloud.sap/docs/cds/cxn>
 
   return parseExprInt(xpr, state);
 
@@ -82,7 +82,7 @@ function parseExpr(xpr, state = { anno: 0, array: true, nary: false }) {
      */
     function rewriteCaseBlock(casePos, endPos) {
       const caseTree = state.array ? [ 'case' ] : { 'case': [] };
-      
+
       let elsePos = endPos;
       let whenPos = casePos;
 
@@ -144,7 +144,7 @@ function parseExpr(xpr, state = { anno: 0, array: true, nary: false }) {
   function conditionOR(xpr, s, e, state) {
     return binaryExpr(xpr, ['or'], conditionAnd, s, e, state);
   }
-  
+
   function conditionAnd(xpr, s, e, state) {
     return binaryExpr(xpr, (xpr, s, e) => {
       let a = s-1;
@@ -283,7 +283,8 @@ function parseExpr(xpr, state = { anno: 0, array: true, nary: false }) {
       //   return xpr;
       for(let n in xpr) {
         const x = xpr[n];
-        if(n[0] === '@')
+        const isAnno = n[0] === '@' && isSimpleAnnoValue(x);
+        if(isAnno)
           state.anno++;
         if(Array.isArray(x)) {
           if(csnarray.includes(n) || state.anno !== 0)
@@ -295,7 +296,7 @@ function parseExpr(xpr, state = { anno: 0, array: true, nary: false }) {
         }
         else
           xpr[n] = parseExprInt(x, state);
-        if(n[0] === '@')
+        if(isAnno)
           state.anno--;
       }
     }
@@ -343,6 +344,11 @@ function parseExpr(xpr, state = { anno: 0, array: true, nary: false }) {
 
 }
 
+function isSimpleAnnoValue(val) {
+  // Expressions as annotation values always have a `=` and another property.
+  return !val?.['='] || Object.keys(val) < 2;
+}
+
 module.exports = {
   parseExpr,
 };

package/lib/transform/transformUtilsNew.js

@@ -321,9 +321,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
    */
   function flattenStructStepsInRef(ref, path, links, scope, resolvedLinkTypes=new WeakMap()) {
     // Refs of length 1 cannot contain steps - no need to check
-    if (ref.length < 2) {
-      return ref;
-    } else if(scope === '$self' && ref.length === 2) {
+    if (ref.length < 2 || (scope === '$self' && ref.length === 2)) {
       return ref;
     }
 
@@ -1136,7 +1134,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
           const rhsIsVal = (rhs === 'null' /*|| rhs.val !== undefined*/);
 
           // lhs & rhs must be expandable types (structures or managed associations)
-          // if ever lhs should be alowed to be a value uncomment this
+          // if ever lhs should be allowed to be a value uncomment this
           if(!(lhsIsVal /*&& rhsIsVal*/) &&
              !(isDollarSelfOrProjectionOperand(lhs) || isDollarSelfOrProjectionOperand(rhs)) &&
              RelationalOperators.includes(op) &&
@@ -1189,6 +1187,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
               // lhs && rhs are present, consistency checks that affect both ends
               else {
                 // is lhs scalar?
+                // eslint-disable-next-line sonarjs/no-gratuitous-expressions
                 if(!lhsIsVal && x.lhs && !isScalarOrNoType(x.lhs._art)) {
                   error(null, location, { prefix, name: `${pathName(x.lhs.ref)}${(xn.length ? '.' + xn : '')}` },
                     '$(PREFIX): Path $(NAME) must end on a scalar type')
@@ -1201,6 +1200,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
                   cont = false;
                 }
                 // info about type incompatibility if no other errors occurred
+                // eslint-disable-next-line sonarjs/no-gratuitous-expressions
                 if(!(lhsIsVal || rhsIsVal) && x.lhs && x.rhs && xn && cont) {
                   const lhst = getType(x.lhs._art);
                   const rhst = getType(x.rhs._art);
@@ -1215,6 +1215,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
               return expr;
 
             // if lhs and rhs are refs set operator from 'like' to '='
+            // eslint-disable-next-line sonarjs/no-gratuitous-expressions
             if(op === 'like' && !(lhsIsVal || rhsIsVal)) {
               op = '=';
             }
@@ -1419,7 +1420,7 @@ function rewriteBuiltinTypeRef(csn) {
   const special$self = !csn?.definitions?.$self && '$self';
   applyTransformations(csn, {
     type: (parent, _prop, type) => {
-      if(type.ref && (
+      if(type?.ref && (
         isBuiltinType(type.ref[0]) ||
         type.ref[0] === special$self)
       ) {

package/lib/transform/translateAssocsToJoins.js

@@ -17,6 +17,7 @@ function translateAssocsToJoinsCSN(csn, options){
   // Do not re-complain about localized
   const compileOptions = { ...options, $skipNameCheck: true };
   delete compileOptions.csnFlavor;
+  // console.log('CSN passed by A2J to compiler:',JSON.stringify(csn,null,2))
   const model = recompileX(csn, compileOptions);
   timetrace.stop('A2J: Recompiling model');
   timetrace.start('A2J: Translating associations to joins');
@@ -251,22 +252,24 @@ function translateAssocsToJoins(model, inputOptions = {})
   */
   function substituteDollarSelf(pathNode)
   {
-    let [head, ...tail] = pathNode.path;
-    if(['$projection', '$self'].includes(head.id) && tail.length) {
+    let pathValue = pathNode;
+    let [head, ...tail] = pathValue.path;
+    while(tail.length && head._navigation?.kind === '$self') {
       const self = head;
-      if(self._navigation && self._navigation.kind === '$self') {
-        [head, ...tail] = tail;
-        if(head) {
-          let pathValue = self._navigation._origin.elements[head.id].value;
-          // core compiler has already caught $self.<assoc>.<postfix> and
-          // non-path $self expressions with postfix path
-          if(pathValue.path && tail.length) {
+      [head, ...tail] = tail;
+      if(head) {
+        pathValue = self._navigation._origin.elements[head.id].value;
+        // core compiler has already caught $self.<assoc>.<postfix> and
+        // non-path $self expressions with postfix path
+        if(pathValue.path) {
+          if(tail.length)
             pathValue = constructPathNode([...pathValue.path, ...tail], pathValue.alias, false);
-          }
-          replaceNodeContent(pathNode, pathValue);
+          [head, ...tail] = pathValue.path;
         }
       }
     }
+    if(head)
+      replaceNodeContent(pathNode, pathValue);
   }
 
   /*
@@ -636,7 +639,7 @@ function translateAssocsToJoins(model, inputOptions = {})
         }
 
         env.assocStack.push(assoc);
-        let onCond = cloneOnCondition(assoc.on);
+        const onCond = cloneOnCondition(assoc.on);
         env.assocStack.pop();
         return onCond;
       }
@@ -655,8 +658,8 @@ function translateAssocsToJoins(model, inputOptions = {})
       }
 
       function cloneOnCondExprStream(expr) {
-        let args = expr.args;
-        let result = { op: { val: expr.op.val }, args: [ ] };
+        const args = expr.args;
+        const result = { op: { val: expr.op.val }, args: [ ] };
         for(let i = 0; i < args.length; i++)
         {
           if(args[i].op && args[i].op.val === 'xpr')
@@ -668,7 +671,7 @@ function translateAssocsToJoins(model, inputOptions = {})
           else if(i < args.length-2 && args[i].path &&
                   args[i+1]?.literal === 'token' && args[i+1]?.val === '=' && args[i+2].path)
           {
-            let fwdAssoc = getForwardAssociation(args[i].path, args[i+2].path);
+            const fwdAssoc = getForwardAssociation(args[i].path, args[i+2].path);
             if(fwdAssoc)
             {
               //env.assocStack.includes(fwdAssoc) => recursion
@@ -702,7 +705,7 @@ function translateAssocsToJoins(model, inputOptions = {})
 
         // If this is a backlink condition, produce the
         // ON cond of the forward assoc with swapped src/tgt aliases
-        let fwdAssoc = getForwardAssociationExpr(expr);
+        const fwdAssoc = getForwardAssociationExpr(expr);
         if(fwdAssoc) {
           if(env.assocStack.length === 2) {
             // reuse (ugly) error message from forHana
@@ -729,25 +732,38 @@ function translateAssocsToJoins(model, inputOptions = {})
       }
 
       // The src/tgtAliases need to be swapped for ON Condition of the forward assoc.
-      // The correct table alias is the QA of the original target. If this target
-      // has been redirected, use the QA of the redirected target.
-      // As last resort use the source alias information.
-      // TODO Discuss: Huh, why do you need to care about redirections?
-      // Probably only with to-be-rewritten ON conditions (should be error in v2).
+      // If the QAT assoc is a mixin and forward assoc was propagated, the original
+      // forward definition must have a target in the query source otherwise the ON cond
+      // is not resolvable (exception propagated mixins, as these are defined against the
+      // view signature and not a query source). If the target is not part of the query source,
+      // raise an error. Swap source and target otherwise.
       function swapTableAliasesForFwdAssoc(fwdAssoc, srcAlias, tgtAlias) {
-        let newSrcAlias = tgtAlias;
+        const newSrcAlias = tgtAlias;
         let newTgtAlias = {};
-        // first try to identify table alias for complex views or redirected associations
-        if(fwdAssoc._redirected && fwdAssoc._redirected.length &&
-           // redirected target must have a $QA
-           fwdAssoc._redirected[fwdAssoc._redirected.length-1].$QA &&
-           // $QA's artifact must either be same srcAlias artifact
-           (fwdAssoc._redirected[fwdAssoc._redirected.length-1].$QA._artifact === srcAlias._artifact ||
-           // OR original assoc is a mixin (then just use the $QA)
-           assoc.kind === 'mixin')) {
-          newTgtAlias.id = fwdAssoc._redirected[fwdAssoc._redirected.length-1].$QA.name.id;
-          newTgtAlias._artifact = fwdAssoc._redirected[fwdAssoc._redirected.length-1]._effectiveType;
-          newTgtAlias._navigation = fwdAssoc._redirected[fwdAssoc._redirected.length-1].$QA.path[0]._navigation;
+
+        let i = 0;
+        let fwdOrigin = fwdAssoc;
+        while(fwdOrigin._origin) {
+          fwdOrigin = fwdOrigin._origin;
+          i++;
+        }
+        // If fwdAssoc was propagated and the origin is not a mixin itself (which always
+        // points to the signature of the current view and ensures that the ON cond is
+        // resolvable) make sure that the original assoc target is contained in the local
+        // query source
+        if(assoc.kind === 'mixin' && i > 0 && fwdOrigin.kind !== 'mixin') {
+          const tas = Object.values(env.lead.$tableAliases);
+          const i = tas.findIndex(ta => ta._artifact === fwdOrigin.target._artifact);
+          if(i >= 0 && tas[i].$QA) {
+            newTgtAlias.id = tas[i].$QA.name.id;
+            newTgtAlias._artifact = tas[i]._effectiveType;
+            newTgtAlias._navigation = tas[i].$QA.path[0]._navigation;
+          }
+          else {
+            error(null, [ assocQAT._origin.location, assocQAT._origin ], { name: fwdOrigin.target._artifact.name.id, art: assoc.name.id },
+                    'Expected association target $(NAME) of association $(ART) to be a query source');
+            newTgtAlias = Object.assign(newTgtAlias, srcAlias);
+          }
         }
         else {
           newTgtAlias = Object.assign(newTgtAlias, srcAlias);

package/package.json

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