firebase-tools 10.2.2 → 10.4.0

package/lib/emulator/storage/index.js

@@ -1,110 +1,58 @@
 "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 = (0, manager_1.createStorageRulesManager)(this.args.rules, this._rulesRuntime);
+        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);
     }
     get storageLayer() {
         return this._storageLayer;
     }
-    get rules() {
-        return this._rules;
+    get uploadService() {
+        return this._uploadService;
+    }
+    get rulesManager() {
+        return this._rulesManager;
     }
     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.start();
         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 stop() {
-        await this.storageLayer.deleteAll();
+        await this._persistence.deleteAll();
+        await this._rulesManager.stop();
         return this.destroyServer ? this.destroyServer() : Promise.resolve();
     }
     getInfo() {
@@ -122,5 +70,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;
@@ -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,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStorageRulesConfig = void 0;
+const error_1 = require("../../../error");
+const fsutils_1 = require("../../../fsutils");
+function getSourceFile(rules, options) {
+    const path = options.config.path(rules);
+    return { name: path, content: (0, fsutils_1.readFile)(path) };
+}
+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");
+        }
+        return getSourceFile(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: getSourceFile(targetConfig.rules, options) });
+        });
+    }
+    return results;
+}
+exports.getStorageRulesConfig = getStorageRulesConfig;

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

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStorageRulesManager = void 0;
+const chokidar = require("chokidar");
+const emulatorLogger_1 = require("../../emulatorLogger");
+const types_1 = require("../../types");
+const runtime_1 = require("./runtime");
+function createStorageRulesManager(rules, runtime) {
+    return Array.isArray(rules)
+        ? new ResourceBasedStorageRulesManager(rules, runtime)
+        : new DefaultStorageRulesManager(rules, runtime);
+}
+exports.createStorageRulesManager = createStorageRulesManager;
+class DefaultStorageRulesManager {
+    constructor(_rules, _runtime) {
+        this._runtime = _runtime;
+        this._watcher = new chokidar.FSWatcher();
+        this._logger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.STORAGE);
+        this._rules = _rules;
+    }
+    start() {
+        return this.updateSourceFile(this._rules);
+    }
+    getRuleset() {
+        return this._ruleset;
+    }
+    async updateSourceFile(rules) {
+        const prevRulesFile = this._rules.name;
+        this._rules = rules;
+        const issues = await this.loadRuleset();
+        this.updateWatcher(rules.name, prevRulesFile);
+        return issues;
+    }
+    async stop() {
+        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._rules] });
+        if (ruleset) {
+            this._ruleset = ruleset;
+            return issues;
+        }
+        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;
+    }
+}
+class ResourceBasedStorageRulesManager {
+    constructor(_rulesConfig, _runtime) {
+        this._runtime = _runtime;
+        this._rulesManagers = new Map();
+        for (const { resource, rules } of _rulesConfig) {
+            this.createRulesManager(resource, rules);
+        }
+    }
+    async start() {
+        const allIssues = new runtime_1.StorageRulesIssues();
+        for (const rulesManager of this._rulesManagers.values()) {
+            allIssues.extend(await rulesManager.start());
+        }
+        return allIssues;
+    }
+    getRuleset(resource) {
+        var _a;
+        return (_a = this._rulesManagers.get(resource)) === null || _a === void 0 ? void 0 : _a.getRuleset();
+    }
+    updateSourceFile(rules, resource) {
+        const rulesManager = this._rulesManagers.get(resource) || this.createRulesManager(resource, rules);
+        return rulesManager.updateSourceFile(rules);
+    }
+    async stop() {
+        await Promise.all(Array.from(this._rulesManagers.values(), async (rulesManager) => await rulesManager.stop()));
+    }
+    createRulesManager(resource, rules) {
+        const rulesManager = new DefaultStorageRulesManager(rules, this._runtime);
+        this._rulesManagers.set(resource, rulesManager);
+        return rulesManager;
+    }
+}

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

@@ -49,6 +49,10 @@ class StorageRulesIssues {
     exist() {
         return !!(this.errors.length || this.warnings.length);
     }
+    extend(other) {
+        this.errors.push(...other.errors);
+        this.warnings.push(...other.warnings);
+    }
 }
 exports.StorageRulesIssues = StorageRulesIssues;
 class StorageRulesRuntime {

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, bucketId, method, variableOverrides, authorization) => {
+            return await isPermitted({
+                ruleset: rulesetProvider(bucketId),
+                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 : "");
+}

package/lib/emulator/storage/server.js

@@ -58,7 +58,7 @@ function createApp(defaultProjectId, emulator) {
         }
         const name = file.name;
         const content = file.content;
-        const issues = await emulator.loadRuleset({ files: [{ name, content }] });
+        const issues = await emulator.rulesManager.updateSourceFile({ name, content }, req.params.bucketId);
         if (issues.errors.length > 0) {
             res.status(400).json({
                 message: "There was an error updating rules, see logs for more details",
@@ -70,7 +70,7 @@ function createApp(defaultProjectId, emulator) {
         });
     });
     app.post("/internal/reset", (req, res) => {
-        storageLayer.reset();
+        emulator.reset();
         res.sendStatus(200);
     });
     app.use("/v0", (0, firebase_1.createFirebaseEndpoints)(emulator));