firebase-tools 10.2.0 → 10.3.0

package/lib/emulator/storage/index.js

@@ -1,110 +1,61 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StorageEmulator = void 0;
+const os_1 = require("os");
 const utils = require("../../utils");
 const constants_1 = require("../constants");
 const types_1 = require("../types");
 const server_1 = require("./server");
 const files_1 = require("./files");
-const chokidar = require("chokidar");
 const emulatorLogger_1 = require("../emulatorLogger");
-const fs = require("fs");
+const manager_1 = require("./rules/manager");
 const runtime_1 = require("./rules/runtime");
-const error_1 = require("../../error");
-const downloadableEmulators_1 = require("../downloadableEmulators");
+const utils_1 = require("./rules/utils");
+const persistence_1 = require("./persistence");
+const upload_1 = require("./upload");
 class StorageEmulator {
     constructor(args) {
         this.args = args;
         this._logger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.STORAGE);
-        const downloadDetails = (0, downloadableEmulators_1.getDownloadDetails)(types_1.Emulators.STORAGE);
         this._rulesRuntime = new runtime_1.StorageRulesRuntime();
-        this._storageLayer = new files_1.StorageLayer(args.projectId);
+        this._rulesManager = new manager_1.StorageRulesManager(this._rulesRuntime);
+        this._persistence = new persistence_1.Persistence(this.getPersistenceTmpDir());
+        this._storageLayer = new files_1.StorageLayer(args.projectId, (0, utils_1.getRulesValidator)(() => this.rules), (0, utils_1.getAdminCredentialValidator)(), this._persistence);
+        this._uploadService = new upload_1.UploadService(this._persistence);
     }
     get storageLayer() {
         return this._storageLayer;
     }
+    get uploadService() {
+        return this._uploadService;
+    }
     get rules() {
-        return this._rules;
+        return this._rulesManager.ruleset;
     }
     get logger() {
         return this._logger;
     }
+    reset() {
+        this._storageLayer.reset();
+        this._persistence.reset(this.getPersistenceTmpDir());
+        this._uploadService.reset();
+    }
     async start() {
         const { host, port } = this.getInfo();
         await this._rulesRuntime.start(this.args.auto_download);
+        await this._rulesManager.setSourceFile(this.args.rules[0].rules);
         this._app = await (0, server_1.createApp)(this.args.projectId, this);
-        if (typeof this.args.rules == "string") {
-            const rulesFile = this.args.rules;
-            this.updateRulesSource(rulesFile);
-        }
-        else {
-            this._rulesetSource = this.args.rules;
-        }
-        if (!this._rulesetSource || this._rulesetSource.files.length == 0) {
-            throw new error_1.FirebaseError("Can not initialize Storage emulator without a rules source / file.");
-        }
-        else if (this._rulesetSource.files.length > 1) {
-            throw new error_1.FirebaseError("Can not initialize Storage emulator with more than one rules source / file.");
-        }
-        await this.loadRuleset();
-        const rulesPath = this._rulesetSource.files[0].name;
-        this._rulesWatcher = chokidar.watch(rulesPath, { persistent: true, ignoreInitial: true });
-        this._rulesWatcher.on("change", async () => {
-            await new Promise((res) => setTimeout(res, 5));
-            this._logger.logLabeled("BULLET", "storage", `Change detected, updating rules for Cloud Storage...`);
-            this.updateRulesSource(rulesPath);
-            await this.loadRuleset();
-        });
         const server = this._app.listen(port, host);
         this.destroyServer = utils.createDestroyer(server);
     }
