firebase-tools 10.6.0 → 10.7.0

package/lib/emulator/controller.js

@@ -6,7 +6,7 @@ const clc = require("cli-color");
 const fs = require("fs");
 const path = require("path");
 const logger_1 = require("../logger");
-const track = require("../track");
+const track_1 = require("../track");
 const utils = require("../utils");
 const registry_1 = require("./registry");
 const types_1 = require("./types");
@@ -95,7 +95,7 @@ async function getAndCheckAddress(emulator, options) {
 }
 async function startEmulator(instance) {
     const name = instance.getName();
-    void track("Emulator Run", name);
+    void (0, track_1.track)("Emulator Run", name);
     await registry_1.EmulatorRegistry.start(instance);
 }
 exports.startEmulator = startEmulator;
@@ -248,7 +248,7 @@ async function startAll(options, showUI = true) {
     if (shouldStart(options, types_1.Emulators.HUB)) {
         const hubAddr = await getAndCheckAddress(types_1.Emulators.HUB, options);
         const hub = new hub_1.EmulatorHub(Object.assign({ projectId }, hubAddr));
-        void track("emulators:start", "hub");
+        void (0, track_1.track)("emulators:start", "hub");
         await startEmulator(hub);
     }
     let exportMetadata = {
@@ -294,8 +294,8 @@ async function startAll(options, showUI = true) {
         const extensionsBackends = await extensionEmulator.getExtensionBackends();
         const filteredExtensionsBackends = extensionEmulator.filterUnemulatedTriggers(options, extensionsBackends);
         emulatableBackends.push(...filteredExtensionsBackends);
-        void track("Emulator Run", types_1.Emulators.EXTENSIONS);
-        registry_1.EmulatorRegistry.registerExtensionsEmulator();
+        void (0, track_1.track)("Emulator Run", types_1.Emulators.EXTENSIONS);
+        await startEmulator(extensionEmulator);
     }
     if (emulatableBackends.length) {
         const functionsLogger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.FUNCTIONS);

package/lib/emulator/downloadableEmulators.js

@@ -29,13 +29,13 @@ exports.DownloadDetails = {
         },
     },
     firestore: {
-        downloadPath: path.join(CACHE_DIR, "cloud-firestore-emulator-v1.14.1.jar"),
-        version: "1.14.1",
+        downloadPath: path.join(CACHE_DIR, "cloud-firestore-emulator-v1.14.3.jar"),
+        version: "1.14.3",
         opts: {
             cacheDir: CACHE_DIR,
-            remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/cloud-firestore-emulator-v1.14.1.jar",
-            expectedSize: 60416634,
-            expectedChecksum: "33cffe8065d4250816f257eb19245932",
+            remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/cloud-firestore-emulator-v1.14.3.jar",
+            expectedSize: 60442855,
+            expectedChecksum: "63517534875818689639ee5dee57dd52",
             namePrefix: "cloud-firestore-emulator",
         },
     },
@@ -50,15 +50,15 @@ exports.DownloadDetails = {
             namePrefix: "cloud-storage-rules-emulator",
         },
     },
