@firebase/data-connect 0.5.0 → 0.6.0-20260409172004

package/dist/index.node.cjs.js

@@ -136,6 +136,138 @@ const CallerSdkTypeEnum = {
     TanstackAngularCore: 'TanstackAngularCore', // Tanstack non-generated Angular SDK
     GeneratedAngular: 'GeneratedAngular' // Generated Angular SDK
 };
+/**
+ * Constructs the value for the X-Goog-Api-Client header
+ * @internal
+ */
+function getGoogApiClientValue$1(isUsingGen, callerSdkType) {
+    let str = 'gl-js/ fire/' + SDK_VERSION;
+    if (callerSdkType !== CallerSdkTypeEnum.Base &&
+        callerSdkType !== CallerSdkTypeEnum.Generated) {
+        str += ' js/' + callerSdkType.toLowerCase();
+    }
+    else if (isUsingGen || callerSdkType === CallerSdkTypeEnum.Generated) {
+        str += ' js/gen';
+    }
+    return str;
+}
+/**
+ * The base class for all DataConnectTransportInterface implementations. Handles common logic such as
+ * URL construction, auth token management, and emulator usage. Concrete transport implementations
+ * should extend this class and implement the abstract {@link DataConnectTransportInterface} methods.
+ * @internal
+ */
+class AbstractDataConnectTransport {
+    constructor(options, apiKey, appId, authProvider, appCheckProvider, transportOptions, _isUsingGen = false, _callerSdkType = CallerSdkTypeEnum.Base) {
+        this.apiKey = apiKey;
+        this.appId = appId;
+        this.authProvider = authProvider;
+        this.appCheckProvider = appCheckProvider;
+        this._isUsingGen = _isUsingGen;
+        this._callerSdkType = _callerSdkType;
+        this._host = '';
+        this._location = 'l';
+        this._connectorName = '';
+        this._secure = true;
+        this._project = 'p';
+        this._authToken = null;
+        this._appCheckToken = null;
+        this._lastToken = null;
+        this._isUsingEmulator = false;
+        if (transportOptions) {
+            if (typeof transportOptions.port === 'number') {
+                this._port = transportOptions.port;
+            }
+            if (typeof transportOptions.sslEnabled !== 'undefined') {
+                this._secure = transportOptions.sslEnabled;
+            }
+            this._host = transportOptions.host;
+        }
+        const { location, projectId: project, connector, service } = options;
+        if (location) {
+            this._location = location;
+        }
+        if (project) {
+            this._project = project;
+        }
+        this._serviceName = service;
+        if (!connector) {
+            throw new DataConnectError(Code.INVALID_ARGUMENT, 'Connector Name required!');
+        }
+        this._connectorName = connector;
+        this._connectorResourcePath = `projects/${this._project}/locations/${this._location}/services/${this._serviceName}/connectors/${this._connectorName}`;
+        this.authProvider?.addTokenChangeListener(token => {
+            logDebug(`New Token Available: ${token}`);
+            this.onAuthTokenChanged(token);
+        });
+        this.appCheckProvider?.addTokenChangeListener(result => {
+            const { token } = result;
+            logDebug(`New App Check Token Available: ${token}`);
+            this._appCheckToken = token;
+        });
+    }
+    useEmulator(host, port, isSecure) {
+        this._host = host;
+        this._isUsingEmulator = true;
+        if (typeof port === 'number') {
+            this._port = port;
+        }
+        if (typeof isSecure !== 'undefined') {
+            this._secure = isSecure;
+        }
+    }
+    async getWithAuth(forceToken = false) {
+        let starterPromise = new Promise(resolve => resolve(this._authToken));
+        if (this.appCheckProvider) {
+            const appCheckToken = await this.appCheckProvider.getToken();
+            if (appCheckToken) {
+                this._appCheckToken = appCheckToken.token;
+            }
+        }
+        if (this.authProvider) {
+            starterPromise = this.authProvider
+                .getToken(/*forceToken=*/ forceToken)
+                .then(data => {
+                if (!data) {
+                    return null;
+                }
+                this._authToken = data.accessToken;
+                return this._authToken;
+            });
+        }
+        else {
+            starterPromise = new Promise(resolve => resolve(''));
+        }
+        return starterPromise;
+    }
+    async withRetry(promiseFactory, retry = false) {
+        let isNewToken = false;
+        return this.getWithAuth(retry)
+            .then(res => {
+            isNewToken = this._lastToken !== res;
+            this._lastToken = res;
+            return res;
+        })
+            .then(promiseFactory)
+            .catch(err => {
+            // Only retry if the result is unauthorized and the last token isn't the same as the new one.
+            if ('code' in err &&
+                err.code === Code.UNAUTHORIZED &&
+                !retry &&
+                isNewToken) {
+                logDebug('Retrying due to unauthorized');
+                return this.withRetry(promiseFactory, true);
+            }
+            throw err;
+        });
+    }
+    _setLastToken(lastToken) {
+        this._lastToken = lastToken;
+    }
+    _setCallerSdkType(callerSdkType) {
+        this._callerSdkType = callerSdkType;
+    }
+}
 
 /**
  * @license
@@ -153,7 +285,13 @@ const CallerSdkTypeEnum = {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+/** The fetch implementation to be used by the {@link RESTTransport}. */
 let connectFetch = globalThis.fetch;
+/**
+ * This function is ONLY used for testing and for ensuring compatability in environments which may
+ * be using a poyfill and/or bundlers. It should not be called by users of the Firebase JS SDK.
+ * @internal
+ */
 function initializeFetch(fetchImpl) {
     connectFetch = fetchImpl;
 }
