@sap/cds-compiler 2.12.0 → 2.15.2

package/lib/compiler/kick-start.js

@@ -0,0 +1,190 @@
+// Kick-start: prepare to resolve all references
+
+'use strict';
+
+const { isBetaEnabled, forEachGeneric } = require('../base/model');
+const { setLink, annotationVal, annotationIsFalse } = require('./utils');
+
+function kickStart( model ) {
+  const { options } = model;
+  const { message } = model.$messageFunctions;
+
+  const { resolveUncheckedPath, resolvePath } = model.$functions;
+  Object.assign( model.$functions, { projectionAncestor } );
+
+  // Set _service link (sorted to set it on parent first).  Could be set
+  // directly, but beware a namespace becoming a service later.
+  Object.keys( model.definitions ).sort().forEach( setAncestorsAndService );
+  forEachGeneric( model, 'definitions', postProcessArtifact );
+
+  forEachGeneric( model, 'sources', resolveUsings );
+  return;
+
+
+  /**
+   * Set projection ancestors, and _service link for artifact with absolute name 'name':
+   *  - not set: internal artifact
+   *  - null: not within service
+   *  - service: the artifact of the embedding service
+   * This function must be called ordered: parent first
+   *
+   * @param {string} name Artifact name
+   */
+  function setAncestorsAndService( name ) {
+    const art = model.definitions[name];
+    if (!('_parent' in art))
+      return;                   // nothing to do for builtins and redefinitions
+    if (art._from && !('_ancestors' in art))
+      setProjectionAncestors( art );
+
+    let parent = art._parent;
+    if (parent === model.definitions.localized)
+      parent = model.definitions[name.substring( 'localized.'.length )];
+    const service = parent && (parent._service || parent.kind === 'service' && parent);
+    setLink( art, '_service', service );
+    if (!parent || !service)
+      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 },
+               '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 },
+               'A context can\'t be nested within a service $(ART)' );
+    }
+  }
+
+  function setProjectionAncestors( art ) {
+    // Must be run after processLocalizedData() as we could have a projection
+    // on a generated entity.
+
+    // TODO: do not do implicit redirection across services, i.e. Service2.E is
+    // no redirection target for E if Service2.E = projection on Service1.E and
+    // Service1.E = projection on E
+    const chain = [];
+    const autoexposed = art.$generated || annotationVal( art['@cds.autoexposed'] );
+    const preferredRedirectionTarget = annotationVal( art['@cds.redirection.target'] );
+    // 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 && !('_ancestors' in art) &&
+           art._from && art._from.length === 1 &&
+           (preferredRedirectionTarget || !annotationIsFalse( art['@cds.redirection.target'] ) ) &&
+           art.query.op && art.query.op.val === 'SELECT') {
+      chain.push( art );
+      setLink( art, '_ancestors', null ); // avoid infloop with cyclic from
+      const name = resolveUncheckedPath( art._from[0], 'include', art ); // TODO: 'include'?
+      art = name && projectionAncestor( model.definitions[name], art.params );
+      if (autoexposed)
+        break;                  // only direct projection for auto-exposed
+    }
+    let ancestors = art && (!autoexposed && art._ancestors || []);
+    chain.reverse();
+    for (const a of chain) {
+      ancestors = (ancestors ? [ ...ancestors, art ] : []);
+      setLink( a, '_ancestors', ancestors );
+      art = a;
+    }
+  }
+
+  // Return argument `source` if entity `source` has parameters like `params`
+  // - same parameters, although `params` can contain a new optional one (with DEFAULT)
+  // - a parameter in `params` can be optional which is not in `source.params`, but not vice versa
+  // - exactly the same types (type argument do not matter)
+  function projectionAncestor( source, params ) {
+    if (!source)
+      return source;
+    if (!params)                // proj has no params => ok if source has no params
+      return !source.params && source;
+    const sourceParams = source.params || Object.create(null);
+    for (const n in sourceParams) {
+      if (!(n in params))       // source param is not projection param
+        return null;            // -> can't be used as implicit redirection target
+    }
+    for (const n in params) {
+      const pp = params[n];
+      const sp = sourceParams[n];
+      if (sp) {
+        if (sp.default && !pp.default) // param DEFAULT clause not supported yet
+          return null;          // param is not optional anymore
+        const pt = pp.type && resolveUncheckedPath( pp.type, 'type', pp );
+        const st = sp.type && resolveUncheckedPath( sp.type, 'type', sp );
+        if ((pt || null) !== (st || null))
+          return null;          // params have different type
+      }
+      else if (!pp.default) {
+        return null;
+      }        // non-optional param in projection, but not source
+    }
+    return source;
+  }
+
+  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;
+    if (!service)
+      return;
+    const sname = service.name.absolute;
+    art._ancestors.forEach( expose );
+    return;
+
+    function expose( ancestor ) {
+      if (ancestor._service === service)
+        return;
+      const desc = ancestor._descendants ||
+            setLink( ancestor, '_descendants', Object.create(null) );
+      if (!desc[sname])
+        desc[sname] = [ art ];
+      else
+        desc[sname].push( art );
+    }
+  }
+
+  function tagCompositionTargets( elem ) {
+    const type = elem.type && elem.type.path;
+    if (elem.target && type && type[0] && type[0].id === 'cds.Composition') {
+      // A target aspect would have already moved to property `targetAspect` in
+      // define.js (hm... more something for kick-start.js...)
+      const target = resolvePath( elem.target, 'target', elem );
+      if (target)
+        model.$compositionTargets[target.name.absolute] = true;
+    }
+    forEachGeneric( elem, 'elements', tagCompositionTargets );
+  }
+
+  // Resolve the using declarations in `using`.  Issue
+  // error message if the referenced artifact does not exist.
+  function resolveUsings( src, topLevel ) {
+    if (!src.usings)
+      return;
+    for (const def of src.usings) {
+      if (def.usings)           // using {...}
+        resolveUsings( def );
+      if (!def.name || !def.name.absolute)
+        continue;               // using {...}, parse error
+      const art = model.definitions[def.name.absolute];
+      if (art && art.$duplicates)
+        continue;
+      const ref = def.extern;
+      const from = (topLevel ? def : src).fileDep;
+      if (art || !from || from.realname)   // no error for non-existing ref with non-existing module
+        resolvePath( ref, 'global', def ); // TODO: consider FROM for validNames
+    }
+  }
+}
+
+module.exports = kickStart;

