firebase-tools 10.7.0 → 10.8.0

package/lib/emulator/functionsEmulator.js

@@ -177,7 +177,9 @@ class FunctionsEmulator {
         });
         return hub;
     }
-    async invokeTrigger(backend, trigger, proto, runtimeOpts) {
+    async invokeTrigger(trigger, proto, runtimeOpts) {
+        const record = this.getTriggerRecordByKey(this.getTriggerKey(trigger));
+        const backend = record.backend;
         const bundleTemplate = this.getBaseBundle();
         const runtimeBundle = Object.assign(Object.assign({}, bundleTemplate), { proto });
         if (this.args.debugPort) {
@@ -221,7 +223,6 @@ class FunctionsEmulator {
         return Promise.resolve();
     }
     async connect() {
-        const loadTriggerPromises = [];
         for (const backend of this.args.emulatableBackends) {
             this.logger.logLabeled("BULLET", "functions", `Watching "${backend.functionsDir}" for Cloud Functions...`);
             const watcher = chokidar.watch(backend.functionsDir, {
@@ -237,9 +238,8 @@ class FunctionsEmulator {
                 this.logger.log("DEBUG", `File ${filePath} changed, reloading triggers`);
                 return debouncedLoadTriggers();
             });
-            loadTriggerPromises.push(this.loadTriggers(backend, true));
+            await this.loadTriggers(backend, true);
         }
-        await Promise.all(loadTriggerPromises);
         await this.performPostLoadOperations();
         return;
     }
@@ -284,6 +284,9 @@ class FunctionsEmulator {
             const discoveredBackend = await runtimeDelegate.discoverSpec(runtimeConfig, Object.assign(Object.assign(Object.assign(Object.assign({}, this.getSystemEnvs()), this.getEmulatorEnvs()), { FIREBASE_CONFIG: this.getFirebaseConfig() }), emulatableBackend.env));
             const endpoints = backend.allEndpoints(discoveredBackend);
             (0, functionsEmulatorShared_1.prepareEndpoints)(endpoints);
+            for (const e of endpoints) {
+                e.codebase = emulatableBackend.codebase;
+            }
             triggerDefinitions = (0, functionsEmulatorShared_1.emulatedFunctionsFromEndpoints)(endpoints);
         }
         const toSetup = triggerDefinitions.filter((definition) => {
@@ -579,6 +582,7 @@ class FunctionsEmulator {
         };
     }
     setTriggersForTesting(triggers, backend) {
+        this.triggers = {};
         triggers.forEach((def) => this.addTriggerRecord(def, { backend, ignored: false }));
     }
     getBaseBundle() {
@@ -847,11 +851,9 @@ class FunctionsEmulator {
     }
     async reloadTriggers() {
         this.triggerGeneration++;
-        const loadTriggerPromises = [];
         for (const backend of this.args.emulatableBackends) {
-            loadTriggerPromises.push(this.loadTriggers(backend));
+            await this.loadTriggers(backend);
         }
-        await Promise.all(loadTriggerPromises);
         await this.performPostLoadOperations();
         return;
     }
@@ -862,7 +864,7 @@ class FunctionsEmulator {
         }
         const trigger = record.def;
         const service = (0, functionsEmulatorShared_1.getFunctionService)(trigger);
-        const worker = await this.invokeTrigger(record.backend, trigger, proto);
+        const worker = await this.invokeTrigger(trigger, proto);
         return new Promise((resolve, reject) => {
             if (projectId !== this.args.projectId) {
                 if (service !== constants_1.Constants.SERVICE_REALTIME_DATABASE) {
@@ -949,7 +951,7 @@ class FunctionsEmulator {
                 req.headers[functionsEmulatorShared_1.HttpConstants.CALLABLE_AUTH_HEADER] = encodeURIComponent(JSON.stringify(contextAuth));
             }
         }
-        const worker = await this.invokeTrigger(record.backend, trigger);
+        const worker = await this.invokeTrigger(trigger);
         worker.onLogs((el) => {
             if (el.level === "FATAL") {
                 res.status(500).send(el.text);

package/lib/emulator/functionsEmulatorRuntime.js

@@ -213,7 +213,7 @@ function initializeNetworkFiltering(frb) {
             })
                 .filter((v) => v);
             const href = (hrefs.length && hrefs[0]) || "";
-            if (href && !history[href] && !href.startsWith("http://localhost")) {
+            if (href && !history[href] && !(0, functionsEmulatorUtils_1.isLocalHost)(href)) {
                 history[href] = true;
                 if (href.indexOf("googleapis.com") !== -1) {
                     new types_1.EmulatorLog("SYSTEM", "googleapis-network-access", "", {

package/lib/emulator/functionsEmulatorShared.js

@@ -66,6 +66,7 @@ function emulatedFunctionsFromEndpoints(endpoints) {
             region: endpoint.region,
             name: endpoint.id,
             id: `${endpoint.region}-${endpoint.id}`,
+            codebase: endpoint.codebase,
         };
         (0, proto_1.copyIfPresent)(def, endpoint, "availableMemoryMb", "labels", "timeoutSeconds", "platform", "secretEnvironmentVariables");
         if (backend.isHttpsTriggered(endpoint)) {
@@ -105,6 +106,9 @@ function emulatedFunctionsFromEndpoints(endpoints) {
                 options: endpoint.blockingTrigger.options || {},
             };
         }
+        else if (backend.isTaskQueueTriggered(endpoint)) {
+            def.httpsTrigger = {};
+        }
         else {
         }
         regionDefinitions.push(def);
@@ -279,7 +283,7 @@ function toBackendInfo(e, cf3Triggers) {
         extension: e.extension,
         extensionVersion: extensionVersion,
         extensionSpec: extensionSpec,
-        functionTriggers: (_b = e.predefinedTriggers) !== null && _b !== void 0 ? _b : cf3Triggers,
+        functionTriggers: (_b = e.predefinedTriggers) !== null && _b !== void 0 ? _b : cf3Triggers.filter((t) => t.codebase === e.codebase),
     }));
 }
 exports.toBackendInfo = toBackendInfo;

package/lib/emulator/functionsEmulatorShell.js

@@ -7,9 +7,8 @@ const utils = require("../utils");
 const logger_1 = require("../logger");
 const error_1 = require("../error");
 class FunctionsEmulatorShell {
-    constructor(emu, backend) {
+    constructor(emu) {
         this.emu = emu;
-        this.backend = backend;
         this.urls = {};
         this.triggers = emu.getTriggerDefinitions();
         this.emulatedFunctions = this.triggers.map((t) => t.id);
@@ -42,7 +41,7 @@ class FunctionsEmulatorShell {
             auth: opts.auth,
             data,
         };
-        this.emu.invokeTrigger(this.backend, trigger, proto);
+        this.emu.invokeTrigger(trigger, proto);
     }
     getTrigger(name) {
         const result = this.triggers.find((trigger) => {

package/lib/emulator/functionsEmulatorUtils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compareVersionStrings = exports.parseVersionString = exports.parseRuntimeVersion = exports.removePathSegments = exports.trimSlashes = exports.isValidWildcardMatch = exports.extractParamsFromPath = void 0;
+exports.isLocalHost = exports.compareVersionStrings = exports.parseVersionString = exports.parseRuntimeVersion = exports.removePathSegments = exports.trimSlashes = exports.isValidWildcardMatch = exports.extractParamsFromPath = void 0;
 const wildcardRegex = new RegExp("{[^/{}]*}");
 const wildcardKeyRegex = new RegExp("^{(.+)}$");
 function extractParamsFromPath(wildcardPath, snapshotPath) {
@@ -85,3 +85,7 @@ function compareVersionStrings(a, b) {
     return 0;
 }
 exports.compareVersionStrings = compareVersionStrings;
+function isLocalHost(href) {
+    return !!href.match(/^(http(s)?:\/\/)?(localhost|127.0.0.1|\[::1])/);
+}
+exports.isLocalHost = isLocalHost;

package/lib/emulator/pubsubEmulator.js

@@ -44,14 +44,7 @@ class PubsubEmulator {
     getName() {
         return types_1.Emulators.PUBSUB;
     }
-    async addTrigger(topicName, triggerKey, signatureType) {
-        this.logger.logLabeled("DEBUG", "pubsub", `addTrigger(${topicName}, ${triggerKey}, ${signatureType})`);
-        const triggers = this.triggersForTopic.get(topicName) || [];
-        if (triggers.some((t) => t.triggerKey === triggerKey) &&
-            this.subscriptionForTopic.has(topicName)) {
-            this.logger.logLabeled("DEBUG", "pubsub", "Trigger already exists");
-            return;
-        }
+    async maybeCreateTopicAndSub(topicName) {
         const topic = this.pubsub.topic(topicName);
         try {
             this.logger.logLabeled("DEBUG", "pubsub", `Creating topic: ${topicName}`);
@@ -74,7 +67,7 @@ class PubsubEmulator {
         catch (e) {
             if (e && e.code === 6) {
                 this.logger.logLabeled("DEBUG", "pubsub", `Sub for ${topicName} exists`);
-                sub = topic.subscription(`emulator-sub-${topicName}`);
+                sub = topic.subscription(subName);
             }
             else {
                 throw new error_1.FirebaseError(`Could not create sub ${subName}`, { original: e });
@@ -83,6 +76,17 @@ class PubsubEmulator {
         sub.on("message", (message) => {
             this.onMessage(topicName, message);
         });
+        return sub;
+    }
+    async addTrigger(topicName, triggerKey, signatureType) {
+        this.logger.logLabeled("DEBUG", "pubsub", `addTrigger(${topicName}, ${triggerKey}, ${signatureType})`);
+        const sub = await this.maybeCreateTopicAndSub(topicName);
+        const triggers = this.triggersForTopic.get(topicName) || [];
+        if (triggers.some((t) => t.triggerKey === triggerKey) &&
+            this.subscriptionForTopic.has(topicName)) {
+            this.logger.logLabeled("DEBUG", "pubsub", "Trigger already exists");
+            return;
+        }
         triggers.push({ triggerKey, signatureType });
         this.triggersForTopic.set(topicName, triggers);
         this.subscriptionForTopic.set(topicName, sub);

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

@@ -118,7 +118,7 @@ function createFirebaseEndpoints(emulator) {
         return res.json(new metadata_1.OutgoingFirebaseMetadata(metadata));
     });
     firebaseStorageAPI.get("/b/:bucketId/o", async (req, res) => {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d;
         const maxResults = (_a = req.query.maxResults) === null || _a === void 0 ? void 0 : _a.toString();
         let listResponse;
         try {
@@ -144,10 +144,12 @@ function createFirebaseEndpoints(emulator) {
         }
         return res.status(200).json({
             nextPageToken: listResponse.nextPageToken,
-            prefixes: (_c = listResponse.prefixes) !== null && _c !== void 0 ? _c : [],
-            items: (_e = (_d = listResponse.items) === null || _d === void 0 ? void 0 : _d.map((item) => {
+            prefixes: ((_c = listResponse.prefixes) !== null && _c !== void 0 ? _c : []).filter(isValidPrefix),
+            items: ((_d = listResponse.items) !== null && _d !== void 0 ? _d : [])
+                .filter((item) => isValidNonEncodedPathString(item.name))
+                .map((item) => {
                 return { name: item.name, bucket: item.bucket };
-            })) !== null && _e !== void 0 ? _e : [],
+            }),
         });
     });
     const handleUpload = async (req, res) => {
@@ -467,3 +469,23 @@ function setObjectHeaders(res, metadata, headerOverride = { "Content-Encoding":
         res.setHeader("Content-Language", metadata.contentLanguage);
     }
 }
+function isValidPrefix(prefix) {
+    return isValidNonEncodedPathString(removeAtMostOneTrailingSlash(prefix));
+}
+function isValidNonEncodedPathString(path) {
+    if (path.startsWith("/")) {
+        path = path.substring(1);
+    }
+    if (!path) {
+        return false;
+    }
+    for (const pathSegment of path.split("/")) {
+        if (!pathSegment) {
+            return false;
+        }
+    }
+    return true;
+}
+function removeAtMostOneTrailingSlash(path) {
+    return path.replace(/\/$/, "");
+}

package/lib/ensureApiEnabled.js

@@ -28,7 +28,7 @@ async function check(projectId, apiName, prefix, silent = false) {
 exports.check = check;
 async function enable(projectId, apiName) {
     try {
-        await apiClient.post(`/projects/${projectId}/services/${apiName}:enable`, {
+        await apiClient.post(`/projects/${projectId}/services/${apiName}:enable`, undefined, {
             skipLog: { resBody: true },
         });
     }

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

@@ -11,6 +11,7 @@ const askUserForParam = require("./askUserForParam");
 const track_1 = require("../track");
 const env = require("../functions/env");
 const utils_1 = require("../utils");
+const warnings_1 = require("./warnings");
 function getBaseParamBindings(params) {
     let ret = {};
     for (const [k, v] of Object.entries(params)) {
@@ -57,6 +58,7 @@ async function getParams(args) {
             paramsMessage);
     }
     else if (args.paramsEnvPath) {
+        (0, warnings_1.paramsFlagDeprecationWarning)();
         params = getParamsFromFile({
             paramSpecs: args.paramSpecs,
             paramsEnvPath: args.paramsEnvPath,

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.displayWarningsForDeploy = exports.displayWarningPrompts = void 0;
+exports.paramsFlagDeprecationWarning = exports.displayWarningsForDeploy = exports.displayWarningPrompts = void 0;
 const { marked } = require("marked");
 const clc = require("cli-color");
 const extensionsApi_1 = require("./extensionsApi");
@@ -11,6 +11,7 @@ const deploymentSummary_1 = require("../deploy/extensions/deploymentSummary");
 const planner_1 = require("../deploy/extensions/planner");
 const functional_1 = require("../functional");
 const utils = require("../utils");
+const logger_1 = require("../logger");
 function displayEAPWarning({ publisherId, sourceDownloadUri, githubLink, }) {
     const publisherNameLink = githubLink ? `[${publisherId}](${githubLink})` : publisherId;
     const warningMsg = `This extension is in preview and is built by a developer in the [Extensions Publisher Early Access Program](http://bit.ly/firex-provider). Its functionality might change in backward-incompatible ways. Since this extension isn't built by Firebase, reach out to ${publisherNameLink} with questions about this extension.`;
@@ -57,14 +58,20 @@ 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;
 }
 exports.displayWarningsForDeploy = displayWarningsForDeploy;
+function paramsFlagDeprecationWarning() {
+    logger_1.logger.warn("The --params flag is deprecated and will be removed in firebase-tools@11. " +
+        "Instead, use an extensions manifest and `firebase deploy --only extensions` to deploy extensions noninteractively. " +
+        "See https://firebase.google.com/docs/extensions/manifest for more details");
+}
+exports.paramsFlagDeprecationWarning = paramsFlagDeprecationWarning;

package/lib/functions/projectConfig.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeAndValidate = exports.validate = exports.normalize = exports.DEFAULT_CODEBASE = void 0;
+exports.configForCodebase = exports.normalizeAndValidate = exports.validate = exports.normalize = exports.DEFAULT_CODEBASE = void 0;
 const error_1 = require("../error");
 exports.DEFAULT_CODEBASE = "default";
 function normalize(config) {
@@ -40,16 +40,21 @@ function assertUnique(config, property) {
     }
 }
 function validate(config) {
-    if (config.length > 1) {
-        throw new error_1.FirebaseError("More than one functions.source detected in firebase.json.");
-    }
-    const validated = validateSingle(config[0]);
-    assertUnique([validated], "source");
-    assertUnique([validated], "codebase");
-    return [validated];
+    const validated = config.map((cfg) => validateSingle(cfg));
+    assertUnique(validated, "source");
+    assertUnique(validated, "codebase");
+    return validated;
 }
 exports.validate = validate;
 function normalizeAndValidate(config) {
     return validate(normalize(config));
 }
 exports.normalizeAndValidate = normalizeAndValidate;
+function configForCodebase(config, codebase) {
+    const codebaseCfg = config.find((c) => c.codebase === codebase);
+    if (!codebaseCfg) {
+        throw new error_1.FirebaseError(`No functions config found for codebase ${codebase}`);
+    }
+    return codebaseCfg;
+}
+exports.configForCodebase = configForCodebase;

package/lib/functionsShellCommandAction.js

@@ -55,7 +55,7 @@ const actionFunction = async (options) => {
     })
         .then(() => {
         const instance = serveFunctions.get();
-        const emulator = new shell.FunctionsEmulatorShell(instance, serveFunctions.getBackend());
+        const emulator = new shell.FunctionsEmulatorShell(instance);
         if (emulator.emulatedFunctions && emulator.emulatedFunctions.length === 0) {
             logger_1.logger.info("No functions emulated.");
             process.exit();

package/lib/gcp/cloudfunctions.js

@@ -145,7 +145,7 @@ async function setInvokerUpdate(projectId, fnName, invoker) {
 exports.setInvokerUpdate = setInvokerUpdate;
 async function updateFunction(cloudFunction) {
     const endpoint = `/${cloudFunction.name}`;
-    const fieldMasks = proto.fieldMasks(cloudFunction, "labels", "environmentVariables");
+    const fieldMasks = proto.fieldMasks(cloudFunction, "labels", "environmentVariables", "secretEnvironmentVariables");
     try {
         const headers = {};
         if (previews_1.previews.artifactregistry) {
@@ -280,6 +280,7 @@ function endpointFromFunction(gcfFunction) {
 }
 exports.endpointFromFunction = endpointFromFunction;
 function functionFromEndpoint(endpoint, sourceUploadUrl) {
+    var _a;
     if (endpoint.platform !== "gcfv1") {
         throw new error_1.FirebaseError("Trying to create a v1 CloudFunction with v2 API. This should never happen");
     }
@@ -334,7 +335,13 @@ function functionFromEndpoint(endpoint, sourceUploadUrl) {
         proto.renameIfPresent(gcfFunction, endpoint.vpc, "vpcConnector", "connector");
         proto.renameIfPresent(gcfFunction, endpoint.vpc, "vpcConnectorEgressSettings", "egressSettings");
     }
-    gcfFunction.labels = Object.assign(Object.assign({}, gcfFunction.labels), { [exports.CODEBASE_LABEL]: endpoint.codebase || projectConfig.DEFAULT_CODEBASE });
+    const codebase = endpoint.codebase || projectConfig.DEFAULT_CODEBASE;
+    if (codebase !== projectConfig.DEFAULT_CODEBASE) {
+        gcfFunction.labels = Object.assign(Object.assign({}, gcfFunction.labels), { [exports.CODEBASE_LABEL]: codebase });
+    }
+    else {
+        (_a = gcfFunction.labels) === null || _a === void 0 ? true : delete _a[exports.CODEBASE_LABEL];
+    }
     return gcfFunction;
 }
 exports.functionFromEndpoint = functionFromEndpoint;