firebase-tools 11.6.0 → 11.8.1

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();
@@ -89,6 +91,9 @@ class Fabricator {
             this.logOpStart("creating", endpoint);
             upserts.push(handle("create", endpoint, () => this.createEndpoint(endpoint, scraper)));
         }
+        for (const endpoint of changes.endpointsToSkip) {
+            utils.logSuccess(this.getLogSuccessMessage("skip", endpoint));
+        }
         for (const update of changes.endpointsToUpdate) {
             this.logOpStart("updating", update.endpoint);
             upserts.push(handle("update", update.endpoint, () => this.updateEndpoint(update, scraper)));
@@ -270,6 +275,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 +357,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 +466,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 +503,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 = {
@@ -509,8 +529,21 @@ class Fabricator {
         utils.logLabeledBullet("functions", `${op} ${runtime} function ${clc.bold(label)}...`);
     }
     logOpSuccess(op, endpoint) {
+        utils.logSuccess(this.getLogSuccessMessage(op, endpoint));
+    }
+    getLogSuccessMessage(op, endpoint) {
         const label = helper.getFunctionLabel(endpoint);
-        utils.logSuccess(`${clc.bold(clc.green(`functions[${label}]`))} Successful ${op} operation.`);
+        switch (op) {
+            case "skip":
+                return `${clc.bold(clc.magenta(`functions[${label}]`))} Skipped (No changes detected)`;
+            default:
+                return `${clc.bold(clc.green(`functions[${label}]`))} Successful ${op} operation.`;
+        }
+    }
+    getSkippedDeployingNopOpMessage(endpoints) {
+        const functionNames = endpoints.map((endpoint) => endpoint.id).join(",");
+        return `${clc.bold(clc.magenta(`functions:`))} You can re-deploy skipped functions with:
+              ${clc.bold(`firebase deploy --only functions:${functionNames}`)} or ${clc.bold(`FUNCTIONS_DEPLOY_UNCHANGED=true firebase deploy`)}`;
     }
 }
 exports.Fabricator = Fabricator;

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/release/planner.js

@@ -7,6 +7,7 @@ const error_1 = require("../../../error");
 const utils = require("../../../utils");
 const backend = require("../backend");
 const v2events = require("../../../functions/events/v2");
+const previews_1 = require("../../../previews");
 function calculateChangesets(want, have, keyFn, deleteAll) {
     const toCreate = utils.groupBy(Object.keys(want)
         .filter((id) => !have[id])
@@ -15,20 +16,36 @@ function calculateChangesets(want, have, keyFn, deleteAll) {
         .filter((id) => !want[id])
         .filter((id) => deleteAll || (0, deploymentTool_1.isFirebaseManaged)(have[id].labels || {}))
         .map((id) => have[id]), keyFn);
+    const { skipdeployingnoopfunctions } = previews_1.previews;
+    const toSkipPredicate = (id) => !!(skipdeployingnoopfunctions &&
+        have[id].hash &&
+        want[id].hash &&
+        want[id].hash === have[id].hash);
+    const toSkipEndpointsMap = Object.keys(want)
+        .filter((id) => have[id])
+        .filter((id) => toSkipPredicate(id))
+        .reduce((memo, id) => {
+        memo[id] = want[id];
+        return memo;
+    }, {});
+    const toSkip = utils.groupBy(Object.values(toSkipEndpointsMap), keyFn);
     const toUpdate = utils.groupBy(Object.keys(want)
         .filter((id) => have[id])
+        .filter((id) => !toSkipEndpointsMap[id])
         .map((id) => calculateUpdate(want[id], have[id])), (eu) => keyFn(eu.endpoint));
     const result = {};
     const keys = new Set([
         ...Object.keys(toCreate),
         ...Object.keys(toDelete),
         ...Object.keys(toUpdate),
+        ...Object.keys(toSkip),
     ]);
     for (const key of keys) {
         result[key] = {
             endpointsToCreate: toCreate[key] || [],
             endpointsToUpdate: toUpdate[key] || [],
             endpointsToDelete: toDelete[key] || [],
+            endpointsToSkip: toSkip[key] || [],
         };
     }
     return result;

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) {
@@ -199,6 +199,15 @@ function addResourcesToBuild(projectId, runtime, annotation, want) {
         return str;
     });
     proto.convertIfPresent(endpoint, annotation, "timeoutSeconds", "timeout", proto.secondsFromDuration);
+    if (annotation.secrets) {
+        endpoint.secretEnvironmentVariables = annotation.secrets.map((secret) => {
+            return {
+                secret,
+                projectId,
+                key: secret,
+            };
+        });
+    }
     want.endpoints[endpointId] = endpoint;
 }
 exports.addResourcesToBuild = addResourcesToBuild;

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

@@ -142,6 +142,7 @@ class ExtensionsEmulator {
         const emulatableBackend = {
             functionsDir,
             env: nonSecretEnv,
+            codebase: "",
             secretEnv: secretEnvVariables,
             predefinedTriggers: extensionTriggers,
             nodeMajorVersion: nodeMajorVersion,