firebase-tools 13.25.0 → 13.27.0

package/lib/emulator/controller.js

@@ -58,7 +58,7 @@ async function exportOnExit(options) {
             await exportEmulatorData(exportOnExitDir, options, "exit");
         }
         catch (e) {
-            utils.logWarning(e);
+            utils.logWarning(`${e}`);
             utils.logWarning(`Automatic export to "${exportOnExitDir}" failed, going to exit now...`);
         }
     }
@@ -561,19 +561,30 @@ async function startAll(options, showUI = true, runningTestScript = false) {
         else if (config.length > 1) {
             logger_1.logger.warn(`TODO: Add support for multiple services in the Data Connect emulator. Currently emulating first service ${config[0].source}`);
         }
-        const configDir = config[0].source;
-        const dataConnectEmulator = new dataconnectEmulator_1.DataConnectEmulator({
+        const args = {
             listen: listenForEmulator.dataconnect,
             projectId,
             auto_download: true,
-            configDir,
+            configDir: config[0].source,
             rc: options.rc,
             config: options.config,
             autoconnectToPostgres: true,
             postgresListen: listenForEmulator["dataconnect.postgres"],
             enable_output_generated_sdk: true,
             enable_output_schema_extensions: true,
-        });
+        };
+        if (exportMetadata.dataconnect) {
+            utils.assertIsString(options.import);
+            const importDirAbsPath = path.resolve(options.import);
+            const exportMetadataFilePath = path.resolve(importDirAbsPath, exportMetadata.dataconnect.path);
+            emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.DATACONNECT).logLabeled("BULLET", "dataconnect", `Importing data from ${exportMetadataFilePath}`);
+            args.importPath = exportMetadataFilePath;
+            void (0, track_1.trackEmulator)("emulator_import", {
+                initiated_by: "start",
+                emulator_name: types_1.Emulators.DATACONNECT,
+            });
+        }
+        const dataConnectEmulator = new dataconnectEmulator_1.DataConnectEmulator(args);
         await startEmulator(dataConnectEmulator);
     }
     if (listenForEmulator.storage) {
@@ -601,18 +612,17 @@ async function startAll(options, showUI = true, runningTestScript = false) {
         });
         await startEmulator(hostingEmulator);
     }
