@expo/cli 54.1.0-canary-20251023-4c86f95 → 54.1.0-canary-20260119-17896bf

package/build/src/start/server/metro/MetroBundlerDevServer.js

@@ -83,13 +83,6 @@ function _path() {
     };
     return data;
 }
-function _resolvefrom() {
-    const data = /*#__PURE__*/ _interop_require_default(require("resolve-from"));
-    _resolvefrom = function() {
-        return data;
-    };
-    return data;
-}
 const _createServerComponentsMiddleware = require("./createServerComponentsMiddleware");
 const _createServerRouteMiddleware = require("./createServerRouteMiddleware");
 const _fetchRouterManifest = require("./fetchRouterManifest");
@@ -108,7 +101,6 @@ const _BundlerDevServer = require("../BundlerDevServer");
 const _getStaticRenderFunctions = require("../getStaticRenderFunctions");
 const _ContextModuleSourceMapsMiddleware = require("../middleware/ContextModuleSourceMapsMiddleware");
 const _CreateFileMiddleware = require("../middleware/CreateFileMiddleware");
-const _DataLoaderModuleMiddleware = require("../middleware/DataLoaderModuleMiddleware");
 const _DevToolsPluginMiddleware = require("../middleware/DevToolsPluginMiddleware");
 const _DomComponentsMiddleware = require("../middleware/DomComponentsMiddleware");
 const _FaviconMiddleware = require("../middleware/FaviconMiddleware");
