firebase-tools 11.4.2 → 11.7.0

package/lib/emulator/eventarcEmulator.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventarcEmulator = void 0;
+const express = require("express");
+const constants_1 = require("./constants");
+const types_1 = require("./types");
+const utils_1 = require("../utils");
+const emulatorLogger_1 = require("./emulatorLogger");
+const registry_1 = require("./registry");
+const apiv2_1 = require("../apiv2");
+const error_1 = require("../error");
+class EventarcEmulator {
+    constructor(args) {
+        this.args = args;
+        this.logger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.EVENTARC);
+        this.customEvents = {};
+    }
+    createHubServer() {
+        const registerTriggerRoute = `/emulator/v1/projects/:project_id/triggers/:trigger_name(*)`;
+        const registerTriggerHandler = (req, res) => {
+            const projectId = req.params.project_id;
+            const triggerName = req.params.trigger_name;
+            if (!projectId || !triggerName) {
+                const error = "Missing project ID or trigger name.";
+                this.logger.log("ERROR", error);
+                res.status(400).send({ error });
+                return;
+            }
+            const bodyString = req.rawBody.toString();
+            const substituted = bodyString.replaceAll("${PROJECT_ID}", projectId);
+            const body = JSON.parse(substituted);
+            const eventTrigger = body.eventTrigger;
+            if (!eventTrigger) {
+                const error = `Missing event trigger for ${triggerName}.`;
+                this.logger.log("ERROR", error);
+                res.status(400).send({ error });
+                return;
+            }
+            const key = `${eventTrigger.eventType}-${eventTrigger.channel}`;
+            this.logger.logLabeled("BULLET", "eventarc", `Registering custom event trigger for ${key} with trigger name ${triggerName}.`);
+            const customEventTriggers = this.customEvents[key] || [];
+            customEventTriggers.push({ projectId, triggerName, eventTrigger });
+            this.customEvents[key] = customEventTriggers;
+            res.status(200).send({ res: "OK" });
+        };
+        const publishEventsRoute = `/projects/:project_id/locations/:location/channels/:channel::publishEvents`;
+        const publishEventsHandler = (req, res) => {
+            const channel = `projects/${req.params.project_id}/locations/${req.params.location}/channels/${req.params.channel}`;
+            const body = JSON.parse(req.rawBody.toString());
+            for (const event of body.events) {
+                if (!event.type) {
+                    res.sendStatus(400);
+                    return;
+                }
+                this.logger.log("INFO", `Received custom event at channel ${channel}: ${JSON.stringify(event, null, 2)}`);
+                this.triggerCustomEventFunction(channel, event);
+            }
+            res.sendStatus(200);
+        };
+        const dataMiddleware = (req, _, next) => {
+            const chunks = [];
+            req.on("data", (chunk) => {
+                chunks.push(chunk);
+            });
+            req.on("end", () => {
+                req.rawBody = Buffer.concat(chunks);
+                next();
+            });
+        };
+        const hub = express();
+        hub.post([registerTriggerRoute], dataMiddleware, registerTriggerHandler);
+        hub.post([publishEventsRoute], dataMiddleware, publishEventsHandler);
+        hub.all("*", (req, res) => {
+            this.logger.log("DEBUG", `Eventarc emulator received unknown request at path ${req.path}`);
+            res.sendStatus(404);
+        });
+        return hub;
+    }
+    async triggerCustomEventFunction(channel, event) {
+        const functionsEmulator = registry_1.EmulatorRegistry.get(types_1.Emulators.FUNCTIONS);
+        if (!functionsEmulator) {
+            this.logger.log("INFO", "Functions emulator not found. This should not happen.");
+            return Promise.reject();
+        }
+        const key = `${event.type}-${channel}`;
+        const triggers = this.customEvents[key] || [];
+        const apiClient = new apiv2_1.Client({
+            urlPrefix: `http://${registry_1.EmulatorRegistry.getInfoHostString(functionsEmulator.getInfo())}`,
+            auth: false,
+        });
+        return await Promise.all(triggers
+            .filter((trigger) => !trigger.eventTrigger.eventFilters ||
+            this.matchesAll(event, trigger.eventTrigger.eventFilters))
+            .map((trigger) => apiClient
+            .request({
+            method: "POST",
+            path: `/functions/projects/${trigger.projectId}/triggers/${trigger.triggerName}`,
+            body: JSON.stringify(event),
+            responseType: "stream",
+            resolveOnHTTPError: true,
+        })
+            .then((res) => {
+            if (res.status >= 400) {
+                throw new error_1.FirebaseError(`Received non-200 status code: ${res.status}`);
+            }
+        })
+            .catch((err) => {
+            this.logger.log("ERROR", `Failed to trigger Functions emulator for ${trigger.triggerName}: ${err}`);
+        })));
+    }
+    matchesAll(event, eventFilters) {
+        return Object.entries(eventFilters).every(([key, value]) => {
+            var _a, _b;
+            let attr = (_a = event[key]) !== null && _a !== void 0 ? _a : event.attributes[key];
+            if (typeof attr === "object" && !Array.isArray(attr)) {
+                attr = (_b = attr.ceTimestamp) !== null && _b !== void 0 ? _b : attr.ceString;
+            }
+            return attr === value;
+        });
+    }
+    async start() {
+        const { host, port } = this.getInfo();
+        const server = this.createHubServer().listen(port, host);
+        this.destroyServer = (0, utils_1.createDestroyer)(server);
+        return Promise.resolve();
+    }
+    async connect() {
+        return Promise.resolve();
+    }
+    async stop() {
+        if (this.destroyServer) {
+            await this.destroyServer();
+        }
+    }
+    getInfo() {
+        const host = this.args.host || constants_1.Constants.getDefaultHost();
+        const port = this.args.port || constants_1.Constants.getDefaultPort(types_1.Emulators.EVENTARC);
+        return {
+            name: this.getName(),
+            host,
+            port,
+        };
+    }
+    getName() {
+        return types_1.Emulators.EVENTARC;
+    }
+}
+exports.EventarcEmulator = EventarcEmulator;

