firebase-tools 11.7.0 → 11.8.0

package/lib/deploy/functions/build.js

@@ -60,12 +60,12 @@ exports.AllIngressSettings = [
     "ALLOW_INTERNAL_ONLY",
     "ALLOW_INTERNAL_AND_GCLB",
 ];
-async function resolveBackend(build, userEnvOpt, userEnvs) {
+async function resolveBackend(build, userEnvOpt, userEnvs, nonInteractive) {
     var _a;
     const projectId = userEnvOpt.projectId;
     let paramValues = {};
     if (previews_1.previews.functionsparams) {
-        paramValues = await params.resolveParams(build.params, projectId, envWithTypes(userEnvs));
+        paramValues = await params.resolveParams(build.params, projectId, envWithTypes(userEnvs), nonInteractive);
         const toWrite = {};
         for (const paramName of Object.keys(paramValues)) {
             if (userEnvs.hasOwnProperty(paramName)) {

package/lib/deploy/functions/params.js

@@ -102,7 +102,7 @@ function canSatisfyParam(param, value) {
     }
     (0, functional_1.assertExhaustive)(param);
 }
-async function resolveParams(params, projectId, userEnvs) {
+async function resolveParams(params, projectId, userEnvs, nonInteractive) {
     const paramValues = {};
     const [provided, outstanding] = (0, functional_1.partition)(params, (param) => {
         return {}.hasOwnProperty.call(userEnvs, param.name);
@@ -117,6 +117,12 @@ async function resolveParams(params, projectId, userEnvs) {
         }
         paramValues[param.name] = userEnvs[param.name];
     }
+    if (nonInteractive && outstanding.length > 0) {
+        const envNames = outstanding.map((p) => p.name).join(", ");
+        throw new error_1.FirebaseError(`In non-interactive mode but have no value for the following environment variables: ${envNames}\n` +
+            "To continue, either run `firebase deploy` with an interactive terminal, or add values to a dotenv file. " +
+            "For information regarding how to use dotenv files, see https://firebase.google.com/docs/functions/config-env");
+    }
     for (const param of outstanding) {
         let paramDefault = param.default;
         if (paramDefault && isCEL(paramDefault)) {

package/lib/deploy/functions/prepare.js

@@ -78,7 +78,7 @@ async function prepare(context, options, payload) {
         const userEnvs = functionsEnv.loadUserEnvs(userEnvOpt);
         const envs = Object.assign(Object.assign({}, userEnvs), firebaseEnvs);
         const wantBuild = await runtimeDelegate.discoverBuild(runtimeConfig, firebaseEnvs);
-        const wantBackend = await build.resolveBackend(wantBuild, userEnvOpt, userEnvs);
+        const wantBackend = await build.resolveBackend(wantBuild, userEnvOpt, userEnvs, options.nonInteractive);
         wantBackend.environmentVariables = envs;
         for (const endpoint of backend.allEndpoints(wantBackend)) {
             endpoint.environmentVariables = wantBackend.environmentVariables;

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,45 +167,26 @@ function createFirebaseEndpoints(emulator) {
         });
     });
     const handleUpload = async (req, res) => {
-        var _a;
+        var _a, _b;
         const bucketId = req.params.bucketId;
         const objectId = req.params.objectId
             ? decodeURIComponent(req.params.objectId)
             : ((_a = req.query.name) === null || _a === void 0 ? void 0 : _a.toString()) || null;
-        const uploadType = req.header("x-goog-upload-protocol");
-        if (uploadType === "multipart") {
-            if (!objectId) {
-                res.sendStatus(400);
-                return;
-            }
-            const contentTypeHeader = req.header("content-type");
-            if (!contentTypeHeader) {
-                return res.sendStatus(400);
-            }
-            let metadataRaw;
-            let dataRaw;
-            try {
-                ({ metadataRaw, dataRaw } = (0, multipart_1.parseObjectUploadMultipartRequest)(contentTypeHeader, await (0, request_1.reqBodyToBuffer)(req)));
+        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 });
             }
-            catch (err) {
-                if (err instanceof Error) {
-                    return res.status(400).send(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,
@@ -213,124 +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") {
-            if (!objectId) {
+        if (uploadType === "resumable") {
+            const uploadCommand = req.header("x-goog-upload-command");
+            if (!uploadCommand) {
                 res.sendStatus(400);
                 return;
             }
-            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 (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;
@@ -469,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) {

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

@@ -15,6 +15,45 @@ const request_1 = require("../../shared/request");
 function createCloudEndpoints(emulator) {
     const gcloudStorageAPI = (0, express_1.Router)();
     const { adminStorageLayer, uploadService } = emulator;
+    if (process.env.STORAGE_EMULATOR_DEBUG) {
+        gcloudStorageAPI.use((req, res, next) => {
+            console.log("--------------INCOMING REQUEST--------------");
+            console.log(`${req.method.toUpperCase()} ${req.path}`);
+            console.log("-- query:");
+            console.log(JSON.stringify(req.query, undefined, 2));
+            console.log("-- headers:");
+            console.log(JSON.stringify(req.headers, undefined, 2));
+            console.log("-- body:");
+            if (req.body instanceof Buffer) {
+                console.log(`Buffer of ${req.body.length}`);
+            }
+            else if (req.body) {
+                console.log(req.body);
+            }
+            else {
+                console.log("Empty body (could be stream)");
+            }
+            const resJson = res.json.bind(res);
+            res.json = (...args) => {
+                console.log("-- response:");
+                args.forEach((data) => console.log(JSON.stringify(data, undefined, 2)));
+                return resJson.call(res, ...args);
+            };
+            const resSendStatus = res.sendStatus.bind(res);
+            res.sendStatus = (status) => {
+                console.log("-- response status:");
+                console.log(status);
+                return resSendStatus.call(res, status);
+            };
+            const resStatus = res.status.bind(res);
+            res.status = (status) => {
+                console.log("-- response status:");
+                console.log(status);
+                return resStatus.call(res, status);
+            };
+            next();
+        });
+    }
     gcloudStorageAPI.use(/.*\/b\/(.+?)\/.*/, (req, res, next) => {
         adminStorageLayer.createBucket(req.params[0]);
         next();
@@ -25,7 +64,11 @@ function createCloudEndpoints(emulator) {
             items: await adminStorageLayer.listBuckets(),
         });
     });
-    gcloudStorageAPI.get(["/b/:bucketId/o/:objectId", "/download/storage/v1/b/:bucketId/o/:objectId"], async (req, res) => {
+    gcloudStorageAPI.get([
+        "/b/:bucketId/o/:objectId",
+        "/download/storage/v1/b/:bucketId/o/:objectId",
+        "/storage/v1/b/:bucketId/o/:objectId",
+    ], async (req, res) => {
         let getObjectResponse;
         try {
             getObjectResponse = await adminStorageLayer.getObject({
@@ -87,7 +130,7 @@ function createCloudEndpoints(emulator) {
             throw err;
         }
         return res.status(200).json({
-            kind: "#storage/objects",
+            kind: "storage#objects",
             nextPageToken: listResponse.nextPageToken,
             prefixes: listResponse.prefixes,
             items: (_a = listResponse.items) === null || _a === void 0 ? void 0 : _a.map((item) => new metadata_1.CloudStorageObjectMetadata(item)),
@@ -177,11 +220,8 @@ function createCloudEndpoints(emulator) {
         });
     });
     gcloudStorageAPI.post("/upload/storage/v1/b/:bucketId/o", async (req, res) => {
-        const contentTypeHeader = req.header("content-type") || req.header("x-upload-content-type");
-        if (!contentTypeHeader) {
-            return res.sendStatus(400);
-        }
-        if (req.query.uploadType === "resumable") {
+        const uploadType = req.query.uploadType || req.header("X-Goog-Upload-Protocol");
+        if (uploadType === "resumable") {
             const emulatorInfo = registry_1.EmulatorRegistry.getInfo(types_1.Emulators.STORAGE);
             if (emulatorInfo === undefined) {
                 return res.sendStatus(500);
@@ -204,45 +244,65 @@ function createCloudEndpoints(emulator) {
             uploadUrl.searchParams.set("upload_id", upload.id);
             return res.header("location", uploadUrl.toString()).sendStatus(200);
         }
-        let metadataRaw;
-        let dataRaw;
-        try {
-            ({ metadataRaw, dataRaw } = (0, multipart_1.parseObjectUploadMultipartRequest)(contentTypeHeader, await (0, request_1.reqBodyToBuffer)(req)));
+        async function finalizeOneShotUpload(upload) {
+            let metadata;
+            try {
+                metadata = await adminStorageLayer.uploadObject(upload);
+            }
+            catch (err) {
+                if (err instanceof errors_1.ForbiddenError) {
+                    return res.sendStatus(403);
+                }
+                throw err;
+            }
+            return res.status(200).json(new metadata_1.CloudStorageObjectMetadata(metadata));
         }
-        catch (err) {
-            if (err instanceof Error) {
-                return res.status(400).json({
-                    error: {
-                        code: 400,
-                        message: err.message,
-                    },
-                });
+        if (uploadType === "multipart") {
+            const contentTypeHeader = req.header("content-type") || req.header("x-upload-content-type");
+            if (!contentTypeHeader) {
+                return res.sendStatus(400);
             }
-            throw err;
+            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 name = getIncomingFileNameFromRequest(req.query, JSON.parse(metadataRaw));
+            if (name === undefined) {
+                res.sendStatus(400);
+                return;
+            }
+            const upload = uploadService.multipartUpload({
+                bucketId: req.params.bucketId,
+                objectId: name,
+                metadataRaw: metadataRaw,
+                dataRaw: dataRaw,
+                authorization: req.header("authorization"),
+            });
+            return await finalizeOneShotUpload(upload);
         }
-        const name = getIncomingFileNameFromRequest(req.query, JSON.parse(metadataRaw));
-        if (name === undefined) {
+        const name = req.query.name;
+        if (!name) {
             res.sendStatus(400);
-            return;
         }
-        const upload = uploadService.multipartUpload({
+        const upload = uploadService.mediaUpload({
             bucketId: req.params.bucketId,
-            objectId: name,
-            metadataRaw: metadataRaw,
-            dataRaw: dataRaw,
+            objectId: name.toString(),
+            dataRaw: await (0, request_1.reqBodyToBuffer)(req),
             authorization: req.header("authorization"),
         });
-        let metadata;
-        try {
-            metadata = await adminStorageLayer.uploadObject(upload);
-        }
-        catch (err) {
-            if (err instanceof errors_1.ForbiddenError) {
-                return res.sendStatus(403);
-            }
-            throw err;
-        }
-        return res.status(200).json(new metadata_1.CloudStorageObjectMetadata(metadata));
+        return await finalizeOneShotUpload(upload);
     });
     gcloudStorageAPI.get("/:bucketId/:objectId(**)", async (req, res) => {
         let getObjectResponse;
@@ -324,11 +384,11 @@ function sendFileBytes(md, data, req, res) {
         data = (0, zlib_1.gunzipSync)(data);
     }
     res.setHeader("Accept-Ranges", "bytes");
-    res.setHeader("Content-Type", md.contentType);
-    res.setHeader("Content-Disposition", md.contentDisposition);
-    res.setHeader("Content-Encoding", isGZipped ? "identity" : md.contentEncoding);
+    res.setHeader("Content-Type", md.contentType || "application/octet-stream");
+    res.setHeader("Content-Disposition", md.contentDisposition || "attachment");
+    res.setHeader("Content-Encoding", isGZipped ? "identity" : md.contentEncoding || "");
     res.setHeader("ETag", md.etag);
-    res.setHeader("Cache-Control", md.cacheControl);
+    res.setHeader("Cache-Control", md.cacheControl || "");
     res.setHeader("x-goog-generation", `${md.generation}`);
     res.setHeader("x-goog-metadatageneration", `${md.metageneration}`);
     res.setHeader("x-goog-storage-class", md.storageClass);

package/lib/emulator/storage/files.js

@@ -142,20 +142,26 @@ class StorageLayer {
         }
         const storedMetadata = this.getMetadata(upload.bucketId, upload.objectId);
         const filePath = this.path(upload.bucketId, upload.objectId);
+        function getIncomingMetadata(field) {
+            if (!upload.metadata) {
+                return undefined;
+            }
+            const value = upload.metadata[field];
+            return value === null ? undefined : value;
+        }
         const metadata = new metadata_1.StoredFileMetadata({
             name: upload.objectId,
             bucket: upload.bucketId,
-            contentType: upload.metadata.contentType || "application/octet-stream",
-            contentDisposition: upload.metadata.contentDisposition,
-            contentEncoding: upload.metadata.contentEncoding,
-            contentLanguage: upload.metadata.contentLanguage,
-            cacheControl: upload.metadata.cacheControl,
-            customMetadata: upload.metadata.metadata,
+            contentType: getIncomingMetadata("contentType"),
+            contentDisposition: getIncomingMetadata("contentDisposition"),
+            contentEncoding: getIncomingMetadata("contentEncoding"),
+            contentLanguage: getIncomingMetadata("contentLanguage"),
+            cacheControl: getIncomingMetadata("cacheControl"),
+            customMetadata: getIncomingMetadata("metadata"),
         }, this._cloudFunctions, this._persistence.readBytes(upload.path, upload.size));
-        metadata.update(upload.metadata, false);
         const authorized = await this._rulesValidator.validate(["b", upload.bucketId, "o", upload.objectId].join("/"), upload.bucketId, types_1.RulesetOperationMethod.CREATE, {
             before: storedMetadata === null || storedMetadata === void 0 ? void 0 : storedMetadata.asRulesResource(),
-            after: metadata === null || metadata === void 0 ? void 0 : metadata.asRulesResource(),
+            after: metadata.asRulesResource(),
         }, upload.authorization);
         if (!authorized) {
             this._persistence.deleteFile(upload.path);
@@ -192,16 +198,20 @@ class StorageLayer {
                     newMetadata.metadata[k] = "";
             }
         }
+        function getMetadata(field) {
+            const value = newMetadata[field];
+            return value === null ? undefined : value;
+        }
         const copiedFileMetadata = new metadata_1.StoredFileMetadata({
             name: destinationObject,
             bucket: destinationBucket,
-            contentType: newMetadata.contentType || "application/octet-stream",
-            contentDisposition: newMetadata.contentDisposition,
-            contentEncoding: newMetadata.contentEncoding,
-            contentLanguage: newMetadata.contentLanguage,
-            cacheControl: newMetadata.cacheControl,
-            customMetadata: newMetadata.metadata,
-        }, this._cloudFunctions, sourceBytes, incomingMetadata);
+            contentType: getMetadata("contentType"),
+            contentDisposition: getMetadata("contentDisposition"),
+            contentEncoding: getMetadata("contentEncoding"),
+            contentLanguage: getMetadata("contentLanguage"),
+            cacheControl: getMetadata("cacheControl"),
+            customMetadata: getMetadata("metadata"),
+        }, this._cloudFunctions, sourceBytes);
         const file = new StoredFile(copiedFileMetadata);
         this._files.set(destinationFilePath, file);
         this._cloudFunctions.dispatch("finalize", new metadata_1.CloudStorageObjectMetadata(file.metadata));