@sap/cds-compiler 4.0.2 → 4.2.2

package/lib/transform/localized.js

@@ -13,6 +13,7 @@ const {
   forAllQueries,
   sortCsnDefinitionsForTests,
 } = require('../model/csnUtils');
+const {CompilerAssertion} = require('../base/error');
 
 /**
  * Indicator that a definition is localized and has a convenience view.
@@ -34,10 +35,11 @@ const _isViewForEntity = Symbol('_isViewForEntity'); // $inferred = 'LOCALIZED-H
  * Used to transitively create convenience views.
  */
 const _targetFor = Symbol('_targetFor');
+const annoPersistenceSkip = '@cds.persistence.skip';
 
 /**
  * Callback function returning `true` if the localization view should be created.
- * @callback acceptLocalizedView
+ * @callback AcceptLocalizedViewCallback
  * @param {string} viewName localization view name
  * @param {string} originalName Artifact name of the original view
  */
@@ -45,20 +47,22 @@ const _targetFor = Symbol('_targetFor');
 /**
  * Create transitive localized convenience views.
  *
- * A convenience view is created if the entity/view has a localized element
+ * A convenience view is created if the entity/view has a localized element[^1]
  * or if it exposes an association leading to a localized-tagged target.
  *
  * INTERNALS:
  * We have three kinds of localized convenience views:
  *
  *  1. "direct ones" using coalesce() for the table entities with localized
- *     elements: as projection on the original (created in extend.js)
- *  2. for table entities with associations to entities which have a localized
- *     convenience views or redirections thereon: as projection on the original
- *  3. for view entities with associations to entities which have a localized
- *     convenience views or redirections thereon: as entity using the same
- *     query as the original, but replacing all sources by their localized
- *     convenience view variant if present
+ *     elements[^1]: as projection on the original and '.texts' entity (created in extend.js)
+ *  2. for _table_ entities with associations to entities which have a localized
+ *     convenience: as projection on the original
+ *  3. for _view_ entities with either localized elements[^1] or associations
+ *     to entities which have a localized convenience view:
+ *     as view using a copy of the original query, but replacing all sources by
+ *     their localized convenience view variant if present
+ *
+ * [^1]: That is, the element has `localized: true`.
  *
  * First, all "direct ones" are built (1).  Then we build all 2 and 3
  * transitively (i.e. as long as an entity has an association which directly or
@@ -68,21 +72,46 @@ const _targetFor = Symbol('_targetFor');
  * variant if present.
  *
  * @param {CSN.Model} csn
- * @param {CSN.Options} options
- * @param {boolean} useJoins If true, rewrite the "localized" association to a
- *                           join in direct convenience views.
+ *     Input CSN model.  Should not have existing convenience views.
+ *
+ * @param {object} options
+ *     CSN options.  Only few options are used, see below for important ones.
+ *     Options such as `testMode` or `testSortCsn` can also be set.
+ *
+ * @param {string} [options.localizedLanguageFallback]
+ *     Valid values (if set): 'none', 'coalesce' (default)
+ *     Whether to use a `coalesce()` function when selecting from `.texts` entities.
+ *     If not set, untranslated strings may not return any value.  If 'coalesce'
+ *     is used, it will fall back to the original string.
+ *
+ * @param {boolean} [options.localizedWithoutCoalesce]
+ *     Deprecated version of localizedLanguageFallback. Do not use.
+ *
+ * @param {boolean} [options.fewerLocalizedViews]
+ *
  * @param {object} config
+ *     Configuration for creating convenience views.  Non-user visible options.
+ *
+ * @param {boolean} [config.useJoins]
+ *     If true, rewrite the "localized" association to a join in direct convenience views.
+ *
+ * @param {AcceptLocalizedViewCallback} [config.acceptLocalizedView]
+ *     A callback that can be used to suppress the creation of localized convenience views
+ *     if desired.  For example, if you want to know which definitions get a convenience view
+ *     but don't actually want to create them.
+ *
+ * @param {boolean} [config.ignoreUnknownExtensions]
+ *     If true, do not emit a warning for annotations on unknown `localized.*` views.
  */
