@sap/cds-compiler 4.0.2 → 4.2.2

package/lib/checks/onConditions.js

@@ -2,6 +2,7 @@
 
 const { forEachGeneric } = require('../model/csnUtils');
 const { otherSideIsExpandableStructure, resolveArtifactType } = require('./utils');
+const { pathId } = require('../model/csnRefs');
 
 // Only to be used with validator.js - a correct this value needs to be provided!
 
@@ -93,7 +94,7 @@ function validateOnCondition( member, memberName, property, path ) {
             }
             else {
               // It's a managed association - access of the foreign keys is allowed
-              checkForeignKeyAccess(member.on[i], j, csnPath, (errorIndex) => {
+              requireForeignKeyAccess(member.on[i], j, (errorIndex) => {
                 this.error('ref-unexpected-navigation', csnPath, {
                   '#': 'std', id, elemref, name: ref[errorIndex].id || ref[errorIndex],
                 });
@@ -158,29 +159,36 @@ function validateOnCondition( member, memberName, property, path ) {
 
 /**
  * Ensure that only foreign keys of the association `parent.ref[refIndex]` are accessed in `parent.ref`.
- * If a non-fk field is accessed, `callback` is invoked.
+ * If a non-fk field is accessed, `noForeignKeyCallback` is invoked.
  *
- * @param {object} parent Object containing `ref` and `_links` from csnRefs.
- * @param {number} refIndex Index of the to-be-checked association in `parent.ref`
- * @param {CSN.Path} csnPath
- * @param {(errorIndex: number) => void} callback Called if there are non-fk path steps. Argument is index in
- *          `parent.ref` that is faulty.  If a fk-step is missing, `errorIndex` will be `> parent.ref.length`.
+ * @param {object} parent
+ *     Object containing `ref` and `_links` from csnRefs.
+ *
+ * @param {number} refIndex
+ *     Index of the to-be-checked association in `parent.ref`
+ *
+ * @param {(errorIndex: number) => void} noForeignKeyCallback
+ *     Called if there are non-fk path steps.  Argument is index in `parent.ref` that is faulty.
+ *     If a fk-step is missing, `errorIndex` will be `> parent.ref.length`.
  */
-function checkForeignKeyAccess( parent, refIndex, csnPath, callback ) {
+function requireForeignKeyAccess( parent, refIndex, noForeignKeyCallback ) {
   const { ref, _links } = parent;
   const assoc = _links[refIndex].art;
 
-  const next = ref[refIndex + 1].id || ref[refIndex + 1];
+  const next = pathId(ref[refIndex + 1]);
   let possibleKeys = next && assoc.keys.filter(r => r.ref[0] === next);
   if (!possibleKeys || possibleKeys.length === 0) {
-    callback(refIndex + 1);
+    noForeignKeyCallback(refIndex + 1);
   }
   else {
     // For cases where `Association to T { struct.one, struct.two };` is used instead of `{ struct }`.
-    // Note: We know that `{ struct, struct.one }` is not possible, so no prefix check required.
+    // We know that `{ struct, struct.one }` is not possible, so no prefix check required.
+    // If `ref.length` does not cover any full foreign key, then we call noForeignKeyCallback()
+    // as well.  This could happen for `struct.one` as foreign key, and `assoc.struct = …`
+    // in ON-condition.
     let fkIndex = 0;
     let success = false;
-    while (!success && possibleKeys.length > 0) {
+    while (!success && possibleKeys.length > 0 && refIndex + fkIndex + 1 < ref.length) {
       const pathStep = ref[refIndex + fkIndex + 1].id || ref[refIndex + fkIndex + 1];
 
       // Function is immediately executed, before next iteration of loop. Access is fine.
@@ -195,7 +203,7 @@ function checkForeignKeyAccess( parent, refIndex, csnPath, callback ) {
       ++fkIndex;
     }
     if (!success)
-      callback(refIndex + fkIndex);
+      noForeignKeyCallback(refIndex + fkIndex);
   }
 }
 
@@ -211,4 +219,4 @@ function validateMixinOnCondition( query, path ) {
     forEachGeneric( query.SELECT, 'mixin', validateOnCondition.bind(this), path );
 }
 
-module.exports = { validateOnCondition, validateMixinOnCondition, checkForeignKeyAccess };
+module.exports = { validateOnCondition, validateMixinOnCondition, requireForeignKeyAccess };

package/lib/checks/queryNoDbArtifacts.js

@@ -1,136 +1,195 @@
 'use strict';
 
 const { hasAnnotationValue, isPersistedOnDatabase, isBuiltinType } = require('../model/csnUtils');
+const { requireForeignKeyAccess } = require('./onConditions');
+const { pathId } = require('../model/csnRefs');
+
+const generalQueryProperties = [ 'from', 'columns', 'where', 'groupBy', 'orderBy', 'having', 'limit' ];
+
 /**
- * Make sure that all source artifacts and association targets reach the database
- * (otherwise the view can't be activated), but only if the source artifact is NOT activated against the database // <- what does this mean?
+ * Ensure that all source artifacts and association targets are persisted on the database.
+ * Otherwise, we would end up with a JOIN against a non-existent table.
  *
  * Check the given query for:
- * - Associations-traversal over skipped/abstract things
+ * - Association-traversal over skipped/abstract things
  * - Associations (indirectly) using managed associations without foreign keys
  *
  * Currently checked:
- * - "columns" for something like toF.id, where F is skipped. But publishing toF is fine, will be ignored later on
+ * - "columns" for something like toF.field, where F is skipped. But publishing toF is fine, will be ignored later on
  * - "from" for something like "select from E.toF" where E, F or E AND F are no-db.
  *
- *
  * @param {CSN.Query} query Query to check
  */
 function checkQueryForNoDBArtifacts( query ) {
   if (isPersistedOnDatabase(this.artifact) && !hasAnnotationValue(this.artifact, '@cds.persistence.table')) {
-    const generalQueryProperties = [ 'from', 'columns', 'where', 'groupBy', 'orderBy', 'having', 'limit' ];
     for (const prop of generalQueryProperties) {
       const queryPart = (query.SELECT || query.SET)[prop];
       if (Array.isArray(queryPart)) {
         for (const part of queryPart)
-          checkRef.call(this, part, prop === 'columns');
+          checkQueryRef.call(this, part, prop === 'columns');
       }
       else if (typeof queryPart === 'object') {
-        checkRef.call(this, queryPart, prop === 'columns');
+        checkQueryRef.call(this, queryPart, prop === 'columns');
       }
     }
   }
 }
 
 /**
- * Count the leaf-elements resulting from a given element.
+ * @param {CSN.Element} assoc Definition to check
+ * @returns {boolean} True, if there are any foreign keys.
+ */
+function hasForeignKeys( assoc ) {
+  if (!assoc || !assoc.keys)
+    return false;
+  return _hasForeignKeyOrElements.call(this, assoc);
+}
+
+/**
+ * Returns true if the given definition has at least one foreign key or element leaf node.
  *
- * @param {CSN.Element} def Definition to check
- * @returns {number} Number of leaf elements
+ * @param {CSN.Artifact} def
+ * @returns {boolean} True if there are FKs/element leaves.
  */
-function leafCount( def ) {
-  let c = 0;
-  if (!def)
-    return c;
-  if (def.elements) {
-    c += Object.values(def.elements).reduce((acc, e) => {
-      acc += leafCount.call(this, e);
-      return acc;
-    }, 0);
+function _hasForeignKeyOrElements( def ) {
+  if (!def) {
+    return false;
   }
   else if (def.keys) {
-    c += def.keys.reduce((acc, e) => {
-      acc += leafCount.call(this, e._art);
-      return acc;
-    }, 0);
+    return def.keys.some(e => _hasForeignKeyOrElements.call(this, e._art));
+  }
+  else if (def.elements) {
+    return Object.values(def.elements).some( e => _hasForeignKeyOrElements.call(this, e));
   }
   else if (def.type) {
     if (isBuiltinType(def.type) && !(def.target))
-      return 1;
-    c += leafCount.call(this, this.csn.definitions[def.type]);
+      return true;
+    return _hasForeignKeyOrElements.call(this, this.artifactRef(def.type, null));
   }
-  return c;
+  return false;
 }
 
 /**
- * Check the given ref for usage of skipped/abstract assoc targets
+ * Check the given `obj.ref` for usage of skipped/abstract assoc targets
  *
- * @param {object} obj CSN "thing" to check
+ * @param {CSN.Column} obj CSN "thing" to check
  * @param {boolean} inColumns True if the ref is part of a from
  */
-function checkRef( obj, inColumns ) {
-  if (!(obj && obj.ref) || !obj._links || obj.$scope === 'alias')
+function checkQueryRef( obj, inColumns ) {
+  if (!obj)
     return;
 
-  const links = obj._links;
+  if (obj.expand || obj.inline)
+    _checkExpandInline.call(this, obj);
+
+  else if (obj.ref && obj._links)
+    _checkRef.call(this, obj.ref, obj._links, obj.$path, inColumns);
+}
+
+/**
+ * Run _checkRef on all expand/inline structure leaf nodes.
+ * We do so by creating artificial paths that follow expand/inline nodes to their leaves.
+ *
+ * @param {CSN.Column} obj
+ * @param {CSN.Path} previousRefs
+ * @param {object[]} previousLinks
+ */
+function _checkExpandInline( obj, previousRefs = [], previousLinks = [] ) {
+  if (obj.ref && obj._links) { // There could be anonymous nested "expand".
+    previousRefs = previousRefs.concat(obj.ref);
+    previousLinks = previousLinks.concat(obj._links);
+  }
+
+  if (!obj.expand && !obj.inline) {
+    if (obj.ref && obj._links) {
+      // `inColumns: true` for expand/inline
+      _checkRef.call(this, previousRefs, previousLinks, obj.$path, true);
+    }
+    return;
+  }
+
+  for (const col of obj.expand || obj.inline)
+    _checkExpandInline.call(this, col, previousRefs, previousLinks);
+}
+
+/**
+ * Implementation of checkQueryRef() that works on ref/links arrays instead of a column.
+ *
+ * @param {CSN.Path} ref
+ * @param {object[]} _links
+ * @param {CSN.Path} $path
+ * @param {boolean} inColumns
+ */
+function _checkRef( ref, _links, $path, inColumns ) {
+  if (!ref || !_links )
+    return;
+
+  let nonPersistedTarget = null;
+  const isPublishedAssoc = this.csnUtils.isAssocOrComposition(_links[_links.length - 1].art);
 
   // Don't check the last element - to allow association publishing in columns
-  for (let i = 0; i < (inColumns ? links.length - 1 : links.length); i++) {
-    const link = links[i];
+  for (let i = 0; i < (inColumns ? _links.length - 1 : _links.length); i++) {
+    const link = _links[i];
     if (!link)
       continue;
-
     const { art } = link;
     if (!art)
       continue;
 
-    const endArtifact = art.target ? this.csn.definitions[art.target] : art;
-    const pathStep = obj.ref[i].id ? obj.ref[i].id : obj.ref[i];
-    const name = art.target ? art.target : pathStep;
-    if (!isPersistedOnDatabase(endArtifact)) {
-      const nextElement = obj.ref[i + 1];
-      /**
-       * if we only navigate to foreign keys of the managed association in a view, we do not need to join,
-       * thus we can produce the view even if the target of the association is not persisted
-       *
-       * @param {CSN.Element} assoc association in ref
-       * @param {string} nextStep the ref step following the association
-       * @returns {boolean} true if no join will be generated
-       */
-      const isJoinRelevant = (assoc, nextStep) => {
-        if (!assoc.keys)
-          return true;
-        const isExposedColumnAssocOrComposition = this.csnUtils.isAssocOrComposition(obj._art.type);
-        return !assoc.keys
-          .some(fk => fk.ref[0] === nextStep && !isExposedColumnAssocOrComposition);
-      };
-      if (isJoinRelevant(art, nextElement)) {
-        const cdsPersistenceSkipped = hasAnnotationValue(endArtifact, '@cds.persistence.skip');
-        this.error( null, obj.$path, {
-          id: pathStep, elemref: obj, name, '#': cdsPersistenceSkipped ? 'std' : 'abstract',
+    const isLast = i >= _links.length - 1;
+    const isUnmanagedOrNoKeys = !art.keys;
+    const targetArt = art.target ? this.artifactRef(art.target) : art;
+    const pathStep = pathId(ref[i]);
+    const name = art.target || pathStep;
+
+    // If any path-step is not persisted, then all following path steps must only access foreign keys.
+    // For example, it could be toF.toG.field, where toG is FK of toF; the FK-only-check would succeed,
+    // but we only check "field" in the next iteration, where it is seen as access on a non-skipped
+    // entity, hence the need to store if any target is skipped.
+    if (!isPersistedOnDatabase(targetArt))
+      nonPersistedTarget = { name, pathStep };
+
+    if (nonPersistedTarget) {
+      let isJoinRelevant = isPublishedAssoc || // publishing associations is always join relevant
+        isLast || // e.g. FROM targets are always join relevant.
+        isUnmanagedOrNoKeys; // unmanaged associations are always join relevant -> no FKs
+
+      if (!isJoinRelevant) {
+        // for managed, published associations with more than one $path-step, only FK
+        // access is allowed.
+        requireForeignKeyAccess({ ref, _links }, i, () => {
+          isJoinRelevant = true;
+        });
+      }
+
+      if (isJoinRelevant) {
+        const cdsPersistenceSkipped = hasAnnotationValue(targetArt, '@cds.persistence.skip');
+        this.error( null, $path, {
+          '#': cdsPersistenceSkipped ? 'std' : 'abstract',
+          id: nonPersistedTarget.pathStep,
+          elemref: { ref },
+          name: nonPersistedTarget.name,
         }, {
           std: 'Unexpected “@cds.persistence.skip” annotation on association target $(NAME) of $(ID) in path $(ELEMREF)',
           abstract: 'Unexpected “abstract” association target $(NAME) of $(ID) in path $(ELEMREF)',
         } );
+        break; // only one error per path
       }
     }
+
     // check managed association to have foreign keys array filled
-    if (art.keys && leafCount.call(this, art) === 0) {
-      this.error(null,
-                 obj.$path,
-                 { id: pathStep, elemref: obj },
-                 'Path step $(ID) of $(ELEMREF) has no foreign keys');
+    if (art.keys && !hasForeignKeys.call(this, art)) {
+      this.error('expr-missing-foreign-key', $path, { id: pathStep, elemref: { ref } } );
+      break; // only one error per path
     }
-
-    if (art.on) {
-      for (let j = 0; j < art.on.length; j++) {
-        if (j < art.on.length - 2 && art.on[j].ref && art.on[j + 1] === '=' && art.on[j + 2].ref) {
+    else if (art.on) {
+      for (let j = 0; j < art.on.length - 2; j++) {
+        if (art.on[j].ref && art.on[j + 1] === '=' && art.on[j + 2].ref) {
           const [ fwdAssoc, fwdPath ] = getForwardAssociation(pathStep, art.on[j], art.on[j + 2]);
-          if (fwdAssoc && fwdAssoc.keys && leafCount.call(this, fwdAssoc) === 0) {
-            this.error(null, obj.$path,
-                       { name: pathStep, elemref: obj, id: fwdPath },
+          if (fwdAssoc?.keys && !hasForeignKeys.call(this, fwdAssoc)) {
+            this.error(null, $path, { name: pathStep, elemref: { ref }, id: fwdPath },
                        'Path step $(NAME) of $(ELEMREF) is a $self comparison with $(ID) that has no foreign keys');
-            j += 2;
+            break; // only one error per path
           }
         }
       }
@@ -139,7 +198,7 @@ function checkRef( obj, inColumns ) {
 }
 
 /**
- * Get the forward association from a backling $self association.
+ * Get the forward association from a backlink $self association.
  *
  * @param {string} prefix Name of the association
  * @param {object} lhs Left hand side of the on-condition part

package/lib/checks/selectItems.js

@@ -5,10 +5,12 @@ const { forEachGeneric, applyTransformationsOnNonDictionary } = require('../mode
 // Only to be used with validator.js - a correct this value needs to be provided!
 
 /**
- * Validate select items of a query. If a column reference starts with $self or $projection, it must not contain association steps.
+ * Validate select items of a query. If a column reference starts with $self or
+ * $projection, it must not contain association steps.
  * Furthermore, for to.hdbcds, window functions are not allowed.
  *
- * For to.hdbcds-hdbcds, structures and managed associations are not allowed as they are not flattened - @see rejectManagedAssociationsAndStructuresForHdbcdsNames
+ * For to.hdbcds-hdbcds, structures and managed associations are not allowed
+ * as they are not flattened - @see rejectManagedAssociationsAndStructuresForHdbcdsNames
  *
  * @param {CSN.Query} query query object
  * @todo Why do we care about this with $self?
@@ -17,58 +19,6 @@ function validateSelectItems( query ) {
   const { SELECT } = query;
   if (!SELECT)
     return;
-  /**
-   * Check for a $self.<assoc> in columns etc. - since the $self.<assoc> references the "outside" view
-   * of the association, this is not allowed.
-   *
-   * @param {string} queryPart Part of the query that is being checked
-   * @returns {Function} Function as callback for applyTransformations
-   */
-  function checkRefForInvalid$Self( queryPart ) {
-    const signalError = (error, parent, type) => {
-      if (queryPart === 'columns') {
-        error(null, parent.$path,
-              { name: parent.ref[0], type },
-              'Select items starting with $(NAME) must not contain path steps of type $(TYPE)');
-      }
-      else if (queryPart === 'orderBy') {
-        error(null, parent.$path,
-              { id: queryPart, type },
-              'Items of the $(ID)-clause must not contain path steps of type $(TYPE)');
-      }
-      else {
-        error(null, parent.$path,
-              { id: queryPart, name: parent.ref[0], type },
-              'Items of the $(ID)-clause starting with $(NAME) must not contain path steps of type $(TYPE)');
-      }
-    };
-    return function checkForInvalid$SelfInRef(parent) {
-      if (parent.ref && (parent.$scope === '$self' || parent.$scope === '$query')) {
-        const { _links } = parent;
-        for (let j = parent.$scope === '$self' ? 1 : 0; j < _links.length - 1; j++) {
-          if (_links[j].art.target) {
-            if (_links[j].art.on) {
-              // It's an unmanaged association - traversal is always forbidden
-              signalError(this.error, parent, _links[j].art.type);
-            }
-            else {
-              // It's a managed association - access of the foreign keys is allowed
-              const nextRef = parent.ref[j + 1].id || parent.ref[j + 1];
-              if (!_links[j].art.keys.some(r => r.ref[0] === nextRef))
-                signalError(this.error, parent, _links[j].art.type);
-            }
-          }
-        }
-
-        const last = _links[_links.length - 1];
-
-        if (last.art.target && last.art.on) {
-          // It's an unmanaged association - traversal is always forbidden
-          signalError(this.error, parent, last.art.type);
-        } // managed is okay, can be handled via tuple expansion
-      }
-    };
-  }
 
   /**
    * Check the given assoc filter for usage of $self - in an assoc-filter, you must only
@@ -90,7 +40,6 @@ function validateSelectItems( query ) {
 
   const aTCB = (parent, prop) => {
     applyTransformationsOnNonDictionary(parent, prop, {
-      ref: checkRefForInvalid$Self(prop).bind(this),
       where: checkFilterForInvalid$Self.bind(this),
     }, { skipStandard: { on: true }, drillRef: true });
   };

package/lib/checks/sql-snippets.js

@@ -18,14 +18,25 @@ function checkSqlAnnotationOnElement( member, memberName, prop, path ) {
     this.message('anno-invalid-sql-element', path, { anno: 'sql.prepend' }, 'Annotation $(ANNO) can\'t be used on elements' );
 
   if (member['@sql.append']) {
-    if (this.artifact.query || this.artifact.projection)
+    if (this.artifact.query || this.artifact.projection) {
       this.message('anno-invalid-sql-view-element', path, { anno: 'sql.append' }, 'Annotation $(ANNO) can\'t be used on elements in views' );
-    else if (this.csnUtils.isStructured(member))
+    }
+    else if (this.csnUtils.isStructured(member)) {
       this.message('anno-invalid-sql-struct', path, { anno: 'sql.append' }, 'Annotation $(ANNO) can\'t be used on structured elements' );
-    else if (member.value && !member.value.stored)
+    }
+    else if (this.csnUtils.isManagedAssociation(member)) {
+      this.message('anno-invalid-sql-assoc', path, { anno: 'sql.append', '#': member.type }, {
+        std: 'Annotation $(ANNO) can\'t be used here',
+        'cds.Association': 'Annotation $(ANNO) can\'t be used on association elements',
+        'cds.Composition': 'Annotation $(ANNO) can\'t be used on composition elements',
+      } );
+    }
+    else if (member.value && !member.value.stored) {
       this.message('anno-invalid-sql-calc', path, { anno: 'sql.append' }, 'Annotation $(ANNO) can\'t be used on calculated elements on read' );
-    else
+    }
+    else {
       checkValidAnnoValue(member, '@sql.append', path, this.error, this.options);
+    }
   }
 }
 

package/lib/checks/types.js

@@ -162,9 +162,9 @@ function errorAboutMissingType( error, path, artifact, name,
   let variant = isElement ? 'elm' : 'std';
   if (artifact.value?.stored)
     variant = 'calc';
-  error('check-proper-type', path, { art: name, '#': variant }, {
-    std: 'Dubious type $(ART) without type information',
-    elm: 'Dubious element $(ART) without type information',
+  error('def-missing-type', path, { art: name, '#': variant }, {
+    std: 'Missing type for $(ART)',
+    elm: 'Missing type for element $(ART)',
     calc: 'A stored calculated element must have a type',
   });
 }

package/lib/checks/utils.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { isBuiltinType } = require('../model/csnUtils');
-const { RelationalOperators } = require('../transform/transformUtilsNew');
+const { RelationalOperators } = require('../transform/transformUtils');
 /**
  * Prepare the ref steps so that they are loggable
  *
@@ -58,8 +58,9 @@ function otherSideIsExpandableStructure( on, startIndex ) {
  * @returns {object} final artifact type
  */
 function resolveArtifactType( art ) {
-  if (art && art.type && !isBuiltinType(art.type))
-    return this.csnUtils.getFinalTypeInfo(art.type);
+  const type = art?._type?.type || art?.type;
+  if (type && !isBuiltinType(type))
+    return this.csnUtils.getFinalTypeInfo(type);
 
   return art;
 }

package/lib/checks/validator.js

@@ -11,6 +11,7 @@ const enrich = require('./enricher');
 const { validateSelectItems } = require('./selectItems');
 const { rejectParamDefaultsInHanaCds, warnAboutDefaultOnAssociationForHanaCds } = require('./defaultValues');
 const validateCdsPersistenceAnnotation = require('./cdsPersistence');
+const navigationIntoMany = require('./manyNavigations');
 const checkUsedTypesForAnonymousAspectComposition = require('./managedInType');
 const validateHasPersistedElements = require('./hasPersistedElements');
 const checkForHanaTypes = require('./checkForTypes');
@@ -71,7 +72,7 @@ const forRelationalDBArtifactValidators
   checkSqlAnnotationOnArtifact,
 ];
 
-const forRelationalDBCsnValidators = [ nonexpandableStructuredInExpression ];
+const forRelationalDBCsnValidators = [ nonexpandableStructuredInExpression, navigationIntoMany ];
 /**
  * @type {Array<(query: CSN.Query, path: CSN.Path) => void>}
  */
@@ -233,6 +234,7 @@ function forRelationalDB( csn, that ) {
                    {
                      skipArtifact: artifact => artifact.abstract ||
                                                 hasAnnotationValue(artifact, '@cds.persistence.skip') ||
+                                                hasAnnotationValue(artifact, '@cds.persistence.exists') ||
                                                 [ 'action', 'function', 'event' ].includes(artifact.kind),
                    });
 }

package/lib/compiler/.eslintrc.json

@@ -2,6 +2,7 @@
   "root": true,
   "extends": "../../.eslintrc-ydkjsi.json",
   "rules": {
-    "cds-compiler/message-no-quotes": "warn"
+    "cds-compiler/message-no-quotes": "warn",
+    "cds-compiler/space-in-func-call": "warn"
   }
 }