package/lib/emulator/extensionsEmulator.js

@@ -4,7 +4,7 @@ exports.ExtensionsEmulator = void 0;
 const fs = require("fs-extra");
 const os = require("os");
 const path = require("path");
-const clc = require("cli-color");
+const clc = require("colorette");
 const Table = require("cli-table");
 const spawn = require("cross-spawn");
 const planner = require("../deploy/extensions/planner");
@@ -103,10 +103,11 @@ class ExtensionsEmulator {
         for (const requiredFile of requiredFiles) {
             const f = path.join(args.path, requiredFile);
             if (!fs.existsSync(f)) {
-                emulatorLogger_1.EmulatorLogger.forExtension({ ref: args.extTarget }).logLabeled("BULLET", "extensions", `Detected invalid source code for ${args.extTarget}, expected to find ${f}`);
+                this.logger.logLabeled("BULLET", "extensions", `Detected invalid source code for ${args.extTarget}, expected to find ${f}`);
                 return false;
             }
         }
+        this.logger.logLabeled("DEBUG", "extensions", `Source code valid for ${args.extTarget}`);
         return true;
     }
     installAndBuildSourceCode(sourceCodePath) {
@@ -166,6 +167,7 @@ class ExtensionsEmulator {
             STORAGE_BUCKET: `${projectId}.appspot.com`,
             ALLOWED_EVENT_TYPES: instance.allowedEventTypes ? instance.allowedEventTypes.join(",") : "",
             EVENTARC_CHANNEL: (_a = instance.eventarcChannel) !== null && _a !== void 0 ? _a : "",
+            EVENTARC_CLOUD_EVENT_SOURCE: `projects/${projectId}/instances/${instance.instanceId}`,
         };
     }
     async checkAndWarnAPIs(instances) {
@@ -186,7 +188,7 @@ class ExtensionsEmulator {
                     apiToWarn.apiName,
                     apiToWarn.instanceIds,
                     apiToWarn.enabled ? "Yes" : "No",
-                    apiToWarn.enabled ? "" : clc.bold.underline(enablementUri),
+                    apiToWarn.enabled ? "" : clc.bold(clc.underline(enablementUri)),
                 ]);
             }
             if (constants_1.Constants.isDemoProject(this.args.projectId)) {

package/lib/emulator/firestoreEmulator.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FirestoreEmulator = void 0;
 const chokidar = require("chokidar");
 const fs = require("fs");
-const clc = require("cli-color");
+const clc = require("colorette");
 const path = require("path");
 const utils = require("../utils");
 const downloadableEmulators = require("./downloadableEmulators");

package/lib/emulator/functionsEmulator.js

@@ -4,7 +4,7 @@ exports.FunctionsEmulator = void 0;
 const fs = require("fs");
 const path = require("path");
 const express = require("express");
-const clc = require("cli-color");
+const clc = require("colorette");
 const http = require("http");
 const jwt = require("jsonwebtoken");
 const cors = require("cors");
@@ -35,6 +35,7 @@ const v1_1 = require("../functions/events/v1");
 const apiv2_1 = require("../apiv2");
 const build_1 = require("../deploy/functions/build");
 const EVENT_INVOKE = "functions:invoke";
+const EVENT_INVOKE_GA4 = "functions_invoke";
 const DATABASE_PATH_PATTERN = new RegExp("^projects/[^/]+/instances/([^/]+)/refs(/.*)$");
 class FunctionsEmulator {
     constructor(args) {
@@ -89,7 +90,7 @@ class FunctionsEmulator {
                 next();
             });
         };
-        const backgroundFunctionRoute = `/functions/projects/:project_id/triggers/:trigger_name`;
+        const backgroundFunctionRoute = `/functions/projects/:project_id/triggers/:trigger_name(*)`;
         const httpsFunctionRoute = `/${this.args.projectId}/:region/:trigger_name`;
         const multicastFunctionRoute = `/functions/projects/:project_id/trigger_multicast`;
         const httpsFunctionRoutes = [httpsFunctionRoute, `${httpsFunctionRoute}/*`];
@@ -245,15 +246,9 @@ class FunctionsEmulator {
             await this.destroyServer();
         }
     }