-    updateRulesSource(rulesFile) {
-        this._rulesetSource = {
-            files: [
-                {
-                    name: rulesFile,
-                    content: fs.readFileSync(rulesFile).toString(),
-                },
-            ],
-        };
-    }
-    async loadRuleset(source) {
-        if (source) {
-            this._rulesetSource = source;
-        }
-        if (!this._rulesetSource) {
-            const msg = "Attempting to update ruleset without a source.";
-            this._logger.log("WARN", msg);
-            const error = JSON.stringify({ error: msg });
-            return new runtime_1.StorageRulesIssues([error], []);
-        }
-        const { ruleset, issues } = await this._rulesRuntime.loadRuleset(this._rulesetSource);
-        if (!ruleset) {
-            issues.all.forEach((issue) => {
-                let parsedIssue;
-                try {
-                    parsedIssue = JSON.parse(issue);
-                }
-                catch (_a) {
-                }
-                if (parsedIssue) {
-                    this._logger.log("WARN", `${parsedIssue.description_.replace(/\.$/, "")} in ${parsedIssue.sourcePosition_.fileName_}:${parsedIssue.sourcePosition_.line_}`);
-                }
-                else {
-                    this._logger.log("WARN", issue);
-                }
-            });
-            delete this._rules;
-        }
-        else {
-            this._rules = ruleset;
-        }
-        return issues;
-    }
     async connect() {
     }
