firebase-tools 9.18.0 → 9.22.0

package/lib/deploy/functions/prepare.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.prepare = void 0;
+exports.inferDetailsFromExisting = exports.prepare = void 0;
 const clc = require("cli-color");
 const ensureCloudBuildEnabled_1 = require("./ensureCloudBuildEnabled");
 const functionsDeployHelper_1 = require("./functionsDeployHelper");
@@ -18,6 +18,7 @@ const runtimes = require("./runtimes");
 const validate = require("./validate");
 const utils = require("../../utils");
 const logger_1 = require("../../logger");
+const triggerRegionHelper_1 = require("./triggerRegionHelper");
 function hasUserConfig(config) {
     return Object.keys(config).length > 1;
 }
@@ -52,56 +53,90 @@ async function prepare(context, options, payload) {
         projectAlias: options.projectAlias,
     };
     const userEnvs = functionsEnv.loadUserEnvs(userEnvOpt);
+    const usedDotenv = hasDotenv(userEnvOpt);
     const tag = hasUserConfig(runtimeConfig)
-        ? hasDotenv(userEnvOpt)
+        ? usedDotenv
             ? "mixed"
             : "runtime_config"
-        : hasDotenv(userEnvOpt)
+        : usedDotenv
             ? "dotenv"
             : "none";
-    track_1.track("functions_codebase_deploy_env_method", tag);
+    await track_1.track("functions_codebase_deploy_env_method", tag);
     logger_1.logger.debug(`Analyzing ${runtimeDelegate.name} backend spec`);
     const wantBackend = await runtimeDelegate.discoverSpec(runtimeConfig, firebaseEnvs);
     wantBackend.environmentVariables = Object.assign(Object.assign({}, userEnvs), firebaseEnvs);
     payload.functions = { backend: wantBackend };
-    if (wantBackend.cloudFunctions.find((f) => f.platform === "gcfv2")) {
-        const V2_APIS = {
-            artifactregistry: "artifactregistry.googleapis.com",
-            cloudrun: "run.googleapis.com",
-            eventarc: "eventarc.googleapis.com",
-            pubsub: "pubsub.googleapis.com",
-        };
-        const enablements = Object.entries(V2_APIS).map(([tag, api]) => {
-            return ensureApiEnabled.ensure(context.projectId, api, tag);
+    if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv2")) {
+        const V2_APIS = [
+            "artifactregistry.googleapis.com",
+            "run.googleapis.com",
+            "eventarc.googleapis.com",
+            "pubsub.googleapis.com",
+            "storage.googleapis.com",
+        ];
+        const enablements = V2_APIS.map((api) => {
+            return ensureApiEnabled.ensure(context.projectId, api, "functions");
         });
         await Promise.all(enablements);
     }
-    if (wantBackend.cloudFunctions.length) {
+    if (backend.someEndpoint(wantBackend, () => true)) {
         utils_1.logBullet(clc.cyan.bold("functions:") +
             " preparing " +
             clc.bold(options.config.src.functions.source) +
             " directory for uploading...");
     }
-    if (wantBackend.cloudFunctions.find((fn) => fn.platform === "gcfv1")) {
+    if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv1")) {
         context.functionsSourceV1 = await prepareFunctionsUpload_1.prepareFunctionsUpload(runtimeConfig, options);
     }
-    if (wantBackend.cloudFunctions.find((fn) => fn.platform === "gcfv2")) {
+    if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv2")) {
         context.functionsSourceV2 = await prepareFunctionsUpload_1.prepareFunctionsUpload(undefined, options);
     }
-    wantBackend.cloudFunctions.forEach((fn) => {
-        fn.environmentVariables = wantBackend.environmentVariables;
-    });
-    await Promise.all(Object.keys(wantBackend.requiredAPIs).map((friendlyName) => {
-        ensureApiEnabled.ensure(projectId, wantBackend.requiredAPIs[friendlyName], friendlyName, false);
+    for (const endpoint of backend.allEndpoints(wantBackend)) {
+        endpoint.environmentVariables = wantBackend.environmentVariables;
+    }
+    await Promise.all(Object.values(wantBackend.requiredAPIs).map((api) => {
+        return ensureApiEnabled.ensure(projectId, api, "functions", false);
     }));
-    validate.functionIdsAreValid(wantBackend.cloudFunctions);
+    validate.functionIdsAreValid(backend.allEndpoints(wantBackend));
     context.filters = functionsDeployHelper_1.getFilterGroups(options);
-    const wantFunctions = wantBackend.cloudFunctions.filter((fn) => {
-        return functionsDeployHelper_1.functionMatchesAnyGroup(fn, context.filters);
+    const matchingBackend = backend.matchingBackend(wantBackend, (endpoint) => {
+        return functionsDeployHelper_1.functionMatchesAnyGroup(endpoint, context.filters);
     });
-    const haveFunctions = (await backend.existingBackend(context)).cloudFunctions;
-    await prompts_1.promptForFailurePolicies(options, wantFunctions, haveFunctions);
-    await prompts_1.promptForMinInstances(options, wantFunctions, haveFunctions);
+    const haveBackend = await backend.existingBackend(context);
+    inferDetailsFromExisting(wantBackend, haveBackend, usedDotenv);
+    await triggerRegionHelper_1.lookupMissingTriggerRegions(wantBackend);
+    await prompts_1.promptForFailurePolicies(options, matchingBackend, haveBackend);
+    await prompts_1.promptForMinInstances(options, matchingBackend, haveBackend);
     await backend.checkAvailability(context, wantBackend);
 }
 exports.prepare = prepare;
+function inferDetailsFromExisting(want, have, usedDotenv) {
+    var _a;
+    for (const wantE of backend.allEndpoints(want)) {
+        const haveE = (_a = have.endpoints[wantE.region]) === null || _a === void 0 ? void 0 : _a[wantE.id];
+        if (!haveE) {
+            continue;
+        }
+        if (!usedDotenv) {
+            wantE.environmentVariables = Object.assign(Object.assign({}, haveE.environmentVariables), wantE.environmentVariables);
+        }
+        if (!wantE.availableMemoryMb && haveE.availableMemoryMb) {
+            wantE.availableMemoryMb = haveE.availableMemoryMb;
+        }
+        maybeCopyTriggerRegion(wantE, haveE);
+    }
+}
+exports.inferDetailsFromExisting = inferDetailsFromExisting;
+function maybeCopyTriggerRegion(wantE, haveE) {
+    if (!backend.isEventTriggered(wantE) || !backend.isEventTriggered(haveE)) {
+        return;
+    }
+    if (wantE.eventTrigger.region || !haveE.eventTrigger.region) {
+        return;
+    }
+    if (JSON.stringify(haveE.eventTrigger.eventFilters) !==
+        JSON.stringify(wantE.eventTrigger.eventFilters)) {
+        return;
+    }
+    wantE.eventTrigger.region = haveE.eventTrigger.region;
+}

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

@@ -10,23 +10,22 @@ const backend = require("./backend");
 const pricing = require("./pricing");
 const utils = require("../../utils");
 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 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);
     });
-    const newRetryFunctions = retryFunctions.filter((fn) => {
-        return !existingRetryFunctions.some(backend.sameFunctionName(fn));
-    });
-    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(backend.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.";
@@ -90,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;
     });
@@ -116,7 +116,8 @@ async function promptForMinInstances(options, want, have) {
             exit: 1,
         });
     }
-    const functionLines = want
+    const functionLines = backend
+        .allEndpoints(want)
         .filter((fn) => fn.minInstances)
         .sort(backend.compareFunctions)
         .map((fn) => {
@@ -126,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;