firebase-tools 10.5.0 → 10.7.1

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) {
@@ -124,9 +126,7 @@ class Fabricator {
         await this.setTrigger(endpoint);
     }
     async updateEndpoint(update, scraper) {
-        if (update.deleteAndRecreate || update.endpoint.platform !== "gcfv2") {
-            update.endpoint.labels = Object.assign(Object.assign({}, update.endpoint.labels), deploymentTool.labels());
-        }
+        update.endpoint.labels = Object.assign(Object.assign({}, update.endpoint.labels), deploymentTool.labels());
         if (update.deleteAndRecreate) {
             await this.deleteEndpoint(update.deleteAndRecreate);
             await this.createEndpoint(update.endpoint, scraper);
@@ -153,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";
         }
@@ -166,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")) {
@@ -197,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 () => {
@@ -226,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;
@@ -254,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;
@@ -281,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))
@@ -288,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;
@@ -312,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))
@@ -326,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"));
@@ -336,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"));
@@ -371,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)) {
@@ -387,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);
@@ -408,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
@@ -429,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

@@ -11,14 +11,31 @@ const fabricator = require("./fabricator");
 const reporter = require("./reporter");
 const executor = require("./executor");
 const prompts = require("../prompts");
+const secrets = require("../../../functions/secrets");
 const functionsConfig_1 = require("../../../functionsConfig");
 const functionsDeployHelper_1 = require("../functionsDeployHelper");
 const error_1 = require("../../../error");
+const projectUtils_1 = require("../../../projectUtils");
+const utils_1 = require("../../../utils");
 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, []);
@@ -37,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, []);
@@ -59,6 +76,24 @@ async function release(context, options, payload) {
         const opts = allErrors.length === 1 ? { original: allErrors[0] } : { children: allErrors };
         throw new error_1.FirebaseError("There was an error deploying functions", Object.assign(Object.assign({}, opts), { exit: 2 }));
     }
+    else {
+        if (secrets.of(haveEndpoints).length > 0) {
+            const projectId = (0, projectUtils_1.needProjectId)(options);
+            const projectNumber = await (0, projectUtils_1.needProjectNumber)(options);
+            const reloadedBackend = await backend.existingBackend({ projectId });
+            const prunedResult = await secrets.pruneAndDestroySecrets({ projectId, projectNumber }, backend.allEndpoints(reloadedBackend));
+            if (prunedResult.destroyed.length > 0) {
+                (0, utils_1.logLabeledBullet)("functions", `Destroyed unused secret versions: ${prunedResult.destroyed
+                    .map((s) => `${s.secret}@${s.version}`)
+                    .join(", ")}`);
+            }
+            if (prunedResult.erred.length > 0) {
+                (0, utils_1.logLabeledWarning)("functions", `Failed to destroy unused secret versions:\n\t${prunedResult.erred
+                    .map((err) => err.message)
+                    .join("\n\t")}`);
+            }
+        }
+    }
 }
 exports.release = release;
 function printTriggerUrls(results) {
@@ -68,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);

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

@@ -7,13 +7,13 @@ const error_1 = require("../../../error");
 const utils = require("../../../utils");
 const backend = require("../backend");
 const v2events = require("../../../functions/events/v2");
