@vercel/microfrontends 0.13.0 → 0.14.0

package/dist/v2/next/config.js

@@ -1,9 +1,9 @@
 // src/next-v2/config/index.ts
-import fs5 from "node:fs";
+import fs6 from "node:fs";
 
 // src/config-v2/microfrontends/server/index.ts
-import fs4 from "node:fs";
-import { dirname as dirname3, join } from "node:path";
+import fs5 from "node:fs";
+import { dirname as dirname3, join as join2 } from "node:path";
 
 // src/config-v2/overrides/constants.ts
 var OVERRIDES_COOKIE_PREFIX = "vercel-micro-frontends-override";
@@ -350,19 +350,6 @@ var validateConfigDefaultApplication = (applicationConfigsById) => {
     );
   }
 };
-var validateConfigOptions = (options) => {
-  var _a;
-  if ((_a = options == null ? void 0 : options.vercel) == null ? void 0 : _a.previewDeploymentSuffix) {
-    if (!/^[a-zA-Z]{2,}\.[a-zA-Z]{2,}$/.test(
-      options.vercel.previewDeploymentSuffix
-    )) {
-      throw new MicrofrontendError(
-        `Invalid preview deployment suffix: ${options.vercel.previewDeploymentSuffix}. Should have be formatted like "vercel.app".`,
-        { type: "config", subtype: "invalid_preview_deployment_suffix" }
-      );
-    }
-  }
-};
 
 // src/config-v2/microfrontends-config/isomorphic/utils/generate-asset-prefix.ts
 var PREFIX = "vc-ap";
@@ -581,7 +568,6 @@ var MicrofrontendConfigIsomorphic = class {
       validateConfigPaths(c.applications);
       validateConfigDefaultApplication(c.applications);
     }
