firebase-tools 10.6.0 → 10.7.2

package/lib/deploy/functions/prepare.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.inferDetailsFromExisting = exports.prepare = void 0;
+exports.inferBlockingDetails = exports.inferDetailsFromExisting = exports.prepare = void 0;
 const clc = require("cli-color");
 const backend = require("./backend");
 const ensureApiEnabled = require("../../ensureApiEnabled");
@@ -21,63 +21,126 @@ const checkIam_1 = require("./checkIam");
 const error_1 = require("../../error");
 const projectConfig_1 = require("../../functions/projectConfig");
 const previews_1 = require("../../previews");
+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];
-    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.config = (0, projectConfig_1.normalizeAndValidate)(options.config.src.functions);
+    context.filters = (0, functionsDeployHelper_1.getEndpointFilters)(options);
+    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 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 checkAPIsEnabled = await Promise.all([
         ensureApiEnabled.ensure(projectId, "cloudfunctions.googleapis.com", "functions"),
         ensureApiEnabled.check(projectId, "runtimeconfig.googleapis.com", "runtimeconfig", true),
         ensure.cloudBuildEnabled(projectId),
         ensure.maybeEnableAR(projectId),
     ]);
-    context.runtimeConfigEnabled = checkAPIsEnabled[1];
     context.artifactRegistryEnabled = checkAPIsEnabled[3];
     const firebaseConfig = await functionsConfig.getFirebaseConfig(options);
     context.firebaseConfig = firebaseConfig;
-    const runtimeConfig = await (0, prepareFunctionsUpload_1.getFunctionsConfig)(context);
-    const firebaseEnvs = functionsEnv.loadFirebaseEnvs(firebaseConfig, projectId);
-    const userEnvOpt = {
-        functionsSource: sourceDir,
-        projectId: projectId,
-        projectAlias: options.projectAlias,
-    };
-    const userEnvs = functionsEnv.loadUserEnvs(userEnvOpt);
-    const usedDotenv = hasDotenv(userEnvOpt);
+    let runtimeConfig = { firebase: firebaseConfig };
+    if (checkAPIsEnabled[1]) {
+        runtimeConfig = Object.assign(Object.assign({}, runtimeConfig), (await (0, prepareFunctionsUpload_1.getFunctionsConfig)(projectId)));
+    }
+    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 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);
-    payload.functions = { backend: wantBackend };
+    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);
+    }));
     if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv2")) {
         const V2_APIS = [
             "artifactregistry.googleapis.com",
@@ -91,45 +154,13 @@ async function prepare(context, options, payload) {
         });
         await Promise.all(enablements);
     }
-    if (backend.someEndpoint(wantBackend, () => true)) {
-        (0, utils_1.logBullet)(clc.cyan.bold("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`");
-        }
-        context.functionsSourceV2 = await (0, prepareFunctionsUpload_1.prepareFunctionsUpload)(sourceDir, context.config);
-    }
-    if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv1")) {
-        context.functionsSourceV1 = await (0, prepareFunctionsUpload_1.prepareFunctionsUpload)(sourceDir, context.config, runtimeConfig);
-    }
-    for (const endpoint of backend.allEndpoints(wantBackend)) {
-        endpoint.environmentVariables = wantBackend.environmentVariables;
-    }
-    await Promise.all(Object.values(wantBackend.requiredAPIs).map(({ api }) => {
-        return ensureApiEnabled.ensure(projectId, api, "functions", false);
-    }));
-    validate.endpointsAreValid(wantBackend);
-    context.filters = (0, functionsDeployHelper_1.getFilterGroups)(options);
     const matchingBackend = backend.matchingBackend(wantBackend, (endpoint) => {
-        return (0, functionsDeployHelper_1.functionMatchesAnyGroup)(endpoint, context.filters);
+        return (0, functionsDeployHelper_1.endpointMatchesAnyFilter)(endpoint, context.filters);
     });
-    const haveBackend = await backend.existingBackend(context);
-    await (0, checkIam_1.ensureServiceAgentRoles)(projectNumber, wantBackend, haveBackend);
-    inferDetailsFromExisting(wantBackend, haveBackend, usedDotenv);
-    await (0, triggerRegionHelper_1.ensureTriggerRegions)(wantBackend);
     await (0, prompts_1.promptForFailurePolicies)(options, matchingBackend, haveBackend);
     await (0, prompts_1.promptForMinInstances)(options, matchingBackend, haveBackend);