-function calculateChangesets(want, have, keyFn, options) {
+function calculateChangesets(want, have, keyFn, deleteAll) {
     const toCreate = utils.groupBy(Object.keys(want)
         .filter((id) => !have[id])
         .map((id) => want[id]), keyFn);
     const toDelete = utils.groupBy(Object.keys(have)
         .filter((id) => !want[id])
-        .filter((id) => options.deleteAll || (0, deploymentTool_1.isFirebaseManaged)(have[id].labels || {}))
+        .filter((id) => deleteAll || (0, deploymentTool_1.isFirebaseManaged)(have[id].labels || {}))
         .map((id) => have[id]), keyFn);
     const toUpdate = utils.groupBy(Object.keys(want)
         .filter((id) => have[id])
@@ -48,20 +48,25 @@ function calculateUpdate(want, have) {
     return update;
 }
 exports.calculateUpdate = calculateUpdate;
-function createDeploymentPlan(want, have, options = {}) {
+function createDeploymentPlan(args) {
+    let { wantBackend, haveBackend, codebase, filters, deleteAll } = args;
     let deployment = {};
-    want = backend.matchingBackend(want, (endpoint) => {
-        return (0, functionsDeployHelper_1.functionMatchesAnyGroup)(endpoint, options.filters || []);
+    wantBackend = backend.matchingBackend(wantBackend, (endpoint) => {
+        return (0, functionsDeployHelper_1.endpointMatchesAnyFilter)(endpoint, filters);
     });
-    have = backend.matchingBackend(have, (endpoint) => {
-        return (0, functionsDeployHelper_1.functionMatchesAnyGroup)(endpoint, options.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"}`, options);
+        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 " +
@@ -103,7 +108,6 @@ function changedTriggerRegion(want, have) {
 }
 exports.changedTriggerRegion = changedTriggerRegion;
 function changedV2PubSubTopic(want, have) {
-    var _a, _b;
     if (want.platform !== "gcfv2") {
         return false;
     }
@@ -122,7 +126,7 @@ function changedV2PubSubTopic(want, have) {
     if (have.eventTrigger.eventType !== v2events.PUBSUB_PUBLISH_EVENT) {
         return false;
     }
-    return (((_a = backend.findEventFilter(have, "topic")) === null || _a === void 0 ? void 0 : _a.value) !== ((_b = backend.findEventFilter(want, "topic")) === null || _b === void 0 ? void 0 : _b.value));
+    return have.eventTrigger.eventFilters.topic !== want.eventTrigger.eventFilters.topic;
 }
 exports.changedV2PubSubTopic = changedV2PubSubTopic;
 function upgradedScheduleFromV1ToV2(want, have) {
@@ -158,6 +162,9 @@ function checkForIllegalUpdate(want, have) {
         else if (backend.isTaskQueueTriggered(e)) {
             return "a task queue";
         }
+        else if (backend.isBlockingTriggered(e)) {
+            return e.blockingTrigger.eventType;
+        }
         throw Error("Functions release planner is not able to handle an unknown trigger type");
     };
     const wantType = triggerType(want);

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

@@ -4,7 +4,7 @@ exports.triggerTag = exports.printAbortedErrors = exports.printErrors = exports.
 const backend = require("../backend");
 const clc = require("cli-color");
 const logger_1 = require("../../../logger");
-const track = require("../../../track");
+const track_1 = require("../../../track");
 const utils = require("../../../utils");
 const functionsDeployHelper_1 = require("../functionsDeployHelper");
 class DeploymentError extends Error {
@@ -36,23 +36,23 @@ async function logAndTrackDeployStats(summary) {
         totalTime += result.durationMs;
         if (!result.error) {
             totalSuccesses++;
-            reports.push(track.track("function_deploy_success", tag, result.durationMs));
+            reports.push((0, track_1.track)("function_deploy_success", tag, result.durationMs));
         }
         else if (result.error instanceof AbortedDeploymentError) {
             totalAborts++;
-            reports.push(track.track("function_deploy_abort", tag, result.durationMs));
+            reports.push((0, track_1.track)("function_deploy_abort", tag, result.durationMs));
         }
         else {
             totalErrors++;
-            reports.push(track.track("function_deploy_failure", tag, result.durationMs));
+            reports.push((0, track_1.track)("function_deploy_failure", tag, result.durationMs));
         }
     }
     const regionCountTag = regions.size < 5 ? regions.size.toString() : ">=5";
-    reports.push(track.track("functions_region_count", regionCountTag, 1));
+    reports.push((0, track_1.track)("functions_region_count", regionCountTag, 1));
     const gcfv1 = summary.results.find((r) => r.endpoint.platform === "gcfv1");
     const gcfv2 = summary.results.find((r) => r.endpoint.platform === "gcfv2");
     const tag = gcfv1 && gcfv2 ? "v1+v2" : gcfv1 ? "v1" : "v2";
-    reports.push(track.track("functions_codebase_deploy", tag, summary.results.length));
+    reports.push((0, track_1.track)("functions_codebase_deploy", tag, summary.results.length));
     const avgTime = totalTime / (totalSuccesses + totalErrors);
     logger_1.logger.debug(`Total Function Deployment time: ${summary.totalTime}`);
     logger_1.logger.debug(`${totalErrors + totalSuccesses + totalAborts} Functions Deployed`);
@@ -61,15 +61,15 @@ async function logAndTrackDeployStats(summary) {
     logger_1.logger.debug(`Average Function Deployment time: ${avgTime}`);
     if (totalErrors + totalSuccesses > 0) {
         if (totalErrors === 0) {
-            reports.push(track.track("functions_deploy_result", "success", totalSuccesses));
+            reports.push((0, track_1.track)("functions_deploy_result", "success", totalSuccesses));
         }
         else if (totalSuccesses > 0) {
-            reports.push(track.track("functions_deploy_result", "partial_success", totalSuccesses));
-            reports.push(track.track("functions_deploy_result", "partial_failure", totalErrors));
-            reports.push(track.track("functions_deploy_result", "partial_error_ratio", totalErrors / (totalSuccesses + totalErrors)));
+            reports.push((0, track_1.track)("functions_deploy_result", "partial_success", totalSuccesses));
+            reports.push((0, track_1.track)("functions_deploy_result", "partial_failure", totalErrors));
+            reports.push((0, track_1.track)("functions_deploy_result", "partial_error_ratio", totalErrors / (totalSuccesses + totalErrors)));
         }
         else {
-            reports.push(track.track("functions_deploy_result", "failure", totalErrors));
+            reports.push((0, track_1.track)("functions_deploy_result", "failure", totalErrors));
         }
     }
     await utils.allSettled(reports);
@@ -171,6 +171,9 @@ function triggerTag(endpoint) {
         }
         return `${prefix}.https`;
     }
+    if (backend.isBlockingTriggered(endpoint)) {
+        return `${prefix}.blocking`;
+    }
     return endpoint.eventTrigger.eventType;
 }
 exports.triggerTag = triggerTag;

package/lib/deploy/functions/runtimes/discovery/parsing.js

@@ -19,31 +19,37 @@ function assertKeyTypes(prefix, yaml, schema) {
     }
     for (const [keyAsString, value] of Object.entries(yaml)) {
         const key = keyAsString;
-        const fullKey = prefix ? prefix + "." + key : key;
+        const fullKey = prefix ? `${prefix}.${keyAsString}` : keyAsString;
         if (!schema[key] || schema[key] === "omit") {
             throw new error_1.FirebaseError(`Unexpected key ${fullKey}. You may need to install a newer version of the Firebase CLI.`);
         }
-        if (schema[key] === "string") {
+        const schemaType = schema[key];
+        if (typeof schemaType === "function") {
+            if (!schemaType(value)) {
+                throw new error_1.FirebaseError(`${Array.isArray(value) ? "array" : typeof value} ${fullKey} failed validation`);
+            }
+        }
+        else if (schemaType === "string") {
             if (typeof value !== "string") {
                 throw new error_1.FirebaseError(`Expected ${fullKey} to be string; was ${typeof value}`);
             }
         }
-        else if (schema[key] === "number") {
+        else if (schemaType === "number") {
             if (typeof value !== "number") {
                 throw new error_1.FirebaseError(`Expected ${fullKey} to be a number; was ${typeof value}`);
             }
         }
-        else if (schema[key] === "boolean") {
+        else if (schemaType === "boolean") {
             if (typeof value !== "boolean") {
                 throw new error_1.FirebaseError(`Expected ${fullKey} to be a boolean; was ${typeof value}`);
             }
         }
-        else if (schema[key] === "array") {
+        else if (schemaType === "array") {
             if (!Array.isArray(value)) {
                 throw new error_1.FirebaseError(`Expected ${fullKey} to be an array; was ${typeof value}`);
             }
         }
-        else if (schema[key] === "object") {
+        else if (schemaType === "object") {
             if (value === null || typeof value !== "object" || Array.isArray(value)) {
                 throw new error_1.FirebaseError(`Expected ${fullKey} to be an object; was ${typeof value}`);
             }