firebase-tools 13.19.0 → 13.20.1

package/lib/emulator/dataconnect/pg-gateway/duplex.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVirtualServer = exports.createDuplexPair = exports.BufferedStream = void 0;
+const web_1 = require("node:stream/web");
+class BufferedStream {
+    constructor() {
+        const buffer = [];
+        this.readable = new web_1.ReadableStream({
+            async pull(controller) {
+                while (buffer.length === 0) {
+                    await new Promise((resolve) => setTimeout(resolve));
+                }
+                const chunk = buffer.shift();
+                controller.enqueue(chunk);
+            },
+        });
+        this.writable = new WritableStream({
+            async write(chunk) {
+                buffer.push(chunk);
+                await new Promise((resolve) => setTimeout(resolve));
+            },
+        });
+    }
+}
+exports.BufferedStream = BufferedStream;
+function createDuplexPair() {
+    const aToB = new BufferedStream();
+    const bToA = new BufferedStream();
+    const duplexA = {
+        readable: bToA.readable,
+        writable: aToB.writable,
+    };
+    const duplexB = {
+        readable: aToB.readable,
+        writable: bToA.writable,
+    };
+    return [duplexA, duplexB];
+}
+exports.createDuplexPair = createDuplexPair;
+function createVirtualServer() {
+    const listener = new BufferedStream();
+    const connWriter = listener.writable.getWriter();
+    function listen() {
+        return listener.readable;
+    }
+    async function connect() {
+        const [clientConn, serverConn] = createDuplexPair();
+        await connWriter.write(serverConn);
+        return clientConn;
+    }
+    return { listen, connect };
+}
+exports.createVirtualServer = createVirtualServer;

package/lib/emulator/dataconnect/pg-gateway/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresConnection = void 0;
+require("./polyfills/readable-stream-async-iterator");
+var connection_1 = require("./connection");
+Object.defineProperty(exports, "PostgresConnection", { enumerable: true, get: function () { return connection_1.default; } });
+__exportStar(require("./connection"), exports);
+__exportStar(require("./auth/sasl/scram-sha-256"), exports);
+__exportStar(require("./auth/md5"), exports);
+__exportStar(require("./backend-error"), exports);
+__exportStar(require("./duplex"), exports);
+__exportStar(require("./message-codes"), exports);
+__exportStar(require("./message-buffer"), exports);

package/lib/emulator/dataconnect/pg-gateway/message-buffer.js

@@ -0,0 +1,96 @@
+"use strict";
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    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.getMessages = exports.MessageBuffer = void 0;
+const utils_1 = require("./utils");
+class MessageBuffer {
+    constructor() {
+        this.buffer = new Uint8Array();
+        this.bufferLength = 0;
+        this.bufferOffset = 0;
+    }
+    mergeBuffer(newData) {
+        if (this.bufferLength > 0) {
+            const newLength = this.bufferLength + newData.byteLength;
+            const newFullLength = newLength + this.bufferOffset;
+            if (newFullLength > this.buffer.byteLength) {
+                let newBuffer;
+                if (newLength <= this.buffer.byteLength && this.bufferOffset >= this.bufferLength) {
+                    newBuffer = this.buffer;
+                }
+                else {
+                    let newBufferLength = this.buffer.byteLength * 2;
+                    while (newLength >= newBufferLength) {
+                        newBufferLength *= 2;
+                    }
+                    newBuffer = new Uint8Array(newBufferLength);
+                }
+                const bufferView = this.buffer.subarray(this.bufferOffset, this.bufferOffset + this.bufferLength);
+                (0, utils_1.copy)(bufferView, newBuffer, 0);
+                this.buffer = newBuffer;
+                this.bufferOffset = 0;
+            }
+            (0, utils_1.copy)(newData, this.buffer, this.bufferOffset + this.bufferLength);
+            this.bufferLength = newLength;
+        }
+        else {
+            this.buffer = newData;
+            this.bufferOffset = 0;
+            this.bufferLength = newData.byteLength;
+        }
+    }
+    processMessages(hasStarted) {
+        return __asyncGenerator(this, arguments, function* processMessages_1() {
+            const bufferFullLength = this.bufferOffset + this.bufferLength;
+            let offset = this.bufferOffset;
+            const codeLength = !hasStarted ? 0 : 1;
+            const headerLength = 4 + codeLength;
+            while (offset + headerLength <= bufferFullLength) {
+                const dataView = new DataView(this.buffer.buffer);
+                const length = dataView.getUint32(offset + codeLength);
+                const fullMessageLength = codeLength + length;
+                if (offset + fullMessageLength <= bufferFullLength) {
+                    yield yield __await(this.buffer.subarray(offset, offset + fullMessageLength));
+                    offset += fullMessageLength;
+                }
+                else {
+                    break;
+                }
+            }
+            if (offset === bufferFullLength) {
+                this.buffer = new Uint8Array();
+                this.bufferLength = 0;
+                this.bufferOffset = 0;
+            }
+            else {
+                this.bufferLength = bufferFullLength - offset;
+                this.bufferOffset = offset;
+            }
+        });
+    }
+}
+exports.MessageBuffer = MessageBuffer;
+function* getMessages(data) {
+    const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    let offset = 0;
+    if (dataView.byteLength === 0) {
+        return;
+    }
+    while (offset < dataView.byteLength) {
+        const length = dataView.getUint32(offset + 1);
+        yield data.subarray(offset, offset + length + 1);
+        offset += length + 1;
+    }
+}
+exports.getMessages = getMessages;