-    await backend.checkAvailability(context, wantBackend);
+    await backend.checkAvailability(context, matchingBackend);
+    await (0, checkIam_1.ensureServiceAgentRoles)(projectNumber, matchingBackend, haveBackend);
     await validate.secretsAreValid(projectId, matchingBackend);
     await ensure.secretAccess(projectId, matchingBackend, haveBackend);
 }
@@ -165,3 +196,30 @@ function maybeCopyTriggerRegion(wantE, haveE) {
     }
     wantE.eventTrigger.region = haveE.eventTrigger.region;
 }
+function inferBlockingDetails(want) {
+    var _a, _b, _c;
+    const authBlockingEndpoints = backend
+        .allEndpoints(want)
+        .filter((ep) => backend.isBlockingTriggered(ep) &&
+        v1_1.AUTH_BLOCKING_EVENTS.includes(ep.blockingTrigger.eventType));
+    if (authBlockingEndpoints.length === 0) {
+        return;
+    }
+    let accessToken = false;
+    let idToken = false;
+    let refreshToken = false;
+    for (const blockingEp of authBlockingEndpoints) {
+        accessToken || (accessToken = !!((_a = blockingEp.blockingTrigger.options) === null || _a === void 0 ? void 0 : _a.accessToken));
+        idToken || (idToken = !!((_b = blockingEp.blockingTrigger.options) === null || _b === void 0 ? void 0 : _b.idToken));
+        refreshToken || (refreshToken = !!((_c = blockingEp.blockingTrigger.options) === null || _c === void 0 ? void 0 : _c.refreshToken));
+    }
+    for (const blockingEp of authBlockingEndpoints) {
+        if (!blockingEp.blockingTrigger.options) {
+            blockingEp.blockingTrigger.options = {};
+        }
+        blockingEp.blockingTrigger.options.accessToken = accessToken;
+        blockingEp.blockingTrigger.options.idToken = idToken;
+        blockingEp.blockingTrigger.options.refreshToken = refreshToken;
+    }
+}
+exports.inferBlockingDetails = inferBlockingDetails;

package/lib/deploy/functions/prepareFunctionsUpload.js

@@ -14,31 +14,26 @@ const functionsConfig = require("../../functionsConfig");
 const utils = require("../../utils");
 const fsAsync = require("../../fsAsync");
 const CONFIG_DEST_FILE = ".runtimeconfig.json";
