Merge branch 'main' into codex/fix-modernjs-splitchunks-warning

Author: 2heal1

.changeset/node-esm-builtin-loader.md

@@ -0,0 +1,5 @@
+---
+"@module-federation/sdk": patch
+---
+
+Handle Node.js built-in imports in the Node ESM remote loader.

apps/router-demo/router-host-2000/cypress/e2e/memory-router.cy.ts

@@ -15,8 +15,6 @@ describe('router-host-2000/memory-router', () => {
   });
 
   describe('memory-router', () => {
-    Cypress.on('uncaught:exception', () => false);
-
     it('remote1', () => {
       cy.verifyContent('Remote1 home page');
       cy.clickByClass('.self-remote1-detail-link');

packages/sdk/__tests__/node-builtin-esm.spec.ts

@@ -0,0 +1,209 @@
+import { jest } from '@jest/globals';
+import { sep as pathSeparator } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const DEFAULT_REMOTE_ENTRY_URL = 'http://example.com/remoteEntry.js';
+
+const createResponse = (body: string) => ({
+  text: async () => body,
+});
+
+const moduleSource = (source: TemplateStringsArray, ...values: string[]) =>
+  String.raw(source, ...values).trim();
+
+const setFetchMock = (
+  handler: (url: string) => ReturnType<typeof createResponse>,
+) => {
+  const fetchMock = jest.fn(async (url: string) => handler(url));
+  globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+  return fetchMock;
+};
+
+const setRemoteEntryFetchMock = (remoteEntryUrl: string, body: string) =>
+  setFetchMock((url) => {
+    if (url !== remoteEntryUrl) {
+      throw new Error(`${url} should not be fetched`);
+    }
+
+    return createResponse(body);
+  });
+
+const loadNodeEsmScript = async <T = unknown>(
+  url = DEFAULT_REMOTE_ENTRY_URL,
+): Promise<T> => {
+  const { createScriptNode } = await import('../src/node');
+
+  return new Promise<T>((resolve, reject) => {
+    createScriptNode(
+      url,
+      (error, scriptContext) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+
+        resolve(scriptContext as T);
+      },
+      { type: 'module' },
+    );
+  });
+};
+
+describe('Node ESM builtin loading', () => {
+  const originalFetch = globalThis.fetch;
+
+  beforeEach(() => {
+    jest.resetModules();
+    jest.clearAllMocks();
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  it('loads node: builtin imports without fetching them as remote chunks', async () => {
+    const fetchMock = setRemoteEntryFetchMock(
+      DEFAULT_REMOTE_ENTRY_URL,
+      moduleSource`
+        import { pathToFileURL } from 'node:url';
+
+        export const marker = pathToFileURL('/tmp/module-federation').href;
+        export default {};
+      `,
+    );
+
+    const scriptContext = await loadNodeEsmScript<{
+      marker: string;
+    }>();
+
+    expect(scriptContext.marker).toBe('file:///tmp/module-federation');
+    expect(fetchMock).toHaveBeenCalledWith(DEFAULT_REMOTE_ENTRY_URL);
+    expect(fetchMock).not.toHaveBeenCalledWith('node:url');
+  });
+
+  it('loads bare Node.js builtin imports without fetching them as remote chunks', async () => {
+    const fetchMock = setRemoteEntryFetchMock(
+      DEFAULT_REMOTE_ENTRY_URL,
+      moduleSource`
+        import { sep } from 'path';
+
+        export const separator = sep;
+        export default {};
+      `,
+    );
+
+    const scriptContext = await loadNodeEsmScript<{
+      separator: string;
+    }>();
+
+    expect(scriptContext.separator).toBe(pathSeparator);
+    expect(fetchMock).toHaveBeenCalledWith(DEFAULT_REMOTE_ENTRY_URL);
+    expect(fetchMock).not.toHaveBeenCalledWith('path');
+  });
+
+  it('bases import.meta.url under the current workspace for createRequire package resolution', async () => {
+    const remoteEntryUrl =
+      'http://example.com/server/remoteEntry.js?v=123#entry';
+    const fetchMock = setRemoteEntryFetchMock(
+      remoteEntryUrl,
+      moduleSource`
+        import { createRequire } from 'node:module';
+
+        const require = createRequire(import.meta.url);
+        const webpack = require('webpack');
+
+        export const webpackType = typeof webpack;
+        export const metaUrl = import.meta.url;
+        export default {};
+      `,
+    );
+
+    const scriptContext = await loadNodeEsmScript<{
+      metaUrl: string;
+      webpackType: string;
+    }>(remoteEntryUrl);
+    const cwdFileUrl = pathToFileURL(process.cwd()).href;
+    const cwdBaseUrl = cwdFileUrl.endsWith('/') ? cwdFileUrl : `${cwdFileUrl}/`;
+
+    expect(['function', 'object']).toContain(scriptContext.webpackType);
+    expect(scriptContext.metaUrl).toContain(
+      '__module_federation_remote__/http/example.com/server/remoteEntry.js/%3Fv%3D123%23entry',
+    );
+    expect(scriptContext.metaUrl.startsWith(cwdBaseUrl)).toBe(true);
+    expect(fetchMock).toHaveBeenCalledWith(remoteEntryUrl);
+  });
+
+  it('evaluates dynamically imported ESM chunks before their namespace is consumed', async () => {
+    const remoteEntryUrl = 'http://example.com/server/remoteEntry.js';
+    const chunkUrl = 'http://example.com/server/chunk.mjs';
+    const fetchMock = setFetchMock((url) => {
+      if (url === remoteEntryUrl) {
+        return createResponse(
+          moduleSource`
+            export const chunkValuePromise = import('./chunk.mjs').then(
+              (chunk) => chunk.value,
+            );
+            export default {};
+          `,
+        );
+      }
+
+      if (url === chunkUrl) {
+        return createResponse(
+          moduleSource`
+            export const value = 'loaded chunk';
+          `,
+        );
+      }
+
+      throw new Error(`${url} should not be fetched`);
+    });
+
+    const scriptContext = await loadNodeEsmScript<{
+      chunkValuePromise: Promise<string>;
+    }>(remoteEntryUrl);
+
+    await expect(scriptContext.chunkValuePromise).resolves.toBe('loaded chunk');
+    expect(fetchMock).toHaveBeenCalledWith(remoteEntryUrl);
+    expect(fetchMock).toHaveBeenCalledWith(chunkUrl);
+  });
+
+  it('rejects absolute non-http module URLs without fetching them', async () => {
+    const remoteEntryUrl = 'http://example.com/server/remoteEntry.js';
+    const fileChunkUrl = 'file:///tmp/chunk.mjs';
+    const fetchMock = setRemoteEntryFetchMock(
+      remoteEntryUrl,
+      moduleSource`
+        import value from '${fileChunkUrl}';
+
+        export default value;
+      `,
+    );
+
+    await expect(loadNodeEsmScript(remoteEntryUrl)).rejects.toThrow(
+      `Unsupported ESM module specifier "${fileChunkUrl}"`,
+    );
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock).toHaveBeenCalledWith(remoteEntryUrl);
+    expect(fetchMock).not.toHaveBeenCalledWith(fileChunkUrl);
+  });
+
+  it('rejects bare non-builtin imports instead of fetching them as relative chunks', async () => {
+    const remoteEntryUrl = 'http://example.com/server/remoteEntry.js';
+    const fetchMock = setRemoteEntryFetchMock(
+      remoteEntryUrl,
+      moduleSource`
+        import React from 'react';
+
+        export default React;
+      `,
+    );
+
+    await expect(loadNodeEsmScript(remoteEntryUrl)).rejects.toThrow(
+      'Unsupported ESM module specifier "react"',
+    );
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock).toHaveBeenCalledWith(remoteEntryUrl);
+  });
+});

packages/sdk/package.json

@@ -76,8 +76,8 @@
   "scripts": {
     "build": "tsdown --config tsdown.config.ts",
     "lint": "ESLINT_USE_FLAT_CONFIG=false pnpm exec eslint --ignore-pattern node_modules \"**/*.ts\" \"package.json\"",
-    "test": "pnpm exec jest --config jest.config.cjs --passWithNoTests",
-    "test:ci": "pnpm exec jest --config jest.config.cjs --passWithNoTests --ci --coverage",
+    "test": "NODE_OPTIONS=--experimental-vm-modules pnpm exec jest --config jest.config.cjs --passWithNoTests",
+    "test:ci": "NODE_OPTIONS=--experimental-vm-modules pnpm exec jest --config jest.config.cjs --passWithNoTests --ci --coverage",
     "pre-release": "pnpm run test && pnpm run build"
   }
 }