@sap/cds-compiler 4.2.2 → 4.3.0

package/lib/transform/forRelationalDB.js

@@ -4,7 +4,7 @@ const { setProp, isBetaEnabled } = require('../base/model');
 const { cloneCsnNonDict,
         forEachMemberRecursively, forAllQueries, applyTransformationsOnNonDictionary,
         getArtifactDatabaseNameOf, getElementDatabaseNameOf, isBuiltinType, applyTransformations,
-        isAspect, walkCsnPath, isPersistedOnDatabase,
+        isAspect, walkCsnPath, isPersistedOnDatabase
       } = require('../model/csnUtils');
 const { makeMessageFunction } = require('../base/messages');
 const transformUtils = require('./transformUtils');
@@ -29,8 +29,8 @@ const enrichUniversalCsn = require('./universalCsn/universalCsnEnricher');
 const { getViewTransformer, ensureColumnNames } = require('./db/views');
 const cdsPersistence = require('./db/cdsPersistence');
 const temporal = require('./db/temporal');
-const associations = require('./db/associations')
-const { ModelError } = require('../base/error');
+const associations = require('./db/associations');
+const backlinks = require('./db/backlinks');
 const { getDefaultTypeLengths } = require('../render/utils/common');
 
 // By default: Do not process non-entities/views
@@ -125,12 +125,10 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
   /** @type {() => void} */
   let throwWithAnyError;
   // transformUtils
-  let addDefaultTypeFacets,
+  let addDefaultTypeFacets, 
     expandStructsInExpression,
     flattenStructuredElement,
-    flattenStructStepsInRef,
-    isAssociationOperand,
-    isDollarSelfOrProjectionOperand;
+    flattenStructStepsInRef;
 
   bindCsnReference();
 
@@ -158,6 +156,9 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
   });
   timetrace.stop('Validate');
 
+  // exit if validators found errors
+  throwWithAnyError();
+
   rewriteCalculatedElementsInViews(csn, options, csnUtils, pathDelimiter, messageFunctions);
 
   // Needs to happen before tuple expansion, so the newly generated WHERE-conditions have it applied
@@ -174,8 +175,6 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
   // @ts-ignore
   expandStructsInExpression(csn, { drillRef: true });
 
