@vercel/microfrontends 0.10.0 → 0.10.1

package/dist/v2/microfrontends/server.js

@@ -1,6 +1,6 @@
 // src/config-v2/microfrontends/server/index.ts
-import fs from "node:fs";
-import { dirname } from "node:path";
+import fs2 from "node:fs";
+import { dirname as dirname2, join } from "node:path";
 
 // src/config-v2/overrides/constants.ts
 var OVERRIDES_COOKIE_PREFIX = "vercel-microfrontends-override";
@@ -184,21 +184,21 @@ var MicrofrontendConfigClient = class {
   isEqual(other) {
     return JSON.stringify(this.applications) === JSON.stringify(other.applications);
   }
-  getApplicationNameForPath(path2) {
-    if (!path2.startsWith("/")) {
+  getApplicationNameForPath(path3) {
+    if (!path3.startsWith("/")) {
       throw new Error(`Path must start with a /`);
     }
-    if (this.pathCache[path2]) {
-      return this.pathCache[path2];
+    if (this.pathCache[path3]) {
+      return this.pathCache[path3];
     }
-    const pathname = new URL(path2, "https://example.com").pathname;
+    const pathname = new URL(path3, "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[path2] = name;
+              this.pathCache[path3] = name;
               return name;
             }
           }
@@ -211,7 +211,7 @@ var MicrofrontendConfigClient = class {
     if (!defaultApplication) {
       return null;
     }
-    this.pathCache[path2] = defaultApplication[0];
+    this.pathCache[path3] = defaultApplication[0];
     return defaultApplication[0];
   }
   serialize() {
@@ -243,22 +243,22 @@ var validateConfigPaths = (applicationConfigsById) => {
       continue;
     }
     for (const pathMatch of app.routing) {
-      for (const path2 of pathMatch.paths) {
-        const tokens = parsePathRegexp(path2);
+      for (const path3 of pathMatch.paths) {
+        const tokens = parsePathRegexp(path3);
         for (const token of tokens.slice(0, -1)) {
           if (typeof token !== "string") {
             errors.push(
-              `Path ${path2} may only have a :wildcard in the last path component`
+              `Path ${path3} may only have a :wildcard in the last path component`
             );
           }
         }
-        const existing = pathsByApplicationId.get(path2);
+        const existing = pathsByApplicationId.get(path3);
         if (existing) {
           existing.applications.push(id);
         } else {
-          pathsByApplicationId.set(path2, {
+          pathsByApplicationId.set(path3, {
             applications: [id],
-            matcher: pathToRegexp2(path2),
+            matcher: pathToRegexp2(path3),
             applicationId: id
           });
         }
@@ -266,10 +266,10 @@ var validateConfigPaths = (applicationConfigsById) => {
     }
   }
   const entries = Array.from(pathsByApplicationId.entries());
-  entries.forEach(([path2, { applications: ids, matcher, applicationId }]) => {
+  entries.forEach(([path3, { applications: ids, matcher, applicationId }]) => {
     if (ids.length > 1) {
       errors.push(
-        `Duplicate path "${path2}" for applications "${ids.join(", ")}"`
+        `Duplicate path "${path3}" for applications "${ids.join(", ")}"`
       );
     }
     entries.forEach(
@@ -277,14 +277,14 @@ var validateConfigPaths = (applicationConfigsById) => {
         matchPath,
         { applications: matchIds, applicationId: matchApplicationId }
       ]) => {
-        if (path2 === matchPath) {
+        if (path3 === matchPath) {
           return;
         }
         if (applicationId === matchApplicationId) {
           return;
         }
         if (matcher.test(matchPath)) {
-          const source = `"${path2}" of application${ids.length > 0 ? "s" : ""} ${ids.join(", ")}`;
+          const source = `"${path3}" 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}`
@@ -775,8 +775,82 @@ var Microfrontends = class {
   }
 };
 
-// src/config-v2/microfrontends/server/utils/get-output-file-path.ts
+// src/config-v2/microfrontends/utils/find-repository-root.ts
+import fs from "node:fs";
 import path from "node:path";
+var GIT_DIRECTORY = ".git";
+function findRepositoryRoot(startDir) {
+  let currentDir = startDir || process.cwd();
+  while (currentDir !== path.parse(currentDir).root) {
+    const gitPath = path.join(currentDir, GIT_DIRECTORY);
+    if (fs.existsSync(gitPath) && fs.statSync(gitPath).isDirectory()) {
+      return currentDir;
+    }
+    currentDir = path.dirname(currentDir);
+  }
+  throw new Error(
+    "Repository root not found. Specify the root of the repository with the `repository.root` option."
+  );
+}
+
+// src/config-v2/microfrontends/utils/find-package-path.ts
+import { dirname } from "node:path";
+import { readFileSync } from "node:fs";
+import fg from "fast-glob";
+var configCache = {};
+function findPackagePathWithGlob({
+  repositoryRoot,
+  name
+}) {
+  try {
+    const packageJsonPaths = fg.globSync("**/package.json", {
+      cwd: repositoryRoot,
+      absolute: true,
+      onlyFiles: true,
+      followSymbolicLinks: false,
+      ignore: ["**/node_modules/**", "**/.git/**"]
+    });
+    const matchingPaths = [];
+    for (const packageJsonPath2 of packageJsonPaths) {
+      const packageJsonContent = readFileSync(packageJsonPath2, "utf-8");
+      const packageJson = JSON.parse(packageJsonContent);
+      if (packageJson.name === name) {
+        matchingPaths.push(packageJsonPath2);
+      }
+    }
+    if (matchingPaths.length > 1) {
+      throw new Error(
+        `Found multiple packages with the name "${name}" in the repository: ${matchingPaths.join(", ")}`
+      );
+    }
+    if (matchingPaths.length === 0) {
+      throw new Error(
+        `Could not find package with the name "${name}" in the repository`
+      );
+    }
+    const [packageJsonPath] = matchingPaths;
+    return dirname(packageJsonPath);
+  } catch (error) {
+    return null;
+  }
+}
+function findPackagePath(opts) {
+  const cacheKey = `${opts.repositoryRoot}-${opts.name}`;
+  if (configCache[cacheKey]) {
+    return configCache[cacheKey];
+  }
+  const result = findPackagePathWithGlob(opts);
+  if (!result) {
+    throw new Error(
+      `Could not find package with the name "${opts.name}" in the repository`
+    );
+  }
+  configCache[cacheKey] = result;
+  return result;
+}
+
+// src/config-v2/microfrontends/server/utils/get-output-file-path.ts
+import path2 from "node:path";
 
 // src/config-v2/microfrontends/server/constants.ts
 var MFE_CONFIG_DEFAULT_FILE_PATH = "microfrontends";
@@ -790,13 +864,13 @@ function isVercel() {
 // src/config-v2/microfrontends/server/utils/get-output-file-path.ts
 function getOutputFilePath() {
   if (isVercel()) {
-    return path.join(
+    return path2.join(
       ".vercel",
       MFE_CONFIG_DEFAULT_FILE_PATH,
       MFE_CONFIG_DEFAULT_FILE_NAME
     );
   }
-  return path.join(MFE_CONFIG_DEFAULT_FILE_PATH, MFE_CONFIG_DEFAULT_FILE_NAME);
+  return path2.join(MFE_CONFIG_DEFAULT_FILE_PATH, MFE_CONFIG_DEFAULT_FILE_NAME);
 }
 
 // src/config-v2/microfrontends/server/validation.ts
@@ -1106,10 +1180,6 @@ var schema_v2_default = {
           type: "string",
           description: "flag name that can be used to enable/disable all paths in the group"
         },
-        routeToDefaultApplication: {
-          type: "boolean",
-          description: "True to route the request to the default application for this micro-frontends set-up. This must be `true` when using `flag` or when you want to use custom logic to make the routing decision for this group of paths."
-        },
         paths: {
           type: "array",
           items: {
@@ -1186,8 +1256,8 @@ var MicrofrontendsServer = class extends Microfrontends {
     pretty: true
   }) {
     const outputPath = getOutputFilePath();
-    fs.mkdirSync(dirname(outputPath), { recursive: true });
-    fs.writeFileSync(
+    fs2.mkdirSync(dirname2(outputPath), { recursive: true });
+    fs2.writeFileSync(
       outputPath,
       JSON.stringify(
         this.config.toSchemaJson(),
@@ -1255,12 +1325,32 @@ var MicrofrontendsServer = class extends Microfrontends {
   static fromFile({
     filePath,
     cookies,
-    meta
+    meta,
+    options
   }) {
     try {
-      const config = fs.readFileSync(filePath, "utf-8");
+      const configJson = fs2.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 mainConfigPath = join(packagePath, "microfrontends.json");
+        return MicrofrontendsServer.fromMainConfigFile({
+          filePath: mainConfigPath,
+          overrides: cookies ? parseOverrides(cookies) : void 0
+        });
+      }
       return new MicrofrontendsServer({
-        config: MicrofrontendsServer.validate(config),
+        config,
         overrides: cookies ? parseOverrides(cookies) : void 0,
         meta
       });
@@ -1278,7 +1368,7 @@ var MicrofrontendsServer = class extends Microfrontends {
     overrides
   }) {
     try {
-      const config = fs.readFileSync(filePath, "utf-8");
+      const config = fs2.readFileSync(filePath, "utf-8");
       const validatedConfig = MicrofrontendsServer.validate(config);
       if (!isMainConfig(validatedConfig)) {
         throw new MicrofrontendError(