@jsenv/core 23.3.0 → 23.5.0

package/src/internal/executing/executeConcurrently.js

@@ -1,12 +1,21 @@
-import { stat } from "node:fs"
+import { existsSync } from "node:fs"
 import wrapAnsi from "wrap-ansi"
-import { loggerToLevels, createDetailedMessage } from "@jsenv/logger"
-import { urlToFileSystemPath } from "@jsenv/filesystem"
-import { createLog } from "@jsenv/log"
+import cuid from "cuid"
+import { loggerToLevels } from "@jsenv/logger"
+import { createLog, startSpinner } from "@jsenv/log"
+import {
+  urlToFileSystemPath,
+  resolveUrl,
+  writeDirectory,
+  ensureEmptyDirectory,
+  normalizeStructuredMetaMap,
+  urlToMeta,
+} from "@jsenv/filesystem"
+import { Abort } from "@jsenv/abort"
 
 import { launchAndExecute } from "../executing/launchAndExecute.js"
 import { reportToCoverage } from "./coverage/reportToCoverage.js"
-import { createExecutionResultLog } from "./executionLogs.js"
+import { formatExecuting, formatExecutionResult } from "./executionLogs.js"
 import { createSummaryLog } from "./createSummaryLog.js"
 
 export const executeConcurrently = async (
@@ -24,39 +33,107 @@ export const executeConcurrently = async (
     babelPluginMap,
 
     defaultMsAllocatedPerExecution = 30000,
+    cooldownBetweenExecutions = 0,
     maxExecutionsInParallel = 1,
     completedExecutionLogMerging,
     completedExecutionLogAbbreviation,
-    measureGlobalDuration = true,
 
     coverage,
     coverageConfig,
     coverageIncludeMissing,
     coverageForceIstanbul,
-    coverageV8MergeConflictIsExpected,
+    coverageV8ConflictWarning,
+    coverageTempDirectoryRelativeUrl,
+    runtimeSupport,
 
-    mainFileNotFoundCallback = ({ fileRelativeUrl }) => {
-      logger.error(
-        new Error(
-          createDetailedMessage(`an execution main file does not exists.`, {
-            ["file relative path"]: fileRelativeUrl,
-          }),
-        ),
-      )
-    },
     beforeExecutionCallback = () => {},
     afterExecutionCallback = () => {},
 
     logSummary,
   },
 ) => {
+  if (completedExecutionLogMerging && !process.stdout.isTTY) {
+    completedExecutionLogMerging = false
+    logger.debug(
+      `Force completedExecutionLogMerging to false because process.stdout.isTTY is false`,
+    )
+  }
+  const executionLogsEnabled = loggerToLevels(logger).info
+  const executionSpinner = executionLogsEnabled && process.stdout.isTTY
+
   const startMs = Date.now()
 
   const report = {}
   const executionCount = executionSteps.length
 
-  let previousExecutionResult
-  let previousExecutionLog
+  let transformReturnValue = (value) => value
+
+  const coverageTempDirectoryUrl = resolveUrl(
+    coverageTempDirectoryRelativeUrl,
+    projectDirectoryUrl,
+  )
+
+  const structuredMetaMapForCover = normalizeStructuredMetaMap(
+    {
+      cover: coverageConfig,
+    },
+    projectDirectoryUrl,
+  )
+  const coverageIgnorePredicate = (url) => {
+    return !urlToMeta({
+      url: resolveUrl(url, projectDirectoryUrl),
+      structuredMetaMap: structuredMetaMapForCover,
+    }).cover
+  }
+
+  if (coverage) {
+    // in case runned multiple times, we don't want to keep writing lot of files in this directory
+    if (!process.env.NODE_V8_COVERAGE) {
+      await ensureEmptyDirectory(coverageTempDirectoryUrl)
+    }
+
+    if (runtimeSupport.node) {
+      // v8 coverage is written in a directoy and auto propagate to subprocesses
+      // through process.env.NODE_V8_COVERAGE.
+      if (!coverageForceIstanbul && !process.env.NODE_V8_COVERAGE) {
+        const v8CoverageDirectory = resolveUrl(
+          `./node_v8/${cuid()}`,
+          coverageTempDirectoryUrl,
+        )
+        await writeDirectory(v8CoverageDirectory, { allowUseless: true })
+        process.env.NODE_V8_COVERAGE = urlToFileSystemPath(v8CoverageDirectory)
+      }
+    }
+
+    transformReturnValue = async (value) => {
+      if (multipleExecutionsOperation.signal.aborted) {
+        // don't try to do the coverage stuff
+        return value
+      }
+
+      try {
+        value.coverage = await reportToCoverage(value.report, {
+          signal: multipleExecutionsOperation.signal,
+          logger,
+          projectDirectoryUrl,
+          babelPluginMap,
+          coverageConfig,
+          coverageIncludeMissing,
+          coverageForceIstanbul,
+          coverageIgnorePredicate,
+          coverageV8ConflictWarning,
+        })
+      } catch (e) {
+        if (Abort.isAbortError(e)) {
+          return value
+        }
+        throw e
+      }
+      return value
+    }
+  }
+
+  let executionLog = createLog({ newLine: "around" })
   let abortedCount = 0
   let timedoutCount = 0
   let erroredCount = 0
@@ -64,18 +141,19 @@ export const executeConcurrently = async (
   const executionsDone = await executeInParallel({
     multipleExecutionsOperation,
     maxExecutionsInParallel,
+    cooldownBetweenExecutions,
     executionSteps,
     start: async (paramsFromStep) => {
       const executionIndex = executionSteps.indexOf(paramsFromStep)
-      const { executionName, fileRelativeUrl } = paramsFromStep
+      const { executionName, fileRelativeUrl, runtime } = paramsFromStep
+      const runtimeName = runtime.name
+      const runtimeVersion = runtime.version
+
       const executionParams = {
         // the params below can be overriden by executionDefaultParams
         measurePerformance: false,
         collectPerformance: false,
-        measureDuration: true,
         captureConsole: true,
-        collectRuntimeName: true,
-        collectRuntimeVersion: true,
         // stopAfterExecute: true to ensure runtime is stopped once executed
         // because we have what we wants: execution is completed and
         // we have associated coverage and capturedConsole
@@ -85,6 +163,7 @@ export const executeConcurrently = async (
         stopAfterExecuteReason: "execution-done",
         allocatedMs: defaultMsAllocatedPerExecution,
         ...paramsFromStep,
+        runtime,
         // mirrorConsole: false because file will be executed in parallel
         // so log would be a mess to read
         mirrorConsole: false,
@@ -92,47 +171,69 @@ export const executeConcurrently = async (
 
       const beforeExecutionInfo = {
         fileRelativeUrl,
+        runtimeName,
+        runtimeVersion,
         executionIndex,
         executionParams,
       }
 
-      const filePath = urlToFileSystemPath(
-        `${projectDirectoryUrl}${fileRelativeUrl}`,
-      )
-      const fileExists = await pathLeadsToFile(filePath)
-      if (!fileExists) {
-        mainFileNotFoundCallback(beforeExecutionInfo)
-        return
+      let spinner
+      if (executionSpinner) {
+        spinner = startSpinner({
+          log: executionLog,
+          text: formatExecuting(beforeExecutionInfo, {
+            executionCount,
+            abortedCount,
+            timedoutCount,
+            erroredCount,
+            completedCount,
+          }),
+        })
       }
-
       beforeExecutionCallback(beforeExecutionInfo)
 
-      // launchAndExecute peut retourner un aborted
-      // et c'est bien, on veut le gérer, si tous les suivants sont aborted
-      // on le gere en dehors de cette boucle
-      const executionResult = await launchAndExecute({
-        signal: multipleExecutionsOperation.signal,
-        launchAndExecuteLogLevel,
+      const filePath = urlToFileSystemPath(
+        `${projectDirectoryUrl}${fileRelativeUrl}`,
+      )
+      let executionResult
+      if (existsSync(filePath)) {
+        executionResult = await launchAndExecute({
+          signal: multipleExecutionsOperation.signal,
+          launchAndExecuteLogLevel,
 
-        ...executionParams,
-        collectCoverage: coverage,
-        runtimeParams: {
-          projectDirectoryUrl,
-          compileServerOrigin,
-          outDirectoryRelativeUrl,
+          ...executionParams,
           collectCoverage: coverage,
-          coverageConfig,
-          coverageForceIstanbul,
-          ...executionParams.runtimeParams,
-        },
-        executeParams: {
-          fileRelativeUrl,
-          ...executionParams.executeParams,
-        },
-        coverageV8MergeConflictIsExpected,
-      })
+          coverageTempDirectoryUrl,
+          runtimeParams: {
+            projectDirectoryUrl,
+            compileServerOrigin,
+            outDirectoryRelativeUrl,
+            collectCoverage: coverage,
+            coverageIgnorePredicate,
+            coverageForceIstanbul,
+            ...executionParams.runtimeParams,
+          },
+          executeParams: {
+            fileRelativeUrl,
+            ...executionParams.executeParams,
+          },
+          coverageV8ConflictWarning,
+        })
+      } else {
+        executionResult = {
+          status: "errored",
+          error: new Error(
+            `No file at ${fileRelativeUrl} for execution "${executionName}"`,
+          ),
+        }
+      }
+      if (fileRelativeUrl in report === false) {
+        report[fileRelativeUrl] = {}
+      }
+      report[fileRelativeUrl][executionName] = executionResult
       const afterExecutionInfo = {
         ...beforeExecutionInfo,
+        endMs: Date.now(),
         executionResult,
       }
       afterExecutionCallback(afterExecutionInfo)
@@ -147,8 +248,8 @@ export const executeConcurrently = async (
         completedCount++
       }
 
-      if (loggerToLevels(logger).info) {
-        let log = createExecutionResultLog(afterExecutionInfo, {
+      if (executionLogsEnabled) {
+        let log = formatExecutionResult(afterExecutionInfo, {
           completedExecutionLogAbbreviation,
           executionCount,
           abortedCount,
@@ -163,31 +264,21 @@ export const executeConcurrently = async (
           wordWrap: false,
         })
 
-        if (
-          previousExecutionLog &&
-          completedExecutionLogMerging &&
-          previousExecutionResult &&
-          previousExecutionResult.status === "completed" &&
-          (previousExecutionResult.consoleCalls
-            ? previousExecutionResult.consoleCalls.length === 0
-            : true) &&
-          executionResult.status === "completed"
-        ) {
-          previousExecutionLog.write(log)
+        // replace spinner with this execution result
+        if (spinner) spinner.stop()
+        executionLog.write(log)
+
+        const canOverwriteLog = canOverwriteLogGetter({
+          completedExecutionLogMerging,
+          executionResult,
+        })
+        if (canOverwriteLog) {
+          // nothing to do, we reuse the current executionLog object
         } else {
-          if (previousExecutionLog) {
-            previousExecutionLog.destroy()
-          }
-          previousExecutionLog = createLog()
-          previousExecutionLog.write(log)
+          executionLog.destroy()
+          executionLog = createLog({ newLine: "around" })
         }
       }
-
-      if (fileRelativeUrl in report === false) {
-        report[fileRelativeUrl] = {}
-      }
-      report[fileRelativeUrl][executionName] = executionResult
-      previousExecutionResult = executionResult
     },
   })
 
@@ -202,37 +293,40 @@ export const executeConcurrently = async (
       executionsDone.length -
       // we substract abortedCount because they are not pushed into executionsDone
       summaryCounts.abortedCount,
-    ...(measureGlobalDuration ? { startMs, endMs: Date.now() } : {}),
+    duration: Date.now() - startMs,
   }
   if (logSummary) {
     logger.info(createSummaryLog(summary))
   }
 
-  if (multipleExecutionsOperation.signal.aborted) {
-    // don't try to do the coverage stuff
-    return {
-      summary,
-      report,
-    }
-  }
-
-  return {
+  return transformReturnValue({
     summary,
     report,
-    ...(coverage
-      ? {
-          coverage: await reportToCoverage(report, {
-            multipleExecutionsOperation,
-            logger,
-            projectDirectoryUrl,
-            babelPluginMap,
-            coverageConfig,
-            coverageIncludeMissing,
-            coverageV8MergeConflictIsExpected,
-          }),
-        }
-      : {}),
+  })
+}
+
+const canOverwriteLogGetter = ({
+  completedExecutionLogMerging,
+  executionResult,
+}) => {
+  if (!completedExecutionLogMerging) {
+    return false
+  }
+
+  if (executionResult.status === "aborted") {
+    return true
+  }
+
+  if (executionResult.status !== "completed") {
+    return false
+  }
+
+  const { consoleCalls = [] } = executionResult
+  if (consoleCalls.length > 0) {
+    return false
   }
+
+  return true
 }
 
 const executeInParallel = async ({
@@ -240,6 +334,7 @@ const executeInParallel = async ({
   executionSteps,
   start,
   maxExecutionsInParallel = 1,
+  cooldownBetweenExecutions,
 }) => {
   const executionResults = []
   let progressionIndex = 0
@@ -275,6 +370,11 @@ const executeInParallel = async ({
     if (!multipleExecutionsOperation.signal.aborted) {
       executionResults[index] = output
     }
+    if (cooldownBetweenExecutions) {
+      await new Promise((resolve) =>
+        setTimeout(resolve, cooldownBetweenExecutions),
+      )
+    }
   }
 
   await nextChunk()
@@ -282,22 +382,6 @@ const executeInParallel = async ({
   return executionResults
 }
 
-const pathLeadsToFile = (path) => {
-  return new Promise((resolve, reject) => {
-    stat(path, (error, stats) => {
-      if (error) {
-        if (error.code === "ENOENT") {
-          resolve(false)
-        } else {
-          reject(error)
-        }
-      } else {
-        resolve(stats.isFile())
-      }
-    })
-  })
-}
-
 const reportToSummary = (report) => {
   const fileNames = Object.keys(report)
 

package/src/internal/executing/executePlan.js

@@ -25,16 +25,17 @@ export const executePlan = async (
 
     defaultMsAllocatedPerExecution,
     maxExecutionsInParallel,
+    cooldownBetweenExecutions,
     completedExecutionLogMerging,
     completedExecutionLogAbbreviation,
     logSummary,
-    measureGlobalDuration,
 
     coverage,
     coverageConfig,
     coverageIncludeMissing,
     coverageForceIstanbul,
-    coverageV8MergeConflictIsExpected,
+    coverageV8ConflictWarning,
+    coverageTempDirectoryRelativeUrl,
 
     compileServerProtocol,
     compileServerPrivateKey,
@@ -81,7 +82,6 @@ export const executePlan = async (
           SIGINT: true,
         },
         () => {
-          logger.info("Aborting execution (SIGINT)")
           abort()
         },
       )
@@ -147,19 +147,22 @@ export const executePlan = async (
 
       defaultMsAllocatedPerExecution,
       maxExecutionsInParallel,
+      cooldownBetweenExecutions,
       completedExecutionLogMerging,
       completedExecutionLogAbbreviation,
       logSummary,
-      measureGlobalDuration,
 
       coverage,
       coverageConfig,
       coverageIncludeMissing,
       coverageForceIstanbul,
-      coverageV8MergeConflictIsExpected,
+      coverageV8ConflictWarning,
+      coverageTempDirectoryRelativeUrl,
+      runtimeSupport,
     })
 
     return {
+      aborted: multipleExecutionsOperation.signal.aborted,
       planSummary: result.summary,
       planReport: result.report,
       planCoverage: result.coverage,

package/src/internal/executing/executionLogs.js

@@ -4,8 +4,40 @@ import { msAsDuration } from "../logs/msAsDuration.js"
 import { EXECUTION_COLORS } from "./execution_colors.js"
 import { createSummaryDetails } from "./createSummaryLog.js"
 
-export const createExecutionResultLog = (
-  { executionIndex, fileRelativeUrl, executionParams, executionResult },
+export const formatExecuting = (
+  { executionIndex },
+  { executionCount, abortedCount, timedoutCount, erroredCount, completedCount },
+) => {
+  const executionNumber = executionIndex + 1
+  const description = ANSI.color(
+    `executing ${executionNumber} of ${executionCount}`,
+    EXECUTION_COLORS.executing,
+  )
+  const summary =
+    executionIndex === 0
+      ? ""
+      : `(${createSummaryDetails({
+          executionCount: executionIndex,
+          abortedCount,
+          timedoutCount,
+          erroredCount,
+          completedCount,
+        })})`
+
+  return formatExecution({
+    label: `${description} ${summary}`,
+  })
+}
+
+export const formatExecutionResult = (
+  {
+    executionIndex,
+    fileRelativeUrl,
+    runtimeName,
+    runtimeVersion,
+    executionParams,
+    executionResult,
+  },
   {
     completedExecutionLogAbbreviation,
     executionCount,
@@ -24,6 +56,7 @@ export const createExecutionResultLog = (
     executionCount,
     allocatedMs,
   })
+
   const summary = `(${createSummaryDetails({
     executionCount: executionNumber,
     abortedCount,
@@ -33,21 +66,22 @@ export const createExecutionResultLog = (
   })})`
 
   if (completedExecutionLogAbbreviation && status === "completed") {
-    return `
-${description} ${summary}`
+    return `${description} ${summary}`
   }
 
-  const { runtimeName, runtimeVersion, consoleCalls, startMs, endMs, error } =
-    executionResult
-
-  const runtime = `${runtimeName}/${runtimeVersion}`
-  return `
-${description} ${summary}
-file: ${fileRelativeUrl}
-runtime: ${runtime}${appendDuration({
-    startMs,
-    endMs,
-  })}${appendConsole(consoleCalls)}${appendError(error)}`
+  const { consoleCalls = [], error, duration } = executionResult
+  const console = formatConsoleCalls(consoleCalls)
+
+  return formatExecution({
+    label: `${description} ${summary}`,
+    details: {
+      file: fileRelativeUrl,
+      runtime: `${runtimeName}/${runtimeVersion}`,
+      duration: msAsDuration(duration),
+      ...(error ? { error: error.stack } : {}),
+    },
+    console,
+  })
 }
 
 const descriptionFormatters = {
@@ -83,38 +117,33 @@ const descriptionFormatters = {
   },
 }
 
-const appendDuration = ({ endMs, startMs }) => {
-  if (!endMs) return ""
-
-  return `
-duration: ${msAsDuration(endMs - startMs)}`
-}
-
-const appendConsole = (consoleCalls) => {
-  if (!consoleCalls || consoleCalls.length === 0) return ""
-
+const formatConsoleCalls = (consoleCalls) => {
   const consoleOutput = consoleCalls.reduce((previous, { text }) => {
     return `${previous}${text}`
   }, "")
 
   const consoleOutputTrimmed = consoleOutput.trim()
-  if (consoleOutputTrimmed === "") return ""
+  if (consoleOutputTrimmed === "") {
+    return ""
+  }
 
-  return `
-${ANSI.color(`-------- console --------`, ANSI.GREY)}
+  return `${ANSI.color(`-------- console --------`, ANSI.GREY)}
 ${consoleOutputTrimmed}
 ${ANSI.color(`-------------------------`, ANSI.GREY)}`
 }
 
-const appendError = (error) => {
-  if (!error) {
-    return ``
+const formatExecution = ({ label, details = {}, console }) => {
+  let message = ``
+
+  message += label
+  Object.keys(details).forEach((key) => {
+    message += `
+${key}: ${details[key]}`
+  })
+  if (console) {
+    message += `
+${console}`
   }
 
-  return `
-error: ${error.stack}`
+  return message
 }
-
-// export const createShortExecutionResultLog = () => {
-//   return `Execution completed (2/9) - (all completed)`
-// }

package/src/internal/executing/execution_colors.js

@@ -1,8 +1,9 @@
 import { ANSI } from "@jsenv/log"
 
 export const EXECUTION_COLORS = {
+  executing: ANSI.BLUE,
   aborted: ANSI.MAGENTA,
-  timedout: ANSI.YELLOW,
+  timedout: ANSI.MAGENTA,
   errored: ANSI.RED,
   completed: ANSI.GREEN,
   cancelled: ANSI.GREY,