firebase-tools 11.5.0 → 11.8.0

package/lib/emulator/registry.js

@@ -39,6 +39,7 @@ class EmulatorRegistry {
             pubsub: 3.2,
             auth: 3.3,
             storage: 3.5,
+            eventarc: 3.6,
             hub: 4,
             logging: 5,
         };

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) {

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

@@ -17,6 +17,8 @@ const logger_1 = require("../../logger");
 const adminSdkConfig_1 = require("../adminSdkConfig");
 const types_1 = require("./rules/types");
 const upload_1 = require("./upload");
+const track_1 = require("../../track");
+const types_2 = require("../types");
 class StoredFile {
     constructor(metadata) {
         this.metadata = metadata;
@@ -140,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);
@@ -190,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));
@@ -292,7 +304,7 @@ class StorageLayer {
     get dirPath() {
         return this._persistence.dirPath;
     }
-    async export(storageExportPath) {
+    async export(storageExportPath, options) {
         var e_1, _a;
         const bucketsList = {
             buckets: [],
@@ -300,6 +312,11 @@ class StorageLayer {
         for (const b of await this.listBuckets()) {
             bucketsList.buckets.push({ id: b.id });
         }
+        void (0, track_1.trackEmulator)("emulator_export", {
+            initiated_by: options.initiatedBy,
+            emulator_name: types_2.Emulators.STORAGE,
+            count: bucketsList.buckets.length,
+        });
         const bucketsFilePath = path.join(storageExportPath, "buckets.json");
         await fse.writeFile(bucketsFilePath, JSON.stringify(bucketsList, undefined, 2));
         const blobsDirPath = path.join(storageExportPath, "blobs");
@@ -323,9 +340,14 @@ class StorageLayer {
             finally { if (e_1) throw e_1.error; }
         }
     }
-    import(storageExportPath) {
+    import(storageExportPath, options) {
         const bucketsFile = path.join(storageExportPath, "buckets.json");
         const bucketsList = JSON.parse((0, fs_1.readFileSync)(bucketsFile, "utf-8"));
+        void (0, track_1.trackEmulator)("emulator_import", {
+            initiated_by: options.initiatedBy,
+            emulator_name: types_2.Emulators.STORAGE,
+            count: bucketsList.buckets.length,
+        });
         for (const b of bucketsList.buckets) {
             const bucketMetadata = new metadata_1.CloudStorageBucketMetadata(b.id);
             this._buckets.set(b.id, bucketMetadata);