@vercel/microfrontends 2.2.0 → 2.2.1

package/dist/utils/mfe-port.cjs

@@ -225,6 +225,28 @@ var import_node_fs2 = require("fs");
 var import_jsonc_parser = require("jsonc-parser");
 var import_fast_glob = __toESM(require("fast-glob"), 1);
 
+// src/bin/logger.ts
+function debug(...args) {
+  if (process.env.MFE_DEBUG) {
+    console.log(...args);
+  }
+}
+function info(...args) {
+  console.log(...args);
+}
+function warn(...args) {
+  console.warn(...args);
+}
+function error(...args) {
+  console.error(...args);
+}
+var logger = {
+  debug,
+  info,
+  warn,
+  error
+};
+
 // src/config/microfrontends/utils/get-config-file-name.ts
 var DEFAULT_CONFIGURATION_FILENAMES = [
   "microfrontends.json",
@@ -254,6 +276,10 @@ function findPackageWithMicrofrontendsConfig({
   customConfigFilename
 }) {
   const applicationName = applicationContext.name;
+  logger.debug(
+    "[MFE Config] Searching repository for configs containing application:",
+    applicationName
+  );
   try {
     const microfrontendsJsonPaths = import_fast_glob.default.globSync(
       `**/{${getPossibleConfigurationFilenames({ customConfigFilename }).join(",")}}`,
@@ -265,6 +291,11 @@ function findPackageWithMicrofrontendsConfig({
         ignore: ["**/node_modules/**", "**/.git/**"]
       }
     );
+    logger.debug(
+      "[MFE Config] Found",
+      microfrontendsJsonPaths.length,
+      "config file(s) in repository"
+    );
     const matchingPaths = [];
     for (const microfrontendsJsonPath of microfrontendsJsonPaths) {
       try {
@@ -274,12 +305,20 @@ function findPackageWithMicrofrontendsConfig({
         );
         const microfrontendsJson = (0, import_jsonc_parser.parse)(microfrontendsJsonContent);
         if (microfrontendsJson.applications[applicationName]) {
+          logger.debug(
+            "[MFE Config] Found application in config:",
+            microfrontendsJsonPath
+          );
           matchingPaths.push(microfrontendsJsonPath);
         } else {
           for (const [_, app] of Object.entries(
             microfrontendsJson.applications
           )) {
             if (app.packageName === applicationName) {
+              logger.debug(
+                "[MFE Config] Found application via packageName in config:",
+                microfrontendsJsonPath
+              );
               matchingPaths.push(microfrontendsJsonPath);
             }
           }
@@ -287,6 +326,10 @@ function findPackageWithMicrofrontendsConfig({
       } catch (error2) {
       }
     }
+    logger.debug(
+      "[MFE Config] Total matching config files:",
+      matchingPaths.length
+    );
     if (matchingPaths.length > 1) {
       throw new MicrofrontendError(
         `Found multiple \`microfrontends.json\` files in the repository referencing the application "${applicationName}", but only one is allowed.
@@ -346,30 +389,6 @@ function inferMicrofrontendsLocation(opts) {
 // src/config/microfrontends/utils/is-monorepo.ts
 var import_node_fs3 = __toESM(require("fs"), 1);
 var import_node_path3 = __toESM(require("path"), 1);
-
-// src/bin/logger.ts
-function debug(...args) {
-  if (process.env.MFE_DEBUG) {
-    console.log(...args);
-  }
-}
-function info(...args) {
-  console.log(...args);
-}
-function warn(...args) {
-  console.warn(...args);
-}
-function error(...args) {
-  console.error(...args);
-}
-var logger = {
-  debug,
-  info,
-  warn,
-  error
-};
-
-// src/config/microfrontends/utils/is-monorepo.ts
 function isMonorepo({
   repositoryRoot
 }) {
@@ -1109,15 +1128,18 @@ var import_node_fs6 = __toESM(require("fs"), 1);
 var import_node_path6 = __toESM(require("path"), 1);
 function getApplicationContext(opts) {
   if (opts?.appName) {
+    logger.debug("[MFE Config] Application name from appName parameter:", opts.appName);
     return { name: opts.appName };
   }
   if (process.env.VERCEL_PROJECT_NAME) {
+    logger.debug("[MFE Config] Application name from VERCEL_PROJECT_NAME:", process.env.VERCEL_PROJECT_NAME);
     return {
       name: process.env.VERCEL_PROJECT_NAME,
       projectName: process.env.VERCEL_PROJECT_NAME
     };
   }
   if (process.env.NX_TASK_TARGET_PROJECT) {
+    logger.debug("[MFE Config] Application name from NX_TASK_TARGET_PROJECT:", process.env.NX_TASK_TARGET_PROJECT);
     return {
       name: process.env.NX_TASK_TARGET_PROJECT,
       packageJsonName: process.env.NX_TASK_TARGET_PROJECT
@@ -1130,6 +1152,7 @@ function getApplicationContext(opts) {
     );
     const projectJson = JSON.parse(vercelProjectJsonPath);
     if (projectJson.projectName) {
+      logger.debug("[MFE Config] Application name from .vercel/project.json:", projectJson.projectName);
       return {
         name: projectJson.projectName,
         projectName: projectJson.projectName
@@ -1153,6 +1176,7 @@ function getApplicationContext(opts) {
         }
       );
     }
+    logger.debug("[MFE Config] Application name from package.json:", packageJson.name);
     return { name: packageJson.name, packageJsonName: packageJson.name };
   } catch (err) {
     throw MicrofrontendError.handle(err, {
@@ -1524,7 +1548,13 @@ var MicrofrontendsServer = class {
     filePath,
     cookies
   } = {}) {
+    logger.debug("[MFE Config] Starting config inference", {
+      appName,
+      directory: directory || process.cwd(),
+      filePath
+    });
     if (filePath) {
+      logger.debug("[MFE Config] Using explicit filePath:", filePath);
       return MicrofrontendsServer.fromFile({
         filePath,
         cookies
@@ -1532,16 +1562,25 @@ var MicrofrontendsServer = class {
     }
     try {
       const packageRoot = findPackageRoot(directory);
+      logger.debug("[MFE Config] Package root:", packageRoot);
       const applicationContext = getApplicationContext({
         appName,
         packageRoot
       });
+      logger.debug("[MFE Config] Application context:", applicationContext);
       const customConfigFilename = process.env.VC_MICROFRONTENDS_CONFIG_FILE_NAME;
+      if (customConfigFilename) {
+        logger.debug(
+          "[MFE Config] Custom config filename from VC_MICROFRONTENDS_CONFIG_FILE_NAME:",
+          customConfigFilename
+        );
+      }
       const maybeConfig = findConfig({
         dir: packageRoot,
         customConfigFilename
       });
       if (maybeConfig) {
+        logger.debug("[MFE Config] Config found at package root:", maybeConfig);
         return MicrofrontendsServer.fromFile({
           filePath: maybeConfig,
           cookies
@@ -1549,42 +1588,78 @@ var MicrofrontendsServer = class {
       }
       const repositoryRoot = findRepositoryRoot();
       const isMonorepo2 = isMonorepo({ repositoryRoot });
+      logger.debug(
+        "[MFE Config] Repository root:",
+        repositoryRoot,
+        "Is monorepo:",
+        isMonorepo2
+      );
       const configFromEnv = process.env.VC_MICROFRONTENDS_CONFIG;
       if (typeof configFromEnv === "string") {
+        logger.debug(
+          "[MFE Config] Checking VC_MICROFRONTENDS_CONFIG:",
+          configFromEnv
+        );
         const maybeConfigFromEnv = (0, import_node_path8.resolve)(packageRoot, configFromEnv);
         if (maybeConfigFromEnv) {
+          logger.debug(
+            "[MFE Config] Config loaded from VC_MICROFRONTENDS_CONFIG:",
+            maybeConfigFromEnv
+          );
           return MicrofrontendsServer.fromFile({
             filePath: maybeConfigFromEnv,
             cookies
           });
         }
       } else {
+        const vercelDir = (0, import_node_path8.join)(packageRoot, ".vercel");
+        logger.debug(
+          "[MFE Config] Searching for config in .vercel directory:",
+          vercelDir
+        );
         const maybeConfigFromVercel = findConfig({
-          dir: (0, import_node_path8.join)(packageRoot, ".vercel"),
+          dir: vercelDir,
           customConfigFilename
         });
         if (maybeConfigFromVercel) {
+          logger.debug(
+            "[MFE Config] Config found in .vercel directory:",
+            maybeConfigFromVercel
+          );
           return MicrofrontendsServer.fromFile({
             filePath: maybeConfigFromVercel,
             cookies
           });
         }
         if (isMonorepo2) {
+          logger.debug(
+            "[MFE Config] Inferring microfrontends location in monorepo for application:",
+            applicationContext.name
+          );
           const defaultPackage = inferMicrofrontendsLocation({
             repositoryRoot,
             applicationContext,
             customConfigFilename
           });
+          logger.debug(
+            "[MFE Config] Inferred package location:",
+            defaultPackage
+          );
           const maybeConfigFromDefault = findConfig({
             dir: defaultPackage,
             customConfigFilename
           });
           if (maybeConfigFromDefault) {
+            logger.debug(
+              "[MFE Config] Config found in inferred package:",
+              maybeConfigFromDefault
+            );
             return MicrofrontendsServer.fromFile({
               filePath: maybeConfigFromDefault,
               cookies
             });
           }
+          logger.debug("[MFE Config] No config found in inferred package");
         }
       }
       throw new MicrofrontendError(
@@ -1610,8 +1685,13 @@ var MicrofrontendsServer = class {
     cookies
   }) {
     try {
+      logger.debug("[MFE Config] Reading config from file:", filePath);
       const configJson = import_node_fs7.default.readFileSync(filePath, "utf-8");
       const config = MicrofrontendsServer.validate(configJson);
+      logger.debug(
+        "[MFE Config] Config loaded with applications:",
+        Object.keys(config.applications)
+      );
       return new MicrofrontendsServer({
         config,
         overrides: cookies ? parseOverrides(cookies) : void 0