-    validateConfigOptions(c.options);
     return c;
   }
   static fromEnv({
@@ -857,29 +843,39 @@ function findPackagePath(opts) {
 // src/config-v2/microfrontends/utils/find-default-package.ts
 import { dirname as dirname2 } from "node:path";
 import { readFileSync as readFileSync2 } from "node:fs";
+import { parse as parse2 } from "jsonc-parser";
 import fg2 from "fast-glob";
+
+// src/config-v2/constants.ts
+var CONFIGURATION_FILENAMES = [
+  "microfrontends.jsonc",
+  "microfrontends.json"
+];
+
+// src/config-v2/microfrontends/utils/find-default-package.ts
 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 microfrontendsJsonPaths = fg2.globSync(
+      `**/{${CONFIGURATION_FILENAMES.join(",")}}`,
+      {
+        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
-      );
+      const microfrontendsJson = parse2(microfrontendsJsonContent);
       if (isMainConfig(microfrontendsJson) && microfrontendsJson.applications[applicationName]) {
         matchingPaths.push(microfrontendsJsonPath);
       }
@@ -909,7 +905,7 @@ function findDefaultMicrofrontendsPackage(opts) {
   const result = findDefaultMicrofrontendsPackages(opts);
   if (!result) {
     throw new Error(
-      `Error trying to resolve the main microfrontends.json configuration`
+      `Error trying to resolve the main microfrontends configuration`
     );
   }
   configCache2[cacheKey] = result;
@@ -961,6 +957,19 @@ function findPackageRoot(startDir) {
   );
 }
 
+// src/config-v2/microfrontends/utils/find-config.ts
+import fs4 from "node:fs";
+import { join } from "node:path";
+function findConfig({ dir }) {
+  for (const filename of CONFIGURATION_FILENAMES) {
+    const maybeConfig = join(dir, filename);
+    if (fs4.existsSync(maybeConfig)) {
+      return maybeConfig;
+    }
+  }
+  return null;
+}
+
 // src/config-v2/microfrontends/server/utils/get-output-file-path.ts
 import path4 from "node:path";
 
@@ -986,7 +995,7 @@ function getOutputFilePath() {
 }
 
 // src/config-v2/microfrontends/server/validation.ts
-import { parse as parse2 } from "jsonc-parser";
+import { parse as parse3 } from "jsonc-parser";
 import { Ajv } from "ajv";
 
 // src/config/errors.ts
@@ -1139,10 +1148,6 @@ var schema_v2_default = {
     VercelOptions: {
       type: "object",
       properties: {
-        previewDeploymentSuffix: {
-          type: "string",
-          description: "If your team uses a custom Preview Deployment Suffix, please specify it here. See https://vercel.com/docs/deployments/preview-deployment-suffix. The default is `vercel.app`."
-        },
         teamSlug: {
           type: "string",
           description: "Team slug for the Vercel team"
@@ -1336,7 +1341,7 @@ var SCHEMA = schema_v2_default;
 
 // src/config-v2/microfrontends/server/validation.ts
 function validateSchema(configString) {
-  const parsedConfig = parse2(configString);
+  const parsedConfig = parse3(configString);
   const ajv = new Ajv();
   const validate = ajv.compile(SCHEMA);
   const isValid = validate(parsedConfig);
@@ -1358,8 +1363,8 @@ var MicrofrontendsServer = class extends Microfrontends {
     pretty: true
   }) {
     const outputPath = getOutputFilePath();
-    fs4.mkdirSync(dirname3(outputPath), { recursive: true });
-    fs4.writeFileSync(
+    fs5.mkdirSync(dirname3(outputPath), { recursive: true });
+    fs5.writeFileSync(
       outputPath,
       JSON.stringify(
         this.config.toSchemaJson(),
@@ -1422,8 +1427,8 @@ 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
+   * Looks up the configuration by inferring the package root and looking for a microfrontends config file. If a file is not found,
+   * it will look for a package in the repository with a microfrontends file that contains the current application
    * and use that configuration.
    *
    * This can return either a Child or Main configuration.
@@ -1445,16 +1450,16 @@ var MicrofrontendsServer = class extends Microfrontends {
     }
     try {
       const packageRoot = findPackageRoot(directory);
-      const packageJsonPath = join(packageRoot, "package.json");
+      const packageJsonPath = join2(packageRoot, "package.json");
       const packageJson = JSON.parse(
-        fs4.readFileSync(packageJsonPath, "utf-8")
+        fs5.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)) {
+      const maybeConfig = findConfig({ dir: packageRoot });
+      if (maybeConfig) {
         return MicrofrontendsServer.fromFile({
           filePath: maybeConfig,
           cookies,
@@ -1469,12 +1474,15 @@ var MicrofrontendsServer = class extends Microfrontends {
           repositoryRoot,
           applicationName: packageJson.name
         });
-        return MicrofrontendsServer.fromFile({
-          filePath: join(defaultPackage, "microfrontends.json"),
-          cookies,
-          meta: configMeta,
-          options
-        });
+        const maybeConfigFromDefault = findConfig({ dir: defaultPackage });
+        if (maybeConfigFromDefault) {
+          return MicrofrontendsServer.fromFile({
+            filePath: maybeConfigFromDefault,
+            cookies,
+            meta: configMeta,
+            options
+          });
+        }
       }
       throw new Error("Unable to infer");
     } catch (e) {
@@ -1494,7 +1502,7 @@ var MicrofrontendsServer = class extends Microfrontends {
     options
   }) {
     try {
-      const configJson = fs4.readFileSync(filePath, "utf-8");
+      const configJson = fs5.readFileSync(filePath, "utf-8");
       const config = MicrofrontendsServer.validate(configJson);
       if (!isMainConfig(config) && (options == null ? void 0 : options.resolveMainConfig)) {
         const repositoryRoot = findRepositoryRoot();
@@ -1510,9 +1518,15 @@ var MicrofrontendsServer = class extends Microfrontends {
               { type: "config", subtype: "not_found" }
             );
           }
-          const mainConfigPath = join(packagePath, "microfrontends.json");
+          const maybeConfig = findConfig({ dir: packagePath });
+          if (!maybeConfig) {
+            throw new MicrofrontendError(
+              `Could not find microfrontends configuration in ${packagePath}`,
+              { type: "config", subtype: "not_found" }
+            );
+          }
           return MicrofrontendsServer.fromMainConfigFile({
-            filePath: mainConfigPath,
+            filePath: maybeConfig,
             overrides: cookies ? parseOverrides(cookies) : void 0
           });
         }
@@ -1536,7 +1550,7 @@ var MicrofrontendsServer = class extends Microfrontends {
     overrides
   }) {
     try {
-      const config = fs4.readFileSync(filePath, "utf-8");
+      const config = fs5.readFileSync(filePath, "utf-8");
       const validatedConfig = MicrofrontendsServer.validate(config);
       if (!isMainConfig(validatedConfig)) {
         throw new MicrofrontendError(
@@ -1814,6 +1828,16 @@ function transform4(args) {
   const buildBeforeFiles = () => {
     const rewrites = /* @__PURE__ */ new Map();
     if (!app.isDefault()) {
+      rewrites.set(`/${app.getAssetPrefix()}/_next/:path+`, {
+        destination: {
+          pathname: `/_next/:path+`
+        }
+      });
+      rewrites.set(`/${app.getAssetPrefix()}/.well-known/vercel/flags`, {
+        destination: {
+          pathname: `/.well-known/vercel/flags`
+        }
+      });
       if (process.env.VERCEL_MICROFRONTENDS_CONSOLIDATE_SPEED_INSIGHTS === "1") {
         rewrites.set(`/${app.getAssetPrefix()}/_vercel/:path*`, {
           destination: { pathname: "/_vercel/:path*" }
@@ -1882,9 +1906,27 @@ function transform4(args) {
 }
 
 // src/next-v2/config/transforms/server-actions.ts
+function debugRewrites2(allowedOrigins) {
+  if (process.env.MFE_DEBUG === "true" && allowedOrigins) {
+    const indent = " ".repeat(4);
+    const header = "server actions allowed origins";
+    const separator = "\u23AF".repeat(header.length);
+    const maxSourceLength = Math.max(
+      ...allowedOrigins.map((key) => key.length)
+    );
+    const table = allowedOrigins.map((origin, idx) => {
+      const paddedSource = origin.padEnd(maxSourceLength);
+      return `${indent} ${idx + 1}. ${paddedSource}`;
+    }).join("\n");
+    console.log(`${indent}${header}
+${indent}${separator}
+${table}
+`);
+  }
+}
 var formatDomainForServerAction = (domain) => domain.replace(/https?:\/\//, "");
 function transform5(args) {
-  var _a;
+  var _a, _b;
   const { next, app, microfrontend } = args;
   if (microfrontend instanceof MicrofrontendChildConfig) {
     console.warn(
@@ -1910,11 +1952,14 @@ function transform5(args) {
       ...existingServerActionConfig,
       allowedOrigins: Array.from(
         /* @__PURE__ */ new Set([
+          // existing
           ...(existingServerActionConfig == null ? void 0 : existingServerActionConfig.allowedOrigins) ?? [],
+          // this deployments host
+          ...process.env.VERCEL_URL ? [formatDomainForServerAction(process.env.VERCEL_URL)] : [],
+          // default application host
+          formatDomainForServerAction(defaultApplication.production.toString()),
+          // environment specific microfrontend hosts
           ...appsToAllow.flatMap((a) => [
-            formatDomainForServerAction(
-              defaultApplication.production.toString()
-            ),
             formatDomainForServerAction(
               getDomainForCurrentEnvironment(microfrontend, a.name)
             )
@@ -1923,6 +1968,7 @@ function transform5(args) {
       )
     }
   };
+  debugRewrites2((_b = next.experimental.serverActions) == null ? void 0 : _b.allowedOrigins);
   return {
     next
   };
@@ -2032,7 +2078,7 @@ function getApplicationContext(opts) {
     return { name: opts.appName };
   }
   try {
-    const packageJsonString = fs5.readFileSync("./package.json", "utf-8");
+    const packageJsonString = fs6.readFileSync("./package.json", "utf-8");
     const packageJson = JSON.parse(packageJsonString);
     if (!packageJson.name) {
       throw new MicrofrontendError(