-function _addLocalizationViews(csn, options, useJoins, config) {
+function _addLocalizationViews(csn, options, config) {
   const messageFunctions = makeMessageFunction(csn, options);
-  if (checkExistingLocalizationViews(csn, options, messageFunctions)) {
-    messageFunctions.throwWithError();
+  if (checkExistingLocalizationViews(csn, options, messageFunctions))
     return csn;
-  }
 
-  const { acceptLocalizedView, ignoreUnknownExtensions } = config;
+  const { useJoins, acceptLocalizedView, ignoreUnknownExtensions } = config;
   const noCoalesce = (options.localizedLanguageFallback === 'none' ||
                       options.localizedWithoutCoalesce);
+  const ignoreAssocToLocalized = !!options.fewerLocalizedViews;
 
   createDirectConvenienceViews();     // 1
   createTransitiveConvenienceViews(); // 2 + 3
@@ -179,10 +208,10 @@ function _addLocalizationViews(csn, options, useJoins, config) {
     copyLocation(convenienceView.query, entity);
 
     if (shouldUseJoin)
-      // Expand elements:
+      // Expand elements; (variant 1)
       columns.push( ...columnsForEntityWithExcludeList( entity, 'L_0', textElements ) )
     else
-      columns.push( '*' );
+      columns.push( '*' ); // (variant 2)
 
     for (const originalElement of textElements) {
       const elem = entity.elements[originalElement];
@@ -330,8 +359,8 @@ function _addLocalizationViews(csn, options, useJoins, config) {
     let keyCount = 0;
     let textElements = [];
 
-    forEachGeneric(art, 'elements', (elem, elemName /*, prop, path*/) => {
-      if (elem._ignore) // from HANA backend
+    forEachGeneric(art, 'elements', (elem, elemName , _prop) => {
+      if (elem.$ignore) // from SAP HANA backend
         return;
 
       if (elem.key || elem.$key)
@@ -339,10 +368,6 @@ function _addLocalizationViews(csn, options, useJoins, config) {
 
       if (elem.key || elem.$key || elem.localized)
         textElements.push( elemName );
-
-      // TODO: Already warned about in extend.js
-      // if (elem.key && isLocalized)
-      //   warning( 'localized-key', path, {}, 'Keyword "localized" is ignored for primary keys' );
     }, artPath);
 
     if (textElements.length <= keyCount || keyCount <= 0)
@@ -363,12 +388,17 @@ function _addLocalizationViews(csn, options, useJoins, config) {
              'Skipped creation of convenience view for $(NAME) because its texts entity could not be found' );
       return null;
     }
-
     if (!isValidTextsEntity( textsEntity )) {
       messageFunctions.info( null, [ 'definitions', textsName ], { name: artName },
              'Skipped creation of convenience view for $(NAME) because its texts entity does not appear to be valid' );
       return null;
     }
+    if (!art[annoPersistenceSkip] && textsEntity[annoPersistenceSkip]) {
+      messageFunctions.message( 'anno-unexpected-localized-skip', artPath,
+          { name: textsName, art: artName, anno: annoPersistenceSkip },
+          'Compiler generated entity $(NAME) must not be annotated with $(ANNO) if $(ART) is not skipped' );
+      return null;
+    }
 
     // There may be keys in the original artifact that were added by the core compiler,
     // for example elements that are marked @cds.valid.from.
@@ -390,22 +420,23 @@ function _addLocalizationViews(csn, options, useJoins, config) {
 
   /**
    * Transitively create convenience views for entities/views that have
-   * associations to localized entities or to views that themselves have such
-   * a dependency.
+   * associations to localized entities, views that themselves have such
+   * a dependency or views that contain projections on localized elements.
    *
    * The algorithm is as follows:
    *
-   *  1. For each view/entity with associations:
-   *    - If target is NOT localized => add view/entity to target's `_targetFor` property
-   *    - If target is     localized => add view/entity to array `entities`
+   *  1. For each view with elements that have `localized: true` markers:
+   *      => add view to array `entities`
+   *     For each view/entity with associations:
+   *      - If target is NOT localized => add view/entity to target's `_targetFor` property
+   *      - If target is     localized => add view/entity to array `entities`
    *  2. As long as `entities` has entries:
-   *     a. For each entry in `entities`
-   *        - Create a convenience view
-   *        - If the entry has a `_targetFor` property, add its entries to
-   *          `nextEntities` because they now have a transitive dependency on a
-   *          localized view.
-   *     b. Copy all entries from `nextEntities` to `entities`.
-   *     c. Clear `nextEntities`.
+   *      a. For each entry in `entities`
+   *         - Create a convenience view
+   *         - If the entry has a `_targetFor` property, add its entries to `nextEntities`
+   *           because they now have a transitive dependency on a localized view.
+   *      b. Copy all entries from `nextEntities` to `entities`.
+   *      c. Clear `nextEntities`.
    *  3. Rewrite all references to the localized variants.
    */
   function createTransitiveConvenienceViews() {
@@ -447,10 +478,9 @@ function _addLocalizationViews(csn, options, useJoins, config) {
             // if the artifact is an entity (already processed in (1))
             entities.push(artName);
           }
-          else if (elem.target) {
+          else if (!ignoreAssocToLocalized && elem.target) {
             // If the target has a localized view then we are localized as well.
             const def = csn.definitions[elem.target];
-            // TODO: What if elem.target cannot be found? Could this happen after flattening, ...?
             if (!def)
               continue;
 
@@ -489,7 +519,7 @@ function _addLocalizationViews(csn, options, useJoins, config) {
 
       addLocalizedView(artName);
 
-      if (art[_targetFor])
+      if (!ignoreAssocToLocalized && art[_targetFor])
         nextEntities.push(...art[_targetFor]);
       delete art[_targetFor];
     }
@@ -577,14 +607,22 @@ function _addLocalizationViews(csn, options, useJoins, config) {
     if (!obj || !obj.ref)
       return;
     const ref = Array.isArray(obj.ref) ? obj.ref[0] : obj.ref;
-    if (typeof ref !== 'string')
-      return;
-    const def = csn.definitions[ref];
-    if (def && def[_hasLocalizedView]) {
-      if (Array.isArray(obj.ref))
-        obj.ref[0] = def[_hasLocalizedView];
-      else
+    if (typeof ref === 'string') {
+      const def = csn.definitions[ref];
+      if (def && def[_hasLocalizedView]) {
+        if (Array.isArray(obj.ref))
+          obj.ref[0] = def[_hasLocalizedView];
+        else
         obj.ref = def[_hasLocalizedView];
+      }
+
+    } else if (ref.id) {
+      const def = csn.definitions[ref.id];
+      if (def && def[_hasLocalizedView])
+        obj.ref[0].id = def[_hasLocalizedView];
+
+    } else if (options.testMode) {
+      throw new CompilerAssertion('Debug me: Unhandled reference during localized-rewrite!');
     }
   }
 
@@ -592,7 +630,7 @@ function _addLocalizationViews(csn, options, useJoins, config) {
    * @param {string} artName
    */
   function textsEntityName(artName) {
-    // We can assume, that the element exists.  This is checked in isEntityPreprocessed()
+    // We can assume that the element exists.  This is checked in isEntityPreprocessed().
     return csn.definitions[artName].elements.texts.target;
   }
 
@@ -625,23 +663,23 @@ function _addLocalizationViews(csn, options, useJoins, config) {
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
- * @param [config] config.acceptLocalizedView: optional callback function returning true if the localized view name and its parent name provided as parameter should be created
+ * @param [config]
  */
 function addLocalizationViews(csn, options, config = {}) {
-  return _addLocalizationViews(csn, options, false, config);
+  return _addLocalizationViews(csn, options, { ...config, useJoins: false });
 }
 
 /**
  * Create transitive localized convenience views to the given CSN but
  * rewrite the "localized" association to joins in direct entity convenience
- * views.  This is needed by e.g. SQL for SQLite where A2J is used.
+ * views.  This is needed e.g. by SQL for SQLite where A2J is used.
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
- * @param [config] config.acceptLocalizedView: optional callback function returning true if the localized view name and its parent name provided as parameter should be created
+ * @param [config]
  */
 function addLocalizationViewsWithJoins(csn, options, config = {}) {
-  return _addLocalizationViews(csn, options, true, config);
+  return _addLocalizationViews(csn, options, { ...config, useJoins: true });
 }
 
 /**

package/lib/transform/odata/toFinalBaseType.js

@@ -94,7 +94,7 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
   function expandToFinalBaseType(node, defName) {
     if (!node) return;
     // TODO: Clarify how should events be handled?
-    // They are not treated by the transformUtilsNew::toFinalBaseType function
+    // They are not treated by the transformUtils::toFinalBaseType function
     // in the same manner as named types, because the elements of structured events are not
     // propagated as it is with types.
     // It is ok to skip the expansion to the final base type for now as events are not rendered in
@@ -130,7 +130,7 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
               */
               if (isBuiltinType(finalBaseType.type)) {
                 /*
-                  use transformUtilsNew::toFinalBaseType for the moment,
+                  use transformUtils::toFinalBaseType for the moment,
                   as it is collects along the chain of types
                   attributes that need to be propagated
                   enum, length, scale, etc.
@@ -161,7 +161,7 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
               */
               if (isBuiltinType(finalBaseType.type)) {
                 /*
-                  use transformUtilsNew::toFinalBaseType for the moment,
+                  use transformUtils::toFinalBaseType for the moment,
                   as it is collects along the chain of types
                   attributes that need to be propagated
                   enum, length, scale, etc.

package/lib/transform/{transformUtilsNew.js → transformUtils.js}

@@ -265,7 +265,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
       } else {
         // Primitive child - clone it and restore its cross references
         let flatElemName = elemName + pathDelimiter + childName;
-        let flatElem = cloneCsnNonDict(childElem, options);
+        let flatElem = cloneCsnNonDict(childElem, { ...options, hiddenPropertiesToClone: [ '$structRef', '$fkExtensions' ] } );
         // Don't take over notNull from leaf elements
         delete flatElem.notNull;
         setProp(flatElem, '_flatElementNameWithDots', elementPath.concat(childName).join('.'));
@@ -420,17 +420,10 @@ function getTransformers(model, options, pathDelimiter = '_') {
     if (typeof type === 'string' && isBuiltinType(type))
       return;
 
-    let typeRef = null;
-    if (resolved.has(type)) {
-      typeRef = resolved.get(type)?.art
-      // The cached entry may not be resolved, yet.
-      if (typeRef.type && !isBuiltinType(typeRef.type))
-        typeRef = getFinalTypeInfo(typeRef.type);
-    } else {
-      typeRef = getFinalTypeInfo(type);
-    }
+    const typeRef = getFinalTypeInfo(type, (t) => resolved.get(t)?.art || csnUtils.artifactRef(t));
     if(!typeRef)
       return;
+
     if (typeRef.elements || typeRef.items) {
       // Copy elements/items and we're finished. No need to look up actual base type,
       // since it must also be structured and must contain at least as many elements,
@@ -543,7 +536,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
       addElement(draftUuid, artifact, artifactName);
 
       // CreationDateTime : Timestamp;
-      const creationDateTime = createScalarElement('CreationDateTime', hanaMode ? 'cds.UTCTimestamp' : 'cds.Timestamp');
+      const creationDateTime = createScalarElement('CreationDateTime', 'cds.Timestamp');
       creationDateTime.CreationDateTime['@Common.Label'] = '{i18n>Draft_CreationDateTime}';
       addElement(creationDateTime, artifact, artifactName);
 
@@ -560,7 +553,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
       addElement(draftIsCreatedByMe, artifact, artifactName);
 
       // LastChangeDateTime : Timestamp;
-      const lastChangeDateTime = createScalarElement('LastChangeDateTime', hanaMode ? 'cds.UTCTimestamp' : 'cds.Timestamp');
+      const lastChangeDateTime = createScalarElement('LastChangeDateTime', 'cds.Timestamp');
       lastChangeDateTime.LastChangeDateTime['@Common.Label'] = '{i18n>Draft_LastChangeDateTime}';
       addElement(lastChangeDateTime, artifact, artifactName);
 
@@ -909,7 +902,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
     if (annotation === undefined) {
       throw new CompilerAssertion('Annotation ' + fromName + ' not found in ' + JSON.stringify(node));
     }
-    if(node[toName] === undefined || node[toName] === null) {
+    if(node[toName] == null) {
       delete node[fromName];
       node[toName] = annotation;
     }
@@ -931,9 +924,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
     if (value === undefined) {
       throw new CompilerAssertion('Annotation value must not be undefined');
     }
-
-    if(node[name] === undefined || node[name] === null)
-      node[name] = value;
+    node[name] ??= value;
   }
 
   /**
@@ -1184,13 +1175,12 @@ function getTransformers(model, options, pathDelimiter = '_') {
               // do the paths match?
               if(op !== 'like' && !(x.lhs && x.rhs)) {
                 if(xn.length) {
-                  error(null, location,
-                    {
-                      prefix: prefix(lhs, op, rhs),
-                      name: xn,
-                      alias: (x.lhs ? rhs : lhs).ref.join('.')
-                    },
-                    '$(PREFIX): Sub path $(NAME) not found in $(ALIAS)');
+                  error('expr-invalid-expansion', location, {
+                    value: prefix(lhs, op, rhs),
+                    name: xn,
+                    alias: (x.lhs ? rhs : lhs).ref.join('.')
+                  },
+                    'Missing sub path $(NAME) in $(ALIAS) for tuple expansion of $(VALUE); both sides must expand to the same sub paths');
                 }
                 else {
                   error(null, location,
@@ -1352,93 +1342,6 @@ function getTransformers(model, options, pathDelimiter = '_') {
 
 }
 
-/**
- * Modify the given CSN/artifact in-place, applying the given customTransformations.
- * Dictionaries are correctly handled - a "type" transformer will not be called on an entity called "type".
- *
- * A custom transformation function has the following signature:
- * (any, object, string, CSN.Path) => undefined
- *
- * Given that we have a custom transformation for "type" and stumble upon a thing like below:
- *
- * {
- *    type: "cds.String",
- *    anotherProp: 1
- * }
- *
- * The input for the function would be:
- *
- * ("cds.String", { type: <>, anotherProp: <>}, "type", [xy, "type"])
- *
- * @param {CSN.Model} csn
- * @param {object} customTransformations Dictionary of functions to apply - if the property matches a key in this dict, it will be called
- * @param {boolean} [transformNonEnumerableElements=false] Transform non-enumerable elements to work with cds linked...
- * @returns {CSN.Model|CSN.Artifact} Return the CSN/artifact
- */
-function transformModel(csn, customTransformations, transformNonEnumerableElements=false){
-  const transformers = {
-    elements: dictionary,
-    definitions: dictionary,
-    actions: dictionary,
-    params: dictionary,
-    enum: dictionary,
-    mixin: dictionary,
-    args: dictionary
-  };
-
-  const csnPath = [];
-  if (csn.definitions)
-    dictionary( csn, 'definitions', csn.definitions );
-  else {
-    // fake it till you make it
-    const obj = { definitions: Object.create(null)};
-    obj.definitions.thing = csn;
-    dictionary(obj, 'definitions', obj.definitions);
-  }
-
-  return csn;
-
-  function standard( parent, prop, node ) {
-    // checking for .kind and .type is safe because annotations with such properties, are already flattened out
-    const isAnnotation = () => (typeof prop === 'string' && prop.startsWith('@') && !node.kind && !node.type);
-    if (!node || node._ignore || typeof node !== 'object' || !{}.propertyIsEnumerable.call( parent, prop ) || isAnnotation())
-      return;
-
-    csnPath.push( prop );
-
-    if (Array.isArray(node)) {
-      node.forEach( (n, i) => standard( node, i, n ) );
-    }
-    else {
-      const iterateOver = Object.getOwnPropertyNames( node );
-      // cds-linked resolves types and add's them to elements as non-enum - need to be processed
-      if(transformNonEnumerableElements && node.elements && !Object.prototype.propertyIsEnumerable.call(node, 'elements')){
-        iterateOver.push('elements');
-      }
-      for (const name of iterateOver) {
-        if(customTransformations[name])
-          customTransformations[name](node[name], node, name, csnPath.concat(name))
-
-        const trans = transformers[name] || standard;
-        trans( node, name, node[name] );
-      }
-    }
-    csnPath.pop();
-  }
-  function dictionary( node, prop, dict ) {
-    csnPath.push( prop );
-
-    if (Array.isArray(dict)) {
-      dict.forEach( (n, i) => standard(dict, i, n))
-    } else {
-      for (const name of Object.getOwnPropertyNames( dict ))
-        standard( dict, name, dict[name] );
-    }
-
-    csnPath.pop();
-  }
-}
-
 /**
  * Mandatory input transformation for all backends:
  * Replace
@@ -1465,7 +1368,6 @@ function rewriteBuiltinTypeRef(csn) {
 module.exports = {
   // This function retrieves the actual exports
   getTransformers,
-  transformModel,
   RelationalOperators,
   rewriteBuiltinTypeRef,
 };

package/lib/transform/translateAssocsToJoins.js

@@ -1124,9 +1124,14 @@ function translateAssocsToJoins(model, inputOptions = {})
     // get paths of managed assocs (unmanaged assocs are not allowed in FK paths)
     if(element.foreignKeys)
     {
-      for(let fkn in element.foreignKeys)
+      for(const fkn in element.foreignKeys)
       {
-        let fk = element.foreignKeys[fkn];
+        const fk = element.foreignKeys[fkn];
+        // ignore an unmanaged association
+        if(fk.targetElement._artifact.target &&
+           fk.targetElement._artifact.on &&
+           !fk.targetElement._artifact.foreignKeys)
+          continue;
         // once a fk is to be followed, treat all sub-paths as srcSide, this will add fk.name.id only
         if(srcSide)
           paths = paths.concat(flattenElement(fk.targetElement._artifact, true,  fk.name.id, fk.targetElement.path.map(ps => ps.id).join(pathDelimiter)));
@@ -1146,9 +1151,9 @@ function translateAssocsToJoins(model, inputOptions = {})
     // get paths of plain structured elements
     else if(element.elements)
     {
-      for(let n in element.elements)
+      for(const n in element.elements)
       {
-        let elt = element.elements[n];
+        const elt = element.elements[n];
         paths = paths.concat(flattenElement(elt, true, elt.name.id, elt.name.id));
       }
     }
@@ -1384,7 +1389,7 @@ function translateAssocsToJoins(model, inputOptions = {})
 
     All prefix trees are put underneath the $tableAlias structure with attribute $qat or $fqat.
     Each path step appears exactly once for a given filter condition in the prefix tree and
-    has a link to it's definition (origin). The default filter is an empty string ''.
+    has a link to its definition (origin). The default filter is an empty string ''.
 
     A special note on paths in filter conditions. Filter paths are treated like postfix
     paths to an association path step, meaning, they are inserted into the assoc's $qat or $fqat
@@ -1409,32 +1414,13 @@ function translateAssocsToJoins(model, inputOptions = {})
 
     let [head, ...tail] = path;
 
-    if(['$projection', '$self'].includes(head.id) && tail.length && head._navigation.kind === '$self') {
-      // make sure not to truncate tail
-      if(tail.length > 1)
-        [head, ...tail] = tail;
-      else
-        head = tail[0];
-      /*
-        if the head is a path (it better be;) then use it as
-        anchor for _navigation and just merge the tail into that QAT
-        example:
-        entity E { key id: Integer; toE: association to E; toF: association to F;}
-        entity F { key id: Integer; toE: association to E; }
-        view V as select from E { toE, $projection.toE.toF.id };
-      */
-      let value = env.lead.elements[head.id].value;
-      if(value.path) {
-        head = value.path[0];
-      }
-      else // value is another expression, don't consider it
-        return;
-    }
-
-
     // qatParent is the node where the starting qat is attached to
     let qatParent = undefined;
 
+    // Note: If head is $self, we would need to resolve it if the path follows associations.
+    //       However, that is already rejected by SQL backend checks. For example $self paths
+    //       can't be "$self.assoc.foo.bar".
+
     // FROM and filter paths do not have a _navigation, but for filter paths
     // the corresponding path step (to where the filter was attached to) is in env.pathStep
     if(!head._navigation)

package/lib/utils/file.js

@@ -101,22 +101,22 @@ function cdsFs( fileCache, enableTrace ) {
         if (body && body.stack && body.message) {
           // NOTE: checks for instanceof Error are not reliable if error
           //       created in different execution env
-          traceFS( 'READFILE:cache-error:', filename, body.message );
+          traceFS( 'READFILE:cache-err:', filename, body.message );
           cb( body );   // no need for process.nextTick( cb, body ) with moduleResolve
         }
         else {
-          traceFS( 'READFILE:cache:', filename, body );
+          traceFS( 'READFILE:cache:    ', filename, body );
           cb( null, body );
         }
       }
       else {
-        traceFS( 'READFILE:start:', filename );
+        traceFS( 'READFILE:start:    ', filename );
         // TODO: set cache directly to some "delay" - store error differently?
         // e.g. an error of callback functions!
         try {
           reader(filename, enc, (err, data) => {
             fileCache[filename] = err || data;
-            traceFS('READFILE:data:', filename, err || data);
+            traceFS('READFILE:data:     ', filename, err || data);
             cb(err, data);
           });
         }
@@ -137,14 +137,14 @@ function cdsFs( fileCache, enableTrace ) {
     return ( filename, cb ) => {
       let body = fileCache[filename];
       if (body !== undefined) {
-        traceFS( 'ISFILE:cache:', filename, body );
+        traceFS( 'ISFILE:cache:      ', filename, body );
         if (body instanceof Error)
           cb( body );   // no need for process.nextTick( cb, body ) with moduleResolve
         else // body could be empty string
           cb( null, !!body || typeof body === 'string');
       }
       else {
-        traceFS( 'ISFILE:start:', filename, body );
+        traceFS( 'ISFILE:start:      ', filename, body );
         // in the future (if we do module resolve ourselves with just readFile),
         // we avoid parallel readFile by storing having an array of `cb`s in
         // fileCache[ filename ] before starting fs.readFile().
@@ -156,7 +156,7 @@ function cdsFs( fileCache, enableTrace ) {
               body = !!(stat.isFile() || stat.isFIFO());
             if (fileCache[filename] === undefined) // parallel readFile() has been processed
               fileCache[filename] = body;
-            traceFS('ISFILE:data:', filename, body);
+            traceFS('ISFILE:data:       ', filename, body);
             if (body instanceof Error)
               cb(err);
             else