-  throwWithAnyError();
-
   forEachDefinition(csn, [
     // (001) Add a temporal where condition to views where applicable before assoc2join
     //       assoc2join eventually rewrites the table aliases
@@ -215,6 +214,9 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
     flattening.resolveTypeReferences(csn, options, new WeakMap(), pathDelimiter);
   }
 
+  // With flattening errors, it makes little sense to continue.
+  throwWithAnyError();
+
   // (010) If requested, translate associations to joins
   if (doA2J)
     handleAssocToJoins();
@@ -335,7 +337,7 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
   // draft shadow entities have crooked '_artifact' links, confusing the backlink processing.
   // But it must also happen after flattenForeignKeys has been called for all artifacts,
   // because otherwise we would produce wrong ON-conditions for the keys involved. Sigh ...
-  forEachDefinition(csn, transformSelfInBacklinks);
+  forEachDefinition(csn, backlinks.getBacklinkTransformer(csnUtils, messageFunctions, options, pathDelimiter, doA2J));
 
   /**
    * Referential Constraints are only supported for sql-dialect "hana" and "sqlite".
@@ -451,8 +453,6 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
 
     ({ flattenStructuredElement,
       flattenStructStepsInRef,
-      isAssociationOperand,
-      isDollarSelfOrProjectionOperand,
       addDefaultTypeFacets,
       expandStructsInExpression,
       csnUtils
@@ -599,28 +599,6 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
     }
   }
 
-
-  /**
-   * @param {CSN.Artifact} artifact
-   * @param {string} artifactName
-   */
-  function transformSelfInBacklinks(artifact, artifactName, dummy, path) {
-    // Fixme: For toHana mixins must be transformed, for toSql -d hana
-    // mixin elements must be transformed, why can't toSql also use mixins?
-    if(artifact.kind === 'entity' || artifact.query || (options.forHana && options.sqlMapping === 'hdbcds' && artifact.kind === 'type'))
-      doit(artifact.elements, path.concat([ 'elements' ]));
-    if (artifact.query && artifact.query.SELECT && artifact.query.SELECT.mixin)
-      doit(artifact.query.SELECT.mixin, path.concat([ 'query', 'SELECT', 'mixin' ]));
-
-    function doit(dict, subPath) {
-      for (const elemName in dict) {
-        const elem = dict[elemName];
-        if (elem.on && csnUtils.isAssocOrComposition(elem))
-          processBacklinkAssoc(elem, elemName, artifact, artifactName, subPath.concat([ elemName, 'on' ]));
-      }
-    }
-  }
-
   /**
    * @param {CSN.Artifact} artifact
    * @param {string} artifactName
@@ -700,8 +678,6 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
   }
 
   function handleAssocToJoins() {
-    // With flattening errors, it makes little sense to continue.
-    throwWithAnyError();
     // the augmentor isn't able to deal with technical configurations and since assoc2join can ignore it we
     // simply make it invisible and copy it over to the result csn
     forEachDefinition(csn,
@@ -838,206 +814,7 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
   }
 
 
-  // If the association element 'elem' of 'art' is a backlink association, massage its ON-condition
-  // (in place) so that it
-  // - compares the generated foreign key fields of the corresponding forward
-  //   association with their respective keys in 'art' (for managed forward associations)
-  // - contains the corresponding forward association's ON-condition in "reversed" form,
-  //   i.e. as seen from 'elem' (for unmanaged associations)
-  // Otherwise, do nothing.
-  function processBacklinkAssoc(elem, elemName, art, artName, pathToOn) {
-    // Don't add braces if it is a single expression (ignoring superfluous braces)
-    const multipleExprs = elem.on.filter(x => x !== '(' && x !== ')' ).length > 3;
-    /**
-     * Process the args
-     *
-     * @param {Array} xprArgs
-     * @param {CSN.Path} path
-     * @returns {Array} Array of parsed expression
-     */
-    function processExpressionArgs(xprArgs, path) {
-      const result = [];
-      let i = 0;
-      while (i < xprArgs.length) {
-        // Only token tripel `<path>, '=', <path>` are of interest here
-        if (i < xprArgs.length - 2 && xprArgs[i + 1] === '=') {
-          // Check if one side is $self and the other an association
-          // (if so, replace all three tokens with the condition generated from the other side, in parentheses)
-          if (isDollarSelfOrProjectionOperand(xprArgs[i]) && isAssociationOperand(xprArgs[i + 2], path.concat([ i + 2 ]))) {
-            const assoc = csnUtils.inspectRef(path.concat([ i + 2 ])).art;
-            if (multipleExprs)
-              result.push('(');
-            const backlinkName = xprArgs[i + 2].ref[xprArgs[i + 2].ref.length - 1];
-            result.push(...transformDollarSelfComparison(xprArgs[i + 2],
-              assoc,
-              backlinkName,
-              elem, elemName, art, artName, path.concat([ i ])
-            ));
-            if (multipleExprs)
-              result.push(')');
-            i += 3;
-            attachBacklinkInformation(backlinkName);
-          }
-          else if (isDollarSelfOrProjectionOperand(xprArgs[i + 2]) && isAssociationOperand(xprArgs[i], path.concat([ i ]))) {
-            const assoc = csnUtils.inspectRef(path.concat([ i ])).art;
-            if (multipleExprs)
-              result.push('(');
-            const backlinkName = xprArgs[i].ref[xprArgs[i].ref.length - 1];
-            result.push(...transformDollarSelfComparison(xprArgs[i], assoc, backlinkName, elem, elemName, art, artName, path.concat([ i + 2 ])));
-            if (multipleExprs)
-              result.push(')');
-            i += 3;
-            attachBacklinkInformation(backlinkName);
-          }
-          // Otherwise take one (!) token unchanged
-          else {
-            result.push(xprArgs[i]);
-            i++;
-          }
-        }
-        // Process subexpressions - but keep them as subexpressions
-        else if(xprArgs[i].xpr){
-          result.push({xpr: processExpressionArgs(xprArgs[i].xpr, path.concat([i, 'xpr']))});
-          i++;
-        }
-        // Take all other tokens unchanged
-        else {
-          result.push(xprArgs[i]);
-          i++;
-        }
-      }
-      return result;
-
-      /**
-       * The knowledge whether an association was an `<up_>` association in a
-       * `$self = <comp>.<up_>` comparison, is important for the foreign key constraints.
-       * By the time we generate them, such on-conditions are already transformed
-       * --> no more `$self` in the on-conditions, that is why we need to remember it here.
-       *
-       * @param {string} backlinkName name of `<up_>` in a `$self = <comp>.<up_>` comparison
-       */
-      function attachBacklinkInformation(backlinkName) {
-        if (elem.$selfOnCondition)
-          elem.$selfOnCondition.up_.push(backlinkName);
-        else {
-          setProp(elem, '$selfOnCondition', {
-            up_: [backlinkName]
-          });
-        }
-      }
-    }
-
-    elem.on = processExpressionArgs(elem.on, pathToOn);
-
-    // Return the condition to replace the comparison `<assocOp> = $self` in the ON-condition
-    // of element <elem> of artifact 'art'. If there is anything to complain, use location <loc>
-    function transformDollarSelfComparison(assocOp, assoc, assocName, elem, elemName, art, artifactName, path) {
-      // Check: The forward link <assocOp> must point back to this artifact
-      // FIXME: Unfortunately, we can currently only check this for non-views (because when a view selects
-      // a backlink association element from an entity, the forward link will point to the entity,
-      // not to the view).
-      // FIXME: This also means that corresponding key fields should be in the select list etc ...
-      if (!art.query && !art.projection && assoc.target && assoc.target !== artifactName)
-        error( null, path, { id: '$self', name: artifactName, target: assoc.target },
-               'Expected association using $(ID) to point back to $(NAME) but found $(TARGET)' );
-
-      // Check: The forward link <assocOp> must not contain '$self' in its own ON-condition
-      if (assoc.on) {
-        const containsDollarSelf = assoc.on.some(isDollarSelfOrProjectionOperand);
-
-        if (containsDollarSelf)
-          error(null, path, { name: '$self' },
-            'An association that uses $(NAME) in its ON-condition can\'t be compared to $(NAME)');
-      }
-
-      // Transform comparison of $self to managed association into AND-combined foreign key comparisons
-      if (assoc.keys) {
-        if(assoc.keys.length)
-          return transformDollarSelfComparisonWithManagedAssoc(assocOp, assoc, assocName, elemName);
-        else {
-          elem.$ignore = true;
-          return [];
-        }
-      }
-
-      // Transform comparison of $self to unmanaged association into "reversed" ON-condition
-      else if (assoc.on)
-        return transformDollarSelfComparisonWithUnmanagedAssoc(assocOp, assoc, assocName, elemName);
-
-      throw new ModelError(`Expected either managed or unmanaged association in $self-comparison: ${ JSON.stringify(elem.on) }`);
-    }
 
-    // For a condition `<elemName>.<assoc> = $self` in the ON-condition of element <elemName>,
-    // where <assoc> is a managed association, return a condition comparing the generated
-    // foreign key elements <elemName>.<assoc>_<fkey1..n> of <assoc> to the corresponding
-    // keys in this artifact.
-    // For example, `ON elem.ass = $self` becomes `ON elem.ass_key1 = key1 AND elem.ass_key2 = key2`
-    // (assuming that `ass` has the foreign keys `key1` and `key2`)
-    function transformDollarSelfComparisonWithManagedAssoc(assocOp, assoc, originalAssocName, elemName) {
-      const conditions = [];
-      // if the element was structured then it was flattened => change of the delimiter from '.' to '_'
-      // this is done in the flattening, but as we do not alter the onCond itself there should be done here as well
-      const assocName = originalAssocName.replace(/\./g, pathDelimiter);
-      elemName = elemName.replace(/\./g, pathDelimiter);
-
-      assoc.keys.forEach((k) => {
-        // Depending on naming conventions, the foreign key may two path steps (hdbcds) or be a single path step with a flattened name (plain, quoted)
-        // With to.hdbcds in conjunction with hdbcds naming, we need to NOT use the alias - else we get deployment errors
-        const keyName = k.as && doA2J ? [k.as] : k.ref;
-        const fKeyPath = !doA2J ? [ assocName, ...keyName ] : [ `${ assocName }${ pathDelimiter }${ keyName[0] }` ];
-        // FIXME: _artifact to the args ???
-        const a = [
-          {
-            ref: [ elemName, ...fKeyPath ],
-          },
-          { ref: k.ref },
-        ];
-
-        conditions.push([ a[0], '=', a[1] ]);
-      });
-
-      return conditions.reduce((prev, current) => {
-        if (prev.length === 0)
-          return [ ...current ];
-
-        return [ ...prev, 'and', ...current ];
-      }, []);
-    }
-
-    // For a condition `<elemName>.<assoc> = $self` in the ON-condition of element <elemName>,
-    // where <assoc> is an unmanaged association, return the ON-condition of <assoc> as it would
-    // be written from the perspective of the artifact containing association <elemName>.
-    // For example, `ON elem.ass = $self` becomes `ON a = elem.x AND b = elem.y`
-    // (assuming that `ass` has the ON-condition `ON ass.a = x AND ass.b = y`)
-    function transformDollarSelfComparisonWithUnmanagedAssoc(assocOp, assoc, originalAssocName, elemName) {
-      // if the element was structured then it may have been flattened => change of the delimiter from '.' to '_'
-      // this is done in the flattening, but as we do not alter the onCond itself there should be done here as well
-      elemName = elemName.replace(/\./g, pathDelimiter);
-      const assocName = originalAssocName.replace(/\./g, pathDelimiter);
-      // clone the onCond for later use in the path transformation
-      const newOnCond = cloneCsnNonDict(assoc.on, options);
-      applyTransformationsOnNonDictionary({on: newOnCond}, 'on', {
-        ref: (parent, prop, ref) => {
-          if (ref[0] === assocName) // we are in the "path" from the forwarding assoc => need to remove the first part of the path
-          {
-            ref.shift();
-          } else if(ref && 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();
-          }
-          else { // we are in the backlink assoc "path" => need to push at the beginning the association's id
-            ref.unshift(elemName);
-            // if there was a $self identifier in the forwarding association onCond
-            // we do not need it anymore, as we prepended in the previous step the back association's id
-            if (ref[1] === '$self')
-              ref.splice(1, 1);
-          }
-        }
-      });
-      return newOnCond;
-    }
-  }
 
   /**
    * @param {CSN.Artifact} artifact

package/lib/transform/localized.js

@@ -395,8 +395,7 @@ function _addLocalizationViews(csn, options, config) {
     }
     if (!art[annoPersistenceSkip] && textsEntity[annoPersistenceSkip]) {
       messageFunctions.message( 'anno-unexpected-localized-skip', artPath,
-          { name: textsName, art: artName, anno: annoPersistenceSkip },
-          'Compiler generated entity $(NAME) must not be annotated with $(ANNO) if $(ART) is not skipped' );
+          { name: textsName, art: artName, anno: annoPersistenceSkip } );
       return null;
     }
 
@@ -654,8 +653,28 @@ function _addLocalizationViews(csn, options, config) {
         }
       },
     });
+    forEachDefinition(csn, checkAnnotationsOnLocalized);
   }
 
+  /**
+   * @param {CSN.Definition} def
+   * @param {string} defName
+   */
+  function checkAnnotationsOnLocalized(def, defName) {
+    const localizedPrefix = 'localized.';
+    if (defName.startsWith(localizedPrefix)) {
+      const artName = defName.substring(localizedPrefix.length);
+      const art = csn.definitions[artName];
+      if (def[annoPersistenceSkip] && !art?.[annoPersistenceSkip]) {
+        messageFunctions.message( 'anno-unexpected-localized-skip', ['definitions', defName], {
+          '#': 'view',
+          name: defName,
+          art: artName,
+          anno: annoPersistenceSkip
+        });
+      }
+    }
+  }
 }
 
 /**
@@ -740,7 +759,7 @@ function copyPersistenceAnnotations(target, source, options) {
     //   lead to some localization views referencing non-existing ones.
     //   But that is the contract: User says that it already exists!
     //   In v2, `.exists` was never copied.
-    if (anno === '@cds.persistence.skip' || (!doNotCopyExists && anno === '@cds.persistence.exists'))
+    if (anno === annoPersistenceSkip || (!doNotCopyExists && anno === '@cds.persistence.exists'))
       target[anno] = source[anno];
   });
 }

package/lib/transform/parseExpr.js

@@ -167,7 +167,7 @@ function parseExpr(xpr, state = { anno: 0, array: true, nary: false }) {
   function conditionTerm(xpr, s, e, state) {
     if(Array.isArray(xpr)) {
       if(xpr.length >= 3 && xpr[s+1] === 'is') {
-        const isnull = conditionOR(xpr[s], state);
+        const isnull = conditionOR(xpr[s], 0, 0, state);
         if(xpr[s+2] === 'null')
           return state.array ? [ isnull, 'is', 'null' ] :  { 'isNull': isnull };
         else if(xpr[s+2] === 'not' && xpr[s+3] === 'null')
@@ -253,12 +253,16 @@ function parseExpr(xpr, state = { anno: 0, array: true, nary: false }) {
   }
 
   function exprMulDiv(xpr, s, e, state) {
-    return binaryExpr(xpr, ['*', '/'], unary, s, e, state);
+    return binaryExpr(xpr, ['*', '/'], (state.array ? unary : dot), s, e, state);
+  }
+
+  function dot(xpr, s, e, state) {
+    return binaryExpr(xpr, ['.'], unary, s, e, state);
   }
 
   function unary(xpr, s, e, state) {
     if(Array.isArray(xpr)) {
-      if(xpr[s] === '+' || xpr[s] === '-') {
+      if(xpr[s] === '+' || xpr[s] === '-' || (!state.array && xpr[s] === 'new')) {
         return [ xpr[s], unary(xpr, s+1, e, state) ];
       }
     }

package/lib/transform/transformUtils.js

@@ -7,7 +7,7 @@
 const { makeMessageFunction } = require('../base/messages');
 const { setProp } = require('../base/model');
 
-const { copyAnnotations, applyTransformations } = require('../model/csnUtils');
+const { copyAnnotations, applyTransformations, isDollarSelfOrProjectionOperand } = require('../model/csnUtils');
 const { cloneCsnNonDict, cloneCsnDictionary, getUtils } = require('../model/csnUtils');
 const { typeParameters, isBuiltinType } = require('../compiler/builtins');
 const { ModelError, CompilerAssertion} = require('../base/error');
@@ -43,8 +43,6 @@ function getTransformers(model, options, pathDelimiter = '_') {
     flattenStructStepsInRef,
     toFinalBaseType,
     copyTypeProperties,
-    isAssociationOperand,
-    isDollarSelfOrProjectionOperand,
     createExposingProjection,
     createAndAddDraftAdminDataProjection,
     createScalarElement,
@@ -73,7 +71,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
    *
    * @param {CSN.Element} element
    * @param {null|object} [internalDefaultLengths] Either null (no implicit default) or an object `{ 'cds.String': N, 'cds.Binary': N }`.
-   * */
+   **/
   function addDefaultTypeFacets(element, internalDefaultLengths = null) {
     if (!element || !element.type)
       return;
@@ -121,7 +119,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
       }
     }
 
