firebase-tools 9.20.0 → 9.23.1

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, _d;
+    var _a;
     ctx.loadedExistingBackend = true;
     ctx.existingBackend = Object.assign({}, empty());
     ctx.unreachableRegions = {
@@ -113,32 +103,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 +117,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 +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));
@@ -237,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

@@ -1,19 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkHttpIam = exports.checkServiceAccountIam = void 0;
+exports.ensureServiceAgentRoles = exports.mergeBindings = exports.checkHttpIam = exports.checkServiceAccountIam = void 0;
 const cli_color_1 = require("cli-color");
 const logger_1 = require("../../logger");
 const functionsDeployHelper_1 = require("./functionsDeployHelper");
 const error_1 = require("../../error");
-const iam_1 = require("../../gcp/iam");
+const iam = require("../../gcp/iam");
 const backend = require("./backend");
 const track = require("../../track");
+const utils = require("../../utils");
+const resourceManager_1 = require("../../gcp/resourceManager");
+const services_1 = require("./services");
 const PERMISSION = "cloudfunctions.functions.setIamPolicy";
 async function checkServiceAccountIam(projectId) {
     const saEmail = `${projectId}@appspot.gserviceaccount.com`;
     let passed = false;
     try {
-        const iamResult = await iam_1.testResourceIamPermissions("https://iam.googleapis.com", "v1", `projects/${projectId}/serviceAccounts/${saEmail}`, ["iam.serviceAccounts.actAs"]);
+        const iamResult = await iam.testResourceIamPermissions("https://iam.googleapis.com", "v1", `projects/${projectId}/serviceAccounts/${saEmail}`, ["iam.serviceAccounts.actAs"]);
         passed = iamResult.passed;
     }
     catch (err) {
@@ -28,20 +31,20 @@ 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]);
+        const iamResult = await iam.testIamPermissions(context.projectId, [PERMISSION]);
         passed = iamResult.passed;
     }
     catch (e) {
@@ -51,9 +54,67 @@ 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");
 }
 exports.checkHttpIam = checkHttpIam;
+function reduceEventsToServices(services, endpoint) {
+    const service = services_1.serviceForEndpoint(endpoint);
+    if (service.requiredProjectBindings && !services.find((s) => s.name === service.name)) {
+        services.push(service);
+    }
+    return services;
+}
+function mergeBindings(policy, allRequiredBindings) {
+    for (const requiredBindings of allRequiredBindings) {
+        if (requiredBindings.length === 0) {
+            continue;
+        }
+        for (const requiredBinding of requiredBindings) {
+            const ndx = policy.bindings.findIndex((policyBinding) => policyBinding.role === requiredBinding.role);
+            if (ndx === -1) {
+                policy.bindings.push(requiredBinding);
+                continue;
+            }
+            requiredBinding.members.forEach((updatedMember) => {
+                if (!policy.bindings[ndx].members.find((member) => member === updatedMember)) {
+                    policy.bindings[ndx].members.push(updatedMember);
+                }
+            });
+        }
+    }
+}
+exports.mergeBindings = mergeBindings;
+async function ensureServiceAgentRoles(projectId, want, have) {
+    const wantServices = backend.allEndpoints(want).reduce(reduceEventsToServices, []);
+    const haveServices = backend.allEndpoints(have).reduce(reduceEventsToServices, []);
+    const newServices = wantServices.filter((wantS) => !haveServices.find((haveS) => wantS.name === haveS.name));
+    if (newServices.length === 0) {
+        return;
+    }
+    let policy;
+    try {
+        policy = await resourceManager_1.getIamPolicy(projectId);
+    }
+    catch (err) {
+        utils.logLabeledBullet("functions", "Could not verify the necessary IAM configuration for the following newly-integrated services: " +
+            `${newServices.map((service) => service.api).join(", ")}` +
+            ". Deployment may fail.", "warn");
+        return;
+    }
+    const findRequiredBindings = [];
+    newServices.forEach((service) => findRequiredBindings.push(service.requiredProjectBindings(projectId, policy)));
+    const allRequiredBindings = await Promise.all(findRequiredBindings);
+    mergeBindings(policy, allRequiredBindings);
+    try {
+        await resourceManager_1.setIamPolicy(projectId, policy, "bindings");
+    }
+    catch (err) {
+        throw new error_1.FirebaseError("We failed to modify the IAM policy for the project. The functions " +
+            "deployment requires specific roles to be granted to service agents," +
+            " otherwise the deployment will fail.", { original: err });
+    }
+}
+exports.ensureServiceAgentRoles = ensureServiceAgentRoles;

