@jsenv/core 23.1.4 → 23.3.0

package/src/internal/compiling/startCompileServer.js

@@ -1,17 +1,14 @@
-/* eslint-disable import/max-dependencies */
 import { readFileSync } from "node:fs"
-import {
-  createCancellationToken,
-  createCancellationSource,
-  composeCancellationToken,
-} from "@jsenv/cancellation"
 import {
   jsenvAccessControlAllowedHeaders,
   startServer,
-  serveFile,
+  fetchFileSystem,
   createSSERoom,
   composeServicesWithTiming,
   urlToContentType,
+  pluginServerTiming,
+  pluginRequestWaitingCheck,
+  pluginCORS,
 } from "@jsenv/server"
 import { createLogger, createDetailedMessage } from "@jsenv/logger"
 import {
@@ -22,17 +19,19 @@ import {
   readFile,
   writeFile,
   ensureEmptyDirectory,
-  registerFileLifecycle,
   registerDirectoryLifecycle,
   urlIsInsideOf,
   urlToBasename,
 } from "@jsenv/filesystem"
+import {
+  createCallbackList,
+  createCallbackListNotifiedOnce,
+} from "@jsenv/abort"
 
 import { isBrowserPartOfSupportedRuntimes } from "@jsenv/core/src/internal/generateGroupMap/runtime_support.js"
 import { loadBabelPluginMapFromFile } from "./load_babel_plugin_map_from_file.js"
 import { extractSyntaxBabelPluginMap } from "./babel_plugins.js"
 import { generateGroupMap } from "../generateGroupMap/generateGroupMap.js"
-import { createCallbackList } from "../createCallbackList.js"
 import {
   jsenvCompileProxyFileInfo,
   sourcemapMainFileInfo,
@@ -48,7 +47,8 @@ import { urlIsCompilationAsset } from "./compile-directory/compile-asset.js"
 import { createTransformHtmlSourceFileService } from "./html_source_file_service.js"
 
 export const startCompileServer = async ({
-  cancellationToken = createCancellationToken(),
+  signal = new AbortController().signal,
+  handleSIGINT,
   compileServerLogLevel,
 
   projectDirectoryUrl,
@@ -89,7 +89,7 @@ export const startCompileServer = async ({
   compileServerIp = "0.0.0.0",
   compileServerPort = 0,
   keepProcessAlive = false,
-  stopOnPackageVersionChange = false,
+  onStop = () => {},
 
   // remaining options
   runtimeSupport,
@@ -218,15 +218,12 @@ export const startCompileServer = async ({
     ...babelPluginMap,
   }
 
-  const serverStopCancellationSource = createCancellationSource()
+  const serverStopCallbackList = createCallbackListNotifiedOnce()
 
   let projectFileRequestedCallback = () => {}
   if (livereloadSSE) {
     const sseSetup = setupServerSentEventsForLivereload({
-      cancellationToken: composeCancellationToken(
-        cancellationToken,
-        serverStopCancellationSource.token,
-      ),
+      serverStopCallbackList,
       projectDirectoryUrl,
       jsenvDirectoryRelativeUrl,
       outDirectoryRelativeUrl,
@@ -236,7 +233,7 @@ export const startCompileServer = async ({
 
     projectFileRequestedCallback = sseSetup.projectFileRequestedCallback
     const serveSSEForLivereload = createSSEForLivereloadService({
-      cancellationToken,
+      serverStopCallbackList,
       outDirectoryRelativeUrl,
       trackMainAndDependencies: sseSetup.trackMainAndDependencies,
     })
@@ -302,7 +299,6 @@ export const startCompileServer = async ({
       projectDirectoryUrl,
     }),
     "service:compiled file": createCompiledFileService({
-      cancellationToken,
       logger,
 
       projectDirectoryUrl,
@@ -351,7 +347,13 @@ export const startCompileServer = async ({
   }
 
   const compileServer = await startServer({
-    cancellationToken,
+    signal,
+    stopOnExit: false,
+    stopOnSIGINT: handleSIGINT,
+    stopOnInternalError: false,
+    sendServerInternalErrorDetails: true,
+    keepProcessAlive,
+
     logLevel: compileServerLogLevel,
 
     protocol: compileServerProtocol,
@@ -360,44 +362,32 @@ export const startCompileServer = async ({
     serverCertificatePrivateKey: compileServerPrivateKey,
     ip: compileServerIp,
     port: compileServerPort,
-    sendServerTiming: true,
-    // nagle: false,
-    requestWaitingMs: 60 * 1000,
-    sendServerInternalErrorDetails: true,
+    plugins: {
+      ...pluginCORS({
+        accessControlAllowRequestOrigin: true,
+        accessControlAllowRequestMethod: true,
+        accessControlAllowRequestHeaders: true,
+        accessControlAllowedRequestHeaders: [
+          ...jsenvAccessControlAllowedHeaders,
+          "x-jsenv-execution-id",
+        ],
+        accessControlAllowCredentials: true,
+      }),
+      ...pluginServerTiming,
+      ...pluginRequestWaitingCheck({
+        requestWaitingMs: 60 * 1000,
+      }),
+    },
     requestToResponse: composeServicesWithTiming({
       ...customServices,
       ...jsenvServices,
     }),
-    accessControlAllowRequestOrigin: true,
-    accessControlAllowRequestMethod: true,
-    accessControlAllowRequestHeaders: true,
-    accessControlAllowedRequestHeaders: [
-      ...jsenvAccessControlAllowedHeaders,
-      "x-jsenv-execution-id",
-    ],
-    accessControlAllowCredentials: true,
-    keepProcessAlive,
+    onStop: (reason) => {
+      onStop()
+      serverStopCallbackList.notify(reason)
+    },
   })
 
-  compileServer.stoppedPromise.then(serverStopCancellationSource.cancel)
-
-  if (stopOnPackageVersionChange) {
-    const stopListeningJsenvPackageVersionChange =
-      listenJsenvPackageVersionChange({
-        projectDirectoryUrl,
-        jsenvDirectoryRelativeUrl,
-        onJsenvPackageVersionChange: () => {
-          compileServer.stop(STOP_REASON_PACKAGE_VERSION_CHANGED)
-        },
-      })
-    compileServer.stoppedPromise.then(
-      () => {
-        stopListeningJsenvPackageVersionChange()
-      },
-      () => {},
-    )
-  }
-
   return {
     jsenvDirectoryRelativeUrl,
     outDirectoryRelativeUrl,
@@ -571,7 +561,7 @@ const compareValueJson = (left, right) => {
  *
  */
 const setupServerSentEventsForLivereload = ({
-  cancellationToken,
+  serverStopCallbackList,
   projectDirectoryUrl,
   jsenvDirectoryRelativeUrl,
   outDirectoryRelativeUrl,
@@ -594,7 +584,7 @@ const setupServerSentEventsForLivereload = ({
       return
     }
 
-    projectFileRequested.notify(relativeUrl, request)
+    projectFileRequested.notify({ relativeUrl, request })
   }
   const watchDescription = {
     ...livereloadWatchConfig,
@@ -617,7 +607,7 @@ const setupServerSentEventsForLivereload = ({
       recursive: true,
     },
   )
-  cancellationToken.register(unregisterDirectoryLifecyle)
+  serverStopCallbackList.add(unregisterDirectoryLifecyle)
 
   const getDependencySet = (mainRelativeUrl) => {
     if (trackerMap.has(mainRelativeUrl)) {
@@ -630,7 +620,7 @@ const setupServerSentEventsForLivereload = ({
   }
 
   // each time a file is requested for the first time its dependencySet is computed
-  projectFileRequested.register((mainRelativeUrl) => {
+  projectFileRequested.add(({ relativeUrl: mainRelativeUrl }) => {
     // for now no use case of livereloading on node.js
     // and for browsers only html file can be main files
     // this avoid collecting dependencies of non html files that will never be used
@@ -644,8 +634,8 @@ const setupServerSentEventsForLivereload = ({
     dependencySet.add(mainRelativeUrl)
     trackerMap.set(mainRelativeUrl, dependencySet)
 
-    const unregisterDependencyRequested = projectFileRequested.register(
-      (relativeUrl, request) => {
+    const removeDependencyRequestedCallback = projectFileRequested.add(
+      ({ relativeUrl, request }) => {
         if (dependencySet.has(relativeUrl)) {
           return
         }
@@ -668,10 +658,10 @@ const setupServerSentEventsForLivereload = ({
         dependencySet.add(relativeUrl)
       },
     )
-    const unregisterMainRemoved = projectFileRemoved.register((relativeUrl) => {
+    const removeMainRemovedCallback = projectFileRemoved.add((relativeUrl) => {
       if (relativeUrl === mainRelativeUrl) {
-        unregisterDependencyRequested()
-        unregisterMainRemoved()
+        removeDependencyRequestedCallback()
+        removeMainRemovedCallback()
         trackerMap.delete(mainRelativeUrl)
       }
     })
@@ -683,19 +673,19 @@ const setupServerSentEventsForLivereload = ({
   ) => {
     livereloadLogger.debug(`track ${mainRelativeUrl} and its dependencies`)
 
-    const unregisterModified = projectFileModified.register((relativeUrl) => {
+    const removeModifiedCallback = projectFileModified.add((relativeUrl) => {
       const dependencySet = getDependencySet(mainRelativeUrl)
       if (dependencySet.has(relativeUrl)) {
         modified(relativeUrl)
       }
     })
-    const unregisterRemoved = projectFileRemoved.register((relativeUrl) => {
+    const removeRemovedCallback = projectFileRemoved.add((relativeUrl) => {
       const dependencySet = getDependencySet(mainRelativeUrl)
       if (dependencySet.has(relativeUrl)) {
         removed(relativeUrl)
       }
     })
-    const unregisterAdded = projectFileAdded.register((relativeUrl) => {
+    const removeAddedCallback = projectFileAdded.add((relativeUrl) => {
       const dependencySet = getDependencySet(mainRelativeUrl)
       if (dependencySet.has(relativeUrl)) {
         added(relativeUrl)
@@ -706,9 +696,9 @@ const setupServerSentEventsForLivereload = ({
       livereloadLogger.debug(
         `stop tracking ${mainRelativeUrl} and its dependencies.`,
       )
-      unregisterModified()
-      unregisterRemoved()
-      unregisterAdded()
+      removeModifiedCallback()
+      removeRemovedCallback()
+      removeAddedCallback()
     }
   }
 
@@ -773,11 +763,14 @@ const setupServerSentEventsForLivereload = ({
     }
   }
 
-  return { projectFileRequestedCallback, trackMainAndDependencies }
+  return {
+    projectFileRequestedCallback,
+    trackMainAndDependencies,
+  }
 }
 
 const createSSEForLivereloadService = ({
-  cancellationToken,
+  serverStopCallbackList,
   outDirectoryRelativeUrl,
   trackMainAndDependencies,
 }) => {
@@ -811,9 +804,8 @@ const createSSEForLivereloadService = ({
       },
     })
 
-    const cancelRegistration = cancellationToken.register(() => {
-      cancelRegistration.unregister()
-
+    const removeSSECleanupCallback = serverStopCallbackList.add(() => {
+      removeSSECleanupCallback()
       sseRoom.close()
       stopTracking()
     })
@@ -821,7 +813,7 @@ const createSSEForLivereloadService = ({
       mainFileRelativeUrl,
       sseRoom,
       cleanup: () => {
-        cancelRegistration.unregister()
+        removeSSECleanupCallback()
         sseRoom.close()
         stopTracking()
       },
@@ -865,10 +857,13 @@ const createCompilationAssetFileService = ({ projectDirectoryUrl }) => {
     const { origin, ressource } = request
     const requestUrl = `${origin}${ressource}`
     if (urlIsCompilationAsset(requestUrl)) {
-      return serveFile(request, {
-        rootDirectoryUrl: projectDirectoryUrl,
-        etagEnabled: true,
-      })
+      return fetchFileSystem(
+        new URL(request.ressource.slice(1), projectDirectoryUrl),
+        {
+          headers: request.headers,
+          etagEnabled: true,
+        },
+      )
     }
     return null
   }
@@ -924,10 +919,13 @@ const createSourceFileService = ({
     const relativeUrl = ressource.slice(1)
     projectFileRequestedCallback(relativeUrl, request)
 
-    const responsePromise = serveFile(request, {
-      rootDirectoryUrl: projectDirectoryUrl,
-      etagEnabled: projectFileEtagEnabled,
-    })
+    const responsePromise = fetchFileSystem(
+      new URL(request.ressource.slice(1), projectDirectoryUrl),
+      {
+        headers: request.headers,
+        etagEnabled: projectFileEtagEnabled,
+      },
+    )
 
     return responsePromise
   }
@@ -1059,10 +1057,13 @@ const createOutFilesService = async ({
       if (!isOutRootFile(requestUrl)) {
         return null
       }
-      return serveFile(request, {
-        rootDirectoryUrl: projectDirectoryUrl,
-        etagEnabled: true,
-      })
+      return fetchFileSystem(
+        new URL(request.ressource.slice(1), projectDirectoryUrl),
+        {
+          headers: request.headers,
+          etagEnabled: true,
+        },
+      )
     }
   }
   // serve from memory
@@ -1118,51 +1119,6 @@ const createCompileProxyService = ({ projectDirectoryUrl }) => {
   }
 }
 
-const listenJsenvPackageVersionChange = ({
-  projectDirectoryUrl,
-  jsenvDirectoryRelativeUrl,
-  onJsenvPackageVersionChange = () => {},
-}) => {
-  const jsenvCoreDirectoryUrl = resolveUrl(
-    jsenvDirectoryRelativeUrl,
-    projectDirectoryUrl,
-  )
-  const packageFileUrl = resolveUrl("./package.json", jsenvCoreDirectoryUrl)
-  const packageFilePath = urlToFileSystemPath(packageFileUrl)
-  let packageVersion
-
-  try {
-    packageVersion = readPackage(packageFilePath).version
-  } catch (e) {
-    if (e.code === "ENOENT") return () => {}
-  }
-
-  const checkPackageVersion = () => {
-    let packageObject
-    try {
-      packageObject = readPackage(packageFilePath)
-    } catch (e) {
-      // package json deleted ? not a problem
-      // let's wait for it to show back
-      if (e.code === "ENOENT") return
-      // package.json malformed ? not a problem
-      // let's wait for use to fix it or filesystem to finish writing the file
-      if (e.name === "SyntaxError") return
-      throw e
-    }
-
-    if (packageVersion !== packageObject.version) {
-      onJsenvPackageVersionChange()
-    }
-  }
-
-  return registerFileLifecycle(packageFilePath, {
-    added: checkPackageVersion,
-    updated: checkPackageVersion,
-    keepProcessAlive: false,
-  })
-}
-
 const readPackage = (packagePath) => {
   const buffer = readFileSync(packagePath)
   const string = String(buffer)
@@ -1170,10 +1126,6 @@ const readPackage = (packagePath) => {
   return packageObject
 }
 
-export const STOP_REASON_PACKAGE_VERSION_CHANGED = {
-  toString: () => `package version changed`,
-}
-
 const __filenameReplacement = `import.meta.url.slice('file:///'.length)`
 
 const __dirnameReplacement = `import.meta.url.slice('file:///'.length).replace(/[\\\/\\\\][^\\\/\\\\]*$/, '')`

package/src/internal/executing/coverage/generateCoverageJsonFile.js

@@ -1,5 +1,22 @@
-import { writeFile } from "@jsenv/filesystem"
+import { writeFile, urlToFileSystemPath } from "@jsenv/filesystem"
 
-export const generateCoverageJsonFile = async (coverage, coverageJsonFileUrl) => {
-  await writeFile(coverageJsonFileUrl, JSON.stringify(coverage, null, "  "))
+import { byteAsFileSize } from "@jsenv/core/src/internal/logs/byteAsFileSize.js"
+
+export const generateCoverageJsonFile = async ({
+  coverage,
+  coverageJsonFileUrl,
+  coverageJsonFileLog,
+  logger,
+}) => {
+  const coverageAsText = JSON.stringify(coverage, null, "  ")
+
+  if (coverageJsonFileLog) {
+    logger.info(
+      `-> ${urlToFileSystemPath(coverageJsonFileUrl)} (${byteAsFileSize(
+        Buffer.byteLength(coverageAsText),
+      )})`,
+    )
+  }
+
+  await writeFile(coverageJsonFileUrl, coverageAsText)
 }

package/src/internal/executing/coverage/relativeUrlToEmptyCoverage.js

@@ -1,52 +1,40 @@
-import { createOperation } from "@jsenv/cancellation"
 import { resolveUrl, urlToFileSystemPath, readFile } from "@jsenv/filesystem"
 
 import {
   babelPluginsFromBabelPluginMap,
   getMinimalBabelPluginMap,
 } from "@jsenv/core/src/internal/compiling/babel_plugins.js"
-
 import { babelPluginInstrument } from "./babel_plugin_instrument.js"
 import { createEmptyCoverage } from "./createEmptyCoverage.js"
 
 export const relativeUrlToEmptyCoverage = async (
   relativeUrl,
-  { cancellationToken, projectDirectoryUrl, babelPluginMap },
+  { multipleExecutionsOperation, projectDirectoryUrl, babelPluginMap },
 ) => {
   const { transformAsync } = await import("@babel/core")
 
   const fileUrl = resolveUrl(relativeUrl, projectDirectoryUrl)
-  const source = await createOperation({
-    cancellationToken,
-    start: () => readFile(fileUrl),
-  })
+  multipleExecutionsOperation.throwIfAborted()
+  const source = await readFile(fileUrl)
 
   try {
-    const { metadata } = await createOperation({
-      cancellationToken,
-      start: async () => {
-        babelPluginMap = {
-          ...getMinimalBabelPluginMap(),
-          ...babelPluginMap,
-          "transform-instrument": [
-            babelPluginInstrument,
-            { projectDirectoryUrl },
-          ],
-        }
+    babelPluginMap = {
+      ...getMinimalBabelPluginMap(),
+      ...babelPluginMap,
+      "transform-instrument": [babelPluginInstrument, { projectDirectoryUrl }],
+    }
 
-        const { metadata } = await transformAsync(source, {
-          filename: urlToFileSystemPath(fileUrl),
-          filenameRelative: relativeUrl,
-          configFile: false,
-          babelrc: false,
-          ast: true,
-          parserOpts: {
-            allowAwaitOutsideFunction: true,
-          },
-          plugins: babelPluginsFromBabelPluginMap(babelPluginMap),
-        })
-        return { metadata }
+    multipleExecutionsOperation.throwIfAborted()
+    const { metadata } = await transformAsync(source, {
+      filename: urlToFileSystemPath(fileUrl),
+      filenameRelative: relativeUrl,
+      configFile: false,
+      babelrc: false,
+      ast: true,
+      parserOpts: {
+        allowAwaitOutsideFunction: true,
       },
+      plugins: babelPluginsFromBabelPluginMap(babelPluginMap),
     })
 
     const { coverage } = metadata

package/src/internal/executing/coverage/reportToCoverage.js

@@ -1,4 +1,5 @@
 import { collectFiles } from "@jsenv/filesystem"
+
 import { relativeUrlToEmptyCoverage } from "./relativeUrlToEmptyCoverage.js"
 import { istanbulCoverageFromCoverages } from "./istanbulCoverageFromCoverages.js"
 import { normalizeIstanbulCoverage } from "./normalizeIstanbulCoverage.js"
@@ -6,8 +7,8 @@ import { normalizeIstanbulCoverage } from "./normalizeIstanbulCoverage.js"
 export const reportToCoverage = async (
   report,
   {
+    multipleExecutionsOperation,
     logger,
-    cancellationToken,
     projectDirectoryUrl,
     babelPluginMap,
     coverageConfig,
@@ -15,50 +16,66 @@ export const reportToCoverage = async (
     coverageV8MergeConflictIsExpected,
   },
 ) => {
-  const istanbulCoverageFromExecution = await executionReportToCoverage(report, {
-    logger,
-    projectDirectoryUrl,
-    coverageV8MergeConflictIsExpected,
-  })
+  // here we should forward multipleExecutionsOperation.signal
+  // to allow aborting this too
+  const istanbulCoverageFromExecution = await executionReportToCoverage(
+    report,
+    {
+      logger,
+      projectDirectoryUrl,
+      coverageV8MergeConflictIsExpected,
+    },
+  )
 
   if (!coverageIncludeMissing) {
     return istanbulCoverageFromExecution
   }
 
   const relativeFileUrlToCoverArray = await listRelativeFileUrlToCover({
-    cancellationToken,
+    multipleExecutionsOperation,
     projectDirectoryUrl,
     coverageConfig,
   })
 
-  const relativeFileUrlMissingCoverageArray = relativeFileUrlToCoverArray.filter(
-    (relativeFileUrlToCover) =>
+  const relativeFileUrlMissingCoverageArray =
+    relativeFileUrlToCoverArray.filter((relativeFileUrlToCover) =>
       Object.keys(istanbulCoverageFromExecution).every((key) => {
         return key !== `./${relativeFileUrlToCover}`
       }),
-  )
+    )
 
   const istanbulCoverageFromMissedFiles = {}
+  // maybe we should prefer reduce over Promise.all here
+  // because it creates a LOT of things to do
   await Promise.all(
-    relativeFileUrlMissingCoverageArray.map(async (relativeFileUrlMissingCoverage) => {
-      const emptyCoverage = await relativeUrlToEmptyCoverage(relativeFileUrlMissingCoverage, {
-        cancellationToken,
-        projectDirectoryUrl,
-        babelPluginMap,
-      })
-      istanbulCoverageFromMissedFiles[relativeFileUrlMissingCoverage] = emptyCoverage
-      return emptyCoverage
-    }),
+    relativeFileUrlMissingCoverageArray.map(
+      async (relativeFileUrlMissingCoverage) => {
+        const emptyCoverage = await relativeUrlToEmptyCoverage(
+          relativeFileUrlMissingCoverage,
+          {
+            multipleExecutionsOperation,
+            projectDirectoryUrl,
+            babelPluginMap,
+          },
+        )
+        istanbulCoverageFromMissedFiles[relativeFileUrlMissingCoverage] =
+          emptyCoverage
+        return emptyCoverage
+      },
+    ),
   )
 
   return {
     ...istanbulCoverageFromExecution, // already normalized
-    ...normalizeIstanbulCoverage(istanbulCoverageFromMissedFiles, projectDirectoryUrl),
+    ...normalizeIstanbulCoverage(
+      istanbulCoverageFromMissedFiles,
+      projectDirectoryUrl,
+    ),
   }
 }
 
 const listRelativeFileUrlToCover = async ({
-  cancellationToken,
+  multipleExecutionsOperation,
   projectDirectoryUrl,
   coverageConfig,
 }) => {
@@ -67,7 +84,7 @@ const listRelativeFileUrlToCover = async ({
   }
 
   const matchingFileResultArray = await collectFiles({
-    cancellationToken,
+    signal: multipleExecutionsOperation.signal,
     directoryUrl: projectDirectoryUrl,
     structuredMetaMap: structuredMetaMapForCoverage,
     predicate: ({ cover }) => cover,
@@ -85,7 +102,8 @@ const executionReportToCoverage = async (
   Object.keys(report).forEach((file) => {
     const executionResultForFile = report[file]
     Object.keys(executionResultForFile).forEach((executionName) => {
-      const executionResultForFileOnRuntime = executionResultForFile[executionName]
+      const executionResultForFileOnRuntime =
+        executionResultForFile[executionName]
 
       const { status, coverage } = executionResultForFileOnRuntime
       if (!coverage) {
@@ -108,7 +126,9 @@ const executionReportToCoverage = async (
         // that were suppose to be coverage but were not.
 
         if (status === "completed") {
-          logger.warn(`No execution.coverage from execution named "${executionName}" of ${file}`)
+          logger.warn(
+            `No execution.coverage from execution named "${executionName}" of ${file}`,
+          )
         }
         return
       }

package/src/internal/executing/coverage/v8CoverageFromNodeV8Directory.js

@@ -26,15 +26,11 @@ export const v8CoverageFromNodeV8Directory = async ({
 }
 
 const readV8CoverageReportsFromDirectory = async (coverageDirectory) => {
-  const tryReadDirectory = async (timeSpentTrying = 0) => {
+  const tryReadDirectory = async () => {
     const dirContent = await readDirectory(coverageDirectory)
     if (dirContent.length > 0) {
       return dirContent
     }
-    if (timeSpentTrying < 800) {
-      await new Promise((resolve) => setTimeout(resolve, 100))
-      return tryReadDirectory(timeSpentTrying + 100)
-    }
     console.warn(`v8 coverage directory is empty at ${coverageDirectory}`)
     return dirContent
   }
@@ -45,20 +41,11 @@ const readV8CoverageReportsFromDirectory = async (coverageDirectory) => {
   await Promise.all(
     dirContent.map(async (dirEntry) => {
       const dirEntryUrl = resolveUrl(dirEntry, coverageDirectoryUrl)
-      const tryReadJsonFile = async (timeSpentTrying = 0) => {
+      const tryReadJsonFile = async () => {
         try {
           const fileContent = await readFile(dirEntryUrl, { as: "json" })
           return fileContent
         } catch (e) {
-          if (e.name === "SyntaxError") {
-            // If there is a syntax error it's likely because Node.js
-            // is not done writing the json file content
-            // -> let's retry to read file after 100ms
-            if (timeSpentTrying < 100) {
-              await new Promise((resolve) => setTimeout(resolve, 100))
-              return tryReadJsonFile(timeSpentTrying + 100)
-            }
-          }
           console.warn(
             createDetailedMessage(`Error while reading coverage file`, {
               "error stack": e.stack,