@sap/cds-compiler 6.4.6 → 6.5.2

package/lib/compiler/extend.js

@@ -19,8 +19,14 @@ const {
   copyExpr,
   setExpandStatusAnnotate,
   linkToOrigin,
+  initItemsLinks,
+  setMemberParent,
   createAndLinkCalcDepElement,
+  initExprAnnoBlock,
+  initDollarSelf,
+  initBoundSelfParam,
   dependsOnSilent,
+  storeExtension,
   pathName,
   annotationHasEllipsis,
 } = require('./utils');
@@ -62,7 +68,8 @@ function extend( model ) {
     resolveTypeArgumentsUnchecked,
     resolveDefinitionName,
     attachAndEmitValidNames,
-    initMembers,
+    targetIsTargetAspect,
+    checkRedefinition,
     initSelectItems,
   } = model.$functions;
 
@@ -730,12 +737,15 @@ function extend( model ) {
 
     for (const ext of extensions) {
       if (!artReturns && art.kind !== 'annotate') {
-        warning( 'ext-unexpected-returns', [ ext.returns.location, ext ], {
+        const msgId = ext.returns && hasSecurityAnno( ext.returns )
+          ? 'ext-unexpected-returns-sec'
+          : 'ext-unexpected-returns';
+        message( msgId, [ ext.returns.location, ext ], {
           '#': (isAction ? art.kind : 'std'), keyword: 'returns',
         }, {
           std: 'Unexpected $(KEYWORD); only actions and functions have return parameters',
           action: 'Unexpected $(KEYWORD) for action without return parameter',
-          // function without `returns` can happen via CSN input!
+          // function without `returns` can happen via CSN input! TODO: check in parser
           function: 'Unexpected $(KEYWORD) for function without return parameter',
         } );
         // Do not put completely wrong returns into a “super annotate” statement;
@@ -816,7 +826,8 @@ function extend( model ) {
     // if we consider this an error or such sub annotates are then ignored
     // (i.e. not put into the "super annotate").
     const dict = parent[prop];
-    if (!dict) {
+    const securityRelevant = hasSecurityAnno( ext ) ? '-sec' : '';
+    if (!dict && !securityRelevant) {
       // TODO: check - for each name? - better locations
       const location = ext._parent?.[prop]?.[$location] || ext.name.location;
       // Remark: no `elements` dict location with `annotate Main:elem`
@@ -851,37 +862,36 @@ function extend( model ) {
       }
       return false;
     }
-    else if (!dict[name]) {
+    else if (!dict?.[name]) {
       // TODO: make variant `returns` an auto-variant for ($ART) ?
-      const inReturns = parent._parent?.returns && parent._parent;
-      const art = inReturns || parent;
+      const inReturns = parent._parent?.returns;
       switch (prop) {
         case 'elements':
           if (canBeDraftMember( name, parent, draftElements ))
             break;
-          notFound( 'ext-undefined-element', ext.name.location, ext,
-                    { '#': (inReturns ? 'returns' : 'element'), art, name },
+          notFound( `ext-undefined-element${ securityRelevant }`, ext.name.location, ext,
+                    { '#': (inReturns ? 'returns' : 'element'), name },
                     parent.elements );
           break;
         case 'enum':            // TODO: extra msg id?
-          notFound( 'ext-undefined-element', ext.name.location, ext,
-                    { '#': (inReturns ? 'enum-returns' : 'enum'), art, name },
+          notFound( `ext-undefined-element${ securityRelevant }`, ext.name.location, ext,
+                    { '#': (inReturns ? 'enum-returns' : 'enum'), name },
                     parent.enum );
           break;
         case 'foreignKeys':
-          notFound( 'ext-undefined-key', ext.name.location, ext,
+          notFound( `ext-undefined-key${ securityRelevant }`, ext.name.location, ext,
                     { name }, parent.foreignKeys );
           break;
         case 'params':
-          notFound( 'ext-undefined-param', ext.name.location, ext,
-                    { '#': 'param', art: parent, name },
+          notFound( `ext-undefined-param${ securityRelevant }`, ext.name.location, ext,
+                    { '#': 'param', name },
                     parent.params );
           break;
         case 'actions':
           if (canBeDraftMember( name, parent, draftBoundActions ))
             break;
-          notFound( 'ext-undefined-action', ext.name.location, ext,
-                    { '#': 'action', art: parent, name },
+          notFound( `ext-undefined-action${ securityRelevant }`, ext.name.location, ext,
+                    { '#': 'action', name },
                     parent.actions );
           break;
         default:
@@ -924,8 +934,16 @@ 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 ) {
-    if (!resolvePath( ext.name, ext.kind, ext )) // error for extend, info for annotate
+    const refCtx = ext.kind === 'annotate' && hasSecurityAnno( ext )
+      ? 'annotate-sec'
+      : ext.kind;
+    if (!resolvePath( ext.name, refCtx, ext )) // error for extend, info for annotate
       return;
 
     if (art?.builtin) {
@@ -1186,6 +1204,272 @@ function extend( model ) {
     }
   }
 
+  // TODO TMP: copied from ./define.js: -----------------------------------------
+
+  /**
+   * Set property `_parent` for all elements in `parent` to `parent` and do so
+   * recursively for all sub elements.
+   *
+   * If not for extensions: construct === parent
+   *
+   * TODO: separate extension!
+   */
+  function initMembers( construct, parent, block ) {
+    // TODO: split extend from init
+    const main = parent._main || parent;
+    const isQueryExtension = construct.kind === 'extend' && main.query;
+    let obj = initItemsLinks( construct, block );
+    initExprAnnoBlock( construct, block );
+    if (obj.target && targetIsTargetAspect( obj )) {
+      obj.targetAspect = obj.target;
+      delete obj.target;
+    }
+    const { targetAspect } = obj;
+    if (targetAspect) {
+      if (obj.foreignKeys) {
+        error( 'type-unexpected-foreign-keys', [ obj.foreignKeys[$location], construct ] );
+        delete obj.foreignKeys; // continuation semantics: not specified
+      }
+      if (obj.on && !obj.target) {
+        error( 'type-unexpected-on-condition', [ obj.on.location, construct ] );
+        delete obj.on;          // continuation semantics: not specified
+      }
+      if (targetAspect.elements)
+        initAnonymousAspect();
+    }
+    if (obj !== parent && obj.elements && parent.enum) { // applying the extension
+      initElementsAsEnum();
+    }
+    else {
+      if (checkDefinitions( construct, parent, 'elements', obj.elements || false ))
+        forEachInOrder( obj, 'elements', init );
+      if (checkDefinitions( construct, parent, 'enum', obj.enum || false ))
+        forEachGeneric( obj, 'enum', init );
+    }
+
+    if (obj.foreignKeys)
+      forEachInOrder( obj, 'foreignKeys', init );
+    if (checkDefinitions( construct, parent, 'actions' ))
+      forEachGeneric( construct, 'actions', init );
+    if (checkDefinitions( construct, parent, 'params' ))
+      forEachInOrder( construct, 'params', init );
+    const { returns } = construct;
+    if (returns) {
+      const { kind } = construct;
+      returns.kind = (kind === 'extend' || kind === 'annotate') ? kind : 'param';
+      init( returns, '' );      // '' is special name for returns parameter
+    }
+    return;
+
+    function initElementsAsEnum() {
+      // in extensions, extended enums are represented as elements
+      let hasElement = false;
+      for (const n in obj.elements) {
+        const e = obj.elements[n];
+        if (e.kind === 'extend')
+          continue;
+        const noVal = e.value?.val === undefined && e.value?.sym === undefined;
+        // TODO: forbid #symbol as enum value
+        if (e.$syntax === 'element' || // `extend … with elements` or `extend with { element … }`
+            noVal && e.$syntax !== 'enum' || // no value in CDL input
+            e.virtual || e.key || e.masked || e.type || e.elements || e.items || e.stored) {
+          // We do not want to complain separately about all element properties:
+          error( 'ext-unexpected-element', [ e.location, construct ],
+                 { name: e.name.id, code: 'extend … with enum' },
+                 // eslint-disable-next-line @stylistic/max-len
+                 'Unexpected elements like $(NAME) in an extension for an enum. Additionally, use $(CODE) when extending enums' );
+          // Don't emit 'ext-expecting-enum' if this error is emitted.
+          return;
+        }
+        e.kind = 'enum';
+        if (noVal || e.$syntax !== 'enum')
+          hasElement = true;    // warning with CDL input or `name: {}` in CSN input
+      }
+      if (hasElement) {
+        // This message is similar to the one above.  In v6, we could probably
+        // turn this warning into an error, remove `$syntax: 'element',
+        // and use the above `ext-unexpected-element` only for CSN input.
+        warning( 'ext-expecting-enum', [ obj.elements[$location], construct ],
+                 { code: 'extend … with enum' }, 'Use $(CODE) when extending enums' );
+      }
+      forEachGeneric( { enum: obj.elements }, 'enum', init );
+    }
+
+    function initAnonymousAspect() {
+      // TODO: main?
+      const inEntity = parent._main?.kind === 'entity';
+      // TODO: also allow indirectly (component in component in entity)?
+      setLink( targetAspect, '_outer', obj );
+      setLink( targetAspect, '_parent', parent._parent );
+      setLink( targetAspect, '_main', null ); // for name resolution
+
+      parent = targetAspect;
+      construct = parent;     // avoid extension behavior
+      targetAspect.kind = 'aspect';   // TODO: probably '$aspect' to detect
+      setLink( targetAspect, '_block', block );
+      initDollarSelf( targetAspect );
+      // allow ref of up_ in anonymous aspect inside entity
+      // (TODO: complain if used and the managed composition is included into
+      // another entity - might induce auto-redirection):
+      if (inEntity && !targetAspect.elements.up_) {
+        const up = {
+          name: { id: 'up_' },
+          kind: '$navElement',
+          location: obj.location,
+        };
+        setLink( up, '_parent', targetAspect );
+        setLink( up, '_main', targetAspect ); // used on main artifact
+        // recompilation case: both target and targetAspect → allow up_ in that case, too:
+        const name = obj.target && resolveUncheckedPath( obj.target, 'target', obj );
+        const entity = name && model.definitions[name];
+        if (entity && entity.elements)
+          setLink( up, '_origin', entity.elements.up_ );
+        // processAspectComposition/expand() sets _origin to element of
+        // generated target entity
+        targetAspect.$tableAliases.up_ = up;
+      }
+      obj = targetAspect;
+    }
+
+    function init( elem, name, prop ) {
+      if (!elem.kind)           // wrong CSN input
+        elem.kind = dictKinds[prop];
+      if (!elem.name && !elem._outer) {
+        const ref = elem.targetElement || elem.kind === 'element' && elem.value;
+        if (ref && ref.path) {
+          elem.name = Object.assign( { $inferred: 'as' },
+                                     ref.path[ref.path.length - 1] );
+        }
+        else {                  // RETURNS, parser robustness
+          elem.name = { id: name, location: elem.location };
+        }
+      }
+
+      if (!elem._block)
+        setLink( elem, '_block', block );
+      // if (!kindProperties[ elem.kind ]) console.log(elem.kind,elem.name)
+      if ((elem.kind === 'extend' || elem.kind === 'annotate')) {
+        storeExtension( elem, name, prop, parent );
+        return;
+      }
+      if (isQueryExtension && elem.kind === 'element') {
+        error( 'extend-query', [ elem.location, construct ], // TODO: searchName ?
+               { code: 'extend projection' },
+               'Use $(CODE) to add select items to the query entity' );
+        return;
+      }
+
+      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 );
+      checkRedefinition( elem );
+      initMembers( elem, elem, elem._block );
+      if (elem.kind === 'action' || elem.kind === 'function')
+        initBoundSelfParam( elem.params, elem._main );
+
+      // for a correct home path, setMemberParent needed to be called
+
+      if (!elem.value || elem.kind !== 'element' ||
+          elem.$syntax === 'enum' && parent.kind === 'extend') // ambiguous in parse-cdl
+        return;
+      // -> it's a calculated element
+      if (!elem.type && elem.value?.type) {  // top-level CAST( expr AS type )
+        if (!elem.target)
+          elem.type = { ...elem.value.type, $inferred: 'cast' };
+      }
+      elem.$syntax = 'calc';
+      // TODO: it is not just "syntax" - maybe better test for `$calcDepElement`?
+      createAndLinkCalcDepElement( elem );
+
+      // Special case (hack) for calculated elements that use composition+filter:
+      // See "Notes on `$enclosed`" 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;
+      }
+    }
+  }
+
+  // TODO: is only necessary for extensions - make special for extend/annotate
+  function checkDefinitions( construct, parent, prop, dict = construct[prop] ) {
+    // TODO: do differently, see also annotateMembers() in resolver
+    // To have been checked by parsers:
+    // - artifacts (CDL-only anyway) only inside [extend] context|service
+    if (!dict)
+      return false;
+    const feature = kindProperties[parent.kind ?? 'element'][prop];
+    if (feature &&
+        (feature === true || construct.kind !== 'extend' || feature( prop, parent )))
+      return true;
+    const location = dict[$location];
+
+    // TODO: a bit inconsistent = not a simple switch on `prop`…
+    if (prop === 'actions') {
+      if (Object.keys( dict ).length) {
+        error( 'def-unexpected-actions', [ location, construct ], {}, // TODO: ext-
+               'Actions and functions only exist top-level and for entities' ); // or aspects
+      }
+      else {
+        warning( 'ext-ignoring-actions', [ location, construct ], {},
+                 'Actions and functions only exist top-level and for entities' );
+        return false;
+      }
+    }
+    else if (parent.kind === 'action' || parent.kind === 'function') {
+      error( 'ext-unexpected-action', [ construct.location, construct ], { '#': parent.kind }, {
+        std: 'Actions and functions can\'t be extended, only annotated', // TODO: → ext-unsupported
+        action: 'Actions can\'t be extended, only annotated',
+        function: 'Functions can\'t be extended, only annotated',
+      } );
+    }
+    else if (prop === 'params') {
+      if (!feature) {
+        // Note: This error can't be triggered at the moment.  But as we likely want to
+        //       allow extensions with params in the future, we keep the code.
+        error( 'def-unexpected-params', [ location, construct ], {},
+               'Parameters only exist for entities, actions or functions' );
+      }
+      else {
+        // remark: we could allow this
+        error( 'extend-with-params', [ location, construct ], {},
+               'Extending artifacts with parameters is not supported' );
+      }
+    }
+    else if (feature) {         // allowed in principle, but not with extend
+      if (!Object.keys( dict ).length) {
+        warning( 'ext-ignoring-elements', [ location, construct ], {},
+                 'Only structures with directly specified elements can be extended by elements' );
+        return false;
+      }
+      else if (parent.$inferred === 'include') { // special case for better error message
+        const variant = (construct.enum || construct.elements) ? 'elements' : 'std';
+        error( 'ref-expected-direct-structure', [ location, construct ],
+               { '#': variant, art: parent } );
+      }
+      else {
+        error( 'extend-type', [ location, construct ], {},
+               'Only structures or enum types can be extended with elements/enums' );
+      }
+    }
+    else if (prop === 'elements') {
+      error( 'def-unexpected-elements', [ location, construct ], {},
+             'Elements only exist in entities, types or typed constructs' );
+    }
+    else if (prop === 'columns') {
+      error( 'extend-columns', [ location, construct ], { art: construct } );
+    }
+    else { // if (prop === 'enum') {
+      error( 'def-unexpected-enum', [ location, construct ], {},
+             'Enum symbols can only be defined for types or typed constructs' );
+    }
+    return construct === parent;
+  }
+
+
   // includes ----------------------------------------------------------------
 
   /**
@@ -1228,7 +1512,7 @@ function extend( model ) {
    * Sets `_ancestors` links on `art`.
    *
    * TODO: try to set `_ancestors` only to entities (but beware “intermediate”
-   * non-entities).
+   * non-entities - TODO: make intermediate non-entities stop chain).
    *
    * Examples:
    *   ext === art:  `entity E : F {}`  => add elements of F to E

package/lib/compiler/finalize-parse-cdl.js

@@ -42,7 +42,7 @@ function finalizeParseCdl( model ) {
       for (const ext of late[name]._extensions) {
         ext.name.id = resolveUncheckedPath( ext.name, '_uncheckedExtension', ext );
         // Initialize members and define annotations in sub-elements.
-        initMembers( ext, ext, ext._block, true );
+        initMembers( ext );
         extensions.push( ext );
       }
     }
@@ -117,15 +117,7 @@ function finalizeParseCdl( model ) {
     // containing it.  Otherwise some type's aren't properly resolved.
     // TODO: If resolveTypeUnchecked is reworked, we may be able to simplify this coding.
     (artifact.$queries || []).forEach( art => resolveTypesForParseCdl( art, artifact ) );
-    (artifact.columns || []).forEach( (col) => {
-      // TODO: Can we use "ensureColumnName" of populate.js? It depends on column indices
-      //  _after_ wildcards were expanded, though.
-      if (!col.name && col.value?.path) {
-        const last = col.value.path.at(-1);
-        col.name = { id: last?.id || '', location: last?.location, $inferred: 'as' };
-      }
-      resolveTypesForParseCdl( col, artifact );
-    } );
+    (artifact.columns || []).forEach( col => resolveTypesForParseCdl( col, artifact ) );
     forEachGeneric( artifact, 'mixin', art => resolveTypesForParseCdl( art, artifact ) );
 
     // For better error messages for `type of`s in `returns`, we pass the object as the new main.

package/lib/compiler/generate.js

@@ -31,7 +31,7 @@ function generate( model ) {
   const {
     resolvePath,
     resolveUncheckedPath,
-    initArtifact,
+    initMainArtifact,
     extendArtifactBefore,
     applyIncludes,
   } = model.$functions;
@@ -340,7 +340,7 @@ function generate( model ) {
     for (const orig of textElems)
       addElementToTextsEntity( orig, art, fioriEnabled, assertUniqueValue );
 
-    initArtifact( art );
+    initMainArtifact( art );
     if (art.includes) {
       // add elements `locale`, etc. which are required below.
       applyIncludes( art, art ); // TODO: rethink - can we avoid this if only new extend?
@@ -411,6 +411,8 @@ function generate( model ) {
     const { location } = art;
 
     art.includes = [ createInclude( textsAspectName, location ) ];
+    propagateEarly( art, '@cds.autoexpose' );
+    propagateEarly( art, '@fiori.draft.enabled' );
 
     if (fioriEnabled) {
       // "Early" include; only for element `locale`, which has its `key` property
@@ -490,6 +492,7 @@ function generate( model ) {
 
   /**
    * Create a structure that can be used as an item in `includes`.
+   * TODO: replace by linkMainArtifact()
    *
    * @param {string} name
    * @param {XSN.Location} location
@@ -638,7 +641,7 @@ function generate( model ) {
              'An aspect $(TARGET) with an element named $(NAME) can\'t be used as target' );
       return false;
     }
-    if (model.definitions[entityName]) {
+    if (model.definitions[entityName]) { // TODO: allow a gap (namespace)?
       error( null, [ location, elem ], { art: entityName },
              // eslint-disable-next-line @stylistic/max-len
              'Target entity $(ART) can\'t be created as there is another definition with this name' );
@@ -696,8 +699,11 @@ function generate( model ) {
       $inferred: 'composition-entity',
     };
     if (target.name) {          // named target aspect
-      if (!isDeprecatedEnabled( options, 'noCompositionIncludes' ))
+      if (!isDeprecatedEnabled( options, 'noCompositionIncludes' )) {
         art.includes = [ createInclude( target.name.id, location ) ];
+        propagateEarly( art, '@cds.autoexpose' );
+        propagateEarly( art, '@fiori.draft.enabled' );
+      }
       setLink( art, '_origin', target );
       setLink( art, '_upperAspects', [ target, ...(elem._main._upperAspects || []) ] );
     }
@@ -736,7 +742,7 @@ function generate( model ) {
 
     setLink( art, '_block', model.$internal );
     model.definitions[entityName] = art;
-    initArtifact( art );
+    initMainArtifact( art );
 
     // Apply annotations to generated artifact, prepare (not apply!) element
     // annotations (remark: adding elements is not allowed for generated artifacts):
@@ -858,4 +864,26 @@ function checkTextsLanguageAssocOption( model, options ) {
 }
 
 
+/**
+ * Propagate the given `prop` (e.g. annotation) early, i.e. copy it from all `.includes`
+ * if they have the property.
+ * TEMPORARY copy from ./extend.js
+ *
+ * @param {XSN.Definition} art
+ * @param {string} prop
+ */
+function propagateEarly( art, prop ) {
+  if (art[prop])
+    return;
+  for (const ref of art.includes) {
+    const aspect = ref._artifact;
+    if (aspect) {
+      const anno = aspect[prop];
+      if (anno && (anno.val !== null || !art[prop]))
+        art[prop] = Object.assign( { $inferred: 'include' }, anno );
+    }
+  }
+}
+
+
 module.exports = generate;

package/lib/compiler/kick-start.js

@@ -32,6 +32,9 @@ function kickStart( model ) {
    *  - service: the artifact of the embedding service
    * This function must be called ordered: parent first
    *
+   * Remark: _service links are not already set in define.js, because we might
+   * have a @cds.redirection.service in the future
+   *
    * @param {string} name Artifact name
    */
   function setAncestorsAndService( name ) {
@@ -50,16 +53,12 @@ function kickStart( model ) {
       return;
     // To be removed when nested services are allowed
     if (!isBetaEnabled( options, 'nestedServices' ) && art.kind === 'service') {
-      while (parent.kind !== 'service')
-        parent = parent._parent;
-      message( 'service-nested-service', [ art.name.location, art ], { art: parent },
+      message( 'service-nested-service', [ art.name.location, art ], { art: service },
                'A service can\'t be nested within a service $(ART)' );
     }
     else if (art.kind === 'context') {
-      while (parent.kind !== 'service')
-        parent = parent._parent;
       // TODO: remove this error
-      message( 'service-nested-context', [ art.name.location, art ], { art: parent },
+      message( 'service-nested-context', [ art.name.location, art ], { art: service },
                'A context can\'t be nested within a service $(ART)' );
     }
   }
@@ -73,7 +72,9 @@ function kickStart( model ) {
     // Service1.E = projection on E
 
     // Remark: _ancestors are also set with includes, and there also for aspects,
-    // types and events.
+    // types and events (TODO: entity only)
+    //
+    // Remark: _ancestors are also tested in populate.js for minmal exposure
     const chain = [];
     const autoexposed = annotationVal( art['@cds.autoexposed'] );
     // no need to set preferredRedirectionTarget in the while loop as we would