@jsenv/core 23.6.1 → 23.8.0

package/src/internal/compiling/babel_plugin_import_visitor.js

@@ -0,0 +1,84 @@
+/*
+ * Not meant to be used directly
+ * Will be used either to put import specifier in metadata
+ * or to transform import specifiers
+ *
+ * see also
+ * https://github.com/jamiebuilds/babel-handbook/blob/master/translations/en/plugin-handbook.md
+ * https://github.com/mjackson/babel-plugin-import-visitor
+ *
+ */
+
+export const babelPluginImportVisitor = (babel, importVisitor = () => {}) => {
+  return {
+    name: "import-visitor",
+
+    // manipulateOptions(opts, parserOpts) {
+    //   parserOpts.plugins.push(
+    //     "dynamicImport",
+    //     "exportDefaultFrom",
+    //     "exportNamespaceFrom",
+    //     "importMeta",
+    //   )
+    // },
+
+    visitor: {
+      CallExpression: (path, state) => {
+        if (path.node.callee.type !== "Import") {
+          // Some other function call, not import();
+          return
+        }
+
+        if (path.node.arguments[0].type !== "StringLiteral") {
+          // Non-string argument, probably a variable or expression, e.g.
+          // import(moduleId)
+          // import('./' + moduleName)
+          return
+        }
+
+        importVisitor({
+          importPath: path,
+          specifierPath: path.get("arguments")[0],
+          state,
+          babel,
+        })
+      },
+
+      ExportAllDeclaration: (path, state) => {
+        importVisitor({
+          importPath: path,
+          specifierPath: path.get("source"),
+          state,
+          babel,
+        })
+      },
+
+      ExportNamedDeclaration: (path, state) => {
+        if (!path.node.source) {
+          // This export has no "source", so it's probably
+          // a local variable or function, e.g.
+          // export { varName }
+          // export const constName = ...
+          // export function funcName() {}
+          return
+        }
+
+        importVisitor({
+          importPath: path,
+          specifierPath: path.get("source"),
+          state,
+          babel,
+        })
+      },
+
+      ImportDeclaration: (path, state) => {
+        importVisitor({
+          importPath: path,
+          specifierPath: path.get("source"),
+          state,
+          babel,
+        })
+      },
+    },
+  }
+}

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