package/lib/emulator/dataconnect/pg-gateway/message-codes.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBackendMessageName = exports.getFrontendMessageName = exports.BackendMessageCode = exports.FrontendMessageCode = void 0;
+exports.FrontendMessageCode = {
+    Query: 0x51,
+    Parse: 0x50,
+    Bind: 0x42,
+    Execute: 0x45,
+    FunctionCall: 0x46,
+    Flush: 0x48,
+    Close: 0x43,
+    Describe: 0x44,
+    CopyFromChunk: 0x64,
+    CopyDone: 0x63,
+    CopyData: 0x64,
+    CopyFail: 0x66,
+    Password: 0x70,
+    Sync: 0x53,
+    Terminate: 0x58,
+};
+exports.BackendMessageCode = {
+    DataRow: 0x44,
+    ParseComplete: 0x31,
+    BindComplete: 0x32,
+    CloseComplete: 0x33,
+    CommandComplete: 0x43,
+    ReadyForQuery: 0x5a,
+    NoData: 0x6e,
+    NotificationResponse: 0x41,
+    AuthenticationResponse: 0x52,
+    ParameterStatus: 0x53,
+    BackendKeyData: 0x4b,
+    ErrorMessage: 0x45,
+    NoticeMessage: 0x4e,
+    RowDescriptionMessage: 0x54,
+    ParameterDescriptionMessage: 0x74,
+    PortalSuspended: 0x73,
+    ReplicationStart: 0x57,
+    EmptyQuery: 0x49,
+    CopyIn: 0x47,
+    CopyOut: 0x48,
+    CopyDone: 0x63,
+    CopyData: 0x64,
+};
+function getFrontendMessageName(code) {
+    var _a;
+    return (_a = Object.entries(exports.FrontendMessageCode).find(([_, value]) => value === code)) === null || _a === void 0 ? void 0 : _a[0];
+}
+exports.getFrontendMessageName = getFrontendMessageName;
+function getBackendMessageName(code) {
+    var _a;
+    return (_a = Object.entries(exports.BackendMessageCode).find(([_, value]) => value === code)) === null || _a === void 0 ? void 0 : _a[0];
+}
+exports.getBackendMessageName = getBackendMessageName;

package/lib/emulator/dataconnect/pg-gateway/platforms/node/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromNodeSocket = void 0;
+const node_stream_1 = require("node:stream");
+const connection_1 = require("../../connection");
+async function fromNodeSocket(socket, options) {
+    const rs = node_stream_1.Readable.toWeb(socket);
+    const ws = node_stream_1.Writable.toWeb(socket);
+    const opts = options
+        ? Object.assign({}, options) : undefined;
+    return new connection_1.default({ readable: rs, writable: ws }, opts);
+}
+exports.fromNodeSocket = fromNodeSocket;

