@jsenv/core 26.0.1 → 27.0.0-alpha.2

package/src/{internal/node_launcher/node_controllable_process.js → execute/runtimes/node/controlled_process.js}

@@ -1,46 +1,33 @@
 import { fork } from "node:child_process"
-import { urlToFileSystemPath, assertFilePresence } from "@jsenv/filesystem"
-import { createLogger, createDetailedMessage } from "@jsenv/logger"
+import { urlToFileSystemPath } from "@jsenv/filesystem"
+import { createDetailedMessage } from "@jsenv/logger"
 import {
   Abort,
   raceCallbacks,
-  createCallbackList,
   createCallbackListNotifiedOnce,
 } from "@jsenv/abort"
 import { uneval } from "@jsenv/uneval"
 
-import { nodeSupportsDynamicImport } from "@jsenv/core/src/internal/features/node_feature_detection/node_feature_detect_dynamic_import.js"
+import { memoize } from "@jsenv/utils/memoize/memoize.js"
 
-import { createChildProcessOptions } from "./child_process_options.js"
-import {
-  processOptionsFromExecArgv,
-  execArgvFromProcessOptions,
-} from "./process_options.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(
-  "./node_controllable_file.mjs",
+  "./controllable_file.mjs",
   import.meta.url,
 ).href
 
