firebase-tools 10.7.2 → 10.8.0

package/lib/deploy/functions/prepare.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.inferBlockingDetails = exports.inferDetailsFromExisting = exports.prepare = void 0;
+exports.resolveCpu = exports.inferBlockingDetails = exports.inferDetailsFromExisting = exports.prepare = void 0;
 const clc = require("cli-color");
 const backend = require("./backend");
+const build = require("./build");
 const ensureApiEnabled = require("../../ensureApiEnabled");
 const functionsConfig = require("../../functionsConfig");
 const functionsEnv = require("../../functions/env");
@@ -22,6 +23,7 @@ const error_1 = require("../../error");
 const projectConfig_1 = require("../../functions/projectConfig");
 const previews_1 = require("../../previews");
 const v1_1 = require("../../functions/events/v1");
+const serviceusage_1 = require("../../gcp/serviceusage");
 function hasUserConfig(config) {
     return Object.keys(config).length > 1;
 }
@@ -76,9 +78,17 @@ async function prepare(context, options, payload) {
             projectAlias: options.projectAlias,
         };
         const userEnvs = functionsEnv.loadUserEnvs(userEnvOpt);
-        logger_1.logger.debug(`Analyzing ${runtimeDelegate.name} backend spec`);
-        const wantBackend = await runtimeDelegate.discoverSpec(runtimeConfig, firebaseEnvs);
-        wantBackend.environmentVariables = Object.assign(Object.assign({}, userEnvs), firebaseEnvs);
+        const envs = Object.assign(Object.assign({}, userEnvs), firebaseEnvs);
+        let wantBackend;
+        if (previews_1.previews.functionsparams) {
+            const wantBuild = await runtimeDelegate.discoverBuild(runtimeConfig, firebaseEnvs);
+            wantBackend = build.resolveBackend(wantBuild, userEnvs);
+        }
+        else {
+            logger_1.logger.debug(`Analyzing ${runtimeDelegate.name} backend spec`);
+            wantBackend = await runtimeDelegate.discoverSpec(runtimeConfig, firebaseEnvs);
+        }
+        wantBackend.environmentVariables = envs;
         for (const endpoint of backend.allEndpoints(wantBackend)) {
             endpoint.environmentVariables = wantBackend.environmentVariables;
             endpoint.codebase = codebase;
@@ -117,12 +127,13 @@ async function prepare(context, options, payload) {
     payload.functions = {};
     const haveBackends = (0, functionsDeployHelper_1.groupEndpointsByCodebase)(wantBackends, backend.allEndpoints(await backend.existingBackend(context)));
     for (const [codebase, wantBackend] of Object.entries(wantBackends)) {
-        const haveBackend = haveBackends[codebase] || Object.assign({}, backend.empty());
+        const haveBackend = haveBackends[codebase] || backend.empty();
         payload.functions[codebase] = { wantBackend, haveBackend };
     }
     for (const [codebase, { wantBackend, haveBackend }] of Object.entries(payload.functions)) {
         inferDetailsFromExisting(wantBackend, haveBackend, codebaseUsesEnvs.includes(codebase));
         await (0, triggerRegionHelper_1.ensureTriggerRegions)(wantBackend);
+        resolveCpu(wantBackend);
         validate.endpointsAreValid(wantBackend);
         inferBlockingDetails(wantBackend);
     }
@@ -153,6 +164,11 @@ async function prepare(context, options, payload) {
             return ensureApiEnabled.ensure(context.projectId, api, "functions");
         });
         await Promise.all(enablements);
+        const services = ["pubsub.googleapis.com", "eventarc.googleapis.com"];
+        const generateServiceAccounts = services.map((service) => {
+            return (0, serviceusage_1.generateServiceIdentity)(projectNumber, service, "functions");
+        });
+        await Promise.all(generateServiceAccounts);
     }
     const matchingBackend = backend.matchingBackend(wantBackend, (endpoint) => {
         return (0, functionsDeployHelper_1.endpointMatchesAnyFilter)(endpoint, context.filters);
@@ -160,7 +176,7 @@ async function prepare(context, options, payload) {
     await (0, prompts_1.promptForFailurePolicies)(options, matchingBackend, haveBackend);
     await (0, prompts_1.promptForMinInstances)(options, matchingBackend, haveBackend);
     await backend.checkAvailability(context, matchingBackend);
-    await (0, checkIam_1.ensureServiceAgentRoles)(projectNumber, matchingBackend, haveBackend);
+    await (0, checkIam_1.ensureServiceAgentRoles)(projectId, projectNumber, matchingBackend, haveBackend);
     await validate.secretsAreValid(projectId, matchingBackend);
     await ensure.secretAccess(projectId, matchingBackend, haveBackend);
 }
@@ -178,6 +194,12 @@ function inferDetailsFromExisting(want, have, usedDotenv) {
         if (!wantE.availableMemoryMb && haveE.availableMemoryMb) {
             wantE.availableMemoryMb = haveE.availableMemoryMb;
         }
+        if (!wantE.concurrency && haveE.concurrency) {
+            wantE.concurrency = haveE.concurrency;
+        }
+        if (!wantE.cpu && haveE.cpu) {
+            wantE.cpu = haveE.cpu;
+        }
         wantE.securityLevel = haveE.securityLevel ? haveE.securityLevel : "SECURE_ALWAYS";
         maybeCopyTriggerRegion(wantE, haveE);
     }
@@ -223,3 +245,17 @@ function inferBlockingDetails(want) {
     }
 }
 exports.inferBlockingDetails = inferBlockingDetails;
+function resolveCpu(want) {
+    for (const e of backend.allEndpoints(want)) {
+        if (e.platform === "gcfv1") {
+            continue;
+        }
+        if (e.cpu === "gcf_gen1") {
+            e.cpu = backend.memoryToGen1Cpu(e.availableMemoryMb || backend.DEFAULT_MEMORY);
+        }
+        else if (!e.cpu) {
+            e.cpu = backend.memoryToGen2Cpu(e.availableMemoryMb || backend.DEFAULT_MEMORY);
+        }
+    }
+}
+exports.resolveCpu = resolveCpu;

package/lib/deploy/functions/pricing.js

@@ -145,12 +145,12 @@ function monthlyMinInstanceCost(endpoints) {
                 usage["gcfv1"][tier].cpu + cpu * SECONDS_PER_MONTH * endpoint.minInstances;
         }
         else {
-            const cpu = 1;
             const tier = V2_REGION_TO_TIER[endpoint.region];
             usage["gcfv2"][tier].ram =
                 usage["gcfv2"][tier].ram + ramGb * SECONDS_PER_MONTH * endpoint.minInstances;
             usage["gcfv2"][tier].cpu =
-                usage["gcfv2"][tier].cpu + cpu * SECONDS_PER_MONTH * endpoint.minInstances;
+                usage["gcfv2"][tier].cpu +
+                    endpoint.cpu * SECONDS_PER_MONTH * endpoint.minInstances;
         }
     }
     let v1MemoryBill = usage["gcfv1"][1].ram * exports.V1_RATES.memoryGb[1] + usage["gcfv1"][2].ram * exports.V1_RATES.memoryGb[2];

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Fabricator = void 0;
+exports.serviceIsResolved = exports.Fabricator = void 0;
 const clc = require("cli-color");
 const error_1 = require("../../../error");
 const sourceTokenScraper_1 = require("./sourceTokenScraper");
