firebase-tools 10.4.2 → 10.7.0

package/lib/deploy/functions/functionsDeployHelper.js

@@ -1,40 +1,71 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFunctionLabel = exports.getFilterGroups = exports.functionMatchesGroup = exports.functionMatchesAnyGroup = void 0;
-function functionMatchesAnyGroup(func, filterGroups) {
-    if (!filterGroups.length) {
+exports.getFunctionLabel = exports.getEndpointFilters = exports.parseFunctionSelector = exports.endpointMatchesFilter = exports.endpointMatchesAnyFilter = void 0;
+const projectConfig = require("../../functions/projectConfig");
+function endpointMatchesAnyFilter(endpoint, filters) {
+    if (!filters) {
         return true;
     }
-    return filterGroups.some((groupChunk) => functionMatchesGroup(func, groupChunk));
+    return filters.some((filter) => endpointMatchesFilter(endpoint, filter));
 }
-exports.functionMatchesAnyGroup = functionMatchesAnyGroup;
-function functionMatchesGroup(func, groupChunks) {
-    const functionNameChunks = func.id.split("-").slice(0, groupChunks.length);
-    if (functionNameChunks.length !== groupChunks.length) {
+exports.endpointMatchesAnyFilter = endpointMatchesAnyFilter;
+function endpointMatchesFilter(endpoint, filter) {
+    if (endpoint.codebase && filter.codebase) {
+        if (endpoint.codebase !== filter.codebase) {
+            return false;
+        }
+    }
+    if (!filter.idChunks) {
+        return true;
+    }
+    const idChunks = endpoint.id.split("-");
+    if (idChunks.length < filter.idChunks.length) {
         return false;
     }
-    for (let i = 0; i < groupChunks.length; i += 1) {
-        if (groupChunks[i] !== functionNameChunks[i]) {
+    for (let i = 0; i < filter.idChunks.length; i += 1) {
+        if (idChunks[i] !== filter.idChunks[i]) {
             return false;
         }
     }
     return true;
 }
-exports.functionMatchesGroup = functionMatchesGroup;
-function getFilterGroups(options) {
+exports.endpointMatchesFilter = endpointMatchesFilter;
+function parseFunctionSelector(selector) {
+    const fragments = selector.split(":");
+    if (fragments.length < 2) {
+        return [
+            { codebase: fragments[0] },
+            { codebase: projectConfig.DEFAULT_CODEBASE, idChunks: fragments[0].split(/[-.]/) },
+        ];
+    }
+    return [
+        {
+            codebase: fragments[0],
+            idChunks: fragments[1].split(/[-.]/),
+        },
+    ];
+}
+exports.parseFunctionSelector = parseFunctionSelector;
+function getEndpointFilters(options) {
     if (!options.only) {
-        return [];
-    }
-    const only = options.only.split(",");
-    const onlyFunctions = only.filter((filter) => {
-        const opts = filter.split(":");
-        return opts[0] === "functions" && opts[1];
-    });
-    return onlyFunctions.map((filter) => {
-        return filter.split(":")[1].split(/[.-]/);
-    });
+        return undefined;
+    }
+    const selectors = options.only.split(",");
+    const filters = [];
+    for (let selector of selectors) {
+        if (selector.startsWith("functions:")) {
+            selector = selector.replace("functions:", "");
+            if (selector.length > 0) {
+                filters.push(...parseFunctionSelector(selector));
+            }
+        }
+    }
+    if (filters.length === 0) {
+        return undefined;
+    }
+    return filters;
 }
-exports.getFilterGroups = getFilterGroups;
+exports.getEndpointFilters = getEndpointFilters;
 function getFunctionLabel(fn) {
     return `${fn.id}(${fn.region})`;
 }

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");
@@ -20,6 +20,8 @@ const triggerRegionHelper_1 = require("./triggerRegionHelper");
 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;
 }
@@ -30,6 +32,25 @@ 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.filters = (0, functionsDeployHelper_1.getEndpointFilters)(options);
+    if (context.filters &&
+        !context.filters.map((f) => f.codebase).includes(context.config.codebase)) {
+        throw new error_1.FirebaseError("No function matches given --only filters. Aborting deployment.");
+    }
+    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.artifactRegistryEnabled = checkAPIsEnabled[3];
+    const firebaseConfig = await functionsConfig.getFirebaseConfig(options);
+    context.firebaseConfig = firebaseConfig;
+    let runtimeConfig = { firebase: firebaseConfig };
+    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`);
@@ -46,17 +67,6 @@ async function prepare(context, options, payload) {
     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,
@@ -76,7 +86,46 @@ async function prepare(context, options, payload) {
     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 };
+    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 };
+    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",
@@ -90,36 +139,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 === "gcfv1")) {
-        context.functionsSourceV1 = await (0, prepareFunctionsUpload_1.prepareFunctionsUpload)(sourceDir, context.config, runtimeConfig);
-    }
-    if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv2")) {
-        context.functionsSourceV2 = await (0, prepareFunctionsUpload_1.prepareFunctionsUpload)(sourceDir, context.config);
-    }
-    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);
 }
@@ -155,3 +181,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/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,6 +37,7 @@ 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 {
@@ -124,9 +127,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);
@@ -197,6 +198,14 @@ 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;
@@ -204,7 +213,7 @@ class Fabricator {
             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 apiFunction = gcfV2.functionFromEndpoint(endpoint, this.storage);
         const topic = (_a = apiFunction.eventTrigger) === null || _a === void 0 ? void 0 : _a.pubsubTopic;
         if (topic) {
             await this.executor
@@ -254,6 +263,12 @@ 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);
@@ -281,6 +296,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))
@@ -293,7 +312,7 @@ class Fabricator {
             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]);
+        const apiFunction = gcfV2.functionFromEndpoint(endpoint, this.storage);
         if ((_a = apiFunction.eventTrigger) === null || _a === void 0 ? void 0 : _a.pubsubTopic) {
             delete apiFunction.eventTrigger.pubsubTopic;
         }
@@ -312,6 +331,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))
@@ -371,6 +394,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 +413,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 +437,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,6 +463,11 @@ 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);

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

@@ -11,14 +11,21 @@ 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;
+    }
+    const { wantBackend, haveBackend } = payload.functions;
+    const plan = planner.createDeploymentPlan(wantBackend, haveBackend, context.filters);
     const fnsToDelete = Object.values(plan)
         .map((regionalChanges) => regionalChanges.endpointsToDelete)
         .reduce(functional_1.reduceFlat, []);
@@ -37,15 +44,15 @@ async function release(context, options, payload) {
     const fab = new fabricator.Fabricator({
         functionExecutor,
         executor: new executor.QueueExecutor({}),
-        sourceUrl: context.sourceUrl,
-        storage: context.storage,
+        sourceUrl: context.source.sourceUrl,
+        storage: context.source.storage,
         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);
+    printTriggerUrls(payload.functions.wantBackend);
+    const haveEndpoints = backend.allEndpoints(payload.functions.wantBackend);
     const deletedEndpoints = Object.values(plan)
         .map((r) => r.endpointsToDelete)
         .reduce(functional_1.reduceFlat, []);
@@ -59,6 +66,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 +93,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,17 +48,17 @@ function calculateUpdate(want, have) {
     return update;
 }
 exports.calculateUpdate = calculateUpdate;
-function createDeploymentPlan(want, have, options = {}) {
+function createDeploymentPlan(want, have, filters, deleteAll) {
     let deployment = {};
     want = backend.matchingBackend(want, (endpoint) => {
-        return (0, functionsDeployHelper_1.functionMatchesAnyGroup)(endpoint, options.filters || []);
+        return (0, functionsDeployHelper_1.endpointMatchesAnyFilter)(endpoint, filters);
     });
     have = backend.matchingBackend(have, (endpoint) => {
-        return (0, functionsDeployHelper_1.functionMatchesAnyGroup)(endpoint, options.filters || []);
+        return (0, functionsDeployHelper_1.endpointMatchesAnyFilter)(endpoint, filters);
     });
     const regions = new Set([...Object.keys(want.endpoints), ...Object.keys(have.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(want.endpoints[region] || {}, have.endpoints[region] || {}, (e) => `${e.region}-${e.availableMemoryMb || "default"}`, deleteAll);
         deployment = Object.assign(Object.assign({}, deployment), changesets);
     }
     if (upgradedToGCFv2WithoutSettingConcurrency(want, have)) {
@@ -103,7 +103,6 @@ function changedTriggerRegion(want, have) {
 }
 exports.changedTriggerRegion = changedTriggerRegion;
 function changedV2PubSubTopic(want, have) {
-    var _a, _b;
     if (want.platform !== "gcfv2") {
         return false;
     }
@@ -122,7 +121,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 +157,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);