@sap/cds-compiler 4.9.6 → 5.1.0

package/lib/transform/effective/flattening.js

@@ -0,0 +1,135 @@
+'use strict';
+
+const {
+  forEachDefinition, forEachMemberRecursively, findAnnotationExpression, applyTransformationsOnNonDictionary, transformExpression,
+} = require('../../model/csnUtils');
+const { getStructStepsFlattener } = require('../db/flattening');
+const { setProp } = require('../../base/model');
+const { forEach } = require('../../utils/objectUtils');
+
+
+/**
+ *
+ * @param csn
+ * @param options
+ * @param csnUtils
+ * @param messageFunctions
+ */
+function flattenRefs( csn, options, csnUtils, messageFunctions ) {
+  const cleanup = [];
+  forEachDefinition(csn, (artifact) => {
+    if (artifact.elements) {
+      const stack = [ { prefix: [], elements: artifact.elements } ];
+      while (stack.length > 0) {
+        const { prefix, elements } = stack.pop();
+        forEach(elements, (elementName, element) => {
+          if (element.elements)
+            stack.push({ prefix: prefix.concat(elementName), elements: element.elements });
+
+          const absolutifier = absolutifyPaths(prefix, cleanup);
+          // Absolutify paths in on-conditions
+          if (element.on) {
+            transformExpression(element, 'on', {
+              ref: absolutifier,
+            }, []);
+          }
+
+          // Absolutify paths in annotation expressions
+          Object.keys(element)
+            .filter(pn => findAnnotationExpression(element, pn))
+            .forEach((anno) => {
+              applyTransformationsOnNonDictionary(element, anno, {
+                xpr: (parent, prop) => {
+                  transformExpression(parent, prop, {
+                    ref: absolutifier,
+                  }, []);
+                },
+              }, {}, []);
+              if (element[anno].ref)
+                absolutifier(element[anno], 'ref', element[anno].ref);
+            });
+        });
+      }
+    }
+  });
+
+
+  const adaptRefs = [];
+  const resolved = new WeakMap();
+  const refFlattener = getStructStepsFlattener(csn, options, messageFunctions, resolved, '_', adaptRefs);
+
+  forEachDefinition(csn, (def, defName) => {
+    if (def.kind === 'entity') {
+      applyTransformationsOnNonDictionary(csn.definitions, defName, refFlattener, { processAnnotations: true, skipDict: { actions: 1 } }, [ 'definitions' ]);
+
+      adaptRefs.forEach(fn => fn());
+      adaptRefs.length = 0;
+
+      // explicit binding parameter of bound action
+      if (def.actions) {
+        const special$self = !csn?.definitions?.$self && '$self';
+        Object.entries(def.actions).forEach(([ an, a ]) => {
+          if (a.params) {
+            const params = Object.entries(a.params);
+            const firstParam = params[0][1];
+            const type = firstParam?.items?.type || firstParam?.type;
+            if (type === special$self) {
+              const bindingParamName = params[0][0];
+              const markBindingParam = {
+                ref: (parent, prop, xpr) => {
+                  if ((xpr[0].id || xpr[0]) === bindingParamName)
+                    setProp(parent, '$bparam', true);
+                },
+              };
+
+              Object.keys(a)
+                .filter(pn => findAnnotationExpression(a, pn))
+                .forEach((pn) => {
+                  transformExpression(a, pn, [ markBindingParam, refFlattener ], [ 'definitions', defName, 'actions', an ]);
+                  adaptRefs.forEach(fn => fn(true, 1, parent => parent.$bparam));
+                  adaptRefs.length = 0;
+                });
+
+
+              forEachMemberRecursively(a, (member, memberName, prop, path) => {
+                Object.keys(member).filter(pn => findAnnotationExpression(member, pn)).forEach((pn) => {
+                  transformExpression(member, pn, [ markBindingParam, refFlattener ], path);
+                  adaptRefs.forEach(fn => fn(true, 1, parent => parent.$bparam));
+                  adaptRefs.length = 0;
+                });
+              }, [ 'definitions', defName, 'actions', an ]);
+            }
+          }
+        });
+      }
+    }
+    else {
+      applyTransformationsOnNonDictionary(csn.definitions, defName, refFlattener, { processAnnotations: false }, [ 'definitions' ]);
+      adaptRefs.forEach(fn => fn());
+      adaptRefs.length = 0;
+    }
+  });
+
+  cleanup.forEach((obj) => {
+    if (obj.ref && obj.ref[0] === '$self')
+      obj.ref.shift();
+  });
+}
+
+function absolutifyPaths(prefix, cleanup) {
+  return function absolutify(_parent, _prop, ref) {
+    if (ref[0].id || ref[0] !== '$self' && ref[0] !== '$projection' && !ref[0].startsWith('$') && !_parent.param) {
+      _parent.ref = [ '$self', ...prefix, ...ref ];
+      cleanup.push(_parent);
+
+      return true;
+    }
+
+    return false;
+  };
+}
+
+
+module.exports = {
+  flattenRefs,
+};

