@jsenv/core 27.4.0 → 27.5.0

package/src/omega/omega_server.js

@@ -1,18 +1,11 @@
 import {
   jsenvAccessControlAllowedHeaders,
   startServer,
-  composeServices,
-  pluginServerTiming,
-  pluginRequestWaitingCheck,
-  pluginCORS,
+  jsenvServiceCORS,
+  jsenvServiceErrorHandler,
 } from "@jsenv/server"
 import { convertFileSystemErrorToResponseProperties } from "@jsenv/server/src/internal/convertFileSystemErrorToResponseProperties.js"
-import {
-  createCallbackListNotifiedOnce,
-  createCallbackList,
-} from "@jsenv/abort"
 
-import { createSSEService } from "@jsenv/core/src/helpers/event_source/sse_service.js"
 import { createFileService } from "./server/file_service.js"
 
 export const startOmegaServer = async ({
@@ -23,76 +16,31 @@ export const startOmegaServer = async ({
   http2 = protocol === "https",
   privateKey,
   certificate,
-  listenAnyIp,
-  ip,
+  acceptAnyIp,
+  host,
   port = 0,
   keepProcessAlive = false,
   onStop = () => {},
-  serverPlugins,
-  services,
+  services = [],
 
   rootDirectoryUrl,
   scenario,
-  urlGraph,
-  kitchen,
-}) => {
-  const serverStopCallbackList = createCallbackListNotifiedOnce()
+  runtimeCompat,
 
-  const serverEventCallbackList = createCallbackList()
-  const sseService = createSSEService({ serverEventCallbackList })
-  const sendServerEvent = ({ type, data }) => {
-    serverEventCallbackList.notify({
-      type,
-      data: JSON.stringify(data),
-    })
-  }
-
-  kitchen.pluginController.addHook("registerServerEvents")
-  kitchen.pluginController.callHooks(
-    "registerServerEvents",
-    { sendServerEvent },
-    {
-      rootDirectoryUrl,
-      urlGraph,
-      scenario,
-    },
-    () => {},
-  )
-
-  const sendServerErrorEvent = (event) => {
-    // setTimeout display first the error
-    // dispatched on window by browser
-    // then display the jsenv error
-    setTimeout(() => {
-      sendServerEvent(event)
-    }, 10)
-  }
-
-  const coreServices = {
-    "service:server_events": (request) => {
-      const { accept } = request.headers
-      if (accept && accept.includes("text/event-stream")) {
-        const room = sseService.getOrCreateSSERoom(request)
-        return room.join(request)
-      }
-      return null
-    },
-    "service:file": createFileService({
-      rootDirectoryUrl,
-      urlGraph,
-      kitchen,
-      scenario,
-      onFileNotFound: (data) => {
-        sendServerErrorEvent({ type: "file_not_found", data })
-      },
-      onParseError: (data) => {
-        sendServerErrorEvent({ type: "parse_error", data })
-      },
-      onUnexpectedError: (data) => {
-        sendServerErrorEvent({ type: "unexpected_error", data })
-      },
-    }),
-  }
+  plugins,
+  urlAnalysis,
+  htmlSupervisor,
+  nodeEsmResolution,
+  fileSystemMagicResolution,
+  transpilation,
+  clientAutoreload,
+  clientFiles,
+  cooldownBetweenFileEvents,
+  explorer,
+  sourcemaps,
+  writeGeneratedFiles,
+}) => {
+  const serverStopCallbacks = []
   const server = await startServer({
     signal,
     stopOnExit: false,
@@ -106,12 +54,12 @@ export const startOmegaServer = async ({
     http2,
     certificate,
     privateKey,
-    listenAnyIp,
-    ip,
+    acceptAnyIp,
+    host,
     port,
-    plugins: {
-      ...serverPlugins,
-      ...pluginCORS({
+    requestWaitingMs: 60_1000,
+    services: [
+      jsenvServiceCORS({
         accessControlAllowRequestOrigin: true,
         accessControlAllowRequestMethod: true,
         accessControlAllowRequestHeaders: true,
@@ -120,62 +68,83 @@ export const startOmegaServer = async ({
           "x-jsenv-execution-id",
         ],
         accessControlAllowCredentials: true,
+        timingAllowOrigin: true,
       }),
-      ...pluginServerTiming(),
-      ...pluginRequestWaitingCheck({
-        requestWaitingMs: 60 * 1000,
-      }),
-    },
-    sendErrorDetails: true,
-    errorToResponse: (error, { request }) => {
-      const getResponseForError = () => {
-        if (error && error.asResponse) {
-          return error.asResponse()
-        }
-        if (error && error.statusText === "Unexpected directory operation") {
+      ...services,
+      {
+        name: "jsenv:omega_file_service",
+        handleRequest: createFileService({
+          signal,
+          logLevel,
+          serverStopCallbacks,
+
+          rootDirectoryUrl,
+          scenario,
+          runtimeCompat,
+
+          plugins,
+          urlAnalysis,
+          htmlSupervisor,
+          nodeEsmResolution,
+          fileSystemMagicResolution,
+          transpilation,
+          clientAutoreload,
+          clientFiles,
+          cooldownBetweenFileEvents,
+          explorer,
+          sourcemaps,
+          writeGeneratedFiles,
+        }),
+      },
+      {
+        name: "jsenv:omega_error_handler",
+        handleError: (error) => {
+          const getResponseForError = () => {
+            if (error && error.asResponse) {
+              return error.asResponse()
+            }
+            if (
+              error &&
+              error.statusText === "Unexpected directory operation"
+            ) {
+              return {
+                status: 403,
+              }
+            }
+            return convertFileSystemErrorToResponseProperties(error)
+          }
+          const response = getResponseForError()
+          if (!response) {
+            return null
+          }
+          const body = JSON.stringify({
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+            body: response.body,
+          })
           return {
-            status: 403,
+            status: 200,
+            headers: {
+              "content-type": "application/json",
+              "content-length": Buffer.byteLength(body),
+            },
+            body,
           }
-        }
-        return convertFileSystemErrorToResponseProperties(error)
-      }
-      const response = getResponseForError()
-      if (!response) {
-        return null
-      }
-      const isInspectRequest = new URL(
-        request.ressource,
-        request.origin,
-      ).searchParams.has("__inspect__")
-      if (!isInspectRequest) {
-        return response
-      }
-      const body = JSON.stringify({
-        status: response.status,
-        statusText: response.statusText,
-        headers: response.headers,
-        body: response.body,
-      })
-      return {
-        status: 200,
-        headers: {
-          "content-type": "application/json",
-          "content-length": Buffer.byteLength(body),
         },
-        body,
-      }
-    },
-    requestToResponse: composeServices({
-      ...services,
-      ...coreServices,
-    }),
+      },
+      // default error handling
+      jsenvServiceErrorHandler({
+        sendErrorDetails: true,
+      }),
+    ],
     onStop: (reason) => {
       onStop()
-      sseService.destroy()
-      serverStopCallbackList.notify(reason)
+      serverStopCallbacks.forEach((serverStopCallback) => {
+        serverStopCallback(reason)
+      })
+      serverStopCallbacks.length = 0
     },
   })
-  return {
-    ...server,
-  }
+  return server
 }

package/src/omega/server/file_service.js

@@ -3,46 +3,242 @@ import {
   serveDirectory,
   composeTwoResponses,
 } from "@jsenv/server"
+import { registerDirectoryLifecycle } from "@jsenv/filesystem"
 import { urlIsInsideOf, moveUrl } from "@jsenv/urls"
+import { URL_META } from "@jsenv/url-meta"
 
+import { getCorePlugins } from "@jsenv/core/src/plugins/plugins.js"
+import { createUrlGraph } from "@jsenv/core/src/omega/url_graph.js"
+import { createKitchen } from "@jsenv/core/src/omega/kitchen.js"
+import { createServerEventsDispatcher } from "@jsenv/core/src/plugins/server_events/server_events_dispatcher.js"
+import { jsenvPluginServerEventsClientInjection } from "@jsenv/core/src/plugins/server_events/jsenv_plugin_server_events_client_injection.js"
 import { parseUserAgentHeader } from "./user_agent.js"
 
 export const createFileService = ({
+  signal,
+  logLevel,
+  serverStopCallbacks,
+
   rootDirectoryUrl,
-  urlGraph,
-  kitchen,
   scenario,
-  onParseError,
-  onFileNotFound,
-  onUnexpectedError,
+  runtimeCompat,
+
+  plugins,
+  urlAnalysis,
+  htmlSupervisor,
+  nodeEsmResolution,
+  fileSystemMagicResolution,
+  transpilation,
+  clientAutoreload,
+  clientFiles,
+  cooldownBetweenFileEvents,
+  explorer,
+  sourcemaps,
+  writeGeneratedFiles,
 }) => {
-  kitchen.pluginController.addHook("serve")
-  kitchen.pluginController.addHook("augmentResponse")
-  const serveContext = {
-    rootDirectoryUrl,
-    urlGraph,
-    scenario,
+  const jsenvDirectoryUrl = new URL(".jsenv/", rootDirectoryUrl).href
+  const onErrorWhileServingFileCallbacks = []
+  const onErrorWhileServingFile = (data) => {
+    onErrorWhileServingFileCallbacks.forEach(
+      (onErrorWhileServingFileCallback) => {
+        onErrorWhileServingFileCallback(data)
+      },
+    )
+  }
+
+  const clientFileChangeCallbackList = []
+  const clientFilesPruneCallbackList = []
+  const clientFileChangeCallback = ({ relativeUrl, event }) => {
+    const url = new URL(relativeUrl, rootDirectoryUrl).href
+    clientFileChangeCallbackList.forEach((callback) => {
+      callback({ url, event })
+    })
   }
-  const augmentResponseContext = {
-    rootDirectoryUrl,
-    urlGraph,
-    scenario,
+  const clientFilePatterns = {
+    ...clientFiles,
+    ".jsenv/": false,
+  }
+
+  if (scenario === "dev") {
+    const stopWatchingClientFiles = registerDirectoryLifecycle(
+      rootDirectoryUrl,
+      {
+        watchPatterns: clientFilePatterns,
+        cooldownBetweenFileEvents,
+        keepProcessAlive: false,
+        recursive: true,
+        added: ({ relativeUrl }) => {
+          clientFileChangeCallback({ event: "added", relativeUrl })
+        },
+        updated: ({ relativeUrl }) => {
+          clientFileChangeCallback({ event: "modified", relativeUrl })
+        },
+        removed: ({ relativeUrl }) => {
+          clientFileChangeCallback({ event: "removed", relativeUrl })
+        },
+      },
+    )
+    serverStopCallbacks.push(stopWatchingClientFiles)
   }
 
-  const getResponse = async (request) => {
+  const contextCache = new Map()
+  const getOrCreateContext = (request) => {
+    const { runtimeName, runtimeVersion } = parseUserAgentHeader(
+      request.headers["user-agent"],
+    )
+    const runtimeId = `${runtimeName}@${runtimeVersion}`
+    const existingContext = contextCache.get(runtimeId)
+    if (existingContext) {
+      return existingContext
+    }
+    const watchAssociations = URL_META.resolveAssociations(
+      { watch: clientFilePatterns },
+      rootDirectoryUrl,
+    )
+    const urlGraph = createUrlGraph({
+      clientFileChangeCallbackList,
+      clientFilesPruneCallbackList,
+      onCreateUrlInfo: (urlInfo) => {
+        const { watch } = URL_META.applyAssociations({
+          url: urlInfo.url,
+          associations: watchAssociations,
+        })
+        urlInfo.isValid = () => watch
+      },
+      includeOriginalUrls: scenario === "dev",
+    })
+    const kitchen = createKitchen({
+      signal,
+      logLevel,
+      rootDirectoryUrl,
+      scenario,
+      runtimeCompat,
+      urlGraph,
+      plugins: [
+        ...plugins,
+        ...getCorePlugins({
+          rootDirectoryUrl,
+          scenario,
+          runtimeCompat,
+
+          urlAnalysis,
+          htmlSupervisor,
+          nodeEsmResolution,
+          fileSystemMagicResolution,
+          transpilation,
+
+          clientAutoreload,
+          clientFileChangeCallbackList,
+          clientFilesPruneCallbackList,
+          explorer,
+        }),
+      ],
+      sourcemaps,
+      writeGeneratedFiles,
+    })
+    serverStopCallbacks.push(() => {
+      kitchen.pluginController.callHooks("destroy", kitchen.kitchenContext)
+    })
+    server_events: {
+      const allServerEvents = {}
+      kitchen.pluginController.plugins.forEach((plugin) => {
+        const { serverEvents } = plugin
+        if (serverEvents) {
+          Object.keys(serverEvents).forEach((serverEventName) => {
+            // we could throw on serverEvent name conflict
+            // we could throw if serverEvents[serverEventName] is not a function
+            allServerEvents[serverEventName] = serverEvents[serverEventName]
+          })
+        }
+      })
+      const serverEventNames = Object.keys(allServerEvents)
+      if (serverEventNames.length > 0) {
+        const serverEventsDispatcher = createServerEventsDispatcher()
+        serverStopCallbacks.push(() => {
+          serverEventsDispatcher.destroy()
+        })
+        Object.keys(allServerEvents).forEach((serverEventName) => {
+          allServerEvents[serverEventName]({
+            rootDirectoryUrl,
+            urlGraph,
+            scenario,
+            sendServerEvent: (data) => {
+              serverEventsDispatcher.dispatch({
+                type: serverEventName,
+                data,
+              })
+            },
+          })
+        })
+        onErrorWhileServingFileCallbacks.push((data) => {
+          serverEventsDispatcher.dispatchToRoomsMatching(
+            {
+              type: "error_while_serving_file",
+              data,
+            },
+            (room) => {
+              // send only to page depending on this file
+              const errorFileUrl = data.url
+              const roomEntryPointUrl = new URL(
+                room.request.ressource.slice(1),
+                rootDirectoryUrl,
+              ).href
+              const isErrorRelatedToEntryPoint = Boolean(
+                urlGraph.findDependent(errorFileUrl, (dependentUrlInfo) => {
+                  return dependentUrlInfo.url === roomEntryPointUrl
+                }),
+              )
+              return isErrorRelatedToEntryPoint
+            },
+          )
+        })
+        // "unshift" because serve must come first to catch event source client request
+        kitchen.pluginController.unshiftPlugin({
+          name: "jsenv:provide_server_events",
+          serve: (request) => {
+            const { accept } = request.headers
+            if (accept && accept.includes("text/event-stream")) {
+              const room = serverEventsDispatcher.addRoom(request)
+              return room.join(request)
+            }
+            return null
+          },
+        })
+        // "push" so that event source client connection can be put as early as possible in html
+        kitchen.pluginController.pushPlugin(
+          jsenvPluginServerEventsClientInjection(),
+        )
+      }
+    }
+
+    const context = {
+      rootDirectoryUrl,
+      scenario,
+      runtimeName,
+      runtimeVersion,
+      urlGraph,
+      kitchen,
+    }
+    contextCache.set(runtimeId, context)
+    return context
+  }
+
+  return async (request) => {
     // serve file inside ".jsenv" directory
     const requestFileUrl = new URL(request.ressource.slice(1), rootDirectoryUrl)
       .href
-    if (urlIsInsideOf(requestFileUrl, kitchen.jsenvDirectoryUrl)) {
+    if (urlIsInsideOf(requestFileUrl, jsenvDirectoryUrl)) {
       return fetchFileSystem(requestFileUrl, {
         headers: request.headers,
       })
     }
+    const { runtimeName, runtimeVersion, urlGraph, kitchen } =
+      getOrCreateContext(request)
     const responseFromPlugin =
       await kitchen.pluginController.callAsyncHooksUntil(
         "serve",
         request,
-        serveContext,
+        kitchen.kitchenContext,
       )
     if (responseFromPlugin) {
       return responseFromPlugin
@@ -67,8 +263,12 @@ export const createFileService = ({
     if (
       ifNoneMatch &&
       urlInfo.contentEtag === ifNoneMatch &&
-      // - isValid is true by default
-      // - isValid can be overriden by plugins such as cjs_to_esm
+      // urlInfo.isValid
+      // - is false by default because there must be some logic capable
+      //   to invalidate the url (otherwise server would return 304 forever)
+      // - is set to a function returning true if the file is watched
+      //   in start_dev_server.js
+      // - is set to a custom function by cjs_to_esm in compiled_file_cache.js
       urlInfo.isValid()
     ) {
       return {
@@ -95,9 +295,6 @@ export const createFileService = ({
         urlInfo.dependsOnPackageJson = false
         urlInfo.timing = {}
       }
-      const { runtimeName, runtimeVersion } = parseUserAgentHeader(
-        request.headers["user-agent"],
-      )
       await kitchen.cook(urlInfo, {
         request,
         reference,
@@ -129,7 +326,7 @@ export const createFileService = ({
       kitchen.pluginController.callHooks(
         "augmentResponse",
         { reference, urlInfo },
-        augmentResponseContext,
+        kitchen.kitchenContext,
         (returnValue) => {
           response = composeTwoResponses(response, returnValue)
         },
@@ -138,13 +335,15 @@ export const createFileService = ({
     } catch (e) {
       const code = e.code
       if (code === "PARSE_ERROR") {
-        onParseError({
-          reason: e.reason,
-          message: e.message,
+        onErrorWhileServingFile({
+          requestedRessource: request.ressource,
+          code: "PARSE_ERROR",
+          message: e.reason,
           url: e.url,
-          line: e.line,
-          column: e.column,
-          contentFrame: e.contentFrame,
+          traceUrl: e.traceUrl,
+          traceLine: e.traceLine,
+          traceColumn: e.traceColumn,
+          traceMessage: e.traceMessage,
         })
         return {
           url: reference.url,
@@ -176,13 +375,18 @@ export const createFileService = ({
         }
       }
       if (code === "NOT_FOUND") {
-        onFileNotFound({
-          reason: e.reason,
-          message: e.message,
+        onErrorWhileServingFile({
+          requestedRessource: request.ressource,
+          isFaviconAutoRequest:
+            request.ressource === "/favicon.ico" &&
+            reference.type === "http_request",
+          code: "NOT_FOUND",
+          message: e.reason,
           url: e.url,
-          line: e.line,
-          column: e.column,
-          contentFrame: e.contentFrame,
+          traceUrl: e.traceUrl,
+          traceLine: e.traceLine,
+          traceColumn: e.traceColumn,
+          traceMessage: e.traceMessage,
         })
         return {
           url: reference.url,
@@ -191,14 +395,15 @@ export const createFileService = ({
           statusMessage: e.message,
         }
       }
-      onUnexpectedError({
-        reason: e.reason,
-        message: e.message,
+      onErrorWhileServingFile({
+        requestedRessource: request.ressource,
+        code: "UNEXPECTED",
         stack: e.stack,
         url: e.url,
-        line: e.line,
-        column: e.column,
-        contentFrame: e.contentFrame,
+        traceUrl: e.traceUrl,
+        traceLine: e.traceLine,
+        traceColumn: e.traceColumn,
+        traceMessage: e.traceMessage,
       })
       return {
         url: reference.url,
@@ -208,10 +413,6 @@ export const createFileService = ({
       }
     }
   }
-  return async (request) => {
-    let response = await getResponse(request)
-    return response
-  }
 }
 
 const inferParentFromRequest = (request, rootDirectoryUrl) => {