package/lib/deploy/functions/containerCleaner.js

@@ -1,38 +1,15 @@
 "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.NoopArtifactRegistryCleaner = exports.ArtifactRegistryCleaner = exports.cleanupBuildImages = void 0;
 const clc = require("cli-color");
+const error_1 = require("../../error");
 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");
-exports.SUBDOMAIN_MAPPING = {
-    "us-west2": "us",
-    "us-west3": "us",
-    "us-west4": "us",
-    "us-central1": "us",
-    "us-central2": "us",
-    "us-east1": "us",
-    "us-east4": "us",
-    "northamerica-northeast1": "us",
-    "southamerica-east1": "us",
-    "europe-west1": "eu",
-    "europe-west2": "eu",
-    "europe-west3": "eu",
-    "europe-west5": "eu",
-    "europe-west6": "eu",
-    "europe-central2": "eu",
-    "asia-east1": "asia",
-    "asia-east2": "asia",
-    "asia-northeast1": "asia",
-    "asia-northeast2": "asia",
-    "asia-northeast3": "asia",
-    "asia-south1": "asia",
-    "asia-southeast2": "asia",
-    "australia-southeast1": "asia",
-};
+const poller = require("../../operation-poller");
 async function retry(func) {
     const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
     const MAX_RETRIES = 3;
@@ -47,7 +24,7 @@ async function retry(func) {
             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 });
@@ -56,19 +33,40 @@ 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 () => {
+    const cleanup = [];
+    const arCleaner = cleaners.ar || new ArtifactRegistryCleaner();
+    cleanup.push(...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}`);
+        }
+    }));
+    cleanup.push(...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}`);
+        }
+    }));
+    const gcrCleaner = cleaners.gcr || new ContainerRegistryCleaner();
+    cleanup.push(...[...haveFunctions, ...deletedFunctions].map(async (func) => {
         try {
             await gcrCleaner.cleanupFunction(func);
         }
         catch (err) {
-            const path = `${func.project}/${exports.SUBDOMAIN_MAPPING[func.region]}/gcf`;
+            const path = `${func.project}/${docker.GCR_SUBDOMAIN_MAPPING[func.region]}/gcf`;
             failedDomains.add(`https://console.cloud.google.com/gcr/images/${path}`);
         }
-    })()));
+    }));
+    await Promise.all(cleanup);
     if (failedDomains.size) {
         let message = "Unhandled error cleaning up build images. This could result in a small monthly bill if not corrected. ";
         message +=
@@ -83,12 +81,60 @@ async function cleanupBuildImages(functions) {
     }
 }
 exports.cleanupBuildImages = cleanupBuildImages;