+    async setRules(rules) {
+        return this._rulesManager.setSourceFile(rules);
+    }
     async stop() {
-        await this.storageLayer.deleteAll();
+        await this._persistence.deleteAll();
+        await this._rulesManager.close();
         return this.destroyServer ? this.destroyServer() : Promise.resolve();
     }
     getInfo() {
@@ -122,5 +73,8 @@ class StorageEmulator {
     getApp() {
         return this._app;
     }
+    getPersistenceTmpDir() {
+        return `${(0, os_1.tmpdir)()}/firebase/storage/blobs`;
+    }
 }
 exports.StorageEmulator = StorageEmulator;

package/lib/emulator/storage/metadata.js

@@ -15,14 +15,19 @@ class StoredFileMetadata {
         this.metageneration = opts.metageneration || 1;
         this.generation = opts.generation || Date.now();
         this.storageClass = opts.storageClass || "STANDARD";
-        this.etag = opts.etag || "someETag";
         this.contentDisposition = opts.contentDisposition || "inline";
-        this.cacheControl = opts.cacheControl;
+        this.cacheControl = opts.cacheControl || "public, max-age=3600";
         this.contentLanguage = opts.contentLanguage;
         this.customTime = opts.customTime;
         this.contentEncoding = opts.contentEncoding || "identity";
         this.customMetadata = opts.customMetadata;
         this.downloadTokens = opts.downloadTokens || [];
+        if (opts.etag) {
+            this.etag = opts.etag;
+        }
+        else {
+            this.etag = generateETag(this.generation, this.metageneration);
+        }
         this.timeCreated = opts.timeCreated ? new Date(opts.timeCreated) : new Date();
         this.updated = opts.updated ? new Date(opts.updated) : this.timeCreated;
         if (bytes) {
@@ -118,7 +123,10 @@ class StoredFileMetadata {
             this.contentType = incoming.contentType;
         }
         if (incoming.metadata) {
-            this.customMetadata = incoming.metadata;
+            this.customMetadata = this.customMetadata ? Object.assign({}, this.customMetadata) : {};
+            for (const [k, v] of Object.entries(incoming.metadata)) {
+                this.customMetadata[k] = v === null ? null : String(v);
+            }
         }
         if (incoming.contentLanguage) {
             this.contentLanguage = incoming.contentLanguage;
@@ -149,9 +157,9 @@ class StoredFileMetadata {
         if (!this.downloadTokens.length) {
             return;
         }
-        const remainingTokens = this.downloadTokens.filter((t) => t != token);
+        const remainingTokens = this.downloadTokens.filter((t) => t !== token);
         this.downloadTokens = remainingTokens;
-        if (remainingTokens.length == 0) {
+        if (remainingTokens.length === 0) {
             this.addDownloadToken();
         }
         this.update({});
@@ -171,25 +179,25 @@ class StoredFileMetadata {
 }
 exports.StoredFileMetadata = StoredFileMetadata;
 class OutgoingFirebaseMetadata {
-    constructor(md) {
-        this.name = md.name;
-        this.bucket = md.bucket;
-        this.generation = md.generation.toString();
-        this.metageneration = md.metageneration.toString();
-        this.contentType = md.contentType;
-        this.timeCreated = toSerializedDate(md.timeCreated);
-        this.updated = toSerializedDate(md.updated);
-        this.storageClass = md.storageClass;
-        this.size = md.size.toString();
-        this.md5Hash = md.md5Hash;
-        this.crc32c = md.crc32c;
-        this.etag = md.etag;
-        this.downloadTokens = md.downloadTokens.join(",");
-        this.contentEncoding = md.contentEncoding;
-        this.contentDisposition = md.contentDisposition;
-        this.metadata = md.customMetadata;
-        this.contentLanguage = md.contentLanguage;
-        this.cacheControl = md.cacheControl;
+    constructor(metadata) {
+        this.name = metadata.name;
+        this.bucket = metadata.bucket;
+        this.generation = metadata.generation.toString();
+        this.metageneration = metadata.metageneration.toString();
+        this.contentType = metadata.contentType;
+        this.timeCreated = toSerializedDate(metadata.timeCreated);
+        this.updated = toSerializedDate(metadata.updated);
+        this.storageClass = metadata.storageClass;
+        this.size = metadata.size.toString();
+        this.md5Hash = metadata.md5Hash;
+        this.crc32c = metadata.crc32c;
+        this.etag = metadata.etag;
+        this.downloadTokens = metadata.downloadTokens.join(",");
+        this.contentEncoding = metadata.contentEncoding;
+        this.contentDisposition = metadata.contentDisposition;
+        this.metadata = metadata.customMetadata;
+        this.contentLanguage = metadata.contentLanguage;
+        this.cacheControl = metadata.cacheControl;
     }
 }
 exports.OutgoingFirebaseMetadata = OutgoingFirebaseMetadata;
@@ -226,44 +234,45 @@ class CloudStorageObjectAccessControlMetadata {
 }
 exports.CloudStorageObjectAccessControlMetadata = CloudStorageObjectAccessControlMetadata;
 class CloudStorageObjectMetadata {
-    constructor(md) {
+    constructor(metadata) {
         var _a, _b, _c, _d;
         this.kind = "#storage#object";
-        this.name = md.name;
-        this.bucket = md.bucket;
-        this.generation = md.generation.toString();
-        this.metageneration = md.metageneration.toString();
-        this.contentType = md.contentType;
-        this.timeCreated = toSerializedDate(md.timeCreated);
-        this.updated = toSerializedDate(md.updated);
-        this.storageClass = md.storageClass;
-        this.size = md.size.toString();
-        this.md5Hash = md.md5Hash;
-        this.etag = md.etag;
+        this.name = metadata.name;
+        this.bucket = metadata.bucket;
+        this.generation = metadata.generation.toString();
+        this.metageneration = metadata.metageneration.toString();
+        this.contentType = metadata.contentType;
+        this.contentDisposition = metadata.contentDisposition;
+        this.timeCreated = toSerializedDate(metadata.timeCreated);
+        this.updated = toSerializedDate(metadata.updated);
+        this.storageClass = metadata.storageClass;
+        this.size = metadata.size.toString();
+        this.md5Hash = metadata.md5Hash;
+        this.etag = metadata.etag;
         this.metadata = {};
-        if (Object.keys(md.customMetadata || {})) {
-            this.metadata = Object.assign(Object.assign({}, this.metadata), md.customMetadata);
+        if (Object.keys(metadata.customMetadata || {})) {
+            this.metadata = Object.assign(Object.assign({}, this.metadata), metadata.customMetadata);
         }
-        if (md.downloadTokens.length) {
-            this.metadata = Object.assign(Object.assign({}, this.metadata), { firebaseStorageDownloadTokens: md.downloadTokens.join(",") });
+        if (metadata.downloadTokens.length) {
+            this.metadata = Object.assign(Object.assign({}, this.metadata), { firebaseStorageDownloadTokens: metadata.downloadTokens.join(",") });
         }
         if (!Object.keys(this.metadata).length) {
             delete this.metadata;
         }
-        if (md.contentLanguage) {
-            this.contentLanguage = md.contentLanguage;
+        if (metadata.contentLanguage) {
+            this.contentLanguage = metadata.contentLanguage;
         }
-        if (md.cacheControl) {
-            this.cacheControl = md.cacheControl;
+        if (metadata.cacheControl) {
+            this.cacheControl = metadata.cacheControl;
         }
-        if (md.customTime) {
-            this.customTime = toSerializedDate(md.customTime);
+        if (metadata.customTime) {
+            this.customTime = toSerializedDate(metadata.customTime);
         }
-        this.crc32c = "----" + Buffer.from([md.crc32c]).toString("base64");
-        this.timeStorageClassUpdated = toSerializedDate(md.timeCreated);
-        this.id = `${md.bucket}/${md.name}/${md.generation}`;
-        this.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)}`;
-        this.mediaLink = `http://${(_c = registry_1.EmulatorRegistry.getInfo(types_1.Emulators.STORAGE)) === null || _c === void 0 ? void 0 : _c.host}:${(_d = registry_1.EmulatorRegistry.getInfo(types_1.Emulators.STORAGE)) === null || _d === void 0 ? void 0 : _d.port}/download/storage/v1/b/${md.bucket}/o/${encodeURIComponent(md.name)}?generation=${md.generation}&alt=media`;
+        this.crc32c = (0, crc_1.crc32cToString)(metadata.crc32c);
+        this.timeStorageClassUpdated = toSerializedDate(metadata.timeCreated);
+        this.id = `${metadata.bucket}/${metadata.name}/${metadata.generation}`;
+        this.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)}`;
+        this.mediaLink = `http://${(_c = registry_1.EmulatorRegistry.getInfo(types_1.Emulators.STORAGE)) === null || _c === void 0 ? void 0 : _c.host}:${(_d = registry_1.EmulatorRegistry.getInfo(types_1.Emulators.STORAGE)) === null || _d === void 0 ? void 0 : _d.port}/download/storage/v1/b/${metadata.bucket}/o/${encodeURIComponent(metadata.name)}?generation=${metadata.generation}&alt=media`;
     }
 }
 exports.CloudStorageObjectMetadata = CloudStorageObjectMetadata;
@@ -287,3 +296,8 @@ function generateMd5Hash(bytes) {
     hash.update(bytes);
     return hash.digest("base64");
 }
+function generateETag(generation, metadatageneration) {
+    const hash = crypto.createHash("sha1");
+    hash.update(`${generation}/${metadatageneration}`);
+    return hash.digest("base64").slice(0, -1);
+}

package/lib/emulator/storage/multipart.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseObjectUploadMultipartRequest = void 0;
+const LINE_SEPARATOR = `\r\n`;
+function splitBufferByDelimiter(buffer, delimiter, maxResults = -1) {
+    let offset = 0;
+    let nextDelimiterIndex = buffer.indexOf(delimiter, offset);
+    const bufferParts = [];
+    while (nextDelimiterIndex !== -1) {
+        if (maxResults === 0) {
+            return bufferParts;
+        }
+        else if (maxResults === 1) {
+            bufferParts.push(Buffer.from(buffer.slice(offset)));
+            return bufferParts;
+        }
+        bufferParts.push(Buffer.from(buffer.slice(offset, nextDelimiterIndex)));
+        offset = nextDelimiterIndex + delimiter.length;
+        nextDelimiterIndex = buffer.indexOf(delimiter, offset);
+        maxResults -= 1;
+    }
+    bufferParts.push(Buffer.from(buffer.slice(offset)));
+    return bufferParts;
+}
+function parseMultipartRequestBody(boundaryId, body) {
+    const boundaryString = `--${boundaryId}`;
+    const bodyParts = splitBufferByDelimiter(body, boundaryString).map((buf) => {
+        return Buffer.from(buf.slice(2));
+    });
+    const parsedParts = [];
+    for (const bodyPart of bodyParts.slice(1, bodyParts.length - 1)) {
+        parsedParts.push(parseMultipartRequestBodyPart(bodyPart));
+    }
+    return parsedParts;
+}
+function parseMultipartRequestBodyPart(bodyPart) {
+    const sections = splitBufferByDelimiter(bodyPart, LINE_SEPARATOR, 3);
+    const contentTypeRaw = sections[0].toString();
+    if (!contentTypeRaw.startsWith("Content-Type: ")) {
+        throw new Error(`Failed to parse multipart request body part. Missing content type.`);
+    }
+    const dataRaw = Buffer.from(sections[2]).slice(0, sections[2].byteLength - LINE_SEPARATOR.length);
+    return { contentTypeRaw, dataRaw };
+}
+function parseObjectUploadMultipartRequest(contentTypeHeader, body) {
+    if (!contentTypeHeader.startsWith("multipart/related")) {
+        throw new Error(`Invalid Content-Type: ${contentTypeHeader}`);
+    }
+    const boundaryId = contentTypeHeader.split("boundary=")[1];
+    if (!boundaryId) {
+        throw new Error(`Invalid Content-Type header: ${contentTypeHeader}`);
+    }
+    const parsedBody = parseMultipartRequestBody(boundaryId, body);
+    if (parsedBody.length !== 2) {
+        throw new Error(`Unexpected number of parts in request body`);
+    }
+    return {
+        metadataRaw: parsedBody[0].dataRaw.toString(),
+        dataRaw: Buffer.from(parsedBody[1].dataRaw),
+    };
+}
+exports.parseObjectUploadMultipartRequest = parseObjectUploadMultipartRequest;

package/lib/emulator/storage/persistence.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Persistence = void 0;
+const fs_1 = require("fs");
+const rimraf = require("rimraf");
+const fs = require("fs");
+const path = require("path");
+class Persistence {
+    constructor(dirPath) {
+        this.reset(dirPath);
+    }
+    reset(dirPath) {
+        this._dirPath = dirPath;
+        (0, fs_1.mkdirSync)(dirPath, {
+            recursive: true,
+        });
+    }
+    get dirPath() {
+        return this._dirPath;
+    }
+    appendBytes(fileName, bytes) {
+        const filepath = this.getDiskPath(fileName);
+        let fd;
+        try {
+            fs.appendFileSync(filepath, bytes);
+            return filepath;
+        }
+        finally {
+            if (fd) {
+                (0, fs_1.closeSync)(fd);
+            }
+        }
+    }
+    readBytes(fileName, size, fileOffset) {
+        let fd;
+        try {
+            fd = (0, fs_1.openSync)(this.getDiskPath(fileName), "r");
+            const buf = Buffer.alloc(size);
+            const offset = fileOffset && fileOffset > 0 ? fileOffset : 0;
+            (0, fs_1.readSync)(fd, buf, 0, size, offset);
+            return buf;
+        }
+        finally {
+            if (fd) {
+                (0, fs_1.closeSync)(fd);
+            }
+        }
+    }
+    deleteFile(fileName, failSilently = false) {
+        try {
+            (0, fs_1.unlinkSync)(this.getDiskPath(fileName));
+        }
+        catch (err) {
+            if (!failSilently) {
+                throw err;
+            }
+        }
+    }
+    deleteAll() {
+        return new Promise((resolve, reject) => {
+            rimraf(this._dirPath, (err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    renameFile(oldName, newName) {
+        (0, fs_1.renameSync)(this.getDiskPath(oldName), this.getDiskPath(newName));
+    }
+    getDiskPath(fileName) {
+        return path.join(this._dirPath, encodeURIComponent(fileName));
+    }
+}
+exports.Persistence = Persistence;

package/lib/emulator/storage/rules/config.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStorageRulesConfig = void 0;
+const error_1 = require("../../../error");
+function getAbsoluteRulesPath(rules, options) {
+    return options.config.path(rules);
+}
+function getStorageRulesConfig(projectId, options) {
+    const storageConfig = options.config.data.storage;
+    if (!storageConfig) {
+        throw new error_1.FirebaseError("Cannot start the Storage emulator without rules file specified in firebase.json: run 'firebase init' and set up your Storage configuration");
+    }
+    if (!Array.isArray(storageConfig)) {
+        if (!storageConfig.rules) {
+            throw new error_1.FirebaseError("Cannot start the Storage emulator without rules file specified in firebase.json: run 'firebase init' and set up your Storage configuration");
+        }
+        const resource = "default";
+        return [{ resource, rules: getAbsoluteRulesPath(storageConfig.rules, options) }];
+    }
+    const results = [];
+    const { rc } = options;
+    for (const targetConfig of storageConfig) {
+        if (!targetConfig.target) {
+            throw new error_1.FirebaseError("Must supply 'target' in Storage configuration");
+        }
+        rc.requireTarget(projectId, "storage", targetConfig.target);
+        rc.target(projectId, "storage", targetConfig.target).forEach((resource) => {
+            results.push({ resource, rules: getAbsoluteRulesPath(targetConfig.rules, options) });
+        });
+    }
+    return results;
+}
+exports.getStorageRulesConfig = getStorageRulesConfig;

package/lib/emulator/storage/rules/manager.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageRulesManager = void 0;
+const chokidar = require("chokidar");
+const fs = require("fs");
+const emulatorLogger_1 = require("../../emulatorLogger");
+const types_1 = require("../../types");
+const error_1 = require("../../../error");
+class StorageRulesManager {
+    constructor(_runtime) {
+        this._runtime = _runtime;
+        this._watcher = new chokidar.FSWatcher();
+        this._logger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.STORAGE);
+    }
+    get ruleset() {
+        return this._ruleset;
+    }
+    async setSourceFile(rules) {
+        var _a;
+        const prevRulesFile = (_a = this._sourceFile) === null || _a === void 0 ? void 0 : _a.name;
+        let rulesFile;
+        if (typeof rules === "string") {
+            this._sourceFile = { name: rules, content: readSourceFile(rules) };
+            rulesFile = rules;
+        }
+        else {
+            this._sourceFile = rules;
+            rulesFile = rules.name;
+        }
+        const issues = await this.loadRuleset();
+        this.updateWatcher(rulesFile, prevRulesFile);
+        return issues;
+    }
+    async close() {
+        delete this._sourceFile;
+        delete this._ruleset;
+        await this._watcher.close();
+    }
+    updateWatcher(rulesFile, prevRulesFile) {
+        if (prevRulesFile) {
+            this._watcher.unwatch(prevRulesFile);
+        }
+        this._watcher = chokidar
+            .watch(rulesFile, { persistent: true, ignoreInitial: true })
+            .on("change", async () => {
+            await new Promise((res) => setTimeout(res, 5));
+            this._logger.logLabeled("BULLET", "storage", "Change detected, updating rules for Cloud Storage...");
+            await this.loadRuleset();
+        });
+    }
+    async loadRuleset() {
+        const { ruleset, issues } = await this._runtime.loadRuleset({ files: [this._sourceFile] });
+        if (ruleset) {
+            this._ruleset = ruleset;
+            return issues;
+        }
+        delete this._ruleset;
+        issues.all.forEach((issue) => {
+            try {
+                const parsedIssue = JSON.parse(issue);
+                this._logger.log("WARN", `${parsedIssue.description_.replace(/\.$/, "")} in ${parsedIssue.sourcePosition_.fileName_}:${parsedIssue.sourcePosition_.line_}`);
+            }
+            catch (_a) {
+                this._logger.log("WARN", issue);
+            }
+        });
+        return issues;
+    }
+}
+exports.StorageRulesManager = StorageRulesManager;
+function readSourceFile(fileName) {
+    try {
+        return fs.readFileSync(fileName).toString();
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            throw new error_1.FirebaseError(`File not found: ${fileName}`);
+        }
+        throw error;
+    }
+}

package/lib/emulator/storage/rules/runtime.js

@@ -20,7 +20,7 @@ class StorageRulesetInstance {
         this.rulesetName = rulesetName;
     }
     async verify(opts, runtimeVariableOverrides = {}) {
-        if (opts.method == types_1.RulesetOperationMethod.LIST && this.rulesVersion < 2) {
+        if (opts.method === types_1.RulesetOperationMethod.LIST && this.rulesVersion < 2) {
             const issues = new StorageRulesIssues();
             issues.warnings.push("Permission denied. List operations are only allowed for rules_version='2'.");
             return {
@@ -103,6 +103,7 @@ class StorageRulesRuntime {
         (_a = this._childprocess.stderr) === null || _a === void 0 ? void 0 : _a.on("data", (buf) => {
             const error = buf.toString();
             if (error.includes("jarfile")) {
+                emulatorLogger_1.EmulatorLogger.forEmulator(types_2.Emulators.STORAGE).log("ERROR", error);
                 throw new error_1.FirebaseError("There was an issue starting the rules emulator, please run 'firebase setup:emulators:storage` again");
             }
             else {
@@ -111,7 +112,7 @@ class StorageRulesRuntime {
         });
         (_b = this._childprocess.stdout) === null || _b === void 0 ? void 0 : _b.on("data", (buf) => {
             const serializedRuntimeActionResponse = buf.toString("UTF8").trim();
-            if (serializedRuntimeActionResponse != "") {
+            if (serializedRuntimeActionResponse !== "") {
                 let rap;
                 try {
                     rap = JSON.parse(serializedRuntimeActionResponse);
@@ -217,14 +218,14 @@ class StorageRulesRuntime {
 }
 exports.StorageRulesRuntime = StorageRulesRuntime;
 function toExpressionValue(obj) {
-    if (typeof obj == "string") {
+    if (typeof obj === "string") {
         return { string_value: obj };
     }
-    if (typeof obj == "boolean") {
+    if (typeof obj === "boolean") {
         return { bool_value: obj };
     }
-    if (typeof obj == "number") {
-        if (Math.floor(obj) == obj) {
+    if (typeof obj === "number") {
+        if (Math.floor(obj) === obj) {
             return { int_value: obj };
         }
         else {
@@ -255,7 +256,7 @@ function toExpressionValue(obj) {
             null_value: 0,
         };
     }
-    if (typeof obj == "object") {
+    if (typeof obj === "object") {
         const fields = {};
         Object.keys(obj).forEach((key) => {
             fields[key] = toExpressionValue(obj[key]);

package/lib/emulator/storage/rules/utils.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPermitted = exports.getAdminCredentialValidator = exports.getRulesValidator = void 0;
+const emulatorLogger_1 = require("../../emulatorLogger");
+const types_1 = require("../../types");
+function getRulesValidator(rulesetProvider) {
+    return {
+        validate: async (path, method, variableOverrides, authorization) => {
+            return await isPermitted({
+                ruleset: rulesetProvider(),
+                file: variableOverrides,
+                path,
+                method,
+                authorization,
+            });
+        },
+    };
+}
+exports.getRulesValidator = getRulesValidator;
+function getAdminCredentialValidator() {
+    return { validate: isValidAdminCredentials };
+}
+exports.getAdminCredentialValidator = getAdminCredentialValidator;
+async function isPermitted(opts) {
+    if (!opts.ruleset) {
+        emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.STORAGE).log("WARN", `Can not process SDK request with no loaded ruleset`);
+        return false;
+    }
+    if (isValidAdminCredentials(opts.authorization)) {
+        return true;
+    }
+    const { permitted, issues } = await opts.ruleset.verify({
+        method: opts.method,
+        path: opts.path,
+        file: opts.file,
+        token: opts.authorization ? opts.authorization.split(" ")[1] : undefined,
+    });
+    if (issues.exist()) {
+        issues.all.forEach((warningOrError) => {
+            emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.STORAGE).log("WARN", warningOrError);
+        });
+    }
+    return !!permitted;
+}
+exports.isPermitted = isPermitted;
+function isValidAdminCredentials(authorization) {
+    return ["Bearer owner", "Firebase owner"].includes(authorization !== null && authorization !== void 0 ? authorization : "");
+}