firebase-tools 9.18.0 → 9.22.0

package/lib/deploy/extensions/validate.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkBilling = void 0;
+const cloudbilling_1 = require("../../gcp/cloudbilling");
+const checkProjectBilling_1 = require("../../extensions/checkProjectBilling");
+const error_1 = require("../../error");
+async function checkBilling(projectId, nonInteractive) {
+    const enabled = await cloudbilling_1.checkBillingEnabled(projectId);
+    if (!enabled && nonInteractive) {
+        throw new error_1.FirebaseError(`Extensions require the Blaze plan, but project ${projectId} is not on the Blaze plan. ` +
+            `Please visit https://console.cloud.google.com/billing/linkedaccount?project=${projectId} to upgrade your project.`);
+    }
+    else if (!enabled) {
+        await checkProjectBilling_1.enableBilling(projectId);
+    }
+}
+exports.checkBilling = checkBilling;

package/lib/deploy/functions/backend.js

@@ -1,38 +1,29 @@
 "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.isTaskQueueTriggered = 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 if (isTaskQueueTriggered(endpoint)) {
+        return "taskQueue";
+    }
+    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",
@@ -58,39 +49,38 @@ function isScheduleTriggered(triggered) {
     return {}.hasOwnProperty.call(triggered, "scheduleTrigger");
 }
 exports.isScheduleTriggered = isScheduleTriggered;
+function isTaskQueueTriggered(triggered) {
+    return {}.hasOwnProperty.call(triggered, "taskQueueTrigger");
+}
+exports.isTaskQueueTriggered = isTaskQueueTriggered;
 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 +94,7 @@ async function existingBackend(context, forceRefresh) {
 }
 exports.existingBackend = existingBackend;
 async function loadExistingBackend(ctx) {
-    var _a, _b, _c;
+    var _a;
     ctx.loadedExistingBackend = true;
     ctx.existingBackend = Object.assign({}, empty());
     ctx.unreachableRegions = {
@@ -113,79 +103,30 @@ 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) {
         return;
     }
-    const gcfV2Results = await gcfV2.listAllFunctions(ctx.projectId);
-    for (const apiFunction of gcfV2Results.functions) {
-        const specFunction = gcfV2.specFromFunction(apiFunction);
-        ctx.existingBackend.cloudFunctions.push(specFunction);
-        const pubsubScheduled = ((_b = apiFunction.labels) === null || _b === void 0 ? void 0 : _b["deployment-scheduled"]) === "true";
-        const httpsScheduled = ((_c = apiFunction.labels) === null || _c === void 0 ? void 0 : _c["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,
-                },
-            });
+    let gcfV2Results;
+    try {
+        gcfV2Results = await gcfV2.listAllFunctions(ctx.projectId);
+    }
+    catch (err) {
+        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 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;
 }
@@ -196,12 +137,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));
@@ -228,6 +169,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/containerCleaner.js

@@ -1,13 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DockerHelper = exports.deleteGcfArtifacts = exports.listGcfPaths = exports.ContainerRegistryCleaner = exports.cleanupBuildImages = exports.SUBDOMAIN_MAPPING = void 0;
+exports.DockerHelper = exports.deleteGcfArtifacts = exports.listGcfPaths = exports.ContainerRegistryCleaner = exports.ArtifactRegistryCleaner = exports.cleanupBuildImages = exports.SUBDOMAIN_MAPPING = void 0;
 const clc = require("cli-color");
+const error_1 = require("../../error");
+const previews_1 = require("../../previews");
 const api_1 = require("../../api");
 const logger_1 = require("../../logger");
-const docker = require("../../gcp/docker");
+const artifactregistry = require("../../gcp/artifactregistry");
 const backend = require("./backend");
+const docker = require("../../gcp/docker");
 const utils = require("../../utils");
