firebase-tools 9.19.0 → 9.23.0

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

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.triggerTag = exports.printAbortedErrors = exports.printErrors = exports.logAndTrackDeployStats = exports.AbortedDeploymentError = exports.DeploymentError = void 0;
+const backend = require("../backend");
+const clc = require("cli-color");
+const logger_1 = require("../../../logger");
+const track = require("../../../track");
+const utils = require("../../../utils");
+const functionsDeployHelper_1 = require("../functionsDeployHelper");
+class DeploymentError extends Error {
+    constructor(endpoint, op, original) {
+        super(`Failed to ${op} function ${endpoint.id} in region ${endpoint.region}`);
+        this.endpoint = endpoint;
+        this.op = op;
+        this.original = original;
+    }
+}
+exports.DeploymentError = DeploymentError;
+class AbortedDeploymentError extends DeploymentError {
+    constructor(endpoint) {
+        super(endpoint, "delete", new Error("aborted"));
+        this.endpoint = endpoint;
+    }
+}
+exports.AbortedDeploymentError = AbortedDeploymentError;
+async function logAndTrackDeployStats(summary) {
+    let totalTime = 0;
+    let totalErrors = 0;
+    let totalSuccesses = 0;
+    let totalAborts = 0;
+    const reports = [];
+    for (const result of summary.results) {
+        const tag = triggerTag(result.endpoint);
+        totalTime += result.durationMs;
+        if (!result.error) {
+            totalSuccesses++;
+            reports.push(track.track("function_deploy_success", tag, result.durationMs));
+        }
+        else if (result.error instanceof AbortedDeploymentError) {
+            totalAborts++;
+            reports.push(track.track("function_deploy_abort", tag, result.durationMs));
+        }
+        else {
+            totalErrors++;
+            reports.push(track.track("function_deploy_failure", tag, result.durationMs));
+        }
+    }
+    const gcfv1 = summary.results.find((r) => r.endpoint.platform === "gcfv1");
+    const gcfv2 = summary.results.find((r) => r.endpoint.platform === "gcfv2");
+    const tag = gcfv1 && gcfv2 ? "v1+v2" : gcfv1 ? "v1" : "v2";
+    reports.push(track.track("functions_codebase_deploy", tag, summary.results.length));
+    const avgTime = totalTime / (totalSuccesses + totalErrors);
+    logger_1.logger.debug(`Total Function Deployment time: ${summary.totalTime}`);
+    logger_1.logger.debug(`${totalErrors + totalSuccesses + totalAborts} Functions Deployed`);
+    logger_1.logger.debug(`${totalErrors} Functions Errored`);
+    logger_1.logger.debug(`${totalAborts} Function Deployments Aborted`);
+    logger_1.logger.debug(`Average Function Deployment time: ${avgTime}`);
+    if (totalErrors + totalSuccesses > 0) {
+        if (totalErrors === 0) {
+            reports.push(track.track("functions_deploy_result", "success", totalSuccesses));
+        }
+        else if (totalSuccesses > 0) {
+            reports.push(track.track("functions_deploy_result", "partial_success", totalSuccesses));
+            reports.push(track.track("functions_deploy_result", "partial_failure", totalErrors));
+            reports.push(track.track("functions_deploy_result", "partial_error_ratio", totalErrors / (totalSuccesses + totalErrors)));
+        }
+        else {
+            reports.push(track.track("functions_deploy_result", "failure", totalErrors));
+        }
+    }
+    await utils.allSettled(reports);
+}
+exports.logAndTrackDeployStats = logAndTrackDeployStats;
+function printErrors(summary) {
+    const errored = summary.results.filter((r) => r.error);
+    if (errored.length === 0) {
+        return;
+    }
+    errored.sort((left, right) => backend.compareFunctions(left.endpoint, right.endpoint));
+    logger_1.logger.info("");
+    logger_1.logger.info("Functions deploy had errors with the following functions:" +
+        errored
+            .filter((r) => !(r.error instanceof AbortedDeploymentError))
+            .map((result) => `\n\t${functionsDeployHelper_1.getFunctionLabel(result.endpoint)}`)
+            .join(""));
+    printIamErrors(errored);
+    printQuotaErrors(errored);
+    printAbortedErrors(errored);
+}
+exports.printErrors = printErrors;
+function printIamErrors(results) {
+    const iamFailures = results.filter((r) => r.error instanceof DeploymentError && r.error.op === "set invoker");
+    if (!iamFailures.length) {
+        return;
+    }
+    logger_1.logger.info("");
+    logger_1.logger.info("Unable to set the invoker for the IAM policy on the following functions:" +
+        iamFailures.map((result) => `\n\t${functionsDeployHelper_1.getFunctionLabel(result.endpoint)}`).join(""));
+    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.");
+    const hadImplicitMakePublic = iamFailures.find((r) => backend.isHttpsTriggered(r.endpoint) && !r.endpoint.httpsTrigger.invoker);
+    if (!hadImplicitMakePublic) {
+        return;
+    }
+    logger_1.logger.info("");
+    logger_1.logger.info("One or more functions were being implicitly made publicly available on function create.");
+    logger_1.logger.info("Functions are not implicitly made public on updates. To try to make " +
+        "these functions public on next deploy, configure these functions with " +
+        `${clc.bold("invoker")} set to ${clc.bold(`"public"`)}`);
+}
+function printQuotaErrors(results) {
+    const hadQuotaError = results.find((r) => {
+        var _a, _b, _c, _d, _e, _f;
+        if (!(r.error instanceof DeploymentError)) {
+            return false;
+        }
+        const original = r.error.original;
+        const code = (original === null || original === void 0 ? void 0 : original.status) || (original === null || original === void 0 ? void 0 : original.code) || ((_b = (_a = original === null || original === void 0 ? void 0 : original.context) === null || _a === void 0 ? void 0 : _a.response) === null || _b === void 0 ? void 0 : _b.statusCode) || ((_c = original === null || original === void 0 ? void 0 : original.original) === null || _c === void 0 ? void 0 : _c.code) || ((_f = (_e = (_d = original === null || original === void 0 ? void 0 : original.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);
+        return code === 429 || code === 409;
+    });
+    if (!hadQuotaError) {
+        return;
+    }
+    logger_1.logger.info("");
+    logger_1.logger.info("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.");
+}
+function printAbortedErrors(results) {
+    const aborted = results.filter((r) => r.error instanceof AbortedDeploymentError);
+    if (!aborted.length) {
+        return;
+    }
+    logger_1.logger.info("");
+    logger_1.logger.info("Because there were errors creating or updating functions, the following " +
+        "functions were not deleted" +
+        aborted.map((result) => `\n\t${functionsDeployHelper_1.getFunctionLabel(result.endpoint)}`).join(""));
+    logger_1.logger.info(`To delete these, use ${clc.bold("firebase functions:delete")}`);
+}
+exports.printAbortedErrors = printAbortedErrors;
+function triggerTag(endpoint) {
+    var _a;
+    const prefix = endpoint.platform === "gcfv1" ? "v1" : "v2";
+    if (backend.isScheduleTriggered(endpoint)) {
+        return `${prefix}.scheduled`;
+    }
+    if (backend.isTaskQueueTriggered(endpoint)) {
+        return `${prefix}.taskQueue`;
+    }
+    if (backend.isHttpsTriggered(endpoint)) {
+        if ((_a = endpoint.labels) === null || _a === void 0 ? void 0 : _a["deployment-callable"]) {
+            return `${prefix}.callable`;
+        }
+        return `${prefix}.https`;
+    }
+    return endpoint.eventTrigger.eventType;
+}
+exports.triggerTag = triggerTag;

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceTokenScraper = void 0;
+const logger_1 = require("../../../logger");
+class SourceTokenScraper {
+    constructor() {
+        this.firstCall = true;
+        this.promise = new Promise((resolve) => (this.resolve = resolve));
+    }
+    tokenPromise() {
+        if (this.firstCall) {
+            this.firstCall = false;
+            return Promise.resolve(undefined);
+        }
+        return this.promise;
+    }
+    get poller() {
+        return (op) => {
+            var _a, _b, _c, _d, _e;
+            if (((_a = op.metadata) === null || _a === void 0 ? void 0 : _a.sourceToken) || op.done) {
+                const [, , , region] = ((_c = (_b = op.metadata) === null || _b === void 0 ? void 0 : _b.target) === null || _c === void 0 ? void 0 : _c.split("/")) || [];
+                logger_1.logger.debug(`Got source token ${(_d = op.metadata) === null || _d === void 0 ? void 0 : _d.sourceToken} for region ${region}`);
+                this.resolve((_e = op.metadata) === null || _e === void 0 ? void 0 : _e.sourceToken);
+            }
+        };
+    }
+}
+exports.SourceTokenScraper = SourceTokenScraper;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timer = void 0;
+class Timer {
+    constructor() {
+        this.start = process.hrtime.bigint();
+    }
+    stop() {
+        const stop = process.hrtime.bigint();
+        const elapsedNanos = stop - this.start;
+        return Number(elapsedNanos / BigInt(1e6));
+    }
+}
+exports.Timer = Timer;

package/lib/deploy/functions/runtimes/discovery/v1alpha1.js

@@ -2,151 +2,154 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.backendFromV1Alpha1 = void 0;
 const backend = require("../../backend");
+const proto_1 = require("../../../../gcp/proto");
 const parsing_1 = require("./parsing");
+const error_1 = require("../../../../error");
 function backendFromV1Alpha1(yaml, project, region, runtime) {
-    const bkend = JSON.parse(JSON.stringify(yaml));
-    delete bkend.specVersion;
-    tryValidate(bkend);
-    fillDefaults(bkend, project, region, runtime);
+    const manifest = JSON.parse(JSON.stringify(yaml));
+    const bkend = backend.empty();
+    bkend.requiredAPIs = parseRequiredAPIs(manifest);
+    parsing_1.requireKeys("", manifest, "endpoints");
+    parsing_1.assertKeyTypes("", manifest, {
+        specVersion: "string",
+        requiredAPIs: "object",
+        endpoints: "object",
+    });
+    for (const id of Object.keys(manifest.endpoints)) {
+        for (const parsed of parseEndpoints(manifest, id, project, region, runtime)) {
+            bkend.endpoints[parsed.region] = bkend.endpoints[parsed.region] || {};
+            bkend.endpoints[parsed.region][parsed.id] = parsed;
+        }
+    }
     return bkend;
 }
 exports.backendFromV1Alpha1 = backendFromV1Alpha1;
-function tryValidate(typed) {
-    var _a, _b;
-    parsing_1.assertKeyTypes("", typed, {
-        requiredAPIs: "object",
-        endpoints: "array",
-        cloudFunctions: "array",
-        topics: "array",
-        schedules: "array",
+function parseRequiredAPIs(manifest) {
+    const requiredAPIs = {};
+    if (typeof manifest !== "object" || Array.isArray(manifest)) {
+        throw new error_1.FirebaseError("Expected requiredApis to be a map of string to string");
+    }
+    for (const [api, reason] of Object.entries(manifest.requiredAPIs || {})) {
+        if (typeof reason !== "string") {
+            throw new error_1.FirebaseError(`Invalid reason "${JSON.stringify(reason)} for API ${api}. Expected string`);
+        }
+        requiredAPIs[api] = reason;
+    }
+    return requiredAPIs;
+}
+function parseEndpoints(manifest, id, project, defaultRegion, runtime) {
+    const allParsed = [];
+    const prefix = `endpoints[${id}]`;
+    const ep = manifest.endpoints[id];
+    parsing_1.assertKeyTypes(prefix, ep, {
+        region: "array",
+        platform: "string",
+        entryPoint: "string",
+        availableMemoryMb: "number",
+        maxInstances: "number",
+        minInstances: "number",
+        concurrency: "number",
+        serviceAccountEmail: "string",
+        timeout: "string",
+        vpcConnector: "string",
+        vpcConnectorEgressSettings: "string",
+        labels: "object",
+        ingressSettings: "string",
         environmentVariables: "object",
+        httpsTrigger: "object",
+        eventTrigger: "object",
+        scheduleTrigger: "object",
+        taskQueueTrigger: "object",
     });
-    parsing_1.requireKeys("", typed, "cloudFunctions");
-    for (let ndx = 0; ndx < typed.cloudFunctions.length; ndx++) {
-        const prefix = `cloudFunctions[${ndx}]`;
-        const func = typed.cloudFunctions[ndx];
-        parsing_1.requireKeys(prefix, func, "platform", "id", "entryPoint", "trigger");
-        parsing_1.assertKeyTypes(prefix, func, {
-            platform: "string",
-            id: "string",
-            region: "string",
-            project: "string",
-            runtime: "string",
-            entryPoint: "string",
-            availableMemoryMb: "number",
-            maxInstances: "number",
-            minInstances: "number",
-            concurrency: "number",
-            serviceAccountEmail: "string",
-            timeout: "string",
-            trigger: "object",
-            vpcConnector: "string",
-            vpcConnectorEgressSettings: "string",
-            labels: "object",
-            ingressSettings: "string",
-            environmentVariables: "omit",
-            uri: "omit",
-            sourceUploadUrl: "omit",
-        });
-        if (backend.isEventTrigger(func.trigger)) {
-            parsing_1.requireKeys(prefix + ".trigger", func.trigger, "eventType", "eventFilters");
-            parsing_1.assertKeyTypes(prefix + ".trigger", func.trigger, {
+    let triggerCount = 0;
+    if (ep.httpsTrigger) {
+        triggerCount++;
+    }
+    if (ep.eventTrigger) {
+        triggerCount++;
+    }
+    if (ep.scheduleTrigger) {
+        triggerCount++;
+    }
+    if (ep.taskQueueTrigger) {
+        triggerCount++;
+    }
+    if (!triggerCount) {
+        throw new error_1.FirebaseError("Expected trigger in endpoint" + id);
+    }
+    if (triggerCount > 1) {
+        throw new error_1.FirebaseError("Multiple triggers defined for endpoint" + id);
+    }
+    for (const region of ep.region || [defaultRegion]) {
+        let triggered;
+        if (backend.isEventTriggered(ep)) {
+            parsing_1.requireKeys(prefix + ".eventTrigger", ep.eventTrigger, "eventType", "eventFilters");
+            parsing_1.assertKeyTypes(prefix + ".eventTrigger", ep.eventTrigger, {
                 eventFilters: "object",
                 eventType: "string",
                 retry: "boolean",
                 region: "string",
                 serviceAccountEmail: "string",
             });
+            triggered = { eventTrigger: ep.eventTrigger };
         }
-        else {
-            parsing_1.assertKeyTypes(prefix + ".trigger", func.trigger, {
+        else if (backend.isHttpsTriggered(ep)) {
+            parsing_1.assertKeyTypes(prefix + ".httpsTrigger", ep.httpsTrigger, {
                 invoker: "array",
             });
+            triggered = { httpsTrigger: {} };
+            proto_1.copyIfPresent(triggered.httpsTrigger, ep.httpsTrigger, "invoker");
         }
-    }
-    for (let ndx = 0; ndx < ((_a = typed.topics) === null || _a === void 0 ? void 0 : _a.length); ndx++) {
-        let prefix = `topics[${ndx}]`;
-        const topic = typed.topics[ndx];
-        parsing_1.requireKeys(prefix, topic, "id", "targetService");
-        parsing_1.assertKeyTypes(prefix, topic, {
-            id: "string",
-            labels: "object",
-            project: "string",
-            targetService: "object",
-        });
-        prefix += ".targetService";
-        parsing_1.requireKeys(prefix, topic.targetService, "id");
-        parsing_1.assertKeyTypes(prefix, topic.targetService, {
-            id: "string",
-            project: "string",
-            region: "string",
-        });
-    }
-    for (let ndx = 0; ndx < ((_b = typed.schedules) === null || _b === void 0 ? void 0 : _b.length); ndx++) {
-        let prefix = `schedules[${ndx}]`;
-        const schedule = typed.schedules[ndx];
-        parsing_1.requireKeys(prefix, schedule, "id", "schedule", "transport", "targetService");
-        parsing_1.assertKeyTypes(prefix, schedule, {
-            id: "string",
-            project: "string",
-            retryConfig: "object",
-            schedule: "string",
-            timeZone: "string",
-            transport: "string",
-            targetService: "object",
-        });
-        parsing_1.assertKeyTypes(prefix + ".retryConfig", schedule.retryConfig, {
-            maxBackoffDuration: "string",
-            minBackoffDuration: "string",
-            maxDoublings: "number",
-            maxRetryDuration: "string",
-            retryCount: "number",
-        });
-        parsing_1.requireKeys((prefix = ".targetService"), schedule.targetService, "id");
-        parsing_1.assertKeyTypes(prefix + ".targetService", schedule.targetService, {
-            id: "string",
-            project: "string",
-            region: "string",
-        });
-    }
-}
-function fillDefaults(want, project, region, runtime) {
-    want.requiredAPIs = want.requiredAPIs || {};
-    want.environmentVariables = want.environmentVariables || {};
-    want.schedules = want.schedules || [];
-    want.topics = want.topics || [];
-    want.endpoints = want.endpoints || [];
-    for (const cloudFunction of want.cloudFunctions) {
-        if (!cloudFunction.project) {
-            cloudFunction.project = project;
-        }
-        if (!cloudFunction.region) {
-            cloudFunction.region = region;
-        }
-        if (!cloudFunction.runtime) {
-            cloudFunction.runtime = runtime;
-        }
-    }
-    for (const topic of want.topics) {
-        if (!topic.project) {
-            topic.project = project;
-        }
-        if (!topic.targetService.project) {
-            topic.targetService.project = project;
-        }
-        if (!topic.targetService.region) {
-            topic.targetService.region = region;
-        }
-    }
-    for (const schedule of want.schedules) {
-        if (!schedule.project) {
-            schedule.project = project;
+        else if (backend.isScheduleTriggered(ep)) {
+            parsing_1.assertKeyTypes(prefix + ".scheduleTrigger", ep.scheduleTrigger, {
+                schedule: "string",
+                timeZone: "string",
+                retryConfig: "object",
+            });
+            parsing_1.assertKeyTypes(prefix + ".scheduleTrigger.retryConfig", ep.scheduleTrigger.retryConfig, {
+                retryCount: "number",
+                maxDoublings: "number",
+                minBackoffDuration: "string",
+                maxBackoffDuration: "string",
+                maxRetryDuration: "string",
+            });
+            triggered = { scheduleTrigger: ep.scheduleTrigger };
         }
-        if (!schedule.targetService.project) {
-            schedule.targetService.project = project;
+        else if (backend.isTaskQueueTriggered(ep)) {
+            parsing_1.assertKeyTypes(prefix + ".taskQueueTrigger", ep.taskQueueTrigger, {
+                rateLimits: "object",
+                retryConfig: "object",
+                invoker: "array",
+            });
+            if (ep.taskQueueTrigger.rateLimits) {
+                parsing_1.assertKeyTypes(prefix + ".taskQueueTrigger.rateLimits", ep.taskQueueTrigger.rateLimits, {
+                    maxBurstSize: "number",
+                    maxConcurrentDispatches: "number",
+                    maxDispatchesPerSecond: "number",
+                });
+            }
+            if (ep.taskQueueTrigger.retryConfig) {
+                parsing_1.assertKeyTypes(prefix + ".taskQueueTrigger.retryConfig", ep.taskQueueTrigger.retryConfig, {
+                    maxAttempts: "number",
+                    maxRetryDuration: "string",
+                    minBackoff: "string",
+                    maxBackoff: "string",
+                    maxDoublings: "number",
+                });
+            }
+            triggered = { taskQueueTrigger: ep.taskQueueTrigger };
         }
-        if (!schedule.targetService.region) {
-            schedule.targetService.region = region;
+        else {
+            throw new error_1.FirebaseError(`Do not recognize trigger type for endpoint ${id}. Try upgrading ` +
+                "firebase-tools with npm install -g firebase-tools@latest");
         }
+        parsing_1.requireKeys(prefix, ep, "entryPoint");
+        const parsed = Object.assign({ platform: ep.platform || "gcfv2", id,
+            region,
+            project,
+            runtime, entryPoint: ep.entryPoint }, triggered);
+        proto_1.copyIfPresent(parsed, ep, "availableMemoryMb", "maxInstances", "minInstances", "concurrency", "serviceAccountEmail", "timeout", "vpcConnector", "vpcConnectorEgressSettings", "labels", "ingressSettings", "environmentVariables");
+        allParsed.push(parsed);
     }
+    return allParsed;
 }

package/lib/deploy/functions/runtimes/node/parseTriggers.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addResourcesToBackend = exports.discoverBackend = exports.useStrategy = void 0;
+exports.addResourcesToBackend = exports.discoverBackend = exports.useStrategy = exports.GCS_EVENTS = void 0;
 const path = require("path");
 const _ = require("lodash");
 const child_process_1 = require("child_process");
@@ -10,6 +10,12 @@ const backend = require("../../backend");
 const api = require("../../../../api");
 const proto = require("../../../../gcp/proto");
 const TRIGGER_PARSER = path.resolve(__dirname, "./triggerParser.js");
+exports.GCS_EVENTS = new Set([
+    "google.cloud.storage.object.v1.finalized",
+    "google.cloud.storage.object.v1.archived",
+    "google.cloud.storage.object.v1.deleted",
+    "google.cloud.storage.object.v1.metadataUpdated",
+]);
 function removeInspectOptions(options) {
     return options.filter((opt) => !opt.startsWith("--inspect"));
 }
@@ -58,68 +64,58 @@ async function discoverBackend(projectId, sourceDir, runtime, configValues, envs
 }
 exports.discoverBackend = discoverBackend;
 function addResourcesToBackend(projectId, runtime, annotation, want) {
+    var _a;
     Object.freeze(annotation);
     for (const region of annotation.regions || [api.functionsDefaultRegion]) {
-        let trigger;
-        if (!!annotation.httpsTrigger == !!annotation.eventTrigger) {
+        let triggered;
+        const triggerCount = +!!annotation.httpsTrigger + +!!annotation.eventTrigger + +!!annotation.taskQueueTrigger;
+        if (triggerCount != 1) {
             throw new error_1.FirebaseError("Unexpected annotation generated by the Firebase Functions SDK. This should never happen.");
         }
-        if (annotation.httpsTrigger) {
-            trigger = {};
+        if (annotation.taskQueueTrigger) {
+            triggered = { taskQueueTrigger: annotation.taskQueueTrigger };
+            want.requiredAPIs["cloudtasks"] = "cloudtasks.googleapis.com";
+        }
+        else if (annotation.httpsTrigger) {
+            const trigger = {};
             if (annotation.failurePolicy) {
                 logger_1.logger.warn(`Ignoring retry policy for HTTPS function ${annotation.name}`);
             }
-            proto.copyIfPresent(trigger, annotation.httpsTrigger, "invoker", "invoker");
+            proto.copyIfPresent(trigger, annotation.httpsTrigger, "invoker");
+            triggered = { httpsTrigger: trigger };
+        }
+        else if (annotation.schedule) {
+            want.requiredAPIs["pubsub"] = "pubsub.googleapis.com";
+            want.requiredAPIs["scheduler"] = "cloudscheduler.googleapis.com";
+            triggered = { scheduleTrigger: annotation.schedule };
         }
         else {
-            trigger = {
-                eventType: annotation.eventTrigger.eventType,
-                eventFilters: {
-                    resource: annotation.eventTrigger.resource,
+            triggered = {
+                eventTrigger: {
+                    eventType: annotation.eventTrigger.eventType,
+                    eventFilters: {
+                        resource: annotation.eventTrigger.resource,
+                    },
+                    retry: !!annotation.failurePolicy,
                 },
-                retry: !!annotation.failurePolicy,
             };
+            if (exports.GCS_EVENTS.has(((_a = annotation.eventTrigger) === null || _a === void 0 ? void 0 : _a.eventType) || "")) {
+                triggered.eventTrigger.eventFilters = {
+                    bucket: annotation.eventTrigger.resource,
+                };
+            }
         }
-        const cloudFunctionName = {
-            id: annotation.name,
-            region: region,
-            project: projectId,
-        };
-        const cloudFunction = Object.assign(Object.assign({ platform: annotation.platform || "gcfv1" }, cloudFunctionName), { entryPoint: annotation.entryPoint, runtime: runtime, trigger: trigger });
+        const endpoint = Object.assign({ platform: annotation.platform || "gcfv1", id: annotation.name, region: region, project: projectId, entryPoint: annotation.entryPoint, runtime: runtime }, triggered);
         if (annotation.vpcConnector) {
             let maybeId = annotation.vpcConnector;
             if (!maybeId.includes("/")) {
                 maybeId = `projects/${projectId}/locations/${region}/connectors/${maybeId}`;
             }
-            cloudFunction.vpcConnector = maybeId;
-        }
-        proto.copyIfPresent(cloudFunction, annotation, "concurrency", "serviceAccountEmail", "labels", "vpcConnectorEgressSettings", "ingressSettings", "timeout", "maxInstances", "minInstances", "availableMemoryMb");
-        if (annotation.schedule) {
-            want.requiredAPIs["pubsub"] = "pubsub.googleapis.com";
-            want.requiredAPIs["scheduler"] = "cloudscheduler.googleapis.com";
-            const id = backend.scheduleIdForFunction(cloudFunctionName);
-            const schedule = {
-                id,
-                project: projectId,
-                schedule: annotation.schedule.schedule,
-                transport: "pubsub",
-                targetService: cloudFunctionName,
-            };
-            proto.copyIfPresent(schedule, annotation.schedule, "timeZone", "retryConfig");
-            want.schedules.push(schedule);
-            const topic = {
-                id,
-                project: projectId,
-                labels: backend.SCHEDULED_FUNCTION_LABEL,
-                targetService: cloudFunctionName,
-            };
-            want.topics.push(topic);
-            if (backend.isEventTrigger(cloudFunction.trigger)) {
-                cloudFunction.trigger.eventFilters.resource = `${cloudFunction.trigger.eventFilters.resource}/${id}`;
-            }
-            cloudFunction.labels = Object.assign(Object.assign({}, cloudFunction.labels), { "deployment-scheduled": "true" });
+            endpoint.vpcConnector = maybeId;
         }
-        want.cloudFunctions.push(cloudFunction);
+        proto.copyIfPresent(endpoint, annotation, "concurrency", "serviceAccountEmail", "labels", "vpcConnectorEgressSettings", "ingressSettings", "timeout", "maxInstances", "minInstances", "availableMemoryMb");
+        want.endpoints[region] = want.endpoints[region] || {};
+        want.endpoints[region][endpoint.id] = endpoint;
     }
 }
 exports.addResourcesToBackend = addResourcesToBackend;

package/lib/deploy/functions/triggerRegionHelper.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lookupMissingTriggerRegions = void 0;
+const backend = require("./backend");
+const storage = require("../../gcp/storage");
+const error_1 = require("../../error");
+const logger_1 = require("../../logger");
+const noop = () => Promise.resolve();
+const LOOKUP_BY_EVENT_TYPE = {
+    "google.cloud.pubsub.topic.v1.messagePublished": noop,
+    "google.cloud.storage.object.v1.finalized": lookupBucketRegion,
+    "google.cloud.storage.object.v1.archived": lookupBucketRegion,
+    "google.cloud.storage.object.v1.deleted": lookupBucketRegion,
+    "google.cloud.storage.object.v1.metadataUpdated": lookupBucketRegion,
+};
+async function lookupMissingTriggerRegions(want) {
+    const regionLookups = [];
+    for (const ep of backend.allEndpoints(want)) {
+        if (ep.platform === "gcfv1" || !backend.isEventTriggered(ep) || ep.eventTrigger.region) {
+            continue;
+        }
+        const lookup = LOOKUP_BY_EVENT_TYPE[ep.eventTrigger.eventType];
+        if (!lookup) {
+            logger_1.logger.debug("Don't know how to look up trigger region for event type", ep.eventTrigger.eventType, ". Deploy will fail unless this event type is global");
+            continue;
+        }
+        regionLookups.push(lookup(ep));
+    }
+    await Promise.all(regionLookups);
+}
+exports.lookupMissingTriggerRegions = lookupMissingTriggerRegions;
+async function lookupBucketRegion(endpoint) {
+    try {
+        const bucket = await storage.getBucket(endpoint.eventTrigger.eventFilters.bucket);
+        endpoint.eventTrigger.region = bucket.location.toLowerCase();
+    }
+    catch (err) {
+        throw new error_1.FirebaseError("Can't find the storage bucket region", { original: err });
+    }
+}