@sap/cds-compiler 5.7.2 → 5.8.0

package/lib/compiler/checks.js

@@ -16,9 +16,11 @@ const {
   forEachMember,
   forEachMemberRecursively,
   isDeprecatedEnabled,
+  isBetaEnabled,
 } = require('../base/model');
 const { typeParameters } = require('./builtins');
 const { propagationRules } = require('../base/builtins');
+const { annotationVal } = require('./utils');
 
 const $location = Symbol.for( 'cds.$location' );
 
@@ -32,7 +34,10 @@ function check( model ) {
     error, warning, info, message,
   } = model.$messageFunctions;
 
-  const { getOrigin } = model.$functions;
+  const {
+    getOrigin,
+    getInheritedProp,
+  } = model.$functions;
 
   checkSapCommonLocale( model );
   checkSapCommonTextsAspects( model );
@@ -55,7 +60,8 @@ function check( model ) {
   function checkEvent( def ) {
     // Ensure that events are structured. Up to compiler v4, we allowed non-structured events,
     // because when we introduced them, it was not fully specified what they are.
-    if (def.kind === 'event' && !def._effectiveType?.elements && !def._effectiveType?.projection)
+    if (def.kind === 'event' && def._effectiveType &&
+        !def._effectiveType.elements && !def._effectiveType.projection)
       message( 'def-expected-structured', [ (def.type || def.name).location, def ] );
   }
 
@@ -268,11 +274,10 @@ function check( model ) {
   function checkLocalizedElement( elem ) {
     if (elem.localized?.val) {
       const type = elem._effectiveType;
-      // TODO(v6): Also for ` || type?.elements`; (#13154)
-      if (type?.category === 'map') {
-        error( 'ref-unexpected-localized-map', [ elem.type?.location, elem ],
-               { keyword: 'localized' },
-               'Map types can\'t be used with $(KEYWORD)' );
+      if (type?.category === 'map' ||
+         (type?.elements && isBetaEnabled( model.options, 'v6preview' ))) {
+        error( 'def-unexpected-localized', [ elem.localized.location, elem ],
+               { keyword: 'localized', '#': type.category === 'map' ? 'map' : 'struct' } );
       }
       else if (!type || !type.builtin || type.category !== 'string') {
         // See discussion issue #6520: should we allow all scalar types?
@@ -584,14 +589,36 @@ function check( model ) {
   }
 
   function checkDefaultValue( art ) {
-    if (!art.default || !art._effectiveType)
+    if (!art._effectiveType)
       return;
-    // TODO(v6): Also reject default for structures (#13154)
-    const isStructured = art._effectiveType?.name.id === 'cds.Map';
-    if (!isStructured)
+    if (art.kind !== 'element' && art.kind !== 'type' && art.kind !== 'param')
+      return;
+
+    const defaultValue = getInheritedProp( art, 'default' );
+    if (defaultValue?.val === undefined)
       return;
-    if (art.default?.val !== undefined) {
-      error( 'type-unexpected-default', [ art.default.location, art ], {
+
+    // Check that "not null" artifacts don't have `null` default values.
+    // At least one property must be written explicitly to avoid reporting on inferred elements.
+    if (isBetaEnabled( model.options, 'v6preview' ) &&
+       (art.default?.val === null || art.notNull?.val)) {
+      const notNullValue = getInheritedProp( art, 'notNull' );
+      if (notNullValue?.val && defaultValue?.val === null) {
+        const loc = (art.default || art.notNull)?.location || art.location;
+        const variant = art.kind + (!art.default && art.notNull ? 'NotNull' : 'DefaultNull');
+        message( 'type-unexpected-null', [ loc, art ], {
+          '#': variant,
+          art,
+          keyword: 'not null',
+          value: 'null',
+        } );
+      }
+    }
+
+    // TODO(v6): Also reject default for structures (#13154), i.e. add `|| !!art.….elements`
+    const isStructured = art._effectiveType?.name.id === 'cds.Map';
+    if (isStructured) {
+      error( 'type-unexpected-default', [ defaultValue.location, art ], {
         '#': 'map', keyword: 'default', type: 'cds.Map',
       } );
     }
@@ -956,21 +983,32 @@ function check( model ) {
   }
 
   function checkAnnotationAssignment1( art, anno ) {
+    const name = anno.name?.id;
     if (art.$contains?.$annotation && anno.kind === '$annotation') {
       if (checkAnnotationAcceptsExpressions( anno, art ))
         checkAnnotationExpressions( anno, art );
     }
 
-    if (!model.vocabularies)
-      return;
-
     // Has been slightly adapted for model.vocabularies but comments need to be
     // adapted, etc.
     // TODO: rework completely!
     // TODO: if we have such a check, consider #variant, anno.@anno, anno@anno
     // Sanity checks (ignore broken assignments)
-    if (!anno.name?.id)
+    if (!name)
+      return;
+
+    // Compiler specific annotation validation.
+    const annotationChecks = {
+      __proto__: null,
+      '@cds.redirection.target': checkAnnoRedirectionTarget,
+    };
+
+    const annoName = `@${ name }`;
+    annotationChecks[annoName]?.(anno, art);
+
+    if (!model.vocabularies)
       return;
+
     // Just a little workaround to adapt to changed `name`s, not nice coding:
     const hashIndex = anno.name.id.indexOf( '#' );
     const path = (hashIndex > 0 ? anno.name.id.substring( 0, hashIndex ) : anno.name.id)
@@ -1000,6 +1038,23 @@ function check( model ) {
     checkAnnotationAssignment( anno, artifact, endOfPath, art );
   }
 
+  function checkAnnoRedirectionTarget( anno, art ) {
+    if (anno.$inferred)
+      return;
+    if (!annotationVal( anno ))
+      return; // ignore falsey values, including 'null'
+
+    // Non-entities can't have this annotation, nor can non-service entities,
+    // nor can complex queries such as joins, unions, or selecting from an association.
+
+    const isIgnored = isComplexView( art ) || (art.kind !== 'entity') || !art._service;
+    if (isIgnored) {
+      const loc = anno.val ? anno.location : anno.name.location;
+      info( 'anno-ignoring-redirection-target', [ loc, art ], { anno: anno.name.id },
+            '$(ANNO) has no effect here; use it on simple projections inside services' );
+    }
+  }
+
   // Perform checks for annotation assignment 'anno', using corresponding annotation declaration,
   // made of 'annoDecl' (artifact or undefined) and 'elementDecl' (annotation or element
   // or undefined). Report errors on 'options.messages.
@@ -1316,4 +1371,11 @@ function isComposition( model, elem ) {
   return false;
 }
 
+function isComplexView( art ) {
+  if (!art?.query) // non-query
+    return false;
+  // Either UNION, JOIN, SUB-SELECT, or target is an association
+  return (!art.query.from?._artifact || art.query.from._artifact.kind === 'element');
+}
+
 module.exports = check;

package/lib/compiler/define.js

@@ -572,9 +572,57 @@ function define( model ) {
     initMembers( art, art, block );
     if (art.params)
       initDollarParameters( art ); // $parameters
+    if (art.query) {
+      initArtifactQuery( art );
+      restrictToSimpleProjection( art );
+    }
+  }
 
-    if (!art.query)
+  /**
+   * Restrict the query of `art` to only simple projections, i.e. those without 'group by', etc.
+   *
+   * @param {XSN.Artifact} art
+   */
+  function restrictToSimpleProjection( art ) {
+    const { query } = art;
+
+    if (art.kind !== 'type')
+      return; // TODO(v6): Also for event
+
+    if (!query.from?.path)
+      return; // union, sub-select, etc. should already be rejected
+
+    const check = (prop, keyword) => (query[prop] && { prop: query[prop], keyword });
+    const unexpectedQueryProp = check( 'where', 'where' ) ||
+      check( 'groupBy', 'group by' ) ||
+      check( 'limit', 'limit' ) ||
+      check( 'having', 'having' ) ||
+      check( 'orderBy', 'order by' ) ||
+      null;
+
+    if (unexpectedQueryProp) {
+      error( 'query-unexpected-prop', [ unexpectedQueryProp.prop.location, query ], {
+        '#': art.kind,
+        keyword: unexpectedQueryProp.keyword,
+      }, {
+        std: 'Unexpected $(KEYWORD) for projection clause used as type expression',
+        type: 'Unexpected $(KEYWORD) for type definition',
+        event: 'Unexpected $(KEYWORD) for event definition',
+      } );
       return;
+    }
+
+    const firstCondition = query.from.path.find(step => step.where)?.where;
+    if (firstCondition) {
+      error( 'query-unexpected-filter', [ firstCondition.location, query ], { '#': art.kind }, {
+        std: 'Unexpected filter in query source for projection clause used as type expression',
+        type: 'Unexpected filter in projection clause of type definition',
+        event: 'Unexpected filter in projection clause of event definition',
+      } );
+    }
+  }
+
+  function initArtifactQuery( art ) {
     art.$queries = [];
     setLink( art, '_from', [] ); // for sequence of resolve steps - TODO: remove
     if (!setLink( art, '_leadingQuery', initQueryExpression( art.query, art ) ) )
@@ -593,6 +641,12 @@ function define( model ) {
     checkRedefinition( art );
     const block = art._block;
     initMembers( art, art, block );
+
+    if (art.query) {
+      initArtifactQuery( art );
+      error( 'def-unsupported-projection', [ art.location, art ], null,
+             'Projections for annotation definitions are not supported' );
+    }
   }
 
   function initArtifactParentLink( art, definitions, path, pathIndex ) {
@@ -665,7 +719,7 @@ function define( model ) {
   // Init queries: --------------------------------------------------------------
 
   // art is:
-  // - entity for top-level queries (including UNION args)
+  // - entity/event/type for top-level queries (including UNION args)
   // - $tableAlias for sub query in FROM - TODO: what about UNION there?
   // - $query for real sub query (in columns, WHERE, ...), again: what about UNION there?
   function initQueryExpression( query, art ) {
@@ -988,7 +1042,7 @@ function define( model ) {
     if (exprOrPathElement.$expected === 'exists')
       exprOrPathElement.$expected = 'approved-exists';
     // Drill down
-    if (exprOrPathElement.args)
+    if (Array.isArray(exprOrPathElement.args))
       exprOrPathElement.args.forEach( elem => approveExistsInChildren( elem ) );
     else if (exprOrPathElement.where?.args)
       exprOrPathElement.where.args.forEach( elem => approveExistsInChildren( elem ) );
@@ -1155,6 +1209,9 @@ function define( model ) {
       setLink( elem, '_block', bl );
       const existing = parent[prop]?.[name];
       const add = construct !== parent && (!existing || elem.$inferred !== 'include');
+      // don't dump with `entity T {}; extend T with { extend e {}; e {}; e {} };`:
+      if (elem.$duplicates === true && add)
+        elem.$duplicates = null;
       setMemberParent( elem, name, parent, add && prop );
       // console.log(message( null, elem.location, elem, {}, 'Info', 'INIT').toString())
       checkRedefinition( elem );

package/lib/compiler/extend.js

@@ -200,8 +200,7 @@ function extend( model ) {
    */
   function extendForeignKeys( art ) {
     // See extendArtifactAfter() for targetAspect/items handling.
-    const sub = art.items || art.targetAspect?.elements && art.targetAspect;
-    if (!art._extensions || sub)
+    if (!art._extensions || art.items || art.targetAspect?.elements)
       return;
 
     // push down foreign keys

package/lib/compiler/generate.js

@@ -141,7 +141,7 @@ function generate( model ) {
         //       Not supported anyway, but important for recompilation (which fails correctly).
         const loc = elem.localized?.location || elem.location;
         error( 'def-unexpected-localized', [ loc, elem ],
-               { '#': !include ? 'std' : 'include', art: textsAspect } );
+               { '#': !include ? 'elements' : 'include', art: textsAspect } );
         hasError = true;
       }
       else if (elem.targetAspect) {

package/lib/compiler/populate.js

@@ -740,6 +740,7 @@ function populate( model ) {
         query._main.elements = elemsParent.elements;
     }
 
+    const isExpand = (query.expand === columns);
     if (!columns)
       columns = [ { val: '*' } ];
 
@@ -768,7 +769,7 @@ function populate( model ) {
         initFromColumns( query, col.inline, col );
       }
       else if (!col.$replacement) {
-        const id = ensureColumnName( col, i, query );
+        const id = ensureColumnName( col, i, query, isExpand );
         col.kind = 'element';
         dictAdd( elemsParent.elements, id, col, ( name, location ) => {
           error( 'duplicate-definition', [ location, query ], { name, '#': 'element' } );
@@ -780,8 +781,17 @@ function populate( model ) {
     return true;
   }
 
-  // TODO: probably do this already in definer.js
-  function ensureColumnName( col, colIndex, query ) {
+  /**
+   * TODO: probably do this already in definer.js
+   *
+   * @param col
+   * @param {number} colIndex
+   * @param query
+   * @param {boolean} insideExpand
+   *     Whether the column is inside 'expand'.
+   *     Anonymous 'expands' don't have a column parent, hence why we need to know this explicitly.
+   */
+  function ensureColumnName( col, colIndex, query, insideExpand ) {
     if (col.name)
       return col.name.id;
     if (col.inline || col.val === '*')
@@ -795,8 +805,9 @@ function populate( model ) {
         return col.name.id;
       }
     }
-    else if (col.expand || col.value && (col._columnParent || query._parent.kind !== 'select')) {
-      // _columnParent => inline/expand; _parent -> only allowed in sub-selects
+    else if (insideExpand || col.expand ||
+        col.value && (col._columnParent || query._parent.kind !== 'select')) {
+      // _columnParent => inline/expand with path head; _parent -> only allowed in sub-selects
       error( 'query-req-name', [ col.value?.location || col.location, query ], {},
              'Alias name is required for this select item' );
     }
@@ -851,7 +862,7 @@ function populate( model ) {
     let seenWildcard = null;
     let colIndex = 0;
     for (const col of columns) {
-      const id = ensureColumnName( col, colIndex, query );
+      const id = ensureColumnName( col, colIndex, query, false );
       if (id) {
         col.$replacement = !seenWildcard;
         siblings[id] = !(id in siblings) && col;

package/lib/compiler/propagator.js

@@ -44,7 +44,7 @@ function propagate( model ) {
     precision: always,
     scale: always,
     srid: always,
-    localized: always,
+    localized: withKind,
     target: notWithExpand,
     targetAspect,
     cardinality: notWithExpand,