package/lib/compiler/moduleLayers.js

@@ -3,14 +3,14 @@
 'use strict';
 
 const detectCycles = require('./cycle-detector');
-const { setProp } = require('../base/model');
+const { setLink } = require('./utils');
 
 function setLayers( sources ) {
   // set dependencies
   for (const name in sources) {
     const ast = sources[name];
     ast.realname = name;
-    setProp( ast, '_deps', [] );
+    setLink( ast, '_deps', [] );
     for (const d of ast.dependencies || []) {
       const art = sources[d.realname];
       if (art)
@@ -24,7 +24,7 @@ function setLayers( sources ) {
   // It is ensured that the representative is called last in SCC and that
   // dependent SCCs are called first
   function setExtends( node, representative, sccDeps = Object.create(null) ) {
-    setProp( node, '_layerRepresentative', representative );
+    setLink( node, '_layerRepresentative', representative );
     if (layerRepresentative !== representative) {
       layerRepresentative = representative;
       ++layerNumber;
@@ -40,7 +40,7 @@ function setLayers( sources ) {
     if (node === representative) {
       const exts = Object.keys( sccDeps ).map( name => sccDeps[name]._layerExtends );
       Object.assign( sccDeps, ...exts );
-      setProp( representative, '_layerExtends', sccDeps );
+      setLink( representative, '_layerExtends', sccDeps );
       // console.log ('SCC:', node.realname)
     }
     return sccDeps;