firebase-tools 9.19.0 → 9.23.0

package/lib/deploy/functions/errorHandler.js

@@ -1,75 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ErrorHandler = void 0;
-const clc = require("cli-color");
-const logger_1 = require("../../logger");
-const functionsDeployHelper_1 = require("./functionsDeployHelper");
-const error_1 = require("../../error");
-class ErrorHandler {
-    constructor() {
-        this.errors = [];
-        this.warnings = [];
-    }
-    record(level, functionName, operationType, message) {
-        const info = {
-            functionName,
-            operationType,
-            message,
-        };
-        if (level === "error") {
-            this.errors.push(info);
-        }
-        else if (level === "warning") {
-            this.warnings.push(info);
-        }
-    }
-    printErrors() {
-        if (this.errors.length === 0) {
-            return;
-        }
-        logger_1.logger.info("");
-        logger_1.logger.info("Functions deploy had errors with the following functions:");
-        for (const failedDeployment of this.errors) {
-            logger_1.logger.info(`\t${functionsDeployHelper_1.getFunctionLabel(failedDeployment.functionName)}`);
-        }
-        const failedIamCalls = this.errors.filter((e) => e.operationType === "set invoker");
-        if (failedIamCalls.length) {
-            logger_1.logger.info("");
-            logger_1.logger.info("Unable to set the invoker for the IAM policy on the following functions:");
-            for (const failedDep of failedIamCalls) {
-                logger_1.logger.info(`\t${failedDep.functionName}`);
-            }
-            logger_1.logger.info("");
-            logger_1.logger.info("Some common causes of this:");
-            logger_1.logger.info("");
-            logger_1.logger.info("- You may not have the roles/functions.admin IAM role. Note that roles/functions.developer does not allow you to change IAM policies.");
-            logger_1.logger.info("");
-            logger_1.logger.info("- An organization policy that restricts Network Access on your project.");
-        }
-        logger_1.logger.info("");
-        logger_1.logger.info("To try redeploying those functions, run:");
-        logger_1.logger.info("    " +
-            clc.bold("firebase deploy --only ") +
-            clc.bold('"') +
-            clc.bold(this.errors
-                .map((failedDeployment) => `functions:${functionsDeployHelper_1.getFunctionId(failedDeployment.functionName).replace(/-/g, ".")}`)
-                .join(",")) +
-            clc.bold('"'));
-        logger_1.logger.info("");
-        logger_1.logger.info("To continue deploying other features (such as database), run:");
-        logger_1.logger.info("    " + clc.bold("firebase deploy --except functions"));
-        for (const failedDeployment of this.errors) {
-            logger_1.logger.debug(`\tError during ${failedDeployment.operationType} for ${failedDeployment.functionName}: ${failedDeployment.message}`);
-        }
-        throw new error_1.FirebaseError("Functions did not deploy properly.");
-    }
-    printWarnings() {
-        if (this.warnings.length === 0) {
-            return;
-        }
-        for (const failedDeployment of this.warnings) {
-            logger_1.logger.debug(`\tWarning during${failedDeployment.operationType} for ${failedDeployment.functionName}: ${failedDeployment.message}`);
-        }
-    }
-}
-exports.ErrorHandler = ErrorHandler;

package/lib/deploy/functions/release.js

