@jsenv/core 23.5.2 → 23.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "23.5.2",
+  "version": "23.6.0",
   "description": "Tool to develop, test and build js projects",
   "license": "MIT",
   "repository": {

package/src/internal/compiling/compile-directory/getOrGenerateCompiledFile.js

@@ -14,14 +14,11 @@ export const getOrGenerateCompiledFile = async ({
   projectDirectoryUrl,
   originalFileUrl,
   compiledFileUrl = originalFileUrl,
-  useFilesystemAsCache,
+  compileCacheStrategy,
   compileCacheSourcesValidation,
   compileCacheAssetsValidation,
   fileContentFallback,
-  clientNeedsEtagHeader,
-  ifEtagMatch,
-  clientNeedsLastModifiedHeader,
-  ifModifiedSinceDate,
+  request,
   compile,
 }) => {
   if (typeof projectDirectoryUrl !== "string") {
@@ -69,13 +66,10 @@ export const getOrGenerateCompiledFile = async ({
           compiledFileUrl,
           compile,
           fileContentFallback,
-          clientNeedsEtagHeader,
-          ifEtagMatch,
-          clientNeedsLastModifiedHeader,
-          ifModifiedSinceDate,
-          useFilesystemAsCache,
+          compileCacheStrategy,
           compileCacheSourcesValidation,
           compileCacheAssetsValidation,
+          request,
           logger,
         })
 
@@ -101,38 +95,32 @@ const computeCompileReport = async ({
   compiledFileUrl,
   compile,
   fileContentFallback,
-  clientNeedsEtagHeader,
-  ifEtagMatch,
-  clientNeedsLastModifiedHeader,
-  ifModifiedSinceDate,
-  useFilesystemAsCache,
+  compileCacheStrategy,
   compileCacheSourcesValidation,
   compileCacheAssetsValidation,
+  request,
   logger,
 }) => {
   const [readCacheTiming, cacheValidity] = await timeFunction(
     "read cache",
     () => {
-      if (!useFilesystemAsCache) {
-        return {
-          isValid: false,
-          code: "META_FILE_NOT_FOUND",
-          meta: {
-            isValid: false,
-            code: "META_FILE_NOT_FOUND",
-          },
-        }
-      }
+      // if (!useFilesystemAsCache) {
+      //   return {
+      //     isValid: false,
+      //     code: "META_FILE_NOT_FOUND",
+      //     meta: {
+      //       isValid: false,
+      //       code: "META_FILE_NOT_FOUND",
+      //     },
+      //   }
+      // }
       return validateCache({
         logger,
-        useFilesystemAsCache,
         compiledFileUrl,
-        clientNeedsEtagHeader,
-        ifEtagMatch,
-        clientNeedsLastModifiedHeader,
-        ifModifiedSinceDate,
+        compileCacheStrategy,
         compileCacheSourcesValidation,
         compileCacheAssetsValidation,
+        request,
       })
     },
   )
@@ -149,6 +137,7 @@ const computeCompileReport = async ({
         logger,
         originalFileUrl,
         fileContentFallback,
+        request,
         compile,
       }),
     )
@@ -189,6 +178,7 @@ const callCompile = async ({
   logger,
   originalFileUrl,
   fileContentFallback,
+  request,
   compile,
 }) => {
   logger.debug(`compile ${originalFileUrl}`)
@@ -201,6 +191,7 @@ const callCompile = async ({
   const compileReturnValue = await compile({
     code: codeBeforeCompile,
     map: undefined,
+    request,
   })
   if (typeof compileReturnValue !== "object" || compileReturnValue === null) {
     throw new TypeError(
@@ -214,6 +205,7 @@ const callCompile = async ({
     sourcesContent = [],
     assets = [],
     assetsContent = [],
+    responseHeaders,
   } = compileReturnValue
   if (typeof contentType !== "string") {
     throw new TypeError(
@@ -233,6 +225,7 @@ const callCompile = async ({
     sourcesContent,
     assets,
     assetsContent,
+    responseHeaders,
   }
 }
 

package/src/internal/compiling/compile-directory/validateCache.js

@@ -5,10 +5,7 @@ import { readFileSync, statSync } from "node:fs"
 
 export const validateCache = async ({
   compiledFileUrl,
-  clientNeedsEtagHeader,
-  ifEtagMatch,
-  clientNeedsLastModifiedHeader,
-  ifModifiedSinceDate,
+  compileCacheStrategy,
   compileCacheSourcesValidation = true,
   // When "compileCacheAssetsValidation" is enabled, code ensures that
   // - asset file exists
@@ -19,6 +16,7 @@ export const validateCache = async ({
   // so by default "compileCacheAssetsValidation" is disabled
   // to avoid checking things for nothing
   compileCacheAssetsValidation = false,
+  request,
 }) => {
   const validity = { isValid: true }
 
@@ -31,10 +29,8 @@ export const validateCache = async ({
 
   const compiledFileValidation = await validateCompiledFile({
     compiledFileUrl,
-    clientNeedsEtagHeader,
-    ifEtagMatch,
-    clientNeedsLastModifiedHeader,
-    ifModifiedSinceDate,
+    request,
+    compileCacheStrategy,
   })
   mergeValidity(validity, "compiledFile", compiledFileValidation)
   if (!validity.isValid) {
@@ -111,31 +107,43 @@ const validateMetaFile = async (metaJsonFileUrl) => {
 
 const validateCompiledFile = async ({
   compiledFileUrl,
-  clientNeedsEtagHeader,
-  ifEtagMatch,
-  clientNeedsLastModifiedHeader,
-  ifModifiedSinceDate,
+  compileCacheStrategy,
+  request,
 }) => {
   const validity = { isValid: true, data: {} }
 
+  const clientCacheDisabled = request.headers["cache-control"] === "no-cache"
+
   try {
     const compiledSourceBuffer = readFileSync(fileURLToPath(compiledFileUrl))
     validity.data.compiledSourceBuffer = compiledSourceBuffer
 
-    if (clientNeedsEtagHeader) {
+    if (!clientCacheDisabled && compileCacheStrategy === "etag") {
       const compiledEtag = bufferToEtag(compiledSourceBuffer)
       validity.data.compiledEtag = compiledEtag
-      if (ifEtagMatch && ifEtagMatch !== compiledEtag) {
+      const ifNoneMatch = request.headers["if-none-match"]
+      if (ifNoneMatch && ifNoneMatch !== compiledEtag) {
         validity.isValid = false
         validity.code = "COMPILED_FILE_ETAG_MISMATCH"
         return validity
       }
     }
 
-    if (clientNeedsLastModifiedHeader) {
+    if (!clientCacheDisabled && compileCacheStrategy === "mtime") {
       const stats = statSync(fileURLToPath(compiledFileUrl))
       const compiledMtime = Math.floor(stats.mtimeMs)
       validity.data.compiledMtime = compiledMtime
+
+      const ifModifiedSince = request.headers["if-modified-since"]
+      let ifModifiedSinceDate
+      try {
+        ifModifiedSinceDate = new Date(ifModifiedSince)
+      } catch (e) {
+        ifModifiedSinceDate = null
+        // ideally we should rather respond with
+        // 400 "if-modified-since header is not a valid date"
+      }
+
       if (
         ifModifiedSinceDate &&
         ifModifiedSinceDate < dateToSecondsPrecision(compiledMtime)

package/src/internal/compiling/compileFile.js

@@ -19,47 +19,21 @@ export const compileFile = async ({
   projectFileRequestedCallback = () => {},
   request,
   compile,
-  writeOnFilesystem,
-  useFilesystemAsCache,
   compileCacheStrategy = "etag",
   compileCacheSourcesValidation,
   compileCacheAssetsValidation,
 }) => {
   if (
-    writeOnFilesystem &&
     compileCacheStrategy !== "etag" &&
-    compileCacheStrategy !== "mtime"
+    compileCacheStrategy !== "mtime" &&
+    compileCacheStrategy !== "none"
   ) {
     throw new Error(
-      `compileCacheStrategy must be etag or mtime , got ${compileCacheStrategy}`,
+      `compileCacheStrategy must be "etag", "mtime" or "none", got ${compileCacheStrategy}`,
     )
   }
 
-  const { headers = {} } = request
-  const clientCacheDisabled = headers["cache-control"] === "no-cache"
-  const cacheWithETag = writeOnFilesystem && compileCacheStrategy === "etag"
-
-  let ifEtagMatch
-  if (cacheWithETag && "if-none-match" in headers) {
-    ifEtagMatch = headers["if-none-match"]
-  }
-
-  const cacheWithMtime = writeOnFilesystem && compileCacheStrategy === "mtime"
-  let ifModifiedSinceDate
-  if (cacheWithMtime && "if-modified-since" in headers) {
-    const ifModifiedSince = headers["if-modified-since"]
-    try {
-      ifModifiedSinceDate = new Date(ifModifiedSince)
-    } catch (e) {
-      return {
-        status: 400,
-        statusText: "if-modified-since header is not a valid date",
-      }
-    }
-  }
-
-  const clientNeedsEtagHeader = cacheWithETag && !clientCacheDisabled
-  const clientNeedsLastModifiedHeader = cacheWithMtime && !clientCacheDisabled
+  const clientCacheDisabled = request.headers["cache-control"] === "no-cache"
 
   try {
     const { meta, compileResult, compileResultStatus, timing } =
@@ -69,25 +43,21 @@ export const compileFile = async ({
         originalFileUrl,
         compiledFileUrl,
         fileContentFallback,
-        clientNeedsEtagHeader,
-        clientNeedsLastModifiedHeader,
-        ifEtagMatch,
-        ifModifiedSinceDate,
-        useFilesystemAsCache,
+        request,
+        compileCacheStrategy,
         compileCacheSourcesValidation,
         compileCacheAssetsValidation,
         compile,
       })
 
-    if (clientNeedsEtagHeader && !compileResult.compiledEtag) {
+    if (compileCacheStrategy === "etag" && !compileResult.compiledEtag) {
       // happens when file was just compiled so etag was not computed
-
       compileResult.compiledEtag = bufferToEtag(
         Buffer.from(compileResult.compiledSource),
       )
     }
 
-    if (clientNeedsLastModifiedHeader && !compileResult.compiledMtime) {
+    if (compileCacheStrategy === "mtime" && !compileResult.compiledMtime) {
       // happens when file was just compiled so it's not yet written on filesystem
       // Here we know the compiled file will be written on the filesystem
       // We could wait for the file to be written before responding to the client
@@ -107,20 +77,29 @@ export const compileFile = async ({
       compileResult.compiledMtime = Date.now()
     }
 
+    const {
+      contentType,
+      compiledEtag,
+      compiledMtime,
+      compiledSource,
+      responseHeaders = {},
+    } = compileResult
+
     if (
-      compileResultStatus === "created" ||
-      compileResultStatus === "updated"
+      compileResultStatus !== "cached" &&
+      compileCacheStrategy !== "none" &&
+      // a cutom compiler explicitely disables cache by returning "cache-control": "no-store"
+      // this file must not be cached on the filesystem and always re-generated
+      responseHeaders["cache-control"] !== "no-store"
     ) {
-      if (writeOnFilesystem) {
-        updateMeta({
-          logger,
-          meta,
-          compileResult,
-          compileResultStatus,
-          compiledFileUrl,
-          // originalFileUrl,
-        })
-      }
+      updateMeta({
+        logger,
+        meta,
+        compileResult,
+        compileResultStatus,
+        compiledFileUrl,
+        // originalFileUrl,
+      })
     }
 
     compileResult.sources.forEach((source) => {
@@ -131,9 +110,6 @@ export const compileFile = async ({
       )
     })
 
-    const { contentType, compiledEtag, compiledMtime, compiledSource } =
-      compileResult
-
     // when a compiled version of the source file was just created or updated
     // we don't want to rely on filesystem because we might want to delay
     // when the file is written for perf reasons
@@ -144,6 +120,7 @@ export const compileFile = async ({
         headers: {
           "content-length": Buffer.byteLength(compiledSource),
           "content-type": contentType,
+          ...responseHeaders,
         },
         body: compiledSource,
         timing,
@@ -152,8 +129,11 @@ export const compileFile = async ({
       return response
     }
 
-    if (clientNeedsEtagHeader) {
-      if (ifEtagMatch && compileResultStatus === "cached") {
+    if (!clientCacheDisabled && compileCacheStrategy === "etag") {
+      if (
+        request.headers["if-none-match"] &&
+        compileResultStatus === "cached"
+      ) {
         return {
           status: 304,
           timing,
@@ -165,8 +145,11 @@ export const compileFile = async ({
       })
     }
 
-    if (clientNeedsLastModifiedHeader) {
-      if (ifModifiedSinceDate && compileResultStatus === "cached") {
+    if (!clientCacheDisabled && compileCacheStrategy === "mtime") {
+      if (
+        request.headers["if-modified-since"] &&
+        compileResultStatus === "cached"
+      ) {
         return {
           status: 304,
           timing,

package/src/internal/compiling/compileHtml.js

@@ -86,10 +86,7 @@ export const getHtmlNodeAttributeByName = (htmlNode, attributeName) => {
 }
 
 export const removeHtmlNodeAttribute = (htmlNode, attributeToRemove) => {
-  let attrIndex
-  if (typeof attributeToRemove === "object") {
-    attrIndex = htmlNode.attrs.indexOf(attributeToRemove)
-  }
+  const attrIndex = htmlNode.attrs.indexOf(attributeToRemove)
   if (attrIndex === -1) {
     return false
   }

package/src/internal/compiling/createCompiledFileService.js

@@ -48,7 +48,6 @@ export const createCompiledFileService = ({
   jsenvToolbarInjection,
 
   projectFileRequestedCallback,
-  useFilesystemAsCache,
   compileCacheStrategy,
   sourcemapMethod,
   sourcemapExcludeSources,
@@ -153,8 +152,6 @@ export const createCompiledFileService = ({
       originalFileUrl,
       compiledFileUrl,
 
-      writeOnFilesystem: true, // we always need them
-      useFilesystemAsCache,
       compileCacheStrategy,
       projectFileRequestedCallback,
       request,
@@ -226,7 +223,10 @@ const getCompiler = ({ originalFileUrl, compileMeta }) => {
       code: customResult.compiledSource,
       map: customResult.sourcemap,
     })
-    return jsenvResult
+    return {
+      ...customResult,
+      ...jsenvResult,
+    }
   }
 }
 

package/src/internal/compiling/startCompileServer.js

@@ -316,11 +316,11 @@ export const startCompileServer = async ({
       jsenvToolbarInjection,
 
       projectFileRequestedCallback,
-      useFilesystemAsCache: compileServerCanReadFromFilesystem,
-      writeOnFilesystem: compileServerCanWriteOnFilesystem,
       sourcemapMethod,
       sourcemapExcludeSources,
-      compileCacheStrategy,
+      compileCacheStrategy: compileServerCanReadFromFilesystem
+        ? compileCacheStrategy
+        : "none",
     }),
     ...(transformHtmlSourceFiles
       ? {