firebase-tools 9.20.0 → 9.21.0

package/CHANGELOG.md

@@ -1 +1,3 @@
-- `ext:install`, `ext:update` and `ext:configure` now support param type `secret`.
+- Fix Auth Emulator deleteTenant not working with Node Admin (#3817).
+- Fix Crashlytics Android Native Symbols not working on Windows due to ":" in the path (#3842)
+- Fixes Firestore emulator UI showing requests out of order

package/lib/apiv2.js

@@ -118,8 +118,10 @@ class Client {
             reqOptions.headers.set("User-Agent", `FirebaseCLI/${CLI_VERSION}`);
         }
         reqOptions.headers.set("X-Client-Version", `FirebaseCLI/${CLI_VERSION}`);
-        if (reqOptions.responseType === "json") {
-            reqOptions.headers.set("Content-Type", "application/json");
+        if (!reqOptions.headers.has("Content-Type")) {
+            if (reqOptions.responseType === "json") {
+                reqOptions.headers.set("Content-Type", "application/json");
+            }
         }
         return reqOptions;
     }

package/lib/commands/crashlytics-symbols-upload.js

@@ -40,7 +40,7 @@ exports.default = new command_1.Command("crashlytics:symbols:upload <symbolFiles
         jarFile,
         app,
         generator,
-        cachePath: path.join(SYMBOL_CACHE_ROOT_DIR, `crashlytics-${uuid.v4()}`, "nativeSymbols", app, generator),
+        cachePath: path.join(SYMBOL_CACHE_ROOT_DIR, `crashlytics-${uuid.v4()}`, "nativeSymbols", app.replace(/:/g, "-"), generator),
         symbolFile: "",
         generate: true,
     };

package/lib/commands/ext-dev-unpublish.js

@@ -12,11 +12,12 @@ const error_1 = require("../error");
 const checkMinRequiredVersion_1 = require("../checkMinRequiredVersion");
 module.exports = new command_1.Command("ext:dev:unpublish <extensionRef>")
     .description("unpublish an extension")
+    .withForce()
     .help("use this command to unpublish an extension, and make it unavailable for developers to install or reconfigure. " +
     "Specify the extension you want to unpublish using the format '<publisherId>/<extensionId>.")
     .before(requireAuth_1.requireAuth)
     .before(checkMinRequiredVersion_1.checkMinRequiredVersion, "extDevMinVersion")
-    .action(async (extensionRef) => {
+    .action(async (extensionRef, options) => {
     const { publisherId, extensionId, version } = refs.parse(extensionRef);
     utils.logLabeledWarning(extensionsHelper_1.logPrefix, "If you unpublish this extension, developers won't be able to install it. For developers who currently have this extension installed, it will continue to run and will appear as unpublished when listed in the Firebase console or Firebase CLI.");
     utils.logLabeledWarning("This is a permanent action", `Once unpublished, you may never use the extension name '${clc.bold(extensionId)}' again.`);
@@ -24,14 +25,20 @@ module.exports = new command_1.Command("ext:dev:unpublish <extensionRef>")
         throw new error_1.FirebaseError(`Unpublishing a single version is not currently supported. You can only unpublish ${clc.bold("ALL versions")} of an extension. To unpublish all versions, please remove the version from the reference.`);
     }
     await extensionsApi_1.getExtension(extensionRef);
-    const consent = await comfirmUnpublish(publisherId, extensionId);
+    const consent = await comfirmUnpublish(publisherId, extensionId, options);
     if (!consent) {
         throw new error_1.FirebaseError("unpublishing cancelled.");
     }
     await extensionsApi_1.unpublishExtension(extensionRef);
     utils.logLabeledSuccess(extensionsHelper_1.logPrefix, "successfully unpublished all versions of this extension.");
 });
-async function comfirmUnpublish(publisherId, extensionId) {
+async function comfirmUnpublish(publisherId, extensionId, options) {
+    if (options.nonInteractive && !options.force) {
+        throw new error_1.FirebaseError("Pass the --force flag to use this command in non-interactive mode");
+    }
+    if (options.nonInteractive && options.force) {
+        return true;
+    }
     const message = `You are about to unpublish ALL versions of ${clc.green(`${publisherId}/${extensionId}`)}.\nDo you wish to continue? `;
     return prompt_1.promptOnce({
         type: "confirm",

package/lib/commands/functions-delete.js

@@ -1,16 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const command_1 = require("../command");
 const clc = require("cli-color");
 const functionsConfig = require("../functionsConfig");
-const functionsDelete_1 = require("../functionsDelete");
+const command_1 = require("../command");
+const error_1 = require("../error");
 const projectUtils_1 = require("../projectUtils");
 const prompt_1 = require("../prompt");
-const helper = require("../deploy/functions/functionsDeployHelper");
+const functional_1 = require("../functional");
 const requirePermissions_1 = require("../requirePermissions");
+const helper = require("../deploy/functions/functionsDeployHelper");
 const utils = require("../utils");
 const backend = require("../deploy/functions/backend");
-const error_1 = require("../error");
+const planner = require("../deploy/functions/release/planner");
+const fabricator = require("../deploy/functions/release/fabricator");
+const executor = require("../deploy/functions/release/executor");
+const reporter = require("../deploy/functions/release/reporter");
 exports.default = new command_1.Command("functions:delete [filters...]")
     .description("delete one or more Cloud Functions by name or group name.")
     .option("--region <region>", "Specify region of the function to be deleted. " +
@@ -23,48 +27,55 @@ exports.default = new command_1.Command("functions:delete [filters...]")
     }
     const context = {
         projectId: projectUtils_1.needProjectId(options),
+        filters: filters.map((f) => f.split(".")),
     };
-    const filterChunks = filters.map((filter) => {
-        return filter.split(".");
+    const [config, existingBackend] = await Promise.all([
+        functionsConfig.getFirebaseConfig(options),
+        backend.existingBackend(context),
+    ]);
+    await backend.checkAvailability(context, backend.empty());
+    const appEngineLocation = functionsConfig.getAppEngineLocation(config);
+    if (options.region) {
+        existingBackend.endpoints = { [options.region]: existingBackend.endpoints[options.region] };
+    }
+    const plan = planner.createDeploymentPlan(backend.empty(), existingBackend, {
+        filters: context.filters,
+        deleteAll: true,
+    });
+    const allEpToDelete = Object.values(plan)
+        .map((changes) => changes.endpointsToDelete)
+        .reduce(functional_1.reduceFlat, [])
+        .sort(backend.compareFunctions);
+    if (allEpToDelete.length === 0) {
+        throw new error_1.FirebaseError(`The specified filters do not match any existing functions in project ${clc.bold(context.projectId)}.`);
+    }
+    const deleteList = allEpToDelete.map((func) => `\t${helper.getFunctionLabel(func)}`).join("\n");
+    const confirmDeletion = await prompt_1.promptOnce({
+        type: "confirm",
+        name: "force",
+        default: false,
+        message: "You are about to delete the following Cloud Functions:\n" +
+            deleteList +
+            "\n  Are you sure?",
+    }, options);
+    if (!confirmDeletion) {
+        throw new error_1.FirebaseError("Command aborted.");
+    }
+    const functionExecutor = new executor.QueueExecutor({
+        retries: 30,
+        backoff: 20000,
+        concurrency: 40,
+        maxBackoff: 40000,
     });
     try {
-        const [config, existingBackend] = await Promise.all([
-            functionsConfig.getFirebaseConfig(options),
-            backend.existingBackend(context),
-        ]);
-        await backend.checkAvailability(context, backend.empty());
-        const appEngineLocation = functionsConfig.getAppEngineLocation(config);
-        const functionsToDelete = existingBackend.cloudFunctions.filter((fn) => {
-            const regionMatches = options.region ? fn.region === options.region : true;
-            const nameMatches = helper.functionMatchesAnyGroup(fn, filterChunks);
-            return regionMatches && nameMatches;
-        });
-        if (functionsToDelete.length === 0) {
-            throw new Error(`The specified filters do not match any existing functions in project ${clc.bold(context.projectId)}.`);
-        }
-        const schedulesToDelete = existingBackend.schedules.filter((schedule) => {
-            functionsToDelete.some(backend.sameFunctionName(schedule.targetService));
-        });
-        const topicsToDelete = existingBackend.topics.filter((topic) => {
-            functionsToDelete.some(backend.sameFunctionName(topic.targetService));
+        const fab = new fabricator.Fabricator({
+            functionExecutor,
+            executor: new executor.QueueExecutor({}),
+            appEngineLocation,
         });
-        const deleteList = functionsToDelete
-            .map((func) => {
-            return "\t" + helper.getFunctionLabel(func);
-        })
-            .join("\n");
-        const confirmDeletion = await prompt_1.promptOnce({
-            type: "confirm",
-            name: "force",
-            default: false,
-            message: "You are about to delete the following Cloud Functions:\n" +
-                deleteList +
-                "\n  Are you sure?",
-        }, options);
-        if (!confirmDeletion) {
-            throw new Error("Command aborted.");
-        }
-        return await functionsDelete_1.deleteFunctions(functionsToDelete, schedulesToDelete, topicsToDelete, appEngineLocation);
+        const summary = await fab.applyPlan(plan);
+        await reporter.logAndTrackDeployStats(summary);
+        reporter.printErrors(summary);
     }
     catch (err) {
         throw new error_1.FirebaseError("Failed to delete functions", {

package/lib/commands/functions-list.js

@@ -5,7 +5,6 @@ const error_1 = require("../error");
 const projectUtils_1 = require("../projectUtils");
 const requirePermissions_1 = require("../requirePermissions");
 const backend = require("../deploy/functions/backend");
-const listFunctions_1 = require("../functions/listFunctions");
 const previews_1 = require("../previews");
 const logger_1 = require("../logger");
 const Table = require("cli-table");
@@ -17,7 +16,8 @@ exports.default = new command_1.Command("functions:list")
         const context = {
             projectId: projectUtils_1.needProjectId(options),
         };
-        const functionList = await listFunctions_1.listFunctions(context);
+        const existing = await backend.existingBackend(context);
+        const endpointsList = backend.allEndpoints(existing).sort(backend.compareFunctions);
         const table = previews_1.previews.functionsv2
             ? new Table({
                 head: ["Function", "Version", "Trigger", "Location", "Memory", "Runtime"],
@@ -27,23 +27,23 @@ exports.default = new command_1.Command("functions:list")
                 head: ["Function", "Trigger", "Location", "Memory", "Runtime"],
                 style: { head: ["yellow"] },
             });
-        for (const fnSpec of functionList.functions) {
-            const trigger = backend.isEventTrigger(fnSpec.trigger) ? fnSpec.trigger.eventType : "https";
-            const availableMemoryMb = fnSpec.availableMemoryMb || "---";
+        for (const endpoint of endpointsList) {
+            const trigger = backend.endpointTriggerType(endpoint);
+            const availableMemoryMb = endpoint.availableMemoryMb || "---";
             const entry = previews_1.previews.functionsv2
                 ? [
-                    fnSpec.entryPoint,
-                    fnSpec.platform === "gcfv2" ? "v2" : "v1",
+                    endpoint.id,
+                    endpoint.platform === "gcfv2" ? "v2" : "v1",
                     trigger,
-                    fnSpec.region,
+                    endpoint.region,
                     availableMemoryMb,
-                    fnSpec.runtime,
+                    endpoint.runtime,
                 ]
-                : [fnSpec.entryPoint, trigger, fnSpec.region, availableMemoryMb, fnSpec.runtime];
+                : [endpoint.id, trigger, endpoint.region, availableMemoryMb, endpoint.runtime];
             table.push(entry);
         }
         logger_1.logger.info(table.toString());
-        return functionList;
+        return endpointsList;
     }
     catch (err) {
         throw new error_1.FirebaseError("Failed to list functions", {

package/lib/deploy/functions/backend.js

@@ -1,38 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compareFunctions = exports.checkAvailability = exports.existingBackend = exports.scheduleIdForFunction = exports.topicName = exports.scheduleName = exports.sameFunctionName = exports.functionName = exports.isEmptyBackend = exports.empty = exports.isScheduleTriggered = exports.isEventTriggered = exports.isHttpsTriggered = exports.SCHEDULED_FUNCTION_LABEL = exports.memoryOptionDisplayName = exports.triggerTag = exports.isEventTrigger = void 0;
+exports.compareFunctions = exports.missingEndpoint = exports.hasEndpoint = exports.regionalEndpoints = exports.matchingBackend = exports.someEndpoint = exports.allEndpoints = exports.checkAvailability = exports.existingBackend = exports.scheduleIdForFunction = exports.functionName = exports.isEmptyBackend = exports.of = exports.empty = exports.isScheduleTriggered = exports.isEventTriggered = exports.isHttpsTriggered = exports.SCHEDULED_FUNCTION_LABEL = exports.memoryOptionDisplayName = exports.endpointTriggerType = void 0;
 const gcf = require("../../gcp/cloudfunctions");
 const gcfV2 = require("../../gcp/cloudfunctionsv2");
 const utils = require("../../utils");
 const error_1 = require("../../error");
 const previews_1 = require("../../previews");
-function isEventTrigger(trigger) {
-    return "eventType" in trigger;
-}
-exports.isEventTrigger = isEventTrigger;
-function triggerTag(fn) {
-    var _a, _b;
-    if ((_a = fn.labels) === null || _a === void 0 ? void 0 : _a["deployment-scheduled"]) {
-        if (fn.platform === "gcfv1") {
-            return "v1.scheduled";
-        }
-        return "v2.scheduled";
+function endpointTriggerType(endpoint) {
+    if (isScheduleTriggered(endpoint)) {
+        return "scheduled";
     }
-    if ((_b = fn.labels) === null || _b === void 0 ? void 0 : _b["deployment-callable"]) {
-        if (fn.platform === "gcfv1") {
-            return "v1.callable";
-        }
-        return "v2.callable";
+    else if (isHttpsTriggered(endpoint)) {
+        return "https";
     }
-    if (!isEventTrigger(fn.trigger)) {
-        if (fn.platform === "gcfv1") {
-            return "v1.https";
-        }
-        return "v2.https";
+    else if (isEventTriggered(endpoint)) {
+        return endpoint.eventTrigger.eventType;
+    }
+    else {
+        throw new Error("Unexpected trigger type for endpoint " + JSON.stringify(endpoint));
     }
-    return fn.trigger.eventType;
 }
-exports.triggerTag = triggerTag;
+exports.endpointTriggerType = endpointTriggerType;
 function memoryOptionDisplayName(option) {
     return {
         128: "128MB",
@@ -61,36 +49,31 @@ exports.isScheduleTriggered = isScheduleTriggered;
 function empty() {
     return {
         requiredAPIs: {},
-        endpoints: [],
-        cloudFunctions: [],
-        schedules: [],
-        topics: [],
+        endpoints: {},
         environmentVariables: {},
     };
 }
 exports.empty = empty;
+function of(...endpoints) {
+    const bkend = Object.assign({}, empty());
+    for (const endpoint of endpoints) {
+        bkend.endpoints[endpoint.region] = bkend.endpoints[endpoint.region] || {};
+        if (bkend.endpoints[endpoint.region][endpoint.id]) {
+            throw new Error("Trying to create a backend with the same endpiont twice");
+        }
+        bkend.endpoints[endpoint.region][endpoint.id] = endpoint;
+    }
+    return bkend;
+}
+exports.of = of;
 function isEmptyBackend(backend) {
-    return (Object.keys(backend.requiredAPIs).length == 0 &&
-        backend.cloudFunctions.length === 0 &&
-        backend.schedules.length === 0 &&
-        backend.topics.length === 0);
+    return (Object.keys(backend.requiredAPIs).length == 0 && Object.keys(backend.endpoints).length === 0);
 }
 exports.isEmptyBackend = isEmptyBackend;
 function functionName(cloudFunction) {
     return `projects/${cloudFunction.project}/locations/${cloudFunction.region}/functions/${cloudFunction.id}`;
 }
 exports.functionName = functionName;
-exports.sameFunctionName = (func) => (test) => {
-    return func.id === test.id && func.region === test.region && func.project == test.project;
-};
-function scheduleName(schedule, appEngineLocation) {
-    return `projects/${schedule.project}/locations/${appEngineLocation}/jobs/${schedule.id}`;
-}
-exports.scheduleName = scheduleName;
-function topicName(topic) {
-    return `projects/${topic.project}/topics/${topic.id}`;
-}
-exports.topicName = topicName;
 function scheduleIdForFunction(cloudFunction) {
     return `firebase-schedule-${cloudFunction.id}-${cloudFunction.region}`;
 }
@@ -104,7 +87,7 @@ async function existingBackend(context, forceRefresh) {
 }
 exports.existingBackend = existingBackend;
 async function loadExistingBackend(ctx) {
-    var _a, _b, _c, _d;
+    var _a;
     ctx.loadedExistingBackend = true;
     ctx.existingBackend = Object.assign({}, empty());
     ctx.unreachableRegions = {
@@ -113,32 +96,10 @@ async function loadExistingBackend(ctx) {
     };
     const gcfV1Results = await gcf.listAllFunctions(ctx.projectId);
     for (const apiFunction of gcfV1Results.functions) {
-        const specFunction = gcf.specFromFunction(apiFunction);
-        ctx.existingBackend.cloudFunctions.push(specFunction);
-        const isScheduled = ((_a = apiFunction.labels) === null || _a === void 0 ? void 0 : _a["deployment-scheduled"]) === "true";
-        if (isScheduled) {
-            const id = scheduleIdForFunction(specFunction);
-            ctx.existingBackend.schedules.push({
-                id,
-                project: specFunction.project,
-                transport: "pubsub",
-                targetService: {
-                    id: specFunction.id,
-                    region: specFunction.region,
-                    project: specFunction.project,
-                },
-            });
-            ctx.existingBackend.topics.push({
-                id,
-                project: specFunction.project,
-                labels: exports.SCHEDULED_FUNCTION_LABEL,
-                targetService: {
-                    id: specFunction.id,
-                    region: specFunction.region,
-                    project: specFunction.project,
-                },
-            });
-        }
+        const endpoint = gcf.endpointFromFunction(apiFunction);
+        ctx.existingBackend.endpoints[endpoint.region] =
+            ctx.existingBackend.endpoints[endpoint.region] || {};
+        ctx.existingBackend.endpoints[endpoint.region][endpoint.id] = endpoint;
     }
     ctx.unreachableRegions.gcfV1 = gcfV1Results.unreachable;
     if (!previews_1.previews.functionsv2) {
@@ -149,52 +110,16 @@ async function loadExistingBackend(ctx) {
         gcfV2Results = await gcfV2.listAllFunctions(ctx.projectId);
     }
     catch (err) {
-        if (err.status === 404 && ((_b = err.message) === null || _b === void 0 ? void 0 : _b.toLowerCase().includes("method not found"))) {
+        if (err.status === 404 && ((_a = err.message) === null || _a === void 0 ? void 0 : _a.toLowerCase().includes("method not found"))) {
             return;
         }
         throw err;
     }
     for (const apiFunction of gcfV2Results.functions) {
-        const specFunction = gcfV2.specFromFunction(apiFunction);
-        ctx.existingBackend.cloudFunctions.push(specFunction);
-        const pubsubScheduled = ((_c = apiFunction.labels) === null || _c === void 0 ? void 0 : _c["deployment-scheduled"]) === "true";
-        const httpsScheduled = ((_d = apiFunction.labels) === null || _d === void 0 ? void 0 : _d["deployment-scheduled"]) === "https";
-        if (pubsubScheduled) {
-            const id = scheduleIdForFunction(specFunction);
-            ctx.existingBackend.schedules.push({
-                id,
-                project: specFunction.project,
-                transport: "pubsub",
-                targetService: {
-                    id: specFunction.id,
-                    region: specFunction.region,
-                    project: specFunction.project,
-                },
-            });
-            ctx.existingBackend.topics.push({
-                id,
-                project: specFunction.project,
-                labels: exports.SCHEDULED_FUNCTION_LABEL,
-                targetService: {
-                    id: specFunction.id,
-                    region: specFunction.region,
-                    project: specFunction.project,
-                },
-            });
-        }
-        if (httpsScheduled) {
-            const id = scheduleIdForFunction(specFunction);
-            ctx.existingBackend.schedules.push({
-                id,
-                project: specFunction.project,
-                transport: "https",
-                targetService: {
-                    id: specFunction.id,
-                    region: specFunction.region,
-                    project: specFunction.project,
-                },
-            });
-        }
+        const endpoint = gcfV2.endpointFromFunction(apiFunction);
+        ctx.existingBackend.endpoints[endpoint.region] =
+            ctx.existingBackend.endpoints[endpoint.region] || {};
+        ctx.existingBackend.endpoints[endpoint.region][endpoint.id] = endpoint;
     }
     ctx.unreachableRegions.gcfV2 = gcfV2Results.unreachable;
 }
@@ -205,12 +130,12 @@ async function checkAvailability(context, want) {
     }
     const gcfV1Regions = new Set();
     const gcfV2Regions = new Set();
-    for (const fn of want.cloudFunctions) {
-        if (fn.platform == "gcfv1") {
-            gcfV1Regions.add(fn.region);
+    for (const ep of allEndpoints(want)) {
+        if (ep.platform == "gcfv1") {
+            gcfV1Regions.add(ep.region);
         }
         else {
-            gcfV2Regions.add(fn.region);
+            gcfV2Regions.add(ep.region);
         }
     }
     const neededUnreachableV1 = ctx.unreachableRegions.gcfV1.filter((region) => gcfV1Regions.has(region));
@@ -237,6 +162,43 @@ async function checkAvailability(context, want) {
     }
 }
 exports.checkAvailability = checkAvailability;
+function allEndpoints(backend) {
+    return Object.values(backend.endpoints).reduce((accum, perRegion) => {
+        return [...accum, ...Object.values(perRegion)];
+    }, []);
+}
+exports.allEndpoints = allEndpoints;
+function someEndpoint(backend, predicate) {
+    for (const endpoints of Object.values(backend.endpoints)) {
+        if (Object.values(endpoints).some(predicate)) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.someEndpoint = someEndpoint;
+function matchingBackend(backend, predicate) {
+    const filtered = Object.assign({}, empty());
+    for (const endpoint of allEndpoints(backend)) {
+        if (!predicate(endpoint)) {
+            continue;
+        }
+        filtered.endpoints[endpoint.region] = filtered.endpoints[endpoint.region] || {};
+        filtered.endpoints[endpoint.region][endpoint.id] = endpoint;
+    }
+    return filtered;
+}
+exports.matchingBackend = matchingBackend;
+function regionalEndpoints(backend, region) {
+    return backend.endpoints[region] ? Object.values(backend.endpoints[region]) : [];
+}
+exports.regionalEndpoints = regionalEndpoints;
+exports.hasEndpoint = (backend) => (endpoint) => {
+    return !!backend.endpoints[endpoint.region] && !!backend.endpoints[endpoint.region][endpoint.id];
+};
+exports.missingEndpoint = (backend) => (endpoint) => {
+    return !exports.hasEndpoint(backend)(endpoint);
+};
 function compareFunctions(left, right) {
     if (left.platform != right.platform) {
         return right.platform < left.platform ? -1 : 1;

package/lib/deploy/functions/checkIam.js

@@ -28,17 +28,17 @@ async function checkServiceAccountIam(projectId) {
 }
 exports.checkServiceAccountIam = checkServiceAccountIam;
 async function checkHttpIam(context, options, payload) {
-    const functions = payload.functions.backend.cloudFunctions;
     const filterGroups = context.filters || functionsDeployHelper_1.getFilterGroups(options);
-    const httpFunctions = functions
-        .filter((f) => !backend.isEventTrigger(f.trigger))
+    const httpEndpoints = backend
+        .allEndpoints(payload.functions.backend)
+        .filter(backend.isHttpsTriggered)
         .filter((f) => functionsDeployHelper_1.functionMatchesAnyGroup(f, filterGroups));
-    const existingFunctions = (await backend.existingBackend(context)).cloudFunctions;
-    const newHttpFunctions = httpFunctions.filter((func) => !existingFunctions.find(backend.sameFunctionName(func)));
-    if (newHttpFunctions.length === 0) {
+    const existing = await backend.existingBackend(context);
+    const newHttpsEndpoints = httpEndpoints.filter(backend.missingEndpoint(existing));
+    if (newHttpsEndpoints.length === 0) {
         return;
     }
-    logger_1.logger.debug("[functions] found", newHttpFunctions.length, "new HTTP functions, testing setIamPolicy permission...");
+    logger_1.logger.debug("[functions] found", newHttpsEndpoints.length, "new HTTP functions, testing setIamPolicy permission...");
     let passed = true;
     try {
         const iamResult = await iam_1.testIamPermissions(context.projectId, [PERMISSION]);
@@ -51,7 +51,7 @@ async function checkHttpIam(context, options, payload) {
     if (!passed) {
         track("Error (User)", "deploy:functions:http_create_missing_iam");
         throw new error_1.FirebaseError(`Missing required permission on project ${cli_color_1.bold(context.projectId)} to deploy new HTTPS functions. The permission ${cli_color_1.bold(PERMISSION)} is required to deploy the following functions:\n\n- ` +
-            newHttpFunctions.map((func) => func.id).join("\n- ") +
+            newHttpsEndpoints.map((func) => func.id).join("\n- ") +
             `\n\nTo address this error, please ask a project Owner to assign your account the "Cloud Functions Admin" role at the following URL:\n\nhttps://console.cloud.google.com/iam-admin/iam?project=${context.projectId}`);
     }
     logger_1.logger.debug("[functions] found setIamPolicy permission, proceeding with deploy");

package/lib/deploy/functions/deploy.js

@@ -11,6 +11,7 @@ const gcs = require("../../gcp/storage");
 const gcf = require("../../gcp/cloudfunctions");
 const gcfv2 = require("../../gcp/cloudfunctionsv2");
 const utils = require("../../utils");
+const backend = require("./backend");
 const GCP_REGION = api_1.functionsUploadRegion;
 tmp_1.setGracefulCleanup();
 async function uploadSourceV1(context) {
@@ -44,18 +45,11 @@ async function deploy(context, options, payload) {
     try {
         const want = payload.functions.backend;
         const uploads = [];
-        if (want.cloudFunctions.some((fn) => fn.platform === "gcfv1")) {
+        if (backend.allEndpoints(want).some((endpoint) => endpoint.platform === "gcfv1")) {
             uploads.push(uploadSourceV1(context));
         }
-        if (want.cloudFunctions.some((fn) => fn.platform === "gcfv2")) {
-            const functions = payload.functions.backend.cloudFunctions;
-            const regions = [];
-            for (const func of functions) {
-                if (func.platform === "gcfv2" && -1 === regions.indexOf(func.region)) {
-                    regions.push(func.region);
-                }
-            }
-            for (const region of regions) {
+        for (const region of Object.keys(want.endpoints)) {
+            if (backend.regionalEndpoints(want, region).some((e) => e.platform === "gcfv2")) {
                 uploads.push(uploadSourceV2(context, region));
             }
         }

package/lib/deploy/functions/functionsDeployHelper.js

@@ -1,11 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printTriggerUrls = exports.printSuccess = exports.logAndTrackDeployStats = exports.getFunctionLabel = exports.getFunctionId = exports.getFilterGroups = exports.functionMatchesGroup = exports.functionMatchesAnyGroup = void 0;
-const clc = require("cli-color");
-const logger_1 = require("../../logger");
-const backend = require("./backend");
-const track = require("../../track");
-const utils = require("../../utils");
+exports.getFunctionLabel = exports.getFilterGroups = exports.functionMatchesGroup = exports.functionMatchesAnyGroup = void 0;
 function functionMatchesAnyGroup(func, filterGroups) {
     if (!filterGroups.length) {
         return true;
@@ -40,67 +35,7 @@ function getFilterGroups(options) {
     });
 }
 exports.getFilterGroups = getFilterGroups;
-function getFunctionId(fullName) {
-    return fullName.split("/")[5];
-}
-exports.getFunctionId = getFunctionId;
-function getRegion(fullName) {
-    return fullName.split("/")[3];
-}
-function getFunctionLabel(fnOrName) {
-    if (typeof fnOrName === "string") {
-        return getFunctionId(fnOrName) + "(" + getRegion(fnOrName) + ")";
-    }
-    else {
-        return `${fnOrName.id}(${fnOrName.region})`;
-    }
+function getFunctionLabel(fn) {
+    return `${fn.id}(${fn.region})`;
 }
 exports.getFunctionLabel = getFunctionLabel;
-function logAndTrackDeployStats(queue, errorHandler) {
-    const stats = queue.stats();
-    logger_1.logger.debug(`Total Function Deployment time: ${stats.elapsed}`);
-    logger_1.logger.debug(`${stats.total} Functions Deployed`);
-    logger_1.logger.debug(`${errorHandler.errors.length} Functions Errored`);
-    logger_1.logger.debug(`Average Function Deployment time: ${stats.avg}`);
-    if (stats.total > 0) {
-        if (errorHandler.errors.length === 0) {
-            track("functions_deploy_result", "success", stats.total);
-        }
-        else if (errorHandler.errors.length < stats.total) {
-            track("functions_deploy_result", "partial_success", stats.total - errorHandler.errors.length);
-            track("functions_deploy_result", "partial_failure", errorHandler.errors.length);
-            track("functions_deploy_result", "partial_error_ratio", errorHandler.errors.length / stats.total);
-        }
-        else {
-            track("functions_deploy_result", "failure", stats.total);
-        }
-    }
-}
-exports.logAndTrackDeployStats = logAndTrackDeployStats;
-function printSuccess(func, type) {
-    utils.logSuccess(clc.bold.green("functions[" + getFunctionLabel(func) + "]: ") +
-        "Successful " +
-        type +
-        " operation. ");
-}
-exports.printSuccess = printSuccess;
-async function printTriggerUrls(context, want) {
-    const have = await backend.existingBackend(context, true);
-    const httpsFunctions = have.cloudFunctions.filter((fn) => {
-        if (backend.isEventTrigger(fn.trigger)) {
-            return false;
-        }
-        return want.cloudFunctions.some(backend.sameFunctionName(fn));
-    });
-    if (httpsFunctions.length === 0) {
-        return;
-    }
-    for (const httpsFunc of httpsFunctions) {
-        if (!httpsFunc.uri) {
-            logger_1.logger.debug("Missing URI for HTTPS function in printTriggerUrls. This shouldn't happen");
-            continue;
-        }
-        logger_1.logger.info(clc.bold("Function URL"), `(${getFunctionLabel(httpsFunc)}):`, httpsFunc.uri);
-    }
-}
-exports.printTriggerUrls = printTriggerUrls;