firebase-tools 10.6.0 → 10.7.2

package/lib/emulator/functionsEmulator.js

@@ -13,7 +13,7 @@ const url_1 = require("url");
 const events_1 = require("events");
 const api = require("../api");
 const logger_1 = require("../logger");
-const track = require("../track");
+const track_1 = require("../track");
 const constants_1 = require("./constants");
 const types_1 = require("./types");
 const chokidar = require("chokidar");
@@ -34,6 +34,7 @@ const secretManager_1 = require("../gcp/secretManager");
 const runtimes = require("../deploy/functions/runtimes");
 const backend = require("../deploy/functions/backend");
 const functionsEnv = require("../functions/env");
+const v1_1 = require("../functions/events/v1");
 const EVENT_INVOKE = "functions:invoke";
 const DATABASE_PATH_PATTERN = new RegExp("^projects/[^/]+/instances/([^/]+)/refs(/.*)$");
 class FunctionsEmulator {
@@ -54,6 +55,16 @@ class FunctionsEmulator {
             : types_1.FunctionsExecutionMode.AUTO;
         this.workerPool = new functionsRuntimeWorker_1.RuntimeWorkerPool(mode);
         this.workQueue = new workQueue_1.WorkQueue(mode);
+        this.blockingFunctionsConfig = {
+            triggers: {
+                beforeCreate: {
+                    functionUri: "",
+                },
+                beforeSignIn: {
+                    functionUri: "",
+                },
+            },
+        };
     }
     static getHttpFunctionUrl(host, port, projectId, name, region) {
         return `http://${host}:${port}/${projectId}/${region}/${name}`;
@@ -166,7 +177,9 @@ class FunctionsEmulator {
         });
         return hub;
     }
