@jsenv/core 25.6.2 → 27.0.0-alpha.0

package/src/internal/compiling/jsenv_directory/getOrGenerateCompiledFile.js

@@ -1,269 +0,0 @@
-import { timeStart, timeFunction } from "@jsenv/server"
-import { urlToFileSystemPath, readFile } from "@jsenv/filesystem"
-import { createDetailedMessage } from "@jsenv/logger"
-
-import { validateCache } from "./validateCache.js"
-import { getMetaJsonFileUrl } from "./compile_asset.js"
-import { createLockRegistry } from "./file_lock_registry.js"
-
-const { lockForRessource } = createLockRegistry()
-
-export const getOrGenerateCompiledFile = async ({
-  logger,
-
-  projectDirectoryUrl,
-  originalFileUrl,
-  compiledFileUrl = originalFileUrl,
-  jsenvRemoteDirectory,
-
-  compileCacheStrategy,
-  compileCacheSourcesValidation,
-  compileCacheAssetsValidation,
-  request,
-  compile,
-}) => {
-  if (typeof projectDirectoryUrl !== "string") {
-    throw new TypeError(
-      `projectDirectoryUrl must be a string, got ${projectDirectoryUrl}`,
-    )
-  }
-  if (typeof originalFileUrl !== "string") {
-    throw new TypeError(
-      `originalFileUrl must be a string, got ${originalFileUrl}`,
-    )
-  }
-  if (!originalFileUrl.startsWith(projectDirectoryUrl)) {
-    throw new Error(
-      createDetailedMessage(`origin file must be inside project`, {
-        ["original file url"]: originalFileUrl,
-        ["project directory url"]: projectDirectoryUrl,
-      }),
-    )
-  }
-  if (typeof compiledFileUrl !== "string") {
-    throw new TypeError(
-      `compiledFileUrl must be a string, got ${compiledFileUrl}`,
-    )
-  }
-  if (!compiledFileUrl.startsWith(projectDirectoryUrl)) {
-    throw new Error(
-      createDetailedMessage(`compiled file must be inside project`, {
-        ["compiled file url"]: compiledFileUrl,
-        ["project directory url"]: projectDirectoryUrl,
-      }),
-    )
-  }
-  if (typeof compile !== "function") {
-    throw new TypeError(`compile must be a function, got ${compile}`)
-  }
-
-  const lockTimeEnd = timeStart("lock")
-  return startAsap(
-    async () => {
-      const lockTiming = lockTimeEnd()
-      const { meta, compileResult, compileResultStatus, timing } =
-        await computeCompileReport({
-          projectDirectoryUrl,
-          originalFileUrl,
-          compiledFileUrl,
-          jsenvRemoteDirectory,
-
-          compile,
-          compileCacheStrategy,
-          compileCacheSourcesValidation,
-          compileCacheAssetsValidation,
-          request,
-          logger,
-        })
-
-      return {
-        meta,
-        compileResult,
-        compileResultStatus,
-        timing: {
-          ...lockTiming,
-          ...timing,
-        },
-      }
-    },
-    {
-      compiledFileUrl,
-      logger,
-    },
-  )
-}
-
-const computeCompileReport = async ({
-  // projectDirectoryUrl,
-  logger,
-  originalFileUrl,
-  compiledFileUrl,
-  jsenvRemoteDirectory,
-
-  compile,
-  compileCacheStrategy,
-  compileCacheSourcesValidation,
-  compileCacheAssetsValidation,
-  request,
-}) => {
-  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",
-      //     },
-      //   }
-      // }
-      return validateCache({
-        logger,
-        compiledFileUrl,
-        compileCacheStrategy,
-        compileCacheSourcesValidation,
-        compileCacheAssetsValidation,
-        request,
-      })
-    },
-  )
-
-  if (!cacheValidity.isValid) {
-    if (cacheValidity.code === "SOURCES_EMPTY") {
-      logger.warn(`WARNING: meta.sources is empty for ${compiledFileUrl}`)
-    }
-
-    const metaIsValid = cacheValidity.meta ? cacheValidity.meta.isValid : false
-
-    const fetchOriginalFile = async () => {
-      // The original file might be behind an http url.
-      // In that case jsenv try first to read file from filesystem
-      // in ".jsenv/.http/" directory. If not found, the url
-      // is fetched and file is written in that ".jsenv/.http/" directory.
-      // After that the only way to re-fetch this ressource is
-      // to delete the content of ".jsenv/.http/"
-      try {
-        const code = await readFile(originalFileUrl)
-        return { code }
-      } catch (e) {
-        // when file is not found and the file is referenced with an http url
-        if (
-          e &&
-          e.code === "ENOENT" &&
-          jsenvRemoteDirectory.isFileUrlForRemoteUrl(originalFileUrl)
-        ) {
-          const responseBodyAsBuffer =
-            await jsenvRemoteDirectory.loadFileUrlFromRemote(
-              originalFileUrl,
-              request,
-            )
-          const code = String(responseBodyAsBuffer)
-          return { code }
-        }
-        throw e
-      }
-    }
-    const { code } = await fetchOriginalFile()
-    const [compileTiming, compileResult] = await timeFunction("compile", () =>
-      callCompile({
-        logger,
-        originalFileUrl,
-        code,
-        compile,
-      }),
-    )
-
-    return {
-      meta: metaIsValid ? cacheValidity.meta.data : null,
-      compileResult,
-      compileResultStatus: metaIsValid ? "updated" : "created",
-      timing: {
-        ...readCacheTiming,
-        ...compileTiming,
-      },
-    }
-  }
-
-  const meta = cacheValidity.meta.data
-  const { contentType, sources, assets, dependencies } = meta
-  return {
-    meta,
-    compileResult: {
-      compiledSource: String(
-        cacheValidity.compiledFile.data.compiledSourceBuffer,
-      ),
-      compiledEtag: cacheValidity.compiledFile.data.compiledEtag,
-      compiledMtime: cacheValidity.compiledFile.data.compiledMtime,
-      contentType,
-      sources,
-      assets,
-      dependencies,
-    },
-    compileResultStatus: "cached",
-    timing: {
-      ...readCacheTiming,
-    },
-  }
-}
-
-const callCompile = async ({ logger, code, originalFileUrl, compile }) => {
-  logger.debug(`compile ${originalFileUrl}`)
-  const compileReturnValue = await compile({ code })
-  if (typeof compileReturnValue !== "object" || compileReturnValue === null) {
-    throw new TypeError(
-      `compile must return an object, got ${compileReturnValue}`,
-    )
-  }
-  const {
-    contentType,
-    compiledSource,
-    sources = [],
-    sourcesContent = [],
-    assets = [],
-    assetsContent = [],
-    dependencies = [],
-    responseHeaders,
-  } = compileReturnValue
-  if (typeof contentType !== "string") {
-    throw new TypeError(
-      `compile must return a contentType string, got ${contentType}`,
-    )
-  }
-  if (typeof compiledSource !== "string") {
-    throw new TypeError(
-      `compile must return a compiledSource string, got ${compiledSource}`,
-    )
-  }
-  return {
-    contentType,
-    compiledSource,
-    sources,
-    sourcesContent,
-    assets,
-    assetsContent,
-    dependencies,
-    responseHeaders,
-  }
-}
-
-const startAsap = async (fn, { logger, compiledFileUrl }) => {
-  const metaJsonFileUrl = getMetaJsonFileUrl(compiledFileUrl)
-  const metaJsonFilePath = urlToFileSystemPath(metaJsonFileUrl)
-
-  logger.debug(`lock ${metaJsonFilePath}`)
-  // in case this process try to concurrently access meta we wait for previous to be done
-  const unlockLocal = await lockForRessource(metaJsonFilePath)
-
-  let unlockInterProcessLock = () => {}
-
-  try {
-    return await fn()
-  } finally {
-    // we want to unlock in case of error too
-    logger.debug(`unlock ${metaJsonFilePath}`)
-    unlockLocal()
-    unlockInterProcessLock()
-  }
-}