@@ -200,14 +338,20 @@ async function dcFetch(url, body, { signal }, appId, accessToken, appCheckToken,
         response = await connectFetch(url, fetchOptions);
     }
     catch (err) {
-        throw new DataConnectError(Code.OTHER, 'Failed to fetch: ' + JSON.stringify(err));
+        const message = err && typeof err === 'object' && 'message' in err
+            ? err['message']
+            : String(err);
+        throw new DataConnectError(Code.OTHER, 'Failed to fetch: ' + message);
     }
     let jsonResponse;
     try {
         jsonResponse = await response.json();
     }
     catch (e) {
-        throw new DataConnectError(Code.OTHER, JSON.stringify(e));
+        const message = e && typeof e === 'object' && 'message' in e
+            ? e['message']
+            : String(e);
+        throw new DataConnectError(Code.OTHER, 'Failed to parse JSON response: ' + message);
     }
     const message = getErrorMessage(jsonResponse);
     if (response.status >= 400) {
@@ -215,32 +359,918 @@ async function dcFetch(url, body, { signal }, appId, accessToken, appCheckToken,
         if (response.status === 401) {
             throw new DataConnectError(Code.UNAUTHORIZED, message);
         }
-        throw new DataConnectError(Code.OTHER, message);
+        throw new DataConnectError(Code.OTHER, message);
+    }
+    if (jsonResponse.errors && jsonResponse.errors.length) {
+        const stringified = JSON.stringify(jsonResponse.errors);
+        const failureResponse = {
+            errors: jsonResponse.errors,
+            data: jsonResponse.data
+        };
+        throw new DataConnectOperationError('DataConnect error while performing request: ' + stringified, failureResponse);
+    }
+    if (!jsonResponse.extensions) {
+        jsonResponse.extensions = {
+            dataConnect: []
+        };
+    }
+    return jsonResponse;
+}
+function getErrorMessage(obj) {
+    if ('message' in obj && obj.message) {
+        return obj.message;
+    }
+    return JSON.stringify(obj);
+}
+
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const PROD_HOST = 'firebasedataconnect.googleapis.com';
+const WEBSOCKET_PATH = 'ws/google.firebase.dataconnect.v1.ConnectorStreamService';
+function restUrlBuilder(projectConfig, transportOptions) {
+    const { connector, location, projectId: project, service } = projectConfig;
+    const { host, sslEnabled, port } = transportOptions;
+    const protocol = sslEnabled ? 'https' : 'http';
+    const realHost = host || PROD_HOST;
+    let baseUrl = `${protocol}://${realHost}`;
+    if (typeof port === 'number') {
+        baseUrl += `:${port}`;
+    }
+    else if (typeof port !== 'undefined') {
+        logError('Port type is of an invalid type');
+        throw new DataConnectError(Code.INVALID_ARGUMENT, 'Incorrect type for port passed in!');
+    }
+    return `${baseUrl}/v1/projects/${project}/locations/${location}/services/${service}/connectors/${connector}`;
+}
+function websocketUrlBuilder(projectConfig, transportOptions) {
+    const { location } = projectConfig;
+    const { host, sslEnabled, port } = transportOptions;
+    const protocol = sslEnabled ? 'wss' : 'ws';
+    const realHost = host || PROD_HOST;
+    let baseUrl = `${protocol}://${realHost}`;
+    if (typeof port === 'number') {
+        baseUrl += `:${port}`;
+    }
+    else if (typeof port !== 'undefined') {
+        logError('Port type is of an invalid type');
+        throw new DataConnectError(Code.INVALID_ARGUMENT, 'Incorrect type for port passed in!');
+    }
+    return `${baseUrl}/${WEBSOCKET_PATH}/Connect/locations/${location}`;
+}
+function addToken(url, apiKey) {
+    if (!apiKey) {
+        return url;
+    }
+    const newUrl = new URL(url);
+    newUrl.searchParams.append('key', apiKey);
+    return newUrl.toString();
+}
+
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Fetch-based REST implementation of {@link AbstractDataConnectTransport}.
+ * @internal
+ */
+class RESTTransport extends AbstractDataConnectTransport {
+    constructor(options, apiKey, appId, authProvider, appCheckProvider, transportOptions, _isUsingGen = false, _callerSdkType = CallerSdkTypeEnum.Base) {
+        super(options, apiKey, appId, authProvider, appCheckProvider, transportOptions, _isUsingGen, _callerSdkType);
+        this.invokeQuery = (queryName, body) => {
+            const abortController = new AbortController();
+            // TODO(mtewani): Update to proper value
+            const withAuth = this.withRetry(() => dcFetch(addToken(`${this.endpointUrl}:executeQuery`, this.apiKey), {
+                name: this._connectorResourcePath,
+                operationName: queryName,
+                variables: body
+            }, abortController, this.appId, this._authToken, this._appCheckToken, this._isUsingGen, this._callerSdkType, this._isUsingEmulator));
+            return withAuth;
+        };
+        this.invokeMutation = (mutationName, body) => {
+            const abortController = new AbortController();
+            const taskResult = this.withRetry(() => {
+                return dcFetch(addToken(`${this.endpointUrl}:executeMutation`, this.apiKey), {
+                    name: this._connectorResourcePath,
+                    operationName: mutationName,
+                    variables: body
+                }, abortController, this.appId, this._authToken, this._appCheckToken, this._isUsingGen, this._callerSdkType, this._isUsingEmulator);
+            });
+            return taskResult;
+        };
+    }
+    get endpointUrl() {
+        return restUrlBuilder({
+            connector: this._connectorName,
+            location: this._location,
+            projectId: this._project,
+            service: this._serviceName
+        }, {
+            host: this._host,
+            sslEnabled: this._secure,
+            port: this._port
+        });
+    }
+    invokeSubscribe(observer, queryName, body) {
+        throw new DataConnectError(Code.NOT_SUPPORTED, 'Subscriptions are not supported using REST!');
+    }
+    invokeUnsubscribe(queryName, body) {
+        throw new DataConnectError(Code.NOT_SUPPORTED, 'Unsubscriptions are not supported using REST!');
+    }
+    onAuthTokenChanged(newToken) {
+        this._authToken = newToken;
+    }
+}
+
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/** The request id of the first request over the stream */
+const FIRST_REQUEST_ID = 1;
+/** Time to wait before closing an idle connection (no active subscriptions) */
+const IDLE_CONNECTION_TIMEOUT_MS = 60 * 1000; // 1 minute
+/**
+ * The base class for all {@link DataConnectStreamTransport | Stream Transport} implementations.
+ * Handles management of logical streams (requests), authentication, data routing to query layer, etc.
+ * @internal
+ */
+class AbstractDataConnectStreamTransport extends AbstractDataConnectTransport {
+    constructor() {
+        super(...arguments);
+        this.pendingClose = false;
+        /** True if the transport is unable to connect to the server */
+        this.isUnableToConnect = false;
+        /** The request ID of the next message to be sent. Monotonically increasing sequence number. */
+        this.requestNumber = FIRST_REQUEST_ID;
+        /**
+         * Map of query/variables to their active execute/resume request bodies.
+         */
+        this.activeQueryExecuteRequests = new Map();
+        /**
+         * Map of mutation/variables to their active execute request bodies.
+         */
+        this.activeMutationExecuteRequests = new Map();
+        /**
+         * Map of query/variables to their active subscribe request bodies.
+         */
+        this.activeSubscribeRequests = new Map();
+        /**
+         * Map of active execution RequestIds and their corresponding Promises and resolvers.
+         */
+        this.executeRequestPromises = new Map();
+        /**
+         * Map of active subscription RequestIds and their corresponding observers.
+         */
+        this.subscribeObservers = new Map();
+        /** current close timeout from setTimeout(), if any */
+        this.closeTimeout = null;
+        /** has the close timeout finished? */
+        this.closeTimeoutFinished = false;
+        /** Flag to ensure we wait for the initial auth state once per connection attempt. */
+        this.hasWaitedForInitialAuth = false;
+        /**
+         * Tracks if the next message to be sent is the first message of the stream.
+         */
+        this.isFirstStreamMessage = true;
+        /**
+         * Tracks the last auth token sent to the server.
+         * Used to detect if the token has changed and needs to be resent.
+         */
+        this.lastSentAuthToken = null;
+    }
+    /** Is the stream currently waiting to close connection? */
+    get isPendingClose() {
+        return this.pendingClose;
+    }
+    /** True if there are active subscriptions on the stream */
+    get hasActiveSubscriptions() {
+        return this.activeSubscribeRequests.size > 0;
+    }
+    /** True if there are active execute or mutation requests on the stream */
+    get hasActiveExecuteRequests() {
+        return (this.activeQueryExecuteRequests.size > 0 ||
+            this.activeMutationExecuteRequests.size > 0);
+    }
+    /**
+     * Generates and returns the next request ID.
+     */
+    nextRequestId() {
+        return (this.requestNumber++).toString();
+    }
+    /**
+     * Tracks a query execution request, storing the request body and creating and storing a promise that
+     * will be resolved when the response is received.
+     * @returns The reject function and the response promise.
+     *
+     * @remarks
+     * This method returns a promise, but is synchronous.
+     */
+    trackQueryExecuteRequest(requestId, mapKey, executeBody) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let resolveFn;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let rejectFn;
+        const responsePromise = new Promise((resolve, reject) => {
+            resolveFn = resolve;
+            rejectFn = reject;
+        });
+        const executeRequestPromise = {
+            responsePromise,
+            resolveFn: resolveFn,
+            rejectFn: rejectFn
+        };
+        this.activeQueryExecuteRequests.set(mapKey, executeBody);
+        this.executeRequestPromises.set(requestId, executeRequestPromise);
+        return executeRequestPromise;
+    }
+    /**
+     * Tracks a mutation execution request, storing the request body and creating and storing a promise
+     * that will be resolved when the response is received.
+     * @returns The reject function and the response promise.
+     *
+     * @remarks
+     * This method returns a promise, but is synchronous.
+     */
+    trackMutationExecuteRequest(requestId, mapKey, executeBody) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let resolveFn;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let rejectFn;
+        const responsePromise = new Promise((resolve, reject) => {
+            resolveFn = resolve;
+            rejectFn = reject;
+        });
+        const executeRequestPromise = {
+            responsePromise,
+            resolveFn: resolveFn,
+            rejectFn: rejectFn
+        };
+        const activeRequests = this.activeMutationExecuteRequests.get(mapKey) || [];
+        activeRequests.push(executeBody);
+        this.activeMutationExecuteRequests.set(mapKey, activeRequests);
+        this.executeRequestPromises.set(requestId, executeRequestPromise);
+        return executeRequestPromise;
+    }
+    /**
+     * Tracks a subscribe request, storing the request body and the notification observer.
+     * @remarks
+     * This method is synchronous.
+     */
+    trackSubscribeRequest(requestId, mapKey, subscribeBody, observer) {
+        this.activeSubscribeRequests.set(mapKey, subscribeBody);
+        this.subscribeObservers.set(requestId, observer);
+    }
+    /**
+     * Cleans up the query execute request tracking data structures, deleting the tracked request and
+     * it's associated promise.
+     */
+    cleanupQueryExecuteRequest(requestId, mapKey) {
+        this.activeQueryExecuteRequests.delete(mapKey);
+        this.executeRequestPromises.delete(requestId);
+    }
+    /**
+     * Cleans up the mutation execute request tracking data structures, deleting the tracked request and
+     * it's associated promise.
+     */
+    cleanupMutationExecuteRequest(requestId, mapKey) {
+        const executeRequests = this.activeMutationExecuteRequests.get(mapKey);
+        if (executeRequests) {
+            const updatedRequests = executeRequests.filter(req => req.requestId !== requestId);
+            if (updatedRequests.length > 0) {
+                this.activeMutationExecuteRequests.set(mapKey, updatedRequests);
+            }
+            else {
+                this.activeMutationExecuteRequests.delete(mapKey);
+            }
+        }
+        this.executeRequestPromises.delete(requestId);
+    }
+    /**
+     * Cleans up the subscribe request tracking data structures, deleting the tracked request and
+     * it's associated promise.
+     */
+    cleanupSubscribeRequest(requestId, mapKey) {
+        this.activeSubscribeRequests.delete(mapKey);
+        this.subscribeObservers.delete(requestId);
+    }
+    /**
+     * Indicates whether we should include the auth token in the next message.
+     * Only true if there is an auth token and it is different from the last sent auth token, or this
+     * is the first message.
+     */
+    get shouldIncludeAuth() {
+        return (this.isFirstStreamMessage ||
+            (!!this._authToken && this._authToken !== this.lastSentAuthToken));
+    }
+    /**
+     * Called by the concrete transport implementation when the physical connection is ready.
+     */
+    onConnectionReady() {
+        this.isFirstStreamMessage = true;
+        this.lastSentAuthToken = null;
+        this.hasWaitedForInitialAuth = false;
+    }
+    /**
+     * Attempt to close the connection. Will only close if there are no active requests preventing it
+     * from doing so.
+     */
+    async attemptClose() {
+        if (this.hasActiveSubscriptions || this.hasActiveExecuteRequests) {
+            return;
+        }
+        this.cancelClose();
+        await this.closeConnection();
+        this.onGracefulStreamClose?.();
+    }
+    /**
+     * Begin closing the connection. Waits for and cleans up all active requests, and waits for
+     * {@link IDLE_CONNECTION_TIMEOUT_MS}. This is a graceful close - it will be called when there are
+     * no more active subscriptions, so there's no need to cleanup.
+     */
+    prepareToCloseGracefully() {
+        if (this.pendingClose) {
+            return;
+        }
+        this.pendingClose = true;
+        this.closeTimeoutFinished = false;
+        this.closeTimeout = setTimeout(() => {
+            this.closeTimeoutFinished = true;
+            void this.attemptClose();
+        }, IDLE_CONNECTION_TIMEOUT_MS);
+    }
+    /**
+     * Cancel closing the connection.
+     */
+    cancelClose() {
+        if (this.closeTimeout) {
+            clearTimeout(this.closeTimeout);
+        }
+        this.pendingClose = false;
+        this.closeTimeoutFinished = false;
+    }
+    /**
+     * Reject all active execute promises and notify all subscribe observers with the given error.
+     * Clear active request tracking maps without cancelling or re-invoking any requests.
+     */
+    rejectAllActiveRequests(code, reason) {
+        this.activeQueryExecuteRequests.clear();
+        this.activeMutationExecuteRequests.clear();
+        this.activeSubscribeRequests.clear();
+        const error = new DataConnectError(code, reason);
+        for (const [requestId, { rejectFn }] of this.executeRequestPromises) {
+            this.executeRequestPromises.delete(requestId);
+            rejectFn(error);
+        }
+        for (const [requestId, observer] of this.subscribeObservers) {
+            this.subscribeObservers.delete(requestId);
+            observer.onDisconnect(code, reason);
+        }
+    }
+    /**
+     * Called by concrete implementations when the stream is successfully closed, gracefully or otherwise.
+     */
+    onStreamClose(code, reason) {
+        this.rejectAllActiveRequests(Code.OTHER, `Stream disconnected with code ${code}: ${reason}`);
+    }
+    /**
+     * Prepares a stream request message by adding necessary headers and metadata.
+     * If this is the first message on the stream, it includes the resource name, auth token, and App Check token.
+     * If the auth token has refreshed since the last message, it includes the new auth token.
+     *
+     * This method is called by the concrete transport implementation before sending a message.
+     *
+     * @returns the requestBody, with attached headers and initial request fields
+     */
+    prepareMessage(requestBody) {
+        const preparedRequestBody = { ...requestBody };
+        const headers = {};
+        if (this.appId) {
+            headers['x-firebase-gmpid'] = this.appId;
+        }
+        headers['X-Goog-Api-Client'] = getGoogApiClientValue$1(this._isUsingGen, this._callerSdkType);
+        if (this.shouldIncludeAuth && this._authToken) {
+            headers['X-Firebase-Auth-Token'] = this._authToken;
+            this.lastSentAuthToken = this._authToken;
+        }
+        if (this.isFirstStreamMessage) {
+            if (this._appCheckToken) {
+                headers['X-Firebase-App-Check'] = this._appCheckToken;
+            }
+            preparedRequestBody.name = this._connectorResourcePath;
+        }
+        preparedRequestBody.headers = headers;
+        this.isFirstStreamMessage = false;
+        return preparedRequestBody;
+    }
+    // TODO(stephenarosaj): just make this async
+    /**
+     * Sends a request message to the server via the concrete implementation.
+     * Ensures the connection is ready and prepares the message before sending.
+     * @returns A promise that resolves when the request message has been sent.
+     */
+    async sendRequestMessage(requestBody) {
+        if (!this.hasWaitedForInitialAuth && this.authProvider) {
+            await this.getWithAuth();
+            this.hasWaitedForInitialAuth = true;
+        }
+        if (this.streamIsReady) {
+            const prepared = this.prepareMessage(requestBody);
+            return this.sendMessage(prepared);
+        }
+        return this.ensureConnection().then(() => {
+            const prepared = this.prepareMessage(requestBody);
+            return this.sendMessage(prepared);
+        });
+    }
+    /**
+     * Helper to generate a consistent string key for the tracking maps.
+     */
+    getMapKey(operationName, variables) {
+        const sortedVariables = this.sortObjectKeys(variables);
+        return JSON.stringify({ operationName, variables: sortedVariables });
+    }
+    /**
+     * Recursively sorts the keys of an object.
+     */
+    sortObjectKeys(obj) {
+        if (obj === null || typeof obj !== 'object' || Array.isArray(obj)) {
+            return obj;
+        }
+        const sortedObj = {};
+        Object.keys(obj)
+            .sort()
+            .forEach(key => {
+            sortedObj[key] = this.sortObjectKeys(obj[key]);
+        });
+        return sortedObj;
+    }
+    /**
+     * @inheritdoc
+     * @remarks
+     * This method synchronously updates the request tracking data structures before sending any message.
+     * If any asynchronous functionality is added to this function, it MUST be done in a way that
+     * preserves the synchronous update of the tracking data structures before the method returns.
+     */
+    invokeQuery(queryName, variables) {
+        const requestId = this.nextRequestId();
+        const activeRequestKey = { operationName: queryName, variables };
+        const mapKey = this.getMapKey(queryName, variables);
+        const executeBody = {
+            requestId,
+            execute: activeRequestKey
+        };
+        let { responsePromise, rejectFn } = this.trackQueryExecuteRequest(requestId, mapKey, executeBody);
+        responsePromise = responsePromise.finally(() => {
+            this.cleanupQueryExecuteRequest(requestId, mapKey);
+            if (!this.hasActiveSubscriptions &&
+                !this.hasActiveExecuteRequests &&
+                this.closeTimeoutFinished) {
+                void this.attemptClose();
+            }
+        });
+        // asynchronous, fire and forget
+        this.sendRequestMessage(executeBody).catch(err => {
+            rejectFn(err);
+        });
+        return responsePromise;
+    }
+    /**
+     * @inheritdoc
+     * @remarks
+     * This method synchronously updates the request tracking data structures before sending any message.
+     * If any asynchronous functionality is added to this function, it MUST be done in a way that
+     * preserves the synchronous update of the tracking data structures before the method returns.
+     */
+    invokeMutation(mutationName, variables) {
+        const requestId = this.nextRequestId();
+        const activeRequestKey = { operationName: mutationName, variables };
+        const mapKey = this.getMapKey(mutationName, variables);
+        const executeBody = {
+            requestId,
+            execute: activeRequestKey
+        };
+        let { responsePromise, rejectFn } = this.trackMutationExecuteRequest(requestId, mapKey, executeBody);
+        responsePromise = responsePromise.finally(() => {
+            this.cleanupMutationExecuteRequest(requestId, mapKey);
+            if (!this.hasActiveSubscriptions &&
+                !this.hasActiveExecuteRequests &&
+                this.closeTimeoutFinished) {
+                void this.attemptClose();
+            }
+        });
+        // asynchronous, fire and forget
+        this.sendRequestMessage(executeBody).catch(err => {
+            rejectFn(err);
+        });
+        return responsePromise;
+    }
+    /**
+     * @inheritdoc
+     * @remarks
+     * This method synchronously updates the request tracking data structures before sending any message
+     * or cancelling the closing of the stream. If any asynchronous functionality is added to this function,
+     * it MUST be done in a way that preserves the synchronous update of the tracking data structures
+     * before the method returns.
+     */
+    invokeSubscribe(observer, queryName, variables) {
+        // if we are waiting to close the stream, cancel closing!
+        this.cancelClose();
+        const requestId = this.nextRequestId();
+        const activeRequestKey = { operationName: queryName, variables };
+        const mapKey = this.getMapKey(queryName, variables);
+        const subscribeBody = {
+            requestId,
+            subscribe: activeRequestKey
+        };
+        this.trackSubscribeRequest(requestId, mapKey, subscribeBody, observer);
+        // asynchronous, fire and forget
+        this.sendRequestMessage(subscribeBody).catch(err => {
+            observer.onError(err instanceof Error ? err : new Error(String(err)));
+            this.cleanupSubscribeRequest(requestId, mapKey);
+            if (!this.hasActiveSubscriptions) {
+                this.prepareToCloseGracefully();
+            }
+        });
+    }
+    /**
+     * @inheritdoc
+     * @remarks
+     * This method synchronously updates the request tracking data structures before sending any message.
+     * If any asynchronous functionality is added to this function, it MUST be done in a way that
+     * preserves the synchronous update of the tracking data structures before the method returns.
+     */
+    invokeUnsubscribe(queryName, variables) {
+        const mapKey = this.getMapKey(queryName, variables);
+        const subscribeRequest = this.activeSubscribeRequests.get(mapKey);
+        if (!subscribeRequest) {
+            return;
+        }
+        const requestId = subscribeRequest.requestId;
+        const cancelBody = {
+            requestId,
+            cancel: {}
+        };
+        this.cleanupSubscribeRequest(requestId, mapKey);
+        // asynchronous, fire and forget
+        this.sendRequestMessage(cancelBody).catch(err => {
+            logError(`Stream Transport failed to send unsubscribe message: ${err}`);
+        });
+        if (!this.hasActiveSubscriptions) {
+            this.prepareToCloseGracefully();
+        }
+    }
+    onAuthTokenChanged(newToken) {
+        const oldAuthToken = this._authToken;
+        this._authToken = newToken;
+        const oldAuthUid = this.authUid;
+        const newAuthUid = this.authProvider?.getAuth()?.getUid();
+        this.authUid = newAuthUid;
+        // onAuthTokenChanged gets called by the auth provider once it initializes, so we must make sure
+        // we don't prematurely disconnect the stream if this is the initial call.
+        const isInitialAuth = oldAuthUid === undefined;
+        if (isInitialAuth) {
+            return;
+        }
+        if ((oldAuthToken && newToken === null) || // user logged out
+            (!oldAuthUid && newAuthUid) || // user logged in
+            (oldAuthUid && newAuthUid !== oldAuthUid) // logged in user changed
+        ) {
+            this.rejectAllActiveRequests(Code.UNAUTHORIZED, 'Stream disconnected due to auth change.');
+            void this.attemptClose();
+        }
+    }
+    /**
+     * Handle a response message from the server. Called by the connection-specific implementation after
+     * it's transformed a message from the server into a {@link DataConnectResponse}.
+     * @param requestId the requestId associated with this response.
+     * @param response the response from the server.
+     */
+    async handleResponse(requestId, response) {
+        if (this.executeRequestPromises.has(requestId)) {
+            // don't clean up the tracking maps here, they're handled automatically when the execute promise settles
+            const { resolveFn, rejectFn } = this.executeRequestPromises.get(requestId);
+            if (response.errors && response.errors.length) {
+                const failureResponse = {
+                    errors: response.errors,
+                    data: response.data
+                };
+                const stringified = JSON.stringify(response.errors);
+                rejectFn(new DataConnectOperationError('DataConnect error while performing request: ' + stringified, failureResponse));
+            }
+            else {
+                resolveFn(response);
+            }
+        }
+        else if (this.subscribeObservers.has(requestId)) {
+            const observer = this.subscribeObservers.get(requestId);
+            await observer.onData(response);
+        }
+        else {
+            throw new DataConnectError(Code.OTHER, `Stream response contained unrecognized requestId '${requestId}'`);
+        }
+    }
+}
+
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/** The WebSocket implementation to be used by the {@link WebSocketTransport}. */
+let connectWebSocket = globalThis.WebSocket;
+/**
+ * This function is ONLY used for testing and for ensuring compatability in environments which may
+ * be using a poyfill and/or bundlers. It should not be called by users of the Firebase JS SDK.
+ * @internal
+ */
+function initializeWebSocket(webSocketImpl) {
+    connectWebSocket = webSocketImpl;
+}
+/**
+ * The code used to close the WebSocket connection.
+ * This is a protocol-level code, and is not the same as the {@link Code | DataConnect error code}.
+ * @internal
+ */
+const WEBSOCKET_CLOSE_CODE = 1000;
+/**
+ * An {@link AbstractDataConnectStreamTransport | Stream Transport} implementation that uses {@link WebSocket | WebSockets} to stream requests and responses.
+ * This class handles the lifecycle of the WebSocket connection, including automatic
+ * reconnection and request correlation.
+ * @internal
+ */
+class WebSocketTransport extends AbstractDataConnectStreamTransport {
+    get endpointUrl() {
+        return websocketUrlBuilder({
+            connector: this._connectorName,
+            location: this._location,
+            projectId: this._project,
+            service: this._serviceName
+        }, {
+            host: this._host,
+            sslEnabled: this._secure,
+            port: this._port
+        });
+    }
+    /**
+     * Decodes a WebSocket response from a Uint8Array to a JSON object.
+     * Emulator does not send messages as Uint8Arrays, but prod does.
+     */
+    decodeBinaryResponse(data) {
+        if (!this.decoder) {
+            this.decoder = new TextDecoder('utf-8');
+        }
+        return this.decoder.decode(data);
+    }
+    get streamIsReady() {
+        return this.connection?.readyState === WebSocket.OPEN;
+    }
+    constructor(options, apiKey, appId, authProvider, appCheckProvider, transportOptions, _isUsingGen = false, _callerSdkType = CallerSdkTypeEnum.Base) {
+        super(options, apiKey, appId, authProvider, appCheckProvider, transportOptions, _isUsingGen, _callerSdkType);
+        this.apiKey = apiKey;
+        this.appId = appId;
+        this.authProvider = authProvider;
+        this.appCheckProvider = appCheckProvider;
+        this._isUsingGen = _isUsingGen;
+        this._callerSdkType = _callerSdkType;
+        /** Decodes binary WebSocket responses to strings */
+        this.decoder = undefined;
+        /** The current connection to the server. Undefined if disconnected. */
+        this.connection = undefined;
+        /**
+         * Current connection attempt. If null, we are not currently attemping to connect (not connected,
+         * or already connected). Will be resolved or rejected when the connection is opened or fails to open.
+         */
+        this.connectionAttempt = null;
+    }
+    ensureConnection() {
+        try {
+            if (this.streamIsReady) {
+                return Promise.resolve();
+            }
+            if (this.connectionAttempt) {
+                return this.connectionAttempt;
+            }
+            this.connectionAttempt = new Promise((resolve, reject) => {
+                if (!connectWebSocket) {
+                    throw new DataConnectError(Code.OTHER, 'No WebSocket Implementation detected!');
+                }
+                const ws = new connectWebSocket(this.endpointUrl);
+                this.connection = ws;
+                this.connection.binaryType = 'arraybuffer';
+                ws.onopen = () => {
+                    this.isUnableToConnect = false;
+                    this.onConnectionReady();
+                    resolve();
+                };
+                ws.onerror = event => {
+                    this.connectionAttempt = null;
+                    this.isUnableToConnect = true;
+                    const error = new DataConnectError(Code.OTHER, `Error using WebSocket connection, closing WebSocket`);
+                    this.handleError(error);
+                    reject(error);
+                };
+                ws.onmessage = ev => this.handleWebSocketMessage(ev).catch(async (reason) => {
+                    this.handleError(reason);
+                });
+                ws.onclose = ev => this.handleWebsocketDisconnect(ev);
+            });
+            return this.connectionAttempt;
+        }
+        catch (error) {
+            this.handleError(error);
+            throw error;
+        }
+    }
+    openConnection() {
+        return this.ensureConnection().catch(err => {
+            throw new DataConnectError(Code.OTHER, `Failed to open connection: ${err}`);
+        });
+    }
+    closeConnection(code, reason) {
+        if (!this.connection) {
+            this.connectionAttempt = null;
+            return Promise.resolve();
+        }
+        let error;
+        try {
+            if (reason) {
+                // reason string can be max 123 bytes (not characters, bytes)
+                // https://developer.mozilla.org/en-US/docs/Web/API/WebSocketStream/close#parameters
+                const MAX_BYTES = 123;
+                const encoder = new TextEncoder();
+                const bytes = encoder.encode(reason);
+                if (bytes.length <= MAX_BYTES) {
+                    this.connection.close(code, reason);
+                }
+                else {
+                    const buf = new Uint8Array(MAX_BYTES);
+                    const { read } = encoder.encodeInto(reason, buf);
+                    const truncatedReason = reason.substring(0, read);
+                    this.connection.close(code, truncatedReason);
+                }
+            }
+            else {
+                this.connection.close(code);
+            }
+        }
+        catch (e) {
+            error = e;
+        }
+        finally {
+            this.connection = undefined;
+            this.connectionAttempt = null;
+        }
+        if (error) {
+            return Promise.reject(error);
+        }
+        return Promise.resolve();
     }
-    if (jsonResponse.errors && jsonResponse.errors.length) {
-        const stringified = JSON.stringify(jsonResponse.errors);
-        const failureResponse = {
-            errors: jsonResponse.errors,
-            data: jsonResponse.data
-        };
-        throw new DataConnectOperationError('DataConnect error while performing request: ' + stringified, failureResponse);
+    /**
+     * Handle a disconnection from the server. Initiates graceful clean up and reconnection attempts.
+     * @param ev the {@link CloseEvent} that closed the WebSocket.
+     */
+    handleWebsocketDisconnect(ev) {
+        this.connection = undefined;
+        this.connectionAttempt = null;
+        this.onStreamClose(ev.code, ev.reason);
     }
-    if (!jsonResponse.extensions) {
-        jsonResponse.extensions = {
-            dataConnect: []
+    /**
+     * Handle an error that occurred on the WebSocket. Close the connection and reject all active requests.
+     */
+    handleError(error) {
+        logError(`DataConnect WebSocket error, closing stream: ${error}`);
+        let reason = error ? String(error) : 'Unknown Error';
+        if (error instanceof DataConnectError) {
+            reason = error.message;
+        }
+        void this.closeConnection(WEBSOCKET_CLOSE_CODE, reason);
+    }
+    sendMessage(requestBody) {
+        return this.ensureConnection().then(() => {
+            try {
+                this.connection.send(JSON.stringify(requestBody));
+                return Promise.resolve();
+            }
+            catch (err) {
+                this.handleError(err);
+                throw new DataConnectError(Code.OTHER, `Failed to send message: ${String(err)}`);
+            }
+        });
+    }
+    /**
+     * Handles incoming WebSocket messages.
+     * @param ev The {@link MessageEvent} from the WebSocket.
+     */
+    async handleWebSocketMessage(ev) {
+        const result = this.parseWebSocketData(ev.data);
+        const requestId = result.requestId;
+        const response = {
+            data: result.data,
+            errors: result.errors,
+            extensions: result.extensions || { dataConnect: [] }
         };
+        await this.handleResponse(requestId, response);
     }
-    return jsonResponse;
-}
-function getErrorMessage(obj) {
-    if ('message' in obj && obj.message) {
-        return obj.message;
+    /**
+     * Parse a response from the server. Assert that it has a {@link DataConnectStreamResponse.requestId | requestId}.
+     * @param data the message from the server to be parsed
+     * @returns the parsed message as a {@link DataConnectStreamResponse}
+     * @throws {DataConnectError} if parsing fails or message is malformed.
+     */
+    parseWebSocketData(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    data) {
+        const dataIsString = typeof data === 'string';
+        /** raw websocket message */
+        let webSocketMessage;
+        /** object containing data, errors, and extensions */
+        let result;
+        try {
+            if (dataIsString) {
+                webSocketMessage = JSON.parse(data);
+            }
+            else {
+                webSocketMessage = JSON.parse(this.decodeBinaryResponse(data));
+            }
+        }
+        catch (err) {
+            throw new DataConnectError(Code.OTHER, `Could not parse WebSocket message: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        if (typeof webSocketMessage !== 'object' || webSocketMessage === null) {
+            throw new DataConnectError(Code.OTHER, 'WebSocket message is not an object');
+        }
+        if (dataIsString) {
+            if (!('result' in webSocketMessage)) {
+                throw new DataConnectError(Code.OTHER, 'WebSocket message from emulator did not include result');
+            }
+            if (typeof webSocketMessage.result !== 'object' ||
+                webSocketMessage.result === null) {
+                throw new DataConnectError(Code.OTHER, 'WebSocket message result is not an object');
+            }
+            result = webSocketMessage.result;
+        }
+        else {
+            result = webSocketMessage;
+        }
+        if (!('requestId' in result)) {
+            throw new DataConnectError(Code.OTHER, 'WebSocket message did not include requestId');
+        }
+        return result;
     }
-    return JSON.stringify(obj);
 }
 
 const name = "@firebase/data-connect";
-const version = "0.5.0";
+const version = "0.6.0-20260409172004";
 
 /**
  * @license
@@ -1047,6 +2077,10 @@ class QueryManager {
         this.dc = dc;
         this.cache = cache;
         this.callbacks = new Map();
+        /**
+         * Map of serialized query keys to most recent Query Result. Used as a simple fallback cache
+         * for subsciptions if caching is not enabled.
+         */
         this.subscriptionCache = new Map();
         this.queue = [];
     }
@@ -1092,7 +2126,12 @@ class QueryManager {
         const unsubscribe = () => {
             if (this.callbacks.has(key)) {
                 const callbackList = this.callbacks.get(key);
-                this.callbacks.set(key, callbackList.filter(callback => callback !== subscription));
+                const newList = callbackList.filter(callback => callback !== subscription);
+                this.callbacks.set(key, newList);
+                if (newList.length === 0) {
+                    this.callbacks.delete(key);
+                    this.transport.invokeUnsubscribe(queryRef.name, queryRef.variables);
+                }
                 onCompleteCallback?.();
             }
         };
@@ -1107,12 +2146,18 @@ class QueryManager {
         const promise = this.preferCacheResults(queryRef, /*allowStale=*/ true);
         // We want to ignore the error and let subscriptions handle it
         promise.then(undefined, err => { });
-        if (!this.callbacks.has(key)) {
-            this.callbacks.set(key, []);
+        if (this.callbacks.has(key)) {
+            this.callbacks
+                .get(key)
+                .push(subscription);
+        }
+        else {
+            this.callbacks.set(key, [
+                subscription
+            ]);
+            // only invoke subscription if we don't already have an active subscription
+            this.transport.invokeSubscribe(this.makeSubscribeObserver(queryRef), queryRef.name, queryRef.variables);
         }
-        this.callbacks
-            .get(key)
-            .push(subscription);
         return unsubscribe;
     }
     async fetchServerResults(queryRef) {
@@ -1135,8 +2180,7 @@ class QueryManager {
                 extensions: getDataConnectExtensionsWithoutMaxAge(originalExtensions),
                 toJSON: getRefSerializer(queryRef, result.data, SOURCE_SERVER, fetchTime)
             };
-            let updatedKeys = [];
-            updatedKeys = await this.updateCache(queryResult, originalExtensions?.dataConnect);
+            const updatedKeys = await this.updateCache(queryResult, originalExtensions?.dataConnect);
             this.publishDataToSubscribers(key, queryResult);
             if (this.cache) {
                 await this.publishCacheResultsToSubscribers(updatedKeys, fetchTime);
@@ -1237,6 +2281,7 @@ class QueryManager {
         result.toJSON = getRefSerializer(result.ref, result.data, SOURCE_CACHE, result.fetchTime);
         return result;
     }
+    /** Call the registered onNext callbacks for the given key */
     publishDataToSubscribers(key, queryResult) {
         if (!this.callbacks.has(key)) {
             return;
@@ -1277,6 +2322,80 @@ class QueryManager {
     enableEmulator(host, port) {
         this.transport.useEmulator(host, port);
     }
+    /**
+     * Create a new {@link SubscribeObserver} for the given QueryRef. This will be passed to
+     * {@link DataConnectTransportInterface.invokeSubscribe | invokeSubscribe()} to notify the query
+     * layer of data update notifications or if the stream disconnected.
+     */
+    makeSubscribeObserver(queryRef) {
+        const key = encoderImpl({
+            name: queryRef.name,
+            variables: queryRef.variables,
+            refType: QUERY_STR
+        });
+        return {
+            onData: async (response) => {
+                await this.handleStreamNotification(key, response, queryRef);
+            },
+            onDisconnect: (code, reason) => {
+                this.handleStreamDisconnect(key, code, reason);
+            },
+            onError: error => {
+                this.publishErrorToSubscribers(key, error);
+            }
+        };
+    }
+    /**
+     * Handle a data update notification from the stream. Notify subscribers of results/errors, and
+     * update the cache.
+     */
+    async handleStreamNotification(key, response, queryRef) {
+        if (response.errors && response.errors.length > 0) {
+            const stringified = JSON.stringify(response.errors.map(e => {
+                if (e && typeof e === 'object') {
+                    return {
+                        message: e.message,
+                        code: e.code
+                    };
+                }
+                return e;
+            }));
+            const failureResponse = {
+                errors: response.errors,
+                data: response.data
+            };
+            const error = new DataConnectOperationError('DataConnect error received from subscribe notification: ' +
+                stringified, failureResponse);
+            this.publishErrorToSubscribers(key, error);
+            return;
+        }
+        const fetchTime = Date.now().toString();
+        const queryResult = {
+            ref: queryRef,
+            source: SOURCE_SERVER,
+            fetchTime,
+            data: response.data,
+            extensions: getDataConnectExtensionsWithoutMaxAge(response.extensions),
+            toJSON: getRefSerializer(queryRef, response.data, SOURCE_SERVER, fetchTime)
+        };
+        const updatedKeys = await this.updateCache(queryResult, response.extensions?.dataConnect);
+        this.publishDataToSubscribers(key, queryResult);
+        if (this.cache) {
+            await this.publishCacheResultsToSubscribers(updatedKeys, fetchTime);
+        }
+    }
+    /**
+     * Handle a disconnect from the stream. Unsubscribe all callbacks for the given key.
+     */
+    handleStreamDisconnect(key, code, reason) {
+        const error = new DataConnectError(code, reason);
+        this.publishErrorToSubscribers(key, error);
+        const callbacks = this.callbacks.get(key);
+        if (callbacks) {
+            [...callbacks].forEach(cb => cb.unsubscribe());
+        }
+        return;
+    }
 }
 function getMaxAgeFromExtensions(extensions) {
     if (!extensions) {
@@ -1300,7 +2419,7 @@ function getDataConnectExtensionsWithoutMaxAge(extensions) {
 
 /**
  * @license
- * Copyright 2024 Google LLC
+ * Copyright 2026 Google LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -1314,188 +2433,110 @@ function getDataConnectExtensionsWithoutMaxAge(extensions) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const PROD_HOST = 'firebasedataconnect.googleapis.com';
-function urlBuilder(projectConfig, transportOptions) {
-    const { connector, location, projectId: project, service } = projectConfig;
-    const { host, sslEnabled, port } = transportOptions;
-    const protocol = sslEnabled ? 'https' : 'http';
-    const realHost = host || PROD_HOST;
-    let baseUrl = `${protocol}://${realHost}`;
-    if (typeof port === 'number') {
-        baseUrl += `:${port}`;
-    }
-    else if (typeof port !== 'undefined') {
-        logError('Port type is of an invalid type');
-        throw new DataConnectError(Code.INVALID_ARGUMENT, 'Incorrect type for port passed in!');
-    }
-    return `${baseUrl}/v1/projects/${project}/locations/${location}/services/${service}/connectors/${connector}`;
-}
-function addToken(url, apiKey) {
-    if (!apiKey) {
-        return url;
-    }
-    const newUrl = new URL(url);
-    newUrl.searchParams.append('key', apiKey);
-    return newUrl.toString();
-}
-
 /**
- * @license
- * Copyright 2024 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * Entry point for the transport layer. Manages routing between transport implementations.
+ * @internal
  */
-class RESTTransport {
-    constructor(options, apiKey, appId, authProvider, appCheckProvider, transportOptions, _isUsingGen = false, _callerSdkType = CallerSdkTypeEnum.Base) {
+class DataConnectTransportManager {
+    constructor(options, apiKey, appId, authProvider, appCheckProvider, transportOptions, _isUsingGen = false, _callerSdkType) {
+        this.options = options;
         this.apiKey = apiKey;
         this.appId = appId;
         this.authProvider = authProvider;
         this.appCheckProvider = appCheckProvider;
+        this.transportOptions = transportOptions;
         this._isUsingGen = _isUsingGen;
         this._callerSdkType = _callerSdkType;
-        this._host = '';
-        this._location = 'l';
-        this._connectorName = '';
-        this._secure = true;
-        this._project = 'p';
-        this._accessToken = null;
-        this._appCheckToken = null;
-        this._lastToken = null;
-        this._isUsingEmulator = false;
-        // TODO(mtewani): Update U to include shape of body defined in line 13.
-        this.invokeQuery = (queryName, body) => {
-            const abortController = new AbortController();
-            // TODO(mtewani): Update to proper value
-            const withAuth = this.withRetry(() => dcFetch(addToken(`${this.endpointUrl}:executeQuery`, this.apiKey), {
-                name: `projects/${this._project}/locations/${this._location}/services/${this._serviceName}/connectors/${this._connectorName}`,
-                operationName: queryName,
-                variables: body
-            }, abortController, this.appId, this._accessToken, this._appCheckToken, this._isUsingGen, this._callerSdkType, this._isUsingEmulator));
-            return withAuth;
-        };
-        this.invokeMutation = (mutationName, body) => {
-            const abortController = new AbortController();
-            const taskResult = this.withRetry(() => {
-                return dcFetch(addToken(`${this.endpointUrl}:executeMutation`, this.apiKey), {
-                    name: `projects/${this._project}/locations/${this._location}/services/${this._serviceName}/connectors/${this._connectorName}`,
-                    operationName: mutationName,
-                    variables: body
-                }, abortController, this.appId, this._accessToken, this._appCheckToken, this._isUsingGen, this._callerSdkType, this._isUsingEmulator);
-            });
-            return taskResult;
-        };
-        if (transportOptions) {
-            if (typeof transportOptions.port === 'number') {
-                this._port = transportOptions.port;
-            }
-            if (typeof transportOptions.sslEnabled !== 'undefined') {
-                this._secure = transportOptions.sslEnabled;
+        this.isUsingEmulator = false;
+        this.restTransport = new RESTTransport(options, apiKey, appId, authProvider, appCheckProvider, transportOptions, _isUsingGen, _callerSdkType);
+    }
+    /**
+     * Initializes the stream transport if it hasn't been already.
+     */
+    initStreamTransport() {
+        if (!this.streamTransport) {
+            this.streamTransport = new WebSocketTransport(this.options, this.apiKey, this.appId, this.authProvider, this.appCheckProvider, this.transportOptions, this._isUsingGen, this._callerSdkType);
+            if (this.isUsingEmulator && this.transportOptions) {
+                this.streamTransport.useEmulator(this.transportOptions.host, this.transportOptions.port, this.transportOptions.sslEnabled);
             }
-            this._host = transportOptions.host;
-        }
-        const { location, projectId: project, connector, service } = options;
-        if (location) {
-            this._location = location;
-        }
-        if (project) {
-            this._project = project;
-        }
-        this._serviceName = service;
-        if (!connector) {
-            throw new DataConnectError(Code.INVALID_ARGUMENT, 'Connector Name required!');
+            this.streamTransport.onGracefulStreamClose = () => {
+                this.streamTransport = undefined;
+            };
         }
-        this._connectorName = connector;
-        this.authProvider?.addTokenChangeListener(token => {
-            logDebug(`New Token Available: ${token}`);
-            this._accessToken = token;
-        });
-        this.appCheckProvider?.addTokenChangeListener(result => {
-            const { token } = result;
-            logDebug(`New App Check Token Available: ${token}`);
-            this._appCheckToken = token;
-        });
+        return this.streamTransport;
     }
-    get endpointUrl() {
-        return urlBuilder({
-            connector: this._connectorName,
-            location: this._location,
-            projectId: this._project,
-            service: this._serviceName
-        }, { host: this._host, sslEnabled: this._secure, port: this._port });
+    /**
+     * Returns true if the stream is in a healthy, ready connection state and has active subscriptions.
+     */
+    executeShouldUseStream() {
+        return (!!this.streamTransport &&
+            !this.streamTransport.isPendingClose &&
+            this.streamTransport.streamIsReady &&
+            this.streamTransport.hasActiveSubscriptions &&
+            !this.streamTransport.isUnableToConnect);
     }
-    useEmulator(host, port, isSecure) {
-        this._host = host;
-        this._isUsingEmulator = true;
-        if (typeof port === 'number') {
-            this._port = port;
-        }
-        if (typeof isSecure !== 'undefined') {
-            this._secure = isSecure;
+    /**
+     * Prefer to use Streaming Transport connection when one is available.
+     * @inheritdoc
+     */
+    invokeQuery(queryName, body) {
+        if (this.executeShouldUseStream()) {
+            return this.streamTransport.invokeQuery(queryName, body).catch(err => {
+                if (this.executeShouldUseStream()) {
+                    throw err;
+                }
+                return this.restTransport.invokeQuery(queryName, body);
+            });
         }
+        return this.restTransport.invokeQuery(queryName, body);
     }
-    onTokenChanged(newToken) {
-        this._accessToken = newToken;
-    }
-    async getWithAuth(forceToken = false) {
-        let starterPromise = new Promise(resolve => resolve(this._accessToken));
-        if (this.appCheckProvider) {
-            const appCheckToken = await this.appCheckProvider.getToken();
-            if (appCheckToken) {
-                this._appCheckToken = appCheckToken.token;
-            }
-        }
-        if (this.authProvider) {
-            starterPromise = this.authProvider
-                .getToken(/*forceToken=*/ forceToken)
-                .then(data => {
-                if (!data) {
-                    return null;
+    /**
+     * Prefer to use Streaming Transport connection when one is available.
+     * @inheritdoc
+     */
+    invokeMutation(queryName, body) {
+        if (this.executeShouldUseStream()) {
+            return this.streamTransport.invokeMutation(queryName, body).catch(err => {
+                if (this.executeShouldUseStream()) {
+                    throw err;
                 }
-                this._accessToken = data.accessToken;
-                return this._accessToken;
+                return this.restTransport.invokeMutation(queryName, body);
             });
         }
-        else {
-            starterPromise = new Promise(resolve => resolve(''));
+        return this.restTransport.invokeMutation(queryName, body);
+    }
+    invokeSubscribe(observer, queryName, body) {
+        const streamTransport = this.initStreamTransport();
+        if (streamTransport.isUnableToConnect) {
+            throw new DataConnectError(Code.OTHER, 'Unable to connect streaming connection to server. Subscriptions are unavailable.');
         }
-        return starterPromise;
+        streamTransport.invokeSubscribe(observer, queryName, body);
     }
-    _setLastToken(lastToken) {
-        this._lastToken = lastToken;
+    invokeUnsubscribe(queryName, body) {
+        if (this.streamTransport) {
+            this.streamTransport.invokeUnsubscribe(queryName, body);
+        }
     }
-    withRetry(promiseFactory, retry = false) {
-        let isNewToken = false;
-        return this.getWithAuth(retry)
-            .then(res => {
-            isNewToken = this._lastToken !== res;
-            this._lastToken = res;
-            return res;
-        })
-            .then(promiseFactory)
-            .catch(err => {
-            // Only retry if the result is unauthorized and the last token isn't the same as the new one.
-            if ('code' in err &&
-                err.code === Code.UNAUTHORIZED &&
-                !retry &&
-                isNewToken) {
-                logDebug('Retrying due to unauthorized');
-                return this.withRetry(promiseFactory, true);
-            }
-            throw err;
-        });
+    useEmulator(host, port, sslEnabled) {
+        this.isUsingEmulator = true;
+        this.transportOptions = { host, port, sslEnabled };
+        this.restTransport.useEmulator(host, port, sslEnabled);
+        if (this.streamTransport) {
+            this.streamTransport.useEmulator(host, port, sslEnabled);
+        }
+    }
+    onAuthTokenChanged(token) {
+        this.restTransport.onAuthTokenChanged(token);
+        if (this.streamTransport) {
+            this.streamTransport.onAuthTokenChanged(token);
+        }
     }
     _setCallerSdkType(callerSdkType) {
         this._callerSdkType = callerSdkType;
+        this.restTransport._setCallerSdkType(callerSdkType);
+        if (this.streamTransport) {
+            this.streamTransport._setCallerSdkType(callerSdkType);
+        }
     }
 }
 
@@ -1661,8 +2702,8 @@ class DataConnect {
             return;
         }
         if (this._transportClass === undefined) {
-            logDebug('transportClass not provided. Defaulting to RESTTransport.');
-            this._transportClass = RESTTransport;
+            logDebug('transportClass not provided. Defaulting to DataConnectTransportManager.');
+            this._transportClass = DataConnectTransportManager;
         }
         this._authTokenProvider = new FirebaseAuthProvider(this.app.name, this.app.options, this._authProvider);
         const connectorConfig = {
@@ -2105,8 +3146,15 @@ function subscribe(queryRefOrSerializedResult, observerOrOnNext, onError, onComp
  * limitations under the License.
  */
 initializeFetch(fetch);
+if (typeof WebSocket !== 'undefined') {
+    initializeWebSocket(WebSocket);
+}
+else {
+    console.warn('WebSocket is not available in this environment. Use a polyfill or upgrade your Node version to one that supports WebSockets.');
+}
 registerDataConnect('node');
 
+exports.AbstractDataConnectTransport = AbstractDataConnectTransport;
 exports.CallerSdkTypeEnum = CallerSdkTypeEnum;
 exports.Code = Code;
 exports.DataConnect = DataConnect;
@@ -2124,6 +3172,7 @@ exports.connectDataConnectEmulator = connectDataConnectEmulator;
 exports.executeMutation = executeMutation;
 exports.executeQuery = executeQuery;
 exports.getDataConnect = getDataConnect;
+exports.getGoogApiClientValue = getGoogApiClientValue$1;
 exports.makeMemoryCacheProvider = makeMemoryCacheProvider;
 exports.mutationRef = mutationRef;
 exports.parseOptions = parseOptions;