+class ArtifactRegistryCleaner {
+    static packagePath(func) {
+        const encodedId = func.id
+            .replace(/_/g, "__")
+            .replace(/-/g, "--")
+            .replace(/^[A-Z]/, (first) => `${first.toLowerCase()}-${first.toLowerCase()}`)
+            .replace(/[A-Z]/g, (upper) => `_${upper.toLowerCase()}`);
+        return `projects/${func.project}/locations/${func.region}/repositories/gcf-artifacts/packages/${encodedId}`;
+    }
+    async cleanupFunction(func) {
+        let op;
+        try {
+            op = await artifactregistry.deletePackage(ArtifactRegistryCleaner.packagePath(func));
+        }
+        catch (err) {
+            if (err.status === 404) {
+                return;
+            }
+            throw err;
+        }
+        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 NoopArtifactRegistryCleaner extends ArtifactRegistryCleaner {
+    cleanupFunction() {
+        return Promise.resolve();
+    }
+    cleanupFunctionCache() {
+        return Promise.resolve();
+    }
+}
+exports.NoopArtifactRegistryCleaner = NoopArtifactRegistryCleaner;
 class ContainerRegistryCleaner {
     constructor() {
         this.helpers = {};
     }
     helper(location) {
-        const subdomain = exports.SUBDOMAIN_MAPPING[location] || "us";
+        const subdomain = docker.GCR_SUBDOMAIN_MAPPING[location] || "us";
         if (!this.helpers[subdomain]) {
             const origin = `https://${subdomain}.${api_1.containerRegistryDomain}`;
             this.helpers[subdomain] = new DockerHelper(origin);
@@ -128,14 +174,14 @@ function getHelper(cache, subdomain) {
 }
 async function listGcfPaths(projectId, locations, dockerHelpers = {}) {
     if (!locations) {
-        locations = Object.keys(exports.SUBDOMAIN_MAPPING);
+        locations = Object.keys(docker.GCR_SUBDOMAIN_MAPPING);
     }
-    const invalidRegion = locations.find((loc) => !exports.SUBDOMAIN_MAPPING[loc]);
+    const invalidRegion = locations.find((loc) => !docker.GCR_SUBDOMAIN_MAPPING[loc]);
     if (invalidRegion) {
         throw new error_1.FirebaseError(`Invalid region ${invalidRegion} supplied`);
     }
     const locationsSet = new Set(locations);
-    const subdomains = new Set(Object.values(exports.SUBDOMAIN_MAPPING));
+    const subdomains = new Set(Object.values(docker.GCR_SUBDOMAIN_MAPPING));
     const failedSubdomains = [];
     const listAll = [];
     for (const subdomain of subdomains) {
@@ -166,26 +212,27 @@ async function listGcfPaths(projectId, locations, dockerHelpers = {}) {
         throw new error_1.FirebaseError(`Failed to search the following subdomains: ${failedSubdomains.join(",")}`);
     }
     return gcfDirs.map((loc) => {
-        return `${exports.SUBDOMAIN_MAPPING[loc]}.${api_1.containerRegistryDomain}/${projectId}/gcf/${loc}`;
+        return `${docker.GCR_SUBDOMAIN_MAPPING[loc]}.${api_1.containerRegistryDomain}/${projectId}/gcf/${loc}`;
     });
 }
 exports.listGcfPaths = listGcfPaths;
 async function deleteGcfArtifacts(projectId, locations, dockerHelpers = {}) {
     if (!locations) {
-        locations = Object.keys(exports.SUBDOMAIN_MAPPING);
+        locations = Object.keys(docker.GCR_SUBDOMAIN_MAPPING);
     }
-    const invalidRegion = locations.find((loc) => !exports.SUBDOMAIN_MAPPING[loc]);
+    const invalidRegion = locations.find((loc) => !docker.GCR_SUBDOMAIN_MAPPING[loc]);
     if (invalidRegion) {
         throw new error_1.FirebaseError(`Invalid region ${invalidRegion} supplied`);
     }
-    const subdomains = new Set(Object.values(exports.SUBDOMAIN_MAPPING));
+    const subdomains = new Set(Object.values(docker.GCR_SUBDOMAIN_MAPPING));
     const failedSubdomains = [];
     const deleteLocations = locations.map((loc) => {
+        const subdomain = docker.GCR_SUBDOMAIN_MAPPING[loc];
         try {
-            return getHelper(dockerHelpers, exports.SUBDOMAIN_MAPPING[loc]).rm(`${projectId}/gcf/${loc}`);
+            return getHelper(dockerHelpers, subdomain).rm(`${projectId}/gcf/${loc}`);
         }
         catch (err) {
-            failedSubdomains.push(exports.SUBDOMAIN_MAPPING[loc]);
+            failedSubdomains.push(subdomain);
             logger_1.logger.debug(err);
         }
     });
@@ -217,7 +264,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);
@@ -225,8 +272,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);
@@ -235,9 +282,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);
@@ -246,7 +293,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) {