Upgrades functions::list command to utilize Cloud Run API

CHANGELOG.md

@@ -1,2 +1,3 @@
+- Upgraded functions::list command to use cloud run api for v2 functions (#9425)
 - [Added] support for new google-genai plugin during `init genkit` (#8957)
 - Updated to v2.17.1 of the Data Connect emulator, which fixes an admin SDK bug for operation without argument #9449 (#9454).

src/commands/functions-list.ts

@@ -1,38 +1,65 @@
 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 endpoints: backend.Endpoint[] = [];
+    try {
+      const existing = await backend.existingBackend(context);
+      endpoints = backend.allEndpoints(existing);
+    } catch (err: any) {
+      logger.debug(`Failed to list functions:`, err);
+      logger.warn(
+        `Failed to list functions: ${err.message}. Ensure you have the Cloud Functions and Cloud Run APIs enabled and the necessary permissions.`,
+      );
+    }
+
+    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/args.ts

@@ -50,7 +50,6 @@ export interface Context {
   existingBackendPromise?: Promise<backend.Backend>;
   unreachableRegions?: {
     gcfV1: string[];
-    gcfV2: string[];
     run: string[];
   };
 

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";
 
@@ -54,7 +55,7 @@
     },
   };
   const GCF_URL = "https://region-project.cloudfunctions.net/id";
   const HAVE_CLOUD_FUNCTION_V2: gcfV2.OutputCloudFunction = {
     ...CLOUD_FUNCTION_V2,
     serviceConfig: {
       service: "service",
@@ -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();
     });
 
@@ -163,18 +167,14 @@
           ],
           unreachable: ["region"],
         });
-        listAllFunctionsV2.onFirstCall().resolves({
-          functions: [],
-          unreachable: [],
-        });
         const firstBackend = await backend.existingBackend(context);
 
         const secondBackend = await backend.existingBackend(context);
         await backend.checkAvailability(context, backend.empty());
 
         expect(firstBackend).to.deep.equal(secondBackend);
         expect(listAllFunctions).to.be.calledOnce;
-        expect(listAllFunctionsV2).to.be.calledOnce;
+        expect(listServices).to.be.calledOnce;
       });
 
       it("should translate functions", async () => {
@@ -187,10 +187,7 @@
           ],
           unreachable: [],
         });
-        listAllFunctionsV2.onFirstCall().resolves({
-          functions: [],
-          unreachable: [],
-        });
+        listServices.resolves([]);
         const have = await backend.existingBackend(newContext());
 
         expect(have).to.deep.equal(backend.of({ ...ENDPOINT, httpsTrigger: {} }));
@@ -201,7 +198,7 @@
           functions: [],
           unreachable: [],
         });
-        listAllFunctionsV2.throws(
+        listServices.throws(
           new FirebaseError("HTTP Error: 500, Internal Error", { status: 500 }),
         );
 
@@ -220,7 +217,7 @@
           ],
           unreachable: [],
         });
-        listAllFunctionsV2.throws(
+        listServices.throws(
           new FirebaseError("HTTP Error: 404, Method not found", { status: 404 }),
         );
 
@@ -267,24 +264,10 @@
           functions: [],
           unreachable: [],
         });
-        listAllFunctionsV2.onFirstCall().resolves({
-          functions: [HAVE_CLOUD_FUNCTION_V2],
-          unreachable: [],
-        });
+        listServices.onFirstCall().resolves([]);
         const have = await backend.existingBackend(newContext());
 
-        expect(have).to.deep.equal(
-          backend.of({
-            ...ENDPOINT,
-            platform: "gcfv2",
-            concurrency: 80,
-            cpu: 1,
-            httpsTrigger: {},
-            runServiceId: HAVE_CLOUD_FUNCTION_V2.serviceConfig?.service,
-            source: HAVE_CLOUD_FUNCTION_V2.buildConfig.source,
-            uri: HAVE_CLOUD_FUNCTION_V2.serviceConfig?.uri,
-          }),
-        );
+        expect(have).to.deep.equal(backend.empty());
       });
 
       it("should deduce features of scheduled functions", async () => {
@@ -303,10 +286,7 @@
           ],
           unreachable: [],
         });
-        listAllFunctionsV2.onFirstCall().resolves({
-          functions: [],
-          unreachable: [],
-        });
+        listServices.resolves([]);
         const have = await backend.existingBackend(newContext());
         const want = backend.of({
           ...ENDPOINT,
@@ -318,6 +298,19 @@
 
         expect(have).to.deep.equal(want);
       });
+
+      it("should list services with correct filter", async () => {
+        listAllFunctions.onFirstCall().resolves({
+          functions: [],
+          unreachable: [],
+        });
+        listServices.resolves([]);
+        const context = { projectId: "project" } as args.Context;
+
+        await backend.existingBackend(context);
+
+        expect(listServices).to.have.been.calledWith("project");
+      });
     });
 
     describe("checkAvailability", () => {
@@ -333,15 +326,12 @@
           functions: [],
           unreachable: [],
         });
