firebase-tools 11.9.0 → 11.10.0

package/lib/emulator/functionsEmulator.js

@@ -25,7 +25,6 @@ const workQueue_1 = require("./workQueue");
 const utils_1 = require("../utils");
 const defaultCredentials_1 = require("../defaultCredentials");
 const adminSdkConfig_1 = require("./adminSdkConfig");
-const types_2 = require("./events/types");
 const validate_1 = require("../deploy/functions/validate");
 const secretManager_1 = require("../gcp/secretManager");
 const runtimes = require("../deploy/functions/runtimes");
@@ -99,32 +98,6 @@ class FunctionsEmulator {
         const multicastFunctionRoute = `/functions/projects/:project_id/trigger_multicast`;
         const httpsFunctionRoutes = [httpsFunctionRoute, `${httpsFunctionRoute}/*`];
         const listBackendsRoute = `/backends`;
-        const backgroundHandler = (req, res) => {
-            var _a;
-            const triggerId = req.params.trigger_name;
-            const projectId = req.params.project_id;
-            const reqBody = req.rawBody;
-            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)
-                    .then((x) => res.json(x))
-                    .catch((errorBundle) => {
-                    if (errorBundle.body) {
-                        res.status(errorBundle.code).send(errorBundle.body);
-                    }
-                    else {
-                        res.sendStatus(errorBundle.code);
-                    }
-                });
-            });
-        };
         const httpsHandler = (req, res) => {
             this.workQueue.submit(() => {
                 return this.handleHttpsTrigger(req, res);
@@ -133,27 +106,34 @@ class FunctionsEmulator {
         const multicastHandler = (req, res) => {
             var _a;
             const projectId = req.params.project_id;
-            const reqBody = req.rawBody;
-            let proto = JSON.parse(reqBody.toString());
+            const rawBody = req.rawBody;
+            const event = JSON.parse(rawBody.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;
-                }
+                triggerKey = `${this.args.projectId}:${event.type}`;
             }
             else {
-                triggerKey = `${this.args.projectId}:${proto.eventType}`;
+                triggerKey = `${this.args.projectId}:${event.eventType}`;
             }
-            if (proto.data.bucket) {
-                triggerKey += `:${proto.data.bucket}`;
+            if (event.data.bucket) {
+                triggerKey += `:${event.data.bucket}`;
             }
             const triggers = this.multicastTriggers[triggerKey] || [];
+            const { host, port } = this.getInfo();
             triggers.forEach((triggerId) => {
                 this.workQueue.submit(() => {
-                    this.logger.log("DEBUG", `Accepted multicast request ${req.method} ${req.url} --> ${triggerId}`);
-                    return this.handleBackgroundTrigger(projectId, triggerId, proto);
+                    return new Promise((resolve, reject) => {
+                        const trigReq = http.request({
+                            host,
+                            port,
+                            method: req.method,
+                            path: `/functions/projects/${projectId}/triggers/${triggerId}`,
+                            headers: req.headers,
+                        }, resolve);
+                        trigReq.on("error", reject);
+                        trigReq.write(rawBody);
+                        trigReq.end();
+                    });
                 });
             });
             res.json({ status: "multicast_acknowledged" });
@@ -162,7 +142,7 @@ class FunctionsEmulator {
             res.json({ backends: this.getBackendInfo() });
         };
         hub.get(listBackendsRoute, cors({ origin: true }), listBackendsHandler);
-        hub.post(backgroundFunctionRoute, dataMiddleware, backgroundHandler);
+        hub.post(backgroundFunctionRoute, dataMiddleware, httpsHandler);
         hub.post(multicastFunctionRoute, dataMiddleware, multicastHandler);
         hub.all(httpsFunctionRoutes, dataMiddleware, httpsHandler);
         hub.all("*", dataMiddleware, (req, res) => {
@@ -171,26 +151,28 @@ class FunctionsEmulator {
         });
         return hub;
     }
-    async invokeTrigger(trigger, proto, runtimeOpts) {
+    async sendRequest(trigger, body) {
         const record = this.getTriggerRecordByKey(this.getTriggerKey(trigger));
-        const backend = record.backend;
-        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.`);
+        const pool = this.workerPools[record.backend.codebase];
+        if (!pool.readyForWork(trigger.id)) {
+            await this.startRuntime(record.backend, trigger);
         }
-        const opts = runtimeOpts || {
-            nodeBinary: backend.nodeBinary,
-            extensionTriggers: backend.predefinedTriggers,
+        const worker = pool.getIdleWorker(trigger.id);
+        const reqBody = JSON.stringify(body);
+        const headers = {
+            "Content-Type": "application/json",
+            "Content-Length": `${reqBody.length}`,
         };
-        const worker = await this.invokeRuntime(backend, trigger, runtimeBundle, opts);
-        return worker;
+        return new Promise((resolve, reject) => {
+            const req = http.request({
+                path: `/`,
+                socketPath: worker.runtime.socketPath,
+                headers: headers,
+            }, resolve);
+            req.on("error", reject);
+            req.write(reqBody);
+            req.end();
+        });
     }
     async start() {
         for (const backend of this.args.emulatableBackends) {
@@ -272,14 +254,15 @@ class FunctionsEmulator {
             logger_1.logger.debug(`Building ${runtimeDelegate.name} source`);
             await runtimeDelegate.build();
             logger_1.logger.debug(`Analyzing ${runtimeDelegate.name} backend spec`);
-            const environment = Object.assign(Object.assign(Object.assign(Object.assign({}, this.getSystemEnvs()), this.getEmulatorEnvs()), { FIREBASE_CONFIG: this.getFirebaseConfig() }), emulatableBackend.env);
+            const firebaseConfig = this.getFirebaseConfig();
+            const environment = Object.assign(Object.assign(Object.assign(Object.assign({}, this.getSystemEnvs()), this.getEmulatorEnvs()), { FIREBASE_CONFIG: firebaseConfig }), emulatableBackend.env);
             const userEnvOpt = {
                 functionsSource: emulatableBackend.functionsDir,
                 projectId: this.args.projectId,
                 projectAlias: this.args.projectAlias,
             };
             const discoveredBuild = await runtimeDelegate.discoverBuild(runtimeConfig, environment);
-            const resolution = await (0, build_1.resolveBackend)(discoveredBuild, userEnvOpt, environment);
+            const resolution = await (0, build_1.resolveBackend)(discoveredBuild, JSON.parse(firebaseConfig), userEnvOpt, environment);
             const discoveredBackend = resolution.backend;
             const endpoints = backend.allEndpoints(discoveredBackend);
             (0, functionsEmulatorShared_1.prepareEndpoints)(endpoints);
@@ -329,8 +312,8 @@ class FunctionsEmulator {
             }
             let added = false;
             let url = undefined;
+            const { host, port } = this.getInfo();
             if (definition.httpsTrigger) {
-                const { host, port } = this.getInfo();
                 added = true;
                 url = FunctionsEmulator.getHttpFunctionUrl(host, port, this.args.projectId, definition.name, definition.region);
             }
@@ -387,7 +370,7 @@ class FunctionsEmulator {
             }
         }
         if (this.args.debugPort) {
-            await this.startRuntime(emulatableBackend, { nodeBinary: emulatableBackend.nodeBinary });
+            await this.startRuntime(emulatableBackend);
         }
     }
     addEventarcTrigger(projectId, key, eventTrigger) {
@@ -620,12 +603,6 @@ class FunctionsEmulator {
         this.triggers = {};
         triggers.forEach((def) => this.addTriggerRecord(def, { backend, ignored: false }));
     }
-    getBaseBundle() {
-        return {
-            proto: {},
-            disabled_features: this.args.disabledRuntimeFeatures,
-        };
-    }
     getNodeBinary(backend) {
         const pkg = require(path.join(backend.functionsDir, "package.json"));
         if ((!pkg.engines || !pkg.engines.node) && !backend.nodeMajorVersion) {
@@ -808,24 +785,13 @@ class FunctionsEmulator {
         }
         return secretEnvs;
     }
-    async invokeRuntime(backend, trigger, frb, opts) {
-        const pool = this.workerPools[backend.codebase];
-        if (!pool.readyForWork(trigger.id)) {
-            await this.startRuntime(backend, opts, trigger);
-        }
-        return pool.submitWork(trigger.id, frb, opts);
-    }
-    async startRuntime(backend, opts, trigger) {
+    async startRuntime(backend, 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) {
-                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`);
+            if (process.env.FIREPIT_VERSION && process.execPath === backend.nodeBinary) {
+                this.logger.log("WARN", `To enable function inspection, please run "${process.execPath} is:npm i node@${backend.nodeMajorVersion} --save-dev" in your functions directory`);
             }
             else {
                 const { host } = this.getInfo();
@@ -841,9 +807,9 @@ class FunctionsEmulator {
         const runtimeEnv = this.getRuntimeEnvs(backend, trigger);
         const secretEnvs = await this.resolveSecretEnvs(backend, trigger);
         const socketPath = (0, functionsEmulatorShared_1.getTemporarySocketPath)();
-        const childProcess = spawn(opts.nodeBinary, args, {
+        const childProcess = spawn(backend.nodeBinary, args, {
             cwd: backend.functionsDir,
-            env: Object.assign(Object.assign(Object.assign(Object.assign({ node: opts.nodeBinary }, process.env), runtimeEnv), secretEnvs), { PORT: socketPath }),
+            env: Object.assign(Object.assign(Object.assign(Object.assign({ node: backend.nodeBinary }, process.env), runtimeEnv), secretEnvs), { PORT: socketPath }),
             stdio: ["pipe", "pipe", "pipe", "ipc"],
         });
         const runtime = {
@@ -857,8 +823,9 @@ class FunctionsEmulator {
             ref: (_a = backend.extensionVersion) === null || _a === void 0 ? void 0 : _a.ref,
         };
         const pool = this.workerPools[backend.codebase];
-        pool.addWorker(trigger === null || trigger === void 0 ? void 0 : trigger.id, runtime, extensionLogInfo);
-        return;
+        const worker = pool.addWorker(trigger === null || trigger === void 0 ? void 0 : trigger.id, runtime, extensionLogInfo);
+        await worker.waitForSocketReady();
+        return worker;
     }
     async disableBackgroundTriggers() {
         Object.values(this.triggers).forEach((record) => {
@@ -877,41 +844,6 @@ class FunctionsEmulator {
         await this.performPostLoadOperations();
         return;
     }
-    async handleBackgroundTrigger(projectId, triggerKey, proto) {
-        const record = this.getTriggerRecordByKey(triggerKey);
-        if (record && !record.enabled) {
-            return Promise.reject({ code: 204, body: "Background triggers are curently disabled." });
-        }
-        const trigger = record.def;
-        const service = (0, functionsEmulatorShared_1.getFunctionService)(trigger);
-        const worker = await this.invokeTrigger(trigger, proto);
-        return new Promise((resolve, reject) => {
-            if (projectId !== this.args.projectId) {
-                if (service !== constants_1.Constants.SERVICE_REALTIME_DATABASE) {
-                    logger_1.logger.debug(`Received functions trigger for service "${service}" for unknown project "${projectId}".`);
-                    reject({ code: 404 });
-                    return;
-                }
-                if (!trigger.eventTrigger.resource.startsWith(`projects/_/instances/${projectId}`)) {
-                    logger_1.logger.debug(`Received functions trigger for function "${trigger.name}" of project "${projectId}" that did not match definition: ${JSON.stringify(trigger)}.`);
-                    reject({ code: 404 });
-                    return;
-                }
-            }
-            worker.onLogs((el) => {
-                if (el.level === "FATAL") {
-                    reject({ code: 500, body: el.text });
-                }
-            });
-            void (0, track_1.track)(EVENT_INVOKE, (0, functionsEmulatorShared_1.getFunctionService)(trigger));
-            void (0, track_1.trackEmulator)(EVENT_INVOKE_GA4, {
-                function_service: (0, functionsEmulatorShared_1.getFunctionService)(trigger),
-            });
-            worker.waitForDone().then(() => {
-                resolve({ status: "acknowledged" });
-            });
-        });
-    }
     getEmulatorInfo(emulator) {
         if (this.args.remoteEmulators) {
             if (this.args.remoteEmulators[emulator]) {
@@ -947,9 +879,10 @@ class FunctionsEmulator {
     }
     async handleHttpsTrigger(req, res) {
         const method = req.method;
-        const region = req.params.region;
-        const triggerName = req.params.trigger_name;
-        const triggerId = `${region}-${triggerName}`;
+        let triggerId = req.params.trigger_name;
+        if (req.params.region) {
+            triggerId = `${req.params.region}-${triggerId}`;
+        }
         if (!this.triggers[triggerId]) {
             res
                 .status(404)
@@ -974,62 +907,29 @@ class FunctionsEmulator {
                 req.headers[functionsEmulatorShared_1.HttpConstants.CALLABLE_AUTH_HEADER] = encodeURIComponent(JSON.stringify(contextAuth));
             }
         }
-        const worker = await this.invokeTrigger(trigger);
-        worker.onLogs((el) => {
-            if (el.level === "FATAL") {
-                res.status(500).send(el.text);
-            }
-        });
-        await worker.waitForSocketReady();
-        void (0, track_1.track)(EVENT_INVOKE, "https");
+        void (0, track_1.track)(EVENT_INVOKE, (0, functionsEmulatorShared_1.getFunctionService)(trigger));
         void (0, track_1.trackEmulator)(EVENT_INVOKE_GA4, {
-            function_service: "https",
+            function_service: (0, functionsEmulatorShared_1.getFunctionService)(trigger),
         });
         this.logger.log("DEBUG", `[functions] Runtime ready! Sending request!`);
         const url = new url_1.URL(`${req.protocol}://${req.hostname}${req.url}`);
-        const path = `${url.pathname}${url.search}`.replace(new RegExp(`\/${this.args.projectId}\/[^\/]*\/${triggerName}\/?`), "/");
+        const path = `${url.pathname}${url.search}`.replace(new RegExp(`\/${this.args.projectId}\/[^\/]*\/${req.params.trigger_name}\/?`), "/");
         this.logger.log("DEBUG", `[functions] Got req.url=${req.url}, mapping to path=${path}`);
-        const runtimeReq = http.request({
+        const pool = this.workerPools[record.backend.codebase];
+        if (!pool.readyForWork(trigger.id)) {
+            await this.startRuntime(record.backend, trigger);
+        }
+        const debugBundle = this.args.debugPort
+            ? {
+                functionTarget: trigger.entryPoint,
+                functionSignature: (0, functionsEmulatorShared_1.getSignatureType)(trigger),
+            }
+            : undefined;
+        await pool.submitRequest(trigger.id, {
             method,
             path,
             headers: req.headers,
-            socketPath: worker.runtime.socketPath,
-        }, (runtimeRes) => {
-            function forwardStatusAndHeaders() {
-                res.status(runtimeRes.statusCode || 200);
-                if (!res.headersSent) {
-                    Object.keys(runtimeRes.headers).forEach((key) => {
-                        const val = runtimeRes.headers[key];
-                        if (val) {
-                            res.setHeader(key, val);
-                        }
-                    });
-                }
-            }
-            runtimeRes.on("data", (buf) => {
-                forwardStatusAndHeaders();
-                res.write(buf);
-            });
-            runtimeRes.on("close", () => {
-                forwardStatusAndHeaders();
-                res.end();
-            });
-            runtimeRes.on("end", () => {
-                forwardStatusAndHeaders();
-                res.end();
-            });
-        });
-        runtimeReq.on("error", () => {
-            res.end();
-        });
-        if (reqBody) {
-            runtimeReq.write(reqBody);
-            runtimeReq.end();
-        }
-        req.pipe(runtimeReq, { end: true }).on("error", () => {
-            res.end();
-        });
-        await worker.waitForDone();
+        }, res, reqBody, debugBundle);
     }
 }
 exports.FunctionsEmulator = FunctionsEmulator;