firebase-tools 10.7.0 → 10.7.1

package/lib/commands/functions-delete.js

@@ -40,7 +40,13 @@ exports.default = new command_1.Command("functions:delete [filters...]")
     if (options.region) {
         existingBackend.endpoints = { [options.region]: existingBackend.endpoints[options.region] };
     }
-    const plan = planner.createDeploymentPlan(backend.empty(), existingBackend, context.filters, true);
+    const plan = planner.createDeploymentPlan({
+        wantBackend: backend.empty(),
+        haveBackend: existingBackend,
+        codebase: "",
+        filters: context.filters,
+        deleteAll: true,
+    });
     const allEpToDelete = Object.values(plan)
         .map((changes) => changes.endpointsToDelete)
         .reduce(functional_1.reduceFlat, [])
@@ -69,8 +75,9 @@ exports.default = new command_1.Command("functions:delete [filters...]")
     try {
         const fab = new fabricator.Fabricator({
             functionExecutor,
-            executor: new executor.QueueExecutor({}),
             appEngineLocation,
+            executor: new executor.QueueExecutor({}),
+            sources: {},
         });
         const summary = await fab.applyPlan(plan);
         await reporter.logAndTrackDeployStats(summary);

package/lib/deploy/functions/backend.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compareFunctions = exports.missingEndpoint = exports.hasEndpoint = exports.regionalEndpoints = exports.matchingBackend = exports.findEndpoint = exports.someEndpoint = exports.allEndpoints = exports.checkAvailability = exports.existingBackend = exports.scheduleIdForFunction = exports.functionName = exports.isEmptyBackend = exports.of = exports.empty = exports.isBlockingTriggered = exports.isTaskQueueTriggered = exports.isScheduleTriggered = exports.isEventTriggered = exports.isCallableTriggered = exports.isHttpsTriggered = exports.AllFunctionsPlatforms = exports.secretVersionName = exports.SCHEDULED_FUNCTION_LABEL = exports.MIN_MEMORY_FOR_CONCURRENCY = exports.DEFAULT_MEMORY = exports.memoryOptionDisplayName = exports.AllMemoryOptions = exports.AllIngressSettings = exports.AllVpcEgressSettings = exports.endpointTriggerType = void 0;
+exports.compareFunctions = exports.missingEndpoint = exports.hasEndpoint = exports.regionalEndpoints = exports.matchingBackend = exports.findEndpoint = exports.someEndpoint = exports.allEndpoints = exports.checkAvailability = exports.existingBackend = exports.scheduleIdForFunction = exports.functionName = exports.isEmptyBackend = exports.merge = exports.of = exports.empty = exports.isBlockingTriggered = exports.isTaskQueueTriggered = exports.isScheduleTriggered = exports.isEventTriggered = exports.isCallableTriggered = exports.isHttpsTriggered = exports.AllFunctionsPlatforms = exports.secretVersionName = exports.SCHEDULED_FUNCTION_LABEL = exports.MIN_MEMORY_FOR_CONCURRENCY = exports.DEFAULT_MEMORY = exports.memoryOptionDisplayName = exports.AllMemoryOptions = exports.AllIngressSettings = exports.AllVpcEgressSettings = exports.endpointTriggerType = void 0;
 const gcf = require("../../gcp/cloudfunctions");
 const gcfV2 = require("../../gcp/cloudfunctionsv2");
 const utils = require("../../utils");
 const error_1 = require("../../error");
 const previews_1 = require("../../previews");
+const functional_1 = require("../../functional");
 function endpointTriggerType(endpoint) {
     if (isScheduleTriggered(endpoint)) {
         return "scheduled";
@@ -102,6 +103,25 @@ function of(...endpoints) {
     return bkend;
 }
 exports.of = of;
+function merge(...backends) {
+    const merged = of(...(0, functional_1.flattenArray)(backends.map((b) => allEndpoints(b))));
+    const apiToReasons = {};
+    for (const b of backends) {
+        for (const { api, reason } of b.requiredAPIs) {
+            const reasons = apiToReasons[api] || new Set();
+            if (reason) {
+                reasons.add(reason);
+            }
+            apiToReasons[api] = reasons;
+        }
+        merged.environmentVariables = Object.assign(Object.assign({}, merged.environmentVariables), b.environmentVariables);
+    }
+    for (const [api, reasons] of Object.entries(apiToReasons)) {
+        merged.requiredAPIs.push({ api, reason: Array.from(reasons).join(" ") });
+    }
+    return merged;
+}
+exports.merge = merge;
 function isEmptyBackend(backend) {
     return (Object.keys(backend.requiredAPIs).length === 0 && Object.keys(backend.endpoints).length === 0);
 }

package/lib/deploy/functions/checkIam.js

@@ -5,6 +5,7 @@ const cli_color_1 = require("cli-color");
 const logger_1 = require("../../logger");
 const functionsDeployHelper_1 = require("./functionsDeployHelper");
 const error_1 = require("../../error");
+const functional_1 = require("../../functional");
 const iam = require("../../gcp/iam");
 const backend = require("./backend");
 const track_1 = require("../../track");
@@ -35,10 +36,12 @@ async function checkServiceAccountIam(projectId) {
 }
 exports.checkServiceAccountIam = checkServiceAccountIam;
 async function checkHttpIam(context, options, payload) {
+    if (!payload.functions) {
+        return;
+    }
     const filters = context.filters || (0, functionsDeployHelper_1.getEndpointFilters)(options);
-    const wantBackend = payload.functions.wantBackend;
-    const httpEndpoints = backend
-        .allEndpoints(wantBackend)
+    const wantBackends = Object.values(payload.functions).map(({ wantBackend }) => wantBackend);
+    const httpEndpoints = [...(0, functional_1.flattenArray)(wantBackends.map((b) => backend.allEndpoints(b)))]
         .filter(backend.isHttpsTriggered)
         .filter((f) => (0, functionsDeployHelper_1.endpointMatchesAnyFilter)(f, filters));
     const existing = await backend.existingBackend(context);

package/lib/deploy/functions/deploy.js

@@ -6,54 +6,62 @@ const clc = require("cli-color");
 const fs = require("fs");
 const checkIam_1 = require("./checkIam");
 const utils_1 = require("../../utils");
+const projectConfig_1 = require("../../functions/projectConfig");
 const gcs = require("../../gcp/storage");
 const gcf = require("../../gcp/cloudfunctions");
 const gcfv2 = require("../../gcp/cloudfunctionsv2");
 const backend = require("./backend");
 (0, tmp_1.setGracefulCleanup)();
-async function uploadSourceV1(context, region) {
-    const uploadUrl = await gcf.generateUploadUrl(context.projectId, region);
-    context.source.sourceUrl = uploadUrl;
+async function uploadSourceV1(projectId, source, wantBackend) {
+    const v1Endpoints = backend.allEndpoints(wantBackend).filter((e) => e.platform === "gcfv1");
+    if (v1Endpoints.length === 0) {
+        return;
+    }
+    const region = v1Endpoints[0].region;
+    const uploadUrl = await gcf.generateUploadUrl(projectId, region);
     const uploadOpts = {
-        file: context.source.functionsSourceV1,
-        stream: fs.createReadStream(context.source.functionsSourceV1),
+        file: source.functionsSourceV1,
+        stream: fs.createReadStream(source.functionsSourceV1),
     };
     await gcs.upload(uploadOpts, uploadUrl, {
         "x-goog-content-length-range": "0,104857600",
     });
+    return uploadUrl;
 }
-async function uploadSourceV2(context, region) {
-    const res = await gcfv2.generateUploadUrl(context.projectId, region);
+async function uploadSourceV2(projectId, source, wantBackend) {
+    const v2Endpoints = backend.allEndpoints(wantBackend).filter((e) => e.platform === "gcfv2");
+    if (v2Endpoints.length === 0) {
+        return;
+    }
+    const region = v2Endpoints[0].region;
+    const res = await gcfv2.generateUploadUrl(projectId, region);
     const uploadOpts = {
-        file: context.source.functionsSourceV2,
-        stream: fs.createReadStream(context.source.functionsSourceV2),
+        file: source.functionsSourceV2,
+        stream: fs.createReadStream(source.functionsSourceV2),
     };
     await gcs.upload(uploadOpts, res.uploadUrl);
-    context.source.storage = res.storageSource;
+    return res.storageSource;
 }
-async function deploy(context, options, payload) {
-    var _a, _b, _c, _d;
-    if (!context.config) {
-        return;
-    }
-    if (!((_a = context.source) === null || _a === void 0 ? void 0 : _a.functionsSourceV1) && !((_b = context.source) === null || _b === void 0 ? void 0 : _b.functionsSourceV2)) {
+async function uploadCodebase(context, codebase, wantBackend) {
+    var _a;
+    const source = (_a = context.sources) === null || _a === void 0 ? void 0 : _a[codebase];
+    if (!source || (!source.functionsSourceV1 && !source.functionsSourceV2)) {
         return;
     }
-    await (0, checkIam_1.checkHttpIam)(context, options, payload);
+    const uploads = [];
     try {
-        const want = payload.functions.wantBackend;
-        const uploads = [];
-        const byPlatform = (0, utils_1.groupBy)(backend.allEndpoints(want), (e) => e.platform);
-        if (((_c = byPlatform.gcfv1) === null || _c === void 0 ? void 0 : _c.length) > 0) {
-            uploads.push(uploadSourceV1(context, byPlatform.gcfv1[0].region));
+        uploads.push(uploadSourceV1(context.projectId, source, wantBackend));
+        uploads.push(uploadSourceV2(context.projectId, source, wantBackend));
+        const [sourceUrl, storage] = await Promise.all(uploads);
+        if (sourceUrl) {
+            source.sourceUrl = sourceUrl;
         }
-        if (((_d = byPlatform.gcfv2) === null || _d === void 0 ? void 0 : _d.length) > 0) {
-            uploads.push(uploadSourceV2(context, byPlatform.gcfv2[0].region));
+        if (storage) {
+            source.storage = storage;
         }
-        await Promise.all(uploads);
-        const source = context.config.source;
+        const sourceDir = (0, projectConfig_1.configForCodebase)(context.config, codebase).source;
         if (uploads.length) {
-            (0, utils_1.logSuccess)(`${clc.green.bold("functions:")} ${clc.bold(source)} folder uploaded successfully`);
+            (0, utils_1.logSuccess)(`${clc.green.bold("functions:")} ${clc.bold(sourceDir)} folder uploaded successfully`);
         }
     }
     catch (err) {
@@ -61,4 +69,18 @@ async function deploy(context, options, payload) {
         throw err;
     }
 }
+async function deploy(context, options, payload) {
+    if (!context.config) {
+        return;
+    }
+    if (!payload.functions) {
+        return;
+    }
+    await (0, checkIam_1.checkHttpIam)(context, options, payload);
+    const uploads = [];
+    for (const [codebase, { wantBackend }] of Object.entries(payload.functions)) {
+        uploads.push(uploadCodebase(context, codebase, wantBackend));
+    }
+    await Promise.all(uploads);
+}
 exports.deploy = deploy;

package/lib/deploy/functions/functionsDeployHelper.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFunctionLabel = exports.getEndpointFilters = exports.parseFunctionSelector = exports.endpointMatchesFilter = exports.endpointMatchesAnyFilter = void 0;
-const projectConfig = require("../../functions/projectConfig");
+exports.groupEndpointsByCodebase = exports.targetCodebases = exports.getFunctionLabel = exports.getEndpointFilters = exports.parseFunctionSelector = exports.endpointMatchesFilter = exports.endpointMatchesAnyFilter = void 0;
+const backend = require("./backend");
+const projectConfig_1 = require("../../functions/projectConfig");
 function endpointMatchesAnyFilter(endpoint, filters) {
     if (!filters) {
         return true;
@@ -35,7 +36,7 @@ function parseFunctionSelector(selector) {
     if (fragments.length < 2) {
         return [
             { codebase: fragments[0] },
-            { codebase: projectConfig.DEFAULT_CODEBASE, idChunks: fragments[0].split(/[-.]/) },
+            { codebase: projectConfig_1.DEFAULT_CODEBASE, idChunks: fragments[0].split(/[-.]/) },
         ];
     }
     return [
@@ -67,6 +68,49 @@ function getEndpointFilters(options) {
 }
 exports.getEndpointFilters = getEndpointFilters;
 function getFunctionLabel(fn) {
-    return `${fn.id}(${fn.region})`;
+    let id = `${fn.id}(${fn.region})`;
+    if (fn.codebase && fn.codebase !== projectConfig_1.DEFAULT_CODEBASE) {
+        id = `[${fn.codebase}]${id}`;
+    }
+    return id;
 }
 exports.getFunctionLabel = getFunctionLabel;
+function targetCodebases(config, filters) {
+    const codebasesFromConfig = [...new Set(Object.values(config).map((c) => c.codebase))];
+    if (!filters) {
+        return [...codebasesFromConfig];
+    }
+    const codebasesFromFilters = [
+        ...new Set(filters.map((f) => f.codebase).filter((c) => c !== undefined)),
+    ];
+    if (codebasesFromFilters.length === 0) {
+        return [...codebasesFromConfig];
+    }
+    const intersections = [];
+    for (const codebase of codebasesFromConfig) {
+        if (codebasesFromFilters.includes(codebase)) {
+            intersections.push(codebase);
+        }
+    }
+    return intersections;
+}
+exports.targetCodebases = targetCodebases;
+function groupEndpointsByCodebase(wantBackends, haveEndpoints) {
+    const grouped = {};
+    let endpointsToAssign = haveEndpoints;
+    for (const codebase of Object.keys(wantBackends)) {
+        const names = backend.allEndpoints(wantBackends[codebase]).map((e) => backend.functionName(e));
+        grouped[codebase] = backend.of(...endpointsToAssign.filter((e) => names.includes(backend.functionName(e))));
+        endpointsToAssign = endpointsToAssign.filter((e) => !names.includes(backend.functionName(e)));
+    }
+    for (const codebase of Object.keys(wantBackends)) {
+        const matchedEndpoints = endpointsToAssign.filter((e) => e.codebase === codebase);
+        grouped[codebase] = backend.merge(grouped[codebase], backend.of(...matchedEndpoints));
+        const matchedNames = matchedEndpoints.map((e) => backend.functionName(e));
+        endpointsToAssign = endpointsToAssign.filter((e) => {
+            return !matchedNames.includes(backend.functionName(e));
+        });
+    }
+    return grouped;
+}
+exports.groupEndpointsByCodebase = groupEndpointsByCodebase;

package/lib/deploy/functions/prepare.js

@@ -25,16 +25,13 @@ const v1_1 = require("../../functions/events/v1");
 function hasUserConfig(config) {
     return Object.keys(config).length > 1;
 }
-function hasDotenv(opts) {
-    return functionsEnv.hasUserEnvs(opts);
-}
 async function prepare(context, options, payload) {
     const projectId = (0, projectUtils_1.needProjectId)(options);
     const projectNumber = await (0, projectUtils_1.needProjectNumber)(options);
-    context.config = (0, projectConfig_1.normalizeAndValidate)(options.config.src.functions)[0];
+    context.config = (0, projectConfig_1.normalizeAndValidate)(options.config.src.functions);
     context.filters = (0, functionsDeployHelper_1.getEndpointFilters)(options);
-    if (context.filters &&
-        !context.filters.map((f) => f.codebase).includes(context.config.codebase)) {
+    const codebases = (0, functionsDeployHelper_1.targetCodebases)(context.config, context.filters);
+    if (codebases.length === 0) {
         throw new error_1.FirebaseError("No function matches given --only filters. Aborting deployment.");
     }
     const checkAPIsEnabled = await Promise.all([
@@ -50,79 +47,97 @@ async function prepare(context, options, payload) {
     if (checkAPIsEnabled[1]) {
         runtimeConfig = Object.assign(Object.assign({}, runtimeConfig), (await (0, prepareFunctionsUpload_1.getFunctionsConfig)(projectId)));
     }
-    (0, utils_1.logLabeledBullet)("functions", `preparing codebase ${clc.bold(context.config.codebase)} for deployment`);
-    const sourceDirName = context.config.source;
-    if (!sourceDirName) {
-        throw new error_1.FirebaseError(`No functions code detected at default location (./functions), and no functions source defined in firebase.json`);
+    context.sources = {};
+    const codebaseUsesEnvs = [];
+    const wantBackends = {};
+    for (const codebase of codebases) {
+        (0, utils_1.logLabeledBullet)("functions", `preparing codebase ${clc.bold(codebase)} for deployment`);
+        const config = (0, projectConfig_1.configForCodebase)(context.config, codebase);
+        const sourceDirName = config.source;
+        if (!sourceDirName) {
+            throw new error_1.FirebaseError(`No functions code detected at default location (./functions), and no functions source defined in firebase.json`);
+        }
+        const sourceDir = options.config.path(sourceDirName);
+        const delegateContext = {
+            projectId,
+            sourceDir,
+            projectDir: options.config.projectDir,
+            runtime: config.runtime || "",
+        };
+        const runtimeDelegate = await runtimes.getRuntimeDelegate(delegateContext);
+        logger_1.logger.debug(`Validating ${runtimeDelegate.name} source`);
+        await runtimeDelegate.validate();
+        logger_1.logger.debug(`Building ${runtimeDelegate.name} source`);
+        await runtimeDelegate.build();
+        const firebaseEnvs = functionsEnv.loadFirebaseEnvs(firebaseConfig, projectId);
+        const userEnvOpt = {
+            functionsSource: sourceDir,
+            projectId: projectId,
+            projectAlias: options.projectAlias,
+        };
+        const userEnvs = functionsEnv.loadUserEnvs(userEnvOpt);
+        logger_1.logger.debug(`Analyzing ${runtimeDelegate.name} backend spec`);
+        const wantBackend = await runtimeDelegate.discoverSpec(runtimeConfig, firebaseEnvs);
+        wantBackend.environmentVariables = Object.assign(Object.assign({}, userEnvs), firebaseEnvs);
+        for (const endpoint of backend.allEndpoints(wantBackend)) {
+            endpoint.environmentVariables = wantBackend.environmentVariables;
+            endpoint.codebase = codebase;
+        }
+        wantBackends[codebase] = wantBackend;
+        if (functionsEnv.hasUserEnvs(userEnvOpt)) {
+            codebaseUsesEnvs.push(codebase);
+        }
+    }
+    validate.endpointsAreUnique(wantBackends);
+    for (const [codebase, wantBackend] of Object.entries(wantBackends)) {
+        const config = (0, projectConfig_1.configForCodebase)(context.config, codebase);
+        const sourceDirName = config.source;
+        const sourceDir = options.config.path(sourceDirName);
+        const source = {};
+        if (backend.someEndpoint(wantBackend, () => true)) {
+            (0, utils_1.logLabeledBullet)("functions", `preparing ${clc.bold(sourceDirName)} directory for uploading...`);
+        }
+        if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv2")) {
+            if (!previews_1.previews.functionsv2) {
+                throw new error_1.FirebaseError("This version of firebase-tools does not support Google Cloud " +
+                    "Functions gen 2\n" +
+                    "If Cloud Functions for Firebase gen 2 is still in alpha, sign up " +
+                    "for the alpha program at " +
+                    "https://services.google.com/fb/forms/firebasealphaprogram/\n" +
+                    "If Cloud Functions for Firebase gen 2 is in beta, get the latest " +
+                    "version of Firebse Tools with `npm i -g firebase-tools@latest`");
+            }
+            source.functionsSourceV2 = await (0, prepareFunctionsUpload_1.prepareFunctionsUpload)(sourceDir, config);
+        }
+        if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv1")) {
+            source.functionsSourceV1 = await (0, prepareFunctionsUpload_1.prepareFunctionsUpload)(sourceDir, config, runtimeConfig);
+        }
+        context.sources[codebase] = source;
+    }
+    payload.functions = {};
+    const haveBackends = (0, functionsDeployHelper_1.groupEndpointsByCodebase)(wantBackends, backend.allEndpoints(await backend.existingBackend(context)));
+    for (const [codebase, wantBackend] of Object.entries(wantBackends)) {
+        const haveBackend = haveBackends[codebase] || Object.assign({}, backend.empty());
+        payload.functions[codebase] = { wantBackend, haveBackend };
+    }
+    for (const [codebase, { wantBackend, haveBackend }] of Object.entries(payload.functions)) {
+        inferDetailsFromExisting(wantBackend, haveBackend, codebaseUsesEnvs.includes(codebase));
+        await (0, triggerRegionHelper_1.ensureTriggerRegions)(wantBackend);
+        validate.endpointsAreValid(wantBackend);
+        inferBlockingDetails(wantBackend);
     }
-    const sourceDir = options.config.path(sourceDirName);
-    const delegateContext = {
-        projectId,
-        sourceDir,
-        projectDir: options.config.projectDir,
-        runtime: context.config.runtime || "",
-    };
-    const runtimeDelegate = await runtimes.getRuntimeDelegate(delegateContext);
-    logger_1.logger.debug(`Validating ${runtimeDelegate.name} source`);
-    await runtimeDelegate.validate();
-    logger_1.logger.debug(`Building ${runtimeDelegate.name} source`);
-    await runtimeDelegate.build();
-    const firebaseEnvs = functionsEnv.loadFirebaseEnvs(firebaseConfig, projectId);
-    const userEnvOpt = {
-        functionsSource: sourceDir,
-        projectId: projectId,
-        projectAlias: options.projectAlias,
-    };
-    const userEnvs = functionsEnv.loadUserEnvs(userEnvOpt);
-    const usedDotenv = hasDotenv(userEnvOpt);
     const tag = hasUserConfig(runtimeConfig)
-        ? usedDotenv
+        ? codebaseUsesEnvs.length > 0
             ? "mixed"
             : "runtime_config"
-        : usedDotenv
+        : codebaseUsesEnvs.length > 0
             ? "dotenv"
             : "none";
     void (0, track_1.track)("functions_codebase_deploy_env_method", tag);
-    logger_1.logger.debug(`Analyzing ${runtimeDelegate.name} backend spec`);
-    const wantBackend = await runtimeDelegate.discoverSpec(runtimeConfig, firebaseEnvs);
-    wantBackend.environmentVariables = Object.assign(Object.assign({}, userEnvs), firebaseEnvs);
-    for (const endpoint of backend.allEndpoints(wantBackend)) {
-        endpoint.environmentVariables = wantBackend.environmentVariables;
-        endpoint.codebase = context.config.codebase;
-    }
-    const source = {};
-    if (backend.someEndpoint(wantBackend, () => true)) {
-        (0, utils_1.logLabeledBullet)("functions", `preparing ${clc.bold(sourceDirName)} directory for uploading...`);
-    }
-    if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv2")) {
-        if (!previews_1.previews.functionsv2) {
-            throw new error_1.FirebaseError("This version of firebase-tools does not support Google Cloud " +
-                "Functions gen 2\n" +
-                "If Cloud Functions for Firebase gen 2 is still in alpha, sign up " +
-                "for the alpha program at " +
-                "https://services.google.com/fb/forms/firebasealphaprogram/\n" +
-                "If Cloud Functions for Firebase gen 2 is in beta, get the latest " +
-                "version of Firebse Tools with `npm i -g firebase-tools@latest`");
-        }
-        source.functionsSourceV2 = await (0, prepareFunctionsUpload_1.prepareFunctionsUpload)(sourceDir, context.config);
-    }
-    if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv1")) {
-        source.functionsSourceV1 = await (0, prepareFunctionsUpload_1.prepareFunctionsUpload)(sourceDir, context.config, runtimeConfig);
-    }
-    context.source = source;
-    const wantEndpointNames = backend.allEndpoints(wantBackend).map((e) => backend.functionName(e));
-    const haveBackend = backend.matchingBackend(await backend.existingBackend(context), (endpoint) => {
-        var _a;
-        if (endpoint.codebase === ((_a = context.config) === null || _a === void 0 ? void 0 : _a.codebase)) {
-            return true;
-        }
-        return wantEndpointNames.includes(backend.functionName(endpoint));
-    });
-    inferDetailsFromExisting(wantBackend, haveBackend, usedDotenv);
-    await (0, triggerRegionHelper_1.ensureTriggerRegions)(wantBackend);
-    validate.endpointsAreValid(wantBackend);
-    inferBlockingDetails(wantBackend);
-    payload.functions = { wantBackend: wantBackend, haveBackend: haveBackend };
+    const codebaseCnt = Object.keys(payload.functions).length;
+    void (0, track_1.track)("functions_codebase_deploy_count", codebaseCnt >= 5 ? "5+" : codebaseCnt.toString());
+    const wantBackend = backend.merge(...Object.values(wantBackends));
+    const haveBackend = backend.merge(...Object.values(haveBackends));
     await Promise.all(Object.values(wantBackend.requiredAPIs).map(({ api }) => {
         return ensureApiEnabled.ensure(projectId, api, "functions", false);
     }));

package/lib/deploy/functions/release/fabricator.js

@@ -44,8 +44,7 @@ class Fabricator {
     constructor(args) {
         this.executor = args.executor;
         this.functionExecutor = args.functionExecutor;
-        this.sourceUrl = args.sourceUrl;
-        this.storage = args.storage;
+        this.sources = args.sources;
         this.appEngineLocation = args.appEngineLocation;
     }
     async applyPlan(plan) {
@@ -154,12 +153,13 @@ class Fabricator {
         }
     }
     async createV1Function(endpoint, scraper) {
-        var _a;
-        if (!this.sourceUrl) {
+        var _a, _b;
+        const sourceUrl = (_a = this.sources[endpoint.codebase]) === null || _a === void 0 ? void 0 : _a.sourceUrl;
+        if (!sourceUrl) {
             logger_1.logger.debug("Precondition failed. Cannot create a GCF function without sourceUrl");
             throw new Error("Precondition failed");
         }
-        const apiFunction = gcf.functionFromEndpoint(endpoint, this.sourceUrl);
+        const apiFunction = gcf.functionFromEndpoint(endpoint, sourceUrl);
         if (apiFunction.httpsTrigger) {
             apiFunction.httpsTrigger.securityLevel = "SECURE_ALWAYS";
         }
@@ -167,10 +167,10 @@ class Fabricator {
         const resultFunction = await this.functionExecutor
             .run(async () => {
             const op = await gcf.createFunction(apiFunction);
-            return poller.pollOperation(Object.assign(Object.assign({}, gcfV1PollerOptions), { pollerName: `create-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name, onPoll: scraper.poller }));
+            return poller.pollOperation(Object.assign(Object.assign({}, gcfV1PollerOptions), { pollerName: `create-${endpoint.codebase}-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name, onPoll: scraper.poller }));
         })
             .catch(rethrowAs(endpoint, "create"));
-        endpoint.uri = (_a = resultFunction === null || resultFunction === void 0 ? void 0 : resultFunction.httpsTrigger) === null || _a === void 0 ? void 0 : _a.url;
+        endpoint.uri = (_b = resultFunction === null || resultFunction === void 0 ? void 0 : resultFunction.httpsTrigger) === null || _b === void 0 ? void 0 : _b.url;
         if (backend.isHttpsTriggered(endpoint)) {
             const invoker = endpoint.httpsTrigger.invoker || ["public"];
             if (!invoker.includes("private")) {
@@ -208,13 +208,14 @@ class Fabricator {
         }
     }
     async createV2Function(endpoint) {
-        var _a;
-        if (!this.storage) {
+        var _a, _b;
+        const storage = (_a = this.sources[endpoint.codebase]) === null || _a === void 0 ? void 0 : _a.storage;
+        if (!storage) {
             logger_1.logger.debug("Precondition failed. Cannot create a GCFv2 function without storage");
             throw new Error("Precondition failed");
         }
-        const apiFunction = gcfV2.functionFromEndpoint(endpoint, this.storage);
-        const topic = (_a = apiFunction.eventTrigger) === null || _a === void 0 ? void 0 : _a.pubsubTopic;
+        const apiFunction = gcfV2.functionFromEndpoint(endpoint, storage);
+        const topic = (_b = apiFunction.eventTrigger) === null || _b === void 0 ? void 0 : _b.pubsubTopic;
         if (topic) {
             await this.executor
                 .run(async () => {
@@ -235,7 +236,7 @@ class Fabricator {
         const resultFunction = await this.functionExecutor
             .run(async () => {
             const op = await gcfV2.createFunction(apiFunction);
-            return await poller.pollOperation(Object.assign(Object.assign({}, gcfV2PollerOptions), { pollerName: `create-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name }));
+            return await poller.pollOperation(Object.assign(Object.assign({}, gcfV2PollerOptions), { pollerName: `create-${endpoint.codebase}-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name }));
         })
             .catch(rethrowAs(endpoint, "create"));
         endpoint.uri = resultFunction.serviceConfig.uri;
@@ -275,20 +276,21 @@ class Fabricator {
         }
     }
     async updateV1Function(endpoint, scraper) {
-        var _a;
-        if (!this.sourceUrl) {
+        var _a, _b;
+        const sourceUrl = (_a = this.sources[endpoint.codebase]) === null || _a === void 0 ? void 0 : _a.sourceUrl;
+        if (!sourceUrl) {
             logger_1.logger.debug("Precondition failed. Cannot update a GCF function without sourceUrl");
             throw new Error("Precondition failed");
         }
-        const apiFunction = gcf.functionFromEndpoint(endpoint, this.sourceUrl);
+        const apiFunction = gcf.functionFromEndpoint(endpoint, sourceUrl);
         apiFunction.sourceToken = await scraper.tokenPromise();
         const resultFunction = await this.functionExecutor
             .run(async () => {
             const op = await gcf.updateFunction(apiFunction);
-            return await poller.pollOperation(Object.assign(Object.assign({}, gcfV1PollerOptions), { pollerName: `update-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name, onPoll: scraper.poller }));
+            return await poller.pollOperation(Object.assign(Object.assign({}, gcfV1PollerOptions), { pollerName: `update-${endpoint.codebase}-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name, onPoll: scraper.poller }));
         })
             .catch(rethrowAs(endpoint, "update"));
-        endpoint.uri = (_a = resultFunction === null || resultFunction === void 0 ? void 0 : resultFunction.httpsTrigger) === null || _a === void 0 ? void 0 : _a.url;
+        endpoint.uri = (_b = resultFunction === null || resultFunction === void 0 ? void 0 : resultFunction.httpsTrigger) === null || _b === void 0 ? void 0 : _b.url;
         let invoker;
         if (backend.isHttpsTriggered(endpoint)) {
             invoker = endpoint.httpsTrigger.invoker;
@@ -307,19 +309,20 @@ class Fabricator {
         }
     }
     async updateV2Function(endpoint) {
-        var _a;
-        if (!this.storage) {
+        var _a, _b;
+        const storage = (_a = this.sources[endpoint.codebase]) === null || _a === void 0 ? void 0 : _a.storage;
+        if (!storage) {
             logger_1.logger.debug("Precondition failed. Cannot update a GCFv2 function without storage");
             throw new Error("Precondition failed");
         }
-        const apiFunction = gcfV2.functionFromEndpoint(endpoint, this.storage);
-        if ((_a = apiFunction.eventTrigger) === null || _a === void 0 ? void 0 : _a.pubsubTopic) {
+        const apiFunction = gcfV2.functionFromEndpoint(endpoint, storage);
+        if ((_b = apiFunction.eventTrigger) === null || _b === void 0 ? void 0 : _b.pubsubTopic) {
             delete apiFunction.eventTrigger.pubsubTopic;
         }
         const resultFunction = await this.functionExecutor
             .run(async () => {
             const op = await gcfV2.updateFunction(apiFunction);
-            return await poller.pollOperation(Object.assign(Object.assign({}, gcfV2PollerOptions), { pollerName: `update-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name }));
+            return await poller.pollOperation(Object.assign(Object.assign({}, gcfV2PollerOptions), { pollerName: `update-${endpoint.codebase}-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name }));
         })
             .catch(rethrowAs(endpoint, "update"));
         endpoint.uri = resultFunction.serviceConfig.uri;
@@ -349,7 +352,7 @@ class Fabricator {
         await this.functionExecutor
             .run(async () => {
             const op = await gcf.deleteFunction(fnName);
-            const pollerOptions = Object.assign(Object.assign({}, gcfV1PollerOptions), { pollerName: `delete-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name });
+            const pollerOptions = Object.assign(Object.assign({}, gcfV1PollerOptions), { pollerName: `delete-${endpoint.codebase}-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name });
             await poller.pollOperation(pollerOptions);
         })
             .catch(rethrowAs(endpoint, "delete"));
@@ -359,7 +362,7 @@ class Fabricator {
         await this.functionExecutor
             .run(async () => {
             const op = await gcfV2.deleteFunction(fnName);
-            const pollerOptions = Object.assign(Object.assign({}, gcfV2PollerOptions), { pollerName: `delete-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name });
+            const pollerOptions = Object.assign(Object.assign({}, gcfV2PollerOptions), { pollerName: `delete-${endpoint.codebase}-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name });
             await poller.pollOperation(pollerOptions);
         })
             .catch(rethrowAs(endpoint, "delete"));
@@ -471,7 +474,7 @@ class Fabricator {
     logOpStart(op, endpoint) {
         const runtime = (0, runtimes_1.getHumanFriendlyRuntimeName)(endpoint.runtime);
         const label = helper.getFunctionLabel(endpoint);
-        utils.logBullet(`${clc.bold.cyan("functions:")} ${op} ${runtime} function ${clc.bold(label)}...`);
+        utils.logLabeledBullet("functions", `${op} ${runtime} function ${clc.bold(label)}...`);
     }
     logOpSuccess(op, endpoint) {
         const label = helper.getFunctionLabel(endpoint);

package/lib/deploy/functions/release/index.js

@@ -24,8 +24,18 @@ async function release(context, options, payload) {
     if (!payload.functions) {
         return;
     }
-    const { wantBackend, haveBackend } = payload.functions;
-    const plan = planner.createDeploymentPlan(wantBackend, haveBackend, context.filters);
+    if (!context.sources) {
+        return;
+    }
+    let plan = {};
+    for (const [codebase, { wantBackend, haveBackend }] of Object.entries(payload.functions)) {
+        plan = Object.assign(Object.assign({}, plan), planner.createDeploymentPlan({
+            codebase,
+            wantBackend,
+            haveBackend,
+            filters: context.filters,
+        }));
+    }
     const fnsToDelete = Object.values(plan)
         .map((regionalChanges) => regionalChanges.endpointsToDelete)
         .reduce(functional_1.reduceFlat, []);
@@ -44,15 +54,15 @@ async function release(context, options, payload) {
     const fab = new fabricator.Fabricator({
         functionExecutor,
         executor: new executor.QueueExecutor({}),
-        sourceUrl: context.source.sourceUrl,
-        storage: context.source.storage,
+        sources: context.sources,
         appEngineLocation: (0, functionsConfig_1.getAppEngineLocation)(context.firebaseConfig),
     });
     const summary = await fab.applyPlan(plan);
     await reporter.logAndTrackDeployStats(summary);
     reporter.printErrors(summary);
-    printTriggerUrls(payload.functions.wantBackend);
-    const haveEndpoints = backend.allEndpoints(payload.functions.wantBackend);
+    const wantBackend = backend.merge(...Object.values(payload.functions).map((p) => p.wantBackend));
+    printTriggerUrls(wantBackend);
+    const haveEndpoints = backend.allEndpoints(wantBackend);
     const deletedEndpoints = Object.values(plan)
         .map((r) => r.endpointsToDelete)
         .reduce(functional_1.reduceFlat, []);

package/lib/deploy/functions/release/planner.js

@@ -48,20 +48,25 @@ function calculateUpdate(want, have) {
     return update;
 }
 exports.calculateUpdate = calculateUpdate;
-function createDeploymentPlan(want, have, filters, deleteAll) {
+function createDeploymentPlan(args) {
+    let { wantBackend, haveBackend, codebase, filters, deleteAll } = args;
     let deployment = {};
-    want = backend.matchingBackend(want, (endpoint) => {
+    wantBackend = backend.matchingBackend(wantBackend, (endpoint) => {
         return (0, functionsDeployHelper_1.endpointMatchesAnyFilter)(endpoint, filters);
     });
-    have = backend.matchingBackend(have, (endpoint) => {
-        return (0, functionsDeployHelper_1.endpointMatchesAnyFilter)(endpoint, filters);
+    const wantedEndpoint = backend.hasEndpoint(wantBackend);
+    haveBackend = backend.matchingBackend(haveBackend, (endpoint) => {
+        return wantedEndpoint(endpoint) || (0, functionsDeployHelper_1.endpointMatchesAnyFilter)(endpoint, filters);
     });
-    const regions = new Set([...Object.keys(want.endpoints), ...Object.keys(have.endpoints)]);
+    const regions = new Set([
+        ...Object.keys(wantBackend.endpoints),
+        ...Object.keys(haveBackend.endpoints),
+    ]);
     for (const region of regions) {
-        const changesets = calculateChangesets(want.endpoints[region] || {}, have.endpoints[region] || {}, (e) => `${e.region}-${e.availableMemoryMb || "default"}`, deleteAll);
+        const changesets = calculateChangesets(wantBackend.endpoints[region] || {}, haveBackend.endpoints[region] || {}, (e) => `${codebase}-${e.region}-${e.availableMemoryMb || "default"}`, deleteAll);
         deployment = Object.assign(Object.assign({}, deployment), changesets);
     }
-    if (upgradedToGCFv2WithoutSettingConcurrency(want, have)) {
+    if (upgradedToGCFv2WithoutSettingConcurrency(wantBackend, haveBackend)) {
         utils.logLabeledBullet("functions", "You are updating one or more functions to Google Cloud Functions v2, " +
             "which introduces support for concurrent execution. New functions " +
             "default to 80 concurrent executions, but existing functions keep the " +

package/lib/deploy/functions/validate.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.secretsAreValid = exports.functionIdsAreValid = exports.functionsDirectoryExists = exports.endpointsAreValid = void 0;
+exports.secretsAreValid = exports.functionIdsAreValid = exports.functionsDirectoryExists = exports.endpointsAreUnique = exports.endpointsAreValid = void 0;
 const path = require("path");
 const clc = require("cli-color");
 const error_1 = require("../../error");
@@ -39,6 +39,29 @@ function endpointsAreValid(wantBackend) {
     }
 }
 exports.endpointsAreValid = endpointsAreValid;
+function endpointsAreUnique(backends) {
+    const endpointToCodebases = {};
+    for (const [codebase, b] of Object.entries(backends)) {
+        for (const endpoint of backend.allEndpoints(b)) {
+            const key = backend.functionName(endpoint);
+            const cs = endpointToCodebases[key] || new Set();
+            cs.add(codebase);
+            endpointToCodebases[key] = cs;
+        }
+    }
+    const conflicts = {};
+    for (const [fn, codebases] of Object.entries(endpointToCodebases)) {
+        if (codebases.size > 1) {
+            conflicts[fn] = Array.from(codebases);
+        }
+    }
+    if (Object.keys(conflicts).length === 0) {
+        return;
+    }
+    const msgs = Object.entries(conflicts).map(([fn, codebases]) => `${fn}: ${codebases.join(",")}`);
+    throw new error_1.FirebaseError("More than one codebase claims following functions:\n\t" + `${msgs.join("\n\t")}`);
+}
+exports.endpointsAreUnique = endpointsAreUnique;
 function functionsDirectoryExists(sourceDir, projectDir) {
     if (!fsutils.dirExistsSync(sourceDir)) {
         const sourceDirName = path.relative(projectDir, sourceDir);

package/lib/deploy/hosting/convertConfig.js

@@ -40,10 +40,12 @@ async function convertConfig(context, payload, config, finalize) {
         return out;
     }
     const endpointBeingDeployed = (serviceId, region = "us-central1") => {
-        var _a, _b, _c;
-        const endpoint = (_c = (_b = (_a = payload.functions) === null || _a === void 0 ? void 0 : _a.wantBackend) === null || _b === void 0 ? void 0 : _b.endpoints[region]) === null || _c === void 0 ? void 0 : _c[serviceId];
-        if (endpoint && (0, backend_1.isHttpsTriggered)(endpoint) && endpoint.platform === "gcfv2")
-            return endpoint;
+        var _a;
+        for (const { wantBackend } of Object.values(payload.functions || {})) {
+            const endpoint = (_a = wantBackend === null || wantBackend === void 0 ? void 0 : wantBackend.endpoints[region]) === null || _a === void 0 ? void 0 : _a[serviceId];
+            if (endpoint && (0, backend_1.isHttpsTriggered)(endpoint) && endpoint.platform === "gcfv2")
+                return endpoint;
+        }
         return undefined;
     };
     const matchingEndpoint = async (serviceId, region = "us-central1") => {

package/lib/emulator/controller.js

@@ -268,16 +268,19 @@ async function startAll(options, showUI = true) {
     const emulatableBackends = [];
     const projectDir = (options.extDevDir || options.config.projectDir);
     if (shouldStart(options, types_1.Emulators.FUNCTIONS)) {
-        const functionsCfg = (0, projectConfig_1.normalizeAndValidate)(options.config.src.functions)[0];
+        const functionsCfg = (0, projectConfig_1.normalizeAndValidate)(options.config.src.functions);
         utils.assertIsStringOrUndefined(options.extDevDir);
-        const functionsDir = path.join(projectDir, functionsCfg.source);
-        emulatableBackends.push({
-            functionsDir,
-            env: Object.assign({}, options.extDevEnv),
-            secretEnv: [],
-            predefinedTriggers: options.extDevTriggers,
-            nodeMajorVersion: (0, functionsEmulatorUtils_1.parseRuntimeVersion)(options.extDevNodeVersion || functionsCfg.runtime),
-        });
+        for (const cfg of functionsCfg) {
+            const functionsDir = path.join(projectDir, cfg.source);
+            emulatableBackends.push({
+                functionsDir,
+                codebase: cfg.codebase,
+                env: Object.assign({}, options.extDevEnv),
+                secretEnv: [],
+                predefinedTriggers: options.extDevTriggers,
+                nodeMajorVersion: (0, functionsEmulatorUtils_1.parseRuntimeVersion)(options.extDevNodeVersion || cfg.runtime),
+            });
+        }
     }
     if (shouldStart(options, types_1.Emulators.EXTENSIONS) && previews_1.previews.extensionsemulator) {
         const projectNumber = constants_1.Constants.isDemoProject(projectId)

package/lib/emulator/functionsEmulator.js

@@ -177,7 +177,9 @@ class FunctionsEmulator {
         });
         return hub;
     }
-    async invokeTrigger(backend, trigger, proto, runtimeOpts) {
+    async invokeTrigger(trigger, proto, runtimeOpts) {
+        const record = this.getTriggerRecordByKey(this.getTriggerKey(trigger));
+        const backend = record.backend;
         const bundleTemplate = this.getBaseBundle();
         const runtimeBundle = Object.assign(Object.assign({}, bundleTemplate), { proto });
         if (this.args.debugPort) {
@@ -284,6 +286,9 @@ class FunctionsEmulator {
             const discoveredBackend = await runtimeDelegate.discoverSpec(runtimeConfig, Object.assign(Object.assign(Object.assign(Object.assign({}, this.getSystemEnvs()), this.getEmulatorEnvs()), { FIREBASE_CONFIG: this.getFirebaseConfig() }), emulatableBackend.env));
             const endpoints = backend.allEndpoints(discoveredBackend);
             (0, functionsEmulatorShared_1.prepareEndpoints)(endpoints);
+            for (const e of endpoints) {
+                e.codebase = emulatableBackend.codebase;
+            }
             triggerDefinitions = (0, functionsEmulatorShared_1.emulatedFunctionsFromEndpoints)(endpoints);
         }
         const toSetup = triggerDefinitions.filter((definition) => {
@@ -579,6 +584,7 @@ class FunctionsEmulator {
         };
     }
     setTriggersForTesting(triggers, backend) {
+        this.triggers = {};
         triggers.forEach((def) => this.addTriggerRecord(def, { backend, ignored: false }));
     }
     getBaseBundle() {
@@ -862,7 +868,7 @@ class FunctionsEmulator {
         }
         const trigger = record.def;
         const service = (0, functionsEmulatorShared_1.getFunctionService)(trigger);
-        const worker = await this.invokeTrigger(record.backend, trigger, proto);
+        const worker = await this.invokeTrigger(trigger, proto);
         return new Promise((resolve, reject) => {
             if (projectId !== this.args.projectId) {
                 if (service !== constants_1.Constants.SERVICE_REALTIME_DATABASE) {
@@ -949,7 +955,7 @@ class FunctionsEmulator {
                 req.headers[functionsEmulatorShared_1.HttpConstants.CALLABLE_AUTH_HEADER] = encodeURIComponent(JSON.stringify(contextAuth));
             }
         }
-        const worker = await this.invokeTrigger(record.backend, trigger);
+        const worker = await this.invokeTrigger(trigger);
         worker.onLogs((el) => {
             if (el.level === "FATAL") {
                 res.status(500).send(el.text);

package/lib/emulator/functionsEmulatorShared.js

@@ -66,6 +66,7 @@ function emulatedFunctionsFromEndpoints(endpoints) {
             region: endpoint.region,
             name: endpoint.id,
             id: `${endpoint.region}-${endpoint.id}`,
+            codebase: endpoint.codebase,
         };
         (0, proto_1.copyIfPresent)(def, endpoint, "availableMemoryMb", "labels", "timeoutSeconds", "platform", "secretEnvironmentVariables");
         if (backend.isHttpsTriggered(endpoint)) {
@@ -279,7 +280,7 @@ function toBackendInfo(e, cf3Triggers) {
         extension: e.extension,
         extensionVersion: extensionVersion,
         extensionSpec: extensionSpec,
-        functionTriggers: (_b = e.predefinedTriggers) !== null && _b !== void 0 ? _b : cf3Triggers,
+        functionTriggers: (_b = e.predefinedTriggers) !== null && _b !== void 0 ? _b : cf3Triggers.filter((t) => t.codebase === e.codebase),
     }));
 }
 exports.toBackendInfo = toBackendInfo;

package/lib/emulator/functionsEmulatorShell.js

@@ -7,9 +7,8 @@ const utils = require("../utils");
 const logger_1 = require("../logger");
 const error_1 = require("../error");
 class FunctionsEmulatorShell {
-    constructor(emu, backend) {
+    constructor(emu) {
         this.emu = emu;
-        this.backend = backend;
         this.urls = {};
         this.triggers = emu.getTriggerDefinitions();
         this.emulatedFunctions = this.triggers.map((t) => t.id);
@@ -42,7 +41,7 @@ class FunctionsEmulatorShell {
             auth: opts.auth,
             data,
         };
-        this.emu.invokeTrigger(this.backend, trigger, proto);
+        this.emu.invokeTrigger(trigger, proto);
     }
     getTrigger(name) {
         const result = this.triggers.find((trigger) => {

package/lib/emulator/pubsubEmulator.js

@@ -44,14 +44,7 @@ class PubsubEmulator {
     getName() {
         return types_1.Emulators.PUBSUB;
     }
-    async addTrigger(topicName, triggerKey, signatureType) {
-        this.logger.logLabeled("DEBUG", "pubsub", `addTrigger(${topicName}, ${triggerKey}, ${signatureType})`);
-        const triggers = this.triggersForTopic.get(topicName) || [];
-        if (triggers.some((t) => t.triggerKey === triggerKey) &&
-            this.subscriptionForTopic.has(topicName)) {
-            this.logger.logLabeled("DEBUG", "pubsub", "Trigger already exists");
-            return;
-        }
+    async maybeCreateTopicAndSub(topicName) {
         const topic = this.pubsub.topic(topicName);
         try {
             this.logger.logLabeled("DEBUG", "pubsub", `Creating topic: ${topicName}`);
@@ -74,7 +67,7 @@ class PubsubEmulator {
         catch (e) {
             if (e && e.code === 6) {
                 this.logger.logLabeled("DEBUG", "pubsub", `Sub for ${topicName} exists`);
-                sub = topic.subscription(`emulator-sub-${topicName}`);
+                sub = topic.subscription(subName);
             }
             else {
                 throw new error_1.FirebaseError(`Could not create sub ${subName}`, { original: e });
@@ -83,6 +76,17 @@ class PubsubEmulator {
         sub.on("message", (message) => {
             this.onMessage(topicName, message);
         });
+        return sub;
+    }
+    async addTrigger(topicName, triggerKey, signatureType) {
+        this.logger.logLabeled("DEBUG", "pubsub", `addTrigger(${topicName}, ${triggerKey}, ${signatureType})`);
+        const sub = await this.maybeCreateTopicAndSub(topicName);
+        const triggers = this.triggersForTopic.get(topicName) || [];
+        if (triggers.some((t) => t.triggerKey === triggerKey) &&
+            this.subscriptionForTopic.has(topicName)) {
+            this.logger.logLabeled("DEBUG", "pubsub", "Trigger already exists");
+            return;
+        }
         triggers.push({ triggerKey, signatureType });
         this.triggersForTopic.set(topicName, triggers);
         this.subscriptionForTopic.set(topicName, sub);

package/lib/ensureApiEnabled.js

@@ -28,7 +28,7 @@ async function check(projectId, apiName, prefix, silent = false) {
 exports.check = check;
 async function enable(projectId, apiName) {
     try {
-        await apiClient.post(`/projects/${projectId}/services/${apiName}:enable`, {
+        await apiClient.post(`/projects/${projectId}/services/${apiName}:enable`, undefined, {
             skipLog: { resBody: true },
         });
     }

package/lib/functions/projectConfig.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeAndValidate = exports.validate = exports.normalize = exports.DEFAULT_CODEBASE = void 0;
+exports.configForCodebase = exports.normalizeAndValidate = exports.validate = exports.normalize = exports.DEFAULT_CODEBASE = void 0;
 const error_1 = require("../error");
 exports.DEFAULT_CODEBASE = "default";
 function normalize(config) {
@@ -40,16 +40,21 @@ function assertUnique(config, property) {
     }
 }
 function validate(config) {
-    if (config.length > 1) {
-        throw new error_1.FirebaseError("More than one functions.source detected in firebase.json.");
-    }
-    const validated = validateSingle(config[0]);
-    assertUnique([validated], "source");
-    assertUnique([validated], "codebase");
-    return [validated];
+    const validated = config.map((cfg) => validateSingle(cfg));
+    assertUnique(validated, "source");
+    assertUnique(validated, "codebase");
+    return validated;
 }
 exports.validate = validate;
 function normalizeAndValidate(config) {
     return validate(normalize(config));
 }
 exports.normalizeAndValidate = normalizeAndValidate;
+function configForCodebase(config, codebase) {
+    const codebaseCfg = config.find((c) => c.codebase === codebase);
+    if (!codebaseCfg) {
+        throw new error_1.FirebaseError(`No functions config found for codebase ${codebase}`);
+    }
+    return codebaseCfg;
+}
+exports.configForCodebase = configForCodebase;

package/lib/functionsShellCommandAction.js

@@ -55,7 +55,7 @@ const actionFunction = async (options) => {
     })
         .then(() => {
         const instance = serveFunctions.get();
-        const emulator = new shell.FunctionsEmulatorShell(instance, serveFunctions.getBackend());
+        const emulator = new shell.FunctionsEmulatorShell(instance);
         if (emulator.emulatedFunctions && emulator.emulatedFunctions.length === 0) {
             logger_1.logger.info("No functions emulated.");
             process.exit();

package/lib/gcp/cloudfunctions.js

@@ -280,6 +280,7 @@ function endpointFromFunction(gcfFunction) {
 }
 exports.endpointFromFunction = endpointFromFunction;
 function functionFromEndpoint(endpoint, sourceUploadUrl) {
+    var _a;
     if (endpoint.platform !== "gcfv1") {
         throw new error_1.FirebaseError("Trying to create a v1 CloudFunction with v2 API. This should never happen");
     }
@@ -334,7 +335,13 @@ function functionFromEndpoint(endpoint, sourceUploadUrl) {
         proto.renameIfPresent(gcfFunction, endpoint.vpc, "vpcConnector", "connector");
         proto.renameIfPresent(gcfFunction, endpoint.vpc, "vpcConnectorEgressSettings", "egressSettings");
     }
-    gcfFunction.labels = Object.assign(Object.assign({}, gcfFunction.labels), { [exports.CODEBASE_LABEL]: endpoint.codebase || projectConfig.DEFAULT_CODEBASE });
+    const codebase = endpoint.codebase || projectConfig.DEFAULT_CODEBASE;
+    if (codebase !== projectConfig.DEFAULT_CODEBASE) {
+        gcfFunction.labels = Object.assign(Object.assign({}, gcfFunction.labels), { [exports.CODEBASE_LABEL]: codebase });
+    }
+    else {
+        (_a = gcfFunction.labels) === null || _a === void 0 ? true : delete _a[exports.CODEBASE_LABEL];
+    }
     return gcfFunction;
 }
 exports.functionFromEndpoint = functionFromEndpoint;

package/lib/gcp/cloudfunctionsv2.js

@@ -157,6 +157,7 @@ async function deleteFunction(cloudFunction) {
 }
 exports.deleteFunction = deleteFunction;
 function functionFromEndpoint(endpoint, source) {
+    var _a;
     if (endpoint.platform !== "gcfv2") {
         throw new error_1.FirebaseError("Trying to create a v2 CloudFunction with v1 API. This should never happen");
     }
@@ -223,7 +224,13 @@ function functionFromEndpoint(endpoint, source) {
     else if (backend.isBlockingTriggered(endpoint)) {
         gcfFunction.labels = Object.assign(Object.assign({}, gcfFunction.labels), { [exports.BLOCKING_LABEL]: BLOCKING_EVENT_TO_LABEL_KEY[endpoint.blockingTrigger.eventType] });
     }
-    gcfFunction.labels = Object.assign(Object.assign({}, gcfFunction.labels), { [exports.CODEBASE_LABEL]: endpoint.codebase || projectConfig.DEFAULT_CODEBASE });
+    const codebase = endpoint.codebase || projectConfig.DEFAULT_CODEBASE;
+    if (codebase !== projectConfig.DEFAULT_CODEBASE) {
+        gcfFunction.labels = Object.assign(Object.assign({}, gcfFunction.labels), { [exports.CODEBASE_LABEL]: codebase });
+    }
+    else {
+        (_a = gcfFunction.labels) === null || _a === void 0 ? true : delete _a[exports.CODEBASE_LABEL];
+    }
     return gcfFunction;
 }
 exports.functionFromEndpoint = functionFromEndpoint;

package/lib/serve/functions.js

@@ -10,28 +10,29 @@ const auth_1 = require("../auth");
 const projectConfig = require("../functions/projectConfig");
 const utils = require("../utils");
 class FunctionsServer {
-    constructor() {
-        this.emulatorServer = undefined;
-        this.backend = undefined;
-    }
     assertServer() {
-        if (!this.emulatorServer || !this.backend) {
+        if (!this.emulatorServer || !this.backends) {
             throw new Error("Must call start() before calling any other operation!");
         }
     }
     async start(options, partialArgs) {
         const projectId = (0, projectUtils_1.needProjectId)(options);
-        const config = projectConfig.normalizeAndValidate(options.config.src.functions)[0];
-        const functionsDir = path.join(options.config.projectDir, config.source);
+        const config = projectConfig.normalizeAndValidate(options.config.src.functions);
+        const backends = [];
+        for (const cfg of config) {
+            const functionsDir = path.join(options.config.projectDir, cfg.source);
+            const nodeMajorVersion = (0, functionsEmulatorUtils_1.parseRuntimeVersion)(cfg.runtime);
+            backends.push({
+                functionsDir,
+                codebase: cfg.codebase,
+                nodeMajorVersion,
+                env: {},
+                secretEnv: [],
+            });
+        }
+        this.backends = backends;
         const account = (0, auth_1.getProjectDefaultAccount)(options.config.projectDir);
-        const nodeMajorVersion = (0, functionsEmulatorUtils_1.parseRuntimeVersion)(config.runtime);
-        this.backend = {
-            functionsDir,
-            nodeMajorVersion,
-            env: {},
-            secretEnv: [],
-        };
-        const args = Object.assign({ projectId, projectDir: options.config.projectDir, emulatableBackends: [this.backend], projectAlias: options.projectAlias, account }, partialArgs);
+        const args = Object.assign({ projectId, projectDir: options.config.projectDir, emulatableBackends: this.backends, projectAlias: options.projectAlias, account }, partialArgs);
         if (options.host) {
             utils.assertIsStringOrUndefined(options.host);
             args.host = options.host;
@@ -59,10 +60,6 @@ class FunctionsServer {
         this.assertServer();
         await this.emulatorServer.stop();
     }
-    getBackend() {
-        this.assertServer();
-        return this.backend;
-    }
     get() {
         this.assertServer();
         return this.emulatorServer.get();

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "firebase-tools",
-  "version": "10.7.0",
+  "version": "10.7.1",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "firebase-tools",
-      "version": "10.7.0",
+      "version": "10.7.1",
       "license": "MIT",
       "dependencies": {
         "@google-cloud/pubsub": "^2.18.4",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firebase-tools",
-  "version": "10.7.0",
+  "version": "10.7.1",
   "description": "Command-Line Interface for Firebase",
   "main": "./lib/index.js",
   "bin": {