firebase-tools 9.20.0 → 9.23.1

package/lib/deploy/functions/deploy.js

@@ -11,6 +11,7 @@ const gcs = require("../../gcp/storage");
 const gcf = require("../../gcp/cloudfunctions");
 const gcfv2 = require("../../gcp/cloudfunctionsv2");
 const utils = require("../../utils");
+const backend = require("./backend");
 const GCP_REGION = api_1.functionsUploadRegion;
 tmp_1.setGracefulCleanup();
 async function uploadSourceV1(context) {
@@ -44,18 +45,11 @@ async function deploy(context, options, payload) {
     try {
         const want = payload.functions.backend;
         const uploads = [];
-        if (want.cloudFunctions.some((fn) => fn.platform === "gcfv1")) {
+        if (backend.allEndpoints(want).some((endpoint) => endpoint.platform === "gcfv1")) {
             uploads.push(uploadSourceV1(context));
         }
-        if (want.cloudFunctions.some((fn) => fn.platform === "gcfv2")) {
-            const functions = payload.functions.backend.cloudFunctions;
-            const regions = [];
-            for (const func of functions) {
-                if (func.platform === "gcfv2" && -1 === regions.indexOf(func.region)) {
-                    regions.push(func.region);
-                }
-            }
-            for (const region of regions) {
+        for (const region of Object.keys(want.endpoints)) {
+            if (backend.regionalEndpoints(want, region).some((e) => e.platform === "gcfv2")) {
                 uploads.push(uploadSourceV2(context, region));
             }
         }

package/lib/deploy/functions/eventTypes.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PUBSUB_V2_EVENT = exports.STORAGE_V2_EVENTS = void 0;
+exports.STORAGE_V2_EVENTS = [
+    "google.cloud.storage.object.v1.finalized",
+    "google.cloud.storage.object.v1.archived",
+    "google.cloud.storage.object.v1.deleted",
+    "google.cloud.storage.object.v1.metadataUpdated",
+];
+exports.PUBSUB_V2_EVENT = "google.cloud.pubsub.topic.v1.messagePublished";

package/lib/deploy/functions/functionsDeployHelper.js

@@ -1,11 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printTriggerUrls = exports.printSuccess = exports.logAndTrackDeployStats = exports.getFunctionLabel = exports.getFunctionId = exports.getFilterGroups = exports.functionMatchesGroup = exports.functionMatchesAnyGroup = void 0;
-const clc = require("cli-color");
-const logger_1 = require("../../logger");
-const backend = require("./backend");
-const track = require("../../track");
-const utils = require("../../utils");
+exports.getFunctionLabel = exports.getFilterGroups = exports.functionMatchesGroup = exports.functionMatchesAnyGroup = void 0;
 function functionMatchesAnyGroup(func, filterGroups) {
     if (!filterGroups.length) {
         return true;
@@ -40,67 +35,7 @@ function getFilterGroups(options) {
     });
 }
 exports.getFilterGroups = getFilterGroups;
-function getFunctionId(fullName) {
-    return fullName.split("/")[5];
-}
-exports.getFunctionId = getFunctionId;
-function getRegion(fullName) {
-    return fullName.split("/")[3];
-}
-function getFunctionLabel(fnOrName) {
-    if (typeof fnOrName === "string") {
-        return getFunctionId(fnOrName) + "(" + getRegion(fnOrName) + ")";
-    }
-    else {
-        return `${fnOrName.id}(${fnOrName.region})`;
-    }
+function getFunctionLabel(fn) {
+    return `${fn.id}(${fn.region})`;
 }
 exports.getFunctionLabel = getFunctionLabel;
-function logAndTrackDeployStats(queue, errorHandler) {
-    const stats = queue.stats();
-    logger_1.logger.debug(`Total Function Deployment time: ${stats.elapsed}`);
-    logger_1.logger.debug(`${stats.total} Functions Deployed`);
-    logger_1.logger.debug(`${errorHandler.errors.length} Functions Errored`);
-    logger_1.logger.debug(`Average Function Deployment time: ${stats.avg}`);
-    if (stats.total > 0) {
-        if (errorHandler.errors.length === 0) {
-            track("functions_deploy_result", "success", stats.total);
-        }
-        else if (errorHandler.errors.length < stats.total) {
-            track("functions_deploy_result", "partial_success", stats.total - errorHandler.errors.length);
-            track("functions_deploy_result", "partial_failure", errorHandler.errors.length);
-            track("functions_deploy_result", "partial_error_ratio", errorHandler.errors.length / stats.total);
-        }
-        else {
-            track("functions_deploy_result", "failure", stats.total);
-        }
-    }
-}
-exports.logAndTrackDeployStats = logAndTrackDeployStats;
-function printSuccess(func, type) {
-    utils.logSuccess(clc.bold.green("functions[" + getFunctionLabel(func) + "]: ") +
-        "Successful " +
-        type +
-        " operation. ");
-}
-exports.printSuccess = printSuccess;
-async function printTriggerUrls(context, want) {
-    const have = await backend.existingBackend(context, true);
-    const httpsFunctions = have.cloudFunctions.filter((fn) => {
-        if (backend.isEventTrigger(fn.trigger)) {
-            return false;
-        }
-        return want.cloudFunctions.some(backend.sameFunctionName(fn));
-    });
-    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"), `(${getFunctionLabel(httpsFunc)}):`, httpsFunc.uri);
-    }
-}
-exports.printTriggerUrls = printTriggerUrls;

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");
@@ -19,12 +19,20 @@ const validate = require("./validate");
 const utils = require("../../utils");
 const logger_1 = require("../../logger");
 const triggerRegionHelper_1 = require("./triggerRegionHelper");
+const checkIam_1 = require("./checkIam");
 function hasUserConfig(config) {
     return Object.keys(config).length > 1;
 }
 function hasDotenv(opts) {
     return previews_1.previews.dotenv && functionsEnv.hasUserEnvs(opts);
 }
+async function maybeEnableAR(projectId) {
+    if (previews_1.previews.artifactregistry) {
+        return ensureApiEnabled.check(projectId, "artifactregistry.googleapis.com", "functions", true);
+    }
+    await ensureApiEnabled.ensure(projectId, "artifactregistry.googleapis.com", "functions");
+    return true;
+}
 async function prepare(context, options, payload) {
     if (!options.config.src.functions) {
         return;
@@ -39,8 +47,10 @@ async function prepare(context, options, payload) {
         ensureApiEnabled.ensure(projectId, "cloudfunctions.googleapis.com", "functions"),
         ensureApiEnabled.check(projectId, "runtimeconfig.googleapis.com", "runtimeconfig", true),
         ensureCloudBuildEnabled_1.ensureCloudBuildEnabled(projectId),
+        maybeEnableAR(projectId),
     ]);
     context.runtimeConfigEnabled = checkAPIsEnabled[1];
+    context.artifactRegistryEnabled = checkAPIsEnabled[3];
     const firebaseConfig = await functionsConfig.getFirebaseConfig(options);
     context.firebaseConfig = firebaseConfig;
     const runtimeConfig = await prepareFunctionsUpload_1.getFunctionsConfig(context);
@@ -53,58 +63,91 @@ 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",
-            storage: "storage.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 triggerRegionHelper_1.setTriggerRegion(wantFunctions, haveFunctions);
-    await prompts_1.promptForFailurePolicies(options, wantFunctions, haveFunctions);
-    await prompts_1.promptForMinInstances(options, wantFunctions, haveFunctions);
+    const haveBackend = await backend.existingBackend(context);
+    await checkIam_1.ensureServiceAgentRoles(projectId, wantBackend, haveBackend);
+    inferDetailsFromExisting(wantBackend, haveBackend, usedDotenv);
+    await triggerRegionHelper_1.ensureTriggerRegions(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;