@sap/cds-compiler 3.1.2 → 3.3.2

package/lib/model/enrichCsn.js

@@ -60,14 +60,20 @@ function enrichCsn( csn, options = {} ) {
     $origin,
     // TODO: excluding
     '@': () => { /* ignore annotations */ },
-  }
+  };
   // 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 {
+    inspectRef,
+    artifactRef,
+    getOrigin,
+    initDefinition,
+    // eslint-disable-next-line camelcase
+    __getCache_forEnrichCsnDebugging,
+  } = csnRefs( csn, true );
 
   const csnPath = [];
   if (csn.definitions)
@@ -87,20 +93,20 @@ function enrichCsn( csn, options = {} ) {
       obj.forEach( (n, i) => standard( obj, i, n ) );
     }
     else {
-      for (let name of Object.getOwnPropertyNames( obj )) {
+      for (const name of Object.getOwnPropertyNames( obj )) {
         const trans = transformers[name] || transformers[name.charAt(0)] || standard;
         trans( obj, name, obj[name] );
       }
       if (obj.$parens)
         reveal( obj, '$parens', obj.$parens );
-      _cache_debug( obj );
+      _cacheDebug( obj );
     }
     csnPath.pop();
   }
 
   function definition( parent, prop, obj ) {
     // call getOrigin() before standard() to set implicit protos inside standard():
-    const origin = handleError( err => err ? err.toString() : getOrigin( obj ) );
+    const origin = handleError( err => (err ? err.toString() : getOrigin( obj )) );
     standard( parent, prop, obj );
     if (obj.$origin === undefined && !obj.type && origin != null)
       obj._origin = refLocation( origin );
@@ -110,29 +116,31 @@ function enrichCsn( csn, options = {} ) {
     if (!dict)                  // value null for inheritance interruption
       return;
     csnPath.push( prop );
-    for (let name of Object.getOwnPropertyNames( dict )) {
+    for (const name of Object.getOwnPropertyNames( dict )) {
       if (prop === 'definitions')
         initDefinition( dict[name] );
       definition( dict, name, dict[name] );
     }
     if (!Object.prototype.propertyIsEnumerable.call( parent, prop ))
-      parent['$'+prop] = dict;
+      parent[`$${ prop }`] = dict;
     csnPath.pop();
   }
 
   function refLocation( art ) {
     if (!art || typeof art !== 'object' || Array.isArray( art )) {
-      if (!options.testMode)
+      if (!options.testMode) {
         return (typeof art === 'string')
-        ? `<illegal ref = ${art}>`
-        : `<illegal ref: ${typeof art}>`;
+          ? `<illegal ref = ${ art }>`
+          : `<illegal ref: ${ typeof art }>`;
+      }
       throw new Error( 'Illegal reference' );
     }
-    else if (art.$location)
+    else if (art.$location) {
       return art.$location;
+    }
 
     if (!options.testMode)
-      return `<${Object.keys( art ).join('+')}+!$location>`;
+      return `<${ Object.keys( art ).join('+') }+!$location>`;
     throw new Error( 'Reference to object without $location' );
   }
 
@@ -140,19 +148,19 @@ function enrichCsn( csn, options = {} ) {
     // try {
     const notFound = (options.testMode) ? undefined : null;
     if (Array.isArray( ref )) {
-      parent['_' + prop] = ref.map( r => refLocation( artifactRef( r, notFound ) ) );
+      parent[`_${ prop }`] = ref.map( r => refLocation( artifactRef( r, notFound ) ) );
     }
     else if (typeof ref === 'string') {
       if (!ref.startsWith( 'cds.'))
-        parent['_' + prop] = refLocation( artifactRef( ref, notFound ) );
+        parent[`_${ prop }`] = refLocation( artifactRef( ref, notFound ) );
     }
     else if (!ref.elements) {
-      parent['_' + prop] = refLocation( artifactRef( ref, notFound ) );
+      parent[`_${ prop }`] = refLocation( artifactRef( ref, notFound ) );
     }
     else {                      // targetAspect, target
       csnPath.push( prop );
       dictionary( ref, 'elements', ref.elements );
-      _cache_debug( ref );
+      _cacheDebug( ref );
       csnPath.pop();
     }
     // } catch (e) {
@@ -160,7 +168,7 @@ function enrichCsn( csn, options = {} ) {
   }
 
   function $origin( parent, prop, ref ) {
-    handleError( err => {
+    handleError( (err) => {
       if (err)
         parent._origin = err.toString();
       else if (Array.isArray( ref ) || typeof ref === 'string') // $origin: […] / "short-ref"
@@ -171,13 +179,13 @@ function enrichCsn( csn, options = {} ) {
   }
 
   function pathRef( parent, prop, path, inspectionPath = csnPath ) {
-    const inspection = handleError( (err) => {
-      return (err) ? { scope: err.toString() } : inspectRef( inspectionPath );
-    });
-    const { links, art, scope, $env } = inspection;
+    const inspection = handleError( err => ((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)
+    if (links && links[links.length - 1].art !== art)
       parent._art = refLocation( art );
     parent._scope = scope;
     if ($env)
@@ -211,12 +219,13 @@ function enrichCsn( csn, options = {} ) {
       return callback();
     try {
       return callback();
-    } catch (err) {
+    }
+    catch (err) {
       return callback( err );
     }
   }
 
-  function _cache_debug( obj, subCache ) {
+  function _cacheDebug( obj, subCache ) {
     if (options.enrichCsn !== 'DEBUG')
       return;
     const cache = subCache || __getCache_forEnrichCsnDebugging( obj );
@@ -251,7 +260,7 @@ function enrichCsn( csn, options = {} ) {
             for (const n in val) {
               const alias = val[n];
               const c = {};
-              _cache_debug( c, alias );
+              _cacheDebug( c, alias );
               sub[n] = c.$$cacheObject;
             }
             obj.$$cacheObject[name] = sub;
@@ -259,10 +268,11 @@ function enrichCsn( csn, options = {} ) {
         }
         else if (name === '$origin$step') { // string value handled above
           const kind = Object.keys( val )[0];
-          obj.$$cacheObject[name] = `${kind}: ${ val[kind] }`;
+          obj.$$cacheObject[name] = `${ kind }: ${ val[kind] }`;
         }
         else if (Array.isArray( val )) {
-          obj.$$cacheObject[name] = val.map( item => {
+          // eslint-disable-next-line no-loop-func
+          obj.$$cacheObject[name] = val.map( (item) => {
             if (!item.$$objectNumber)
               item.$$objectNumber = -(++$$cacheObjectNumber);
             return item.$$objectNumber;
@@ -281,7 +291,7 @@ function enrichCsn( csn, options = {} ) {
     if (debugLocationInfo && !userProvided) {
       loc = loc.replace( /\([0-9]+\)\^/, '^' );
       debugLocationInfo[loc] = (debugLocationInfo[loc] || 0) + 1;
-      loc = `${loc}(${debugLocationInfo[loc]})`;
+      loc = `${ loc }(${ debugLocationInfo[loc] })`;
     }
     return loc;
   }
@@ -298,11 +308,11 @@ function enrichCsn( csn, options = {} ) {
         reveal( node, '$location', debugLocation( loc, !node.$generated ) );
     }
     else if (prop === true || prop === 'returns') { // in dictionary or returns
-      loc = debugLocation( loc + '^' );
+      loc = debugLocation( `${ loc }^` );
       node.$location = loc;
     }
     else if (prop === 'items') {
-      let iloc = loc + '[]';
+      let iloc = `${ loc }[]`;
       let obj = node;
       while (obj) {
         // should not appear in --enrich-csn, only for _origin info

package/lib/model/revealInternalProperties.js

@@ -25,10 +25,10 @@ function locationString( loc ) {
     return '';
   return (typeof loc === 'object' && loc.file)
     ? msg.locationString(loc)
-    : (typeof loc) + ':' + msg.locationString(loc);
+    : `${ typeof loc }:${ msg.locationString(loc) }`;
 }
 
-var unique_id = 0;
+let uniqueId = 0;
 
 // some (internal) kinds are normally represented as links
 const kindsRepresentedAsLinks = {
@@ -36,13 +36,13 @@ const kindsRepresentedAsLinks = {
   select: (art, parent) => art._main && parent !== art._main.$queries,
   // represent table alias in from / join-args property as link:
   $tableAlias: tableAliasAsLink,
-  // represent "navigation elemens" in _combined as links:
+  // represent "navigation elements" in _combined as links:
   $navElement: (art, parent) => art._parent && parent !== art._parent.elements && art._parent.kind !== 'aspect',
   // represent mixin in $tableAliases as link:
   mixin: tableAliasAsLink,
   // represent $projection as link, as it is just another search name for $self:
   $self: (_a, _p, name) => name !== '$self',
-}
+};
 
 function tableAliasAsLink( art, parent, name ) {
   return art._parent && art._parent.$tableAliases && // initXYZ() is run
@@ -98,8 +98,8 @@ function revealInternalProperties( model, nameOrPath ) {
     _status: primOrString,       // is a string anyway
     $annotations: as => as.map( $annotation ),
     $messageFunctions: () => '‹some functions›',
-  }
-  unique_id = 1;
+  };
+  uniqueId = 1;
   return revealXsnPath(nameOrPath, model);
 
   // Returns the desired artifact/dictionary in the XSN.
@@ -132,7 +132,7 @@ function revealInternalProperties( model, nameOrPath ) {
     if (path.length === 1) {
       const def = xsn.definitions?.[path[0]] || xsn.vocabularies?.[path[0]];
       if (!def)
-        throw new Error(`reveal xsn: Unknown definition: “${path[0]}”`)
+        throw new Error(`reveal xsn: Unknown definition: “${ path[0] }”`);
       return reveal( def );
     }
 
@@ -141,11 +141,11 @@ function revealInternalProperties( model, nameOrPath ) {
 
     for (const segment of path) {
       if (xsn[segment])
-        xsn = xsn[segment]
+        xsn = xsn[segment];
       else if (segment)         // huh, this should be a call error
-        throw new Error(`Raw Output: Path segment "${ segment }" could not be found. Path: ${ JSON.stringify(path) }!"`)
+        throw new Error(`Raw Output: Path segment "${ segment }" could not be found. Path: ${ JSON.stringify(path) }!"`);
     }
-    const propName = path[path.length > 1 ? path.length - 2 : 0 ];
+    const propName = path[path.length > 1 ? path.length - 2 : 0];
     const obj = {};
     obj[propName] = xsn;
     return reveal( obj );
@@ -175,9 +175,9 @@ function revealInternalProperties( model, nameOrPath ) {
 
   function layerExtends( dict ) {
     const r = Object.create( Object.getPrototypeOf(dict)
-                             ? NOT_A_DICTIONARY.prototype
-                             : Object.prototype );
-    for (let name in dict)
+      ? NOT_A_DICTIONARY.prototype
+      : Object.prototype );
+    for (const name in dict)
       r[name] = true;
     return r;
   }
@@ -185,17 +185,17 @@ function revealInternalProperties( model, nameOrPath ) {
   function $annotation( anno ) { // property for cds-lsp
     const { name, $flatten } = anno.value || anno;
     const value = ($flatten)
-          ? { name: reveal( name ), $flatten: $flatten.map( $annotation ) }
-          : `@${name?.absolute}`;
+      ? { name: reveal( name ), $flatten: $flatten.map( $annotation ) }
+      : `@${ name?.absolute }`;
     return { value, location: locationString( anno.location || anno.name.location ) };
   }
 
   function columns( nodes, query ) {
     // If we will have specified elements, we need another test to see columns in --parse-cdl
     return nodes && array( nodes,
-                           c => (c._parent && c._parent.elements)
-                           ? artifactIdentifier( c, query )
-                           : reveal( c, nodes ) );
+                           c => ((c._parent && c._parent.elements)
+                             ? artifactIdentifier( c, query )
+                             : reveal( c, nodes )) );
   }
 
   function elements( dict, parent ) {
@@ -213,9 +213,9 @@ function revealInternalProperties( model, nameOrPath ) {
     if (!node || typeof node !== 'object' || !model.definitions || parent === model )
       return dictionary( node );    // no dictionary or no definitions section
     const dict = Object.create( Object.getPrototypeOf(node)
-                                ? NOT_A_DICTIONARY.prototype
-                                : Object.prototype );
-    for (let name in node) {
+      ? NOT_A_DICTIONARY.prototype
+      : Object.prototype );
+    for (const name in node) {
       const art = node[name];
       dict[name] = (art.kind !== 'using')
         ? artifactIdentifier( art )
@@ -231,9 +231,9 @@ function revealInternalProperties( model, nameOrPath ) {
       return array( node, reveal );
     // Make unexpected prototype visible with node-10+:
     const r = Object.create( Object.getPrototypeOf(node)
-                             ? NOT_A_DICTIONARY.prototype
-                             : Object.prototype );
-    for (let prop of Object.getOwnPropertyNames( node )) { // also non-enumerable
+      ? NOT_A_DICTIONARY.prototype
+      : Object.prototype );
+    for (const prop of Object.getOwnPropertyNames( node )) { // also non-enumerable
       r[prop] = reveal( node[prop], node, prop );
     }
     if (node[$inferred] && !node['[$inferred]'])
@@ -246,8 +246,7 @@ function revealInternalProperties( model, nameOrPath ) {
   function origin( node, parent ) {
     if (!node || node.$inferred === 'REDIRECTED')
       return reveal( node, parent );
-    else
-      return artifactIdentifier( node, parent );
+    return artifactIdentifier( node, parent );
   }
 
   function revealNonEnum( node, parent ) {
@@ -263,20 +262,20 @@ function revealInternalProperties( model, nameOrPath ) {
 
   function reveal( node, parent, name ) {
     if (node == null || typeof node !== 'object' )
-      return node
+      return node;
     if (Array.isArray(node))
       return array( node, n => reveal( n, node, name ) );
 
-    const asLinkTest = kindsRepresentedAsLinks[ node.kind ];
+    const asLinkTest = kindsRepresentedAsLinks[node.kind];
     if (asLinkTest && asLinkTest( node, parent, name ))
       return artifactIdentifier( node, parent );
 
-    let r = Object.create( Object.getPrototypeOf( node ) );
+    const r = Object.create( Object.getPrototypeOf( node ) );
     // property to recognize === objects
     if (node.kind && node.__unique_id__ == null)
-      Object.defineProperty( node, '__unique_id__', { value: ++unique_id } );
+      Object.defineProperty( node, '__unique_id__', { value: ++uniqueId } );
 
-    for (let prop of Object.getOwnPropertyNames( node )) { // also non-enumerable
+    for (const prop of Object.getOwnPropertyNames( node )) { // also non-enumerable
       const func = transformers[prop] ||
             ({}.propertyIsEnumerable.call( node, prop ) ? reveal : revealNonEnum);
       r[prop] = func( node[prop], node );
@@ -285,8 +284,8 @@ function revealInternalProperties( model, nameOrPath ) {
   }
 
   function targetAspect( node, parent ) {
-    if (node.elements && unique_id && node.__unique_id__ == null)
-      Object.defineProperty( node, '__unique_id__', { value: ++unique_id } );
+    if (node.elements && uniqueId && node.__unique_id__ == null)
+      Object.defineProperty( node, '__unique_id__', { value: ++uniqueId } );
     return reveal( node, parent );
   }
 
@@ -305,28 +304,33 @@ function array( node, fn ) {
 function artifactIdentifier( node, parent ) {
   if (Array.isArray(node))
     return node.map( a => artifactIdentifier( a, node ) );
-  if (unique_id && node.__unique_id__ == null)
-    Object.defineProperty( node, '__unique_id__', { value: ++unique_id } );
-  let outer = unique_id ? '##' + node.__unique_id__ : '';
+  if (uniqueId && node.__unique_id__ == null)
+    Object.defineProperty( node, '__unique_id__', { value: ++uniqueId } );
+  let outer = uniqueId ? `##${ node.__unique_id__ }` : '';
   if (node._outer) {
-    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;
+    if (node.$inferred === 'REDIRECTED') {
+      outer = `/redirected${ outer }`;
+    }
+    else {
+      // eslint-disable-next-line no-nested-ternary
+      outer = (node._outer.items === node) ? `/items${ outer }`
+        // eslint-disable-next-line no-nested-ternary
+        : (node._outer.returns === node) ? `/returns${ outer }`
+          // eslint-disable-next-line no-nested-ternary
+          : (node._outer.targetAspect === node) ? `/target${ outer }`
+            : `/returns/items${ outer }`;
+    }
     node = node._outer;
   }
   if (node === parent)
     return 'this';
   if (node.kind === 'source')
-    return 'source:' + quoted( node.location.file );
+    return `source:${ quoted( node.location.file ) }`;
   if (node.kind === '$magicVariables')
     return '$magicVariables';
   if (!node.name) {
     try {
-      return (locationString( node.location ) || '') + '##' + node.__unique_id__;
+      return `${ locationString( node.location ) || '' }##${ node.__unique_id__ }`;
       // return JSON.stringify(node);
     }
     catch (e) {
@@ -339,47 +343,47 @@ function artifactIdentifier( node, parent ) {
         ? artifactIdentifier( node._artifact )
         : JSON.stringify(node.name);
     case 'builtin':
-      return '$magicVariables/' + msg.artName(node);
+      return `$magicVariables/${ msg.artName(node) }`;
     case 'source':
     case 'using':
-      return 'source:' + quoted( node.location && node.location.file ) +
-        '/using:' + quoted( node.name.id )
+      return `source:${ quoted( node.location && node.location.file )
+      }/using:${ quoted( node.name.id ) }`;
     default: {
       let main = node._main;
       while (main && main._outer) // anonymous aspect
         main = main._outer._main;
-      return ((main || node).kind || '<kind>') + ':' + msg.artName( node ) + outer;
+      return `${ (main || node).kind || '<kind>' }:${ msg.artName( node ) }${ outer }`;
     }
   }
 }
 
 function primOrString( node ) {
   if (node == null || typeof node !== 'object')
-    return node
+    return node;
   if (Array.isArray(node))
     return array( node, primOrString );
   if (Object.getPrototypeOf( node ))
-    return '' + node;
-  else
-    return '<dict>';
+    return `${ node }`;
+  return '<dict>';
 }
 
 function quoted( name, undef = '‹undefined›' ) {
-  return (typeof name === 'number')
-    ? name
-    : name ? '“' + name + '”' : undef;
+  if (typeof name === 'number')
+    return name;
+  return (name ? `“${ name }”` : undef);
 }
 
 // To be used for tracing, e.g. by
 // require('../model/revealInternalProperties').log(model, 'E_purposes')
 function logXsnModel( model, name ) {
+  // eslint-disable-next-line no-console, global-require
   console.log( require('util').inspect( revealInternalProperties( model, name ), false, null ) );
 }
 
 // To be used for tracing, e.g. by
 // console.log(require('../model/revealInternalProperties').ref(type._artifact))
 function xsnRef( node ) {
-  unique_id = 0;
+  uniqueId = 0;
   return artifactIdentifier( node );
 }
 

package/lib/model/sortViews.js

@@ -1,6 +1,7 @@
 'use strict';
-const {setDependencies} = require('./csnUtils');
-const { ModelError } = require("../base/error");
+
+const { setDependencies } = require('./csnUtils');
+const { ModelError } = require('../base/error');
 
 /**
  * @typedef {Object} Layers
@@ -19,22 +20,22 @@ const { ModelError } = require("../base/error");
  * @param {Symbol} _dependencies Symbol used to attach the dependencies
  * @returns {Layers}
  */
-function sortTopologically(csn, _dependents, _dependencies){
+function sortTopologically(csn, _dependents, _dependencies) {
   const layers = [];
   let { zero, nonZero } = _calculateDepth(Object.entries(csn.definitions), _dependents, _dependencies);
-  while (zero.length !== 0){
+  while (zero.length !== 0) {
     const currentLayer = [];
-    zero.forEach(([artifactName, artifact]) => {
+    zero.forEach(([ artifactName, artifact ]) => {
       currentLayer.push(artifactName);
-      if(artifact[_dependents]) {
+      if (artifact[_dependents]) {
         Object.values(artifact[_dependents]).forEach((dependant) => {
-          dependant.$pointers = dependant.$pointers - 1;
+          dependant.$pointers -= 1;
           dependant[_dependencies].delete(artifact);
         });
       }
     });
     layers.push(currentLayer);
-    ({zero, nonZero} = _findWithXPointers(nonZero, 0, _dependents, _dependencies));
+    ({ zero, nonZero } = _findWithXPointers(nonZero, 0, _dependents, _dependencies));
   }
 
   return { layers, leftover: nonZero };
@@ -44,37 +45,37 @@ function _calculateDepth(definitionsArray, _dependents, _dependencies) {
   const zero = [];
   const nonZero = [];
 
-  definitionsArray.forEach(([artifactName, artifact]) => {
-    if(artifact[_dependencies]) {
+  definitionsArray.forEach(([ artifactName, artifact ]) => {
+    if (artifact[_dependencies]) {
       artifact.$pointers = artifact[_dependencies].size;
-      nonZero.push([artifactName, artifact]);
-    } else {
+      nonZero.push([ artifactName, artifact ]);
+    }
+    else {
       artifact.$pointers = 0;
-      zero.push([artifactName, artifact]);
+      zero.push([ artifactName, artifact ]);
     }
   });
   return {
     zero,
-    nonZero
-  }
+    nonZero,
+  };
 }
 
-function _findWithXPointers(definitionsArray, x, _dependents, _dependencies){
+function _findWithXPointers(definitionsArray, x, _dependents, _dependencies) {
   const zero = [];
   const nonZero = [];
 
-  definitionsArray.forEach(([artifactName, artifact]) => {
-    if(artifact.$pointers !== undefined && artifact.$pointers === x) {
-      zero.push([artifactName, artifact]);
-    } else {
-      nonZero.push([artifactName, artifact]);
-    }
+  definitionsArray.forEach(([ artifactName, artifact ]) => {
+    if (artifact.$pointers !== undefined && artifact.$pointers === x)
+      zero.push([ artifactName, artifact ]);
+    else
+      nonZero.push([ artifactName, artifact ]);
   });
 
   return {
     zero,
-    nonZero
-  }
+    nonZero,
+  };
 }
 
 /**
@@ -86,24 +87,23 @@ function _findWithXPointers(definitionsArray, x, _dependents, _dependencies){
  * @param {CSN.Model} csn
  *
  * @returns {{name: string, sql: string}[]} Sorted array of artifact name / "CREATE STATEMENTS" pairs
- *
  */
-module.exports = function({sql, csn}){
-  const {cleanup, _dependents, _dependencies} = setDependencies(csn);
+module.exports = function sortViews({ sql, csn }) {
+  const { cleanup, _dependents, _dependencies } = setDependencies(csn);
   const { layers, leftover } = sortTopologically(csn, _dependents, _dependencies);
   cleanup.forEach(fn => fn());
-  if(leftover.length > 0)
+  if (leftover.length > 0)
     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]})));
+  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 })
+      result.push({ name, sql: sqlString });
   });
   return result;
-}
+};

package/lib/modelCompare/compare.js

@@ -46,17 +46,17 @@ function validateCsnVersions(beforeModel, afterModel, options) {
 
   if (!beforeVersionParts || beforeVersionParts.length < 2) {
     const { error, throwWithAnyError } = makeMessageFunction(beforeModel, options, 'modelCompare');
-    error(null, null, `Invalid CSN version: ${beforeVersion}`);
+    error(null, null, {}, `Invalid CSN version: ${beforeVersion}`);
     throwWithAnyError();
   }
   if (!afterVersionParts || afterVersionParts.length < 2) {
     const { error, throwWithAnyError } = makeMessageFunction(afterModel, options, 'modelCompare');
-    error(null, null, `Invalid CSN version: ${afterVersion}`);
+    error(null, null, {}, `Invalid CSN version: ${afterVersion}`);
     throwWithAnyError();
   }
   if (beforeVersionParts[0] > afterVersionParts[0] && !(options && options.allowCsnDowngrade)) {
     const { error, throwWithAnyError } = makeMessageFunction(afterModel, options, 'modelCompare');
-    error(null, null, `Incompatible CSN versions: ${afterVersion} is a major downgrade from ${beforeVersion}. Is @sap/cds-compiler version ${require('../../package.json').version} outdated?`);
+    error(null, null, {}, `Incompatible CSN versions: ${afterVersion} is a major downgrade from ${beforeVersion}. Is @sap/cds-compiler version ${require('../../package.json').version} outdated?`);
     throwWithAnyError();
   }
 }
@@ -65,7 +65,7 @@ function getArtifactComparator(otherModel, options, addedEntities, deletedEntiti
   return function compareArtifacts(artifact, name) {
     function addElements() {
       const elements = {};
-      forEachMember(artifact, getElementComparator(otherArtifact, elements));
+      forEachMember(artifact, getElementComparator(otherArtifact, elements), [ 'definitions', name ], true, { elementsOnly: true });
       if (Object.keys(elements).length > 0) {
         elementAdditions.push(addedElements(name, elements));
       }
@@ -92,12 +92,12 @@ function getArtifactComparator(otherModel, options, addedEntities, deletedEntiti
         migration.properties = changedProperties;
       }
 
-      forEachMember(otherArtifact, getElementComparator(artifact, removedElements));
+      forEachMember(otherArtifact, getElementComparator(artifact, removedElements), [ 'definitions', name ], true, { elementsOnly: true });
       if (Object.keys(removedElements).length > 0) {
         migration.remove = removedElements;
       }
 
-      forEachMember(artifact, getElementComparator(otherArtifact, null, changedElements));
+      forEachMember(artifact, getElementComparator(otherArtifact, null, changedElements), [ 'definitions', name ], true, { elementsOnly: true });
       if (Object.keys(changedElements).length > 0) {
         migration.change = changedElements;
       }

package/lib/optionProcessor.js

@@ -142,6 +142,11 @@ optionProcessor
        manageConstraints [options] <files...>   (internal) Generate ALTER TABLE statements to
                                                            add / modify referential constraints.
        inspect [options] <files...>             (internal) Inspect the given CDS files.
+
+  Environment variables
+    NO_COLOR                If set, compiler messages (/output) will not be colored.
+                            Can be overwritten by '--color'
+    CDSC_TIMETRACING        If set, additional timing information is printed to stderr.
 `);
 
 // ----------- toHana -----------