@@ -246,7 +238,10 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
             debug('Adding RSC route to the manifest:', rscPath);
             // NOTE: This might need to be sorted to the correct spot in the future.
             manifest.apiRoutes.push({
-                file: (0, _resolvefrom().default)(this.projectRoot, '@expo/cli/static/template/[...rsc]+api.ts'),
+                // TODO(@kitten): This isn't great, we shouldn't be needing to rely on files like this
+                // It might even be better to make templating strings since that'd be type-checked, but currently,
+                // we rely on this being an entrypoint for Metro
+                file: require.resolve('@expo/cli/static/template/[...rsc]+api.ts'),
                 page: rscPath,
                 namedRegex: '^/_flight(?:/(?<rsc>.+?))?(?:/)?$',
                 routeKeys: {
@@ -307,7 +302,7 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
         var _exp_extra, _exp_extra1;
         const { exp } = (0, _config().getConfig)(this.projectRoot);
         // NOTE: This could probably be folded back into `renderStaticContent` when expo-asset and font support RSC.
-        const { getBuildTimeServerManifestAsync, getManifest } = await this.ssrLoadModule('@expo/router-server/build/static/getServerManifest.js', {
+        const { getBuildTimeServerManifestAsync, getManifest } = await this.ssrLoadModule('expo-router/build/static/getServerManifest.js', {
             // Only use react-server environment when the routes are using react-server rendering by default.
             environment: this.isReactServerRoutesEnabled ? 'react-server' : 'node'
         });
@@ -320,22 +315,19 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
             })
         };
     }
-    /**
-   * This function is invoked when exporting via `expo export`
-   */ async getStaticRenderFunctionAsync() {
+    async getStaticRenderFunctionAsync() {
         var _exp_extra, _exp_extra1;
         const url = this.getDevServerUrlOrAssert();
-        const { getStaticContent, getManifest, getBuildTimeServerManifestAsync } = await this.ssrLoadModule('@expo/router-server/node/render.js', {
+        const { getStaticContent, getManifest, getBuildTimeServerManifestAsync } = await this.ssrLoadModule('expo-router/node/render.js', {
             // This must always use the legacy rendering resolution (no `react-server`) because it leverages
             // the previous React SSG utilities which aren't available in React 19.
             environment: 'node'
         });
         const { exp } = (0, _config().getConfig)(this.projectRoot);
-        const serverManifest = await getBuildTimeServerManifestAsync({
-            ...(_exp_extra = exp.extra) == null ? void 0 : _exp_extra.router
-        });
         return {
-            serverManifest,
+            serverManifest: await getBuildTimeServerManifestAsync({
+                ...(_exp_extra = exp.extra) == null ? void 0 : _exp_extra.router
+            }),
             // Get routes from Expo Router.
             manifest: await getManifest({
                 preserveApiRoutes: false,
@@ -371,10 +363,7 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
             bytecode: false
         });
     }
-    /**
-   * This function is invoked when running in development via `expo start`
-   */ async getStaticPageAsync(pathname, route) {
-        const { exp } = (0, _config().getConfig)(this.projectRoot);
+    async getStaticPageAsync(pathname) {
         const { mode, isExporting, clientBoundaries, baseUrl, reactCompiler, routerRoot, asyncRoutes } = this.instanceMetroOptions;
         (0, _assert().default)(mode != null && isExporting != null && baseUrl != null && reactCompiler != null && routerRoot != null && asyncRoutes != null, 'The server must be started before calling getStaticPageAsync.');
         const platform = 'web';
@@ -396,8 +385,7 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
             bytecode: false
         });
         const bundleStaticHtml = async ()=>{
-            var _exp_extra_router, _exp_extra;
-            const { getStaticContent } = await this.ssrLoadModule('@expo/router-server/node/render.js', {
+            const { getStaticContent } = await this.ssrLoadModule('expo-router/node/render.js', {
                 // This must always use the legacy rendering resolution (no `react-server`) because it leverages
                 // the previous React SSG utilities which aren't available in React 19.
                 environment: 'node',
@@ -406,17 +394,7 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
                 platform
             });
             const location = new URL(pathname, this.getDevServerUrlOrAssert());
-            const useServerDataLoaders = (_exp_extra = exp.extra) == null ? void 0 : (_exp_extra_router = _exp_extra.router) == null ? void 0 : _exp_extra_router.unstable_useServerDataLoaders;
-            if (useServerDataLoaders) {
-                const data = await this.executeServerDataLoaderAsync(location, route);
-                return await getStaticContent(location, {
-                    loader: {
-                        data
-                    }
-                });
-            } else {
-                return await getStaticContent(location);
-            }
+            return await getStaticContent(location);
         };
         const [{ artifacts: resources }, staticHtml] = await Promise.all([
             this.getStaticResourcesAsync({
@@ -820,34 +798,13 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
             // Add support for DOM components.
             // TODO: Maybe put behind a flag for now?
             middleware.use(domComponentRenderer);
-            // TODO: Disable both of these when tunneling to prevent security issues
-            middleware.use(new _CreateFileMiddleware.CreateFileMiddleware(this.projectRoot).getHandler());
-            // For providing info to the error overlay.
-            middleware.use((req, res, next)=>{
-                var _req_url;
-                // Use by `@expo/log-box` https://github.com/expo/expo/blob/f29b9f3715e42dca87bf3eebf11f7e7dd1ff73c1/packages/%40expo/log-box/src/utils/devServerEndpoints.ts#L82
-                if ((_req_url = req.url) == null ? void 0 : _req_url.startsWith('/_expo/error-overlay-meta')) {
-                    res.statusCode = 200;
-                    res.setHeader('Content-Type', 'application/json');
-                    res.end(JSON.stringify({
-                        projectRoot: this.projectRoot,
-                        serverRoot,
-                        sdkVersion: exp.sdkVersion
-                    }));
-                    return;
-                }
-                return next();
-            });
+            middleware.use(new _CreateFileMiddleware.CreateFileMiddleware({
+                metroRoot: serverRoot,
+                projectRoot: this.projectRoot,
+                appDir
+            }).getHandler());
             // Append support for redirecting unhandled requests to the index.html page on web.
             if (this.isTargetingWeb()) {
-                var _exp_extra_router1, _exp_extra2;
-                if ((_exp_extra2 = exp.extra) == null ? void 0 : (_exp_extra_router1 = _exp_extra2.router) == null ? void 0 : _exp_extra_router1.unstable_useServerDataLoaders) {
-                    const loaderModuleMiddleware = new _DataLoaderModuleMiddleware.DataLoaderModuleMiddleware(this.projectRoot, appDir, async (location, route)=>{
-                        return this.executeServerDataLoaderAsync(location, route);
-                    }, ()=>this.getDevServerUrlOrAssert());
-                    // This MUST be before ServeStaticMiddleware so it doesn't treat the loader files as static assets
-                    middleware.use(loaderModuleMiddleware.getHandler());
-                }
                 // This MUST be after the manifest middleware so it doesn't have a chance to serve the template `public/index.html`.
                 middleware.use(new _ServeStaticMiddleware.ServeStaticMiddleware(this.projectRoot).getHandler());
                 // This should come after the static middleware so it doesn't serve the favicon from `public/favicon.ico`.
@@ -858,7 +815,6 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
                     metro,
                     server
                 }, (events)=>{
-                    var _exp_extra_router, _exp_extra;
                     if (hasApiRoutes) {
                         // NOTE(EvanBacon): We aren't sure what files the API routes are using so we'll just invalidate
                         // aggressively to ensure we always have the latest. The only caching we really get here is for
@@ -877,15 +833,6 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
                             }
                         }
                     }
-                    // Handle loader file changes for HMR
-                    if ((_exp_extra = exp.extra) == null ? void 0 : (_exp_extra_router = _exp_extra.router) == null ? void 0 : _exp_extra_router.unstable_useServerDataLoaders) {
-                        for (const event of events){
-                            var _event_metadata1;
-                            if (((_event_metadata1 = event.metadata) == null ? void 0 : _event_metadata1.type) !== 'd') {
-                                this.handleLoaderFileChange(event.filePath);
-                            }
-                        }
-                    }
                 });
             }
             // If React 19 is enabled, then add RSC middleware to the dev server.
@@ -919,7 +866,7 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
                         bundleApiRoute: (functionFilePath)=>this.ssrImportApiRoute(functionFilePath, {
                                 platform: 'web'
                             }),
-                        getStaticPageAsync: async (pathname, route)=>{
+                        getStaticPageAsync: async (pathname)=>{
                             // TODO: Add server rendering when RSC is enabled.
                             if (isReactServerComponentsEnabled) {
                                 // NOTE: This is a temporary hack to return the SPA/template index.html in development when RSC is enabled.
@@ -930,7 +877,7 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
                                 };
                             }
                             // Non-RSC apps will bundle the static HTML for a given pathname and respond with it.
-                            return this.getStaticPageAsync(pathname, route);
+                            return this.getStaticPageAsync(pathname);
                         }
                     }));
                 }
@@ -1164,62 +1111,6 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
     invalidateApiRouteCache() {
         this.pendingRouteOperations.clear();
     }
-    /**
-   * Execute a route's loader function. Used during SSR/SSG to fetch data required by routes.
-   *
-   * This function is used during development and production builds, and **must** receive a valid
-   * matched route.
-   *
-   * @experimental
-   */ async executeServerDataLoaderAsync(location, route) {
-        var _exp_extra;
-        const { exp } = (0, _config().getConfig)(this.projectRoot);
-        const { unstable_useServerDataLoaders } = (_exp_extra = exp.extra) == null ? void 0 : _exp_extra.router;
-        if (!unstable_useServerDataLoaders) {
-            throw new _errors.CommandError('LOADERS_NOT_ENABLED', 'Server data loaders are not enabled. Add `unstable_useServerDataLoaders` to your `expo-router` plugin config.');
-        }
-        // If the route is unmatched, we can ignore it
-        // TODO(@hassankhan): Is this the best way of determining the route is unmatched?
-        if (route.page === '/+not-found') {
-            return;
-        }
-        const { routerRoot } = this.instanceMetroOptions;
-        (0, _assert().default)(routerRoot != null, 'The server must be started before calling executeRouteLoaderAsync.');
-        let loaderData;
-        try {
-            debug('Matched route loader to file: ', route.file);
-            // TODO(@hassankhan): This should move to a util function
-            const params = {};
-            const match = route.namedRegex.exec(location.pathname);
-            if (match == null ? void 0 : match.groups) {
-                for (const [key, value] of Object.entries(match.groups)){
-                    const namedKey = route.routeKeys[key];
-                    params[namedKey] = value;
-                }
-            }
-            let modulePath = route.file;
-            const appDir = _path().default.join(this.projectRoot, routerRoot);
-            modulePath = _path().default.isAbsolute(modulePath) ? modulePath : _path().default.join(appDir, modulePath);
-            modulePath = modulePath.replace(/\.(js|ts)x?$/, '');
-            debug('Using loader module path: ', modulePath);
-            const routeModule = await this.ssrLoadModule(modulePath, {
-                environment: 'node'
-            });
-            if (routeModule.loader) {
-                // Register this module for loader HMR
-                this.setupLoaderHmr(modulePath);
-                loaderData = await routeModule.loader({
-                    params,
-                    // NOTE(@hassankhan): The `request` object should only be available when using SSR
-                    request: null
-                });
-            }
-        } catch (error) {
-            throw new _errors.CommandError('LOADER_EXECUTION_FAILED', `Failed to execute loader for route "${location.pathname}": ${error.message}`);
-        }
-        debug('Loader data:', loaderData, ' for location:', location.pathname);
-        return loaderData;
-    }
     // Ensure the global is available for SSR CSS modules to inject client updates.
     bindRSCDevModuleInjectionHandler() {
         // Used by SSR CSS modules to broadcast client updates.
@@ -1258,30 +1149,6 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
         };
         this.registerSsrHmrAsync(url.toString(), onReload);
     }
-    setupLoaderHmr(modulePath) {
-        if (this.watchedLoaderFiles.has(modulePath)) {
-            return;
-        }
-        this.watchedLoaderFiles.add(modulePath);
-        debug('[Loader HMR] Registering loader file for HMR:', modulePath);
-    }
-    handleLoaderFileChange(changedFilePath) {
-        for (const loaderPath of this.watchedLoaderFiles){
-            const possibleExtensions = [
-                '.tsx',
-                '.ts',
-                '.jsx',
-                '.js'
-            ];
-            const isLoaderFile = possibleExtensions.some((ext)=>changedFilePath === loaderPath + ext || changedFilePath === loaderPath);
-            if (isLoaderFile) {
-                debug('[Loader HMR] Loader file changed, triggering reload:', changedFilePath);
-                this.broadcastMessage('sendDevCommand', {
-                    name: 'reload'
-                });
-            }
-        }
-    }
     // Direct Metro access
     // Emulates the Metro dev server .bundle endpoint without having to go through a server.
     async _bundleDirectAsync(resolvedEntryFilePath, { transformOptions, resolverOptions, graphOptions, serializerOptions }) {
@@ -1492,7 +1359,14 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
     constructor(...args){
         super(...args), this.metro = null, this.hmrServer = null, this.ssrHmrClients = new Map(), // Set when the server is started.
         this.instanceMetroOptions = {}, this.ssrLoadModule = async (filePath, specificOptions = {}, extras = {})=>{
-            const res = await this.ssrLoadModuleContents(filePath, specificOptions);
+            // NOTE(@kitten): We don't properly initialize the server-side modules
+            // Instead, we first load an entrypoint with an empty bundle to initialize the runtime instead
+            // See: ./createServerComponentsMiddleware.ts
+            const getEmptyModulePath = ()=>{
+                (0, _assert().default)(this.metro, 'Metro server must be running to load SSR modules.');
+                return this.metro._config.resolver.emptyModulePath;
+            };
+            const res = await this.ssrLoadModuleContents(filePath ?? getEmptyModulePath(), specificOptions);
             if (// TODO: hot should be a callback function for invalidating the related SSR module.
             extras.hot && this.instanceMetroOptions.isExporting !== true) {
                 // Register SSR HMR
@@ -1503,7 +1377,7 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
             }
             return (0, _getStaticRenderFunctions.evalMetroAndWrapFunctions)(this.projectRoot, res.src, res.filename, specificOptions.isExporting ?? this.instanceMetroOptions.isExporting);
         }, this.rscRenderer = null, this.onReloadRscEvent = null, // API Routes
-        this.pendingRouteOperations = new Map(), this.watchedLoaderFiles = new Set();
+        this.pendingRouteOperations = new Map();
     }
 }
 function getBuildID(buildNumber) {