@@ -1,116 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.release = void 0;
-const queue_1 = require("../../throttler/queue");
-const deploymentPlanner_1 = require("./deploymentPlanner");
-const functionsConfig_1 = require("../../functionsConfig");
-const env_1 = require("../../functions/env");
-const prompts_1 = require("./prompts");
-const deploymentTimer_1 = require("./deploymentTimer");
-const errorHandler_1 = require("./errorHandler");
-const previews_1 = require("../../previews");
-const backend = require("./backend");
-const containerCleaner = require("./containerCleaner");
-const helper = require("./functionsDeployHelper");
-const tasks = require("./tasks");
-const utils = require("../../utils");
-const track_1 = require("../../track");
-async function release(context, options, payload) {
-    if (!options.config.has("functions")) {
-        return;
-    }
-    const projectId = context.projectId;
-    const sourceUrl = context.uploadUrl;
-    const functionsSource = options.config.get("functions.source");
-    const appEngineLocation = functionsConfig_1.getAppEngineLocation(context.firebaseConfig);
-    const timer = new deploymentTimer_1.DeploymentTimer();
-    const errorHandler = new errorHandler_1.ErrorHandler();
-    const fullDeployment = deploymentPlanner_1.createDeploymentPlan(payload.functions.backend, await backend.existingBackend(context), {
-        filters: context.filters,
-        overwriteEnvs: previews_1.previews.dotenv &&
-            env_1.hasUserEnvs({
-                functionsSource: options.config.path(functionsSource),
-                projectId,
-                projectAlias: options.projectAlias,
-            }),
-    });
-    const cloudFunctionsQueue = new queue_1.default({
-        retries: 30,
-        backoff: 20000,
-        concurrency: 40,
-        maxBackoff: 40000,
-        handler: tasks.functionsDeploymentHandler(timer, errorHandler),
-    });
-    const schedulerQueue = new queue_1.default({
-        handler: tasks.schedulerDeploymentHandler(errorHandler),
-    });
-    const pubSubQueue = new queue_1.default({
-        handler: tasks.schedulerDeploymentHandler(errorHandler),
-    });
-    const regionPromises = [];
-    const taskParams = {
-        projectId,
-        sourceUrl,
-        storage: context.storage,
-        errorHandler,
-    };
-    const allFnsToDelete = Object.values(fullDeployment.regionalDeployments).reduce((accum, region) => [...accum, ...region.functionsToDelete], []);
-    const shouldDeleteFunctions = await prompts_1.promptForFunctionDeletion(allFnsToDelete, options.force, options.nonInteractive);
-    if (!shouldDeleteFunctions) {
-        fullDeployment.schedulesToDelete = fullDeployment.schedulesToDelete.filter((schedule) => {
-            return !allFnsToDelete.find(backend.sameFunctionName(schedule.targetService));
-        });
-        fullDeployment.topicsToDelete = fullDeployment.topicsToDelete.filter((topic) => {
-            return !allFnsToDelete.find(backend.sameFunctionName(topic.targetService));
-        });
-        for (const regionalDeployment of Object.values(fullDeployment.regionalDeployments)) {
-            regionalDeployment.functionsToDelete = [];
-        }
-    }
-    for (const [region, deployment] of Object.entries(fullDeployment.regionalDeployments)) {
-        regionPromises.push(tasks.runRegionalFunctionDeployment(taskParams, region, deployment, cloudFunctionsQueue));
-    }
-    for (const schedule of fullDeployment.schedulesToUpsert) {
-        const task = tasks.upsertScheduleTask(taskParams, schedule, appEngineLocation);
-        void schedulerQueue.run(task);
-    }
-    for (const schedule of fullDeployment.schedulesToDelete) {
-        const task = tasks.deleteScheduleTask(taskParams, schedule, appEngineLocation);
-        void schedulerQueue.run(task);
-    }
-    for (const topic of fullDeployment.topicsToDelete) {
-        const task = tasks.deleteTopicTask(taskParams, topic);
-        void pubSubQueue.run(task);
-    }
-    const queuePromises = [cloudFunctionsQueue.wait(), schedulerQueue.wait(), pubSubQueue.wait()];
-    cloudFunctionsQueue.process();
-    schedulerQueue.process();
-    pubSubQueue.process();
-    schedulerQueue.close();
-    pubSubQueue.close();
-    await Promise.all(regionPromises);
-    cloudFunctionsQueue.close();
-    try {
-        await Promise.all(queuePromises);
-    }
-    catch (err) {
-        utils.reject("Exceeded maximum retries while deploying functions. " +
-            "If you are deploying a large number of functions, " +
-            "please deploy your functions in batches by using the --only flag, " +
-            "and wait a few minutes before deploying again. " +
-            "Go to https://firebase.google.com/docs/cli/#partial_deploys to learn more.", {
-            original: err,
-        });
-    }
-    const functions = payload.functions.backend.cloudFunctions;
-    const gcfv1 = functions.find((fn) => fn.platform === "gcfv1");
-    const gcfv2 = functions.find((fn) => fn.platform === "gcfv2");
-    const tag = gcfv1 && gcfv2 ? "v1+v2" : gcfv1 ? "v1" : "v2";
-    track_1.track("functions_codebase_deploy", tag, functions.length);
-    helper.logAndTrackDeployStats(cloudFunctionsQueue, errorHandler);
-    await containerCleaner.cleanupBuildImages(payload.functions.backend.cloudFunctions);
-    await helper.printTriggerUrls(context, payload.functions.backend);
-    errorHandler.printWarnings();
-    errorHandler.printErrors();
-}
-exports.release = release;