package/lib/transform/effective/main.js

@@ -4,6 +4,7 @@ const {
   getUtils, isAspect, mergeTransformers, applyTransformations,
 } = require('../../model/csnUtils');
 const transformUtils = require('../transformUtils');
+const effectiveFlattening = require('./flattening');
 const flattening = require('../db/flattening');
 const types = require('./types');
 // const { addLocalizationViews } = require('../../transform/localized');
@@ -65,8 +66,9 @@ function effectiveCsn( model, options, messageFunctions ) {
   // Remove properties attached by validator - they do not "grow" as the model grows.
   cleanup();
 
-  flattening.flattenAllStructStepsInRefs(csn, options, messageFunctions, new WeakMap(), '_');
-  flattening.flattenElements(csn, options, messageFunctions, '_');
+
+  effectiveFlattening.flattenRefs(csn, options, csnUtils, messageFunctions);
+  flattening.flattenElements(csn, options, messageFunctions, '_', { skipDict: { actions: true } });
 
   resolveTypesInActionsAfterFlattening();
 
@@ -76,8 +78,8 @@ function effectiveCsn( model, options, messageFunctions ) {
   processCalculatedElementsInEntities(csn);
   associations.managedToUnmanaged(csn, options, csnUtils, messageFunctions);
   associations.transformBacklinks(csn, options, csnUtils, messageFunctions);
-  const transformers = mergeTransformers([ misc.attachPersistenceName(csn, options, csnUtils), options.remapOdataAnnotations ? annotations.remapODataAnnotations(csn) : {}, misc.removeDefinitionsAndProperties(csn, options) ], null);
-  applyTransformations(csn, transformers, [], { skipIgnore: false });
+  const transformers = mergeTransformers([ options.addCdsPersistenceName ? misc.attachPersistenceName(csn, options, csnUtils) : {}, options.remapOdataAnnotations ? annotations.remapODataAnnotations(csn) : {}, misc.removeDefinitionsAndProperties(csn, options) ], null);
+  applyTransformations(csn, transformers, [], { skipIgnore: false, processAnnotations: true });
 
   if (!options.resolveProjections)
     redoProjections.forEach(fn => fn());

package/lib/transform/effective/types.js

@@ -18,18 +18,15 @@ const { cloneCsnDict, cloneCsnNonDict } = require('../../model/cloneCsn');
  * @param {CSN.Model} csn will be transformed
  * @param {object} csnUtils
  * @param {CSN.Options} options
- * @returns {Function} Callback to resolve things (actions and their returns) later - as for them, $self would lead to unresolvable constructs at this point
+ * @returns {Function} Callback to resolve types in action returns later - as for them, $self would lead to unresolvable constructs at this point
  * so we can call this callback after flattening is done - then we can safely resolve their types.
  */
 function resolveTypes( csn, csnUtils, options ) {
   const { getFinalTypeInfo } = csnUtils;
   const later = [];
   applyTransformations(csn, {
-    type: (parent, prop, type, path) => {
-      const artifact = csn.definitions[path[1]];
-      // TODO: What about events?
-      if (!(artifact.kind === 'action' || artifact.kind === 'function'))
-        resolveType(parent);
+    type: (parent) => {
+      resolveType(parent);
     },
   }, [ (definitions, artifactName, artifact) => {
     // In a non-flat model, replacing types with some $self inside causes issues for actions (bound or unbound)
@@ -38,12 +35,20 @@ function resolveTypes( csn, csnUtils, options ) {
       later.push({ [artifactName]: artifact });
     else if (artifact.actions)
       later.push(artifact.actions);
-  } ], { skipDict: { actions: true }, processAnnotations: true });
+  } ], { skipStandard: { returns: true }, processAnnotations: true });
 
+  // TODO: Directly push the .returns into the later so we have a more minimal looping
   return function resolveTypesInActions() {
-    later.forEach(action => applyTransformationsOnDictionary(action, { type: parent => resolveType(parent) }));
+    later.forEach((a) => {
+      applyTransformationsOnDictionary(a, {
+        type: (parent) => {
+          resolveType(parent);
+        },
+      });
+    });
   };
 
+
   /**
    * Resolve a type to its
    * - elements
@@ -123,7 +128,6 @@ function resolveTypes( csn, csnUtils, options ) {
   }
 }
 
-
 module.exports = {
   resolve: resolveTypes,
 };

package/lib/transform/forOdata.js

@@ -167,8 +167,6 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
     { skipArtifact: isExternalServiceMember }
   );
 
-  flattening.linkForeignKeyAnnotationExtensionsToAssociation(csn, options);
-
   // All type refs must be resolved, including external APIs.
   // OData has no 'type of' so 'real' imported OData APIs marked @cds.external are safe.
   // If in the future 'other' APIs that might support type refs are imported, these refs must be

package/lib/transform/forRelationalDB.js

@@ -34,6 +34,7 @@ const backlinks = require('./db/backlinks');
 const { getDefaultTypeLengths } = require('../render/utils/common');
 const { featureFlags } = require('./db/featureFlags');
 const { cloneCsnNonDict, cloneFullCsn } = require('../model/cloneCsn');
+const { processSqlServices } = require('./db/processSqlServices');
 
 // By default: Do not process non-entities/views
 function forEachDefinition(csn, cb) {
@@ -169,8 +170,6 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   // Needs to happen before tuple expansion, so the newly generated WHERE-conditions have it applied
   handleExists(csn, options, error, csnUtils.inspectRef, csnUtils.initDefinition, csnUtils.dropDefinitionCache);
 
-  doA2J && flattening.linkForeignKeyAnnotationExtensionsToAssociation(csn, options);
-
   // Check if structured elements and managed associations are compared in an expression
   // and expand these structured elements. This tuple expansion allows all other
   // subsequent procession steps (especially a2j) to see plain paths in expressions.
@@ -370,6 +369,8 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     removeKeyPropInType,
   ]);
 
+  // TODO: Might have to do this earlier if we want special rendering for projections?
+  const findAndMarkSqlServiceArtifacts = options.sqlDialect === 'hana' && options.src === 'hdi' && csn.meta?.[featureFlags]?.$sqlService ? processSqlServices(csn): () => {}
 
   // TODO: Could we maybe merge this with the final applyTransformations?
   applyTransformations(csn, {
@@ -389,6 +390,8 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     // Attach @cds.persistence.name to artifacts
     if (!artifact.$ignore && artifact.kind !== 'service' && artifact.kind !== 'context')
       csnUtils.addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(artifactName, options.sqlMapping, csn, options.sqlDialect), artifact);
+
+    findAndMarkSqlServiceArtifacts(artifact, artifactName);
   }], { allowArtifact: artifact => artifact.kind === 'entity'});
 
   throwWithAnyError();
@@ -702,23 +705,10 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
         newCsn.definitions[artName].technicalConfig = art.technicalConfig;
 
     });
-    // restore $fkExtensions and $structRef for foreign key annotations
-    if (isBetaEnabled(options, 'annotateForeignKeys')) {
-      forEachDefinition(csn, (oldDef, artName) => {
-        const newDef = newCsn.definitions[artName];
-        if(oldDef?.elements) {
-          Object.entries(oldDef.elements).forEach(([eltName, oldElt]) => {
-            const newElt = newDef.elements[eltName];
-            if(oldElt.$fkExtensions)
-              setProp(newElt, '$fkExtensions', oldElt.$fkExtensions);
-            oldElt.keys?.forEach((fk, i) => {
-              if(fk.$structRef && newElt.keys?.[i])
-                setProp(newElt.keys[i], '$structRef', fk.$structRef);
-            })
-          })
-        }
-      });
-    }
+
+    // To ensure we preserve feature flags
+    newCsn.meta = csn.meta;
+
     csn = newCsn;
   }
 

package/lib/transform/localized.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { makeMessageFunction } = require('../base/messages');
-const { setProp, isDeprecatedEnabled, isBetaEnabled} = require('../base/model');
+const { setProp } = require('../base/model');
 const { forEachKey } = require('../utils/objectUtils');
 const { cleanSymbols } = require('../base/cleanSymbols.js');
 const {
@@ -91,6 +91,7 @@ const annoPersistenceSkip = '@cds.persistence.skip';
  *     Deprecated version of localizedLanguageFallback. Do not use.
  *
  * @param {boolean} [options.fewerLocalizedViews]
+ *     Default: true
  *
  * @param {object} config
  *     Configuration for creating convenience views.  Non-user visible options.
@@ -114,7 +115,8 @@ function _addLocalizationViews(csn, options, config) {
   const { useJoins, acceptLocalizedView, ignoreUnknownExtensions } = config;
   const noCoalesce = (options.localizedLanguageFallback === 'none' ||
                       options.localizedWithoutCoalesce);
-  const ignoreAssocToLocalized = !!options.fewerLocalizedViews;
+  // default is true, hence only check for explicitly disabled option
+  const ignoreAssocToLocalized = options.fewerLocalizedViews !== false;
 
   createDirectConvenienceViews();     // 1
   createTransitiveConvenienceViews(); // 2 + 3
@@ -176,7 +178,7 @@ function _addLocalizationViews(csn, options, config) {
     else
       view = createLocalizedViewForEntity(art, artName, textElements);
 
-    copyPersistenceAnnotations(view, art, options);
+    copyPersistenceAnnotations(view, art);
     csn.definitions[viewName] = view;
   }
 
@@ -752,18 +754,15 @@ function copyLocation(target, source) {
  *
  * @param {CSN.Artifact} target
  * @param {CSN.Artifact} source
- * @param {CSN.Options} options
  */
-function copyPersistenceAnnotations(target, source, options) {
-  const copyExists = !isBetaEnabled(options, 'v5preview') &&
-    !isDeprecatedEnabled( options, 'eagerPersistenceForGeneratedEntities' );
+function copyPersistenceAnnotations(target, source) {
   forEachKey(source, anno => {
     // Note:
     //   v3/v4: Because `.exists` is copied to the convenience view, it could
     //   lead to some localization views referencing non-existing ones.
     //   But that is the contract: User says that it already exists!
     //   v2/>=v5, `.exists` is never copied.
-    if (anno === annoPersistenceSkip || (copyExists && anno === '@cds.persistence.exists'))
+    if (anno === annoPersistenceSkip)
       target[anno] = source[anno];
   });
 }

package/lib/transform/odata/flattening.js

@@ -8,8 +8,7 @@ const transformUtils = require('../transformUtils');
 const { setProp } = require('../../base/model');
 const { applyTransformationsOnDictionary,
   applyTransformationsOnNonDictionary } = require('../db/applyTransformations.js');
-const { linkForeignKeyAnnotationExtensionsToAssociation,
-  handleManagedAssociationsAndCreateForeignKeys } = require('../db/flattening');
+const { handleManagedAssociationsAndCreateForeignKeys } = require('../db/flattening');
 const { cloneCsnNonDict } = require('../../model/cloneCsn');
 const { forEach } = require('../../utils/objectUtils');
 
@@ -293,17 +292,27 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
 
     const refCheck = {
       ref: (elemref, prop, xpr, path) => {
-        const { art, scope } = inspectRef(path);
+        const { links, art, scope } = inspectRef(path);
         if (scope !== '$magic' && art) {
-          const ft = csnUtils.getFinalTypeInfo(art.type);
-          if (!isBuiltinType(ft?.type) && refCheck.anno !== 'value') {
-            error('odata-anno-xpr-ref', path,
-              {
-                anno: refCheck.anno,
-                elemref,
-                name: refCheck.eltLocationStr,
-                '#': 'flatten_builtin'
-              });
+          // try to find rightmost 'items', terminate if association comes first.
+          let i = links.length-1;
+          const getProp = (propName) => links[i].art?.[propName];
+  
+          let hasItems = false;
+          for(; i >= 0 && !getProp('target') && !hasItems; i--) {
+            hasItems = !!getProp('items')
+          }
+          if(!hasItems) {
+            const ft = csnUtils.getFinalTypeInfo(art.type);
+            if (!isBuiltinType(ft?.items?.type || ft?.type) && refCheck.anno !== 'value') {
+              error('odata-anno-xpr-ref', path,
+                {
+                  anno: refCheck.anno,
+                  elemref,
+                  name: refCheck.eltLocationStr,
+                  '#': 'flatten_builtin'
+                });
+            }  
           }
         }
       }
@@ -421,24 +430,24 @@ function flattenAllStructStepsInRefs( csn, refFlattener, adaptRefs, inspectRef,
 
   const refCheck = {
     ref: (elemref, prop, xpr, path) => {
-      const { links, art } = (elemref._links && elemref._art
-        ? { links: elemref._links, art: elemref._art }
-        : inspectRef(path) );
-
-      let i = links.length-2;
-      const getProp = (propName) =>
-        (links[i].art?.[propName] ||
-        effectiveType(links[i].art)[propName]);
-
-      const ft = csnUtils.getFinalTypeInfo(art?.type);
-      let target = undefined;
-      for(; i >= 0 && !getProp('items') && !target; i--) {
-        target = getProp('target');
-      }
-      if (target && csn.definitions[target].$flatelements
-          && !isBuiltinType(ft?.type) && refCheck.anno !== 'value') {
-        error('odata-anno-xpr-ref', path,
-        { anno: refCheck.anno, elemref, '#': 'flatten_builtin_type' });
+      const { links, art, scope } = inspectRef(path);
+
+      if (scope !== '$magic' && art) {
+        let i = links.length-2;
+        const getProp = (propName) =>
+          (links[i].art?.[propName] ||
+          effectiveType(links[i].art)[propName]);
+
+        let target = undefined;
+        for(; i >= 0 && !getProp('items') && !target; i--) {
+          target = getProp('target');
+        }
+        const ft = csnUtils.getFinalTypeInfo(art.type);
+        if (target && csn.definitions[target].$flatelements
+            && !isBuiltinType(ft?.type) && refCheck.anno !== 'value') {
+          error('odata-anno-xpr-ref', path,
+          { anno: refCheck.anno, elemref, '#': 'flatten_builtin_type' });
+        }
       }
     }
   }
@@ -548,7 +557,6 @@ function getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, optio
 module.exports = {
   allInOneFlattening,
   flattenAllStructStepsInRefs,
-  linkForeignKeyAnnotationExtensionsToAssociation,
   handleManagedAssociationsAndCreateForeignKeys,
   getStructRefFlatteningTransformer
 };

package/lib/transform/odata/typesExposure.js

@@ -8,7 +8,7 @@
 
 const { setProp, isBetaEnabled } = require('../../base/model');
 const { defNameWithoutServiceOrContextName, isArtifactInService } = require('./utils');
-const { getNamespace, copyAnnotations, findAnnotationExpression,
+const { getNamespace, copyAnnotations,
   forEachDefinition, forEachMember, forEachGeneric, isEdmPropertyRendered } = require('../../model/csnUtils');
 const { isBuiltinType } = require('../../base/builtins');
 const { CompilerAssertion } = require('../../base/error');
@@ -229,22 +229,10 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
             }
           });
 
-          // TODO: remove the this if and the else clause for the V5 release
-          if (isBetaEnabled(options, 'v5preview')) {
-            // We need this check, as we only need to copy the annotions if the type
-            // is user defined structured type outside of the service
-            if (!isAnonymous) {
-              copyAnnotations(typeDef, newType);
-            }
-          } else {
-            // expression annos and their sub annotations are not propagated to type
-            let [ xprANames, nxprANames ] = Object.keys(typeDef).reduce((acc, pn) => {
-              if (pn[0] === '@')
-                acc[findAnnotationExpression(typeDef, pn) ? 0 : 1].push(pn);
-              return acc;
-            }, [ [], [] ]);
-            nxprANames = nxprANames.filter(an => !xprANames.some(ean => an.startsWith(`${ean}.`)));
-            copyAnnotations(typeDef, newType, false, {}, nxprANames);
+          // Annotations are propagated only from user defined structured
+          // types that need to be added to a service
+          if (!isAnonymous) {
+            copyAnnotations(typeDef, newType);
           }
 
           // if the origin type had items, add items to exposed type

package/lib/transform/transformUtils.js

@@ -266,7 +266,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
       } else {
         // Primitive child - clone it and restore its cross references
         const flatElemName = elemName + pathDelimiter + childName;
-        const flatElem = cloneCsnNonDict(childElem, { ...options, hiddenPropertiesToClone: [ '$structRef', '$fkExtensions' ] } );
+        const flatElem = cloneCsnNonDict(childElem, options);
         // Don't take over notNull from leaf elements
         delete flatElem.notNull;
         setProp(flatElem, '_flatElementNameWithDots', elementPath.concat(childName).join('.'));

package/lib/transform/translateAssocsToJoins.js

@@ -1710,7 +1710,6 @@ function translateAssocsToJoins(model, inputOptions = {})
     const path = pathDict.path;
     const s = pathAsStr(path, '"');
     const me = env.lead && (env.lead.name.id || env.lead.op);
-    // eslint-disable-next-line no-console
     console.log(me + ': ' + env.location + ': ' + s + ' alias: ' + alias);
   }
 

package/lib/utils/file.js

@@ -4,6 +4,8 @@
 
 const fs = require('fs');
 const util = require('util');
+const path = require('path');
+const os = require('os');
 
 /**
  * Split the given source string into its lines.  Respects Unix,
@@ -16,6 +18,74 @@ function splitLines( src ) {
   return src.split(/\r\n?|\n/);
 }
 
+/**
+ * Returns the file's normalized extension, e.g. for `file.CDS` -> `cds`
+ * Returns null if the given filename is not a string.
+ *
+ * @param filename
+ * @returns {null|string}
+ */
+function fileExtension( filename ) {
+  if (typeof filename === 'string')
+    return path.extname( filename ).slice(1).toLowerCase();
+  return null;
+}
+
+/**
+ * Create a temporary file path using the system's temporary folder and a filename
+ * consisting of the given name/extension and a random string.
+ *
+ * @param {string} name
+ * @param {string} extension
+ * @returns {string}
+ */
+function tmpFilePath( name, extension ) {
+  const crypto = require('crypto');
+  const id = crypto.randomBytes(32).toString('hex');
+  const filename = `${ name }-${ id }.${ extension }`;
+  return path.join(os.tmpdir(), filename);
+}
+
+/**
+ * Read input from the given stream.
+ * See https://nodejs.org/api/stream.html#readablereadsize
+ *
+ * @returns {Promise<string>}
+ */
+function readStream( stream ) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+
+    const listeners = {
+      __proto__: null,
+      data: onData,
+      error: onError,
+      end: onEnd,
+    };
+    for (const name in listeners)
+      stream.on(name, listeners[name]);
+
+    function onData( chunk ) {
+      chunks.push(chunk);
+    }
+
+    function onEnd() {
+      removeListeners();
+      resolve(chunks.join(''));
+    }
+
+    function onError( error ) {
+      removeListeners();
+      reject(error);
+    }
+
+    function removeListeners() {
+      for (const name in listeners)
+        stream.removeListener(name, listeners[name]);
+    }
+  });
+}
+
 /**
  * Returns filesystem utils readFile(), isFile(), realpath() for _CDS_ usage.
  * This includes a trace as well as usage of a file cache.
@@ -49,24 +119,30 @@ function cdsFs( fileCache, enableTrace ) {
 
   return {
     /** @type {function(string, string)} */
-    readFileAsync: util.promisify(readFile),
+    readFileAsync: util.promisify( readFile ),
     readFile,
     readFileSync,
-    isFileAsync: util.promisify(isFile),
     isFile,
     isFileSync,
-    realpathAsync: util.promisify(realpath),
-    realpath,
+    realpath: fs.realpath,
+    realpathNative: fs.realpath.native,
     realpathSync,
+    realpathSyncNative,
   };
 
-  function realpath( path, cb ) {
-    return fs.realpath.native(path, cb);
+
+  function realpathSync( filepath, cb ) {
+    try {
+      cb(null, fs.realpathSync(filepath));
+    }
+    catch (err) {
+      cb(err, null);
+    }
   }
 
-  function realpathSync( path, cb ) {
+  function realpathSyncNative( filepath, cb ) {
     try {
-      cb(null, fs.realpathSync.native(path));
+      cb(null, fs.realpathSync.native(filepath));
     }
     catch (err) {
       cb(err, null);
@@ -188,5 +264,8 @@ function cdsFs( fileCache, enableTrace ) {
 
 module.exports = {
   splitLines,
+  readStream,
+  fileExtension,
+  tmpFilePath,
   cdsFs,
 };