firebase-tools 11.6.0 → 11.7.0

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

@@ -24,6 +24,7 @@ const utils = require("../../../utils");
 const services = require("../services");
 const v1_1 = require("../../../functions/events/v1");
 const throttler_1 = require("../../../throttler/throttler");
+const checkIam_1 = require("../checkIam");
 const gcfV1PollerOptions = {
     apiOrigin: api_1.functionsOrigin,
     apiVersion: gcf.API_VERSION,
@@ -46,6 +47,7 @@ class Fabricator {
         this.functionExecutor = args.functionExecutor;
         this.sources = args.sources;
         this.appEngineLocation = args.appEngineLocation;
+        this.projectNumber = args.projectNumber;
     }
     async applyPlan(plan) {
         const timer = new timer_1.Timer();
@@ -270,6 +272,12 @@ class Fabricator {
                 .run(() => run.setInvokerCreate(endpoint.project, serviceName, ["public"]))
                 .catch(rethrowAs(endpoint, "set invoker"));
         }
+        else if (backend.isScheduleTriggered(endpoint)) {
+            const invoker = [(0, checkIam_1.getDefaultComputeServiceAgent)(this.projectNumber)];
+            await this.executor
+                .run(() => run.setInvokerCreate(endpoint.project, serviceName, invoker))
+                .catch(rethrowAs(endpoint, "set invoker"));
+        }
         const mem = endpoint.availableMemoryMb || backend.DEFAULT_MEMORY;
         const hasCustomCPU = endpoint.cpu !== backend.memoryToGen1Cpu(mem);
         if (!endpoint.concurrency) {
@@ -346,6 +354,9 @@ class Fabricator {
             v1_1.AUTH_BLOCKING_EVENTS.includes(endpoint.blockingTrigger.eventType)) {
             invoker = ["public"];
         }
+        else if (backend.isScheduleTriggered(endpoint)) {
+            invoker = [(0, checkIam_1.getDefaultComputeServiceAgent)(this.projectNumber)];
+        }
         if (invoker) {
             await this.executor
                 .run(() => run.setInvokerUpdate(endpoint.project, serviceName, invoker))
@@ -452,13 +463,16 @@ class Fabricator {
         }
     }
     async upsertScheduleV1(endpoint) {
-        const job = scheduler.jobFromEndpoint(endpoint, this.appEngineLocation);
+        const job = scheduler.jobFromEndpoint(endpoint, this.appEngineLocation, this.projectNumber);
         await this.executor
             .run(() => scheduler.createOrReplaceJob(job))
             .catch(rethrowAs(endpoint, "upsert schedule"));
     }
-    upsertScheduleV2(endpoint) {
-        return Promise.reject(new reporter.DeploymentError(endpoint, "upsert schedule", new Error("Not implemented")));
+    async upsertScheduleV2(endpoint) {
+        const job = scheduler.jobFromEndpoint(endpoint, endpoint.region, this.projectNumber);
+        await this.executor
+            .run(() => scheduler.createOrReplaceJob(job))
+            .catch(rethrowAs(endpoint, "upsert schedule"));
     }
     async upsertTaskQueue(endpoint) {
         const queue = cloudtasks.queueFromEndpoint(endpoint);
@@ -486,8 +500,11 @@ class Fabricator {
             .run(() => pubsub.deleteTopic(topicName))
             .catch(rethrowAs(endpoint, "delete topic"));
     }
-    deleteScheduleV2(endpoint) {
-        return Promise.reject(new reporter.DeploymentError(endpoint, "delete schedule", new Error("Not implemented")));
+    async deleteScheduleV2(endpoint) {
+        const jobName = scheduler.jobNameForEndpoint(endpoint, endpoint.region);
+        await this.executor
+            .run(() => scheduler.deleteJob(jobName))
+            .catch(rethrowAs(endpoint, "delete schedule"));
     }
     async disableTaskQueue(endpoint) {
         const update = {

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

@@ -14,6 +14,7 @@ const prompts = require("../prompts");
 const functionsConfig_1 = require("../../../functionsConfig");
 const functionsDeployHelper_1 = require("../functionsDeployHelper");
 const error_1 = require("../../../error");
+const getProjectNumber_1 = require("../../../getProjectNumber");
 async function release(context, options, payload) {
     if (!context.config) {
         return;
@@ -53,6 +54,7 @@ async function release(context, options, payload) {
         executor: new executor.QueueExecutor({}),
         sources: context.sources,
         appEngineLocation: (0, functionsConfig_1.getAppEngineLocation)(context.firebaseConfig),
+        projectNumber: options.projectNumber || (await (0, getProjectNumber_1.getProjectNumber)(context.projectId)),
     });
     const summary = await fab.applyPlan(plan);
     await reporter.logAndTrackDeployStats(summary);

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectFromPort = exports.detectFromYaml = exports.yamlToBuild = exports.yamlToBackend = exports.readFileAsync = void 0;
+exports.detectFromPort = exports.detectFromYaml = exports.yamlToBuild = exports.readFileAsync = void 0;
 const node_fetch_1 = require("node-fetch");
 const fs = require("fs");
 const path = require("path");
@@ -11,21 +11,6 @@ const api = require("../../.../../../../api");
 const v1alpha1 = require("./v1alpha1");
 const error_1 = require("../../../../error");
 exports.readFileAsync = (0, util_1.promisify)(fs.readFile);
-function yamlToBackend(yaml, project, region, runtime) {
-    try {
-        if (!yaml.specVersion) {
-            throw new error_1.FirebaseError("Expect backend yaml to specify a version number");
-        }
-        if (yaml.specVersion === "v1alpha1") {
-            return v1alpha1.backendFromV1Alpha1(yaml, project, region, runtime);
-        }
-        throw new error_1.FirebaseError("It seems you are using a newer SDK than this version of the CLI can handle. Please update your CLI with `npm install -g firebase-tools`");
-    }
-    catch (err) {
-        throw new error_1.FirebaseError("Failed to parse backend specification", { children: [err] });
-    }
-}
-exports.yamlToBackend = yamlToBackend;
 function yamlToBuild(yaml, project, region, runtime) {
     try {
         if (!yaml.specVersion) {

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

@@ -31,6 +31,22 @@ function assertKeyTypes(prefix, yaml, schema) {
             }
             continue;
         }
+        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.includes("Field")) {
+            const match = /^Field<(\w+)>$/.exec(schemaType);
+            if (match && typeof value !== "string" && typeof value !== match[1]) {
+                throw new error_1.FirebaseError(`Expected ${fullKey} to be Field<${match[1]}>; was ${typeof value}`);
+            }
+            continue;
+        }
         if (value === null) {
             if (schemaType.endsWith("?")) {
                 continue;

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

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.backendFromV1Alpha1 = exports.buildFromV1Alpha1 = void 0;
-const backend = require("../../backend");
+exports.buildFromV1Alpha1 = void 0;
 const build = require("../../build");
 const proto_1 = require("../../../../gcp/proto");
 const parsing_1 = require("./parsing");
@@ -27,33 +26,13 @@ function buildFromV1Alpha1(yaml, project, region, runtime) {
     bd.requiredAPIs = parseRequiredAPIs(manifest);
     for (const id of Object.keys(manifest.endpoints)) {
         const me = manifest.endpoints[id];
-        assertManifestEndpoint(me, id);
+        assertBuildEndpoint(me, id);
         const be = parseEndpointForBuild(id, me, project, region, runtime);
         bd.endpoints[id] = be;
     }
     return bd;
 }
 exports.buildFromV1Alpha1 = buildFromV1Alpha1;
-function backendFromV1Alpha1(yaml, project, region, runtime) {
-    const manifest = JSON.parse(JSON.stringify(yaml));
-    const bkend = backend.empty();
-    bkend.requiredAPIs = parseRequiredAPIs(manifest);
-    (0, parsing_1.requireKeys)("", manifest, "endpoints");
-    (0, parsing_1.assertKeyTypes)("", manifest, {
-        specVersion: "string",
-        params: "array",
-        requiredAPIs: "array",
-        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 parseRequiredAPIs(manifest) {
     const requiredAPIs = manifest.requiredAPIs || [];
     for (const { api, reason } of requiredAPIs) {
@@ -66,22 +45,22 @@ function parseRequiredAPIs(manifest) {
     }
     return requiredAPIs;
 }
-function assertManifestEndpoint(ep, id) {
+function assertBuildEndpoint(ep, id) {
     const prefix = `endpoints[${id}]`;
     (0, parsing_1.assertKeyTypes)(prefix, ep, {
         region: "array",
-        platform: (platform) => backend.AllFunctionsPlatforms.includes(platform),
+        platform: (platform) => build.AllFunctionsPlatforms.includes(platform),
         entryPoint: "string",
-        availableMemoryMb: (mem) => mem === null || backend.isValidMemoryOption(mem),
-        maxInstances: "number?",
-        minInstances: "number?",
-        concurrency: "number?",
+        availableMemoryMb: (mem) => mem === null || isCEL(mem) || build.isValidMemoryOption(mem),
+        maxInstances: "Field<number>?",
+        minInstances: "Field<number>?",
+        concurrency: "Field<number>?",
         serviceAccount: "string?",
         serviceAccountEmail: "string?",
-        timeoutSeconds: "number?",
+        timeoutSeconds: "Field<number>?",
         vpc: "object?",
         labels: "object?",
-        ingressSettings: (setting) => setting === null || backend.AllIngressSettings.includes(setting),
+        ingressSettings: (setting) => setting === null || build.AllIngressSettings.includes(setting),
         environmentVariables: "object?",
         secretEnvironmentVariables: "array?",
         httpsTrigger: "object",
@@ -90,12 +69,12 @@ function assertManifestEndpoint(ep, id) {
         scheduleTrigger: "object",
         taskQueueTrigger: "object",
         blockingTrigger: "object",
-        cpu: (cpu) => cpu === null || typeof cpu === "number" || cpu === "gcf_gen1",
+        cpu: (cpu) => cpu === null || isCEL(cpu) || cpu === "gcf_gen1" || typeof cpu === "number",
     });
     if (ep.vpc) {
         (0, parsing_1.assertKeyTypes)(prefix + ".vpc", ep.vpc, {
             connector: "string",
-            egressSettings: (setting) => setting === null || backend.AllVpcEgressSettings.includes(setting),
+            egressSettings: (setting) => setting === null || build.AllVpcEgressSettings.includes(setting),
         });
         (0, parsing_1.requireKeys)(prefix + ".vpc", ep.vpc, "connector");
     }
@@ -124,44 +103,46 @@ function assertManifestEndpoint(ep, id) {
     if (triggerCount > 1) {
         throw new error_1.FirebaseError("Multiple triggers defined for endpoint" + id);
     }
-    if (backend.isEventTriggered(ep)) {
+    if (build.isEventTriggered(ep)) {
         (0, parsing_1.requireKeys)(prefix + ".eventTrigger", ep.eventTrigger, "eventType", "eventFilters");
         (0, parsing_1.assertKeyTypes)(prefix + ".eventTrigger", ep.eventTrigger, {
             eventFilters: "object",
             eventFilterPathPatterns: "object",
             eventType: "string",
-            retry: "boolean",
-            region: "string",
+            retry: "Field<boolean>",
+            region: "Field<string>",
             serviceAccount: "string?",
             serviceAccountEmail: "string?",
             channel: "string",
         });
     }
-    else if (backend.isHttpsTriggered(ep)) {
+    else if (build.isHttpsTriggered(ep)) {
         (0, parsing_1.assertKeyTypes)(prefix + ".httpsTrigger", ep.httpsTrigger, {
             invoker: "array?",
         });
     }
-    else if (backend.isCallableTriggered(ep)) {
+    else if (build.isCallableTriggered(ep)) {
     }
-    else if (backend.isScheduleTriggered(ep)) {
+    else if (build.isScheduleTriggered(ep)) {
         (0, parsing_1.assertKeyTypes)(prefix + ".scheduleTrigger", ep.scheduleTrigger, {
-            schedule: "string",
-            timeZone: "string?",
+            schedule: "Field<string>",
+            timeZone: "Field<string>?",
             retryConfig: "object?",
         });
-        (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?",
-        });
+        if (ep.scheduleTrigger.retryConfig) {
+            (0, parsing_1.assertKeyTypes)(prefix + ".scheduleTrigger.retryConfig", ep.scheduleTrigger.retryConfig, {
+                retryCount: "Field<number>?",
+                maxDoublings: "Field<number>?",
+                minBackoffSeconds: "Field<number>?",
+                maxBackoffSeconds: "Field<number>?",
+                maxRetrySeconds: "Field<number>?",
+                maxRetryDuration: "string?",
+                minBackoffDuration: "string?",
+                maxBackoffDuration: "string?",
+            });
+        }
     }
-    else if (backend.isTaskQueueTriggered(ep)) {
+    else if (build.isTaskQueueTriggered(ep)) {
         (0, parsing_1.assertKeyTypes)(prefix + ".taskQueueTrigger", ep.taskQueueTrigger, {
             rateLimits: "object?",
             retryConfig: "object?",
@@ -169,21 +150,21 @@ function assertManifestEndpoint(ep, id) {
         });
         if (ep.taskQueueTrigger.rateLimits) {
             (0, parsing_1.assertKeyTypes)(prefix + ".taskQueueTrigger.rateLimits", ep.taskQueueTrigger.rateLimits, {
-                maxConcurrentDispatches: "number?",
-                maxDispatchesPerSecond: "number?",
+                maxConcurrentDispatches: "Field<number>?",
+                maxDispatchesPerSecond: "Field<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: "Field<number>?",
+                maxRetrySeconds: "Field<number>?",
+                minBackoffSeconds: "Field<number>?",
+                maxBackoffSeconds: "Field<number>?",
+                maxDoublings: "Field<number>?",
             });
         }
     }
-    else if (backend.isBlockingTriggered(ep)) {
+    else if (build.isBlockingTriggered(ep)) {
         (0, parsing_1.requireKeys)(prefix + ".blockingTrigger", ep.blockingTrigger, "eventType");
         (0, parsing_1.assertKeyTypes)(prefix + ".blockingTrigger", ep.blockingTrigger, {
             eventType: "string",
@@ -198,12 +179,14 @@ function assertManifestEndpoint(ep, id) {
 function parseEndpointForBuild(id, ep, project, defaultRegion, runtime) {
     var _a;
     let triggered;
-    if (backend.isEventTriggered(ep)) {
+    if (build.isEventTriggered(ep)) {
         const eventTrigger = {
             eventType: ep.eventTrigger.eventType,
             retry: ep.eventTrigger.retry,
         };
-        (0, proto_1.renameIfPresent)(eventTrigger, ep.eventTrigger, "serviceAccount", "serviceAccountEmail");
+        if ("serviceAccountEmail" in ep.eventTrigger) {
+            eventTrigger.serviceAccount = ep.eventTrigger.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) => {
@@ -215,20 +198,23 @@ function parseEndpointForBuild(id, ep, project, defaultRegion, runtime) {
         });
         triggered = { eventTrigger };
     }
-    else if (backend.isHttpsTriggered(ep)) {
+    else if (build.isHttpsTriggered(ep)) {
         triggered = { httpsTrigger: {} };
         (0, proto_1.copyIfPresent)(triggered.httpsTrigger, ep.httpsTrigger, "invoker");
     }
-    else if (backend.isCallableTriggered(ep)) {
+    else if (build.isCallableTriggered(ep)) {
         triggered = { callableTrigger: {} };
     }
-    else if (backend.isScheduleTriggered(ep)) {
+    else if (build.isScheduleTriggered(ep)) {
         const st = {
             schedule: ep.scheduleTrigger.schedule || "",
             timeZone: (_a = ep.scheduleTrigger.timeZone) !== null && _a !== void 0 ? _a : null,
         };
         if (ep.scheduleTrigger.retryConfig) {
             st.retryConfig = {};
+            (0, proto_1.convertIfPresent)(st.retryConfig, ep.scheduleTrigger.retryConfig, "maxBackoffSeconds", "maxBackoffDuration", (duration) => (duration === null ? null : (0, proto_1.secondsFromDuration)(duration)));
+            (0, proto_1.convertIfPresent)(st.retryConfig, ep.scheduleTrigger.retryConfig, "minBackoffSeconds", "minBackoffDuration", (duration) => (duration === null ? null : (0, proto_1.secondsFromDuration)(duration)));
+            (0, proto_1.convertIfPresent)(st.retryConfig, ep.scheduleTrigger.retryConfig, "maxRetrySeconds", "maxRetryDuration", (duration) => (duration === null ? null : (0, proto_1.secondsFromDuration)(duration)));
             (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));
@@ -239,7 +225,7 @@ function parseEndpointForBuild(id, ep, project, defaultRegion, runtime) {
         }
         triggered = { scheduleTrigger: st };
     }
-    else if (backend.isTaskQueueTriggered(ep)) {
+    else if (build.isTaskQueueTriggered(ep)) {
         const tq = {};
         if (ep.taskQueueTrigger.invoker) {
             tq.invoker = ep.taskQueueTrigger.invoker;
@@ -261,7 +247,7 @@ function parseEndpointForBuild(id, ep, project, defaultRegion, runtime) {
         }
         triggered = { taskQueueTrigger: tq };
     }
-    else if (backend.isBlockingTriggered(ep)) {
+    else if (ep.blockingTrigger) {
         triggered = { blockingTrigger: ep.blockingTrigger };
     }
     else {
@@ -270,7 +256,9 @@ function parseEndpointForBuild(id, ep, project, defaultRegion, runtime) {
     }
     const parsed = Object.assign({ platform: ep.platform || "gcfv2", region: ep.region || [defaultRegion], project,
         runtime, entryPoint: ep.entryPoint }, triggered);
-    (0, proto_1.renameIfPresent)(parsed, ep, "serviceAccount", "serviceAccountEmail");
+    if ("serviceAccountEmail" in ep) {
+        parsed.serviceAccount = ep.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) {
@@ -282,69 +270,6 @@ function parseEndpointForBuild(id, ep, project, defaultRegion, runtime) {
     });
     return parsed;
 }
-function parseEndpoints(manifest, id, project, defaultRegion, runtime) {
-    const allParsed = [];
-    const prefix = `endpoints[${id}]`;
-    const ep = manifest.endpoints[id];
-    assertManifestEndpoint(ep, id);
-    for (const region of ep.region || [defaultRegion]) {
-        let triggered;
-        if (backend.isEventTriggered(ep)) {
-            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: {} };
-            (0, proto_1.copyIfPresent)(triggered.httpsTrigger, ep.httpsTrigger, "invoker");
-        }
-        else if (backend.isCallableTriggered(ep)) {
-            triggered = { callableTrigger: {} };
-        }
-        else if (backend.isScheduleTriggered(ep)) {
-            triggered = { scheduleTrigger: ep.scheduleTrigger };
-        }
-        else if (backend.isTaskQueueTriggered(ep)) {
-            triggered = { taskQueueTrigger: ep.taskQueueTrigger };
-        }
-        else if (backend.isBlockingTriggered(ep)) {
-            triggered = { blockingTrigger: ep.blockingTrigger };
-        }
-        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");
-        }
-        (0, parsing_1.requireKeys)(prefix, ep, "entryPoint");
-        const parsed = Object.assign({ platform: ep.platform || "gcfv2", id,
-            region,
-            project,
-            runtime, entryPoint: ep.entryPoint }, triggered);
-        (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 senvs.map(({ key, secret }) => {
-                return { key, secret: secret || key, projectId: project };
-            });
-        });
-        allParsed.push(parsed);
-    }
-    return allParsed;
-}
 function resolveChannelName(projectId, channel, defaultRegion) {
     if (!channel.includes("/")) {
         const location = defaultRegion;
@@ -365,3 +290,6 @@ function resolveChannelName(projectId, channel, defaultRegion) {
         return "projects/" + projectId + "/locations/" + location + "/channels/" + channelId;
     }
 }
+function isCEL(expr) {
+    return typeof expr === "string" && expr.includes("{{") && expr.includes("}}");
+}

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

@@ -116,7 +116,7 @@ function addResourcesToBuild(projectId, runtime, annotation, want) {
             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);
+            proto.convertIfPresent(triggered.taskQueueTrigger.retryConfig, annotation.taskQueueTrigger.retryConfig, "maxRetrySeconds", "maxRetryDuration", toSeconds);
         }
     }
     else if (annotation.httpsTrigger) {

package/lib/emulator/constants.js

@@ -28,7 +28,7 @@ exports.FIND_AVAILBLE_PORT_BY_DEFAULT = {
     auth: false,
     storage: false,
     extensions: false,
-    eventarc: false,
+    eventarc: true,
 };
 exports.EMULATOR_DESCRIPTION = {
     ui: "Emulator UI",

package/lib/emulator/controller.js

@@ -338,18 +338,13 @@ async function startAll(options, showUI = true) {
             projectAlias: options.projectAlias,
         });
         await startEmulator(functionsEmulator);
+        const eventarcAddr = await getAndCheckAddress(types_1.Emulators.EVENTARC, options);
+        const eventarcEmulator = new eventarcEmulator_1.EventarcEmulator({
+            host: eventarcAddr.host,
+            port: eventarcAddr.port,
+        });
+        await startEmulator(eventarcEmulator);
     }
-    if (!shouldStart(options, types_1.Emulators.EVENTARC)) {
-        if (options.config.src.emulators) {
-            options.config.src.emulators.eventarc = { host: constants_1.DEFAULT_HOST, port: constants_1.DEFAULT_PORTS.eventarc };
-        }
-    }
-    const eventarcAddr = await getAndCheckAddress(types_1.Emulators.EVENTARC, options);
-    const eventarcEmulator = new eventarcEmulator_1.EventarcEmulator({
-        host: eventarcAddr.host,
-        port: eventarcAddr.port,
-    });
-    await startEmulator(eventarcEmulator);
     if (shouldStart(options, types_1.Emulators.FIRESTORE)) {
         const firestoreLogger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.FIRESTORE);
         const firestoreAddr = await getAndCheckAddress(types_1.Emulators.FIRESTORE, options);

package/lib/emulator/functionsEmulatorRuntime.js

@@ -675,24 +675,19 @@ async function initializeRuntime() {
     await initializeFirebaseFunctionsStubs();
     await initializeFirebaseAdminStubs();
 }
-async function loadTriggers(serializedFunctionTrigger) {
+async function loadTriggers() {
     let triggerModule;
-    if (serializedFunctionTrigger) {
-        triggerModule = eval(serializedFunctionTrigger)();
+    try {
+        triggerModule = require(process.cwd());
     }
-    else {
-        try {
-            triggerModule = require(process.cwd());
-        }
-        catch (err) {
-            if (err.code !== "ERR_REQUIRE_ESM") {
-                await moduleResolutionDetective(err);
-                throw err;
-            }
-            const modulePath = require.resolve(process.cwd());
-            const moduleURL = (0, url_1.pathToFileURL)(modulePath).href;
-            triggerModule = await dynamicImport(moduleURL);
+    catch (err) {
+        if (err.code !== "ERR_REQUIRE_ESM") {
+            await moduleResolutionDetective(err);
+            throw err;
         }
+        const modulePath = require.resolve(process.cwd());
+        const moduleURL = (0, url_1.pathToFileURL)(modulePath).href;
+        triggerModule = await dynamicImport(moduleURL);
     }
     return triggerModule;
 }
@@ -716,8 +711,7 @@ async function handleMessage(message) {
     }
     if (!functionModule) {
         try {
-            const serializedTriggers = runtimeArgs.opts ? runtimeArgs.opts.serializedTriggers : undefined;
-            functionModule = await loadTriggers(serializedTriggers);
+            functionModule = await loadTriggers();
         }
         catch (e) {
             logDebug(e);
@@ -739,12 +733,7 @@ async function handleMessage(message) {
     logDebug(`Beginning invocation function ${FUNCTION_TARGET_NAME}!`);
     try {
         await invokeTrigger(trigger, runtimeArgs.frb);
-        if (runtimeArgs.opts && runtimeArgs.opts.serializedTriggers) {
-            await flushAndExit(0);
-        }
-        else {
-            await goIdle();
-        }
+        await goIdle();
     }
     catch (err) {
         new types_1.EmulatorLog("FATAL", "runtime-error", err.stack ? err.stack : err).log();

package/lib/emulator/storage/apis/firebase.js

@@ -165,14 +165,17 @@ function createFirebaseEndpoints(emulator) {
         });
     });
     const handleUpload = async (req, res) => {
-        if (!req.query.name) {
-            res.sendStatus(400);
-            return;
-        }
+        var _a;
         const bucketId = req.params.bucketId;
-        const objectId = req.query.name.toString();
+        const objectId = req.params.objectId
+            ? decodeURIComponent(req.params.objectId)
+            : ((_a = req.query.name) === null || _a === void 0 ? void 0 : _a.toString()) || null;
         const uploadType = req.header("x-goog-upload-protocol");
         if (uploadType === "multipart") {
+            if (!objectId) {
+                res.sendStatus(400);
+                return;
+            }
             const contentTypeHeader = req.header("content-type");
             if (!contentTypeHeader) {
                 return res.sendStatus(400);
@@ -184,12 +187,7 @@ function createFirebaseEndpoints(emulator) {
             }
             catch (err) {
                 if (err instanceof Error) {
-                    return res.status(400).json({
-                        error: {
-                            code: 400,
-                            message: err.message,
-                        },
-                    });
+                    return res.status(400).send(err.message);
                 }
                 throw err;
             }
@@ -224,6 +222,10 @@ function createFirebaseEndpoints(emulator) {
             return;
         }
         if (uploadCommand === "start") {
+            if (!objectId) {
+                res.sendStatus(400);
+                return;
+            }
             const upload = uploadService.startResumableUpload({
                 bucketId,
                 objectId,

package/lib/emulator/storage/multipart.js

@@ -45,11 +45,11 @@ function parseMultipartRequestBodyPart(bodyPart) {
 }
 function parseObjectUploadMultipartRequest(contentTypeHeader, body) {
     if (!contentTypeHeader.startsWith("multipart/related")) {
-        throw new Error(`Invalid Content-Type: ${contentTypeHeader}`);
+        throw new Error(`Bad content type. ${contentTypeHeader}`);
     }
     const boundaryId = contentTypeHeader.split("boundary=")[1];
     if (!boundaryId) {
-        throw new Error(`Invalid Content-Type header: ${contentTypeHeader}`);
+        throw new Error(`Bad content type. ${contentTypeHeader}`);
     }
     const parsedBody = parseMultipartRequestBody(boundaryId, body);
     if (parsedBody.length !== 2) {