Set local build configs throughout the deploy steps (#9184)

annajowang · web-flow · commit c34bbef6d03d · 2025-09-25T14:03:32.000-04:00
Sets the deploy context config for localBuild backends

In prepare, call the local build and set the build outputs in the config
In deploy, zip and upload the build directory
diff --git a/src/deploy/apphosting/args.ts b/src/deploy/apphosting/args.ts
@@ -4,6 +4,7 @@ import { BuildConfig } from "../../gcp/apphosting";
 export interface LocalBuild {
   buildConfig: BuildConfig;
   buildDir: string;
+  annotations: Record<string, string>;
 }
 
 export interface Context {
diff --git a/src/deploy/apphosting/deploy.spec.ts b/src/deploy/apphosting/deploy.spec.ts
@@ -35,10 +35,28 @@ function initializeContext(): Context {
           ignore: [],
         },
       ],
+      [
+        "foo-local-build",
+        {
+          backendId: "foo-local-build",
+          rootDir: "/",
+          ignore: [],
+          localBuild: true,
+        },
+      ],
+    ]),
+    backendLocations: new Map<string, string>([
+      ["foo", "us-central1"],
+      ["foo-local-build", "us-central1"],
     ]),
-    backendLocations: new Map<string, string>([["foo", "us-central1"]]),
     backendStorageUris: new Map<string, string>(),
-    backendLocalBuilds: {},
+    backendLocalBuilds: {
+      "foo-local-build": {
+        buildDir: "./nextjs/standalone",
+        buildConfig: {},
+        annotations: {},
+      },
+    },
   };
 }
 
@@ -67,17 +85,25 @@ describe("apphosting", () => {
     sinon.verifyAndRestore();
   });
 
-  describe("deploy", () => {
+  describe("deploy local source", () => {
     const opts = {
       ...BASE_OPTS,
       projectId: "my-project",
       only: "apphosting",
       config: new Config({
-        apphosting: {
-          backendId: "foo",
-          rootDir: "/",
-          ignore: [],
-        },
+        apphosting: [
+          {
+            backendId: "foo",
+            rootDir: "/",
+            ignore: [],
+          },
+          {
+            backendId: "foo-local-build",
+            rootDir: "/",
+            ignore: [],
+            localBuild: true,
+          },
+        ],
       }),
     };
 
@@ -89,36 +115,87 @@ describe("apphosting", () => {
           original: new FirebaseError("original error", { status: 404 }),
         }),
       );
+      getBucketStub.onSecondCall().rejects(
+        new FirebaseError("error", {
+          original: new FirebaseError("original error", { status: 404 }),
+        }),
+      );
       createBucketStub.resolves();
-      createArchiveStub.resolves("path/to/foo-1234.zip");
-      uploadObjectStub.resolves({
+      createArchiveStub.onFirstCall().resolves("path/to/foo-1234.zip");
+      createArchiveStub.onSecondCall().resolves("path/to/foo-local-build-1234.zip");
+      uploadObjectStub.onFirstCall().resolves({
         bucket: "firebaseapphosting-sources-12345678-us-central1",
         object: "foo-1234",
       });
+      uploadObjectStub.onSecondCall().resolves({
+        bucket: "firebaseapphosting-build-12345678-us-central1",
+        object: "foo-local-build-1234",
+      });
+
       createReadStreamStub.resolves();
 
       await deploy(context, opts);
 
-      expect(createBucketStub).to.be.calledOnce;
+      // assert backend foo calls
+      expect(createBucketStub).to.be.calledWithMatch("my-project", {
+        name: "firebaseapphosting-sources-000000000000-us-central1",
+        location: "us-central1",
+        lifecycle: sinon.match.any,
+      });
+      expect(createArchiveStub).to.be.calledWithExactly(
+        context.backendConfigs.get("foo"),
+        process.cwd(),
+        undefined,
+      );
+      expect(uploadObjectStub).to.be.calledWithMatch(
+        sinon.match.any,
+        "firebaseapphosting-sources-000000000000-us-central1",
+      );
+
+      // assert backend foo-local-build calls
+      expect(createBucketStub).to.be.calledWithMatch("my-project", {
+        name: "firebaseapphosting-build-000000000000-us-central1",
+        location: "us-central1",
+        lifecycle: sinon.match.any,
+      });
+      expect(createArchiveStub).to.be.calledWithExactly(
+        context.backendConfigs.get("foo-local-build"),
+        process.cwd(),
+        "./nextjs/standalone",
+      );
+      expect(uploadObjectStub).to.be.calledWithMatch(
+        sinon.match.any,
+        "firebaseapphosting-build-000000000000-us-central1",
+      );
     });
 
     it("correctly creates and sets storage URIs", async () => {
       const context = initializeContext();
       getProjectNumberStub.resolves("000000000000");
       getBucketStub.resolves();
       createBucketStub.resolves();
-      createArchiveStub.resolves("path/to/foo-1234.zip");
-      uploadObjectStub.resolves({
-        bucket: "firebaseapphosting-sources-12345678-us-central1",
+      createArchiveStub.onFirstCall().resolves("path/to/foo-1234.zip");
+      createArchiveStub.onSecondCall().resolves("path/to/foo-local-build-1234.zip");
+
+      uploadObjectStub.onFirstCall().resolves({
+        bucket: "firebaseapphosting-sources-000000000000-us-central1",
         object: "foo-1234",
       });
+
+      uploadObjectStub.onSecondCall().resolves({
+        bucket: "firebaseapphosting-build-000000000000-us-central1",
+        object: "foo-local-build-1234",
+      });
       createReadStreamStub.resolves();
 
       await deploy(context, opts);
 
       expect(context.backendStorageUris.get("foo")).to.equal(
         "gs://firebaseapphosting-sources-000000000000-us-central1/foo-1234.zip",
       );
+      expect(context.backendStorageUris.get("foo-local-build")).to.equal(
+        "gs://firebaseapphosting-build-000000000000-us-central1/foo-local-build-1234.zip",
+      );
     });
   });
 });
diff --git a/src/deploy/apphosting/deploy.ts b/src/deploy/apphosting/deploy.ts
@@ -24,8 +24,9 @@ export default async function (context: Context, options: Options): Promise<void
   }
 
   // Ensure that a bucket exists in each region that a backend is or will be deployed to
