@expo/cli 0.17.9 → 0.18.0

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

@@ -3,24 +3,61 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 exports.getDeepLinkHandler = getDeepLinkHandler;
-var _config = require("@expo/config");
-var runtimeEnv = _interopRequireWildcard(require("@expo/env"));
-var _chalk = _interopRequireDefault(require("chalk"));
-var _nodeFetch = _interopRequireDefault(require("node-fetch"));
-var _path = _interopRequireDefault(require("path"));
-var _bundleApiRoutes = require("./bundleApiRoutes");
+function _config() {
+    const data = require("@expo/config");
+    _config = function() {
+        return data;
+    };
+    return data;
+}
+function runtimeEnv() {
+    const data = _interopRequireWildcard(require("@expo/env"));
+    runtimeEnv = function() {
+        return data;
+    };
+    return data;
+}
+function _assert() {
+    const data = _interopRequireDefault(require("assert"));
+    _assert = function() {
+        return data;
+    };
+    return data;
+}
+function _chalk() {
+    const data = _interopRequireDefault(require("chalk"));
+    _chalk = function() {
+        return data;
+    };
+    return data;
+}
+function _nodeFetch() {
+    const data = _interopRequireDefault(require("node-fetch"));
+    _nodeFetch = function() {
+        return data;
+    };
+    return data;
+}
+function _path() {
+    const data = _interopRequireDefault(require("path"));
+    _path = function() {
+        return data;
+    };
+    return data;
+}
 var _createServerRouteMiddleware = require("./createServerRouteMiddleware");
 var _fetchRouterManifest = require("./fetchRouterManifest");
 var _instantiateMetro = require("./instantiateMetro");
+var _metroErrorInterface = require("./metroErrorInterface");
 var _metroWatchTypeScriptFiles = require("./metroWatchTypeScriptFiles");
 var _router = require("./router");
 var _serializeHtml = require("./serializeHtml");
 var _waitForMetroToObserveTypeScriptFile = require("./waitForMetroToObserveTypeScriptFile");
 var _log = require("../../../log");
 var _getDevClientProperties = _interopRequireDefault(require("../../../utils/analytics/getDevClientProperties"));
-var _rudderstackClient = require("../../../utils/analytics/rudderstackClient");
 var _errors = require("../../../utils/errors");
 var _port = require("../../../utils/port");
+var _telemetry = require("../../../utils/telemetry");
 var _bundlerDevServer = require("../BundlerDevServer");
 var _getStaticRenderFunctions = require("../getStaticRenderFunctions");
 var _contextModuleSourceMapsMiddleware = require("../middleware/ContextModuleSourceMapsMiddleware");
@@ -85,26 +122,42 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
         (options.devClient ? Number(process.env.RCT_METRO_PORT) || DEV_CLIENT_METRO_PORT : await (0, _port).getFreePortAsync(EXPO_GO_METRO_PORT));
         return port;
     }