-const error_1 = require("../../error");
+const poller = require("../../operation-poller");
 exports.SUBDOMAIN_MAPPING = {
     "us-west2": "us",
     "us-west3": "us",
@@ -37,13 +40,17 @@ async function retry(func) {
     const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
     const MAX_RETRIES = 3;
     const INITIAL_BACKOFF = 100;
+    const TIMEOUT_MS = 10000;
     let retry = 0;
     while (true) {
         try {
-            return await func();
+            const timeout = new Promise((resolve, reject) => {
+                setTimeout(() => reject(new Error("Timeout")), TIMEOUT_MS);
+            });
+            return await Promise.race([func(), timeout]);
         }
         catch (error) {
-            logger_1.logger.debug("Failed docker command with error", error);
+            logger_1.logger.debug("Failed docker command with error ", error);
             retry += 1;
             if (retry >= MAX_RETRIES) {
                 throw new error_1.FirebaseError("Failed to clean up artifacts", { original: error });
@@ -52,19 +59,47 @@ async function retry(func) {
         }
     }
 }
-async function cleanupBuildImages(functions) {
+async function cleanupBuildImages(haveFunctions, deletedFunctions, cleaners = {}) {
     utils.logBullet(clc.bold.cyan("functions: ") + "cleaning up build files...");
-    const gcrCleaner = new ContainerRegistryCleaner();
     const failedDomains = new Set();
-    await Promise.all(functions.map((func) => (async () => {
-        try {
-            await gcrCleaner.cleanupFunction(func);
-        }
-        catch (err) {
-            const path = `${func.project}/${exports.SUBDOMAIN_MAPPING[func.region]}/gcf`;
-            failedDomains.add(`https://console.cloud.google.com/gcr/images/${path}`);
-        }
-    })()));
+    if (previews_1.previews.artifactregistry) {
+        const arCleaner = cleaners.ar || new ArtifactRegistryCleaner();
+        await Promise.all([
+            ...haveFunctions.map(async (func) => {
+                try {
+                    await arCleaner.cleanupFunction(func);
+                }
+                catch (err) {
+                    const path = `${func.project}/${func.region}/gcf-artifacts`;
+                    failedDomains.add(`https://console.cloud.google.com/artifacts/docker/${path}`);
+                }
+            }),
+            ...deletedFunctions.map(async (func) => {
+                try {
+                    await Promise.all([
+                        arCleaner.cleanupFunction(func),
+                        arCleaner.cleanupFunctionCache(func),
+                    ]);
+                }
+                catch (err) {
+                    const path = `${func.project}/${func.region}/gcf-artifacts`;
+                    failedDomains.add(`https://console.cloud.google.com/artifacts/docker/${path}`);
+                }
+            }),
+        ]);
+    }
+    else {
+        const gcrCleaner = cleaners.gcr || new ContainerRegistryCleaner();
+        await Promise.all([...haveFunctions, ...deletedFunctions].map(async (func) => {
+            try {
+                await gcrCleaner.cleanupFunction(func);
+            }
+            catch (err) {
+                const path = `${func.project}/${exports.SUBDOMAIN_MAPPING[func.region]}/gcf`;
+                failedDomains.add(`https://console.cloud.google.com/gcr/images/${path}`);
+            }
+        }));
+    }
     if (failedDomains.size) {
         let message = "Unhandled error cleaning up build images. This could result in a small monthly bill if not corrected. ";
         message +=
@@ -79,6 +114,31 @@ async function cleanupBuildImages(functions) {
     }
 }
 exports.cleanupBuildImages = cleanupBuildImages;
+class ArtifactRegistryCleaner {
+    static packagePath(func) {
+        return `projects/${func.project}/locations/${func.region}/repositories/gcf-artifacts/packages/${func.id}`;
+    }
+    async cleanupFunction(func) {
+        const op = await artifactregistry.deletePackage(ArtifactRegistryCleaner.packagePath(func));
+        if (op.done) {
+            return;
+        }
+        await poller.pollOperation(Object.assign(Object.assign({}, ArtifactRegistryCleaner.POLLER_OPTIONS), { pollerName: `cleanup-${func.region}-${func.id}`, operationResourceName: op.name }));
+    }
+    async cleanupFunctionCache(func) {
+        const op = await artifactregistry.deletePackage(`${ArtifactRegistryCleaner.packagePath(func)}%2Fcache`);
+        if (op.done) {
+            return;
+        }
+        await poller.pollOperation(Object.assign(Object.assign({}, ArtifactRegistryCleaner.POLLER_OPTIONS), { pollerName: `cleanup-cache-${func.region}-${func.id}`, operationResourceName: op.name }));
+    }
+}
+exports.ArtifactRegistryCleaner = ArtifactRegistryCleaner;
+ArtifactRegistryCleaner.POLLER_OPTIONS = {
+    apiOrigin: api_1.artifactRegistryDomain,
+    apiVersion: artifactregistry.API_VERSION,
+    masterTimeout: 5 * 60 * 1000,
+};
 class ContainerRegistryCleaner {
     constructor() {
         this.helpers = {};
@@ -213,7 +273,7 @@ class DockerHelper {
     async rm(path) {
         let toThrowLater = undefined;
         const stat = await this.ls(path);
-        const recursive = stat.children.map((child) => (async () => {
+        const recursive = stat.children.map(async (child) => {
             try {
                 await this.rm(`${path}/${child}`);
                 stat.children.splice(stat.children.indexOf(child), 1);
@@ -221,8 +281,8 @@ class DockerHelper {
             catch (err) {
                 toThrowLater = err;
             }
-        })());
-        const deleteTags = stat.tags.map((tag) => (async () => {
+        });
+        const deleteTags = stat.tags.map(async (tag) => {
             try {
                 await retry(() => this.client.deleteTag(path, tag));
                 stat.tags.splice(stat.tags.indexOf(tag), 1);
@@ -231,9 +291,9 @@ class DockerHelper {
                 logger_1.logger.debug("Got error trying to remove docker tag:", err);
                 toThrowLater = err;
             }
-        })());
+        });
         await Promise.all(deleteTags);
-        const deleteImages = stat.digests.map((digest) => (async () => {
+        const deleteImages = stat.digests.map(async (digest) => {
             try {
                 await retry(() => this.client.deleteImage(path, digest));
                 stat.digests.splice(stat.digests.indexOf(digest), 1);
@@ -242,7 +302,7 @@ class DockerHelper {
                 logger_1.logger.debug("Got error trying to remove docker image:", err);
                 toThrowLater = err;
             }
-        })());
+        });
         await Promise.all(deleteImages);
         await Promise.all(recursive);
         if (toThrowLater) {

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;