-    async loadTriggers(emulatableBackend, force = false) {
-        this.workerPool.refresh();
-        if (!emulatableBackend.nodeBinary) {
-            throw new error_1.FirebaseError(`No node binary for ${emulatableBackend.functionsDir}. This should never happen.`);
-        }
-        this.blockingFunctionsConfig = {};
-        let triggerDefinitions;
+    async discoverTriggers(emulatableBackend) {
         if (emulatableBackend.predefinedTriggers) {
-            triggerDefinitions = (0, functionsEmulatorShared_1.emulatedFunctionsByRegion)(emulatableBackend.predefinedTriggers, emulatableBackend.secretEnv);
+            return (0, functionsEmulatorShared_1.emulatedFunctionsByRegion)(emulatableBackend.predefinedTriggers, emulatableBackend.secretEnv);
         }
         else {
             const runtimeConfig = this.getRuntimeConfig(emulatableBackend);
@@ -284,8 +279,26 @@ class FunctionsEmulator {
             for (const e of endpoints) {
                 e.codebase = emulatableBackend.codebase;
             }
-            triggerDefinitions = (0, functionsEmulatorShared_1.emulatedFunctionsFromEndpoints)(endpoints);
+            return (0, functionsEmulatorShared_1.emulatedFunctionsFromEndpoints)(endpoints);
         }
+    }
+    async loadTriggers(emulatableBackend, force = false) {
+        if (!emulatableBackend.nodeBinary) {
+            throw new error_1.FirebaseError(`No node binary for ${emulatableBackend.functionsDir}. This should never happen.`);
+        }
+        let triggerDefinitions = [];
+        try {
+            triggerDefinitions = await this.discoverTriggers(emulatableBackend);
+            this.logger.logLabeled("SUCCESS", "functions", `Loaded functions definitions from source: ${triggerDefinitions
+                .map((t) => t.entryPoint)
+                .join(", ")}.`);
+        }
+        catch (e) {
+            this.logger.logLabeled("ERROR", "functions", `Failed to load function definition from source: ${e}`);
+            return;
+        }
+        this.workerPool.refresh();
+        this.blockingFunctionsConfig = {};
         const toSetup = triggerDefinitions.filter((definition) => {
             if (force) {
                 return true;
@@ -305,8 +318,7 @@ class FunctionsEmulator {
                 (0, validate_1.functionIdsAreValid)([Object.assign(Object.assign({}, definition), { id: definition.name })]);
             }
             catch (e) {
-                this.logger.logLabeled("WARN", `functions[${definition.id}]`, `Invalid function id: ${e.message}`);
-                continue;
+                throw new error_1.FirebaseError(`functions[${definition.id}]: Invalid function id: ${e.message}`);
             }
             let added = false;
             let url = undefined;
@@ -329,6 +341,9 @@ class FunctionsEmulator {
                     case constants_1.Constants.SERVICE_PUBSUB:
                         added = await this.addPubsubTrigger(definition.name, key, definition.eventTrigger, signature, definition.schedule);
                         break;
+                    case constants_1.Constants.SERVICE_EVENTARC:
+                        added = await this.addEventarcTrigger(this.args.projectId, key, definition.eventTrigger);
+                        break;
                     case constants_1.Constants.SERVICE_AUTH:
                         added = this.addAuthTrigger(this.args.projectId, key, definition.eventTrigger);
                         break;
@@ -368,6 +383,27 @@ class FunctionsEmulator {
             this.startRuntime(emulatableBackend, { nodeBinary: emulatableBackend.nodeBinary });
         }
     }
+    addEventarcTrigger(projectId, key, eventTrigger) {
+        const eventarcEmu = registry_1.EmulatorRegistry.get(types_1.Emulators.EVENTARC);
+        if (!eventarcEmu) {
+            return Promise.resolve(false);
+        }
+        const bundle = {
+            eventTrigger: Object.assign(Object.assign({}, eventTrigger), { service: "eventarc.googleapis.com" }),
+        };
+        logger_1.logger.debug(`addEventarcTrigger`, JSON.stringify(bundle));
+        const client = new apiv2_1.Client({
+            urlPrefix: `http://${registry_1.EmulatorRegistry.getInfoHostString(eventarcEmu.getInfo())}`,
+            auth: false,
+        });
+        return client
+            .post(`/emulator/v1/projects/${projectId}/triggers/${key}`, bundle)
+            .then(() => true)
+            .catch((err) => {
+            this.logger.log("WARN", "Error adding Eventarc function: " + err);
+            return false;
+        });
+    }
     async performPostLoadOperations() {
         if (!this.blockingFunctionsConfig.triggers &&
             !this.blockingFunctionsConfig.forwardInboundCredentials) {
@@ -544,7 +580,13 @@ class FunctionsEmulator {
         return record;
     }
     getTriggerKey(def) {
-        return def.eventTrigger ? `${def.id}-${this.triggerGeneration}` : def.id;
+        if (def.eventTrigger) {
+            const triggerKey = `${def.id}-${this.triggerGeneration}`;
+            return def.eventTrigger.channel ? `${triggerKey}-${def.eventTrigger.channel}` : triggerKey;
+        }
+        else {
+            return def.id;
+        }
     }
     getBackendInfo() {
         const cf3Triggers = this.getCF3Triggers();
@@ -688,6 +730,10 @@ class FunctionsEmulator {
             const pubsubHost = (0, functionsEmulatorShared_1.formatHost)(pubsubEmulator);
             process.env.PUBSUB_EMULATOR_HOST = pubsubHost;
         }
+        const eventarcEmulator = this.getEmulatorInfo(types_1.Emulators.EVENTARC);
+        if (eventarcEmulator) {
+            envs[constants_1.Constants.CLOUD_EVENTARC_EMULATOR_HOST] = `http://${(0, functionsEmulatorShared_1.formatHost)(eventarcEmulator)}`;
+        }
         if (this.args.debugPort) {
             envs["FUNCTION_DEBUG_MODE"] = "true";
         }
@@ -884,6 +930,9 @@ class FunctionsEmulator {
                 }
             });
             void (0, track_1.track)(EVENT_INVOKE, (0, functionsEmulatorShared_1.getFunctionService)(trigger));
+            void (0, track_1.trackEmulator)(EVENT_INVOKE_GA4, {
+                function_service: (0, functionsEmulatorShared_1.getFunctionService)(trigger),
+            });
             worker.waitForDone().then(() => {
                 resolve({ status: "acknowledged" });
             });
@@ -959,6 +1008,9 @@ class FunctionsEmulator {
         });
         await worker.waitForSocketReady();
         void (0, track_1.track)(EVENT_INVOKE, "https");
+        void (0, track_1.trackEmulator)(EVENT_INVOKE_GA4, {
+            function_service: "https",
+        });
         this.logger.log("DEBUG", `[functions] Runtime ready! Sending request!`);
         const url = new url_1.URL(`${req.protocol}://${req.hostname}${req.url}`);
         const path = `${url.pathname}${url.search}`.replace(new RegExp(`\/${this.args.projectId}\/[^\/]*\/${triggerName}\/?`), "/");

package/lib/emulator/functionsEmulatorRuntime.js

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

package/lib/emulator/functionsEmulatorShared.js

@@ -83,12 +83,14 @@ function emulatedFunctionsFromEndpoints(endpoints) {
             else {
                 const { resource, topic, bucket } = endpoint.eventTrigger.eventFilters;
                 const eventResource = resource || topic || bucket;
-                if (!eventResource) {
+                if (!eventResource && !eventTrigger.channel) {
                     continue;
                 }
                 def.eventTrigger = {
                     eventType: eventTrigger.eventType,
                     resource: eventResource,
+                    channel: eventTrigger.channel,
+                    eventFilters: eventTrigger.eventFilters,
                 };
             }
         }
@@ -151,6 +153,9 @@ exports.getTemporarySocketPath = getTemporarySocketPath;
 function getFunctionService(def) {
     var _a;
     if (def.eventTrigger) {
+        if (def.eventTrigger.channel) {
+            return constants_1.Constants.SERVICE_EVENTARC;
+        }
         return (_a = def.eventTrigger.service) !== null && _a !== void 0 ? _a : getServiceFromEventType(def.eventTrigger.eventType);
     }
     if (def.blockingTrigger) {

package/lib/emulator/hub.js

@@ -32,10 +32,14 @@ class EmulatorHub {
             res.json(body);
         });
         this.hub.post(EmulatorHub.PATH_EXPORT, async (req, res) => {
-            const exportPath = req.body.path;
-            utils.logLabeledBullet("emulators", `Received export request. Exporting data to ${exportPath}.`);
+            const path = req.body.path;
+            const initiatedBy = req.body.initiatedBy || "unknown";
+            utils.logLabeledBullet("emulators", `Received export request. Exporting data to ${path}.`);
             try {
-                await new hubExport_1.HubExport(this.args.projectId, exportPath).exportAll();
+                await new hubExport_1.HubExport(this.args.projectId, {
+                    path,
+                    initiatedBy,
+                }).exportAll();
                 utils.logLabeledSuccess("emulators", "Export complete.");
                 res.status(200).send({
                     message: "OK",

package/lib/emulator/hubClient.js

@@ -21,9 +21,9 @@ class EmulatorHubClient {
         const res = await apiClient.get(hub_1.EmulatorHub.PATH_EMULATORS);
         return res.body;
     }
-    async postExport(path) {
+    async postExport(options) {
         const apiClient = new apiv2_1.Client({ urlPrefix: this.origin, auth: false });
-        await apiClient.post(hub_1.EmulatorHub.PATH_EXPORT, { path });
+        await apiClient.post(hub_1.EmulatorHub.PATH_EXPORT, options);
     }
     get origin() {
         const locator = this.assertLocator();

package/lib/emulator/hubExport.js

@@ -13,10 +13,12 @@ const hub_1 = require("./hub");
 const downloadableEmulators_1 = require("./downloadableEmulators");
 const rimraf = require("rimraf");
 const apiv2_1 = require("../apiv2");
+const track_1 = require("../track");
 class HubExport {
-    constructor(projectId, exportPath) {
+    constructor(projectId, options) {
         this.projectId = projectId;
-        this.exportPath = exportPath;
+        this.options = options;
+        this.exportPath = options.path;
         this.tmpDir = fs.mkdtempSync(`firebase-export-${new Date().getTime()}`);
     }
     static readMetadata(exportPath) {
@@ -66,6 +68,10 @@ class HubExport {
         if (!fs.existsSync(this.exportPath)) {
             fs.mkdirSync(this.exportPath);
         }
+        void (0, track_1.trackEmulator)("emulator_export", {
+            initiated_by: this.options.initiatedBy,
+            emulator_name: types_1.Emulators.HUB,
+        });
         const metadataPath = path.join(this.tmpDir, HubExport.METADATA_FILE_NAME);
         fs.writeFileSync(metadataPath, JSON.stringify(metadata, undefined, 2));
         logger_1.logger.debug(`hubExport: swapping ${this.tmpDir} with ${this.exportPath}`);
@@ -73,6 +79,10 @@ class HubExport {
         fse.moveSync(this.tmpDir, this.exportPath);
     }
     async exportFirestore(metadata) {
+        void (0, track_1.trackEmulator)("emulator_export", {
+            initiated_by: this.options.initiatedBy,
+            emulator_name: types_1.Emulators.FIRESTORE,
+        });
         const firestoreInfo = registry_1.EmulatorRegistry.get(types_1.Emulators.FIRESTORE).getInfo();
         const firestoreHost = `http://${registry_1.EmulatorRegistry.getInfoHostString(firestoreInfo)}`;
         const firestoreExportBody = {
@@ -115,6 +125,11 @@ class HubExport {
                 namespacesToExport.push(ns);
             }
         }
+        void (0, track_1.trackEmulator)("emulator_export", {
+            initiated_by: this.options.initiatedBy,
+            emulator_name: types_1.Emulators.DATABASE,
+            count: namespacesToExport.length,
+        });
         const dbExportPath = path.join(this.tmpDir, metadata.database.path);
         if (!fs.existsSync(dbExportPath)) {
             fs.mkdirSync(dbExportPath);
@@ -132,6 +147,10 @@ class HubExport {
         }
     }
     async exportAuth(metadata) {
+        void (0, track_1.trackEmulator)("emulator_export", {
+            initiated_by: this.options.initiatedBy,
+            emulator_name: types_1.Emulators.AUTH,
+        });
         const { host, port } = registry_1.EmulatorRegistry.get(types_1.Emulators.AUTH).getInfo();
         const authExportPath = path.join(this.tmpDir, metadata.auth.path);
         if (!fs.existsSync(authExportPath)) {
@@ -164,6 +183,7 @@ class HubExport {
         const storageHost = `http://${registry_1.EmulatorRegistry.getInfoHostString(storageEmulator.getInfo())}`;
         const storageExportBody = {
             path: storageExportPath,
+            initiatedBy: this.options.initiatedBy,
         };
         const client = new apiv2_1.Client({ urlPrefix: storageHost, auth: false });
         const res = await client.request({

package/lib/emulator/loggingEmulator.js

@@ -7,7 +7,7 @@ const triple_beam_1 = require("triple-beam");
 const WebSocket = require("ws");
 const TransportStream = require("winston-transport");
 const logger_1 = require("../logger");
-const ansiStrip = require("cli-color/strip");
+const stripAnsi = require("strip-ansi");
 class LoggingEmulator {
     constructor(args) {
         this.args = args;
@@ -106,7 +106,7 @@ class WebSocketTransport extends TransportStream {
         if (bundle.data && bundle.data.metadata && bundle.data.metadata.message) {
             bundle.message = bundle.data.metadata.message;
         }
-        bundle.message = ansiStrip(bundle.message);
+        bundle.message = stripAnsi(bundle.message);
         this.history.push(bundle);
         this.connections.forEach((ws) => {
             ws.send(JSON.stringify(bundle));

package/lib/emulator/registry.js

@@ -39,6 +39,7 @@ class EmulatorRegistry {
             pubsub: 3.2,
             auth: 3.3,
             storage: 3.5,
+            eventarc: 3.6,
             hub: 4,
             logging: 5,
         };

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

@@ -121,10 +121,22 @@ function createFirebaseEndpoints(emulator) {
         var _a, _b, _c, _d;
         const maxResults = (_a = req.query.maxResults) === null || _a === void 0 ? void 0 : _a.toString();
         let listResponse;
+        let prefix = "";
+        if (req.query.prefix) {
+            prefix = req.query.prefix.toString();
+            if (prefix.charAt(prefix.length - 1) !== "/") {
+                return res.status(400).json({
+                    error: {
+                        code: 400,
+                        message: "The prefix parameter is required to be empty or ends with a single / character.",
+                    },
+                });
+            }
+        }
         try {
             listResponse = await storageLayer.listObjects({
                 bucketId: req.params.bucketId,
-                prefix: req.query.prefix ? req.query.prefix.toString() : "",
+                prefix: prefix,
                 delimiter: req.query.delimiter ? req.query.delimiter.toString() : "",
                 pageToken: (_b = req.query.pageToken) === null || _b === void 0 ? void 0 : _b.toString(),
                 maxResults: maxResults ? +maxResults : undefined,
@@ -153,14 +165,17 @@ function createFirebaseEndpoints(emulator) {
         });
     });
     const handleUpload = async (req, res) => {
-        if (!req.query.name) {
-            res.sendStatus(400);
-            return;
-        }
+        var _a;
         const bucketId = req.params.bucketId;
-        const objectId = req.query.name.toString();
+        const objectId = req.params.objectId
+            ? decodeURIComponent(req.params.objectId)
+            : ((_a = req.query.name) === null || _a === void 0 ? void 0 : _a.toString()) || null;
         const uploadType = req.header("x-goog-upload-protocol");
         if (uploadType === "multipart") {
+            if (!objectId) {
+                res.sendStatus(400);
+                return;
+            }
             const contentTypeHeader = req.header("content-type");
             if (!contentTypeHeader) {
                 return res.sendStatus(400);
@@ -172,12 +187,7 @@ function createFirebaseEndpoints(emulator) {
             }
             catch (err) {
                 if (err instanceof Error) {
-                    return res.status(400).json({
-                        error: {
-                            code: 400,
-                            message: err.message,
-                        },
-                    });
+                    return res.status(400).send(err.message);
                 }
                 throw err;
             }
@@ -212,6 +222,10 @@ function createFirebaseEndpoints(emulator) {
             return;
         }
         if (uploadCommand === "start") {
+            if (!objectId) {
+                res.sendStatus(400);
+                return;
+            }
             const upload = uploadService.startResumableUpload({
                 bucketId,
                 objectId,