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

package/dist/microfrontends/server.cjs

@@ -33,8 +33,8 @@ __export(server_exports, {
   MicrofrontendsServer: () => MicrofrontendsServer
 });
 module.exports = __toCommonJS(server_exports);
-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/overrides/constants.ts
 var OVERRIDES_COOKIE_PREFIX = "vercel-micro-frontends-override";
@@ -217,21 +217,21 @@ var MicrofrontendConfigClient = class {
   isEqual(other) {
     return JSON.stringify(this.applications) === JSON.stringify(other.applications);
   }
-  getApplicationNameForPath(path5) {
-    if (!path5.startsWith("/")) {
+  getApplicationNameForPath(path6) {
+    if (!path6.startsWith("/")) {
       throw new Error(`Path must start with a /`);
     }
-    if (this.pathCache[path5]) {
-      return this.pathCache[path5];
+    if (this.pathCache[path6]) {
+      return this.pathCache[path6];
     }
-    const pathname = new URL(path5, "https://example.com").pathname;
+    const pathname = new URL(path6, "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_regexp.pathToRegexp)(childPath);
             if (regexp.test(pathname)) {
-              this.pathCache[path5] = name;
+              this.pathCache[path6] = name;
               return name;
             }
           }
@@ -244,7 +244,7 @@ var MicrofrontendConfigClient = class {
     if (!defaultApplication) {
       return null;
     }
-    this.pathCache[path5] = defaultApplication[0];
+    this.pathCache[path6] = defaultApplication[0];
     return defaultApplication[0];
   }
   serialize() {
@@ -266,18 +266,18 @@ var validateConfigPaths = (applicationConfigsById) => {
     }
     const childApp = app;
     for (const pathMatch of childApp.routing) {
-      for (const path5 of pathMatch.paths) {
-        const maybeError = validatePathExpression(path5);
+      for (const path6 of pathMatch.paths) {
+        const maybeError = validatePathExpression(path6);
         if (maybeError) {
           errors.push(maybeError);
         } else {
-          const existing = pathsByApplicationId.get(path5);
+          const existing = pathsByApplicationId.get(path6);
           if (existing) {
             existing.applications.push(id);
           } else {
-            pathsByApplicationId.set(path5, {
+            pathsByApplicationId.set(path6, {
               applications: [id],
-              matcher: (0, import_path_to_regexp2.pathToRegexp)(path5),
+              matcher: (0, import_path_to_regexp2.pathToRegexp)(path6),
               applicationId: id
             });
           }
@@ -286,24 +286,24 @@ var validateConfigPaths = (applicationConfigsById) => {
     }
   }
   const entries = Array.from(pathsByApplicationId.entries());
-  for (const [path5, { applications: ids, matcher, applicationId }] of entries) {
+  for (const [path6, { applications: ids, matcher, applicationId }] of entries) {
     if (ids.length > 1) {
       errors.push(
-        `Duplicate path "${path5}" for applications "${ids.join(", ")}"`
+        `Duplicate path "${path6}" for applications "${ids.join(", ")}"`
       );
     }
     for (const [
       matchPath,
       { applications: matchIds, applicationId: matchApplicationId }
     ] of entries) {
-      if (path5 === matchPath) {
+      if (path6 === matchPath) {
         continue;
       }
       if (applicationId === matchApplicationId) {
         continue;
       }
       if (matcher.test(matchPath)) {
-        const source = `"${path5}" of application${ids.length > 0 ? "s" : ""} ${ids.join(", ")}`;
+        const source = `"${path6}" 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}`
@@ -319,39 +319,42 @@ var validateConfigPaths = (applicationConfigsById) => {
   }
 };
 var PATH_DEFAULT_PATTERN = "[^\\/#\\?]+?";
-function validatePathExpression(path5) {
+function validatePathExpression(path6) {
   try {
-    const tokens = (0, import_path_to_regexp2.parse)(path5);
-    if (/(?<!\\)\{/.test(path5)) {
-      return `Optional paths are not supported: ${path5}`;
+    const tokens = (0, import_path_to_regexp2.parse)(path6);
+    if (/(?<!\\)\{/.test(path6)) {
+      return `Optional paths are not supported: ${path6}`;
     }
-    if (/(?<!\\|\()\?/.test(path5)) {
-      return `Optional paths are not supported: ${path5}`;
+    if (/(?<!\\|\()\?/.test(path6)) {
+      return `Optional paths are not supported: ${path6}`;
     }
-    if (/\/[^/]*(?<!\\):[^/]*(?<!\\):[^/]*/.test(path5)) {
-      return `Only one wildcard is allowed per path segment: ${path5}`;
+    if (/\/[^/]*(?<!\\):[^/]*(?<!\\):[^/]*/.test(path6)) {
+      return `Only one wildcard is allowed per path segment: ${path6}`;
     }
     for (let i = 0; i < tokens.length; i++) {
       const token = tokens[i];
       if (token === void 0) {
-        return `token ${i} in ${path5} is undefined, this shouldn't happen`;
+        return `token ${i} in ${path6} is undefined, this shouldn't happen`;
       }
       if (typeof token !== "string") {
+        if (!token.name) {
+          return `Only named wildcards are allowed: ${path6} (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 ${path5} cannot use unsupported regular expression wildcard`;
+          return `Path ${path6} 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 ${path5}. Modifiers are only allowed in the last path component`;
+          return `Modifier ${token.modifier} is not allowed on wildcard :${token.name} in ${path6}. Modifiers are only allowed in the last path component`;
         }
       }
     }
   } catch (e) {
     const message = e instanceof Error ? e.message : String(e);
-    return `Path ${path5} could not be parsed into regexp: ${message}`;
+    return `Path ${path6} could not be parsed into regexp: ${message}`;
   }
   return void 0;
 }
@@ -906,6 +909,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);
@@ -1063,6 +1069,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;
@@ -1108,8 +1117,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";
@@ -1117,7 +1160,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
@@ -1456,8 +1499,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(),
@@ -1543,14 +1586,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({
@@ -1565,7 +1602,7 @@ var MicrofrontendsServer = class extends Microfrontends {
       if (isMonorepo2) {
         const defaultPackage = findDefaultMicrofrontendsPackage({
           repositoryRoot,
-          applicationName: packageJson.name
+          applicationName: appName
         });
         const maybeConfigFromDefault = findConfig({ dir: defaultPackage });
         if (maybeConfigFromDefault) {
@@ -1595,7 +1632,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();
@@ -1643,7 +1680,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(