firebase-tools 11.4.1 → 11.6.0

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.serviceIsResolved = exports.Fabricator = void 0;
-const clc = require("cli-color");
+const clc = require("colorette");
 const error_1 = require("../../../error");
 const sourceTokenScraper_1 = require("./sourceTokenScraper");
 const timer_1 = require("./timer");
@@ -301,10 +301,10 @@ class Fabricator {
         endpoint.uri = (_b = resultFunction === null || resultFunction === void 0 ? void 0 : resultFunction.httpsTrigger) === null || _b === void 0 ? void 0 : _b.url;
         let invoker;
         if (backend.isHttpsTriggered(endpoint)) {
-            invoker = endpoint.httpsTrigger.invoker;
+            invoker = endpoint.httpsTrigger.invoker === null ? ["public"] : endpoint.httpsTrigger.invoker;
         }
         else if (backend.isTaskQueueTriggered(endpoint)) {
-            invoker = endpoint.taskQueueTrigger.invoker;
+            invoker = endpoint.taskQueueTrigger.invoker === null ? [] : endpoint.taskQueueTrigger.invoker;
         }
         else if (backend.isBlockingTriggered(endpoint) &&
             v1_1.AUTH_BLOCKING_EVENTS.includes(endpoint.blockingTrigger.eventType)) {
@@ -337,10 +337,10 @@ class Fabricator {
         const serviceName = resultFunction.serviceConfig.service;
         let invoker;
         if (backend.isHttpsTriggered(endpoint)) {
-            invoker = endpoint.httpsTrigger.invoker;
+            invoker = endpoint.httpsTrigger.invoker === null ? ["public"] : endpoint.httpsTrigger.invoker;
         }
         else if (backend.isTaskQueueTriggered(endpoint)) {
-            invoker = endpoint.taskQueueTrigger.invoker;
+            invoker = endpoint.taskQueueTrigger.invoker === null ? [] : endpoint.taskQueueTrigger.invoker;
         }
         else if (backend.isBlockingTriggered(endpoint) &&
             v1_1.AUTH_BLOCKING_EVENTS.includes(endpoint.blockingTrigger.eventType)) {
@@ -477,12 +477,13 @@ class Fabricator {
             .catch(rethrowAs(endpoint, "register blocking trigger"));
     }
     async deleteScheduleV1(endpoint) {
-        const job = scheduler.jobFromEndpoint(endpoint, this.appEngineLocation);
+        const jobName = scheduler.jobNameForEndpoint(endpoint, this.appEngineLocation);
         await this.executor
-            .run(() => scheduler.deleteJob(job.name))
+            .run(() => scheduler.deleteJob(jobName))
             .catch(rethrowAs(endpoint, "delete schedule"));
+        const topicName = scheduler.topicNameForEndpoint(endpoint);
         await this.executor
-            .run(() => pubsub.deleteTopic(job.pubsubTarget.topicName))
+            .run(() => pubsub.deleteTopic(topicName))
             .catch(rethrowAs(endpoint, "delete topic"));
     }
     deleteScheduleV2(endpoint) {
@@ -509,7 +510,7 @@ class Fabricator {
     }
     logOpSuccess(op, endpoint) {
         const label = helper.getFunctionLabel(endpoint);
-        utils.logSuccess(`${clc.bold.green(`functions[${label}]`)} Successful ${op} operation.`);
+        utils.logSuccess(`${clc.bold(clc.green(`functions[${label}]`))} Successful ${op} operation.`);
     }
 }
 exports.Fabricator = Fabricator;

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.printTriggerUrls = exports.release = void 0;
-const clc = require("cli-color");
+const clc = require("colorette");
 const logger_1 = require("../../../logger");
 const functional_1 = require("../../../functional");
 const backend = require("../backend");

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

@@ -2,7 +2,7 @@
 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 clc = require("colorette");
 const logger_1 = require("../../../logger");
 const track_1 = require("../../../track");
 const utils = require("../../../utils");

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

@@ -23,35 +23,46 @@ function assertKeyTypes(prefix, yaml, schema) {
         if (!schema[key] || schema[key] === "omit") {
             throw new error_1.FirebaseError(`Unexpected key ${fullKey}. You may need to install a newer version of the Firebase CLI.`);
         }
-        const schemaType = schema[key];
+        let schemaType = schema[key];
         if (typeof schemaType === "function") {
             if (!schemaType(value)) {
-                throw new error_1.FirebaseError(`${Array.isArray(value) ? "array" : typeof value} ${fullKey} failed validation`);
+                const friendlyName = value === null ? "null" : Array.isArray(value) ? "array" : typeof value;
+                throw new error_1.FirebaseError(`${friendlyName} ${fullKey} failed validation`);
             }
+            continue;
         }
-        else if (schemaType === "string") {
+        if (value === null) {
+            if (schemaType.endsWith("?")) {
+                continue;
+            }
+            throw new error_1.FirebaseError(`Expected ${fullKey}} to be type ${schemaType}; was null`);
+        }
+        if (schemaType.endsWith("?")) {
+            schemaType = schemaType.slice(0, schemaType.length - 1);
+        }
+        if (schemaType === "string") {
             if (typeof value !== "string") {
-                throw new error_1.FirebaseError(`Expected ${fullKey} to be string; was ${typeof value}`);
+                throw new error_1.FirebaseError(`Expected ${fullKey} to be type string; was ${typeof value}`);
             }
         }
         else if (schemaType === "number") {
             if (typeof value !== "number") {
-                throw new error_1.FirebaseError(`Expected ${fullKey} to be a number; was ${typeof value}`);
+                throw new error_1.FirebaseError(`Expected ${fullKey} to be type number; was ${typeof value}`);
             }
         }
         else if (schemaType === "boolean") {
             if (typeof value !== "boolean") {
-                throw new error_1.FirebaseError(`Expected ${fullKey} to be a boolean; was ${typeof value}`);
+                throw new error_1.FirebaseError(`Expected ${fullKey} to be type boolean; was ${typeof value}`);
             }
         }
         else if (schemaType === "array") {
             if (!Array.isArray(value)) {
-                throw new error_1.FirebaseError(`Expected ${fullKey} to be an array; was ${typeof value}`);
+                throw new error_1.FirebaseError(`Expected ${fullKey} to be type array; was ${typeof value}`);
             }
         }
         else if (schemaType === "object") {
             if (value === null || typeof value !== "object" || Array.isArray(value)) {
-                throw new error_1.FirebaseError(`Expected ${fullKey} to be an object; was ${typeof value}`);
+                throw new error_1.FirebaseError(`Expected ${fullKey} to be type object; was ${typeof value}`);
             }
         }
         else {

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/parseRuntimeAndValidateSDK.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRuntimeChoice = exports.DEPRECATED_NODE_VERSION_INFO = exports.UNSUPPORTED_NODE_VERSION_PACKAGE_JSON_MSG = exports.UNSUPPORTED_NODE_VERSION_FIREBASE_JSON_MSG = exports.RUNTIME_NOT_SET = void 0;
 const path = require("path");
-const clc = require("cli-color");
+const clc = require("colorette");
 const error_1 = require("../../../../error");
 const track_1 = require("../../../../track");
 const runtimes = require("../../runtimes");

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,18 +177,28 @@ 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("/")) {
-            maybeId = `projects/${projectId}/locations/$REGION/connectors/${maybeId}`;
-        }
-        endpoint.vpc = { connector: maybeId };
+        endpoint.vpc = { connector: annotation.vpcConnector };
         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 +294,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);