@sap/cds-compiler 2.4.4 → 2.10.2

package/lib/transform/transformUtilsNew.js

@@ -8,9 +8,8 @@ const { hasErrors, makeMessageFunction } = require('../base/messages');
 const { setProp } = require('../base/model');
 const { csnRefs } = require('../model/csnRefs');
 
-const { copyAnnotations } = require('../model/csnUtils');
-const { cloneCsn, forEachMemberRecursively, forEachGeneric, forAllQueries,
-  getUtils, isBuiltinType } = require('../model/csnUtils');
+const { copyAnnotations, applyTransformations } = require('../model/csnUtils');
+const { cloneCsn, 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).
@@ -22,7 +21,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
   const {
     getCsnDef,
     getFinalBaseType,
-    hasBoolAnnotation,
+    hasAnnotationValue,
     inspectRef,
     isStructured,
   } = getUtils(model);
@@ -62,7 +61,8 @@ function getTransformers(model, options, pathDelimiter = '_') {
     recurseElements,
     renameAnnotation,
     setAnnotation,
-    expandStructsInOnConditions,
+    resetAnnotation,
+    expandStructsInExpression,
   };
 
   // Try to apply length, precision, scale from options if no type facet is set on the primitive types 'cds.String' or 'cds.Decimal'.
@@ -268,7 +268,6 @@ function getTransformers(model, options, pathDelimiter = '_') {
         let flatElem = cloneCsn(childElem, options);
         // Don't take over notNull from leaf elements
         delete flatElem.notNull;
-        setProp(flatElem, '$viaTransform', true); // FIXME: This name is not ideal but used elsewhere, too)
         setProp(flatElem, '_flatElementNameWithDots', elementPath.concat(childName).join('.'));
         addGeneratedFlattenedElement(flatElem, flatElemName);
       }
@@ -288,49 +287,56 @@ function getTransformers(model, options, pathDelimiter = '_') {
     return result;
   }
 