package/lib/emulator/dataconnect/pg-gateway/polyfills/readable-stream-async-iterator.js

@@ -0,0 +1,36 @@
+"use strict";
+var _a, _b;
+var _c;
+(_a = (_c = ReadableStream.prototype).values) !== null && _a !== void 0 ? _a : (_c.values = function ({ preventCancel = false } = {}) {
+    const reader = this.getReader();
+    return {
+        async next() {
+            try {
+                const result = await reader.read();
+                if (result.done) {
+                    reader.releaseLock();
+                }
+                return result;
+            }
+            catch (e) {
+                reader.releaseLock();
+                throw e;
+            }
+        },
+        async return(value) {
+            if (!preventCancel) {
+                const cancelPromise = reader.cancel(value);
+                reader.releaseLock();
+                await cancelPromise;
+            }
+            else {
+                reader.releaseLock();
+            }
+            return { done: true, value };
+        },
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+    };
+});
+(_b = ReadableStream.prototype) !== null && _b !== void 0 ? _b : (ReadableStream.prototype = ReadableStream.prototype.values);

package/lib/emulator/dataconnect/pg-gateway/utils.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copy = exports.AsyncIterableWithMetadata = void 0;
+class AsyncIterableWithMetadata {
+    constructor(iterable) {
+        this.iterable = iterable;
+        this.returnValue = undefined;
+        this.iterations = 0;
+    }
+    [Symbol.asyncIterator]() {
+        const asyncIterator = Symbol.asyncIterator in this.iterable
+            ? this.iterable[Symbol.asyncIterator]()
+            : this.iterable[Symbol.iterator]();
+        this.returnValue = undefined;
+        this.iterations = 0;
+        return {
+            next: async () => {
+                const result = await asyncIterator.next();
+                if (result.done) {
+                    this.returnValue = result.value;
+                }
+                else {
+                    this.iterations++;
+                }
+                return result;
+            },
+        };
+    }
+}
+exports.AsyncIterableWithMetadata = AsyncIterableWithMetadata;
+function copy(src, dst, offset = 0) {
+    offset = Math.max(0, Math.min(offset, dst.byteLength));
+    const dstBytesAvailable = dst.byteLength - offset;
+    if (src.byteLength > dstBytesAvailable) {
+        src = src.subarray(0, dstBytesAvailable);
+    }
+    dst.set(src, offset);
+    return src.byteLength;
+}
+exports.copy = copy;

package/lib/emulator/dataconnect/pgliteServer.js

