@jsenv/core 27.0.0-alpha.9 → 27.0.0-alpha.92

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 {
+  Abort,
+  raceCallbacks,
+  createCallbackListNotifiedOnce,
+} from "@jsenv/abort"
+import { uneval } from "@jsenv/uneval"
+import { urlToFileSystemPath } from "@jsenv/urls"
+import { createDetailedMessage } from "@jsenv/log"
+import { memoize } from "@jsenv/utils/src/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,276 @@ 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(
+      {
+        aborted: (cb) => {
+          return actionOperation.addAbortCallback(cb)
+        },
+        // 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 === "aborted") {
+      return {
+        status: "aborted",
+      }
+    }
+    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/helpers/command/command.js

@@ -0,0 +1,73 @@
+import { exec } from "node:child_process"
+import { createDetailedMessage, createLogger, UNICODE } from "@jsenv/log"
+
+export const executeCommand = (
+  command,
+  {
+    logLevel = "info",
+    signal = new AbortController().signal,
+    onStdout = () => {},
+    onStderr = () => {},
+    cwd,
+    env,
+    timeout,
+  } = {},
+) => {
+  const logger = createLogger({ logLevel })
+
+  return new Promise((resolve, reject) => {
+    logger.debug(`${UNICODE.COMMAND} ${command}`)
+    const commandProcess = exec(command, {
+      signal,
+      cwd:
+        cwd && typeof cwd === "string" && cwd.startsWith("file:")
+          ? new URL(cwd)
+          : cwd,
+      env,
+      timeout,
+      silent: true,
+    })
+    commandProcess.on("error", (error) => {
+      if (error && error.code === "ETIMEDOUT") {
+        logger.error(`timeout after ${timeout} ms`)
+        reject(error)
+      } else {
+        reject(error)
+      }
+    })
+    const stdoutDatas = []
+    commandProcess.stdout.on("data", (data) => {
+      stdoutDatas.push(data)
+      logger.debug(data)
+      onStderr(data)
+    })
+    let stderrDatas = []
+    commandProcess.stderr.on("data", (data) => {
+      stderrDatas.push(data)
+      logger.debug(data)
+      onStdout(data)
+    })
+    if (commandProcess.stdin) {
+      commandProcess.stdin.on("error", (error) => {
+        reject(error)
+      })
+    }
+    commandProcess.on("exit", (exitCode, signal) => {
+      if (signal) {
+        reject(new Error(`killed with ${signal}`))
+      }
+      if (exitCode) {
+        reject(
+          new Error(
+            createDetailedMessage(`failed with exit code ${exitCode}`, {
+              "command stderr": stderrDatas.join(""),
+              // "command stdout": stdoutDatas.join(""),
+            }),
+          ),
+        )
+        return
+      }
+      resolve({ exitCode, signal })
+    })
+  })
+}

package/src/{dev/plugins/autoreload/client/event_source_connection.js → helpers/event_source/event_source.js}

