@sap/cds-compiler 2.11.2 → 2.13.6

package/lib/model/enrichCsn.js

@@ -7,23 +7,35 @@
 
 // * `File.cds:3:5` if the original CSN has a non-enumerable `$location` property
 //   with value `{file: "File.cds", line: 3, col: 5}`.
-// * `File.cds:3:5-1` if the original CSN has _no_ `$location` property, for an
+// * `File.cds:3:5^` if the original CSN has _no_ `$location` property, for an
 //   inferred member of a main artifact or member with `$location: `File.cds:3:5`;
-//   the number of digits in the `-1` suffix is the member depth.
+//   the number of `^`s in the suffix is the member depth.
 
 // Other enumerable properties in the JSON for non-enumerable properties in the
 // original CSN:
 
-// * `$env` for the non-enumerable `$env` property in the original CSN.
-// * `$elements` for a non-enumerable `elements` property for sub queries.
+// * `$parens`: the number of parentheses provided by the user around an expression
+//   or query if the number is different to the usual (mostly 0, sometimes 1).
+// * `$elements` (in client-style CSN only) for a non-enumerable `elements` property
+//   for sub queries.
 
 // The following properties in the JSON represent the result of the CSN API
 // functions:
 
-// * `_type`, `_includes` and `_targets` have as values the `$locations` of the
+// * `_type`, `_includes` and `_targets` have as values the `$location`s of the
 //   referred artifacts which are returned by function `artifactRef`.
-// * `_links`, `_art` and `_scope` as sibling properties of `ref` have as values
-//   the `$locations` of the artifacts/members returned by function `inspectRef`.
+// * `_links` and `_art` as sibling properties of `ref` have as values the
+//   `$locations` of the artifacts/members returned by function `inspectRef` (`_art`
+//   for ref in `from` only, where it is different to the last item of `_links`).
+// * `_scope` and `_env` as sibling properties of `ref` have (string) values,
+//   returned by function `inspectRef`, giving add/ info about the “ref base”.
+// * `_origin` (in Universal CSN only) has as value the `$location` of the
+//   prototype returned by function getOrigin().
+// * `_test.inspect.csnpath` as sibling property of `ref` has an object value
+//   with properties `_links` and `_scope` of a further `inspectRef` call;
+//   it is only called, with `[‹art›, ...‹csnpath›]` as argument, if `‹art›`,
+//   which is the referred artifact returned by the first `inspectRef` call,
+//   has an annotation `@$test.inspect.csnpath` with array value `‹csnpath›`.
 
 'use strict';
 
