@sap/cds-dk 10.0.7 → 10.1.0

package/node_modules/@sap/cds-compiler/lib/compiler/extend.js

@@ -18,6 +18,8 @@ const {
   initExprAnnoBlock,
   initBoundSelfParam,
   dependsOnSilent,
+  hasSecurityAnno,
+  extensionRefContext,
   pathName,
   annotationHasEllipsis,
   forEachInOrder,
@@ -525,14 +527,30 @@ function extend( model ) {
         prop === 'params' || prop === '$add' )
       return;                   // extensions currently handled extra
     // TODO: columns?
+    const isTypeParam = typeParameters.list.includes( prop );
+    const isAnnoOrDoc = prop.charAt(0) === '@' || prop === 'doc';
+    if (!isAnnoOrDoc && !isTypeParam && prop !== 'orderBy')
+      return;
     if (issue) {
+      if (prop === 'orderBy' && issue === 'unrelated') {
+        for (const ext of extensions) {
+          const clause = ext[prop];
+          if (clause) {
+            message( 'ext-unstable-order', [ clause[0]?.location || ext.location, ext ],
+                     { keyword: prop },
+                     // eslint-disable-next-line @stylistic/max-len
+                     'Unstable order of entries in the $(KEYWORD) clause due to another extension in unrelated layer' );
+          }
+        }
+        return;
+      }
       // eslint-disable-next-line no-nested-ternary
       let msg = (index < 0)
         ? 'anno-unstable-array'
         : (issue === true)
           ? 'anno-duplicate'
           : 'anno-duplicate-unrelated-layer';
-      if (prop.charAt(0) !== '@' && prop !== 'doc') {
+      if (!isAnnoOrDoc) {
         msg = (issue === true)
           ? 'ext-duplicate-extend-type'
           : 'ext-duplicate-extend-type-unrelated-layer';
@@ -551,7 +569,7 @@ function extend( model ) {
     }
     else if (index > 0) {     // more than one set (not just ...)
       const variant = prop === 'doc' ? 'doc' : 'std';
-      const msgid = (prop.charAt(0) === '@' || prop === 'doc')
+      const msgid = (isAnnoOrDoc)
         ? 'anno-duplicate-same-file' // TODO: always ext-duplicate-…
         : 'ext-duplicate-same-file';
       while (index >= 0) {    // do not report for trailing [...]
@@ -636,11 +654,27 @@ function extend( model ) {
         query[prop] = [];
       query[prop].push( ...clause );
     }
-    else {
-      if (query[prop]) {
-        error( 'ext-unexpected-sql-clause', [ clause.location, ext ], { art, keyword: prop } );
-        return;
+    else if (prop === 'where' || prop === 'having') {
+      const existing = query[prop];
+      if (!existing) {
+        query[prop] = clause;
+      }
+      else if (existing.op?.val === 'and' &&
+               existing.args.some( a => a.$extended === prop )) {
+        existing.args.push( clause );
+      }
+      else {
+        query[prop] = {
+          op: { val: 'and', location: art.name.location },
+          args: [ existing, clause ],
+          location: clause.location,
+        };
       }
+    }
+    else if (query[prop]) {
+      error( 'ext-unexpected-sql-clause', [ clause.location, ext ], { art, keyword: prop } );
+    }
+    else {
       query[prop] = clause;
     }
   }
@@ -1074,11 +1108,6 @@ function extend( model ) {
     forEachMember( annotate, createSuperAnnotate );
   }
 
-  function hasSecurityAnno( ext ) {
-    return ext['@restrict'] || ext['@requires'] ||
-      Object.keys( ext ).some( prop => prop.startsWith( '@ams.' ) );
-  }
-
   function checkRemainingMainExtensions( art, ext ) {
     const refCtx = extensionRefContext( ext );
     if (resolvePath( ext.name, refCtx, ext ) && art?.builtin) {
@@ -1101,21 +1130,6 @@ function extend( model ) {
     }
   }
 
-  function extensionRefContext( ext ) {
-    if (ext.kind === 'annotate') {
-      if (hasSecurityAnno( ext ))
-        return 'annotate-sec';
-    }
-    else if (ext.artifacts ||   // extend … with definitions
-             ext._block.$frontend === 'json' && !ext.elements && !ext.actions) {
-      // TODO: not for `extend context` and `extend service` → !ext.expectedKind
-      // TODO v7: also fully with CSN input
-      if (!ext.doc && !Object.keys( ext ).some( a => a.charAt(0) === '@') )
-        return 'annotate';      // TODO: or an extra refCtx ?
-    }
-    return ext.kind;
-  }
-
   // Issue messages for annotations on namespaces and builtins
   // (TODO: really here?, probably split main artifacts vs returns)
   // see also createRemainingAnnotateStatements() where similar messages are reported

package/node_modules/@sap/cds-compiler/lib/compiler/populate.js

@@ -19,7 +19,7 @@
 
 const { isDeprecatedEnabled } = require('../base/specialOptions');
 const {
-  dictAdd, dictAddArray, dictFirst, dictForEach,
+  dictAdd, dictAddArray, dictForEach,
 } = require('./dictionaries');
 const { weakLocation, weakRefLocation } = require('../base/location');
 const { CompilerAssertion } = require('../base/error');
@@ -37,6 +37,7 @@ const {
   proxyCopyMembers,
   setExpandStatus,
   dependsOnSilent,
+  isLeadingQuery,
   columnRefStartsWithSelf,
   forEachDefinition,
   forEachMember,
@@ -127,7 +128,7 @@ function populate( model ) {
       effectiveType( art.targetAspect );
       forEachGeneric( art.targetAspect, 'elements', traverseElementEnvironments );
     }
-    else if (art !== art._main?._leadingQuery) { // already done for leading query elems
+    else if (!isLeadingQuery( art )) { // already done for leading query elems
       while (art.items)
         art = art.items;
       forEachMember( art, traverseElementEnvironments );
@@ -209,7 +210,7 @@ function populate( model ) {
       // For a query and its parent (usually the query entity!), it is the other way
       // around: to calculate the _effectiveType of the query entity, we might need
       // to calculate the _effectiveType of a query in FROM first.
-      if (a.kind !== 'select')
+      if (a.kind !== 'select' && a.kind !== '$tableAlias')
         effectiveType( a._outer || a._main && a._parent );
       // TODO: forbid $self+$self.elem inline, see expandWildcard()
       // Without type, value.path or _origin at beginning, link to itself:
@@ -267,24 +268,29 @@ function populate( model ) {
     }
 
     // With properties to be calculated: ----------------------------------------
-    if (art.query && art.kind !== '$tableAlias') { // query entity
+    if (art.kind === '$tableAlias') {
+      if (!origEffective)
+        return origEffective;
+      proxyCopyMembers( art, 'elements', origEffective.elements, art.path?.location,
+                        '$navElement' );
+      return art;
+    }
+    if (art.query) {            // query entity/event/...
       const leading = art.$queries[0];
       if (!leading)             // parse error
         return null;
       if (leading._effectiveType !== undefined) {
-        // You cannot refer to a query of another artifact:
         throw new CompilerAssertion(
           `Unexpected _effectiveType on leading query of ${ art.name.id }`
         );
       }
-      // TODO: try just return (effectiveType( leading )) === 0 ? 0 : art;
       setLink( leading, '_effectiveType', 0 ); // relevant to detect invalid $self.*
       populateQuery( leading );
       setLink( leading, '_effectiveType', leading );
       leading.$effectiveSeqNo = ++effectiveSeqNo;
       return art;
     }
-    if (art.from)
+    if (art.from)               // non-leading query
       return populateQuery( art );
 
     if (art.expand) {
@@ -292,7 +298,7 @@ function populate( model ) {
       // (we could allow that later: then some basic structural check is needed)
       if (!art.value) {
         initFromColumns( art, art.expand );
-        if (origEffective?.target) // consider `{ … } as x: AssocType
+        if (origEffective?.target) // consider future feature `{ … } as x: AssocType
           redirectImplicitly( art, origEffective );
       }
       else if (art.value.path) {
@@ -368,35 +374,19 @@ function populate( model ) {
   }
 
   function getOriginRaw( art ) {
-    if (!art._main) {
-      if (art.query)
-        return getOrigin( art.$queries?.[0] );
-      // TODO: if we add the `includes` mechanism, use resolveUncheckedPath() for
-      // includes here, because the accept function for includes requires the
-      // elements to have been calculated!
-    }
-    else {
-      // TODO: write checks for path in enum?
-      if (art.value?.path)
-        return resolvePath( art.value, (art.$syntax === 'calc' ? 'calc' : 'column'), art );
-      if (art.kind === 'select') {
-        const alias = dictFirst( art.$tableAliases );
-        // With parse errors, the first “alias” might be $self.  Using its origin
-        // would lead to a cyclic processing dependency.
-        return (alias.kind === '$tableAlias') ? getOrigin( alias ) : null;
-      }
+    if (art.value?.path)
+      return resolvePath( art.value, (art.$syntax === 'calc' ? 'calc' : 'column'), art );
+
+    if (art.kind === '$tableAlias') {
       // init sets _origin for alias to sub query, only need to handle ref here:
-      if (art.kind === '$tableAlias') {
-        // do not call effectiveType() on the source to avoid a deeper callstack
-        const source = resolvePath( art, 'from', art._parent );
-        if (!source?._main)
-          return source;        // direct entity (or undefined)
-        // Before having done the resolvePath cleanup, do not rely on resolvePath
-        // to call effectiveType() on the last assoc of a from ref:
+      const source = resolvePath( art, 'from', art._parent );
+      if (!source?._main)
+        return source;        // direct entity (or undefined)
+      // Before having done the resolvePath cleanup, do not rely on resolvePath
+      // to call effectiveType() on the last assoc of a from ref:
         // TODO: check this with test3/Queries/DollarSelf/CorruptedSource.err.cds
-        const assoc = effectiveType( source );
-        return assoc?.target._artifact;
-      }
+      const assoc = effectiveType( source );
+      return assoc?.target._artifact;
     }
     return '';
   }
@@ -441,10 +431,6 @@ function populate( model ) {
   }
 
   function expandElements( art, struct ) {
-    if (art.kind === '$tableAlias') {
-      proxyCopyMembers( art, 'elements', struct.elements, art.path?.location, '$navElement' );
-      return true;
-    }
     if (art.elements || art.kind === '$inline' ||
         // no element expansions for "non-proper" types like
         // entities (as parameter types) etc:
@@ -552,7 +538,6 @@ function populate( model ) {
   //--------------------------------------------------------------------------
 
   // TODO: delete XSN._entities
-  // TODO: delete ENTITY._from - use _origin? instead _from[0]
 
   /**
    * Merge _specified_ elements with _inferred_ elements in the given view/element,
@@ -779,7 +764,7 @@ function populate( model ) {
     const elemsParent = query.items || query;
     if (!inlineHead) {
       elemsParent.elements = Object.create( null );
-      if (query._main._leadingQuery === query) // never the case for 'expand'
+      if (isLeadingQuery( query )) // never the case for 'expand'
         query._main.elements = elemsParent.elements;
     }
 
@@ -1085,7 +1070,7 @@ function populate( model ) {
     if (assoc.kind === 'mixin')
       return false;
     const query = userQuery( assoc );
-    return !query || query._main._leadingQuery === query;
+    return !query || isLeadingQuery( query );
   }
 
   function redirectImplicitlyDo( elem, assoc, target, service ) {
@@ -1258,35 +1243,35 @@ function populate( model ) {
   }
 
   function isDirectProjection( proj, base ) {
-    return proj.kind === 'entity' && // not event
-      // direct proj (TODO: or should we add them to another list?)
-      proj.query && proj.query.op && proj.query.op.val === 'SELECT' &&
-      proj._from && proj._from.length === 1 &&
-      base === resolvePath( proj._from[0], 'from', proj.query );
+    const { query } = proj;
+    return query?.op?.val === 'SELECT' && proj.kind === 'entity' && // not event
+      query.from?.path &&
+      // TODO: what about navigation along assoc?
+      base === resolvePath( query.from, 'from', query );
   }
 
   // Auto-exposure -----------------------------------------------------------
 
-  // TODO: do something in kick-start.js ?
   // Remark: With includes, the compiler propagates @cds.autoexpose early.
   function isAutoExposed( target ) {
+    // remark: effectiveType( target ) has been called → we can use links directly
     if (target.$autoexpose !== undefined)
       return target.$autoexpose;
-    // Remark: this can probably be simplified now that we have called
-    // effectiveType() on the original target
+
     const origTarget = target;
     const chain = [];
-    const alias1 = target._from?.[0]; // TODO: delete ENTITY._from ?
-    let source = alias1 && resolvePath( alias1, 'from', alias1._parent );
-    // query source ref might not have been resolved yet, cycle avoided as
-    // setAutoExposed() sets $autoexpose and a second call on same art would
-    // return false
-    while (target.$autoexpose === undefined && setAutoExposed( target ) && source) {
+    while (target.$autoexpose === undefined && setAutoExposed( target )) {
       // stop at first ancestor with annotation or at non-query entity
+      let source = target._origin; // first table alias of leading query
+      // no propagation along `Source:assoc` → cannot traverse source._origin
+      // until we find main artifact
+      while (source?._origin?._main) // sub query in from
+        source = source._origin._origin; // its first table alias
+      source = source?._artifact; // different to source._origin if `Source:assoc`
+      if (!source || source._main) // ref error of `Source:assoc`
+        break;
       chain.push( target );
       target = source;
-      const alias = target._from?.[0]; // TODO: delete ENTITY._from ?
-      source = alias && resolvePath( alias, 'from', alias._parent );
     }
     const autoexpose = target.$autoexpose;
     if (typeof autoexpose === 'boolean') {
@@ -1302,11 +1287,11 @@ function populate( model ) {
     if (anno && anno.val !== null) { // XSN TODO: set val, but no location for anno short form
       // @cds.autoexpose:true or @cds.autoexpose:false
       art.$autoexpose = anno.val === undefined || !!anno.val;
-      return false;
+      return false;             // stop with @cds.autoexpose
     }
     // no @cds.autoexpose or @cds.autoexpose:null
     art.$autoexpose = model.$compositionTargets[art.name.id] ? true : null;
-    return true;                // still check for inherited @cds.autoexpose
+    return art.query; // still check for inherited @cds.autoexpose if query entity
   }
 
   function autoExposedName( target, service, elemScope ) {

package/node_modules/@sap/cds-compiler/lib/compiler/propagator.js

@@ -12,12 +12,12 @@ const {
   setLink,
   linkToOrigin,
   withAssociation,
-  viewFromPrimary,
   copyExpr,
   forEachDefinition,
   forEachMember,
   forEachGeneric,
 } = require('./utils');
+
 const { propagationRules } = require('../base/builtins');
 const $inferred = Symbol.for( 'cds.$inferred' );
 const { xprRewriteFns } = require('./xpr-rewrite');
@@ -328,11 +328,20 @@ function propagate( model ) {
   }
 
   function onlyViaArtifact( prop, target, source ) {
-    const from = viewFromPrimary( target )?.path;
-    // do not propagate from member / if follow assoc in from or into `returns` of actions (v4)
-    if (!(from ? from[from.length - 1]._artifact : source)._main &&
-       !(target._parent && target._parent.returns === target))
-      annotation( prop, target, source );
+    if (source._main)           // don't propagate from member
+      return;
+    // TODO v8: also do not propagate into member in general, now just not into returns
+    if (target._parent?.returns === target)
+      return;
+    // Additionally, do not propagate for `select from Source:assoc`:
+    if (target.query) {
+      let alias = target._origin;
+      while (alias?._origin?._main) // sub query in from
+        alias = alias._origin._origin; // its first table alias
+      if (alias?._artifact?._main) // Source:assoc` (BTW, `source` is its target)
+        return;
+    }
+    annotation( prop, target, source );
   }
 
   /**
@@ -426,7 +435,7 @@ function targetMinZero( art ) {
 
 function getOrigin( art ) {
   let origin = art._origin;
-  while (origin?.kind === 'select')
+  while (origin?.kind === '$tableAlias' || origin?.kind === 'select')
     origin = origin._origin;
   if (origin)
     // Do not consider _origin if due to expand of table alias ref

package/node_modules/@sap/cds-compiler/lib/compiler/resolve.js

@@ -59,6 +59,7 @@ const {
   compositionTextVariant,
   targetCantBeAspect,
   userParam,
+  isLeadingQuery,
   userQuery,
   forEachDefinition,
   forEachMember,
@@ -616,6 +617,8 @@ function resolve( model ) {
       }
     }
 
+    checkUnmanagedAssocInType( art );
+
     // Set '@Core.Computed' in the Core Compiler to have it propagated...
     if (art.kind !== 'element' || art['@Core.Computed'])
       return;
@@ -877,6 +880,20 @@ function resolve( model ) {
     }
   }
 
+  /**
+   * Warn if a type contains an unmanaged association, because the ON-condition
+   * can't be rewritten if the type is used as element type.
+   */
+  function checkUnmanagedAssocInType( art ) {
+    if (art._main?.kind !== 'type')
+      return;
+    if (!art.target || !getInheritedProp( art, 'on' ))
+      return;
+
+    warning( 'def-unsupported-assoc', [ art.name.location, art ], {},
+             'With an unmanaged association, a type can only be used as include' );
+  }
+
   /**
    * Issue warnings for restrictions concerning `localized`, i.e. for situations
    * where a (later) inherited `localized` does not lead to the texts entity
@@ -1016,20 +1033,14 @@ function resolve( model ) {
       resolveExpr( col.value, 'column', col );
     // for (const col of query.$inlines)
     //   if (!col.value.path) throw new CompilerAssertion(col.name.element)
-    if (query !== query._main._leadingQuery) // will be done later
+    if (!isLeadingQuery( query )) // will be done later
       forEachGeneric( query, 'elements', resolveRefs );
     if (query.from)
       resolveJoinOn( query.from );
-    if (query.where) {
-      const user = query.where._block ? query.where : query;
-      resolveExpr( query.where, 'where', user );
-    }
+    resolveWhereOrHaving( query, 'where' );
     if (query.groupBy)
       resolveBy( query.groupBy, 'groupBy', 'groupBy' );
-    if (query.having) {
-      const user = query.having._block ? query.having : query;
-      resolveExpr( query.having, 'having', user );
-    }
+    resolveWhereOrHaving( query, 'having' );
     if (query.$orderBy)       // ORDER BY from UNION:
       // TODO clarify: can I access the tab alias of outer queries?  If not:
       // 4th arg query._main instead query._parent.
@@ -1087,6 +1098,23 @@ function resolve( model ) {
     }
   }
 
+  function resolveWhereOrHaving( query, prop ) {
+    const expr = query[prop];
+    if (!expr)
+      return;
+    const merged = expr.op?.val === 'and' &&
+      expr.args.some( a => a.$extended === prop );
+    if (!merged) {
+      const user = expr._block ? expr : query;
+      resolveExpr( expr, prop, user );
+      return;
+    }
+    for (const arg of expr.args) {
+      const user = arg._block ? arg : query;
+      resolveExpr( arg, prop, user );
+    }
+  }
+
   /**
    * Resolve user-provided target.
    */
@@ -1186,8 +1214,7 @@ function resolve( model ) {
         if (assoc.on.$inferred)
           return;
         const query = userQuery( assoc );
-        const main = query?._main;
-        if (query && query !== main._leadingQuery) {
+        if (query && !isLeadingQuery( query )) {
           const { txt, op } = getQueryOperatorName( query );
           const { location, id } = path[0];
           error( 'ref-unexpected-self', [ location, assoc ], { '#': txt, id, op } );
@@ -1662,7 +1689,7 @@ function resolve( model ) {
             .filter( i => i ),  // _artifact may be `null` if the include cannot be found
         } );
       }
-      const query = art._leadingQuery;
+      const query = art.$queries?.[0];
       if (!query)
         return false;           // non-query entity
       if (!query.$tableAliases) // previous error in query definition
@@ -1781,8 +1808,7 @@ function resolve( model ) {
       const { query } = expr;
       if (!query.from && !query.args) // parser error
         return type;                  // ...see also TODO in initQueryExpression()
-      if (query._main?.kind === 'type' ||
-         (!query.kind && !query._leadingQuery)) { // UNION has _leadingQuery
+      if (query._main?.kind === 'type' || query._origin === undefined) {
         error( 'expr-no-subquery', [ expr.location, user ], {
           '#': query._main?.kind === 'type' ? 'type' : 'std',
         }, {
@@ -1837,7 +1863,7 @@ function resolve( model ) {
       const unexpectedFilter = (expected !== 'annotation' && expected !== 'column' &&
           expected !== 'calc' && 'std') ||
         isQuasiVirtualAssociation( type ) && 'model-only' ||
-        last.where?.args?.length === 0 && 'last-empty-filter';
+        expected === 'annotation' && last.where?.args?.length === 0 && 'last-empty-filter';
       reportUnexpectedArgsAndFilter( last, expected, user, art, unexpectedFilter );
     }
     // TODO: we should have different message-ids for the "last" stuff: adding

package/node_modules/@sap/cds-compiler/lib/compiler/shared.js

@@ -63,6 +63,7 @@ function fns( model ) {
       lexical: userBlock,
       dynamic: modelDefinitions,
       notFound: undefinedForAnnotate,
+      messageMap: { 'ref-undefined-def': 'ext-undefined-def' },
       accept: extendableArtifact,
     },
     'annotate-sec': {
@@ -1678,16 +1679,15 @@ function fns( model ) {
   /**
    * Returns true, if the artifact is a _real_ artifact that can be used for `extend`/`annotate`.
    */
-  function extendableArtifact( art, user, ref ) {
+  function extendableArtifact( art, user, ref, semantics ) {
     if (art.kind !== 'namespace')
       return art;
     const { location } = ref.path[ref.path.length - 1];
-    if (user.kind === 'extend' && !(user.elements || user.actions || user.includes))
-      return art; // allow `extend with definitions` and empty extends
+    if (user.artifacts)
+      return art; // allow `extend with definitions` on "namespace" without message
 
     // for `annotate`, handle "namespaces" just like unknown artifacts: only emit a warning
-    signalNotFound( user.kind === 'annotate' ? 'ext-undefined-def' : 'ref-undefined-def',
-                    [ location, user ], null, { art } );
+    signalNotFound( 'ref-undefined-def', [ location, user ], null, { art }, semantics );
     return false;
   }
 
@@ -2024,6 +2024,7 @@ function fns( model ) {
   }
 
 
+  // for message text variant and text argument:
   // right of union: parent = main → get correct operator
   // FROM subquery: parent = tab alias of outer query
   // other sub query: parent = outer query
@@ -2033,7 +2034,7 @@ function fns( model ) {
 
     for (let set = query._main.query; set.op; set = set.args[0]) {
       const right = set.args[1];
-      if (query.name.id >= ((right._leadingQuery || right).name?.id ?? 0))
+      if (right.name && query.name.id >= (right.name.id ?? 0))
         return { txt: 'setQuery', op: set.op.val };
     }
     throw new CompilerAssertion( 'Did we pass the leading query as argument?' );