-    if (experiments.isEnabled("emulatorapphosting")) {
-        const apphostingConfig = (_l = options.config.src.emulators) === null || _l === void 0 ? void 0 : _l[types_1.Emulators.APPHOSTING];
-        if (listenForEmulator.apphosting) {
-            const apphostingAddr = legacyGetFirstAddr(types_1.Emulators.APPHOSTING);
-            const apphostingEmulator = new apphosting_1.AppHostingEmulator({
-                host: apphostingAddr.host,
-                port: apphostingAddr.port,
-                startCommandOverride: apphostingConfig === null || apphostingConfig === void 0 ? void 0 : apphostingConfig.startCommandOverride,
-                options,
-            });
-            await startEmulator(apphostingEmulator);
-        }
+    const apphostingConfig = (_l = options.config.src.emulators) === null || _l === void 0 ? void 0 : _l[types_1.Emulators.APPHOSTING];
+    if (listenForEmulator.apphosting) {
+        const apphostingAddr = legacyGetFirstAddr(types_1.Emulators.APPHOSTING);
+        const apphostingEmulator = new apphosting_1.AppHostingEmulator({
+            host: apphostingAddr.host,
+            port: apphostingAddr.port,
+            startCommandOverride: apphostingConfig === null || apphostingConfig === void 0 ? void 0 : apphostingConfig.startCommandOverride,
+            rootDirectory: apphostingConfig === null || apphostingConfig === void 0 ? void 0 : apphostingConfig.rootDirectory,
+            options,
+        });
+        await startEmulator(apphostingEmulator);
     }
     if (listenForEmulator.logging) {
         const loggingAddr = legacyGetFirstAddr(types_1.Emulators.LOGGING);
@@ -630,7 +640,6 @@ async function startAll(options, showUI = true, runningTestScript = false) {
     if (listenForEmulator.ui) {
         const ui = new ui_1.EmulatorUI({
             projectId: projectId,
-            auto_download: true,
             listen: listenForEmulator[types_1.Emulators.UI],
         });
         await startEmulator(ui);

package/lib/emulator/dataconnect/pgliteServer.js

@@ -19,17 +19,28 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar
     function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PGliteExtendedQueryPatch = exports.PostgresServer = void 0;
+exports.PGliteExtendedQueryPatch = exports.PostgresServer = exports.TRUNCATE_TABLES_SQL = void 0;
 const pglite_1 = require("@electric-sql/pglite");
 const { dynamicImport } = require(true && "../../dynamicImport");
 const net = require("node:net");
+const fs = require("fs");
 const index_1 = require("./pg-gateway/index");
 const node_1 = require("./pg-gateway/platforms/node");
 const logger_1 = require("../../logger");
+exports.TRUNCATE_TABLES_SQL = `
+DO $do$
+BEGIN
+   EXECUTE
+   (SELECT 'TRUNCATE TABLE ' || string_agg(oid::regclass::text, ', ') || ' CASCADE'
+    FROM   pg_class
+    WHERE  relkind = 'r'
+    AND    relnamespace = 'public'::regnamespace
+   );
+END
+$do$;`;
 class PostgresServer {
     async createPGServer(host = "127.0.0.1", port) {
-        const db = await this.getDb();
-        await db.waitReady;
+        const getDb = this.getDb.bind(this);
         const server = net.createServer(async (socket) => {
             const connection = await (0, node_1.fromNodeSocket)(socket, {
                 serverVersion: "16.3 (PGlite 0.2.0)",
@@ -38,6 +49,7 @@ class PostgresServer {
                     if (!isAuthenticated) {
                         return;
                     }
+                    const db = await getDb();
                     const result = await db.execProtocolRaw(data);
                     return extendedQueryPatch.filterResponse(data, result);
                 },
@@ -55,29 +67,50 @@ class PostgresServer {
                 resolve();
             });
         });
-        await db.waitReady;
         await listeningPromise;
         return server;
     }
     async getDb() {
-        if (this.db) {
-            return this.db;
+        if (!this.db) {
+            const vector = (await dynamicImport("@electric-sql/pglite/vector")).vector;
+            const uuidOssp = (await dynamicImport("@electric-sql/pglite/contrib/uuid_ossp")).uuid_ossp;
+            const pgliteArgs = {
+                username: this.username,
+                database: this.database,
+                debug: 0,
+                extensions: {
+                    vector,
+                    uuidOssp,
+                },
+                dataDir: this.dataDirectory,
+            };
+            if (this.importPath) {
+                logger_1.logger.debug(`Importing from ${this.importPath}`);
+                const rf = fs.readFileSync(this.importPath);
+                const file = new File([rf], this.importPath);
+                pgliteArgs.loadDataDir = file;
+            }
+            this.db = await pglite_1.PGlite.create(pgliteArgs);
+            await this.db.waitReady;
         }
-        const vector = (await dynamicImport("@electric-sql/pglite/vector")).vector;
-        const uuidOssp = (await dynamicImport("@electric-sql/pglite/contrib/uuid_ossp")).uuid_ossp;
-        return pglite_1.PGlite.create({
-            username: this.username,
-            database: this.database,
-            debug: 0,
-            extensions: {
-                vector,
-                uuidOssp,
-            },
-        });
+        return this.db;
+    }
+    async clearDb() {
+        const db = await this.getDb();
+        await db.query(exports.TRUNCATE_TABLES_SQL);
+    }
+    async exportData(exportPath) {
+        const db = await this.getDb();
+        const dump = await db.dumpDataDir();
+        const arrayBuff = await dump.arrayBuffer();
+        fs.writeFileSync(exportPath, new Uint8Array(arrayBuff));
     }
-    constructor(database, username) {
+    constructor(database, username, dataDirectory, importPath) {
+        this.db = undefined;
         this.username = username;
         this.database = database;
+        this.dataDirectory = dataDirectory;
+        this.importPath = importPath;
     }
 }
 exports.PostgresServer = PostgresServer;

package/lib/emulator/dataconnectEmulator.js

@@ -2,8 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataConnectEmulatorClient = exports.DataConnectEmulator = exports.dataConnectEmulatorEvents = void 0;
 const childProcess = require("child_process");
+const pg = require("pg");
 const events_1 = require("events");
 const clc = require("colorette");
+const path = require("path");
 const api_1 = require("../api");
 const constants_1 = require("./constants");
 const downloadableEmulators_1 = require("./downloadableEmulators");
@@ -63,8 +65,12 @@ class DataConnectEmulator {
                 this.logger.logLabeled("INFO", "dataconnect", `FIREBASE_DATACONNECT_POSTGRESQL_STRING is set to ${clc.bold(connStr)} - using that instead of starting a new database`);
             }
             else if (pgHost && pgPort) {
-                const pgServer = new pgliteServer_1.PostgresServer(dbId, "postgres");
-                const server = await pgServer.createPGServer(pgHost, pgPort);
+                const dataDirectory = this.args.config.get("emulators.dataconnect.dataDir");
+                const postgresDumpPath = this.args.importPath
+                    ? path.join(this.args.importPath, "postgres.tar.gz")
+                    : undefined;
+                this.postgresServer = new pgliteServer_1.PostgresServer(dbId, "postgres", dataDirectory, postgresDumpPath);
+                const server = await this.postgresServer.createPGServer(pgHost, pgPort);
                 const connectableHost = (0, utils_1.connectableHostname)(pgHost);
                 connStr = `postgres://${connectableHost}:${pgPort}/${dbId}?sslmode=disable`;
                 server.on("error", (err) => {
@@ -110,6 +116,24 @@ class DataConnectEmulator {
     getName() {
         return types_1.Emulators.DATACONNECT;
     }
+    async clearData() {
+        if (this.postgresServer) {
+            await this.postgresServer.clearDb();
+        }
+        else {
+            const conn = new pg.Client((0, api_1.dataConnectLocalConnString)());
+            await conn.query(pgliteServer_1.TRUNCATE_TABLES_SQL);
+            await conn.end();
+        }
+    }
+    async exportData(exportPath) {
+        if (this.postgresServer) {
+            await this.postgresServer.exportData(path.join(exportPath, "postgres.tar.gz"));
+        }
+        else {
+            throw new error_1.FirebaseError("The Data Connect emulator is currently connected to a separate Postgres instance. Export is not supported.");
+        }
+    }
     static async generate(args) {
         const commandInfo = await (0, downloadableEmulators_1.downloadIfNecessary)(types_1.Emulators.DATACONNECT);
         const cmd = [

package/lib/emulator/downloadableEmulators.js

@@ -48,20 +48,20 @@ const EMULATOR_UPDATE_DETAILS = {
     },
     dataconnect: process.platform === "darwin"
         ? {
-            version: "1.7.0",
-            expectedSize: 25350912,
-            expectedChecksum: "1479411a52b689a990179c7f674362b6",
+            version: "1.7.3",
+            expectedSize: 25211648,
+            expectedChecksum: "8410794304b2ae340c3facf07d7edc16",
         }
         : process.platform === "win32"
             ? {
-                version: "1.7.0",
-                expectedSize: 25783808,
-                expectedChecksum: "fef62bf25e816aa4ba250e80050f0125",
+                version: "1.7.3",
+                expectedSize: 25641984,
+                expectedChecksum: "a4bd0f9d9d884528fa4494e4d7918c08",
             }
             : {
-                version: "1.7.0",
-                expectedSize: 25272472,
-                expectedChecksum: "24d873457787546ca6f2470fe9ec3edd",
+                version: "1.7.3",
+                expectedSize: 25125016,
+                expectedChecksum: "48660e6370aeed973f33c3420c3255fb",
             },
 };
 exports.DownloadDetails = {
@@ -233,8 +233,8 @@ const Commands = {
         shell: true,
     },
     ui: {
-        binary: "node",
-        args: [getExecPath(types_1.Emulators.UI)],
+        binary: "",
+        args: [],
         optionalArgs: [],
         joinArgs: false,
         shell: false,

package/lib/emulator/hub.js

@@ -10,7 +10,7 @@ const types_1 = require("./types");
 const hubExport_1 = require("./hubExport");
 const registry_1 = require("./registry");
 const ExpressBasedEmulator_1 = require("./ExpressBasedEmulator");
-const utils_1 = require("../utils");
+const vsCodeUtils_1 = require("../vsCodeUtils");
 const pkg = require("../../package.json");
 class EmulatorHub extends ExpressBasedEmulator_1.ExpressBasedEmulator {
     static readLocatorFile(projectId) {
@@ -20,7 +20,7 @@ class EmulatorHub extends ExpressBasedEmulator_1.ExpressBasedEmulator {
         }
         const data = fs.readFileSync(locatorPath, "utf8").toString();
         const locator = JSON.parse(data);
-        if (!utils_1.isVSCodeExtension && locator.version !== this.CLI_VERSION) {
+        if (!vsCodeUtils_1.isVSCodeExtension && locator.version !== this.CLI_VERSION) {
             logger_1.logger.debug(`Found locator with mismatched version, ignoring: ${JSON.stringify(locator)}`);
             return undefined;
         }
@@ -41,17 +41,20 @@ class EmulatorHub extends ExpressBasedEmulator_1.ExpressBasedEmulator {
         await super.start();
         await this.writeLocatorFile();
     }
+    getRunningEmulatorsMapping() {
+        const emulators = {};
+        for (const info of registry_1.EmulatorRegistry.listRunningWithInfo()) {
+            emulators[info.name] = Object.assign({ listen: this.args.listenForEmulator[info.name] }, info);
+        }
+        return emulators;
+    }
     async createExpressApp() {
         const app = await super.createExpressApp();
         app.get("/", (req, res) => {
             res.json(Object.assign(Object.assign({}, this.getLocator()), { host: utils.connectableHostname(this.args.listen[0].address), port: this.args.listen[0].port }));
         });
         app.get(EmulatorHub.PATH_EMULATORS, (req, res) => {
-            const body = {};
-            for (const info of registry_1.EmulatorRegistry.listRunningWithInfo()) {
-                body[info.name] = Object.assign({ listen: this.args.listenForEmulator[info.name] }, info);
-            }
-            res.json(body);
+            res.json(this.getRunningEmulatorsMapping());
         });
         app.post(EmulatorHub.PATH_EXPORT, async (req, res) => {
             if (req.headers.origin) {
@@ -102,6 +105,21 @@ class EmulatorHub extends ExpressBasedEmulator_1.ExpressBasedEmulator {
             await emu.reloadTriggers();
             res.status(200).json({ enabled: true });
         });
+        app.post(EmulatorHub.PATH_CLEAR_DATA_CONNECT, async (req, res) => {
+            if (req.headers.origin) {
+                res.status(403).json({
+                    message: `Clear Data Connect cannot be triggered by external callers.`,
+                });
+            }
+            utils.logLabeledBullet("emulators", `Clearing data from Data Connect data sources.`);
+            const instance = registry_1.EmulatorRegistry.get(types_1.Emulators.DATACONNECT);
+            if (!instance) {
+                res.status(400).json({ error: "The Data Connect emulator is not running." });
+                return;
+            }
+            await instance.clearData();
+            res.status(200).send("Data cleared");
+        });
         return app;
     }
     async stop() {
@@ -166,3 +184,4 @@ EmulatorHub.PATH_EXPORT = "/_admin/export";
 EmulatorHub.PATH_DISABLE_FUNCTIONS = "/functions/disableBackgroundTriggers";
 EmulatorHub.PATH_ENABLE_FUNCTIONS = "/functions/enableBackgroundTriggers";
 EmulatorHub.PATH_EMULATORS = "/emulators";
+EmulatorHub.PATH_CLEAR_DATA_CONNECT = "/dataconnect/clearData";

package/lib/emulator/hubExport.js

@@ -71,6 +71,13 @@ class HubExport {
             };
             await this.exportStorage(metadata);
         }
+        if (shouldExport(types_1.Emulators.DATACONNECT)) {
+            metadata.dataconnect = {
+                version: hub_1.EmulatorHub.CLI_VERSION,
+                path: "dataconnect_export",
+            };
+            await this.exportDataConnect(metadata);
+        }
         if (!fs.existsSync(this.exportPath)) {
             fs.mkdirSync(this.exportPath);
         }
@@ -197,6 +204,22 @@ class HubExport {
             throw new error_1.FirebaseError(`Failed to export storage: ${await res.response.text()}`);
         }
     }
+    async exportDataConnect(metadata) {
+        void (0, track_1.trackEmulator)("emulator_export", {
+            initiated_by: this.options.initiatedBy,
+            emulator_name: types_1.Emulators.DATACONNECT,
+        });
+        const instance = registry_1.EmulatorRegistry.get(types_1.Emulators.DATACONNECT);
+        if (!instance) {
+            throw new error_1.FirebaseError("Unable to export Data Connect emulator data: the Data Connect emulator is not running.");
+        }
+        const dataconnectExportPath = path.join(this.tmpDir, metadata.dataconnect.path);
+        if (fs.existsSync(dataconnectExportPath)) {
+            fse.removeSync(dataconnectExportPath);
+        }
+        fs.mkdirSync(dataconnectExportPath);
+        await instance.exportData(dataconnectExportPath);
+    }
 }
 exports.HubExport = HubExport;
 HubExport.METADATA_FILE_NAME = "firebase-export-metadata.json";

package/lib/emulator/initEmulators.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdditionalInitFns = void 0;
+const path_1 = require("path");
+const prompt_1 = require("../prompt");
+const developmentServer_1 = require("./apphosting/developmentServer");
+const emulatorLogger_1 = require("./emulatorLogger");
+const types_1 = require("./types");
+const config_1 = require("../apphosting/config");
+const detectProjectRoot_1 = require("../detectProjectRoot");
+exports.AdditionalInitFns = {
+    [types_1.Emulators.APPHOSTING]: async () => {
+        var _a;
+        const cwd = process.cwd();
+        const additionalConfigs = new Map();
+        const logger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.APPHOSTING);
+        logger.logLabeled("INFO", "Initializing Emulator");
+        const backendRelativeDir = await (0, prompt_1.promptOnce)({
+            name: "rootDir",
+            type: "input",
+            default: "./",
+            message: "Specify your app's root directory relative to your repository",
+        });
+        additionalConfigs.set("rootDirectory", backendRelativeDir);
+        const backendRoot = (0, path_1.join)(cwd, backendRelativeDir);
+        try {
+            const startCommand = await (0, developmentServer_1.detectStartCommand)(backendRoot);
+            additionalConfigs.set("startCommandOverride", startCommand);
+        }
+        catch (e) {
+            logger.log("WARN", "Failed to auto-detect your project's start command. Consider manually setting the start command by setting `firebase.json#emulators.apphosting.startCommandOverride`");
+        }
+        try {
+            const projectRoot = (_a = (0, detectProjectRoot_1.detectProjectRoot)({})) !== null && _a !== void 0 ? _a : backendRoot;
+            await (0, config_1.exportConfig)(cwd, projectRoot, backendRoot);
+        }
+        catch (e) {
+            logger.log("WARN", "failed to export app hosting configs");
+        }
+        return mapToObject(additionalConfigs);
+    },
+};
+function mapToObject(map) {
+    const newObject = {};
+    for (const [key, value] of map) {
+        newObject[key] = value;
+    }
+    return newObject;
+}

package/lib/emulator/types.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Severity = exports.EmulatorLog = exports.FunctionsExecutionMode = exports.isEmulator = exports.isDownloadableEmulator = exports.ALL_EMULATORS = exports.EMULATORS_SUPPORTED_BY_USE_EMULATOR = exports.EMULATORS_SUPPORTED_BY_UI = exports.EMULATORS_SUPPORTED_BY_FUNCTIONS = exports.ALL_SERVICE_EMULATORS = exports.IMPORT_EXPORT_EMULATORS = exports.DOWNLOADABLE_EMULATORS = exports.Emulators = void 0;
-const experiments = require("../experiments");
 var Emulators;
 (function (Emulators) {
     Emulators["AUTH"] = "auth";
@@ -33,9 +32,10 @@ exports.IMPORT_EXPORT_EMULATORS = [
     Emulators.DATABASE,
     Emulators.AUTH,
     Emulators.STORAGE,
+    Emulators.DATACONNECT,
 ];
 exports.ALL_SERVICE_EMULATORS = [
-    ...(experiments.isEnabled("emulatorapphosting") ? [Emulators.APPHOSTING] : []),
+    Emulators.APPHOSTING,
     Emulators.AUTH,
     Emulators.FUNCTIONS,
     Emulators.FIRESTORE,

package/lib/emulator/ui.js

@@ -1,52 +1,74 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EmulatorUI = void 0;
+const express = require("express");
+const path = require("path");
 const types_1 = require("./types");
 const downloadableEmulators = require("./downloadableEmulators");
 const registry_1 = require("./registry");
 const error_1 = require("../error");
+const emulatorLogger_1 = require("./emulatorLogger");
 const constants_1 = require("./constants");
 const track_1 = require("../track");
 const ExpressBasedEmulator_1 = require("./ExpressBasedEmulator");
 const experiments_1 = require("../experiments");
-class EmulatorUI {
+class EmulatorUI extends ExpressBasedEmulator_1.ExpressBasedEmulator {
     constructor(args) {
+        super({
+            listen: args.listen,
+        });
         this.args = args;
     }
-    start() {
+    async start() {
+        await super.start();
+    }
+    async createExpressApp() {
         if (!registry_1.EmulatorRegistry.isRunning(types_1.Emulators.HUB)) {
             throw new error_1.FirebaseError(`Cannot start ${constants_1.Constants.description(types_1.Emulators.UI)} without ${constants_1.Constants.description(types_1.Emulators.HUB)}!`);
         }
-        const { auto_download: autoDownload, projectId } = this.args;
-        const env = {
-            LISTEN: JSON.stringify(ExpressBasedEmulator_1.ExpressBasedEmulator.listenOptionsFromSpecs(this.args.listen)),
-            GCLOUD_PROJECT: projectId,
-            [constants_1.Constants.FIREBASE_EMULATOR_HUB]: registry_1.EmulatorRegistry.url(types_1.Emulators.HUB).host,
-        };
-        const session = (0, track_1.emulatorSession)();
-        if (session) {
-            env[constants_1.Constants.FIREBASE_GA_SESSION] = JSON.stringify(session);
-        }
+        const hub = registry_1.EmulatorRegistry.get(types_1.Emulators.HUB);
+        const app = await super.createExpressApp();
+        const { projectId } = this.args;
         const enabledExperiments = Object.keys(experiments_1.ALL_EXPERIMENTS).filter((experimentName) => (0, experiments_1.isEnabled)(experimentName));
-        env[constants_1.Constants.FIREBASE_ENABLED_EXPERIMENTS] = JSON.stringify(enabledExperiments);
-        return downloadableEmulators.start(types_1.Emulators.UI, { auto_download: autoDownload }, env);
+        const emulatorGaSession = (0, track_1.emulatorSession)();
+        await downloadableEmulators.downloadIfNecessary(types_1.Emulators.UI);
+        const downloadDetails = downloadableEmulators.getDownloadDetails(types_1.Emulators.UI);
+        const webDir = path.join(downloadDetails.unzipDir, "client");
+        app.get("/api/config", this.jsonHandler(() => {
+            const json = Object.assign({ projectId, experiments: [] }, hub.getRunningEmulatorsMapping());
+            if (emulatorGaSession) {
+                json.analytics = emulatorGaSession;
+            }
+            if (enabledExperiments) {
+                json.experiments = enabledExperiments;
+            }
+            return Promise.resolve(json);
+        }));
+        app.use(express.static(webDir));
+        app.get("*", (_, res) => {
+            res.sendFile(path.join(webDir, "index.html"));
+        });
+        return app;
     }
     connect() {
         return Promise.resolve();
     }
-    stop() {
-        return downloadableEmulators.stop(types_1.Emulators.UI);
-    }
-    getInfo() {
-        return {
-            name: this.getName(),
-            host: this.args.listen[0].address,
-            port: this.args.listen[0].port,
-            pid: downloadableEmulators.getPID(types_1.Emulators.UI),
-        };
-    }
     getName() {
         return types_1.Emulators.UI;
     }
+    jsonHandler(handler) {
+        return (req, res) => {
+            handler(req).then((body) => {
+                res.status(200).json(body);
+            }, (err) => {
+                emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.UI).log("ERROR", err);
+                res.status(500).json({
+                    message: err.message,
+                    stack: err.stack,
+                    raw: err,
+                });
+            });
+        };
+    }
 }
 exports.EmulatorUI = EmulatorUI;

package/lib/error.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isBillingError = exports.getErrStatus = exports.getErrMsg = exports.FirebaseError = void 0;
+exports.isBillingError = exports.getError = exports.getErrStatus = exports.getErrMsg = exports.FirebaseError = void 0;
 const lodash_1 = require("lodash");
 const DEFAULT_CHILDREN = [];
 const DEFAULT_EXIT = 1;
@@ -41,6 +41,13 @@ function getErrStatus(err, defaultStatus) {
     return defaultStatus || DEFAULT_STATUS;
 }
 exports.getErrStatus = getErrStatus;
+function getError(err) {
+    if (err instanceof Error) {
+        return err;
+    }
+    return Error(getErrMsg(err));
+}
+exports.getError = getError;
 function isBillingError(e) {
     var _a, _b, _c, _d;
     return !!((_d = (_c = (_b = (_a = e.context) === null || _a === void 0 ? void 0 : _a.body) === null || _b === void 0 ? void 0 : _b.error) === null || _c === void 0 ? void 0 : _c.details) === null || _d === void 0 ? void 0 : _d.find((d) => {

package/lib/gcp/cloudfunctionsv2.js

@@ -381,6 +381,7 @@ function endpointFromFunction(gcfFunction) {
             endpoint.runServiceId = utils.last(serviceName.split("/"));
         }
     }
+    proto.renameIfPresent(endpoint, gcfFunction, "uri", "url");
     endpoint.codebase = ((_e = gcfFunction.labels) === null || _e === void 0 ? void 0 : _e[constants_1.CODEBASE_LABEL]) || projectConfig.DEFAULT_CODEBASE;
     if ((_f = gcfFunction.labels) === null || _f === void 0 ? void 0 : _f[constants_1.HASH_LABEL]) {
         endpoint.hash = gcfFunction.labels[constants_1.HASH_LABEL];

package/lib/getProjectNumber.js

@@ -8,7 +8,7 @@ async function getProjectNumber(options) {
         return options.projectNumber;
     }
     const projectId = (0, projectUtils_1.needProjectId)(options);
-    const metadata = await (0, projects_1.getFirebaseProject)(projectId);
+    const metadata = await (0, projects_1.getProject)(projectId);
     options.projectNumber = metadata.projectNumber;
     return options.projectNumber;
 }

package/lib/init/features/emulators.js

@@ -7,6 +7,7 @@ const prompt_1 = require("../../prompt");
 const types_1 = require("../../emulator/types");
 const constants_1 = require("../../emulator/constants");
 const downloadableEmulators_1 = require("../../emulator/downloadableEmulators");
+const initEmulators_1 = require("../../emulator/initEmulators");
 async function doSetup(setup, config) {
     var _a, _b, _c;
     const choices = types_1.ALL_SERVICE_EMULATORS.map((e) => {
@@ -46,6 +47,13 @@ async function doSetup(setup, config) {
                 },
             ]);
         }
+        const additionalInitFn = initEmulators_1.AdditionalInitFns[selected];
+        if (additionalInitFn) {
+            const additionalOptions = await additionalInitFn();
+            if (additionalOptions) {
+                setup.config.emulators[selected] = Object.assign(Object.assign({}, setup.config.emulators[selected]), additionalOptions);
+            }
+        }
     }
     if (selections.emulators.length) {
         const uiDesc = constants_1.Constants.description(types_1.Emulators.UI);