@jsenv/core 25.6.2 → 27.0.0-alpha.0

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

@@ -1,264 +0,0 @@
-import { fileURLToPath } from "node:url"
-import { readFileSync, statSync } from "node:fs"
-import { resolveUrl, bufferToEtag } from "@jsenv/filesystem"
-
-export const validateCache = async ({
-  compiledFileUrl,
-  compileCacheStrategy,
-  compileCacheSourcesValidation = true,
-  // When "compileCacheAssetsValidation" is enabled, code ensures that
-  // - asset file exists
-  // - asset file content matches an etag generated when the file was compiled
-  // In practice a compiled file asset is a sourcemap file or a coverage.json file.
-  // It's unlikely that something or someone would update an asset file
-  // and even when it happens it would be a bit strict to invalidate the cache
-  // so by default "compileCacheAssetsValidation" is disabled
-  // to avoid checking things for nothing
-  compileCacheAssetsValidation = false,
-  request,
-}) => {
-  const validity = { isValid: true }
-
-  const metaJsonFileUrl = `${compiledFileUrl}__asset__meta.json`
-  const metaValidity = await validateMetaFile(metaJsonFileUrl)
-  mergeValidity(validity, "meta", metaValidity)
-  if (!validity.isValid) {
-    return validity
-  }
-
-  const compiledFileValidation = await validateCompiledFile({
-    compiledFileUrl,
-    request,
-    compileCacheStrategy,
-  })
-  mergeValidity(validity, "compiledFile", compiledFileValidation)
-  if (!validity.isValid) {
-    return validity
-  }
-
-  const meta = metaValidity.data
-  const [sourcesValidity, assetsValidity] = await Promise.all([
-    compileCacheSourcesValidation
-      ? validateSources({
-          meta,
-          metaJsonFileUrl,
-        })
-      : { isValid: true, code: "SOURCES_VALIDATION_DISABLED" },
-    compileCacheAssetsValidation
-      ? validateAssets({
-          meta,
-          metaJsonFileUrl,
-        })
-      : { isValid: true, code: "ASSETS_VALIDATION_DISABLED" },
-  ])
-  mergeValidity(validity, "sources", sourcesValidity)
-  if (!validity.valid) {
-    return validity
-  }
-  mergeValidity(validity, "assets", assetsValidity)
-
-  return validity
-}
-
-const mergeValidity = (parentValidity, childValidityName, childValidity) => {
-  parentValidity.isValid = childValidity.isValid
-  if (childValidity.code) parentValidity.code = childValidity.code
-  parentValidity[childValidityName] = childValidity
-}
-
-const validateMetaFile = async (metaJsonFileUrl) => {
-  const validity = { isValid: true, data: {} }
-
-  let metaJsonBuffer
-  try {
-    metaJsonBuffer = readFileSync(fileURLToPath(metaJsonFileUrl))
-  } catch (error) {
-    if (error && error.code === "ENOENT") {
-      validity.isValid = false
-      validity.code = "META_FILE_NOT_FOUND"
-      return validity
-    }
-    throw error
-  }
-
-  const metaJsonString = String(metaJsonBuffer)
-  let meta
-  try {
-    meta = JSON.parse(metaJsonString)
-  } catch (error) {
-    if (error && error.name === "SyntaxError") {
-      validity.isValid = false
-      validity.code = "META_FILE_SYNTAX_ERROR"
-      return validity
-    }
-    throw error
-  }
-
-  validity.data = meta
-  if (meta.sources.length === 0) {
-    validity.isValid = false
-    validity.code = "SOURCES_EMPTY"
-    return validity
-  }
-
-  return validity
-}
-
-const validateCompiledFile = async ({
-  compiledFileUrl,
-  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 (!clientCacheDisabled && compileCacheStrategy === "etag") {
-      const compiledEtag = bufferToEtag(compiledSourceBuffer)
-      validity.data.compiledEtag = compiledEtag
-      const ifNoneMatch = request.headers["if-none-match"]
-      if (ifNoneMatch && ifNoneMatch !== compiledEtag) {
-        validity.isValid = false
-        validity.code = "COMPILED_FILE_ETAG_MISMATCH"
-        return validity
-      }
-    }
-
-    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)
-      ) {
-        validity.isValid = false
-        validity.code = "COMPILED_FILE_MTIME_OUTDATED"
-        return validity
-      }
-    }
-
-    return validity
-  } catch (error) {
-    if (error && error.code === "ENOENT") {
-      validity.isValid = false
-      validity.code = "COMPILED_FILE_NOT_FOUND"
-      return validity
-    }
-    throw error
-  }
-}
-
-const validateSources = async ({ meta, metaJsonFileUrl }) => {
-  const sourcesValidity = { isValid: true }
-  await Promise.all(
-    meta.sources.map(async (source, index) => {
-      const sourceValidity = await validateSource({
-        metaJsonFileUrl,
-        source,
-        eTag: meta.sourcesEtag[index],
-      })
-      mergeValidity(sourcesValidity, source, sourceValidity)
-    }),
-  )
-  return sourcesValidity
-}
-
-const validateSource = async ({ metaJsonFileUrl, source, eTag }) => {
-  const validity = { isValid: true, data: {} }
-  const sourceFileUrl = resolveUrl(source, metaJsonFileUrl)
-
-  try {
-    const sourceBuffer = readFileSync(fileURLToPath(sourceFileUrl))
-    const sourceETag = bufferToEtag(sourceBuffer)
-    validity.data.sourceBuffer = sourceBuffer
-    validity.data.sourceETag = sourceETag
-
-    if (sourceETag !== eTag) {
-      validity.isValid = false
-      validity.code = "SOURCE_ETAG_MISMATCH"
-      return validity
-    }
-
-    return validity
-  } catch (e) {
-    if (e && e.code === "ENOENT") {
-      // missing source invalidates the cache because
-      // we cannot check its validity
-      // HOWEVER inside writeMeta we will check if a source can be found
-      // when it cannot we will not put it as a dependency
-      // to invalidate the cache.
-      // It is important because some files are constructed on other files
-      // which are not truly on the filesystem
-      // (IN theory the above happens only for convertCommonJsWithRollup because jsenv
-      // always have a concrete file especially to avoid that kind of thing)
-      validity.isValid = false
-      validity.code = "SOURCE_NOT_FOUND"
-      return validity
-    }
-    throw e
-  }
-}
-
-const validateAssets = async ({ metaJsonFileUrl, meta }) => {
-  const assetsValidity = { isValid: true }
-  await Promise.all(
-    meta.assets.map(async (asset, index) => {
-      const assetValidity = await validateAsset({
-        asset,
-        metaJsonFileUrl,
-        eTag: meta.assetsEtag[index],
-      })
-      mergeValidity(assetsValidity, asset, assetValidity)
-    }),
-  )
-  return assetsValidity
-}
-
-const validateAsset = async ({ asset, metaJsonFileUrl, eTag }) => {
-  const validity = { isValid: true, data: {} }
-  const assetFileUrl = resolveUrl(asset, metaJsonFileUrl)
-
-  try {
-    const assetBuffer = readFileSync(fileURLToPath(assetFileUrl))
-    const assetContentETag = bufferToEtag(assetBuffer)
-    validity.data.buffer = assetBuffer
-    validity.data.etag = assetContentETag
-
-    if (eTag !== assetContentETag) {
-      validity.isValid = false
-      validity.code = "ASSET_ETAG_MISMATCH"
-      return validity
-    }
-
-    return validity
-  } catch (error) {
-    if (error && error.code === "ENOENT") {
-      validity.isValid = false
-      validity.code = "ASSET_FILE_NOT_FOUND"
-      return validity
-    }
-    throw error
-  }
-}
-
-const dateToSecondsPrecision = (date) => {
-  const dateWithSecondsPrecision = new Date(date)
-  dateWithSecondsPrecision.setMilliseconds(0)
-  return dateWithSecondsPrecision
-}

