@sap/cds-compiler 4.6.0 → 4.7.4

package/lib/checks/elements.js

@@ -109,29 +109,97 @@ function checkVirtualElement( member ) {
 }
 
 /**
- * Checks whether managed associations
- * with cardinality 'to many' have an on-condition.
+ * Checks whether managed associations with cardinality 'to many' have no ON-condition.
+ * If there isn't, and if _all_ key elements on the target side are covered by the foreign key,
+ * then the association is effectively to-one -> warning.
  *
  * @param {CSN.Artifact} member The member (e.g. element artifact)
  */
 function checkManagedAssoc( member ) {
   if (!member.target || isManagedComposition.bind(this)(member))
     return;
-
   // Implementation note:  Imported services (i.e. external ones) may contain to-many associations
   // with an empty foreign key list.  If the user (in this case importer) explicitly sets an empty
   // foreign key array, we won't emit a warning to avoid spamming the user.
-  const max = member.cardinality?.max ? member.cardinality.max : 1;
-  if (max !== 1 && !member.on && (!member.keys || member.keys.length > 0)) {
-    const isNoDb = this.artifact['@cds.persistence.skip'] || this.artifact['@cds.persistence.exists'];
-    this.warning(isNoDb ? 'to-many-no-on-noDB' : 'to-many-no-on', member.cardinality ? member.cardinality.$path : member.$path, {
-      value: cardinality2str(member, false),
-      '#': this.csnUtils.isComposition(member) ? 'comp' : 'std',
-    }, {
-      std: 'Expected association with target cardinality $(VALUE) to have an ON-condition',
-      comp: 'Expected composition with target cardinality $(VALUE) to have an ON-condition',
-    });
+  const max = member.cardinality?.max ?? 1;
+  if (max === 1 || member.on || !member.keys || member.keys.length === 0)
+    return;
+  // We use the fact that `key` is only supported top-level (warning otherwise).
+  // And if an element of a structured _type_ is "key", we get a warning for the key.
+  // However, we may get false negatives for our warning, which is acceptable, e.g. for
+  // `type T : { key i: String; }; entity A { id : T; };` with `… to many A { id };`
+  const target = typeof member.target === 'object' ? member.target : this.csnUtils.getCsnDef(member.target);
+  const targetKeys = Object.entries(target.elements || {}).filter(elem => !!elem[1].key);
+  const foreignKeys = structurizeForeignKeys(member.keys);
+  if (!coversAllTargetKeys.call(this, foreignKeys, targetKeys))
+    return; // foreign key does not cover at least one target key -> can be to-many
+
+  const isNoDb = this.artifact['@cds.persistence.skip'] || this.artifact['@cds.persistence.exists'];
+  this.warning(isNoDb ? 'to-many-no-on-noDB' : 'to-many-no-on', member.cardinality?.$path || member.$path, {
+    value: cardinality2str(member, false),
+    '#': this.csnUtils.isComposition(member) ? 'comp' : 'std',
+  }, {
+    std: 'Expected association with target cardinality $(VALUE) to have an ON-condition',
+    comp: 'Expected composition with target cardinality $(VALUE) to have an ON-condition',
+  });
+}
+
+/**
+ * Returns true if the foreign keys cover _all_ of the target keys.
+ * Returns false otherwise.
+ *
+ * @see checkManagedAssoc()
+ *
+ * @param {object} foreignKeys Structure returned by `structurizeForeignKeys()`.
+ * @param {Array} targetKeys Object.entries() value of target keys.
+ * @returns {boolean} Whether all target keys are covered
+ */
+function coversAllTargetKeys( foreignKeys, targetKeys ) {
+  if (foreignKeys.length < targetKeys.length || targetKeys.length === 0) {
+    // there are fewer foreign keys than keys on the target side
+    // or there are no keys on the target side, in which case there is no
+    // possibility to cover all keys.
+    return false;
+  }
+
+  for (const [ targetKeyName, targetKey ] of targetKeys) {
+    const foreignKey = foreignKeys.entries[targetKeyName];
+    if (!foreignKey)
+      return false; // foreign key does not cover this target key
+    if (foreignKey.length > 0) { // foreign key only selects sub-structures, not whole structured key
+      const elements = targetKey.elements || this.csnUtils.getFinalTypeInfo(targetKey.type)?.elements;
+      if (!elements)
+        return false; // model error (e.g. 'many type')
+      if (!coversAllTargetKeys( foreignKey, Object.entries(elements) ))
+        return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * Structurizes a foreign key into an object that can be used to compare foreign
+ * keys against their corresponding keys on target side.
+ *
+ * For `Association to T { a.b, a.c, b }` this structure will be returned:
+ *  `{ length: 2, entries: { a: { length: 2, entries: { b: { length: 0, … }, …} } }}`
+ *
+ * @param {object[]} keys Foreign key array.
+ * @returns {object} Structured foreign key. Custom format, i.e. not via `elements`.
+ */
+function structurizeForeignKeys( keys ) {
+  const map = { entries: Object.create(null), length: 0 };
+  for (const key of keys) {
+    let entry = map;
+    for (const step of key.ref) {
+      if (!entry.entries[step]) {
+        entry.entries[step] = { entries: Object.create(null), length: 0 };
+        ++entry.length;
+      }
+      entry = entry.entries[step];
+    }
   }
+  return map;
 }
 
 /**

package/lib/checks/enricher.js

@@ -85,6 +85,7 @@ function enrichCsn( csn, options ) {
     csnPath.pop();
   }
 
+
   /**
    * Transformer for things that are annotations. When we have a "=" plus an expression of some sorts,
    * we treat it like a "standard" thing.
@@ -94,7 +95,7 @@ function enrichCsn( csn, options ) {
    * @param {object} node The value of node[_prop]
    */
   function annotation( _parent, _prop, node ) {
-    if (options.processAnnotations) {
+    if (options.enrichAnnotations) {
       if (node?.['='] !== undefined && xprInAnnoProperties.some(xProp => node[xProp] !== undefined)) {
         standard(_parent, _prop, node);
       }
@@ -212,5 +213,5 @@ module.exports = enrichCsn;
 
 /**
  * @typedef {object} enrichCsnOptions
- * @property {boolean} [processAnnotations=false] Wether to process annotations and call custom transformers on them
+ * @property {boolean} [enrichAnnotations=false] Wether to process annotations and call custom transformers on them
  */

package/lib/checks/validator.js

@@ -5,7 +5,7 @@ const {
   forEachMember, getNormalizedQuery, hasAnnotationValue,
   applyTransformations, functionList,
 } = require('../model/csnUtils');
-const enrich = require('./enricher');
+const enrichCsn = require('./enricher');
 
 // forRelationalDB
 const { validateSelectItems } = require('./selectItems');
@@ -48,6 +48,7 @@ const {
   checkSqlAnnotationOnArtifact,
   checkSqlAnnotationOnElement,
 } = require('./sql-snippets');
+const dbFeatureFlags = require('./dbFeatureFlags');
 
 const forRelationalDBMemberValidators
 = [
@@ -65,8 +66,7 @@ const forRelationalDBMemberValidators
   checkElementTypeDefinitionHasType,
 ];
 
-const forRelationalDBArtifactValidators
-= [
+const forRelationalDBArtifactValidators = [
   checkPrimaryKey,
   // @cds.persistence has no impact on odata
   validateCdsPersistenceAnnotation,
@@ -74,6 +74,8 @@ const forRelationalDBArtifactValidators
   validateHasPersistedElements,
   // sql.prepend/append
   checkSqlAnnotationOnArtifact,
+  // strip down CSN to reduce it's size by removing non-sql relevant parts
+  stripNonDbRelevant,
 ];
 
 const forRelationalDBCsnValidators = [
@@ -82,6 +84,7 @@ const forRelationalDBCsnValidators = [
   nonexpandableStructuredInExpression,
   navigationIntoMany,
   checkPathsInStoredCalcElement,
+  dbFeatureFlags,
 ];
 /**
  * @type {Array<(query: CSN.Query, path: CSN.Path) => void>}
@@ -149,7 +152,9 @@ function _validate( csn, that,
                     artifactValidators = [],
                     queryValidators = [],
                     iterateOptions = {} ) {
-  const { cleanup } = enrich(csn, { processAnnotations: that.options.tranformation === 'odata' });
+  const { cleanup } = enrichCsn(csn, that.options);
+  // TODO: Don't know if that's feasible? Do we really need to enrich annotations always?
+  // const { cleanup } = enrich(csn, { processAnnotations: that.options.tranformation === 'odata' });
 
   applyTransformations(csn, mergeCsnValidators(csnValidators, that), [], { drillRef: true });
 
@@ -277,4 +282,33 @@ function forOdata( csn, that ) {
                    });
 }
 
+const dbRelevantKinds = {
+  entity: true,
+  type: true,
+  aspect: true,
+  service: true,
+  context: true,
+};
+
+/**
+ * Shrink the CSN by
+ * - deleting bound actions
+ * - turning all non-entity/type/aspect/service/context entities into dummies
+ *
+ * @param {CSN.Artifact} artifact
+ * @param {string} artifactName
+ */
+function stripNonDbRelevant( artifact, artifactName ) {
+  if (this.options.transformation !== 'effective') {
+    if ( !dbRelevantKinds[artifact.kind] ) {
+      this.csn.definitions[artifactName] = {
+        kind: 'action',
+      };
+    }
+    else if (artifact.actions) {
+      delete artifact.actions;
+    }
+  }
+}
+
 module.exports = { forRelationalDB, forOdata };

package/lib/compiler/assert-consistency.js

@@ -364,7 +364,7 @@ function assertConsistency( model, stage ) {
       optional: [
         'path', 'elements', '_outer', '_parent', '_main', '_block', 'kind',
         'scope', '_artifact', '$inferred', '$expand', '$inCycle', '$tableAliases', '_$next',
-        '_origin', '_effectiveType', '$effectiveSeqNo', '_extensions',
+        '_origin', '_effectiveType', '$effectiveSeqNo', '_extensions', '$contains',
       ],
     },
     target: {
@@ -463,7 +463,7 @@ function assertConsistency( model, stage ) {
           ...typeProperties,    // for CAST
         ],
       },
-      query: { requires: [ 'query', 'location' ], optional: [ 'stored' ] },
+      query: { requires: [ 'query', 'location' ], optional: [ 'stored', '$parens' ] },
     },
     literal: {                  // TODO: check value against literal
       test: isString,
@@ -481,7 +481,7 @@ function assertConsistency( model, stage ) {
         'literal', 'val', 'sym', 'struct', 'variant', 'path', 'name', '$duplicates', 'upTo',
         // expressions as annotation values
         '$tokenTexts', 'op', 'args', 'func', '_artifact', 'type', '$typeArgs',
-        'scale', 'srid', 'length', 'precision',
+        'scale', 'srid', 'length', 'precision', 'scope',
       ],
       // TODO: restrict path to #simplePath
     },
@@ -490,7 +490,7 @@ function assertConsistency( model, stage ) {
     args: {
       inherits: 'value',
       optional: [
-        'name', '$duplicate', '$expected', 'args', 'suffix',
+        'name', '$duplicate', '$expected', 'args', 'suffix', '$parens',
         'param', 'scope', // for dynamic parameter '?'
       ],
       test: args,

package/lib/compiler/checks.js

@@ -591,10 +591,11 @@ function check( model ) {
    *
    * @param {any} xpr The expression to check
    * @param {XSN.Artifact} user User for semantic location
-   * @returns {void}
+   * @param {string} [context] where the expression is used, e.g. 'anno'
    */
-  function checkGenericExpression( xpr, user ) {
-    checkExpressionNotVirtual( xpr, user );
+  function checkGenericExpression( xpr, user, context ) {
+    if (context !== 'anno')
+      checkExpressionNotVirtual( xpr, user );
     checkExpressionAssociationUsage( xpr, user, false );
     if (xpr.op?.val === 'cast') {
       requireExplicitTypeInSqlCast( xpr, user );
@@ -903,7 +904,7 @@ function check( model ) {
    */
   function checkAnnotationExpressions( anno, art ) {
     if (anno.$tokenTexts) {
-      checkGenericExpression( anno, art );
+      checkGenericExpression( anno, art, 'anno' );
     }
     else if (anno.literal === 'array') {
       anno.val.forEach( val => checkAnnotationExpressions( val, art ) );

package/lib/compiler/define.js

@@ -946,8 +946,8 @@ function define( model ) {
 
     if (hasItems && !wildcard && parent.excludingDict && !options.$recompile) {
       // TODO: the SQL backend should probably delete `excluding` when expanding `*`
-      // TODO: use `parent` for semantic location, use `-excluding`
-      warning( 'query-ignoring-exclude', [ parent.excludingDict[$location], user ],
+      // TODO: use `parent` for semantic location; requires `_parent`/... links.
+      warning( 'query-ignoring-excluding', [ parent.excludingDict[$location], user ],
                { prop: '*' },
                'Excluding elements without wildcard $(PROP) has no effect' );
     }

package/lib/compiler/generate.js

@@ -782,7 +782,7 @@ function generate( model ) {
   }
 
   /**
-   * Copy the annotations `@cds.persistence.skip`/`@cds.persistence.exists` from
+   * Copy relevant annotations from
    * source to target if present on source but not target.
    *
    * @param {object} target
@@ -796,6 +796,7 @@ function generate( model ) {
     if (copyExists)
       copy( '@cds.persistence.exists' );
     copy( '@cds.persistence.skip' );
+    copy( '@cds.tenant.independent' );
 
     function copy( anno ) {
       if ( source[anno] && !target[anno] )

package/lib/compiler/populate.js

@@ -100,6 +100,8 @@ function populate( model ) {
           ? 'Composition'
           : true;
   const redirectInSubQueries = isDeprecatedEnabled( options, '_redirectInSubQueries' );
+  const ignoreSpecifiedElements
+        = isDeprecatedEnabled( model.options, 'ignoreSpecifiedQueryElements' );
 
   forEachDefinition( model, traverseElementEnvironments );
   while (newAutoExposed.length) {
@@ -542,7 +544,9 @@ function populate( model ) {
             ielem[prop].$priority = 'annotate';
             wasAnnotated = true;
           }
-          else if (typePropertiesFromSpecifiedElements[prop]) {
+          else if (typePropertiesFromSpecifiedElements[prop] && !ignoreSpecifiedElements) {
+            // If ignoreSpecifiedElements is set, we ignore type properties of specified elements,
+            // similar to how it was done in cds-compiler v3. Only annotations are copied.
             if (!ielem.typeProps$)
               setLink( ielem, 'typeProps$', Object.create( null ) );
             // Note: At this point in time, effectiveType() was likely not called on the

package/lib/compiler/propagator.js

@@ -27,11 +27,12 @@ const $inferred = Symbol.for( 'cds.$inferred' );
 function propagate( model ) {
   const props = {
     '@com.sap.gtt.core.CoreModel.Indexable': never,
-    '@cds.persistence.exists': never,
+    '@cds.persistence.exists': never, // also copied in generate.js
     '@cds.persistence.table': never,
     '@cds.persistence.calcview': never,
     '@cds.persistence.udf': never,
-    '@cds.persistence.skip': notWithPersistenceTable,
+    '@cds.persistence.skip': notWithPersistenceTable, // also copied in generate.js
+    // '@cds.tenant.independent' is propagated as normal, but also copied in generate.js
     '@sql.append': never,
     '@sql.prepend': never,
     '@sql.replace': never,
@@ -106,15 +107,6 @@ function propagate( model ) {
             chain.push({ target, source: target.value._artifact });
             if (checkAndSetStatus( target.value._artifact ))
               news.push( target.value._artifact );
-
-            if (target.value?._artifact.$inferred !== 'include') {
-              // If the referred to element is not inferred, it is a new one and not the original.
-              // The new one was not originally referred to => error;
-              // TODO: no messages in propagator.js
-              warning( 'ref-unexpected-override', [ target.name.location, target ],
-                       { id: target.name.id, target: target.value?._artifact },
-                       'Calculated element $(ID) does not originally refer to $(TARGET)' );
-            }
           }
           chain.push( { target, source: origin } );
           if (checkAndSetStatus( origin ))

package/lib/compiler/shared.js

@@ -1245,7 +1245,8 @@ function fns( model ) {
     else {
       if (!art.query && !art.type && !art.params && (art.elements || art.kind === 'aspect'))
         return art;
-      signalNotFound( 'ref-invalid-include', [ ref.location, user ], null );
+      const variant = art.params && 'param' || 'std';
+      signalNotFound( 'ref-invalid-include', [ ref.location, user ], null, { '#': variant } );
     }
     return false;
   }

package/lib/compiler/tweak-assocs.js

@@ -160,12 +160,23 @@ function tweakAssocs( model ) {
   function checkAnnotationForRefs( expr, user ) {
     if (expr.$tokenTexts)
       return traverseExpr( expr, 'annoRewrite', user, checkAnnotationRef );
-    if (expr.literal === 'array')
-      return expr.val.find( val => checkAnnotationForRefs( val, user ) );
+    if (expr.literal === 'array') {
+      for (const val of expr.val) {
+        const found = checkAnnotationForRefs( val, user );
+        if (found)
+          return found;
+      }
+      return null;
+    }
     if (expr.literal !== 'struct')
       return null;
     const struct = Object.values( expr.struct );
-    return struct.find( val => checkAnnotationForRefs( val, user ) );
+    for (const val of struct) {
+      const found = checkAnnotationForRefs( val, user );
+      if (found)
+        return found;
+    }
+    return null;
   }
 
   function checkAnnotationRef( ref, refCtx, user ) {
@@ -308,6 +319,8 @@ function tweakAssocs( model ) {
     let elem = element.items || element; // TODO v5: nested items
     if (elem.elements)
       forEachGeneric( elem, 'elements', rewriteAssociation );
+    if (elem.targetAspect?.elements)
+      forEachGeneric( elem.targetAspect, 'elements', rewriteAssociation );
     if (!originTarget( elem ))
       return;
     // console.log(message( null, elem.location, elem,
@@ -451,11 +464,7 @@ function tweakAssocs( model ) {
              'Selecting unmanaged associations from a sub query is not supported' );
     }
 
-    // filter was copied in original element already
-    // TODO: not correct for e.g. composition-of-inline-aspect (#12223)
-    if (elem.$inferred !== 'include')
-      addConditionFromAssocPublishing( elem, assoc, nav );
-
+    addConditionFromAssocPublishing( elem, assoc, nav );
     elem.on.$inferred = 'rewrite';
   }
 
@@ -468,6 +477,10 @@ function tweakAssocs( model ) {
    * The added condition (filter) is already rewritten relative to `elem`.
    */
   function addConditionFromAssocPublishing( elem, assoc, nav ) {
+    if (elem.$inferred || elem._main?.$inferred === 'composition-entity') {
+      // filter was copied in original element already
+      return;
+    }
     const publishAssoc = (elem._main?.query || elem.$syntax === 'calc') &&
       elem.value?.path?.length > 0;
     if (!publishAssoc)
@@ -501,10 +514,10 @@ function tweakAssocs( model ) {
     }
 
     elem.on = {
-      op: { val: 'and', location },
+      op: { val: 'ixpr', location },
       args: [
-        // TODO: Get rid of $parens
         { ...elem.on, $parens: [ assoc.location ] },
+        { val: 'and', literal: 'token', location },
         filterToCondition( lastStep, elem, nav ),
       ],
       location,
@@ -526,7 +539,6 @@ function tweakAssocs( model ) {
    */
   function filterToCondition( assocPathStep, elem, nav ) {
     const cond = copyExpr( assocPathStep.where );
-    // TODO: Get rid of $parens
     cond.$parens = [ assocPathStep.location ];
     traverseExpr( cond, 'rewrite-filter', elem, (expr) => {
       if (!expr.path || expr.path.length === 0)
@@ -584,7 +596,7 @@ function tweakAssocs( model ) {
       const lhs = {
         path: [
           { id: assoc.name.id, location: elem.name.location },
-          ...copyExpr( fKey.targetElement.path ),
+          ...copyExpr( fKey.targetElement.path, weakLocation( elem.name.location ) ),
         ],
         location: elem.name.location,
       };
@@ -597,7 +609,7 @@ function tweakAssocs( model ) {
         path: [
           // use origin's name; elem could have alias
           { id: assoc.name.id, location: elem.name.location },
-          ...copyExpr( fKey.targetElement.path ),
+          ...copyExpr( fKey.targetElement.path, weakLocation( elem.name.location ) ),
         ],
         location: elem.name.location,
       };
@@ -762,7 +774,7 @@ function tweakAssocs( model ) {
           state = setArtifactLink( i, elem );
       }
       else if (i) {
-        state = rewriteItem( state, i, i.id, assoc );
+        state = rewriteItem( state, i, i.id, assoc, false );
         if (!state || state === true)
           break;
       }
@@ -801,9 +813,10 @@ function tweakAssocs( model ) {
                           elem;
           // TODO: probably better to collect the non-projected foreign keys
           // and have one message for all
-          error( 'rewrite-undefined-key', [ weakLocation( culprit.location ), assoc ],
-                 { id: item.id, art: alias._main },
-                 'Foreign key $(ID) has not been found in target $(ART)' );
+          error( 'rewrite-undefined-key', [ weakLocation( culprit.location ), assoc ], {
+            '#': 'std', id: item.id, target: alias._main, name: assoc.name.id,
+          });
+          // ''
           return null;
         }
         item.id = name;
@@ -813,13 +826,19 @@ function tweakAssocs( model ) {
     // refs in ON cannot navigate along `items`, no need to consider `items` here
     if (env?.target)
       env = env.target._artifact?._effectiveType;
-    elem = setArtifactLink( item, env?.elements?.[name] );
-
-    if (elem)
-      return elem;
-    // TODO: better (extra message), TODO: do it
-    error( 'query-undefined-element', [ item.location, assoc ],
-           { id: name || item.id, '#': 'redirected' } );
+    const found = setArtifactLink( item, env?.elements?.[name] );
+    if (found)
+      return found;
+
+    const isExplicit = elem.target && !elem.target.$inferred;
+    const loc = isExplicit ? elem.target.location : item.location;
+    error( 'query-undefined-element', [ loc, assoc ], {
+      '#': isExplicit ? 'redirected' : 'std',
+      id: name || item.id,
+      name: elem.name.id,
+      target: elem.target._artifact,
+      keyword: 'redirected to',
+    } );
     return null;
   }
 }

package/lib/edm/annotations/edmJson.js

@@ -309,6 +309,9 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
         anno, elemref: parent, '#': 'wrongref',
       });
     }
+    const [ head, ...tail ] = xpr;
+    if ((head.id || head) === '$self')
+      xpr = tail;
     parentparent[parentprop] = { $Path: xpr.map(ps => ps.id || ps).join('/') };
   };
   //----------------------------------