@sap/cds-compiler 4.0.2 → 4.1.2

package/lib/base/messages.js

@@ -17,6 +17,7 @@ const { cdlNewLineRegEx } = require('../language/textUtils');
 const fs = require('fs');
 const path = require('path');
 const { inspect } = require('util')
+const { CsnLocation } = require('../compiler/classes');
 
 // term instance for messages
 const colorTerm = term();
@@ -94,7 +95,7 @@ class CompilationError extends Error {
     super( `CDS compilation failed\n${messages?.map( m => m.toString() ).join('\n') || ''}` );
     /** @since v4.0.0 */
     this.code = 'ERR_CDS_COMPILATION_FAILURE';
-    this.messages = messages;
+    this.messages = [ ...messages ].sort(compareMessageSeverityAware);
 
     // TODO: remove this bin/cdsc.js specifics
     Object.defineProperty( this, 'hasBeenReported', { value: false, configurable: true, writable: true, enumerable: false } );
@@ -128,7 +129,7 @@ class CompilationError extends Error {
 class CompileMessage {
   /**
    * Creates an instance of CompileMessage.
-   * @param {any} location Location of the message
+   * @param {CSN.Location} location Location of the message
    * @param {string} msg The message text
    * @param {MessageSeverity} [severity='Error'] Severity: Debug, Info, Warning, Error
    * @param {string} [id] The ID of the message - visible as property messageId
@@ -139,7 +140,7 @@ class CompileMessage {
    */
   constructor(location, msg, severity = 'Error', id = null, home = null, moduleName = null) {
     this.message = msg;
-    this.$location = { ...location, address: undefined };
+    this.$location = { __proto__: CsnLocation.prototype, ...location, address: undefined };
     this.validNames = null;
     this.home = home;  // semantic location, e.g. 'entity:"E"/element:"x"'
     this.severity = severity;
@@ -892,14 +893,14 @@ function replaceInString( text, params ) {
 }
 
 /**
- * @param {CSN.Location} loc
- * @returns {CSN.Location}
+ * @param {CsnLocation} loc
+ * @returns {CsnLocation}
  */
 function weakLocation( loc ) {
   if (!loc)
-    return {};
+    return new CsnLocation();
   // no endLine/endCol
-  return { file: loc.file, line: loc.line, col: loc.col };
+  return new CsnLocation( loc.file, loc.line, loc.col, undefined, undefined );
 }
 
 /**
@@ -1310,14 +1311,14 @@ function artName( art, omit ) {
   const r = (name.absolute) ? [ quoted( name.absolute ) ] : [];
   if (name.select && name.select > 1 || name.select != null && art.kind !== 'element') // Yes, omit select:1 for element - TODO: re-check
     r.push( (art.kind === 'extend' ? 'block:' : 'query:') + name.select ); // TODO: rename to 'select:1' and consider whether there are more selects
-  if (name.action && omit !== 'action')
+  if (name.action != null && omit !== 'action')
     r.push( `${ memberActionName(art) }:${ quoted( name.action ) }` );
-  if (name.alias && art.kind !== '$self' && name.$inferred !== '$internal')
+  if (name.alias != null && art.kind !== '$self' && name.$inferred !== '$internal')
     r.push( (art.kind === 'mixin' ? 'mixin:' : 'alias:') + quoted( name.alias ) );
   if (name.param != null && omit !== 'param')
     r.push( name.param ? `param:${ quoted( name.param ) }` : 'returns' ); // TODO: join
 
-  if (name.element && omit !== 'element') {
+  if (name.element != null && omit !== 'element') {
     if (name.select != null && !art.$inferred)
       r.push( 'column:' + quoted( name.element ) );
     else

package/lib/base/model.js

@@ -1,3 +1,8 @@
+// module- and csn/XSN-independent definitions
+
+// TODO: move XSN-specific things to lib/compiler/utils/
+// TODO: move CSN-specific things to ???
+
 'use strict';
 
 const { forEach } = require('../utils/objectUtils');
@@ -22,14 +27,13 @@ const queryOps = {
 const availableBetaFlags = {
   // enabled by --beta-mode
   annotationExpressions: true,
-  toRename: true, // Removes once it's publicly documented
   assocsWithParams: true, // beta, because runtimes don't support it, yet.
   hanaAssocRealCardinality: true,
   mapAssocToJoinCardinality: true, // only SAP HANA HEX engine supports it
   enableUniversalCsn: true,
-  aspectWithoutElements: true, // TODO: do not just remove beta flag - remove elements, too!
   odataTerms: true,
   optionalActionFunctionParameters: true, // not supported by runtime, yet.
+  associationDefault: true,
   // disabled by --beta-mode
   nestedServices: false,
 };

package/lib/checks/defaultValues.js

@@ -53,12 +53,12 @@ function rejectParamDefaultsInHanaCds( member, memberName, prop, path ) {
  */
 function warnAboutDefaultOnAssociationForHanaCds( member, memberName, prop, path ) {
   const art = this.csn.definitions[path[1]];
-  if (!art.query && !art.projection && this.options.transformation === 'hdbcds' && member.target && member.default) {
-    this.warning(null, path, { '#': member._type.type === 'cds.Association' ? 'std' : 'comp' },
-                 {
-                   std: 'Unexpected default defined on association',
-                   comp: 'Unexpected default defined on composition',
-                 });
+  if (this.options.transformation === 'hdbcds' && !art.query && !art.projection && member.target && member.default) {
+    const type = member._type?.type || member.type || 'cds.Association';
+    this.warning('type-invalid-default', path, { '#': type === 'cds.Association' ? 'std' : 'comp' }, {
+      std: 'Default on associations is not supported for HDBCDS',
+      comp: 'Default on compositions is not supported for HDBCDS',
+    });
   }
 }
 

package/lib/checks/foreignKeys.js

@@ -16,8 +16,6 @@ const { setProp } = require('../base/model');
 function validateForeignKeys( member, memberName ) {
   // We have a managed association
   const isManagedAssoc = mem => mem && mem.target && !mem.on;
-  // We have an unmanaged association
-  const isUnmanagedAssoc = mem => mem && mem.target && mem.on && !mem.keys;
 
   // Declared as arrow-function to keep scope the same (this value)
   const handleAssociation = (mem) => {
@@ -46,9 +44,6 @@ function validateForeignKeys( member, memberName ) {
     if (mem.items) {
       this.error(null, member.$path, {}, 'Array-like properties must not be foreign keys');
     }
-    else if (isUnmanagedAssoc(mem)) {
-      this.error(null, member.$path, {}, 'Unmanaged association must not be a foreign key');
-    }
     else if (mem.keys) {
       handleAssociation(mem);
     }

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,22 +159,26 @@ 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 }`.
@@ -195,7 +200,7 @@ function checkForeignKeyAccess( parent, refIndex, csnPath, callback ) {
       ++fkIndex;
     }
     if (!success)
-      callback(refIndex + fkIndex);
+      noForeignKeyCallback(refIndex + fkIndex);
   }
 }
 
@@ -211,4 +216,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,196 @@
 '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 || obj.$scope === 'alias')
     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 },
+    if (art.keys && !hasForeignKeys.call(this, art)) {
+      this.error(null, $path, { id: pathStep, elemref: { ref } },
                  'Path step $(ID) of $(ELEMREF) has no foreign keys');
+      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 +199,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/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
  *