firebase-tools 11.2.2 → 11.3.0

package/lib/deploy/functions/build.js

@@ -93,7 +93,7 @@ function discoverTrigger(endpoint, paramValues) {
     if ("httpsTrigger" in endpoint) {
         const bkHttps = {};
         if (endpoint.httpsTrigger.invoker) {
-            bkHttps.invoker = [endpoint.httpsTrigger.invoker];
+            bkHttps.invoker = endpoint.httpsTrigger.invoker;
         }
         trigger = { httpsTrigger: bkHttps };
     }
@@ -113,12 +113,22 @@ function discoverTrigger(endpoint, paramValues) {
             eventFilters: bkEventFilters,
             retry: resolveBoolean(endpoint.eventTrigger.retry || false),
         };
+        if (endpoint.eventTrigger.eventFilterPathPatterns) {
+            const bkEventFiltersPathPatterns = {};
+            for (const [key, value] of Object.entries(endpoint.eventTrigger.eventFilterPathPatterns)) {
+                bkEventFiltersPathPatterns[key] = params.resolveString(value, paramValues);
+            }
+            bkEvent.eventFilterPathPatterns = bkEventFiltersPathPatterns;
+        }
         if (endpoint.eventTrigger.serviceAccount) {
             bkEvent.serviceAccountEmail = endpoint.eventTrigger.serviceAccount;
         }
         if (endpoint.eventTrigger.region) {
             bkEvent.region = resolveString(endpoint.eventTrigger.region);
         }
+        if (endpoint.eventTrigger.channel) {
+            bkEvent.channel = endpoint.eventTrigger.channel;
+        }
         trigger = { eventTrigger: bkEvent };
     }
     else if ("scheduleTrigger" in endpoint) {

package/lib/deploy/functions/runtimes/node/parseTriggers.js

@@ -126,7 +126,7 @@ function addResourcesToBuild(projectId, runtime, annotation, want) {
                 logger_1.logger.warn(`Ignoring retry policy for HTTPS function ${annotation.name}`);
             }
             if (annotation.httpsTrigger.invoker) {
-                trigger.invoker = annotation.httpsTrigger.invoker[0];
+                trigger.invoker = annotation.httpsTrigger.invoker;
             }
             triggered = { httpsTrigger: trigger };
         }

package/lib/downloadUtils.js

@@ -20,7 +20,7 @@ async function downloadToTmp(remoteUrl) {
         resolveOnHTTPError: true,
     });
     if (res.status !== 200) {
-        throw new error_1.FirebaseError(`download failed, status ${res.status}`, { exit: 1 });
+        throw new error_1.FirebaseError(`download failed, status ${res.status}: ${await res.response.text()}`);
     }
     const total = parseInt(res.response.headers.get("content-length") || "0", 10);
     const totalMb = Math.ceil(total / 1000000);

package/lib/emulator/downloadableEmulators.js

@@ -55,7 +55,7 @@ exports.DownloadDetails = {
             version: "SNAPSHOT",
             downloadPath: path.join(CACHE_DIR, "ui-vSNAPSHOT.zip"),
             unzipDir: path.join(CACHE_DIR, "ui-vSNAPSHOT"),
-            binaryPath: path.join(CACHE_DIR, "ui-vSNAPSHOT", "server.bundle.js"),
+            binaryPath: path.join(CACHE_DIR, "ui-vSNAPSHOT", "server", "server.js"),
             opts: {
                 cacheDir: CACHE_DIR,
                 remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/ui-vSNAPSHOT.zip",
@@ -67,15 +67,15 @@ exports.DownloadDetails = {
             },
         }
         : {
-            version: "1.7.0",
-            downloadPath: path.join(CACHE_DIR, "ui-v1.7.0.zip"),
-            unzipDir: path.join(CACHE_DIR, "ui-v1.7.0"),
-            binaryPath: path.join(CACHE_DIR, "ui-v1.7.0", "server.bundle.js"),
+            version: "1.8.1",
+            downloadPath: path.join(CACHE_DIR, "ui-v1.8.1.zip"),
+            unzipDir: path.join(CACHE_DIR, "ui-v1.8.1"),
+            binaryPath: path.join(CACHE_DIR, "ui-v1.8.1", "server", "server.js"),
             opts: {
                 cacheDir: CACHE_DIR,
-                remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/ui-v1.7.0.zip",
-                expectedSize: 4053708,
-                expectedChecksum: "aea9ae19091df5974a88a8847aaf127c",
+                remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/ui-v1.8.1.zip",
+                expectedSize: 3056552,
+                expectedChecksum: "92590fdda20f9883588438d9551111b5",
                 namePrefix: "ui",
             },
         },

package/lib/emulator/functionsEmulatorRuntime.js

@@ -104,7 +104,7 @@ class Proxied {
         return this.proxy;
     }
 }