@@ -32,7 +44,6 @@ const { locationString } = require('../base/location');
 
 function enrichCsn( csn, options = {} ) {
   const transformers = {
-    // $env: reveal,
     elements: dictionary,
     definitions: dictionary,
     actions: dictionary,
@@ -50,10 +61,14 @@ function enrichCsn( csn, options = {} ) {
     // TODO: excluding
     '@': () => { /* ignore annotations */ },
   }
-  setLocations( csn, false, null );
-  const { inspectRef, artifactRef, getOrigin, __getCache_forEnrichCsnDebugging } =
-      csnRefs( csn );
+  // options.enrichCsn = 'DEBUG';
   let $$cacheObjectNumber = 0;   // for debugging
+  const debugLocationInfo = options.enrichCsn === 'DEBUG' && Object.create(null);
+
+  setLocations( csn, false, null );
+  const { inspectRef, artifactRef, getOrigin, initDefinition, __getCache_forEnrichCsnDebugging } =
+        csnRefs( csn, true );
+
   const csnPath = [];
   if (csn.definitions)
     dictionary( csn, 'definitions', csn.definitions );
@@ -84,9 +99,10 @@ function enrichCsn( csn, options = {} ) {
   }
 
   function definition( parent, prop, obj ) {
-    const origin = getOrigin( obj ); // before standard for implicit protos inside
+    // call getOrigin() before standard() to set implicit protos inside standard():
+    const origin = handleError( err => err ? err.toString() : getOrigin( obj ) );
     standard( parent, prop, obj );
-    if (obj.$origin === undefined && origin != null)
+    if (obj.$origin === undefined && !obj.type && origin != null)
       obj._origin = refLocation( origin );
   }
 
@@ -95,6 +111,8 @@ function enrichCsn( csn, options = {} ) {
       return;
     csnPath.push( prop );
     for (let name of Object.getOwnPropertyNames( dict )) {
+      if (prop === 'definitions')
+        initDefinition( dict[name] );
       definition( dict, name, dict[name] );
     }
     if (!Object.prototype.propertyIsEnumerable.call( parent, prop ))
@@ -103,11 +121,19 @@ function enrichCsn( csn, options = {} ) {
   }
 
   function refLocation( art ) {
-    if (art)
-      return art.$location || '<no location>';
+    if (!art || typeof art !== 'object' || Array.isArray( art )) {
+      if (!options.testMode)
+        return (typeof art === 'string')
+        ? `<illegal ref = ${art}>`
+        : `<illegal ref: ${typeof art}>`;
+      throw new Error( 'Illegal reference' );
+    }
+    else if (art.$location)
+      return art.$location;
+
     if (!options.testMode)
-      return '<illegal link>';
-    throw new Error( 'Undefined reference' );
+      return `<${Object.keys( art ).join('+')}+!$location>`;
+    throw new Error( 'Reference to object without $location' );
   }
 
   function simpleRef( parent, prop, ref ) {
@@ -133,37 +159,21 @@ function enrichCsn( csn, options = {} ) {
   }
 
   function $origin( parent, prop, ref ) {
-    if (options.testMode) {
-      if (Array.isArray( ref ) || typeof ref === 'string') // $origin: […], not $origin: {…}
-        parent._origin = refLocation( getOrigin( parent, true ) );
-      else if ( ref )
-        standard( parent, prop, ref )
-    }
-    else {
-      try {
-        if (Array.isArray( ref ) || typeof ref === 'string')  // $origin: […], not $origin: {…}
-          parent._origin = refLocation( getOrigin( parent, true ) );
-        else if ( ref )
-          standard( parent, prop, ref )
-      } catch (e) {
-        parent._origin = e.toString();
-      }
-    }
+    handleError( err => {
+      if (err)
+        parent._origin = err.toString();
+      else if (Array.isArray( ref ) || typeof ref === 'string') // $origin: […] / "short-ref"
+        parent._origin = refLocation( getOrigin( parent ) );
+      else if ( ref )                                           // $origin: {…}
+        standard( parent, prop, ref );
+    } );
   }
 
-  function pathRef( parent, prop, path ) {
-    const { links, art, scope, $env } = (() => {
-      if (options.testMode)
-        return inspectRef( csnPath );
-      else {
-        try {
-          return inspectRef( csnPath );
-        }
-        catch (e) {
-          return { scope: e.toString() };
-        }
-      }
-    } )();
+  function pathRef( parent, prop, path, inspectionPath = csnPath ) {
+    const inspection = handleError( (err) => {
+      return (err) ? { scope: err.toString() } : inspectRef( inspectionPath );
+    });
+    const { links, art, scope, $env } = inspection;
     if (links)
       parent._links = links.map( l => refLocation( l.art ) );
     if (links && links[links.length-1].art !== art)
@@ -172,6 +182,15 @@ function enrichCsn( csn, options = {} ) {
     if ($env)
       parent._env = $env;
 
+    if (!prop)                  // recursive call for @$test.inspect.csnpath
+      return;
+    const testPath = art && art['@$test.inspect.csnpath'];
+    if (testPath && parent.ref) {
+      const further = {};
+      pathRef( further, null, null, [ inspection, ...testPath ] );
+      parent['_test.inspect.csnpath'] = further;
+    }
+
     csnPath.push( prop );
     path.forEach( function step( s, i ) {
       if (s && typeof s === 'object') {
@@ -186,6 +205,16 @@ function enrichCsn( csn, options = {} ) {
     csnPath.pop();
   }
 
+  function handleError( callback ) {
+    if (options.testMode)
+      return callback();
+    try {
+      return callback();
+    } catch (err) {
+      return callback( err );
+    }
+  }
+
   function _cache_debug( obj, subCache ) {
     if (options.enrichCsn !== 'DEBUG')
       return;
@@ -227,6 +256,10 @@ function enrichCsn( csn, options = {} ) {
             obj.$$cacheObject[name] = sub;
           }
         }
+        else if (name === '$origin$step') { // string value handled above
+          const kind = Object.keys( val )[0];
+          obj.$$cacheObject[name] = `${kind}: ${ val[kind] }`;
+        }
         else if (Array.isArray( val )) {
           obj.$$cacheObject[name] = val.map( item => {
             if (!item.$$objectNumber)
@@ -242,8 +275,53 @@ function enrichCsn( csn, options = {} ) {
       }
     }
   }
+
+  function debugLocation( loc, userProvided ) {
+    if (debugLocationInfo && !userProvided) {
+      loc = loc.replace( /\([0-9]+\)\^/, '^' );
+      debugLocationInfo[loc] = (debugLocationInfo[loc] || 0) + 1;
+      loc = `${loc}(${debugLocationInfo[loc]})`;
+    }
+    return loc;
+  }
+
+  function setLocations( node, prop, loc ) {
+    if (!node || typeof node !== 'object')
+      return;
+    const isMember = artifactProperties.includes( prop );
+    if (!isMember && node.$location) {
+      if (typeof node.$location === 'string') // already set for nested 'items'
+        return;
+      loc = locationString( node.$location, true );
+      if (!node.SELECT) // compatibility: $location of query both inside and as sibling of SELECT
+        reveal( node, '$location', debugLocation( loc, !node.$generated ) );
+    }
+    else if (prop === true || prop === 'returns') { // in dictionary or returns
+      loc = debugLocation( loc + '^' );
+      node.$location = loc;
+    }
+    else if (prop === 'items') {
+      let iloc = loc + '[]';
+      let obj = node;
+      while (obj) {
+        // should not appear in --enrich-csn, only for _origin info
+        Object.defineProperty( obj, '$location', { value: iloc, enumerable: false } );
+        obj = obj.items;
+        iloc += '[]';
+      }
+    }
+    if (Array.isArray( node )) {
+      for (const item of node)
+        setLocations( item, isMember, loc );
+    }
+    else {
+      for (const name of Object.getOwnPropertyNames( node ))
+        setLocations( node[name], isMember || name, loc );
+    }
+  }
 }
 
+
 function reveal( node, prop, value ) {
   Object.defineProperty( node, prop, {
     value,
@@ -253,27 +331,4 @@ function reveal( node, prop, value ) {
   } );
 }
 
-function setLocations( node, prop, loc ) {
-  if (!node || typeof node !== 'object')
-    return;
-  const isMember = artifactProperties.includes( prop );
-  if (!isMember && node.$location) {
-    const value = locationString( node.$location, true );
-    reveal( node, '$location', value );
-    loc = value + '-';
-  }
-  else if (prop === true) {
-    loc += '1';
-    node.$location = loc;
-  }
-  if (Array.isArray( node )) {
-    for (const item of node)
-      setLocations( item, isMember, loc );
-  }
-  else {
-    for (const name of Object.getOwnPropertyNames( node ))
-      setLocations( node[name], isMember || name, loc );
-  }
-}
-
 module.exports = enrichCsn;

package/lib/model/revealInternalProperties.js

@@ -50,7 +50,16 @@ function tableAliasAsLink( art, parent, name ) {
       parent === art._parent.$tableAliases[name].$duplicates);
 }
 
-function revealInternalProperties( model, name ) {
+/**
+ * Reveal internal properties of `model` for the given artifact name (or path).
+ * `path` could be a definition name or a `/`-separated XSN path such as
+ * `name.space/S/E/elements/a/type/scope/`.
+ *
+ * @param {XSN.Model} model
+ * @param {string} [nameOrPath]
+ * @returns {string}
+ */
+function revealInternalProperties( model, nameOrPath ) {
   const transformers = {
     messages: m => m,
     name: shortenName,
@@ -76,6 +85,7 @@ function revealInternalProperties( model, name ) {
     $tableAliases: dictionary,
     $duplicates: duplicates,
     $keysNavigation: dictionary,
+    targetAspect,
     $layerNumber: n => n,
     $extra: e => e,
     _layerRepresentative: s => s.realname,
@@ -89,7 +99,7 @@ function revealInternalProperties( model, name ) {
     $messageFunctions: () => '‹some functions›',
   }
   unique_id = 1;
-  return revealXsnPath(name, model);
+  return revealXsnPath(nameOrPath, model);
 
   // Returns the desired artifact/dictionary in the XSN.
   //
@@ -259,6 +269,12 @@ function revealInternalProperties( model, name ) {
     return r;
   }
 
+  function targetAspect( node, parent ) {
+    if (node.elements && unique_id && node.__unique_id__ == null)
+      Object.defineProperty( node, '__unique_id__', { value: ++unique_id } );
+    return reveal( node, parent );
+  }
+
   function duplicates( node, parent ) {
     return reveal( node, parent, parent.name && parent.name.id );
   }
@@ -271,12 +287,15 @@ function artifactIdentifier( node, parent ) {
     Object.defineProperty( node, '__unique_id__', { value: ++unique_id } );
   let outer = unique_id ? '##' + node.__unique_id__ : '';
   if (node._outer) {
-    outer = (node._outer.items === node) ? '/items'
-      : (node._outer.returns === node) ? '/returns' : '/returns/items';
+    if (node.$inferred === 'REDIRECTED')
+      outer = '/redirected' + outer;
+    else
+      outer = (node._outer.items === node) ? '/items' + outer
+            : (node._outer.returns === node) ? '/returns' + outer
+            : (node._outer.targetAspect === node) ? '/target' + outer
+            : '/returns/items' + outer;
     node = node._outer;
   }
-  else if (node.$inferred === 'REDIRECTED')
-    outer = '/redirected';
   if (node === parent)
     return 'this';
   if (node.kind === 'source')
@@ -304,7 +323,10 @@ function artifactIdentifier( node, parent ) {
       return 'source:' + quoted( node.location && node.location.file ) +
         '/using:' + quoted( node.name.id )
     default: {
-      return ((node._main || node).kind || '<kind>') + ':' + msg.artName( node ) + outer;
+      let main = node._main;
+      while (main && main._outer) // anonymous aspect
+        main = main._outer._main;
+      return ((main || node).kind || '<kind>') + ':' + msg.artName( node ) + outer;
     }
   }
 }

package/lib/model/sortViews.js

@@ -1,5 +1,6 @@
 'use strict';
 const {setDependencies} = require('./csnUtils');
+const { ModelError } = require("../base/error");
 
 /**
  * @typedef {Object} Layers
@@ -79,7 +80,7 @@ function sortTopologically(csn, _dependents, _dependencies){
 /**
  * Sort the given sql statements so that they can be deployed sequentially.
  * For ordering, only the FROM clause of views is checked - this requires A2J to
- * be run beforehand to resovle association usages.
+ * be run beforehand to resolve association usages.
  *
  * @param {object} sql Map of <object name>: "CREATE STATEMENT"
  *
@@ -91,10 +92,17 @@ module.exports = function({sql, csn}){
   const { layers, leftover } = sortTopologically(csn, _dependents, _dependencies);
   cleanup.forEach(fn => fn());
   if(leftover.length > 0)
-    throw new Error('Unable to build a correct dependency graph! Are there cycles?');
+    throw new ModelError('Unable to build a correct dependency graph! Are there cycles?');
 
   const result = [];
   // keep the "artifact name" - needed for to.hdi sorting
   layers.forEach(layer => layer.forEach(objName => result.push({name: objName, sql: sql[objName]})));
+  // attach sql artifacts which are not considered during the view sorting algorithm
+  // --> this is the case for "ALTER TABLE ADD CONSTRAINT" statements,
+  //     because their identifiers are not part of the csn.definitions
+  Object.entries(sql).forEach(([ name, sqlString ]) => {
+    if (!result.some( o => o.name === name )) // not in result but in incoming sql
+      result.push({ name, sql: sqlString })
+  });
   return result;
 }

package/lib/modelCompare/compare.js

@@ -6,13 +6,14 @@ const {
   forEachMember,
   hasAnnotationValue
 } = require('../model/csnUtils');
+const { isBetaEnabled } = require('../base/model');
 
 /**
  * Compares two models, in HANA-transformed CSN format, to each other.
  *
  * @param beforeModel the before-model
  * @param afterModel the after-model
- * @param {import('../api/main.js').hdiOptions|false} options
+ * @param {HdiOptions|false} options
  * @returns {object} the sets of deletions, extensions, and migrations of entities necessary to transform the before-model
  * to the after-model, together with all the definitions of the after-model
  */
@@ -26,8 +27,8 @@ function compareModels(beforeModel, afterModel, options) {
   const migrations = []; // element changes/removals or changes of entity properties
 
   // There is currently no use in knowing the added entities only. If this changes, hand in `addedEntities` to `getArtifactComparator` below.
-  forEachDefinition(afterModel, getArtifactComparator(beforeModel, null, null, elementAdditions, migrations));
-  forEachDefinition(beforeModel, getArtifactComparator(afterModel, null, deletedEntities, null, null));
+  forEachDefinition(afterModel, getArtifactComparator(beforeModel, options, null, null, elementAdditions, migrations));
+  forEachDefinition(beforeModel, getArtifactComparator(afterModel, options, null, deletedEntities, null, null));
 
   const returnObj = Object.create(null);
   returnObj.definitions = afterModel.definitions;
@@ -60,7 +61,7 @@ function validateCsnVersions(beforeModel, afterModel, options) {
   }
 }
 
-function getArtifactComparator(otherModel, addedEntities, deletedEntities, elementAdditions, migrations) {
+function getArtifactComparator(otherModel, options, addedEntities, deletedEntities, elementAdditions, migrations) {
   return function compareArtifacts(artifact, name) {
     function addElements() {
       const elements = {};
@@ -70,7 +71,11 @@ function getArtifactComparator(otherModel, addedEntities, deletedEntities, eleme
       }
     }
     function changePropsOrRemoveOrChangeElements() {
-      const relevantProperties = ['doc'];
+      const relevantProperties = [
+        { name: 'doc' },
+        { name: '@sql.prepend' },
+        { name: '@sql.append' },
+      ];
       const changedProperties = {};
 
       const removedElements = {};
@@ -79,8 +84,8 @@ function getArtifactComparator(otherModel, addedEntities, deletedEntities, eleme
       const migration = { migrate: name };
 
       relevantProperties.forEach(prop => {
-        if (artifact[prop] !== otherArtifact[prop]) {
-          changedProperties[prop] = changedElement(artifact[prop], otherArtifact[prop] || null);
+        if (artifact[prop.name] !== otherArtifact[prop.name] && (!prop.beta || isBetaEnabled(options, prop.beta))) {
+          changedProperties[prop.name] = changedElement(artifact[prop.name], otherArtifact[prop.name] || null);
         }
       });
       if (Object.keys(changedProperties).length > 0) {
@@ -150,7 +155,7 @@ function isPersistedAsTable(artifact) {
       && !hasAnnotationValue(artifact, '@cds.persistence.exists');
 }
 
-function getElementComparator(otherArtifact, addedElements = null, changedElements = null) {
+function getElementComparator(otherArtifact, addedElementsDict = null, changedElementsDict = null) {
   return function compareElements(element, name) {
     if (element._ignore) {
       return;
@@ -159,19 +164,19 @@ function getElementComparator(otherArtifact, addedElements = null, changedElemen
     const otherElement = otherArtifact.elements[name];
     if (otherElement && !otherElement._ignore) {
       // Element type changed?
-      if (!changedElements) {
+      if (!changedElementsDict) {
         return;
       }
       if (relevantTypeChange(element.type, otherElement.type) || typeParametersChanged(element, otherElement)) {
         // Type or parameters, e.g. association target, changed.
-        changedElements[name] = changedElement(element, otherElement);
+        changedElementsDict[name] = changedElement(element, otherElement);
       }
 
       return;
     }
 
-    if (addedElements) {
-      addedElements[name] = element;
+    if (addedElementsDict) {
+      addedElementsDict[name] = element;
     }
   }
 }

package/lib/optionProcessor.js

@@ -30,7 +30,8 @@ optionProcessor
   .option('    --integrity-not-validated')
   .option('    --integrity-not-enforced')
   .option('    --assert-integrity <mode>', [ 'true', 'false', 'individual' ])
-  .option('    --assert-integrity-type <type>', [ 'RT', 'DB' ])
+  .option('    --assert-integrity-type <type>', [ 'RT', 'DB' ], { ignoreCase: true })
+  .option('    --constraints-in-create-table')
   .option('    --deprecated <list>')
   .option('    --hana-flavor')
   .option('    --direct-backend')
@@ -103,14 +104,17 @@ optionProcessor
        --integrity-not-validated         If this option is supplied, referential constraints are NOT VALIDATED.
                                          This option is also applied to result of "cdsc manageConstraints"
        --assert-integrity      <mode>    Turn DB constraints on/off:
-                                           true        : Constraints will be generated for all associations if 
+                                           true        : (default) Constraints will be generated for all associations if
                                                          the assert-integrity-type is set to DB
                                            false       : No constraints will be generated
                                            individual  : Constraints will be generated for selected associations
        --assert-integrity-type <type>  Specifies how the referential integrity checks should be performed:
                                            RT : (default) No database constraint for an association
                                                if not explicitly demanded via annotation
-                                           DB : Create database constraints for associations 
+                                           DB : Create database constraints for associations
+       --constraints-in-create-table   If set, the foreign key constraints will be rendered as
+                                       part of the "CREATE TABLE" statements rather than as separate
+                                       "ALTER TABLE ADD CONSTRAINT" statements
        --deprecated <list>  Comma separated list of deprecated options.
                             Valid values are:
                               noElementsExpansion
@@ -120,6 +124,7 @@ optionProcessor
                               renderVirtualElements
                               unmanagedUpInComponent
                               createLocalizedViews
+                              redirectInSubQueries
        --hana-flavor        Compile with backward compatibility for HANA CDS (incomplete)
        --parse-only         Stop compilation after parsing and write result to <stdout>
        --fallback-parser <type>  If the language cannot be deduced by the file's extensions, use this

package/lib/render/.eslintrc.json

@@ -13,8 +13,7 @@
     // Who cares - just very whiny and in the way
     "complexity": "off",
     "max-len": "off",
-    // We should enable this
-    "no-shadow": "off"
+    "no-shadow": "warn"
   },
   "env": {
     "es6": true

package/lib/render/DuplicateChecker.js

@@ -62,7 +62,7 @@ class DuplicateChecker {
    * Add an element to the "seen"-list
    *
    * @param {string} name Rendered element name
-   * @param {CSN.Location} location
+   * @param {CSN.Location|CSN.Path} location
    * @param {string} modelName CSN element name
    *
    */