-  // Return a copy of 'ref' where all path steps resulting from struct traversal are
-  // fused together into one step, using '_' (so that the path fits again for flattened
-  // structs), e.g.
-  //   [ (Entity), (struct1), (struct2), (assoc), (elem) ] should result in
-  //   [ (Entity), (struct1_struct2_assoc), (elem) ]
-  // 'path' is the csn path to the ref
-  function flattenStructStepsInRef(ref, path) {
+  /**
+   * Return a copy of 'ref' where all path steps resulting from struct traversal are
+   * fused together into one step, using '_' (so that the path fits again for flattened
+   * structs), e.g.
+   *  [ (Entity), (struct1), (struct2), (assoc), (elem) ] should result in
+   *  [ (Entity), (struct1_struct2_assoc), (elem) ]
+   *
+   * @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
+   * @param {WeakMap} [resolvedLinkTypes=new WeakMap()] A WeakMap with already resolved types for each link-step - safes an `artifactRef` call
+   * @returns {string[]}
+   */
+  function flattenStructStepsInRef(ref, path, links, scope, resolvedLinkTypes=new WeakMap()) {
     // Refs of length 1 cannot contain steps - no need to check
     if (ref.length < 2) {
       return ref;
     }
 
-    try {
-      return flatten(ref, path);
-    } catch (e) {
-      if (e.message && e.message === "Scope 'ref-where' but no entity was provided.") {
-        return flatten(ref, path);
-      } else {
-        throw e;
-      }
-    }
+    return flatten(ref, path);
 
     function flatten(ref, path) {
       let result = [];
       //let stack = []; // IDs of path steps not yet processed or part of a struct traversal
-      const { links, scope } = inspectRef(path);
+      if(!links && !scope) { // calculate JIT if not supplied
+        const res = inspectRef(path);
+        links = res.links;
+        scope = res.scope;
+      }
       if (scope === '$magic')
         return ref;
       let flattenStep = false;
       links.forEach((value, idx) => {
-        if (flattenStep)
-          result[result.length - 1] += pathDelimiter + ref[idx];
+        if (flattenStep) {
+          result[result.length - 1] += pathDelimiter + (ref[idx].id ? ref[idx].id : ref[idx]);
+          // if we had a filter or args, we had an assoc so this step is done
+          // we then keep along the filter/args by updating the id of the current ref
+          if(ref[idx].id) {
+            ref[idx].id = result[result.length-1];
+            result[result.length-1] = ref[idx];
+          }
+        }
         else {
           result.push(ref[idx]);
         }
-        flattenStep = value.art && !(value.art.kind === 'entity') && !value.art.SELECT && !value.art.from && (value.art.elements || effectiveType(value.art).elements);
+
+        flattenStep = value.art && !value.art.kind && !value.art.SELECT && !value.art.from && (value.art.elements || effectiveType(value.art).elements || (resolvedLinkTypes.get(value)||{}).elements);
       });
-      const magicVars = ['$now']
-      // If the path starts with '$self', this is now redundant (because of flattening) and can be omitted,
-      // making life easier for consumers
-      if (result[0] === '$self' && result.length > 1 && !magicVars.includes(result[1])) {
-        result = result.slice(1);
-      }
+
       return result;
     }
   }
@@ -366,22 +372,31 @@ function getTransformers(model, options, pathDelimiter = '_') {
       Object.assign(node, { srid: typeDef.srid });
   }
 
-  // Replace the type of 'node' with its final base type (in contrast to the compiler,
-  // 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)
-  function toFinalBaseType(node) {
+  /**
+   * Replace the type of 'node' with its final base type (in contrast to the compiler,
+   * 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 {WeakMap} [resolved] WeakMap containing already resolved refs
+   * @param {boolean} [keepLocalized=false] Wether to clone .localized from a type def
+   * @returns {void}
+   */
+  function toFinalBaseType(node, resolved, keepLocalized=false) {
     // Nothing to do if no type (or if array/struct type)
     if (!node || !node.type) return;
     // In case of a ref -> Follow the ref
     if (node.type && node.type.ref) {
-      let finalBaseType = getFinalBaseType(node.type);
+      const finalBaseType = getFinalBaseType(node.type, undefined, resolved);
       if(finalBaseType === null)
         throw Error('Failed to obtain final base type for reference : ' + node.type.ref.join('/'));
-      if (finalBaseType.elements) {
-        node.elements = cloneCsn(finalBaseType.elements, options); // copy elements
+      if(finalBaseType.elements) {
+          // This changes the order - to be discussed!
+        node.elements = cloneCsn(finalBaseType, options).elements; // copy elements
         delete node.type; // delete the type reference as edm processing does not expect it
-      } else if (finalBaseType.items) {
-        node.items = cloneCsn(finalBaseType.items, options); // copy items
+      } else if(finalBaseType.items) {
+          // This changes the order - to be discussed!
+        node.items = cloneCsn(finalBaseType, options).items; // copy items
         delete node.type;
       } else {
         node.type=finalBaseType;
@@ -394,10 +409,31 @@ function getTransformers(model, options, pathDelimiter = '_') {
     // The type might already be a full fledged type def (array of)
     let typeDef = typeof node.type === 'string' ? getCsnDef(node.type) : node.type;
     // Nothing to do if type is an array or a struct type
-    if (typeDef.items || typeDef.elements) return;
+    if (typeDef.items || typeDef.elements) {
+      if(!(options.transformation === 'hdbcds' || options.toSql))
+        return;
+
+      // cloneCsn only works correctly if we start "from the top"
+      const clone = cloneCsn({definitions: {'TypeDef': 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});
+      }
+      if(typeDef.elements && !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds')) {
+        if(!typeDef.items)
+          delete node.type;
+        Object.assign(node, {elements: clone.definitions.TypeDef.elements});
+      }
+
+
+      return;
+    }
     // if the declared element is an enum, these values are with priority
-    if (!node.enum && typeDef.enum)
-      Object.assign(node, { enum: cloneCsn(typeDef.enum, options) });
+    if (!node.enum && typeDef.enum) {
+      const clone = cloneCsn({definitions: {'TypeDef': typeDef }}, options).definitions.TypeDef.enum;
+      Object.assign(node, { enum: clone });
+    }
     if (node.length === undefined && typeDef.length !== undefined)
       Object.assign(node, { length: typeDef.length });
     if (node.precision === undefined && typeDef.precision !== undefined)
@@ -406,6 +442,8 @@ function getTransformers(model, options, pathDelimiter = '_') {
       Object.assign(node, { scale: typeDef.scale });
     if (node.srid === undefined && typeDef.srid !== undefined)
       Object.assign(node, { srid: typeDef.srid });
+    if (keepLocalized && node.localized === undefined && typeDef.localized !== undefined)
+      Object.assign(node, { localized: typeDef.localized });
     node.type = typeDef.type;
     toFinalBaseType(node);
   }
@@ -765,13 +803,13 @@ function getTransformers(model, options, pathDelimiter = '_') {
    */
   function extractValidFromToKeyElement(element, path) {
     let validFroms = [], validTos = [], validKeys = [];
-    if (hasBoolAnnotation(element, '@cds.valid.from')) {
+    if (hasAnnotationValue(element, '@cds.valid.from')) {
       validFroms.push({ element, path: [...path] });
     }
-    if (hasBoolAnnotation(element, '@cds.valid.to')) {
+    if (hasAnnotationValue(element, '@cds.valid.to')) {
       validTos.push({ element, path: [...path] });
     }
-    if (hasBoolAnnotation(element, '@cds.valid.key')) {
+    if (hasAnnotationValue(element, '@cds.valid.key')) {
       validKeys.push({ element, path: [...path] });
     }
     return [validFroms, validTos, validKeys];
@@ -856,7 +894,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
     if (!toName.startsWith('@')) {
       throw Error('Annotation name should start with "@": ' + toName);
     }
-    if (annotation == undefined) {
+    if (annotation === undefined) {
       throw Error('Annotation ' + fromName + ' not found in ' + JSON.stringify(node));
     }
     if(node[toName] === undefined || node[toName] === null) {
@@ -886,6 +924,34 @@ function getTransformers(model, options, pathDelimiter = '_') {
       node[name] = value;
   }
 
+  /**
+   * Assigns unconditionally annotation to a node, which means it overwrites already existing annotation assignment.
+   * Overwritting is when the assignment differs from undefined and null, also when differs from the already set value.
+   * Setting new assignment results false as return value and overwriting - true.
+   *
+   * @param {object} node Assignee
+   * @param {string} name Annotation name
+   * @param {any} value Annotation value
+   * @param {function} info function that reports info messages
+   * @param {CSN.Path} path location of the warning
+   * @returns {boolean} wasOverwritten true when the annotation was overwritten
+   */
+  function resetAnnotation(node, name, value, info, path) {
+    if (!name.startsWith('@')) {
+      throw Error('Annotation name should start with "@": ' + name);
+    }
+    if (value === undefined) {
+      throw Error('Annotation value must not be undefined');
+    }
+
+    const wasOverwritten = node[name] !== undefined && node[name] !== null && node[name] !== value;
+    const oldValue = node[name];
+    node[name] = value;
+    if(wasOverwritten)
+      info(null, path, { anno: name, prop: value, otherprop: oldValue },
+      `Value $(OTHERPROP) of annotation $(ANNO) is overwritten with new value $(PROP)`);
+    return wasOverwritten;
+  }
 
   /*
     Resolve the type of an artifact
@@ -967,7 +1033,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
   function flattenPath(path, fullRef=false, followMgdAssoc=false) {
     let art = path._art;
     if(art) {
-      if(art && art.type && !((art.items && art.items.elements) || art.elements)) {
+      if(art && !((art.items && art.items.elements) || art.elements)) {
         if(followMgdAssoc && art.target && art.keys) {
           let rc = [];
           for(const k of art.keys) {
@@ -980,9 +1046,9 @@ function getTransformers(model, options, pathDelimiter = '_') {
           }
           return rc;
         }
-        if(art.type.ref)
+        if(art.type && art.type.ref)
           art = resolvePath(art.type);
-        else if(!isBuiltinType(art.type))
+        else if(art.type && !isBuiltinType(art.type))
           art = model.definitions[art.type];
       }
       const elements = art.items && art.items.elements || art.elements;
@@ -1004,35 +1070,33 @@ function getTransformers(model, options, pathDelimiter = '_') {
     return [path];
   }
 
-/*
-   * Expand structured ON condition arguments to flat reference paths.
+  /**
+   * 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 
+   * .xpr in columns.
    *
-   * TODO: Check if can be skipped for abstract entity  and or cds.persistence.skip ?
-  */
-  function expandStructsInOnConditions(artifact, artifactName, prop, path) {
-    forEachMemberRecursively(artifact,
-      (elem, elemName, prop, path) => {
-        if(prop === 'elements') {
-          if(elem.target && elem.on) {
-            elem.on = expand(elem.on, path)
-          }
-        }
-      }, path);
-
-    if(artifact.query) {
-      forAllQueries(artifact.query, (query) => {
-        if(query.SELECT && query.SELECT.mixin) {
-          forEachGeneric(query.SELECT, 'mixin', (mixin, mixinName, prop, path) => {
-            if(mixin.target && mixin.on) {
-              mixin.on = expand(mixin.on, path);
-            }
-          },
-          path);
-        }
-      }, path.concat([ 'query' ]));
-    }
+   * @todo Check if can be skipped for abstract entity  and or cds.persistence.skip ?
+   * @param {CSN.Model} csn
+   * @param {object} [options={}] "skipArtifact": (artifact, name) => Boolean to skip certain artifacts
+   */
+  function expandStructsInExpression(csn, options = {}) {
+    applyTransformations(csn, {
+      'on': (parent, name, on, path) => {
+        parent.on = expand(parent.on, path);
+      },
+      'having': (parent, name, having, path) => {
+        parent.having = expand(parent.having, path);
+      },
+      'where': (parent, name, where, path) => {
+        parent.where = expand(parent.where, path);
+      },
+      'xpr': (parent, name, xpr, path) => {
+        parent.xpr = expand(parent.xpr, path);
+      }
+    }, undefined, undefined, options);
+
     /*
       flatten structured leaf types and return array of paths
       Flattening stops on all non-structured types.

package/lib/transform/translateAssocsToJoins.js

@@ -1,7 +1,8 @@
 'use strict'
 
 const { setProp, forEachGeneric, forEachDefinition, isBetaEnabled } = require('../base/model');
-var { handleMessages, makeMessageFunction } = require('../base/messages');
+var { makeMessageFunction } = require('../base/messages');
+const { recompileX } = require('../compiler/index');
 var { linkToOrigin } = require('../compiler/shared');
 const  {compactModel, compactExpr} = require('../json/to-csn');
 const { deduplicateMessages } = require('../base/messages');
@@ -12,13 +13,10 @@ const internalArtifactKinds = ['builtin'/*, '$parameters'*/, 'param'];
 
 function translateAssocsToJoinsCSN(csn, options){
   timetrace.start('Recompiling model');
-  let { augment } = require('../json/from-csn');
-  // Append `.csn` to `.cds` files to indicate recompilation.
-  const file = csn.$location && csn.$location.file.replace(/[.]cds$/, '.cds.csn') || '<recompile>.csn';
-  let xsn = augment(csn, file, options);
-  const { compileSourcesX } = require('../compiler');
   // Do not re-complain about localized
-  const model = compileSourcesX( { [file]: xsn }, { ...options, $recompile: true } );
+  const compileOptions = { ...options, $skipNameCheck: true };
+  delete compileOptions.csnFlavor;
+  const model = recompileX(csn, compileOptions);
   timetrace.stop();
   timetrace.start('Translating associations to joins');
   translateAssocsToJoins(model, options);
@@ -46,9 +44,9 @@ function translateAssocsToJoinsCSN(csn, options){
   }
 
   // If A2J reports error - end! Continuing with a broken CSN makes no sense
-  handleMessages(model, options);
+  makeMessageFunction(model, options).throwWithError();
   // FIXME: Move this somewhere more appropriate
-  const compact = compactModel(model);
+  const compact = compactModel(model, compileOptions);
   return compact;
 }
 
@@ -618,7 +616,7 @@ function translateAssocsToJoins(model, inputOptions = {})
             const id = this.id();
             if(elt) {
               let found = true;
-              const epath = elt.split('.');
+              const epath = [elt];
               const epl = epath.length+offset;
               if(epl < path.length) {
                 for(let i = 0; i < epl && found; i++) {
@@ -630,7 +628,7 @@ function translateAssocsToJoins(model, inputOptions = {})
             }
             if(id) {
               let found = true;
-              const epath = id.split('.');
+              const epath = [id];
               const epl = epath.length+offset;
               if(epl < path.length) {
                 for(let i = 0; i < epl && found; i++) {
@@ -745,9 +743,14 @@ function translateAssocsToJoins(model, inputOptions = {})
       function swapTableAliasesForFwdAssoc(fwdAssoc, srcAlias, tgtAlias) {
         let newSrcAlias = tgtAlias;
         let newTgtAlias = {};
-        // first try to identify table alias for complex views or
-        // redirected associations
-        if(fwdAssoc._redirected && fwdAssoc._redirected.length) {
+        // first try to identify table alias for complex views or redirected associations
+        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
+           (fwdAssoc._redirected[fwdAssoc._redirected.length-1].$QA._artifact === srcAlias._artifact ||
+           // OR original assoc is a mixin (then just use the $QA)
+           assoc.kind === 'mixin')) {
           newTgtAlias.id = fwdAssoc._redirected[fwdAssoc._redirected.length-1].$QA.name.id;
           newTgtAlias._artifact = fwdAssoc._redirected[fwdAssoc._redirected.length-1]._effectiveType;
           newTgtAlias._navigation = fwdAssoc._redirected[fwdAssoc._redirected.length-1].$QA.path[0]._navigation;

package/lib/transform/universalCsnEnricher.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const { forEachDefinition } = require('../base/model');
+const {
+  applyTransformations,
+  cloneCsn,
+  getUtils,
+  isBuiltinType,
+} = require('../model/csnUtils');
+
+/**
+ * Loop through a universal CSN and enrich it with the properties
+ * 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);
+    }
+  });
+
+  // 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);
+        }
+
+      }
+    }
+  }, 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;
+    }
+    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;
+    }
+    // TODO: check if this works fine for items/returns/actions
+    construct[memberName] = newMember;
+  }
+}

package/lib/utils/file.js

@@ -15,16 +15,6 @@ function splitLines(src) {
   return src.split(/\r\n?|\n/);
 }
 
-/**
- * Change Windows style line endings to Unix style
- *
- * @param {string} src
- * @returns {string}
- */
-function normalizeLineEndings(src) {
-  return (src && process.platform === 'win32') ? src.replace(/\r\n/g, '\n') : src;
-}
-
 /**
  * Returns filesystem utils readFile(), isFile(), realpath() for _CDS_ usage.
  * This includes a trace as well as usage of a file cache.
@@ -181,6 +171,5 @@ function cdsFs(fileCache, enableTrace) {
 
 module.exports = {
   splitLines,
-  normalizeLineEndings,
   cdsFs,
 };

package/lib/utils/moduleResolve.js

@@ -7,7 +7,6 @@
 
 const path = require('path');
 
-const { makeMessageFunction } = require('../base/messages');
 const { cdsFs } = require('./file');
 
 const DEFAULT_ENCODING = 'utf-8';
@@ -44,7 +43,7 @@ function adaptCdsModule(modulePath) {
  * @param {object} fileCache
  * @param {CSN.Options} options
  */
-function resolveModule( dep, fileCache, options ) {
+function resolveModule( dep, fileCache, options, messageFunctions ) {
   const _fs = cdsFs(fileCache, options.traceFs);
   // let opts = { extensions, basedir: dep.basedir, preserveSymlinks: false };
   // `preserveSymlinks` option does not really work -> provide workaround anyway...
@@ -96,7 +95,7 @@ function resolveModule( dep, fileCache, options ) {
       }
     }
   }).catch( () => {
-    _errorFileNotFound(dep, options);
+    _errorFileNotFound(dep, options, messageFunctions);
     return false;
   });
 }
@@ -107,7 +106,7 @@ function resolveModule( dep, fileCache, options ) {
  * @param {object} fileCache
  * @param {CSN.Options} options
  */
-function resolveModuleSync( dep, fileCache, options ) {
+function resolveModuleSync( dep, fileCache, options, messageFunctions ) {
   const _fs = cdsFs(fileCache, options.traceFs);
   const opts = {
     extensions,
@@ -129,7 +128,7 @@ function resolveModuleSync( dep, fileCache, options ) {
   });
 
   if (error) {
-    _errorFileNotFound(dep, options);
+    _errorFileNotFound(dep, options, messageFunctions);
     return false;
   }
 
@@ -148,7 +147,7 @@ function resolveModuleSync( dep, fileCache, options ) {
   }
 
   if (error) {
-    _errorFileNotFound(dep, options);
+    _errorFileNotFound(dep, options, messageFunctions);
     return false;
   }
 
@@ -161,8 +160,7 @@ function resolveModuleSync( dep, fileCache, options ) {
   return result;
 }
 
-function _errorFileNotFound(dep, options) {
-  const { error } = makeMessageFunction( null, options, 'compile' );
+function _errorFileNotFound(dep, options, { error }) {
   if (dep.resolved) {
     let resolved = path.relative( dep.basedir, dep.resolved );
     if (options.testMode)

package/lib/utils/timetrace.js

@@ -95,5 +95,10 @@ class TimeTracer {
   }
 }
 
+const ignoreTimeTrace = {
+  start: () => { /* ignore */ },
+  stop: () => { /* ignore */ },
+};
+
 const doTimeTrace = process && process.env && process.env.CDSC_TIMETRACING !== undefined;
-module.exports = doTimeTrace ? new TimeTracer() : { start: () => {}, stop: () => {} };
+module.exports = doTimeTrace ? new TimeTracer() : ignoreTimeTrace;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "2.4.4",
+  "version": "2.10.2",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",
@@ -11,6 +11,7 @@
     "cdsse": "bin/cdsse.js"
   },
   "main": "lib/main.js",
+  "types": "lib/main.d.ts",
   "scripts": {
     "postinstall": "node lib/fix_antlr4-8_warning.js"
   },