Upgrades functions::list command to utilize Cloud Run API

CHANGELOG.md

@@ -0,0 +1 @@
+- Upgraded functions::list command to use cloud run api (#9425)

src/commands/functions-list.ts

@@ -1,38 +1,72 @@
 import { Command } from "../command";
 import * as args from "../deploy/functions/args";
 import { needProjectId } from "../projectUtils";
-import { Options } from "../options";
 import { requirePermissions } from "../requirePermissions";
 import * as backend from "../deploy/functions/backend";
 import { logger } from "../logger";
 import * as Table from "cli-table3";
+import { Options } from "../options";
+import { FunctionsPlatform } from "../deploy/functions/backend";
+
+type PLATFORM_DISPLAY_NAME = "v1" | "v2" | "run";
+const PLATFORM_TO_DISPLAY_NAME: Record<FunctionsPlatform, PLATFORM_DISPLAY_NAME> = {
+  gcfv1: "v1",
+  gcfv2: "v2",
+  run: "run",
+};
 
 export const command = new Command("functions:list")
   .description("list all deployed functions in your Firebase project")
-  .before(requirePermissions, ["cloudfunctions.functions.list"])
+  .before(requirePermissions, ["cloudfunctions.functions.list", "run.services.list"])
   .action(async (options: Options) => {
+    const projectId = needProjectId(options);
     const context = {
-      projectId: needProjectId(options),
+      projectId,
     } as args.Context;
-    const existing = await backend.existingBackend(context);
-    const endpointsList = backend.allEndpoints(existing).sort(backend.compareFunctions);
+
+    let v1Endpoints: backend.Endpoint[] = [];
+    try {
+      const existing = await backend.existingBackend(context);
+      v1Endpoints = backend.allEndpoints(existing);
+    } catch (err: any) {
+      logger.debug(`Failed to list v1 functions:`, err);
+      logger.warn(
+        `Failed to list v1 functions. Ensure you have the Cloud Functions API enabled and the necessary permissions.`,
+      );
+    }
+
+    const endpointMap = new Map<string, backend.Endpoint>();
+    for (const endpoint of v1Endpoints) {
+      const key = `${endpoint.region}/${endpoint.id}`;
+      endpointMap.set(key, endpoint);
+    }
+
+    const endpoints = Array.from(endpointMap.values());
+    endpoints.sort(backend.compareFunctions);
+
+    if (endpoints.length === 0) {
+      logger.info(`No functions found in project ${projectId}.`);
+      return [];
+    }
+
     const table = new Table({
       head: ["Function", "Version", "Trigger", "Location", "Memory", "Runtime"],
       style: { head: ["yellow"] },
-    });
-    for (const endpoint of endpointsList) {
+    }) as any;
+
+    for (const endpoint of endpoints) {
       const trigger = backend.endpointTriggerType(endpoint);
       const availableMemoryMb = endpoint.availableMemoryMb || "---";
       const entry = [
         endpoint.id,
-        endpoint.platform === "gcfv2" ? "v2" : "v1",
+        PLATFORM_TO_DISPLAY_NAME[endpoint.platform] || "v1",
         trigger,
         endpoint.region,
         availableMemoryMb,
         endpoint.runtime,
       ];
       table.push(entry);
     }
     logger.info(table.toString());
-    return endpointsList;
+    return endpoints;
   });

src/deploy/functions/backend.spec.ts

@@ -6,6 +6,7 @@
 import * as backend from "./backend";
 import * as gcf from "../../gcp/cloudfunctions";
 import * as gcfV2 from "../../gcp/cloudfunctionsv2";
+import * as runv2 from "../../gcp/runv2";
 import * as utils from "../../utils";
 import * as projectConfig from "../../functions/projectConfig";
 
@@ -126,17 +127,20 @@
   describe("existing backend", () => {
     let listAllFunctions: sinon.SinonStub;
     let listAllFunctionsV2: sinon.SinonStub;
+    let listServices: sinon.SinonStub;
     let logLabeledWarning: sinon.SinonSpy;
 
     beforeEach(() => {
       listAllFunctions = sinon.stub(gcf, "listAllFunctions").rejects("Unexpected call");
       listAllFunctionsV2 = sinon.stub(gcfV2, "listAllFunctions").rejects("Unexpected v2 call");
+      listServices = sinon.stub(runv2, "listServices").resolves([]);
       logLabeledWarning = sinon.spy(utils, "logLabeledWarning");
     });
 
     afterEach(() => {
       listAllFunctions.restore();
       listAllFunctionsV2.restore();
+      listServices.restore();
       logLabeledWarning.restore();
     });
 
@@ -318,6 +322,21 @@
 
         expect(have).to.deep.equal(want);
       });
