firebase-tools 10.7.2 → 10.9.1

package/lib/deploy/functions/validate.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.secretsAreValid = exports.functionIdsAreValid = exports.functionsDirectoryExists = exports.endpointsAreUnique = exports.endpointsAreValid = void 0;
+exports.secretsAreValid = exports.functionIdsAreValid = exports.functionsDirectoryExists = exports.endpointsAreUnique = exports.cpuConfigIsValid = exports.endpointsAreValid = void 0;
 const path = require("path");
 const clc = require("cli-color");
 const error_1 = require("../../error");
@@ -11,34 +11,98 @@ const backend = require("./backend");
 const utils = require("../../utils");
 const secrets = require("../../functions/secrets");
 const services_1 = require("./services");
+function matchingIds(endpoints, filter) {
+    return endpoints
+        .filter(filter)
+        .map((endpoint) => endpoint.id)
+        .join(",");
+}
+const mem = (endpoint) => endpoint.availableMemoryMb || backend.DEFAULT_MEMORY;
+const cpu = (endpoint) => {
+    var _a;
+    return endpoint.cpu === "gcf_gen1"
+        ? backend.memoryToGen1Cpu(mem(endpoint))
+        : (_a = endpoint.cpu) !== null && _a !== void 0 ? _a : backend.memoryToGen2Cpu(mem(endpoint));
+};
 function endpointsAreValid(wantBackend) {
     const endpoints = backend.allEndpoints(wantBackend);
     functionIdsAreValid(endpoints);
     for (const ep of endpoints) {
         (0, services_1.serviceForEndpoint)(ep).validateTrigger(ep, wantBackend);
     }
-    const gcfV1WithConcurrency = endpoints
-        .filter((endpoint) => (endpoint.concurrency || 1) !== 1 && endpoint.platform === "gcfv1")
-        .map((endpoint) => endpoint.id);
+    const gcfV1WithConcurrency = matchingIds(endpoints, (endpoint) => (endpoint.concurrency || 1) !== 1 && endpoint.platform === "gcfv1");
     if (gcfV1WithConcurrency.length) {
-        const msg = `Cannot set concurrency on the functions ${gcfV1WithConcurrency.join(",")} because they are GCF gen 1`;
+        const msg = `Cannot set concurrency on the functions ${gcfV1WithConcurrency} because they are GCF gen 1`;
         throw new error_1.FirebaseError(msg);
     }
-    const tooSmallForConcurrency = endpoints
-        .filter((endpoint) => {
+    const tooSmallForConcurrency = matchingIds(endpoints, (endpoint) => {
         if ((endpoint.concurrency || 1) === 1) {
             return false;
         }
-        const mem = endpoint.availableMemoryMb || backend.DEFAULT_MEMORY;
-        return mem < backend.MIN_MEMORY_FOR_CONCURRENCY;
-    })
-        .map((endpoint) => endpoint.id);
+        return cpu(endpoint) < backend.MIN_CPU_FOR_CONCURRENCY;
+    });
     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;
         throw new error_1.FirebaseError(msg);
     }
+    cpuConfigIsValid(endpoints);
 }
 exports.endpointsAreValid = endpointsAreValid;
