@sap/cds-compiler 3.7.2 → 3.8.2

package/lib/main.js

@@ -26,6 +26,7 @@ const compiler = lazyload('./compiler');
 const shared = lazyload('./compiler/shared');
 const define = lazyload('./compiler/define');
 const builtins = lazyload('./compiler/builtins');
+const base = lazyload('./compiler/base');
 const finalizeParseCdl = lazyload('./compiler/finalize-parse-cdl');
 
 // The compiler version (taken from package.json)
@@ -157,9 +158,10 @@ module.exports = {
   // INTERNAL functions for the cds-lsp package and friends - before you use
   // it, you MUST talk with us - there can be potential incompatibilities with
   // new releases (even having the same major version):
-  $lsp: { parse: (...args) => compiler.parseX(...args),
+  $lsp: {
+    parse: (...args) => compiler.parseX(...args),
     compile: (...args) => compiler.compileX(...args),
-    getArtifactName: a => a.name
+    getArtifactName: (...args) => base.getArtifactName(...args),
   },
 
   // CSN Model related functionality

package/lib/model/csnRefs.js

@@ -620,6 +620,9 @@ function csnRefs( csn, universalReady ) {
         return resolvePath( path, art, parent, 'parent' );
       }
 
+      if (!qcache)
+        throw new CompilerAssertion( `Query not in cache at: ${ locationString(query.$location) }` );
+
       if (semantics.dynamic === 'query')
         // TODO: for ON condition in expand, would need to use cached _element
         return resolvePath( path, qcache.elements[head], null, 'query' );
@@ -637,10 +640,18 @@ function csnRefs( csn, universalReady ) {
   /**
    * @param {CSN.Path} path
    * @param {CSN.Artifact} art
+   * @param {CSN.Artifact} parent
    * @param {string} [scope]
    * @param [extraInfo]
    */
   function resolvePath( path, art, parent, scope, extraInfo ) {
+    if (!art && path.length > 1) {
+      // TODO: For path.length===1, it may be that `art` is undefined, e.g. for CSN paths such
+      //       as `[…, 'on', 1]` where the path segment refers to `=`.
+      // TODO: Check the call-side.
+      const loc = locationString(parent?.$location);
+      throw new ModelError(`Path item 0='${ pathId(path[0]) }' refers to nothing; in ${ loc }; path=${ JSON.stringify(path) }`);
+    }
     const staticAssoc = extraInfo === 'static' && scope === 'global';
     /** @type {{idx, art?, env?}[]} */
     const links = path.map( (_v, idx) => ({ idx }) );
@@ -706,8 +717,12 @@ function csnRefs( csn, universalReady ) {
         if (query !== main)
           cache.set( query, qcache );
 
-        if (fromSelect)
-          getCache( fromSelect, '$aliases' )[query.as] = qcache;
+        if (fromSelect) {
+          const $queryNumber = all.length + 1;
+          const alias = query.as || `$_select_${ $queryNumber }__`;
+          getCache(fromSelect, '$aliases')[alias] = qcache;
+        }
+
         const select = query.SELECT || query.projection;
         if (select) {
           cache.set( select, qcache ); // query and query.SELECT have the same cache qcache
@@ -870,8 +885,8 @@ function traverseFrom( from, fromSelect, parentQuery, callback ) {
   }
   else if (from.args) {         // join
     from.args.forEach( arg => traverseFrom( arg, fromSelect, parentQuery, callback ) );
-    if (from.on)                // join-on, potentially having a sub query
-      from.on.forEach( arg => traverseQuery( arg, null, fromSelect, callback ) );
+    if (from.on)                // join-on, potentially having a sub query (in xpr)
+      from.on.forEach(arg => traverseExpr(arg, fromSelect, callback));
   }
   else {                        // sub query in FROM
     traverseQuery( from, fromSelect, parentQuery, callback );

package/lib/model/csnUtils.js

@@ -63,7 +63,6 @@ function getUtils( model, universalReady ) {
     addStringAnnotationTo,
     getServiceName,
     hasAnnotationValue,
-    cloneWithTransformations,
     getFinalBaseTypeWithProps,
     get$combined,
     getQueryPrimarySource,
@@ -81,7 +80,7 @@ function getUtils( model, universalReady ) {
   }
 
   /**
-   * Get the union of all elements from the from clause
+   * Get the union of all elements from the "from" clause
    * - descend into unions, following the lead query
    * - merge all queries in case of joins
    * - follow subqueries
@@ -93,7 +92,7 @@ function getUtils( model, universalReady ) {
   function getSources( query, isSubquery = false ) {
     // Remark CW: better just a while along query.SET.args[0]
     if (query.SET) {
-      if (query.SET.args[0].SELECT && query.SET.args[0].SELECT.elements)
+      if (query.SET.args[0].SELECT?.elements)
         return mergeElementsIntoMap(Object.create(null), query.SET.args[0].SELECT.elements, query.SET.args[0].$location);
 
       return getSources(query.SET.args[0], isSubquery);
@@ -111,9 +110,12 @@ function getUtils( model, universalReady ) {
         if (isSubquery && !query.SELECT.elements)
           throw new ModelError('Expected subquery to have .elements');
 
-        return mergeElementsIntoMap(Object.create(null), isSubquery ? query.SELECT.elements : art.elements, art.$location,
-                                    query.SELECT.from.as || query.SELECT.from.ref[query.SELECT.from.ref.length - 1],
-                                    query.SELECT.from.ref[query.SELECT.from.ref.length - 1] || query.SELECT.from.as );
+        const elements = isSubquery ? query.SELECT.elements : art.elements;
+        // sub-queries also have an alias that is reachable by outer queries, in contrast to `from.as`.
+        const parent = query.as || query.SELECT.from.as || implicitAs(query.SELECT.from.ref);
+        // for better error messages, we refer to the actual reference name first
+        const errorParent = implicitAs(query.SELECT.from.ref);
+        return mergeElementsIntoMap(Object.create(null), elements, art.$location, parent, errorParent);
       }
       else if (query.SELECT.from.SET || query.SELECT.from.SELECT) {
         return getSources(query.SELECT.from, true);
@@ -131,7 +133,7 @@ function getUtils( model, universalReady ) {
       }
       else if (arg.ref) {
         const art = artifactRef(arg);
-        elements = mergeElementsIntoMap(elements, art.elements, art.$location, arg.as || arg.ref[arg.ref.length - 1], arg.ref[arg.ref.length - 1] || arg.as);
+        elements = mergeElementsIntoMap(elements, art.elements, art.$location, arg.as || implicitAs(arg.ref), implicitAs(arg.ref) || arg.as);
       }
       else if (arg.SELECT || arg.SET) {
         elements = mergeElementMaps(elements, getSources(arg));
@@ -176,27 +178,13 @@ function getUtils( model, universalReady ) {
         existingMap[elementName] = [];
 
       existingMap[elementName].push({
-        element, name: elementName, source: $location, parent: getBaseName(parent), errorParent,
+        element, name: elementName, source: $location, parent, errorParent,
       });
     }
 
     return existingMap;
   }
 
-  /**
-   * Return the name part of the artifact name - no namespace etc.
-   * @param {string|object} name Absolute name of the artifact
-   */
-  function getBaseName( name ) {
-    if (!name)
-      return name;
-
-    if (name.id)
-      return name.id.substring( name.id.lastIndexOf('.') + 1 );
-
-    return name.substring( name.lastIndexOf('.') + 1 );
-  }
-
   /**
    * Return the left-most, primary source of the given query.
    * @param {*} query Definition's query object
@@ -341,57 +329,6 @@ function getUtils( model, universalReady ) {
     }
   }
 
-  /**
-   * Clone 'node', transforming nodes therein recursively. Object 'transformers' is expected
-   * to contain a mapping of property 'key' names to transformer functions. The node's properties
-   * are walked recursively, calling each transformer function on its corresponding property
-   * 'key' of 'node', replacing 'value' in 'resultNode' with the function's return value
-   * (returning 'undefined' will delete the property).
-   * If no transformation function is found for 'key', the first letter of 'key' is tried
-   * instead (this seems to be intended for handling annotations that start with '@' ?)
-   *
-   * Regardless of their names, transformers are never applied to dictionary elements.
-   *
-   * The transformer functions are called with the following signature:
-   * transformer(value, node, resultNode, key)
-   *
-   * @param {any} rootNode Node to transform
-   * @param {any} transformers Object defining transformer functions
-   * @returns {object}
-   */
-  function cloneWithTransformations( rootNode, transformers ) {
-    return transformNode(rootNode);
-
-    // This general transformation function will be applied to each node recursively
-    function transformNode( node ) {
-    // Return primitive values and null unchanged, but let objects and dictionaries through
-    // (Note that 'node instanceof Object' would be false for dictionaries).
-      if (node === null || typeof node !== 'object')
-        return node;
-
-      // Simply return if node is to be ignored
-      if (node === undefined || node._ignore)
-        return undefined;
-      // Transform arrays element-wise
-      if (Array.isArray(node))
-        return node.map(transformNode);
-
-      // Things not having 'proto' are dictionaries
-      const proto = Object.getPrototypeOf(node);
-      // Iterate own properties of 'node' and transform them into 'resultNode'
-      const resultNode = Object.create(proto);
-      for (const key of Object.keys(node)) {
-      // Dictionary always use transformNode(), other objects their transformer according to key
-        const transformer = (proto === null || proto === undefined) ? transformNode : transformers[key] || transformers[key.charAt(0)];
-        // Apply transformer, or use transformNode() if there is none
-        const resultValue = (transformer || transformNode)(node[key], node, resultNode, key);
-        if (resultValue !== undefined)
-          resultNode[key] = resultValue;
-      }
-      return resultNode;
-    }
-  }
-
   /**
    * Resolve to the final type of a type, that means follow type chains, references, etc.
    * Input is a fully qualified type name, i.e. string, or type ref, i.e. `{ ref: [...] }`.
@@ -931,7 +868,7 @@ function getUnderscoredName( startIndex, parts, csn ) {
   for (let i = startIndex; i < parts.length; i++) {
     const namePart = parts.slice(0, i).join('.');
     const art = csn.definitions[namePart];
-    if (art && !(art.kind === 'namespace' || art.kind === 'context' || art.kind === 'service')) {
+    if (art && !(art.kind === 'context' || art.kind === 'service')) {
       const prefix = parts.slice(0, i - 1).join('.');
       const suffix = parts.slice(i - 1).join('_');
       const result = [];

package/lib/model/revealInternalProperties.js

@@ -61,6 +61,7 @@ function tableAliasAsLink( art, parent, name ) {
  * @param {string} [nameOrPath]
  */
 function revealInternalProperties( model, nameOrPath ) {
+  // return model;
   const transformers = {
     messages: m => m,
     name: shortenName,
@@ -71,6 +72,7 @@ function revealInternalProperties( model, nameOrPath ) {
     artifacts: artifactDictionary,
     definitions: artifactDictionary,
     vocabularies: dictionary,
+    $lateExtensions: dictionary,
     elements,
     columns,
     expand: columns,
@@ -95,6 +97,7 @@ function revealInternalProperties( model, nameOrPath ) {
     $compositionTargets: d => d,   // dictionary( boolean )
     _extend: reveal,
     _annotate: reveal,
+    _annotateS: artifactIdentifier,
     _deps: dependencyInfo,
     _status: primOrString,       // is a string anyway
     $annotations: as => as.map( $annotation ),

package/lib/optionProcessor.js

@@ -226,6 +226,7 @@ optionProcessor.command('O, toOdata')
   .option('    --odata-x-service-refs')
   .option('    --odata-foreign-keys')
   .option('    --odata-v2-partial-constr')
+  .option('    --odata-voc-refs <list>')
   .option('-c, --csn')
   .option('-f, --odata-format <format>', ['flat', 'structured'])
   .option('-n, --sql-mapping <style>', ['plain', 'quoted', 'hdbcds'], { aliases: [ '--names' ] })
@@ -254,6 +255,8 @@ optionProcessor.command('O, toOdata')
        --odata-foreign-keys        Render foreign keys in structured format (V4 only)
        --odata-v2-partial-constr   Render referential constraints also for partial principal key tuple
                                    (Not spec compliant and V2 only)
+       --odata-voc-refs <list>     JSON array of adhoc vocabulary definitions
+                                   [ { alias, ns, uri }, ... ]
    -n, --sql-mapping <style> Annotate artifacts and elements with "@cds.persistence.name", which is
                              the corresponding database name (see "--sql-mapping" for "toHana or "toSql")
                                plain   : (default) Names in uppercase and flattened with underscores