@sap/cds-compiler 6.6.2 → 6.7.1

package/lib/compiler/kick-start.js

@@ -1,24 +1,25 @@
 // Kick-start: prepare to resolve all references
 
+// Remark: it would probably be better to move this to extend.js
+
 'use strict';
 
-const { builtinLocation } = require('../base/location');
-const { isBetaEnabled, forEachGeneric } = require('../base/model');
+const { isBetaEnabled } = require('../base/model');
 const {
   setLink,
   annotationVal,
   annotationIsFalse,
-  isDirectComposition,
+  forEachGeneric,
 } = require('./utils');
 
 function kickStart( model ) {
   const { options } = model;
   const { message } = model.$messageFunctions;
 
-  const { resolveUncheckedPath, initMainArtifact } = model.$functions;
+  const { resolveUncheckedPath, createGapArtifact } = model.$functions;
 
   // Set _service link (sorted to set it on parent first).  Could be set
-  // directly, but beware a namespace becoming a service later.
+  // directly, but beware a gap artifact becoming a service later.
   Object.keys( model.definitions ).sort().forEach( setAncestorsAndService );
   forEachGeneric( model, 'definitions', postProcessArtifact );
   return;
@@ -40,8 +41,9 @@ function kickStart( model ) {
     const art = model.definitions[name];
     if (art._parent === undefined)
       return;                   // nothing to do for builtins and redefinitions
-    if (art.query && art._ancestors === undefined && art.kind === 'entity')
-      setProjectionAncestors( art );
+    if ((art.query || art._entityIncludes) &&
+        art._ancestors === undefined && art.kind === 'entity')
+      setProjectionAncestors( art ); // TODO: set to [] for other entities
 
     let parent = art._parent;
     if (parent === model.definitions.localized)
@@ -62,7 +64,7 @@ function kickStart( model ) {
     }
   }
 
-  function setProjectionAncestors( art ) {
+  function setProjectionAncestors( art ) { // TODO: rename
     // Must be run after processLocalizedData() as we could have a projection
     // on a generated entity.
 
@@ -70,19 +72,36 @@ function kickStart( model ) {
     // no redirection target for E if Service2.E = projection on Service1.E and
     // Service1.E = projection on E
 
-    // Remark: _ancestors are also set with includes, and there also for aspects,
-    // types and events (TODO: entity only)
-    //
+    //   Remark: _ancestors are also set with entity includes in extend.js,
     // Remark: _ancestors are also tested in populate.js for minmal exposure
+    //
+    // Remark: @cds.autoexpose is considered on-demand in populate.js
     const chain = [];
     const autoexposed = annotationVal( art['@cds.autoexposed'] );
     // no need to set preferredRedirectionTarget in the while loop as we would
     // use the projection having @cds.redirection.target anyhow instead of
     // `art` anyway (if we do the no-x-service-implicit-redirection TODO above)
-    while (art?.query?.from?.path && // direct select with one source
-           art._ancestors !== 0) {   // prevent inf-loop
-      chain.push( art );
+    while (art?.kind === 'entity' &&
+           (art.query?.from?.path || // direct select with one source
+            art._entityIncludes?.length) &&
+           !art._ancestors && art._ancestors !== 0) {   // prevent inf-loop
       setLink( art, '_ancestors', 0 ); // avoid infloop with cyclic from
+      if (art._entityIncludes?.length) {
+        if (art._entityIncludes.length === 1) {
+          chain.push( art );
+          art = art._entityIncludes[0];
+          continue;
+        }
+        setLink( art, '_ancestors', [] );
+        for (const incl of art._entityIncludes) {
+          if ((incl.query || incl._entityIncludes?.length) &&
+              incl._ancestors === undefined)
+            setProjectionAncestors( incl );
+          art._ancestors.push( ...(incl._ancestors || []), incl );
+        }
+        break;
+      }
+      chain.push( art );
       const name = resolveUncheckedPath( art.query.from, 'from', art );
       art = name && (model.definitions[name] || createGapArtifact( name ));
       if (autoexposed)
@@ -97,26 +116,7 @@ function kickStart( model ) {
     }
   }
 
-  function createGapArtifact( name, location = builtinLocation() ) {
-    // TODO: make it probably part of define.js
-    // TODO: make it work without location (or value undefined/null)
-    // TODO: change the location later if overwritten
-    const art = {
-      kind: 'namespace', name: { id: name, location }, location,
-    };
-    model.definitions[name] = art;
-    initMainArtifact( art );
-    return art;
-  }
-
   function postProcessArtifact( art ) {
-    tagCompositionTargets( art );
-    if (art.$queries) {
-      for (const query of art.$queries) {
-        if (query.mixin)
-          forEachGeneric( query, 'mixin', tagCompositionTargets );
-      }
-    }
     if (!art._ancestors || art.kind !== 'entity')
       return;                   // redirections only to entities
     const service = art._service;
@@ -130,28 +130,13 @@ function kickStart( model ) {
       if (ancestor._service === service || annotationIsFalse( art['@cds.redirection.target'] ))
         return;
       const desc = ancestor._descendants ||
-            setLink( ancestor, '_descendants', Object.create( null ) );
+        setLink( ancestor, '_descendants', Object.create( null ) );
       if (!desc[sname])
         desc[sname] = [ art ];
       else
         desc[sname].push( art );
     }
   }
-
-  function tagCompositionTargets( elem ) {
-    // TODO: together with test for targetIsTargetAspect()
-    if (elem.target && isDirectComposition( elem )) {
-      // A target aspect would have already moved to property `targetAspect` in
-      // define.js (hm... more something for kick-start.js...)
-      // TODO: for safety, just use resolveUncheckedPath()
-      const target = resolveUncheckedPath( elem.target, 'target', elem );
-      if (target)
-        model.$compositionTargets[target] = true;
-    }
-    if (elem.targetAspect?.elements)
-      elem = elem.targetAspect;
-    forEachGeneric( elem, 'elements', tagCompositionTargets );
-  }
 }
 
 module.exports = kickStart;

package/lib/compiler/populate.js

@@ -17,12 +17,7 @@
 
 'use strict';
 
-const {
-  isDeprecatedEnabled,
-  forEachDefinition,
-  forEachMember,
-  forEachGeneric,
-} = require('../base/model');
+const { isDeprecatedEnabled } = require('../base/model');
 const {
   dictAdd, dictAddArray, dictFirst, dictForEach,
 } = require('../base/dictionaries');
@@ -44,6 +39,9 @@ const {
   setExpandStatusAnnotate,
   dependsOnSilent,
   columnRefStartsWithSelf,
+  forEachDefinition,
+  forEachMember,
+  forEachGeneric,
 } = require('./utils');
 const { typeParameters } = require('./builtins');
 
@@ -73,39 +71,48 @@ function populate( model ) {
   } = model.$messageFunctions;
   const {
     resolvePath,
+    resolveUncheckedPath,
+    createGapArtifact,
     nestedElements,
     attachAndEmitValidNames,
     initMainArtifact,
+    initArtifactParentLink,
     extendArtifactBefore,
     extendArtifactAfter,
+    extendArtifactAdd,
+    generateForEntity,
+    populateGeneratedEntity,
   } = model.$functions;
   Object.assign( model.$functions, {
     effectiveType,
+    generateOnDemand,
     getOrigin,
     getInheritedProp,
     mergeSpecifiedForeignKeys,
+    registerGeneratedEntity,
   } );
   // let depth = 100;
 
   let effectiveSeqNo = 0;   // artifact number set after having set _effectiveType
   /** @type {any} may also be a boolean */
-  let newAutoExposed = [];
+  let newGeneratedEntities = [];
 
   const ignoreSpecifiedElements
     = isDeprecatedEnabled( model.options, 'ignoreSpecifiedQueryElements' );
 
   forEachDefinition( model, traverseElementEnvironments );
-  while (newAutoExposed.length) {
-    // console.log( newAutoExposed.map( a => a.name.id ) )
-    const all = newAutoExposed;
-    newAutoExposed = [];
+  while (newGeneratedEntities.length) {
+    // console.log( newGeneratedEntities.map( a => a.name.id ) )
+    const all = newGeneratedEntities;
+    newGeneratedEntities = [];
     all.forEach( traverseElementEnvironments );
   }
-  newAutoExposed = true;      // internal error if auto-expose after here
+  newGeneratedEntities = true;  // internal error if entity generation after here
   return;
 
   /** Make sure that effectiveType() is called on all members and items */
   function traverseElementEnvironments( art ) {
+    // console.log('TEE:',require('../model/revealInternalProperties').ref(art))
     // We leave out foreign keys (as they are traversed via forEachMember).
     // Keys are handled in tweak-assocs.js
     if (art.kind === 'key')
@@ -117,10 +124,15 @@ function populate( model ) {
       art.$queries.forEach( traverseElementEnvironments );
     if (art.mixin)
       dictForEach( art.mixin, effectiveType );
-    if (art.targetAspect?.elements)
+    if (art.targetAspect?.elements) {
       effectiveType( art.targetAspect );
-    if (art !== art._main?._leadingQuery) // already done
+      forEachGeneric( art.targetAspect, 'elements', traverseElementEnvironments );
+    }
+    else if (art !== art._main?._leadingQuery) { // already done for leading query elems
+      while (art.items)
+        art = art.items;
       forEachMember( art, traverseElementEnvironments );
+    }
   }
 
 
@@ -191,6 +203,7 @@ function populate( model ) {
     }
     chain.reverse();
     for (const a of chain) {
+      // console.log('PEA:',require('../model/revealInternalProperties').ref(a))
       // Ensure that the _effectiveType of the parent has been calculated.  This
       // is usually the case, but might not be for elements of anonymous target
       // aspects.  Without it, extensions/annotations might get lost.
@@ -202,6 +215,10 @@ function populate( model ) {
       // TODO: forbid $self+$self.elem inline, see expandWildcard()
       // Without type, value.path or _origin at beginning, link to itself:
       extendArtifactBefore( a );
+      populateGeneratedEntity( a );
+      if (a.includes)
+        a.includes.forEach( i => resolveInclude( i, a ) );
+      extendArtifactAdd( a );
       art = populateArtifact( a, art ) || a;
       setLink( a, '_effectiveType', art );
       a.$effectiveSeqNo = ++effectiveSeqNo;
@@ -209,6 +226,8 @@ function populate( model ) {
       if (a.elements$ || a.enum$)
         mergeSpecifiedElementsOrEnum( a );
       // console.log( 'ET-DO:', effectiveSeqNo, a?.kind, a?.name, a._extensions?.elements?.length )
+      if (a.kind === 'entity' && !a.query)
+        generateForEntity( a );
       extendArtifactAfter( a ); // after setting _effectiveType (for messages)
       if (a.typeProps$)
         setSpecifiedElementTypeProperties( a );
@@ -217,13 +236,22 @@ function populate( model ) {
     return art;
   }
 
+  function resolveInclude( include, art ) {
+    // includes have been resolved with resolveUncheckedPath() with art/ext
+    // before, i.e. it is ok to just use `a` as "user"
+    const name = resolveUncheckedPath( include, 'include', art );
+    // use effectiveType(), which applies extensions, before resolvePath()
+    // where we check for the number of elements in the accept functions
+    if (name)
+      effectiveType( model.definitions[name] );
+    resolvePath( include, 'include', art );
+  }
+
   function populateArtifact( art, origEffective ) {
     // Name-resolution relevant properties directly at artifact:
     // ‹view›.elements of input must have been moved (to elements$) before!
     // console.log('Q:',art.elements,art.enum,art.items,!!art.query)
     // console.log('PA:',require('../model/revealInternalProperties').ref(art))
-    if (art.includes)           // first version of includes via effectiveTpe()
-      art.includes.forEach( i => effectiveType( i._artifact ) );
     if (art.elements != null || art.enum != null || art.items != null)
       return art;
     if (art.target) {
@@ -292,6 +320,36 @@ function populate( model ) {
     return origEffective;
   }
 
+  /**
+   * Potentially create texts or target entity on demand.
+   *
+   * `nameOrArt` is the name of the requested entity or a gap artifact having that
+   * name.  Returns the generated entity, or null if no such entity is created.
+   */
+  function generateOnDemand( nameOrArt ) {
+    const gap = (typeof nameOrArt === 'string')
+      ? model.definitions[nameOrArt] || createGapArtifact( nameOrArt )
+      : nameOrArt;
+    let base = gap._parent;
+    if (!base)
+      return null;
+    const chain = [];
+    // We could have requested Base.component.texts before Base.component:
+    // from Base, first create Base.component, then Base.component.texts
+    for (; base?.kind === 'namespace'; base = base._parent)
+      chain.push( base );
+    if (base?.kind !== 'entity' || base.query || base.$duplicates || !base.elements)
+      return null;
+    effectiveType( base );    // induces localized data and target entity creation
+    chain.reverse();
+    for (const art of chain) {
+      if (art.kind !== 'entity')
+        return null;
+      effectiveType( art );   // induces localized data and target entity creation
+    }
+    return gap.kind === 'entity' ? gap : null;
+  }
+
   // TODO: test it in combination with top-level CAST function
   // TODO: we could probably "extend" this function to all other cases where we
   // set an _origin in Universal CSN
@@ -497,7 +555,6 @@ function populate( model ) {
 
   // TODO: delete XSN._entities
   // TODO: delete ENTITY._from - use _origin? instead _from[0]
-  // TODO (after on-demand ext): delete XSN.$entity
 
   /**
    * Merge _specified_ elements with _inferred_ elements in the given view/element,
@@ -1048,7 +1105,8 @@ function populate( model ) {
 
     if (!exposed.length) {
       const origTarget = target;
-      if (isAutoExposed( target ))
+      // TODO: probably calculate effectiveType of target earlier
+      if (effectiveType( target ) && isAutoExposed( target ))
         target = createAutoExposed( origTarget, service, elemScope );
       const desc = origTarget._descendants ||
             setLink( origTarget, '_descendants', Object.create( null ) );
@@ -1217,6 +1275,8 @@ function populate( model ) {
   function isAutoExposed( target ) {
     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 ?
@@ -1314,7 +1374,7 @@ function populate( model ) {
     // console.log(absolute)
     const location = weakRefLocation( target.name );
     const from = { path: [ { id: target.name.id, location } ], location };
-    let art = {
+    const art = registerGeneratedEntity( {
       kind: 'entity',
       name: { location, id: absolute },
       location,
@@ -1325,7 +1385,7 @@ function populate( model ) {
         name: { path: [ { id: 'cds.autoexposed', location } ], location },
         $inferred: '$generated',
       },
-    };
+    } );
     // forward target parameters to projection
     if (target.params) {
       art.params = Object.create( null );
@@ -1342,19 +1402,26 @@ function populate( model ) {
       } );
     }
     // TODO: do we need to tag the generated entity with elemScope = 'auto'?
-    if (autoexposed) {
-      Object.assign( autoexposed, art );
-      art = autoexposed;
-    }
-    else {
-      model.definitions[absolute] = art;
-    }
     setLink( art, '_service', service );
     setLink( art, '_block', model.$internal );
     initMainArtifact( art, !!autoexposed );
     effectiveType( art );
     // TODO: try to set locations of elements locations of orig target elements
-    newAutoExposed.push( art );
+    newGeneratedEntities.push( art );
+    return art;
+  }
+
+  function registerGeneratedEntity( art ) {
+    const { id } = art.name;
+    const gap = model.definitions[id];
+    if (gap)
+      art = Object.assign( gap, art );
+    else
+      model.definitions[id] = art;
+    newGeneratedEntities.push( art );
+    // add gen entity to _subArtifacts of parent (not done in createGapArtifact()):
+    if (art.$inferred !== 'autoexposed')
+      initArtifactParentLink( art, model.definitions );
     return art;
   }
 }

package/lib/compiler/propagator.js

@@ -8,17 +8,15 @@
 
 'use strict';
 
-const {
-  forEachDefinition,
-  forEachMember,
-  forEachGeneric,
-} = require( '../base/model');
 const {
   setLink,
   linkToOrigin,
   withAssociation,
   viewFromPrimary,
   copyExpr,
+  forEachDefinition,
+  forEachMember,
+  forEachGeneric,
 } = require('./utils');
 const { propagationRules } = require('../base/builtins');
 const $inferred = Symbol.for( 'cds.$inferred' );

package/lib/compiler/resolve.js

@@ -38,13 +38,7 @@
 
 'use strict';
 
-const {
-  forEachDefinition,
-  forEachMember,
-  forEachGeneric,
-  forEachInOrder,
-  isDeprecatedEnabled,
-} = require('../base/model');
+const { isDeprecatedEnabled } = require('../base/model');
 const { dictAdd } = require('../base/dictionaries');
 const { weakLocation } = require('../base/location');
 const { combinedLocation } = require('../base/location');
@@ -65,6 +59,10 @@ const {
   compositionTextVariant,
   targetCantBeAspect,
   userParam,
+  forEachDefinition,
+  forEachMember,
+  forEachGeneric,
+  forEachInOrder,
 } = require('./utils');
 
 const detectCycles = require('./cycle-detector');
@@ -109,7 +107,9 @@ function resolve( model ) {
     = isDeprecatedEnabled( options, 'ignoreSpecifiedQueryElements' );
 
   forEachGeneric( model, 'sources', resolveUsings );
-  return doResolve();
+  doResolve();
+  model.$functions.checkGenerateConditions();
+  return model;
 
   /**
    * Resolve the using declarations in `using`.
@@ -173,7 +173,6 @@ function resolve( model ) {
       error( '$internal-expecting-cyclic', null, {},
              'INTERNAL: the compiler should have issued an Error[ref-cyclic]' );
     }
-    return model;
   }
 
   //--------------------------------------------------------------------------
@@ -447,6 +446,8 @@ function resolve( model ) {
       if (getInheritedProp( art, 'targetAspect' )) {
         error( 'def-invalid-key', [ key.location, art ], { '#': 'composition' } );
         // TODO: test with managed composition exposed with explicit KEY
+        // TODO: this should be checked in generate.js (with setting), see
+        // test3/ManagedCompositions/CompositionAsKey/
       }
       else if (art.target && getInheritedProp( art, 'on' )) {
         error( 'def-invalid-key', [ key.location, art ], { '#': 'unmanaged' } );
@@ -587,7 +588,7 @@ function resolve( model ) {
     }
 
     resolveExprInAnnotations( art );
-    forEachMember( art, resolveRefs, art.targetAspect );
+    forEachMember( obj.targetAspect || obj, resolveRefs );
     // After the resolving of foreign keys (and adding implicit ones):
     if (obj.target?.$inferred === '')
       checkRedirectedUserTarget( art );
@@ -916,7 +917,8 @@ function resolve( model ) {
         error( 'ref-invalid-calc-elem', [ include.location || art.value.location, art ],
                { '#': art._main.kind } );
       }
-      else {
+      else if (art._main.kind !== 'extend') {
+        // if there was an error while extending, the main kind can be still 'extend'
         error( 'def-invalid-calc-elem', loc, { '#': art._main.kind } );
       }
     }
@@ -1072,8 +1074,9 @@ function resolve( model ) {
     const target = resolvePath( obj.target, 'target', art );
 
     if (obj._columnParent && obj.type && !obj.type.$inferred && art._main && art._main.query) {
-      // New association inside expand/inline: The on-condition can't be properly checked,
-      // so abort early. See #8797
+      // New association inside expand/inline: The on-condition can't be properly
+      // checked, so abort early. See #8797. If we'd allow this in the future, we
+      // must consider composition targets in expand/inline for auto-redirections
       error( 'query-unexpected-assoc', [ obj.name.location, art ], {},
              'Unexpected new association in expand/inline' );
       return; // avoid subsequent errors
@@ -1199,6 +1202,7 @@ function resolve( model ) {
     return max && (typeof max.val !== 'number' || max.val > 1);
   }
 
+  // TODO: move to populate.js and call there
   function addImplicitForeignKeys( art, obj, target ) {
     if (!art.$inferred && !art.virtual?.val && isQuasiVirtualAssociation( obj )) {
       if (!isDeprecatedEnabled( options, 'noQuasiVirtualAssocs' )) {