-// 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"
-
-export const createControllableNodeProcess = async ({
+export const createControlledProcess = async ({
   signal = new AbortController().signal,
-  logLevel,
+  logger,
+  logProcessCommand = false,
+
+  onStop,
+  onError,
+  onConsole,
+
   debugPort,
   debugMode,
   debugModeInheritBreak,
@@ -51,50 +38,47 @@ export const createControllableNodeProcess = async ({
   stdin = "pipe",
   stdout = "pipe",
   stderr = "pipe",
-  logProcessCommand = false,
 }) => {
-  const logger = createLogger({ logLevel })
-  const dynamicImportSupported = await nodeSupportsDynamicImport()
-  if (!dynamicImportSupported) {
-    throw new Error(`node does not support dynamic import`)
+  if (env !== undefined && typeof env !== "object") {
+    throw new TypeError(`env must be an object, got ${env}`)
+  }
+  const cleanupCallbackList = createCallbackListNotifiedOnce()
+  const cleanup = async (reason) => {
+    await cleanupCallbackList.notify({ reason })
   }
 
-  const childProcessOptions = await createChildProcessOptions({
+  const childExecOptions = await createChildExecOptions({
     signal,
     debugPort,
     debugMode,
     debugModeInheritBreak,
   })
-  const processOptions = {
-    ...childProcessOptions,
-    ...processOptionsFromExecArgv(commandLineOptions),
-  }
-  const execArgv = execArgvFromProcessOptions(processOptions)
-
-  if (env !== undefined && typeof env !== "object") {
-    throw new TypeError(`env must be an object, got ${env}`)
-  }
-
-  await assertFilePresence(NODE_CONTROLLABLE_FILE_URL)
+  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(`fork child process pid ${childProcess.pid}`, {
+    createDetailedMessage(`child process forked (pid ${childProcess.pid})`, {
       "execArgv": execArgv.join(`\n`),
       "custom env": JSON.stringify(env, null, "  "),
     }),
   )
-
-  // if we passe stream, pipe them https://github.com/sindresorhus/execa/issues/81
+  // if we pass stream, pipe them https://github.com/sindresorhus/execa/issues/81
   if (typeof stdin === "object") {
     stdin.pipe(childProcess.stdin)
   }
@@ -104,30 +88,49 @@ export const createControllableNodeProcess = async ({
   if (typeof stderr === "object") {
     childProcess.stderr.pipe(stderr)
   }
-  if (logProcessCommand) {
-    console.log(
-      `${process.argv[0]} ${execArgv.join(" ")} ${urlToFileSystemPath(
-        NODE_CONTROLLABLE_FILE_URL,
-      )}`,
-    )
-  }
-
   const childProcessReadyPromise = new Promise((resolve) => {
     onceProcessMessage(childProcess, "ready", resolve)
   })
-
-  const outputCallbackList = createCallbackList()
   const removeOutputListener = installProcessOutputListener(
     childProcess,
     ({ type, text }) => {
-      outputCallbackList.notify({ type, text })
+      onConsole({ type, text })
     },
   )
-
-  const errorCallbackList = createCallbackList()
-
-  const stoppedCallbackList = createCallbackListNotifiedOnce()
-
+  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
+  })
   raceCallbacks(
     {
       // https://nodejs.org/api/child_process.html#child_process_event_disconnect
@@ -157,9 +160,9 @@ export const createControllableNodeProcess = async ({
           ) {
             return
           }
-          errorCallbackList.notify(error)
+          onError(error)
         },
-        exit: ({ code, signal }) => {
+        exit: async ({ code, signal }) => {
           // 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.
           if (
@@ -169,112 +172,88 @@ export const createControllableNodeProcess = async ({
             code !== SIGTERM_EXIT_CODE &&
             code !== SIGABORT_EXIT_CODE
           ) {
-            errorCallbackList.notify(createExitWithFailureCodeError(code))
+            onError(createExitWithFailureCodeError(code))
           }
-          stoppedCallbackList.notify({ code, signal })
+          await cleanup("process exit")
+          onStop({ code, signal })
         },
       }
       raceEffects[winner.name](winner.data)
     },
   )
-
-  const stop = async ({ gracefulStopAllocatedMs } = {}) => {
-    if (stoppedCallbackList.notified) {
-      return {}
-    }
-
-    const createStoppedPromise = async () => {
-      if (stoppedCallbackList.notified) {
-        return
-      }
-      await new Promise((resolve) => stoppedCallbackList.add(resolve))
-    }
-
-    if (gracefulStopAllocatedMs) {
-      try {
-        await killProcessTree(childProcess.pid, {
-          signal: GRACEFUL_STOP_SIGNAL,
-          timeout: gracefulStopAllocatedMs,
-        })
-        await createStoppedPromise()
-        return { graceful: true }
-      } 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,
-          })
-          await createStoppedPromise()
-          return { graceful: false }
-        }
-        throw e
-      }
-    }
-
-    await killProcessTree(childProcess.pid, { signal: STOP_SIGNAL })
-    await createStoppedPromise()
-    return { graceful: false }
-  }
-
-  const requestActionOnChildProcess = ({
+  const requestActionOnChildProcess = async ({
     signal,
     actionType,
     actionParams,
   }) => {
     const actionOperation = Abort.startOperation()
     actionOperation.addAbortSignal(signal)
-
-    return new Promise(async (resolve, reject) => {
-      actionOperation.throwIfAborted()
-      await childProcessReadyPromise
-
-      onceProcessMessage(childProcess, "action-result", ({ status, value }) => {
-        if (status === "action-completed") {
-          resolve(value)
-        } else {
-          reject(value)
-        }
-      })
-
-      logger.debug(
-        createDetailedMessage(`ask child process to perform an action`, {
-          actionType,
-          actionParams: JSON.stringify(actionParams, null, "  "),
-        }),
-      )
-
-      try {
+    try {
+      const result = await new Promise(async (resolve, reject) => {
         actionOperation.throwIfAborted()
-        await sendToProcess(childProcess, "action", {
-          actionType,
-          actionParams,
-        })
-      } catch (e) {
-        if (Abort.isAbortError(e) && actionOperation.signal.aborted) {
-          throw e
-        }
-        logger.error(
-          createDetailedMessage(`error while sending message to child`, {
-            ["error stack"]: e.stack,
+        await childProcessReadyPromise
+        onceProcessMessage(
+          childProcess,
+          "action-result",
+          ({ status, value }) => {
+            if (status === "action-completed") {
+              resolve(value)
+            } else {
+              reject(value)
+            }
+          },
+        )
+        logger.debug(
+          createDetailedMessage(`ask child process to perform an action`, {
+            actionType,
+            actionParams: JSON.stringify(actionParams, null, "  "),
           }),
         )
-        throw e
-      }
-    })
+        try {
+          actionOperation.throwIfAborted()
+          await sendToProcess(childProcess, "action", {
+            actionType,
+            actionParams,
+          })
+        } catch (e) {
+          if (Abort.isAbortError(e) && actionOperation.signal.aborted) {
+            throw e
+          }
+          logger.error(
+            createDetailedMessage(`error while sending message to child`, {
+              ["error stack"]: e.stack,
+            }),
+          )
+          throw e
+        }
+      })
+      return result
+    } finally {
+      await actionOperation.end()
+    }
   }
-
   return {
     execArgv,
-    stoppedCallbackList,
-    errorCallbackList,
-    outputCallbackList,
     stop,
     requestActionOnChildProcess,
   }
 }
 
+// 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) => {
@@ -331,7 +310,6 @@ const onceProcessMessage = (childProcess, type, callback) => {
 
 const onceProcessEvent = (childProcess, type, callback) => {
   childProcess.once(type, callback)
-
   return () => {
     childProcess.removeListener(type, callback)
   }

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

@@ -0,0 +1,44 @@
+export const ExecOptions = {
+  fromExecArgv: (execArgv) => {
+    const execOptions = {}
+    let i = 0
+    while (i < execArgv.length) {
+      const execArg = execArgv[i]
+      const option = execOptionFromExecArg(execArg)
+      execOptions[option.name] = option.value
+      i++
+    }
+    return execOptions
+  },
+  toExecArgv: (execOptions) => {
+    const execArgv = []
+    Object.keys(execOptions).forEach((optionName) => {
+      const optionValue = execOptions[optionName]
+      if (optionValue === "unset") {
+        return
+      }
+      if (optionValue === "") {
+        execArgv.push(optionName)
+        return
+      }
+      execArgv.push(`${optionName}=${optionValue}`)
+    })
+    return execArgv
+  },
+}
+
+const execOptionFromExecArg = (execArg) => {
+  const equalCharIndex = execArg.indexOf("=")
+  if (equalCharIndex === -1) {
+    return {
+      name: execArg,
+      value: "",
+    }
+  }
+  const name = execArg.slice(0, equalCharIndex)
+  const value = execArg.slice(equalCharIndex + 1)
+  return {
+    name,
+    value,
+  }
+}

package/src/{internal/node_launcher → execute/runtimes/node}/kill_process_tree.js

@@ -1,4 +1,6 @@
-import { require } from "@jsenv/core/src/internal/require.js"
+import { createRequire } from "node:module"
+
+const require = createRequire(import.meta.url)
 
 // see also https://github.com/sindresorhus/execa/issues/96
 export const killProcessTree = async (

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

@@ -0,0 +1,92 @@
+import { createControlledProcess } from "./controlled_process.js"
+
+export const nodeProcess = {
+  name: "node",
+  version: process.version.slice(1),
+}
+
+nodeProcess.run = async ({
+  signal = new AbortController().signal,
+  logger,
+  logProcessCommand,
+  rootDirectoryUrl,
+  fileRelativeUrl,
+
+  keepRunning,
+  gracefulStopAllocatedMs = 4000,
+  stopSignal,
+  onStop,
+  onError,
+  onConsole,
+  onResult,
+
+  measurePerformance,
+  collectPerformance,
+  collectCoverage = false,
+  coverageForceIstanbul,
+
+  debugPort,
+  debugMode,
+  debugModeInheritBreak,
+  env,
+  inheritProcessEnv,
+  commandLineOptions = [],
+  stdin,
+  stdout,
+  stderr,
+}) => {
+  env = {
+    ...env,
+    COVERAGE_ENABLED: collectCoverage,
+    JSENV: true,
+  }
+  if (coverageForceIstanbul) {
+    // if we want to force istanbul, we will set process.env.NODE_V8_COVERAGE = ''
+    // into the child_process
+    env.NODE_V8_COVERAGE = ""
+  }
+  commandLineOptions = [
+    "--experimental-import-meta-resolve",
+    ...commandLineOptions,
+  ]
+  const { stop, requestActionOnChildProcess } = await createControlledProcess({
+    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,
+    },
+  })
+  onResult({
+    status: "completed",
+    namespace,
+  })
+  if (keepRunning) {
+    stopSignal.notify = stop
+    return
+  }
+  await stop({
+    gracefulStopAllocatedMs,
+  })
+}

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

@@ -0,0 +1,28 @@
+// https://github.com/avajs/ava/blob/576f534b345259055c95fa0c2b33bef10847a2af/lib/fork.js#L23
+// https://nodejs.org/api/worker_threads.html
+// https://github.com/avajs/ava/blob/576f534b345259055c95fa0c2b33bef10847a2af/lib/worker/base.js
+// import { Worker } from "node:worker_threads"
+
+// export const nodeWorkerThread = {
+//   name: "node_worker",
+//   version: process.version.slice(1),
+//   launch: async ({ env }) => {
+//     // https://nodejs.org/api/worker_threads.html#new-workerfilename-options
+//     const worker = new Worker(workerPath, {
+//       argv: options.workerArgv,
+//       env: {
+//         NODE_ENV: "test",
+//         JSENV: true,
+//         ...process.env,
+//       },
+//       execArgv: [...execArgv, ...additionalExecArgv],
+//       workerData: {
+//         options,
+//       },
+//       trackUnmanagedFds: true,
+//       stdin: true,
+//       stdout: true,
+//       stderr: true,
+//     })
+//   },
+// }

package/src/omega/core_plugins/babel/babel_helper/babel_helper_directory.js

@@ -0,0 +1,29 @@
+// https://github.com/babel/babel/blob/99f4f6c3b03c7f3f67cf1b9f1a21b80cfd5b0224/packages/babel-core/src/tools/build-external-helpers.js
+// the list of possible helpers:
+// https://github.com/babel/babel/blob/99f4f6c3b03c7f3f67cf1b9f1a21b80cfd5b0224/packages/babel-helpers/src/helpers.js#L13
+
+const babelHelperClientDirectoryUrl = new URL("./client/", import.meta.url).href
+
+// we cannot use "@jsenv/core/src/*" because babel helper might be injected
+// into node_modules not depending on "@jsenv/core"
+export const getBabelHelperFileUrl = (babelHelperName) => {
+  const babelHelperFileUrl = new URL(
+    `./${babelHelperName}/${babelHelperName}.js`,
+    babelHelperClientDirectoryUrl,
+  ).href
+  return babelHelperFileUrl
+}
+
+export const babelHelperNameFromUrl = (url) => {
+  if (!url.startsWith(babelHelperClientDirectoryUrl)) {
+    return null
+  }
+  const afterBabelHelperDirectory = url.slice(
+    babelHelperClientDirectoryUrl.length,
+  )
+  const babelHelperName = afterBabelHelperDirectory.slice(
+    0,
+    afterBabelHelperDirectory.indexOf("/"),
+  )
+  return babelHelperName
+}

package/src/{internal/compile_server/js → omega/core_plugins/babel/babel_helper}/babel_plugin_babel_helpers_as_jsenv_imports.js

@@ -1,11 +1,11 @@
-import { fileSystemPathToUrl } from "@jsenv/filesystem"
+import { pathToFileURL } from "node:url"
 
-import { require } from "@jsenv/core/src/internal/require.js"
+import { injectImport } from "@jsenv/utils/js_ast/babel_utils.js"
 
 import {
+  getBabelHelperFileUrl,
   babelHelperNameFromUrl,
-  babelHelperNameToImportSpecifier,
-} from "./babelHelper.js"
+} from "./babel_helper_directory.js"
 
 // named import approach found here:
 // https://github.com/rollup/rollup-plugin-babel/blob/18e4232a450f320f44c651aa8c495f21c74d59ac/src/helperPlugin.js#L1
@@ -15,36 +15,32 @@ import {
 // a named import
 // https://github.com/babel/babel/blob/99f4f6c3b03c7f3f67cf1b9f1a21b80cfd5b0224/packages/babel-plugin-external-helpers/src/index.js
 
-export const babelPluginBabelHelpersAsJsenvImports = (api) => {
-  // https://github.com/babel/babel/tree/master/packages/babel-helper-module-imports
-  const { addDefault } = require("@babel/helper-module-imports")
-
-  api.assertVersion(7)
-
+export const babelPluginBabelHelpersAsJsenvImports = (
+  babel,
+  { getImportSpecifier },
+) => {
   return {
+    name: "babel-helper-as-jsenv-import",
     pre: (file) => {
       const cachedHelpers = {}
       file.set("helperGenerator", (name) => {
         // the list of possible helpers name
         // https://github.com/babel/babel/blob/99f4f6c3b03c7f3f67cf1b9f1a21b80cfd5b0224/packages/babel-helpers/src/helpers.js#L13
-
         if (!file.availableHelper(name)) {
           return undefined
         }
-
         if (cachedHelpers[name]) {
           return cachedHelpers[name]
         }
-
         const filePath = file.opts.filename
-        const babelHelperImportSpecifier =
-          babelHelperNameToImportSpecifier(name)
-
-        if (babelHelperNameFromUrl(fileSystemPathToUrl(filePath)) === name) {
+        const fileUrl = pathToFileURL(filePath).href
+        if (babelHelperNameFromUrl(fileUrl) === name) {
           return undefined
         }
-
-        const helper = addDefault(file.path, babelHelperImportSpecifier, {
+        const babelHelperImportSpecifier = getBabelHelperFileUrl(name)
+        const helper = injectImport({
+          programPath: file.path,
+          from: getImportSpecifier(babelHelperImportSpecifier),
           nameHint: `_${name}`,
           // disable interop, useless as we work only with js modules
           importedType: "es6",