@sap/cds-compiler 3.6.2 → 3.8.0

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: [...] }`.
@@ -423,6 +360,7 @@ function getUtils( model, universalReady ) {
     //  - r({ref: ['\\', '\\', '\\\\'] }) != r({ref: ['\\', '\\\\', '\\'] })
     //  - r({ref: ['\\', '\\', '\\\\'] }) != r({ref: ['\\', '\\\\2:\\\\'] })
     const resolvedKey = (typeof type === 'object')
+      // eslint-disable-next-line sonarjs/no-nested-template-literals
       ? `ref[${ type.ref.length }]:${ type.ref.map((val, i) => `${ i }:${ val }`).join('\\') }`
       : `type:${ type }`;
 
@@ -930,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 ),
@@ -170,8 +173,7 @@ function revealInternalProperties( model, nameOrPath ) {
     if (!Array.isArray(deps))
       return primOrString( deps );
     return deps
-      .filter( d => d.location )
-      .map( d => artifactIdentifier( d.art ) );
+      .map( d => `${ d.location ? '' : '-' }${ artifactIdentifier( d.art ) }`);
   }
 
   function layerExtends( dict ) {

package/lib/modelCompare/compare.js

@@ -120,6 +120,7 @@ function getArtifactComparator(otherModel, options, addedEntities, deletedEntiti
       // Arguments are interchanged in this case: `artifact` from beforeModel and `otherArtifact` from afterModel.
       if (isPersisted && !isPersistedOther) {
         deletedEntities[name] = artifact;
+      // eslint-disable-next-line sonarjs/no-duplicated-branches
       } else if(isPersistedAsView(artifact) && isPersistedOther) { // view turned into table - need to render a drop for the view
         deletedEntities[name] = artifact;
       }
@@ -254,7 +255,7 @@ module.exports = {
 /**
  * A ModelDiff encapsulates the changes between two models ("before" and "after"). It contains information
  * about changes to .elements and removed artifacts.
- * 
+ *
  * @typedef {object} ModelDiff
  * @property {CSN.Definitions} definitions The artifacts present in the "after" model
  * @property {CSN.Definitions} deletions The artifacts present in the "before", but not in the "after"

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

package/lib/render/manageConstraints.js

@@ -23,12 +23,15 @@ const { sortCsn } = require('../json/to-csn');
  * @param {CSN.Options} options
  */
 function alterConstraintsWithCsn( csn, options ) {
-  const { error } = makeMessageFunction(csn, options, 'manageConstraints');
+  const { error, warning } = makeMessageFunction(csn, options, 'manageConstraints');
 
   const {
-    drop, alter, src, violations,
+    drop, alter, src, violations, sqlDialect,
   } = options || {};
 
+  if (!sqlDialect || sqlDialect === 'h2' || sqlDialect === 'plain')
+    warning(null, null, { prop: sqlDialect || 'plain' }, 'Referential Constraints are not available for sql dialect $(PROP)');
+
   if (drop && alter)
     error(null, null, 'Option “--drop” can\'t be combined with “--alter”');