@@ -23,6 +23,7 @@ const scheduler = require("../../../gcp/cloudscheduler");
 const utils = require("../../../utils");
 const services = require("../services");
 const v1_1 = require("../../../functions/events/v1");
+const throttler_1 = require("../../../throttler/throttler");
 const gcfV1PollerOptions = {
     apiOrigin: api_1.functionsOrigin,
     apiVersion: gcf.API_VERSION,
@@ -271,8 +272,16 @@ class Fabricator {
                 .catch(rethrowAs(endpoint, "set invoker"));
         }
         const mem = endpoint.availableMemoryMb || backend.DEFAULT_MEMORY;
-        if (mem >= backend.MIN_MEMORY_FOR_CONCURRENCY && endpoint.concurrency !== 1) {
-            await this.setConcurrency(endpoint, serviceName, endpoint.concurrency || DEFAULT_GCFV2_CONCURRENCY);
+        const hasCustomCPU = endpoint.cpu !== backend.memoryToGen1Cpu(mem);
+        if (!endpoint.concurrency) {
+            endpoint.concurrency =
+                endpoint.cpu >= backend.MIN_CPU_FOR_CONCURRENCY
+                    ? backend.DEFAULT_CONCURRENCY
+                    : 1;
+        }
+        const hasConcurrency = endpoint.concurrency !== 1;
+        if (hasCustomCPU || hasConcurrency) {
+            await this.setRunTraits(serviceName, endpoint);
         }
     }
     async updateV1Function(endpoint, scraper) {
@@ -343,8 +352,17 @@ class Fabricator {
                 .run(() => run.setInvokerUpdate(endpoint.project, serviceName, invoker))
                 .catch(rethrowAs(endpoint, "set invoker"));
         }
-        if (endpoint.concurrency) {
-            await this.setConcurrency(endpoint, serviceName, endpoint.concurrency);
+        const hasCustomCPU = endpoint.cpu !==
+            backend.memoryToGen1Cpu(endpoint.availableMemoryMb || backend.DEFAULT_MEMORY);
+        const explicitConcurrency = endpoint.concurrency !== undefined;
+        if (hasCustomCPU || explicitConcurrency) {
+            if (endpoint.concurrency === undefined) {
+                endpoint.concurrency =
+                    endpoint.cpu < backend.MIN_CPU_FOR_CONCURRENCY
+                        ? 1
+                        : backend.DEFAULT_CONCURRENCY;
+            }
+            await this.setRunTraits(serviceName, endpoint);
         }
     }
     async deleteV1Function(endpoint) {
@@ -367,18 +385,32 @@ class Fabricator {
         })
             .catch(rethrowAs(endpoint, "delete"));
     }
-    async setConcurrency(endpoint, serviceName, concurrency) {
+    async setRunTraits(serviceName, endpoint) {
         await this.functionExecutor
             .run(async () => {
-            const service = await run.getService(serviceName);
-            if (service.spec.template.spec.containerConcurrency === concurrency) {
-                logger_1.logger.debug("Skipping setConcurrency on", serviceName, " because it already matches");
+            let service = await run.getService(serviceName);
+            let changed = false;
+            if (service.spec.template.spec.containerConcurrency !== endpoint.concurrency) {
+                service.spec.template.spec.containerConcurrency = endpoint.concurrency;
+                changed = true;
+            }
+            if (+service.spec.template.spec.containers[0].resources.limits.cpu !== endpoint.cpu) {
+                service.spec.template.spec.containers[0].resources.limits.cpu = `${endpoint.cpu}`;
+                changed = true;
+            }
+            if (!changed) {
+                logger_1.logger.debug("Skipping setRunTraits on", serviceName, " because it already matches");
                 return;
             }
             delete service.status;
             delete service.spec.template.metadata.name;
-            service.spec.template.spec.containerConcurrency = concurrency;
-            await run.replaceService(serviceName, service);
+            service = await run.replaceService(serviceName, service);
+            let retry = 0;
+            while (!exports.serviceIsResolved(service)) {
+                await (0, throttler_1.backoff)(retry, 2, 30);
+                retry = retry + 1;
+                service = await run.getService(serviceName);
+            }
         })
             .catch(rethrowAs(endpoint, "set concurrency"));
     }
@@ -482,3 +514,26 @@ class Fabricator {
     }
 }
 exports.Fabricator = Fabricator;
+function serviceIsResolved(service) {
+    var _a, _b, _c, _d, _e;
+    if (((_a = service.status) === null || _a === void 0 ? void 0 : _a.observedGeneration) !== service.metadata.generation) {
+        logger_1.logger.debug(`Service ${service.metadata.name} is not resolved because` +
+            `observed generation ${(_b = service.status) === null || _b === void 0 ? void 0 : _b.observedGeneration} does not ` +
+            `match spec generation ${service.metadata.generation}`);
+        return false;
+    }
+    const readyCondition = (_d = (_c = service.status) === null || _c === void 0 ? void 0 : _c.conditions) === null || _d === void 0 ? void 0 : _d.find((condition) => {
+        return condition.type === "Ready";
+    });
+    if ((readyCondition === null || readyCondition === void 0 ? void 0 : readyCondition.status) === "Unknown") {
+        logger_1.logger.debug(`Waiting for service ${service.metadata.name} to be ready. ` +
+            `Status is ${JSON.stringify((_e = service.status) === null || _e === void 0 ? void 0 : _e.conditions)}`);
+        return false;
+    }
+    else if ((readyCondition === null || readyCondition === void 0 ? void 0 : readyCondition.status) === "True") {
+        return true;
+    }
+    logger_1.logger.debug(`Service ${service.metadata.name} has unexpected ready status ${JSON.stringify(readyCondition)}. It may have failed rollout.`);
+    throw new error_1.FirebaseError(`Unexpected Status ${readyCondition === null || readyCondition === void 0 ? void 0 : readyCondition.status} for service ${service.metadata.name}`);
+}
+exports.serviceIsResolved = serviceIsResolved;

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

@@ -11,12 +11,9 @@ const fabricator = require("./fabricator");
 const reporter = require("./reporter");
 const executor = require("./executor");
 const prompts = require("../prompts");
-const secrets = require("../../../functions/secrets");
 const functionsConfig_1 = require("../../../functionsConfig");
 const functionsDeployHelper_1 = require("../functionsDeployHelper");
 const error_1 = require("../../../error");
-const projectUtils_1 = require("../../../projectUtils");
-const utils_1 = require("../../../utils");
 async function release(context, options, payload) {
     if (!context.config) {
         return;
@@ -76,24 +73,6 @@ async function release(context, options, payload) {
         const opts = allErrors.length === 1 ? { original: allErrors[0] } : { children: allErrors };
         throw new error_1.FirebaseError("There was an error deploying functions", Object.assign(Object.assign({}, opts), { exit: 2 }));
     }
-    else {
-        if (secrets.of(haveEndpoints).length > 0) {
-            const projectId = (0, projectUtils_1.needProjectId)(options);
-            const projectNumber = await (0, projectUtils_1.needProjectNumber)(options);
-            const reloadedBackend = await backend.existingBackend({ projectId });
-            const prunedResult = await secrets.pruneAndDestroySecrets({ projectId, projectNumber }, backend.allEndpoints(reloadedBackend));
-            if (prunedResult.destroyed.length > 0) {
-                (0, utils_1.logLabeledBullet)("functions", `Destroyed unused secret versions: ${prunedResult.destroyed
-                    .map((s) => `${s.secret}@${s.version}`)
-                    .join(", ")}`);
-            }
-            if (prunedResult.erred.length > 0) {
-                (0, utils_1.logLabeledWarning)("functions", `Failed to destroy unused secret versions:\n\t${prunedResult.erred
-                    .map((err) => err.message)
-                    .join("\n\t")}`);
-            }
-        }
-    }
 }
 exports.release = release;
 function printTriggerUrls(results) {

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

@@ -187,7 +187,19 @@ 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");
+        (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) => {
+            if (senvs && senvs.length > 0) {
+                ep.secretEnvironmentVariables = [];
+                for (const { key, secret } of senvs) {
+                    ep.secretEnvironmentVariables.push({
+                        key,
+                        secret: secret || key,
+                        projectId: project,
+                    });
+                }
+            }
+        });
         allParsed.push(parsed);
     }
     return allParsed;

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

@@ -6,20 +6,14 @@ const logger_1 = require("../../../logger");
 const error_1 = require("../../../error");
 const location_1 = require("../../../gcp/location");
 const PUBSUB_PUBLISHER_ROLE = "roles/pubsub.publisher";
-async function obtainStorageBindings(projectNumber, existingPolicy) {
+async function obtainStorageBindings(projectNumber) {
     const storageResponse = await storage.getServiceAccount(projectNumber);
     const storageServiceAgent = `serviceAccount:${storageResponse.email_address}`;
-    let pubsubBinding = existingPolicy.bindings.find((b) => b.role === PUBSUB_PUBLISHER_ROLE);
-    if (!pubsubBinding) {
-        pubsubBinding = {
-            role: PUBSUB_PUBLISHER_ROLE,
-            members: [],
-        };
-    }
-    if (!pubsubBinding.members.find((m) => m === storageServiceAgent)) {
-        pubsubBinding.members.push(storageServiceAgent);
-    }
-    return [pubsubBinding];
+    const pubsubPublisherBinding = {
+        role: PUBSUB_PUBLISHER_ROLE,
+        members: [storageServiceAgent],
+    };
+    return [pubsubPublisherBinding];
 }
 exports.obtainStorageBindings = obtainStorageBindings;
 async function ensureStorageTriggerRegion(endpoint) {

package/lib/deploy/functions/validate.js

@@ -29,12 +29,39 @@ function endpointsAreValid(wantBackend) {
         if ((endpoint.concurrency || 1) === 1) {
             return false;
         }
-        const mem = endpoint.availableMemoryMb || backend.DEFAULT_MEMORY;
-        return mem < backend.MIN_MEMORY_FOR_CONCURRENCY;
+        return endpoint.cpu < backend.MIN_CPU_FOR_CONCURRENCY;
     })
         .map((endpoint) => endpoint.id);
     if (tooSmallForConcurrency.length) {
-        const msg = `Cannot set concurency on the functions ${tooSmallForConcurrency.join(",")} because they have fewer than 2GB memory`;
+        const msg = "The following functions are configured to allow concurrent " +
+            "execution and less than one full CPU. This is not supported: " +
+            tooSmallForConcurrency.join(",");
+        throw new error_1.FirebaseError(msg);
+    }
+    const gcfV1WithCPU = endpoints
+        .filter((endpoint) => endpoint.platform === "gcfv1" && typeof endpoint["cpu"] !== "undefined")
+        .map((endpoint) => endpoint.id);
+    if (gcfV1WithCPU.length) {
+        const msg = `Cannot set CPU on the functions ${gcfV1WithCPU.join(",")} because they are GCF gen 1`;
+        throw new error_1.FirebaseError(msg);
+    }
+    const invalidCPU = endpoints
+        .filter((endpoint) => {
+        if (typeof endpoint.cpu === "undefined") {
+            return false;
+        }
+        if (endpoint.cpu === "gcf_gen1") {
+            return false;
+        }
+        const cpu = endpoint.cpu;
+        if (cpu < 1) {
+            return false;
+        }
+        return ![1, 2, 4, 6, 8].includes(cpu);
+    })
+        .map((endpoint) => endpoint.id);
+    if (invalidCPU.length) {
+        const msg = `The following functions have invalid CPU settings ${invalidCPU.join(",")}. Valid CPU options are (0, 1], 2, 4, 6, 8, or "gcf_gen1"`;
         throw new error_1.FirebaseError(msg);
     }
 }
@@ -100,13 +127,13 @@ async function secretsAreValid(projectId, wantBackend) {
     await validateSecretVersions(projectId, endpoints);
 }
 exports.secretsAreValid = secretsAreValid;
+const secretsSupportedPlatforms = ["gcfv1", "gcfv2"];
 function validatePlatformTargets(endpoints) {
-    const supportedPlatforms = ["gcfv1"];
-    const unsupported = endpoints.filter((e) => !supportedPlatforms.includes(e.platform));
+    const unsupported = endpoints.filter((e) => !secretsSupportedPlatforms.includes(e.platform));
     if (unsupported.length > 0) {
         const errs = unsupported.map((e) => `${e.id}[platform=${e.platform}]`);
         throw new error_1.FirebaseError(`Tried to set secret environment variables on ${errs.join(", ")}. ` +
-            `Only ${supportedPlatforms.join(", ")} support secret environments.`);
+            `Only ${secretsSupportedPlatforms.join(", ")} support secret environments.`);
     }
 }
 async function validateSecretVersions(projectId, endpoints) {

package/lib/emulator/extensionsEmulator.js

@@ -152,6 +152,7 @@ class ExtensionsEmulator {
         return emulatableBackend;
     }
     autoPopulatedParams(instance) {
+        var _a;
         const projectId = this.args.projectId;
         return {
             PROJECT_ID: projectId !== null && projectId !== void 0 ? projectId : "",
@@ -159,6 +160,8 @@ class ExtensionsEmulator {
             DATABASE_INSTANCE: projectId !== null && projectId !== void 0 ? projectId : "",
             DATABASE_URL: `https://${projectId}.firebaseio.com`,
             STORAGE_BUCKET: `${projectId}.appspot.com`,
+            ALLOWED_EVENT_TYPES: instance.allowedEventTypes ? instance.allowedEventTypes.join(",") : "",
+            EVENTARC_CHANNEL: (_a = instance.eventarcChannel) !== null && _a !== void 0 ? _a : "",
         };
     }
     async checkAndWarnAPIs(instances) {

package/lib/extensions/askUserForEventsConfig.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.askForEventArcLocation = exports.askShouldCollectEventsConfig = exports.askForAllowedEventTypes = exports.askForEventsConfig = exports.checkAllowedEventTypesResponse = void 0;
+const prompt_1 = require("../prompt");
+const extensionsApi = require("../extensions/extensionsApi");
+const utils = require("../utils");
+const clc = require("cli-color");
+const logger_1 = require("../logger");
+const { marked } = require("marked");
+function checkAllowedEventTypesResponse(response, validEvents) {
+    const validEventTypes = validEvents.map((e) => e.type);
+    if (response.length === 0) {
+        return false;
+    }
+    for (const e of response) {
+        if (!validEventTypes.includes(e)) {
+            utils.logWarning(`Unexpected event type '${e}' was configured to be emitted. This event type is not part of the extension spec.`);
+            return false;
+        }
+    }
+    return true;
+}
+exports.checkAllowedEventTypesResponse = checkAllowedEventTypesResponse;
+async function askForEventsConfig(events, projectId, instanceId) {
+    var _a, _b;
+    logger_1.logger.info(`\n${clc.bold("Enable Events")}: ${marked("If you enable events, you can write custom event handlers ([https://firebase.google.com/docs/extensions/install-extensions#eventarc](https://firebase.google.com/docs/extensions/install-extensions#eventarc)) that respond to these events.\n\nYou can always enable or disable events later. Events will be emitted via Eventarc. Fees apply ([https://cloud.google.com/eventarc/pricing](https://cloud.google.com/eventarc/pricing)).")}`);
+    if (!(await askShouldCollectEventsConfig())) {
+        return undefined;
+    }
+    let existingInstance;
+    try {
+        existingInstance = instanceId
+            ? await extensionsApi.getInstance(projectId, instanceId)
+            : undefined;
+    }
+    catch (_c) {
+    }
+    const preselectedTypes = (_a = existingInstance === null || existingInstance === void 0 ? void 0 : existingInstance.config.allowedEventTypes) !== null && _a !== void 0 ? _a : [];
+    const oldLocation = (_b = existingInstance === null || existingInstance === void 0 ? void 0 : existingInstance.config.eventarcChannel) === null || _b === void 0 ? void 0 : _b.split("/")[3];
+    const location = await askForEventArcLocation(oldLocation);
+    const channel = `projects/${projectId}/locations/${location}/channels/firebase`;
+    const allowedEventTypes = await askForAllowedEventTypes(events, preselectedTypes);
+    return { channel, allowedEventTypes };
+}
+exports.askForEventsConfig = askForEventsConfig;
+async function askForAllowedEventTypes(eventDescriptors, preselectedTypes) {
+    let valid = false;
+    let response = [];
+    const eventTypes = eventDescriptors.map((e, index) => ({
+        checked: false,
+        name: `${index + 1}. ${e.type}\n   ${e.description}`,
+        value: e.type,
+    }));
+    while (!valid) {
+        response = await (0, prompt_1.promptOnce)({
+            name: "selectedEventTypesInput",
+            type: "checkbox",
+            default: preselectedTypes !== null && preselectedTypes !== void 0 ? preselectedTypes : [],
+            message: `Please select the events [${eventTypes.length} types total] that this extension is permitted to emit. ` +
+                "You can implement your own handlers that trigger when these events are emitted to customize the extension's behavior. ",
+            choices: eventTypes,
+            pageSize: 20,
+        });
+        valid = checkAllowedEventTypesResponse(response, eventDescriptors);
+    }
+    return response.filter((e) => e !== "");
+}
+exports.askForAllowedEventTypes = askForAllowedEventTypes;
+async function askShouldCollectEventsConfig() {
+    return (0, prompt_1.promptOnce)({
+        type: "confirm",
+        name: "shouldCollectEvents",
+        message: `Would you like to enable events?`,
+        default: false,
+    });
+}
+exports.askShouldCollectEventsConfig = askShouldCollectEventsConfig;
+async function askForEventArcLocation(preselectedLocation) {
+    let valid = false;
+    const allowedRegions = ["us-central1", "us-west1", "europe-west4", "asia-northeast1"];
+    let location = "";
+    while (!valid) {
+        location = await (0, prompt_1.promptOnce)({
+            name: "input",
+            type: "list",
+            default: preselectedLocation !== null && preselectedLocation !== void 0 ? preselectedLocation : "us-central1",
+            message: "Which location would you like the Eventarc channel to live in? We recommend using the default option. A channel location that differs from the extension's Cloud Functions location can incur egress cost.",
+            choices: allowedRegions.map((e) => ({ checked: false, value: e })),
+        });
+        valid = allowedRegions.includes(location);
+        if (!valid) {
+            utils.logWarning(`Unexpected EventArc region '${location}' was specified. Allowed regions: ${allowedRegions.join(", ")}`);
+        }
+    }
+    return location;
+}
+exports.askForEventArcLocation = askForEventArcLocation;

package/lib/extensions/export.js

@@ -45,6 +45,7 @@ function displayExportInfo(withRef, withoutRef) {
 }
 exports.displayExportInfo = displayExportInfo;
 function displaySpecs(specs) {
+    var _a;
     for (let i = 0; i < specs.length; i++) {
         const spec = specs[i];
         logger_1.logger.info(`${i + 1}. ${(0, deploymentSummary_1.humanReadable)(spec)}`);
@@ -52,6 +53,12 @@ function displaySpecs(specs) {
         for (const p of Object.entries(spec.params)) {
             logger_1.logger.info(`\t${p[0]}=${p[1]}`);
         }
+        if ((_a = spec.allowedEventTypes) === null || _a === void 0 ? void 0 : _a.length) {
+            logger_1.logger.info(`\tALLOWED_EVENTS=${spec.allowedEventTypes}`);
+        }
+        if (spec.eventarcChannel) {
+            logger_1.logger.info(`\tEVENTARC_CHANNEL=${spec.eventarcChannel}`);
+        }
         logger_1.logger.info("");
     }
 }

package/lib/extensions/extensionsApi.js

@@ -58,6 +58,8 @@ async function createInstance(args) {
     var _a, _b;
     const config = {
         params: args.params,
+        allowedEventTypes: args.allowedEventTypes,
+        eventarcChannel: args.eventarcChannel,
     };
     if (args.extensionSource && args.extensionVersionRef) {
         throw new error_1.FirebaseError("ExtensionSource and ExtensionVersion both provided, but only one should be.");
@@ -73,6 +75,12 @@ async function createInstance(args) {
     else {
         throw new error_1.FirebaseError("No ExtensionVersion or ExtensionSource provided but one is required.");
     }
+    if (args.allowedEventTypes) {
+        config.allowedEventTypes = args.allowedEventTypes;
+    }
+    if (args.eventarcChannel) {
+        config.eventarcChannel = args.eventarcChannel;
+    }
     return createInstanceHelper(args.projectId, args.instanceId, config, args.validateOnly);
 }
 exports.createInstance = createInstance;
@@ -88,8 +96,16 @@ async function deleteInstance(projectId, instanceId) {
 }
 exports.deleteInstance = deleteInstance;
 async function getInstance(projectId, instanceId) {
-    const res = await apiClient.get(`/projects/${projectId}/instances/${instanceId}`);
-    return res.body;
+    try {
+        const res = await apiClient.get(`/projects/${projectId}/instances/${instanceId}`);
+        return res.body;
+    }
+    catch (err) {
+        if (err.status === 404) {
+            throw new error_1.FirebaseError(`Extension instance '${clc.bold(instanceId)}' not found in project '${clc.bold(projectId)}'.`, { status: 404 });
+        }
+        throw err;
+    }
 }
 exports.getInstance = getInstance;
 async function listInstances(projectId) {
@@ -114,7 +130,7 @@ async function listInstances(projectId) {
 exports.listInstances = listInstances;
 async function configureInstance(args) {
     var _a;
-    const res = await patchInstance({
+    const reqBody = {
         projectId: args.projectId,
         instanceId: args.instanceId,
         updateMask: "config.params",
@@ -124,8 +140,16 @@ async function configureInstance(args) {
                 params: args.params,
             },
         },
-    });
-    return res;
+    };
+    if (args.canEmitEvents) {
+        if (args.allowedEventTypes === undefined || args.eventarcChannel === undefined) {
+            throw new error_1.FirebaseError(`This instance is configured to emit events, but either allowed event types or eventarc channel is undefined.`);
+        }
+        reqBody.data.config.allowedEventTypes = args.allowedEventTypes;
+        reqBody.data.config.eventarcChannel = args.eventarcChannel;
+    }
+    reqBody.updateMask += ",config.allowed_event_types,config.eventarc_channel";
+    return patchInstance(reqBody);
 }
 exports.configureInstance = configureInstance;
 async function updateInstance(args) {
@@ -140,7 +164,15 @@ async function updateInstance(args) {
         body.config.params = args.params;
         updateMask += ",config.params";
     }
-    return await patchInstance({
+    if (args.canEmitEvents) {
+        if (args.allowedEventTypes === undefined || args.eventarcChannel === undefined) {
+            throw new error_1.FirebaseError(`This instance is configured to emit events, but either allowed event types or eventarc channel is undefined.`);
+        }
+        body.config.allowedEventTypes = args.allowedEventTypes;
+        body.config.eventarcChannel = args.eventarcChannel;
+    }
+    updateMask += ",config.allowed_event_types,config.eventarc_channel";
+    return patchInstance({
         projectId: args.projectId,
         instanceId: args.instanceId,
         updateMask,
@@ -163,7 +195,15 @@ async function updateInstanceFromRegistry(args) {
         body.config.params = args.params;
         updateMask += ",config.params";
     }
-    return await patchInstance({
+    if (args.canEmitEvents) {
+        if (args.allowedEventTypes === undefined || args.eventarcChannel === undefined) {
+            throw new error_1.FirebaseError(`This instance is configured to emit events, but either allowed event types or eventarc channel is undefined.`);
+        }
+        body.config.allowedEventTypes = args.allowedEventTypes;
+        body.config.eventarcChannel = args.eventarcChannel;
+    }
+    updateMask += ",config.allowed_event_types,config.eventarc_channel";
+    return patchInstance({
         projectId: args.projectId,
         instanceId: args.instanceId,
         updateMask,

package/lib/extensions/manifest.js

@@ -48,7 +48,7 @@ async function writeLocalSecrets(specs, config, force) {
             continue;
         }
         const writeBuffer = {};
-        const locallyOverridenSecretParams = extensionSpec.params.filter((p) => p.type === extensionsApi_1.ParamType.SECRET && spec.params[p.param].local);
+        const locallyOverridenSecretParams = extensionSpec.params.filter((p) => { var _a; return p.type === extensionsApi_1.ParamType.SECRET && ((_a = spec.params[p.param]) === null || _a === void 0 ? void 0 : _a.local); });
         for (const paramSpec of locallyOverridenSecretParams) {
             const key = paramSpec.param;
             const localValue = spec.params[key].local;