firebase-tools 10.5.0 → 10.7.1

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}`;
@@ -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) {
@@ -229,6 +242,7 @@ class FunctionsEmulator {
             loadTriggerPromises.push(this.loadTriggers(backend, true));
         }
         await Promise.all(loadTriggerPromises);
+        await this.performPostLoadOperations();
         return;
     }
     async stop() {
@@ -271,6 +285,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 +345,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 +373,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 +467,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 +508,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 +584,7 @@ class FunctionsEmulator {
         };
     }
     setTriggersForTesting(triggers, backend) {
+        this.triggers = {};
         triggers.forEach((def) => this.addTriggerRecord(def, { backend, ignored: false }));
     }
     getBaseBundle() {
@@ -781,7 +857,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);
@@ -790,7 +868,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 +887,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 +955,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/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");
@@ -8,9 +8,11 @@ const fs = require("fs");
 const backend = require("../deploy/functions/backend");
 const constants_1 = require("./constants");
 const proto_1 = require("../gcp/proto");
-const logger_1 = require("../logger");
 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,
@@ -33,12 +35,7 @@ class EmulatedTrigger {
         return memoryLookup[this.definition.availableMemoryMb || "128MB"] * 1024 * 1024;
     }
     get timeoutMs() {
-        if (typeof this.definition.timeout === "number") {
-            return this.definition.timeout * 1000;
-        }
-        else {
-            return parseInt((this.definition.timeout || "60s").split("s")[0], 10) * 1000;
-        }
+        return (this.definition.timeoutSeconds || 60) * 1000;
     }
     getRawFunction() {
         if (!this.module) {
@@ -49,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) {
@@ -61,8 +66,9 @@ function emulatedFunctionsFromEndpoints(endpoints) {
             region: endpoint.region,
             name: endpoint.id,
             id: `${endpoint.region}-${endpoint.id}`,
+            codebase: endpoint.codebase,
         };
-        (0, proto_1.copyIfPresent)(def, endpoint, "timeout", "availableMemoryMb", "labels", "platform", "secretEnvironmentVariables");
+        (0, proto_1.copyIfPresent)(def, endpoint, "availableMemoryMb", "labels", "timeoutSeconds", "platform", "secretEnvironmentVariables");
         if (backend.isHttpsTriggered(endpoint)) {
             def.httpsTrigger = endpoint.httpsTrigger;
         }
@@ -73,25 +79,20 @@ function emulatedFunctionsFromEndpoints(endpoints) {
         else if (backend.isEventTriggered(endpoint)) {
             const eventTrigger = endpoint.eventTrigger;
             if (endpoint.platform === "gcfv1") {
-                const resourceFilter = backend.findEventFilter(endpoint, "resource");
-                if (!resourceFilter) {
-                    logger_1.logger.debug(`Invalid event trigger ${JSON.stringify(endpoint)}, expected event filter with resource attribute. Skipping.`);
-                    continue;
-                }
                 def.eventTrigger = {
                     eventType: eventTrigger.eventType,
-                    resource: resourceFilter.value,
+                    resource: eventTrigger.eventFilters.resource,
                 };
             }
             else {
-                const [eventFilter] = endpoint.eventTrigger.eventFilters;
-                if (!eventFilter) {
-                    logger_1.logger.debug(`Invalid event trigger ${JSON.stringify(endpoint)}, expected at least one event filter. Skipping.`);
+                const { resource, topic, bucket } = endpoint.eventTrigger.eventFilters;
+                const eventResource = resource || topic || bucket;
+                if (!eventResource) {
                     continue;
                 }
                 def.eventTrigger = {
                     eventType: eventTrigger.eventType,
-                    resource: eventFilter.value,
+                    resource: eventResource,
                 };
             }
         }
@@ -99,6 +100,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);
@@ -146,6 +153,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;
@@ -244,7 +254,7 @@ function getSecretLocalPath(backend, projectDir) {
 }
 exports.getSecretLocalPath = getSecretLocalPath;
 function toBackendInfo(e, cf3Triggers) {
-    var _a;
+    var _a, _b;
     const envWithSecrets = Object.assign({}, e.env);
     for (const s of e.secretEnv) {
         envWithSecrets[s.key] = backend.secretVersionName(s);
@@ -252,10 +262,16 @@ function toBackendInfo(e, cf3Triggers) {
     let extensionVersion = e.extensionVersion;
     if (extensionVersion) {
         extensionVersion = (0, extensionsHelper_1.substituteParams)(extensionVersion, e.env);
+        if ((_a = extensionVersion.spec) === null || _a === void 0 ? void 0 : _a.postinstallContent) {
+            extensionVersion.spec.postinstallContent = (0, postinstall_1.replaceConsoleLinks)(extensionVersion.spec.postinstallContent);
+        }
     }
     let extensionSpec = e.extensionSpec;
     if (extensionSpec) {
         extensionSpec = (0, extensionsHelper_1.substituteParams)(extensionSpec, e.env);
+        if (extensionSpec === null || extensionSpec === void 0 ? void 0 : extensionSpec.postinstallContent) {
+            extensionSpec.postinstallContent = (0, postinstall_1.replaceConsoleLinks)(extensionSpec.postinstallContent);
+        }
     }
     return JSON.parse(JSON.stringify({
         directory: e.functionsDir,
@@ -264,7 +280,7 @@ function toBackendInfo(e, cf3Triggers) {
         extension: e.extension,
         extensionVersion: extensionVersion,
         extensionSpec: extensionSpec,
-        functionTriggers: (_a = e.predefinedTriggers) !== null && _a !== void 0 ? _a : 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/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();