firebase-tools 10.2.0 → 10.3.0

package/lib/emulator/functionsEmulator.js

@@ -8,7 +8,9 @@ const express = require("express");
 const clc = require("cli-color");
 const http = require("http");
 const jwt = require("jsonwebtoken");
+const cors = require("cors");
 const url_1 = require("url");
+const events_1 = require("events");
 const api = require("../api");
 const logger_1 = require("../logger");
 const track = require("../track");
@@ -19,7 +21,6 @@ const spawn = require("cross-spawn");
 const child_process_1 = require("child_process");
 const functionsEmulatorShared_1 = require("./functionsEmulatorShared");
 const registry_1 = require("./registry");
-const events_1 = require("events");
 const emulatorLogger_1 = require("./emulatorLogger");
 const functionsRuntimeWorker_1 = require("./functionsRuntimeWorker");
 const error_1 = require("../error");
@@ -29,10 +30,10 @@ const defaultCredentials_1 = require("../defaultCredentials");
 const adminSdkConfig_1 = require("./adminSdkConfig");
 const types_2 = require("./events/types");
 const validate_1 = require("../deploy/functions/validate");
-const runtimes_1 = require("../deploy/functions/runtimes");
+const secretManager_1 = require("../gcp/secretManager");
+const runtimes = require("../deploy/functions/runtimes");
 const backend = require("../deploy/functions/backend");
 const functionsEnv = require("../functions/env");
-const secretManager_1 = require("../gcp/secretManager");
 const EVENT_INVOKE = "functions:invoke";
 const LOCAL_SECRETS_FILE = ".secret.local";
 const DATABASE_PATH_PATTERN = new RegExp("^projects/[^/]+/instances/([^/]+)/refs(/.*)$");
@@ -92,6 +93,7 @@ class FunctionsEmulator {
         const httpsFunctionRoute = `/${this.args.projectId}/:region/:trigger_name`;
         const multicastFunctionRoute = `/functions/projects/:project_id/trigger_multicast`;
         const httpsFunctionRoutes = [httpsFunctionRoute, `${httpsFunctionRoute}/*`];
+        const listBackendsRoute = `/backends`;
         const backgroundHandler = (req, res) => {
             var _a;
             const region = req.params.region;
@@ -152,6 +154,10 @@ class FunctionsEmulator {
             });
             res.json({ status: "multicast_acknowledged" });
         };
+        const listBackendsHandler = (req, res) => {
+            res.json({ backends: this.getBackendInfo() });
+        };
+        hub.get(listBackendsRoute, cors({ origin: true }), listBackendsHandler);
         hub.post(backgroundFunctionRoute, dataMiddleware, backgroundHandler);
         hub.post(multicastFunctionRoute, dataMiddleware, multicastHandler);
         hub.all(httpsFunctionRoutes, dataMiddleware, httpsHandler);
@@ -161,9 +167,15 @@ class FunctionsEmulator {
         });
         return hub;
     }
