redirect to apphosting

Author: leoortizz

src/init/features/hosting/index.spec.ts

@@ -97,31 +97,33 @@ describe("hosting feature init", () => {
       expect(setup.featureInfo?.hosting?.newSiteId).to.equal("new-site-id");
     });
 
-    it("should recommend App Hosting and throw when a Node.js framework is detected", async () => {
+    it("should redirect to apphosting init when a Node.js framework is detected", async () => {
       const setup: Setup = {
         config: {},
         rcfile: { projects: {}, targets: {}, etags: {} },
         projectId: "test-project",
+        features: [],
         instructions: [],
       };
       const cfg = new config.Config({}, { projectDir: "/", cwd: "/" });
 
       sandbox.stub(frameworks, "discover").resolves({ framework: "next", mayWantBackend: true });
-      sandbox.stub(getDefaultHostingSiteMod, "getDefaultHostingSite").resolves("test-site");
-
-      sandbox.stub(prompt, "confirm").resolves(false);
-      sandbox.stub(prompt, "input").resolves("public");
+      const confirmStub = sandbox.stub(prompt, "confirm");
+      const inputStub = sandbox.stub(prompt, "input");
       sandbox.stub(github, "initGitHub").resolves();
 
-      await expect(
-        askQuestions(setup, cfg, {
-          cwd: "/",
-          configPath: "",
-          only: "",
-          except: "",
-          nonInteractive: false,
-        } as any),
-      ).to.be.rejectedWith(/firebase init apphosting/);
+      await askQuestions(setup, cfg, {
+        cwd: "/",
+        configPath: "",
+        only: "",
+        except: "",
+        nonInteractive: false,
+      } as any);
+
+      expect(setup.features).to.deep.equal(["apphosting"]);
+      expect(setup.featureInfo?.hosting).to.deep.equal({ redirectToAppHosting: true });
+      expect(confirmStub.called).to.be.false;
+      expect(inputStub.called).to.be.false;
     });
 
     it("should not terminate when no framework is detected", async () => {
@@ -221,6 +223,48 @@ describe("hosting feature init", () => {
   });
 
   describe("actuate", () => {
+    it("should throw when hosting info is missing", async () => {
+      const setup: Setup = {
+        config: {},
+        rcfile: { projects: {}, targets: {}, etags: {} },
+        projectId: "test-project",
+        instructions: [],
+      };
+      const cfg = new config.Config({}, { projectDir: "/", cwd: "/" });
+
+      await expect(
+        actuate(setup, cfg, {
+          cwd: "/",
+          configPath: "",
+          only: "",
+          except: "",
+          nonInteractive: false,
+        } as any),
+      ).to.be.rejectedWith(/Could not find hosting info/);
+    });
+
+    it("should be a no-op when hosting was redirected to apphosting", async () => {
+      const setup: Setup = {
+        config: {},
+        rcfile: { projects: {}, targets: {}, etags: {} },
+        projectId: "test-project",
+        featureInfo: { hosting: { redirectToAppHosting: true } },
+        instructions: [],
+      };
+      const cfg = new config.Config({}, { projectDir: "/", cwd: "/" });
+      const askWriteStub = sandbox.stub(cfg, "askWriteProjectFile").resolves();
+
+      await actuate(setup, cfg, {
+        cwd: "/",
+        configPath: "",
+        only: "",
+        except: "",
+        nonInteractive: false,
+      } as any);
+
+      expect(askWriteStub.called).to.be.false;
+    });
+
     it("should write 404.html and index.html for non-SPA", async () => {
       const setup: Setup = {
         config: {},

src/init/features/hosting/index.ts

@@ -1,7 +1,7 @@
 import * as clc from "colorette";
 import { join } from "path";
 import { Client } from "../../../apiv2";
-import { discover, WebFrameworks } from "../../../frameworks";
+import { discover } from "../../../frameworks";
 import * as github from "./github";
 import { confirm, input } from "../../../prompt";
 import { logger } from "../../../logger";
@@ -10,16 +10,17 @@ import { Options } from "../../../options";
 import { logSuccess } from "../../../utils";
 import { pickHostingSiteName } from "../../../hosting/interactive";
 import { readTemplateSync } from "../../../templates";
-import { FirebaseError } from "../../../error";
 import { Setup } from "../..";
 import { Config } from "../../../config";
 import { createSite } from "../../../hosting/api";
+import { FirebaseError } from "../../../error";
 
 const INDEX_TEMPLATE = readTemplateSync("init/hosting/index.html");
 const MISSING_TEMPLATE = readTemplateSync("init/hosting/404.html");
 const DEFAULT_IGNORES = ["firebase.json", "**/.*", "**/node_modules/**"];
 
 export interface RequiredInfo {
+  redirectToAppHosting?: boolean;
   newSiteId?: string;
   public?: string;
   spa?: boolean;
@@ -28,12 +29,23 @@ export interface RequiredInfo {
 // TODO: come up with a better way to type this
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export async function askQuestions(setup: Setup, config: Config, options: Options): Promise<void> {
+  // Detect frameworks first, before asking any hosting questions
+  const discoveredFramework = await discover(config.projectDir, false);
+  if (discoveredFramework && discoveredFramework.mayWantBackend) {
+    const frameworkName = discoveredFramework.framework;
+    logger.info();
+    logger.info(
+      `Detected a ${frameworkName} codebase. Setting up ${clc.bold("App Hosting")} instead.`,
+    );
+    setup.featureInfo ||= {};
+    setup.featureInfo.hosting = { redirectToAppHosting: true };
+    setup.features?.unshift("apphosting");
+    return;
+  }
+
   setup.featureInfo = setup.featureInfo || {};
   setup.featureInfo.hosting = {};
 
-  // Fire off framework detection concurrently so it runs while the site check happens
-  const discoverPromise = discover(config.projectDir, false);
-
   // There's a path where we can set up Hosting without a project, so if
   // if setup.projectId is empty, we don't do any checking for a Hosting site.
   if (setup.projectId) {
@@ -62,15 +74,6 @@ export async function askQuestions(setup: Setup, config: Config, options: Option
     }
   }
 
-  const discoveredFramework = await discoverPromise;
-  if (discoveredFramework && discoveredFramework.mayWantBackend) {
-    const frameworkName =
-      WebFrameworks[discoveredFramework.framework]?.name ?? discoveredFramework.framework;
-    throw new FirebaseError(
-      `Detected a ${frameworkName} codebase. Use ${clc.bold("firebase init apphosting")} instead.`,
-    );
-  }
-
   logger.info();
   logger.info(
     `Your ${clc.bold("public")} directory is the folder (relative to your project directory) that`,
@@ -106,6 +109,11 @@ export async function actuate(setup: Setup, config: Config, options: Options): P
     );
   }
 
+  // if the user was redirected to App Hosting, we don't need to do anything here
+  if (hostingInfo.redirectToAppHosting) {
+    return;
+  }
+
   if (hostingInfo.newSiteId && setup.projectId) {
     await createSite(setup.projectId, hostingInfo.newSiteId);
     logger.info();