package/src/internal/compiling/jsenv_directory/jsenv_directory.js

@@ -1,174 +0,0 @@
-import {
-  resolveUrl,
-  readFile,
-  writeFile,
-  ensureEmptyDirectory,
-} from "@jsenv/filesystem"
-
-import { compareCompileContexts } from "./compile_context.js"
-import { compareCompileProfiles } from "./compile_profile.js"
-
-export const setupJsenvDirectory = async ({
-  logger,
-  projectDirectoryUrl,
-  jsenvDirectoryRelativeUrl,
-  jsenvDirectoryClean,
-  compileServerCanWriteOnFilesystem,
-  compileContext,
-}) => {
-  const jsenvDirectoryUrl = resolveUrl(
-    jsenvDirectoryRelativeUrl,
-    projectDirectoryUrl,
-  )
-  const jsenvDirectoryMetaFileUrl = resolveUrl(
-    "__jsenv_meta__.json",
-    jsenvDirectoryUrl,
-  )
-  const compileDirectories = {}
-  const jsenvDirectoryMeta = {
-    jsenvDirectoryRelativeUrl,
-    compileContext,
-    compileDirectories,
-  }
-
-  const writeMetaFile = async () => {
-    await writeFile(
-      jsenvDirectoryMetaFileUrl,
-      JSON.stringify(jsenvDirectoryMeta, null, "  "),
-    )
-  }
-
-  if (compileServerCanWriteOnFilesystem) {
-    if (jsenvDirectoryClean) {
-      await ensureEmptyDirectory(jsenvDirectoryUrl)
-    }
-    await applyFileSystemEffects({
-      logger,
-      jsenvDirectoryUrl,
-      jsenvDirectoryMetaFileUrl,
-      writeMetaFile,
-      jsenvDirectoryMeta,
-    })
-  }
-
-  /*
-   * This function try to reuse existing compiled id
-   * (the goal being to reuse file that would be in a corresponding compile directory)
-   * To decide if we reuse a compile directory we need to know
-   * how the files inside that directory where generated
-   * and if what we want matches what we have, the compile id is reused
-   *
-   * Note: some parameters means only a subset of files would be invalid
-   * but to keep things simple the whole directory is ignored
-   */
-  const getOrCreateCompileId = async ({
-    runtimeName,
-    runtimeVersion,
-    compileProfile,
-  }) => {
-    const missingFeatureNames = Object.keys(compileProfile.missingFeatures)
-    if (missingFeatureNames.length === 0) {
-      return null
-    }
-    const existingCompileIds = Object.keys(compileDirectories)
-    const existingCompileId = existingCompileIds.find((compileIdCandidate) => {
-      const compileDirectoryCandidate = compileDirectories[compileIdCandidate]
-      return compareCompileProfiles(
-        compileDirectoryCandidate.compileProfile,
-        compileProfile,
-      )
-    })
-    const runtime = `${runtimeName}@${runtimeVersion}`
-    if (existingCompileId) {
-      const compileDirectory = compileDirectories[existingCompileId]
-      const { runtimes } = compileDirectory
-      if (!runtimes.includes(runtime)) {
-        runtimes.push(runtime)
-        writeMetaFile()
-      }
-      return existingCompileId
-    }
-    const compileIdBase = generateCompileId({ compileProfile })
-    let compileId = compileIdBase
-    let integer = 1
-    while (existingCompileIds.includes(compileId)) {
-      compileId = `${compileIdBase}_${integer}`
-      integer++
-    }
-    compileDirectories[compileId] = {
-      compileProfile,
-      runtimes: [runtime],
-    }
-    await writeMetaFile()
-    return compileId
-  }
-
-  return {
-    compileDirectories,
-    getOrCreateCompileId,
-  }
-}
-
-const generateCompileId = ({ compileProfile }) => {
-  if (compileProfile.missingFeatures["transform-instrument"]) {
-    return `out_instrumented`
-  }
-  return `out`
-}
-
-const applyFileSystemEffects = async ({
-  logger,
-  jsenvDirectoryUrl,
-  jsenvDirectoryMetaFileUrl,
-  jsenvDirectoryMeta,
-  writeMetaFile,
-}) => {
-  try {
-    const source = await readFile(jsenvDirectoryMetaFileUrl)
-    if (source === "") {
-      logger.warn(
-        `${jsenvDirectoryMetaFileUrl} is empty -> clean ${jsenvDirectoryUrl} directory`,
-      )
-      await ensureEmptyDirectory(jsenvDirectoryUrl)
-      await writeMetaFile()
-      return
-    }
-    const jsenvDirectoryMetaPrevious = JSON.parse(source)
-    if (
-      !compareCompileContexts(
-        jsenvDirectoryMetaPrevious.compileContext,
-        jsenvDirectoryMeta.compileContext,
-      )
-    ) {
-      logger.debug(
-        `compile context has changed -> clean ${jsenvDirectoryUrl} directory`,
-      )
-      await ensureEmptyDirectory(jsenvDirectoryUrl)
-      await writeMetaFile()
-      return
-    }
-    // reuse existing compile directories
-    Object.assign(
-      jsenvDirectoryMeta.compileDirectories,
-      jsenvDirectoryMetaPrevious.compileDirectories,
-    )
-  } catch (e) {
-    if (e.code === "ENOENT") {
-      logger.debug(
-        `${jsenvDirectoryMetaFileUrl} not found -> clean ${jsenvDirectoryUrl} directory`,
-      )
-      await ensureEmptyDirectory(jsenvDirectoryUrl)
-      await writeMetaFile()
-      return
-    }
-    if (e.name === "SyntaxError") {
-      logger.warn(
-        `${jsenvDirectoryMetaFileUrl} syntax error -> clean ${jsenvDirectoryUrl} directory`,
-      )
-      await ensureEmptyDirectory(jsenvDirectoryUrl)
-      await writeMetaFile()
-      return
-    }
-    throw e
-  }
-}

