Support env vars for local/zip deploys

src/apphosting/config.spec.ts

@@ -473,6 +473,29 @@
     });
   });
 
+  describe("splitEnvVars", () => {
+    it("should stringify numeric values", () => {
+      const env: AppHostingYamlConfig["env"] = {
+        STR: { value: "string" },
+        NUM: { value: 12345 as any },
+        BUILD_AND_RUNTIME_NUM: { value: 67890 as any, availability: ["BUILD", "RUNTIME"] },
+      };
+
+      const { build, runtime } = config.splitEnvVars(env);
+
+      expect(build["STR"].value).to.equal("string");
+      expect(build["NUM"].value).to.equal("12345");
+      expect(build["BUILD_AND_RUNTIME_NUM"].value).to.equal("67890");
+      expect(runtime).to.deep.include({ variable: "STR", value: "string" });
+      expect(runtime).to.deep.include({ variable: "NUM", value: "12345" });
+      expect(runtime).to.deep.include({
+        variable: "BUILD_AND_RUNTIME_NUM",
+        value: "67890",
+        availability: ["BUILD", "RUNTIME"],
+      });
+    });
+  });
+
   describe("getAppHostingConfiguration", () => {
     let loadAppHostingYamlStub: sinon.SinonStub;
     let listAppHostingFilesInPathStub: sinon.SinonStub;

src/apphosting/config.ts

@@ -1,4 +1,4 @@
-import { join, dirname } from "path";
+import { join, dirname, basename } from "path";
 import { writeFileSync } from "fs";
 import * as yaml from "yaml";
 import * as clc from "colorette";
@@ -11,7 +11,6 @@
 import { logger } from "../logger";
 import * as csm from "../gcp/secretManager";
 import { FirebaseError, getError } from "../error";
-import { basename } from "path";
 
 // Common config across all environments
 export const APPHOSTING_BASE_YAML_FILE = "apphosting.yaml";
@@ -62,7 +61,7 @@
 export function discoverBackendRoot(cwd: string): string | null {
   let dir = cwd;
 
   while (true) {
     const files = fs.listFiles(dir);
     if (files.some((file) => APPHOSTING_YAML_FILE_REGEX.test(file))) {
       return dir;
@@ -101,8 +100,8 @@
   let raw: string;
   try {
     raw = fs.readFile(yamlPath);
   } catch (err: any) {
     if (err.code !== "ENOENT") {
       throw new FirebaseError(`Unexpected error trying to load ${yamlPath}`, {
         original: getError(err),
       });
@@ -360,7 +359,7 @@
         default: suggestedTestKeyName(name),
       });
 
       if (await csm.secretExists(projectId!, secretRef)) {
         action = await prompt.select<"reuse" | "pick-new">({
           message:
             "This secret reference already exists, would you like to reuse it or create a new one?",
@@ -374,7 +373,7 @@
       }
     }
 
     newEnv[name] = { variable: name, secret: secretRef! };
     if (action === "reuse") {
       continue;
     }
@@ -383,7 +382,7 @@
       `What new value would you like for secret ${name} [input is hidden]?`,
     );
     // TODO: Do we need to support overriding locations? Inferring them from the original?
     await csm.createSecret(projectId!, secretRef!, { [csm.FIREBASE_MANAGED]: "apphosting" });
     await csm.addVersion(projectId!, secretRef!, secretValue);
   }
 
@@ -393,3 +392,27 @@
 export function suggestedTestKeyName(variable: string): string {
   return "test-" + variable.replace(/_/g, "-").toLowerCase();
 }
+
+/**
+ * Split a set of environment variables into build and runtime variables.
+ */
+export function splitEnvVars(env: EnvMap): { build: EnvMap; runtime: Env[] } {
+  const build: EnvMap = {};
+  const runtime: Env[] = [];
+
+  for (const [key, val] of Object.entries(env)) {
+    const envVal = { ...val };
+    if (envVal.value !== undefined) {
+      envVal.value = String(envVal.value);
+    }
+
+    if (val.availability?.includes("BUILD") || !val.availability) {
+      build[key] = envVal;
+    }
+    if (val.availability?.includes("RUNTIME") || !val.availability) {
+      runtime.push({ variable: key, ...envVal });
+    }
+  }
+
+  return { build, runtime };
+}

src/apphosting/localbuilds.ts

@@ -1,5 +1,7 @@
+import * as path from "path";
 import { BuildConfig, Env } from "../gcp/apphosting";
 import { localBuild as localAppHostingBuild } from "@apphosting/build";
+import { EnvMap } from "./yaml";
 
 /**
  * Triggers a local build of your App Hosting codebase.
@@ -17,31 +19,72 @@ import { localBuild as localAppHostingBuild } from "@apphosting/build";
 export async function localBuild(
   projectRoot: string,
   framework: string,
+  env: EnvMap = {},
 ): Promise<{
   outputFiles: string[];
   annotations: Record<string, string>;
   buildConfig: BuildConfig;
 }> {
-  const apphostingBuildOutput = await localAppHostingBuild(projectRoot, framework);
+  // We need to inject the environment variables into the process.env
+  // because the build adapter uses them to build the app.
+  // We'll restore the original process.env after the build is done.
+  const originalEnv = { ...process.env };
+  const projectNodeModules = path.join(projectRoot, "node_modules");
+  const newNodePath = process.env.NODE_PATH
+    ? `${process.env.NODE_PATH}${path.delimiter}${projectNodeModules}`
+    : projectNodeModules;
+
+  const addedEnv = toProcessEnv(env);
+  for (const [key, value] of Object.entries(addedEnv)) {
+    process.env[key] = value;
+  }
+  const originalNodePath = process.env.NODE_PATH;
+  process.env.NODE_PATH = newNodePath;
+
+  let apphostingBuildOutput;
+  try {
+    apphostingBuildOutput = await localAppHostingBuild(projectRoot, framework);
+  } finally {
+    for (const key in process.env) {
+      if (!(key in originalEnv)) {
+        delete process.env[key];
+      }
+    }
+    for (const [key, value] of Object.entries(originalEnv)) {
+      process.env[key] = value;
+    }
+    if (originalNodePath !== undefined) {
+      process.env.NODE_PATH = originalNodePath;
+    } else {
+      delete process.env.NODE_PATH;
+    }
+  }
 
   const annotations: Record<string, string> = Object.fromEntries(
     Object.entries(apphostingBuildOutput.metadata).map(([key, value]) => [key, String(value)]),
   );
 
-  const env: Env[] | undefined = apphostingBuildOutput.runConfig.environmentVariables?.map(
-    ({ variable, value, availability }) => ({
-      variable,
-      value,
-      availability,
-    }),
-  );
+  const discoveredEnv: Env[] | undefined =
+    apphostingBuildOutput.runConfig.environmentVariables?.map(
+      ({ variable, value, availability }) => ({
+        variable,
+        value,
+        availability,
+      }),
+    );
 
   return {
     outputFiles: apphostingBuildOutput.outputFiles?.serverApp.include ?? [],
     annotations,
     buildConfig: {
       runCommand: apphostingBuildOutput.runConfig.runCommand,
-      env: env ?? [],
+      env: discoveredEnv ?? [],
     },
   };
 }
+
+function toProcessEnv(env: EnvMap): NodeJS.ProcessEnv {
+  return Object.fromEntries(
+    Object.entries(env).map(([key, value]) => [key, value.value || ""]),
+  ) as NodeJS.ProcessEnv;
+}

src/apphosting/utils.ts

@@ -1,6 +1,6 @@
 import { FirebaseError } from "../error";
-import { APPHOSTING_BASE_YAML_FILE, APPHOSTING_YAML_FILE_REGEX } from "./config";
 import { WebConfig } from "../fetchWebSetup";
+import { APPHOSTING_BASE_YAML_FILE, APPHOSTING_YAML_FILE_REGEX } from "./config";
 import * as prompt from "../prompt";
 
 /**

src/deploy/apphosting/prepare.spec.ts

@@ -11,6 +11,7 @@ import { Context } from "./args";
 import { FirebaseError } from "../../error";
 import prepare, { getBackendConfigs } from "./prepare";
 import * as localbuilds from "../../apphosting/localbuilds";
+import * as managementApps from "../../management/apps";
 import * as experiments from "../../experiments";
 import * as getProjectNumber from "../../getProjectNumber";
 import * as resourceManager from "../../gcp/resourceManager";
@@ -68,13 +69,14 @@ describe("apphosting", () => {
       .stub(apphosting, "listBackends")
       .throws("Unexpected listBackends call");
     sinon.stub(backend, "ensureAppHostingComputeServiceAccount").resolves();
+    sinon.stub(getProjectNumber, "getProjectNumber").resolves("123456789");
     sinon.stub(apiEnabled, "ensure").resolves();
     getGitRepositoryLinkStub = sinon
       .stub(devconnect, "getGitRepositoryLink")
       .throws("Unexpected getGitRepositoryLink call");
     assertEnabledStub = sinon.stub(experiments, "assertEnabled").returns();
     sinon.stub(experiments, "isEnabled").returns(true);
-    sinon.stub(getProjectNumber, "getProjectNumber").resolves("123456789");
+
     addServiceAccountToRolesStub = sinon
       .stub(resourceManager, "addServiceAccountToRoles")
       .resolves();
@@ -143,6 +145,71 @@ describe("apphosting", () => {
       );
     });
 
+    it("injects Firebase configuration when appId is present", async () => {
+      const optsWithLocalBuild = {
+        ...opts,
+        config: new Config({
+          apphosting: {
+            backendId: "foo",
+            rootDir: "/",
+            ignore: [],
+            localBuild: true,
+          },
+        }),
+      };
+      const context = initializeContext();
+
+      const webAppConfig = {
+        projectId: "my-project",
+        appId: "my-app-id",
+        apiKey: "my-api-key",
+        authDomain: "my-project.firebaseapp.com",
+        databaseURL: "https://my-project.firebaseio.com",
+        storageBucket: "my-project.appspot.com",
+        messagingSenderId: "123456",
+        measurementId: "G-123456",
+      };
+
+      sinon.stub(managementApps, "getAppConfig").resolves(webAppConfig);
+      const localBuildStub = sinon.stub(localbuilds, "localBuild").resolves({
+        outputFiles: ["./next/standalone"],
+        buildConfig: { runCommand: "npm run build", env: [] },
+        annotations: {},
+      });
+
+      listBackendsStub.onFirstCall().resolves({
+        backends: [
+          {
+            name: "projects/my-project/locations/us-central1/backends/foo",
+            appId: "my-app-id",
+          },
+        ],
+      });
+
+      await prepare(context, optsWithLocalBuild);
+
+      expect(localBuildStub).to.be.calledWithMatch(
+        sinon.match.any,
+        "nextjs",
+        sinon.match({
+          FIREBASE_WEBAPP_CONFIG: { value: JSON.stringify(webAppConfig) },
+          FIREBASE_CONFIG: {
+            value: JSON.stringify({
+              databaseURL: webAppConfig.databaseURL,
+              storageBucket: webAppConfig.storageBucket,
+              projectId: webAppConfig.projectId,
+            }),
+          },
+        }),
+      );
+      expect(addServiceAccountToRolesStub).to.have.been.calledWith(
+        "my-project",
+        apphosting.serviceAgentEmail("123456789"),
+        ["roles/storage.objectViewer"],
+        true,
+      );
+    });
+
     it("should fail if localBuild is specified but experiment is disabled", async () => {
       const optsWithLocalBuild = {
         ...opts,

src/deploy/apphosting/prepare.ts

@@ -11,6 +11,9 @@ import {
   parseBackendName,
   serviceAgentEmail,
 } from "../../gcp/apphosting";
+import { AppHostingYamlConfig, EnvMap } from "../../apphosting/yaml";
+import { WebConfig } from "../../fetchWebSetup";
+import { Env, getAppHostingConfiguration, splitEnvVars } from "../../apphosting/config";
 import { getGitRepositoryLink, parseGitRepositoryLinkName } from "../../gcp/devConnect";
 import { addServiceAccountToRoles } from "../../gcp/resourceManager";
 
@@ -22,6 +25,8 @@ import { logLabeledBullet, logLabeledWarning } from "../../utils";
 import { localBuild } from "../../apphosting/localbuilds";
 import { Context } from "./args";
 import { FirebaseError } from "../../error";
+import * as managementApps from "../../management/apps";
+import { getAutoinitEnvVars } from "../../apphosting/utils";
 import * as experiments from "../../experiments";
 import { logger } from "../../logger";
 
@@ -46,6 +51,27 @@ export default async function (context: Context, options: Options): Promise<void
     await ensureAppHostingServiceAgentRoles(projectId, projectNumber);
   }
 
+  const buildEnv: Record<string, EnvMap> = {};
+  const runtimeEnv: Record<string, Env[]> = {};
+
+  for (const cfg of configs) {
+    const rootDir = options.projectRoot || process.cwd();
+    const appDir = path.join(rootDir, cfg.rootDir || "");
+    let yamlConfig = AppHostingYamlConfig.empty();
+    try {
+      yamlConfig = await getAppHostingConfiguration(appDir);
+    } catch (e: unknown) {
+      if (e instanceof Error && e.message && !e.message.includes("doesn't exist")) {
+        throw e;
+      }
+    }
+
+    const { build, runtime } = splitEnvVars(yamlConfig.env);
+
+    buildEnv[cfg.backendId] = build;
+    runtimeEnv[cfg.backendId] = runtime;
+  }
+
   const { backends } = await listBackends(projectId, "-");
 
   const foundBackends: AppHostingSingle[] = [];
@@ -169,20 +195,46 @@ export default async function (context: Context, options: Options): Promise<void
     }
     experiments.assertEnabled("apphostinglocalbuilds", "locally build App Hosting backends");
     logLabeledBullet("apphosting", `Starting local build for backend ${cfg.backendId}`);
+    const backend = backends.find((b) => parseBackendName(b.name).id === cfg.backendId);
+    if (backend?.appId) {
+      try {
+        const webappConfig = (await managementApps.getAppConfig(
+          backend.appId,
+          managementApps.AppPlatform.WEB,
+        )) as WebConfig;
+        const autoinitVars = getAutoinitEnvVars(webappConfig);
+        for (const [key, value] of Object.entries(autoinitVars)) {
+          if (!(key in buildEnv[cfg.backendId])) {
+            buildEnv[cfg.backendId][key] = { value };
+          }
+          if (!runtimeEnv[cfg.backendId].some((e) => e.variable === key)) {
+            runtimeEnv[cfg.backendId].push({ variable: key, value });
+          }
+        }
+      } catch (e) {
+        logLabeledWarning(
+          "apphosting",
+          `Unable to lookup details for backend ${cfg.backendId}. Firebase SDK autoinit will not be available.`,
+        );
+      }
+    }
     try {
       const { outputFiles, annotations, buildConfig } = await localBuild(
         options.projectRoot || "./",
         "nextjs",
+        buildEnv[cfg.backendId] || {},
       );
       if (outputFiles.length !== 1) {
         throw new FirebaseError(
           `Local build for backend ${cfg.backendId} failed: No output files found.`,
         );
       }
       context.backendLocalBuilds[cfg.backendId] = {
-        // TODO(9114): This only works for nextjs.
         buildDir: outputFiles[0],
-        buildConfig,
+        buildConfig: {
+          ...buildConfig,
+          env: mergeEnvVars(buildConfig.env || [], runtimeEnv[cfg.backendId] || []),
+        },
         annotations,
       };
     } catch (e: unknown) {
@@ -227,6 +279,24 @@ export function getBackendConfigs(options: Options): AppHostingMultiple {
   return backendConfigs.filter((cfg) => backendIds.includes(cfg.backendId));
 }
 
+/**
+ * Merges two lists of environment variables, giving precedence to the values in overrides.
+ */
+function mergeEnvVars(base: Env[], overrides: Env[]): Env[] {
+  const merged = new Map<string, Env>();
+  for (const env of base) {
+    if (env.variable) {
+      merged.set(env.variable, env);
+    }
+  }
+  for (const env of overrides) {
+    if (env.variable) {
+      merged.set(env.variable, env);
+    }
+  }
+  return Array.from(merged.values());
+}
+
 /**
  * Ensures that the App Hosting service agent has the necessary roles to access
  * project resources (e.g. storage) for a given project.

src/deploy/apphosting/release.ts

@@ -50,7 +50,8 @@ export default async function (context: Context, options: Options): Promise<void
       backendId,
       location: context.backendLocations[backendId],
       buildInput: {
-        config: context.backendLocalBuilds[backendId]?.buildConfig,
+        // TODO: Confirm this config behavior
+        config: context.backendLocalBuilds[backendId]?.buildConfig || {},
         source: {
           archive: {
             userStorageUri: context.backendStorageUris[backendId],