@sap/cds-compiler 2.11.4 → 2.12.0

package/lib/transform/forOdataNew.js

@@ -191,10 +191,10 @@ function transform4odataWithCsn(inputModel, options) {
   generateForeignKeys(csn, options, referenceFlattener, csnUtils, error, isExternalServiceMember);
 
   // Apply default type facets as set by options
-  // Flatten on-conditions in unmanaged associations 
+  // Flatten on-conditions in unmanaged associations
   /* FIXME (HJB): Is this comment still correct? processOnCond only strips $self
                   We should not remove $self prefixes in structured OData to not
-                  interfer with path resolution 
+                  interfer with path resolution
   */
   // This must be done before all the draft logic as all
   // composition targets are annotated with @odata.draft.enabled in this step
@@ -303,8 +303,9 @@ function transform4odataWithCsn(inputModel, options) {
     // If @Core.Computed is explicitly set, don't overwrite it!
     if (node['@Core.Computed'] !== undefined) return;
 
-    // For @odata.on.insert/update, also add @Core.Computed
-    if (node['@odata.on.insert'] || node['@odata.on.update'])
+    // For @odata.on.insert/update,  also add @Core.Computed
+    // @odata.on is deprecated, use @cds.on {update|insert} instead
+    if(['@odata.on.insert', '@odata.on.update', '@cds.on.insert', '@cds.on.update'].some(a => node[a]))
       node['@Core.Computed'] = true;
   }
 

package/lib/transform/localized.js

@@ -5,14 +5,12 @@ const { setProp } = require('../base/model');
 const { hasErrors } = require('../base/messages');
 const { cloneCsnDictionary } = require('../model/csnUtils');
 const { cleanSymbols } = require('../base/cleanSymbols.js');
-const { rejectManagedAssociationsAndStructuresForHdbcsNames } = require('../checks/selectItems');
 const {
   cloneCsn,
   forEachDefinition,
   forEachGeneric,
   forAllQueries,
   sortCsnDefinitionsForTests,
-  getUtils,
 } = require('../model/csnUtils');
 
 /**
@@ -79,7 +77,7 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
   if (hasExistingLocalizationViews(csn, options))
     return csn;
 
-  const { info, error } = makeMessageFunction(csn, options);
+  const { info } = makeMessageFunction(csn, options);
 
   const noCoalesce = (options.localizedLanguageFallback === 'none' ||
                       options.localizedWithoutCoalesce);
@@ -87,16 +85,7 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
   createDirectConvenienceViews();     // 1
   createTransitiveConvenienceViews(); // 2 + 3
 
-  forEachDefinition(csn, (definition, artName, prop, path) => {
-    cleanSymbols(definition, _hasLocalizedView, _isViewForEntity, _isViewForView, _targetFor)
-    if(definition.query) {
-      // reject managed association and structure publishing for to-hdbcds.hdbcds
-      const that = { csnUtils: getUtils(csn), options, error };
-      rejectManagedAssociationsAndStructuresForHdbcsNames.call(that, definition, path)
-    }
-  });
-
-
+  forEachDefinition(csn, definition => cleanSymbols(definition, _hasLocalizedView, _isViewForEntity, _isViewForView, _targetFor));
 
   sortCsnDefinitionsForTests(csn, options);
   return csn;
@@ -144,7 +133,7 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
 
     art[_hasLocalizedView] = viewName;
 
-    if(acceptLocalizedView && !acceptLocalizedView(viewName, artName))
+    if (acceptLocalizedView && !acceptLocalizedView(viewName, artName))
       return;
 
     let view;

package/lib/transform/odata/generateForeignKeyElements.js

@@ -201,13 +201,13 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error, is
       // Transfer selected type properties from target key element
       // FIXME: There is currently no other way but to treat the annotation '@odata.Type' as a type property.
       for (let prop of ['type', 'length', 'scale', 'precision', 'srid', 'default', '@odata.Type']) {
-        if (fkArtifact[prop] != undefined) {
+        if (fkArtifact[prop] !== undefined) {
           foreignKeyElement[prop] = fkArtifact[prop];
         }
       }
       // If the association is non-fkArtifact resp. key, so should be the foreign key field
       for (let prop of ['notNull', 'key']) {
-        if (assoc[prop] != undefined) {
+        if (assoc[prop] !== undefined) {
           foreignKeyElement[prop] = assoc[prop];
         }
       }

package/lib/transform/transformUtilsNew.js

@@ -9,7 +9,7 @@ const { setProp } = require('../base/model');
 const { csnRefs } = require('../model/csnRefs');
 
 const { copyAnnotations, applyTransformations } = require('../model/csnUtils');
-const { cloneCsn, getUtils, isBuiltinType } = require('../model/csnUtils');
+const { cloneCsn, cloneCsnDictionary, getUtils, isBuiltinType } = require('../model/csnUtils');
 
 // Return the public functions of this module, with 'model' captured in a closure (for definitions, options etc).
 // Use 'pathDelimiter' for flattened names (e.g. of struct elements or foreign key elements).
@@ -108,7 +108,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
     // Transfer selected type properties from target key element
     // FIXME: There is currently no other way but to treat the annotation '@odata.Type' as a type property.
     for (const prop of ['type', 'length', 'scale', 'precision', 'srid', 'default', '@odata.Type']) {
-      if (fkArtifact[prop] != undefined) {
+      if (fkArtifact[prop] !== undefined) {
         foreignKeyElement[prop] = fkArtifact[prop];
       }
     }
@@ -118,7 +118,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
 
     // If the association is non-fkArtifact resp. key, so should be the foreign key field
     for (const prop of ['notNull', 'key']) {
-      if (assoc[prop] != undefined) {
+      if (assoc[prop] !== undefined) {
         foreignKeyElement[prop] = assoc[prop];
       }
     }
@@ -302,7 +302,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
    *  [ (Entity), (struct1), (struct2), (assoc), (elem) ] should result in
    *  [ (Entity), (struct1_struct2_assoc), (elem) ]
    *
-   * @param {string[]} ref 
+   * @param {string[]} ref
    * @param {CSN.Path} path CSN path to the ref
    * @param {object[]} [links] Pre-resolved links for the given ref - if not provided, will be calculated JIT
    * @param {string} [scope] Pre-resolved scope for the given ref - if not provided, will be calculated JIT
@@ -351,7 +351,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
 
   /**
    * Copy properties of the referenced type, but don't resolve to the final base type.
-   * 
+   *
    * Do not copy the length if it was just set via the default-value.
    *
    * @param {any} node Node to copy to
@@ -387,7 +387,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
    * also unravel derived enum types, i.e. take the final base type of the enum's base type.
    * Similar with associations and compositions (we probably need a _baseType link)
    *
-   * @param {CSN.Artifact} node 
+   * @param {CSN.Artifact} node
    * @param {WeakMap} [resolved] WeakMap containing already resolved refs
    * @param {boolean} [keepLocalized=false] Wether to clone .localized from a type def
    * @returns {void}
@@ -406,7 +406,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
         delete node.type; // delete the type reference as edm processing does not expect it
       } else if(finalBaseType.items) {
           // This changes the order - to be discussed!
-        node.items = cloneCsn(finalBaseType, options).items; // copy items
+        node.items = cloneCsn(finalBaseType.items, options); // copy items
         delete node.type;
       } else {
         node.type=finalBaseType;
@@ -424,16 +424,16 @@ function getTransformers(model, options, pathDelimiter = '_') {
         return;
 
       // cloneCsn only works correctly if we start "from the top"
-      const clone = cloneCsn({definitions: {'TypeDef': typeDef }}, options);
+      const cloneTypeDef = cloneCsn(typeDef, options);
       // With hdbcds-hdbcds, don't resolve structured types - but propagrate ".items", to turn into LargeString later on.
       if(typeDef.items) {
         delete node.type;
-        Object.assign(node, {items: clone.definitions.TypeDef.items});
+        Object.assign(node, {items: cloneTypeDef.items});
       }
       if(typeDef.elements && !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds')) {
         if(!typeDef.items)
           delete node.type;
-        Object.assign(node, {elements: clone.definitions.TypeDef.elements});
+        Object.assign(node, {elements: cloneTypeDef.elements});
       }
 
 
@@ -441,7 +441,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
     }
     // if the declared element is an enum, these values are with priority
     if (!node.enum && typeDef.enum) {
-      const clone = cloneCsn({definitions: {'TypeDef': typeDef }}, options).definitions.TypeDef.enum;
+      const clone = cloneCsnDictionary(typeDef.enum, options);
       Object.assign(node, { enum: clone });
     }
     if (node.length === undefined && typeDef.length !== undefined)
@@ -865,7 +865,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
   function checkMultipleAssignments(array, annoName, artifact, artifactName, err = true) {
     if (array.length > 1) {
       const loc = ['definitions', artifactName];
-      if (err == true) {
+      if (err === true) {
         error(null, loc, { anno: annoName }, `Annotation $(ANNO) must be assigned only once`);
       } else {
         warning(null, loc, { anno: annoName },`Annotation $(ANNO) must be assigned only once`);
@@ -1084,7 +1084,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
    * Expand structured expression arguments to flat reference paths.
    * Structured elements are real sub element lists and managed associations.
    * All unmanaged association definitions are rewritten if applicable (elements/mixins).
-   * Also, HAVING and WHERE clauses are rewritten. We also check for infix filters and 
+   * Also, HAVING and WHERE clauses are rewritten. We also check for infix filters and
    * .xpr in columns.
    *
    * @todo Check if can be skipped for abstract entity  and or cds.persistence.skip ?

package/lib/transform/translateAssocsToJoins.js

@@ -315,7 +315,7 @@ function translateAssocsToJoins(model, inputOptions = {})
       }
       // if the found QA is the mixin QA and if the path length is one,
       // this indicates the publishing of a mixin assoc, don't rewrite the path
-      if(QA.mixin && tail.length == 1)
+      if(QA.mixin && tail.length === 1)
         return;
       let pos = tail.indexOf(ps);
       // cut off ps if it's a join relevant association with postfix
@@ -670,7 +670,7 @@ function translateAssocsToJoins(model, inputOptions = {})
             if(fwdAssoc)
             {
               //env.assocStack.includes(fwdAssoc) => recursion
-              if(env.assocStack.length == 2) {
+              if(env.assocStack.length === 2) {
                 // reuse (ugly) error message from forHana
                 error(null, env.assocStack[0].location,
                   { name: '$self', id: '$self' },
@@ -702,7 +702,7 @@ function translateAssocsToJoins(model, inputOptions = {})
         // ON cond of the forward assoc with swapped src/tgt aliases
         let fwdAssoc = getForwardAssociationExpr(expr);
         if(fwdAssoc) {
-          if(env.assocStack.length == 2) {
+          if(env.assocStack.length === 2) {
             // reuse (ugly) error message from forHana
             error(null, expr.location, 'An association that uses “$self” in its ON-condition can\'t be compared to “$self”');
             // don't check these paths again
@@ -736,7 +736,7 @@ function translateAssocsToJoins(model, inputOptions = {})
         let newSrcAlias = tgtAlias;
         let newTgtAlias = {};
         // first try to identify table alias for complex views or redirected associations
-        if(fwdAssoc._redirected && fwdAssoc._redirected.length && 
+        if(fwdAssoc._redirected && fwdAssoc._redirected.length &&
            // redirected target must have a $QA
            fwdAssoc._redirected[fwdAssoc._redirected.length-1].$QA &&
            // $QA's artifact must either be same srcAlias artifact
@@ -912,7 +912,7 @@ function translateAssocsToJoins(model, inputOptions = {})
               combined list of elements made available by the from clause.
           */
           let _navigation = undefined; // don't modify original path
-          if(env.assocStack.length == 2) {
+          if(env.assocStack.length === 2) {
             // a mixin assoc cannot have a structure prefix, it's sufficient to check head
             if(head.id === env.assocStack.id()) {
               // source side from view point of view (target side from forward point of view)
@@ -974,7 +974,7 @@ function translateAssocsToJoins(model, inputOptions = {})
 
       // Return the original association if expr is a backlink term, undefined otherwise
       function getForwardAssociationExpr(expr) {
-        if(expr.op && expr.op.val === '=' && expr.args.length == 2) {
+        if(expr.op && expr.op.val === '=' && expr.args.length === 2) {
           return getForwardAssociation(expr.args[0].path, expr.args[1].path);
         }
         return undefined;
@@ -983,10 +983,10 @@ function translateAssocsToJoins(model, inputOptions = {})
       function getForwardAssociation(lhs, rhs) {
         // [alpha.]BACKLINK.[beta.]FORWARD
         if(lhs && rhs) {
-          if(rhs.length == 1 && rhs[0].id === '$self' &&
+          if(rhs.length === 1 && rhs[0].id === '$self' &&
               lhs.length > 1 && hasPrefix(lhs))
             return lhs[lhs.length-1]._artifact;
-          if(lhs.length == 1 && lhs[0].id === '$self' &&
+          if(lhs.length === 1 && lhs[0].id === '$self' &&
               rhs.length > 1 && hasPrefix(rhs))
             return rhs[rhs.length-1]._artifact;
         }

package/lib/transform/universalCsnEnricher.js

@@ -1,67 +1,237 @@
 'use strict';
 
-const { forEachDefinition } = require('../base/model');
+const { setProp } = require('../base/model');
 const {
-  applyTransformations,
-  cloneCsn,
+  forEachDefinition,
+  forAllQueries,
   getUtils,
-  isBuiltinType,
+  forEachMember,
+  forEachMemberRecursively,
 } = require('../model/csnUtils');
 
 /**
- * Loop through a universal CSN and enrich it with the properties
+ * Loop through a universal CSN and enrich it with the properties/annotations
  * from the source definition - modifies the input model in-place
- * 
+ *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
  */
-module.exports = function(csn, options) {
-  let { getOrigin, getFinalType, getFinalTypeDef } = getUtils(csn);
-  // User-defined structured types do not have the elements propagated any longer
-  // if there is no association among the elements. For that reason,
-  // as a first step propagate the elements of these
-  forEachDefinition(csn, (def) => {
-    if (def.kind === 'type' && def.type && !def.elements) {
-      const finalType = getFinalType(def.type);
-      if (isBuiltinType(finalType)) return;
-      const finalTypeDef = getFinalTypeDef(def.type);
-      if (finalTypeDef.elements)
-        def.elements = cloneCsn(finalTypeDef.elements, options);
+module.exports = function (csn, options) {
+  let { getOrigin, getQueryPrimarySource, artifactRef } = getUtils(csn);
+
+  // Properties on definition level that we treat specially.
+  // TODO: There might be more annotations that will need special treatment
+  // see lib/compiler/propagator.js for reference
+  const defProps = {
+    '@cds.autoexpose': onlyViaArtifact,
+    '@fiori.draft.enabled': onlyViaArtifact,
+    '@': (prop, target, source) => { target[prop] = source[prop] },
+    // Example: `type E : F;` does not have `elements`, but they are required for e.g. OData.
+    'elements': onlyTypeDef,
+  }
+
+  // In this first loop through the model, missing properties in universal CSN
+  // are propagated so the CSN can become client one
+  forEachDefinition(csn, propagate);
+
+  // The $origin properties need to be removed separately
+  // as the values are used in csnRef::getOrigin that is used during
+  // the propagation above.
+  // Currently testMode-only for comparison against client CSN.
+  if (options.testMode) removeDollarProperties(csn);
+
+  /**
+   * Identify the sources of the passed object and propagate the relevant
+   * properties/annotations.
+   *
+   * @param {Object} art Target object for propagation
+   */
+  function propagate(art) {
+    // check if art was already processed by the status flag
+    // TODO: clean up later on, together with validator clean up probably or
+    //       when this module is meant to be used standalone -> use internal cache to store already processed definitions?
+    if (art._status === 'propagated') return;
+
+    // collect chain of origins and propagate
+    // from the farthest to the nearest one to the target
+    let chain = [];
+    let target = art;
+    let origin = undefined;
+    do {
+      origin = getOrigin(target);
+      if (origin) {
+        chain.push({ target, origin });
+        target = origin;
+      }
+    } while (origin);
+
+    if (chain.length)
+      chain.reverse().forEach(propagateSingleStep);
+    else
+      // even if there weren't any found origin(s) on definition level
+      // we need to loop through the members
+      // TODO: construct use-/test-case where there might be the need that an origin chain
+      //       needs to be constructed for members as well, specifically for this 'else'
+      //       case where we do not run through the definitions
+      propagateMembersProps(target);
+
+    function propagateSingleStep({ target, origin }) {
+      // if target was already processed -> continue
+      if (target._status === 'propagated') return;
+      // propagate relevant definition level properties
+      // we check for kind as in the future the function should be
+      // generic and work for parts of CSN
+      if (target.kind) propagateDefProps(target, origin);
+      // propagate properties to members
+      propagateMembersProps(target);
+
+      setProp(target, '_status', 'propagated');
+    }
+
+    /**
+     * Propagate from 'source' to 'target' the relevant properties
+     * for CSN definitions.
+     *
+     * @param {CSN.Definition} target
+     * @param {CSN.Definition} source
+     */
+    function propagateDefProps(target, source) {
+      const keys = Object.keys(source);
+      for (const prop of keys) {
+        // do not overwrite properties in target def
+        if (!(prop in target)) {
+          const func = defProps[prop] || defProps[prop.charAt(0)];
+          if (func) func(prop, target, source);
+        }
+      }
+    }
+
+    /**
+     * Propagate properties from Universal to Client CSN relevant for members.
+     *
+     * @param {CSN.Artifact} target
+     */
+    function propagateMembersProps(target) {
+      // TODO: in the future, consider case when target is a member itself,
+      //       for when we do not run with the complete CSN
+      // TODO: use newly added 'forEachMemberRecursivelyWithQuery'
+      forEachMemberRecursively(target, (member) => {
+        propagateMemberPropsFromOrigin(member);
+        if (member.target && !member.keys && !member.on)
+          calculateForeignKeys(member);
+      });
+      target.query && forAllQueries(target.query, (query) => {
+        if (query.SELECT && query.SELECT.elements) {
+          forEachMember(query.SELECT, (member) => {
+            propagateMemberPropsFromOrigin(member);
+            if (member.target && !member.keys && !member.on)
+              calculateForeignKeys(member);
+          });
+        }
+      });
+      setProp(target, '_status', 'propagated');
     }
-  });
-
-  // as a second step, loop through all the $origin properties in the model
-  // and propagate the properties from the origin definition
-  applyTransformations(csn, {
-    '$origin': (node, _$orign, $originValue, _path, parent, propName) => {
-      if (!node.kind) { // we do not want to replace whole definitions
-        if (Array.isArray($originValue))
-          propagatePropsFromOrigin(node, propName, parent);
-        else if ($originValue.$origin && Array.isArray($originValue.$origin)) {
-          // cover the case of query entity elements where we have own and ihnerited attributes/annotations
-          propagatePropsFromOrigin($originValue, propName, parent);
+
+    function propagateMemberPropsFromOrigin(member) {
+      // For empty members (`{}`), the origin was set in a previous call to `getOrigin(definition)`.
+      const memberOrigin = getOrigin(member);
+      if (!memberOrigin) return;
+
+      // when having an element with a type property that is
+      // user-defined there is no need to propagate 'elements',
+      // 'kind', etc. from the origin (which is the type definition)
+      if (member.type && Object.keys(member).length === 1) return;
+
+      const keys = Object.keys(memberOrigin);
+      // Copy over properties from the origin element.
+      // Don't propagate "kind" as this property is not allowed in elements.
+      for (const key of keys) {
+        if (!(key in member) && key !== 'kind')
+          member[key] = memberOrigin[key];
+      }
+
+      // copy over own annotations/properties
+      // TODO: try to create use-/test-case where this needs
+      //       to be applied on definition level, ATM it is done only for members
+      if (member.$origin && !Array.isArray(member.$origin) && member.$origin.$origin) {
+        const ownKeys = Object.keys(member.$origin);
+        for (const key of ownKeys) {
+          if (key !== '$origin')
+            member[key] = member.$origin[key];
         }
+      }
 
+      // In case of managed composition an anonymous $origin is used.
+      // csnRefs::getOrigin returns {} for such a member, thus have to recreate the client CSN from
+      // the values in the $origin. PR #8072
+      if (!Object.keys(memberOrigin).length && member.$origin && member.$origin.type === 'cds.Composition') {
+        member.type = member.$origin.type;
+        member.cardinality = member.$origin.cardinality;
+        member.targetAspect = member.$origin.target;
       }
     }
-  }, undefined, undefined, options);
-
-  function propagatePropsFromOrigin(member, memberName, construct) {
-    // TODO: shall the $origin be kept as part of the element?
-    const origin = getOrigin(member);
-    if (origin.kind) return;
-    if (member.elements && origin.type) {
-      delete member.$origin;
-      member.type = origin.type;
-      return;
+
+    function calculateForeignKeys(member) {
+      // managed assocs in universal CSN have no longer keys
+      // if they are not explicitly defined - PR#8064
+      const target = artifactRef(member.target);
+      const targetKeys = Object.keys(target.elements).filter((key) => target.elements[key].key);
+      member.keys = targetKeys.map(
+        keyName => { return { ref: [keyName] } }
+      );
     }
-    let newMember = cloneCsn(origin, options);
-    // keep targets and keys of assoc, if it was redirected
-    if (origin.type === 'cds.Association') {
-      newMember.target = member.target || newMember.target;
-      newMember.keys = member.keys || newMember.keys;
+
+  }
+
+  /**
+   * @cds.autoexpose for example, is propagated only if at definition level and only if
+   * the primary source (left-most) does not follow an association.
+   *
+   * @param {String} prop
+   * @param {CSN.Definition} target
+   * @param {CSN.Definition} source
+   */
+  function onlyViaArtifact(prop, target, source) {
+    if (!target.kind) return;
+    const primarySourceRef = getQueryPrimarySource(target.query || target.projection);
+    const artRef = primarySourceRef ? artifactRef(primarySourceRef) : source;
+    if (!artRef.target) {
+      target[prop] = source[prop];
     }
-    // TODO: check if this works fine for items/returns/actions
-    construct[memberName] = newMember;
+  }
+
+  /**
+   * Execute only if the target definition is a user-defined type.
+   *
+   * @param {String} prop
+   * @param {CSN.Definition} target
+   * @param {CSN.Definition} source
+   * @returns
+   */
+  function onlyTypeDef(prop, target, source) {
+    if (target.kind !== 'type') return;
+    target[prop] = source[prop];
+  }
+
+  /**
+   * Removes every occurrence of '$origin' and '$generated'
+   * for compatibility with what we have in client CSN.
+   *
+   * @param {CSN.Model} csn
+   */
+  function removeDollarProperties(csn) {
+    forEachDefinition(csn, (def) => {
+      delete def.$origin;
+      delete def.$generated;
+      // TODO: use newly added 'forEachMemberRecursivelyWithQuery'
+      forEachMemberRecursively(def, (member) => delete member.$origin);
+      def.query && forAllQueries(def.query, (query) => {
+        if (query.SELECT && query.SELECT.elements) {
+          forEachMember(query.SELECT, (member) => {
+            delete member.$origin;
+          });
+        }
+      });
+    })
   }
 }

package/lib/utils/file.js

@@ -7,7 +7,7 @@ const util = require('util');
 
 /**
  * Split the given source string into its lines.  Respects Unix,
- * Windows und Macintosh line breaks.
+ * Windows and Macintosh line breaks.
  *
  * @param {string} src
  * @returns {string[]}
@@ -48,6 +48,7 @@ function cdsFs(fileCache, enableTrace) {
   });
 
   return {
+    /** @type {function(string, string)} */
     readFileAsync: util.promisify(readFile),
     readFile,
     readFileSync,

package/lib/utils/timetrace.js

@@ -1,7 +1,7 @@
 'use strict';
 
 /**
- * A single TimeTrace encapsulates the runtime of a selected code frame.
+ * A single StopWatch encapsulates the runtime of a selected code frame.
  *
  * @class TimeTrace
  */
@@ -14,6 +14,8 @@ class StopWatch {
    */
   constructor(id) {
     this.id = id;
+    // TODO: If we require Node 12, use process.hrtime.bigint()
+    //       as process.hrtime() is deprecated.
     // eslint-disable-next-line no-multi-assign
     this.startTime = this.lapTime = process.hrtime();
   }
@@ -123,4 +125,8 @@ const ignoreTimeTrace = {
 };
 
 const doTimeTrace = process && process.env && process.env.CDSC_TIMETRACING !== undefined;
-module.exports = { timetrace: (doTimeTrace ? new TimeTracer() : ignoreTimeTrace), StopWatch };
+module.exports = {
+  timetrace: (doTimeTrace ? new TimeTracer() : ignoreTimeTrace),
+  TimeTracer,
+  StopWatch,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "2.11.4",
+  "version": "2.12.0",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",