@jsenv/core 23.1.3 → 23.2.2

package/src/internal/executing/launchAndExecute.js

@@ -1,14 +1,7 @@
-import {
-  createCancellationToken,
-  createOperation,
-  createStoppableOperation,
-  createCancellationSource,
-  composeCancellationToken,
-  errorToCancelReason,
-} from "@jsenv/cancellation"
 import { createLogger, createDetailedMessage } from "@jsenv/logger"
 
-import { promiseTrackRace } from "../promise_track_race.js"
+import { Abortable } from "@jsenv/core/src/abort/main.js"
+import { raceCallbacks } from "../../abort/callback_race.js"
 import { composeIstanbulCoverages } from "./coverage/composeIstanbulCoverages.js"
 
 const TIMING_BEFORE_EXECUTION = "before-execution"
@@ -16,8 +9,8 @@ const TIMING_DURING_EXECUTION = "during-execution"
 const TIMING_AFTER_EXECUTION = "after-execution"
 
 export const launchAndExecute = async ({
+  signal = new AbortController().signal,
   launchAndExecuteLogLevel,
-  cancellationToken = createCancellationToken(),
 
   runtime,
   runtimeParams,
@@ -39,7 +32,7 @@ export const launchAndExecute = async ({
   // however unit test will pass true because they want to move on
   stopAfterExecute = false,
   stopAfterExecuteReason = "stop after execute",
-  // when launch returns { disconnected, gracefulStop, stop }
+  // when launch returns { stoppedSignal, gracefulStop, stop }
   // the launched runtime have that amount of ms for disconnected to resolve
   // before we call stop
   gracefulStopAllocatedMs = 4000,
@@ -51,7 +44,6 @@ export const launchAndExecute = async ({
     // by default throw on error after execution
     throw error
   },
-  runtimeDisconnectCallback = () => {},
 
   coverageV8MergeConflictIsExpected,
 } = {}) => {
@@ -68,14 +60,24 @@ export const launchAndExecute = async ({
 
   let executionResultTransformer = (executionResult) => executionResult
 
-  if (measureDuration) {
-    const startMs = Date.now()
+  const launchAndExecuteOperation = Abortable.fromSignal(signal)
+
+  const hasAllocatedMs =
+    typeof allocatedMs === "number" && allocatedMs !== Infinity
+  let timeoutAbortEffect
+
+  if (hasAllocatedMs) {
+    timeoutAbortEffect = Abortable.timeout(
+      launchAndExecuteOperation,
+      // FIXME: if allocatedMs is veryyyyyy big
+      // setTimeout may be called immediatly
+      // in that case we should just throw that the number is too big
+      allocatedMs,
+    )
     executionResultTransformer = composeTransformer(
       executionResultTransformer,
       (executionResult) => {
-        const endMs = Date.now()
-        executionResult.startMs = startMs
-        executionResult.endMs = endMs
+        timeoutAbortEffect.cleanup()
         return executionResult
       },
     )
@@ -166,7 +168,7 @@ export const launchAndExecute = async ({
     executionResultTransformer = composeTransformer(
       executionResultTransformer,
       (executionResult) => {
-        const { coverage, indirectCoverage } = executionResult
+        const { coverage = {}, indirectCoverage } = executionResult
         if (indirectCoverage) {
           executionResult.coverage = composeIstanbulCoverages(
             [coverage, indirectCoverage],
@@ -191,274 +193,212 @@ export const launchAndExecute = async ({
     )
   }
 
-  let executionResult
-  const executionParams = {
-    logger,
-    cancellationToken,
-
-    runtime,
-    runtimeParams: {
-      measurePerformance,
-      collectPerformance,
-      ...runtimeParams,
-    },
-    executeParams,
-
-    stopAfterExecute,
-    stopAfterExecuteReason,
-    gracefulStopAllocatedMs,
-    runtimeConsoleCallback,
-    runtimeErrorAfterExecutionCallback,
-    runtimeDisconnectCallback,
-    runtimeStartedCallback,
-    runtimeStoppedCallback,
-  }
-  const hasAllocatedMs =
-    typeof allocatedMs === "number" && allocatedMs !== Infinity
-  if (hasAllocatedMs) {
-    const TIMEOUT_CANCEL_REASON = "timeout"
-
-    const timeoutCancellationSource = createCancellationSource()
-
-    const id = setTimeout(() => {
-      // here if allocatedMs is very big
-      // setTimeout may be called immediatly
-      // in that case we should just throw that hte number is too big
-      timeoutCancellationSource.cancel(TIMEOUT_CANCEL_REASON)
-    }, allocatedMs)
-    const timeoutCancel = () => clearTimeout(id)
-
-    cancellationToken.register(timeoutCancel)
-
-    const externalOrTimeoutCancellationToken = composeCancellationToken(
-      cancellationToken,
-      timeoutCancellationSource.token,
+  if (stopAfterExecute) {
+    executionResultTransformer = composeTransformer(
+      executionResultTransformer,
+      async (executionResult) => {
+        // if there is an error while cleaning (stopping the runtime)
+        // the execution is considered as failed
+        try {
+          await launchAndExecuteOperation.cleaner.clean(stopAfterExecuteReason)
+          return executionResult
+        } catch (e) {
+          return executionResultTransformer(
+            createErroredExecutionResult({
+              error: e,
+            }),
+          )
+        }
+      },
     )
-
-    try {
-      executionResult = await computeExecutionResult({
-        ...executionParams,
-        cancellationToken: externalOrTimeoutCancellationToken,
-      })
-      timeoutCancel()
-    } catch (e) {
-      if (errorToCancelReason(e) === TIMEOUT_CANCEL_REASON) {
-        executionResult = createTimedoutExecutionResult()
-      } else {
-        throw e
-      }
-    }
-  } else {
-    executionResult = await computeExecutionResult(executionParams)
-  }
-
-  return executionResultTransformer(executionResult)
-}
-
-const composeCallback = (previousCallback, callback) => {
-  return (...args) => {
-    previousCallback(...args)
-    return callback(...args)
   }
-}
 
-const composeTransformer = (previousTransformer, transformer) => {
-  return (value) => {
-    const transformedValue = previousTransformer(value)
-    return transformer(transformedValue)
+  if (measureDuration) {
+    const startMs = Date.now()
+    executionResultTransformer = composeTransformer(
+      executionResultTransformer,
+      (executionResult) => {
+        const endMs = Date.now()
+        executionResult.startMs = startMs
+        executionResult.endMs = endMs
+        return executionResult
+      },
+    )
   }
-}
-
-const computeExecutionResult = async ({
-  logger,
-  cancellationToken,
 
-  runtime,
-  runtimeParams,
-  executeParams,
+  try {
+    const runtimeLabel = `${runtime.name}/${runtime.version}`
+    logger.debug(`launch ${runtimeLabel} to execute something in it`)
 
-  stopAfterExecute,
-  stopAfterExecuteReason,
-  gracefulStopAllocatedMs,
-  runtimeStartedCallback,
-  runtimeStoppedCallback,
-  runtimeConsoleCallback,
-  runtimeErrorAfterExecutionCallback,
-  runtimeDisconnectCallback,
-}) => {
-  const runtimeLabel = `${runtime.name}/${runtime.version}`
-
-  logger.debug(`launch ${runtimeLabel} to execute something in it`)
-
-  const launchOperation = createStoppableOperation({
-    cancellationToken,
-    start: async () => {
-      const value = await runtime.launch({
+    Abortable.throwIfAborted(launchAndExecuteOperation)
+    const launchReturnValue = await runtime.launch({
+      signal: launchAndExecuteOperation.signal,
+      logger,
+      stopAfterExecute,
+      measurePerformance,
+      collectPerformance,
+      ...runtimeParams,
+    })
+    validateLaunchReturnValue(launchReturnValue)
+    launchAndExecuteOperation.cleaner.addCallback(async (reason) => {
+      await stopRuntime({
         logger,
-        cancellationToken,
-        stopAfterExecute,
-        ...runtimeParams,
+        runtimeLabel,
+        launchReturnValue,
+        gracefulStopAllocatedMs,
+        reason,
       })
-      runtimeStartedCallback()
-      return value
-    },
-    stop: async ({ gracefulStop, stop }, reason) => {
-      // external code can cancel using cancellationToken at any time.
-      // it is important to keep the code inside this stop function because once cancelled
-      // all code after the operation won't execute because it will be rejected with
-      // the cancellation error
-
-      let stoppedGracefully
-
-      if (gracefulStop && gracefulStopAllocatedMs) {
-        logger.debug(
-          `${runtimeLabel}: runtime.gracefulStop() because ${reason}`,
-        )
-
-        const gracefulStopPromise = (async () => {
-          await gracefulStop({ reason })
-          return true
-        })()
-
-        const stopPromise = (async () => {
-          stoppedGracefully = await new Promise(async (resolve) => {
-            const timeoutId = setTimeout(() => {
-              resolve(false)
-            }, gracefulStopAllocatedMs)
-            try {
-              await gracefulStopPromise
-              resolve(true)
-            } finally {
-              clearTimeout(timeoutId)
+    })
+
+    logger.debug(createDetailedMessage(`${runtimeLabel}: runtime launched`))
+    runtimeStartedCallback()
+
+    logger.debug(`${runtimeLabel}: start execution`)
+    const {
+      errorSignal,
+      outputSignal,
+      stoppedSignal,
+      execute,
+      finalizeExecutionResult = (executionResult) => executionResult,
+    } = launchReturnValue
+    executionResultTransformer = composeTransformer(
+      executionResultTransformer,
+      finalizeExecutionResult,
+    )
+    outputSignal.addCallback(runtimeConsoleCallback)
+
+    let timing = TIMING_BEFORE_EXECUTION
+    stoppedSignal.addCallback(() => {
+      logger.debug(`${runtimeLabel}: runtime stopped ${timing}`)
+      runtimeStoppedCallback()
+    })
+
+    const winnerPromise = new Promise((resolve, reject) => {
+      raceCallbacks(
+        {
+          aborted: (cb) => {
+            launchAndExecuteOperation.signal.addEventListener("abort", cb)
+            return () => {
+              launchAndExecuteOperation.signal.removeEventListener("abort", cb)
             }
-          })
-          if (stoppedGracefully) {
-            return stoppedGracefully
-          }
-
-          logger.debug(
-            `${runtimeLabel}: runtime.stop() because gracefulStop still pending after ${gracefulStopAllocatedMs}ms`,
-          )
-          await stop({ reason, gracefulFailed: true })
-          return false
-        })()
-
-        stoppedGracefully = await Promise.race([
-          gracefulStopPromise,
-          stopPromise,
-        ])
-      } else {
-        await stop({ reason, gracefulFailed: false })
-        stoppedGracefully = false
-      }
-
-      logger.debug(
-        `${runtimeLabel}: runtime stopped${
-          stoppedGracefully ? " gracefully" : ""
-        }`,
+          },
+          error: (cb) => {
+            return errorSignal.addCallback(cb)
+          },
+          stopped: (cb) => {
+            return stoppedSignal.addCallback(cb)
+          },
+          executed: (cb) => {
+            timing = TIMING_DURING_EXECUTION
+            const executed = execute({
+              signal: launchAndExecuteOperation.signal,
+              ...executeParams,
+            })
+            executed.then(cb, reject)
+          },
+        },
+        resolve,
       )
-      runtimeStoppedCallback({ stoppedGracefully })
-    },
-  })
+    })
 
-  const launchReturnValue = await launchOperation
-  validateLaunchReturnValue(launchReturnValue)
-  const {
-    execute,
-    disconnected,
-    registerErrorCallback = () => {},
-    registerConsoleCallback = () => {},
-    finalizeExecutionResult = (executionResult) => executionResult,
-  } = launchReturnValue
-
-  logger.debug(createDetailedMessage(`${runtimeLabel}: runtime launched.`))
-
-  logger.debug(`${runtimeLabel}: start execution.`)
-  registerConsoleCallback(runtimeConsoleCallback)
-
-  const executeOperation = createOperation({
-    cancellationToken,
-    start: async () => {
-      let timing = TIMING_BEFORE_EXECUTION
-
-      disconnected.then(() => {
-        logger.debug(`${runtimeLabel}: runtime disconnected ${timing}.`)
-        runtimeDisconnectCallback({ timing })
-      })
+    Abortable.throwIfAborted(launchAndExecuteOperation)
 
-      const executed = execute(executeParams)
+    const winner = await winnerPromise
 
-      timing = TIMING_DURING_EXECUTION
+    if (winner.name === "aborted") {
+      Abortable.throwIfAborted(launchAndExecuteOperation)
+    }
 
-      const raceResult = await promiseTrackRace([disconnected, executed])
-      timing = TIMING_AFTER_EXECUTION
+    if (winner.name === "error") {
+      return executionResultTransformer(
+        createErroredExecutionResult({
+          error: winner.data,
+        }),
+      )
+    }
 
-      if (raceResult.winner === disconnected) {
-        return createDisconnectedExecutionResult()
-      }
+    if (winner.name === "stopped") {
+      return executionResultTransformer(
+        createErroredExecutionResult({
+          error: new Error(`runtime stopped during execution`),
+        }),
+      )
+    }
 
-      if (stopAfterExecute) {
-        // if there is an error while stopping the runtine
-        // the execution is considered as failed
-        try {
-          await launchOperation.stop(stopAfterExecuteReason)
-        } catch (e) {
-          return finalizeExecutionResult(
-            createErroredExecutionResult({
-              error: e,
-            }),
-          )
-        }
-      } else {
-        // when the process is still alive
-        // we want to catch error to notify runtimeErrorAfterExecutionCallback
-        // and throw that error by default
-        registerErrorCallback((error) => {
-          runtimeErrorAfterExecutionCallback(error)
-        })
-      }
+    timing = TIMING_AFTER_EXECUTION
 
-      const executionResult = raceResult.value
-      const { status } = executionResult
-
-      if (status === "errored") {
-        // debug log level because this error happens during execution
-        // there is no need to log it.
-        // the code will know the execution errored because it receives
-        // an errored execution result
-        logger.debug(
-          createDetailedMessage(`error ${TIMING_DURING_EXECUTION}.`, {
-            ["error stack"]: executionResult.error.stack,
-            ["execute params"]: JSON.stringify(executeParams, null, "  "),
-            ["runtime"]: runtime,
-          }),
-        )
-        return finalizeExecutionResult(
-          createErroredExecutionResult(executionResult),
-        )
-      }
+    if (!stopAfterExecute) {
+      // when the process is still alive
+      // we want to catch error to notify runtimeErrorAfterExecutionCallback
+      // and throw that error by default
+      errorSignal.addCallback((error) => {
+        runtimeErrorAfterExecutionCallback(error)
+      })
+    }
+
+    const executeResult = winner.data
+    const { status } = executeResult
 
-      logger.debug(`${runtimeLabel}: execution completed.`)
-      return finalizeExecutionResult(
-        createCompletedExecutionResult(executionResult),
+    if (status === "errored") {
+      // debug log level because this error happens during execution
+      // there is no need to log it.
+      // the code will know the execution errored because it receives
+      // an errored execution result
+      logger.debug(
+        createDetailedMessage(`error ${TIMING_DURING_EXECUTION}`, {
+          ["error stack"]: executeResult.error.stack,
+          ["execute params"]: JSON.stringify(executeParams, null, "  "),
+          ["runtime"]: runtime,
+        }),
       )
-    },
-  })
+      return executionResultTransformer(
+        createErroredExecutionResult(executeResult),
+      )
+    }
 
-  const executionResult = await executeOperation
+    logger.debug(`${runtimeLabel}: execution completed`)
+    return executionResultTransformer(
+      createCompletedExecutionResult(executeResult),
+    )
+  } catch (e) {
+    if (e.name === "AbortError") {
+      if (timeoutAbortEffect && timeoutAbortEffect.signal.aborted) {
+        const executionResult = createTimedoutExecutionResult()
+        return executionResultTransformer(executionResult)
+      }
+      const executionResult = createAbortedExecutionResult()
+      return executionResultTransformer(executionResult)
+    }
+    throw e
+  }
+}
 
-  return executionResult
+const stopRuntime = async ({
+  logger,
+  runtimeLabel,
+  launchReturnValue,
+  gracefulStopAllocatedMs,
+  reason,
+}) => {
+  const { stop } = launchReturnValue
+  logger.debug(`${runtimeLabel}: stop() because ${reason}`)
+  const { graceful } = await stop({ reason, gracefulStopAllocatedMs })
+  if (graceful) {
+    logger.debug(`${runtimeLabel}: runtime stopped gracefully`)
+  } else {
+    logger.debug(`${runtimeLabel}: runtime stopped`)
+  }
 }
 
-const createTimedoutExecutionResult = () => {
+const createAbortedExecutionResult = () => {
   return {
-    status: "timedout",
+    status: "aborted",
   }
 }
 
-const createDisconnectedExecutionResult = () => {
+const createTimedoutExecutionResult = () => {
   return {
-    status: "disconnected",
+    status: "timedout",
   }
 }
 
@@ -488,6 +428,20 @@ const normalizeNamespace = (namespace) => {
   return normalized
 }
 
+const composeCallback = (previousCallback, callback) => {
+  return (...args) => {
+    previousCallback(...args)
+    return callback(...args)
+  }
+}
+
+const composeTransformer = (previousTransformer, transformer) => {
+  return async (value) => {
+    const transformedValue = await previousTransformer(value)
+    return transformer(transformedValue)
+  }
+}
+
 const validateLaunchReturnValue = (launchReturnValue) => {
   if (launchReturnValue === null) {
     throw new Error(`launch must return an object, got null`)
@@ -502,8 +456,10 @@ const validateLaunchReturnValue = (launchReturnValue) => {
     throw new Error(`launch must return an execute function, got ${execute}`)
   }
 
-  const { disconnected } = launchReturnValue
-  if (!disconnected || typeof disconnected.then !== "function") {
-    throw new Error(`launch must return a disconnected promise, got ${execute}`)
+  const { stoppedSignal } = launchReturnValue
+  if (!stoppedSignal) {
+    throw new Error(
+      `launch must return a stoppedSignal object, got ${stoppedSignal}`,
+    )
   }
 }

package/src/internal/exploring/fetchExploringJson.js

@@ -1,16 +1,15 @@
 import { createDetailedMessage } from "@jsenv/logger"
-import { isCancelError } from "@jsenv/cancellation/main.browser.js"
 
 import { fetchJson } from "../browser-utils/fetchJson.js"
 
-export const fetchExploringJson = async ({ cancellationToken } = {}) => {
+export const fetchExploringJson = async ({ signal } = {}) => {
   try {
     const exploringInfo = await fetchJson("/.jsenv/exploring.json", {
-      cancellationToken,
+      signal,
     })
     return exploringInfo
   } catch (e) {
-    if (isCancelError(e)) {
+    if (signal && signal.aborted && e.name === "AbortError") {
       throw e
     }
     throw new Error(

package/src/internal/fetchUrl.js

@@ -1,5 +1,6 @@
 import { globalAgent } from "node:https"
-import { fetchUrl as serverFetchUrl, headersToObject } from "@jsenv/server"
+import { fetchUrl as serverFetchUrl } from "@jsenv/server"
+import { headersToObject } from "@jsenv/server/src/internal/headersToObject.js"
 
 // ideally we should only pass this to the fetch below
 globalAgent.options.rejectUnauthorized = false
@@ -8,7 +9,10 @@ export const fetchUrl = async (
   url,
   { ignoreHttpsError = true, ...rest } = {},
 ) => {
-  const response = await serverFetchUrl(url, { ignoreHttpsError, ...rest })
+  const response = await serverFetchUrl(url, {
+    ignoreHttpsError,
+    ...rest,
+  })
 
   return {
     url: response.url,

package/src/internal/logs/log_style.js

@@ -16,37 +16,25 @@ if (process.env.GITHUB_WORKFLOW) {
   }
 }
 
-const ansiStyles = {
-  red: { open: 31, close: 39 },
-  green: { open: 32, close: 39 },
-  yellow: { open: 33, close: 39 },
-  blue: { open: 34, close: 39 },
-  magenta: { open: 35, close: 39 },
-  grey: { open: 39, close: 39 },
-}
-
-export const ANSI_RED = ansiStyles.red
-export const ANSI_GREEN = ansiStyles.green
-export const ANSI_YELLOW = ansiStyles.yellow
-export const ANSI_BLUE = ansiStyles.blue
-export const ANSI_MAGENTA = ansiStyles.magenta
-export const ANSI_GREY = ansiStyles.grey
-
+// https://github.com/Marak/colors.js/blob/master/lib/styles.js
+export const ANSI_RED = "\x1b[31m"
+export const ANSI_GREEN = "\x1b[32m"
+export const ANSI_YELLOW = "\x1b[33m"
+export const ANSI_BLUE = "\x1b[34m"
+export const ANSI_MAGENTA = "\x1b[35m"
+export const ANSI_GREY = "\x1b[90m"
 export const ANSI_RESET = "\x1b[0m"
 
 export const setANSIColor = canUseColors
-  ? (text, ansiColor) =>
-      `\x1b[${ansiColor.open}m${text}\x1b[${ansiColor.close}m`
+  ? (text, ANSI_COLOR) => `${ANSI_COLOR}${text}${ANSI_RESET}`
   : (text) => text
 
-export const commandSignDefault = canUseUnicode ? `❯` : `>`
-export const okSignDefault = canUseUnicode ? `✔` : `√`
-export const failureSignDefault = canUseUnicode ? `✖` : `×`
-export const infoSignDefault = canUseUnicode ? `ℹ` : `i`
-export const warningSignDefault = canUseUnicode ? `⚠` : `‼`
+export const commandSignColorLess = canUseUnicode ? `❯` : `>`
+export const okSignColorLess = canUseUnicode ? `✔` : `√`
+export const failureSignColorLess = canUseUnicode ? `✖` : `×`
 
-export const commandSign = setANSIColor(commandSignDefault, ANSI_GREY) // ANSI_MAGENTA)
-export const okSign = setANSIColor(okSignDefault, ANSI_GREEN)
-export const failureSign = setANSIColor(failureSignDefault, ANSI_RED)
-export const infoSign = setANSIColor(infoSignDefault, ANSI_BLUE)
-export const warningSign = setANSIColor(warningSignDefault, ANSI_YELLOW)
+export const commandSign = setANSIColor(commandSignColorLess, ANSI_GREY) // ANSI_MAGENTA)
+export const okSign = setANSIColor(okSignColorLess, ANSI_GREEN)
+export const failureSign = setANSIColor(failureSignColorLess, ANSI_RED)
+export const infoSign = setANSIColor(canUseUnicode ? `ℹ` : `i`, ANSI_BLUE)
+export const warningSign = setANSIColor(canUseUnicode ? `⚠` : `‼`, ANSI_YELLOW)

package/src/internal/logs/msAsDuration.js

@@ -5,7 +5,7 @@ const humanizeDuration = require("humanize-duration")
 export const msAsDuration = (metricValue) => {
   return humanizeDuration(metricValue, {
     largest: 2,
-    maxDecimalPoints: metricValue < 1 ? 4 : metricValue < 1000 ? 3 : 2,
+    maxDecimalPoints: metricValue < 0.1 ? 3 : metricValue < 1000 ? 2 : 1,
     // units: ["s"]
   })
 }