firebase-tools 9.21.0 → 9.22.0

package/lib/deploy/extensions/prepare.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepare = void 0;
+const planner = require("./planner");
+const deploymentSummary = require("./deploymentSummary");
+const prompt = require("../../prompt");
+const refs = require("../../extensions/refs");
+const projectUtils_1 = require("../../projectUtils");
+const logger_1 = require("../../logger");
+const error_1 = require("../../error");
+const requirePermissions_1 = require("../../requirePermissions");
+const extensionsHelper_1 = require("../../extensions/extensionsHelper");
+const secretsUtils_1 = require("../../extensions/secretsUtils");
+const secrets_1 = require("./secrets");
+const warnings_1 = require("../../extensions/warnings");
+async function prepare(context, options, payload) {
+    var _a;
+    const projectId = projectUtils_1.needProjectId(options);
+    await extensionsHelper_1.ensureExtensionsApiEnabled(options);
+    await requirePermissions_1.requirePermissions(options, ["firebaseextensions.instances.list"]);
+    context.have = await planner.have(projectId);
+    context.want = await planner.want(projectId, options.config.projectDir, options.config.get("extensions"));
+    const usingSecrets = await Promise.all((_a = context.have) === null || _a === void 0 ? void 0 : _a.map(secrets_1.checkSpecForSecrets));
+    if (usingSecrets.some((i) => i)) {
+        await secretsUtils_1.ensureSecretManagerApiEnabled(options);
+    }
+    payload.instancesToCreate = context.want.filter((i) => { var _a; return !((_a = context.have) === null || _a === void 0 ? void 0 : _a.some(matchesInstanceId(i))); });
+    payload.instancesToConfigure = context.want.filter((i) => { var _a; return (_a = context.have) === null || _a === void 0 ? void 0 : _a.some(isConfigure(i)); });
+    payload.instancesToUpdate = context.want.filter((i) => { var _a; return (_a = context.have) === null || _a === void 0 ? void 0 : _a.some(isUpdate(i)); });
+    payload.instancesToDelete = context.have.filter((i) => { var _a; return !((_a = context.want) === null || _a === void 0 ? void 0 : _a.some(matchesInstanceId(i))); });
+    if (await warnings_1.displayWarningsForDeploy(payload.instancesToCreate)) {
+        if (!options.force && options.nonInteractive) {
+            throw new error_1.FirebaseError("Pass the --force flag to acknowledge these terms in non-interactive mode");
+        }
+        else if (!options.force &&
+            !options.nonInteractive &&
+            !(await prompt.promptOnce({
+                type: "confirm",
+                message: `Do you wish to continue deploying these extensions?`,
+                default: true,
+            }))) {
+            throw new error_1.FirebaseError("Deployment cancelled");
+        }
+    }
+    if (await warnings_1.displayWarningsForDeploy(payload.instancesToCreate)) {
+        if (!options.force && options.nonInteractive) {
+            throw new error_1.FirebaseError("Pass the --force flag to acknowledge these terms in non-interactive mode");
+        }
+        else if (!options.force &&
+            !options.nonInteractive &&
+            !(await prompt.promptOnce({
+                type: "confirm",
+                message: `Do you wish to continue deploying these extensions?`,
+                default: true,
+            }))) {
+            throw new error_1.FirebaseError("Deployment cancelled");
+        }
+    }
+    const permissionsNeeded = [];
+    if (payload.instancesToCreate.length) {
+        permissionsNeeded.push("firebaseextensions.instances.create");
+        logger_1.logger.info(deploymentSummary.createsSummary(payload.instancesToCreate));
+    }
+    if (payload.instancesToUpdate.length) {
+        permissionsNeeded.push("firebaseextensions.instances.update");
+        logger_1.logger.info(deploymentSummary.updatesSummary(payload.instancesToUpdate, context.have));
+    }
+    if (payload.instancesToConfigure.length) {
+        permissionsNeeded.push("firebaseextensions.instances.update");
+        logger_1.logger.info(deploymentSummary.configuresSummary(payload.instancesToConfigure));
+    }
+    if (payload.instancesToDelete.length) {
+        logger_1.logger.info(deploymentSummary.deletesSummary(payload.instancesToDelete));
+        if (!options.force && options.nonInteractive) {
+            throw new error_1.FirebaseError("Pass the --force flag to use this command in non-interactive mode");
+        }
+        else if (!options.force &&
+            !options.nonInteractive &&
+            !(await prompt.promptOnce({
+                type: "confirm",
+                message: `Would you like to delete ${payload.instancesToDelete
+                    .map((i) => i.instanceId)
+                    .join(", ")}?`,
+                default: false,
+            }))) {
+            payload.instancesToDelete = [];
+        }
+        else {
+            permissionsNeeded.push("firebaseextensions.instances.delete");
+        }
+    }
+    await requirePermissions_1.requirePermissions(options, permissionsNeeded);
+}
+exports.prepare = prepare;
+const matchesInstanceId = (dep) => (test) => {
+    return dep.instanceId === test.instanceId;
+};
+const isUpdate = (dep) => (test) => {
+    return dep.instanceId === test.instanceId && !refs.equal(dep.ref, test.ref);
+};
+const isConfigure = (dep) => (test) => {
+    return dep.instanceId === test.instanceId && refs.equal(dep.ref, test.ref);
+};