-async function resolveDeveloperNodeModule(frb, name) {
+async function resolveDeveloperNodeModule(name) {
     const pkg = requirePackageJson();
     if (!pkg) {
         new types_1.EmulatorLog("SYSTEM", "missing-package-json", "").log();
@@ -130,20 +130,20 @@ async function resolveDeveloperNodeModule(frb, name) {
     logDebug(`Resolved module ${name}`, moduleResolution);
     return moduleResolution;
 }
-async function assertResolveDeveloperNodeModule(frb, name) {
-    const resolution = await resolveDeveloperNodeModule(frb, name);
+async function assertResolveDeveloperNodeModule(name) {
+    const resolution = await resolveDeveloperNodeModule(name);
     if (!(resolution.installed && resolution.declared && resolution.resolution && resolution.version)) {
         throw new Error(`Assertion failure: could not fully resolve ${name}: ${JSON.stringify(resolution)}`);
     }
     return resolution;
 }
-async function verifyDeveloperNodeModules(frb) {
+async function verifyDeveloperNodeModules() {
     const modBundles = [
         { name: "firebase-admin", isDev: false, minVersion: "8.9.0" },
         { name: "firebase-functions", isDev: false, minVersion: "3.13.1" },
     ];
     for (const modBundle of modBundles) {
-        const resolution = await resolveDeveloperNodeModule(frb, modBundle.name);
+        const resolution = await resolveDeveloperNodeModule(modBundle.name);
         if (!resolution.declared) {
             new types_1.EmulatorLog("SYSTEM", "missing-module", "", modBundle).log();
             return false;
@@ -240,8 +240,8 @@ function initializeNetworkFiltering() {
     });
     logDebug("Outgoing network have been stubbed.", results);
 }
-async function initializeFirebaseFunctionsStubs(frb) {
-    const firebaseFunctionsResolution = await assertResolveDeveloperNodeModule(frb, "firebase-functions");
+async function initializeFirebaseFunctionsStubs() {
+    const firebaseFunctionsResolution = await assertResolveDeveloperNodeModule("firebase-functions");
     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");
@@ -343,10 +343,10 @@ function initializeRuntimeConfig() {
         }
     }
 }
-async function initializeFirebaseAdminStubs(frb) {
-    const adminResolution = await assertResolveDeveloperNodeModule(frb, "firebase-admin");
+async function initializeFirebaseAdminStubs() {
+    const adminResolution = await assertResolveDeveloperNodeModule("firebase-admin");
     const localAdminModule = require(adminResolution.resolution);
-    const functionsResolution = await assertResolveDeveloperNodeModule(frb, "firebase-functions");
+    const functionsResolution = await assertResolveDeveloperNodeModule("firebase-functions");
     const localFunctionsModule = require(functionsResolution.resolution);
     const defaultConfig = getDefaultConfig();
     const adminModuleProxy = new Proxied(localAdminModule);
@@ -360,7 +360,7 @@ async function initializeFirebaseAdminStubs(frb) {
         new types_1.EmulatorLog("SYSTEM", "default-admin-app-used", `config=${defaultAppOptions}`, {
             opts: defaultAppOptions,
         }).log();
-        const defaultApp = makeProxiedFirebaseApp(frb, adminModuleTarget.initializeApp(defaultAppOptions));
+        const defaultApp = makeProxiedFirebaseApp(adminModuleTarget.initializeApp(defaultAppOptions));
         logDebug("initializeApp(DEFAULT)", defaultAppOptions);
         localFunctionsModule.app.setEmulatedAdminApp(defaultApp);
         if (process.env[constants_1.Constants.FIREBASE_AUTH_EMULATOR_HOST]) {
@@ -405,7 +405,7 @@ async function initializeFirebaseAdminStubs(frb) {
         adminResolution,
     });
 }
-function makeProxiedFirebaseApp(frb, original) {
+function makeProxiedFirebaseApp(original) {
     const appProxy = new Proxied(original);
     return appProxy
         .when("firestore", (target) => {
@@ -450,8 +450,8 @@ function warnAboutStorageProd() {
     }
     new types_1.EmulatorLog("WARN_ONCE", "runtime-status", "The Firebase Storage emulator is not running, so calls to Firebase Storage will affect production.").log();
 }
-async function initializeFunctionsConfigHelper(frb) {
-    const functionsResolution = await assertResolveDeveloperNodeModule(frb, "firebase-functions");
+async function initializeFunctionsConfigHelper() {
+    const functionsResolution = await assertResolveDeveloperNodeModule("firebase-functions");
     const localFunctionsModule = require(functionsResolution.resolution);
     logDebug("Checked functions.config()", {
         config: localFunctionsModule.config(),
@@ -487,27 +487,7 @@ function rawBodySaver(req, res, buf) {
 }
 async function processHTTPS(trigger) {
     const ephemeralServer = express();
-    const functionRouter = express.Router();
     await new Promise((resolveEphemeralServer, rejectEphemeralServer) => {
-        const handler = async (req, res) => {
-            try {
-                logDebug(`Ephemeral server handling ${req.method} request`);
-                res.on("finish", () => {
-                    instance.close((err) => {
-                        if (err) {
-                            rejectEphemeralServer(err);
-                        }
-                        else {
-                            resolveEphemeralServer();
-                        }
-                    });
-                });
-                await runHTTPS(trigger, [req, res]);
-            }
-            catch (err) {
-                rejectEphemeralServer(err);
-            }
-        };
         ephemeralServer.enable("trust proxy");
         ephemeralServer.use(bodyParser.json({
             limit: "10mb",
@@ -527,14 +507,39 @@ async function processHTTPS(trigger) {
             limit: "10mb",
             verify: rawBodySaver,
         }));
-        functionRouter.all("*", handler);
-        ephemeralServer.use([`/`, `/*`], functionRouter);
-        logDebug(`Attempting to listen to port: ${process.env.PORT}`);
-        const instance = ephemeralServer.listen(process.env.PORT, () => {
-            logDebug(`Listening to port: ${process.env.PORT}`);
-            new types_1.EmulatorLog("SYSTEM", "runtime-status", "ready", { state: "ready" }).log();
+        let server;
+        function closeServer() {
+            if (server) {
+                server.close((err) => {
+                    if (err) {
+                        rejectEphemeralServer(err);
+                    }
+                    else {
+                        resolveEphemeralServer();
+                    }
+                });
+            }
+        }
+        ephemeralServer.get("/__/health", (req, res) => {
+            res.status(200).send();
         });
-        instance.on("error", rejectEphemeralServer);
+        ephemeralServer.all("/favicon.ico|/robots.txt", (req, res) => {
+            res.on("finish", closeServer);
+            res.status(404).send();
+        });
+        ephemeralServer.all(`/*`, async (req, res) => {
+            try {
+                logDebug(`Ephemeral server handling ${req.method} request`);
+                res.on("finish", closeServer);
+                await runHTTPS(trigger, [req, res]);
+            }
+            catch (err) {
+                rejectEphemeralServer(err);
+            }
+        });
+        logDebug(`Attempting to listen to port: ${process.env.PORT}`);
+        server = ephemeralServer.listen(process.env.PORT);
+        server.on("error", rejectEphemeralServer);
     });
 }
 async function processBackground(trigger, frb, signature) {
@@ -587,7 +592,7 @@ async function runHTTPS(trigger, args) {
         return trigger(args[0], args[1]);
     });
 }
-async function moduleResolutionDetective(frb, error) {
+async function moduleResolutionDetective(error) {
     const clues = {
         tsconfigJSON: await requireAsync("./tsconfig.json", { paths: [process.cwd()] }).catch(noOp),
         packageJSON: await requireAsync("./package.json", { paths: [process.cwd()] }).catch(noOp),
@@ -645,7 +650,7 @@ async function invokeTrigger(trigger, frb) {
     clearInterval(timerId);
     new types_1.EmulatorLog("INFO", "runtime-status", `Finished "${FUNCTION_TARGET_NAME}" in ~${Math.max(seconds, 1)}s`).log();
 }
-async function initializeRuntime(frb) {
+async function initializeRuntime() {
     FUNCTION_DEBUG_MODE = process.env.FUNCTION_DEBUG_MODE || "";
     if (!FUNCTION_DEBUG_MODE) {
         FUNCTION_TARGET_NAME = process.env.FUNCTION_TARGET || "";
@@ -659,19 +664,18 @@ async function initializeRuntime(frb) {
             await flushAndExit(1);
         }
     }
-    logDebug(`Disabled runtime features: ${JSON.stringify(frb.disabled_features)}`);
-    const verified = await verifyDeveloperNodeModules(frb);
+    const verified = await verifyDeveloperNodeModules();
     if (!verified) {
         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();
     initializeNetworkFiltering();
-    await initializeFunctionsConfigHelper(frb);
-    await initializeFirebaseFunctionsStubs(frb);
-    await initializeFirebaseAdminStubs(frb);
+    await initializeFunctionsConfigHelper();
+    await initializeFirebaseFunctionsStubs();
+    await initializeFirebaseAdminStubs();
 }
-async function loadTriggers(frb, serializedFunctionTrigger) {
+async function loadTriggers(serializedFunctionTrigger) {
     let triggerModule;
     if (serializedFunctionTrigger) {
         triggerModule = eval(serializedFunctionTrigger)();
@@ -682,7 +686,7 @@ async function loadTriggers(frb, serializedFunctionTrigger) {
         }
         catch (err) {
             if (err.code !== "ERR_REQUIRE_ESM") {
-                await moduleResolutionDetective(frb, err);
+                await moduleResolutionDetective(err);
                 throw err;
             }
             const modulePath = require.resolve(process.cwd());
@@ -712,9 +716,8 @@ async function handleMessage(message) {
     }
     if (!functionModule) {
         try {
-            await initializeRuntime(runtimeArgs.frb);
             const serializedTriggers = runtimeArgs.opts ? runtimeArgs.opts.serializedTriggers : undefined;
-            functionModule = await loadTriggers(runtimeArgs.frb, serializedTriggers);
+            functionModule = await loadTriggers(serializedTriggers);
         }
         catch (e) {
             logDebug(e);
@@ -748,7 +751,7 @@ async function handleMessage(message) {
         await flushAndExit(1);
     }
 }
-function main() {
+async function main() {
     let lastSignal = new Date().getTime();
     let signalCount = 0;
     process.on("SIGINT", () => {
@@ -762,10 +765,7 @@ function main() {
             process.exit(1);
         }
     });
-    logDebug("Functions runtime initialized.", {
-        cwd: process.cwd(),
-        node_version: process.versions.node,
-    });
+    await initializeRuntime();
     let messageHandlePromise = Promise.resolve();
     process.on("message", (message) => {
         messageHandlePromise = messageHandlePromise
@@ -780,5 +780,15 @@ function main() {
     });
 }
 if (require.main === module) {
-    main();
+    main()
+        .then(() => {
+        logDebug("Functions runtime initialized.", {
+            cwd: process.cwd(),
+            node_version: process.versions.node,
+        });
+    })
+        .catch((err) => {
+        new types_1.EmulatorLog("FATAL", "runtime-error", err.message || err, err).log();
+        return flushAndExit(1);
+    });
 }

package/lib/emulator/functionsRuntimeWorker.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RuntimeWorkerPool = exports.RuntimeWorker = exports.RuntimeWorkerState = void 0;
+const http = require("http");
 const uuid = require("uuid");
 const types_1 = require("./types");
 const events_1 = require("events");
@@ -49,17 +50,11 @@ class RuntimeWorker {
         return this._state;
     }
     set state(state) {
-        if (state === RuntimeWorkerState.BUSY) {
-            this.socketReady = types_1.EmulatorLog.waitForLog(this.runtime.events, "SYSTEM", "runtime-status", (el) => {
-                return el.data.state === "ready";
-            });
-        }
         if (state === RuntimeWorkerState.IDLE) {
             for (const l of this.logListeners) {
                 this.runtime.events.removeListener("log", l);
             }
             this.logListeners = [];
-            this.socketReady = undefined;
         }
         if (state === RuntimeWorkerState.FINISHED) {
             this.runtime.events.removeAllListeners();
@@ -88,9 +83,40 @@ class RuntimeWorker {
             this.stateEvents.once(RuntimeWorkerState.FINISHED, listener);
         });
     }
-    waitForSocketReady() {
-        return (this.socketReady ||
-            Promise.reject(new Error("Cannot call waitForSocketReady() if runtime is not BUSY")));
+    isSocketReady() {
+        return new Promise((resolve, reject) => {
+            const req = http
+                .request({
+                method: "GET",
+                path: "/__/health",
+                socketPath: this.runtime.socketPath,
+            }, () => resolve())
+                .end();
+            req.on("error", (error) => {
+                reject(error);
+            });
+        });
+    }
+    async waitForSocketReady() {
+        const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+        const timeout = new Promise((resolve, reject) => {
+            setTimeout(() => {
+                reject(new error_1.FirebaseError("Failed to load function."));
+            }, 7000);
+        });
+        while (true) {
+            try {
+                await Promise.race([this.isSocketReady(), timeout]);
+                break;
+            }
+            catch (err) {
+                if (["ECONNREFUSED", "ENOENT"].includes(err === null || err === void 0 ? void 0 : err.code)) {
+                    await sleep(100);
+                    continue;
+                }
+                throw err;
+            }
+        }
     }
     log(msg) {
         emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.FUNCTIONS).log("DEBUG", `[worker-${this.key}-${this.id}]: ${msg}`);

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

@@ -324,7 +324,7 @@ function sendFileBytes(md, data, req, res) {
     res.setHeader("Accept-Ranges", "bytes");
     res.setHeader("Content-Type", md.contentType);
     res.setHeader("Content-Disposition", md.contentDisposition);
-    res.setHeader("Content-Encoding", md.contentEncoding);
+    res.setHeader("Content-Encoding", isGZipped ? "identity" : md.contentEncoding);
     res.setHeader("ETag", md.etag);
     res.setHeader("Cache-Control", md.cacheControl);
     res.setHeader("x-goog-generation", `${md.generation}`);

package/lib/gcp/runtimeconfig.js

@@ -48,7 +48,7 @@ function listVariables(configPath) {
         retryCodes: [500, 503],
     })
         .then((resp) => {
-        return Promise.resolve(resp.body.variables);
+        return Promise.resolve(resp.body.variables || []);
     });
 }
 function getVariable(varPath) {

package/lib/requireConfig.js

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.requireConfig = void 0;
 const error_1 = require("./error");
 async function requireConfig(options) {
-    await Promise.resolve();
-    if (!options.config) {
-        throw options.configError
-            ? options.configError
-            : new error_1.FirebaseError("Not in a Firebase project directory (could not locate firebase.json)");
-    }
+    return new Promise((resolve, reject) => {
+        var _a;
+        return options.config
+            ? resolve()
+            : reject((_a = options.configError) !== null && _a !== void 0 ? _a : new error_1.FirebaseError("Not in a Firebase project directory (could not locate firebase.json)"));
+    });
 }
 exports.requireConfig = requireConfig;

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "firebase-tools",
-  "version": "11.2.2",
+  "version": "11.3.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "firebase-tools",
-      "version": "11.2.2",
+      "version": "11.3.0",
       "license": "MIT",
       "dependencies": {
         "@google-cloud/pubsub": "^3.0.1",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firebase-tools",
-  "version": "11.2.2",
+  "version": "11.3.0",
   "description": "Command-Line Interface for Firebase",
   "main": "./lib/index.js",
   "bin": {