redirect to init apphosting for webframeworks on init hosting

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

@@ -5,6 +5,7 @@ import * as config from "../../../config";
 import * as getDefaultHostingSiteMod from "../../../getDefaultHostingSite";
 import * as hostingInteractive from "../../../hosting/interactive";
 import * as hostingApi from "../../../hosting/api";
+import * as frameworks from "../../../frameworks";
 import { Client } from "../../../apiv2";
 import { askQuestions, actuate } from "./index";
 import { Setup } from "../..";
@@ -31,6 +32,7 @@ describe("hosting feature init", () => {
       };
       const cfg = new config.Config({}, { projectDir: "/", cwd: "/" });
 
+      sandbox.stub(frameworks, "discover").resolves(undefined);
       // Mock existing site check
       sandbox.stub(getDefaultHostingSiteMod, "getDefaultHostingSite").resolves("test-site");
 
@@ -72,6 +74,7 @@ describe("hosting feature init", () => {
       };
       const cfg = new config.Config({}, { projectDir: "/", cwd: "/" });
 
+      sandbox.stub(frameworks, "discover").resolves(undefined);
       sandbox
         .stub(getDefaultHostingSiteMod, "getDefaultHostingSite")
         .rejects(getDefaultHostingSiteMod.errNoDefaultSite);
@@ -93,9 +96,175 @@ describe("hosting feature init", () => {
       expect(pickSiteStub.called).to.be.true;
       expect(setup.featureInfo?.hosting?.newSiteId).to.equal("new-site-id");
     });
+
+    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 });
+      const confirmStub = sandbox.stub(prompt, "confirm");
+      const inputStub = sandbox.stub(prompt, "input");
+      sandbox.stub(github, "initGitHub").resolves();
+
+      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 () => {
+      const setup: Setup = {
+        config: {},
+        rcfile: { projects: {}, targets: {}, etags: {} },
+        projectId: "test-project",
+        instructions: [],
+      };
+      const cfg = new config.Config({}, { projectDir: "/", cwd: "/" });
+
+      sandbox.stub(frameworks, "discover").resolves(undefined);
+      sandbox.stub(getDefaultHostingSiteMod, "getDefaultHostingSite").resolves("test-site");
+
+      sandbox.stub(prompt, "confirm").resolves(false);
+      const inputStub = sandbox.stub(prompt, "input").resolves("public");
+      sandbox.stub(github, "initGitHub").resolves();
+
+      await askQuestions(setup, cfg, {
+        cwd: "/",
+        configPath: "",
+        only: "",
+        except: "",
+        nonInteractive: false,
+      } as any);
+
+      expect(
+        inputStub.calledWith(
+          sinon.match({ message: "What do you want to use as your public directory?" }),
+        ),
+      ).to.be.true;
+    });
+
+    it("should not terminate for static frameworks like Flutter", async () => {
+      const setup: Setup = {
+        config: {},
+        rcfile: { projects: {}, targets: {}, etags: {} },
+        projectId: "test-project",
+        instructions: [],
+      };
+      const cfg = new config.Config({}, { projectDir: "/", cwd: "/" });
+
+      sandbox
+        .stub(frameworks, "discover")
+        .resolves({ framework: "flutter", mayWantBackend: false });
+      sandbox.stub(getDefaultHostingSiteMod, "getDefaultHostingSite").resolves("test-site");
+
+      sandbox.stub(prompt, "confirm").resolves(false);
+      const inputStub = sandbox.stub(prompt, "input").resolves("public");
+      sandbox.stub(github, "initGitHub").resolves();
+
+      await askQuestions(setup, cfg, {
+        cwd: "/",
+        configPath: "",
+        only: "",
+        except: "",
+        nonInteractive: false,
+      } as any);
+
+      expect(
+        inputStub.calledWith(
+          sinon.match({ message: "What do you want to use as your public directory?" }),
+        ),
+      ).to.be.true;
+    });
+
+    it("should not terminate when a framework without backend is detected", async () => {
+      const setup: Setup = {
+        config: {},
+        rcfile: { projects: {}, targets: {}, etags: {} },
+        projectId: "test-project",
+        instructions: [],
+      };
+      const cfg = new config.Config({}, { projectDir: "/", cwd: "/" });
+
+      sandbox.stub(frameworks, "discover").resolves({ framework: "nextjs", mayWantBackend: false });
+      sandbox.stub(getDefaultHostingSiteMod, "getDefaultHostingSite").resolves("test-site");
+
+      sandbox.stub(prompt, "confirm").resolves(false);
+      const inputStub = sandbox.stub(prompt, "input").resolves("public");
+      sandbox.stub(github, "initGitHub").resolves();
+
+      await askQuestions(setup, cfg, {
+        cwd: "/",
+        configPath: "",
+        only: "",
+        except: "",
+        nonInteractive: false,
+      } as any);
+
+      expect(
+        inputStub.calledWith(
+          sinon.match({ message: "What do you want to use as your public directory?" }),
+        ),
+      ).to.be.true;
+    });
   });
 
   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,6 +1,7 @@
 import * as clc from "colorette";
 import { join } from "path";
 import { Client } from "../../../apiv2";
+import { discover } from "../../../frameworks";
 import * as github from "./github";
 import { confirm, input } from "../../../prompt";
 import { logger } from "../../../logger";
@@ -19,6 +20,7 @@ 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;
@@ -27,6 +29,19 @@ 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> {
+  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 = {};
 
@@ -93,6 +108,10 @@ export async function actuate(setup: Setup, config: Config, options: Options): P
     );
   }
 
+  if (hostingInfo.redirectToAppHosting) {
+    return;
+  }
+
   if (hostingInfo.newSiteId && setup.projectId) {
     await createSite(setup.projectId, hostingInfo.newSiteId);
     logger.info();