+
+      it("should list services with correct filter", async () => {
+        listAllFunctions.onFirstCall().resolves({
+          functions: [],
+          unreachable: [],
+        });
+        listAllFunctionsV2.onFirstCall().resolves({
+          functions: [],
+          unreachable: [],
+        });
+
+        await backend.existingBackend(newContext());
+
+        expect(listServices).to.have.been.calledWith(sinon.match.any, "goog-managed-by=cloudfunctions");
+      });
     });
 
     describe("checkAvailability", () => {

src/deploy/functions/backend.ts

@@ -1,5 +1,6 @@
 import * as gcf from "../../gcp/cloudfunctions";
 import * as gcfV2 from "../../gcp/cloudfunctionsv2";
+import { listServices, endpointFromService } from "../../gcp/runv2";
 import * as utils from "../../utils";
 import { Runtime } from "./runtimes/supported";
 import { FirebaseError } from "../../error";
@@ -551,14 +552,29 @@
       existingBackend.endpoints[endpoint.region][endpoint.id] = endpoint;
     }
     unreachableRegions.gcfV2 = gcfV2Results.unreachable;
   } catch (err: any) {
     if (err.status === 404 && err.message?.toLowerCase().includes("method not found")) {
       // customer has preview enabled without allowlist set
     } else {
       throw err;
     }
   }
 
+  try {
+    const runServices = await listServices(ctx.projectId, "goog-managed-by=cloudfunctions");
+    for (const service of runServices) {
+      const endpoint = endpointFromService(service);
+      existingBackend.endpoints[endpoint.region] = existingBackend.endpoints[endpoint.region] || {};
+      existingBackend.endpoints[endpoint.region][endpoint.id] = endpoint;
+    }
+  } catch (err: any) {
+    utils.logLabeledWarning(
+      "functions",
+      `Failed to list Cloud Run services: ${err.message}. Ensure you have the Cloud Run Admin API enabled and the necessary permissions.`,
+    );
+    unreachableRegions.run = ["unknown"]; // Indicate that Run services could not be listed
+  }
+
   ctx.existingBackend = existingBackend;
   ctx.unreachableRegions = unreachableRegions;
   return ctx.existingBackend;

src/gcp/runv2.spec.ts

@@ -1,9 +1,12 @@
 import { expect } from "chai";
+import * as sinon from "sinon";
 
 import * as runv2 from "./runv2";
 import * as backend from "../deploy/functions/backend";
 import { latest } from "../deploy/functions/runtimes/supported";
 import { CODEBASE_LABEL } from "../functions/constants";