package/lib/deploy/functions/tasks.js

@@ -1,324 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.schedulerDeploymentHandler = exports.deleteTopicTask = exports.deleteScheduleTask = exports.upsertScheduleTask = exports.runRegionalFunctionDeployment = exports.functionsDeploymentHandler = exports.deleteFunctionTask = exports.updateFunctionTask = exports.createFunctionTask = void 0;
-const clc = require("cli-color");
-const logger_1 = require("../../logger");
-const operation_poller_1 = require("../../operation-poller");
-const api_1 = require("../../api");
-const runtimes_1 = require("./runtimes");
-const backend = require("./backend");
-const cloudscheduler = require("../../gcp/cloudscheduler");
-const deploymentTool = require("../../deploymentTool");
-const gcf = require("../../gcp/cloudfunctions");
-const gcfV2 = require("../../gcp/cloudfunctionsv2");
-const cloudrun = require("../../gcp/run");
-const helper = require("./functionsDeployHelper");
-const pubsub = require("../../gcp/pubsub");
-const utils = require("../../utils");
-const error_1 = require("../../error");
-const track_1 = require("../../track");
-const gcfV1PollerOptions = {
-    apiOrigin: api_1.functionsOrigin,
-    apiVersion: gcf.API_VERSION,
-    masterTimeout: 25 * 60 * 1000,
-};
-const gcfV2PollerOptions = {
-    apiOrigin: api_1.functionsV2Origin,
-    apiVersion: gcfV2.API_VERSION,
-    masterTimeout: 25 * 60 * 1000,
-};
-const pollerOptionsByPlatform = {
-    gcfv1: gcfV1PollerOptions,
-    gcfv2: gcfV2PollerOptions,
-};
-function createFunctionTask(params, fn, sourceToken, onPoll) {
-    const fnName = backend.functionName(fn);
-    const run = async () => {
-        var _a;
-        utils.logBullet(clc.bold.cyan("functions: ") +
-            "creating " +
-            runtimes_1.getHumanFriendlyRuntimeName(fn.runtime) +
-            " function " +
-            clc.bold(helper.getFunctionLabel(fn)) +
-            "...");
-        let op;
-        if (fn.platform === "gcfv1") {
-            const apiFunction = gcf.functionFromSpec(fn, params.sourceUrl);
-            if (sourceToken) {
-                apiFunction.sourceToken = sourceToken;
-            }
-            op = await gcf.createFunction(apiFunction);
-        }
-        else {
-            const apiFunction = gcfV2.functionFromSpec(fn, params.storage[fn.region]);
-            if ((_a = apiFunction.eventTrigger) === null || _a === void 0 ? void 0 : _a.pubsubTopic) {
-                try {
-                    await pubsub.getTopic(apiFunction.eventTrigger.pubsubTopic);
-                }
-                catch (err) {
-                    if (err.status !== 404) {
-                        throw new error_1.FirebaseError("Unexpected error looking for Pub/Sub topic", {
-                            original: err,
-                        });
-                    }
-                    await pubsub.createTopic({
-                        name: apiFunction.eventTrigger.pubsubTopic,
-                    });
-                }
-            }
-            op = await gcfV2.createFunction(apiFunction);
-        }
-        const cloudFunction = await operation_poller_1.pollOperation(Object.assign(Object.assign({}, pollerOptionsByPlatform[fn.platform]), { pollerName: `create-${fnName}`, operationResourceName: op.name, onPoll }));
-        if (!backend.isEventTrigger(fn.trigger)) {
-            const invoker = fn.trigger.invoker || ["public"];
-            if (invoker[0] !== "private") {
-                try {
-                    if (fn.platform === "gcfv1") {
-                        await gcf.setInvokerCreate(params.projectId, fnName, invoker);
-                    }
-                    else {
-                        const serviceName = cloudFunction.serviceConfig.service;
-                        cloudrun.setInvokerCreate(params.projectId, serviceName, invoker);
-                    }
-                }
-                catch (err) {
-                    params.errorHandler.record("error", fnName, "set invoker", err.message);
-                }
-            }
-        }
-        if (fn.platform !== "gcfv1") {
-            await setConcurrency(cloudFunction.serviceConfig.service, fn.concurrency || 80);
-        }
-    };
-    return {
-        run,
-        data: fn,
-        operationType: "create",
-    };
-}
-exports.createFunctionTask = createFunctionTask;
-function updateFunctionTask(params, fn, sourceToken, onPoll) {
-    const fnName = backend.functionName(fn);
-    const run = async () => {
-        var _a;
-        utils.logBullet(clc.bold.cyan("functions: ") +
-            "updating " +
-            runtimes_1.getHumanFriendlyRuntimeName(fn.runtime) +
-            " function " +
-            clc.bold(helper.getFunctionLabel(fn)) +
-            "...");
-        let opName;
-        if (fn.platform == "gcfv1") {
-            const apiFunction = gcf.functionFromSpec(fn, params.sourceUrl);
-            if (sourceToken) {
-                apiFunction.sourceToken = sourceToken;
-            }
-            opName = (await gcf.updateFunction(apiFunction)).name;
-        }
-        else {
-            const apiFunction = gcfV2.functionFromSpec(fn, params.storage[fn.region]);
-            if ((_a = apiFunction.eventTrigger) === null || _a === void 0 ? void 0 : _a.pubsubTopic) {
-                delete apiFunction.eventTrigger.pubsubTopic;
-            }
-            opName = (await gcfV2.updateFunction(apiFunction)).name;
-        }
-        const pollerOptions = Object.assign(Object.assign({}, pollerOptionsByPlatform[fn.platform]), { pollerName: `update-${fnName}`, operationResourceName: opName, onPoll });
-        const cloudFunction = await operation_poller_1.pollOperation(pollerOptions);
-        if (!backend.isEventTrigger(fn.trigger) && fn.trigger.invoker) {
-            try {
-                if (fn.platform === "gcfv1") {
-                    await gcf.setInvokerUpdate(params.projectId, fnName, fn.trigger.invoker);
-                }
-                else {
-                    const serviceName = cloudFunction.serviceConfig.service;
-                    cloudrun.setInvokerUpdate(params.projectId, serviceName, fn.trigger.invoker);
-                }
-            }
-            catch (err) {
-                params.errorHandler.record("error", fnName, "set invoker", err.message);
-            }
-        }
-        if ("concurrency" in fn) {
-            if (fn.platform === "gcfv1") {
-                throw new error_1.FirebaseError("Precondition failed: GCFv1 does not support concurrency");
-            }
-            else {
-                await setConcurrency(cloudFunction.serviceConfig.service, fn.concurrency || 80);
-            }
-        }
-    };
-    return {
-        run,
-        data: fn,
-        operationType: "update",
-    };
-}
-exports.updateFunctionTask = updateFunctionTask;
-function deleteFunctionTask(params, fn) {
-    const fnName = backend.functionName(fn);
-    const run = async () => {
-        utils.logBullet(clc.bold.cyan("functions: ") +
-            "deleting function " +
-            clc.bold(helper.getFunctionLabel(fnName)) +
-            "...");
-        let res;
-        if (fn.platform == "gcfv1") {
-            res = await gcf.deleteFunction(fnName);
-        }
-        else {
-            res = await gcfV2.deleteFunction(fnName);
-        }
-        const pollerOptions = Object.assign(Object.assign({}, pollerOptionsByPlatform[fn.platform]), { pollerName: `delete-${fnName}`, operationResourceName: res.name });
-        await operation_poller_1.pollOperation(pollerOptions);
-    };
-    return {
-        run,
-        data: fn,
-        operationType: "delete",
-    };
-}
-exports.deleteFunctionTask = deleteFunctionTask;
-async function setConcurrency(name, concurrency) {
-    const err = null;
-    while (true) {
-        const service = await cloudrun.getService(name);
-        delete service.status;
-        delete service.spec.template.metadata.name;
-        service.spec.template.spec.containerConcurrency = concurrency;
-        try {
-            await cloudrun.replaceService(name, service);
-            return;
-        }
-        catch (err) {
-            if (err.status !== 409) {
-                throw new error_1.FirebaseError("Unexpected error while trying to set concurrency", {
-                    original: err,
-                });
-            }
-        }
-    }
-}
-function functionsDeploymentHandler(timer, errorHandler) {
-    return async (task) => {
-        var _a, _b, _c, _d;
-        let result;
-        const fnName = backend.functionName(task.data);
-        try {
-            timer.startTimer(fnName, task.operationType);
-            result = await task.run();
-            helper.printSuccess(task.data, task.operationType);
-            const duration = timer.endTimer(fnName);
-            track_1.track("function_deploy_success", backend.triggerTag(task.data), duration);
-        }
-        catch (err) {
-            if (((_c = (_b = (_a = err.original) === null || _a === void 0 ? void 0 : _a.context) === null || _b === void 0 ? void 0 : _b.response) === null || _c === void 0 ? void 0 : _c.statusCode) === 429) {
-                throw err;
-            }
-            errorHandler.record("error", fnName, task.operationType, ((_d = err.original) === null || _d === void 0 ? void 0 : _d.message) || "");
-            const duration = timer.endTimer(fnName);
-            track_1.track("function_deploy_failure", backend.triggerTag(task.data), duration);
-        }
-        return result;
-    };
-}
-exports.functionsDeploymentHandler = functionsDeploymentHandler;
-async function runRegionalFunctionDeployment(params, region, regionalDeployment, queue) {
-    let resolveToken;
-    const getRealToken = new Promise((resolve) => (resolveToken = resolve));
-    let firstToken = true;
-    const getToken = () => {
-        if (firstToken) {
-            firstToken = false;
-            return Promise.resolve(undefined);
-        }
-        return getRealToken;
-    };
-    const onPollFn = (op) => {
-        var _a, _b;
-        if (((_a = op.metadata) === null || _a === void 0 ? void 0 : _a.sourceToken) || op.done) {
-            logger_1.logger.debug(`Got sourceToken ${op.metadata.sourceToken} for region ${region}`);
-            resolveToken((_b = op.metadata) === null || _b === void 0 ? void 0 : _b.sourceToken);
-        }
-    };
-    const deploy = async (functionSpec, createTask) => {
-        functionSpec.labels = Object.assign(Object.assign({}, (functionSpec.labels || {})), deploymentTool.labels());
-        let task;
-        if (functionSpec.platform == "gcfv2") {
-            task = createTask(params, functionSpec, undefined, () => undefined);
-        }
-        else {
-            const sourceToken = await getToken();
-            task = createTask(params, functionSpec, sourceToken, onPollFn);
-        }
-        return queue.run(task);
-    };
-    const deploys = [];
-    deploys.push(...regionalDeployment.functionsToCreate.map((fn) => deploy(fn, createFunctionTask)));
-    deploys.push(...regionalDeployment.functionsToUpdate.map(async (update) => {
-        if (update.deleteAndRecreate) {
-            await queue.run(deleteFunctionTask(params, update.func));
-            return deploy(update.func, createFunctionTask);
-        }
-        else {
-            return deploy(update.func, updateFunctionTask);
-        }
-    }));
-    await Promise.all(deploys);
-    const deletes = regionalDeployment.functionsToDelete.map(async (fn) => {
-        const task = deleteFunctionTask(params, fn);
-        await queue.run(task);
-    });
-    await Promise.all(deletes);
-}
-exports.runRegionalFunctionDeployment = runRegionalFunctionDeployment;
-function upsertScheduleTask(params, schedule, appEngineLocation) {
-    const run = async () => {
-        const job = cloudscheduler.jobFromSpec(schedule, appEngineLocation);
-        await cloudscheduler.createOrReplaceJob(job);
-    };
-    return {
-        run,
-        data: schedule,
-        operationType: "upsert schedule",
-    };
-}
-exports.upsertScheduleTask = upsertScheduleTask;
-function deleteScheduleTask(params, schedule, appEngineLocation) {
-    const run = async () => {
-        const jobName = backend.scheduleName(schedule, appEngineLocation);
-        await cloudscheduler.deleteJob(jobName);
-    };
-    return {
-        run,
-        data: schedule,
-        operationType: "delete schedule",
-    };
-}
-exports.deleteScheduleTask = deleteScheduleTask;
-function deleteTopicTask(params, topic) {
-    const run = async () => {
-        const topicName = backend.topicName(topic);
-        await pubsub.deleteTopic(topicName);
-    };
-    return {
-        run,
-        data: topic,
-        operationType: "delete topic",
-    };
-}
-exports.deleteTopicTask = deleteTopicTask;
-exports.schedulerDeploymentHandler = (errorHandler) => async (task) => {
-    try {
-        const result = await task.run();
-        helper.printSuccess(task.data.targetService, task.operationType);
-        return result;
-    }
-    catch (err) {
-        if (err.status === 429) {
-            throw err;
-        }
-        else if (err.status !== 404) {
-            errorHandler.record("error", backend.functionName(task.data.targetService), task.operationType, err.message || "");
-        }
-    }
-};