-    async startFunctionRuntime(backend, trigger, proto, runtimeOpts) {
+    async invokeTrigger(backend, trigger, proto, runtimeOpts) {
         const bundleTemplate = this.getBaseBundle();
         const runtimeBundle = Object.assign(Object.assign({}, bundleTemplate), { proto });
+        if (this.args.debugPort) {
+            runtimeBundle.debug = {
+                functionTarget: trigger.entryPoint,
+                functionSignature: (0, functionsEmulatorShared_1.getSignatureType)(trigger),
+            };
+        }
         if (!backend.nodeBinary) {
             throw new error_1.FirebaseError(`No node binary for ${trigger.id}. This should never happen.`);
         }
@@ -240,20 +252,25 @@ class FunctionsEmulator {
         }
         let triggerDefinitions;
         if (emulatableBackend.predefinedTriggers) {
-            triggerDefinitions = (0, functionsEmulatorShared_1.emulatedFunctionsByRegion)(emulatableBackend.predefinedTriggers);
+            triggerDefinitions = (0, functionsEmulatorShared_1.emulatedFunctionsByRegion)(emulatableBackend.predefinedTriggers, emulatableBackend.secretEnv);
         }
         else {
-            const runtimeDelegate = await (0, runtimes_1.getRuntimeDelegate)({
+            const runtimeConfig = this.getRuntimeConfig(emulatableBackend);
+            const runtimeDelegateContext = {
                 projectId: this.args.projectId,
                 projectDir: this.args.projectDir,
                 sourceDir: emulatableBackend.functionsDir,
-            });
+            };
+            if (emulatableBackend.nodeMajorVersion) {
+                runtimeDelegateContext.runtime = `nodejs${emulatableBackend.nodeMajorVersion}`;
+            }
+            const runtimeDelegate = await runtimes.getRuntimeDelegate(runtimeDelegateContext);
             logger_1.logger.debug(`Validating ${runtimeDelegate.name} source`);
             await runtimeDelegate.validate();
             logger_1.logger.debug(`Building ${runtimeDelegate.name} source`);
             await runtimeDelegate.build();
             logger_1.logger.debug(`Analyzing ${runtimeDelegate.name} backend spec`);
-            const discoveredBackend = await runtimeDelegate.discoverSpec({}, Object.assign(Object.assign(Object.assign(Object.assign({}, this.getSystemEnvs()), this.getEmulatorEnvs()), { FIREBASE_CONFIG: this.getFirebaseConfig() }), emulatableBackend.env));
+            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);
             triggerDefinitions = (0, functionsEmulatorShared_1.emulatedFunctionsFromEndpoints)(endpoints);
         }
@@ -330,6 +347,9 @@ class FunctionsEmulator {
                 this.logger.logLabeled("SUCCESS", `functions[${definition.id}]`, msg);
             }
         }
