@jsenv/core 27.0.0-alpha.2 → 27.0.0-alpha.20

package/src/execute/execute.js

@@ -3,8 +3,8 @@ import { Abort, raceProcessTeardownEvents } from "@jsenv/abort"
 import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
 import { createLogger } from "@jsenv/logger"
 
+import { getCorePlugins } from "@jsenv/core/src/plugins/plugins.js"
 import { createUrlGraph } from "@jsenv/core/src/omega/url_graph.js"
-import { getCorePlugins } from "@jsenv/core/src/omega/core_plugins.js"
 import { createKitchen } from "@jsenv/core/src/omega/kitchen.js"
 import { startOmegaServer } from "@jsenv/core/src/omega/omega_server.js"
 
@@ -26,9 +26,13 @@ export const execute = async ({
   runtime,
   runtimeParams,
 
-  plugins = [],
   scenario = "dev",
   sourcemaps = "inline",
+  plugins = [],
+  nodeEsmResolution,
+  fileSystemMagicResolution,
+  injectedGlobals,
+  transpilation,
 
   port,
   protocol,
@@ -53,6 +57,7 @@ export const execute = async ({
     })
   }
 
+  let resultTransformer = (result) => result
   runtimeParams = {
     rootDirectoryUrl,
     fileRelativeUrl,
@@ -65,9 +70,18 @@ export const execute = async ({
       logger,
       rootDirectoryUrl,
       urlGraph,
-      plugins: [...plugins, ...getCorePlugins()],
       scenario,
       sourcemaps,
+      plugins: [
+        ...plugins,
+        ...getCorePlugins({
+          scenario,
+          nodeEsmResolution,
+          fileSystemMagicResolution,
+          injectedGlobals,
+          transpilation,
+        }),
+      ],
     })
     const serverLogger = createLogger({ logLevel: "warn" })
     const server = await startOmegaServer({
@@ -91,9 +105,13 @@ export const execute = async ({
       ...runtimeParams,
       server,
     }
+    resultTransformer = (result) => {
+      result.server = server
+      return result
+    }
   }
 
-  const result = await run({
+  let result = await run({
     signal: executeOperation.signal,
     logger,
     allocatedMs,
@@ -105,6 +123,7 @@ export const execute = async ({
     runtime,
     runtimeParams,
   })
+  result = resultTransformer(result)
 
   try {
     if (result.status === "errored") {

package/src/execute/run.js

@@ -1,7 +1,6 @@
 import cuid from "cuid"
 import { Abort, raceCallbacks } from "@jsenv/abort"
 import { resolveUrl, writeFile } from "@jsenv/filesystem"
-import { createDetailedMessage } from "@jsenv/logger"
 
 export const run = async ({
   signal = new AbortController().signal,
@@ -18,9 +17,7 @@ export const run = async ({
   runtime,
   runtimeParams,
 }) => {
-  const onErrorRef = { current: () => {} }
   const onConsoleRef = { current: () => {} }
-  const onStopRef = { current: () => {} }
   const stopSignal = { notify: () => {} }
 
   let resultTransformer = (result) => result
@@ -105,7 +102,7 @@ export const run = async ({
   try {
     logger.debug(`run() ${runtimeLabel}`)
     runOperation.throwIfAborted()
-    const winnerPromise = new Promise((resolve, reject) => {
+    const winnerPromise = new Promise((resolve) => {
       raceCallbacks(
         {
           aborted: (cb) => {
@@ -114,35 +111,22 @@ export const run = async ({
               runOperation.signal.removeEventListener("abort", cb)
             }
           },
-          errored: (cb) => {
-            onErrorRef.current = (error) => {
-              logger.debug(
-                createDetailedMessage(`error during execution`, {
-                  ["error stack"]: error.stack,
-                  ["runtime"]: runtimeLabel,
-                }),
-              )
-              cb(error)
-            }
-          },
-          stopped: (cb) => {
-            onStopRef.current = cb
-          },
           runned: async (cb) => {
             try {
-              await runtime.run({
-                signal,
+              const result = await runtime.run({
+                signal: runOperation.signal,
                 logger,
                 ...runtimeParams,
                 keepRunning,
                 stopSignal,
-                onStop: (stopInfo) => onStopRef.current(stopInfo),
-                onError: (error) => onErrorRef.current(error),
                 onConsole: (log) => onConsoleRef.current(log),
-                onResult: cb,
               })
+              cb(result)
             } catch (e) {
-              reject(e)
+              cb({
+                status: "errored",
+                error: e,
+              })
             }
           },
         },
@@ -153,31 +137,16 @@ export const run = async ({
     if (winner.name === "aborted") {
       runOperation.throwIfAborted()
     }
-    if (winner.name === "errored") {
-      return await resultTransformer(
-        createErroredExecutionResult({
-          error: winner.data,
-        }),
-      )
-    }
-    if (winner.name === "stopped") {
-      return await resultTransformer(
-        createErroredExecutionResult({
-          error: new Error(`runtime stopped during execution`),
-        }),
-      )
-    }
-    onErrorRef.current = (error) => {
-      throw error
+    let result = winner.data
+    result = await resultTransformer(result)
+    return result
+  } catch (e) {
+    let result = {
+      status: "errored",
+      error: e,
     }
-    const result = winner.data
-    return await resultTransformer(result)
-  } catch (error) {
-    return await resultTransformer(
-      createErroredExecutionResult({
-        error,
-      }),
-    )
+    result = await resultTransformer(result)
+    return result
   } finally {
     await runOperation.end()
   }
@@ -200,9 +169,3 @@ const createTimedoutResult = () => {
     status: "timedout",
   }
 }
-const createErroredExecutionResult = ({ error }) => {
-  return {
-    status: "errored",
-    error,
-  }
-}

package/src/execute/runtimes/browsers/from_playwright.js

@@ -4,6 +4,7 @@ import {
   Abort,
   createCallbackListNotifiedOnce,
   raceProcessTeardownEvents,
+  raceCallbacks,
 } from "@jsenv/abort"
 import { moveUrl } from "@jsenv/filesystem"
 
@@ -42,10 +43,7 @@ export const createRuntimeFromPlaywright = ({
     stopAfterAllSignal,
     stopSignal,
     keepRunning,
-    onStop,
-    onError,
     onConsole,
-    onResult,
 
     executablePath,
     headful = false,
@@ -74,11 +72,27 @@ export const createRuntimeFromPlaywright = ({
     }
     const { browser, browserContext } = await browserAndContextPromise
     const closeBrowser = async () => {
+      const disconnected = browser.isConnected()
+        ? new Promise((resolve) => {
+            const disconnectedCallback = () => {
+              browser.removeListener("disconnected", disconnectedCallback)
+              resolve()
+            }
+            browser.on("disconnected", disconnectedCallback)
+          })
+        : Promise.resolve()
+      // for some reason without this 100ms timeout
+      // browser.close() never resolves (playwright does not like something)
+      await new Promise((resolve) => setTimeout(resolve, 100))
       try {
-        await stopBrowser(browser)
+        await browser.close()
       } catch (e) {
-        onError(e)
+        if (isTargetClosedError(e)) {
+          return
+        }
+        throw e
       }
+      await disconnected
     }
     const page = await browserContext.newPage()
     const closePage = async () => {
@@ -88,44 +102,9 @@ export const createRuntimeFromPlaywright = ({
         if (isTargetClosedError(e)) {
           return
         }
-        onError(e)
-      }
-    }
-    // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-disconnected
-    if (isBrowserDedicatedToExecution) {
-      browser.on("disconnected", async () => {
-        await cleanup("browser disconnected")
-        onStop({ reason: "browser disconnected" })
-      })
-      cleanupCallbackList.add(closePage)
-      cleanupCallbackList.add(closeBrowser)
-    } else {
-      const disconnectedCallback = async () => {
-        await cleanup("browser disconnected")
-        onError(new Error("browser disconnected during execution"))
-      }
-      browser.on("disconnected", disconnectedCallback)
-      page.on("close", () => {
-        onStop({ reason: "page closed" })
-      })
-      cleanupCallbackList.add(closePage)
-      const notifyPrevious = stopAfterAllSignal.notify
-      stopAfterAllSignal.notify = async () => {
-        await notifyPrevious()
-        browser.removeListener("disconnected", disconnectedCallback)
-        await closeBrowser()
+        throw e
       }
     }
-    const stopTrackingToNotify = trackPageToNotify(page, {
-      onError: (error) => {
-        error = transformErrorHook(error)
-        if (!ignoreErrorHook(error)) {
-          onError(error)
-        }
-      },
-      onConsole,
-    })
-    cleanupCallbackList.add(stopTrackingToNotify)
 
     let resultTransformer = (result) => result
     if (collectCoverage) {
@@ -169,30 +148,164 @@ export const createRuntimeFromPlaywright = ({
         resultTransformer = composeTransformer(
           resultTransformer,
           async (result) => {
-            result.coverage = generateCoverageForPage(result.namespace)
+            const scriptExecutionResults = result.namespace
+            if (scriptExecutionResults) {
+              result.coverage = generateCoverageForPage(scriptExecutionResults)
+            }
             return result
           },
         )
       }
     } else {
       resultTransformer = composeTransformer(resultTransformer, (result) => {
-        const { namespace: fileExecutionResultMap } = result
-        Object.keys(fileExecutionResultMap).forEach((fileRelativeUrl) => {
-          delete fileExecutionResultMap[fileRelativeUrl].coverage
-        })
+        const scriptExecutionResults = result.namespace
+        if (scriptExecutionResults) {
+          Object.keys(scriptExecutionResults).forEach((fileRelativeUrl) => {
+            delete scriptExecutionResults[fileRelativeUrl].coverage
+          })
+        }
         return result
       })
     }
     const fileClientUrl = new URL(fileRelativeUrl, `${server.origin}/`).href
-    await page.goto(fileClientUrl, { timeout: 0 })
-    let result = await getResult({
-      page,
-      rootDirectoryUrl,
-      server,
-      transformErrorHook,
+
+    // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-console
+    const removeConsoleListener = registerEvent({
+      object: page,
+      eventType: "console",
+      // https://github.com/microsoft/playwright/blob/master/docs/api.md#event-console
+      callback: async (consoleMessage) => {
+        onConsole({
+          type: consoleMessage.type(),
+          text: `${extractTextFromConsoleMessage(consoleMessage)}
+    `,
+        })
+      },
+    })
+    cleanupCallbackList.add(removeConsoleListener)
+    const winnerPromise = new Promise((resolve, reject) => {
+      raceCallbacks(
+        {
+          // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-error
+          error: (cb) => {
+            return registerEvent({
+              object: page,
+              eventType: "error",
+              callback: (error) => {
+                if (ignoreErrorHook(error)) {
+                  return
+                }
+                cb(transformErrorHook(error))
+              },
+            })
+          },
+          // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-pageerror
+          pageerror: (cb) => {
+            return registerEvent({
+              object: page,
+              eventType: "pageerror",
+              callback: (error) => {
+                if (ignoreErrorHook(error)) {
+                  return
+                }
+                cb(transformErrorHook(error))
+              },
+            })
+          },
+          closed: (cb) => {
+            // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-disconnected
+            if (isBrowserDedicatedToExecution) {
+              browser.on("disconnected", async () => {
+                cb({ reason: "browser disconnected" })
+              })
+              cleanupCallbackList.add(closePage)
+              cleanupCallbackList.add(closeBrowser)
+            } else {
+              const disconnectedCallback = async () => {
+                throw new Error("browser disconnected during execution")
+              }
+              browser.on("disconnected", disconnectedCallback)
+              page.on("close", () => {
+                cb({ reason: "page closed" })
+              })
+              cleanupCallbackList.add(closePage)
+              const notifyPrevious = stopAfterAllSignal.notify
+              stopAfterAllSignal.notify = async () => {
+                await notifyPrevious()
+                browser.removeListener("disconnected", disconnectedCallback)
+                await closeBrowser()
+              }
+            }
+          },
+          response: async (cb) => {
+            try {
+              await page.goto(fileClientUrl, { timeout: 0 })
+              const result = await page.evaluate(
+                /* eslint-disable no-undef */
+                /* istanbul ignore next */
+                () => {
+                  return window.__html_supervisor__.getScriptExecutionResults()
+                },
+                /* eslint-enable no-undef */
+              )
+              const { status, scriptExecutionResults } = result
+              if (status === "errored") {
+                const { exceptionSource } = result
+                const error = evalException(exceptionSource, {
+                  rootDirectoryUrl,
+                  server,
+                  transformErrorHook,
+                })
+                cb({
+                  status: "errored",
+                  error,
+                  namespace: scriptExecutionResults,
+                })
+              } else {
+                cb({
+                  status: "completed",
+                  namespace: scriptExecutionResults,
+                })
+              }
+            } catch (e) {
+              reject(e)
+            }
+          },
+        },
+        resolve,
+      )
     })
-    result = await resultTransformer(result)
-    onResult(result)
+
+    const getResult = async () => {
+      const winner = await winnerPromise
+      if (winner.name === "error" || winner.name === "pageerror") {
+        const error = winner.data
+        return {
+          status: "errored",
+          error,
+        }
+      }
+      if (winner.name === "closed") {
+        return {
+          status: "errored",
+          error: isBrowserDedicatedToExecution
+            ? new Error(`browser disconnected during execution`)
+            : new Error(`page closed during execution`),
+        }
+      }
+      return winner.data
+    }
+    let result
+
+    try {
+      result = await getResult()
+      result = await resultTransformer(result)
+    } catch (e) {
+      result = {
+        status: "errored",
+        error: e,
+      }
+    }
     if (keepRunning) {
       stopSignal.notify = cleanup
     } else {
@@ -214,40 +327,6 @@ export const createRuntimeFromPlaywright = ({
   return runtime
 }
 
-const getResult = async ({
-  page,
-  rootDirectoryUrl,
-  server,
-  transformErrorHook,
-}) => {
-  const result = await page.evaluate(
-    /* eslint-disable no-undef */
-    /* istanbul ignore next */
-    () => {
-      return window.__html_supervisor__.getScriptExecutionResults()
-    },
-    /* eslint-enable no-undef */
-  )
-  const { status, scriptExecutionResults } = result
-  if (status === "errored") {
-    const { exceptionSource } = result
-    const error = evalException(exceptionSource, {
-      rootDirectoryUrl,
-      server,
-      transformErrorHook,
-    })
-    return {
-      status: "errored",
-      error,
-      namespace: scriptExecutionResults,
-    }
-  }
-  return {
-    status: "completed",
-    namespace: scriptExecutionResults,
-  }
-}
-
 const generateCoverageForPage = (scriptExecutionResults) => {
   let istanbulCoverageComposed = null
   Object.keys(scriptExecutionResults).forEach((fileRelativeUrl) => {
@@ -262,31 +341,6 @@ const generateCoverageForPage = (scriptExecutionResults) => {
   return istanbulCoverageComposed
 }
 
-const stopBrowser = async (browser) => {
-  const disconnected = browser.isConnected()
-    ? new Promise((resolve) => {
-        const disconnectedCallback = () => {
-          browser.removeListener("disconnected", disconnectedCallback)
-          resolve()
-        }
-        browser.on("disconnected", disconnectedCallback)
-      })
-    : Promise.resolve()
-
-  // for some reason without this 100ms timeout
-  // browser.close() never resolves (playwright does not like something)
-  await new Promise((resolve) => setTimeout(resolve, 100))
-  try {
-    await browser.close()
-  } catch (e) {
-    if (isTargetClosedError(e)) {
-      return
-    }
-    throw e
-  }
-  await disconnected
-}
-
 const launchBrowserUsingPlaywright = async ({
   signal,
   browserName,
@@ -366,39 +420,6 @@ const isTargetClosedError = (error) => {
   return false
 }
 
-const trackPageToNotify = (page, { onError, onConsole }) => {
-  // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-error
-  const removeErrorListener = registerEvent({
-    object: page,
-    eventType: "error",
-    callback: onError,
-  })
-  // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-pageerror
-  const removePageErrorListener = registerEvent({
-    object: page,
-    eventType: "pageerror",
-    callback: onError,
-  })
-  // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-console
-  const removeConsoleListener = registerEvent({
-    object: page,
-    eventType: "console",
-    // https://github.com/microsoft/playwright/blob/master/docs/api.md#event-console
-    callback: async (consoleMessage) => {
-      onConsole({
-        type: consoleMessage.type(),
-        text: `${extractTextFromConsoleMessage(consoleMessage)}
-`,
-      })
-    },
-  })
-  return () => {
-    removeErrorListener()
-    removePageErrorListener()
-    removeConsoleListener()
-  }
-}
-
 const composeTransformer = (previousTransformer, transformer) => {
   return async (value) => {
     const transformedValue = await previousTransformer(value)