firebase-tools 11.4.1 → 11.4.2

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

@@ -1,15 +1,4 @@
 "use strict";
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.backendFromV1Alpha1 = exports.buildFromV1Alpha1 = void 0;
 const backend = require("../../backend");
@@ -17,6 +6,7 @@ const build = require("../../build");
 const proto_1 = require("../../../../gcp/proto");
 const parsing_1 = require("./parsing");
 const error_1 = require("../../../../error");
+const functional_1 = require("../../../../functional");
 const CHANNEL_NAME_REGEX = new RegExp("(projects\\/" +
     "(?<project>(?:\\d+)|(?:[A-Za-z]+[A-Za-z\\d-]*[A-Za-z\\d]?))\\/)?" +
     "locations\\/" +
@@ -82,29 +72,30 @@ function assertManifestEndpoint(ep, id) {
         region: "array",
         platform: (platform) => backend.AllFunctionsPlatforms.includes(platform),
         entryPoint: "string",
-        availableMemoryMb: (mem) => backend.AllMemoryOptions.includes(mem),
-        maxInstances: "number",
-        minInstances: "number",
-        concurrency: "number",
-        serviceAccountEmail: "string",
-        timeoutSeconds: "number",
-        vpc: "object",
-        labels: "object",
-        ingressSettings: (setting) => backend.AllIngressSettings.includes(setting),
-        environmentVariables: "object",
-        secretEnvironmentVariables: "array",
+        availableMemoryMb: (mem) => mem === null || backend.isValidMemoryOption(mem),
+        maxInstances: "number?",
+        minInstances: "number?",
+        concurrency: "number?",
+        serviceAccount: "string?",
+        serviceAccountEmail: "string?",
+        timeoutSeconds: "number?",
+        vpc: "object?",
+        labels: "object?",
+        ingressSettings: (setting) => setting === null || backend.AllIngressSettings.includes(setting),
+        environmentVariables: "object?",
+        secretEnvironmentVariables: "array?",
         httpsTrigger: "object",
         callableTrigger: "object",
         eventTrigger: "object",
         scheduleTrigger: "object",
         taskQueueTrigger: "object",
         blockingTrigger: "object",
-        cpu: (cpu) => typeof cpu === "number" || cpu === "gcf_gen1",
+        cpu: (cpu) => cpu === null || typeof cpu === "number" || cpu === "gcf_gen1",
     });
     if (ep.vpc) {
         (0, parsing_1.assertKeyTypes)(prefix + ".vpc", ep.vpc, {
             connector: "string",
-            egressSettings: (setting) => backend.AllVpcEgressSettings.includes(setting),
+            egressSettings: (setting) => setting === null || backend.AllVpcEgressSettings.includes(setting),
         });
         (0, parsing_1.requireKeys)(prefix + ".vpc", ep.vpc, "connector");
     }
