@jsenv/core 27.0.0-alpha.6 → 27.0.0-alpha.60

package/src/execute/runtimes/node/node_process.js

@@ -1,4 +1,22 @@
-import { createControlledProcess } from "./controlled_process.js"
+import { fork } from "node:child_process"
+import { urlToFileSystemPath } from "@jsenv/filesystem"
+import { createDetailedMessage } from "@jsenv/logger"
+import {
+  Abort,
+  raceCallbacks,
+  createCallbackListNotifiedOnce,
+} from "@jsenv/abort"
+import { uneval } from "@jsenv/uneval"
+
+import { memoize } from "@jsenv/utils/memoize/memoize.js"
+import { createChildExecOptions } from "./child_exec_options.js"
+import { ExecOptions } from "./exec_options.js"
+import { killProcessTree } from "./kill_process_tree.js"
+
+const NODE_CONTROLLABLE_FILE_URL = new URL(
+  "./controllable_file.mjs",
+  import.meta.url,
+).href
 
 export const nodeProcess = {
   name: "node",
@@ -8,33 +26,32 @@ export const nodeProcess = {
 nodeProcess.run = async ({
   signal = new AbortController().signal,
   logger,
-  logProcessCommand,
+  logProcessCommand = false,
   rootDirectoryUrl,
   fileRelativeUrl,
 
   keepRunning,
   gracefulStopAllocatedMs = 4000,
   stopSignal,
-  onStop,
-  onError,
   onConsole,
-  onResult,
 
-  measurePerformance,
-  collectPerformance,
   collectCoverage = false,
   coverageForceIstanbul,
+  collectPerformance,
 
   debugPort,
   debugMode,
   debugModeInheritBreak,
   env,
-  inheritProcessEnv,
+  inheritProcessEnv = true,
   commandLineOptions = [],
-  stdin,
-  stdout,
-  stderr,
+  stdin = "pipe",
+  stdout = "pipe",
+  stderr = "pipe",
 }) => {
+  if (env !== undefined && typeof env !== "object") {
+    throw new TypeError(`env must be an object, got ${env}`)
+  }
   env = {
     ...env,
     COVERAGE_ENABLED: collectCoverage,
@@ -49,44 +66,268 @@ nodeProcess.run = async ({
     "--experimental-import-meta-resolve",
     ...commandLineOptions,
   ]
-  const { stop, requestActionOnChildProcess } = await createControlledProcess({
+
+  const cleanupCallbackList = createCallbackListNotifiedOnce()
+  const cleanup = async (reason) => {
+    await cleanupCallbackList.notify({ reason })
+  }
+
+  const childExecOptions = await createChildExecOptions({
     signal,
-    logger,
     debugPort,
     debugMode,
     debugModeInheritBreak,
-    env,
-    inheritProcessEnv,
-    commandLineOptions,
-    stdin,
-    stdout,
-    stderr,
-    logProcessCommand,
-
-    stopSignal,
-    onStop,
-    onError,
-    onConsole,
   })
-  const namespace = await requestActionOnChildProcess({
-    signal,
-    actionType: "execute-using-dynamic-import",
-    actionParams: {
-      fileUrl: new URL(fileRelativeUrl, rootDirectoryUrl).href,
-      measurePerformance,
-      collectPerformance,
-      collectCoverage,
+  const execArgv = ExecOptions.toExecArgv({
+    ...childExecOptions,
+    ...ExecOptions.fromExecArgv(commandLineOptions),
+  })
+  const envForChildProcess = {
+    ...(inheritProcessEnv ? process.env : {}),
+    ...env,
+  }
+  logger[logProcessCommand ? "info" : "debug"](
+    `${process.argv[0]} ${execArgv.join(" ")} ${urlToFileSystemPath(
+      NODE_CONTROLLABLE_FILE_URL,
+    )}`,
+  )
+  const childProcess = fork(urlToFileSystemPath(NODE_CONTROLLABLE_FILE_URL), {
+    execArgv,
+    // silent: true
+    stdio: ["pipe", "pipe", "pipe", "ipc"],
+    env: envForChildProcess,
+  })
+  logger.debug(
+    createDetailedMessage(`child process forked (pid ${childProcess.pid})`, {
+      "execArgv": execArgv.join(`\n`),
+      "custom env": JSON.stringify(env, null, "  "),
+    }),
+  )
+  // if we pass stream, pipe them https://github.com/sindresorhus/execa/issues/81
+  if (typeof stdin === "object") {
+    stdin.pipe(childProcess.stdin)
+  }
+  if (typeof stdout === "object") {
+    childProcess.stdout.pipe(stdout)
+  }
+  if (typeof stderr === "object") {
+    childProcess.stderr.pipe(stderr)
+  }
+  const childProcessReadyPromise = new Promise((resolve) => {
+    onceProcessMessage(childProcess, "ready", resolve)
+  })
+  const removeOutputListener = installProcessOutputListener(
+    childProcess,
+    ({ type, text }) => {
+      onConsole({ type, text })
     },
+  )
+  const stop = memoize(async ({ gracefulStopAllocatedMs } = {}) => {
+    // all libraries are facing problem on windows when trying
+    // to kill a process spawning other processes.
+    // "killProcessTree" is theorically correct but sometimes keep process handing forever.
+    // Inside GitHub workflow the whole Virtual machine gets unresponsive and ends up being killed
+    // There is no satisfying solution to this problem so we stick to the basic
+    // childProcess.kill()
+    if (process.platform === "win32") {
+      childProcess.kill()
+      return
+    }
+    if (gracefulStopAllocatedMs) {
+      try {
+        await killProcessTree(childProcess.pid, {
+          signal: GRACEFUL_STOP_SIGNAL,
+          timeout: gracefulStopAllocatedMs,
+        })
+        return
+      } catch (e) {
+        if (e.code === "TIMEOUT") {
+          logger.debug(
+            `kill with SIGTERM because gracefulStop still pending after ${gracefulStopAllocatedMs}ms`,
+          )
+          await killProcessTree(childProcess.pid, {
+            signal: GRACEFUL_STOP_FAILED_SIGNAL,
+          })
+          return
+        }
+        throw e
+      }
+    }
+    await killProcessTree(childProcess.pid, { signal: STOP_SIGNAL })
+    return
   })
-  onResult({
-    status: "completed",
-    namespace,
+
+  const actionOperation = Abort.startOperation()
+  actionOperation.addAbortSignal(signal)
+  const winnerPromise = new Promise((resolve) => {
+    raceCallbacks(
+      {
+        // https://nodejs.org/api/child_process.html#child_process_event_disconnect
+        // disconnect: (cb) => {
+        //   return onceProcessEvent(childProcess, "disconnect", cb)
+        // },
+        // https://nodejs.org/api/child_process.html#child_process_event_error
+        error: (cb) => {
+          return onceProcessEvent(childProcess, "error", cb)
+        },
+        exit: (cb) => {
+          return onceProcessEvent(childProcess, "exit", (code, signal) => {
+            cb({ code, signal })
+          })
+        },
+        response: (cb) => {
+          onceProcessMessage(childProcess, "action-result", cb)
+        },
+      },
+      resolve,
+    )
   })
+  const getResult = async () => {
+    actionOperation.throwIfAborted()
+    await childProcessReadyPromise
+    actionOperation.throwIfAborted()
+    await sendToProcess(childProcess, "action", {
+      actionType: "execute-using-dynamic-import",
+      actionParams: {
+        fileUrl: new URL(fileRelativeUrl, rootDirectoryUrl).href,
+        collectPerformance,
+      },
+    })
+    const winner = await winnerPromise
+    if (winner.name === "error") {
+      const error = winner.data
+      removeOutputListener()
+      return {
+        status: "errored",
+        error,
+      }
+    }
+    if (winner.name === "exit") {
+      const { code } = winner.data
+      await cleanup("process exit")
+      if (code === 12) {
+        return {
+          status: "errored",
+          error: new Error(
+            `node process exited with 12 (the forked child process wanted to use a non-available port for debug)`,
+          ),
+        }
+      }
+      if (
+        code === null ||
+        code === 0 ||
+        code === SIGINT_EXIT_CODE ||
+        code === SIGTERM_EXIT_CODE ||
+        code === SIGABORT_EXIT_CODE
+      ) {
+        return {
+          status: "errored",
+          error: new Error(`node process exited during execution`),
+        }
+      }
+      // process.exit(1) in child process or process.exitCode = 1 + process.exit()
+      // means there was an error even if we don't know exactly what.
+      return {
+        status: "errored",
+        error: new Error(
+          `node process exited with code ${code} during execution`,
+        ),
+      }
+    }
+    const { status, value } = winner.data
+    if (status === "action-failed") {
+      return {
+        status: "errored",
+        error: value,
+      }
+    }
+    return {
+      status: "completed",
+      ...value,
+    }
+  }
+
+  let result
+  try {
+    result = await getResult()
+  } catch (e) {
+    result = {
+      status: "errored",
+      error: e,
+    }
+  }
   if (keepRunning) {
     stopSignal.notify = stop
-    return
+  } else {
+    await stop({
+      gracefulStopAllocatedMs,
+    })
   }
-  await stop({
-    gracefulStopAllocatedMs,
+  await actionOperation.end()
+  return result
+}
+
+// https://nodejs.org/api/process.html#process_signal_events
+const SIGINT_SIGNAL_NUMBER = 2
+const SIGABORT_SIGNAL_NUMBER = 6
+const SIGTERM_SIGNAL_NUMBER = 15
+const SIGINT_EXIT_CODE = 128 + SIGINT_SIGNAL_NUMBER
+const SIGABORT_EXIT_CODE = 128 + SIGABORT_SIGNAL_NUMBER
+const SIGTERM_EXIT_CODE = 128 + SIGTERM_SIGNAL_NUMBER
+// http://man7.org/linux/man-pages/man7/signal.7.html
+// https:// github.com/nodejs/node/blob/1d9511127c419ec116b3ddf5fc7a59e8f0f1c1e4/lib/internal/child_process.js#L472
+const GRACEFUL_STOP_SIGNAL = "SIGTERM"
+const STOP_SIGNAL = "SIGKILL"
+// it would be more correct if GRACEFUL_STOP_FAILED_SIGNAL was SIGHUP instead of SIGKILL.
+// but I'm not sure and it changes nothing so just use SIGKILL
+const GRACEFUL_STOP_FAILED_SIGNAL = "SIGKILL"
+
+const sendToProcess = async (childProcess, type, data) => {
+  const source = uneval(data, { functionAllowed: true })
+  return new Promise((resolve, reject) => {
+    childProcess.send({ type, data: source }, (error) => {
+      if (error) {
+        reject(error)
+      } else {
+        resolve()
+      }
+    })
   })
 }
+
+const installProcessOutputListener = (childProcess, callback) => {
+  // beware that we may receive ansi output here, should not be a problem but keep that in mind
+  const stdoutDataCallback = (chunk) => {
+    callback({ type: "log", text: String(chunk) })
+  }
+  childProcess.stdout.on("data", stdoutDataCallback)
+  const stdErrorDataCallback = (chunk) => {
+    callback({ type: "error", text: String(chunk) })
+  }
+  childProcess.stderr.on("data", stdErrorDataCallback)
+  return () => {
+    childProcess.stdout.removeListener("data", stdoutDataCallback)
+    childProcess.stderr.removeListener("data", stdoutDataCallback)
+  }
+}
+
+const onceProcessMessage = (childProcess, type, callback) => {
+  const onmessage = (message) => {
+    if (message.type === type) {
+      childProcess.removeListener("message", onmessage)
+      // eslint-disable-next-line no-eval
+      callback(message.data ? eval(`(${message.data})`) : "")
+    }
+  }
+  childProcess.on("message", onmessage)
+  return () => {
+    childProcess.removeListener("message", onmessage)
+  }
+}
+
+const onceProcessEvent = (childProcess, type, callback) => {
+  childProcess.once(type, callback)
+  return () => {
+    childProcess.removeListener(type, callback)
+  }
+}

package/src/jsenv_root_directory_url.js

@@ -0,0 +1 @@
+export const jsenvRootDirectoryUrl = new URL("../", import.meta.url).href

package/src/omega/{runtime_support/default_runtime_support.js → compat/default_runtime_compat.js}

@@ -1,13 +1,11 @@
 // correspond to dynamic import
-export const defaultRuntimeSupport = {
+export const defaultRuntimeCompat = {
   // android: "8",
   chrome: "63",
   edge: "79",
-  electron: "8.1",
   firefox: "67",
-  ios: "11",
+  ios: "11.3",
   opera: "50",
   safari: "11.3",
-  node: "13.2",
-  samsung: "8.0",
+  samsung: "8.2",
 }

package/src/omega/{runtime_support/features_compatibility.js → compat/features_compats.js}

@@ -1,4 +1,4 @@
-export const featuresCompatMap = {
+export const featureCompats = {
   script_type_module: {
     edge: "16",
     firefox: "60",
@@ -9,6 +9,15 @@ export const featuresCompatMap = {
     android: "61",
     samsung: "8.2",
   },
+  document_current_script: {
+    edge: "12",
+    firefox: "4",
+    chrome: "29",
+    safari: "8",
+    opera: "16",
+    android: "4.4",
+    samsung: "4",
+  },
   import_meta: {
     chrome: "64",
     edge: "79",
@@ -18,13 +27,16 @@ export const featuresCompatMap = {
     ios: "12",
     android: "9",
   },
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import#browser_compatibility
   import_dynamic: {
+    android: "8",
+    chrome: "63",
     edge: "79",
     firefox: "67",
-    chrome: "63",
-    safari: "11.3",
+    ios: "11.3",
     opera: "50",
-    android: "8",
+    safari: "11.3",
+    samsung: "8.0",
     node: "13.2",
   },
   top_level_await: {
@@ -52,6 +64,7 @@ export const featuresCompatMap = {
     chrome: "93",
     edge: "93",
   },
+  import_type_text: {},
   // https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleSheet#browser_compatibility
   new_stylesheet: {
     chrome: "73",
@@ -59,6 +72,18 @@ export const featuresCompatMap = {
     opera: "53",
     android: "73",
   },
+  // https://caniuse.com/?search=worker
+  worker: {
+    ie: "10",
+    edge: "12",
+    firefox: "3.5",
+    chrome: "4",
+    opera: "11.5",
+    safari: "4",
+    ios: "5",
+    android: "4.4",
+  },
+  // https://developer.mozilla.org/en-US/docs/Web/API/Worker/Worker#browser_compatibility
   worker_type_module: {
     chrome: "80",
     edge: "80",
@@ -66,6 +91,32 @@ export const featuresCompatMap = {
     android: "80",
   },
   worker_importmap: {},
+  service_worker: {
+    edge: "17",
+    firefox: "44",
+    chrome: "40",
+    safari: "11.1",
+    opera: "27",
+    ios: "11.3",
+    android: "12.12",
+  },
+  service_worker_type_module: {
+    chrome: "80",
+    edge: "80",
+    opera: "67",
+    android: "80",
+  },
+  shared_worker: {
+    chrome: "4",
+    edge: "79",
+    firefox: "29",
+    opera: "10.6",
+  },
+  shared_worker_type_module: {
+    chrome: "80",
+    edge: "80",
+    opera: "67",
+  },
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/globalThis#browser_compatibility
   global_this: {
     edge: "79",
@@ -88,4 +139,15 @@ export const featuresCompatMap = {
     samsung: "8",
     electron: "3",
   },
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#browser_compatibility
+  template_literals: {
+    chrome: "41",
+    edge: "12",
+    firefox: "34",
+    opera: "28",
+    safari: "9",
+    ios: "9",
+    android: "4",
+    node: "4",
+  },
 }

package/src/omega/compat/runtime_compat.js

@@ -0,0 +1,50 @@
+import { findHighestVersion } from "@jsenv/utils/semantic_versioning/highest_version.js"
+import { featureCompats } from "./features_compats.js"
+
+export const RUNTIME_COMPAT = {
+  featureCompats,
+
+  add: (originalRuntimeCompat, feature) => {
+    const featureCompat = getFeatureCompat(feature)
+    const runtimeCompat = {
+      ...originalRuntimeCompat,
+    }
+    Object.keys(featureCompat).forEach((runtimeName) => {
+      const firstVersion = originalRuntimeCompat[runtimeName]
+      const secondVersion = featureCompat[runtimeName]
+      runtimeCompat[runtimeName] = firstVersion
+        ? findHighestVersion(firstVersion, secondVersion)
+        : secondVersion
+    })
+    return runtimeCompat
+  },
+
+  isSupported: (runtimeCompat, feature) => {
+    const featureCompat = getFeatureCompat(feature)
+    const runtimeNames = Object.keys(runtimeCompat)
+    const runtimeWithoutCompat = runtimeNames.find((runtimeName) => {
+      const runtimeVersion = runtimeCompat[runtimeName]
+      const runtimeVersionCompatible = featureCompat[runtimeName] || "Infinity"
+      const highestVersion = findHighestVersion(
+        runtimeVersion,
+        runtimeVersionCompatible,
+      )
+      return highestVersion !== runtimeVersion
+    })
+    return !runtimeWithoutCompat
+  },
+}
+
+const getFeatureCompat = (feature) => {
+  if (typeof feature === "string") {
+    const compat = featureCompats[feature]
+    if (!compat) {
+      throw new Error(`"${feature}" feature is unknown`)
+    }
+    return compat
+  }
+  if (typeof feature !== "object") {
+    throw new TypeError(`feature must be a string or an object, got ${feature}`)
+  }
+  return feature
+}