+function cpuConfigIsValid(endpoints) {
+    const gcfV1WithCPU = matchingIds(endpoints, (endpoint) => endpoint.platform === "gcfv1" && typeof endpoint["cpu"] !== "undefined");
+    if (gcfV1WithCPU.length) {
+        const msg = `Cannot set CPU on the functions ${gcfV1WithCPU} because they are GCF gen 1`;
+        throw new error_1.FirebaseError(msg);
+    }
+    const invalidCPU = matchingIds(endpoints, (endpoint) => {
+        const c = cpu(endpoint);
+        if (c < 0.08) {
+            return true;
+        }
+        if (c < 1) {
+            return false;
+        }
+        return ![1, 2, 4, 6, 8].includes(c);
+    });
+    if (invalidCPU.length) {
+        const msg = `The following functions have invalid CPU settings ${invalidCPU}. Valid CPU options are (0.08, 1], 2, 4, 6, 8, or "gcf_gen1"`;
+        throw new error_1.FirebaseError(msg);
+    }
+    const smallCPURegions = ["australia-southeast2", "asia-northeast3", "asia-south2"];
+    const tooBigCPUForRegion = matchingIds(endpoints, (endpoint) => smallCPURegions.includes(endpoint.region) && cpu(endpoint) > 4);
+    if (tooBigCPUForRegion) {
+        const msg = `The functions ${tooBigCPUForRegion} have > 4 CPU in a region that supports a maximum 4 CPU`;
+        throw new error_1.FirebaseError(msg);
+    }
+    const tooSmallCPUSmall = matchingIds(endpoints, (endpoint) => mem(endpoint) > 512 && cpu(endpoint) < 0.5);
+    if (tooSmallCPUSmall) {
+        const msg = `The functions ${tooSmallCPUSmall} have too little CPU for their memory allocation. A minimum of 0.5 CPU is needed to set a memory limit greater than 512MiB`;
+        throw new error_1.FirebaseError(msg);
+    }
+    const tooSmallCPUBig = matchingIds(endpoints, (endpoint) => mem(endpoint) > 1024 && cpu(endpoint) < 1);
+    if (tooSmallCPUBig) {
+        const msg = `The functions ${tooSmallCPUSmall} have too little CPU for their memory allocation. A minimum of 1 CPU is needed to set a memory limit greater than 1GiB`;
+        throw new error_1.FirebaseError(msg);
+    }
+    const tooSmallMemory4CPU = matchingIds(endpoints, (endpoint) => cpu(endpoint) === 4 && mem(endpoint) < 2 << 10);
+    if (tooSmallMemory4CPU) {
+        const msg = `The functions ${tooSmallMemory4CPU} have too little memory for their CPU. Functions with 4 CPU require at least 2GiB`;
+        throw new error_1.FirebaseError(msg);
+    }
+    const tooSmallMemory6CPU = matchingIds(endpoints, (endpoint) => cpu(endpoint) === 6 && mem(endpoint) < 3 << 10);
+    if (tooSmallMemory6CPU) {
+        const msg = `The functions ${tooSmallMemory6CPU} have too little memory for their CPU. Functions with 6 CPU require at least 3GiB`;
+        throw new error_1.FirebaseError(msg);
+    }
+    const tooSmallMemory8CPU = matchingIds(endpoints, (endpoint) => cpu(endpoint) === 8 && mem(endpoint) < 4 << 10);
+    if (tooSmallMemory8CPU) {
+        const msg = `The functions ${tooSmallMemory8CPU} have too little memory for their CPU. Functions with 8 CPU require at least 4GiB`;
+        throw new error_1.FirebaseError(msg);
+    }
+}
+exports.cpuConfigIsValid = cpuConfigIsValid;
 function endpointsAreUnique(backends) {
     const endpointToCodebases = {};
     for (const [codebase, b] of Object.entries(backends)) {
@@ -100,13 +164,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/deploy/index.js

@@ -18,6 +18,7 @@ const FunctionsTarget = require("./functions");
 const StorageTarget = require("./storage");
 const RemoteConfigTarget = require("./remoteconfig");
 const ExtensionsTarget = require("./extensions");
+const frameworks_1 = require("../frameworks");
 const TARGETS = {
     hosting: HostingTarget,
     database: DatabaseTarget,
@@ -45,7 +46,7 @@ const deploy = async function (targetNames, options, customContext = {}) {
     if (previews_1.previews.frameworkawareness && targetNames.includes("hosting")) {
         const config = options.config.get("hosting");
         if (Array.isArray(config) ? config.some((it) => it.source) : config.source) {
-            await require("firebase-frameworks").prepare(targetNames, context, options);
+            await (0, frameworks_1.prepareFrameworks)(targetNames, context, options);
         }
     }
     for (const targetName of targetNames) {

package/lib/emulator/controller.js

@@ -37,9 +37,10 @@ const config_1 = require("./storage/rules/config");
 const getDefaultDatabaseInstance_1 = require("../getDefaultDatabaseInstance");
 const auth_2 = require("../auth");
 const extensionsEmulator_1 = require("./extensionsEmulator");
-const previews_1 = require("../previews");
 const projectConfig_1 = require("../functions/projectConfig");
 const downloadableEmulators_1 = require("./downloadableEmulators");
+const frameworks_1 = require("../frameworks");
+const previews_1 = require("../previews");
 const START_LOGGING_EMULATOR = utils.envOverride("START_LOGGING_EMULATOR", "false", (val) => val === "true");
 async function getAndCheckAddress(emulator, options) {
     var _a, _b, _c, _d;
@@ -125,9 +126,7 @@ async function cleanShutdown() {
 exports.cleanShutdown = cleanShutdown;
 function filterEmulatorTargets(options) {
     let targets = [...types_1.ALL_SERVICE_EMULATORS];
-    if (previews_1.previews.extensionsemulator) {
-        targets.push(types_1.Emulators.EXTENSIONS);
-    }
+    targets.push(types_1.Emulators.EXTENSIONS);
     targets = targets.filter((e) => {
         return options.config.has(e) || options.config.has(`emulators.${e}`);
     });
@@ -245,6 +244,12 @@ async function startAll(options, showUI = true) {
             }
         }
     }
+    if (previews_1.previews.frameworkawareness) {
+        const config = options.config.get("hosting");
+        if (Array.isArray(config) ? config.some((it) => it.source) : config.source) {
+            await (0, frameworks_1.prepareFrameworks)(targets, options, options);
+        }
+    }
     if (shouldStart(options, types_1.Emulators.HUB)) {
         const hubAddr = await getAndCheckAddress(types_1.Emulators.HUB, options);
         const hub = new hub_1.EmulatorHub(Object.assign({ projectId }, hubAddr));
@@ -282,7 +287,7 @@ async function startAll(options, showUI = true) {
             });
         }
     }
-    if (shouldStart(options, types_1.Emulators.EXTENSIONS) && previews_1.previews.extensionsemulator) {
+    if (shouldStart(options, types_1.Emulators.EXTENSIONS)) {
         const projectNumber = constants_1.Constants.isDemoProject(projectId)
             ? constants_1.Constants.FAKE_PROJECT_NUMBER
             : await (0, projectUtils_1.needProjectNumber)(options);

package/lib/emulator/downloadableEmulators.js

@@ -50,15 +50,15 @@ exports.DownloadDetails = {
             namePrefix: "cloud-storage-rules-emulator",
         },
     },
-    ui: previews_1.previews.extensionsemulator
+    ui: previews_1.previews.emulatoruisnapshot
         ? {
-            version: "EXTENSIONS",
-            downloadPath: path.join(CACHE_DIR, "ui-vEXTENSIONS.zip"),
-            unzipDir: path.join(CACHE_DIR, "ui-vEXTENSIONS"),
-            binaryPath: path.join(CACHE_DIR, "ui-vEXTENSIONS", "server.bundle.js"),
+            version: "SNAPSHOT",
+            downloadPath: path.join(CACHE_DIR, "ui-vSNAPSHOT.zip"),
+            unzipDir: path.join(CACHE_DIR, "ui-vSNAPSHOT"),
+            binaryPath: path.join(CACHE_DIR, "ui-vSNAPSHOT", "server.bundle.js"),
             opts: {
                 cacheDir: CACHE_DIR,
-                remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/ui-vEXTENSIONS.zip",
+                remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/ui-vSNAPSHOT.zip",
                 expectedSize: -1,
                 expectedChecksum: "",
                 skipCache: true,
@@ -66,35 +66,19 @@ exports.DownloadDetails = {
                 namePrefix: "ui",
             },
         }
-        : previews_1.previews.emulatoruisnapshot
-            ? {
-                version: "SNAPSHOT",
-                downloadPath: path.join(CACHE_DIR, "ui-vSNAPSHOT.zip"),
-                unzipDir: path.join(CACHE_DIR, "ui-vSNAPSHOT"),
-                binaryPath: path.join(CACHE_DIR, "ui-vSNAPSHOT", "server.bundle.js"),
-                opts: {
-                    cacheDir: CACHE_DIR,
-                    remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/ui-vSNAPSHOT.zip",
-                    expectedSize: -1,
-                    expectedChecksum: "",
-                    skipCache: true,
-                    skipChecksumAndSize: true,
-                    namePrefix: "ui",
-                },
-            }
-            : {
-                version: "1.6.6",
-                downloadPath: path.join(CACHE_DIR, "ui-v1.6.6.zip"),
-                unzipDir: path.join(CACHE_DIR, "ui-v1.6.6"),
-                binaryPath: path.join(CACHE_DIR, "ui-v1.6.6", "server.bundle.js"),
-                opts: {
-                    cacheDir: CACHE_DIR,
-                    remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/ui-v1.6.6.zip",
-                    expectedSize: 3817247,
-                    expectedChecksum: "c80a3f0ae1e3f682ace0a18a9cdd2861",
-                    namePrefix: "ui",
-                },
+        : {
+            version: "1.7.0",
+            downloadPath: path.join(CACHE_DIR, "ui-v1.7.0.zip"),
+            unzipDir: path.join(CACHE_DIR, "ui-v1.7.0"),
+            binaryPath: path.join(CACHE_DIR, "ui-v1.7.0", "server.bundle.js"),
+            opts: {
+                cacheDir: CACHE_DIR,
+                remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/ui-v1.7.0.zip",
+                expectedSize: 4053708,
+                expectedChecksum: "aea9ae19091df5974a88a8847aaf127c",
+                namePrefix: "ui",
             },
+        },
     pubsub: {
         downloadPath: path.join(CACHE_DIR, "pubsub-emulator-0.1.0.zip"),
         version: "0.1.0",

package/lib/emulator/extensionsEmulator.js

@@ -65,7 +65,7 @@ class ExtensionsEmulator {
             if (!this.hasValidSource({ path: instance.localPath, extTarget: instance.localPath })) {
                 throw new error_1.FirebaseError(`Tried to emulate local extension at ${instance.localPath}, but it was missing required files.`);
             }
-            return instance.localPath;
+            return path.resolve(instance.localPath);
         }
         else if (instance.ref) {
             const ref = (0, refs_1.toExtensionVersionRef)(instance.ref);
@@ -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/emulator/functionsEmulator.js

@@ -667,7 +667,10 @@ class FunctionsEmulator {
         envs.FUNCTIONS_EMULATOR = "true";
         envs.TZ = "UTC";
         envs.FIREBASE_DEBUG_MODE = "true";
-        envs.FIREBASE_DEBUG_FEATURES = JSON.stringify({ skipTokenVerification: true });
+        envs.FIREBASE_DEBUG_FEATURES = JSON.stringify({
+            skipTokenVerification: true,
+            enableCors: true,
+        });
         const firestoreEmulator = this.getEmulatorInfo(types_1.Emulators.FIRESTORE);
         if (firestoreEmulator != null) {
             envs[constants_1.Constants.FIRESTORE_EMULATOR_HOST] = (0, functionsEmulatorShared_1.formatHost)(firestoreEmulator);

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;

package/lib/extensions/updateHelper.js

@@ -59,13 +59,16 @@ async function displayChanges(args) {
 }
 exports.displayChanges = displayChanges;
 async function update(updateOptions) {
-    const { projectId, instanceId, source, extRef, params } = updateOptions;
+    const { projectId, instanceId, source, extRef, params, canEmitEvents, allowedEventTypes, eventarcChannel, } = updateOptions;
     if (extRef) {
         return await extensionsApi.updateInstanceFromRegistry({
             projectId,
             instanceId,
             extRef,
             params,
+            canEmitEvents,
+            allowedEventTypes,
+            eventarcChannel,
         });
     }
     else if (source) {
@@ -74,6 +77,9 @@ async function update(updateOptions) {
             instanceId,
             extensionSource: source,
             params,
+            canEmitEvents,
+            allowedEventTypes,
+            eventarcChannel,
         });
     }
     throw new error_1.FirebaseError(`Neither a source nor a version of the extension was supplied for ${instanceId}. Please make sure this is a valid extension and try again.`);

package/lib/extensions/warnings.js

@@ -58,13 +58,13 @@ async function displayWarningsForDeploy(instancesToCreate) {
     const experimental = nonEapExtensions.filter((i) => i.extension.registryLaunchStage === extensionsApi_1.RegistryLaunchStage.EXPERIMENTAL);
     if (experimental.length) {
         const humanReadableList = experimental.map((i) => `\t${(0, deploymentSummary_1.humanReadable)(i)}`).join("\n");
-        utils.logLabeledBullet(extensionsHelper_1.logPrefix, marked(`The following are instances of ${clc.bold("experimental")} extensions.They may not be production-ready. Their functionality may change in backward-incompatible ways before their official release, or they may be discontinued.\n${humanReadableList}\n`));
+        utils.logLabeledBullet(extensionsHelper_1.logPrefix, marked(`The following are instances of ${clc.bold("experimental")} extensions.They may not be production-ready. Their functionality may change in backward-incompatible ways before their official release, or they may be discontinued.\n${humanReadableList}\n`, { gfm: false }));
     }
     if (eapExtensions.length) {
         const humanReadableList = eapExtensions.map(toListEntry).join("\n");
-        utils.logLabeledBullet(extensionsHelper_1.logPrefix, marked(`These extensions are in preview and are built by a developer in the Extensions Publisher Early Access Program (http://bit.ly/firex-provider. Their functionality might change in backwards-incompatible ways. Since these extensions aren't built by Firebase, reach out to their publisher with questions about them.` +
+        utils.logLabeledBullet(extensionsHelper_1.logPrefix, marked(`These extensions are in preview and are built by a developer in the Extensions Publisher Early Access Program (http://bit.ly/firex-provider). Their functionality might change in backwards-incompatible ways. Since these extensions aren't built by Firebase, reach out to their publisher with questions about them.` +
             ` They are provided “AS IS”, without any warranty, express or implied, from Google.` +
-            ` Google disclaims all liability for any damages, direct or indirect, resulting from the use of these extensions\n${humanReadableList}`));
+            ` Google disclaims all liability for any damages, direct or indirect, resulting from the use of these extensions\n${humanReadableList}`, { gfm: false }));
     }
     return experimental.length > 0 || eapExtensions.length > 0;
 }