package/src/internal/compiling/load_babel_plugin_map_from_file.js

@@ -1,49 +0,0 @@
-import {
-  isFileSystemPath,
-  fileSystemPathToUrl,
-  urlToFileSystemPath,
-} from "@jsenv/filesystem"
-
-export const loadBabelPluginMapFromFile = async ({
-  projectDirectoryUrl,
-  babelConfigFileUrl,
-}) => {
-  const babelOptions = await loadBabelOptionsFromFile({
-    projectDirectoryUrl,
-    babelConfigFileUrl,
-  })
-
-  const babelPluginMap = {}
-  babelOptions.plugins.forEach((plugin) => {
-    const babelPluginName = babelPluginNameFromPlugin(plugin)
-    babelPluginMap[babelPluginName] = plugin
-  })
-
-  return babelPluginMap
-}
-
-const loadBabelOptionsFromFile = async ({
-  projectDirectoryUrl,
-  babelConfigFileUrl,
-}) => {
-  const { loadOptionsAsync } = await import("@babel/core")
-  const babelOptions = await loadOptionsAsync({
-    cwd: urlToFileSystemPath(projectDirectoryUrl),
-    configFile: babelConfigFileUrl
-      ? urlToFileSystemPath(babelConfigFileUrl)
-      : undefined,
-  })
-  return babelOptions
-}
-
-const babelPluginNameFromPlugin = ({ key }) => {
-  if (
-    isFileSystemPath(key) &&
-    fileSystemPathToUrl(key).endsWith(
-      "babel-plugin-transform-async-to-promises/async-to-promises.js",
-    )
-  ) {
-    return "transform-async-to-promises"
-  }
-  return key
-}