-async function getFunctionsConfig(context) {
+async function getFunctionsConfig(projectId) {
     var _a, _b;
-    let config = {};
-    if (context.runtimeConfigEnabled) {
-        try {
-            config = await functionsConfig.materializeAll(context.firebaseConfig.projectId);
+    try {
+        return await functionsConfig.materializeAll(projectId);
+    }
+    catch (err) {
+        logger_1.logger.debug(err);
+        let errorCode = (_b = (_a = err === null || err === void 0 ? void 0 : err.context) === null || _a === void 0 ? void 0 : _a.response) === null || _b === void 0 ? void 0 : _b.statusCode;
+        if (!errorCode) {
+            logger_1.logger.debug("Got unexpected error from Runtime Config; it has no status code:", err);
+            errorCode = 500;
         }
-        catch (err) {
-            logger_1.logger.debug(err);
-            let errorCode = (_b = (_a = err === null || err === void 0 ? void 0 : err.context) === null || _a === void 0 ? void 0 : _a.response) === null || _b === void 0 ? void 0 : _b.statusCode;
-            if (!errorCode) {
-                logger_1.logger.debug("Got unexpected error from Runtime Config; it has no status code:", err);
-                errorCode = 500;
-            }
-            if (errorCode === 500 || errorCode === 503) {
-                throw new error_1.FirebaseError("Cloud Runtime Config is currently experiencing issues, " +
-                    "which is preventing your functions from being deployed. " +
-                    "Please wait a few minutes and then try to deploy your functions again." +
-                    "\nRun `firebase deploy --except functions` if you want to continue deploying the rest of your project.");
-            }
-            config = {};
+        if (errorCode === 500 || errorCode === 503) {
+            throw new error_1.FirebaseError("Cloud Runtime Config is currently experiencing issues, " +
+                "which is preventing your functions from being deployed. " +
+                "Please wait a few minutes and then try to deploy your functions again." +
+                "\nRun `firebase deploy --except functions` if you want to continue deploying the rest of your project.");
         }
     }
-    config.firebase = context.firebaseConfig;
-    return config;
+    return {};
 }
 exports.getFunctionsConfig = getFunctionsConfig;
 async function pipeAsync(from, to) {

package/lib/deploy/functions/pricing.js

@@ -93,14 +93,17 @@ exports.V2_FREE_TIER = {
     vCpu: 180000,
     egress: 1,
 };
+const VCPU_TO_GHZ = 2.4;
 const MB_TO_GHZ = {
     128: 0.2,
     256: 0.4,
     512: 0.8,
     1024: 1.4,
-    2048: 2.4,
-    4096: 4.8,
-    8192: 4.8,
+    2048: 1 * VCPU_TO_GHZ,
+    4096: 2 * VCPU_TO_GHZ,
+    8192: 2 * VCPU_TO_GHZ,
+    16384: 4 * VCPU_TO_GHZ,
+    32768: 8 * VCPU_TO_GHZ,
 };
 function canCalculateMinInstanceCost(endpoint) {
     if (!endpoint.minInstances) {

package/lib/deploy/functions/prompts.js

@@ -136,19 +136,13 @@ async function promptForMinInstances(options, want, have) {
         const cost = pricing.monthlyMinInstanceCost(backend.allEndpoints(want)).toFixed(2);
         costLine = `With these options, your minimum bill will be $${cost} in a 30-day month`;
     }
-    let cudAnnotation = "";
-    if (backend.someEndpoint(want, (fn) => fn.platform === "gcfv2" && !!fn.minInstances)) {
-        cudAnnotation =
-            "\nThis bill can be lowered with a one year commitment. See https://cloud.google.com/run/cud for more";
-    }
     const warnMessage = "The following functions have reserved minimum instances. This will " +
         "reduce the frequency of cold starts but increases the minimum cost. " +
         "You will be charged for the memory allocation and a fraction of the " +
         "CPU allocation of instances while they are idle.\n\n" +
         functionLines +
         "\n\n" +
-        costLine +
-        cudAnnotation;
+        costLine;
     utils.logLabeledWarning("functions", warnMessage);
     const proceed = await (0, prompt_1.promptOnce)({
         type: "confirm",

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

@@ -13,7 +13,7 @@ async function handler(op) {
             ((_b = (_a = err.context) === null || _a === void 0 ? void 0 : _a.response) === null || _b === void 0 ? void 0 : _b.statusCode) ||
             ((_c = err.original) === null || _c === void 0 ? void 0 : _c.code) ||
             ((_f = (_e = (_d = err.original) === null || _d === void 0 ? void 0 : _d.context) === null || _e === void 0 ? void 0 : _e.response) === null || _f === void 0 ? void 0 : _f.statusCode);
-        if (code === 429 || code === 409) {
+        if (code === 429 || code === 409 || code === 503) {
             throw err;
         }
         op.error = err;

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

@@ -21,6 +21,8 @@ const reporter = require("./reporter");
 const run = require("../../../gcp/run");
 const scheduler = require("../../../gcp/cloudscheduler");
 const utils = require("../../../utils");
+const services = require("../services");
+const v1_1 = require("../../../functions/events/v1");
 const gcfV1PollerOptions = {
     apiOrigin: api_1.functionsOrigin,
     apiVersion: gcf.API_VERSION,
@@ -35,14 +37,14 @@ const gcfV2PollerOptions = {
 };
 const DEFAULT_GCFV2_CONCURRENCY = 80;
 const rethrowAs = (endpoint, op) => (err) => {
+    logger_1.logger.error(err.message);
     throw new reporter.DeploymentError(endpoint, op, err);
 };
 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) {
@@ -151,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";
         }
@@ -164,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")) {
@@ -195,15 +198,24 @@ class Fabricator {
                     .catch(rethrowAs(endpoint, "set invoker"));
             }
         }
+        else if (backend.isBlockingTriggered(endpoint) &&
+            v1_1.AUTH_BLOCKING_EVENTS.includes(endpoint.blockingTrigger.eventType)) {
+            await this.executor
+                .run(async () => {
+                await gcf.setInvokerCreate(endpoint.project, backend.functionName(endpoint), ["public"]);
+            })
+                .catch(rethrowAs(endpoint, "set invoker"));
+        }
     }
     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[endpoint.region]);
-        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 () => {
@@ -224,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;
@@ -252,26 +264,33 @@ class Fabricator {
                     .catch(rethrowAs(endpoint, "set invoker"));
             }
         }
+        else if (backend.isBlockingTriggered(endpoint) &&
+            v1_1.AUTH_BLOCKING_EVENTS.includes(endpoint.blockingTrigger.eventType)) {
+            await this.executor
+                .run(() => run.setInvokerCreate(endpoint.project, serviceName, ["public"]))
+                .catch(rethrowAs(endpoint, "set invoker"));
+        }
         const mem = endpoint.availableMemoryMb || backend.DEFAULT_MEMORY;
         if (mem >= backend.MIN_MEMORY_FOR_CONCURRENCY && endpoint.concurrency !== 1) {
             await this.setConcurrency(endpoint, serviceName, endpoint.concurrency || DEFAULT_GCFV2_CONCURRENCY);
         }
     }
     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;
@@ -279,6 +298,10 @@ class Fabricator {
         else if (backend.isTaskQueueTriggered(endpoint)) {
             invoker = endpoint.taskQueueTrigger.invoker;
         }
+        else if (backend.isBlockingTriggered(endpoint) &&
+            v1_1.AUTH_BLOCKING_EVENTS.includes(endpoint.blockingTrigger.eventType)) {
+            invoker = ["public"];
+        }
         if (invoker) {
             await this.executor
                 .run(() => gcf.setInvokerUpdate(endpoint.project, backend.functionName(endpoint), invoker))
@@ -286,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[endpoint.region]);
-        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;
@@ -310,6 +334,10 @@ class Fabricator {
         else if (backend.isTaskQueueTriggered(endpoint)) {
             invoker = endpoint.taskQueueTrigger.invoker;
         }
+        else if (backend.isBlockingTriggered(endpoint) &&
+            v1_1.AUTH_BLOCKING_EVENTS.includes(endpoint.blockingTrigger.eventType)) {
+            invoker = ["public"];
+        }
         if (invoker) {
             await this.executor
                 .run(() => run.setInvokerUpdate(endpoint.project, serviceName, invoker))
@@ -324,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"));
@@ -334,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"));
@@ -369,6 +397,9 @@ class Fabricator {
         else if (backend.isTaskQueueTriggered(endpoint)) {
             await this.upsertTaskQueue(endpoint);
         }
+        else if (backend.isBlockingTriggered(endpoint)) {
+            await this.registerBlockingTrigger(endpoint);
+        }
     }
     async deleteTrigger(endpoint) {
         if (backend.isScheduleTriggered(endpoint)) {
@@ -385,6 +416,9 @@ class Fabricator {
         else if (backend.isTaskQueueTriggered(endpoint)) {
             await this.disableTaskQueue(endpoint);
         }
+        else if (backend.isBlockingTriggered(endpoint)) {
+            await this.unregisterBlockingTrigger(endpoint);
+        }
     }
     async upsertScheduleV1(endpoint) {
         const job = scheduler.jobFromEndpoint(endpoint, this.appEngineLocation);
@@ -406,6 +440,11 @@ class Fabricator {
                 .catch(rethrowAs(endpoint, "set invoker"));
         }
     }
+    async registerBlockingTrigger(endpoint) {
+        await this.executor
+            .run(() => services.serviceForEndpoint(endpoint).registerTrigger(endpoint))
+            .catch(rethrowAs(endpoint, "register blocking trigger"));
+    }
     async deleteScheduleV1(endpoint) {
         const job = scheduler.jobFromEndpoint(endpoint, this.appEngineLocation);
         await this.executor
@@ -427,10 +466,15 @@ class Fabricator {
             .run(() => cloudtasks.updateQueue(update))
             .catch(rethrowAs(endpoint, "disable task queue"));
     }
+    async unregisterBlockingTrigger(endpoint) {
+        await this.executor
+            .run(() => services.serviceForEndpoint(endpoint).unregisterTrigger(endpoint))
+            .catch(rethrowAs(endpoint, "unregister blocking trigger"));
+    }
     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

@@ -21,7 +21,21 @@ async function release(context, options, payload) {
     if (!context.config) {
         return;
     }
-    const plan = planner.createDeploymentPlan(payload.functions.backend, await backend.existingBackend(context), { filters: context.filters });
+    if (!payload.functions) {
+        return;
+    }
+    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, []);
@@ -40,15 +54,15 @@ async function release(context, options, payload) {
     const fab = new fabricator.Fabricator({
         functionExecutor,
         executor: new executor.QueueExecutor({}),
-        sourceUrl: context.sourceUrl,
-        storage: context.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.backend);
-    const haveEndpoints = backend.allEndpoints(payload.functions.backend);
+    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, []);
@@ -89,7 +103,7 @@ function printTriggerUrls(results) {
     }
     for (const httpsFunc of httpsFunctions) {
         if (!httpsFunc.uri) {
-            logger_1.logger.debug("Missing URI for HTTPS function in printTriggerUrls. This shouldn't happen");
+            logger_1.logger.debug("Not printing URL for HTTPS function. Typically this means it didn't match a filter or we failed deployment");
             continue;
         }
         logger_1.logger.info(clc.bold("Function URL"), `(${(0, functionsDeployHelper_1.getFunctionLabel)(httpsFunc)}):`, httpsFunc.uri);