@@ -141,13 +132,14 @@ function assertManifestEndpoint(ep, id) {
             eventType: "string",
             retry: "boolean",
             region: "string",
-            serviceAccountEmail: "string",
+            serviceAccount: "string?",
+            serviceAccountEmail: "string?",
             channel: "string",
         });
     }
     else if (backend.isHttpsTriggered(ep)) {
         (0, parsing_1.assertKeyTypes)(prefix + ".httpsTrigger", ep.httpsTrigger, {
-            invoker: "array",
+            invoker: "array?",
         });
     }
     else if (backend.isCallableTriggered(ep)) {
@@ -155,36 +147,39 @@ function assertManifestEndpoint(ep, id) {
     else if (backend.isScheduleTriggered(ep)) {
         (0, parsing_1.assertKeyTypes)(prefix + ".scheduleTrigger", ep.scheduleTrigger, {
             schedule: "string",
-            timeZone: "string",
-            retryConfig: "object",
+            timeZone: "string?",
+            retryConfig: "object?",
         });
-        (0, parsing_1.assertKeyTypes)(prefix + ".scheduleTrigger.retryConfig", ep.scheduleTrigger.retryConfig, {
-            retryCount: "number",
-            maxDoublings: "number",
-            minBackoffDuration: "string",
-            maxBackoffDuration: "string",
-            maxRetryDuration: "string",
+        (0, parsing_1.assertKeyTypes)(prefix + ".scheduleTrigger.retryConfig", ep.scheduleTrigger.retryConfig || {}, {
+            retryCount: "number?",
+            maxDoublings: "number?",
+            minBackoffSeconds: "number?",
+            maxBackoffSeconds: "number?",
+            maxRetrySeconds: "number?",
+            minBackoffDuration: "string?",
+            maxBackoffDuration: "string?",
+            maxRetryDuration: "string?",
         });
     }
     else if (backend.isTaskQueueTriggered(ep)) {
         (0, parsing_1.assertKeyTypes)(prefix + ".taskQueueTrigger", ep.taskQueueTrigger, {
-            rateLimits: "object",
-            retryConfig: "object",
-            invoker: "array",
+            rateLimits: "object?",
+            retryConfig: "object?",
+            invoker: "array?",
         });
         if (ep.taskQueueTrigger.rateLimits) {
             (0, parsing_1.assertKeyTypes)(prefix + ".taskQueueTrigger.rateLimits", ep.taskQueueTrigger.rateLimits, {
-                maxConcurrentDispatches: "number",
-                maxDispatchesPerSecond: "number",
+                maxConcurrentDispatches: "number?",
+                maxDispatchesPerSecond: "number?",
             });
         }
         if (ep.taskQueueTrigger.retryConfig) {
             (0, parsing_1.assertKeyTypes)(prefix + ".taskQueueTrigger.retryConfig", ep.taskQueueTrigger.retryConfig, {
-                maxAttempts: "number",
-                maxRetrySeconds: "number",
-                minBackoffSeconds: "number",
-                maxBackoffSeconds: "number",
-                maxDoublings: "number",
+                maxAttempts: "number?",
+                maxRetrySeconds: "number?",
+                minBackoffSeconds: "number?",
+                maxBackoffSeconds: "number?",
+                maxDoublings: "number?",
             });
         }
     }
@@ -201,18 +196,24 @@ function assertManifestEndpoint(ep, id) {
     }
 }
 function parseEndpointForBuild(id, ep, project, defaultRegion, runtime) {
+    var _a;
     let triggered;
     if (backend.isEventTriggered(ep)) {
-        const newTrigger = __rest(ep.eventTrigger, []);
-        delete newTrigger.serviceAccountEmail;
-        triggered = { eventTrigger: newTrigger };
-        triggered.eventTrigger.serviceAccount = ep.eventTrigger.serviceAccountEmail;
-        (0, proto_1.renameIfPresent)(triggered.eventTrigger, ep.eventTrigger, "channel", "channel", (c) => resolveChannelName(project, c, defaultRegion));
-        for (const [k, v] of Object.entries(triggered.eventTrigger.eventFilters)) {
-            if (k === "topic" && !v.startsWith("projects/")) {
-                triggered.eventTrigger.eventFilters[k] = `projects/${project}/topics/${v}`;
+        const eventTrigger = {
+            eventType: ep.eventTrigger.eventType,
+            retry: ep.eventTrigger.retry,
+        };
+        (0, proto_1.renameIfPresent)(eventTrigger, ep.eventTrigger, "serviceAccount", "serviceAccountEmail");
+        (0, proto_1.copyIfPresent)(eventTrigger, ep.eventTrigger, "serviceAccount", "eventFilterPathPatterns", "region");
+        (0, proto_1.convertIfPresent)(eventTrigger, ep.eventTrigger, "channel", (c) => resolveChannelName(project, c, defaultRegion));
+        (0, proto_1.convertIfPresent)(eventTrigger, ep.eventTrigger, "eventFilters", (filters) => {
+            const copy = Object.assign({}, filters);
+            if (copy["topic"] && !copy["topic"].startsWith("projects/")) {
+                copy["topic"] = `projects/${project}/topics/${copy["topic"]}`;
             }
-        }
+            return copy;
+        });
+        triggered = { eventTrigger };
     }
     else if (backend.isHttpsTriggered(ep)) {
         triggered = { httpsTrigger: {} };
@@ -224,39 +225,39 @@ function parseEndpointForBuild(id, ep, project, defaultRegion, runtime) {
     else if (backend.isScheduleTriggered(ep)) {
         const st = {
             schedule: ep.scheduleTrigger.schedule || "",
-            timeZone: ep.scheduleTrigger.timeZone || "",
-            retryConfig: {},
+            timeZone: (_a = ep.scheduleTrigger.timeZone) !== null && _a !== void 0 ? _a : null,
         };
         if (ep.scheduleTrigger.retryConfig) {
-            st.retryConfig = {
-                retryCount: ep.scheduleTrigger.retryConfig.retryCount,
-                maxDoublings: ep.scheduleTrigger.retryConfig.maxDoublings,
-            };
-            if (ep.scheduleTrigger.retryConfig.maxRetryDuration) {
-                st.retryConfig.maxRetrySeconds = (0, proto_1.secondsFromDuration)(ep.scheduleTrigger.retryConfig.maxRetryDuration);
-            }
-            if (ep.scheduleTrigger.retryConfig.maxBackoffDuration) {
-                st.retryConfig.maxBackoffSeconds = (0, proto_1.secondsFromDuration)(ep.scheduleTrigger.retryConfig.maxBackoffDuration);
-            }
-            if (ep.scheduleTrigger.retryConfig.minBackoffDuration) {
-                st.retryConfig.minBackoffSeconds = (0, proto_1.secondsFromDuration)(ep.scheduleTrigger.retryConfig.minBackoffDuration);
-            }
+            st.retryConfig = {};
+            (0, proto_1.copyIfPresent)(st.retryConfig, ep.scheduleTrigger.retryConfig, "retryCount", "minBackoffSeconds", "maxBackoffSeconds", "maxRetrySeconds", "maxDoublings");
+            (0, proto_1.convertIfPresent)(st.retryConfig, ep.scheduleTrigger.retryConfig, "minBackoffSeconds", "minBackoffDuration", (0, functional_1.nullsafeVisitor)(proto_1.secondsFromDuration));
+            (0, proto_1.convertIfPresent)(st.retryConfig, ep.scheduleTrigger.retryConfig, "maxBackoffSeconds", "maxBackoffDuration", (0, functional_1.nullsafeVisitor)(proto_1.secondsFromDuration));
+            (0, proto_1.convertIfPresent)(st.retryConfig, ep.scheduleTrigger.retryConfig, "maxRetrySeconds", "maxRetryDuration", (0, functional_1.nullsafeVisitor)(proto_1.secondsFromDuration));
+        }
+        else if (ep.scheduleTrigger.retryConfig === null) {
+            st.retryConfig = null;
         }
         triggered = { scheduleTrigger: st };
     }
     else if (backend.isTaskQueueTriggered(ep)) {
-        const tq = {
-            invoker: ep.taskQueueTrigger.invoker,
-            rateLimits: ep.taskQueueTrigger.rateLimits,
-        };
+        const tq = {};
+        if (ep.taskQueueTrigger.invoker) {
+            tq.invoker = ep.taskQueueTrigger.invoker;
+        }
+        else if (ep.taskQueueTrigger.invoker === null) {
+            tq.invoker = null;
+        }
         if (ep.taskQueueTrigger.retryConfig) {
-            tq.retryConfig = {
-                maxRetryDurationSeconds: ep.taskQueueTrigger.retryConfig.maxRetrySeconds,
-                maxBackoffSeconds: ep.taskQueueTrigger.retryConfig.maxBackoffSeconds,
-                minBackoffSeconds: ep.taskQueueTrigger.retryConfig.minBackoffSeconds,
-                maxDoublings: ep.taskQueueTrigger.retryConfig.maxDoublings,
-                maxAttempts: ep.taskQueueTrigger.retryConfig.maxAttempts,
-            };
+            tq.retryConfig = Object.assign({}, ep.taskQueueTrigger.retryConfig);
+        }
+        else if (ep.taskQueueTrigger.retryConfig === null) {
+            tq.retryConfig = null;
+        }
+        if (ep.taskQueueTrigger.rateLimits) {
+            tq.rateLimits = Object.assign({}, ep.taskQueueTrigger.rateLimits);
+        }
+        else if (ep.taskQueueTrigger.rateLimits === null) {
+            tq.rateLimits = null;
         }
         triggered = { taskQueueTrigger: tq };
     }
@@ -268,18 +269,16 @@ function parseEndpointForBuild(id, ep, project, defaultRegion, runtime) {
             "firebase-tools with npm install -g firebase-tools@latest");
     }
     const parsed = Object.assign({ platform: ep.platform || "gcfv2", region: ep.region || [defaultRegion], project,
-        runtime, entryPoint: ep.entryPoint, serviceAccount: ep.serviceAccountEmail || null }, triggered);
-    (0, proto_1.copyIfPresent)(parsed, ep, "availableMemoryMb", "maxInstances", "minInstances", "concurrency", "timeoutSeconds", "vpc", "labels", "ingressSettings", "environmentVariables");
-    (0, proto_1.renameIfPresent)(parsed, ep, "secretEnvironmentVariables", "secretEnvironmentVariables", (senvs) => {
-        const secretEnvironmentVariables = [];
-        for (const { key, secret } of senvs) {
-            secretEnvironmentVariables.push({
-                key,
-                secret: secret || key,
-                projectId: project,
-            });
+        runtime, entryPoint: ep.entryPoint }, triggered);
+    (0, proto_1.renameIfPresent)(parsed, ep, "serviceAccount", "serviceAccountEmail");
+    (0, proto_1.copyIfPresent)(parsed, ep, "availableMemoryMb", "cpu", "maxInstances", "minInstances", "concurrency", "timeoutSeconds", "vpc", "labels", "ingressSettings", "environmentVariables", "serviceAccount");
+    (0, proto_1.convertIfPresent)(parsed, ep, "secretEnvironmentVariables", (senvs) => {
+        if (!senvs) {
+            return null;
         }
-        return secretEnvironmentVariables;
+        return senvs.map(({ key, secret }) => {
+            return { key, secret: secret || key, projectId: project };
+        });
     });
     return parsed;
 }
@@ -287,17 +286,25 @@ function parseEndpoints(manifest, id, project, defaultRegion, runtime) {
     const allParsed = [];
     const prefix = `endpoints[${id}]`;
     const ep = manifest.endpoints[id];
-    assertManifestEndpoint(ep, prefix);
+    assertManifestEndpoint(ep, id);
     for (const region of ep.region || [defaultRegion]) {
         let triggered;
         if (backend.isEventTriggered(ep)) {
-            triggered = { eventTrigger: ep.eventTrigger };
-            (0, proto_1.renameIfPresent)(triggered.eventTrigger, ep.eventTrigger, "channel", "channel", (c) => resolveChannelName(project, c, defaultRegion));
-            for (const [k, v] of Object.entries(triggered.eventTrigger.eventFilters)) {
-                if (k === "topic" && !v.startsWith("projects/")) {
-                    triggered.eventTrigger.eventFilters[k] = `projects/${project}/topics/${v}`;
+            const eventTrigger = {
+                eventType: ep.eventTrigger.eventType,
+                retry: false,
+            };
+            (0, proto_1.renameIfPresent)(eventTrigger, ep.eventTrigger, "serviceAccount", "serviceAccountEmail");
+            (0, proto_1.copyIfPresent)(eventTrigger, ep.eventTrigger, "eventFilterPathPatterns", "retry", "serviceAccount", "region");
+            (0, proto_1.convertIfPresent)(eventTrigger, ep.eventTrigger, "channel", (c) => resolveChannelName(project, c, defaultRegion));
+            (0, proto_1.convertIfPresent)(eventTrigger, ep.eventTrigger, "eventFilters", (filters) => {
+                const copy = Object.assign({}, filters);
+                if (copy["topic"] && !copy["topic"].startsWith("projects/")) {
+                    copy["topic"] = `projects/${project}/topics/${copy["topic"]}`;
                 }
-            }
+                return copy;
+            });
+            triggered = { eventTrigger };
         }
         else if (backend.isHttpsTriggered(ep)) {
             triggered = { httpsTrigger: {} };
@@ -324,17 +331,15 @@ function parseEndpoints(manifest, id, project, defaultRegion, runtime) {
             region,
             project,
             runtime, entryPoint: ep.entryPoint }, triggered);
-        (0, proto_1.copyIfPresent)(parsed, ep, "availableMemoryMb", "maxInstances", "minInstances", "concurrency", "serviceAccountEmail", "timeoutSeconds", "vpc", "labels", "ingressSettings", "environmentVariables", "cpu");
-        (0, proto_1.renameIfPresent)(parsed, ep, "secretEnvironmentVariables", "secretEnvironmentVariables", (senvs) => {
-            const secretEnvironmentVariables = [];
-            for (const { key, secret } of senvs) {
-                secretEnvironmentVariables.push({
-                    key,
-                    secret: secret || key,
-                    projectId: project,
-                });
+        (0, proto_1.renameIfPresent)(parsed, ep, "serviceAccount", "serviceAccountEmail");
+        (0, proto_1.copyIfPresent)(parsed, ep, "availableMemoryMb", "maxInstances", "minInstances", "concurrency", "serviceAccount", "timeoutSeconds", "vpc", "labels", "ingressSettings", "environmentVariables", "cpu");
+        (0, proto_1.convertIfPresent)(parsed, ep, "secretEnvironmentVariables", (senvs) => {
+            if (!senvs) {
+                return null;
             }
-            return secretEnvironmentVariables;
+            return senvs.map(({ key, secret }) => {
+                return { key, secret: secret || key, projectId: project };
+            });
         });
         allParsed.push(parsed);
     }

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

@@ -10,6 +10,7 @@ const backend = require("../../backend");
 const api = require("../../../../api");
 const proto = require("../../../../gcp/proto");
 const events = require("../../../../functions/events");
+const functional_1 = require("../../../../functional");
 const TRIGGER_PARSER = path.resolve(__dirname, "./triggerParser.js");
 function removeInspectOptions(options) {
     return options.filter((opt) => !opt.startsWith("--inspect"));
@@ -88,8 +89,9 @@ function mergeRequiredAPIs(backend) {
 }
 exports.mergeRequiredAPIs = mergeRequiredAPIs;
 function addResourcesToBuild(projectId, runtime, annotation, want) {
-    var _a;
+    var _a, _b;
     Object.freeze(annotation);
+    const toSeconds = (0, functional_1.nullsafeVisitor)(proto.secondsFromDuration);
     const regions = annotation.regions || [api.functionsDefaultRegion];
     let triggered;
     const triggerCount = +!!annotation.httpsTrigger +
@@ -110,9 +112,11 @@ function addResourcesToBuild(projectId, runtime, annotation, want) {
         proto.copyIfPresent(triggered.taskQueueTrigger, annotation.taskQueueTrigger, "invoker");
         proto.copyIfPresent(triggered.taskQueueTrigger, annotation.taskQueueTrigger, "rateLimits");
         if (annotation.taskQueueTrigger.retryConfig) {
-            triggered.taskQueueTrigger.retryConfig = Object.assign(annotation.taskQueueTrigger.retryConfig, {
-                maxRetryDurationSeconds: proto.secondsFromDuration(annotation.taskQueueTrigger.retryConfig.maxRetryDuration || "0"),
-            });
+            triggered.taskQueueTrigger.retryConfig = {};
+            proto.copyIfPresent(triggered.taskQueueTrigger.retryConfig, annotation.taskQueueTrigger.retryConfig, "maxAttempts", "maxDoublings");
+            proto.convertIfPresent(triggered.taskQueueTrigger.retryConfig, annotation.taskQueueTrigger.retryConfig, "minBackoffSeconds", "minBackoff", toSeconds);
+            proto.convertIfPresent(triggered.taskQueueTrigger.retryConfig, annotation.taskQueueTrigger.retryConfig, "maxBackoffSeconds", "maxBackoff", toSeconds);
+            proto.convertIfPresent(triggered.taskQueueTrigger.retryConfig, annotation.taskQueueTrigger.retryConfig, "maxRetryDurationSeconds", "maxRetryDuration", toSeconds);
         }
     }
     else if (annotation.httpsTrigger) {
@@ -139,21 +143,16 @@ function addResourcesToBuild(projectId, runtime, annotation, want) {
         triggered = {
             scheduleTrigger: {
                 schedule: annotation.schedule.schedule,
-                timeZone: annotation.schedule.timeZone || "America/Los_Angeles",
+                timeZone: (_b = annotation.schedule.timeZone) !== null && _b !== void 0 ? _b : null,
                 retryConfig: {},
             },
         };
         if (annotation.schedule.retryConfig) {
-            if (annotation.schedule.retryConfig.maxBackoffDuration) {
-                triggered.scheduleTrigger.retryConfig.maxBackoffSeconds = proto.secondsFromDuration(annotation.schedule.retryConfig.maxBackoffDuration);
-            }
-            if (annotation.schedule.retryConfig.minBackoffDuration) {
-                triggered.scheduleTrigger.retryConfig.minBackoffSeconds = proto.secondsFromDuration(annotation.schedule.retryConfig.minBackoffDuration);
-            }
-            if (annotation.schedule.retryConfig.maxRetryDuration) {
-                triggered.scheduleTrigger.retryConfig.maxRetrySeconds = proto.secondsFromDuration(annotation.schedule.retryConfig.maxRetryDuration);
-            }
-            proto.copyIfPresent(triggered.scheduleTrigger.retryConfig, annotation.schedule.retryConfig, "maxDoublings", "retryCount");
+            triggered.scheduleTrigger.retryConfig = {};
+            proto.copyIfPresent(triggered.scheduleTrigger.retryConfig, annotation.schedule.retryConfig, "retryCount", "maxDoublings");
+            proto.convertIfPresent(triggered.scheduleTrigger.retryConfig, annotation.schedule.retryConfig, "maxRetrySeconds", "maxRetryDuration", toSeconds);
+            proto.convertIfPresent(triggered.scheduleTrigger.retryConfig, annotation.schedule.retryConfig, "minBackoffSeconds", "minBackoffDuration", toSeconds);
+            proto.convertIfPresent(triggered.scheduleTrigger.retryConfig, annotation.schedule.retryConfig, "maxBackoffSeconds", "maxBackoffDuration", toSeconds);
         }
     }
     else if (annotation.blockingTrigger) {
@@ -169,7 +168,7 @@ function addResourcesToBuild(projectId, runtime, annotation, want) {
             },
         };
     }
-    else {
+    else if (annotation.eventTrigger) {
         triggered = {
             eventTrigger: {
                 eventType: annotation.eventTrigger.eventType,
@@ -178,8 +177,13 @@ function addResourcesToBuild(projectId, runtime, annotation, want) {
             },
         };
     }
+    else {
+        throw new error_1.FirebaseError("Do not understand Cloud Function annotation without a trigger" +
+            JSON.stringify(annotation, null, 2));
+    }
     const endpointId = annotation.name;
-    const endpoint = Object.assign({ platform: annotation.platform || "gcfv1", region: regions, project: projectId, entryPoint: annotation.entryPoint, runtime: runtime, serviceAccount: annotation.serviceAccountEmail || null }, triggered);
+    const endpoint = Object.assign({ platform: annotation.platform || "gcfv1", region: regions, project: projectId, entryPoint: annotation.entryPoint, runtime: runtime }, triggered);
+    proto.renameIfPresent(endpoint, annotation, "serviceAccount", "serviceAccountEmail");
     if (annotation.vpcConnector != null) {
         let maybeId = annotation.vpcConnector;
         if (maybeId && !maybeId.includes("/")) {
@@ -188,8 +192,17 @@ function addResourcesToBuild(projectId, runtime, annotation, want) {
         endpoint.vpc = { connector: maybeId };
         proto.renameIfPresent(endpoint.vpc, annotation, "egressSettings", "vpcConnectorEgressSettings");
     }
-    proto.copyIfPresent(endpoint, annotation, "concurrency", "labels", "ingressSettings", "maxInstances", "minInstances", "availableMemoryMb");
-    proto.renameIfPresent(endpoint, annotation, "timeoutSeconds", "timeout", proto.secondsFromDuration);
+    proto.copyIfPresent(endpoint, annotation, "concurrency", "labels", "maxInstances", "minInstances", "availableMemoryMb");
+    proto.convertIfPresent(endpoint, annotation, "ingressSettings", (str) => {
+        if (str === null) {
+            return null;
+        }
+        if (!backend.AllIngressSettings.includes(str)) {
+            throw new Error(`Invalid ingress setting ${str}`);
+        }
+        return str;
+    });
+    proto.convertIfPresent(endpoint, annotation, "timeoutSeconds", "timeout", proto.secondsFromDuration);
     want.endpoints[endpointId] = endpoint;
 }
 exports.addResourcesToBuild = addResourcesToBuild;
@@ -285,8 +298,27 @@ function addResourcesToBackend(projectId, runtime, annotation, want) {
             }
             endpoint.secretEnvironmentVariables = secretEnvs;
         }
-        proto.copyIfPresent(endpoint, annotation, "concurrency", "serviceAccountEmail", "labels", "ingressSettings", "maxInstances", "minInstances", "availableMemoryMb");
-        proto.renameIfPresent(endpoint, annotation, "timeoutSeconds", "timeout", proto.secondsFromDuration);
+        proto.copyIfPresent(endpoint, annotation, "concurrency", "labels", "maxInstances", "minInstances");
+        proto.renameIfPresent(endpoint, annotation, "serviceAccount", "serviceAccountEmail");
+        proto.convertIfPresent(endpoint, annotation, "ingressSettings", (ingress) => {
+            if (ingress == null) {
+                return null;
+            }
+            if (!backend.AllIngressSettings.includes(ingress)) {
+                throw new error_1.FirebaseError(`Invalid ingress setting ${ingress}`);
+            }
+            return ingress;
+        });
+        proto.convertIfPresent(endpoint, annotation, "availableMemoryMb", (mem) => {
+            if (mem === null) {
+                return null;
+            }
+            if (!backend.isValidMemoryOption(mem)) {
+                throw new error_1.FirebaseError(`This version of firebase-tools does not know about the memory option ${mem}. Is an upgrade necessary?`);
+            }
+            return mem;
+        });
+        proto.convertIfPresent(endpoint, annotation, "timeoutSeconds", "timeout", proto.secondsFromDuration);
         want.endpoints[region] = want.endpoints[region] || {};
         want.endpoints[region][endpoint.id] = endpoint;
         mergeRequiredAPIs(want);

package/lib/deploy/functions/services/storage.js

@@ -17,8 +17,14 @@ async function obtainStorageBindings(projectNumber) {
 }
 exports.obtainStorageBindings = obtainStorageBindings;
 async function ensureStorageTriggerRegion(endpoint) {
+    var _a;
     const { eventTrigger } = endpoint;
     if (!eventTrigger.region) {
+        logger_1.logger.debug("Looking up bucket region for the storage event trigger");
+        if (!((_a = eventTrigger.eventFilters) === null || _a === void 0 ? void 0 : _a.bucket)) {
+            throw new error_1.FirebaseError("Error: storage event trigger is missing bucket filter: " +
+                JSON.stringify(eventTrigger, null, 2));
+        }
         logger_1.logger.debug(`Looking up bucket region for the storage event trigger on bucket ${eventTrigger.eventFilters.bucket}`);
         try {
             const bucket = await storage.getBucket(eventTrigger.eventFilters.bucket);

package/lib/deploy/hosting/convertConfig.js

@@ -50,11 +50,18 @@ async function convertConfig(context, payload, config, finalize) {
                 (!functionsEndpointInfo.platform || endpoint.platform === functionsEndpointInfo.platform));
         });
         if (matchingBackends.length > 1) {
+            for (const endpoint of matchingBackends) {
+                if (endpoint.region === "us-central1") {
+                    (0, utils_1.logLabeledBullet)(`hosting[${config.site}]`, `Function \`${functionsEndpointInfo.serviceId}\` found in multiple regions, defaulting to \`us-central1\`. ` +
+                        `To rewrite to a different region, specify a \`region\` for the rewrite in \`firebase.json\`.`);
+                    return endpoint;
+                }
+            }
             throw new error_1.FirebaseError(`More than one backend found for function name: ${functionsEndpointInfo.serviceId}. If the function is deployed in multiple regions, you must specify a region.`);
         }
         if (matchingBackends.length === 1) {
             const endpoint = matchingBackends[0];
-            if (endpoint && (0, backend_1.isHttpsTriggered)(endpoint)) {
+            if (endpoint && ((0, backend_1.isHttpsTriggered)(endpoint) || (0, backend_1.isCallableTriggered)(endpoint))) {
                 return endpoint;
             }
         }

package/lib/emulator/functionsEmulatorShared.js

@@ -8,20 +8,11 @@ const crypto_1 = require("crypto");
 const _ = require("lodash");
 const backend = require("../deploy/functions/backend");
 const constants_1 = require("./constants");
-const proto_1 = require("../gcp/proto");
 const manifest_1 = require("../extensions/manifest");
 const extensionsHelper_1 = require("../extensions/extensionsHelper");
 const postinstall_1 = require("./extensions/postinstall");
 const services_1 = require("../deploy/functions/services");
 const prepare_1 = require("../deploy/functions/prepare");
-const memoryLookup = {
-    "128MB": 128,
-    "256MB": 256,
-    "512MB": 512,
-    "1GB": 1024,
-    "2GB": 2048,
-    "4GB": 4096,
-};
 class HttpConstants {
 }
 exports.HttpConstants = HttpConstants;
@@ -33,7 +24,7 @@ class EmulatedTrigger {
         this.module = module;
     }
     get memoryLimitBytes() {
-        return memoryLookup[this.definition.availableMemoryMb || "128MB"] * 1024 * 1024;
+        return (this.definition.availableMemoryMb || 128) * 1024 * 1024;
     }
     get timeoutMs() {
         return (this.definition.timeoutSeconds || 60) * 1000;
@@ -69,7 +60,11 @@ function emulatedFunctionsFromEndpoints(endpoints) {
             id: `${endpoint.region}-${endpoint.id}`,
             codebase: endpoint.codebase,
         };
-        (0, proto_1.copyIfPresent)(def, endpoint, "availableMemoryMb", "labels", "timeoutSeconds", "platform", "secretEnvironmentVariables");
+        def.availableMemoryMb = endpoint.availableMemoryMb || 256;
+        def.labels = endpoint.labels || {};
+        def.timeoutSeconds = endpoint.timeoutSeconds || 60;
+        def.secretEnvironmentVariables = endpoint.secretEnvironmentVariables || [];
+        def.platform = endpoint.platform;
         if (backend.isHttpsTriggered(endpoint)) {
             def.httpsTrigger = endpoint.httpsTrigger;
         }

package/lib/emulator/storage/files.js

@@ -327,6 +327,10 @@ class StorageLayer {
         }
         const metadataDir = path.join(storageExportPath, "metadata");
         const blobsDir = path.join(storageExportPath, "blobs");
+        if (!(0, fs_1.existsSync)(metadataDir) || !(0, fs_1.existsSync)(blobsDir)) {
+            logger_1.logger.warn(`Could not find metadata directory at "${metadataDir}" and/or blobs directory at "${blobsDir}".`);
+            return;
+        }
         const metadataList = this.walkDirSync(metadataDir);
         const dotJson = ".json";
         for (const f of metadataList) {

package/lib/emulator/storage/metadata.js

@@ -287,15 +287,15 @@ class CloudStorageObjectMetadata {
 }
 exports.CloudStorageObjectMetadata = CloudStorageObjectMetadata;
 function toSerializedDate(d) {
-    const day = `${d.getFullYear()}-${(d.getMonth() + 1).toString().padStart(2, "0")}-${d
-        .getDate()
+    const day = `${d.getUTCFullYear()}-${(d.getUTCMonth() + 1).toString().padStart(2, "0")}-${d
+        .getUTCDate()
         .toString()
         .padStart(2, "0")}`;
-    const time = `${d.getHours().toString().padStart(2, "0")}:${d
-        .getMinutes()
+    const time = `${d.getUTCHours().toString().padStart(2, "0")}:${d
+        .getUTCMinutes()
         .toString()
-        .padStart(2, "0")}:${d.getSeconds().toString().padStart(2, "0")}.${d
-        .getMilliseconds()
+        .padStart(2, "0")}:${d.getUTCSeconds().toString().padStart(2, "0")}.${d
+        .getUTCMilliseconds()
         .toString()
         .padStart(3, "0")}`;
     return `${day}T${time}Z`;