package/src/internal/compiling/rollup_plugin_commonjs_named_exports.js

@@ -1,187 +0,0 @@
-// https://github.com/snowpackjs/snowpack/blob/main/esinstall/src/rollup-plugins/rollup-plugin-wrap-install-targets.ts
-
-import { readFileSync } from "node:fs"
-import { fileURLToPath } from "node:url"
-import { VM as VM2 } from "vm2"
-import isValidIdentifier from "is-valid-identifier"
-import resolve from "resolve"
-import { init, parse } from "cjs-module-lexer"
-import { fileSystemPathToUrl } from "@jsenv/filesystem"
-
-export const rollupPluginCommonJsNamedExports = ({ logger }) => {
-  const inputSummaries = {}
-  const cjsScannedNamedExports = {}
-
-  return {
-    async buildStart({ input }) {
-      await init()
-
-      Object.keys(input).forEach((key) => {
-        const inputFilePath = input[key]
-        const inputFileUrl = fileSystemPathToUrl(inputFilePath)
-        inputSummaries[inputFileUrl] = {
-          all: true,
-          default: true,
-          namespace: true,
-          named: [],
-        }
-
-        const cjsExports =
-          detectStaticExports({ logger, fileUrl: inputFileUrl }) ||
-          detectExportsUsingSandboxedRuntime({ logger, fileUrl: inputFileUrl })
-
-        if (cjsExports && cjsExports.length) {
-          cjsScannedNamedExports[inputFileUrl] = cjsExports
-        }
-        input[key] = `jsenv:${inputFileUrl}`
-      })
-    },
-    resolveId(source) {
-      if (source.startsWith("jsenv:")) {
-        return source
-      }
-
-      return null
-    },
-    load(id) {
-      if (!id.startsWith("jsenv:")) {
-        return null
-      }
-
-      const inputFileUrl = id.substring("jsenv:".length)
-      const inputSummary = inputSummaries[inputFileUrl]
-      let uniqueNamedExports = inputSummary.named
-      const scannedNamedExports = cjsScannedNamedExports[inputFileUrl]
-      if (scannedNamedExports) {
-        uniqueNamedExports = scannedNamedExports || []
-        inputSummary.default = true
-      }
-      const codeForExports = generateCodeForExports({
-        uniqueNamedExports,
-        inputSummary,
-        inputFileUrl,
-      })
-      return codeForExports
-    },
-  }
-}
-
-/*
- * Attempt #1: Static analysis: Lower Fidelity, but faster.
- * Do our best job to statically scan a file for named exports. This uses "cjs-module-lexer", the
- * same CJS export scanner that Node.js uses internally. Very fast, but only works on some modules,
- * depending on how they were build/written/compiled.
- */
-const detectStaticExports = ({ logger, fileUrl, visited = new Set() }) => {
-  const isMainEntrypoint = visited.size === 0
-  // Prevent infinite loops via circular dependencies.
-  if (visited.has(fileUrl)) {
-    return []
-  }
-  visited.add(fileUrl)
-
-  const fileContents = readFileSync(new URL(fileUrl), "utf8")
-  try {
-    const { exports, reexports } = parse(fileContents)
-    // If re-exports were detected (`exports.foo = require(...)`) then resolve them here.
-    let resolvedReexports = []
-    if (reexports.length > 0) {
-      reexports.forEach((reexport) => {
-        const reExportedFilePath = resolve.sync(reexport, {
-          basedir: fileURLToPath(new URL("./", fileUrl)),
-        })
-        const reExportedFileUrl = fileSystemPathToUrl(reExportedFilePath)
-        const staticExports = detectStaticExports({
-          logger,
-          fileUrl: reExportedFileUrl,
-          visited,
-        })
-        if (staticExports) {
-          resolvedReexports = [...resolvedReexports, ...staticExports]
-        }
-      })
-    }
-    const resolvedExports = Array.from(
-      new Set([...exports, ...resolvedReexports]),
-    ).filter(isValidNamedExport)
-
-    if (isMainEntrypoint && resolvedExports.length === 0) {
-      return undefined
-    }
-
-    return resolvedExports
-  } catch (err) {
-    // Safe to ignore, this is usually due to the file not being CJS.
-    logger.debug(`detectStaticExports ${fileUrl}: ${err.message}`)
-    return undefined
-  }
-}
-
-/*
- * Attempt #2b - Sandboxed runtime analysis: More powerful, but slower.
- * This will only work on UMD and very simple CJS files (require not supported).
- * Uses VM2 to run safely sandbox untrusted code (no access no Node.js primitives, just JS).
- * If nothing was detected, return undefined.
- */
-const detectExportsUsingSandboxedRuntime = ({ logger, fileUrl }) => {
-  try {
-    const fileContents = readFileSync(new URL(fileUrl), "utf8")
-    const vm = new VM2({ wasm: false, fixAsync: false })
-    const codeToRun = wrapCodeToRunInVm(fileContents)
-    const vmResult = vm.run(codeToRun)
-    const exportsResult = Object.keys(vmResult)
-    logger.debug(
-      `detectExportsUsingSandboxedRuntime success ${fileUrl}: ${exportsResult}`,
-    )
-    return exportsResult.filter((identifier) => isValidIdentifier(identifier))
-  } catch (err) {
-    logger.debug(
-      `detectExportsUsingSandboxedRuntime error ${fileUrl}: ${err.message}`,
-    )
-    return undefined
-  }
-}
-
-const isValidNamedExport = (name) =>
-  name !== "default" && name !== "__esModule" && isValidIdentifier(name)
-
-const wrapCodeToRunInVm = (code) => {
-  return `const exports = {};
-const module = { exports };
-${code};;
-module.exports;`
-}
-
-const generateCodeForExports = ({
-  uniqueNamedExports,
-  inputSummary,
-  inputFileUrl,
-}) => {
-  const from =
-    process.platform === "win32"
-      ? inputFileUrl.slice("file:///".length)
-      : inputFileUrl.slice("file://".length)
-  const lines = [
-    ...(inputSummary.namespace ? [stringifyNamespaceReExport({ from })] : []),
-    ...(inputSummary.default ? [stringifyDefaultReExport({ from })] : []),
-    stringifyNamedReExports({
-      namedExports: uniqueNamedExports,
-      from,
-    }),
-  ]
-  return lines.join(`
-`)
-}
-
-const stringifyNamespaceReExport = ({ from }) => {
-  return `export * from "${from}";`
-}
-
-const stringifyDefaultReExport = ({ from }) => {
-  return `import __jsenv_default_import__ from "${from}";
-export default __jsenv_default_import__;`
-}
-
-const stringifyNamedReExports = ({ namedExports, from }) => {
-  return `export { ${namedExports.join(",")} } from "${from}";`
-}