+        if (this.args.debugPort) {
+            this.startRuntime(emulatableBackend, { nodeBinary: emulatableBackend.nodeBinary });
+        }
     }
     addRealtimeDatabaseTrigger(projectId, key, eventTrigger) {
         const databaseEmu = registry_1.EmulatorRegistry.get(types_1.Emulators.DATABASE);
@@ -468,8 +488,26 @@ class FunctionsEmulator {
     getTriggerKey(def) {
         return def.eventTrigger ? `${def.id}-${this.triggerGeneration}` : def.id;
     }
-    getBackends() {
-        return this.args.emulatableBackends;
+    getBackendInfo() {
+        const cf3Triggers = Object.values(this.triggers)
+            .filter((t) => !t.backend.extensionInstanceId)
+            .map((t) => t.def);
+        return this.args.emulatableBackends.map((e) => {
+            var _a;
+            const envWithSecrets = Object.assign({}, e.env);
+            for (const s of e.secretEnv) {
+                envWithSecrets[s.key] = backend.secretVersionName(s);
+            }
+            return {
+                directory: e.functionsDir,
+                env: envWithSecrets,
+                extensionInstanceId: e.extensionInstanceId,
+                extension: e.extension,
+                extensionVersion: e.extensionVersion,
+                extensionSpec: e.extensionSpec,
+                functionTriggers: (_a = e.predefinedTriggers) !== null && _a !== void 0 ? _a : cf3Triggers,
+            };
+        });
     }
     addTriggerRecord(def, opts) {
         const key = this.getTriggerKey(def);
@@ -521,10 +559,21 @@ class FunctionsEmulator {
         }
         return process.execPath;
     }
+    getRuntimeConfig(backend) {
+        const configPath = `${backend.functionsDir}/.runtimeconfig.json`;
+        try {
+            const configContent = fs.readFileSync(configPath, "utf8");
+            return JSON.parse(configContent.toString());
+        }
+        catch (e) {
+        }
+        return {};
+    }
     getUserEnvs(backend) {
         const projectInfo = {
             functionsSource: backend.functionsDir,
             projectId: this.args.projectId,
+            projectAlias: this.args.projectAlias,
             isEmulator: true,
         };
         if (functionsEnv.hasUserEnvs(projectInfo)) {
@@ -543,11 +592,10 @@ class FunctionsEmulator {
         envs.K_REVISION = "1";
         envs.PORT = "80";
         if (trigger) {
-            const service = trigger.name;
-            const target = service.replace(/-/g, ".");
+            const target = trigger.entryPoint;
             envs.FUNCTION_TARGET = target;
             envs.FUNCTION_SIGNATURE_TYPE = (0, functionsEmulatorShared_1.getSignatureType)(trigger);
-            envs.K_SERVICE = service;
+            envs.K_SERVICE = trigger.name;
         }
         return envs;
     }
@@ -579,6 +627,9 @@ class FunctionsEmulator {
             const pubsubHost = (0, functionsEmulatorShared_1.formatHost)(pubsubEmulator);
             process.env.PUBSUB_EMULATOR_HOST = pubsubHost;
         }
+        if (this.args.debugPort) {
+            envs["FUNCTION_DEBUG_MODE"] = "true";
+        }
         return envs;
     }
     getFirebaseConfig() {
@@ -612,44 +663,51 @@ class FunctionsEmulator {
                 this.logger.logLabeled("ERROR", "functions", `Failed to read local secrets file ${LOCAL_SECRETS_FILE}: ${e.message}`);
             }
         }
-        const secrets = trigger.secretEnvironmentVariables || [];
-        const accesses = secrets
-            .filter((s) => !secretEnvs[s.secret])
-            .map(async (s) => {
-            this.logger.logLabeled("INFO", "functions", `Trying to access secret ${s.key}@latest`);
-            const value = await (0, secretManager_1.accessSecretVersion)(this.getProjectId(), s.key, "latest");
-            return [s.secret, value];
-        });
-        const accessResults = await (0, utils_1.allSettled)(accesses);
-        const errs = [];
-        for (const result of accessResults) {
-            if (result.status === "rejected") {
-                errs.push(result.reason);
+        if (trigger) {
+            const secrets = trigger.secretEnvironmentVariables || [];
+            const accesses = secrets
+                .filter((s) => !secretEnvs[s.key])
+                .map(async (s) => {
+                var _a;
+                this.logger.logLabeled("INFO", "functions", `Trying to access secret ${s.secret}@latest`);
+                const value = await (0, secretManager_1.accessSecretVersion)(this.getProjectId(), s.secret, (_a = s.version) !== null && _a !== void 0 ? _a : "latest");
+                return [s.key, value];
+            });
+            const accessResults = await (0, utils_1.allSettled)(accesses);
+            const errs = [];
+            for (const result of accessResults) {
+                if (result.status === "rejected") {
+                    errs.push(result.reason);
+                }
+                else {
+                    const [k, v] = result.value;
+                    secretEnvs[k] = v;
+                }
             }
-            else {
-                const [k, v] = result.value;
-                secretEnvs[k] = v;
+            if (errs.length > 0) {
+                this.logger.logLabeled("ERROR", "functions", "Unable to access secret environment variables from Google Cloud Secret Manager. " +
+                    "Make sure the credential used for the Functions Emulator have access " +
+                    `or provide override values in ${LOCAL_SECRETS_FILE}:\n\t` +
+                    errs.join("\n\t"));
             }
         }
-        if (errs.length > 0) {
-            this.logger.logLabeled("ERROR", "functions", "Unable to access secret environment variables from Google Cloud Secret Manager. " +
-                "Make sure the credential used for the Functions Emulator have access " +
-                `or provide override values in ${LOCAL_SECRETS_FILE}:\n\t` +
-                errs.join("\n\t"));
-        }
         return secretEnvs;
     }
     async invokeRuntime(backend, trigger, frb, opts) {
-        if (this.workerPool.readyForWork(trigger.id)) {
-            return this.workerPool.submitWork(trigger.id, frb, opts);
+        if (!this.workerPool.readyForWork(trigger.id)) {
+            await this.startRuntime(backend, opts, trigger);
         }
+        return this.workerPool.submitWork(trigger.id, frb, opts);
+    }
+    async startRuntime(backend, opts, trigger) {
+        var _a;
         const emitter = new events_1.EventEmitter();
         const args = [path.join(__dirname, "functionsEmulatorRuntime")];
         if (opts.ignore_warnings) {
             args.unshift("--no-warnings");
         }
         if (this.args.debugPort) {
-            if (process.env.FIREPIT_VERSION && process.execPath == opts.nodeBinary) {
+            if (process.env.FIREPIT_VERSION && process.execPath === opts.nodeBinary) {
                 const requestedMajorNodeVersion = this.getNodeBinary(backend);
                 this.logger.log("WARN", `To enable function inspection, please run "${process.execPath} is:npm i node@${requestedMajorNodeVersion} --save-dev" in your functions directory`);
             }
@@ -711,8 +769,12 @@ class FunctionsEmulator {
                 return childProcess.send(JSON.stringify(args));
             },
         };
-        this.workerPool.addWorker(trigger.id, runtime);
-        return this.workerPool.submitWork(trigger.id, frb, opts);
+        const extensionLogInfo = {
+            instanceId: backend.extensionInstanceId,
+            ref: (_a = backend.extensionVersion) === null || _a === void 0 ? void 0 : _a.ref,
+        };
+        this.workerPool.addWorker(trigger === null || trigger === void 0 ? void 0 : trigger.id, runtime, extensionLogInfo);
+        return;
     }
     async disableBackgroundTriggers() {
         Object.values(this.triggers).forEach((record) => {
@@ -738,7 +800,7 @@ class FunctionsEmulator {
         }
         const trigger = record.def;
         const service = (0, functionsEmulatorShared_1.getFunctionService)(trigger);
-        const worker = await this.startFunctionRuntime(record.backend, trigger, proto);
+        const worker = await this.invokeTrigger(record.backend, trigger, proto);
         return new Promise((resolve, reject) => {
             if (projectId !== this.args.projectId) {
                 if (service !== constants_1.Constants.SERVICE_REALTIME_DATABASE) {
@@ -757,7 +819,7 @@ class FunctionsEmulator {
                     reject({ code: 500, body: el.text });
                 }
             });
-            track(EVENT_INVOKE, (0, functionsEmulatorShared_1.getFunctionService)(trigger));
+            void track(EVENT_INVOKE, (0, functionsEmulatorShared_1.getFunctionService)(trigger));
             worker.waitForDone().then(() => {
                 resolve({ status: "acknowledged" });
             });
@@ -825,14 +887,14 @@ class FunctionsEmulator {
                 req.headers[functionsEmulatorShared_1.HttpConstants.CALLABLE_AUTH_HEADER] = encodeURIComponent(JSON.stringify(contextAuth));
             }
         }
-        const worker = await this.startFunctionRuntime(record.backend, trigger);
+        const worker = await this.invokeTrigger(record.backend, trigger);
         worker.onLogs((el) => {
             if (el.level === "FATAL") {
                 res.status(500).send(el.text);
             }
         });
         await worker.waitForSocketReady();
-        track(EVENT_INVOKE, "https");
+        void track(EVENT_INVOKE, "https");
         this.logger.log("DEBUG", `[functions] Runtime ready! Sending request!`);
         if (!worker.lastArgs) {
             throw new error_1.FirebaseError("Cannot execute on a worker with no arguments");

package/lib/emulator/functionsEmulatorRuntime.js

@@ -10,9 +10,10 @@ const types_1 = require("./types");
 const constants_1 = require("./constants");
 const functionsEmulatorShared_1 = require("./functionsEmulatorShared");
 const functionsEmulatorUtils_1 = require("./functionsEmulatorUtils");
-let functionTrigger;
+let functionModule;
 let FUNCTION_TARGET_NAME;
 let FUNCTION_SIGNATURE;
+let FUNCTION_DEBUG_MODE;
 let developerPkgJSON;
 const dynamicImport = new Function("modulePath", "return import(modulePath)");
 function isFeatureEnabled(frb, feature) {
@@ -484,7 +485,7 @@ async function initializeFunctionsConfigHelper(frb) {
 function rawBodySaver(req, res, buf) {
     req.rawBody = buf;
 }
-async function processHTTPS(frb) {
+async function processHTTPS(trigger, frb) {
     const ephemeralServer = express();
     const functionRouter = express.Router();
     const socketPath = frb.socketPath;
@@ -506,7 +507,7 @@ async function processHTTPS(frb) {
                         }
                     });
                 });
-                await runHTTPS([req, res]);
+                await runHTTPS(trigger, [req, res]);
             }
             catch (err) {
                 rejectEphemeralServer(err);
@@ -540,11 +541,11 @@ async function processHTTPS(frb) {
         instance.on("error", rejectEphemeralServer);
     });
 }
-async function processBackground(frb, signature) {
+async function processBackground(trigger, frb, signature) {
     const proto = frb.proto;
     logDebug("ProcessBackground", proto);
     if (signature === "cloudevent") {
-        return runCloudEvent(proto);
+        return runCloudEvent(trigger, proto);
     }
     const data = proto.data;
     delete proto.data;
@@ -555,7 +556,7 @@ async function processBackground(frb, signature) {
             context.resource = context.resource.name;
         }
     }
-    await runBackground({ data, context });
+    await runBackground(trigger, { data, context });
 }
 async function runFunction(func) {
     let caughtErr;
@@ -570,24 +571,24 @@ async function runFunction(func) {
         throw caughtErr;
     }
 }
-async function runBackground(proto) {
+async function runBackground(trigger, proto) {
     logDebug("RunBackground", proto);
     await runFunction(() => {
-        return functionTrigger(proto.data, proto.context);
+        return trigger(proto.data, proto.context);
     });
 }
-async function runCloudEvent(event) {
+async function runCloudEvent(trigger, event) {
     logDebug("RunCloudEvent", event);
     await runFunction(() => {
-        return functionTrigger(event);
+        return trigger(event);
     });
 }
-async function runHTTPS(args) {
+async function runHTTPS(trigger, args) {
     if (args.length < 2) {
         throw new Error("Function must be passed 2 args.");
     }
     await runFunction(() => {
-        return functionTrigger(args[0], args[1]);
+        return trigger(args[0], args[1]);
     });
 }
 async function moduleResolutionDetective(frb, error) {
@@ -611,7 +612,7 @@ async function moduleResolutionDetective(frb, error) {
 function logDebug(msg, data) {
     new types_1.EmulatorLog("DEBUG", "runtime-status", `[${process.pid}] ${msg}`, data).log();
 }
-async function invokeTrigger(frb) {
+async function invokeTrigger(trigger, frb) {
     new types_1.EmulatorLog("INFO", "runtime-status", `Beginning execution of "${FUNCTION_TARGET_NAME}"`, {
         frb,
     }).log();
@@ -636,10 +637,10 @@ async function invokeTrigger(frb) {
     switch (FUNCTION_SIGNATURE) {
         case "event":
         case "cloudevent":
-            await processBackground(frb, FUNCTION_SIGNATURE);
+            await processBackground(trigger, frb, FUNCTION_SIGNATURE);
             break;
         case "http":
-            await processHTTPS(frb);
+            await processHTTPS(trigger, frb);
             break;
     }
     if (timeoutId) {
@@ -649,15 +650,18 @@ async function invokeTrigger(frb) {
     new types_1.EmulatorLog("INFO", "runtime-status", `Finished "${FUNCTION_TARGET_NAME}" in ~${Math.max(seconds, 1)}s`).log();
 }
 async function initializeRuntime(frb) {
-    FUNCTION_TARGET_NAME = process.env.FUNCTION_TARGET || "";
-    if (!FUNCTION_TARGET_NAME) {
-        new types_1.EmulatorLog("FATAL", "runtime-status", `Environment variable FUNCTION_TARGET cannot be empty. This shouldn't happen.`).log();
-        await flushAndExit(1);
-    }
-    FUNCTION_SIGNATURE = process.env.FUNCTION_SIGNATURE_TYPE || "";
-    if (!FUNCTION_SIGNATURE) {
-        new types_1.EmulatorLog("FATAL", "runtime-status", `Environment variable FUNCTION_SIGNATURE_TYPE cannot be empty. This shouldn't happen.`).log();
-        await flushAndExit(1);
+    FUNCTION_DEBUG_MODE = process.env.FUNCTION_DEBUG_MODE || "";
+    if (!FUNCTION_DEBUG_MODE) {
+        FUNCTION_TARGET_NAME = process.env.FUNCTION_TARGET || "";
+        if (!FUNCTION_TARGET_NAME) {
+            new types_1.EmulatorLog("FATAL", "runtime-status", `Environment variable FUNCTION_TARGET cannot be empty. This shouldn't happen.`).log();
+            await flushAndExit(1);
+        }
+        FUNCTION_SIGNATURE = process.env.FUNCTION_SIGNATURE_TYPE || "";
+        if (!FUNCTION_SIGNATURE) {
+            new types_1.EmulatorLog("FATAL", "runtime-status", `Environment variable FUNCTION_SIGNATURE_TYPE cannot be empty. This shouldn't happen.`).log();
+            await flushAndExit(1);
+        }
     }
     logDebug(`Disabled runtime features: ${JSON.stringify(frb.disabled_features)}`);
     const verified = await verifyDeveloperNodeModules(frb);
@@ -671,7 +675,7 @@ async function initializeRuntime(frb) {
     await initializeFirebaseFunctionsStubs(frb);
     await initializeFirebaseAdminStubs(frb);
 }
-async function loadTrigger(frb, functionTarget, serializedFunctionTrigger) {
+async function loadTriggers(frb, serializedFunctionTrigger) {
     let triggerModule;
     if (serializedFunctionTrigger) {
         triggerModule = eval(serializedFunctionTrigger)();
@@ -690,13 +694,7 @@ async function loadTrigger(frb, functionTarget, serializedFunctionTrigger) {
             triggerModule = await dynamicImport(moduleURL);
         }
     }
-    const maybeTrigger = functionTarget.split(".").reduce((mod, functionTargetPart) => {
-        return mod === null || mod === void 0 ? void 0 : mod[functionTargetPart];
-    }, triggerModule);
-    if (!maybeTrigger) {
-        throw new Error(`Failed to find function ${functionTarget} in the loaded module`);
-    }
-    return maybeTrigger;
+    return triggerModule;
 }
 async function flushAndExit(code) {
     await types_1.EmulatorLog.waitForFlush();
@@ -716,22 +714,32 @@ async function handleMessage(message) {
         await flushAndExit(1);
         return;
     }
-    if (!functionTrigger) {
+    if (!functionModule) {
         try {
             await initializeRuntime(runtimeArgs.frb);
             const serializedTriggers = runtimeArgs.opts ? runtimeArgs.opts.serializedTriggers : undefined;
-            functionTrigger = await loadTrigger(runtimeArgs.frb, FUNCTION_TARGET_NAME, serializedTriggers);
+            functionModule = await loadTriggers(runtimeArgs.frb, serializedTriggers);
         }
         catch (e) {
             logDebug(e);
-            new types_1.EmulatorLog("FATAL", "runtime-status", `Failed to initialize and load trigger. This shouldn't happen: ${e.message}`).log();
+            new types_1.EmulatorLog("FATAL", "runtime-status", `Failed to initialize and load triggers. This shouldn't happen: ${e.message}`).log();
             await flushAndExit(1);
             return;
         }
     }
+    if (FUNCTION_DEBUG_MODE) {
+        FUNCTION_TARGET_NAME = runtimeArgs.frb.debug.functionTarget;
+        FUNCTION_SIGNATURE = runtimeArgs.frb.debug.functionSignature;
+    }
+    const trigger = FUNCTION_TARGET_NAME.split(".").reduce((mod, functionTargetPart) => {
+        return mod === null || mod === void 0 ? void 0 : mod[functionTargetPart];
+    }, functionModule);
+    if (!trigger) {
+        throw new Error(`Failed to find function ${FUNCTION_TARGET_NAME} in the loaded module`);
+    }
     logDebug(`Beginning invocation function ${FUNCTION_TARGET_NAME}!`);
     try {
-        await invokeTrigger(runtimeArgs.frb);
+        await invokeTrigger(trigger, runtimeArgs.frb);
         if (runtimeArgs.opts && runtimeArgs.opts.serializedTriggers) {
             await flushAndExit(0);
         }

package/lib/emulator/functionsEmulatorShared.js

@@ -5,9 +5,10 @@ const _ = require("lodash");
 const os = require("os");
 const path = require("path");
 const fs = require("fs");
+const backend = require("../deploy/functions/backend");
 const constants_1 = require("./constants");
-const backend_1 = require("../deploy/functions/backend");
 const proto_1 = require("../gcp/proto");
+const logger_1 = require("../logger");
 const memoryLookup = {
     "128MB": 128,
     "256MB": 256,
@@ -60,30 +61,35 @@ function emulatedFunctionsFromEndpoints(endpoints) {
             id: `${endpoint.region}-${endpoint.id}`,
         };
         (0, proto_1.copyIfPresent)(def, endpoint, "timeout", "availableMemoryMb", "labels", "platform", "secretEnvironmentVariables");
-        if ((0, backend_1.isHttpsTriggered)(endpoint)) {
+        if (backend.isHttpsTriggered(endpoint)) {
             def.httpsTrigger = endpoint.httpsTrigger;
         }
-        else if ((0, backend_1.isEventTriggered)(endpoint)) {
+        else if (backend.isEventTriggered(endpoint)) {
             const eventTrigger = endpoint.eventTrigger;
             if (endpoint.platform === "gcfv1") {
+                const resourceFilter = backend.findEventFilter(endpoint, "resource");
+                if (!resourceFilter) {
+                    logger_1.logger.debug(`Invalid event trigger ${JSON.stringify(endpoint)}, expected event filter with resource attribute. Skipping.`);
+                    continue;
+                }
                 def.eventTrigger = {
                     eventType: eventTrigger.eventType,
-                    resource: eventTrigger.eventFilters.resource,
+                    resource: resourceFilter.value,
                 };
             }
             else {
-                const { resource, topic, bucket } = endpoint.eventTrigger.eventFilters;
-                const eventResource = resource || topic || bucket;
-                if (!eventResource) {
+                const [eventFilter] = endpoint.eventTrigger.eventFilters;
+                if (!eventFilter) {
+                    logger_1.logger.debug(`Invalid event trigger ${JSON.stringify(endpoint)}, expected at least one event filter. Skipping.`);
                     continue;
                 }
                 def.eventTrigger = {
                     eventType: eventTrigger.eventType,
-                    resource: eventResource,
+                    resource: eventFilter.value,
                 };
             }
         }
-        else if ((0, backend_1.isScheduleTriggered)(endpoint)) {
+        else if (backend.isScheduleTriggered(endpoint)) {
             def.eventTrigger = { eventType: "pubsub", resource: "" };
             def.schedule = endpoint.scheduleTrigger;
         }
@@ -94,7 +100,7 @@ function emulatedFunctionsFromEndpoints(endpoints) {
     return regionDefinitions;
 }
 exports.emulatedFunctionsFromEndpoints = emulatedFunctionsFromEndpoints;
-function emulatedFunctionsByRegion(definitions) {
+function emulatedFunctionsByRegion(definitions, secretEnvVariables = []) {
     const regionDefinitions = [];
     for (const def of definitions) {
         if (!def.regions) {
@@ -106,6 +112,7 @@ function emulatedFunctionsByRegion(definitions) {
             defDeepCopy.region = region;
             defDeepCopy.id = `${region}-${defDeepCopy.name}`;
             defDeepCopy.platform = defDeepCopy.platform || "gcfv1";
+            defDeepCopy.secretEnvironmentVariables = secretEnvVariables;
             regionDefinitions.push(defDeepCopy);
         }
     }

package/lib/emulator/functionsEmulatorShell.js

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

package/lib/emulator/functionsEmulatorUtils.js

@@ -52,7 +52,7 @@ function parseRuntimeVersion(runtime) {
         return undefined;
     }
     const runtimeRe = /(nodejs)?([0-9]+)/;
-    const match = runtime.match(runtimeRe);
+    const match = runtimeRe.exec(runtime);
     if (match) {
         return Number.parseInt(match[2]);
     }
@@ -73,13 +73,13 @@ exports.parseVersionString = parseVersionString;
 function compareVersionStrings(a, b) {
     const versionA = parseVersionString(a);
     const versionB = parseVersionString(b);
-    if (versionA.major != versionB.major) {
+    if (versionA.major !== versionB.major) {
         return versionA.major - versionB.major;
     }
-    if (versionA.minor != versionB.minor) {
+    if (versionA.minor !== versionB.minor) {
         return versionA.minor - versionB.minor;
     }
-    if (versionA.patch != versionB.patch) {
+    if (versionA.patch !== versionB.patch) {
         return versionA.patch - versionB.patch;
     }
     return 0;

package/lib/emulator/functionsRuntimeWorker.js

@@ -170,14 +170,14 @@ class RuntimeWorkerPool {
         }
         return;
     }
-    addWorker(triggerId, runtime) {
+    addWorker(triggerId, runtime, extensionLogInfo) {
         const worker = new RuntimeWorker(this.getKey(triggerId), runtime);
         this.log(`addWorker(${worker.key})`);
         const keyWorkers = this.getTriggerWorkers(triggerId);
         keyWorkers.push(worker);
         this.setTriggerWorkers(triggerId, keyWorkers);
         const logger = triggerId
-            ? emulatorLogger_1.EmulatorLogger.forFunction(triggerId)
+            ? emulatorLogger_1.EmulatorLogger.forFunction(triggerId, extensionLogInfo)
             : emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.FUNCTIONS);
         worker.onLogs((log) => {
             logger.handleRuntimeLog(log);

package/lib/emulator/hub.js

@@ -25,9 +25,10 @@ class EmulatorHub {
         });
         this.hub.get(EmulatorHub.PATH_EMULATORS, (req, res) => {
             const body = {};
-            registry_1.EmulatorRegistry.listRunning().forEach((name) => {
-                body[name] = registry_1.EmulatorRegistry.get(name).getInfo();
-            });
+            for (const emulator of registry_1.EmulatorRegistry.listRunning()) {
+                const info = registry_1.EmulatorRegistry.getInfo(emulator);
+                body[emulator] = info;
+            }
             res.json(body);
         });
         this.hub.post(EmulatorHub.PATH_EXPORT, async (req, res) => {

package/lib/emulator/loggingEmulator.js

@@ -82,7 +82,7 @@ class WebSocketTransport extends TransportStream {
         };
         const splat = [info.message, ...(info[triple_beam_1.SPLAT] || [])]
             .map((value) => {
-            if (typeof value == "string") {
+            if (typeof value === "string") {
                 try {
                     bundle.data = Object.assign(Object.assign({}, bundle.data), JSON.parse(value));
                     return null;

package/lib/emulator/pubsubEmulator.js

@@ -88,7 +88,7 @@ class PubsubEmulator {
         this.subscriptionForTopic.set(topicName, sub);
     }
     ensureFunctionsClient() {
-        if (this.client != undefined)
+        if (this.client !== undefined)
             return;
         const funcEmulator = registry_1.EmulatorRegistry.get(types_1.Emulators.FUNCTIONS);
         if (!funcEmulator) {