@jsenv/core 28.1.2 → 28.2.1

package/src/omega/server/file_service.js

@@ -1,9 +1,10 @@
+import { readFileSync } from "node:fs"
 import {
   fetchFileSystem,
   serveDirectory,
   composeTwoResponses,
 } from "@jsenv/server"
-import { registerDirectoryLifecycle } from "@jsenv/filesystem"
+import { registerDirectoryLifecycle, bufferToEtag } from "@jsenv/filesystem"
 import { urlIsInsideOf, moveUrl } from "@jsenv/urls"
 import { URL_META } from "@jsenv/url-meta"
 
@@ -42,38 +43,41 @@ export const createFileService = ({
 
   const clientFileChangeCallbackList = []
   const clientFilesPruneCallbackList = []
-  const clientFileChangeCallback = ({ relativeUrl, event }) => {
-    const url = new URL(relativeUrl, rootDirectoryUrl).href
-    clientFileChangeCallbackList.forEach((callback) => {
-      callback({ url, event })
-    })
-  }
   const clientFilePatterns = {
     ...clientFiles,
     ".jsenv/": false,
   }
 
-  if (scenarios.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 onFileChange = (url) => {
+    clientFileChangeCallbackList.forEach((callback) => {
+      callback(url)
+    })
   }
+  const stopWatchingClientFiles = registerDirectoryLifecycle(rootDirectoryUrl, {
+    watchPatterns: clientFilePatterns,
+    cooldownBetweenFileEvents,
+    keepProcessAlive: false,
+    recursive: true,
+    added: ({ relativeUrl }) => {
+      onFileChange({
+        url: new URL(relativeUrl, rootDirectoryUrl).href,
+        event: "added",
+      })
+    },
+    updated: ({ relativeUrl }) => {
+      onFileChange({
+        url: new URL(relativeUrl, rootDirectoryUrl).href,
+        event: "modified",
+      })
+    },
+    removed: ({ relativeUrl }) => {
+      onFileChange({
+        url: new URL(relativeUrl, rootDirectoryUrl).href,
+        event: "removed",
+      })
+    },
+  })
+  serverStopCallbacks.push(stopWatchingClientFiles)
 
   const contextCache = new Map()
   const getOrCreateContext = (request) => {
@@ -89,17 +93,12 @@ export const createFileService = ({
       { watch: clientFilePatterns },
       rootDirectoryUrl,
     )
-    const urlGraph = createUrlGraph({
-      clientFileChangeCallbackList,
-      clientFilesPruneCallbackList,
-      onCreateUrlInfo: (urlInfo) => {
-        const { watch } = URL_META.applyAssociations({
-          url: urlInfo.url,
-          associations: watchAssociations,
-        })
-        urlInfo.isValid = () => watch
-      },
-      includeOriginalUrls: scenarios.dev,
+    const urlGraph = createUrlGraph()
+    clientFileChangeCallbackList.push(({ url }) => {
+      const urlInfo = urlGraph.getUrlInfo(url)
+      if (urlInfo) {
+        urlGraph.considerModified(urlInfo)
+      }
     })
     const kitchen = createKitchen({
       signal,
@@ -133,7 +132,51 @@ export const createFileService = ({
       sourcemapsSourcesProtocol,
       sourcemapsSourcesContent,
       writeGeneratedFiles,
+      outDirectoryUrl: scenarios.dev
+        ? `${rootDirectoryUrl}.jsenv/${runtimeName}@${runtimeVersion}/`
+        : `${rootDirectoryUrl}.jsenv/${
+            scenarios.test ? "test" : "build"
+          }/${runtimeName}@${runtimeVersion}/`,
     })
+    urlGraph.createUrlInfoCallbackRef.current = (urlInfo) => {
+      const { watch } = URL_META.applyAssociations({
+        url: urlInfo.url,
+        associations: watchAssociations,
+      })
+      urlInfo.isWatched = watch
+      // si une urlInfo dépends de pleins d'autres alors
+      // on voudrait check chacune de ces url infos (package.json dans mon cas)
+      urlInfo.isValid = () => {
+        if (!urlInfo.url.startsWith("file:")) {
+          return false
+        }
+        if (watch && urlInfo.contentEtag === undefined) {
+          // we trust the watching mecanism
+          // doing urlInfo.contentEtag = undefined
+          // when file is modified
+          return false
+        }
+        if (!watch) {
+          const fileContentAsBuffer = readFileSync(new URL(urlInfo.url))
+          const fileContentEtag = bufferToEtag(fileContentAsBuffer)
+          if (fileContentEtag !== urlInfo.originalContentEtag) {
+            return false
+          }
+        }
+        for (const implicitUrl of urlInfo.implicitUrls) {
+          const implicitUrlInfo = context.urlGraph.getUrlInfo(implicitUrl)
+          if (implicitUrlInfo && !implicitUrlInfo.isValid()) {
+            return false
+          }
+        }
+        return true
+      }
+    }
+    urlGraph.prunedUrlInfosCallbackRef.current = (urlInfos, firstUrlInfo) => {
+      clientFilesPruneCallbackList.forEach((callback) => {
+        callback(urlInfos, firstUrlInfo)
+      })
+    }
     serverStopCallbacks.push(() => {
       kitchen.pluginController.callHooks("destroy", kitchen.kitchenContext)
     })
@@ -192,8 +235,7 @@ export const createFileService = ({
         headers: request.headers,
       })
     }
-    const { runtimeName, runtimeVersion, urlGraph, kitchen } =
-      getOrCreateContext(request)
+    const { urlGraph, kitchen } = getOrCreateContext(request)
     const responseFromPlugin =
       await kitchen.pluginController.callAsyncHooksUntil(
         "serve",
@@ -218,25 +260,21 @@ export const createFileService = ({
       reference = entryPoint[0]
     }
     const urlInfo = urlGraph.reuseOrCreateUrlInfo(reference.url)
-
     const ifNoneMatch = request.headers["if-none-match"]
-    if (
-      ifNoneMatch &&
-      urlInfo.contentEtag === ifNoneMatch &&
-      // 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 {
-        status: 304,
-        headers: {
-          "cache-control": `private,max-age=0,must-revalidate`,
-          ...urlInfo.headers,
-        },
+    const urlInfoTargetedByCache = urlGraph.getParentIfInline(urlInfo)
+
+    if (ifNoneMatch) {
+      if (
+        urlInfoTargetedByCache.contentEtag === ifNoneMatch &&
+        urlInfoTargetedByCache.isValid()
+      ) {
+        return {
+          status: 304,
+          headers: {
+            "cache-control": `private,max-age=0,must-revalidate`,
+            ...urlInfo.headers,
+          },
+        }
       }
     }
     try {
@@ -253,17 +291,11 @@ export const createFileService = ({
         urlInfo.originalContent = null
         urlInfo.type = null
         urlInfo.subtype = null
-        urlInfo.dependsOnPackageJson = false
         urlInfo.timing = {}
       }
       await kitchen.cook(urlInfo, {
         request,
         reference,
-        outDirectoryUrl: scenarios.dev
-          ? `${rootDirectoryUrl}.jsenv/${runtimeName}@${runtimeVersion}/`
-          : `${rootDirectoryUrl}.jsenv/${
-              scenarios.test ? "test" : "build"
-            }/${runtimeName}@${runtimeVersion}/`,
       })
       let { response } = urlInfo
       if (response) {
@@ -275,7 +307,7 @@ export const createFileService = ({
         headers: {
           "content-length": Buffer.byteLength(urlInfo.content),
           "cache-control": `private,max-age=0,must-revalidate`,
-          "eTag": urlInfo.contentEtag,
+          "eTag": urlInfoTargetedByCache.contentEtag,
           ...urlInfo.headers,
           "content-type": urlInfo.contentType,
         },
@@ -293,13 +325,14 @@ export const createFileService = ({
       return response
     } catch (e) {
       urlInfo.error = e
-      const code = e.code
+      const originalError = e ? e.cause || e : e
+      const code = originalError.code
       if (code === "PARSE_ERROR") {
         return {
           url: reference.url,
           status: 200, // let the browser re-throw the syntax error
-          statusText: e.reason,
-          statusMessage: e.message,
+          statusText: originalError.reason,
+          statusMessage: originalError.message,
           headers: {
             "content-type": urlInfo.contentType,
             "content-length": Buffer.byteLength(urlInfo.content),
@@ -321,15 +354,15 @@ export const createFileService = ({
         return {
           url: reference.url,
           status: 403,
-          statusText: e.reason,
+          statusText: originalError.reason,
         }
       }
       if (code === "NOT_FOUND") {
         return {
           url: reference.url,
           status: 404,
-          statusText: e.reason,
-          statusMessage: e.message,
+          statusText: originalError.reason,
+          statusMessage: originalError.message,
         }
       }
       return {

package/src/omega/url_graph/url_graph_loader.js

@@ -0,0 +1,77 @@
+export const createUrlGraphLoader = (context) => {
+  const promises = []
+  const promiseMap = new Map()
+  const load = (
+    urlInfo,
+    dishContext,
+    { ignoreRessourceHint = true, ignoreDynamicImport = false } = {},
+  ) => {
+    const promiseFromData = promiseMap.get(urlInfo)
+    if (promiseFromData) return promiseFromData
+    const promise = (async () => {
+      await context.cook(urlInfo, {
+        cookDuringCook: load,
+        ...dishContext,
+      })
+      loadReferencedUrlInfos(urlInfo, {
+        ignoreRessourceHint,
+        ignoreDynamicImport,
+      })
+    })()
+    promises.push(promise)
+    promiseMap.set(urlInfo, promise)
+    return promise
+  }
+
+  const loadReferencedUrlInfos = (
+    urlInfo,
+    { ignoreRessourceHint, ignoreDynamicImport },
+  ) => {
+    const { references } = urlInfo
+    references.forEach((reference) => {
+      // we don't cook resource hints
+      // because they might refer to resource that will be modified during build
+      // It also means something else have to reference that url in order to cook it
+      // so that the preload is deleted by "resync_resource_hints.js" otherwise
+      if (ignoreRessourceHint && reference.isResourceHint) {
+        return
+      }
+      if (ignoreDynamicImport && reference.subtype === "import_dynamic") {
+        return
+      }
+      // we use reference.generatedUrl to mimic what a browser would do:
+      // do a fetch to the specifier as found in the file
+      const referencedUrlInfo = context.urlGraph.reuseOrCreateUrlInfo(
+        reference.generatedUrl,
+      )
+      load(referencedUrlInfo, {
+        reference,
+        ignoreRessourceHint,
+        ignoreDynamicImport,
+      })
+    })
+  }
+
+  const getAllLoadDonePromise = async (operation) => {
+    const waitAll = async () => {
+      if (operation) {
+        operation.throwIfAborted()
+      }
+      if (promises.length === 0) {
+        return
+      }
+      const promisesToWait = promises.slice()
+      promises.length = 0
+      await Promise.all(promisesToWait)
+      await waitAll()
+    }
+    await waitAll()
+    promiseMap.clear()
+  }
+
+  return {
+    load,
+    loadReferencedUrlInfos,
+    getAllLoadDonePromise,
+  }
+}

package/src/omega/url_graph/url_info_transformations.js

@@ -15,23 +15,14 @@ export const createUrlInfoTransformer = ({
   sourcemapsSourcesContent,
   sourcemapsRelativeSources,
   urlGraph,
-  clientRuntimeCompat,
   injectSourcemapPlaceholder,
   foundSourcemap,
 }) => {
-  const runtimeNames = Object.keys(clientRuntimeCompat)
-  const chromeAsSingleRuntime =
-    runtimeNames.length === 1 && runtimeNames[0] === "chrome"
   if (sourcemapsSourcesProtocol === undefined) {
     sourcemapsSourcesProtocol = "file:///"
   }
   if (sourcemapsSourcesContent === undefined) {
-    if (chromeAsSingleRuntime && sourcemapsSourcesProtocol === "file:///") {
-      // chrome is able to fetch source when referenced with "file:"
-      sourcemapsSourcesContent = false
-    } else {
-      sourcemapsSourcesContent = true
-    }
+    sourcemapsSourcesContent = true
   }
 
   const sourcemapsEnabled =
@@ -75,6 +66,9 @@ export const createUrlInfoTransformer = ({
   }
 
   const initTransformations = async (urlInfo, context) => {
+    urlInfo.originalContentEtag =
+      urlInfo.originalContentEtag ||
+      bufferToEtag(Buffer.from(urlInfo.originalContent))
     if (!sourcemapsEnabled) {
       return
     }
@@ -133,7 +127,7 @@ export const createUrlInfoTransformer = ({
     }
   }
 
-  const applyIntermediateTransformations = async (urlInfo, transformations) => {
+  const applyIntermediateTransformations = (urlInfo, transformations) => {
     if (!transformations) {
       return
     }
@@ -150,7 +144,7 @@ export const createUrlInfoTransformer = ({
     }
     if (sourcemapsEnabled && sourcemap) {
       const sourcemapNormalized = normalizeSourcemap(urlInfo, sourcemap)
-      const finalSourcemap = await composeTwoSourcemaps(
+      const finalSourcemap = composeTwoSourcemaps(
         urlInfo.sourcemap,
         sourcemapNormalized,
       )
@@ -172,9 +166,9 @@ export const createUrlInfoTransformer = ({
     }
   }
 
-  const applyFinalTransformations = async (urlInfo, transformations) => {
+  const applyFinalTransformations = (urlInfo, transformations) => {
     if (transformations) {
-      await applyIntermediateTransformations(urlInfo, transformations)
+      applyIntermediateTransformations(urlInfo, transformations)
     }
     if (
       sourcemapsEnabled &&
@@ -227,7 +221,10 @@ export const createUrlInfoTransformer = ({
       // in the end we don't use the sourcemap placeholder
       urlGraph.deleteUrlInfo(urlInfo.sourcemapReference.url)
     }
-    urlInfo.contentEtag = bufferToEtag(Buffer.from(urlInfo.content))
+    urlInfo.contentEtag =
+      urlInfo.content === urlInfo.originalContent
+        ? urlInfo.originalContentEtag
+        : bufferToEtag(Buffer.from(urlInfo.content))
   }
 
   return {