@@ -0,0 +1,134 @@
+"use strict";
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    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;
+const pglite_1 = require("@electric-sql/pglite");
+const { dynamicImport } = require(true && "../../dynamicImport");
+const net = require("node:net");
+const index_1 = require("./pg-gateway/index");
+const node_1 = require("./pg-gateway/platforms/node");
+const logger_1 = require("../../logger");
+class PostgresServer {
+    async createPGServer(host = "127.0.0.1", port) {
+        const db = await this.getDb();
+        await db.waitReady;
+        const server = net.createServer(async (socket) => {
+            const connection = await (0, node_1.fromNodeSocket)(socket, {
+                serverVersion: "16.3 (PGlite 0.2.0)",
+                auth: { method: "trust" },
+                async onMessage(data, { isAuthenticated }) {
+                    if (!isAuthenticated) {
+                        return;
+                    }
+                    const result = await db.execProtocolRaw(data);
+                    return extendedQueryPatch.filterResponse(data, result);
+                },
+            });
+            const extendedQueryPatch = new PGliteExtendedQueryPatch(connection);
+            socket.on("end", () => {
+                logger_1.logger.debug("Postgres client disconnected");
+            });
+            socket.on("error", (err) => {
+                server.emit("error", err);
+            });
+        });
+        const listeningPromise = new Promise((resolve) => {
+            server.listen(port, host, () => {
+                resolve();
+            });
+        });
+        await db.waitReady;
+        await listeningPromise;
+        return server;
+    }
+    async getDb() {
+        if (this.db) {
+            return this.db;
+        }
+        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,
+            },
+        });
+    }
+    constructor(database, username) {
+        this.username = username;
+        this.database = database;
+    }
+}
+exports.PostgresServer = PostgresServer;
+class PGliteExtendedQueryPatch {
+    constructor(connection) {
+        this.connection = connection;
+        this.isExtendedQuery = false;
+    }
+    filterResponse(message, response) {
+        return __asyncGenerator(this, arguments, function* filterResponse_1() {
+            var _a, e_1, _b, _c;
+            const pipelineStartMessages = [
+                index_1.FrontendMessageCode.Parse,
+                index_1.FrontendMessageCode.Bind,
+                index_1.FrontendMessageCode.Close,
+            ];
+            if (pipelineStartMessages.includes(message[0])) {
+                this.isExtendedQuery = true;
+            }
+            if (message[0] === index_1.FrontendMessageCode.Sync) {
+                this.isExtendedQuery = false;
+                return yield __await(this.connection.createReadyForQuery());
+            }
+            try {
+                for (var _d = true, _e = __asyncValues((0, index_1.getMessages)(response)), _f; _f = yield __await(_e.next()), _a = _f.done, !_a;) {
+                    _c = _f.value;
+                    _d = false;
+                    try {
+                        const message = _c;
+                        if (message[0] === index_1.BackendMessageCode.ErrorMessage) {
+                            this.isExtendedQuery = false;
+                        }
+                        if (this.isExtendedQuery && message[0] === index_1.BackendMessageCode.ReadyForQuery) {
+                            logger_1.logger.debug("Filtered out a ReadyForQuery.");
+                            continue;
+                        }
+                        yield yield __await(message);
+                    }
+                    finally {
+                        _d = true;
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        });
+    }
+}
+exports.PGliteExtendedQueryPatch = PGliteExtendedQueryPatch;

package/lib/emulator/dataconnectEmulator.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkIfDataConnectEmulatorRunningOnAddress = exports.DataConnectEmulatorClient = exports.DataConnectEmulator = exports.dataConnectEmulatorEvents = void 0;
+exports.DataConnectEmulatorClient = exports.DataConnectEmulator = exports.dataConnectEmulatorEvents = void 0;
 const childProcess = require("child_process");
-const clc = require("colorette");
+const events_1 = require("events");
 const api_1 = require("../api");
 const constants_1 = require("./constants");
 const downloadableEmulators_1 = require("./downloadableEmulators");
@@ -11,12 +11,12 @@ const error_1 = require("../error");
 const emulatorLogger_1 = require("./emulatorLogger");
 const types_2 = require("../dataconnect/types");
 const portUtils_1 = require("./portUtils");
-const apiv2_1 = require("../apiv2");
 const registry_1 = require("./registry");
 const logger_1 = require("../logger");
 const load_1 = require("../dataconnect/load");
+const pgliteServer_1 = require("./dataconnect/pgliteServer");
+const controller_1 = require("./controller");
 const utils_1 = require("../utils");
-const events_1 = require("events");
 exports.dataConnectEmulatorEvents = new events_1.EventEmitter();
 class DataConnectEmulator {
     constructor(args) {
@@ -26,6 +26,7 @@ class DataConnectEmulator {
         this.emulatorClient = new DataConnectEmulatorClient();
     }
     async start() {
+        var _a, _b, _c, _d;
         let resolvedConfigDir;
         try {
             resolvedConfigDir = this.args.config.path(this.args.configDir);
@@ -42,24 +43,41 @@ class DataConnectEmulator {
         catch (err) {
             this.logger.log("DEBUG", `'fdc build' failed with error: ${err.message}`);
         }
-        const alreadyRunning = await this.discoverRunningInstance();
-        if (alreadyRunning) {
-            this.logger.logLabeled("INFO", "Data Connect", "Detected an instance of the emulator already running with your service, reusing it. This emulator will not be shut down at the end of this command.");
-            this.usingExistingEmulator = true;
-            this.watchUnmanagedInstance();
-        }
-        else {
-            await (0, downloadableEmulators_1.start)(types_1.Emulators.DATACONNECT, {
-                auto_download: this.args.auto_download,
-                listen: (0, portUtils_1.listenSpecsToString)(this.args.listen),
-                config_dir: resolvedConfigDir,
-                enable_output_schema_extensions: true,
-                enable_output_generated_sdk: true,
-            });
-            this.usingExistingEmulator = false;
-        }
-        if (!(0, utils_1.isVSCodeExtension)()) {
-            await this.connectToPostgres();
+        const info = await (0, load_1.load)(this.args.projectId, this.args.config, this.args.configDir);
+        const dbId = ((_a = info.dataConnectYaml.schema.datasource.postgresql) === null || _a === void 0 ? void 0 : _a.database) || "postgres";
+        const serviceId = info.dataConnectYaml.serviceId;
+        await (0, downloadableEmulators_1.start)(types_1.Emulators.DATACONNECT, {
+            auto_download: this.args.auto_download,
+            listen: (0, portUtils_1.listenSpecsToString)(this.args.listen),
+            config_dir: resolvedConfigDir,
+            enable_output_schema_extensions: this.args.enable_output_schema_extensions,
+            enable_output_generated_sdk: this.args.enable_output_generated_sdk,
+        });
+        this.usingExistingEmulator = false;
+        if (this.args.autoconnectToPostgres) {
+            const pgPort = (_b = this.args.postgresListen) === null || _b === void 0 ? void 0 : _b[0].port;
+            const pgHost = (_c = this.args.postgresListen) === null || _c === void 0 ? void 0 : _c[0].address;
+            let connStr = (0, api_1.dataConnectLocalConnString)();
+            if ((0, api_1.dataConnectLocalConnString)()) {
+                this.logger.logLabeled("INFO", "Data Connect", `FIREBASE_DATACONNECT_POSTGRESQL_STRING is set to ${(0, api_1.dataConnectLocalConnString)()} - 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 connectableHost = (0, utils_1.connectableHostname)(pgHost);
+                connStr = `postgres://${connectableHost}:${pgPort}/${dbId}?sslmode=disable`;
+                server.on("error", (err) => {
+                    if (err instanceof error_1.FirebaseError) {
+                        this.logger.logLabeled("ERROR", "Data Connect", `${err}`);
+                    }
+                    else {
+                        this.logger.logLabeled("ERROR", "Data Connect", `Postgres threw an unexpected error, shutting down the Data Connect emulator: ${err}`);
+                    }
+                    void (0, controller_1.cleanShutdown)();
+                });
+                this.logger.logLabeled("INFO", "Data Connect", `Started up Postgres server, listening on ${(_d = server.address()) === null || _d === void 0 ? void 0 : _d.toString()}`);
+            }
+            await this.connectToPostgres(new URL(connStr), dbId, serviceId);
         }
         return;
     }
@@ -100,6 +118,9 @@ class DataConnectEmulator {
             `--config_dir=${args.configDir}`,
             `--connector_id=${args.connectorId}`,
         ];
+        if (args.watch) {
+            cmd.push("--watch");
+        }
         const res = childProcess.spawnSync(commandInfo.binary, cmd, { encoding: "utf-8" });
         logger_1.logger.info(res.stderr);
         if (res.error) {
@@ -135,54 +156,23 @@ class DataConnectEmulator {
             throw new error_1.FirebaseError(`Unable to parse 'fdc build' output: ${(_a = res.stdout) !== null && _a !== void 0 ? _a : res.stderr}`);
         }
     }
-    getLocalConectionString() {
-        var _a, _b;
-        if ((0, api_1.dataConnectLocalConnString)()) {
-            return (0, api_1.dataConnectLocalConnString)();
-        }
-        return (_b = (_a = this.args.rc.getDataconnect()) === null || _a === void 0 ? void 0 : _a.postgres) === null || _b === void 0 ? void 0 : _b.localConnectionString;
-    }
-    async discoverRunningInstance() {
-        const emuInfo = await this.emulatorClient.getInfo();
-        if (!emuInfo) {
-            return false;
-        }
-        const serviceInfo = await (0, load_1.load)(this.args.projectId, this.args.config, this.args.configDir);
-        const sameService = emuInfo.services.find((s) => serviceInfo.dataConnectYaml.serviceId === s.serviceId);
-        if (!sameService) {
-            throw new error_1.FirebaseError(`There is a Data Connect emulator already running on ${this.args.listen[0].address}:${this.args.listen[0].port}, but it is emulating a different service. Please stop that instance of the Data Connect emulator, or specify a different port in 'firebase.json'`);
-        }
-        if (sameService.connectionString &&
-            sameService.connectionString !== this.getLocalConectionString()) {
-            throw new error_1.FirebaseError(`There is a Data Connect emulator already running, but it is using a different Postgres connection string. Please stop that instance of the Data Connect emulator, or specify a different port in 'firebase.json'`);
-        }
-        return true;
-    }
-    watchUnmanagedInstance() {
-        return setInterval(async () => {
-            if (!this.usingExistingEmulator) {
-                return;
-            }
-            const emuInfo = await this.emulatorClient.getInfo();
-            if (!emuInfo) {
-                this.logger.logLabeled("INFO", "Data Connect", "The already running emulator seems to have shut down. Starting a new instance of the Data Connect emulator...");
-                await this.start();
-                exports.dataConnectEmulatorEvents.emit("restart");
-            }
-        }, 5000);
-    }
-    async connectToPostgres(localConnectionString, database, serviceId) {
-        const connectionString = localConnectionString !== null && localConnectionString !== void 0 ? localConnectionString : this.getLocalConectionString();
+    async connectToPostgres(connectionString, database, serviceId) {
         if (!connectionString) {
-            const msg = `No Postgres connection string found in '.firebaserc'. The Data Connect emulator will not be able to execute operations.
-Run ${clc.bold("firebase setup:emulators:dataconnect")} to set up a Postgres connection.`;
+            const msg = `No Postgres connection found. The Data Connect emulator will not be able to execute operations.`;
             throw new error_1.FirebaseError(msg);
         }
         const MAX_RETRIES = 3;
         for (let i = 1; i <= MAX_RETRIES; i++) {
             try {
-                this.logger.logLabeled("DEBUG", "Data Connect", `Connecting to ${connectionString}}`);
-                await this.emulatorClient.configureEmulator({ connectionString, database, serviceId });
+                this.logger.logLabeled("DEBUG", "Data Connect", `Connecting to ${connectionString}}...`);
+                connectionString.toString();
+                await this.emulatorClient.configureEmulator({
+                    connectionString: connectionString.toString(),
+                    database,
+                    serviceId,
+                    maxOpenConnections: 1,
+                });
+                this.logger.logLabeled("DEBUG", "Data Connect", `Successfully connected to ${connectionString}}`);
                 return true;
             }
             catch (err) {
@@ -190,7 +180,7 @@ Run ${clc.bold("firebase setup:emulators:dataconnect")} to set up a Postgres con
                     throw err;
                 }
                 this.logger.logLabeled("DEBUG", "Data Connect", `Retrying connectToPostgress call (${i} of ${MAX_RETRIES} attempts): ${err}`);
-                await new Promise((resolve) => setTimeout(resolve, 800));
+                await new Promise((resolve) => setTimeout(resolve, 2000));
             }
         }
         return false;
@@ -225,14 +215,6 @@ class DataConnectEmulatorClient {
     }
 }
 exports.DataConnectEmulatorClient = DataConnectEmulatorClient;
-async function checkIfDataConnectEmulatorRunningOnAddress(l) {
-    const client = new apiv2_1.Client({
-        urlPrefix: `http:/${l.family === "IPv6" ? `[${l.address}]` : l.address}:${l.port}`,
-        auth: false,
-    });
-    return getInfo(client);
-}
-exports.checkIfDataConnectEmulatorRunningOnAddress = checkIfDataConnectEmulatorRunningOnAddress;
 async function getInfo(client) {
     try {
         const res = await client.get("emulator/info");