@jsenv/core 25.1.1 → 25.2.0

package/src/internal/jsenv_remote_directory.js

@@ -0,0 +1,156 @@
+import {
+  urlIsInsideOf,
+  urlToRelativeUrl,
+  urlToRessource,
+  normalizeStructuredMetaMap,
+  urlToMeta,
+  writeFile,
+} from "@jsenv/filesystem"
+
+import { fetchUrl } from "@jsenv/core/src/internal/fetchUrl.js"
+import { validateResponseIntegrity } from "@jsenv/core/src/internal/integrity/integrity_validation.js"
+
+import { originDirectoryConverter } from "./origin_directory_converter.js"
+
+export const createJsenvRemoteDirectory = ({
+  projectDirectoryUrl,
+  jsenvDirectoryRelativeUrl,
+  preservedUrls,
+}) => {
+  const jsenvRemoteDirectoryUrl = `${projectDirectoryUrl}${jsenvDirectoryRelativeUrl}.remote/`
+  const structuredMetaMap = normalizeStructuredMetaMap(
+    { preserved: preservedUrls },
+    projectDirectoryUrl,
+  )
+  const isPreservedUrl = (url) => {
+    const meta = urlToMeta({ url, structuredMetaMap })
+    return Boolean(meta.preserved)
+  }
+
+  const jsenvRemoteDirectory = {
+    isPreservedUrl,
+
+    isRemoteUrl: (url) => {
+      return url.startsWith("http://") || url.startsWith("https://")
+    },
+
+    isFileUrlForRemoteUrl: (url) => {
+      return urlIsInsideOf(url, jsenvRemoteDirectoryUrl)
+    },
+
+    fileUrlFromRemoteUrl: (remoteUrl) => {
+      const origin = originFromUrlOrUrlPattern(remoteUrl)
+      const ressource = urlToRessource(remoteUrl)
+      const [pathname, search = ""] = ressource.split("?")
+      const directoryName = originDirectoryConverter.toDirectoryName(origin)
+      const fileRelativeUrl = `${directoryName}${
+        pathname === "" ? "/" : pathname
+      }`
+      const fileUrl = `${jsenvRemoteDirectoryUrl}${fileRelativeUrl}${search}`
+      return fileUrl
+    },
+
+    remoteUrlFromFileUrl: (fileUrl) => {
+      const fileRelativeUrl = urlToRelativeUrl(fileUrl, jsenvRemoteDirectoryUrl)
+      const firstSlashIndex = fileRelativeUrl.indexOf("/")
+      const directoryName = fileRelativeUrl.slice(0, firstSlashIndex)
+      const origin = originDirectoryConverter.fromDirectoryName(directoryName)
+      const ressource = fileRelativeUrl.slice(firstSlashIndex)
+      const remoteUrlObject = new URL(ressource, origin)
+      remoteUrlObject.searchParams.delete("integrity")
+      const remoteUrl = remoteUrlObject.href
+      return remoteUrl
+    },
+
+    loadFileUrlFromRemote: async (url, request) => {
+      const urlObject = new URL(url)
+      const integrity = urlObject.searchParams.get("integrity")
+      if (integrity) {
+        urlObject.searchParams.delete("integrity")
+      }
+      const remoteUrl = jsenvRemoteDirectory.remoteUrlFromFileUrl(
+        urlObject.href,
+      )
+      const requestHeadersToForward = { ...request.headers }
+      delete requestHeadersToForward.host
+      const response = await fetchUrl(remoteUrl, {
+        mode: "cors",
+        headers: requestHeadersToForward,
+      })
+      if (response.status !== 200) {
+        throw createRemoteFetchError({
+          code: "UNEXPECTED_STATUS",
+          message: `unexpected status for ressource "${remoteUrl}", received ${response.status}`,
+        })
+      }
+      const responseBodyAsBuffer = Buffer.from(await response.arrayBuffer())
+      if (integrity) {
+        try {
+          validateResponseIntegrity(
+            {
+              url: response.url,
+              type: response.type,
+              dataRepresentation: responseBodyAsBuffer,
+            },
+            integrity,
+          )
+        } catch (e) {
+          throw createRemoteFetchError({
+            code: e.code,
+            message: e.message,
+          })
+        }
+      }
+      await writeFile(url, responseBodyAsBuffer)
+      return responseBodyAsBuffer
+    },
+  }
+
+  return jsenvRemoteDirectory
+}
+
+const createRemoteFetchError = ({ message, code }) => {
+  const error = new Error(message)
+  error.code = "UNEXPECTED_REMOTE_URL_RESPONSE"
+  error.asResponse = () => {
+    const data = {
+      code,
+      message,
+    }
+    const json = JSON.stringify(data)
+    return {
+      status: 502,
+      statusText: "Bad Gateway",
+      headers: {
+        "cache-control": "no-store",
+        "content-length": Buffer.byteLength(json),
+        "content-type": "application/json",
+      },
+      body: json,
+    }
+  }
+  return error
+}
+
+const originFromUrlOrUrlPattern = (url) => {
+  if (url.startsWith("http://")) {
+    const slashAfterProtocol = url.indexOf("/", "http://".length + 1)
+    if (slashAfterProtocol === -1) {
+      return url
+    }
+    const origin = url.slice(0, slashAfterProtocol)
+    return origin
+  }
+  if (url.startsWith("https://")) {
+    const slashAfterProtocol = url.indexOf("/", "https://".length + 1)
+    if (slashAfterProtocol === -1) {
+      return url
+    }
+    const origin = url.slice(0, slashAfterProtocol)
+    return origin
+  }
+  if (url.startsWith("file://")) {
+    return "file://"
+  }
+  return new URL(url).origin
+}