package/src/internal/compiling/jsenv_directory/updateMeta.js

@@ -1,150 +0,0 @@
-import {
-  urlToRelativeUrl,
-  urlToFileSystemPath,
-  bufferToEtag,
-} from "@jsenv/filesystem"
-import { utimesSync } from "node:fs"
-
-import { writeFileContent, testFilePresence } from "./fs-optimized-for-cache.js"
-import { getMetaJsonFileUrl } from "./compile_asset.js"
-
-export const updateMeta = async ({
-  logger,
-  meta,
-  compiledFileUrl,
-  compileResult,
-  compileResultStatus,
-}) => {
-  const isNew = compileResultStatus === "created"
-  const isUpdated = compileResultStatus === "updated"
-  const {
-    compiledSource,
-    contentType,
-    sources,
-    sourcesContent,
-    assets,
-    assetsContent,
-    dependencies,
-  } = compileResult
-
-  const promises = []
-  if (isNew || isUpdated) {
-    // ensure source that does not leads to concrete files are not capable to invalidate the cache
-    const sourcesToRemove = sources.filter((sourceFileUrl) => {
-      return (
-        sourceFileUrl.startsWith("file://") && !testFilePresence(sourceFileUrl)
-      )
-    })
-    const sourceNotFoundCount = sourcesToRemove.length
-    if (sourceNotFoundCount > 0) {
-      logger.warn(`SOURCE_META_NOT_FOUND: ${sourceNotFoundCount} source file(s) not found.
---- consequence ---
-cache will be reused even if one of the source file is modified
---- source files not found ---
-${sourcesToRemove.join(`\n`)}`)
-      sourcesToRemove.forEach((url) => {
-        const sourceIndex = sources.indexOf(url)
-        if (sourceIndex) {
-          sources.splice(sourceIndex, 1)
-          sourcesContent.splice(sourceIndex, 1)
-        }
-      })
-    }
-
-    const { writeCompiledSourceFile = true, writeAssetsFile = true } =
-      compileResult
-
-    if (writeCompiledSourceFile) {
-      logger.debug(
-        `write compiled file at ${urlToFileSystemPath(compiledFileUrl)}`,
-      )
-      promises.push(
-        writeFileContent(compiledFileUrl, compiledSource, {
-          fileLikelyNotFound: isNew,
-        }).then(() => {
-          const mtime = compileResult.compiledMtime
-          // when compileResult.compiledMtime do not exists it means
-          // the client is not interested in it so
-          // -> moment we write the file is not important
-          // -> There is no need to update mtime
-          if (mtime) {
-            utimesSync(
-              urlToFileSystemPath(compiledFileUrl),
-              new Date(mtime),
-              new Date(mtime),
-            )
-          }
-        }),
-      )
-    }
-
-    if (writeAssetsFile) {
-      promises.push(
-        ...assets.map((assetFileUrl, index) => {
-          logger.debug(
-            `write compiled file asset at ${urlToFileSystemPath(assetFileUrl)}`,
-          )
-          return writeFileContent(assetFileUrl, assetsContent[index], {
-            fileLikelyNotFound: isNew,
-          })
-        }),
-      )
-    }
-  }
-
-  const metaJsonFileUrl = getMetaJsonFileUrl(compiledFileUrl)
-
-  if (isNew || isUpdated) {
-    let latestMeta
-
-    const sourceAndAssetProps = {
-      sources: sources.map((source) =>
-        urlToRelativeUrl(source, metaJsonFileUrl),
-      ),
-      sourcesEtag: sourcesContent.map((sourceContent) =>
-        bufferToEtag(Buffer.from(sourceContent)),
-      ),
-      assets: assets.map((asset) => urlToRelativeUrl(asset, metaJsonFileUrl)),
-      assetsEtag: assetsContent.map((assetContent) =>
-        bufferToEtag(Buffer.from(assetContent)),
-      ),
-      dependencies: dependencies.filter((dep) => {
-        return !dep.startsWith("data:")
-      }),
-    }
-
-    if (isNew) {
-      latestMeta = {
-        contentType,
-        ...sourceAndAssetProps,
-        createdMs: Number(Date.now()),
-        lastModifiedMs: Number(Date.now()),
-      }
-    } else if (isUpdated) {
-      latestMeta = {
-        ...meta,
-        ...sourceAndAssetProps,
-        lastModifiedMs: Number(Date.now()),
-      }
-    } else {
-      latestMeta = {
-        ...meta,
-      }
-    }
-
-    logger.debug(
-      `write compiled file meta at ${urlToFileSystemPath(metaJsonFileUrl)}`,
-    )
-    promises.push(
-      writeFileContent(
-        metaJsonFileUrl,
-        JSON.stringify(latestMeta, null, "  "),
-        {
-          fileLikelyNotFound: isNew,
-        },
-      ),
-    )
-  }
-
-  return Promise.all(promises)
-}