package/lib/deploy/extensions/release.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.release = void 0;
+const queue_1 = require("../../throttler/queue");
+const tasks = require("./tasks");
+const error_1 = require("../../error");
+const errors_1 = require("./errors");
+const projectUtils_1 = require("../../projectUtils");
+async function release(context, options, payload) {
+    var _a, _b, _c, _d;
+    const projectId = projectUtils_1.needProjectId(options);
+    const errorHandler = new errors_1.ErrorHandler();
+    const deploymentQueue = new queue_1.default({
+        retries: 5,
+        concurrency: 5,
+        handler: tasks.extensionsDeploymentHandler(errorHandler),
+    });
+    for (const creation of (_a = payload.instancesToCreate) !== null && _a !== void 0 ? _a : []) {
+        const task = tasks.createExtensionInstanceTask(projectId, creation);
+        void deploymentQueue.run(task);
+    }
+    for (const update of (_b = payload.instancesToUpdate) !== null && _b !== void 0 ? _b : []) {
+        const task = tasks.updateExtensionInstanceTask(projectId, update);
+        void deploymentQueue.run(task);
+    }
+    for (const update of (_c = payload.instancesToConfigure) !== null && _c !== void 0 ? _c : []) {
+        const task = tasks.configureExtensionInstanceTask(projectId, update);
+        void deploymentQueue.run(task);
+    }
+    for (const deletion of (_d = payload.instancesToDelete) !== null && _d !== void 0 ? _d : []) {
+        const task = tasks.deleteExtensionInstanceTask(projectId, deletion);
+        void deploymentQueue.run(task);
+    }
+    const deploymentPromise = deploymentQueue.wait();
+    deploymentQueue.process();
+    deploymentQueue.close();
+    await deploymentPromise;
+    if (errorHandler.hasErrors()) {
+        errorHandler.print();
+        throw new error_1.FirebaseError(`Extensions deployment failed.`);
+    }
+}
+exports.release = release;

