Merge localBuild support into firebase deploy

package.json

@@ -102,6 +102,8 @@
     ]
   },
   "dependencies": {
+    "@apphosting/build": "^0.1.6",
+    "@apphosting/common": "^0.0.8",
     "@electric-sql/pglite": "^0.3.3",
     "@electric-sql/pglite-tools": "^0.2.8",
     "@google-cloud/cloud-sql-connector": "^1.3.3",

schema/firebase-config.json

@@ -1107,6 +1107,9 @@
                             },
                             "type": "array"
                         },
+                        "localBuild": {
+                            "type": "boolean"
+                        },
                         "rootDir": {
                             "type": "string"
                         }
@@ -1134,6 +1137,9 @@
                                 },
                                 "type": "array"
                             },
+                            "localBuild": {
+                                "type": "boolean"
+                            },
                             "rootDir": {
                                 "type": "string"
                             }

src/apphosting/localbuilds.spec.ts

@@ -0,0 +1,47 @@
+import * as sinon from "sinon";
+import { expect } from "chai";
+import * as localBuildModule from "@apphosting/build";
+import { localBuild } from "./localbuilds";
+
+describe("localBuild", () => {
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  it("returns the expected output", async () => {
+    const bundleConfig = {
+      version: "v1" as const,
+      runConfig: {
+        runCommand: "npm run build:prod",
+      },
+      metadata: {
+        adapterPackageName: "@apphosting/angular-adapter",
+        adapterVersion: "14.1",
+        framework: "nextjs",
+      },
+      outputFiles: {
+        serverApp: {
+          include: ["./next/standalone"],
+        },
+      },
+    };
+    const expectedAnnotations = {
+      adapterPackageName: "@apphosting/angular-adapter",
+      adapterVersion: "14.1",
+      framework: "nextjs",
+    };
+    const expectedOutputFiles = ["./next/standalone"];
+    const expectedBuildConfig = {
+      runCommand: "npm run build:prod",
+      env: [],
+    };
+    const localApphostingBuildStub: sinon.SinonStub = sinon
+      .stub(localBuildModule, "localBuild")
+      .resolves(bundleConfig);
+    const { outputFiles, annotations, buildConfig } = await localBuild("./", "nextjs");
+    expect(annotations).to.deep.equal(expectedAnnotations);
+    expect(buildConfig).to.deep.equal(expectedBuildConfig);
+    expect(outputFiles).to.deep.equal(expectedOutputFiles);
+    sinon.assert.calledWith(localApphostingBuildStub, "./", "nextjs");
+  });
+});

src/apphosting/localbuilds.ts

@@ -0,0 +1,37 @@
+import { BuildConfig, Env } from "../gcp/apphosting";
+import { localBuild as localAppHostingBuild } from "@apphosting/build";
+
+/**
+ * Triggers a local apphosting build.
+ */
+export async function localBuild(
+  projectRoot: string,
+  framework: string,
+): Promise<{
+  outputFiles: string[];
+  annotations: Record<string, string>;
+  buildConfig: BuildConfig;
+}> {
+  const apphostingBuildOutput = await localAppHostingBuild(projectRoot, framework);
+
+  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,
+    }),
+  );
+
+  return {
+    outputFiles: apphostingBuildOutput.outputFiles?.serverApp.include ?? [],
+    annotations,
+    buildConfig: {
+      runCommand: apphostingBuildOutput.runConfig.runCommand,
+      env: env ?? [],
+    },
+  };
+}

src/deploy/apphosting/args.ts

@@ -1,7 +1,15 @@
 import { AppHostingSingle } from "../../firebaseConfig";
+import { BuildConfig } from "../../gcp/apphosting";
+
+export interface LocalBuild {
+  buildConfig: BuildConfig;
+  buildDir: string;
+  annotations: Record<string, string>;
+}
 
 export interface Context {
   backendConfigs: Record<string, AppHostingSingle>;
   backendLocations: Record<string, string>;
   backendStorageUris: Record<string, string>;
+  backendLocalBuilds: Record<string, LocalBuild>;
 }

src/deploy/apphosting/deploy.spec.ts

@@ -30,9 +30,22 @@ function initializeContext(): Context {
         rootDir: "/",
         ignore: [],
       },
+      fooLocalBuild: {
+        backendId: "fooLocalBuild",
+        rootDir: "/",
+        ignore: [],
+        localBuild: true,
+      },
     },
