@vercel/microfrontends 1.0.1-canary.3 → 1.0.1-canary.5

package/dist/bin/cli.cjs

@@ -29,7 +29,7 @@ var import_commander = require("commander");
 // package.json
 var package_default = {
   name: "@vercel/microfrontends",
-  version: "1.0.1-canary.3",
+  version: "1.0.1-canary.5",
   private: false,
   description: "Defines configuration and utilities for microfrontends development",
   keywords: [
@@ -189,7 +189,7 @@ var package_default = {
     "fast-glob": "^3.3.2",
     "http-proxy": "^1.18.1",
     "jsonc-parser": "^3.3.1",
-    nanoid: "^5.1.2",
+    nanoid: "^3.3.9",
     "path-to-regexp": "6.2.1"
   },
   devDependencies: {
@@ -372,18 +372,18 @@ var validateConfigPaths = (applicationConfigsById) => {
     }
     const childApp = app;
     for (const pathMatch of childApp.routing) {
-      for (const path6 of pathMatch.paths) {
-        const maybeError = validatePathExpression(path6);
+      for (const path7 of pathMatch.paths) {
+        const maybeError = validatePathExpression(path7);
         if (maybeError) {
           errors.push(maybeError);
         } else {
-          const existing = pathsByApplicationId.get(path6);
+          const existing = pathsByApplicationId.get(path7);
           if (existing) {
             existing.applications.push(id);
           } else {
-            pathsByApplicationId.set(path6, {
+            pathsByApplicationId.set(path7, {
               applications: [id],
-              matcher: (0, import_path_to_regexp.pathToRegexp)(path6),
+              matcher: (0, import_path_to_regexp.pathToRegexp)(path7),
               applicationId: id
             });
           }
@@ -392,24 +392,24 @@ var validateConfigPaths = (applicationConfigsById) => {
     }
   }
   const entries = Array.from(pathsByApplicationId.entries());
-  for (const [path6, { applications: ids, matcher, applicationId }] of entries) {
+  for (const [path7, { applications: ids, matcher, applicationId }] of entries) {
     if (ids.length > 1) {
       errors.push(
-        `Duplicate path "${path6}" for applications "${ids.join(", ")}"`
+        `Duplicate path "${path7}" for applications "${ids.join(", ")}"`
       );
     }
     for (const [
       matchPath,
       { applications: matchIds, applicationId: matchApplicationId }
     ] of entries) {
-      if (path6 === matchPath) {
+      if (path7 === matchPath) {
         continue;
       }
       if (applicationId === matchApplicationId) {
         continue;
       }
       if (matcher.test(matchPath)) {
-        const source = `"${path6}" of application${ids.length > 0 ? "s" : ""} ${ids.join(", ")}`;
+        const source = `"${path7}" 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}`
@@ -425,39 +425,42 @@ var validateConfigPaths = (applicationConfigsById) => {
   }
 };
 var PATH_DEFAULT_PATTERN = "[^\\/#\\?]+?";
-function validatePathExpression(path6) {
+function validatePathExpression(path7) {
   try {
-    const tokens = (0, import_path_to_regexp.parse)(path6);
-    if (/(?<!\\)\{/.test(path6)) {
-      return `Optional paths are not supported: ${path6}`;
+    const tokens = (0, import_path_to_regexp.parse)(path7);
+    if (/(?<!\\)\{/.test(path7)) {
+      return `Optional paths are not supported: ${path7}`;
     }
-    if (/(?<!\\|\()\?/.test(path6)) {
-      return `Optional paths are not supported: ${path6}`;
+    if (/(?<!\\|\()\?/.test(path7)) {
+      return `Optional paths are not supported: ${path7}`;
     }
-    if (/\/[^/]*(?<!\\):[^/]*(?<!\\):[^/]*/.test(path6)) {
-      return `Only one wildcard is allowed per path segment: ${path6}`;
+    if (/\/[^/]*(?<!\\):[^/]*(?<!\\):[^/]*/.test(path7)) {
+      return `Only one wildcard is allowed per path segment: ${path7}`;
     }
     for (let i = 0; i < tokens.length; i++) {
       const token = tokens[i];
       if (token === void 0) {
-        return `token ${i} in ${path6} is undefined, this shouldn't happen`;
+        return `token ${i} in ${path7} is undefined, this shouldn't happen`;
       }
       if (typeof token !== "string") {
+        if (!token.name) {
+          return `Only named wildcards are allowed: ${path7} (hint: add ":path" to the wildcard)`;
+        }
         if (token.pattern !== PATH_DEFAULT_PATTERN && // Allows (a|b|c) and ((?!a|b|c).*) regex
         // Only limited regex is supported for now, due to performance considerations
         !/^(?<allowed>[\w]+(?:\|[^|()]+)+)$|^\(\?!(?<disallowed>[\w]+(?:\|[^|()]+)+)\)\.\*$/.test(
           token.pattern
         )) {
-          return `Path ${path6} cannot use unsupported regular expression wildcard`;
+          return `Path ${path7} cannot use unsupported regular expression wildcard`;
         }
         if (token.modifier && i !== tokens.length - 1) {
-          return `Modifier ${token.modifier} is not allowed on wildcard :${token.name} in ${path6}. Modifiers are only allowed in the last path component`;
+          return `Modifier ${token.modifier} is not allowed on wildcard :${token.name} in ${path7}. Modifiers are only allowed in the last path component`;
         }
       }
     }
   } catch (e) {
     const message = e instanceof Error ? e.message : String(e);
-    return `Path ${path6} could not be parsed into regexp: ${message}`;
+    return `Path ${path7} could not be parsed into regexp: ${message}`;
   }
   return void 0;
 }
@@ -798,21 +801,21 @@ var MicrofrontendConfigClient = class {
   isEqual(other) {
     return JSON.stringify(this.applications) === JSON.stringify(other.applications);
   }
-  getApplicationNameForPath(path6) {
-    if (!path6.startsWith("/")) {
+  getApplicationNameForPath(path7) {
+    if (!path7.startsWith("/")) {
       throw new Error(`Path must start with a /`);
     }
-    if (this.pathCache[path6]) {
-      return this.pathCache[path6];
+    if (this.pathCache[path7]) {
+      return this.pathCache[path7];
     }
-    const pathname = new URL(path6, "https://example.com").pathname;
+    const pathname = new URL(path7, "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 = (0, import_path_to_regexp2.pathToRegexp)(childPath);
             if (regexp.test(pathname)) {
-              this.pathCache[path6] = name;
+              this.pathCache[path7] = name;
               return name;
             }
           }
@@ -825,7 +828,7 @@ var MicrofrontendConfigClient = class {
     if (!defaultApplication) {
       return null;
     }
-    this.pathCache[path6] = defaultApplication[0];
+    this.pathCache[path7] = defaultApplication[0];
     return defaultApplication[0];
   }
   serialize() {
@@ -1091,8 +1094,8 @@ function isMainConfig2(c) {
 }
 
 // src/config/microfrontends/server/index.ts
-var import_node_fs7 = __toESM(require("fs"), 1);
-var import_node_path8 = require("path");
+var import_node_fs8 = __toESM(require("fs"), 1);
+var import_node_path9 = require("path");
 
 // src/config/microfrontends-config/isomorphic/child.ts
 var MicrofrontendChildConfig = class extends MicrofrontendConfigIsomorphic {
@@ -1140,6 +1143,9 @@ var import_node_fs = __toESM(require("fs"), 1);
 var import_node_path = __toESM(require("path"), 1);
 var GIT_DIRECTORY = ".git";
 function findRepositoryRoot(startDir) {
+  if (process.env.NX_WORKSPACE_ROOT) {
+    return process.env.NX_WORKSPACE_ROOT;
+  }
   let currentDir = startDir || process.cwd();
   while (currentDir !== import_node_path.default.parse(currentDir).root) {
     const gitPath = import_node_path.default.join(currentDir, GIT_DIRECTORY);
@@ -1297,6 +1303,9 @@ function isMonorepo({
     if (import_node_fs4.default.existsSync(import_node_path4.default.join(repositoryRoot, "vlt-workspaces.json"))) {
       return true;
     }
+    if (process.env.NX_WORKSPACE_ROOT === import_node_path4.default.resolve(repositoryRoot)) {
+      return true;
+    }
     const packageJsonPath = import_node_path4.default.join(repositoryRoot, "package.json");
     if (!import_node_fs4.default.existsSync(packageJsonPath)) {
       return false;
@@ -1342,8 +1351,42 @@ function findConfig({ dir }) {
   return null;
 }
 
-// src/config/microfrontends/server/utils/get-output-file-path.ts
+// src/config/microfrontends/utils/get-application-context.ts
+var import_node_fs7 = __toESM(require("fs"), 1);
 var import_node_path7 = __toESM(require("path"), 1);
+function getApplicationContext(opts) {
+  if (opts?.appName) {
+    return { name: opts.appName };
+  }
+  if (process.env.NX_TASK_TARGET_PROJECT) {
+    return { name: process.env.NX_TASK_TARGET_PROJECT };
+  }
+  try {
+    const packageJsonString = import_node_fs7.default.readFileSync(
+      import_node_path7.default.join(opts?.packageRoot || ".", "package.json"),
+      "utf-8"
+    );
+    const packageJson = JSON.parse(packageJsonString);
+    if (!packageJson.name) {
+      throw new MicrofrontendError(
+        `package.json file missing required field "name"`,
+        {
+          type: "packageJson",
+          subtype: "missing_field_name",
+          source: "@vercel/microfrontends/next"
+        }
+      );
+    }
+    return { name: packageJson.name };
+  } catch (err) {
+    throw MicrofrontendError.handle(err, {
+      fileName: "package.json"
+    });
+  }
+}
+
+// src/config/microfrontends/server/utils/get-output-file-path.ts
+var import_node_path8 = __toESM(require("path"), 1);
 
 // src/config/microfrontends/server/constants.ts
 var MFE_CONFIG_DEFAULT_FILE_PATH = "microfrontends";
@@ -1351,7 +1394,7 @@ var MFE_CONFIG_DEFAULT_FILE_NAME = "microfrontends.json";
 
 // src/config/microfrontends/server/utils/get-output-file-path.ts
 function getOutputFilePath() {
-  return import_node_path7.default.join(MFE_CONFIG_DEFAULT_FILE_PATH, MFE_CONFIG_DEFAULT_FILE_NAME);
+  return import_node_path8.default.join(MFE_CONFIG_DEFAULT_FILE_PATH, MFE_CONFIG_DEFAULT_FILE_NAME);
 }
 
 // src/config/microfrontends/server/validation.ts
@@ -1690,8 +1733,8 @@ var MicrofrontendsServer = class extends Microfrontends {
     pretty: true
   }) {
     const outputPath = getOutputFilePath();
-    import_node_fs7.default.mkdirSync((0, import_node_path8.dirname)(outputPath), { recursive: true });
-    import_node_fs7.default.writeFileSync(
+    import_node_fs8.default.mkdirSync((0, import_node_path9.dirname)(outputPath), { recursive: true });
+    import_node_fs8.default.writeFileSync(
       outputPath,
       JSON.stringify(
         this.config.toSchemaJson(),
@@ -1777,14 +1820,8 @@ var MicrofrontendsServer = class extends Microfrontends {
     }
     try {
       const packageRoot = findPackageRoot(directory);
-      const packageJsonPath = (0, import_node_path8.join)(packageRoot, "package.json");
-      const packageJson = JSON.parse(
-        import_node_fs7.default.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 { name: appName } = getApplicationContext({ packageRoot });
+      const configMeta = meta ?? { fromApp: appName };
       const maybeConfig = findConfig({ dir: packageRoot });
       if (maybeConfig) {
         return MicrofrontendsServer.fromFile({
@@ -1799,7 +1836,7 @@ var MicrofrontendsServer = class extends Microfrontends {
       if (isMonorepo2) {
         const defaultPackage = findDefaultMicrofrontendsPackage({
           repositoryRoot,
-          applicationName: packageJson.name
+          applicationName: appName
         });
         const maybeConfigFromDefault = findConfig({ dir: defaultPackage });
         if (maybeConfigFromDefault) {
@@ -1829,7 +1866,7 @@ var MicrofrontendsServer = class extends Microfrontends {
     options
   }) {
     try {
-      const configJson = import_node_fs7.default.readFileSync(filePath, "utf-8");
+      const configJson = import_node_fs8.default.readFileSync(filePath, "utf-8");
       const config = MicrofrontendsServer.validate(configJson);
       if (!isMainConfig(config) && options?.resolveMainConfig) {
         const repositoryRoot = findRepositoryRoot();
@@ -1877,7 +1914,7 @@ var MicrofrontendsServer = class extends Microfrontends {
     overrides
   }) {
     try {
-      const config = import_node_fs7.default.readFileSync(filePath, "utf-8");
+      const config = import_node_fs8.default.readFileSync(filePath, "utf-8");
       const validatedConfig = MicrofrontendsServer.validate(config);
       if (!isMainConfig(validatedConfig)) {
         throw new MicrofrontendError(
@@ -1967,7 +2004,7 @@ var ProxyRequestRouter = class {
     const isJWTRedirect = url.searchParams.has("_vercel_jwt");
     const defaultHost = this.getDefaultHost(config);
     let hostname = null;
-    let path6 = request2.url;
+    let path7 = request2.url;
     if (isAuthRedirect) {
       hostname = url.searchParams.get("_host_override");
     }
@@ -1977,12 +2014,12 @@ var ProxyRequestRouter = class {
     if (isJWTRedirect) {
       hostname = url.searchParams.get("_host_override");
       url.searchParams.delete("_host_override");
-      path6 = `${url.pathname}${url.search}`;
+      path7 = `${url.pathname}${url.search}`;
     }
     if (!hostname) {
       return void 0;
     }
-    return { ...defaultHost, path: path6, hostname, protocol: "https", port: 443 };
+    return { ...defaultHost, path: path7, hostname, protocol: "https", port: 443 };
   }
   getConfigWithOverrides(cookies) {
     const cookieOverrides = parseOverrides(
@@ -2006,14 +2043,14 @@ var ProxyRequestRouter = class {
     if (!request2.url) {
       return this.getDefaultHost(config);
     }
-    const { path: path6, mfeFlagValue } = extractMfeFlagValue(request2.url);
+    const { path: path7, mfeFlagValue } = extractMfeFlagValue(request2.url);
     const authTarget = this.getAuthTarget(request2, config);
     if (authTarget) {
       return authTarget;
     }
-    const url = new import_node_url.URL(`http://example.com${path6}`);
+    const url = new import_node_url.URL(`http://example.com${path7}`);
     const target = this.findMatchingApplication({
-      path: path6,
+      path: path7,
       url,
       applications: config.getChildApplications(),
       referer: request2.headers.referer,
@@ -2029,12 +2066,12 @@ var ProxyRequestRouter = class {
       return target;
     const defaultHost = this.getDefaultHost(config);
     mfeDebug(
-      `no matching routes, routing ${path6} to default application: ${JSON.stringify(defaultHost)}`
+      `no matching routes, routing ${path7} to default application: ${JSON.stringify(defaultHost)}`
     );
-    return { path: path6, ...defaultHost };
+    return { path: path7, ...defaultHost };
   }
   findMatchingApplication({
-    path: path6,
+    path: path7,
     url,
     applications,
     referer = void 0,
@@ -2046,15 +2083,15 @@ var ProxyRequestRouter = class {
       if (middlewareMfeZone) {
         if (middlewareMfeZone === application.name) {
           mfeDebug(
-            `routing ${path6} to '${target.application}' at ${target.hostname} according to 'x-vercel-mfe-zone' header`
+            `routing ${path7} to '${target.application}' at ${target.hostname} according to 'x-vercel-mfe-zone' header`
           );
-          return { path: path6, ...target };
+          return { path: path7, ...target };
         }
         continue;
       }
       const builtInRewrite = this.checkBuiltinAssetPrefix({
         rewrites: ["/:path*"],
-        path: path6,
+        path: path7,
         url,
         app: application
       }) || this.checkNextOriginalFrame({ url, referer, applications });
@@ -2066,7 +2103,7 @@ var ProxyRequestRouter = class {
           const regexp = (0, import_path_to_regexp3.pathToRegexp)(childPath);
           if (regexp.test(url.pathname)) {
             mfeDebug(
-              `routing ${path6} to '${target.application}' at ${target.hostname}`
+              `routing ${path7} to '${target.application}' at ${target.hostname}`
             );
             if (group.flag) {
               if (mfeFlagValue === true) {
@@ -2079,13 +2116,13 @@ var ProxyRequestRouter = class {
                 if (!this.isDefaultAppLocal()) {
                   const defaultApp = this.getDefaultHost(this.config);
                   console.error(
-                    `'${path6}' is a flagged path, but the default application is not running locally. Using '${defaultApp.hostname}' to handle this request.`
+                    `'${path7}' is a flagged path, but the default application is not running locally. Using '${defaultApp.hostname}' to handle this request.`
                   );
                 }
                 return null;
               }
             }
-            return { path: path6, ...target };
+            return { path: path7, ...target };
           }
         }
       }
@@ -2099,7 +2136,7 @@ var ProxyRequestRouter = class {
   }
   checkBuiltinAssetPrefix({
     rewrites,
-    path: path6,
+    path: path7,
     url,
     app
   }) {
@@ -2111,7 +2148,7 @@ var ProxyRequestRouter = class {
           `routing ${pathname} to '${target.application}' at ${target.hostname}`
         );
         return {
-          path: path6,
+          path: path7,
           ...target
         };
       }
@@ -2210,10 +2247,10 @@ var LocalProxy = class {
     const target = this.router.getTarget(req);
     const { req: strippedReq, mfeFlagValue } = removeMfeFlagQuery(req);
     if (target.protocol === "https") {
-      const { hostname, port, path: path6 } = target;
+      const { hostname, port, path: path7 } = target;
       const requestOptions = {
         hostname,
-        path: path6,
+        path: path7,
         method: req.method,
         headers: { ...req.headers, host: hostname },
         port
@@ -2238,7 +2275,7 @@ var LocalProxy = class {
         console.error("Proxy request error: ", err);
         res.writeHead(500, { "Content-Type": "text/plain" });
         res.end(
-          `Error proxying request for ${target.application} to ${hostname}:${port}${path6}`
+          `Error proxying request for ${target.application} to ${hostname}:${port}${path7}`
         );
       });
     } else {
@@ -2255,11 +2292,11 @@ var LocalProxy = class {
   }
   // Handles requests that return data from the local proxy itself.
   // Returns true if the request was handled, false otherwise.
-  handleProxyInfoRequest(path6, res) {
-    if (!path6) {
+  handleProxyInfoRequest(path7, res) {
+    if (!path7) {
       return false;
     }
-    const url = new import_node_url.URL(`http://example.comf${path6}`);
+    const url = new import_node_url.URL(`http://example.comf${path7}`);
     const pathname = url.pathname;
     switch (pathname) {
       case "/.well-known/vercel/microfrontends/routing": {
@@ -2282,12 +2319,12 @@ var LocalProxy = class {
     return false;
   }
 };
-function extractMfeFlagValue(path6) {
+function extractMfeFlagValue(path7) {
   const host = "http://example.com";
-  const url = new import_node_url.URL(`${host}${path6}`);
+  const url = new import_node_url.URL(`${host}${path7}`);
   const mfeFlagValue = stringAsBoolean(url.searchParams.get(MFE_FLAG_VALUE));
   url.searchParams.delete(MFE_FLAG_VALUE);
-  const pathWithoutMfe = mfeFlagValue === void 0 ? path6 : url.toString().substring(host.length);
+  const pathWithoutMfe = mfeFlagValue === void 0 ? path7 : url.toString().substring(host.length);
   return { path: pathWithoutMfe, mfeFlagValue };
 }
 function stringAsBoolean(value) {
@@ -2302,11 +2339,11 @@ function removeMfeFlagQuery(req) {
   if (!req.url) {
     return { req };
   }
-  const { path: path6, mfeFlagValue } = extractMfeFlagValue(req.url);
+  const { path: path7, mfeFlagValue } = extractMfeFlagValue(req.url);
   if (mfeFlagValue === void 0) {
     return { req };
   }
-  req.url = path6;
+  req.url = path7;
   return { req, mfeFlagValue };
 }
 
@@ -2314,8 +2351,8 @@ function removeMfeFlagQuery(req) {
 var import_node_process = require("process");
 
 // src/utils/mfe-port.ts
-var import_node_path9 = __toESM(require("path"), 1);
-var import_node_fs8 = __toESM(require("fs"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
+var import_node_fs9 = __toESM(require("fs"), 1);
 function mfePort(packageDir) {
   const { name: appName, version } = getPackageJson(packageDir);
   const result = loadConfig({ packageDir, appName });
@@ -2333,8 +2370,8 @@ function mfePort(packageDir) {
   };
 }
 function getPackageJson(packageDir) {
-  const filePath = import_node_path9.default.join(packageDir, "package.json");
-  return JSON.parse(import_node_fs8.default.readFileSync(filePath, "utf-8"));
+  const filePath = import_node_path10.default.join(packageDir, "package.json");
+  return JSON.parse(import_node_fs9.default.readFileSync(filePath, "utf-8"));
 }
 function loadConfig({
   packageDir,

package/dist/config.cjs

@@ -323,6 +323,9 @@ function validatePathExpression(path) {
         return `token ${i} in ${path} is undefined, this shouldn't happen`;
       }
       if (typeof token !== "string") {
+        if (!token.name) {
+          return `Only named wildcards are allowed: ${path} (hint: add ":path" to the wildcard)`;
+        }
         if (token.pattern !== PATH_DEFAULT_PATTERN && // Allows (a|b|c) and ((?!a|b|c).*) regex
         // Only limited regex is supported for now, due to performance considerations
         !/^(?<allowed>[\w]+(?:\|[^|()]+)+)$|^\(\?!(?<disallowed>[\w]+(?:\|[^|()]+)+)\)\.\*$/.test(