package/lib/functions/listFunctions.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.listFunctions = void 0;
-const backend = require("../deploy/functions/backend");
-async function listFunctions(context) {
-    const functionSpecs = (await backend.existingBackend(context, true)).cloudFunctions;
-    functionSpecs.sort(backend.compareFunctions);
-    return { functions: functionSpecs };
-}
-exports.listFunctions = listFunctions;

package/lib/functionsDelete.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteFunctions = void 0;
-const helper = require("./deploy/functions/functionsDeployHelper");
-const queue_1 = require("./throttler/queue");
-const tasks = require("./deploy/functions/tasks");
-const deploymentTimer_1 = require("./deploy/functions/deploymentTimer");
-const errorHandler_1 = require("./deploy/functions/errorHandler");
-async function deleteFunctions(functionsToDelete, schedulesToDelete, topicsToDelete, appEngineLocation) {
-    const timer = new deploymentTimer_1.DeploymentTimer();
-    const errorHandler = new errorHandler_1.ErrorHandler();
-    const cloudFunctionsQueue = new queue_1.Queue({
-        handler: tasks.functionsDeploymentHandler(timer, errorHandler),
-        retries: 30,
-        backoff: 10000,
-        concurrency: 40,
-        maxBackoff: 40000,
-    });
-    const schedulerQueue = new queue_1.Queue({
-        handler: tasks.schedulerDeploymentHandler(errorHandler),
-    });
-    const topicQueue = new queue_1.Queue({
-        handler: tasks.schedulerDeploymentHandler(errorHandler),
-    });
-    functionsToDelete.forEach((fn) => {
-        const taskParams = {
-            projectId: fn.project,
-            errorHandler,
-        };
-        const deleteFunctionTask = tasks.deleteFunctionTask(taskParams, fn);
-        void cloudFunctionsQueue.run(deleteFunctionTask);
-    });
-    schedulesToDelete.forEach((schedule) => {
-        const taskParams = {
-            projectId: schedule.project,
-            errorHandler,
-        };
-        const deleteSchedulerTask = tasks.deleteScheduleTask(taskParams, schedule, appEngineLocation);
-        void schedulerQueue.run(deleteSchedulerTask);
-    });
-    topicsToDelete.forEach((topic) => {
-        const taskParams = {
-            projectId: topic.project,
-            errorHandler,
-        };
-        const deleteTopicTask = tasks.deleteTopicTask(taskParams, topic);
-        void topicQueue.run(deleteTopicTask);
-    });
-    const queuePromises = [cloudFunctionsQueue.wait(), schedulerQueue.wait(), topicQueue.wait()];
-    cloudFunctionsQueue.close();
-    schedulerQueue.close();
-    topicQueue.close();
-    cloudFunctionsQueue.process();
-    schedulerQueue.process();
-    topicQueue.process();
-    await Promise.all(queuePromises);
-    helper.logAndTrackDeployStats(cloudFunctionsQueue, errorHandler);
-    errorHandler.printErrors();
-}
-exports.deleteFunctions = deleteFunctions;