@vercel/microfrontends 1.1.1-canary.6 → 1.2.0

package/dist/next/testing.js

@@ -3,7 +3,7 @@ import { readFileSync } from "node:fs";
 import {
   NextRequest
 } from "next/server.js";
-import { match } from "path-to-regexp";
+import { match, pathToRegexp as pathToRegexp3 } from "path-to-regexp";
 import { parse as parse2 } from "jsonc-parser";
 
 // src/config/microfrontends-config/isomorphic/index.ts
@@ -233,8 +233,7 @@ var validateConfigPaths = (applicationConfigsById) => {
     if (isDefaultApp(app)) {
       continue;
     }
-    const childApp = app;
-    for (const pathMatch of childApp.routing) {
+    for (const pathMatch of app.routing) {
       for (const path of pathMatch.paths) {
         const maybeError = validatePathExpression(path);
         if (maybeError) {
@@ -382,64 +381,15 @@ var validateConfigDefaultApplication = (applicationConfigsById) => {
 };
 var validateDeprecatedFields = (config) => {
   const errors = [];
-  if (config.options?.vercel) {
-    errors.push(
-      `Configuration cannot contain deprecated field 'options.vercel'. Use 'options.disableOverrides' instead.`
-    );
-  }
-  if (config.options?.localProxy) {
-    errors.push(
-      `Configuration cannot contain deprecated field 'options.localProxy'. Use 'options.localProxyPort' instead.`
-    );
-  }
   for (const [applicationId, application] of Object.entries(
     config.applications
   )) {
-    if (application.vercel) {
-      errors.push(
-        `Application '${applicationId}' cannot contain deprecated field 'vercel'. Use 'projectId' instead.`
-      );
-    }
-    if (application.production) {
-      errors.push(
-        `Application '${applicationId}' cannot contain deprecated field 'production'. Use 'development.fallback' instead.`
-      );
-    }
     if (application.development?.localPort) {
       errors.push(
         `Application '${applicationId}' cannot contain deprecated field 'development.localPort'. Use 'developement.local' instead.`
       );
     }
-    if (application.development?.fallback && typeof application.development.fallback !== "string") {
-      const fallback = application.development.fallback;
-      let asString = fallback.host;
-      if (fallback.protocol) {
-        asString = `${fallback.protocol}://${asString}`;
-      }
-      if (fallback.port) {
-        asString = `${asString}:${fallback.port}`;
-      }
-      errors.push(
-        `Application '${applicationId}' requires a string (not an object) for the 'development.fallback' field. Please set 'development.fallback' to '${asString}'.`
-      );
-    }
-    if (application.development?.local && typeof application.development.local !== "string" && typeof application.development.local !== "number") {
-      const local = application.development.local;
-      let asString;
-      if (local.port && !local.protocol && !local.host) {
-        asString = String(local.port);
-      } else {
-        asString = local.host ?? "localhost";
-        if (local.protocol) {
-          asString = `${local.protocol}://${asString}`;
-        }
-        if (local.port) {
-          asString = `${asString}:${local.port}`;
-        }
-      }
-      errors.push(
-        `Application '${applicationId}' requires a string or number (not an object) for the 'development.local' field. Please set 'development.local' to '${asString}'.`
-      );
+    if (application.projectId) {
     }
   }
   if (errors.length) {
@@ -594,6 +544,13 @@ var LocalHost = class extends Host {
   }
 };
 
+// src/config/microfrontends-config/isomorphic/utils/generate-automation-bypass-env-var-name.ts
+function generateAutomationBypassEnvVarName({
+  name
+}) {
+  return `AUTOMATION_BYPASS_${name.toUpperCase().replace(/[^a-zA-Z0-9]/g, "_")}`;
+}
+
 // src/config/microfrontends-config/isomorphic/application.ts
 var Application = class {
   constructor(name, {
@@ -612,10 +569,8 @@ var Application = class {
     };
     if (app.development?.fallback) {
       this.fallback = new Host(app.development.fallback);
-    } else if (app.production) {
-      this.fallback = new Host(app.production);
     }
-    this.projectId = app.projectId ?? app.vercel?.projectId;
+    this.projectId = app.projectId;
     this.packageName = app.packageName;
     this.overrides = overrides?.environment ? {
       environment: new Host(overrides.environment)
@@ -629,6 +584,9 @@ var Application = class {
   getAssetPrefix() {
     return generateAssetPrefixFromName({ name: this.name });
   }
+  getAutomationBypassEnvVarName() {
+    return generateAutomationBypassEnvVarName({ name: this.name });
+  }
   serialize() {
     return this.serialized;
   }
@@ -644,16 +602,7 @@ var DefaultApplication = class extends Application {
       isDefault: true
     });
     this.default = true;
-    const fallbackHost = app.development?.fallback ?? app.production;
-    if (fallbackHost === void 0) {
-      throw new Error(
-        "`app.production` or `app.development.fallback` must be set in the default application in microfrontends.json."
-      );
-    }
-    this.fallback = new Host(fallbackHost);
-    if (app.production) {
-      this.production = new Host(app.production);
-    }
+    this.fallback = new Host(app.development.fallback);
   }
   getAssetPrefix() {
     return "";
@@ -690,7 +639,7 @@ var MicrofrontendConfigIsomorphic = class {
   }) {
     this.childApplications = {};
     MicrofrontendConfigIsomorphic.validate(config, opts);
-    const disableOverrides = config.options?.disableOverrides ?? config.options?.vercel?.disableOverrides ?? false;
+    const disableOverrides = config.options?.disableOverrides ?? false;
     this.overrides = overrides && !disableOverrides ? overrides : void 0;
     let defaultApplication;
     for (const [appId, appConfig] of Object.entries(config.applications)) {
@@ -743,7 +692,7 @@ var MicrofrontendConfigIsomorphic = class {
     });
   }
   isOverridesDisabled() {
-    return this.options?.vercel?.disableOverrides ?? false;
+    return this.options?.disableOverrides ?? false;
   }
   getConfig() {
     return this.config;
@@ -781,6 +730,14 @@ var MicrofrontendConfigIsomorphic = class {
     }
     return app;
   }
+  hasApplication(name) {
+    try {
+      this.getApplication(name);
+      return true;
+    } catch {
+      return false;
+    }
+  }
   getApplicationByProjectId(projectId) {
     if (this.defaultApplication.projectId === projectId) {
       return this.defaultApplication;
@@ -799,7 +756,7 @@ var MicrofrontendConfigIsomorphic = class {
    * Returns the configured port for the local proxy
    */
   getLocalProxyPort() {
-    return this.config.options?.localProxyPort ?? this.config.options?.localProxy?.port ?? DEFAULT_LOCAL_PROXY_PORT;
+    return this.config.options?.localProxyPort ?? DEFAULT_LOCAL_PROXY_PORT;
   }
   /**
    * Serializes the class back to the Schema type.
@@ -831,34 +788,6 @@ var MicrofrontendConfigIsomorphic = class {
   }
 };
 
-// src/routing/get-domain-from-environment.ts
-function getDomainFromEnvironment({
-  app,
-  target
-}) {
-  const mfeProjects = JSON.parse(
-    process.env.VERCEL_MICROFRONTENDS_PROJECTS ?? "[]"
-  );
-  if (mfeProjects.length === 0) {
-    throw new Error("Missing related microfrontends project information");
-  }
-  const vercelProject = mfeProjects.find(
-    (p) => p.project.name === app.name || p.project.id === app.projectId
-  );
-  if (!vercelProject) {
-    throw new Error(
-      `Could not find the Vercel project for application "${app.name}". If the name does not match the Vercel project name, set the \`projectId\` field in the application config.`
-    );
-  }
-  const domain = target === "preview" && vercelProject.preview.branch ? vercelProject.preview.branch : vercelProject.production.alias ?? vercelProject.production.url;
-  if (!domain) {
-    throw new Error(
-      `Missing domain for target "${target}" in application "${app.name}"`
-    );
-  }
-  return domain.startsWith("https://") ? domain : `https://${domain}`;
-}
-
 // src/next/testing/index.ts
 function expandWildcards(path) {
   if (path.includes("/:path*") || path.includes("/:slug*")) {
@@ -905,18 +834,6 @@ function getFlaggedPathsForApp(mfConfig, appName) {
   }
   return app.routing.filter((group) => Boolean(group.flag)).flatMap((group) => group.paths.flatMap(expandWildcards));
 }
-function getExpectedDomainForApp(mfConfig, appName, env) {
-  const app = mfConfig.getApplication(appName);
-  const defaultApp = mfConfig.getDefaultApplication();
-  if (env === "development") {
-    return app.development.local.toString();
-  }
-  if (["preview", "production"].includes(env)) {
-    const target = env;
-    return getDomainFromEnvironment({ app, target });
-  }
-  return defaultApp.fallback.toString();
-}
 function getAllMicrofrontendPaths(mfConfig) {
   return mfConfig.getChildApplications().flatMap((app) => {
     return app.routing.flatMap((group) => group.paths.flatMap(expandWildcards));
@@ -1000,41 +917,29 @@ async function validateMiddlewareOnFlaggedPaths(microfrontendConfigOrPath, middl
     for (const appName of allAppNames) {
       const flaggedPaths = getFlaggedPathsForApp(microfrontendConfig, appName);
       if (flaggedPaths.length) {
-        for (const env of ["preview", "production"]) {
-          process.env.VERCEL_ENV = env;
-          for (const path of flaggedPaths) {
-            const expectedHost = getExpectedDomainForApp(
-              microfrontendConfig,
-              appName,
-              env
+        for (const path of flaggedPaths) {
+          const host = microfrontendConfig.defaultApplication.fallback.toString();
+          const requestPath = `${host}${path}`;
+          const request = new NextRequest(requestPath);
+          const response = await middleware(
+            request,
+            {}
+          );
+          const routedZone = response?.headers.get(
+            "x-middleware-request-x-vercel-mfe-zone"
+          );
+          if (!response) {
+            errors.push(
+              `middleware did not action for ${requestPath}. Expected to route to ${appName}`
             );
-            const expectedDefaultHost = getExpectedDomainForApp(
-              microfrontendConfig,
-              microfrontendConfig.getDefaultApplication().name,
-              env
+          } else if (response.status !== 200) {
+            errors.push(
+              `expected 200 status for ${requestPath} but got ${response.status}`
             );
-            const requestPath = `${expectedDefaultHost}${path}`;
-            const request = new NextRequest(requestPath, {
-              headers: { "x-vercel-skip-deployment-existence-check": "1" }
-            });
-            const response = await middleware(
-              request,
-              {}
+          } else if (routedZone !== appName) {
+            errors.push(
+              `expected ${requestPath} to route to ${appName}, but got ${routedZone}`
             );
-            const expectedUrl = `${expectedHost}${path}`;
-            if (!response) {
-              errors.push(
-                `middleware did not action for ${requestPath} in ${env}. Expected a rewrite to ${expectedUrl}`
-              );
-            } else if (response.status !== 200) {
-              errors.push(
-                `expected 200 status for ${requestPath} in ${env} but got ${response.status}`
-              );
-            } else if (response.headers.get("x-middleware-request-x-vercel-mfe-zone") !== appName) {
-              errors.push(
-                `Expected microfrontends middleware to return rewrite to ${appName} in ${env}, but got ${response.headers.get("x-middleware-request-x-vercel-mfe-zone")} instead`
-              );
-            }
           }
         }
       }
@@ -1047,15 +952,89 @@ async function validateMiddlewareOnFlaggedPaths(microfrontendConfigOrPath, middl
     process.env.MFE_PREVIEW_DOMAINS = initialMfePreviewDomains;
   }
 }
+function validateRouting(microfrontendConfigOrPath, routesToTest) {
+  const microfrontendConfig = typeof microfrontendConfigOrPath === "string" ? loadMicrofrontendConfigForEdge(microfrontendConfigOrPath) : microfrontendConfigOrPath;
+  const matches = /* @__PURE__ */ new Map();
+  for (const application of microfrontendConfig.getChildApplications()) {
+    for (const route of application.routing) {
+      for (const path of route.paths) {
+        matches.set({ path, flag: route.flag }, application.name);
+      }
+    }
+  }
+  const errors = [];
+  for (const [applicationName, paths] of Object.entries(routesToTest)) {
+    if (!microfrontendConfig.hasApplication(applicationName)) {
+      errors.push(
+        `Application ${applicationName} does not exist in the microfrontends config. The applications in the config are: ${microfrontendConfig.getAllApplications().map((app) => app.name).join(", ")}`
+      );
+      continue;
+    }
+    for (const expected of paths) {
+      const path = typeof expected === "string" ? expected : expected.path;
+      const flag = typeof expected === "string" ? void 0 : expected.flag;
+      const matchedApplications = /* @__PURE__ */ new Map();
+      const matchesWithoutFlags = /* @__PURE__ */ new Map();
+      for (const [matcher, applicationMatched] of matches.entries()) {
+        if (pathToRegexp3(matcher.path).test(path)) {
+          if (!matcher.flag || matcher.flag === flag) {
+            const existingMatches = matchedApplications.get(applicationMatched) ?? [];
+            existingMatches.push(matcher.path);
+            matchedApplications.set(applicationMatched, existingMatches);
+          } else {
+            matchesWithoutFlags.set(applicationName, matcher.flag);
+          }
+        }
+      }
+      if (matchedApplications.size === 0) {
+        matchedApplications.set(
+          microfrontendConfig.getDefaultApplication().name,
+          ["fallback to default application"]
+        );
+      }
+      if (matchedApplications.size > 1) {
+        const formattedMatches = Array.from(
+          matchedApplications.entries().map(
+            ([matchedApplication, matchers]) => `${matchedApplication} (on ${matchers.join(", ")})`
+          )
+        ).join(", ");
+        errors.push(
+          `${path} can only match one application, but it matched multiple: ${formattedMatches}`
+        );
+      } else if (!matchedApplications.has(applicationName)) {
+        const actualMatch = matchedApplications.entries().next().value;
+        if (!actualMatch) {
+          throw new Error("this shouldn't happen");
+        }
+        const [matchedApplication, matchers] = actualMatch;
+        let extraMessage = "";
+        if (matchesWithoutFlags.has(applicationName)) {
+          const flagToSet = matchesWithoutFlags.get(applicationName);
+          extraMessage = ` It would've matched ${applicationName} if the ${flagToSet} flag was set. If this is what you want, replace ${path} in the paths-to-test list with {path: '${path}', flag: '${flagToSet}'}.`;
+        }
+        errors.push(
+          `Expected ${path}${flag ? ` (with flag ${flag})` : ""} to match ${applicationName}, but it matched ${matchedApplication} (on ${matchers.join(", ")}).${extraMessage}`
+        );
+      }
+    }
+  }
+  if (errors.length) {
+    throw new Error(
+      `Incorrect microfrontends routing detected:
+
+- ${errors.join("\n- ")}`
+    );
+  }
+}
 export {
   expandWildcards,
   getAllChildApplicationNames,
   getAllMicrofrontendPaths,
-  getExpectedDomainForApp,
   getFlaggedPathsForApp,
   getLaunchedPathsForApp,
   loadMicrofrontendConfigForEdge,
   validateMiddlewareConfig,
-  validateMiddlewareOnFlaggedPaths
+  validateMiddlewareOnFlaggedPaths,
+  validateRouting
 };
 //# sourceMappingURL=testing.js.map