firebase-tools 10.2.0 → 10.3.0

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

@@ -7,9 +7,13 @@ const types_1 = require("../../types");
 const metadata_1 = require("../metadata");
 const registry_1 = require("../../registry");
 const emulatorLogger_1 = require("../../emulatorLogger");
+const crc_1 = require("../crc");
+const multipart_1 = require("../multipart");
+const upload_1 = require("../upload");
+const errors_1 = require("../errors");
 function createCloudEndpoints(emulator) {
     const gcloudStorageAPI = (0, express_1.Router)();
-    const { storageLayer } = emulator;
+    const { storageLayer, uploadService } = emulator;
     gcloudStorageAPI.use(/.*\/b\/(.+?)\/.*/, (req, res, next) => {
         storageLayer.createBucket(req.params[0]);
         next();
@@ -20,103 +24,158 @@ function createCloudEndpoints(emulator) {
             items: await storageLayer.listBuckets(),
         });
     });
-    gcloudStorageAPI.get(["/b/:bucketId/o/:objectId", "/download/storage/v1/b/:bucketId/o/:objectId"], (req, res) => {
-        const md = storageLayer.getMetadata(req.params.bucketId, req.params.objectId);
-        if (!md) {
-            res.sendStatus(404);
-            return;
+    gcloudStorageAPI.get(["/b/:bucketId/o/:objectId", "/download/storage/v1/b/:bucketId/o/:objectId"], async (req, res) => {
+        let getObjectResponse;
+        try {
+            getObjectResponse = await storageLayer.handleGetObject({
+                bucketId: req.params.bucketId,
+                decodedObjectId: req.params.objectId,
+            }, true);
+        }
+        catch (err) {
+            if (err instanceof errors_1.NotFoundError) {
+                return sendObjectNotFound(req, res);
+            }
+            if (err instanceof errors_1.ForbiddenError) {
+                throw new Error("Request failed unexpectedly due to Firebase Rules.");
+            }
+            throw err;
         }
-        if (req.query.alt == "media") {
-            return sendFileBytes(md, storageLayer, req, res);
+        if (req.query.alt === "media") {
+            return sendFileBytes(getObjectResponse.metadata, getObjectResponse.data, req, res);
         }
-        const outgoingMd = new metadata_1.CloudStorageObjectMetadata(md);
-        res.json(outgoingMd).status(200).send();
-        return;
+        return res.json(new metadata_1.CloudStorageObjectMetadata(getObjectResponse.metadata));
     });
-    gcloudStorageAPI.patch("/b/:bucketId/o/:objectId", (req, res) => {
-        const md = storageLayer.getMetadata(req.params.bucketId, req.params.objectId);
-        if (!md) {
-            res.sendStatus(404);
-            return;
+    gcloudStorageAPI.patch("/b/:bucketId/o/:objectId", async (req, res) => {
+        let updatedMetadata;
+        try {
+            updatedMetadata = await storageLayer.handleUpdateObjectMetadata({
+                bucketId: req.params.bucketId,
+                decodedObjectId: req.params.objectId,
+                metadata: req.body,
+            }, true);
+        }
+        catch (err) {
+            if (err instanceof errors_1.NotFoundError) {
+                return sendObjectNotFound(req, res);
+            }
+            if (err instanceof errors_1.ForbiddenError) {
+                throw new Error("Request failed unexpectedly due to Firebase Rules.");
+            }
+            throw err;
         }
-        md.update(req.body);
-        const outgoingMetadata = new metadata_1.CloudStorageObjectMetadata(md);
-        res.json(outgoingMetadata).status(200).send();
-        return;
+        return res.json(new metadata_1.CloudStorageObjectMetadata(updatedMetadata));
     });
     gcloudStorageAPI.get("/b/:bucketId/o", (req, res) => {
         let maxRes = undefined;
         if (req.query.maxResults) {
             maxRes = +req.query.maxResults.toString();
         }
-        const delimiter = req.query.delimiter ? req.query.delimiter.toString() : "/";
+        const delimiter = req.query.delimiter ? req.query.delimiter.toString() : "";
         const pageToken = req.query.pageToken ? req.query.pageToken.toString() : undefined;
         const prefix = req.query.prefix ? req.query.prefix.toString() : "";
         const listResult = storageLayer.listItems(req.params.bucketId, prefix, delimiter, pageToken, maxRes);
-        res.json(listResult);
+        res.json(Object.assign(Object.assign({}, listResult), { kind: "#storage/objects" }));
     });
-    gcloudStorageAPI.delete("/b/:bucketId/o/:objectId", (req, res) => {
-        const md = storageLayer.getMetadata(req.params.bucketId, req.params.objectId);
-        if (!md) {
-            res.sendStatus(404);
-            return;
+    gcloudStorageAPI.delete("/b/:bucketId/o/:objectId", async (req, res) => {
+        try {
+            await storageLayer.handleDeleteObject({
+                bucketId: req.params.bucketId,
+                decodedObjectId: req.params.objectId,
+            }, true);
         }
-        storageLayer.deleteFile(req.params.bucketId, req.params.objectId);
-        res.status(200).send();
+        catch (err) {
+            if (err instanceof errors_1.NotFoundError) {
+                return sendObjectNotFound(req, res);
+            }
+            if (err instanceof errors_1.ForbiddenError) {
+                throw new Error("Request failed unexpectedly due to Firebase Rules.");
+            }
+            throw err;
+        }
+        return res.sendStatus(204);
     });
-    gcloudStorageAPI.put("/upload/storage/v1/b/:bucketId/o", async (req, res) => {
-        if (!req.query.upload_id) {
-            res.sendStatus(400);
-            return;
+    const reqBodyToBuffer = async (req) => {
+        if (req.body instanceof Buffer) {
+            return Buffer.from(req.body);
         }
-        const uploadId = req.query.upload_id.toString();
         const bufs = [];
         req.on("data", (data) => {
             bufs.push(data);
         });
         await new Promise((resolve) => {
             req.on("end", () => {
-                req.body = Buffer.concat(bufs);
                 resolve();
             });
         });
-        let upload = storageLayer.uploadBytes(uploadId, req.body);
-        if (!upload) {
+        return Buffer.concat(bufs);
+    };
+    gcloudStorageAPI.put("/upload/storage/v1/b/:bucketId/o", async (req, res) => {
+        if (!req.query.upload_id) {
             res.sendStatus(400);
             return;
         }
-        const finalizedUpload = storageLayer.finalizeUpload(uploadId);
-        if (!finalizedUpload) {
-            res.sendStatus(400);
-            return;
+        const uploadId = req.query.upload_id.toString();
+        let upload;
+        try {
+            uploadService.continueResumableUpload(uploadId, await reqBodyToBuffer(req));
+            upload = uploadService.finalizeResumableUpload(uploadId);
         }
-        upload = finalizedUpload.upload;
-        res.status(200).json(new metadata_1.CloudStorageObjectMetadata(finalizedUpload.file.metadata)).send();
+        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;
+        }
+        let metadata;
+        try {
+            metadata = await storageLayer.handleUploadObject(upload, true);
+        }
+        catch (err) {
+            if (err instanceof errors_1.ForbiddenError) {
+                throw new Error("Request failed unexpectedly due to Firebase Rules.");
+            }
+            throw err;
+        }
+        return res.json(new metadata_1.CloudStorageObjectMetadata(metadata));
     });
-    gcloudStorageAPI.post("/b/:bucketId/o/:objectId/acl", (req, res) => {
+    gcloudStorageAPI.post("/b/:bucketId/o/:objectId/acl", async (req, res) => {
         var _a, _b;
         emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.STORAGE).log("WARN_ONCE", "Cloud Storage ACLs are not supported in the Storage Emulator. All related methods will succeed, but have no effect.");
-        const md = storageLayer.getMetadata(req.params.bucketId, req.params.objectId);
-        if (!md) {
-            res.sendStatus(404);
-            return;
+        let getObjectResponse;
+        try {
+            getObjectResponse = await storageLayer.handleGetObject({
+                bucketId: req.params.bucketId,
+                decodedObjectId: req.params.objectId,
+            }, true);
+        }
+        catch (err) {
+            if (err instanceof errors_1.NotFoundError) {
+                return sendObjectNotFound(req, res);
+            }
+            if (err instanceof errors_1.ForbiddenError) {
+                throw new Error("Request failed unexpectedly due to Firebase Rules.");
+            }
+            throw err;
         }
-        md.update({});
-        res
-            .json({
+        const { metadata } = getObjectResponse;
+        metadata.update({});
+        return res.json({
             kind: "storage#objectAccessControl",
-            object: md.name,
-            id: `${req.params.bucketId}/${md.name}/${md.generation}/allUsers`,
-            selfLink: `http://${(_a = registry_1.EmulatorRegistry.getInfo(types_1.Emulators.STORAGE)) === null || _a === void 0 ? void 0 : _a.host}:${(_b = registry_1.EmulatorRegistry.getInfo(types_1.Emulators.STORAGE)) === null || _b === void 0 ? void 0 : _b.port}/storage/v1/b/${md.bucket}/o/${encodeURIComponent(md.name)}/acl/allUsers`,
-            bucket: md.bucket,
+            object: metadata.name,
+            id: `${req.params.bucketId}/${metadata.name}/${metadata.generation}/allUsers`,
+            selfLink: `http://${(_a = registry_1.EmulatorRegistry.getInfo(types_1.Emulators.STORAGE)) === null || _a === void 0 ? void 0 : _a.host}:${(_b = registry_1.EmulatorRegistry.getInfo(types_1.Emulators.STORAGE)) === null || _b === void 0 ? void 0 : _b.port}/storage/v1/b/${metadata.bucket}/o/${encodeURIComponent(metadata.name)}/acl/allUsers`,
+            bucket: metadata.bucket,
             entity: req.body.entity,
             role: req.body.role,
             etag: "someEtag",
-            generation: md.generation.toString(),
-        })
-            .status(200);
+            generation: metadata.generation.toString(),
+        });
     });
-    gcloudStorageAPI.post("/upload/storage/v1/b/:bucketId/o", (req, res) => {
+    gcloudStorageAPI.post("/upload/storage/v1/b/:bucketId/o", async (req, res) => {
         if (!req.query.name) {
             res.sendStatus(400);
             return;
@@ -125,69 +184,112 @@ function createCloudEndpoints(emulator) {
         if (name.startsWith("/")) {
             name = name.slice(1);
         }
-        const contentType = req.header("content-type") || req.header("x-upload-content-type");
-        if (!contentType) {
-            res.sendStatus(400);
-            return;
+        const contentTypeHeader = req.header("content-type") || req.header("x-upload-content-type");
+        if (!contentTypeHeader) {
+            return res.sendStatus(400);
         }
-        if (req.query.uploadType == "resumable") {
-            const upload = storageLayer.startUpload(req.params.bucketId, name, contentType, req.body);
+        if (req.query.uploadType === "resumable") {
             const emulatorInfo = registry_1.EmulatorRegistry.getInfo(types_1.Emulators.STORAGE);
-            if (emulatorInfo == undefined) {
-                res.sendStatus(500);
-                return;
+            if (emulatorInfo === undefined) {
+                return res.sendStatus(500);
             }
+            const upload = uploadService.startResumableUpload({
+                bucketId: req.params.bucketId,
+                objectId: name,
+                metadataRaw: JSON.stringify(req.body),
+                authorization: req.header("authorization"),
+            });
             const { host, port } = emulatorInfo;
-            const uploadUrl = `http://${host}:${port}/upload/storage/v1/b/${upload.bucketId}/o?name=${upload.fileLocation}&uploadType=resumable&upload_id=${upload.uploadId}`;
-            res.header("location", uploadUrl).status(200).send();
-            return;
+            const uploadUrl = `http://${host}:${port}/upload/storage/v1/b/${req.params.bucketId}/o?name=${name}&uploadType=resumable&upload_id=${upload.id}`;
+            return res.header("location", uploadUrl).sendStatus(200);
         }
-        if (!contentType.startsWith("multipart/related")) {
-            res.sendStatus(400);
-            return;
+        let metadataRaw;
+        let dataRaw;
+        try {
+            ({ metadataRaw, dataRaw } = (0, multipart_1.parseObjectUploadMultipartRequest)(contentTypeHeader, await reqBodyToBuffer(req)));
         }
-        const boundary = `--${contentType.split("boundary=")[1]}`;
-        const bodyString = req.body.toString();
-        const bodyStringParts = bodyString.split(boundary).filter((v) => v);
-        const metadataString = bodyStringParts[0].split(/\r?\n/)[3];
-        const blobParts = bodyStringParts[1].split(/\r?\n/);
-        const blobContentTypeString = blobParts[1];
-        if (!blobContentTypeString || !blobContentTypeString.startsWith("Content-Type: ")) {
-            res.sendStatus(400);
-            return;
+        catch (err) {
+            return res.status(400).json({
+                error: {
+                    code: 400,
+                    message: err,
+                },
+            });
         }
-        const blobContentType = blobContentTypeString.slice("Content-Type: ".length);
-        const bodyBuffer = req.body;
-        const metadataSegment = `${boundary}${bodyString.split(boundary)[1]}`;
-        const dataSegment = `${boundary}${bodyString.split(boundary).slice(2)[0]}`;
-        const dataSegmentHeader = (dataSegment.match(/.+Content-Type:.+?\r?\n\r?\n/s) || [])[0];
-        if (!dataSegmentHeader) {
-            res.sendStatus(400);
-            return;
+        const upload = uploadService.multipartUpload({
+            bucketId: req.params.bucketId,
+            objectId: name,
+            metadataRaw: metadataRaw,
+            dataRaw: dataRaw,
+            authorization: req.header("authorization"),
+        });
+        let metadata;
+        try {
+            metadata = await storageLayer.handleUploadObject(upload, true);
         }
-        const bufferOffset = metadataSegment.length + dataSegmentHeader.length;
-        const blobBytes = Buffer.from(bodyBuffer.slice(bufferOffset, -`\r\n${boundary}--`.length));
-        const metadata = storageLayer.oneShotUpload(req.params.bucketId, name, blobContentType, JSON.parse(metadataString), blobBytes);
-        if (!metadata) {
-            res.sendStatus(400);
-            return;
+        catch (err) {
+            if (err instanceof errors_1.ForbiddenError) {
+                throw new Error("Request failed unexpectedly due to Firebase Rules.");
+            }
+            throw err;
         }
-        res.status(200).json(new metadata_1.CloudStorageObjectMetadata(metadata)).send();
-        return;
+        return res.status(200).json(new metadata_1.CloudStorageObjectMetadata(metadata));
     });
-    gcloudStorageAPI.get("/:bucketId/:objectId(**)", (req, res) => {
+    gcloudStorageAPI.get("/:bucketId/:objectId(**)", async (req, res) => {
+        let getObjectResponse;
+        try {
+            getObjectResponse = await storageLayer.handleGetObject({
+                bucketId: req.params.bucketId,
+                decodedObjectId: req.params.objectId,
+            }, true);
+        }
+        catch (err) {
+            if (err instanceof errors_1.NotFoundError) {
+                return sendObjectNotFound(req, res);
+            }
+            if (err instanceof errors_1.ForbiddenError) {
+                throw new Error("Request failed unexpectedly due to Firebase Rules.");
+            }
+            throw err;
+        }
+        return sendFileBytes(getObjectResponse.metadata, getObjectResponse.data, req, res);
+    });
+    gcloudStorageAPI.post("/b/:bucketId/o/:objectId/:method(rewriteTo|copyTo)/b/:destBucketId/o/:destObjectId", (req, res, next) => {
         const md = storageLayer.getMetadata(req.params.bucketId, req.params.objectId);
         if (!md) {
-            res.sendStatus(404);
+            return sendObjectNotFound(req, res);
+        }
+        if (req.params.method === "rewriteTo" && req.query.rewriteToken) {
+            return next();
+        }
+        const metadata = storageLayer.copyFile(md, req.params.destBucketId, req.params.destObjectId, req.body);
+        if (!metadata) {
+            res.sendStatus(400);
             return;
         }
-        return sendFileBytes(md, storageLayer, req, res);
+        const resource = new metadata_1.CloudStorageObjectMetadata(metadata);
+        res.status(200);
+        if (req.params.method === "copyTo") {
+            return res.json(resource);
+        }
+        else if (req.params.method === "rewriteTo") {
+            return res.json({
+                kind: "storage#rewriteResponse",
+                totalBytesRewritten: String(metadata.size),
+                objectSize: String(metadata.size),
+                done: true,
+                resource,
+            });
+        }
+        else {
+            return next();
+        }
     });
     gcloudStorageAPI.all("/**", (req, res) => {
         if (process.env.STORAGE_EMULATOR_DEBUG) {
             console.table(req.headers);
             console.log(req.method, req.url);
-            res.json("endpoint not implemented");
+            res.status(501).json("endpoint not implemented");
         }
         else {
             res.sendStatus(501);
@@ -196,32 +298,50 @@ function createCloudEndpoints(emulator) {
     return gcloudStorageAPI;
 }
 exports.createCloudEndpoints = createCloudEndpoints;
-function sendFileBytes(md, storageLayer, req, res) {
-    let data = storageLayer.getBytes(req.params.bucketId, req.params.objectId);
-    if (!data) {
-        res.sendStatus(404);
-        return;
-    }
-    const isGZipped = md.contentEncoding == "gzip";
+function sendFileBytes(md, data, req, res) {
+    const isGZipped = md.contentEncoding === "gzip";
     if (isGZipped) {
         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", "identity");
-    const byteRange = [...(req.header("range") || "").split("bytes="), "", ""];
-    const [rangeStart, rangeEnd] = byteRange[1].split("-");
-    if (rangeStart) {
-        const range = {
-            start: parseInt(rangeStart),
-            end: rangeEnd ? parseInt(rangeEnd) : data.byteLength,
-        };
-        res.setHeader("Content-Range", `bytes ${range.start}-${range.end - 1}/${data.byteLength}`);
-        res.status(206).end(data.slice(range.start, range.end));
+    res.setHeader("Content-Encoding", md.contentEncoding);
+    res.setHeader("ETag", md.etag);
+    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);
+    res.setHeader("x-goog-hash", `crc32c=${(0, crc_1.crc32cToString)(md.crc32c)},md5=${md.md5Hash}`);
+    const byteRange = req.range(data.byteLength, { combine: true });
+    if (Array.isArray(byteRange) && byteRange.type === "bytes" && byteRange.length > 0) {
+        const range = byteRange[0];
+        res.setHeader("Content-Range", `${byteRange.type} ${range.start}-${range.end}/${data.byteLength}`);
+        res.status(206).end(data.slice(range.start, range.end + 1));
     }
     else {
         res.end(data);
     }
-    return;
+}
+function sendObjectNotFound(req, res) {
+    res.status(404);
+    const message = `No such object: ${req.params.bucketId}/${req.params.objectId}`;
+    if (req.method === "GET" && req.query.alt === "media") {
+        res.send(message);
+    }
+    else {
+        res.json({
+            error: {
+                code: 404,
+                message,
+                errors: [
+                    {
+                        message,
+                        domain: "global",
+                        reason: "notFound",
+                    },
+                ],
+            },
+        });
+    }
 }

package/lib/emulator/storage/crc.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.crc32c = void 0;
+exports.crc32cToString = exports.crc32c = void 0;
 function makeCRCTable(poly) {
     let c;
     const crcTable = [];
@@ -24,3 +24,7 @@ function crc32c(bytes) {
     return (crc ^ -1) >>> 0;
 }
 exports.crc32c = crc32c;
+function crc32cToString(crc32cValue) {
+    return "----" + Buffer.from([crc32cValue]).toString("base64");
+}
+exports.crc32cToString = crc32cToString;

package/lib/emulator/storage/errors.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForbiddenError = exports.NotFoundError = void 0;
+class NotFoundError extends Error {
+}
+exports.NotFoundError = NotFoundError;
+class ForbiddenError extends Error {
+}
+exports.ForbiddenError = ForbiddenError;