-    async invokeTrigger(backend, trigger, proto, runtimeOpts) {
+    async invokeTrigger(trigger, proto, runtimeOpts) {
+        const record = this.getTriggerRecordByKey(this.getTriggerKey(trigger));
+        const backend = record.backend;
         const bundleTemplate = this.getBaseBundle();
         const runtimeBundle = Object.assign(Object.assign({}, bundleTemplate), { proto });
         if (this.args.debugPort) {
@@ -210,7 +223,6 @@ class FunctionsEmulator {
         return Promise.resolve();
     }
     async connect() {
-        const loadTriggerPromises = [];
         for (const backend of this.args.emulatableBackends) {
             this.logger.logLabeled("BULLET", "functions", `Watching "${backend.functionsDir}" for Cloud Functions...`);
             const watcher = chokidar.watch(backend.functionsDir, {
@@ -226,9 +238,9 @@ class FunctionsEmulator {
                 this.logger.log("DEBUG", `File ${filePath} changed, reloading triggers`);
                 return debouncedLoadTriggers();
             });
-            loadTriggerPromises.push(this.loadTriggers(backend, true));
+            await this.loadTriggers(backend, true);
         }
-        await Promise.all(loadTriggerPromises);
+        await this.performPostLoadOperations();
         return;
     }
     async stop() {
@@ -271,6 +283,10 @@ class FunctionsEmulator {
             logger_1.logger.debug(`Analyzing ${runtimeDelegate.name} backend spec`);
             const discoveredBackend = await runtimeDelegate.discoverSpec(runtimeConfig, Object.assign(Object.assign(Object.assign(Object.assign({}, this.getSystemEnvs()), this.getEmulatorEnvs()), { FIREBASE_CONFIG: this.getFirebaseConfig() }), emulatableBackend.env));
             const endpoints = backend.allEndpoints(discoveredBackend);
+            (0, functionsEmulatorShared_1.prepareEndpoints)(endpoints);
+            for (const e of endpoints) {
+                e.codebase = emulatableBackend.codebase;
+            }
             triggerDefinitions = (0, functionsEmulatorShared_1.emulatedFunctionsFromEndpoints)(endpoints);
         }
         const toSetup = triggerDefinitions.filter((definition) => {
@@ -327,6 +343,11 @@ class FunctionsEmulator {
                         break;
                 }
             }
+            else if (definition.blockingTrigger) {
+                const { host, port } = this.getInfo();
+                url = FunctionsEmulator.getHttpFunctionUrl(host, port, this.args.projectId, definition.name, definition.region);
+                added = this.addBlockingTrigger(url, definition.blockingTrigger);
+            }
             else {
                 this.logger.log("WARN", `Unsupported function type on ${definition.name}. Expected either httpsTrigger or eventTrigger.`);
             }
@@ -350,6 +371,34 @@ class FunctionsEmulator {
             this.startRuntime(emulatableBackend, { nodeBinary: emulatableBackend.nodeBinary });
         }
     }
+    async performPostLoadOperations() {
+        var _a, _b, _c, _d;
+        if (((_b = (_a = this.blockingFunctionsConfig.triggers) === null || _a === void 0 ? void 0 : _a.beforeCreate) === null || _b === void 0 ? void 0 : _b.functionUri) === "" &&
+            ((_d = (_c = this.blockingFunctionsConfig.triggers) === null || _c === void 0 ? void 0 : _c.beforeSignIn) === null || _d === void 0 ? void 0 : _d.functionUri) === "") {
+            return;
+        }
+        const authEmu = registry_1.EmulatorRegistry.get(types_1.Emulators.AUTH);
+        if (!authEmu) {
+            return;
+        }
+        const path = `/identitytoolkit.googleapis.com/v2/projects/${this.getProjectId()}/config?updateMask=blockingFunctions`;
+        try {
+            await api.request("PATCH", path, {
+                origin: `http://${registry_1.EmulatorRegistry.getInfoHostString(authEmu.getInfo())}`,
+                headers: {
+                    Authorization: "Bearer owner",
+                },
+                data: {
+                    blockingFunctions: this.blockingFunctionsConfig,
+                },
+                json: true,
+            });
+        }
+        catch (err) {
+            this.logger.log("WARN", "Error updating blocking functions config to the auth emulator: " + err);
+            throw err;
+        }
+    }
     addRealtimeDatabaseTrigger(projectId, key, eventTrigger) {
         const databaseEmu = registry_1.EmulatorRegistry.get(types_1.Emulators.DATABASE);
         if (!databaseEmu) {
@@ -416,11 +465,10 @@ class FunctionsEmulator {
         });
     }
     async addPubsubTrigger(triggerName, key, eventTrigger, signatureType, schedule) {
-        const pubsubPort = registry_1.EmulatorRegistry.getPort(types_1.Emulators.PUBSUB);
-        if (!pubsubPort) {
+        const pubsubEmulator = registry_1.EmulatorRegistry.get(types_1.Emulators.PUBSUB);
+        if (!pubsubEmulator) {
             return false;
         }
-        const pubsubEmulator = registry_1.EmulatorRegistry.get(types_1.Emulators.PUBSUB);
         logger_1.logger.debug(`addPubsubTrigger`, JSON.stringify({ eventTrigger }));
         const resource = eventTrigger.resource;
         let topic;
@@ -458,6 +506,31 @@ class FunctionsEmulator {
         this.multicastTriggers[eventTriggerId] = triggers;
         return true;
     }
+    addBlockingTrigger(url, blockingTrigger) {
+        logger_1.logger.debug(`addBlockingTrigger`, JSON.stringify({ blockingTrigger }));
+        const eventType = blockingTrigger.eventType;
+        if (v1_1.AUTH_BLOCKING_EVENTS.includes(eventType)) {
+            if (blockingTrigger.eventType === v1_1.BEFORE_CREATE_EVENT) {
+                this.blockingFunctionsConfig.triggers = Object.assign(Object.assign({}, this.blockingFunctionsConfig.triggers), { beforeCreate: {
+                        functionUri: url,
+                    } });
+            }
+            else {
+                this.blockingFunctionsConfig.triggers = Object.assign(Object.assign({}, this.blockingFunctionsConfig.triggers), { beforeSignIn: {
+                        functionUri: url,
+                    } });
+            }
+            this.blockingFunctionsConfig.forwardInboundCredentials = {
+                accessToken: blockingTrigger.options.accessToken,
+                idToken: blockingTrigger.options.idToken,
+                refreshToken: blockingTrigger.options.refreshToken,
+            };
+        }
+        else {
+            return false;
+        }
+        return true;
+    }
     getProjectId() {
         return this.args.projectId;
     }
@@ -509,6 +582,7 @@ class FunctionsEmulator {
         };
     }
     setTriggersForTesting(triggers, backend) {
+        this.triggers = {};
         triggers.forEach((def) => this.addTriggerRecord(def, { backend, ignored: false }));
     }
     getBaseBundle() {
@@ -777,11 +851,11 @@ class FunctionsEmulator {
     }
     async reloadTriggers() {
         this.triggerGeneration++;
-        const loadTriggerPromises = [];
         for (const backend of this.args.emulatableBackends) {
-            loadTriggerPromises.push(this.loadTriggers(backend));
+            await this.loadTriggers(backend);
         }
-        return Promise.all(loadTriggerPromises);
+        await this.performPostLoadOperations();
+        return;
     }
     async handleBackgroundTrigger(projectId, triggerKey, proto) {
         const record = this.getTriggerRecordByKey(triggerKey);
@@ -790,7 +864,7 @@ class FunctionsEmulator {
         }
         const trigger = record.def;
         const service = (0, functionsEmulatorShared_1.getFunctionService)(trigger);
-        const worker = await this.invokeTrigger(record.backend, trigger, proto);
+        const worker = await this.invokeTrigger(trigger, proto);
         return new Promise((resolve, reject) => {
             if (projectId !== this.args.projectId) {
                 if (service !== constants_1.Constants.SERVICE_REALTIME_DATABASE) {
@@ -809,7 +883,7 @@ class FunctionsEmulator {
                     reject({ code: 500, body: el.text });
                 }
             });
-            void track(EVENT_INVOKE, (0, functionsEmulatorShared_1.getFunctionService)(trigger));
+            void (0, track_1.track)(EVENT_INVOKE, (0, functionsEmulatorShared_1.getFunctionService)(trigger));
             worker.waitForDone().then(() => {
                 resolve({ status: "acknowledged" });
             });
@@ -877,14 +951,14 @@ class FunctionsEmulator {
                 req.headers[functionsEmulatorShared_1.HttpConstants.CALLABLE_AUTH_HEADER] = encodeURIComponent(JSON.stringify(contextAuth));
             }
         }
-        const worker = await this.invokeTrigger(record.backend, trigger);
+        const worker = await this.invokeTrigger(trigger);
         worker.onLogs((el) => {
             if (el.level === "FATAL") {
                 res.status(500).send(el.text);
             }
         });
         await worker.waitForSocketReady();
-        void track(EVENT_INVOKE, "https");
+        void (0, track_1.track)(EVENT_INVOKE, "https");
         this.logger.log("DEBUG", `[functions] Runtime ready! Sending request!`);
         if (!worker.lastArgs) {
             throw new error_1.FirebaseError("Cannot execute on a worker with no arguments");

package/lib/emulator/functionsEmulatorRuntime.js

@@ -213,7 +213,7 @@ function initializeNetworkFiltering(frb) {
             })
                 .filter((v) => v);
             const href = (hrefs.length && hrefs[0]) || "";
-            if (href && !history[href] && !href.startsWith("http://localhost")) {
+            if (href && !history[href] && !(0, functionsEmulatorUtils_1.isLocalHost)(href)) {
                 history[href] = true;
                 if (href.indexOf("googleapis.com") !== -1) {
                     new types_1.EmulatorLog("SYSTEM", "googleapis-network-access", "", {

package/lib/emulator/functionsEmulatorShared.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toBackendInfo = exports.getSecretLocalPath = exports.getSignatureType = exports.formatHost = exports.findModuleRoot = exports.waitForBody = exports.getServiceFromEventType = exports.getFunctionService = exports.getTemporarySocketPath = exports.getEmulatedTriggersFromDefinitions = exports.emulatedFunctionsByRegion = exports.emulatedFunctionsFromEndpoints = exports.EmulatedTrigger = exports.HttpConstants = void 0;
+exports.toBackendInfo = exports.getSecretLocalPath = exports.getSignatureType = exports.formatHost = exports.findModuleRoot = exports.waitForBody = exports.getServiceFromEventType = exports.getFunctionService = exports.getTemporarySocketPath = exports.getEmulatedTriggersFromDefinitions = exports.emulatedFunctionsByRegion = exports.emulatedFunctionsFromEndpoints = exports.prepareEndpoints = exports.EmulatedTrigger = exports.HttpConstants = void 0;
 const _ = require("lodash");
 const os = require("os");
 const path = require("path");
@@ -11,6 +11,8 @@ const proto_1 = require("../gcp/proto");
 const manifest_1 = require("../extensions/manifest");
 const extensionsHelper_1 = require("../extensions/extensionsHelper");
 const postinstall_1 = require("./extensions/postinstall");
+const services_1 = require("../deploy/functions/services");
+const prepare_1 = require("../deploy/functions/prepare");
 const memoryLookup = {
     "128MB": 128,
     "256MB": 256,
@@ -44,6 +46,14 @@ class EmulatedTrigger {
     }
 }
 exports.EmulatedTrigger = EmulatedTrigger;
+function prepareEndpoints(endpoints) {
+    const bkend = backend.of(...endpoints);
+    for (const ep of endpoints) {
+        (0, services_1.serviceForEndpoint)(ep).validateTrigger(ep, bkend);
+    }
+    (0, prepare_1.inferBlockingDetails)(bkend);
+}
+exports.prepareEndpoints = prepareEndpoints;
 function emulatedFunctionsFromEndpoints(endpoints) {
     const regionDefinitions = [];
     for (const endpoint of endpoints) {
@@ -56,6 +66,7 @@ function emulatedFunctionsFromEndpoints(endpoints) {
             region: endpoint.region,
             name: endpoint.id,
             id: `${endpoint.region}-${endpoint.id}`,
+            codebase: endpoint.codebase,
         };
         (0, proto_1.copyIfPresent)(def, endpoint, "availableMemoryMb", "labels", "timeoutSeconds", "platform", "secretEnvironmentVariables");
         if (backend.isHttpsTriggered(endpoint)) {
@@ -89,6 +100,15 @@ function emulatedFunctionsFromEndpoints(endpoints) {
             def.eventTrigger = { eventType: "pubsub", resource: "" };
             def.schedule = endpoint.scheduleTrigger;
         }
+        else if (backend.isBlockingTriggered(endpoint)) {
+            def.blockingTrigger = {
+                eventType: endpoint.blockingTrigger.eventType,
+                options: endpoint.blockingTrigger.options || {},
+            };
+        }
+        else if (backend.isTaskQueueTriggered(endpoint)) {
+            def.httpsTrigger = {};
+        }
         else {
         }
         regionDefinitions.push(def);
@@ -136,6 +156,9 @@ function getFunctionService(def) {
     if (def.eventTrigger) {
         return (_a = def.eventTrigger.service) !== null && _a !== void 0 ? _a : getServiceFromEventType(def.eventTrigger.eventType);
     }
+    if (def.blockingTrigger) {
+        return def.blockingTrigger.eventType;
+    }
     return "unknown";
 }
 exports.getFunctionService = getFunctionService;
@@ -260,7 +283,7 @@ function toBackendInfo(e, cf3Triggers) {
         extension: e.extension,
         extensionVersion: extensionVersion,
         extensionSpec: extensionSpec,
-        functionTriggers: (_b = e.predefinedTriggers) !== null && _b !== void 0 ? _b : cf3Triggers,
+        functionTriggers: (_b = e.predefinedTriggers) !== null && _b !== void 0 ? _b : cf3Triggers.filter((t) => t.codebase === e.codebase),
     }));
 }
 exports.toBackendInfo = toBackendInfo;

package/lib/emulator/functionsEmulatorShell.js

@@ -7,9 +7,8 @@ const utils = require("../utils");
 const logger_1 = require("../logger");
 const error_1 = require("../error");
 class FunctionsEmulatorShell {
-    constructor(emu, backend) {
+    constructor(emu) {
         this.emu = emu;
-        this.backend = backend;
         this.urls = {};
         this.triggers = emu.getTriggerDefinitions();
         this.emulatedFunctions = this.triggers.map((t) => t.id);
@@ -42,7 +41,7 @@ class FunctionsEmulatorShell {
             auth: opts.auth,
             data,
         };
-        this.emu.invokeTrigger(this.backend, trigger, proto);
+        this.emu.invokeTrigger(trigger, proto);
     }
     getTrigger(name) {
         const result = this.triggers.find((trigger) => {

package/lib/emulator/functionsEmulatorUtils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compareVersionStrings = exports.parseVersionString = exports.parseRuntimeVersion = exports.removePathSegments = exports.trimSlashes = exports.isValidWildcardMatch = exports.extractParamsFromPath = void 0;
+exports.isLocalHost = exports.compareVersionStrings = exports.parseVersionString = exports.parseRuntimeVersion = exports.removePathSegments = exports.trimSlashes = exports.isValidWildcardMatch = exports.extractParamsFromPath = void 0;
 const wildcardRegex = new RegExp("{[^/{}]*}");
 const wildcardKeyRegex = new RegExp("^{(.+)}$");
 function extractParamsFromPath(wildcardPath, snapshotPath) {
@@ -85,3 +85,7 @@ function compareVersionStrings(a, b) {
     return 0;
 }
 exports.compareVersionStrings = compareVersionStrings;
+function isLocalHost(href) {
+    return !!href.match(/^(http(s)?:\/\/)?(localhost|127.0.0.1|\[::1])/);
+}
+exports.isLocalHost = isLocalHost;

package/lib/emulator/pubsubEmulator.js

@@ -44,14 +44,7 @@ class PubsubEmulator {
     getName() {
         return types_1.Emulators.PUBSUB;
     }
-    async addTrigger(topicName, triggerKey, signatureType) {
-        this.logger.logLabeled("DEBUG", "pubsub", `addTrigger(${topicName}, ${triggerKey}, ${signatureType})`);
-        const triggers = this.triggersForTopic.get(topicName) || [];
-        if (triggers.some((t) => t.triggerKey === triggerKey) &&
-            this.subscriptionForTopic.has(topicName)) {
-            this.logger.logLabeled("DEBUG", "pubsub", "Trigger already exists");
-            return;
-        }
+    async maybeCreateTopicAndSub(topicName) {
         const topic = this.pubsub.topic(topicName);
         try {
             this.logger.logLabeled("DEBUG", "pubsub", `Creating topic: ${topicName}`);
@@ -74,7 +67,7 @@ class PubsubEmulator {
         catch (e) {
             if (e && e.code === 6) {
                 this.logger.logLabeled("DEBUG", "pubsub", `Sub for ${topicName} exists`);
-                sub = topic.subscription(`emulator-sub-${topicName}`);
+                sub = topic.subscription(subName);
             }
             else {
                 throw new error_1.FirebaseError(`Could not create sub ${subName}`, { original: e });
@@ -83,6 +76,17 @@ class PubsubEmulator {
         sub.on("message", (message) => {
             this.onMessage(topicName, message);
         });
+        return sub;
+    }
+    async addTrigger(topicName, triggerKey, signatureType) {
+        this.logger.logLabeled("DEBUG", "pubsub", `addTrigger(${topicName}, ${triggerKey}, ${signatureType})`);
+        const sub = await this.maybeCreateTopicAndSub(topicName);
+        const triggers = this.triggersForTopic.get(topicName) || [];
+        if (triggers.some((t) => t.triggerKey === triggerKey) &&
+            this.subscriptionForTopic.has(topicName)) {
+            this.logger.logLabeled("DEBUG", "pubsub", "Trigger already exists");
+            return;
+        }
         triggers.push({ triggerKey, signatureType });
         this.triggersForTopic.set(topicName, triggers);
         this.subscriptionForTopic.set(topicName, sub);

package/lib/emulator/registry.js

@@ -14,11 +14,10 @@ class EmulatorRegistry {
         }
         this.set(instance.getName(), instance);
         await instance.start();
-        const info = instance.getInfo();
-        await portUtils.waitForPortClosed(info.port, info.host);
-    }
-    static registerExtensionsEmulator() {
-        this.extensionsEmulatorRegistered = true;
+        if (instance.getName() !== types_1.Emulators.EXTENSIONS) {
+            const info = instance.getInfo();
+            await portUtils.waitForPortClosed(info.port, info.host);
+        }
     }
     static async stop(name) {
         emulatorLogger_1.EmulatorLogger.forEmulator(name).logLabeled("BULLET", name, `Stopping ${constants_1.Constants.description(name)}`);
@@ -57,7 +56,7 @@ class EmulatorRegistry {
     }
     static isRunning(emulator) {
         if (emulator === types_1.Emulators.EXTENSIONS) {
-            return this.extensionsEmulatorRegistered && this.isRunning(types_1.Emulators.FUNCTIONS);
+            return this.INSTANCES.get(emulator) !== undefined && this.isRunning(types_1.Emulators.FUNCTIONS);
         }
         const instance = this.INSTANCES.get(emulator);
         return instance !== undefined;
@@ -89,12 +88,36 @@ class EmulatorRegistry {
             return `${host}:${port}`;
         }
     }
-    static getPort(emulator) {
-        const instance = this.INSTANCES.get(emulator);
-        if (!instance) {
-            return undefined;
+    static url(emulator, req) {
+        const url = new URL("http://unknown/");
+        if (req) {
+            url.protocol = req.protocol;
+            const host = req.headers.host;
+            if (host) {
+                url.host = host;
+                return url;
+            }
+        }
+        const info = EmulatorRegistry.getInfo(emulator);
+        if (info) {
+            if (info.host === "0.0.0.0") {
+                url.hostname = "127.0.0.1";
+            }
+            else if (info.host === "::") {
+                url.hostname = "[::1]";
+            }
+            else if (info.host.includes(":")) {
+                url.hostname = `[${info.host}]`;
+            }
+            else {
+                url.hostname = info.host;
+            }
+            url.port = info.port.toString();
+        }
+        else {
+            console.warn(`Cannot determine host and port of ${emulator}`);
         }
-        return instance.getInfo().port;
+        return url;
     }
     static set(emulator, instance) {
         this.INSTANCES.set(emulator, instance);
@@ -104,5 +127,4 @@ class EmulatorRegistry {
     }
 }
 exports.EmulatorRegistry = EmulatorRegistry;
-EmulatorRegistry.extensionsEmulatorRegistered = false;
 EmulatorRegistry.INSTANCES = new Map();

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

@@ -118,7 +118,7 @@ function createFirebaseEndpoints(emulator) {
         return res.json(new metadata_1.OutgoingFirebaseMetadata(metadata));
     });
     firebaseStorageAPI.get("/b/:bucketId/o", async (req, res) => {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d;
         const maxResults = (_a = req.query.maxResults) === null || _a === void 0 ? void 0 : _a.toString();
         let listResponse;
         try {
@@ -144,10 +144,12 @@ function createFirebaseEndpoints(emulator) {
         }
         return res.status(200).json({
             nextPageToken: listResponse.nextPageToken,
-            prefixes: (_c = listResponse.prefixes) !== null && _c !== void 0 ? _c : [],
-            items: (_e = (_d = listResponse.items) === null || _d === void 0 ? void 0 : _d.map((item) => {
+            prefixes: ((_c = listResponse.prefixes) !== null && _c !== void 0 ? _c : []).filter(isValidPrefix),
+            items: ((_d = listResponse.items) !== null && _d !== void 0 ? _d : [])
+                .filter((item) => isValidNonEncodedPathString(item.name))
+                .map((item) => {
                 return { name: item.name, bucket: item.bucket };
-            })) !== null && _e !== void 0 ? _e : [],
+            }),
         });
     });
     const handleUpload = async (req, res) => {
@@ -219,9 +221,13 @@ function createFirebaseEndpoints(emulator) {
             res.header("x-goog-upload-chunk-granularity", "10000");
             res.header("x-goog-upload-control-url", "");
             res.header("x-goog-upload-status", "active");
-            const emulatorInfo = registry_1.EmulatorRegistry.getInfo(types_1.Emulators.STORAGE);
-            res.header("x-goog-upload-url", `http://${req.hostname}:${emulatorInfo === null || emulatorInfo === void 0 ? void 0 : emulatorInfo.port}/v0/b/${bucketId}/o?name=${objectId}&upload_id=${upload.id}&upload_protocol=resumable`);
             res.header("x-gupload-uploadid", upload.id);
+            const uploadUrl = registry_1.EmulatorRegistry.url(types_1.Emulators.STORAGE, req);
+            uploadUrl.pathname = `/v0/b/${bucketId}/o`;
+            uploadUrl.searchParams.set("name", objectId);
+            uploadUrl.searchParams.set("upload_id", upload.id);
+            uploadUrl.searchParams.set("upload_protocol", "resumable");
+            res.header("x-goog-upload-url", uploadUrl.toString());
             return res.sendStatus(200);
         }
         if (!req.query.upload_id) {
@@ -306,6 +312,7 @@ function createFirebaseEndpoints(emulator) {
                 }
                 throw err;
             }
+            res.header("x-goog-upload-status", "final");
             storedMetadata.addDownloadToken(false);
             return res.status(200).json(new metadata_1.OutgoingFirebaseMetadata(storedMetadata));
         }
@@ -462,3 +469,23 @@ function setObjectHeaders(res, metadata, headerOverride = { "Content-Encoding":
         res.setHeader("Content-Language", metadata.contentLanguage);
     }
 }
+function isValidPrefix(prefix) {
+    return isValidNonEncodedPathString(removeAtMostOneTrailingSlash(prefix));
+}
+function isValidNonEncodedPathString(path) {
+    if (path.startsWith("/")) {
+        path = path.substring(1);
+    }
+    if (!path) {
+        return false;
+    }
+    for (const pathSegment of path.split("/")) {
+        if (!pathSegment) {
+            return false;
+        }
+    }
+    return true;
+}
+function removeAtMostOneTrailingSlash(path) {
+    return path.replace(/\/$/, "");
+}

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

@@ -200,9 +200,12 @@ 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;

package/lib/emulator/storage/files.js

@@ -348,7 +348,11 @@ class StorageLayer {
                 logger_1.logger.warn(`Could not find file "${blobPath}" in storage export.`);
                 continue;
             }
-            const decodedBlobPath = decodeURIComponent(blobPath);
+            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);
@@ -369,3 +373,7 @@ class StorageLayer {
     }
 }
 exports.StorageLayer = StorageLayer;
+function getPathSep(decodedPath) {
+    const firstSepIndex = decodedPath.search(/[^a-z0-9-_.]/g);
+    return decodedPath[firstSepIndex];
+}

package/lib/ensureApiEnabled.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.enableApiURI = exports.ensure = exports.check = exports.POLL_SETTINGS = void 0;
 const cli_color_1 = require("cli-color");
-const track = require("./track");
+const track_1 = require("./track");
 const api_1 = require("./api");
 const apiv2_1 = require("./apiv2");
 const utils = require("./utils");
@@ -16,7 +16,9 @@ const apiClient = new apiv2_1.Client({
     apiVersion: "v1",
 });
 async function check(projectId, apiName, prefix, silent = false) {
-    const res = await apiClient.get(`/projects/${projectId}/services/${apiName}`);
+    const res = await apiClient.get(`/projects/${projectId}/services/${apiName}`, {
+        skipLog: { resBody: true },
+    });
     const isEnabled = res.body.state === "ENABLED";
     if (isEnabled && !silent) {
         utils.logLabeledSuccess(prefix, `required API ${(0, cli_color_1.bold)(apiName)} is enabled`);
@@ -26,7 +28,9 @@ async function check(projectId, apiName, prefix, silent = false) {
 exports.check = check;
 async function enable(projectId, apiName) {
     try {
-        await apiClient.post(`/projects/${projectId}/services/${apiName}:enable`);
+        await apiClient.post(`/projects/${projectId}/services/${apiName}:enable`, undefined, {
+            skipLog: { resBody: true },
+        });
     }
     catch (err) {
         if ((0, error_1.isBillingError)(err)) {
@@ -46,7 +50,7 @@ async function pollCheckEnabled(projectId, apiName, prefix, silent, enablementRe
     });
     const isEnabled = await check(projectId, apiName, prefix, silent);
     if (isEnabled) {
-        void track("api_enabled", apiName);
+        void (0, track_1.track)("api_enabled", apiName);
         return;
     }
     if (!silent) {

package/lib/extensions/changelog.js

@@ -16,7 +16,7 @@ marked.setOptions({
     renderer: new TerminalRenderer(),
 });
 const EXTENSIONS_CHANGELOG = "CHANGELOG.md";
-const VERSION_LINE_REGEX = /##.*(\d+\.\d+\.\d+).*/;
+const VERSION_LINE_REGEX = /##.*(\d+\.\d+\.\d+(?:-((\d+|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(\d+|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?).*/;
 async function getReleaseNotesForUpdate(args) {
     const releaseNotes = {};
     const filter = `id<="${args.toVersion}" AND id>"${args.fromVersion}"`;

package/lib/extensions/emulator/optionsHelper.js

@@ -9,6 +9,7 @@ const localHelper = require("../localHelper");
 const triggerHelper = require("./triggerHelper");
 const extensionsApi_1 = require("../extensionsApi");
 const extensionsHelper = require("../extensionsHelper");
+const planner = require("../../deploy/extensions/planner");
 const config_1 = require("../../config");
 const error_1 = require("../../error");
 const emulatorLogger_1 = require("../../emulator/emulatorLogger");
@@ -35,13 +36,13 @@ async function buildOptions(options) {
     return options;
 }
 exports.buildOptions = buildOptions;
-async function getExtensionFunctionInfo(extensionDir, instanceId, paramValues) {
-    const spec = await specHelper.readExtensionYaml(extensionDir);
+async function getExtensionFunctionInfo(instance, paramValues) {
+    const spec = await planner.getExtensionSpec(instance);
     const functionResources = specHelper.getFunctionResourcesWithParamSubstitution(spec, paramValues);
     const extensionTriggers = functionResources
         .map((r) => triggerHelper.functionResourceToEmulatedTriggerDefintion(r))
         .map((trigger) => {
-        trigger.name = `ext-${instanceId}-${trigger.name}`;
+        trigger.name = `ext-${instance.instanceId}-${trigger.name}`;
         return trigger;
     });
     const nodeMajorVersion = specHelper.getNodeVersion(functionResources);