@vercel/microfrontends 0.10.1 → 0.11.0

package/dist/v2/next/config.js

@@ -1,12 +1,12 @@
 // src/next-v2/config/index.ts
-import fs3 from "node:fs";
+import fs5 from "node:fs";
 
 // src/config-v2/microfrontends/server/index.ts
-import fs2 from "node:fs";
-import { dirname as dirname2, join } from "node:path";
+import fs4 from "node:fs";
+import { dirname as dirname3, join } from "node:path";
 
 // src/config-v2/overrides/constants.ts
-var OVERRIDES_COOKIE_PREFIX = "vercel-microfrontends-override";
+var OVERRIDES_COOKIE_PREFIX = "vercel-micro-frontends-override";
 var OVERRIDES_ENV_COOKIE_PREFIX = `${OVERRIDES_COOKIE_PREFIX}:env:`;
 
 // src/config-v2/overrides/is-override-cookie.ts
@@ -187,21 +187,21 @@ var MicrofrontendConfigClient = class {
   isEqual(other) {
     return JSON.stringify(this.applications) === JSON.stringify(other.applications);
   }
-  getApplicationNameForPath(path3) {
-    if (!path3.startsWith("/")) {
+  getApplicationNameForPath(path5) {
+    if (!path5.startsWith("/")) {
       throw new Error(`Path must start with a /`);
     }
-    if (this.pathCache[path3]) {
-      return this.pathCache[path3];
+    if (this.pathCache[path5]) {
+      return this.pathCache[path5];
     }
-    const pathname = new URL(path3, "https://example.com").pathname;
+    const pathname = new URL(path5, "https://example.com").pathname;
     for (const [name, application] of Object.entries(this.applications)) {
       if (application.routing) {
         for (const group of application.routing) {
           for (const childPath of group.paths) {
             const regexp = pathToRegexp(childPath);
             if (regexp.test(pathname)) {
-              this.pathCache[path3] = name;
+              this.pathCache[path5] = name;
               return name;
             }
           }
@@ -214,7 +214,7 @@ var MicrofrontendConfigClient = class {
     if (!defaultApplication) {
       return null;
     }
-    this.pathCache[path3] = defaultApplication[0];
+    this.pathCache[path5] = defaultApplication[0];
     return defaultApplication[0];
   }
   serialize() {
@@ -246,22 +246,22 @@ var validateConfigPaths = (applicationConfigsById) => {
       continue;
     }
     for (const pathMatch of app.routing) {
-      for (const path3 of pathMatch.paths) {
-        const tokens = parsePathRegexp(path3);
+      for (const path5 of pathMatch.paths) {
+        const tokens = parsePathRegexp(path5);
         for (const token of tokens.slice(0, -1)) {
           if (typeof token !== "string") {
             errors.push(
-              `Path ${path3} may only have a :wildcard in the last path component`
+              `Path ${path5} may only have a :wildcard in the last path component`
             );
           }
         }
-        const existing = pathsByApplicationId.get(path3);
+        const existing = pathsByApplicationId.get(path5);
         if (existing) {
           existing.applications.push(id);
         } else {
-          pathsByApplicationId.set(path3, {
+          pathsByApplicationId.set(path5, {
             applications: [id],
-            matcher: pathToRegexp2(path3),
+            matcher: pathToRegexp2(path5),
             applicationId: id
           });
         }
@@ -269,10 +269,10 @@ var validateConfigPaths = (applicationConfigsById) => {
     }
   }
   const entries = Array.from(pathsByApplicationId.entries());
-  entries.forEach(([path3, { applications: ids, matcher, applicationId }]) => {
+  entries.forEach(([path5, { applications: ids, matcher, applicationId }]) => {
     if (ids.length > 1) {
       errors.push(
-        `Duplicate path "${path3}" for applications "${ids.join(", ")}"`
+        `Duplicate path "${path5}" for applications "${ids.join(", ")}"`
       );
     }
     entries.forEach(
@@ -280,14 +280,14 @@ var validateConfigPaths = (applicationConfigsById) => {
         matchPath,
         { applications: matchIds, applicationId: matchApplicationId }
       ]) => {
-        if (path3 === matchPath) {
+        if (path5 === matchPath) {
           return;
         }
         if (applicationId === matchApplicationId) {
           return;
         }
         if (matcher.test(matchPath)) {
-          const source = `"${path3}" of application${ids.length > 0 ? "s" : ""} ${ids.join(", ")}`;
+          const source = `"${path5}" of application${ids.length > 0 ? "s" : ""} ${ids.join(", ")}`;
           const destination = `"${matchPath}" of application${matchIds.length > 0 ? "s" : ""} ${matchIds.join(", ")}`;
           errors.push(
             `Overlapping path detected between ${source} and ${destination}`
@@ -852,8 +852,115 @@ function findPackagePath(opts) {
   return result;
 }
 
-// src/config-v2/microfrontends/server/utils/get-output-file-path.ts
+// src/config-v2/microfrontends/utils/find-default-package.ts
+import { dirname as dirname2 } from "node:path";
+import { readFileSync as readFileSync2 } from "node:fs";
+import fg2 from "fast-glob";
+var configCache2 = {};
+function findDefaultMicrofrontendsPackages({
+  repositoryRoot,
+  applicationName
+}) {
+  try {
+    const microfrontendsJsonPaths = fg2.globSync("**/microfrontends.json", {
+      cwd: repositoryRoot,
+      absolute: true,
+      onlyFiles: true,
+      followSymbolicLinks: false,
+      ignore: ["**/node_modules/**", "**/.git/**"]
+    });
+    const matchingPaths = [];
+    for (const microfrontendsJsonPath of microfrontendsJsonPaths) {
+      const microfrontendsJsonContent = readFileSync2(
+        microfrontendsJsonPath,
+        "utf-8"
+      );
+      const microfrontendsJson = JSON.parse(
+        microfrontendsJsonContent
+      );
+      if (isMainConfig(microfrontendsJson) && microfrontendsJson.applications[applicationName]) {
+        matchingPaths.push(microfrontendsJsonPath);
+      }
+    }
+    if (matchingPaths.length > 1) {
+      throw new Error(
+        `Found multiple default applications referencing "${applicationName}" in the repository, this is not yet supported.
+${matchingPaths.join("\n  \u2022 ")}`
+      );
+    }
+    if (matchingPaths.length === 0) {
+      throw new Error(
+        `Could not find default application with "applications.${applicationName}"`
+      );
+    }
+    const [packageJsonPath] = matchingPaths;
+    return dirname2(packageJsonPath);
+  } catch (error) {
+    return null;
+  }
+}
+function findDefaultMicrofrontendsPackage(opts) {
+  const cacheKey = `${opts.repositoryRoot}-${opts.applicationName}`;
+  if (configCache2[cacheKey]) {
+    return configCache2[cacheKey];
+  }
+  const result = findDefaultMicrofrontendsPackages(opts);
+  if (!result) {
+    throw new Error(
+      `Error trying to resolve the main microfrontends.json configuration`
+    );
+  }
+  configCache2[cacheKey] = result;
+  return result;
+}
+
+// src/config-v2/microfrontends/utils/is-monorepo.ts
+import fs2 from "node:fs";
 import path2 from "node:path";
+function isMonorepo({
+  repositoryRoot
+}) {
+  try {
+    if (fs2.existsSync(path2.join(repositoryRoot, "pnpm-workspace.yaml"))) {
+      return true;
+    }
+    if (fs2.existsSync(path2.join(repositoryRoot, "vlt-workspaces.json"))) {
+      return true;
+    }
+    const packageJsonPath = path2.join(repositoryRoot, "package.json");
+    if (!fs2.existsSync(packageJsonPath)) {
+      return false;
+    }
+    const packageJson = JSON.parse(
+      fs2.readFileSync(packageJsonPath, "utf-8")
+    );
+    return packageJson.workspaces !== void 0;
+  } catch (error) {
+    console.error("Error determining if repository is a monorepo", error);
+    return false;
+  }
+}
+
+// src/config-v2/microfrontends/utils/find-package-root.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+var PACKAGE_JSON = "package.json";
+function findPackageRoot(startDir) {
+  let currentDir = startDir || process.cwd();
+  while (currentDir !== path3.parse(currentDir).root) {
+    const pkgJsonPath = path3.join(currentDir, PACKAGE_JSON);
+    if (fs3.existsSync(pkgJsonPath)) {
+      return currentDir;
+    }
+    currentDir = path3.dirname(currentDir);
+  }
+  throw new Error(
+    "Package root not found. Specify the root of the package with the `package.root` option."
+  );
+}
+
+// src/config-v2/microfrontends/server/utils/get-output-file-path.ts
+import path4 from "node:path";
 
 // src/config-v2/microfrontends/server/constants.ts
 var MFE_CONFIG_DEFAULT_FILE_PATH = "microfrontends";
@@ -867,13 +974,13 @@ function isVercel() {
 // src/config-v2/microfrontends/server/utils/get-output-file-path.ts
 function getOutputFilePath() {
   if (isVercel()) {
-    return path2.join(
+    return path4.join(
       ".vercel",
       MFE_CONFIG_DEFAULT_FILE_PATH,
       MFE_CONFIG_DEFAULT_FILE_NAME
     );
   }
-  return path2.join(MFE_CONFIG_DEFAULT_FILE_PATH, MFE_CONFIG_DEFAULT_FILE_NAME);
+  return path4.join(MFE_CONFIG_DEFAULT_FILE_PATH, MFE_CONFIG_DEFAULT_FILE_NAME);
 }
 
 // src/config-v2/microfrontends/server/validation.ts
@@ -1087,9 +1194,6 @@ var schema_v2_default = {
         projectId: {
           type: "string",
           description: "Vercel project ID"
-        },
-        routeSpeedInsightsToDefaultZone: {
-          type: "boolean"
         }
       },
       required: ["projectId"]
@@ -1259,8 +1363,8 @@ var MicrofrontendsServer = class extends Microfrontends {
     pretty: true
   }) {
     const outputPath = getOutputFilePath();
-    fs2.mkdirSync(dirname2(outputPath), { recursive: true });
-    fs2.writeFileSync(
+    fs4.mkdirSync(dirname3(outputPath), { recursive: true });
+    fs4.writeFileSync(
       outputPath,
       JSON.stringify(
         this.config.toSchemaJson(),
@@ -1322,6 +1426,69 @@ var MicrofrontendsServer = class extends Microfrontends {
     }
     return config;
   }
+  /**
+   * Looks up the configuration by inferring the package root and looking for a microfrontends.json file. If a file is not found,
+   * it will look for a package in the repository with a microfrontends.json file that contains the current application
+   * and use that configuration.
+   *
+   * This can return either a Child or Main configuration.
+   */
+  static infer({
+    directory,
+    filePath,
+    meta,
+    cookies,
+    options
+  } = {}) {
+    if (filePath && meta) {
+      return MicrofrontendsServer.fromFile({
+        filePath,
+        cookies,
+        meta,
+        options
+      });
+    }
+    try {
+      const packageRoot = findPackageRoot(directory);
+      const packageJsonPath = join(packageRoot, "package.json");
+      const packageJson = JSON.parse(
+        fs4.readFileSync(packageJsonPath, "utf-8")
+      );
+      if (!packageJson.name) {
+        throw new Error(`No name found in package.json at ${packageJsonPath}`);
+      }
+      const configMeta = meta ?? { fromApp: packageJson.name };
+      const maybeConfig = join(packageRoot, "microfrontends.json");
+      if (fs4.existsSync(maybeConfig)) {
+        return MicrofrontendsServer.fromFile({
+          filePath: maybeConfig,
+          cookies,
+          meta: configMeta,
+          options
+        });
+      }
+      const repositoryRoot = findRepositoryRoot();
+      const isMonorepo2 = isMonorepo({ repositoryRoot });
+      if (isMonorepo2) {
+        const defaultPackage = findDefaultMicrofrontendsPackage({
+          repositoryRoot,
+          applicationName: packageJson.name
+        });
+        return MicrofrontendsServer.fromFile({
+          filePath: join(defaultPackage, "microfrontends.json"),
+          cookies,
+          meta: configMeta,
+          options
+        });
+      }
+      throw new Error("Unable to infer");
+    } catch (e) {
+      throw new MicrofrontendError(
+        "Unable to infer microfrontends configuration",
+        { type: "config", subtype: "inference_failed" }
+      );
+    }
+  }
   /*
    * Generates a MicrofrontendsServer instance from a file.
    */
@@ -1332,25 +1499,28 @@ var MicrofrontendsServer = class extends Microfrontends {
     options
   }) {
     try {
-      const configJson = fs2.readFileSync(filePath, "utf-8");
+      const configJson = fs4.readFileSync(filePath, "utf-8");
       const config = MicrofrontendsServer.validate(configJson);
       if (!isMainConfig(config) && (options == null ? void 0 : options.resolveMainConfig)) {
         const repositoryRoot = findRepositoryRoot();
-        const packagePath = findPackagePath({
-          repositoryRoot,
-          name: config.partOf
-        });
-        if (!packagePath) {
-          throw new MicrofrontendError(
-            `Could not find default application "${config.partOf}" in the repository`,
-            { type: "config", subtype: "not_found" }
-          );
+        const isMonorepo2 = isMonorepo({ repositoryRoot });
+        if (isMonorepo2) {
+          const packagePath = findPackagePath({
+            repositoryRoot,
+            name: config.partOf
+          });
+          if (!packagePath) {
+            throw new MicrofrontendError(
+              `Could not find default application "${config.partOf}" in the repository`,
+              { type: "config", subtype: "not_found" }
+            );
+          }
+          const mainConfigPath = join(packagePath, "microfrontends.json");
+          return MicrofrontendsServer.fromMainConfigFile({
+            filePath: mainConfigPath,
+            overrides: cookies ? parseOverrides(cookies) : void 0
+          });
         }
-        const mainConfigPath = join(packagePath, "microfrontends.json");
-        return MicrofrontendsServer.fromMainConfigFile({
-          filePath: mainConfigPath,
-          overrides: cookies ? parseOverrides(cookies) : void 0
-        });
       }
       return new MicrofrontendsServer({
         config,
@@ -1371,7 +1541,7 @@ var MicrofrontendsServer = class extends Microfrontends {
     overrides
   }) {
     try {
-      const config = fs2.readFileSync(filePath, "utf-8");
+      const config = fs4.readFileSync(filePath, "utf-8");
       const validatedConfig = MicrofrontendsServer.validate(config);
       if (!isMainConfig(validatedConfig)) {
         throw new MicrofrontendError(
@@ -1509,24 +1679,26 @@ function getDomainFromEnvironment({
   app,
   target
 }) {
-  const projects = JSON.parse(
-    process.env.VERCEL_RELATED_PROJECTS ?? "[]"
+  var _a, _b;
+  const mfeProjects = JSON.parse(
+    process.env.VERCEL_MICROFRONTENDS_PROJECTS ?? "{}"
   );
-  if (projects.length === 0) {
-    throw new Error("Missing related vercel project information");
+  if (Object.keys(mfeProjects).length === 0) {
+    throw new Error("Missing related microfrontends project information");
   }
-  const vercelProject = projects.find(
-    (project) => {
-      var _a;
-      return project.projectId === ((_a = app.vercel) == null ? void 0 : _a.projectId) || project.appName === app.name;
-    }
-  );
+  if (!((_a = app.vercel) == null ? void 0 : _a.projectId)) {
+    throw new Error(`Missing applications[${app.name}].vercel.projectId`);
+  }
+  const vercelProject = (_b = mfeProjects.applications) == null ? void 0 : _b[app.vercel.projectId];
   if (!vercelProject) {
     throw new Error(
-      `Missing related vercel project information for application "${app.name}"`
+      `Missing related microfrontends project information for application "${app.name}"`
     );
   }
-  return vercelProject.aliases[target];
+  if (target === "preview" && vercelProject.deploymentAlias) {
+    return vercelProject.deploymentAlias;
+  }
+  return vercelProject.productionHost;
 }
 
 // src/routing-v2/get-domain-for-current-environment.ts
@@ -1565,12 +1737,12 @@ function getDomainForCurrentEnvironment(config, appName) {
   const productionHost = config.getDefaultApplication().production.toString();
   switch (group) {
     case "development": {
-      const domain = process.env.NODE_ENV === "test" ? app.development.local.toString() : productionHost;
+      const domain = ["test", "development"].includes(process.env.NODE_ENV) ? app.development.local.toString() : productionHost;
       debugDomains(appName, "development", domain);
       return domain;
     }
     case "preview": {
-      return getDomainFromEnvironment({ app, target: "branch" });
+      return getDomainFromEnvironment({ app, target: "preview" });
     }
     case "production": {
       return getDomainFromEnvironment({ app, target: "production" });
@@ -1602,11 +1774,11 @@ ${table}
 `);
   }
 }
-function pathToRewrites(path3) {
+function pathToRewrites(path5) {
   var _a;
   const regex = /(?<base>^.+)\/:.+\*$/;
-  const match = regex.exec(path3);
-  const paths = [path3];
+  const match = regex.exec(path5);
+  const paths = [path5];
   if ((_a = match == null ? void 0 : match.groups) == null ? void 0 : _a.base) {
     paths.unshift(match.groups.base);
   }
@@ -1620,7 +1792,16 @@ function rewritesMapToArr(rewrites) {
     return [
       {
         source,
-        destination
+        destination,
+        missing: [
+          // if this header is present, the proxy has performed the rewrite.
+          // once the proxy routing is fully rolled out, this package should
+          // be updated to not perform any rewrites when deployed.
+          {
+            type: "header",
+            key: "x-vercel-mfe-host"
+          }
+        ]
       }
     ];
   });
@@ -1628,15 +1809,9 @@ function rewritesMapToArr(rewrites) {
 function transform4(args) {
   const { next, microfrontend, app } = args;
   const buildBeforeFiles = () => {
-    var _a;
     const rewrites = /* @__PURE__ */ new Map();
     if (!app.isDefault()) {
-      rewrites.set(`/${app.getAssetPrefix()}/_next/:path+`, {
-        destination: {
-          pathname: `/_next/:path+`
-        }
-      });
-      if (!((_a = app.vercel) == null ? void 0 : _a.routeSpeedInsightsToDefaultZone)) {
+      if (process.env.VERCEL_MICROFRONTENDS_CONSOLIDATE_SPEED_INSIGHTS === "1") {
         rewrites.set(`/${app.getAssetPrefix()}/_vercel/:path*`, {
           destination: { pathname: "/_vercel/:path*" }
         });
@@ -1854,7 +2029,7 @@ function getApplicationContext(opts) {
     return { name: opts.appName };
   }
   try {
-    const packageJsonString = fs3.readFileSync("./package.json", "utf-8");
+    const packageJsonString = fs5.readFileSync("./package.json", "utf-8");
     const packageJson = JSON.parse(packageJsonString);
     if (!packageJson.name) {
       throw new MicrofrontendError(
@@ -1879,8 +2054,8 @@ function withMicrofrontends(nextConfig, opts) {
     process.env.MFE_DEBUG = "true";
   }
   const { name: fromApp } = getApplicationContext(opts);
-  const microfrontends = MicrofrontendsServer.fromFile({
-    filePath: (opts == null ? void 0 : opts.configPath) ?? "./microfrontends.json",
+  const microfrontends = MicrofrontendsServer.infer({
+    filePath: opts == null ? void 0 : opts.configPath,
     meta: {
       fromApp
     }