package/lib/deploy/extensions/secrets.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkSpecForSecrets = exports.handleSecretParams = void 0;
+const clc = require("cli-color");
+const secretUtils = require("../../extensions/secretsUtils");
+const secretManager = require("../../gcp/secretManager");
+const planner_1 = require("./planner");
+const askUserForParam_1 = require("../../extensions/askUserForParam");
+const extensionsApi_1 = require("../../extensions/extensionsApi");
+const error_1 = require("../../error");
+const logger_1 = require("../../logger");
+const utils_1 = require("../../utils");
+async function handleSecretParams(payload, have, nonInteractive) {
+    var _a, _b, _c;
+    for (const i of (_a = payload.instancesToCreate) !== null && _a !== void 0 ? _a : []) {
+        if (await checkSpecForSecrets(i)) {
+            utils_1.logLabeledBullet("extensions", `Verifying secret params for ${clc.bold(i.instanceId)}`);
+            await handleSecretsCreateInstance(i, nonInteractive);
+        }
+    }
+    const updates = [...((_b = payload.instancesToUpdate) !== null && _b !== void 0 ? _b : []), ...((_c = payload.instancesToConfigure) !== null && _c !== void 0 ? _c : [])];
+    for (const i of updates) {
+        if (await checkSpecForSecrets(i)) {
+            utils_1.logLabeledBullet("extensions", `Verifying secret params for ${clc.bold(i.instanceId)}`);
+            const previousSpec = have.find((h) => h.instanceId === i.instanceId);
+            await handleSecretsUpdateInstance(i, previousSpec, nonInteractive);
+        }
+    }
+}
+exports.handleSecretParams = handleSecretParams;
+async function checkSpecForSecrets(i) {
+    const extensionVersion = await planner_1.getExtensionVersion(i);
+    return secretUtils.usesSecrets(extensionVersion.spec);
+}
+exports.checkSpecForSecrets = checkSpecForSecrets;
+const secretsInSpec = (spec) => {
+    return spec.params.filter((p) => p.type === extensionsApi_1.ParamType.SECRET);
+};
+async function handleSecretsCreateInstance(i, nonInteractive) {
+    const extensionVersion = await planner_1.getExtensionVersion(i);
+    const secretParams = secretsInSpec(extensionVersion.spec);
+    for (const s of secretParams) {
+        await handleSecretParamForCreate(s, i, nonInteractive);
+    }
+}
+async function handleSecretsUpdateInstance(i, prevSpec, nonInteractive) {
+    const extensionVersion = await planner_1.getExtensionVersion(i);
+    const prevExtensionVersion = await planner_1.getExtensionVersion(prevSpec);
+    const secretParams = secretsInSpec(extensionVersion.spec);
+    for (const s of secretParams) {
+        const prevParam = prevExtensionVersion.spec.params.find((p) => p.param === s.param);
+        if ((prevParam === null || prevParam === void 0 ? void 0 : prevParam.type) === extensionsApi_1.ParamType.SECRET && prevSpec.params[prevParam === null || prevParam === void 0 ? void 0 : prevParam.param]) {
+            await handleSecretParamForUpdate(s, i, prevSpec.params[prevParam === null || prevParam === void 0 ? void 0 : prevParam.param], nonInteractive);
+        }
+        else {
+            await handleSecretParamForCreate(s, i, nonInteractive);
+        }
+    }
+}
+async function handleSecretParamForCreate(secretParam, i, nonInteractive) {
+    var _a;
+    const providedValue = i.params[secretParam.param];
+    if (!providedValue) {
+        return;
+    }
+    const [, projectId, , secretName, , version] = providedValue.split("/");
+    if (!projectId || !secretName || !version) {
+        throw new error_1.FirebaseError(`${clc.bold(i.instanceId)}: Found '${providedValue}' for secret param ${secretParam.param}, but expected a secret version.`);
+    }
+    const secretInfo = await getSecretInfo(projectId, secretName, version);
+    if (!secretInfo.secret) {
+        await promptForCreateSecret({
+            projectId,
+            secretName,
+            instanceId: i.instanceId,
+            secretParam,
+            nonInteractive,
+        });
+        return;
+    }
+    else if (!secretInfo.secretVersion) {
+        throw new error_1.FirebaseError(`${clc.bold(i.instanceId)}: Found '${providedValue}' for secret param ${secretParam.param}. ` +
+            `projects/${projectId}/secrets/${secretName} exists, but version ${version} does not. ` +
+            `See more information about this secret at ${secretManager.secretManagerConsoleUri(projectId)}`);
+    }
+    if (!!((_a = secretInfo === null || secretInfo === void 0 ? void 0 : secretInfo.secret) === null || _a === void 0 ? void 0 : _a.labels) &&
+        !!(secretInfo === null || secretInfo === void 0 ? void 0 : secretInfo.secret.labels[secretUtils.SECRET_LABEL]) &&
+        secretInfo.secret.labels[secretUtils.SECRET_LABEL] !== i.instanceId) {
+        throw new error_1.FirebaseError(`${clc.bold(i.instanceId)}: Found '${providedValue}' for secret param ${secretParam.param}. ` +
+            `projects/${projectId}/secrets/${secretName} is managed by a different extension instance (${secretInfo.secret.labels[secretUtils.SECRET_LABEL]}), so reusing it here can lead to unexpected behavior. ` +
+            "Please choose a different name for this secret, and rerun this command.");
+    }
+    await secretUtils.grantFirexServiceAgentSecretAdminRole(secretInfo.secret);
+}
+async function handleSecretParamForUpdate(secretParam, i, prevValue, nonInteractive) {
+    const providedValue = i.params[secretParam.param];
+    if (!providedValue) {
+        return;
+    }
+    const [, projectId, , secretName, , version] = providedValue.split("/");
+    if (!projectId || !secretName || !version) {
+        throw new error_1.FirebaseError(`${clc.bold(i.instanceId)}: Found '${providedValue}' for secret param ${secretParam.param}, but expected a secret version.`);
+    }
+    const [, prevProjectId, , prevSecretName] = prevValue.split("/");
+    if (prevSecretName !== secretName) {
+        throw new error_1.FirebaseError(`${clc.bold(i.instanceId)}: Found '${providedValue}' for secret param ${secretParam.param}, ` +
+            `but this instance was previously using a different secret projects/${prevProjectId}/secrets/${prevSecretName}.\n` +
+            `Changing secrets is not supported. If you want to change the value of this secret, ` +
+            `use a new version of projects/${prevProjectId}/secrets/${prevSecretName}.` +
+            `You can create a new version at ${secretManager.secretManagerConsoleUri(projectId)}`);
+    }
+    const secretInfo = await getSecretInfo(projectId, secretName, version);
+    if (!secretInfo.secret) {
+        i.params[secretParam.param] = await promptForCreateSecret({
+            projectId,
+            secretName,
+            instanceId: i.instanceId,
+            secretParam,
+            nonInteractive,
+        });
+        return;
+    }
+    else if (!secretInfo.secretVersion) {
+        throw new error_1.FirebaseError(`${clc.bold(i.instanceId)}: Found '${providedValue}' for secret param ${secretParam.param}. ` +
+            `projects/${projectId}/secrets/${secretName} exists, but version ${version} does not. ` +
+            `See more information about this secret at ${secretManager.secretManagerConsoleUri(projectId)}`);
+    }
+    i.params[secretParam.param] = secretManager.toSecretVersionResourceName(secretInfo.secretVersion);
+    await secretUtils.grantFirexServiceAgentSecretAdminRole(secretInfo.secret);
+}
+async function getSecretInfo(projectId, secretName, version) {
+    const secretInfo = {};
+    try {
+        secretInfo.secret = await secretManager.getSecret(projectId, secretName);
+        secretInfo.secretVersion = await secretManager.getSecretVersion(projectId, secretName, version);
+    }
+    catch (err) {
+        if (err.status !== 404) {
+            throw err;
+        }
+    }
+    return secretInfo;
+}
+async function promptForCreateSecret(args) {
+    logger_1.logger.info(`${clc.bold(args.instanceId)}: Secret ${args.projectId}/${args.secretName} doesn't exist yet.`);
+    if (args.nonInteractive) {
+        throw new error_1.FirebaseError(`To create this secret, run this command in interactive mode, or go to ${secretManager.secretManagerConsoleUri(args.projectId)}`);
+    }
+    return askUserForParam_1.promptCreateSecret(args.projectId, args.instanceId, args.secretParam, args.secretName);
+}

