firebase-tools 10.4.2 → 10.7.0

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

@@ -11,33 +11,34 @@ const crc_1 = require("../crc");
 const multipart_1 = require("../multipart");
 const upload_1 = require("../upload");
 const errors_1 = require("../errors");
+const request_1 = require("../../shared/request");
 function createCloudEndpoints(emulator) {
     const gcloudStorageAPI = (0, express_1.Router)();
-    const { storageLayer, uploadService } = emulator;
+    const { adminStorageLayer, uploadService } = emulator;
     gcloudStorageAPI.use(/.*\/b\/(.+?)\/.*/, (req, res, next) => {
-        storageLayer.createBucket(req.params[0]);
+        adminStorageLayer.createBucket(req.params[0]);
         next();
     });
     gcloudStorageAPI.get("/b", async (req, res) => {
         res.json({
             kind: "storage#buckets",
-            items: await storageLayer.listBuckets(),
+            items: await adminStorageLayer.listBuckets(),
         });
     });
     gcloudStorageAPI.get(["/b/:bucketId/o/:objectId", "/download/storage/v1/b/:bucketId/o/:objectId"], async (req, res) => {
         let getObjectResponse;
         try {
-            getObjectResponse = await storageLayer.handleGetObject({
+            getObjectResponse = await adminStorageLayer.getObject({
                 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.");
+                return res.sendStatus(403);
             }
             throw err;
         }
@@ -49,67 +50,67 @@ function createCloudEndpoints(emulator) {
     gcloudStorageAPI.patch("/b/:bucketId/o/:objectId", async (req, res) => {
         let updatedMetadata;
         try {
-            updatedMetadata = await storageLayer.handleUpdateObjectMetadata({
+            updatedMetadata = await adminStorageLayer.updateObjectMetadata({
                 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.");
+                return res.sendStatus(403);
             }
             throw err;
         }
         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 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(Object.assign(Object.assign({}, listResult), { kind: "#storage/objects" }));
+    gcloudStorageAPI.get("/b/:bucketId/o", async (req, res) => {
+        var _a;
+        let listResponse;
+        try {
+            listResponse = await adminStorageLayer.listObjects({
+                bucketId: req.params.bucketId,
+                prefix: req.query.prefix ? req.query.prefix.toString() : "",
+                delimiter: req.query.delimiter ? req.query.delimiter.toString() : "",
+                pageToken: req.query.pageToken ? req.query.pageToken.toString() : undefined,
+                maxResults: req.query.maxResults ? +req.query.maxResults.toString() : undefined,
+                authorization: req.header("authorization"),
+            });
+        }
+        catch (err) {
+            if (err instanceof errors_1.ForbiddenError) {
+                return res.sendStatus(403);
+            }
+            throw err;
+        }
+        return res.status(200).json({
+            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)),
+        });
     });
     gcloudStorageAPI.delete("/b/:bucketId/o/:objectId", async (req, res) => {
         try {
-            await storageLayer.handleDeleteObject({
+            await adminStorageLayer.deleteObject({
                 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.");
+                return res.sendStatus(403);
             }
             throw err;
         }
         return res.sendStatus(204);
     });
-    const reqBodyToBuffer = async (req) => {
-        if (req.body instanceof Buffer) {
-            return Buffer.from(req.body);
-        }
-        const bufs = [];
-        req.on("data", (data) => {
-            bufs.push(data);
-        });
-        await new Promise((resolve) => {
-            req.on("end", () => {
-                resolve();
-            });
-        });
-        return Buffer.concat(bufs);
-    };
     gcloudStorageAPI.put("/upload/storage/v1/b/:bucketId/o", async (req, res) => {
         if (!req.query.upload_id) {
             res.sendStatus(400);
@@ -118,7 +119,7 @@ function createCloudEndpoints(emulator) {
         const uploadId = req.query.upload_id.toString();
         let upload;
         try {
-            uploadService.continueResumableUpload(uploadId, await reqBodyToBuffer(req));
+            uploadService.continueResumableUpload(uploadId, await (0, request_1.reqBodyToBuffer)(req));
             upload = uploadService.finalizeResumableUpload(uploadId);
         }
         catch (err) {
@@ -132,11 +133,11 @@ function createCloudEndpoints(emulator) {
         }
         let metadata;
         try {
-            metadata = await storageLayer.handleUploadObject(upload, true);
+            metadata = await adminStorageLayer.uploadObject(upload);
         }
         catch (err) {
             if (err instanceof errors_1.ForbiddenError) {
-                throw new Error("Request failed unexpectedly due to Firebase Rules.");
+                return res.sendStatus(403);
             }
             throw err;
         }
@@ -147,17 +148,17 @@ function createCloudEndpoints(emulator) {
         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.");
         let getObjectResponse;
         try {
-            getObjectResponse = await storageLayer.handleGetObject({
+            getObjectResponse = await adminStorageLayer.getObject({
                 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.");
+                return res.sendStatus(403);
             }
             throw err;
         }
@@ -199,22 +200,28 @@ function createCloudEndpoints(emulator) {
                 metadataRaw: JSON.stringify(req.body),
                 authorization: req.header("authorization"),
             });
-            const { host, port } = emulatorInfo;
-            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);
+            const uploadUrl = registry_1.EmulatorRegistry.url(types_1.Emulators.STORAGE, req);
+            uploadUrl.pathname = `/upload/storage/v1/b/${req.params.bucketId}/o`;
+            uploadUrl.searchParams.set("name", name);
+            uploadUrl.searchParams.set("uploadType", "resumable");
+            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 reqBodyToBuffer(req)));
+            ({ metadataRaw, dataRaw } = (0, multipart_1.parseObjectUploadMultipartRequest)(contentTypeHeader, await (0, request_1.reqBodyToBuffer)(req)));
         }
         catch (err) {
-            return res.status(400).json({
-                error: {
-                    code: 400,
-                    message: err,
-                },
-            });
+            if (err instanceof Error) {
+                return res.status(400).json({
+                    error: {
+                        code: 400,
+                        message: err.message,
+                    },
+                });
+            }
+            throw err;
         }
         const upload = uploadService.multipartUpload({
             bucketId: req.params.bucketId,
@@ -225,11 +232,11 @@ function createCloudEndpoints(emulator) {
         });
         let metadata;
         try {
-            metadata = await storageLayer.handleUploadObject(upload, true);
+            metadata = await adminStorageLayer.uploadObject(upload);
         }
         catch (err) {
             if (err instanceof errors_1.ForbiddenError) {
-                throw new Error("Request failed unexpectedly due to Firebase Rules.");
+                return res.sendStatus(403);
             }
             throw err;
         }
@@ -238,34 +245,45 @@ function createCloudEndpoints(emulator) {
     gcloudStorageAPI.get("/:bucketId/:objectId(**)", async (req, res) => {
         let getObjectResponse;
         try {
-            getObjectResponse = await storageLayer.handleGetObject({
+            getObjectResponse = await adminStorageLayer.getObject({
                 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.");
+                return res.sendStatus(403);
             }
             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) {
-            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;
+        let metadata;
+        try {
+            metadata = adminStorageLayer.copyObject({
+                sourceBucket: req.params.bucketId,
+                sourceObject: req.params.objectId,
+                destinationBucket: req.params.destBucketId,
+                destinationObject: req.params.destObjectId,
+                incomingMetadata: req.body,
+                authorization: "Bearer owner",
+            });
+        }
+        catch (err) {
+            if (err instanceof errors_1.NotFoundError) {
+                return sendObjectNotFound(req, res);
+            }
+            if (err instanceof errors_1.ForbiddenError) {
+                return res.sendStatus(403);
+            }
+            throw err;
         }
         const resource = new metadata_1.CloudStorageObjectMetadata(metadata);
         res.status(200);

package/lib/emulator/storage/files.js

@@ -9,12 +9,10 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StorageLayer = exports.StoredFile = void 0;
 const fs_1 = require("fs");
-const list_1 = require("./list");
 const metadata_1 = require("./metadata");
 const errors_1 = require("./errors");
 const path = require("path");
 const fse = require("fs-extra");
-const cloudFunctions_1 = require("./cloudFunctions");
 const logger_1 = require("../../logger");
 const adminSdkConfig_1 = require("../adminSdkConfig");
 const types_1 = require("./rules/types");
@@ -39,17 +37,14 @@ class StoredFile {
 }
 exports.StoredFile = StoredFile;
 class StorageLayer {
-    constructor(_projectId, _rulesValidator, _adminCredsValidator, _persistence) {
+    constructor(_projectId, _files, _buckets, _rulesValidator, _adminCredsValidator, _persistence, _cloudFunctions) {
         this._projectId = _projectId;
+        this._files = _files;
+        this._buckets = _buckets;
         this._rulesValidator = _rulesValidator;
         this._adminCredsValidator = _adminCredsValidator;
         this._persistence = _persistence;
-        this.reset();
-        this._cloudFunctions = new cloudFunctions_1.StorageCloudFunctions(this._projectId);
-    }
-    reset() {
-        this._files = new Map();
-        this._buckets = new Map();
+        this._cloudFunctions = _cloudFunctions;
     }
     createBucket(id) {
         if (!this._buckets.has(id)) {
@@ -66,11 +61,11 @@ class StorageLayer {
         }
         return [...this._buckets.values()];
     }
-    async handleGetObject(request, skipAuth = false) {
+    async getObject(request) {
         var _a;
         const metadata = this.getMetadata(request.bucketId, request.decodedObjectId);
         const hasValidDownloadToken = ((metadata === null || metadata === void 0 ? void 0 : metadata.downloadTokens) || []).includes((_a = request.downloadToken) !== null && _a !== void 0 ? _a : "");
-        let authorized = skipAuth || hasValidDownloadToken;
+        let authorized = hasValidDownloadToken;
         if (!authorized) {
             authorized = await this._rulesValidator.validate(["b", request.bucketId, "o", request.decodedObjectId].join("/"), request.bucketId, types_1.RulesetOperationMethod.GET, { before: metadata === null || metadata === void 0 ? void 0 : metadata.asRulesResource() }, request.authorization);
         }
@@ -99,10 +94,9 @@ class StorageLayer {
         }
         return undefined;
     }
-    async handleDeleteObject(request, skipAuth = false) {
+    async deleteObject(request) {
         const storedMetadata = this.getMetadata(request.bucketId, request.decodedObjectId);
-        const authorized = skipAuth ||
-            (await this._rulesValidator.validate(["b", request.bucketId, "o", request.decodedObjectId].join("/"), request.bucketId, types_1.RulesetOperationMethod.DELETE, { before: storedMetadata === null || storedMetadata === void 0 ? void 0 : storedMetadata.asRulesResource() }, request.authorization));
+        const authorized = await this._rulesValidator.validate(["b", request.bucketId, "o", request.decodedObjectId].join("/"), request.bucketId, types_1.RulesetOperationMethod.DELETE, { before: storedMetadata === null || storedMetadata === void 0 ? void 0 : storedMetadata.asRulesResource() }, request.authorization);
         if (!authorized) {
             throw new errors_1.ForbiddenError();
         }
@@ -131,13 +125,12 @@ class StorageLayer {
             return true;
         }
     }
-    async handleUpdateObjectMetadata(request, skipAuth = false) {
+    async updateObjectMetadata(request) {
         const storedMetadata = this.getMetadata(request.bucketId, request.decodedObjectId);
-        const authorized = skipAuth ||
-            (await this._rulesValidator.validate(["b", request.bucketId, "o", request.decodedObjectId].join("/"), request.bucketId, types_1.RulesetOperationMethod.UPDATE, {
-                before: storedMetadata === null || storedMetadata === void 0 ? void 0 : storedMetadata.asRulesResource(),
-                after: storedMetadata === null || storedMetadata === void 0 ? void 0 : storedMetadata.asRulesResource(request.metadata),
-            }, request.authorization));
+        const authorized = await this._rulesValidator.validate(["b", request.bucketId, "o", request.decodedObjectId].join("/"), request.bucketId, types_1.RulesetOperationMethod.UPDATE, {
+            before: storedMetadata === null || storedMetadata === void 0 ? void 0 : storedMetadata.asRulesResource(),
+            after: storedMetadata === null || storedMetadata === void 0 ? void 0 : storedMetadata.asRulesResource(request.metadata),
+        }, request.authorization);
         if (!authorized) {
             throw new errors_1.ForbiddenError();
         }
@@ -147,7 +140,7 @@ class StorageLayer {
         storedMetadata.update(request.metadata);
         return storedMetadata;
     }
-    async handleUploadObject(upload, skipAuth = false) {
+    async uploadObject(upload) {
         if (upload.status !== upload_1.UploadStatus.FINISHED) {
             throw new Error(`Unexpected upload status encountered: ${upload.status}.`);
         }
@@ -162,8 +155,8 @@ class StorageLayer {
             cacheControl: upload.metadata.cacheControl,
             customMetadata: upload.metadata.metadata,
         }, this._cloudFunctions, this._persistence.readBytes(upload.path, upload.size));
-        const authorized = skipAuth ||
-            (await this._rulesValidator.validate(["b", upload.bucketId, "o", upload.objectId].join("/"), upload.bucketId, types_1.RulesetOperationMethod.CREATE, { after: metadata === null || metadata === void 0 ? void 0 : metadata.asRulesResource() }, upload.authorization));
+        metadata.update(upload.metadata, false);
+        const authorized = await this._rulesValidator.validate(["b", upload.bucketId, "o", upload.objectId].join("/"), upload.bucketId, types_1.RulesetOperationMethod.CREATE, { after: metadata === null || metadata === void 0 ? void 0 : metadata.asRulesResource() }, upload.authorization);
         if (!authorized) {
             this._persistence.deleteFile(upload.path);
             throw new errors_1.ForbiddenError();
@@ -174,17 +167,24 @@ class StorageLayer {
         this._cloudFunctions.dispatch("finalize", new metadata_1.CloudStorageObjectMetadata(metadata));
         return metadata;
     }
-    copyFile(sourceFile, destinationBucket, destinationObject, incomingMetadata) {
-        const filePath = this.path(destinationBucket, destinationObject);
-        this._persistence.deleteFile(filePath, true);
-        const bytes = this.getBytes(sourceFile.bucket, sourceFile.name);
-        this._persistence.appendBytes(filePath, bytes);
-        const newMetadata = Object.assign(Object.assign(Object.assign({}, sourceFile), { metadata: sourceFile.customMetadata }), incomingMetadata);
-        if (sourceFile.downloadTokens.length &&
+    copyObject({ sourceBucket, sourceObject, destinationBucket, destinationObject, incomingMetadata, authorization, }) {
+        if (!this._adminCredsValidator.validate(authorization)) {
+            throw new errors_1.ForbiddenError();
+        }
+        const sourceMetadata = this.getMetadata(sourceBucket, sourceObject);
+        if (!sourceMetadata) {
+            throw new errors_1.NotFoundError();
+        }
+        const sourceBytes = this.getBytes(sourceBucket, sourceObject);
+        const destinationFilePath = this.path(destinationBucket, destinationObject);
+        this._persistence.deleteFile(destinationFilePath, true);
+        this._persistence.appendBytes(destinationFilePath, sourceBytes);
+        const newMetadata = Object.assign(Object.assign(Object.assign({}, sourceMetadata), { metadata: sourceMetadata.customMetadata }), incomingMetadata);
+        if (sourceMetadata.downloadTokens.length &&
             !((incomingMetadata === null || incomingMetadata === void 0 ? void 0 : incomingMetadata.metadata) && Object.keys(incomingMetadata === null || incomingMetadata === void 0 ? void 0 : incomingMetadata.metadata).length)) {
             if (!newMetadata.metadata)
                 newMetadata.metadata = {};
-            newMetadata.metadata.firebaseStorageDownloadTokens = sourceFile.downloadTokens.join(",");
+            newMetadata.metadata.firebaseStorageDownloadTokens = sourceMetadata.downloadTokens.join(",");
         }
         if (newMetadata.metadata) {
             for (const [k, v] of Object.entries(newMetadata.metadata)) {
@@ -201,27 +201,23 @@ class StorageLayer {
             contentLanguage: newMetadata.contentLanguage,
             cacheControl: newMetadata.cacheControl,
             customMetadata: newMetadata.metadata,
-        }, this._cloudFunctions, bytes, incomingMetadata);
-        const file = new StoredFile(copiedFileMetadata, this._persistence.getDiskPath(filePath));
-        this._files.set(filePath, file);
+        }, this._cloudFunctions, sourceBytes, incomingMetadata);
+        const file = new StoredFile(copiedFileMetadata, this._persistence.getDiskPath(destinationFilePath));
+        this._files.set(destinationFilePath, file);
         this._cloudFunctions.dispatch("finalize", new metadata_1.CloudStorageObjectMetadata(file.metadata));
         return file.metadata;
     }
-    async handleListObjects(request, skipAuth = false) {
-        var _a, _b, _c;
-        const authorized = skipAuth ||
-            (await this._rulesValidator.validate(["b", request.bucketId, "o", request.prefix].join("/"), request.bucketId, types_1.RulesetOperationMethod.LIST, {}, request.authorization));
+    async listObjects(request) {
+        var _a;
+        const { bucketId, prefix, delimiter, pageToken, authorization } = request;
+        const authorized = await this._rulesValidator.validate(["b", bucketId, "o", prefix].join("/"), bucketId, types_1.RulesetOperationMethod.LIST, {}, authorization);
         if (!authorized) {
             throw new errors_1.ForbiddenError();
         }
-        const itemsResults = this.listItems(request.bucketId, request.prefix, request.delimiter, request.pageToken, request.maxResults);
-        return new list_1.ListResponse((_a = itemsResults.prefixes) !== null && _a !== void 0 ? _a : [], (_c = (_b = itemsResults.items) === null || _b === void 0 ? void 0 : _b.map((i) => new list_1.ListItem(i.name, i.bucket))) !== null && _c !== void 0 ? _c : [], itemsResults.nextPageToken);
-    }
-    listItems(bucket, prefix, delimiter, pageToken, maxResults) {
         let items = [];
         const prefixes = new Set();
         for (const [, file] of this._files) {
-            if (file.metadata.bucket !== bucket) {
+            if (file.metadata.bucket !== bucketId) {
                 continue;
             }
             const name = file.metadata.name;
@@ -258,9 +254,7 @@ class StorageLayer {
                 items = items.slice(idx);
             }
         }
-        if (!maxResults) {
-            maxResults = 1000;
-        }
+        const maxResults = (_a = request.maxResults) !== null && _a !== void 0 ? _a : 1000;
         let nextPageToken = undefined;
         if (items.length > maxResults) {
             nextPageToken = items[maxResults].name;
@@ -269,10 +263,10 @@ class StorageLayer {
         return {
             nextPageToken,
             prefixes: prefixes.size > 0 ? [...prefixes].sort() : undefined,
-            items: items.length > 0 ? items.map((item) => new metadata_1.CloudStorageObjectMetadata(item)) : undefined,
+            items: items.length > 0 ? items : undefined,
         };
     }
-    handleCreateDownloadToken(request) {
+    createDownloadToken(request) {
         if (!this._adminCredsValidator.validate(request.authorization)) {
             throw new errors_1.ForbiddenError();
         }
@@ -283,7 +277,7 @@ class StorageLayer {
         metadata.addDownloadToken();
         return metadata;
     }
-    handleDeleteDownloadToken(request) {
+    deleteDownloadToken(request) {
         if (!this._adminCredsValidator.validate(request.authorization)) {
             throw new errors_1.ForbiddenError();
         }
@@ -354,10 +348,16 @@ class StorageLayer {
                 logger_1.logger.warn(`Could not find file "${blobPath}" in storage export.`);
                 continue;
             }
-            const file = new StoredFile(metadata, blobPath);
-            this._files.set(blobPath, file);
+            let decodedBlobPath = decodeURIComponent(blobPath);
+            const decodedBlobPathSep = getPathSep(decodedBlobPath);
+            if (decodedBlobPathSep !== path.sep) {
+                decodedBlobPath = decodedBlobPath.split(decodedBlobPathSep).join(path.sep);
+            }
+            const blobDiskPath = this._persistence.getDiskPath(decodedBlobPath);
+            const file = new StoredFile(metadata, blobDiskPath);
+            this._files.set(decodedBlobPath, file);
+            fse.copyFileSync(blobAbsPath, blobDiskPath);
         }
-        fse.copySync(blobsDir, this.dirPath);
     }
     *walkDirSync(dir) {
         const files = (0, fs_1.readdirSync)(dir);
@@ -373,3 +373,7 @@ class StorageLayer {
     }
 }
 exports.StorageLayer = StorageLayer;
+function getPathSep(decodedPath) {
+    const firstSepIndex = decodedPath.search(/[^a-z0-9-_.]/g);
+    return decodedPath[firstSepIndex];
+}

package/lib/emulator/storage/index.js

@@ -13,19 +13,30 @@ const runtime_1 = require("./rules/runtime");
 const utils_1 = require("./rules/utils");
 const persistence_1 = require("./persistence");
 const upload_1 = require("./upload");
+const cloudFunctions_1 = require("./cloudFunctions");
 class StorageEmulator {
     constructor(args) {
         this.args = args;
         this._logger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.STORAGE);
+        this._files = new Map();
+        this._buckets = new Map();
         this._rulesRuntime = new runtime_1.StorageRulesRuntime();
-        this._rulesManager = (0, manager_1.createStorageRulesManager)(this.args.rules, this._rulesRuntime);
+        this._rulesManager = this.createRulesManager(this.args.rules);
+        this._cloudFunctions = new cloudFunctions_1.StorageCloudFunctions(args.projectId);
         this._persistence = new persistence_1.Persistence(this.getPersistenceTmpDir());
-        this._storageLayer = new files_1.StorageLayer(args.projectId, (0, utils_1.getRulesValidator)((resource) => this._rulesManager.getRuleset(resource)), (0, utils_1.getAdminCredentialValidator)(), this._persistence);
         this._uploadService = new upload_1.UploadService(this._persistence);
+        const createStorageLayer = (rulesValidator) => {
+            return new files_1.StorageLayer(args.projectId, this._files, this._buckets, rulesValidator, (0, utils_1.getAdminCredentialValidator)(), this._persistence, this._cloudFunctions);
+        };
+        this._storageLayer = createStorageLayer((0, utils_1.getFirebaseRulesValidator)((resource) => this._rulesManager.getRuleset(resource)));
+        this._adminStorageLayer = createStorageLayer((0, utils_1.getAdminOnlyFirebaseRulesValidator)());
     }
     get storageLayer() {
         return this._storageLayer;
     }
+    get adminStorageLayer() {
+        return this._adminStorageLayer;
+    }
     get uploadService() {
         return this._uploadService;
     }
@@ -36,7 +47,8 @@ class StorageEmulator {
         return this._logger;
     }
     reset() {
-        this._storageLayer.reset();
+        this._files.clear();
+        this._buckets.clear();
         this._persistence.reset(this.getPersistenceTmpDir());
         this._uploadService.reset();
     }
@@ -70,6 +82,14 @@ class StorageEmulator {
     getApp() {
         return this._app;
     }
+    async replaceRules(rules) {
+        await this._rulesManager.stop();
+        this._rulesManager = this.createRulesManager(rules);
+        return this._rulesManager.start();
+    }
+    createRulesManager(rules) {
+        return (0, manager_1.createStorageRulesManager)(rules, this._rulesRuntime);
+    }
     getPersistenceTmpDir() {
         return `${(0, os_1.tmpdir)()}/firebase/storage/blobs`;
     }

package/lib/emulator/storage/metadata.js

@@ -44,7 +44,7 @@ class StoredFileMetadata {
             throw new Error("Must pass bytes array or opts object with size, md5hash, and crc32c");
         }
         if (incomingMetadata) {
-            this.update(incomingMetadata);
+            this.update(incomingMetadata, false);
         }
         this.deleteFieldsSetAsNull();
         this.setDownloadTokensFromCustomMetadata();
@@ -86,8 +86,10 @@ class StoredFileMetadata {
         }
         if (this.customMetadata.firebaseStorageDownloadTokens) {
             this.downloadTokens = [
-                ...this.downloadTokens,
-                ...this.customMetadata.firebaseStorageDownloadTokens.split(","),
+                ...new Set([
+                    ...this.downloadTokens,
+                    ...this.customMetadata.firebaseStorageDownloadTokens.split(","),
+                ]),
             ];
             delete this.customMetadata.firebaseStorageDownloadTokens;
         }
@@ -115,7 +117,7 @@ class StoredFileMetadata {
             });
         }
     }
-    update(incoming) {
+    update(incoming, shouldTrigger = true) {
         if (incoming.contentDisposition) {
             this.contentDisposition = incoming.contentDisposition;
         }
@@ -143,15 +145,17 @@ class StoredFileMetadata {
         }
         this.setDownloadTokensFromCustomMetadata();
         this.deleteFieldsSetAsNull();
-        this._cloudFunctions.dispatch("metadataUpdate", new CloudStorageObjectMetadata(this));
+        if (shouldTrigger) {
+            this._cloudFunctions.dispatch("metadataUpdate", new CloudStorageObjectMetadata(this));
+        }
     }
-    addDownloadToken() {
+    addDownloadToken(shouldTrigger = true) {
         if (!this.downloadTokens.length) {
             this.downloadTokens.push(uuid.v4());
             return;
         }
         this.downloadTokens = [...this.downloadTokens, uuid.v4()];
-        this.update({});
+        this.update({}, shouldTrigger);
     }
     deleteDownloadToken(token) {
         if (!this.downloadTokens.length) {
@@ -160,7 +164,7 @@ class StoredFileMetadata {
         const remainingTokens = this.downloadTokens.filter((t) => t !== token);
         this.downloadTokens = remainingTokens;
         if (remainingTokens.length === 0) {
-            this.addDownloadToken();
+            this.addDownloadToken(false);
         }
         this.update({});
     }
@@ -265,6 +269,12 @@ class CloudStorageObjectMetadata {
         if (metadata.cacheControl) {
             this.cacheControl = metadata.cacheControl;
         }
+        if (metadata.contentDisposition) {
+            this.contentDisposition = metadata.contentDisposition;
+        }
+        if (metadata.contentEncoding) {
+            this.contentEncoding = metadata.contentEncoding;
+        }
         if (metadata.customTime) {
             this.customTime = toSerializedDate(metadata.customTime);
         }