@jsenv/core 23.1.3 → 23.2.2

package/src/internal/compiling/startCompileServer.js

@@ -1,10 +1,4 @@
-/* eslint-disable import/max-dependencies */
 import { readFileSync } from "node:fs"
-import {
-  createCancellationToken,
-  createCancellationSource,
-  composeCancellationToken,
-} from "@jsenv/cancellation"
 import {
   jsenvAccessControlAllowedHeaders,
   startServer,
@@ -12,6 +6,9 @@ import {
   createSSERoom,
   composeServicesWithTiming,
   urlToContentType,
+  pluginServerTiming,
+  pluginRequestWaitingCheck,
+  pluginCORS,
 } from "@jsenv/server"
 import { createLogger, createDetailedMessage } from "@jsenv/logger"
 import {
@@ -22,12 +19,12 @@ import {
   readFile,
   writeFile,
   ensureEmptyDirectory,
-  registerFileLifecycle,
   registerDirectoryLifecycle,
   urlIsInsideOf,
   urlToBasename,
 } from "@jsenv/filesystem"
 
+import { Abortable } from "@jsenv/core/src/abort/main.js"
 import { isBrowserPartOfSupportedRuntimes } from "@jsenv/core/src/internal/generateGroupMap/runtime_support.js"
 import { loadBabelPluginMapFromFile } from "./load_babel_plugin_map_from_file.js"
 import { extractSyntaxBabelPluginMap } from "./babel_plugins.js"
@@ -48,7 +45,7 @@ import { urlIsCompilationAsset } from "./compile-directory/compile-asset.js"
 import { createTransformHtmlSourceFileService } from "./html_source_file_service.js"
 
 export const startCompileServer = async ({
-  cancellationToken = createCancellationToken(),
+  signal = new AbortController().signal,
   compileServerLogLevel,
 
   projectDirectoryUrl,
@@ -89,7 +86,7 @@ export const startCompileServer = async ({
   compileServerIp = "0.0.0.0",
   compileServerPort = 0,
   keepProcessAlive = false,
-  stopOnPackageVersionChange = false,
+  onStop = () => {},
 
   // remaining options
   runtimeSupport,
@@ -218,15 +215,12 @@ export const startCompileServer = async ({
     ...babelPluginMap,
   }
 
-  const serverStopCancellationSource = createCancellationSource()
+  const compileServerOperation = Abortable.fromSignal(signal)
 
   let projectFileRequestedCallback = () => {}
   if (livereloadSSE) {
     const sseSetup = setupServerSentEventsForLivereload({
-      cancellationToken: composeCancellationToken(
-        cancellationToken,
-        serverStopCancellationSource.token,
-      ),
+      compileServerOperation,
       projectDirectoryUrl,
       jsenvDirectoryRelativeUrl,
       outDirectoryRelativeUrl,
@@ -236,7 +230,7 @@ export const startCompileServer = async ({
 
     projectFileRequestedCallback = sseSetup.projectFileRequestedCallback
     const serveSSEForLivereload = createSSEForLivereloadService({
-      cancellationToken,
+      compileServerOperation,
       outDirectoryRelativeUrl,
       trackMainAndDependencies: sseSetup.trackMainAndDependencies,
     })
@@ -283,31 +277,6 @@ export const startCompileServer = async ({
     })
   }
 
-  const sourceFileService = composeServicesWithTiming({
-    ...(transformHtmlSourceFiles
-      ? {
-          "service:transform html source file":
-            createTransformHtmlSourceFileService({
-              logger,
-              projectDirectoryUrl,
-              inlineImportMapIntoHTML,
-              jsenvScriptInjection,
-              jsenvToolbarInjection,
-            }),
-        }
-      : {}),
-    "service:source file": createSourceFileService({
-      logger,
-      projectDirectoryUrl,
-      projectFileRequestedCallback,
-      projectFileEtagEnabled,
-      transformHtmlSourceFiles,
-      inlineImportMapIntoHTML,
-      jsenvScriptInjection,
-      jsenvToolbarInjection,
-    }),
-  })
-
   const jsenvServices = {
     "service:compilation asset": createCompilationAssetFileService({
       projectDirectoryUrl,
@@ -327,8 +296,7 @@ export const startCompileServer = async ({
       projectDirectoryUrl,
     }),
     "service:compiled file": createCompiledFileService({
-      sourceFileService,
-      cancellationToken,
+      compileServerOperation,
       logger,
 
       projectDirectoryUrl,
@@ -352,10 +320,38 @@ export const startCompileServer = async ({
       sourcemapExcludeSources,
       compileCacheStrategy,
     }),
+    ...(transformHtmlSourceFiles
+      ? {
+          "service:transform html source file":
+            createTransformHtmlSourceFileService({
+              logger,
+              projectDirectoryUrl,
+              inlineImportMapIntoHTML,
+              jsenvScriptInjection,
+              jsenvToolbarInjection,
+            }),
+        }
+      : {}),
+    "service:source file": createSourceFileService({
+      logger,
+      projectDirectoryUrl,
+      projectFileRequestedCallback,
+      projectFileEtagEnabled,
+      transformHtmlSourceFiles,
+      inlineImportMapIntoHTML,
+      jsenvScriptInjection,
+      jsenvToolbarInjection,
+    }),
   }
 
   const compileServer = await startServer({
-    cancellationToken,
+    signal: compileServerOperation.signal,
+    stopOnExit: false,
+    stopOnSIGINT: false,
+    stopOnInternalError: false,
+    sendServerInternalErrorDetails: true,
+    keepProcessAlive,
+
     logLevel: compileServerLogLevel,
 
     protocol: compileServerProtocol,
@@ -364,44 +360,32 @@ export const startCompileServer = async ({
     serverCertificatePrivateKey: compileServerPrivateKey,
     ip: compileServerIp,
     port: compileServerPort,
-    sendServerTiming: true,
-    // nagle: false,
-    requestWaitingMs: 60 * 1000,
-    sendServerInternalErrorDetails: true,
+    plugins: {
+      ...pluginCORS({
+        accessControlAllowRequestOrigin: true,
+        accessControlAllowRequestMethod: true,
+        accessControlAllowRequestHeaders: true,
+        accessControlAllowedRequestHeaders: [
+          ...jsenvAccessControlAllowedHeaders,
+          "x-jsenv-execution-id",
+        ],
+        accessControlAllowCredentials: true,
+      }),
+      ...pluginServerTiming,
+      ...pluginRequestWaitingCheck({
+        requestWaitingMs: 60 * 1000,
+      }),
+    },
     requestToResponse: composeServicesWithTiming({
       ...customServices,
       ...jsenvServices,
     }),
-    accessControlAllowRequestOrigin: true,
-    accessControlAllowRequestMethod: true,
-    accessControlAllowRequestHeaders: true,
-    accessControlAllowedRequestHeaders: [
-      ...jsenvAccessControlAllowedHeaders,
-      "x-jsenv-execution-id",
-    ],
-    accessControlAllowCredentials: true,
-    keepProcessAlive,
+    onStop: () => {
+      onStop()
+      compileServerOperation.cleaner.clean()
+    },
   })
 
-  compileServer.stoppedPromise.then(serverStopCancellationSource.cancel)
-
-  if (stopOnPackageVersionChange) {
-    const stopListeningJsenvPackageVersionChange =
-      listenJsenvPackageVersionChange({
-        projectDirectoryUrl,
-        jsenvDirectoryRelativeUrl,
-        onJsenvPackageVersionChange: () => {
-          compileServer.stop(STOP_REASON_PACKAGE_VERSION_CHANGED)
-        },
-      })
-    compileServer.stoppedPromise.then(
-      () => {
-        stopListeningJsenvPackageVersionChange()
-      },
-      () => {},
-    )
-  }
-
   return {
     jsenvDirectoryRelativeUrl,
     outDirectoryRelativeUrl,
@@ -575,7 +559,7 @@ const compareValueJson = (left, right) => {
  *
  */
 const setupServerSentEventsForLivereload = ({
-  cancellationToken,
+  compileServerOperation,
   projectDirectoryUrl,
   jsenvDirectoryRelativeUrl,
   outDirectoryRelativeUrl,
@@ -621,7 +605,7 @@ const setupServerSentEventsForLivereload = ({
       recursive: true,
     },
   )
-  cancellationToken.register(unregisterDirectoryLifecyle)
+  compileServerOperation.cleaner.addCallback(unregisterDirectoryLifecyle)
 
   const getDependencySet = (mainRelativeUrl) => {
     if (trackerMap.has(mainRelativeUrl)) {
@@ -777,11 +761,14 @@ const setupServerSentEventsForLivereload = ({
     }
   }
 
-  return { projectFileRequestedCallback, trackMainAndDependencies }
+  return {
+    projectFileRequestedCallback,
+    trackMainAndDependencies,
+  }
 }
 
 const createSSEForLivereloadService = ({
-  cancellationToken,
+  compileServerOperation,
   outDirectoryRelativeUrl,
   trackMainAndDependencies,
 }) => {
@@ -815,17 +802,18 @@ const createSSEForLivereloadService = ({
       },
     })
 
-    const cancelRegistration = cancellationToken.register(() => {
-      cancelRegistration.unregister()
-
-      sseRoom.close()
-      stopTracking()
-    })
+    const removeSSECleanupCallback = compileServerOperation.cleaner.addCallback(
+      () => {
+        removeSSECleanupCallback()
+        sseRoom.close()
+        stopTracking()
+      },
+    )
     cache.push({
       mainFileRelativeUrl,
       sseRoom,
       cleanup: () => {
-        cancelRegistration.unregister()
+        removeSSECleanupCallback()
         sseRoom.close()
         stopTracking()
       },
@@ -1122,51 +1110,6 @@ const createCompileProxyService = ({ projectDirectoryUrl }) => {
   }
 }
 
-const listenJsenvPackageVersionChange = ({
-  projectDirectoryUrl,
-  jsenvDirectoryRelativeUrl,
-  onJsenvPackageVersionChange = () => {},
-}) => {
-  const jsenvCoreDirectoryUrl = resolveUrl(
-    jsenvDirectoryRelativeUrl,
-    projectDirectoryUrl,
-  )
-  const packageFileUrl = resolveUrl("./package.json", jsenvCoreDirectoryUrl)
-  const packageFilePath = urlToFileSystemPath(packageFileUrl)
-  let packageVersion
-
-  try {
-    packageVersion = readPackage(packageFilePath).version
-  } catch (e) {
-    if (e.code === "ENOENT") return () => {}
-  }
-
-  const checkPackageVersion = () => {
-    let packageObject
-    try {
-      packageObject = readPackage(packageFilePath)
-    } catch (e) {
-      // package json deleted ? not a problem
-      // let's wait for it to show back
-      if (e.code === "ENOENT") return
-      // package.json malformed ? not a problem
-      // let's wait for use to fix it or filesystem to finish writing the file
-      if (e.name === "SyntaxError") return
-      throw e
-    }
-
-    if (packageVersion !== packageObject.version) {
-      onJsenvPackageVersionChange()
-    }
-  }
-
-  return registerFileLifecycle(packageFilePath, {
-    added: checkPackageVersion,
-    updated: checkPackageVersion,
-    keepProcessAlive: false,
-  })
-}
-
 const readPackage = (packagePath) => {
   const buffer = readFileSync(packagePath)
   const string = String(buffer)
@@ -1174,10 +1117,6 @@ const readPackage = (packagePath) => {
   return packageObject
 }
 
-export const STOP_REASON_PACKAGE_VERSION_CHANGED = {
-  toString: () => `package version changed`,
-}
-
 const __filenameReplacement = `import.meta.url.slice('file:///'.length)`
 
 const __dirnameReplacement = `import.meta.url.slice('file:///'.length).replace(/[\\\/\\\\][^\\\/\\\\]*$/, '')`

package/src/internal/executing/coverage/generateCoverageJsonFile.js

@@ -1,5 +1,22 @@
-import { writeFile } from "@jsenv/filesystem"
+import { writeFile, urlToFileSystemPath } from "@jsenv/filesystem"
 
-export const generateCoverageJsonFile = async (coverage, coverageJsonFileUrl) => {
-  await writeFile(coverageJsonFileUrl, JSON.stringify(coverage, null, "  "))
+import { byteAsFileSize } from "@jsenv/core/src/internal/logs/byteAsFileSize.js"
+
+export const generateCoverageJsonFile = async ({
+  coverage,
+  coverageJsonFileUrl,
+  coverageJsonFileLog,
+  logger,
+}) => {
+  const coverageAsText = JSON.stringify(coverage, null, "  ")
+
+  if (coverageJsonFileLog) {
+    logger.info(
+      `-> ${urlToFileSystemPath(coverageJsonFileUrl)} (${byteAsFileSize(
+        Buffer.byteLength(coverageAsText),
+      )})`,
+    )
+  }
+
+  await writeFile(coverageJsonFileUrl, coverageAsText)
 }

package/src/internal/executing/coverage/relativeUrlToEmptyCoverage.js

@@ -1,52 +1,41 @@
-import { createOperation } from "@jsenv/cancellation"
 import { resolveUrl, urlToFileSystemPath, readFile } from "@jsenv/filesystem"
 
+import { Abortable } from "@jsenv/core/src/abort/main.js"
 import {
   babelPluginsFromBabelPluginMap,
   getMinimalBabelPluginMap,
 } from "@jsenv/core/src/internal/compiling/babel_plugins.js"
-
 import { babelPluginInstrument } from "./babel_plugin_instrument.js"
 import { createEmptyCoverage } from "./createEmptyCoverage.js"
 
 export const relativeUrlToEmptyCoverage = async (
   relativeUrl,
-  { cancellationToken, projectDirectoryUrl, babelPluginMap },
+  { multipleExecutionsOperation, projectDirectoryUrl, babelPluginMap },
 ) => {
   const { transformAsync } = await import("@babel/core")
 
   const fileUrl = resolveUrl(relativeUrl, projectDirectoryUrl)
-  const source = await createOperation({
-    cancellationToken,
-    start: () => readFile(fileUrl),
-  })
+  Abortable.throwIfAborted(multipleExecutionsOperation)
+  const source = await readFile(fileUrl)
 
   try {
-    const { metadata } = await createOperation({
-      cancellationToken,
-      start: async () => {
-        babelPluginMap = {
-          ...getMinimalBabelPluginMap(),
-          ...babelPluginMap,
-          "transform-instrument": [
-            babelPluginInstrument,
-            { projectDirectoryUrl },
-          ],
-        }
+    babelPluginMap = {
+      ...getMinimalBabelPluginMap(),
+      ...babelPluginMap,
+      "transform-instrument": [babelPluginInstrument, { projectDirectoryUrl }],
+    }
 
-        const { metadata } = await transformAsync(source, {
-          filename: urlToFileSystemPath(fileUrl),
-          filenameRelative: relativeUrl,
-          configFile: false,
-          babelrc: false,
-          ast: true,
-          parserOpts: {
-            allowAwaitOutsideFunction: true,
-          },
-          plugins: babelPluginsFromBabelPluginMap(babelPluginMap),
-        })
-        return { metadata }
+    Abortable.throwIfAborted(multipleExecutionsOperation)
+    const { metadata } = await transformAsync(source, {
+      filename: urlToFileSystemPath(fileUrl),
+      filenameRelative: relativeUrl,
+      configFile: false,
+      babelrc: false,
+      ast: true,
+      parserOpts: {
+        allowAwaitOutsideFunction: true,
       },
+      plugins: babelPluginsFromBabelPluginMap(babelPluginMap),
     })
 
     const { coverage } = metadata

package/src/internal/executing/coverage/reportToCoverage.js

@@ -1,4 +1,5 @@
 import { collectFiles } from "@jsenv/filesystem"
+
 import { relativeUrlToEmptyCoverage } from "./relativeUrlToEmptyCoverage.js"
 import { istanbulCoverageFromCoverages } from "./istanbulCoverageFromCoverages.js"
 import { normalizeIstanbulCoverage } from "./normalizeIstanbulCoverage.js"
@@ -6,8 +7,8 @@ import { normalizeIstanbulCoverage } from "./normalizeIstanbulCoverage.js"
 export const reportToCoverage = async (
   report,
   {
+    multipleExecutionsOperation,
     logger,
-    cancellationToken,
     projectDirectoryUrl,
     babelPluginMap,
     coverageConfig,
@@ -15,50 +16,66 @@ export const reportToCoverage = async (
     coverageV8MergeConflictIsExpected,
   },
 ) => {
-  const istanbulCoverageFromExecution = await executionReportToCoverage(report, {
-    logger,
-    projectDirectoryUrl,
-    coverageV8MergeConflictIsExpected,
-  })
+  // here we should forward multipleExecutionsOperation.signal
+  // to allow aborting this too
+  const istanbulCoverageFromExecution = await executionReportToCoverage(
+    report,
+    {
+      logger,
+      projectDirectoryUrl,
+      coverageV8MergeConflictIsExpected,
+    },
+  )
 
   if (!coverageIncludeMissing) {
     return istanbulCoverageFromExecution
   }
 
   const relativeFileUrlToCoverArray = await listRelativeFileUrlToCover({
-    cancellationToken,
+    multipleExecutionsOperation,
     projectDirectoryUrl,
     coverageConfig,
   })
 
-  const relativeFileUrlMissingCoverageArray = relativeFileUrlToCoverArray.filter(
-    (relativeFileUrlToCover) =>
+  const relativeFileUrlMissingCoverageArray =
+    relativeFileUrlToCoverArray.filter((relativeFileUrlToCover) =>
       Object.keys(istanbulCoverageFromExecution).every((key) => {
         return key !== `./${relativeFileUrlToCover}`
       }),
-  )
+    )
 
   const istanbulCoverageFromMissedFiles = {}
+  // maybe we should prefer reduce over Promise.all here
+  // because it creates a LOT of things to do
   await Promise.all(
-    relativeFileUrlMissingCoverageArray.map(async (relativeFileUrlMissingCoverage) => {
-      const emptyCoverage = await relativeUrlToEmptyCoverage(relativeFileUrlMissingCoverage, {
-        cancellationToken,
-        projectDirectoryUrl,
-        babelPluginMap,
-      })
-      istanbulCoverageFromMissedFiles[relativeFileUrlMissingCoverage] = emptyCoverage
-      return emptyCoverage
-    }),
+    relativeFileUrlMissingCoverageArray.map(
+      async (relativeFileUrlMissingCoverage) => {
+        const emptyCoverage = await relativeUrlToEmptyCoverage(
+          relativeFileUrlMissingCoverage,
+          {
+            multipleExecutionsOperation,
+            projectDirectoryUrl,
+            babelPluginMap,
+          },
+        )
+        istanbulCoverageFromMissedFiles[relativeFileUrlMissingCoverage] =
+          emptyCoverage
+        return emptyCoverage
+      },
+    ),
   )
 
   return {
     ...istanbulCoverageFromExecution, // already normalized
-    ...normalizeIstanbulCoverage(istanbulCoverageFromMissedFiles, projectDirectoryUrl),
+    ...normalizeIstanbulCoverage(
+      istanbulCoverageFromMissedFiles,
+      projectDirectoryUrl,
+    ),
   }
 }
 
 const listRelativeFileUrlToCover = async ({
-  cancellationToken,
+  multipleExecutionsOperation,
   projectDirectoryUrl,
   coverageConfig,
 }) => {
@@ -67,7 +84,7 @@ const listRelativeFileUrlToCover = async ({
   }
 
   const matchingFileResultArray = await collectFiles({
-    cancellationToken,
+    signal: multipleExecutionsOperation.signal,
     directoryUrl: projectDirectoryUrl,
     structuredMetaMap: structuredMetaMapForCoverage,
     predicate: ({ cover }) => cover,
@@ -85,7 +102,8 @@ const executionReportToCoverage = async (
   Object.keys(report).forEach((file) => {
     const executionResultForFile = report[file]
     Object.keys(executionResultForFile).forEach((executionName) => {
-      const executionResultForFileOnRuntime = executionResultForFile[executionName]
+      const executionResultForFileOnRuntime =
+        executionResultForFile[executionName]
 
       const { status, coverage } = executionResultForFileOnRuntime
       if (!coverage) {
@@ -108,7 +126,9 @@ const executionReportToCoverage = async (
         // that were suppose to be coverage but were not.
 
         if (status === "completed") {
-          logger.warn(`No execution.coverage from execution named "${executionName}" of ${file}`)
+          logger.warn(
+            `No execution.coverage from execution named "${executionName}" of ${file}`,
+          )
         }
         return
       }

package/src/internal/executing/coverage/v8CoverageFromNodeV8Directory.js

@@ -26,15 +26,11 @@ export const v8CoverageFromNodeV8Directory = async ({
 }
 
 const readV8CoverageReportsFromDirectory = async (coverageDirectory) => {
-  const tryReadDirectory = async (timeSpentTrying = 0) => {
+  const tryReadDirectory = async () => {
     const dirContent = await readDirectory(coverageDirectory)
     if (dirContent.length > 0) {
       return dirContent
     }
-    if (timeSpentTrying < 800) {
-      await new Promise((resolve) => setTimeout(resolve, 100))
-      return tryReadDirectory(timeSpentTrying + 100)
-    }
     console.warn(`v8 coverage directory is empty at ${coverageDirectory}`)
     return dirContent
   }
@@ -45,20 +41,11 @@ const readV8CoverageReportsFromDirectory = async (coverageDirectory) => {
   await Promise.all(
     dirContent.map(async (dirEntry) => {
       const dirEntryUrl = resolveUrl(dirEntry, coverageDirectoryUrl)
-      const tryReadJsonFile = async (timeSpentTrying = 0) => {
+      const tryReadJsonFile = async () => {
         try {
           const fileContent = await readFile(dirEntryUrl, { as: "json" })
           return fileContent
         } catch (e) {
-          if (e.name === "SyntaxError") {
-            // If there is a syntax error it's likely because Node.js
-            // is not done writing the json file content
-            // -> let's retry to read file after 100ms
-            if (timeSpentTrying < 100) {
-              await new Promise((resolve) => setTimeout(resolve, 100))
-              return tryReadJsonFile(timeSpentTrying + 100)
-            }
-          }
           console.warn(
             createDetailedMessage(`Error while reading coverage file`, {
               "error stack": e.stack,