-        listAllFunctionsV2.onFirstCall().resolves({
-          functions: [],
-          unreachable: [],
-        });
+        listServices.resolves([]);
 
         await backend.checkAvailability(newContext(), backend.empty());
 
         expect(listAllFunctions).to.have.been.called;
-        expect(listAllFunctionsV2).to.have.been.called;
+        expect(listServices).to.have.been.called;
         expect(logLabeledWarning).to.not.have.been.called;
       });
 
@@ -350,15 +340,12 @@
           functions: [],
           unreachable: ["region"],
         });
-        listAllFunctionsV2.resolves({
-          functions: [],
-          unreachable: [],
-        });
+        listServices.resolves([]);
 
         await backend.checkAvailability(newContext(), backend.empty());
 
         expect(listAllFunctions).to.have.been.called;
-        expect(listAllFunctionsV2).to.have.been.called;
+        expect(listServices).to.have.been.called;
         expect(logLabeledWarning).to.have.been.called;
       });
 
@@ -367,15 +354,20 @@
           functions: [],
           unreachable: [],
         });
-        listAllFunctionsV2.onFirstCall().resolves({
-          functions: [],
-          unreachable: ["region"],
-        });
+        listServices.onFirstCall().resolves([]);
+        // Simulate unreachable run/v2 regions by manually setting context
+        const context = newContext();
 
-        await backend.checkAvailability(newContext(), backend.empty());
+        await backend.existingBackend(context);
+
+        // Manually set the run region as unreachable to test the warning
+        if (!context.unreachableRegions) {
+          context.unreachableRegions = { gcfV1: [], run: [] };
+        }
+        context.unreachableRegions.run = ["region"];
+
+        await backend.checkAvailability(context, backend.empty());
 
-        expect(listAllFunctions).to.have.been.called;
-        expect(listAllFunctionsV2).to.have.been.called;
         expect(logLabeledWarning).to.have.been.called;
       });
 
@@ -384,10 +376,7 @@
           functions: [],
           unreachable: ["region"],
         });
-        listAllFunctionsV2.resolves({
-          functions: [],
-          unreachable: [],
-        });
+        listServices.resolves([]);
         const want = backend.of({ ...ENDPOINT, httpsTrigger: {} });
         await expect(backend.checkAvailability(newContext(), want)).to.eventually.be.rejectedWith(
           FirebaseError,
@@ -400,17 +389,22 @@
           functions: [],
           unreachable: [],
         });
-        listAllFunctionsV2.onFirstCall().resolves({
-          functions: [],
-          unreachable: ["region"],
-        });
+        listServices.onFirstCall().resolves([]);
         const want: backend.Backend = backend.of({
           ...ENDPOINT,
           platform: "gcfv2",
           httpsTrigger: {},
         });
 
-        await expect(backend.checkAvailability(newContext(), want)).to.eventually.be.rejectedWith(
+        // Manually set the run region as unreachable to simulate unavailability
+        const context = newContext();
+        await backend.existingBackend(context);
+        if (!context.unreachableRegions) {
+          context.unreachableRegions = { gcfV1: [], run: [] };
+        }
+        context.unreachableRegions.run = ["region"];
+
+        await expect(backend.checkAvailability(context, want)).to.eventually.be.rejectedWith(
           FirebaseError,
           /The following Cloud Functions V2 regions are currently unreachable:/,
         );
@@ -421,16 +415,20 @@
           functions: [],
           unreachable: [],
         });
-        listAllFunctionsV2.onFirstCall().resolves({
-          functions: [],
-          unreachable: ["us-central1"],
-        });
+        listServices.resolves([]);
 
         const want = backend.of({ ...ENDPOINT, httpsTrigger: {} });
-        await backend.checkAvailability(newContext(), want);
+        const context = newContext();
+        await backend.existingBackend(context);
+        if (!context.unreachableRegions) {
+          context.unreachableRegions = { gcfV1: [], run: [] };
+        }
+        context.unreachableRegions.run = ["us-central1"];
+
+        await backend.checkAvailability(context, want);
 
         expect(listAllFunctions).to.have.been.called;
-        expect(listAllFunctionsV2).to.have.been.called;
+        expect(listServices).to.have.been.called;
         expect(logLabeledWarning).to.have.been.called;
       });
 
@@ -439,16 +437,13 @@
           functions: [],
           unreachable: ["us-central1"],
         });
-        listAllFunctionsV2.onFirstCall().resolves({
-          functions: [],
-          unreachable: [],
-        });
+        listServices.resolves([]);
 
         const want: backend.Backend = backend.of({ ...ENDPOINT, httpsTrigger: {} });
         await backend.checkAvailability(newContext(), want);
 
         expect(listAllFunctions).to.have.been.called;
-        expect(listAllFunctionsV2).to.have.been.called;
+        expect(listServices).to.have.been.called;
         expect(logLabeledWarning).to.have.been.called;
       });
     });