@@ -1,265 +1,268 @@
-import { urlToFileSystemPath } from "@jsenv/filesystem"
-import { createDetailedMessage } from "@jsenv/logger"
-import { timeStart, timeFunction } from "@jsenv/server"
-import { readFileContent } from "./fs-optimized-for-cache.js"
-import { validateCache } from "./validateCache.js"
-import { getMetaJsonFileUrl } from "./compile-asset.js"
-import { createLockRegistry } from "./createLockRegistry.js"
-
-const { lockForRessource } = createLockRegistry()
-
-export const getOrGenerateCompiledFile = async ({
-  logger,
-
-  projectDirectoryUrl,
-  originalFileUrl,
-  compiledFileUrl = originalFileUrl,
-  compileCacheStrategy,
-  compileCacheSourcesValidation,
-  compileCacheAssetsValidation,
-  fileContentFallback,
-  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({
-          originalFileUrl,
-          compiledFileUrl,
-          compile,
-          fileContentFallback,
-          compileCacheStrategy,
-          compileCacheSourcesValidation,
-          compileCacheAssetsValidation,
-          request,
-          logger,
-        })
-
-      return {
-        meta,
-        compileResult,
-        compileResultStatus,
-        timing: {
-          ...lockTiming,
-          ...timing,
-        },
-      }
-    },
-    {
-      compiledFileUrl,
-      logger,
-    },
-  )
-}
-
-const computeCompileReport = async ({
-  originalFileUrl,
-  compiledFileUrl,
-  compile,
-  fileContentFallback,
-  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",
-      //     },
-      //   }
-      // }
-      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.isValid
-
-    const [compileTiming, compileResult] = await timeFunction("compile", () =>
-      callCompile({
-        logger,
-        originalFileUrl,
-        fileContentFallback,
-        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 } = meta
-  return {
-    meta,
-    compileResult: {
-      compiledSource: String(
-        cacheValidity.compiledFile.data.compiledSourceBuffer,
-      ),
-      compiledEtag: cacheValidity.compiledFile.data.compiledEtag,
-      compiledMtime: cacheValidity.compiledFile.data.compiledMtime,
-      contentType,
-      sources,
-      assets,
-    },
-    compileResultStatus: "cached",
-    timing: {
-      ...readCacheTiming,
-    },
-  }
-}
-
-const callCompile = async ({
-  logger,
-  originalFileUrl,
-  fileContentFallback,
-  compile,
-}) => {
-  logger.debug(`compile ${originalFileUrl}`)
-
-  const codeBeforeCompile =
-    compile.length === 0
-      ? ""
-      : await getCodeToCompile({ originalFileUrl, fileContentFallback })
-
-  const compileReturnValue = await compile({
-    code: codeBeforeCompile,
-    map: undefined,
-  })
-  if (typeof compileReturnValue !== "object" || compileReturnValue === null) {
-    throw new TypeError(
-      `compile must return an object, got ${compileReturnValue}`,
-    )
-  }
-  const {
-    contentType,
-    compiledSource,
-    sources = [],
-    sourcesContent = [],
-    assets = [],
-    assetsContent = [],
-    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,
-    responseHeaders,
-  }
-}
-
-const getCodeToCompile = async ({ originalFileUrl, fileContentFallback }) => {
-  let fileContent
-  if (fileContentFallback) {
-    try {
-      fileContent = await readFileContent(originalFileUrl)
-    } catch (e) {
-      if (e.code === "ENOENT") {
-        fileContent = await fileContentFallback()
-      } else {
-        throw e
-      }
-    }
-  } else {
-    fileContent = await readFileContent(originalFileUrl)
-  }
-  return fileContent
-}
-
-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()
-  }
-}
+import { urlToFileSystemPath } from "@jsenv/filesystem"
+import { createDetailedMessage } from "@jsenv/logger"
+import { timeStart, timeFunction } from "@jsenv/server"
+import { readFileContent } from "./fs-optimized-for-cache.js"
+import { validateCache } from "./validateCache.js"
+import { getMetaJsonFileUrl } from "./compile-asset.js"
+import { createLockRegistry } from "./createLockRegistry.js"
+
+const { lockForRessource } = createLockRegistry()
+
+export const getOrGenerateCompiledFile = async ({
+  logger,
+
+  projectDirectoryUrl,
+  originalFileUrl,
+  compiledFileUrl = originalFileUrl,
+  compileCacheStrategy,
+  compileCacheSourcesValidation,
+  compileCacheAssetsValidation,
+  fileContentFallback,
+  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({
+          originalFileUrl,
+          compiledFileUrl,
+          compile,
+          fileContentFallback,
+          compileCacheStrategy,
+          compileCacheSourcesValidation,
+          compileCacheAssetsValidation,
+          request,
+          logger,
+        })
+
+      return {
+        meta,
+        compileResult,
+        compileResultStatus,
+        timing: {
+          ...lockTiming,
+          ...timing,
+        },
+      }
+    },
+    {
+      compiledFileUrl,
+      logger,
+    },
+  )
+}
+
+const computeCompileReport = async ({
+  originalFileUrl,
+  compiledFileUrl,
+  compile,
+  fileContentFallback,
+  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",
+      //     },
+      //   }
+      // }
+      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.isValid
+
+    const [compileTiming, compileResult] = await timeFunction("compile", () =>
+      callCompile({
+        logger,
+        originalFileUrl,
+        fileContentFallback,
+        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,
+  originalFileUrl,
+  fileContentFallback,
+  compile,
+}) => {
+  logger.debug(`compile ${originalFileUrl}`)
+
+  const codeBeforeCompile =
+    compile.length === 0
+      ? ""
+      : await getCodeToCompile({ originalFileUrl, fileContentFallback })
+
+  const compileReturnValue = await compile({
+    code: codeBeforeCompile,
+    map: undefined,
+  })
+  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 getCodeToCompile = async ({ originalFileUrl, fileContentFallback }) => {
+  let fileContent
+  if (fileContentFallback) {
+    try {
+      fileContent = await readFileContent(originalFileUrl)
+    } catch (e) {
+      if (e.code === "ENOENT") {
+        fileContent = await fileContentFallback()
+      } else {
+        throw e
+      }
+    }
+  } else {
+    fileContent = await readFileContent(originalFileUrl)
+  }
+  return fileContent
+}
+
+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()
+  }
+}