-  for (const loc of context.backendLocations.values()) {
-    const bucketName = `firebaseapphosting-sources-${options.projectNumber}-${loc.toLowerCase()}`;
+  for (const [backendId, loc] of context.backendLocations) {
+    const cfg = context.backendConfigs.get(backendId);
+    const bucketName = `firebaseapphosting-${cfg?.localBuild ? "build" : "sources"}-${options.projectNumber}-${loc.toLowerCase()}`;
     try {
       await gcs.getBucket(bucketName);
     } catch (err) {
@@ -73,8 +74,20 @@ export default async function (context: Context, options: Options): Promise<void
   }
 
   for (const cfg of context.backendConfigs.values()) {
-    const projectSourcePath = options.projectRoot ? options.projectRoot : process.cwd();
-    const zippedSourcePath = await createArchive(cfg, projectSourcePath);
+    const rootDir = options.projectRoot ?? process.cwd();
+    let builtAppDir;
+    if (cfg.localBuild) {
+      builtAppDir = context.backendLocalBuilds[cfg.backendId].buildDir;
+      if (!builtAppDir) {
+        throw new FirebaseError(`No local build dir found for ${cfg.backendId}`);
+      }
+    }
+    const zippedSourcePath = await createArchive(cfg, rootDir, builtAppDir);
+    logLabeledBullet(
+      "apphosting",
+      `Zipped ${cfg.localBuild ? "built app" : "source"} for backend ${cfg.backendId}`,
+    );
+
     const backendLocation = context.backendLocations.get(cfg.backendId);
     if (!backendLocation) {
       throw new FirebaseError(
@@ -83,19 +96,20 @@ export default async function (context: Context, options: Options): Promise<void
     }
     logLabeledBullet(
       "apphosting",
-      `Uploading source code at ${projectSourcePath} for backend ${cfg.backendId}...`,
+      `Uploading ${cfg.localBuild ? "built app" : "source"} for backend ${cfg.backendId}...`,
     );
+    const gcsBucketName = `firebaseapphosting-${cfg.localBuild ? "build" : "sources"}-${options.projectNumber}-${backendLocation.toLowerCase()}`;
     const { bucket, object } = await gcs.uploadObject(
       {
         file: zippedSourcePath,
         stream: fs.createReadStream(zippedSourcePath),
       },
-      `firebaseapphosting-sources-${options.projectNumber}-${backendLocation.toLowerCase()}`,
+      gcsBucketName,
     );
     logLabeledBullet("apphosting", `Source code uploaded at gs://${bucket}/${object}`);
     context.backendStorageUris.set(
       cfg.backendId,
-      `gs://firebaseapphosting-sources-${options.projectNumber}-${backendLocation.toLowerCase()}/${path.basename(zippedSourcePath)}`,
+      `gs://${gcsBucketName}/${path.basename(zippedSourcePath)}`,
     );
   }
 }
diff --git a/src/deploy/apphosting/prepare.spec.ts b/src/deploy/apphosting/prepare.spec.ts
@@ -10,6 +10,7 @@ import * as prompt from "../../prompt";
 import { RC } from "../../rc";
 import { Context } from "./args";
 import prepare, { getBackendConfigs } from "./prepare";
+import * as localbuilds from "../../apphosting/localbuilds";
 
 const BASE_OPTS = {
   cwd: "/",
@@ -75,6 +76,58 @@ describe("apphosting", () => {
   });
 
   describe("prepare", () => {
+    it("correctly creates configs for localBuild backends", async () => {
+      const optsWithLocalBuild = {
+        ...opts,
+        config: new Config({
+          apphosting: {
+            backendId: "foo",
+            rootDir: "/",
+            ignore: [],
+            localBuild: true,
+          },
+        }),
+      };
+      const context = initializeContext();
+
+      const annotations = {
+        adapterPackageName: "@apphosting/angular-adapter",
+        adapterVersion: "14.1",
+        framework: "nextjs",
+      };
+      const buildConfig = {
+        runCommand: "npm run build:prod",
+        env: [],
+      };
+      sinon.stub(localbuilds, "localBuild").resolves({
+        outputFiles: ["./next/standalone"],
+        buildConfig,
+        annotations,
+      });
+      listBackendsStub.onFirstCall().resolves({
+        backends: [
+          {
+            name: "projects/my-project/locations/us-central1/backends/foo",
+          },
+        ],
+      });
+
+      await prepare(context, optsWithLocalBuild);
+
+      expect(context.backendLocations.get("foo")).to.equal("us-central1");
+      expect(context.backendConfigs.get("foo")).to.deep.equal({
+        backendId: "foo",
+        rootDir: "/",
+        ignore: [],
+        localBuild: true,
+      });
+      expect(context.backendLocalBuilds["foo"]).to.deep.equal({
+        buildDir: "./next/standalone",
+        buildConfig,
+        annotations,
+      });
+    });
+
     it("links to existing backend if it already exists", async () => {
       const context = initializeContext();
       listBackendsStub.onFirstCall().resolves({
@@ -93,6 +146,7 @@ describe("apphosting", () => {
         rootDir: "/",
         ignore: [],
       });
+      expect(context.backendLocalBuilds).to.deep.equal({});
     });
 
     it("creates a backend if it doesn't exist yet", async () => {
@@ -113,6 +167,7 @@ describe("apphosting", () => {
         rootDir: "/",
         ignore: [],
       });
+      expect(context.backendLocalBuilds).to.deep.equal({});
     });
 
     it("skips backend deployment if alwaysDeployFromSource is false", async () => {
@@ -143,6 +198,7 @@ describe("apphosting", () => {
 
       expect(context.backendLocations.get("foo")).to.equal(undefined);
       expect(context.backendConfigs.get("foo")).to.deep.equal(undefined);
+      expect(context.backendLocalBuilds).to.deep.equal({});
     });
 
     it("prompts user if codebase is already connected and alwaysDeployFromSource is undefined", async () => {
@@ -172,6 +228,7 @@ describe("apphosting", () => {
         ignore: [],
         alwaysDeployFromSource: true,
       });
+      expect(context.backendLocalBuilds).to.deep.equal({});
     });
   });
 
diff --git a/src/deploy/apphosting/prepare.ts b/src/deploy/apphosting/prepare.ts
@@ -11,7 +11,9 @@ import { Options } from "../../options";
 import { needProjectId } from "../../projectUtils";
 import { checkbox, confirm } from "../../prompt";
 import { logLabeledBullet, logLabeledWarning } from "../../utils";
+import { localBuild } from "../../apphosting/localbuilds";
 import { Context } from "./args";
+import { FirebaseError } from "../../error";
 
 /**
  * Prepare backend targets to deploy from source. Checks that all required APIs are enabled,
@@ -26,6 +28,7 @@ export default async function (context: Context, options: Options): Promise<void
   context.backendConfigs = new Map<string, AppHostingSingle>();
   context.backendLocations = new Map<string, string>();
   context.backendStorageUris = new Map<string, string>();
+  context.backendLocalBuilds = {};
 
   const configs = getBackendConfigs(options);
   const { backends } = await listBackends(projectId, "-");
@@ -144,6 +147,32 @@ export default async function (context: Context, options: Options): Promise<void
       `Skipping deployment of backend(s) ${skippedBackends.map((cfg) => cfg.backendId).join(", ")}.`,
     );
   }
+
+  for (const config of context.backendConfigs.values()) {
+    if (!config.localBuild) {
+      continue;
+    }
+    logLabeledBullet("apphosting", `Starting local build for backend ${config.backendId}`);
+    try {
+      const { outputFiles, annotations, buildConfig } = await localBuild(
+        options.projectRoot || "./",
+        "nextjs",
+      );
+      if (outputFiles.length !== 1) {
+        throw new FirebaseError(
+          `Local build for backend ${config.backendId} failed: No output files found.`,
+        );
+      }
+      context.backendLocalBuilds[config.backendId] = {
+        // TODO(9114): This only works for nextjs.
+        buildDir: outputFiles[0],
+        buildConfig,
+        annotations,
+      };
+    } catch (e) {
+      throw new FirebaseError(`Local Build for backend ${config.backendId} failed: ${e}`);
+    }
+  }
   return;
 }
 
diff --git a/src/deploy/apphosting/release.spec.ts b/src/deploy/apphosting/release.spec.ts
@@ -63,6 +63,7 @@ describe("apphosting", () => {
               env: [{ variable: "CHICKEN", value: "bok-bok" }],
             },
             buildDir: "./",
+            annotations: {},
           },
         },
       };
diff --git a/src/deploy/apphosting/release.ts b/src/deploy/apphosting/release.ts
@@ -34,6 +34,7 @@ export default async function (context: Context, options: Options): Promise<void
       continue;
     }
     backendIds.push(backendId);
+    // TODO(9114): Add run_command
     let buildConfig;
     if (config.localBuild) {
       buildConfig = context.backendLocalBuilds[backendId].buildConfig;

Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@ import { BuildConfig } from "../../gcp/apphosting";`
`4`	`4`	`export interface LocalBuild {`
`5`	`5`	`buildConfig: BuildConfig;`
`6`	`6`	`buildDir: string;`
	`7`	`+ annotations: Record<string, string>;`
`7`	`8`	`}`
`8`	`9`
`9`	`10`	`export interface Context {`
Original file line number	Diff line number	Diff line change
`@@ -34,6 +34,7 @@ export default async function (context: Context, options: Options): Promise<void`
`34`	`34`	`continue;`
`35`	`35`	`}`
`36`	`36`	`backendIds.push(backendId);`
	`37`	`+ // TODO(9114): Add run_command`
`37`	`38`	`let buildConfig;`
`38`	`39`	`if (config.localBuild) {`
`39`	`40`	`buildConfig = context.backendLocalBuilds[backendId].buildConfig;`