firebase-tools 11.6.0 → 11.8.1

package/lib/emulator/functionsEmulator.js

@@ -54,7 +54,11 @@ class FunctionsEmulator {
         const mode = this.args.debugPort
             ? types_1.FunctionsExecutionMode.SEQUENTIAL
             : types_1.FunctionsExecutionMode.AUTO;
-        this.workerPool = new functionsRuntimeWorker_1.RuntimeWorkerPool(mode);
+        this.workerPools = {};
+        for (const backend of this.args.emulatableBackends) {
+            const pool = new functionsRuntimeWorker_1.RuntimeWorkerPool(mode);
+            this.workerPools[backend.codebase] = pool;
+        }
         this.workQueue = new workQueue_1.WorkQueue(mode);
     }
     static getHttpFunctionUrl(host, port, projectId, name, region) {
@@ -241,7 +245,9 @@ class FunctionsEmulator {
             this.logger.logLabeled("WARN", "functions", "Functions emulator work queue did not empty before stopping");
         }
         this.workQueue.stop();
-        this.workerPool.exit();
+        for (const pool of Object.values(this.workerPools)) {
+            pool.exit();
+        }
         if (this.destroyServer) {
             await this.destroyServer();
         }
@@ -273,7 +279,8 @@ class FunctionsEmulator {
                 projectAlias: this.args.projectAlias,
             };
             const discoveredBuild = await runtimeDelegate.discoverBuild(runtimeConfig, environment);
-            const discoveredBackend = await (0, build_1.resolveBackend)(discoveredBuild, userEnvOpt, environment);
+            const resolution = await (0, build_1.resolveBackend)(discoveredBuild, userEnvOpt, environment);
+            const discoveredBackend = resolution.backend;
             const endpoints = backend.allEndpoints(discoveredBackend);
             (0, functionsEmulatorShared_1.prepareEndpoints)(endpoints);
             for (const e of endpoints) {
@@ -297,7 +304,7 @@ class FunctionsEmulator {
             this.logger.logLabeled("ERROR", "functions", `Failed to load function definition from source: ${e}`);
             return;
         }
-        this.workerPool.refresh();
+        this.workerPools[emulatableBackend.codebase].refresh();
         this.blockingFunctionsConfig = {};
         const toSetup = triggerDefinitions.filter((definition) => {
             if (force) {
@@ -380,7 +387,7 @@ class FunctionsEmulator {
             }
         }
         if (this.args.debugPort) {
-            this.startRuntime(emulatableBackend, { nodeBinary: emulatableBackend.nodeBinary });
+            await this.startRuntime(emulatableBackend, { nodeBinary: emulatableBackend.nodeBinary });
         }
     }
     addEventarcTrigger(projectId, key, eventTrigger) {
@@ -802,10 +809,11 @@ class FunctionsEmulator {
         return secretEnvs;
     }
     async invokeRuntime(backend, trigger, frb, opts) {
-        if (!this.workerPool.readyForWork(trigger.id)) {
+        const pool = this.workerPools[backend.codebase];
+        if (!pool.readyForWork(trigger.id)) {
             await this.startRuntime(backend, opts, trigger);
         }
-        return this.workerPool.submitWork(trigger.id, frb, opts);
+        return pool.submitWork(trigger.id, frb, opts);
     }
     async startRuntime(backend, opts, trigger) {
         var _a;
@@ -838,52 +846,18 @@ class FunctionsEmulator {
             env: Object.assign(Object.assign(Object.assign(Object.assign({ node: opts.nodeBinary }, process.env), runtimeEnv), secretEnvs), { PORT: socketPath }),
             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: "" },
-        };
-        const ipcBuffer = { value: "" };
-        childProcess.on("message", (message) => {
-            this.onData(childProcess, emitter, ipcBuffer, message);
-        });
-        for (const id in buffers) {
-            if (buffers.hasOwnProperty(id)) {
-                const buffer = buffers[id];
-                buffer.pipe.on("data", (buf) => {
-                    this.onData(childProcess, emitter, buffer, buf);
-                });
-            }
-        }
         const runtime = {
-            pid: childProcess.pid,
-            exit: new Promise((resolve) => {
-                childProcess.on("exit", resolve);
-            }),
+            process: childProcess,
             events: emitter,
             cwd: backend.functionsDir,
             socketPath,
-            shutdown: () => {
-                childProcess.kill();
-            },
-            kill: (signal) => {
-                childProcess.kill(signal);
-                emitter.emit("log", new types_1.EmulatorLog("SYSTEM", "runtime-status", "killed"));
-            },
-            send: (args) => {
-                return childProcess.send(JSON.stringify(args));
-            },
         };
         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);
+        const pool = this.workerPools[backend.codebase];
+        pool.addWorker(trigger === null || trigger === void 0 ? void 0 : trigger.id, runtime, extensionLogInfo);
         return;
     }
     async disableBackgroundTriggers() {
@@ -1057,20 +1031,5 @@ class FunctionsEmulator {
         });
         await worker.waitForDone();
     }
-    onData(runtime, emitter, buffer, buf) {
-        buffer.value += buf.toString();
-        const lines = buffer.value.split("\n");
-        if (lines.length > 1) {
-            lines.slice(0, -1).forEach((line) => {
-                const log = types_1.EmulatorLog.fromJSON(line);
-                emitter.emit("log", log);
-                if (log.level === "FATAL") {
-                    emitter.emit("log", new types_1.EmulatorLog("SYSTEM", "runtime-status", "killed"));
-                    runtime.kill();
-                }
-            });
-        }
-        buffer.value = lines[lines.length - 1];
-    }
 }
 exports.FunctionsEmulator = FunctionsEmulator;

package/lib/emulator/functionsEmulatorRuntime.js

@@ -675,24 +675,19 @@ async function initializeRuntime() {
     await initializeFirebaseFunctionsStubs();
     await initializeFirebaseAdminStubs();
 }
-async function loadTriggers(serializedFunctionTrigger) {
+async function loadTriggers() {
     let triggerModule;
-    if (serializedFunctionTrigger) {
-        triggerModule = eval(serializedFunctionTrigger)();
+    try {
+        triggerModule = require(process.cwd());
     }
-    else {
-        try {
-            triggerModule = require(process.cwd());
-        }
-        catch (err) {
-            if (err.code !== "ERR_REQUIRE_ESM") {
-                await moduleResolutionDetective(err);
-                throw err;
-            }
-            const modulePath = require.resolve(process.cwd());
-            const moduleURL = (0, url_1.pathToFileURL)(modulePath).href;
-            triggerModule = await dynamicImport(moduleURL);
+    catch (err) {
+        if (err.code !== "ERR_REQUIRE_ESM") {
+            await moduleResolutionDetective(err);
+            throw err;
         }
+        const modulePath = require.resolve(process.cwd());
+        const moduleURL = (0, url_1.pathToFileURL)(modulePath).href;
+        triggerModule = await dynamicImport(moduleURL);
     }
     return triggerModule;
 }
@@ -716,8 +711,7 @@ async function handleMessage(message) {
     }
     if (!functionModule) {
         try {
-            const serializedTriggers = runtimeArgs.opts ? runtimeArgs.opts.serializedTriggers : undefined;
-            functionModule = await loadTriggers(serializedTriggers);
+            functionModule = await loadTriggers();
         }
         catch (e) {
             logDebug(e);
@@ -739,12 +733,7 @@ async function handleMessage(message) {
     logDebug(`Beginning invocation function ${FUNCTION_TARGET_NAME}!`);
     try {
         await invokeTrigger(trigger, runtimeArgs.frb);
-        if (runtimeArgs.opts && runtimeArgs.opts.serializedTriggers) {
-            await flushAndExit(0);
-        }
-        else {
-            await goIdle();
-        }
+        await goIdle();
     }
     catch (err) {
         new types_1.EmulatorLog("FATAL", "runtime-error", err.stack ? err.stack : err).log();

package/lib/emulator/functionsRuntimeWorker.js

@@ -30,21 +30,52 @@ class RuntimeWorker {
                     }
                     else if (this.state === RuntimeWorkerState.FINISHING) {
                         this.log(`IDLE --> FINISHING`);
-                        this.runtime.shutdown();
+                        this.runtime.process.kill();
                     }
                 }
             }
         });
-        this.runtime.exit.then(() => {
+        const childProc = this.runtime.process;
+        let msgBuffer = "";
+        childProc.on("message", (msg) => {
+            msgBuffer = this.processStream(msg, msgBuffer);
+        });
+        let stdBuffer = "";
+        if (childProc.stdout) {
+            childProc.stdout.on("data", (data) => {
+                stdBuffer = this.processStream(data, stdBuffer);
+            });
+        }
+        if (childProc.stderr) {
+            childProc.stderr.on("data", (data) => {
+                stdBuffer = this.processStream(data, stdBuffer);
+            });
+        }
+        childProc.on("exit", () => {
             this.log("exited");
             this.state = RuntimeWorkerState.FINISHED;
         });
     }
+    processStream(s, buf) {
+        buf += s.toString();
+        const lines = buf.split("\n");
+        if (lines.length > 1) {
+            lines.slice(0, -1).forEach((line) => {
+                const log = types_1.EmulatorLog.fromJSON(line);
+                this.runtime.events.emit("log", log);
+                if (log.level === "FATAL") {
+                    this.runtime.events.emit("log", new types_1.EmulatorLog("SYSTEM", "runtime-status", "killed"));
+                    this.runtime.process.kill();
+                }
+            });
+        }
+        return lines[lines.length - 1];
+    }
     execute(frb, opts) {
         const execFrb = Object.assign({}, frb);
         const args = { frb: execFrb, opts };
         this.state = RuntimeWorkerState.BUSY;
-        this.runtime.send(args);
+        this.runtime.process.send(JSON.stringify(args));
     }
     get state() {
         return this._state;
@@ -102,7 +133,7 @@ class RuntimeWorker {
         const timeout = new Promise((resolve, reject) => {
             setTimeout(() => {
                 reject(new error_1.FirebaseError("Failed to load function."));
-            }, 7000);
+            }, 30000);
         });
         while (true) {
             try {
@@ -142,7 +173,7 @@ class RuntimeWorkerPool {
                 if (w.state === RuntimeWorkerState.IDLE) {
                     this.log(`Shutting down IDLE worker (${w.key})`);
                     w.state = RuntimeWorkerState.FINISHING;
-                    w.runtime.shutdown();
+                    w.runtime.process.kill();
                 }
                 else if (w.state === RuntimeWorkerState.BUSY) {
                     this.log(`Marking BUSY worker to finish (${w.key})`);
@@ -155,10 +186,10 @@ class RuntimeWorkerPool {
         for (const arr of this.workers.values()) {
             arr.forEach((w) => {
                 if (w.state === RuntimeWorkerState.IDLE) {
-                    w.runtime.shutdown();
+                    w.runtime.process.kill();
                 }
                 else {
-                    w.runtime.kill();
+                    w.runtime.process.kill();
                 }
             });
         }

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createFirebaseEndpoints = void 0;
 const emulatorLogger_1 = require("../../emulatorLogger");
 const types_1 = require("../../types");
+const uuid = require("uuid");
 const zlib_1 = require("zlib");
 const metadata_1 = require("../metadata");
 const express_1 = require("express");
@@ -93,8 +94,8 @@ function createFirebaseEndpoints(emulator) {
             }
             throw err;
         }
-        if (!metadata.downloadTokens.length) {
-            metadata.addDownloadToken();
+        if (metadata.downloadTokens.length === 0) {
+            metadata.addDownloadToken(true);
         }
         if (req.query.alt === "media") {
             const isGZipped = metadata.contentEncoding === "gzip";
@@ -102,7 +103,8 @@ function createFirebaseEndpoints(emulator) {
                 data = (0, zlib_1.gunzipSync)(data);
             }
             res.setHeader("Accept-Ranges", "bytes");
-            res.setHeader("Content-Type", metadata.contentType);
+            res.setHeader("Content-Type", metadata.contentType || "application/octet-stream");
+            res.setHeader("Content-Disposition", metadata.contentDisposition || "inline");
             setObjectHeaders(res, metadata, { "Content-Encoding": isGZipped ? "identity" : undefined });
             const byteRange = req.range(data.byteLength, { combine: true });
             if (Array.isArray(byteRange) && byteRange.type === "bytes" && byteRange.length > 0) {
@@ -165,47 +167,26 @@ function createFirebaseEndpoints(emulator) {
         });
     });
     const handleUpload = async (req, res) => {
-        if (!req.query.name) {
-            res.sendStatus(400);
-            return;
-        }
+        var _a, _b;
         const bucketId = req.params.bucketId;
-        const objectId = req.query.name.toString();
-        const uploadType = req.header("x-goog-upload-protocol");
-        if (uploadType === "multipart") {
-            const contentTypeHeader = req.header("content-type");
-            if (!contentTypeHeader) {
-                return res.sendStatus(400);
+        const objectId = req.params.objectId
+            ? decodeURIComponent(req.params.objectId)
+            : ((_a = req.query.name) === null || _a === void 0 ? void 0 : _a.toString()) || null;
+        const uploadType = (_b = req.header("x-goog-upload-protocol")) === null || _b === void 0 ? void 0 : _b.toString();
+        async function finalizeOneShotUpload(upload) {
+            var _a, _b, _c;
+            if (!((_b = (_a = upload.metadata) === null || _a === void 0 ? void 0 : _a.metadata) === null || _b === void 0 ? void 0 : _b.firebaseStorageDownloadTokens)) {
+                const customMetadata = Object.assign(Object.assign({}, (((_c = upload.metadata) === null || _c === void 0 ? void 0 : _c.metadata) || {})), { firebaseStorageDownloadTokens: uuid.v4() });
+                upload.metadata = Object.assign(Object.assign({}, (upload.metadata || {})), { metadata: customMetadata });
             }
-            let metadataRaw;
-            let dataRaw;
-            try {
-                ({ metadataRaw, dataRaw } = (0, multipart_1.parseObjectUploadMultipartRequest)(contentTypeHeader, await (0, request_1.reqBodyToBuffer)(req)));
-            }
-            catch (err) {
-                if (err instanceof Error) {
-                    return res.status(400).json({
-                        error: {
-                            code: 400,
-                            message: err.message,
-                        },
-                    });
-                }
-                throw err;
-            }
-            const upload = uploadService.multipartUpload({
-                bucketId,
-                objectId,
-                metadataRaw,
-                dataRaw: dataRaw,
-                authorization: req.header("authorization"),
-            });
             let metadata;
             try {
                 metadata = await storageLayer.uploadObject(upload);
             }
             catch (err) {
                 if (err instanceof errors_1.ForbiddenError) {
+                    res.header("x-goog-upload-status", "final");
+                    uploadService.setResponseCode(upload.id, 403);
                     return res.status(403).json({
                         error: {
                             code: 403,
@@ -215,120 +196,153 @@ function createFirebaseEndpoints(emulator) {
                 }
                 throw err;
             }
-            metadata.addDownloadToken(false);
+            if (!metadata.contentDisposition) {
+                metadata.contentDisposition = "inline";
+            }
             return res.status(200).json(new metadata_1.OutgoingFirebaseMetadata(metadata));
         }
-        const uploadCommand = req.header("x-goog-upload-command");
-        if (!uploadCommand) {
-            res.sendStatus(400);
-            return;
-        }
-        if (uploadCommand === "start") {
-            const upload = uploadService.startResumableUpload({
-                bucketId,
-                objectId,
-                metadataRaw: JSON.stringify(req.body),
-                authorization: req.header("authorization"),
-            });
-            res.header("x-goog-upload-chunk-granularity", "10000");
-            res.header("x-goog-upload-control-url", "");
-            res.header("x-goog-upload-status", "active");
-            res.header("x-gupload-uploadid", upload.id);
-            const uploadUrl = registry_1.EmulatorRegistry.url(types_1.Emulators.STORAGE, req);
-            uploadUrl.pathname = `/v0/b/${bucketId}/o`;
-            uploadUrl.searchParams.set("name", objectId);
-            uploadUrl.searchParams.set("upload_id", upload.id);
-            uploadUrl.searchParams.set("upload_protocol", "resumable");
-            res.header("x-goog-upload-url", uploadUrl.toString());
-            return res.sendStatus(200);
-        }
-        if (!req.query.upload_id) {
-            return res.sendStatus(400);
-        }
-        const uploadId = req.query.upload_id.toString();
-        if (uploadCommand === "query") {
-            let upload;
-            try {
-                upload = uploadService.getResumableUpload(uploadId);
-            }
-            catch (err) {
-                if (err instanceof errors_1.NotFoundError) {
-                    return res.sendStatus(404);
+        if (uploadType === "resumable") {
+            const uploadCommand = req.header("x-goog-upload-command");
+            if (!uploadCommand) {
+                res.sendStatus(400);
+                return;
+            }
+            if (uploadCommand === "start") {
+                if (!objectId) {
+                    res.sendStatus(400);
+                    return;
                 }
-                throw err;
+                const upload = uploadService.startResumableUpload({
+                    bucketId,
+                    objectId,
+                    metadataRaw: JSON.stringify(req.body),
+                    authorization: req.header("authorization"),
+                });
+                res.header("x-goog-upload-chunk-granularity", "10000");
+                res.header("x-goog-upload-control-url", "");
+                res.header("x-goog-upload-status", "active");
+                res.header("x-gupload-uploadid", upload.id);
+                const uploadUrl = registry_1.EmulatorRegistry.url(types_1.Emulators.STORAGE, req);
+                uploadUrl.pathname = `/v0/b/${bucketId}/o`;
+                uploadUrl.searchParams.set("name", objectId);
+                uploadUrl.searchParams.set("upload_id", upload.id);
+                uploadUrl.searchParams.set("upload_protocol", "resumable");
+                res.header("x-goog-upload-url", uploadUrl.toString());
+                return res.sendStatus(200);
             }
-            res.header("X-Goog-Upload-Size-Received", upload.size.toString());
-            return res.sendStatus(200);
-        }
-        if (uploadCommand === "cancel") {
-            try {
-                uploadService.cancelResumableUpload(uploadId);
+            if (!req.query.upload_id) {
+                return res.sendStatus(400);
             }
-            catch (err) {
-                if (err instanceof errors_1.NotFoundError) {
-                    return res.sendStatus(404);
+            const uploadId = req.query.upload_id.toString();
+            if (uploadCommand === "query") {
+                let upload;
+                try {
+                    upload = uploadService.getResumableUpload(uploadId);
                 }
-                else if (err instanceof upload_1.NotCancellableError) {
-                    return res.sendStatus(400);
+                catch (err) {
+                    if (err instanceof errors_1.NotFoundError) {
+                        return res.sendStatus(404);
+                    }
+                    throw err;
                 }
-                throw err;
-            }
-            return res.sendStatus(200);
-        }
-        if (uploadCommand.includes("upload")) {
-            let upload;
-            try {
-                upload = uploadService.continueResumableUpload(uploadId, await (0, request_1.reqBodyToBuffer)(req));
+                res.header("X-Goog-Upload-Size-Received", upload.size.toString());
+                return res.sendStatus(200);
             }
-            catch (err) {
-                if (err instanceof errors_1.NotFoundError) {
-                    return res.sendStatus(404);
+            if (uploadCommand === "cancel") {
+                try {
+                    uploadService.cancelResumableUpload(uploadId);
                 }
-                else if (err instanceof upload_1.UploadNotActiveError) {
-                    return res.sendStatus(400);
+                catch (err) {
+                    if (err instanceof errors_1.NotFoundError) {
+                        return res.sendStatus(404);
+                    }
+                    else if (err instanceof upload_1.NotCancellableError) {
+                        return res.sendStatus(400);
+                    }
+                    throw err;
                 }
-                throw err;
-            }
-            if (!uploadCommand.includes("finalize")) {
-                res.header("x-goog-upload-status", "active");
-                res.header("x-gupload-uploadid", upload.id);
                 return res.sendStatus(200);
             }
-        }
-        if (uploadCommand.includes("finalize")) {
-            let upload;
-            try {
-                upload = uploadService.finalizeResumableUpload(uploadId);
+            if (uploadCommand.includes("upload")) {
+                let upload;
+                try {
+                    upload = uploadService.continueResumableUpload(uploadId, await (0, request_1.reqBodyToBuffer)(req));
+                }
+                catch (err) {
+                    if (err instanceof errors_1.NotFoundError) {
+                        return res.sendStatus(404);
+                    }
+                    else if (err instanceof upload_1.UploadNotActiveError) {
+                        return res.sendStatus(400);
+                    }
+                    throw err;
+                }
+                if (!uploadCommand.includes("finalize")) {
+                    res.header("x-goog-upload-status", "active");
+                    res.header("x-gupload-uploadid", upload.id);
+                    return res.sendStatus(200);
+                }
             }
-            catch (err) {
-                if (err instanceof errors_1.NotFoundError) {
-                    return res.sendStatus(404);
+            if (uploadCommand.includes("finalize")) {
+                let upload;
+                try {
+                    upload = uploadService.finalizeResumableUpload(uploadId);
                 }
-                else if (err instanceof upload_1.UploadNotActiveError) {
-                    return res.sendStatus(400);
+                catch (err) {
+                    if (err instanceof errors_1.NotFoundError) {
+                        uploadService.setResponseCode(uploadId, 404);
+                        return res.sendStatus(404);
+                    }
+                    else if (err instanceof upload_1.UploadNotActiveError) {
+                        uploadService.setResponseCode(uploadId, 400);
+                        return res.sendStatus(400);
+                    }
+                    else if (err instanceof upload_1.UploadPreviouslyFinalizedError) {
+                        res.header("x-goog-upload-status", "final");
+                        return res.sendStatus(uploadService.getPreviousResponseCode(uploadId));
+                    }
+                    throw err;
                 }
-                throw err;
+                res.header("x-goog-upload-status", "final");
+                return await finalizeOneShotUpload(upload);
+            }
+        }
+        if (!objectId) {
+            res.sendStatus(400);
+            return;
+        }
+        if (uploadType === "multipart") {
+            const contentTypeHeader = req.header("content-type");
+            if (!contentTypeHeader) {
+                return res.sendStatus(400);
             }
-            let storedMetadata;
+            let metadataRaw;
+            let dataRaw;
             try {
-                storedMetadata = await storageLayer.uploadObject(upload);
+                ({ metadataRaw, dataRaw } = (0, multipart_1.parseObjectUploadMultipartRequest)(contentTypeHeader, await (0, request_1.reqBodyToBuffer)(req)));
             }
             catch (err) {
-                if (err instanceof errors_1.ForbiddenError) {
-                    return res.status(403).json({
-                        error: {
-                            code: 403,
-                            message: `Permission denied. No WRITE permission.`,
-                        },
-                    });
+                if (err instanceof Error) {
+                    return res.status(400).send(err.message);
                 }
                 throw err;
             }
-            res.header("x-goog-upload-status", "final");
-            storedMetadata.addDownloadToken(false);
-            return res.status(200).json(new metadata_1.OutgoingFirebaseMetadata(storedMetadata));
+            const upload = uploadService.multipartUpload({
+                bucketId,
+                objectId,
+                metadataRaw,
+                dataRaw: dataRaw,
+                authorization: req.header("authorization"),
+            });
+            return await finalizeOneShotUpload(upload);
         }
-        return res.sendStatus(400);
+        const upload = uploadService.mediaUpload({
+            bucketId: req.params.bucketId,
+            objectId: objectId,
+            dataRaw: await (0, request_1.reqBodyToBuffer)(req),
+            authorization: req.header("authorization"),
+        });
+        return await finalizeOneShotUpload(upload);
     };
     const handleTokenRequest = (req, res) => {
         var _a, _b;
@@ -467,11 +481,13 @@ function createFirebaseEndpoints(emulator) {
 }
 exports.createFirebaseEndpoints = createFirebaseEndpoints;
 function setObjectHeaders(res, metadata, headerOverride = { "Content-Encoding": undefined }) {
-    res.setHeader("Content-Disposition", metadata.contentDisposition);
+    if (metadata.contentDisposition) {
+        res.setHeader("Content-Disposition", metadata.contentDisposition);
+    }
     if (headerOverride["Content-Encoding"]) {
         res.setHeader("Content-Encoding", headerOverride["Content-Encoding"]);
     }
-    else {
+    else if (metadata.contentEncoding) {
         res.setHeader("Content-Encoding", metadata.contentEncoding);
     }
     if (metadata.cacheControl) {