-    ui: previews_1.previews.emulatoruisnapshot
+    ui: previews_1.previews.extensionsemulator
         ? {
-            version: "SNAPSHOT",
-            downloadPath: path.join(CACHE_DIR, "ui-vSNAPSHOT.zip"),
-            unzipDir: path.join(CACHE_DIR, "ui-vSNAPSHOT"),
-            binaryPath: path.join(CACHE_DIR, "ui-vSNAPSHOT", "server.bundle.js"),
+            version: "EXTENSIONS",
+            downloadPath: path.join(CACHE_DIR, "ui-vEXTENSIONS.zip"),
+            unzipDir: path.join(CACHE_DIR, "ui-vEXTENSIONS"),
+            binaryPath: path.join(CACHE_DIR, "ui-vEXTENSIONS", "server.bundle.js"),
             opts: {
                 cacheDir: CACHE_DIR,
-                remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/ui-vSNAPSHOT.zip",
+                remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/ui-vEXTENSIONS.zip",
                 expectedSize: -1,
                 expectedChecksum: "",
                 skipCache: true,
@@ -66,19 +66,35 @@ exports.DownloadDetails = {
                 namePrefix: "ui",
             },
         }
-        : {
-            version: "1.6.5",
-            downloadPath: path.join(CACHE_DIR, "ui-v1.6.5.zip"),
-            unzipDir: path.join(CACHE_DIR, "ui-v1.6.5"),
-            binaryPath: path.join(CACHE_DIR, "ui-v1.6.5", "server.bundle.js"),
-            opts: {
-                cacheDir: CACHE_DIR,
-                remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/ui-v1.6.5.zip",
-                expectedSize: 3816994,
-                expectedChecksum: "92dfff4b2ef8ab616e8a60cc93e0a00b",
-                namePrefix: "ui",
+        : previews_1.previews.emulatoruisnapshot
+            ? {
+                version: "SNAPSHOT",
+                downloadPath: path.join(CACHE_DIR, "ui-vSNAPSHOT.zip"),
+                unzipDir: path.join(CACHE_DIR, "ui-vSNAPSHOT"),
+                binaryPath: path.join(CACHE_DIR, "ui-vSNAPSHOT", "server.bundle.js"),
+                opts: {
+                    cacheDir: CACHE_DIR,
+                    remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/ui-vSNAPSHOT.zip",
+                    expectedSize: -1,
+                    expectedChecksum: "",
+                    skipCache: true,
+                    skipChecksumAndSize: true,
+                    namePrefix: "ui",
+                },
+            }
+            : {
+                version: "1.6.5",
+                downloadPath: path.join(CACHE_DIR, "ui-v1.6.5.zip"),
+                unzipDir: path.join(CACHE_DIR, "ui-v1.6.5"),
+                binaryPath: path.join(CACHE_DIR, "ui-v1.6.5", "server.bundle.js"),
+                opts: {
+                    cacheDir: CACHE_DIR,
+                    remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/ui-v1.6.5.zip",
+                    expectedSize: 3816994,
+                    expectedChecksum: "92dfff4b2ef8ab616e8a60cc93e0a00b",
+                    namePrefix: "ui",
+                },
             },
-        },
     pubsub: {
         downloadPath: path.join(CACHE_DIR, "pubsub-emulator-0.1.0.zip"),
         version: "0.1.0",

package/lib/emulator/extensions/validation.js

@@ -17,8 +17,8 @@ async function getUnemulatedAPIs(projectId, instances) {
     var _a;
     const unemulatedAPIs = {};
     for (const i of instances) {
-        const extensionVersion = await planner.getExtensionVersion(i);
-        for (const api of (_a = extensionVersion.spec.apis) !== null && _a !== void 0 ? _a : []) {
+        const extensionSpec = await planner.getExtensionSpec(i);
+        for (const api of (_a = extensionSpec.apis) !== null && _a !== void 0 ? _a : []) {
             if (!EMULATED_APIS.includes(api.apiName)) {
                 if (unemulatedAPIs[api.apiName]) {
                     unemulatedAPIs[api.apiName].instanceIds.push(i.instanceId);

package/lib/emulator/extensionsEmulator.js

@@ -18,13 +18,37 @@ const validation_1 = require("./extensions/validation");
 const ensureApiEnabled_1 = require("../ensureApiEnabled");
 const shortenUrl_1 = require("../shortenUrl");
 const constants_1 = require("./constants");
+const registry_1 = require("./registry");
 class ExtensionsEmulator {
     constructor(args) {
         this.want = [];
+        this.backends = [];
         this.logger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.EXTENSIONS);
         this.pendingDownloads = new Map();
         this.args = args;
     }
+    start() {
+        this.logger.logLabeled("DEBUG", "Extensions", "Started Extensions emulator, this is a noop.");
+        return Promise.resolve();
+    }
+    stop() {
+        this.logger.logLabeled("DEBUG", "Extensions", "Stopping Extensions emulator, this is a noop.");
+        return Promise.resolve();
+    }
+    connect() {
+        this.logger.logLabeled("DEBUG", "Extensions", "Connecting Extensions emulator, this is a noop.");
+        return Promise.resolve();
+    }
+    getInfo() {
+        const info = registry_1.EmulatorRegistry.getInfo(types_1.Emulators.FUNCTIONS);
+        if (!info) {
+            throw new error_1.FirebaseError("Extensions Emulator is running but Functions emulator is not. This should never happen.");
+        }
+        return info;
+    }
+    getName() {
+        return types_1.Emulators.EXTENSIONS;
+    }
     async readManifest() {
         var _a;
         this.want = await planner.want({
@@ -37,22 +61,30 @@ class ExtensionsEmulator {
         });
     }
     async ensureSourceCode(instance) {
-        if (!instance.ref) {
-            throw new error_1.FirebaseError(`No ref found for ${instance.instanceId}. Emulating local extensions is not yet supported.`);
+        if (instance.localPath) {
+            if (!this.hasValidSource({ path: instance.localPath, extTarget: instance.localPath })) {
+                throw new error_1.FirebaseError(`Tried to emulate local extension at ${instance.localPath}, but it was missing required files.`);
+            }
+            return instance.localPath;
         }
-        const ref = (0, refs_1.toExtensionVersionRef)(instance.ref);
-        const cacheDir = process.env.FIREBASE_EXTENSIONS_CACHE_PATH ||
-            path.join(os.homedir(), ".cache", "firebase", "extensions");
-        const sourceCodePath = path.join(cacheDir, ref);
-        if (this.pendingDownloads.get(ref)) {
-            await this.pendingDownloads.get(ref);
+        else if (instance.ref) {
+            const ref = (0, refs_1.toExtensionVersionRef)(instance.ref);
+            const cacheDir = process.env.FIREBASE_EXTENSIONS_CACHE_PATH ||
+                path.join(os.homedir(), ".cache", "firebase", "extensions");
+            const sourceCodePath = path.join(cacheDir, ref);
+            if (this.pendingDownloads.get(ref)) {
+                await this.pendingDownloads.get(ref);
+            }
+            if (!this.hasValidSource({ path: sourceCodePath, extTarget: ref })) {
+                const promise = this.downloadSource(instance, ref, sourceCodePath);
+                this.pendingDownloads.set(ref, promise);
+                await promise;
+            }
+            return sourceCodePath;
         }
-        if (!this.hasValidSource({ path: sourceCodePath, extRef: ref })) {
-            const promise = this.downloadSource(instance, ref, sourceCodePath);
-            this.pendingDownloads.set(ref, promise);
-            await promise;
+        else {
+            throw new error_1.FirebaseError("Tried to emulate an extension instance without a ref or localPath. This should never happen.");
         }
-        return sourceCodePath;
     }
     async downloadSource(instance, ref, sourceCodePath) {
         const extensionVersion = await planner.getExtensionVersion(instance);
@@ -71,7 +103,7 @@ class ExtensionsEmulator {
         for (const requiredFile of requiredFiles) {
             const f = path.join(args.path, requiredFile);
             if (!fs.existsSync(f)) {
-                emulatorLogger_1.EmulatorLogger.forExtension({ ref: args.extRef }).logLabeled("BULLET", "extensions", `Detected invalid source code for ${args.extRef}, expected to find ${f}`);
+                emulatorLogger_1.EmulatorLogger.forExtension({ ref: args.extTarget }).logLabeled("BULLET", "extensions", `Detected invalid source code for ${args.extTarget}, expected to find ${f}`);
                 return false;
             }
         }
@@ -92,27 +124,32 @@ class ExtensionsEmulator {
     async getExtensionBackends() {
         await this.readManifest();
         await this.checkAndWarnAPIs(this.want);
-        return Promise.all(this.want.map((i) => {
+        this.backends = await Promise.all(this.want.map((i) => {
             return this.toEmulatableBackend(i);
         }));
+        return this.backends;
     }
     async toEmulatableBackend(instance) {
         const extensionDir = await this.ensureSourceCode(instance);
         const functionsDir = path.join(extensionDir, "functions");
         const env = Object.assign(this.autoPopulatedParams(instance), instance.params);
-        const { extensionTriggers, nodeMajorVersion, nonSecretEnv, secretEnvVariables } = await (0, optionsHelper_1.getExtensionFunctionInfo)(extensionDir, instance.instanceId, env);
-        const extension = await planner.getExtension(instance);
-        const extensionVersion = await planner.getExtensionVersion(instance);
-        return {
+        const { extensionTriggers, nodeMajorVersion, nonSecretEnv, secretEnvVariables } = await (0, optionsHelper_1.getExtensionFunctionInfo)(instance, env);
+        const emulatableBackend = {
             functionsDir,
             env: nonSecretEnv,
             secretEnv: secretEnvVariables,
             predefinedTriggers: extensionTriggers,
             nodeMajorVersion: nodeMajorVersion,
             extensionInstanceId: instance.instanceId,
-            extension,
-            extensionVersion,
         };
+        if (instance.ref) {
+            emulatableBackend.extension = await planner.getExtension(instance);
+            emulatableBackend.extensionVersion = await planner.getExtensionVersion(instance);
+        }
+        else if (instance.localPath) {
+            emulatableBackend.extensionSpec = await planner.getExtensionSpec(instance);
+        }
+        return emulatableBackend;
     }
     autoPopulatedParams(instance) {
         const projectId = this.args.projectId;
@@ -174,5 +211,32 @@ class ExtensionsEmulator {
         }
         return filteredBackends;
     }
+    extensionDetailsUILink(backend) {
+        const uiInfo = registry_1.EmulatorRegistry.getInfo(types_1.Emulators.UI);
+        if (!uiInfo || !backend.extensionInstanceId) {
+            return "";
+        }
+        const uiUrl = registry_1.EmulatorRegistry.getInfoHostString(uiInfo);
+        return clc.underline(clc.bold(`http://${uiUrl}/${types_1.Emulators.EXTENSIONS}/${backend.extensionInstanceId}`));
+    }
+    extensionsInfoTable(options) {
+        var _a;
+        const filtedBackends = this.filterUnemulatedTriggers(options, this.backends);
+        const uiRunning = registry_1.EmulatorRegistry.isRunning(types_1.Emulators.UI);
+        const tableHead = ["Extension Instance Name", "Extension Ref"];
+        if (uiRunning) {
+            tableHead.push("View in Emulator UI");
+        }
+        const table = new Table({ head: tableHead, style: { head: ["yellow"] } });
+        for (const b of filtedBackends) {
+            if (b.extensionInstanceId) {
+                const tableEntry = [b.extensionInstanceId, ((_a = b.extensionVersion) === null || _a === void 0 ? void 0 : _a.ref) || "Local Extension"];
+                if (uiRunning)
+                    tableEntry.push(this.extensionDetailsUILink(b));
+                table.push(tableEntry);
+            }
+        }
+        return table.toString();
+    }
 }
 exports.ExtensionsEmulator = ExtensionsEmulator;

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}`;
@@ -229,6 +240,7 @@ class FunctionsEmulator {
             loadTriggerPromises.push(this.loadTriggers(backend, true));
         }
         await Promise.all(loadTriggerPromises);
+        await this.performPostLoadOperations();
         return;
     }
     async stop() {
@@ -271,6 +283,7 @@ 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);
             triggerDefinitions = (0, functionsEmulatorShared_1.emulatedFunctionsFromEndpoints)(endpoints);
         }
         const toSetup = triggerDefinitions.filter((definition) => {
@@ -327,6 +340,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 +368,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 +462,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 +503,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;
     }
@@ -781,7 +851,9 @@ class FunctionsEmulator {
         for (const backend of this.args.emulatableBackends) {
             loadTriggerPromises.push(this.loadTriggers(backend));
         }
-        return Promise.all(loadTriggerPromises);
+        await Promise.all(loadTriggerPromises);
+        await this.performPostLoadOperations();
+        return;
     }
     async handleBackgroundTrigger(projectId, triggerKey, proto) {
         const record = this.getTriggerRecordByKey(triggerKey);
@@ -809,7 +881,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" });
             });
@@ -884,7 +956,7 @@ class FunctionsEmulator {
             }
         });
         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/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) {
@@ -89,6 +99,12 @@ 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 {
         }
         regionDefinitions.push(def);
@@ -136,6 +152,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;

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

@@ -219,9 +219,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 +310,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));
         }

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];
+}