@sap/cds-compiler 4.5.0 → 4.6.2

package/lib/checks/enricher.js

@@ -6,6 +6,8 @@
 
 const { csnRefs } = require('../model/csnRefs');
 const { setProp } = require('../base/model');
+const { xprInAnnoProperties } = require('../compiler/builtins');
+
 /**
  * The following properties are attached as non-enumerable where appropriate:
  *
@@ -16,9 +18,10 @@ const { setProp } = require('../base/model');
  *- `$path` has the csnPath to reach that property.
  *
  * @param {CSN.Model} csn CSN to enrich in-place
+ * @param {enrichCsnOptions} [options={}]
  * @returns {{ csn: CSN.Model, cleanup: () => void }} CSN with all ref's pre-resolved
  */
-function enrichCsn( csn ) {
+function enrichCsn( csn, options ) {
   const transformers = {
     elements: dictionary,
     definitions: dictionary,
@@ -31,8 +34,7 @@ function enrichCsn( csn ) {
     target,
     includes: simpleRef,
     columns,
-    // Annotations are ignored.
-    '@': () => { /* ignore annotations */ },
+    '@': annotation,
   };
   let cleanupCallbacks = [];
 
@@ -83,6 +85,35 @@ function enrichCsn( csn ) {
     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.
+   *
+   * @param {object | Array} _parent the thing that has _prop
+   * @param {string|number} _prop the name of the current property or index
+   * @param {object} node The value of node[_prop]
+   */
+  function annotation( _parent, _prop, node ) {
+    if (options.processAnnotations) {
+      if (node?.['='] !== undefined && xprInAnnoProperties.some(xProp => node[xProp] !== undefined)) {
+        standard(_parent, _prop, node);
+      }
+      else if (node && typeof node === 'object') {
+        csnPath.push(_prop);
+
+        if (Array.isArray(node)) {
+          node.forEach( (n, i) => annotation( node, i, n ) );
+        }
+        else {
+          for (const name of Object.getOwnPropertyNames( node ))
+            annotation( node, name, node[name] );
+        }
+
+        csnPath.pop();
+      }
+    }
+  }
+
   // eslint-disable-next-line jsdoc/require-jsdoc
   function columns( parent, prop, node ) {
     // Establish the link relationships
@@ -178,3 +209,8 @@ function enrichCsn( csn ) {
 }
 
 module.exports = enrichCsn;
+
+/**
+ * @typedef {object} enrichCsnOptions
+ * @property {boolean} [processAnnotations=false] Wether to process annotations and call custom transformers on them
+ */

package/lib/checks/validator.js

@@ -121,12 +121,11 @@ const forOdataQueryValidators = [];
 const commonMemberValidators
 = [ validateOnCondition, validateForeignKeys,
   validateAssociationsInItems, checkForInvalidTarget,
-  checkVirtualElement ];
+  checkVirtualElement, checkManagedAssoc ];
 
 // TODO: checkManagedAssoc is a forEachMemberRecursively!
 const commonArtifactValidators = [
   checkTypeDefinitionHasType,
-  checkManagedAssoc,
   checkRecursiveTypeUsage,
 ];
 // TODO: Does it make sense to run the on-condition check as part of a CSN validator?
@@ -150,7 +149,7 @@ function _validate( csn, that,
                     artifactValidators = [],
                     queryValidators = [],
                     iterateOptions = {} ) {
-  const { cleanup } = enrich(csn);
+  const { cleanup } = enrich(csn, { processAnnotations: that.options.tranformation === 'odata' });
 
   applyTransformations(csn, mergeCsnValidators(csnValidators, that), [], { drillRef: true });
 

package/lib/compiler/assert-consistency.js

@@ -480,7 +480,8 @@ function assertConsistency( model, stage ) {
       optional: [
         'literal', 'val', 'sym', 'struct', 'variant', 'path', 'name', '$duplicates', 'upTo',
         // expressions as annotation values
-        '$tokenTexts', 'op', 'args', 'func', '_artifact', 'type',
+        '$tokenTexts', 'op', 'args', 'func', '_artifact', 'type', '$typeArgs',
+        'scale', 'srid', 'length', 'precision',
       ],
       // TODO: restrict path to #simplePath
     },

package/lib/compiler/builtins.js

@@ -32,6 +32,7 @@ const core = {
   Timestamp: { category: 'dateTime' },
   Boolean: { category: 'boolean' },
   UUID: { category: 'string' },
+  Vector: { parameters: [ 'length' /* , 'type' */ ], category: 'vector' },
   Association: { internal: true, category: 'relation' },
   Composition: { internal: true, category: 'relation' },
 };
@@ -320,9 +321,7 @@ function checkDate( year, month, day ) {
  * Return whether JSON object `val` is a representation for an annotation expression
  */
 function isAnnotationExpression( val ) {
-  // TODO: we might allow `'=': true`, not just a string, for expressions, to be
-  // decided → just check truthy at the moment
-  return val['='] && xprInAnnoProperties.some( prop => val[prop] !== undefined );
+  return val?.['='] !== undefined && xprInAnnoProperties.some( prop => val[prop] !== undefined );
 }
 
 /**
@@ -354,6 +353,7 @@ const typeCategories = {
   boolean: [],
   relation: [],
   geo: [],
+  vector: [],
 };
 // Fill type categories with `cds.*` types
 Object.keys( core ).forEach( (type) => {
@@ -399,6 +399,16 @@ function isBuiltinType( type ) {
   return typeof type === 'string' && isInReservedNamespace( type );
 }
 
+/**
+ * Tell if a name is a magic variable
+ *
+ * @param {string} name
+ * @returns {boolean}
+ */
+function isMagicVariable( name ) {
+  return typeof name === 'string' && Object.prototype.hasOwnProperty.call(magicVariables, name);
+}
+
 /**
  * Add CDS builtins like the `cds` namespace with types like `cds.Integer` to
  * `definitions` of the XSN model as well as to `$builtins`.
@@ -411,9 +421,14 @@ function initBuiltins( model ) {
   // namespace:"cds" stores the builtins ---
   const cds = createNamespace( 'cds', 'reserved' );
   model.definitions.cds = cds;
+
   // Also add the core artifacts to model.definitions`
-  model.$builtins = env( core, 'cds.', cds );
+  const c = { ...core };
+  if (!isBetaEnabled( model.options, 'vectorType' ))
+    delete c.Vector;
+  model.$builtins = env( c, 'cds.', cds );
   model.$builtins.cds = cds;
+
   // namespace:"cds.hana" stores HANA-specific builtins ---
   const hana = createNamespace( 'cds.hana', 'reserved' );
   model.definitions['cds.hana'] = hana;
@@ -534,5 +549,6 @@ module.exports = {
   isAnnotationExpression,
   isInReservedNamespace,
   isBuiltinType,
+  isMagicVariable,
   isGeoTypeName,
 };

package/lib/compiler/checks.js

@@ -15,6 +15,7 @@ const {
   forEachDefinition,
   forEachMember,
   forEachMemberRecursively,
+  isDeprecatedEnabled,
 } = require('../base/model');
 const { CompilerAssertion } = require('../base/error');
 const { typeParameters } = require('./builtins');
@@ -153,13 +154,18 @@ function check( model ) {
     while (effectiveType?.enum)
       effectiveType = (effectiveType._origin || effectiveType.type?._artifact)?._effectiveType;
 
-    if (!effectiveType) {
-      return; // e.g. illegal definition references, cycles, ...
+    if (!effectiveType || (effectiveType.type && !effectiveType.type._artifact)) {
+      return; // e.g. illegal definition references, cycles, unknown artifacts, …
     }
     else if (!art.type && !effectiveType.type && !effectiveType?.builtin) {
-      error( 'type-missing-type', [ art.location, user ],
-             { otherprop: 'type', prop: actualParams[0] },
-             'Missing $(OTHERPROP) property next to $(PROP)' );
+      // Special case for deprecated flag "ignore specified elements": The `type` property
+      // is lost in columns, but `length`,… are kept -> mismatch.  This behavior is the
+      // same as in cds-compiler v3.  See #12169 for details.
+      if (!isDeprecatedEnabled( model.options, 'ignoreSpecifiedQueryElements' )) {
+        error( 'type-missing-type', [ art.location, user ],
+               { otherprop: 'type', prop: actualParams[0] },
+               'Missing $(OTHERPROP) property next to $(PROP)' );
+      }
       return;
     }
 
@@ -815,6 +821,9 @@ function check( model ) {
   // Has been slightly adapted for model.vocabularies but comments need to be
   // adapted, etc.
   function checkAnnotationAssignment1( art, anno ) {
+    if (art.$contains?.$annotation)
+      checkAnnotationExpressions( anno, art );
+
     // Sanity checks (ignore broken assignments)
     if (!anno.name?.id)
       return;
@@ -882,7 +891,6 @@ function check( model ) {
         warning( 'anno-expecting-value', [ anno.location || anno.name.location, art, anno ],
                  { '#': 'std', anno: anno.name.id } );
       }
-
       return;
     }
 
@@ -890,6 +898,22 @@ function check( model ) {
     checkValueAssignableTo( anno, anno, elementDecl, art );
   }
 
+  /**
+   * Check the expressions inside annotations.
+   */
+  function checkAnnotationExpressions( anno, art ) {
+    if (anno.$tokenTexts) {
+      checkGenericExpression( anno, art );
+    }
+    else if (anno.literal === 'array') {
+      anno.val.forEach( val => checkAnnotationExpressions( val, art ) );
+    }
+    else if (anno.literal === 'struct') {
+      const struct = Object.values(anno.struct);
+      struct.forEach(val => checkAnnotationExpressions( val, art ));
+    }
+  }
+
   // Check that annotation assignment 'value' (having 'path or 'literal' and
   // 'val') is potentially assignable to element 'element'. Complain on 'loc'
   // if not

package/lib/compiler/define.js

@@ -940,6 +940,8 @@ function define( model ) {
           initExprForQuery( col.value, parent );
         initSelectItems( col, null, user ); // TODO: use col as user (i.e. remove param)
       }
+
+      initItemsLinks( col, parent._block );
     }
 
     if (hasItems && !wildcard && parent.excludingDict && !options.$recompile) {
@@ -999,15 +1001,7 @@ function define( model ) {
     // TODO: split extend from init
     const main = parent._main || parent;
     const isQueryExtension = construct.kind === 'extend' && main.query;
-    let obj = construct;
-    let { items } = obj;
-    while (items) {
-      setLink( items, '_outer', obj );
-      setLink( items, '_parent', obj._parent );
-      setLink( items, '_block', block );
-      obj = items;
-      items = obj.items;
-    }
+    let obj = initItemsLinks( construct, block );
     if (obj.target && targetIsTargetAspect( obj )) {
       obj.targetAspect = obj.target;
       delete obj.target;
@@ -1172,6 +1166,14 @@ function define( model ) {
       elem.$syntax = 'calc';
       // TODO: it is not just "syntax" - maybe better test for `$calcDepElement`?
       createAndLinkCalcDepElement( elem );
+
+      // Special case (hack) for calculated elements that use associations+filter:
+      // See "Notes on `$filtered`" in `ExposingAssocWithFilter.md` for details.
+      if (elem.target && elem.value.path?.[elem.value.path.length - 1]?.where) {
+        delete elem.type;
+        delete elem.on;
+        delete elem.target;
+      }
     }
   }
 
@@ -1199,6 +1201,26 @@ function define( model ) {
     }
   }
 
+  /**
+   * Initialize artifact links inside `obj.items` (for nested ones as well).
+   * Does nothing, it `obj.items` does not exist.
+   *
+   * @param {XSN.Artifact} obj
+   * @param {object} block
+   * @return {XSN.Artifact}
+   */
+  function initItemsLinks( obj, block ) {
+    let { items } = obj;
+    while (items) {
+      setLink( items, '_outer', obj );
+      setLink( items, '_parent', obj._parent );
+      setLink( items, '_block', block );
+      obj = items;
+      items = obj.items;
+    }
+    return obj;
+  }
+
   // To be reworked -------------------------------------------------------------
 
   // TODO: is only necessary for extensions - make special for extend/annotate

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/resolve.js

@@ -519,8 +519,8 @@ function resolve( model ) {
     if (art.value) {
       if (art.$syntax === 'calc')
         checkCalculatedElement( art );
-      else if (art.type && !art.$inferred )
-        checkStructureCast( art );
+      else if (art.type && !art.$inferred)
+        checkColumnTypeCast( art );
     }
 
     resolveExprInAnnotations( art );
@@ -557,10 +557,12 @@ function resolve( model ) {
 
       // Check explicit types: If either side has one, so must the other.
       const sType = specifiedElement.type?._artifact;
-      const iType = getInferredPropFromOrigin( 'type' )?._artifact || inferredElement;
+      const iTypeArt = getInferredPropFromOrigin( 'type' )?._artifact;
+      const iType = iTypeArt || inferredElement;
 
       // xor: could be missing a type;
       // FIXME: The coding above returns incorrect iType for expand on associations
+
       if (!specifiedElement.type && inferredElement.type) {
         error( 'query-mismatched-element', [ specifiedElement.location, user ], {
           '#': !specifiedElement.type ? 'missing' : 'extra', name: user.name.id, prop: 'type',
@@ -568,8 +570,12 @@ function resolve( model ) {
         return;
       }
       // If specified type is `null`, type could not be resolved.
-      else if (sType && sType !== iType) {
-        const typeName = iType?.name && sType?.name ? 'typeName' : 'type';
+      else if (sType && sType !== iType &&
+        // Special case for $recompilation: allow one level of type indirection. See #12113.
+        (!model.options.$recompile || sType !== iType.type?._artifact)) {
+        const typeName = !iTypeArt && 'typeExtra' ||  // no inferred type prop
+          iType?.name && sType?.name && 'typeName' || // both types are named
+          'type';                                     // unknown type names
         const othertype = typeName !== 'type' && iType || '';
         error( 'query-mismatched-element', [
           specifiedElement.type.location || specifiedElement.location, user,
@@ -815,24 +821,20 @@ function resolve( model ) {
     else if (!allowedInKind.includes( parent.kind )) {
       error( 'def-invalid-calc-elem', loc, { '#': parent.kind } );
     }
-    else if (effectiveType( art )?.elements) {
+    else if (effectiveType( art )?.elements && !art.$inferred) {
       // For inferred (e.g. included) calc elements, this error is already emitted at the origin.
-      if (!art.$inferred) {
-        if (art.type)
-          error( 'type-unexpected-structure', [ art.type.location, art ], { '#': 'calc' } );
-        else
-          error( 'ref-unexpected-structured', [ art.value.location, art ], { '#': 'expr' } );
-      }
+      if (art.type)
+        error( 'type-unexpected-structure', [ art.type.location, art ], { '#': 'calc' } );
+      else
+        error( 'ref-unexpected-structured', [ art.value.location, art ], { '#': 'expr' } );
     }
-    else if (effectiveType( art )?.items) {
+    else if (effectiveType( art )?.items && !art.$inferred) {
       // For inferred (e.g. included) calc elements, this error is already emitted at the origin.
-      if (!art.$inferred) {
-        const isCast = art.type?.$inferred === 'cast';
-        error( 'type-unexpected-many', [ (art.type || art.value).location, art ], {
-          '#': (!art.type && 'calc-implicit') || (isCast && 'calc-cast') || 'calc',
-          elemref: art.type ? undefined : { ref: art.value.path },
-        } );
-      }
+      const isCast = art.type?.$inferred === 'cast';
+      error( 'type-unexpected-many', [ (art.type || art.value).location, art ], {
+        '#': (!art.type && 'calc-implicit') || (isCast && 'calc-cast') || 'calc',
+        elemref: art.type ? undefined : { ref: art.value.path },
+      } );
     }
     else {
       const noTruthyAllowed = [ 'localized', 'key', 'virtual' ];
@@ -847,7 +849,7 @@ function resolve( model ) {
     }
   }
 
-  function checkStructureCast( art ) {
+  function checkColumnTypeCast( art ) {
     const elem = (art.value.op?.val === 'cast')
       ? art.value.args[0]?._artifact
       : art.value._artifact;
@@ -856,6 +858,9 @@ function resolve( model ) {
         error( 'type-invalid-cast', [ art.type.location, art ], { '#': 'to-structure' } );
       else if (elem.elements) // TODO: calc elements
         error( 'type-invalid-cast', [ art.type.location, art ], { '#': 'from-structure' } );
+      else if (elem.target && !art.type._artifact?.target)
+        // allow cast to association -> that is already checked and denied elsewhere
+        error( 'type-invalid-cast', [ art.type.location, art ], { '#': 'from-assoc' } );
     }
   }
 

package/lib/compiler/shared.js

@@ -105,7 +105,7 @@ function fns( model ) {
       dynamic: modelBuiltinsOrDefinitions,
       navigation: environment,
       notFound: undefinedDefinition,
-      accept: acceptEntityOrAssoc,
+      accept: acceptQuerySource,
       noDep: '',                // dependency special for from
     },
     type: {
@@ -335,9 +335,7 @@ function fns( model ) {
     if (expr.args && !first) {
       const args = Array.isArray( expr.args ) ? expr.args : Object.values( expr.args );
       // TODO: re-think $expected
-      first = callback.traverse // TODO: still in use?
-        ? callback.traverse( args, exprCtx, user, callback )
-        : args.find( e => traverseExpr( e, exprCtx, user, callback ) );
+      first = args.find( e => traverseExpr( e, exprCtx, user, callback ) );
     }
 
     first ??= expr.suffix &&    // fn( … ) OVER …
@@ -1281,15 +1279,17 @@ function fns( model ) {
     return false;
   }
 
-  function acceptEntityOrAssoc( art, user, ref ) { // for FROM
+  function acceptQuerySource( art, user, ref ) { // for FROM
     const { path, scope } = ref;
     // see getPathItem(): how many path items are for the main artifact ref?
     const artItemsCount = (typeof scope === 'number' && scope) || (scope ? 1 : path.length);
-    // at least the last main definition should be an entity
+    // at least the last main definition should be an entity or an
+    // event (if the user is also an event)
     // an additional check for target would need effectiveType()
     const source = path[artItemsCount - 1]._artifact;
-    if (source.kind !== 'entity') {
-      signalNotFound( 'ref-invalid-source', [ ref.location, user ], null );
+    const variant = (user._main.kind === 'event') ? 'event' : 'std';
+    if (source.kind !== 'entity' && !acceptEventProjectionSource( source, user )) {
+      signalNotFound( 'ref-invalid-source', [ ref.location, user ], null, { '#': variant } );
       return false;
     }
     if (source === art)
@@ -1297,10 +1297,20 @@ function fns( model ) {
     const assoc = Functions.effectiveType( art );
     if (assoc.target)
       return art;               // TODO: use target here
-    signalNotFound( 'ref-invalid-source', [ ref.location, user ], null );
+    signalNotFound( 'ref-invalid-source', [ ref.location, user ], null, { '#': variant } );
     return false;
   }
 
+  function acceptEventProjectionSource( source, user ) {
+    if (user._main.kind !== 'event' || (source.kind !== 'event' && source.kind !== 'type'))
+      return false;
+    const effectiveType = Functions.effectiveType( source );
+    if (!effectiveType)
+      return false;
+    const { kind } = effectiveType;
+    return (kind === 'entity' || kind === 'event' || (kind === 'type' && effectiveType.elements));
+  }
+
   function acceptTypeOrElement( art, user, ref ) { // for type
     // was ['action', 'function'].includes( user._parent?.kind ))
     while (user._outer)