firebase-tools 9.17.0 → 9.21.0

package/lib/deploy/functions/pricing.js

@@ -102,52 +102,52 @@ const MB_TO_GHZ = {
     4096: 4.8,
     8192: 4.8,
 };
-function canCalculateMinInstanceCost(functionSpec) {
-    if (!functionSpec.minInstances) {
+function canCalculateMinInstanceCost(endpoint) {
+    if (!endpoint.minInstances) {
         return true;
     }
-    if (functionSpec.platform == "gcfv1") {
-        if (!MB_TO_GHZ[functionSpec.availableMemoryMb || 256]) {
+    if (endpoint.platform == "gcfv1") {
+        if (!MB_TO_GHZ[endpoint.availableMemoryMb || 256]) {
             return false;
         }
-        if (!V1_REGION_TO_TIER[functionSpec.region]) {
+        if (!V1_REGION_TO_TIER[endpoint.region]) {
             return false;
         }
         return true;
     }
-    if (!V2_REGION_TO_TIER[functionSpec.region]) {
+    if (!V2_REGION_TO_TIER[endpoint.region]) {
         return false;
     }
     return true;
 }
 exports.canCalculateMinInstanceCost = canCalculateMinInstanceCost;
 const SECONDS_PER_MONTH = 30 * 24 * 60 * 60;
-function monthlyMinInstanceCost(functions) {
+function monthlyMinInstanceCost(endpoints) {
     const usage = {
         gcfv1: { 1: { ram: 0, cpu: 0 }, 2: { ram: 0, cpu: 0 } },
         gcfv2: { 1: { ram: 0, cpu: 0 }, 2: { ram: 0, cpu: 0 } },
     };
-    for (const func of functions) {
-        if (!func.minInstances) {
+    for (const endpoint of endpoints) {
+        if (!endpoint.minInstances) {
             continue;
         }
-        const ramMb = func.availableMemoryMb || 256;
+        const ramMb = endpoint.availableMemoryMb || 256;
         const ramGb = ramMb / 1024;
-        if (func.platform === "gcfv1") {
+        if (endpoint.platform === "gcfv1") {
             const cpu = MB_TO_GHZ[ramMb];
-            const tier = V1_REGION_TO_TIER[func.region];
+            const tier = V1_REGION_TO_TIER[endpoint.region];
             usage["gcfv1"][tier].ram =
-                usage["gcfv1"][tier].ram + ramGb * SECONDS_PER_MONTH * func.minInstances;
+                usage["gcfv1"][tier].ram + ramGb * SECONDS_PER_MONTH * endpoint.minInstances;
             usage["gcfv1"][tier].cpu =
-                usage["gcfv1"][tier].cpu + MB_TO_GHZ[ramMb] * SECONDS_PER_MONTH * func.minInstances;
+                usage["gcfv1"][tier].cpu + cpu * SECONDS_PER_MONTH * endpoint.minInstances;
         }
         else {
             const cpu = 1;
-            const tier = V2_REGION_TO_TIER[func.region];
+            const tier = V2_REGION_TO_TIER[endpoint.region];
             usage["gcfv2"][tier].ram =
-                usage["gcfv2"][tier].ram + ramGb * SECONDS_PER_MONTH * func.minInstances;
+                usage["gcfv2"][tier].ram + ramGb * SECONDS_PER_MONTH * endpoint.minInstances;
             usage["gcfv2"][tier].cpu =
-                usage["gcfv2"][tier].cpu + cpu * SECONDS_PER_MONTH * func.minInstances;
+                usage["gcfv2"][tier].cpu + cpu * SECONDS_PER_MONTH * endpoint.minInstances;
         }
     }
     let v1MemoryBill = usage["gcfv1"][1].ram * exports.V1_RATES.memoryGb[1] + usage["gcfv1"][2].ram * exports.V1_RATES.memoryGb[2];

package/lib/deploy/functions/prompts.js

@@ -9,42 +9,23 @@ const logger_1 = require("../../logger");
 const backend = require("./backend");
 const pricing = require("./pricing");
 const utils = require("../../utils");
-function compareFunctions(left, right) {
-    if (left.platform != right.platform) {
-        return right.platform < left.platform ? -1 : 1;
-    }
-    if (left.region < right.region) {
-        return -1;
-    }
-    if (left.region > right.region) {
-        return 1;
-    }
-    if (left.id < right.id) {
-        return -1;
-    }
-    if (left.id > right.id) {
-        return 1;
-    }
-    return 0;
-}
 async function promptForFailurePolicies(options, want, have) {
-    const retryFunctions = want.filter((fn) => {
-        return backend.isEventTrigger(fn.trigger) && fn.trigger.retry;
+    const retryEndpoints = backend.allEndpoints(want).filter((e) => {
+        return backend.isEventTriggered(e) && e.eventTrigger.retry;
     });
-    if (retryFunctions.length === 0) {
+    if (retryEndpoints.length === 0) {
         return;
     }
-    const existingRetryFunctions = have.filter((fn) => {
-        return backend.isEventTrigger(fn.trigger) && fn.trigger.retry;
-    });
-    const newRetryFunctions = retryFunctions.filter((fn) => {
-        return !existingRetryFunctions.some(backend.sameFunctionName(fn));
+    const newRetryEndpoints = retryEndpoints.filter((endpoint) => {
+        var _a;
+        const existing = (_a = have.endpoints[endpoint.region]) === null || _a === void 0 ? void 0 : _a[endpoint.id];
+        return !(existing && backend.isEventTriggered(existing) && existing.eventTrigger.retry);
     });
-    if (newRetryFunctions.length == 0) {
+    if (newRetryEndpoints.length == 0) {
         return;
     }
     const warnMessage = "The following functions will newly be retried in case of failure: " +
-        clc.bold(newRetryFunctions.sort(compareFunctions).map(functionsDeployHelper_1.getFunctionLabel).join(", ")) +
+        clc.bold(newRetryEndpoints.sort(backend.compareFunctions).map(functionsDeployHelper_1.getFunctionLabel).join(", ")) +
         ". " +
         "Retried executions are billed as any other execution, and functions are retried repeatedly until they either successfully execute or the maximum retry period has elapsed, which can be up to 7 days. " +
         "For safety, you might want to ensure that your functions are idempotent; see https://firebase.google.com/docs/functions/retries to learn more.";
@@ -74,7 +55,7 @@ async function promptForFunctionDeletion(functionsToDelete, force, nonInteractiv
         return true;
     }
     const deleteList = functionsToDelete
-        .sort(compareFunctions)
+        .sort(backend.compareFunctions)
         .map((fn) => "\t" + functionsDeployHelper_1.getFunctionLabel(fn))
         .join("\n");
     if (nonInteractive) {
@@ -108,21 +89,22 @@ async function promptForMinInstances(options, want, have) {
     if (options.force) {
         return;
     }
-    const increasesCost = want.some((wantFn) => {
-        if (!pricing.canCalculateMinInstanceCost(wantFn)) {
+    const increasesCost = backend.someEndpoint(want, (wantE) => {
+        var _a;
+        if (!pricing.canCalculateMinInstanceCost(wantE)) {
             return true;
         }
-        const wantCost = pricing.monthlyMinInstanceCost([wantFn]);
-        const haveFn = have.find(backend.sameFunctionName(wantFn));
+        const wantCost = pricing.monthlyMinInstanceCost([wantE]);
+        const haveE = (_a = have.endpoints[wantE.region]) === null || _a === void 0 ? void 0 : _a[wantE.id];
         let haveCost;
-        if (!haveFn) {
+        if (!haveE) {
             haveCost = 0;
         }
-        else if (!pricing.canCalculateMinInstanceCost(wantFn)) {
+        else if (!pricing.canCalculateMinInstanceCost(wantE)) {
             return true;
         }
         else {
-            haveCost = pricing.monthlyMinInstanceCost([haveFn]);
+            haveCost = pricing.monthlyMinInstanceCost([haveE]);
         }
         return wantCost > haveCost;
     });
@@ -134,9 +116,10 @@ async function promptForMinInstances(options, want, have) {
             exit: 1,
         });
     }
-    const functionLines = want
+    const functionLines = backend
+        .allEndpoints(want)
         .filter((fn) => fn.minInstances)
-        .sort(compareFunctions)
+        .sort(backend.compareFunctions)
         .map((fn) => {
         return (`\t${functionsDeployHelper_1.getFunctionLabel(fn)}: ${fn.minInstances} instances, ` +
             backend.memoryOptionDisplayName(fn.availableMemoryMb || 256) +
@@ -144,17 +127,17 @@ async function promptForMinInstances(options, want, have) {
     })
         .join("\n");
     let costLine;
-    if (want.some((fn) => !pricing.canCalculateMinInstanceCost(fn))) {
+    if (backend.someEndpoint(want, (fn) => !pricing.canCalculateMinInstanceCost(fn))) {
         costLine =
             "Cannot calculate the minimum monthly bill for this configuration. Consider running " +
                 clc.bold("npm install -g firebase-tools");
     }
     else {
-        const cost = pricing.monthlyMinInstanceCost(want).toFixed(2);
+        const cost = pricing.monthlyMinInstanceCost(backend.allEndpoints(want)).toFixed(2);
         costLine = `With these options, your minimum bill will be $${cost} in a 30-day month`;
     }
     let cudAnnotation = "";
-    if (want.some((fn) => fn.platform == "gcfv2" && fn.minInstances)) {
+    if (backend.someEndpoint(want, (fn) => fn.platform == "gcfv2" && !!fn.minInstances)) {
         cudAnnotation =
             "\nThis bill can be lowered with a one year commitment. See https://cloud.google.com/run/cud for more";
     }

package/lib/deploy/functions/release/executor.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InlineExecutor = exports.QueueExecutor = void 0;
+const queue_1 = require("../../../throttler/queue");
+async function handler(op) {
+    var _a, _b, _c, _d, _e, _f;
+    try {
+        op.result = await op.func();
+    }
+    catch (err) {
+        const code = err.status ||
+            err.code || ((_b = (_a = err.context) === null || _a === void 0 ? void 0 : _a.response) === null || _b === void 0 ? void 0 : _b.statusCode) || ((_c = err.original) === null || _c === void 0 ? void 0 : _c.code) || ((_f = (_e = (_d = err.original) === null || _d === void 0 ? void 0 : _d.context) === null || _e === void 0 ? void 0 : _e.response) === null || _f === void 0 ? void 0 : _f.statusCode);
+        if (code === 429 || code === 409) {
+            throw err;
+        }
+        op.error = err;
+    }
+    return;
+}
+class QueueExecutor {
+    constructor(options) {
+        this.queue = new queue_1.Queue(Object.assign(Object.assign({}, options), { handler }));
+    }
+    async run(func) {
+        const op = { func };
+        await this.queue.run(op);
+        if (op.error) {
+            throw op.error;
+        }
+        return op.result;
+    }
+}
+exports.QueueExecutor = QueueExecutor;
+class InlineExecutor {
+    run(func) {
+        return func();
+    }
+}
+exports.InlineExecutor = InlineExecutor;

package/lib/deploy/functions/release/fabricator.js

@@ -0,0 +1,362 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Fabricator = void 0;
+const clc = require("cli-color");
+const error_1 = require("../../../error");
+const sourceTokenScraper_1 = require("./sourceTokenScraper");
+const timer_1 = require("./timer");
+const functional_1 = require("../../../functional");
+const runtimes_1 = require("../runtimes");
+const api_1 = require("../../../api");
+const logger_1 = require("../../../logger");
+const backend = require("../backend");
+const deploymentTool = require("../../../deploymentTool");
+const gcf = require("../../../gcp/cloudfunctions");
+const gcfV2 = require("../../../gcp/cloudfunctionsv2");
+const helper = require("../functionsDeployHelper");
+const poller = require("../../../operation-poller");
+const pubsub = require("../../../gcp/pubsub");
+const reporter = require("./reporter");
+const run = require("../../../gcp/run");
+const scheduler = require("../../../gcp/cloudscheduler");
+const utils = require("../../../utils");
+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 DEFAULT_GCFV2_CONCURRENCY = 80;
+const rethrowAs = (endpoint, op) => (err) => {
+    throw new reporter.DeploymentError(endpoint, op, err);
+};
+class Fabricator {
+    constructor(args) {
+        this.executor = args.executor;
+        this.functionExecutor = args.functionExecutor;
+        this.sourceUrl = args.sourceUrl;
+        this.storage = args.storage;
+        this.appEngineLocation = args.appEngineLocation;
+    }
+    async applyPlan(plan) {
+        const timer = new timer_1.Timer();
+        const summary = {
+            totalTime: 0,
+            results: [],
+        };
+        const deployRegions = Object.values(plan).map(async (changes) => {
+            const results = await this.applyRegionalChanges(changes);
+            summary.results.push(...results);
+            return;
+        });
+        const promiseResults = await utils.allSettled(deployRegions);
+        const errs = promiseResults
+            .filter((r) => r.status === "rejected")
+            .map((r) => r.reason);
+        if (errs.length) {
+            logger_1.logger.debug("Fabricator.applyRegionalChanges returned an unhandled exception. This should never happen", JSON.stringify(errs, null, 2));
+        }
+        summary.totalTime = timer.stop();
+        return summary;
+    }
+    async applyRegionalChanges(changes) {
+        const deployResults = [];
+        const handle = async (op, endpoint, fn) => {
+            const timer = new timer_1.Timer();
+            const result = { endpoint };
+            try {
+                await fn();
+                this.logOpSuccess(op, endpoint);
+            }
+            catch (err) {
+                result.error = err;
+            }
+            result.durationMs = timer.stop();
+            deployResults.push(result);
+        };
+        const upserts = [];
+        const scraper = new sourceTokenScraper_1.SourceTokenScraper();
+        for (const endpoint of changes.endpointsToCreate) {
+            this.logOpStart("creating", endpoint);
+            upserts.push(handle("create", endpoint, () => this.createEndpoint(endpoint, scraper)));
+        }
+        for (const update of changes.endpointsToUpdate) {
+            this.logOpStart("updating", update.endpoint);
+            upserts.push(handle("update", update.endpoint, () => this.updateEndpoint(update, scraper)));
+        }
+        await utils.allSettled(upserts);
+        if (deployResults.find((r) => r.error)) {
+            for (const endpoint of changes.endpointsToDelete) {
+                deployResults.push({
+                    endpoint,
+                    durationMs: 0,
+                    error: new reporter.AbortedDeploymentError(endpoint),
+                });
+            }
+            return deployResults;
+        }
+        const deletes = [];
+        for (const endpoint of changes.endpointsToDelete) {
+            this.logOpStart("deleting", endpoint);
+            deletes.push(handle("delete", endpoint, () => this.deleteEndpoint(endpoint)));
+        }
+        await utils.allSettled(deletes);
+        return deployResults;
+    }
+    async createEndpoint(endpoint, scraper) {
+        endpoint.labels = Object.assign(Object.assign({}, endpoint.labels), deploymentTool.labels());
+        if (endpoint.platform === "gcfv1") {
+            await this.createV1Function(endpoint, scraper);
+        }
+        else if (endpoint.platform === "gcfv2") {
+            await this.createV2Function(endpoint);
+        }
+        else {
+            functional_1.assertExhaustive(endpoint.platform);
+        }
+        await this.setTrigger(endpoint);
+    }
+    async updateEndpoint(update, scraper) {
+        update.endpoint.labels = Object.assign(Object.assign({}, update.endpoint.labels), deploymentTool.labels());
+        if (update.deleteAndRecreate) {
+            await this.deleteEndpoint(update.deleteAndRecreate);
+            await this.createEndpoint(update.endpoint, scraper);
+            return;
+        }
+        if (update.endpoint.platform === "gcfv1") {
+            await this.updateV1Function(update.endpoint, scraper);
+        }
+        else if (update.endpoint.platform === "gcfv2") {
+            await this.updateV2Function(update.endpoint);
+        }
+        else {
+            functional_1.assertExhaustive(update.endpoint.platform);
+        }
+        await this.setTrigger(update.endpoint);
+    }
+    async deleteEndpoint(endpoint) {
+        await this.deleteTrigger(endpoint);
+        if (endpoint.platform === "gcfv1") {
+            await this.deleteV1Function(endpoint);
+        }
+        else {
+            await this.deleteV2Function(endpoint);
+        }
+    }
+    async createV1Function(endpoint, scraper) {
+        var _a;
+        if (!this.sourceUrl) {
+            logger_1.logger.debug("Precondition failed. Cannot create a GCF function without sourceUrl");
+            throw new Error("Precondition failed");
+        }
+        const apiFunction = gcf.functionFromEndpoint(endpoint, this.sourceUrl);
+        apiFunction.sourceToken = await scraper.tokenPromise();
+        const resultFunction = await this.functionExecutor
+            .run(async () => {
+            const op = await gcf.createFunction(apiFunction);
+            return poller.pollOperation(Object.assign(Object.assign({}, gcfV1PollerOptions), { pollerName: `create-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name, onPoll: scraper.poller }));
+        })
+            .catch(rethrowAs(endpoint, "create"));
+        endpoint.uri = (_a = resultFunction === null || resultFunction === void 0 ? void 0 : resultFunction.httpsTrigger) === null || _a === void 0 ? void 0 : _a.url;
+        if (backend.isHttpsTriggered(endpoint)) {
+            const invoker = endpoint.httpsTrigger.invoker || ["public"];
+            if (!invoker.includes("private")) {
+                await this.executor
+                    .run(async () => {
+                    await gcf.setInvokerCreate(endpoint.project, backend.functionName(endpoint), invoker);
+                })
+                    .catch(rethrowAs(endpoint, "set invoker"));
+            }
+        }
+    }
+    async createV2Function(endpoint) {
+        var _a;
+        if (!this.storage) {
+            logger_1.logger.debug("Precondition failed. Cannot create a GCFv2 function without storage");
+            throw new Error("Precondition failed");
+        }
+        const apiFunction = gcfV2.functionFromEndpoint(endpoint, this.storage[endpoint.region]);
+        const topic = (_a = apiFunction.eventTrigger) === null || _a === void 0 ? void 0 : _a.pubsubTopic;
+        if (topic) {
+            await this.executor
+                .run(async () => {
+                try {
+                    await pubsub.createTopic({ name: topic });
+                }
+                catch (err) {
+                    if (err.status === 409) {
+                        return;
+                    }
+                    throw new error_1.FirebaseError("Unexpected error creating Pub/Sub topic", {
+                        original: err,
+                    });
+                }
+            })
+                .catch(rethrowAs(endpoint, "create topic"));
+        }
+        const resultFunction = (await this.functionExecutor
+            .run(async () => {
+            const op = await gcfV2.createFunction(apiFunction);
+            return await poller.pollOperation(Object.assign(Object.assign({}, gcfV2PollerOptions), { pollerName: `create-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name }));
+        })
+            .catch(rethrowAs(endpoint, "create")));
+        endpoint.uri = resultFunction.serviceConfig.uri;
+        const serviceName = resultFunction.serviceConfig.service;
+        if (backend.isHttpsTriggered(endpoint)) {
+            const invoker = endpoint.httpsTrigger.invoker || ["public"];
+            if (!invoker.includes("private")) {
+                await this.executor
+                    .run(() => run.setInvokerCreate(endpoint.project, serviceName, invoker))
+                    .catch(rethrowAs(endpoint, "set invoker"));
+            }
+        }
+        await this.setConcurrency(endpoint, serviceName, endpoint.concurrency || DEFAULT_GCFV2_CONCURRENCY);
+    }
+    async updateV1Function(endpoint, scraper) {
+        var _a;
+        if (!this.sourceUrl) {
+            logger_1.logger.debug("Precondition failed. Cannot update a GCF function without sourceUrl");
+            throw new Error("Precondition failed");
+        }
+        const apiFunction = gcf.functionFromEndpoint(endpoint, this.sourceUrl);
+        apiFunction.sourceToken = await scraper.tokenPromise();
+        const resultFunction = await this.functionExecutor
+            .run(async () => {
+            const op = await gcf.updateFunction(apiFunction);
+            return await poller.pollOperation(Object.assign(Object.assign({}, gcfV1PollerOptions), { pollerName: `update-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name, onPoll: scraper.poller }));
+        })
+            .catch(rethrowAs(endpoint, "update"));
+        endpoint.uri = (_a = resultFunction === null || resultFunction === void 0 ? void 0 : resultFunction.httpsTrigger) === null || _a === void 0 ? void 0 : _a.url;
+        if (backend.isHttpsTriggered(endpoint) && endpoint.httpsTrigger.invoker) {
+            await this.executor
+                .run(async () => {
+                await gcf.setInvokerUpdate(endpoint.project, backend.functionName(endpoint), endpoint.httpsTrigger.invoker);
+                return;
+            })
+                .catch(rethrowAs(endpoint, "set invoker"));
+        }
+    }
+    async updateV2Function(endpoint) {
+        var _a;
+        if (!this.storage) {
+            logger_1.logger.debug("Precondition failed. Cannot update a GCFv2 function without storage");
+            throw new Error("Precondition failed");
+        }
+        const apiFunction = gcfV2.functionFromEndpoint(endpoint, this.storage[endpoint.region]);
+        if ((_a = apiFunction.eventTrigger) === null || _a === void 0 ? void 0 : _a.pubsubTopic) {
+            delete apiFunction.eventTrigger.pubsubTopic;
+        }
+        const resultFunction = (await this.functionExecutor
+            .run(async () => {
+            const op = await gcfV2.updateFunction(apiFunction);
+            return await poller.pollOperation(Object.assign(Object.assign({}, gcfV2PollerOptions), { pollerName: `update-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name }));
+        })
+            .catch(rethrowAs(endpoint, "update")));
+        endpoint.uri = resultFunction.serviceConfig.uri;
+        const serviceName = resultFunction.serviceConfig.service;
+        if (backend.isHttpsTriggered(endpoint) && endpoint.httpsTrigger.invoker) {
+            await this.executor
+                .run(() => run.setInvokerUpdate(endpoint.project, serviceName, endpoint.httpsTrigger.invoker))
+                .catch(rethrowAs(endpoint, "set invoker"));
+        }
+        if (endpoint.concurrency) {
+            await this.setConcurrency(endpoint, serviceName, endpoint.concurrency);
+        }
+    }
+    async deleteV1Function(endpoint) {
+        const fnName = backend.functionName(endpoint);
+        await this.functionExecutor
+            .run(async () => {
+            const op = await gcf.deleteFunction(fnName);
+            const pollerOptions = Object.assign(Object.assign({}, gcfV1PollerOptions), { pollerName: `delete-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name });
+            await poller.pollOperation(pollerOptions);
+        })
+            .catch(rethrowAs(endpoint, "delete"));
+    }
+    async deleteV2Function(endpoint) {
+        const fnName = backend.functionName(endpoint);
+        await this.functionExecutor
+            .run(async () => {
+            const op = await gcfV2.deleteFunction(fnName);
+            const pollerOptions = Object.assign(Object.assign({}, gcfV2PollerOptions), { pollerName: `delete-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name });
+            await poller.pollOperation(pollerOptions);
+        })
+            .catch(rethrowAs(endpoint, "delete"));
+    }
+    async setConcurrency(endpoint, serviceName, concurrency) {
+        await this.functionExecutor
+            .run(async () => {
+            const service = await run.getService(serviceName);
+            if (service.spec.template.spec.containerConcurrency === concurrency) {
+                logger_1.logger.debug("Skipping setConcurrency on", serviceName, " because it already matches");
+                return;
+            }
+            delete service.status;
+            delete service.spec.template.metadata.name;
+            service.spec.template.spec.containerConcurrency = concurrency;
+            await run.replaceService(serviceName, service);
+        })
+            .catch(rethrowAs(endpoint, "set concurrency"));
+    }
+    async setTrigger(endpoint) {
+        if (backend.isScheduleTriggered(endpoint)) {
+            if (endpoint.platform === "gcfv1") {
+                await this.upsertScheduleV1(endpoint);
+                return;
+            }
+            else if (endpoint.platform === "gcfv2") {
+                await this.upsertScheduleV2(endpoint);
+                return;
+            }
+            functional_1.assertExhaustive(endpoint.platform);
+        }
+    }
+    async deleteTrigger(endpoint) {
+        if (backend.isScheduleTriggered(endpoint)) {
+            if (endpoint.platform === "gcfv1") {
+                await this.deleteScheduleV1(endpoint);
+                return;
+            }
+            else if (endpoint.platform === "gcfv2") {
+                await this.deleteScheduleV2(endpoint);
+                return;
+            }
+            functional_1.assertExhaustive(endpoint.platform);
+        }
+    }
+    async upsertScheduleV1(endpoint) {
+        const job = scheduler.jobFromEndpoint(endpoint, this.appEngineLocation);
+        await this.executor
+            .run(() => scheduler.createOrReplaceJob(job))
+            .catch(rethrowAs(endpoint, "upsert schedule"));
+    }
+    upsertScheduleV2(endpoint) {
+        return Promise.reject(new reporter.DeploymentError(endpoint, "upsert schedule", new Error("Not implemented")));
+    }
+    async deleteScheduleV1(endpoint) {
+        const job = scheduler.jobFromEndpoint(endpoint, this.appEngineLocation);
+        await this.executor
+            .run(() => scheduler.deleteJob(job.name))
+            .catch(rethrowAs(endpoint, "delete schedule"));
+        await this.executor
+            .run(() => pubsub.deleteTopic(job.pubsubTarget.topicName))
+            .catch(rethrowAs(endpoint, "delete topic"));
+    }
+    deleteScheduleV2(endpoint) {
+        return Promise.reject(new reporter.DeploymentError(endpoint, "delete schedule", new Error("Not implemented")));
+    }
+    logOpStart(op, endpoint) {
+        const runtime = runtimes_1.getHumanFriendlyRuntimeName(endpoint.runtime);
+        const label = helper.getFunctionLabel(endpoint);
+        utils.logBullet(`${clc.bold.cyan("functions:")} ${op} ${runtime} function ${clc.bold(label)}...`);
+    }
+    logOpSuccess(op, endpoint) {
+        const label = helper.getFunctionLabel(endpoint);
+        utils.logSuccess(`${clc.bold.green(`functions[${label}]`)} Successful ${op} operation.`);
+    }
+}
+exports.Fabricator = Fabricator;

package/lib/deploy/functions/release/index.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printTriggerUrls = exports.release = void 0;
+const clc = require("cli-color");
+const logger_1 = require("../../../logger");
+const functional_1 = require("../../../functional");
+const backend = require("../backend");
+const containerCleaner = require("../containerCleaner");
+const planner = require("./planner");
+const fabricator = require("./fabricator");
+const reporter = require("./reporter");
+const executor = require("./executor");
+const prompts = require("../prompts");
+const functionsConfig_1 = require("../../../functionsConfig");
+const functionsDeployHelper_1 = require("../functionsDeployHelper");
+const error_1 = require("../../../error");
+async function release(context, options, payload) {
+    if (!options.config.has("functions")) {
+        return;
+    }
+    const plan = planner.createDeploymentPlan(payload.functions.backend, await backend.existingBackend(context), { filters: context.filters });
+    const fnsToDelete = Object.values(plan)
+        .map((regionalChanges) => regionalChanges.endpointsToDelete)
+        .reduce(functional_1.reduceFlat, []);
+    const shouldDelete = await prompts.promptForFunctionDeletion(fnsToDelete, options.force, options.nonInteractive);
+    if (!shouldDelete) {
+        for (const change of Object.values(plan)) {
+            change.endpointsToDelete = [];
+        }
+    }
+    const functionExecutor = new executor.QueueExecutor({
+        retries: 30,
+        backoff: 20000,
+        concurrency: 40,
+        maxBackoff: 40000,
+    });
+    const fab = new fabricator.Fabricator({
+        functionExecutor,
+        executor: new executor.QueueExecutor({}),
+        sourceUrl: context.uploadUrl,
+        storage: context.storage,
+        appEngineLocation: functionsConfig_1.getAppEngineLocation(context.firebaseConfig),
+    });
+    const summary = await fab.applyPlan(plan);
+    await reporter.logAndTrackDeployStats(summary);
+    reporter.printErrors(summary);
+    printTriggerUrls(payload.functions.backend);
+    await containerCleaner.cleanupBuildImages(backend.allEndpoints(payload.functions.backend));
+    const allErrors = summary.results.filter((r) => r.error).map((r) => r.error);
+    if (allErrors.length) {
+        const opts = allErrors.length == 1 ? { original: allErrors[0] } : { children: allErrors };
+        throw new error_1.FirebaseError("There was an error deploying functions", Object.assign(Object.assign({}, opts), { exit: 2 }));
+    }
+}
+exports.release = release;
+function printTriggerUrls(results) {
+    const httpsFunctions = backend.allEndpoints(results).filter(backend.isHttpsTriggered);
+    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"), `(${functionsDeployHelper_1.getFunctionLabel(httpsFunc)}):`, httpsFunc.uri);
+    }
+}
+exports.printTriggerUrls = printTriggerUrls;