-    if (!options.forHana)
+    if (options.transformation === 'odata' || options.transformation === 'effective')
       copyAnnotations(assoc, foreignKeyElement, true);
 
     // If the association is non-fkArtifact resp. key, so should be the foreign key field
@@ -134,7 +132,8 @@ function getTransformers(model, options, pathDelimiter = '_') {
     // Establish the relationship between generated field and association:
     // - generated field has annotation '@odata.foreignKey4'.
     // - foreign key info has 'generatedFieldName'
-    foreignKeyElement['@odata.foreignKey4'] = assocName;
+    if(options.transformation !== 'effective')
+      foreignKeyElement['@odata.foreignKey4'] = assocName;
     foreignKey.$generatedFieldName = foreignKeyElementName;
     // attach $path to the newly created element - used for inspectRef in processAssociationOrComposition
     setProp(foreignKeyElement, '$path', path);
@@ -608,22 +607,6 @@ function getTransformers(model, options, pathDelimiter = '_') {
     return result;
   }
 
-  // Return true if 'arg' is an expression argument denoting "$self" || "$projection"
-  function isDollarSelfOrProjectionOperand(arg) {
-    return arg.ref && arg.ref.length === 1 && (arg.ref[0] === '$self' || arg.ref[0] === '$projection');
-  }
-
-  // Return true if 'arg' is an expression argument of type association or composition
-  function isAssociationOperand(arg, path) {
-    if (!arg.ref) {
-      // Not a path, hence not an association (literal, expression, function, whatever ...)
-      return false;
-    }
-    const { art } = inspectRef(path);
-    // If it has a target, it is an association or composition
-    return art && art.target !== undefined;
-  }
-
   // Create an artificial element 'elemName' of type 'cds.Association',
   // having association target 'target'. If 'isManaged' is true, take all keys
   // of 'target' as foreign keys.