firebase-tools 9.18.0 → 9.22.0

package/lib/emulator/functionsEmulator.js

@@ -8,6 +8,7 @@ const express = require("express");
 const clc = require("cli-color");
 const http = require("http");
 const jwt = require("jsonwebtoken");
+const url_1 = require("url");
 const api = require("../api");
 const logger_1 = require("../logger");
 const track = require("../track");
@@ -26,6 +27,8 @@ const workQueue_1 = require("./workQueue");
 const utils_1 = require("../utils");
 const defaultCredentials_1 = require("../defaultCredentials");
 const adminSdkConfig_1 = require("./adminSdkConfig");
+const functionsEnv = require("../functions/env");
+const types_2 = require("./events/types");
 const EVENT_INVOKE = "functions:invoke";
 const DATABASE_PATH_PATTERN = new RegExp("^projects/[^/]+/instances/([^/]+)/refs(/.*)$");
 class FunctionsEmulator {
@@ -88,11 +91,18 @@ class FunctionsEmulator {
         const multicastFunctionRoute = `/functions/projects/:project_id/trigger_multicast`;
         const httpsFunctionRoutes = [httpsFunctionRoute, `${httpsFunctionRoute}/*`];
         const backgroundHandler = (req, res) => {
+            var _a;
             const region = req.params.region;
             const triggerId = req.params.trigger_name;
             const projectId = req.params.project_id;
             const reqBody = req.rawBody;
-            const proto = JSON.parse(reqBody.toString());
+            let proto = JSON.parse(reqBody.toString());
+            if ((_a = req.headers["content-type"]) === null || _a === void 0 ? void 0 : _a.includes("cloudevent")) {
+                if (types_2.EventUtils.isBinaryCloudEvent(req)) {
+                    proto = types_2.EventUtils.extractBinaryCloudEventContext(req);
+                    proto.data = req.body;
+                }
+            }
             this.workQueue.submit(() => {
                 this.logger.log("DEBUG", `Accepted request ${req.method} ${req.url} --> ${triggerId}`);
                 return this.handleBackgroundTrigger(projectId, triggerId, proto)
@@ -113,10 +123,22 @@ class FunctionsEmulator {
             });
         };
         const multicastHandler = (req, res) => {
-            const reqBody = req.rawBody;
-            const proto = JSON.parse(reqBody.toString());
-            const triggers = this.multicastTriggers[`${this.args.projectId}:${proto.eventType}`] || [];
+            var _a;
             const projectId = req.params.project_id;
+            const reqBody = req.rawBody;
+            let proto = JSON.parse(reqBody.toString());
+            let triggerKey;
+            if ((_a = req.headers["content-type"]) === null || _a === void 0 ? void 0 : _a.includes("cloudevent")) {
+                triggerKey = `${this.args.projectId}:${proto.type}`;
+                if (types_2.EventUtils.isBinaryCloudEvent(req)) {
+                    proto = types_2.EventUtils.extractBinaryCloudEventContext(req);
+                    proto.data = req.body;
+                }
+            }
+            else {
+                triggerKey = `${this.args.projectId}:${proto.eventType}`;
+            }
+            const triggers = this.multicastTriggers[triggerKey] || [];
             triggers.forEach((triggerId) => {
                 this.workQueue.submit(() => {
                     this.logger.log("DEBUG", `Accepted multicast request ${req.method} ${req.url} --> ${triggerId}`);
@@ -134,7 +156,7 @@ class FunctionsEmulator {
         });
         return hub;
     }
-    startFunctionRuntime(triggerId, targetName, triggerType, proto, runtimeOpts) {
+    startFunctionRuntime(triggerId, targetName, signatureType, proto, runtimeOpts) {
         const bundleTemplate = this.getBaseBundle();
         const runtimeBundle = Object.assign(Object.assign({}, bundleTemplate), { emulators: {
                 firestore: this.getEmulatorInfo(types_1.Emulators.FIRESTORE),
@@ -144,14 +166,12 @@ class FunctionsEmulator {
                 storage: this.getEmulatorInfo(types_1.Emulators.STORAGE),
             }, nodeMajorVersion: this.args.nodeMajorVersion, proto,
             triggerId,
-            targetName,
-            triggerType });
+            targetName });
         const opts = runtimeOpts || {
             nodeBinary: this.nodeBinary,
-            env: this.args.env,
             extensionTriggers: this.args.predefinedTriggers,
         };
-        const worker = this.invokeRuntime(runtimeBundle, opts);
+        const worker = this.invokeRuntime(runtimeBundle, opts, this.getRuntimeEnvs({ targetName, signatureType }));
         return worker;
     }
     async start() {
@@ -206,9 +226,8 @@ class FunctionsEmulator {
         this.workerPool.refresh();
         const worker = this.invokeRuntime(this.getBaseBundle(), {
             nodeBinary: this.nodeBinary,
-            env: this.args.env,
             extensionTriggers: this.args.predefinedTriggers,
-        });
+        }, Object.assign(Object.assign(Object.assign(Object.assign({}, this.getSystemEnvs()), this.getEmulatorEnvs()), { FIREBASE_CONFIG: this.getFirebaseConfig() }), this.args.env));
         const triggerParseEvent = await types_1.EmulatorLog.waitForLog(worker.runtime.events, "SYSTEM", "triggers-parsed");
         const parsedDefinitions = triggerParseEvent.data
             .triggerDefinitions;
@@ -238,6 +257,7 @@ class FunctionsEmulator {
             else if (definition.eventTrigger) {
                 const service = functionsEmulatorShared_1.getFunctionService(definition);
                 const key = this.getTriggerKey(definition);
+                const signature = functionsEmulatorShared_1.getSignatureType(definition);
                 switch (service) {
                     case constants_1.Constants.SERVICE_FIRESTORE:
                         added = await this.addFirestoreTrigger(this.args.projectId, key, definition.eventTrigger);
@@ -246,7 +266,7 @@ class FunctionsEmulator {
                         added = await this.addRealtimeDatabaseTrigger(this.args.projectId, key, definition.eventTrigger);
                         break;
                     case constants_1.Constants.SERVICE_PUBSUB:
-                        added = await this.addPubsubTrigger(definition.name, key, definition.eventTrigger, definition.schedule);
+                        added = await this.addPubsubTrigger(definition.name, key, definition.eventTrigger, signature, definition.schedule);
                         break;
                     case constants_1.Constants.SERVICE_AUTH:
                         added = this.addAuthTrigger(this.args.projectId, key, definition.eventTrigger);
@@ -342,7 +362,7 @@ class FunctionsEmulator {
             throw err;
         });
     }
-    async addPubsubTrigger(triggerName, key, eventTrigger, schedule) {
+    async addPubsubTrigger(triggerName, key, eventTrigger, signatureType, schedule) {
         const pubsubPort = registry_1.EmulatorRegistry.getPort(types_1.Emulators.PUBSUB);
         if (!pubsubPort) {
             return false;
@@ -359,7 +379,7 @@ class FunctionsEmulator {
             topic = resourceParts[resourceParts.length - 1];
         }
         try {
-            await pubsubEmulator.addTrigger(topic, key);
+            await pubsubEmulator.addTrigger(topic, key, signatureType);
             return true;
         }
         catch (e) {
@@ -424,7 +444,6 @@ class FunctionsEmulator {
             projectId: this.args.projectId,
             triggerId: "",
             targetName: "",
-            triggerType: undefined,
             emulators: {
                 firestore: registry_1.EmulatorRegistry.getInfo(types_1.Emulators.FIRESTORE),
                 database: registry_1.EmulatorRegistry.getInfo(types_1.Emulators.DATABASE),
@@ -473,7 +492,87 @@ class FunctionsEmulator {
         this.logger.log("WARN", `Your requested "node" version "${requestedMajorVersion}" doesn't match your global version "${hostMajorVersion}"`);
         return process.execPath;
     }
-    invokeRuntime(frb, opts) {
+    getUserEnvs() {
+        const projectInfo = {
+            functionsSource: this.args.functionsDir,
+            projectId: this.args.projectId,
+            isEmulator: true,
+        };
+        if (functionsEnv.hasUserEnvs(projectInfo)) {
+            try {
+                return functionsEnv.loadUserEnvs(projectInfo);
+            }
+            catch (e) {
+                logger_1.logger.debug("Failed to load local environment variables", e);
+            }
+        }
+        return {};
+    }
+    getSystemEnvs(triggerDef) {
+        const envs = {};
+        envs.GCLOUD_PROJECT = this.args.projectId;
+        envs.K_REVISION = "1";
+        envs.PORT = "80";
+        if (triggerDef) {
+            const service = triggerDef.targetName;
+            const target = service.replace(/-/g, ".");
+            envs.FUNCTION_TARGET = target;
+            envs.FUNCTION_SIGNATURE_TYPE = triggerDef.signatureType;
+            envs.K_SERVICE = service;
+        }
+        return envs;
+    }
+    getEmulatorEnvs() {
+        const envs = {};
+        envs.FUNCTIONS_EMULATOR = "true";
+        envs.TZ = "UTC";
+        envs.FIREBASE_DEBUG_MODE = "true";
+        envs.FIREBASE_DEBUG_FEATURES = JSON.stringify({ skipTokenVerification: true });
+        const firestoreEmulator = this.getEmulatorInfo(types_1.Emulators.FIRESTORE);
+        if (firestoreEmulator != null) {
+            envs[constants_1.Constants.FIRESTORE_EMULATOR_HOST] = functionsEmulatorShared_1.formatHost(firestoreEmulator);
+        }
+        const databaseEmulator = this.getEmulatorInfo(types_1.Emulators.DATABASE);
+        if (databaseEmulator) {
+            envs[constants_1.Constants.FIREBASE_DATABASE_EMULATOR_HOST] = functionsEmulatorShared_1.formatHost(databaseEmulator);
+        }
+        const authEmulator = this.getEmulatorInfo(types_1.Emulators.AUTH);
+        if (authEmulator) {
+            envs[constants_1.Constants.FIREBASE_AUTH_EMULATOR_HOST] = functionsEmulatorShared_1.formatHost(authEmulator);
+        }
+        const storageEmulator = this.getEmulatorInfo(types_1.Emulators.STORAGE);
+        if (storageEmulator) {
+            envs[constants_1.Constants.FIREBASE_STORAGE_EMULATOR_HOST] = functionsEmulatorShared_1.formatHost(storageEmulator);
+            envs[constants_1.Constants.CLOUD_STORAGE_EMULATOR_HOST] = `http://${functionsEmulatorShared_1.formatHost(storageEmulator)}`;
+        }
+        const pubsubEmulator = this.getEmulatorInfo(types_1.Emulators.PUBSUB);
+        if (pubsubEmulator) {
+            const pubsubHost = functionsEmulatorShared_1.formatHost(pubsubEmulator);
+            process.env.PUBSUB_EMULATOR_HOST = pubsubHost;
+        }
+        return envs;
+    }
+    getFirebaseConfig() {
+        const databaseEmulator = this.getEmulatorInfo(types_1.Emulators.DATABASE);
+        let emulatedDatabaseURL = undefined;
+        if (databaseEmulator) {
+            let ns = this.args.projectId;
+            if (this.adminSdkConfig.databaseURL) {
+                const asUrl = new url_1.URL(this.adminSdkConfig.databaseURL);
+                ns = asUrl.hostname.split(".")[0];
+            }
+            emulatedDatabaseURL = `http://${functionsEmulatorShared_1.formatHost(databaseEmulator)}/?ns=${ns}`;
+        }
+        return JSON.stringify({
+            storageBucket: this.adminSdkConfig.storageBucket,
+            databaseURL: emulatedDatabaseURL || this.adminSdkConfig.databaseURL,
+            projectId: this.args.projectId,
+        });
+    }
+    getRuntimeEnvs(triggerDef) {
+        return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, this.getUserEnvs()), this.getSystemEnvs(triggerDef)), this.getEmulatorEnvs()), { FIREBASE_CONFIG: this.getFirebaseConfig() }), this.args.env);
+    }
+    invokeRuntime(frb, opts, runtimeEnv) {
         if (this.workerPool.readyForWork(frb.triggerId)) {
             return this.workerPool.submitWork(frb.triggerId, frb, opts);
         }
@@ -499,7 +598,7 @@ class FunctionsEmulator {
                 "See https://yarnpkg.com/getting-started/migration#step-by-step for more information.");
         }
         const childProcess = spawn(opts.nodeBinary, args, {
-            env: Object.assign(Object.assign({ node: opts.nodeBinary }, opts.env), process.env),
+            env: Object.assign(Object.assign({ node: opts.nodeBinary }, process.env), (runtimeEnv !== null && runtimeEnv !== void 0 ? runtimeEnv : {})),
             cwd: frb.cwd,
             stdio: ["pipe", "pipe", "pipe", "ipc"],
         });
@@ -559,7 +658,7 @@ class FunctionsEmulator {
         }
         const trigger = this.getTriggerDefinitionByKey(triggerKey);
         const service = functionsEmulatorShared_1.getFunctionService(trigger);
-        const worker = this.startFunctionRuntime(trigger.id, trigger.name, functionsEmulatorShared_1.EmulatedTriggerType.BACKGROUND, proto);
+        const worker = this.startFunctionRuntime(trigger.id, trigger.name, functionsEmulatorShared_1.getSignatureType(trigger), proto);
         return new Promise((resolve, reject) => {
             if (projectId !== this.args.projectId) {
                 if (service !== constants_1.Constants.SERVICE_REALTIME_DATABASE) {
@@ -633,7 +732,7 @@ class FunctionsEmulator {
         const reqBody = req.rawBody;
         const isCallable = trigger.labels && trigger.labels["deployment-callable"] === "true";
         const authHeader = req.header("Authorization");
-        if (authHeader && isCallable) {
+        if (authHeader && isCallable && trigger.platform !== "gcfv2") {
             const token = this.tokenFromAuthHeader(authHeader);
             if (token) {
                 const contextAuth = {
@@ -645,7 +744,7 @@ class FunctionsEmulator {
                 req.headers[functionsEmulatorShared_1.HttpConstants.CALLABLE_AUTH_HEADER] = encodeURIComponent(JSON.stringify(contextAuth));
             }
         }
-        const worker = this.startFunctionRuntime(trigger.id, trigger.name, functionsEmulatorShared_1.EmulatedTriggerType.HTTPS, undefined);
+        const worker = this.startFunctionRuntime(trigger.id, trigger.name, "http", undefined);
         worker.onLogs((el) => {
             if (el.level === "FATAL") {
                 res.status(500).send(el.text);
@@ -660,7 +759,7 @@ class FunctionsEmulator {
         if (!worker.lastArgs.frb.socketPath) {
             throw new error_1.FirebaseError(`Cannot execute on a worker without a socketPath: ${JSON.stringify(worker.lastArgs)}`);
         }
-        const url = new URL(`${req.protocol}://${req.hostname}${req.url}`);
+        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}\/?`), "/");
         this.logger.log("DEBUG", `[functions] Got req.url=${req.url}, mapping to path=${path}`);
         const runtimeReq = http.request({

package/lib/emulator/functionsEmulatorRuntime.js

@@ -1,15 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const functionsEnv = require("../functions/env");
-const error_1 = require("../error");
 const types_1 = require("./types");
 const functionsEmulatorShared_1 = require("./functionsEmulatorShared");
-const constants_1 = require("./constants");
 const functionsEmulatorUtils_1 = require("./functionsEmulatorUtils");
 const express = require("express");
 const path = require("path");
 const bodyParser = require("body-parser");
-const fs = require("fs");
 const url_1 = require("url");
 const _ = require("lodash");
 let triggers;
@@ -263,13 +259,35 @@ async function initializeFirebaseFunctionsStubs(frb) {
     };
     const onCallInnerMethodName = "_onCallWithOptions";
     const onCallMethodOriginal = httpsProvider[onCallInnerMethodName];
-    httpsProvider[onCallInnerMethodName] = (handler, opts) => {
-        const wrapped = wrapCallableHandler(handler);
-        const cf = onCallMethodOriginal(wrapped, opts);
-        return cf;
-    };
-    httpsProvider.onCall = (handler) => {
-        return httpsProvider[onCallInnerMethodName](handler, {});
+    if (onCallMethodOriginal.length === 3) {
+        httpsProvider[onCallInnerMethodName] = (opts, handler, deployOpts) => {
+            const wrapped = wrapCallableHandler(handler);
+            const cf = onCallMethodOriginal(opts, wrapped, deployOpts);
+            return cf;
+        };
+    }
+    else {
+        httpsProvider[onCallInnerMethodName] = (handler, opts) => {
+            const wrapped = wrapCallableHandler(handler);
+            const cf = onCallMethodOriginal(wrapped, opts);
+            return cf;
+        };
+    }
+    httpsProvider.onCall = function (optsOrHandler, handler) {
+        if (onCallMethodOriginal.length === 3) {
+            let opts;
+            if (arguments.length === 1) {
+                opts = {};
+                handler = optsOrHandler;
+            }
+            else {
+                opts = optsOrHandler;
+            }
+            return httpsProvider[onCallInnerMethodName](opts, handler, {});
+        }
+        else {
+            return httpsProvider[onCallInnerMethodName](optsOrHandler, {});
+        }
     };
 }
 function wrapCallableHandler(handler) {
@@ -393,108 +411,6 @@ function warnAboutAuthProd(frb) {
     }
     new types_1.EmulatorLog("WARN_ONCE", "runtime-status", "The Firebase Authentication emulator is not running, so calls to Firebase Authentication will affect production.").log();
 }
-async function initializeEnvironmentalVariables(frb) {
-    var _a;
-    process.env.TZ = "UTC";
-    process.env.GCLOUD_PROJECT = frb.projectId;
-    process.env.FUNCTIONS_EMULATOR = "true";
-    if (functionsEnv.hasUserEnvs({ functionsSource: frb.cwd, projectId: "local" })) {
-        try {
-            const userEnvs = functionsEnv.loadUserEnvs({ functionsSource: frb.cwd, projectId: "local" });
-            for (const [k, v] of Object.entries(userEnvs)) {
-                process.env[k] = v;
-            }
-        }
-        catch (e) {
-            let message = e.message || `${e}`;
-            if (e instanceof error_1.FirebaseError) {
-                for (const child of e.children) {
-                    if (child instanceof Error) {
-                        message += `\n- ${child.message}`;
-                    }
-                }
-            }
-            new types_1.EmulatorLog("SYSTEM", "function-env-load-failed", message).log();
-        }
-    }
-    const configPath = `${frb.cwd}/.runtimeconfig.json`;
-    try {
-        const configContent = fs.readFileSync(configPath, "utf8");
-        if (configContent) {
-            try {
-                JSON.parse(configContent.toString());
-                logDebug(`Found local functions config: ${configPath}`);
-                process.env.CLOUD_RUNTIME_CONFIG = configContent.toString();
-            }
-            catch (e) {
-                new types_1.EmulatorLog("SYSTEM", "function-runtimeconfig-json-invalid", "").log();
-            }
-        }
-    }
-    catch (e) {
-    }
-    const functionsResolution = await assertResolveDeveloperNodeModule(frb, "firebase-functions");
-    const functionsGt380 = functionsEmulatorUtils_1.compareVersionStrings(functionsResolution.version, "3.8.0") >= 0;
-    let emulatedDatabaseURL = undefined;
-    if (frb.emulators.database && functionsGt380) {
-        let ns = frb.projectId;
-        if (frb.adminSdkConfig.databaseURL) {
-            const asUrl = new url_1.URL(frb.adminSdkConfig.databaseURL);
-            ns = asUrl.hostname.split(".")[0];
-        }
-        emulatedDatabaseURL = `http://${formatHost(frb.emulators.database)}/?ns=${ns}`;
-    }
-    process.env.FIREBASE_CONFIG = JSON.stringify({
-        storageBucket: frb.adminSdkConfig.storageBucket,
-        databaseURL: emulatedDatabaseURL || frb.adminSdkConfig.databaseURL,
-        projectId: frb.projectId,
-    });
-    if (frb.triggerId) {
-        const service = frb.targetName || "";
-        const target = service.replace(/-/g, ".");
-        const mode = frb.triggerType === functionsEmulatorShared_1.EmulatedTriggerType.BACKGROUND ? "event" : "http";
-        let nodeVersion = 0;
-        if (frb.nodeMajorVersion) {
-            nodeVersion = frb.nodeMajorVersion;
-        }
-        else {
-            const pkg = requirePackageJson(frb);
-            if ((_a = pkg === null || pkg === void 0 ? void 0 : pkg.engines) === null || _a === void 0 ? void 0 : _a.node) {
-                const nodeSemVer = functionsEmulatorUtils_1.parseVersionString(pkg.engines.node);
-                nodeVersion = nodeSemVer.major;
-            }
-        }
-        if (nodeVersion >= 10) {
-            setNode10EnvVars(target, mode, service);
-        }
-    }
-    if (frb.emulators.firestore) {
-        process.env[constants_1.Constants.FIRESTORE_EMULATOR_HOST] = formatHost(frb.emulators.firestore);
-    }
-    if (frb.emulators.database) {
-        process.env[constants_1.Constants.FIREBASE_DATABASE_EMULATOR_HOST] = formatHost(frb.emulators.database);
-    }
-    if (frb.emulators.auth) {
-        process.env[constants_1.Constants.FIREBASE_AUTH_EMULATOR_HOST] = formatHost(frb.emulators.auth);
-    }
-    if (frb.emulators.storage) {
-        process.env[constants_1.Constants.FIREBASE_STORAGE_EMULATOR_HOST] = formatHost(frb.emulators.storage);
-        process.env[constants_1.Constants.CLOUD_STORAGE_EMULATOR_HOST] = `http://${formatHost(frb.emulators.storage)}`;
-    }
-    if (frb.emulators.pubsub) {
-        const pubsubHost = formatHost(frb.emulators.pubsub);
-        process.env.PUBSUB_EMULATOR_HOST = pubsubHost;
-        logDebug(`Set PUBSUB_EMULATOR_HOST to ${pubsubHost}`);
-    }
-}
-function formatHost(info) {
-    if (info.host.includes(":")) {
-        return `[${info.host}]:${info.port}`;
-    }
-    else {
-        return `${info.host}:${info.port}`;
-    }
-}
 async function initializeFunctionsConfigHelper(frb) {
     const functionsResolution = await assertResolveDeveloperNodeModule(frb, "firebase-functions");
     const localFunctionsModule = require(functionsResolution.resolution);
@@ -594,9 +510,12 @@ async function processHTTPS(frb, trigger) {
         instance.on("error", rejectEphemeralServer);
     });
 }
-async function processBackground(frb, trigger) {
+async function processBackground(frb, trigger, signature) {
     const proto = frb.proto;
     logDebug("ProcessBackground", proto);
+    if (signature === "cloudevent") {
+        return runCloudEvent(proto, trigger.getRawFunction());
+    }
     const data = proto.data;
     delete proto.data;
     const context = proto.context ? proto.context : proto;
@@ -627,6 +546,12 @@ async function runBackground(proto, func) {
         return func(proto.data, proto.context);
     });
 }
+async function runCloudEvent(event, func) {
+    logDebug("RunCloudEvent", event);
+    await runFunction(() => {
+        return func(event);
+    });
+}
 async function runHTTPS(args, func) {
     if (args.length < 2) {
         throw new Error("Function must be passed 2 args.");
@@ -665,8 +590,8 @@ async function invokeTrigger(frb, triggers) {
     }).log();
     const trigger = triggers[frb.triggerId];
     logDebug("triggerDefinition", trigger.definition);
-    const mode = trigger.definition.httpsTrigger ? "HTTPS" : "BACKGROUND";
-    logDebug(`Running ${frb.triggerId} in mode ${mode}`);
+    const signature = functionsEmulatorShared_1.getSignatureType(trigger.definition);
+    logDebug(`Running ${frb.triggerId} in signature ${signature}`);
     let seconds = 0;
     const timerId = setInterval(() => {
         seconds++;
@@ -679,11 +604,12 @@ async function invokeTrigger(frb, triggers) {
             throw new Error("Function timed out.");
         }, trigger.timeoutMs);
     }
-    switch (mode) {
-        case "BACKGROUND":
-            await processBackground(frb, triggers[frb.triggerId]);
+    switch (signature) {
+        case "event":
+        case "cloudevent":
+            await processBackground(frb, triggers[frb.triggerId], signature);
             break;
-        case "HTTPS":
+        case "http":
             await processHTTPS(frb, triggers[frb.triggerId]);
             break;
     }
@@ -700,7 +626,6 @@ async function initializeRuntime(frb, serializedFunctionTrigger, extensionTrigge
         new types_1.EmulatorLog("INFO", "runtime-status", `Your functions could not be parsed due to an issue with your node_modules (see above)`).log();
         return;
     }
-    await initializeEnvironmentalVariables(frb);
     initializeNetworkFiltering(frb);
     await initializeFunctionsConfigHelper(frb);
     await initializeFirebaseFunctionsStubs(frb);

package/lib/emulator/functionsEmulatorShared.js

@@ -1,15 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findModuleRoot = exports.waitForBody = exports.getFunctionService = exports.getTemporarySocketPath = exports.getEmulatedTriggersFromDefinitions = exports.emulatedFunctionsByRegion = exports.EmulatedTrigger = exports.HttpConstants = exports.EmulatedTriggerType = void 0;
+exports.getSignatureType = exports.formatHost = exports.findModuleRoot = exports.waitForBody = exports.getServiceFromEventType = exports.getFunctionService = exports.getTemporarySocketPath = exports.getEmulatedTriggersFromDefinitions = exports.emulatedFunctionsByRegion = exports.EmulatedTrigger = exports.HttpConstants = void 0;
 const _ = require("lodash");
 const os = require("os");
 const path = require("path");
 const fs = require("fs");
-var EmulatedTriggerType;
-(function (EmulatedTriggerType) {
-    EmulatedTriggerType["BACKGROUND"] = "BACKGROUND";
-    EmulatedTriggerType["HTTPS"] = "HTTPS";
-})(EmulatedTriggerType = exports.EmulatedTriggerType || (exports.EmulatedTriggerType = {}));
+const constants_1 = require("./constants");
 const memoryLookup = {
     "128MB": 128,
     "256MB": 256,
@@ -82,12 +78,44 @@ function getTemporarySocketPath(pid, cwd) {
 }
 exports.getTemporarySocketPath = getTemporarySocketPath;
 function getFunctionService(def) {
+    var _a;
     if (def.eventTrigger) {
-        return def.eventTrigger.service;
+        return (_a = def.eventTrigger.service) !== null && _a !== void 0 ? _a : getServiceFromEventType(def.eventTrigger.eventType);
     }
     return "unknown";
 }
 exports.getFunctionService = getFunctionService;
+function getServiceFromEventType(eventType) {
+    if (eventType.includes("firestore")) {
+        return constants_1.Constants.SERVICE_FIRESTORE;
+    }
+    if (eventType.includes("database")) {
+        return constants_1.Constants.SERVICE_REALTIME_DATABASE;
+    }
+    if (eventType.includes("pubsub")) {
+        return constants_1.Constants.SERVICE_PUBSUB;
+    }
+    if (eventType.includes("storage")) {
+        return constants_1.Constants.SERVICE_STORAGE;
+    }
+    if (eventType.includes("analytics")) {
+        return constants_1.Constants.SERVICE_ANALYTICS;
+    }
+    if (eventType.includes("auth")) {
+        return constants_1.Constants.SERVICE_AUTH;
+    }
+    if (eventType.includes("crashlytics")) {
+        return constants_1.Constants.SERVICE_CRASHLYTICS;
+    }
+    if (eventType.includes("remoteconfig")) {
+        return constants_1.Constants.SERVICE_REMOTE_CONFIG;
+    }
+    if (eventType.includes("testing")) {
+        return constants_1.Constants.SERVICE_TEST_LAB;
+    }
+    return "";
+}
+exports.getServiceFromEventType = getServiceFromEventType;
 function waitForBody(req) {
     let data = "";
     return new Promise((resolve) => {
@@ -124,3 +152,19 @@ function findModuleRoot(moduleName, filepath) {
     return "";
 }
 exports.findModuleRoot = findModuleRoot;
+function formatHost(info) {
+    if (info.host.includes(":")) {
+        return `[${info.host}]:${info.port}`;
+    }
+    else {
+        return `${info.host}:${info.port}`;
+    }
+}
+exports.formatHost = formatHost;
+function getSignatureType(def) {
+    if (def.httpsTrigger) {
+        return "http";
+    }
+    return def.platform === "gcfv2" ? "cloudevent" : "event";
+}
+exports.getSignatureType = getSignatureType;

package/lib/emulator/functionsEmulatorShell.js

@@ -42,7 +42,7 @@ class FunctionsEmulatorShell {
             auth: opts.auth,
             data,
         };
-        this.emu.startFunctionRuntime(trigger.id, trigger.name, functionsEmulatorShared_1.EmulatedTriggerType.BACKGROUND, proto);
+        this.emu.startFunctionRuntime(trigger.id, trigger.name, functionsEmulatorShared_1.getSignatureType(trigger), proto);
     }
     getTrigger(name) {
         const result = this.triggers.find((trigger) => {