-    backendLocations: { foo: "us-central1" },
+    backendLocations: { foo: "us-central1", fooLocalBuild: "us-central1" },
     backendStorageUris: {},
+    backendLocalBuilds: {
+      fooLocalBuild: {
+        buildDir: "./nextjs/standalone",
+        buildConfig: {},
+        annotations: {},
+      },
+    },
   };
 }
 
@@ -59,33 +72,49 @@ 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: "fooLocalBuild",
+            rootDir: "/",
+            ignore: [],
+            localBuild: true,
+          },
+        ],
       }),
     };
 
     it("upserts regional GCS bucket", async () => {
       const context = initializeContext();
       getProjectNumberStub.resolves("000000000000");
       upsertBucketStub.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);
 
+      // assert backend foo calls
+
       expect(upsertBucketStub).to.be.calledWith({
         product: "apphosting",
         createMessage:
@@ -104,24 +133,63 @@ describe("apphosting", () => {
           },
         },
       });
+
+      // assert backend fooLocalBuild calls
+      expect(upsertBucketStub).to.be.calledWith({
+        product: "apphosting",
+        createMessage:
+          "Creating Cloud Storage bucket in us-central1 to store App Hosting source code uploads at firebaseapphosting-build-000000000000-us-central1...",
+        projectId: "my-project",
+        req: {
+          name: "firebaseapphosting-build-000000000000-us-central1",
+          location: "us-central1",
+          lifecycle: {
+            rule: [
+              {
+                action: { type: "Delete" },
+                condition: { age: 30 },
+              },
+            ],
+          },
+        },
+      });
+      expect(createArchiveStub).to.be.calledWithExactly(
+        context.backendConfigs["fooLocalBuild"],
+        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");
       upsertBucketStub.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["foo"]).to.equal(
         "gs://firebaseapphosting-sources-000000000000-us-central1/foo-1234.zip",
       );
+      expect(context.backendStorageUris["fooLocalBuild"]).to.equal(
+        "gs://firebaseapphosting-build-000000000000-us-central1/foo-local-build-1234.zip",
+      );
     });
   });
 });

src/deploy/apphosting/deploy.ts

@@ -25,8 +25,15 @@
 
   // Ensure that a bucket exists in each region that a backend is or will be deployed to
   await Promise.all(
-    Object.values(context.backendLocations).map(async (loc) => {
-      const bucketName = `firebaseapphosting-sources-${options.projectNumber}-${loc.toLowerCase()}`;
+    Object.entries(context.backendLocations).map(async ([backendId, loc]) => {
+      const cfg = context.backendConfigs[backendId];
+      if (!cfg) {
+        throw new FirebaseError(
+          `Failed to find config for backend ${backendId}. Please contact support with the contents of your firebase-debug.log to report your issue.`,
+        );
+      }
+
+      const bucketName = `firebaseapphosting-${cfg.localBuild ? "build" : "sources"}-${options.projectNumber}-${loc.toLowerCase()}`;
       await gcs.upsertBucket({
         product: "apphosting",
         createMessage: `Creating Cloud Storage bucket in ${loc} to store App Hosting source code uploads at ${bucketName}...`,
@@ -51,10 +58,23 @@
     }),
   );
 
+  // Zip and upload code to GCS bucket.
   await Promise.all(
     Object.values(context.backendConfigs).map(async (cfg) => {
-      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[cfg.backendId];
       if (!backendLocation) {
         throw new FirebaseError(
@@ -63,17 +83,18 @@
       }
       logLabeledBullet(
         "apphosting",
-        `Uploading source code at ${projectSourcePath} for backend ${cfg.backendId}...`,
+        `Uploading ${cfg.localBuild ? "built app" : "source"} for backend ${cfg.backendId}...`,
       );
-      const bucketName = `firebaseapphosting-sources-${options.projectNumber}-${backendLocation.toLowerCase()}`;
+      const bucketName = `firebaseapphosting-${cfg.localBuild ? "build" : "sources"}-${options.projectNumber}-${backendLocation.toLowerCase()}`;
+
       const { bucket, object } = await gcs.uploadObject(
         {
           file: zippedSourcePath,
           stream: fs.createReadStream(zippedSourcePath),
         },
         bucketName,
       );
-      logLabeledBullet("apphosting", `Source code uploaded at gs://${bucket}/${object}`);
+      logLabeledBullet("apphosting", `Uploaded at gs://${bucket}/${object}`);
       context.backendStorageUris[cfg.backendId] =
         `gs://${bucketName}/${path.basename(zippedSourcePath)}`;
     }),