package/src/internal/origin_directory_converter.js

@@ -0,0 +1,62 @@
+// https://stackoverflow.com/a/1184263
+// using the list of bad characters from:
+// https://github.com/parshap/node-sanitize-filename/blob/master/index.js
+// so that the directory name can be decoded
+// so that we can find back the http origin
+// we should also ignore the query string params part
+// it does not matter, it can be removed from the url and added back
+// when performing the http request
+
+const escapeChar = "$"
+const reservedChars = ["/", "?", "<", ">", "\\", ":", "*", "|", '"']
+
+export const originDirectoryConverter = {
+  toDirectoryName: (origin) => {
+    let directoryName = ""
+    let i = 0
+    while (i < origin.length) {
+      const char = origin[i]
+      i++
+      if (reservedChars.includes(char)) {
+        const charAsHex = charToHexString(char)
+        directoryName += `${escapeChar}${charAsHex}`
+      } else {
+        directoryName += char
+      }
+    }
+    return directoryName
+  },
+
+  fromDirectoryName: (filename) => {
+    let origin = ""
+    let i = 0
+    while (i < filename.length) {
+      const char = filename[i]
+      i++
+      if (char === escapeChar) {
+        const encodedChar = `${filename[i]}${filename[i + 1]}`
+        i += 2
+        const decodedChar = charFromHexString(encodedChar)
+        origin += decodedChar
+      } else {
+        origin += char
+      }
+    }
+    return origin
+  },
+}
+
+const charToHexString = (char) => {
+  const charCode = char.charCodeAt(0)
+  const hexString = charCode.toString(16)
+  if (charCode < 16) {
+    return `0${hexString}`
+  }
+  return hexString
+}
+
+const charFromHexString = (hexString) => {
+  const charCode = parseInt(hexString, 16)
+  const char = String.fromCharCode(charCode)
+  return char
+}

package/src/internal/response_validation.js

@@ -10,7 +10,6 @@ export const validateResponse = async (
   } = {},
 ) => {
   const validity = { isValid: true }
-
   if (statusValidation) {
     const statusValidity = await checkStatus(response, {
       originalUrl,
@@ -21,7 +20,6 @@ export const validateResponse = async (
       return validity
     }
   }
-
   if (contentTypeExpected) {
     const contentTypeValidity = await checkContentType(response, {
       originalUrl,
@@ -33,7 +31,6 @@ export const validateResponse = async (
       return validity
     }
   }
-
   return validity
 }
 
@@ -47,36 +44,28 @@ const mergeValidity = (parentValidity, childValidityName, childValidity) => {
 const checkStatus = async (response, { originalUrl, urlTrace }) => {
   const url = originalUrl || response.url
   const { status } = response
-
-  if (status === 500) {
-    if (response.headers["content-type"] === "application/json") {
-      return {
-        isValid: false,
-        message: `error 500 on url`,
-        details: {
-          "response status": status,
-          "response json": JSON.stringify(await response.json(), null, "  "),
-          url,
-          ...formatUrlTrace(urlTrace),
-        },
-      }
-    }
-  }
-
   if (status < 200 || status > 299) {
-    const responseText = await response.text()
     return {
       isValid: false,
       message: `invalid response status on url`,
       details: {
         "response status": status,
-        ...(responseText ? { "response text": responseText } : {}),
         url,
         ...formatUrlTrace(urlTrace),
+        ...(response.headers["content-type"] === "application/json"
+          ? {
+              "response text": JSON.stringify(
+                await response.json(),
+                null,
+                "  ",
+              ),
+            }
+          : {
+              "response text": await response.text(),
+            }),
       },
     }
   }
-
   return { isValid: true }
 }
 
@@ -86,11 +75,9 @@ const checkContentType = async (
 ) => {
   const url = originalUrl || response.url
   const responseContentType = response.headers["content-type"] || ""
-
   const isOk = Array.isArray(contentTypeExpected)
     ? contentTypeExpected.includes(responseContentType)
     : responseContentType === contentTypeExpected
-
   if (!isOk) {
     return {
       isValid: false,

package/src/internal/sourceMappingURLUtils.js

@@ -1,3 +1,13 @@
+export const generateSourcemapUrl = (url) => {
+  // we want to remove eventual search params from url
+  const urlString = String(url)
+  const urlObject = new URL(url)
+  const origin = urlString.startsWith("file://") ? "file://" : urlObject.origin
+  const pathname = urlObject.pathname
+  const sourcemapUrl = `${origin}${pathname}.map`
+  return sourcemapUrl
+}
+
 export const getJavaScriptSourceMappingUrl = (javaScriptSource) => {
   let sourceMappingUrl
   replaceSourceMappingUrl(

package/src/internal/url_conversion.js

@@ -124,6 +124,7 @@ export const createUrlConverter = ({
   }
 
   return {
+    compileServerOriginForRollup,
     asRollupUrl,
     asProjectUrl,
     asServerUrl,