fix: refactor prefix processing at one level higher.

Author: taeold

src/deploy/functions/build.spec.ts

@@ -224,27 +224,6 @@ describe("toBackend", () => {
       expect(endpointDef.func.serviceAccount).to.equal("service-account-1@");
     }
   });
-
-  it("should apply the prefix to the function name", () => {
-    const desiredBuild: build.Build = build.of({
-      func: {
-        platform: "gcfv1",
-        region: ["us-central1"],
-        project: "project",
-        runtime: "nodejs16",
-        entryPoint: "func",
-        httpsTrigger: {},
-      },
-    });
-    const backend = build.toBackend(desiredBuild, {}, "my-prefix");
-    expect(Object.keys(backend.endpoints).length).to.equal(1);
-    const regionalEndpoints = Object.values(backend.endpoints)[0];
-    const endpoint = Object.values(regionalEndpoints)[0];
-    expect(endpoint).to.not.equal(undefined);
-    if (endpoint) {
-      expect(endpoint.id).to.equal("my-prefix-func");
-    }
-  });
 });
 
 describe("envWithType", () => {

src/deploy/functions/build.ts

@@ -287,7 +287,6 @@ interface ResolveBackendOpts {
   userEnvs: Record<string, string>;
   nonInteractive?: boolean;
   isEmulator?: boolean;
-  prefix?: string;
 }
 
 /**
@@ -317,7 +316,7 @@ export async function resolveBackend(
   }
   writeUserEnvs(toWrite, opts.userEnvOpt);
 
-  return { backend: toBackend(opts.build, paramValues, opts.prefix), envs: paramValues };
+  return { backend: toBackend(opts.build, paramValues), envs: paramValues };
 }
 
 // Exported for testing
@@ -447,7 +446,6 @@ class Resolver {
 export function toBackend(
   build: Build,
   paramValues: Record<string, params.ParamValue>,
-  prefix?: string,
 ): backend.Backend {
   const r = new Resolver(paramValues);
   const bkEndpoints: Array<backend.Endpoint> = [];
@@ -483,7 +481,7 @@ export function toBackend(
         throw new FirebaseError("platform can't be undefined");
       }
       const bkEndpoint: backend.Endpoint = {
-        id: prefix ? `${prefix}-${endpointId}` : endpointId,
+        id: endpointId,
         project: bdEndpoint.project,
         region: region,
         entryPoint: bdEndpoint.entryPoint,

src/deploy/functions/prepare.spec.ts

@@ -1,13 +1,18 @@
 import { expect } from "chai";
-
-import * as backend from "./backend";
+import * as sinon from "sinon";
+import * as build from "./build";
 import * as prepare from "./prepare";
+import * as runtimes from "./runtimes";
+import { RuntimeDelegate } from "./runtimes";
+import { RUNTIMES } from "./runtimes/supported";
+import { FirebaseError } from "../../error";
+import { Options } from "../../options";
+import { ValidatedConfig } from "../../functions/projectConfig";
+import * as backend from "./backend";
 import * as ensureApiEnabled from "../../ensureApiEnabled";
 import * as serviceusage from "../../gcp/serviceusage";
 import { BEFORE_CREATE_EVENT, BEFORE_SIGN_IN_EVENT } from "../../functions/events/v1";
-import * as sinon from "sinon";
 import * as prompt from "../../prompt";
-import { FirebaseError } from "../../error";
 
 describe("prepare", () => {
   const ENDPOINT_BASE: Omit<backend.Endpoint, "httpsTrigger"> = {
@@ -16,14 +21,68 @@ describe("prepare", () => {
     region: "region",
     project: "project",
     entryPoint: "entry",
-    runtime: "nodejs16",
+    runtime: "nodejs22",
   };
 
   const ENDPOINT: backend.Endpoint = {
     ...ENDPOINT_BASE,
     httpsTrigger: {},
   };
 
+  describe("loadCodebases", () => {
+    let sandbox: sinon.SinonSandbox;
+    let runtimeDelegateStub: RuntimeDelegate;
+    let discoverBuildStub: sinon.SinonStub;
+
+    beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      discoverBuildStub = sandbox.stub();
+      runtimeDelegateStub = {
+        language: "nodejs",
+        runtime: "nodejs22",
+        bin: "node",
+        validate: sandbox.stub().resolves(),
+        build: sandbox.stub().resolves(),
+        watch: sandbox.stub().resolves(() => Promise.resolve()),
+        discoverBuild: discoverBuildStub,
+      };
+      discoverBuildStub.resolves(
+        build.of({
+          test: {
+            platform: "gcfv2",
+            entryPoint: "test",
+            project: "project",
+            runtime: "nodejs22",
+            httpsTrigger: {},
+          },
+        }),
+      );
+      sandbox.stub(runtimes, "getRuntimeDelegate").resolves(runtimeDelegateStub);
+    });
+
+    afterEach(() => {
+      sandbox.restore();
+    });
+
+    it("should apply the prefix to the function name", async () => {
+      const config: ValidatedConfig = [
+        { source: "source", codebase: "codebase", prefix: "my-prefix", runtime: "nodejs22" },
+      ];
+      const options = {
+        config: {
+          path: (p: string) => p,
+        },
+        projectId: "project",
+      } as unknown as Options;
+      const firebaseConfig = { projectId: "project" };
+      const runtimeConfig = {};
+
+      const builds = await prepare.loadCodebases(config, options, firebaseConfig, runtimeConfig);
+
+      expect(Object.keys(builds.codebase.endpoints)).to.deep.equal(["my-prefix-test"]);
+    });
+  });
+
   describe("inferDetailsFromExisting", () => {
     it("merges env vars if .env is not used", () => {
       const oldE = {
@@ -304,7 +363,7 @@ describe("prepare", () => {
       region: "us-central1",
       project: "project",
       entryPoint: "entry",
-      runtime: "nodejs16",
+      runtime: "nodejs22",
       httpsTrigger: {},
     };
 
@@ -314,7 +373,7 @@ describe("prepare", () => {
       region: "us-central1",
       project: "project",
       entryPoint: "entry",
-      runtime: "nodejs16",
+      runtime: "nodejs22",
       callableTrigger: {
         genkitAction: "action",
       },
@@ -333,7 +392,7 @@ describe("prepare", () => {
       region: "us-central1",
       project: "project",
       entryPoint: "entry",
-      runtime: "nodejs16",
+      runtime: "nodejs22",
       callableTrigger: {
         genkitAction: "action",
       },

src/deploy/functions/prepare.ts

@@ -135,7 +135,6 @@ export async function prepare(
       userEnvs,
       nonInteractive: options.nonInteractive,
       isEmulator: false,
-      prefix: config.prefix,
     });
 
     let hasEnvsFromParams = false;
@@ -474,13 +473,21 @@ export async function loadCodebases(
       "functions",
       `Loading and analyzing source code for codebase ${codebase} to determine what to deploy`,
     );
-    wantBuilds[codebase] = await runtimeDelegate.discoverBuild(runtimeConfig, {
+    const build = await runtimeDelegate.discoverBuild(runtimeConfig, {
       ...firebaseEnvs,
       // Quota project is required when using GCP's Client-based APIs
       // Some GCP client SDKs, like Vertex AI, requires appropriate quota project setup
       // in order for .init() calls to succeed.
       GOOGLE_CLOUD_QUOTA_PROJECT: projectId,
     });
+    if (codebaseConfig.prefix) {
+      const newEndpoints: Record<string, build.Endpoint> = {};
+      for (const id of Object.keys(build.endpoints)) {
+        newEndpoints[`${codebaseConfig.prefix}-${id}`] = build.endpoints[id];
+      }
+      build.endpoints = newEndpoints;
+    }
+    wantBuilds[codebase] = build;
     wantBuilds[codebase].runtime = codebaseConfig.runtime;
   }
   return wantBuilds;

src/emulator/functionsEmulator.ts

@@ -564,14 +564,20 @@ export class FunctionsEmulator implements EmulatorInstance {
         );
         await this.loadDynamicExtensionBackends();
       }
+      if (emulatableBackend.prefix) {
+        const newEndpoints: Record<string, backend.Endpoint> = {};
+        for (const id of Object.keys(discoveredBuild.endpoints)) {
+          newEndpoints[`${emulatableBackend.prefix}-${id}`] = discoveredBuild.endpoints[id];
+        }
+        discoveredBuild.endpoints = newEndpoints;
+      }
       const resolution = await resolveBackend({
         build: discoveredBuild,
         firebaseConfig: JSON.parse(firebaseConfig),
         userEnvOpt,
         userEnvs,
         nonInteractive: false,
         isEmulator: true,
-        prefix: emulatableBackend.prefix,
       });
       const discoveredBackend = resolution.backend;
       const endpoints = backend.allEndpoints(discoveredBackend);