@@ -1,3 +1,5 @@
+/* eslint-env browser */
+
 export const createEventSourceConnection = (
   eventSourceUrl,
   events = {},

package/src/helpers/event_source/sse_service.js

@@ -0,0 +1,53 @@
+import { createSSERoom } from "@jsenv/server"
+import { createCallbackListNotifiedOnce } from "@jsenv/abort"
+
+export const createSSEService = ({ serverEventCallbackList }) => {
+  const destroyCallbackList = createCallbackListNotifiedOnce()
+
+  const cache = []
+  const sseRoomLimit = 100
+  const getOrCreateSSERoom = (request) => {
+    const htmlFileRelativeUrl = request.ressource.slice(1)
+    const cacheEntry = cache.find(
+      (cacheEntryCandidate) =>
+        cacheEntryCandidate.htmlFileRelativeUrl === htmlFileRelativeUrl,
+    )
+    if (cacheEntry) {
+      return cacheEntry.sseRoom
+    }
+    const sseRoom = createSSERoom({
+      retryDuration: 2000,
+      historyLength: 100,
+      welcomeEventEnabled: true,
+      effect: () => {
+        return serverEventCallbackList.add((event) => {
+          sseRoom.sendEvent(event)
+        })
+      },
+    })
+    const removeSSECleanupCallback = destroyCallbackList.add(() => {
+      removeSSECleanupCallback()
+      sseRoom.close()
+    })
+    cache.push({
+      htmlFileRelativeUrl,
+      sseRoom,
+      cleanup: () => {
+        removeSSECleanupCallback()
+        sseRoom.close()
+      },
+    })
+    if (cache.length >= sseRoomLimit) {
+      const firstCacheEntry = cache.shift()
+      firstCacheEntry.cleanup()
+    }
+    return sseRoom
+  }
+
+  return {
+    getOrCreateSSERoom,
+    destroy: () => {
+      destroyCallbackList.notify()
+    },
+  }
+}

package/src/helpers/worker_reload.js

@@ -0,0 +1,57 @@
+import { fileURLToPath } from "node:url"
+import { Worker, workerData } from "node:worker_threads"
+
+// https://nodejs.org/api/worker_threads.html
+export const createReloadableWorker = (workerFileUrl, options = {}) => {
+  const workerFilePath = fileURLToPath(workerFileUrl)
+  const isPrimary = !workerData || workerData.workerFilePath !== workerFilePath
+  let worker
+
+  const terminate = async () => {
+    if (worker) {
+      let _worker = worker
+      worker = null
+      const exitPromise = new Promise((resolve) => {
+        _worker.once("exit", resolve)
+      })
+      _worker.terminate()
+      await exitPromise
+    }
+  }
+
+  const load = async () => {
+    if (!isPrimary) {
+      throw new Error(`worker can be loaded from primary file only`)
+    }
+    worker = new Worker(workerFilePath, {
+      ...options,
+      workerData: {
+        ...options.workerData,
+        workerFilePath,
+      },
+    })
+
+    worker.once("error", (error) => {
+      console.error(error)
+    })
+    await new Promise((resolve) => {
+      worker.once("online", resolve)
+    })
+    worker.once("exit", () => {
+      worker = null
+    })
+    return worker
+  }
+
+  const reload = async () => {
+    await terminate()
+    await load()
+  }
+
+  return {
+    isPrimary,
+    load,
+    reload,
+    terminate,
+  }
+}

package/src/main.js

@@ -0,0 +1,27 @@
+// dev
+export { startDevServer } from "./dev/start_dev_server.js"
+// test
+export {
+  executeTestPlan,
+  defaultCoverageConfig,
+} from "./test/execute_test_plan.js"
+export {
+  chromium,
+  chromiumIsolatedTab,
+} from "./execute/runtimes/browsers/chromium.js"
+export {
+  firefox,
+  firefoxIsolatedTab,
+} from "./execute/runtimes/browsers/firefox.js"
+export {
+  webkit,
+  webkitIsolatedTab,
+} from "./execute/runtimes/browsers/webkit.js"
+export { nodeProcess } from "./execute/runtimes/node/node_process.js"
+// build
+export { build } from "./build/build.js"
+export { startBuildServer } from "./build/start_build_server.js"
+
+// advanced
+export { execute } from "./execute/execute.js"
+export { jsenvPluginInjectGlobals } from "./plugins/inject_globals/jsenv_plugin_inject_globals.js"

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

@@ -9,6 +9,15 @@ export const featureCompats = {
     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 featureCompats = {
     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: {
@@ -71,6 +83,14 @@ export const featureCompats = {
     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",
+    opera: "67",
+    android: "80",
+  },
+  worker_importmap: {},
   service_worker: {
     edge: "17",
     firefox: "44",
@@ -86,14 +106,17 @@ export const featureCompats = {
     opera: "67",
     android: "80",
   },
-  // https://developer.mozilla.org/en-US/docs/Web/API/Worker/Worker#browser_compatibility
-  worker_type_module: {
+  shared_worker: {
+    chrome: "4",
+    edge: "79",
+    firefox: "29",
+    opera: "10.6",
+  },
+  shared_worker_type_module: {
     chrome: "80",
     edge: "80",
     opera: "67",
-    android: "80",
   },
-  worker_importmap: {},
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/globalThis#browser_compatibility
   global_this: {
     edge: "79",