Merge next to master (#8360)

* Update "location" => "primary region" in the backend display table. (#8205)

* Remove --location from apphosting:backend:list. (#8272)

* Remove --location from apphosting:rollouts:create and error when more than one backend is found. (#8271)

* Remove --location from apphosting:backends:get and return the first backend if multiple are found. (#8260)

* Remove `--location` from apphosting:backends:delete (#8262)

* Remove --location from apphosting:backends:create and prompt for primary region. (#8264)

* Enable FDC connector evolution and insecure operations linter. (#8281)

* Enable FDC connector evolution and insecure operations linter.

* Enable in VSCode.

* Actually get VSCode working.

* Replace pkg with yao-pkg/pkg (#8328)

Co-authored-by: aalej <[email protected]>

* List regions of duplicate backend in warning/error message (#8285)

* Update dataconnect.yaml template to v1. (#8346)

* Remove support for node 18 (#8334)

---------

Co-authored-by: annajowang <[email protected]>
Co-authored-by: Joe Hanley <[email protected]>
Co-authored-by: Rosalyn Tan <[email protected]>
Co-authored-by: aalej <[email protected]>

Author: 5 people

.github/workflows/node-test.yml

@@ -46,7 +46,6 @@ jobs:
     strategy:
       matrix:
         node-version:
-          - "18"
           - "20"
           - "22"
     steps:
@@ -73,7 +72,6 @@ jobs:
     strategy:
       matrix:
         node-version:
-          - "18"
           - "20"
 
     env:
@@ -132,7 +130,6 @@ jobs:
     strategy:
       matrix:
         node-version:
-          - "18"
           - "20"
           - "22"
     steps:

firebase-vscode/src/data-connect/toolkit.ts

@@ -38,6 +38,13 @@ export class DataConnectToolkit implements vscode.Disposable {
   async startFDCToolkit(configDir: string, config: Config, RC: RC) {
     const port = await findOpenPort(DEFAULT_PORT);
     const settings = getSettings();
+
+    // Set the conn_evolution preview flag if it's not already set.
+    const previewFlags = new Set(["conn_evolution"]);
+    if (settings.extraEnv["DATA_CONNECT_PREVIEW"]) {
+      settings.extraEnv["DATA_CONNECT_PREVIEW"].split(',').forEach(f => previewFlags.add(f));
+    }
+
     const toolkitArgs: DataConnectEmulatorArgs = {
       projectId: "toolkit",
       listen: [{ address: "localhost", port, family: "IPv4" }],
@@ -47,7 +54,7 @@ export class DataConnectToolkit implements vscode.Disposable {
       autoconnectToPostgres: false,
       enable_output_generated_sdk: true,
       enable_output_schema_extensions: true,
-      extraEnv: settings.extraEnv,
+      extraEnv: {...settings.extraEnv, ...{"DATA_CONNECT_PREVIEW": Array.from(previewFlags).join(',')}},
     };
     pluginLogger.info(`Starting Data Connect toolkit (version ${DataConnectToolkitController.getVersion()}) on port ${port}`);
     return DataConnectToolkitController.start(toolkitArgs);

npm-shrinkwrap.json

@@ -69,7 +69,7 @@
   ],
   "preferGlobal": true,
   "engines": {
-    "node": ">=18.0.0 || >=20.0.0 || >=22.0.0"
+    "node": ">=20.0.0 || >=22.0.0"
   },
   "author": "Firebase (https://firebase.google.com/)",
   "license": "MIT",

package.json

@@ -12,7 +12,9 @@ import {
   promptLocation,
   setDefaultTrafficPolicy,
   ensureAppHostingComputeServiceAccount,
+  chooseBackends,
   getBackendForAmbiguousLocation,
+  getBackend,
 } from "./backend";
 import * as deploymentTool from "../deploymentTool";
 import { FirebaseError } from "../error";
@@ -266,6 +268,85 @@ describe("apphosting setup functions", () => {
     });
   });
 
+  describe("chooseBackends", () => {
+    const backendChickenAsia = {
+      name: `projects/${projectId}/locations/asia-east1/backends/chicken`,
+      labels: {},
+      createTime: "0",
+      updateTime: "1",
+      uri: "https://placeholder.com",
+    };
+
+    const backendChickenEurope = {
+      name: `projects/${projectId}/locations/europe-west4/backends/chicken`,
+      labels: {},
+      createTime: "0",
+      updateTime: "1",
+      uri: "https://placeholder.com",
+    };
+
+    const backendChickenUS = {
+      name: `projects/${projectId}/locations/us-central1/backends/chicken`,
+      labels: {},
+      createTime: "0",
+      updateTime: "1",
+      uri: "https://placeholder.com",
+    };
+
+    const backendCow = {
+      name: `projects/${projectId}/locations/asia-east1/backends/cow`,
+      labels: {},
+      createTime: "0",
+      updateTime: "1",
+      uri: "https://placeholder.com",
+    };
+
+    const allBackends = [backendChickenAsia, backendChickenEurope, backendChickenUS, backendCow];
+
+    it("returns backend if only one is found", async () => {
+      listBackendsStub.resolves({
+        backends: allBackends,
+      });
+
+      await expect(chooseBackends(projectId, "cow", /* prompt= */ "")).to.eventually.deep.equal([
+        backendCow,
+      ]);
+    });
+
+    it("throws if --force is used when multiple backends are found", async () => {
+      listBackendsStub.resolves({
+        backends: allBackends,
+      });
+
+      await expect(
+        chooseBackends(projectId, "chicken", /* prompt= */ "", /* force= */ true),
+      ).to.be.rejectedWith(
+        "Force cannot be used because multiple backends were found with ID chicken.",
+      );
+    });
+
+    it("throws if no backend is found", async () => {
+      listBackendsStub.resolves({
+        backends: allBackends,
+      });
+
+      await expect(chooseBackends(projectId, "farmer", /* prompt= */ "")).to.be.rejectedWith(
+        'No backend named "farmer" found.',
+      );
+    });
+
+    it("lets user choose backends when more than one share a name", async () => {
+      listBackendsStub.resolves({
+        backends: allBackends,
+      });
+      promptOnceStub.resolves(["chicken(asia-east1)", "chicken(europe-west4)"]);
+
+      await expect(chooseBackends(projectId, "chicken", /* prompt= */ "")).to.eventually.deep.equal(
+        [backendChickenAsia, backendChickenEurope],
+      );
+    });
+  });
+
   describe("getBackendForAmbiguousLocation", () => {
     const backendFoo = {
       name: `projects/${projectId}/locations/${location}/backends/foo`,
@@ -327,4 +408,57 @@ describe("apphosting setup functions", () => {
       });
     });
   });
+
+  describe("getBackend", () => {
+    const backendChickenAsia = {
+      name: `projects/${projectId}/locations/asia-east1/backends/chicken`,
+      labels: {},
+      createTime: "0",
+      updateTime: "1",
+      uri: "https://placeholder.com",
+    };
+
+    const backendChickenEurope = {
+      name: `projects/${projectId}/locations/europe-west4/backends/chicken`,
+      labels: {},
+      createTime: "0",
+      updateTime: "1",
+      uri: "https://placeholder.com",
+    };
+
+    const backendCow = {
+      name: `projects/${projectId}/locations/us-central1/backends/cow`,
+      labels: {},
+      createTime: "0",
+      updateTime: "1",
+      uri: "https://placeholder.com",
+    };
+
+    const allBackends = [backendChickenAsia, backendChickenEurope, backendCow];
+
+    it("throws if more than one backend is found", async () => {
+      listBackendsStub.resolves({ backends: allBackends });
+
+      await expect(getBackend(projectId, "chicken")).to.be.rejectedWith(
+        "You have multiple backends with the same chicken ID in regions: " +
+          "asia-east1, europe-west4. " +
+          "This is not allowed until we can support more locations. " +
+          "Please delete and recreate any backends that share an ID with another backend.",
+      );
+    });
+
+    it("throws if no backend is found", async () => {
+      listBackendsStub.resolves({ backends: allBackends });
+
+      await expect(getBackend(projectId, "farmer")).to.be.rejectedWith(
+        "No backend named farmer found.",
+      );
+    });
+
+    it("returns backend", async () => {
+      listBackendsStub.resolves({ backends: allBackends });
+
+      await expect(getBackend(projectId, "cow")).to.eventually.equal(backendCow);
+    });
+  });
 });

src/apphosting/backend.spec.ts

@@ -73,7 +73,6 @@ async function awaitTlsReady(url: string): Promise<void> {
 export async function doSetup(
   projectId: string,
   webAppName: string | null,
-  location: string | null,
   serviceAccount: string | null,
 ): Promise<void> {
   await Promise.all([
@@ -89,17 +88,13 @@ export async function doSetup(
   // possible to reduce the likelihood that the subsequent Cloud Build fails. See b/336862200.
   await ensureAppHostingComputeServiceAccount(projectId, serviceAccount);
 
-  const allowedLocations = (await apphosting.listLocations(projectId)).map((loc) => loc.locationId);
-  if (location) {
-    if (!allowedLocations.includes(location)) {
-      throw new FirebaseError(
-        `Invalid location ${location}. Valid choices are ${allowedLocations.join(", ")}`,
-      );
-    }
-  }
-
-  location =
-    location || (await promptLocation(projectId, "Select a location to host your backend:\n"));
+  // TODO(https://github.com/firebase/firebase-tools/issues/8283): The "primary region"
+  // is still "locations" in the V1 API. This will change in the V2 API and we may need to update
+  // the variables and API methods we're calling under the hood when fetching "primary region".
+  const location = await promptLocation(
+    projectId,
+    "Select a primary region to host your backend:\n",
+  );
 
   const gitRepositoryLink: GitRepositoryLink = await githubConnections.linkGitHubRepository(
     projectId,
@@ -429,6 +424,64 @@ export async function getBackendForLocation(
   }
 }
 
+/**
+ * Fetches backends of the given backendId and lets the user choose if more than one is found.
+ */
+export async function chooseBackends(
+  projectId: string,
+  backendId: string,
+  chooseBackendPrompt: string,
+  force?: boolean,
+): Promise<apphosting.Backend[]> {
+  let { unreachable, backends } = await apphosting.listBackends(projectId, "-");
+  if (unreachable && unreachable.length !== 0) {
+    logWarning(
+      `The following locations are currently unreachable: ${unreachable.join(",")}.\n` +
+        "If your backend is in one of these regions, please try again later.",
+    );
+  }
+  backends = backends.filter(
+    (backend) => apphosting.parseBackendName(backend.name).id === backendId,
+  );
+  if (backends.length === 0) {
+    throw new FirebaseError(`No backend named "${backendId}" found.`);
+  }
+  if (backends.length === 1) {
+    return backends;
+  }
+
+  if (force) {
+    throw new FirebaseError(
+      `Force cannot be used because multiple backends were found with ID ${backendId}.`,
+    );
+  }
+  const backendsByDisplay = new Map<string, apphosting.Backend>();
+  backends.forEach((backend) => {
+    const { location, id } = apphosting.parseBackendName(backend.name);
+    backendsByDisplay.set(`${id}(${location})`, backend);
+  });
+  const chosenBackendDisplays = await promptOnce({
+    name: "backend",
+    type: "checkbox",
+    message: chooseBackendPrompt,
+    choices: Array.from(backendsByDisplay.keys(), (name) => {
+      return {
+        checked: false,
+        name: name,
+        value: name,
+      };
+    }),
+  });
+  const chosenBackends: apphosting.Backend[] = [];
+  chosenBackendDisplays.forEach((backendDisplay) => {
+    const backend = backendsByDisplay.get(backendDisplay);
+    if (backend !== undefined) {
+      chosenBackends.push(backend);
+    }
+  });
+  return chosenBackends;
+}
+
 /**
  * Fetches a backend from the server. If there are multiple backends with that name (ie multi-regional backends),
  * prompts the user to disambiguate. If the force option is specified and multiple backends have the same name,
@@ -443,7 +496,7 @@ export async function getBackendForAmbiguousLocation(
   let { unreachable, backends } = await apphosting.listBackends(projectId, "-");
   if (unreachable && unreachable.length !== 0) {
     logWarning(
-      `The following locations are currently unreachable: ${unreachable}.\n` +
+      `The following locations are currently unreachable: ${unreachable.join(", ")}.\n` +
         "If your backend is in one of these regions, please try again later.",
     );
   }
@@ -474,3 +527,34 @@ export async function getBackendForAmbiguousLocation(
   });
   return backendsByLocation.get(location)!;
 }
+
+/**
+ * Fetches a backend from the server. If there are multiple backends with the name, it will throw an error
+ * telling the user that there are other backends with the same name that need to be deleted.
+ */
+export async function getBackend(
+  projectId: string,
+  backendId: string,
+): Promise<apphosting.Backend> {
+  let { unreachable, backends } = await apphosting.listBackends(projectId, "-");
+  backends = backends.filter(
+    (backend) => apphosting.parseBackendName(backend.name).id === backendId,
+  );
+  if (backends.length > 1) {
+    const locations = backends.map((b) => apphosting.parseBackendName(b.name).location);
+    throw new FirebaseError(
+      `You have multiple backends with the same ${backendId} ID in regions: ${locations.join(", ")}. This is not allowed until we can support more locations. ` +
+        "Please delete and recreate any backends that share an ID with another backend.",
+    );
+  }
+  if (backends.length === 1) {
+    return backends[0];
+  }
+  if (unreachable && unreachable.length !== 0) {
+    logWarning(
+      `Backends with the following primary regions are unreachable: ${unreachable.join(", ")}.\n` +
+        "If your backend is in one of these regions, please try again later.",
+    );
+  }
+  throw new FirebaseError(`No backend named ${backendId} found.`);
+}