+import { Client } from "../apiv2";
+import { FirebaseError } from "../error";
 
 describe("runv2", () => {
   const PROJECT_ID = "project-id";
@@ -201,13 +204,11 @@ describe("runv2", () => {
       const service: Omit<runv2.Service, runv2.ServiceOutputFields> = {
         ...BASE_RUN_SERVICE,
         name: `projects/${PROJECT_ID}/locations/${LOCATION}/services/${SERVICE_ID}`,
-        labels: {
-          [runv2.RUNTIME_LABEL]: latest("nodejs"),
-        },
         annotations: {
           ...BASE_RUN_SERVICE.annotations,
           [runv2.FUNCTION_ID_ANNOTATION]: FUNCTION_ID, // Using FUNCTION_ID_ANNOTATION as primary source for id
           [runv2.FUNCTION_TARGET_ANNOTATION]: "customEntryPoint",
+          [runv2.TRIGGER_TYPE_ANNOTATION]: "HTTP_TRIGGER",
         },
         template: {
           containers: [
@@ -239,6 +240,7 @@ describe("runv2", () => {
         httpsTrigger: {},
         labels: {
           [runv2.RUNTIME_LABEL]: latest("nodejs"),
+          [runv2.CLIENT_NAME_LABEL]: "firebase-functions",
         },
         environmentVariables: {},
         secretEnvironmentVariables: [],
@@ -259,6 +261,7 @@ describe("runv2", () => {
           ...BASE_RUN_SERVICE.annotations,
           [runv2.FUNCTION_ID_ANNOTATION]: FUNCTION_ID, // Using FUNCTION_ID_ANNOTATION as primary source for id
           [runv2.FUNCTION_TARGET_ANNOTATION]: "customEntryPoint",
+          [runv2.TRIGGER_TYPE_ANNOTATION]: "HTTP_TRIGGER",
         },
         template: {
           containers: [
@@ -442,7 +445,7 @@ describe("runv2", () => {
         entryPoint: SERVICE_ID, // No FUNCTION_TARGET_ANNOTATION
         availableMemoryMb: 128,
         cpu: 0.5,
-        httpsTrigger: {},
+        eventTrigger: { eventType: "unknown", retry: false },
         labels: {},
         environmentVariables: {},
         secretEnvironmentVariables: [],
@@ -452,4 +455,78 @@ describe("runv2", () => {
       expect(runv2.endpointFromService(service)).to.deep.equal(expectedEndpoint);
     });
   });
+
+  describe("listServices", () => {
+    let sandbox: sinon.SinonSandbox;
+    let getStub: sinon.SinonStub;
+
+    beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      getStub = sandbox.stub(Client.prototype, "get");
+    });
+
+    afterEach(() => {
+      sandbox.restore();
+    });
+
+    it("should return a list of services", async () => {
+      const mockServices = [{ name: "service1" }, { name: "service2" }];
+      getStub.resolves({ status: 200, body: { services: mockServices } });
+
+      const services = await runv2.listServices(PROJECT_ID);
+
+      expect(services).to.deep.equal(mockServices);
+      expect(getStub).to.have.been.calledOnceWithExactly(
+        `/projects/${PROJECT_ID}/locations/-/services`,
+        { queryParams: {} },
+      );
+    });
+
+    it("should handle pagination", async () => {
+      const mockServices1 = [{ name: "service1" }];
+      const mockServices2 = [{ name: "service2" }];
+      getStub
+        .onFirstCall()
+        .resolves({ status: 200, body: { services: mockServices1, nextPageToken: "nextPage" } });
+      getStub.onSecondCall().resolves({ status: 200, body: { services: mockServices2 } });
+
+      const services = await runv2.listServices(PROJECT_ID);
+
+      expect(services).to.deep.equal([...mockServices1, ...mockServices2]);
+      expect(getStub).to.have.been.calledTwice;
+      expect(getStub.firstCall).to.have.been.calledWithExactly(
+        `/projects/${PROJECT_ID}/locations/-/services`,
+        { queryParams: {} },
+      );
+      expect(getStub.secondCall).to.have.been.calledWithExactly(
+        `/projects/${PROJECT_ID}/locations/-/services`,
+        { queryParams: { pageToken: "nextPage" } },
+      );
+    });
+
+    it("should throw an error if the API call fails", async () => {
+      getStub.resolves({ status: 500, body: "Internal Server Error" });
+
+      try {
+        await runv2.listServices(PROJECT_ID);
+        expect.fail("Should have thrown an error");
+      } catch (err: any) {
+        expect(err).to.be.instanceOf(FirebaseError);
+        expect(err.message).to.contain('Failed to list services: 500 "Internal Server Error"');
+      }
+    });
+
+    it("should filter by labelSelector", async () => {
+      const mockServices = [{ name: "service1" }];
+      getStub.resolves({ status: 200, body: { services: mockServices } });
+
+      const services = await runv2.listServices(PROJECT_ID, "foo=bar");
+
+      expect(services).to.deep.equal(mockServices);
+      expect(getStub).to.have.been.calledOnceWithExactly(
+        `/projects/${PROJECT_ID}/locations/-/services`,
+        { queryParams: { filter: 'labels."foo"="bar"' } },
+      );
+    });
+  });
 });

src/gcp/runv2.ts

@@ -200,6 +200,38 @@ export async function updateService(service: Omit<Service, ServiceOutputFields>)
   return svc;
 }
 
+export async function listServices(projectId: string, filter?: string): Promise<Service[]> {
+  const allServices: Service[] = [];
+  let pageToken: string | undefined = undefined;
+
+  do {
+    const queryParams: Record<string, string> = {};
+    if (pageToken) {
+      queryParams["pageToken"] = pageToken;
+    }
+    if (filter) {
+      const parts = filter.split("=");
+      queryParams["filter"] = `labels."${parts[0]}"="${parts[1]}"`;
+    }
+
+    const res = await client.get<{ services?: Service[]; nextPageToken?: string }>(
+      `/projects/${projectId}/locations/-/services`,
+      { queryParams },
+    );
+
+    if (res.status !== 200) {
+      throw new FirebaseError(`Failed to list services: ${res.status} ${JSON.stringify(res.body)}`);
+    }
+
+    if (res.body.services) {
+      allServices.push(...res.body.services);
+    }
+    pageToken = res.body.nextPageToken;
+  } while (pageToken);
+
+  return allServices;
+}
+
 // TODO: Replace with real version:
 function functionNameToServiceName(id: string): string {
   return id.toLowerCase().replace(/_/g, "-");
@@ -487,9 +519,14 @@ export function endpointFromService(service: Omit<Service, ServiceOutputFields>)
       service.annotations?.[FUNCTION_TARGET_ANNOTATION] ||
       service.annotations?.[FUNCTION_ID_ANNOTATION] ||
       id,
-
-    // TODO: trigger types.
-    httpsTrigger: {},
+    ...(service.annotations?.[TRIGGER_TYPE_ANNOTATION] === "HTTP_TRIGGER"
+      ? { httpsTrigger: {} }
+      : {
+          eventTrigger: {
+            eventType: service.annotations?.[TRIGGER_TYPE_ANNOTATION] || "unknown",
+            retry: false,
+          },
+        }),
   };
   proto.renameIfPresent(endpoint, service.template, "concurrency", "containerConcurrency");
   proto.renameIfPresent(endpoint, service.labels || {}, "codebase", CODEBASE_LABEL);