Inlined.web frameworks label

src/deploy/hosting/context.ts

@@ -1,4 +1,4 @@
-import { HostingResolved } from "../../firebaseConfig";
+import { HostingResolved } from "../../hosting/config";
 import { Context as FunctionsContext } from "../functions/args";
 
 export interface HostingDeploy {

src/deploy/hosting/prepare.ts

@@ -6,6 +6,7 @@ import { Context } from "./context";
 import { Options } from "../../options";
 import { HostingOptions } from "../../hosting/options";
 import { zipIn } from "../../functional";
+import { track } from "../../track";
 
 /**
  *  Prepare creates versions for each Hosting site to be deployed.
@@ -25,12 +26,24 @@ export async function prepare(context: Context, options: HostingOptions & Option
     return Promise.resolve();
   }
 
-  const version: Omit<api.Version, api.VERSION_OUTPUT_FIELDS> = {
-    status: "CREATED",
-    labels: deploymentTool.labels(),
-  };
   const versions = await Promise.all(
-    configs.map((config) => api.createVersion(config.site, version))
+    configs.map(async (config) => {
+      const labels: Record<string, string> = {
+        ...deploymentTool.labels(),
+      };
+      if (config.webFramework) {
+        labels["firebase-web-framework"] = config.webFramework;
+      }
+      const version: Omit<api.Version, api.VERSION_OUTPUT_FIELDS> = {
+        status: "CREATED",
+        labels,
+      };
+      const [, versionName] = await Promise.all([
+        track("hosting_deploy", config.webFramework || "classic"),
+        api.createVersion(config.site, version),
+      ]);
+      return versionName;
+    })
   );
   context.hosting = {
     deploys: [],

src/deploy/index.ts

@@ -61,11 +61,10 @@ export const deploy = async function (
 
   if (targetNames.includes("hosting")) {
     const config = options.config.get("hosting");
-    let deployedFrameworks: string[] = [];
     if (Array.isArray(config) ? config.some((it) => it.source) : config.source) {
       experiments.assertEnabled("webframeworks", "deploy a web framework to hosting");
       const usedToTargetFunctions = targetNames.includes("functions");
-      deployedFrameworks = await prepareFrameworks(targetNames, context, options);
+      await prepareFrameworks(targetNames, context, options);
       const nowTargetsFunctions = targetNames.includes("functions");
       if (nowTargetsFunctions && !usedToTargetFunctions) {
         if (context.hostingChannel && !experiments.isEnabled("pintags")) {
@@ -75,11 +74,7 @@ export const deploy = async function (
         }
         await requirePermissions(TARGET_PERMISSIONS["functions"]);
       }
-    } else {
-      const count = Array.isArray(config) ? config.length : 1;
-      deployedFrameworks = Array<string>(count).fill("classic");
     }
-    await Promise.all(deployedFrameworks.map((framework) => track("hosting_deploy", framework)));
   }
 
   for (const targetName of targetNames) {

src/firebaseConfig.ts

@@ -10,7 +10,7 @@ import { RequireAtLeastOne } from "./metaprogramming";
 // should be sourced from - https://github.com/firebase/firebase-tools/blob/master/src/deploy/functions/runtimes/index.ts#L15
 type CloudFunctionRuntimes = "nodejs10" | "nodejs12" | "nodejs14" | "nodejs16";
 
-type Deployable = {
+export type Deployable = {
   predeploy?: string | string[];
   postdeploy?: string | string[];
 };
@@ -67,7 +67,7 @@ export type HostingHeaders = HostingSource & {
   }[];
 };
 
-type HostingBase = {
+export type HostingBase = {
   public?: string;
   source?: string;
   ignore?: string[];
@@ -101,13 +101,6 @@ export type HostingMultiple = (HostingBase &
   }> &
   Deployable)[];
 
-// After validating a HostingMultiple and resolving targets, we will instead
-// have a HostingResolved.
-export type HostingResolved = HostingBase & {
-  site: string;
-  target?: string;
-} & Deployable;
-
 type StorageSingle = {
   rules: string;
   target?: string;

src/frameworks/index.ts

@@ -248,7 +248,7 @@ export async function prepareFrameworks(
   context: any,
   options: any,
   emulators: EmulatorInfo[] = []
-): Promise<string[]> {
+): Promise<void> {
   // `firebase-frameworks` requires Node >= 16. We must check for this to avoid horrible errors.
   const nodeVersion = process.version;
   if (!semver.satisfies(nodeVersion, ">=16.0.0")) {
@@ -257,7 +257,6 @@ export async function prepareFrameworks(
     );
   }
 
-  const deployedFrameworks: string[] = [];
   const project = needProjectId(context);
   const { projectRoot } = options;
   const account = getProjectDefaultAccount(projectRoot);
@@ -284,12 +283,11 @@ export async function prepareFrameworks(
   const configs = hostingConfig(options);
   let firebaseDefaults: FirebaseDefaults | undefined = undefined;
   if (configs.length === 0) {
-    return deployedFrameworks;
+    return;
   }
   for (const config of configs) {
     const { source, site, public: publicDir } = config;
     if (!source) {
-      deployedFrameworks.push("classic");
       continue;
     }
     config.rewrites ||= [];
@@ -411,7 +409,7 @@ export async function prepareFrameworks(
       config.public = relative(projectRoot, hostingDist);
       if (wantsBackend) codegenFunctionsDirectory = codegenProdModeFunctionsDirectory;
     }
-    deployedFrameworks.push(`${framework}${codegenFunctionsDirectory ? "_ssr" : ""}`);
+    config.webFramework = `${framework}${codegenFunctionsDirectory ? "_ssr" : ""}`;
     if (codegenFunctionsDirectory) {
       if (firebaseDefaults) firebaseDefaults._authTokenSyncURL = "/__session";
 
@@ -555,7 +553,6 @@ exports.ssr = onRequest((req, res) => server.then(it => it.handle(req, res)));
       });
     }
   }
-  return deployedFrameworks;
 }
 
 function codegenDevModeFunctionsDirectory() {

src/hosting/config.ts

@@ -5,7 +5,8 @@ import { FirebaseError } from "../error";
 import {
   HostingMultiple,
   HostingSingle,
-  HostingResolved,
+  HostingBase,
+  Deployable,
   HostingRewrites,
   FunctionsRewrite,
   LegacyFunctionsRewrite,
@@ -20,6 +21,14 @@ import * as path from "node:path";
 import * as experiments from "../experiments";
 import { logger } from "../logger";
 
+// After validating a HostingMultiple and resolving targets, we will instead
+// have a HostingResolved.
+export type HostingResolved = HostingBase & {
+  site: string;
+  target?: string;
+  webFramework?: string;
+} & Deployable;
+
 // assertMatches allows us to throw when an --only flag doesn't match a target
 // but an --except flag doesn't. Is this desirable behavior?
 function matchingConfigs(

src/hosting/options.ts

@@ -1,6 +1,7 @@
-import { FirebaseConfig, HostingResolved } from "../firebaseConfig";
+import { FirebaseConfig } from "../firebaseConfig";
 import { Implements } from "../metaprogramming";
 import { Options } from "../options";
+import { HostingResolved } from "./config";
 
 /**
  * The set of fields that the Hosting codebase needs from Options.