package/lib/deploy/extensions/tasks.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteExtensionInstanceTask = exports.configureExtensionInstanceTask = exports.updateExtensionInstanceTask = exports.createExtensionInstanceTask = exports.extensionsDeploymentHandler = void 0;
+const clc = require("cli-color");
+const extensionsApi = require("../../extensions/extensionsApi");
+const refs = require("../../extensions/refs");
+const utils = require("../../utils");
+const isRetryable = (err) => err.status == 429 || err.status == 409;
+function extensionsDeploymentHandler(errorHandler) {
+    return async (task) => {
+        var _a, _b, _c, _d;
+        let result;
+        try {
+            result = await task.run();
+        }
+        catch (err) {
+            if (isRetryable(err)) {
+                throw err;
+            }
+            errorHandler.record(task.spec.instanceId, task.type, (_d = (_c = (_b = (_a = err.context) === null || _a === void 0 ? void 0 : _a.body) === null || _b === void 0 ? void 0 : _b.error) === null || _c === void 0 ? void 0 : _c.message) !== null && _d !== void 0 ? _d : err);
+        }
+        return result;
+    };
+}
+exports.extensionsDeploymentHandler = extensionsDeploymentHandler;
+function createExtensionInstanceTask(projectId, instanceSpec, validateOnly = false) {
+    const run = async () => {
+        const res = await extensionsApi.createInstance({
+            projectId,
+            instanceId: instanceSpec.instanceId,
+            params: instanceSpec.params,
+            extensionVersionRef: refs.toExtensionVersionRef(instanceSpec.ref),
+            validateOnly,
+        });
+        printSuccess(instanceSpec.instanceId, "create", validateOnly);
+        return;
+    };
+    return {
+        run,
+        spec: instanceSpec,
+        type: "create",
+    };
+}
+exports.createExtensionInstanceTask = createExtensionInstanceTask;
+function updateExtensionInstanceTask(projectId, instanceSpec, validateOnly = false) {
+    const run = async () => {
+        const res = await extensionsApi.updateInstanceFromRegistry({
+            projectId,
+            instanceId: instanceSpec.instanceId,
+            extRef: refs.toExtensionVersionRef(instanceSpec.ref),
+            params: instanceSpec.params,
+            validateOnly,
+        });
+        printSuccess(instanceSpec.instanceId, "update", validateOnly);
+        return;
+    };
+    return {
+        run,
+        spec: instanceSpec,
+        type: "update",
+    };
+}
+exports.updateExtensionInstanceTask = updateExtensionInstanceTask;
+function configureExtensionInstanceTask(projectId, instanceSpec, validateOnly = false) {
+    const run = async () => {
+        const res = await extensionsApi.configureInstance({
+            projectId,
+            instanceId: instanceSpec.instanceId,
+            params: instanceSpec.params,
+            validateOnly,
+        });
+        printSuccess(instanceSpec.instanceId, "configure", validateOnly);
+        return;
+    };
+    return {
+        run,
+        spec: instanceSpec,
+        type: "configure",
+    };
+}
+exports.configureExtensionInstanceTask = configureExtensionInstanceTask;
+function deleteExtensionInstanceTask(projectId, instanceSpec) {
+    const run = async () => {
+        const res = await extensionsApi.deleteInstance(projectId, instanceSpec.instanceId);
+        printSuccess(instanceSpec.instanceId, "delete", false);
+        return;
+    };
+    return {
+        run,
+        spec: instanceSpec,
+        type: "delete",
+    };
+}
+exports.deleteExtensionInstanceTask = deleteExtensionInstanceTask;
+function printSuccess(instanceId, type, validateOnly) {
+    const action = validateOnly ? `validated ${type} for` : `${type}d`;
+    utils.logSuccess(clc.bold.green("extensions") + ` Successfully ${action} ${instanceId}`);
+}

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,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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;
+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");
@@ -16,6 +16,9 @@ function endpointTriggerType(endpoint) {
     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));
     }
@@ -46,6 +49,10 @@ 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: {},

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",
@@ -47,7 +50,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 +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 +=
@@ -83,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 = {};
@@ -217,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);
@@ -225,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);
@@ -235,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);
@@ -246,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) {