-    async exportExpoRouterApiRoutesAsync({ mode , outputDir , prerenderManifest , baseUrl , routerRoot  }) {
-        const appDir = _path.default.join(this.projectRoot, routerRoot);
+    async exportExpoRouterApiRoutesAsync({ includeSourceMaps , outputDir , prerenderManifest  }) {
+        const { routerRoot  } = this.instanceMetroOptions;
+        _assert().default(routerRoot != null, "The server must be started before calling exportExpoRouterApiRoutesAsync.");
+        const appDir = _path().default.join(this.projectRoot, routerRoot);
         const manifest = await this.getExpoRouterRoutesManifestAsync({
             appDir
         });
         const files = new Map();
         for (const route of manifest.apiRoutes){
-            var ref;
-            const filepath = _path.default.join(appDir, route.file);
-            const contents = await (0, _bundleApiRoutes).bundleApiRoute(this.projectRoot, filepath, {
-                mode,
-                routerRoot,
-                port: (ref = this.getInstance()) == null ? void 0 : ref.location.port,
-                shouldThrow: true,
-                baseUrl
-            });
-            const artifactFilename = _path.default.join(outputDir, _path.default.relative(appDir, filepath.replace(/\.[tj]sx?$/, ".js")));
+            const filepath = _path().default.join(appDir, route.file);
+            const contents = await this.bundleApiRoute(filepath);
+            const artifactFilename = _path().default.join(outputDir, _path().default.relative(appDir, filepath.replace(/\.[tj]sx?$/, ".js")));
             if (contents) {
+                let src = contents.src;
+                if (includeSourceMaps && contents.map) {
+                    // TODO(kitten): Merge the source map transformer in the future
+                    // https://github.com/expo/expo/blob/0dffdb15/packages/%40expo/metro-config/src/serializer/serializeChunks.ts#L422-L439
+                    // Alternatively, check whether `sourcesRoot` helps here
+                    const artifactBasename = encodeURIComponent(_path().default.basename(artifactFilename) + ".map");
+                    src = src.replace(/\/\/# sourceMappingURL=.*/g, `//# sourceMappingURL=${artifactBasename}`);
+                    files.set(artifactFilename + ".map", {
+                        contents: JSON.stringify({
+                            version: contents.map.version,
+                            sources: contents.map.sources.map((source)=>{
+                                source = typeof source === "string" && source.startsWith(this.projectRoot) ? _path().default.relative(this.projectRoot, source) : source;
+                                return source.split(_path().default.sep).join("/");
+                            }),
+                            sourcesContent: new Array(contents.map.sources.length).fill(null),
+                            names: contents.map.names,
+                            mappings: contents.map.mappings
+                        }),
+                        targetDomain: "server"
+                    });
+                }
                 files.set(artifactFilename, {
-                    contents: contents.src,
+                    contents: src,
                     targetDomain: "server"
                 });
             }
@@ -130,21 +183,19 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
         }
         return manifest;
     }
-    async getStaticRenderFunctionAsync({ mode , minify =mode !== "development" , baseUrl , routerRoot  }) {
+    async getStaticRenderFunctionAsync() {
+        const { mode , minify , isExporting  } = this.instanceMetroOptions;
+        _assert().default(mode != null && minify != null && isExporting != null, "The server must be started before calling ssrLoadModule.");
         const url = this.getDevServerUrl();
-        const { getStaticContent , getManifest , getBuildTimeServerManifestAsync  } = await (0, _getStaticRenderFunctions).getStaticRenderFunctions(this.projectRoot, url, {
+        const { getStaticContent , getManifest , getBuildTimeServerManifestAsync  } = await this.ssrLoadModule("expo-router/node/render.js", {
             minify,
-            dev: mode !== "production",
-            // Ensure the API Routes are included
-            environment: "node",
-            baseUrl,
-            routerRoot
+            mode,
+            isExporting
         });
         return {
             serverManifest: await getBuildTimeServerManifestAsync(),
             // Get routes from Expo Router.
             manifest: await getManifest({
-                fetchData: true,
                 preserveApiRoutes: false
             }),
             // Get route generating function
@@ -153,17 +204,20 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
             }
         };
     }
-    async getStaticResourcesAsync({ mode , minify =mode !== "development" , includeSourceMaps , baseUrl , mainModuleName , isExporting , asyncRoutes , routerRoot  }) {
+    async getStaticResourcesAsync({ includeSourceMaps , mainModuleName  } = {}) {
         var ref;
+        const { mode , minify , isExporting , baseUrl , routerRoot , asyncRoutes  } = this.instanceMetroOptions;
+        _assert().default(mode != null && minify != null && isExporting != null && baseUrl != null && routerRoot != null && asyncRoutes != null, "The server must be started before calling getStaticPageAsync.");
+        const platform = "web";
         const devBundleUrlPathname = (0, _metroOptions).createBundleUrlPath({
-            platform: "web",
+            platform,
             mode,
             minify,
             environment: "client",
             serializerOutput: "static",
             serializerIncludeMaps: includeSourceMaps,
             mainModuleName: mainModuleName != null ? mainModuleName : (0, _manifestMiddleware).resolveMainModuleName(this.projectRoot, {
-                platform: "web"
+                platform
             }),
             lazy: (0, _metroOptions).shouldEnableAsyncImports(this.projectRoot),
             asyncRoutes,
@@ -174,7 +228,7 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
         });
         const bundleUrl = new URL(devBundleUrlPathname, this.getDevServerUrl());
         // Fetch the generated HTML from our custom Metro serializer
-        const results = await (0, _nodeFetch).default(bundleUrl.toString());
+        const results = await _nodeFetch().default(bundleUrl.toString());
         const txt = await results.text();
         let data;
         try {
@@ -214,13 +268,16 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
         }
         throw new Error("Invalid resources returned from the Metro serializer. Expected array, found: " + data);
     }
-    async getStaticPageAsync(pathname, { mode , minify =mode !== "development" , baseUrl , routerRoot , isExporting , asyncRoutes  }) {
+    async getStaticPageAsync(pathname) {
+        const { mode , minify , isExporting , baseUrl , routerRoot , asyncRoutes  } = this.instanceMetroOptions;
+        _assert().default(mode != null && minify != null && isExporting != null && baseUrl != null && routerRoot != null && asyncRoutes != null, "The server must be started before calling getStaticPageAsync.");
+        const platform = "web";
         const devBundleUrlPathname = (0, _metroOptions).createBundleUrlPath({
-            platform: "web",
+            platform,
             mode,
             environment: "client",
             mainModuleName: (0, _manifestMiddleware).resolveMainModuleName(this.projectRoot, {
-                platform: "web"
+                platform
             }),
             lazy: (0, _metroOptions).shouldEnableAsyncImports(this.projectRoot),
             baseUrl,
@@ -230,30 +287,21 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
             bytecode: false
         });
         const bundleStaticHtml = async ()=>{
-            const { getStaticContent  } = await (0, _getStaticRenderFunctions).getStaticRenderFunctions(this.projectRoot, this.getDevServerUrl(), {
+            const { getStaticContent  } = await this.ssrLoadModule("expo-router/node/render.js", {
                 minify: false,
-                dev: mode !== "production",
-                // Ensure the API Routes are included
-                environment: "node",
-                baseUrl,
-                routerRoot
+                mode,
+                isExporting,
+                platform
             });
             const location = new URL(pathname, this.getDevServerUrl());
             return await getStaticContent(location);
         };
         const [{ artifacts: resources  }, staticHtml] = await Promise.all([
-            this.getStaticResourcesAsync({
-                isExporting,
-                mode,
-                minify,
-                baseUrl,
-                asyncRoutes,
-                routerRoot
-            }),
+            this.getStaticResourcesAsync(),
             bundleStaticHtml(), 
         ]);
         const content = (0, _serializeHtml).serializeHtmlWithAssets({
-            mode,
+            isExporting,
             resources,
             template: staticHtml,
             devBundleUrl: devBundleUrlPathname,
@@ -264,6 +312,40 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
             resources
         };
     }
+    // Set when the server is started.
+    instanceMetroOptions = {};
+    async ssrLoadModule(filePath, specificOptions = {}) {
+        const { baseUrl , routerRoot , isExporting  } = this.instanceMetroOptions;
+        _assert().default(baseUrl != null && routerRoot != null && isExporting != null, "The server must be started before calling ssrLoadModule.");
+        return (await (0, _getStaticRenderFunctions).getStaticRenderFunctionsForEntry(this.projectRoot, this.getDevServerUrl(), {
+            // Bundle in Node.js mode for SSR.
+            environment: "node",
+            platform: "web",
+            mode: "development",
+            bytecode: false,
+            ...this.instanceMetroOptions,
+            baseUrl,
+            routerRoot,
+            isExporting,
+            ...specificOptions
+        }, filePath)).fn;
+    }
+    async ssrLoadModuleContents(filePath, specificOptions = {}) {
+        const { baseUrl , routerRoot , isExporting  } = this.instanceMetroOptions;
+        _assert().default(baseUrl != null && routerRoot != null && isExporting != null, "The server must be started before calling ssrLoadModule.");
+        return await (0, _getStaticRenderFunctions).requireFileContentsWithMetro(this.projectRoot, this.getDevServerUrl(), filePath, {
+            // Bundle in Node.js mode for SSR.
+            environment: "node",
+            platform: "web",
+            mode: "development",
+            bytecode: false,
+            ...this.instanceMetroOptions,
+            baseUrl,
+            routerRoot,
+            isExporting,
+            ...specificOptions
+        });
+    }
     async watchEnvironmentVariables() {
         if (!this.instance) {
             throw new Error("Cannot observe environment variable changes without a running Metro instance.");
@@ -274,7 +356,7 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
             debug("Skipping Environment Variable observation because Metro is not running (headless).");
             return;
         }
-        const envFiles = runtimeEnv.getFiles(process.env.NODE_ENV).map((fileName)=>_path.default.join(this.projectRoot, fileName)
+        const envFiles = runtimeEnv().getFiles(process.env.NODE_ENV).map((fileName)=>_path().default.join(this.projectRoot, fileName)
         );
         (0, _waitForMetroToObserveTypeScriptFile).observeFileChanges({
             metro: this.metro,
@@ -282,14 +364,42 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
         }, envFiles, ()=>{
             debug("Reloading environment variables...");
             // Force reload the environment variables.
-            runtimeEnv.load(this.projectRoot, {
+            runtimeEnv().load(this.projectRoot, {
                 force: true
             });
         });
     }
+    getExpoLineOptions() {
+        return this.instanceMetroOptions;
+    }
     async startImplementationAsync(options) {
+        var ref3;
         options.port = await this.resolvePortAsync(options);
         this.urlCreator = this.getUrlCreator(options);
+        const config = _config().getConfig(this.projectRoot, {
+            skipSDKVersionRequirement: true
+        });
+        const { exp  } = config;
+        var ref1;
+        const useServerRendering = [
+            "static",
+            "server"
+        ].includes((ref1 = (ref3 = exp.web) == null ? void 0 : ref3.output) != null ? ref1 : "");
+        const baseUrl = (0, _metroOptions).getBaseUrlFromExpoConfig(exp);
+        var _mode;
+        const asyncRoutes = (0, _metroOptions).getAsyncRoutesFromExpoConfig(exp, (_mode = options.mode) != null ? _mode : "development", "web");
+        const routerRoot = (0, _router).getRouterDirectoryModuleIdWithManifest(this.projectRoot, exp);
+        const appDir = _path().default.join(this.projectRoot, routerRoot);
+        var _mode1;
+        const mode = (_mode1 = options.mode) != null ? _mode1 : "development";
+        this.instanceMetroOptions = {
+            isExporting: !!options.isExporting,
+            baseUrl,
+            mode,
+            routerRoot,
+            minify: options.minify,
+            asyncRoutes
+        };
         const parsedOptions = {
             port: options.port,
             maxWorkers: options.maxWorkers,
@@ -335,43 +445,19 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
         middleware.use(new _createFileMiddleware.CreateFileMiddleware(this.projectRoot).getHandler());
         // Append support for redirecting unhandled requests to the index.html page on web.
         if (this.isTargetingWeb()) {
-            var ref3;
-            const config = (0, _config).getConfig(this.projectRoot, {
-                skipSDKVersionRequirement: true
-            });
-            const { exp  } = config;
-            var ref1;
-            const useServerRendering = [
-                "static",
-                "server"
-            ].includes((ref1 = (ref3 = exp.web) == null ? void 0 : ref3.output) != null ? ref1 : "");
             // 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`.
             middleware.use(new _faviconMiddleware.FaviconMiddleware(this.projectRoot).getHandler());
             if (useServerRendering) {
-                const baseUrl = (0, _metroOptions).getBaseUrlFromExpoConfig(exp);
-                var _mode1;
-                const asyncRoutes = (0, _metroOptions).getAsyncRoutesFromExpoConfig(exp, (_mode1 = options.mode) != null ? _mode1 : "development", "web");
-                const routerRoot = (0, _router).getRouterDirectoryModuleIdWithManifest(this.projectRoot, exp);
-                const appDir = _path.default.join(this.projectRoot, routerRoot);
                 middleware.use((0, _createServerRouteMiddleware).createRouteHandlerMiddleware(this.projectRoot, {
-                    ...options,
                     appDir,
-                    baseUrl,
                     routerRoot,
                     config,
-                    getWebBundleUrl: manifestMiddleware.getWebBundleUrl.bind(manifestMiddleware),
+                    bundleApiRoute: (functionFilePath)=>this.ssrImportApiRoute(functionFilePath)
+                    ,
                     getStaticPageAsync: (pathname)=>{
-                        var _mode;
-                        return this.getStaticPageAsync(pathname, {
-                            isExporting: !!options.isExporting,
-                            mode: (_mode = options.mode) != null ? _mode : "development",
-                            minify: options.minify,
-                            baseUrl,
-                            asyncRoutes,
-                            routerRoot
-                        });
+                        return this.getStaticPageAsync(pathname);
                     }
                 }));
                 (0, _waitForMetroToObserveTypeScriptFile).observeAnyFileChanges({
@@ -385,7 +471,7 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
                         // cases where the user is making subsequent requests to the same API route without changing anything.
                         // This is useful for testing but pretty suboptimal. Luckily our caching is pretty aggressive so it makes
                         // up for a lot of the overhead.
-                        (0, _bundleApiRoutes).invalidateApiRouteCache();
+                        this.invalidateApiRouteCache();
                     } else if (!(0, _router).hasWarnedAboutApiRoutes()) {
                         for (const event of events){
                             var // If the user did not delete a file that matches the Expo Router API Route convention, then we should warn that
@@ -464,7 +550,7 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
                         // Ensure the process doesn't fail if the TypeScript check fails.
                         // This could happen during the install.
                         _log.Log.log();
-                        _log.Log.error(_chalk.default.red`Failed to automatically setup TypeScript for your project. Try restarting the dev server to fix.`);
+                        _log.Log.error(_chalk().default.red`Failed to automatically setup TypeScript for your project. Try restarting the dev server to fix.`);
                         _log.Log.exception(error);
                         resolve(false);
                     }
@@ -487,13 +573,75 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
             "./rn-cli.config.js"
         ];
     }
+    pendingRouteOperations = new Map();
+    // API Routes
+    // Bundle the API Route with Metro and return the string contents to be evaluated in the server.
+    async bundleApiRoute(filePath) {
+        if (this.pendingRouteOperations.has(filePath)) {
+            return this.pendingRouteOperations.get(filePath);
+        }
+        const bundleAsync = async ()=>{
+            try {
+                debug("Bundle API route:", this.instanceMetroOptions.routerRoot, filePath);
+                return await this.ssrLoadModuleContents(filePath);
+            } catch (error) {
+                if (error instanceof Error) {
+                    await (0, _metroErrorInterface).logMetroErrorAsync({
+                        error,
+                        projectRoot: this.projectRoot
+                    });
+                }
+                throw error;
+            } finally{
+            // pendingRouteOperations.delete(filepath);
+            }
+        };
+        const route = bundleAsync();
+        this.pendingRouteOperations.set(filePath, route);
+        return route;
+    }
+    async ssrImportApiRoute(filePath) {
+        // TODO: Cache the evaluated function.
+        try {
+            const apiRoute = await this.bundleApiRoute(filePath);
+            if (!(apiRoute == null ? void 0 : apiRoute.src)) {
+                return null;
+            }
+            return (0, _getStaticRenderFunctions).evalMetroNoHandling(this.projectRoot, apiRoute.src, apiRoute.filename);
+        } catch (error) {
+            // Format any errors that were thrown in the global scope of the evaluation.
+            if (error instanceof Error) {
+                try {
+                    const htmlServerError = await (0, _metroErrorInterface).getErrorOverlayHtmlAsync({
+                        error,
+                        projectRoot: this.projectRoot,
+                        routerRoot: this.getExpoLineOptions().routerRoot
+                    });
+                    return new Response(htmlServerError, {
+                        status: 500,
+                        headers: {
+                            "Content-Type": "text/html"
+                        }
+                    });
+                } catch (internalError) {
+                    debug("Failed to generate Metro server error UI for API Route error:", internalError);
+                    throw error;
+                }
+            } else {
+                throw error;
+            }
+        }
+    }
+    invalidateApiRouteCache() {
+        this.pendingRouteOperations.clear();
+    }
 }
 exports.MetroBundlerDevServer = MetroBundlerDevServer;
 function getDeepLinkHandler(projectRoot) {
     return async ({ runtime  })=>{
         if (runtime === "expo") return;
-        const { exp  } = (0, _config).getConfig(projectRoot);
-        await (0, _rudderstackClient).logEventAsync("dev client start command", {
+        const { exp  } = _config().getConfig(projectRoot);
+        await (0, _telemetry).logEventAsync("dev client start command", {
             status: "started",
             ...(0, _getDevClientProperties).default(projectRoot, exp)
         });