firebase-tools 10.0.0 → 10.1.2

package/lib/emulator/functionsEmulator.js

@@ -35,7 +35,6 @@ const DATABASE_PATH_PATTERN = new RegExp("^projects/[^/]+/instances/([^/]+)/refs
 class FunctionsEmulator {
     constructor(args) {
         this.args = args;
-        this.nodeBinary = "";
         this.triggers = {};
         this.triggerGeneration = 0;
         this.logger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.FUNCTIONS);
@@ -63,7 +62,7 @@ class FunctionsEmulator {
             this.logger.logLabeled("WARN", "functions", `Your GOOGLE_APPLICATION_CREDENTIALS environment variable points to ${process.env.GOOGLE_APPLICATION_CREDENTIALS}. Non-emulated services will access production using these credentials. Be careful!`);
         }
         else if (this.args.account) {
-            const defaultCredPath = await defaultCredentials_1.getCredentialPathAsync(this.args.account);
+            const defaultCredPath = await (0, defaultCredentials_1.getCredentialPathAsync)(this.args.account);
             if (defaultCredPath) {
                 this.logger.log("DEBUG", `Setting GAC to ${defaultCredPath}`);
                 credentialEnv.GOOGLE_APPLICATION_CREDENTIALS = defaultCredPath;
@@ -160,58 +159,70 @@ class FunctionsEmulator {
         });
         return hub;
     }
-    startFunctionRuntime(triggerId, targetName, signatureType, proto, runtimeOpts) {
-        const bundleTemplate = this.getBaseBundle();
+    startFunctionRuntime(backend, triggerId, targetName, signatureType, proto, runtimeOpts) {
+        const bundleTemplate = this.getBaseBundle(backend);
         const runtimeBundle = Object.assign(Object.assign({}, bundleTemplate), { emulators: {
                 firestore: this.getEmulatorInfo(types_1.Emulators.FIRESTORE),
                 database: this.getEmulatorInfo(types_1.Emulators.DATABASE),
                 pubsub: this.getEmulatorInfo(types_1.Emulators.PUBSUB),
                 auth: this.getEmulatorInfo(types_1.Emulators.AUTH),
                 storage: this.getEmulatorInfo(types_1.Emulators.STORAGE),
-            }, nodeMajorVersion: this.args.nodeMajorVersion, proto,
+            }, nodeMajorVersion: backend.nodeMajorVersion, proto,
             triggerId,
             targetName });
+        if (!backend.nodeBinary) {
+            throw new error_1.FirebaseError(`No node binary for ${triggerId}. This should never happen.`);
+        }
         const opts = runtimeOpts || {
-            nodeBinary: this.nodeBinary,
-            extensionTriggers: this.args.predefinedTriggers,
+            nodeBinary: backend.nodeBinary,
+            extensionTriggers: backend.predefinedTriggers,
         };
-        const worker = this.invokeRuntime(runtimeBundle, opts, this.getRuntimeEnvs({ targetName, signatureType }));
+        const worker = this.invokeRuntime(runtimeBundle, opts, this.getRuntimeEnvs(backend, { targetName, signatureType }));
         return worker;
     }
     async start() {
-        this.nodeBinary = this.askInstallNodeVersion(this.args.functionsDir, this.args.nodeMajorVersion);
+        for (const backend of this.args.emulatableBackends) {
+            backend.nodeBinary = this.getNodeBinary(backend);
+        }
         const credentialEnv = await this.getCredentialsEnvironment();
-        this.args.env = Object.assign(Object.assign({}, credentialEnv), this.args.env);
-        const adminSdkConfig = await adminSdkConfig_1.getProjectAdminSdkConfigOrCached(this.args.projectId);
+        for (const e of this.args.emulatableBackends) {
+            e.env = Object.assign(Object.assign({}, credentialEnv), e.env);
+        }
+        const adminSdkConfig = await (0, adminSdkConfig_1.getProjectAdminSdkConfigOrCached)(this.args.projectId);
         if (adminSdkConfig) {
             this.adminSdkConfig = adminSdkConfig;
         }
         else {
             this.logger.logLabeled("WARN", "functions", "Unable to fetch project Admin SDK configuration, Admin SDK behavior in Cloud Functions emulator may be incorrect.");
-            this.adminSdkConfig = adminSdkConfig_1.constructDefaultAdminSdkConfig(this.args.projectId);
+            this.adminSdkConfig = (0, adminSdkConfig_1.constructDefaultAdminSdkConfig)(this.args.projectId);
         }
         const { host, port } = this.getInfo();
         this.workQueue.start();
         const server = this.createHubServer().listen(port, host);
-        this.destroyServer = utils_1.createDestroyer(server);
+        this.destroyServer = (0, utils_1.createDestroyer)(server);
         return Promise.resolve();
     }
     async connect() {
-        this.logger.logLabeled("BULLET", "functions", `Watching "${this.args.functionsDir}" for Cloud Functions...`);
-        const watcher = chokidar.watch(this.args.functionsDir, {
-            ignored: [
-                /.+?[\\\/]node_modules[\\\/].+?/,
-                /(^|[\/\\])\../,
-                /.+\.log/,
-            ],
-            persistent: true,
-        });
-        const debouncedLoadTriggers = _.debounce(() => this.loadTriggers(), 1000);
-        watcher.on("change", (filePath) => {
-            this.logger.log("DEBUG", `File ${filePath} changed, reloading triggers`);
-            return debouncedLoadTriggers();
-        });
-        return this.loadTriggers(true);
+        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, {
+                ignored: [
+                    /.+?[\\\/]node_modules[\\\/].+?/,
+                    /(^|[\/\\])\../,
+                    /.+\.log/,
+                ],
+                persistent: true,
+            });
+            const debouncedLoadTriggers = _.debounce(() => this.loadTriggers(backend), 1000);
+            watcher.on("change", (filePath) => {
+                this.logger.log("DEBUG", `File ${filePath} changed, reloading triggers`);
+                return debouncedLoadTriggers();
+            });
+            loadTriggerPromises.push(this.loadTriggers(backend, true));
+        }
+        await Promise.all(loadTriggerPromises);
+        return;
     }
     async stop() {
         try {
@@ -226,16 +237,19 @@ class FunctionsEmulator {
             await this.destroyServer();
         }
     }
-    async loadTriggers(force = false) {
+    async loadTriggers(emulatableBackend, force = false) {
         this.workerPool.refresh();
-        const worker = this.invokeRuntime(this.getBaseBundle(), {
-            nodeBinary: this.nodeBinary,
-            extensionTriggers: this.args.predefinedTriggers,
-        }, Object.assign(Object.assign(Object.assign(Object.assign({}, this.getSystemEnvs()), this.getEmulatorEnvs()), { FIREBASE_CONFIG: this.getFirebaseConfig() }), this.args.env));
+        if (!emulatableBackend.nodeBinary) {
+            throw new error_1.FirebaseError(`No node binary for ${emulatableBackend.functionsDir}. This should never happen.`);
+        }
+        const worker = this.invokeRuntime(this.getBaseBundle(emulatableBackend), {
+            nodeBinary: emulatableBackend.nodeBinary,
+            extensionTriggers: emulatableBackend.predefinedTriggers,
+        }, Object.assign(Object.assign(Object.assign(Object.assign({}, this.getSystemEnvs()), this.getEmulatorEnvs()), { FIREBASE_CONFIG: this.getFirebaseConfig() }), emulatableBackend.env));
         const triggerParseEvent = await types_1.EmulatorLog.waitForLog(worker.runtime.events, "SYSTEM", "triggers-parsed");
         const parsedDefinitions = triggerParseEvent.data
             .triggerDefinitions;
-        const triggerDefinitions = functionsEmulatorShared_1.emulatedFunctionsByRegion(parsedDefinitions);
+        const triggerDefinitions = (0, functionsEmulatorShared_1.emulatedFunctionsByRegion)(parsedDefinitions);
         const toSetup = triggerDefinitions.filter((definition) => {
             if (force) {
                 return true;
@@ -252,7 +266,7 @@ class FunctionsEmulator {
         });
         for (const definition of toSetup) {
             try {
-                validate_1.functionIdsAreValid([definition]);
+                (0, validate_1.functionIdsAreValid)([definition]);
             }
             catch (e) {
                 this.logger.logLabeled("WARN", `functions[${definition.id}]`, `Invalid function id: ${e.message}`);
@@ -266,9 +280,9 @@ class FunctionsEmulator {
                 url = FunctionsEmulator.getHttpFunctionUrl(host, port, this.args.projectId, definition.name, definition.region);
             }
             else if (definition.eventTrigger) {
-                const service = functionsEmulatorShared_1.getFunctionService(definition);
+                const service = (0, functionsEmulatorShared_1.getFunctionService)(definition);
                 const key = this.getTriggerKey(definition);
-                const signature = functionsEmulatorShared_1.getSignatureType(definition);
+                const signature = (0, functionsEmulatorShared_1.getSignatureType)(definition);
                 switch (service) {
                     case constants_1.Constants.SERVICE_FIRESTORE:
                         added = await this.addFirestoreTrigger(this.args.projectId, key, definition.eventTrigger);
@@ -294,10 +308,10 @@ class FunctionsEmulator {
                 this.logger.log("WARN", `Trigger trigger "${definition.name}" has has neither "httpsTrigger" or "eventTrigger" member`);
             }
             const ignored = !added;
-            this.addTriggerRecord(definition, { ignored, url });
+            this.addTriggerRecord(definition, { backend: emulatableBackend, ignored, url });
             const type = definition.httpsTrigger
                 ? "http"
-                : constants_1.Constants.getServiceName(functionsEmulatorShared_1.getFunctionService(definition));
+                : constants_1.Constants.getServiceName((0, functionsEmulatorShared_1.getFunctionService)(definition));
             if (ignored) {
                 const msg = `function ignored because the ${type} emulator does not exist or is not running.`;
                 this.logger.logLabeled("BULLET", `functions[${definition.id}]`, msg);
@@ -434,27 +448,36 @@ class FunctionsEmulator {
     getTriggerDefinitions() {
         return Object.values(this.triggers).map((record) => record.def);
     }
-    getTriggerDefinitionByKey(triggerKey) {
+    getTriggerRecordByKey(triggerKey) {
         const record = this.triggers[triggerKey];
         if (!record) {
             logger_1.logger.debug(`Could not find key=${triggerKey} in ${JSON.stringify(this.triggers)}`);
             throw new error_1.FirebaseError(`No trigger with key ${triggerKey}`);
         }
-        return record.def;
+        return record;
     }
     getTriggerKey(def) {
         return def.eventTrigger ? `${def.id}-${this.triggerGeneration}` : def.id;
     }
+    getBackends() {
+        return this.args.emulatableBackends;
+    }
     addTriggerRecord(def, opts) {
         const key = this.getTriggerKey(def);
-        this.triggers[key] = { def, enabled: true, ignored: opts.ignored, url: opts.url };
+        this.triggers[key] = {
+            def,
+            enabled: true,
+            backend: opts.backend,
+            ignored: opts.ignored,
+            url: opts.url,
+        };
     }
-    setTriggersForTesting(triggers) {
-        triggers.forEach((def) => this.addTriggerRecord(def, { ignored: false }));
+    setTriggersForTesting(triggers, backend) {
+        triggers.forEach((def) => this.addTriggerRecord(def, { backend, ignored: false }));
     }
-    getBaseBundle() {
+    getBaseBundle(backend) {
         return {
-            cwd: this.args.functionsDir,
+            cwd: backend.functionsDir,
             projectId: this.args.projectId,
             triggerId: "",
             targetName: "",
@@ -476,21 +499,21 @@ class FunctionsEmulator {
         const pkg = require(path.join(frb.cwd, "package.json"));
         return frb.nodeMajorVersion || (pkg.engines && pkg.engines.node);
     }
-    askInstallNodeVersion(cwd, nodeMajorVersion) {
-        const pkg = require(path.join(cwd, "package.json"));
-        if ((!pkg.engines || !pkg.engines.node) && !nodeMajorVersion) {
-            this.logger.log("WARN", "Your functions directory does not specify a Node version.\n   " +
+    getNodeBinary(backend) {
+        const pkg = require(path.join(backend.functionsDir, "package.json"));
+        if ((!pkg.engines || !pkg.engines.node) && !backend.nodeMajorVersion) {
+            this.logger.log("WARN", `Your functions directory ${backend.functionsDir} does not specify a Node version.\n   ` +
                 "- Learn more at https://firebase.google.com/docs/functions/manage-functions#set_runtime_options");
             return process.execPath;
         }
         const hostMajorVersion = process.versions.node.split(".")[0];
-        const requestedMajorVersion = nodeMajorVersion
-            ? `${nodeMajorVersion}`
+        const requestedMajorVersion = backend.nodeMajorVersion
+            ? `${backend.nodeMajorVersion}`
             : pkg.engines.node;
         let localMajorVersion = "0";
-        const localNodePath = path.join(cwd, "node_modules/.bin/node");
+        const localNodePath = path.join(backend.functionsDir, "node_modules/.bin/node");
         try {
-            const localNodeOutput = child_process_1.spawnSync(localNodePath, ["--version"]).stdout.toString();
+            const localNodeOutput = (0, child_process_1.spawnSync)(localNodePath, ["--version"]).stdout.toString();
             localMajorVersion = localNodeOutput.slice(1).split(".")[0];
         }
         catch (err) {
@@ -501,14 +524,13 @@ class FunctionsEmulator {
         }
         if (requestedMajorVersion === hostMajorVersion) {
             this.logger.logLabeled("SUCCESS", "functions", `Using node@${requestedMajorVersion} from host.`);
-            return process.execPath;
         }
         this.logger.log("WARN", `Your requested "node" version "${requestedMajorVersion}" doesn't match your global version "${hostMajorVersion}"`);
         return process.execPath;
     }
-    getUserEnvs() {
+    getUserEnvs(backend) {
         const projectInfo = {
-            functionsSource: this.args.functionsDir,
+            functionsSource: backend.functionsDir,
             projectId: this.args.projectId,
             isEmulator: true,
         };
@@ -544,24 +566,24 @@ class FunctionsEmulator {
         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);
+            envs[constants_1.Constants.FIRESTORE_EMULATOR_HOST] = (0, 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);
+            envs[constants_1.Constants.FIREBASE_DATABASE_EMULATOR_HOST] = (0, 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);
+            envs[constants_1.Constants.FIREBASE_AUTH_EMULATOR_HOST] = (0, 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)}`;
+            envs[constants_1.Constants.FIREBASE_STORAGE_EMULATOR_HOST] = (0, functionsEmulatorShared_1.formatHost)(storageEmulator);
+            envs[constants_1.Constants.CLOUD_STORAGE_EMULATOR_HOST] = `http://${(0, functionsEmulatorShared_1.formatHost)(storageEmulator)}`;
         }
         const pubsubEmulator = this.getEmulatorInfo(types_1.Emulators.PUBSUB);
         if (pubsubEmulator) {
-            const pubsubHost = functionsEmulatorShared_1.formatHost(pubsubEmulator);
+            const pubsubHost = (0, functionsEmulatorShared_1.formatHost)(pubsubEmulator);
             process.env.PUBSUB_EMULATOR_HOST = pubsubHost;
         }
         return envs;
@@ -575,7 +597,7 @@ class FunctionsEmulator {
                 const asUrl = new url_1.URL(this.adminSdkConfig.databaseURL);
                 ns = asUrl.hostname.split(".")[0];
             }
-            emulatedDatabaseURL = `http://${functionsEmulatorShared_1.formatHost(databaseEmulator)}/?ns=${ns}`;
+            emulatedDatabaseURL = `http://${(0, functionsEmulatorShared_1.formatHost)(databaseEmulator)}/?ns=${ns}`;
         }
         return JSON.stringify({
             storageBucket: this.adminSdkConfig.storageBucket,
@@ -583,8 +605,8 @@ class FunctionsEmulator {
             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);
+    getRuntimeEnvs(backend, triggerDef) {
+        return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, this.getUserEnvs(backend)), this.getSystemEnvs(triggerDef)), this.getEmulatorEnvs()), { FIREBASE_CONFIG: this.getFirebaseConfig() }), backend.env);
     }
     invokeRuntime(frb, opts, runtimeEnv) {
         if (this.workerPool.readyForWork(frb.triggerId)) {
@@ -616,6 +638,12 @@ class FunctionsEmulator {
             cwd: frb.cwd,
             stdio: ["pipe", "pipe", "pipe", "ipc"],
         });
+        if (!childProcess.stderr) {
+            throw new error_1.FirebaseError(`childProcess.stderr is undefined.`);
+        }
+        if (!childProcess.stdout) {
+            throw new error_1.FirebaseError(`childProcess.stdout is undefined.`);
+        }
         const buffers = {
             stderr: { pipe: childProcess.stderr, value: "" },
             stdout: { pipe: childProcess.stdout, value: "" },
@@ -663,16 +691,20 @@ class FunctionsEmulator {
     }
     async reloadTriggers() {
         this.triggerGeneration++;
-        return this.loadTriggers();
+        const loadTriggerPromises = [];
+        for (const backend of this.args.emulatableBackends) {
+            loadTriggerPromises.push(this.loadTriggers(backend));
+        }
+        return Promise.all(loadTriggerPromises);
     }
     async handleBackgroundTrigger(projectId, triggerKey, proto) {
-        const record = this.triggers[triggerKey];
+        const record = this.getTriggerRecordByKey(triggerKey);
         if (record && !record.enabled) {
             return Promise.reject({ code: 204, body: "Background triggers are curently disabled." });
         }
-        const trigger = this.getTriggerDefinitionByKey(triggerKey);
-        const service = functionsEmulatorShared_1.getFunctionService(trigger);
-        const worker = this.startFunctionRuntime(trigger.id, trigger.name, functionsEmulatorShared_1.getSignatureType(trigger), proto);
+        const trigger = record.def;
+        const service = (0, functionsEmulatorShared_1.getFunctionService)(trigger);
+        const worker = this.startFunctionRuntime(record.backend, trigger.id, trigger.name, (0, functionsEmulatorShared_1.getSignatureType)(trigger), proto);
         return new Promise((resolve, reject) => {
             if (projectId !== this.args.projectId) {
                 if (service !== constants_1.Constants.SERVICE_REALTIME_DATABASE) {
@@ -691,7 +723,7 @@ class FunctionsEmulator {
                     reject({ code: 500, body: el.text });
                 }
             });
-            track(EVENT_INVOKE, functionsEmulatorShared_1.getFunctionService(trigger));
+            track(EVENT_INVOKE, (0, functionsEmulatorShared_1.getFunctionService)(trigger));
             worker.waitForDone().then(() => {
                 resolve({ status: "acknowledged" });
             });
@@ -741,7 +773,8 @@ class FunctionsEmulator {
                 .send(`Function ${triggerId} does not exist, valid triggers are: ${Object.keys(this.triggers).join(", ")}`);
             return;
         }
-        const trigger = this.getTriggerDefinitionByKey(triggerId);
+        const record = this.getTriggerRecordByKey(triggerId);
+        const trigger = record.def;
         logger_1.logger.debug(`Accepted request ${method} ${req.url} --> ${triggerId}`);
         const reqBody = req.rawBody;
         const isCallable = trigger.labels && trigger.labels["deployment-callable"] === "true";
@@ -758,7 +791,7 @@ class FunctionsEmulator {
                 req.headers[functionsEmulatorShared_1.HttpConstants.CALLABLE_AUTH_HEADER] = encodeURIComponent(JSON.stringify(contextAuth));
             }
         }
-        const worker = this.startFunctionRuntime(trigger.id, trigger.name, "http", undefined);
+        const worker = this.startFunctionRuntime(record.backend, trigger.id, trigger.name, "http", undefined);
         worker.onLogs((el) => {
             if (el.level === "FATAL") {
                 res.status(500).send(el.text);

package/lib/emulator/functionsEmulatorRuntime.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
 const types_1 = require("./types");
 const functionsEmulatorShared_1 = require("./functionsEmulatorShared");
 const functionsEmulatorUtils_1 = require("./functionsEmulatorUtils");
@@ -54,7 +55,7 @@ class Proxied {
             },
             apply: (target, thisArg, argArray) => {
                 if (this.appliedValue) {
-                    return this.appliedValue.apply(thisArg, argArray);
+                    return this.appliedValue.apply(thisArg);
                 }
                 else {
                     return Proxied.applyOriginal(target, thisArg, argArray);
@@ -115,7 +116,7 @@ async function resolveDeveloperNodeModule(frb, name) {
     if (!resolveResult) {
         return { declared: true, installed: false };
     }
-    const modPackageJSON = require(path.join(functionsEmulatorShared_1.findModuleRoot(name, resolveResult), "package.json"));
+    const modPackageJSON = require(path.join((0, functionsEmulatorShared_1.findModuleRoot)(name, resolveResult), "package.json"));
     const moduleResolution = {
         declared: true,
         installed: true,
@@ -147,7 +148,7 @@ async function verifyDeveloperNodeModules(frb) {
             new types_1.EmulatorLog("SYSTEM", "uninstalled-module", "", modBundle).log();
             return false;
         }
-        if (functionsEmulatorUtils_1.compareVersionStrings(resolution.version, modBundle.minVersion) < 0) {
+        if ((0, functionsEmulatorUtils_1.compareVersionStrings)(resolution.version, modBundle.minVersion) < 0) {
             new types_1.EmulatorLog("SYSTEM", "out-of-date-module", "", modBundle).log();
             return false;
         }
@@ -237,7 +238,7 @@ function initializeNetworkFiltering(frb) {
 }
 async function initializeFirebaseFunctionsStubs(frb) {
     const firebaseFunctionsResolution = await assertResolveDeveloperNodeModule(frb, "firebase-functions");
-    const firebaseFunctionsRoot = functionsEmulatorShared_1.findModuleRoot("firebase-functions", firebaseFunctionsResolution.resolution);
+    const firebaseFunctionsRoot = (0, functionsEmulatorShared_1.findModuleRoot)("firebase-functions", firebaseFunctionsResolution.resolution);
     const httpsProviderResolution = path.join(firebaseFunctionsRoot, "lib/providers/https");
     const httpsProviderV1Resolution = path.join(firebaseFunctionsRoot, "lib/v1/providers/https");
     let httpsProvider;
@@ -318,6 +319,26 @@ function wrapCallableHandler(handler) {
 function getDefaultConfig() {
     return JSON.parse(process.env.FIREBASE_CONFIG || "{}");
 }
+function initializeRuntimeConfig(frb) {
+    if (!process.env.CLOUD_RUNTIME_CONFIG) {
+        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) {
+        }
+    }
+}
 async function initializeFirebaseAdminStubs(frb) {
     const adminResolution = await assertResolveDeveloperNodeModule(frb, "firebase-admin");
     const localAdminModule = require(adminResolution.resolution);
@@ -339,10 +360,10 @@ async function initializeFirebaseAdminStubs(frb) {
         logDebug("initializeApp(DEFAULT)", defaultAppOptions);
         localFunctionsModule.app.setEmulatedAdminApp(defaultApp);
         if (frb.emulators.auth) {
-            if (functionsEmulatorUtils_1.compareVersionStrings(adminResolution.version, "9.3.0") < 0) {
+            if ((0, functionsEmulatorUtils_1.compareVersionStrings)(adminResolution.version, "9.3.0") < 0) {
                 new types_1.EmulatorLog("WARN_ONCE", "runtime-status", "The Firebase Authentication emulator is running, but your 'firebase-admin' dependency is below version 9.3.0, so calls to Firebase Authentication will affect production.").log();
             }
-            else if (functionsEmulatorUtils_1.compareVersionStrings(adminResolution.version, "9.4.2") <= 0) {
+            else if ((0, functionsEmulatorUtils_1.compareVersionStrings)(adminResolution.version, "9.4.2") <= 0) {
                 const auth = defaultApp.auth();
                 if (typeof auth.setJwtVerificationEnabled === "function") {
                     logDebug("auth.setJwtVerificationEnabled(false)", {});
@@ -368,10 +389,10 @@ async function initializeFirebaseAdminStubs(frb) {
         return Proxied.getOriginal(target, "auth");
     })
         .finalize();
-    require.cache[adminResolution.resolution] = {
+    require.cache[adminResolution.resolution] = Object.assign(require.cache[adminResolution.resolution], {
         exports: proxiedAdminModule,
         path: path.dirname(adminResolution.resolution),
-    };
+    });
     logDebug("firebase-admin has been stubbed.", {
         adminResolution,
     });
@@ -435,21 +456,14 @@ async function initializeFunctionsConfigHelper(frb) {
         return proxiedConfig;
     })
         .finalize();
-    require.cache[functionsResolution.resolution] = {
+    require.cache[functionsResolution.resolution] = Object.assign(require.cache[functionsResolution.resolution], {
         exports: proxiedFunctionsModule,
         path: path.dirname(functionsResolution.resolution),
-    };
+    });
     logDebug("firebase-functions has been stubbed.", {
         functionsResolution,
     });
 }
-function setNode10EnvVars(target, mode, service) {
-    process.env.FUNCTION_TARGET = target;
-    process.env.FUNCTION_SIGNATURE_TYPE = mode;
-    process.env.K_SERVICE = service;
-    process.env.K_REVISION = "1";
-    process.env.PORT = "80";
-}
 function rawBodySaver(req, res, buf) {
     req.rawBody = buf;
 }
@@ -590,7 +604,7 @@ async function invokeTrigger(frb, triggers) {
     }).log();
     const trigger = triggers[frb.triggerId];
     logDebug("triggerDefinition", trigger.definition);
-    const signature = functionsEmulatorShared_1.getSignatureType(trigger.definition);
+    const signature = (0, functionsEmulatorShared_1.getSignatureType)(trigger.definition);
     logDebug(`Running ${frb.triggerId} in signature ${signature}`);
     let seconds = 0;
     const timerId = setInterval(() => {
@@ -626,6 +640,7 @@ 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;
     }
+    initializeRuntimeConfig(frb);
     initializeNetworkFiltering(frb);
     await initializeFunctionsConfigHelper(frb);
     await initializeFirebaseFunctionsStubs(frb);
@@ -645,7 +660,7 @@ async function initializeRuntime(frb, serializedFunctionTrigger, extensionTrigge
                 return;
             }
             const modulePath = require.resolve(frb.cwd);
-            const moduleURL = url_1.pathToFileURL(modulePath).href;
+            const moduleURL = (0, url_1.pathToFileURL)(modulePath).href;
             triggerModule = await dynamicImport(moduleURL);
         }
     }
@@ -655,8 +670,8 @@ async function initializeRuntime(frb, serializedFunctionTrigger, extensionTrigge
     else {
         require("../deploy/functions/runtimes/node/extractTriggers")(triggerModule, parsedDefinitions);
     }
-    const triggerDefinitions = functionsEmulatorShared_1.emulatedFunctionsByRegion(parsedDefinitions);
-    const triggers = functionsEmulatorShared_1.getEmulatedTriggersFromDefinitions(triggerDefinitions, triggerModule);
+    const triggerDefinitions = (0, functionsEmulatorShared_1.emulatedFunctionsByRegion)(parsedDefinitions);
+    const triggers = (0, functionsEmulatorShared_1.getEmulatedTriggersFromDefinitions)(triggerDefinitions, triggerModule);
     new types_1.EmulatorLog("SYSTEM", "triggers-parsed", "", { triggers, triggerDefinitions }).log();
     return triggers;
 }

package/lib/emulator/functionsEmulatorShell.js

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

package/lib/emulator/functionsRuntimeWorker.js

@@ -43,7 +43,7 @@ class RuntimeWorker {
     execute(frb, opts) {
         const execFrb = Object.assign({}, frb);
         if (!execFrb.socketPath) {
-            execFrb.socketPath = functionsEmulatorShared_1.getTemporarySocketPath(this.runtime.pid, execFrb.cwd);
+            execFrb.socketPath = (0, functionsEmulatorShared_1.getTemporarySocketPath)(this.runtime.pid, execFrb.cwd);
             this.log(`Assigning socketPath: ${execFrb.socketPath}`);
         }
         const args = { frb: execFrb, opts };

package/lib/emulator/hubExport.js

@@ -36,7 +36,7 @@ class HubExport {
         };
         if (shouldExport(types_1.Emulators.FIRESTORE)) {
             metadata.firestore = {
-                version: downloadableEmulators_1.getDownloadDetails(types_1.Emulators.FIRESTORE).version,
+                version: (0, downloadableEmulators_1.getDownloadDetails)(types_1.Emulators.FIRESTORE).version,
                 path: "firestore_export",
                 metadata_file: "firestore_export/firestore_export.overall_export_metadata",
             };
@@ -44,7 +44,7 @@ class HubExport {
         }
         if (shouldExport(types_1.Emulators.DATABASE)) {
             metadata.database = {
-                version: downloadableEmulators_1.getDownloadDetails(types_1.Emulators.DATABASE).version,
+                version: (0, downloadableEmulators_1.getDownloadDetails)(types_1.Emulators.DATABASE).version,
                 path: "database_export",
             };
             await this.exportDatabase(metadata);

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

@@ -31,7 +31,7 @@ async function isPermitted(opts) {
     return !!permitted;
 }
 function createFirebaseEndpoints(emulator) {
-    const firebaseStorageAPI = express_1.Router();
+    const firebaseStorageAPI = (0, express_1.Router)();
     const { storageLayer } = emulator;
     if (process.env.STORAGE_EMULATOR_DEBUG) {
         firebaseStorageAPI.use((req, res, next) => {
@@ -124,7 +124,7 @@ function createFirebaseEndpoints(emulator) {
                 return;
             }
             if (isGZipped) {
-                data = zlib_1.gunzipSync(data);
+                data = (0, zlib_1.gunzipSync)(data);
             }
             res.setHeader("Accept-Ranges", "bytes");
             res.setHeader("Content-Type", md.contentType);

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

@@ -8,7 +8,7 @@ const metadata_1 = require("../metadata");
 const registry_1 = require("../../registry");
 const emulatorLogger_1 = require("../../emulatorLogger");
 function createCloudEndpoints(emulator) {
-    const gcloudStorageAPI = express_1.Router();
+    const gcloudStorageAPI = (0, express_1.Router)();
     const { storageLayer } = emulator;
     gcloudStorageAPI.use(/.*\/b\/(.+?)\/.*/, (req, res, next) => {
         storageLayer.createBucket(req.params[0]);
@@ -204,7 +204,7 @@ function sendFileBytes(md, storageLayer, req, res) {
     }
     const isGZipped = md.contentEncoding == "gzip";
     if (isGZipped) {
-        data = zlib_1.gunzipSync(data);
+        data = (0, zlib_1.gunzipSync)(data);
     }
     res.setHeader("Accept-Ranges", "bytes");
     res.setHeader("Content-Type", md.contentType);

package/lib/emulator/storage/cloudFunctions.js

@@ -60,7 +60,7 @@ class StorageCloudFunctions {
         const timestamp = new Date();
         return {
             eventId: `${timestamp.getTime()}`,
-            timestamp: metadata_1.toSerializedDate(timestamp),
+            timestamp: (0, metadata_1.toSerializedDate)(timestamp),
             eventType: `google.storage.object.${action}`,
             resource: {
                 service: "storage.googleapis.com",