@firebase/data-connect 0.5.0 → 0.6.0-20260408221811

package/dist/src/network/stream/streamTransport.d.ts

@@ -0,0 +1,241 @@
+/**
+ * @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.
+ */
+import { AbstractDataConnectTransport, DataConnectResponse, SubscribeObserver } from '../transport';
+import { DataConnectStreamRequest } from './wire';
+/**
+ * The base class for all {@link DataConnectStreamTransport | Stream Transport} implementations.
+ * Handles management of logical streams (requests), authentication, data routing to query layer, etc.
+ * @internal
+ */
+export declare abstract class AbstractDataConnectStreamTransport extends AbstractDataConnectTransport {
+    /** Optional callback invoked when the stream closes gracefully. */
+    onGracefulStreamClose?: () => void;
+    /** True if the physical stream connection is fully open and ready to transmit data. */
+    abstract get streamIsReady(): boolean;
+    /** Is the stream currently waiting to close connection? */
+    get isPendingClose(): boolean;
+    private pendingClose;
+    /** True if the transport is unable to connect to the server */
+    isUnableToConnect: boolean;
+    /** True if there are active subscriptions on the stream */
+    get hasActiveSubscriptions(): boolean;
+    /** True if there are active execute or mutation requests on the stream */
+    get hasActiveExecuteRequests(): boolean;
+    /**
+     * Open a physical connection to the server.
+     * @returns a promise which resolves when the connection is ready, or rejects if it fails to open.
+     */
+    protected abstract openConnection(): Promise<void>;
+    /**
+     * Close the physical connection with the server. Handles no cleanup - simply closes the
+     * implementation-specific connection.
+     * @returns a promise which resolves when the connection is closed, or rejects if it fails to close.
+     * On failure to close, the connection is still considered closed.
+     */
+    protected abstract closeConnection(): Promise<void>;
+    /**
+     * Queue a message to be sent over the stream.
+     * @param requestBody The body of the message to be sent.
+     * @throws DataConnectError if sending fails.
+     */
+    protected abstract sendMessage<Variables>(requestBody: DataConnectStreamRequest<Variables>): Promise<void>;
+    /**
+     * Ensures that that there is an open connection. If there is none, it initiates a new one.
+     * If a connection attempt is already in progress, it returns the existing connection promise.
+     * @returns A promise that resolves when the stream is open and ready.
+     */
+    protected abstract ensureConnection(): Promise<void>;
+    /** The request ID of the next message to be sent. Monotonically increasing sequence number. */
+    private requestNumber;
+    /**
+     * Generates and returns the next request ID.
+     */
+    private nextRequestId;
+    /**
+     * Map of query/variables to their active execute/resume request bodies.
+     */
+    private activeQueryExecuteRequests;
+    /**
+     * Map of mutation/variables to their active execute request bodies.
+     */
+    private activeMutationExecuteRequests;
+    /**
+     * Map of query/variables to their active subscribe request bodies.
+     */
+    private activeSubscribeRequests;
+    /**
+     * Map of active execution RequestIds and their corresponding Promises and resolvers.
+     */
+    private executeRequestPromises;
+    /**
+     * Map of active subscription RequestIds and their corresponding observers.
+     */
+    private subscribeObservers;
+    /** current close timeout from setTimeout(), if any */
+    private closeTimeout;
+    /** has the close timeout finished? */
+    private closeTimeoutFinished;
+    /** current auth uid. used to detect if a different user logs in */
+    private authUid;
+    /**
+     * 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.
+     */
+    private trackQueryExecuteRequest;
+    /**
+     * 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.
+     */
+    private trackMutationExecuteRequest;
+    /**
+     * Tracks a subscribe request, storing the request body and the notification observer.
+     * @remarks
+     * This method is synchronous.
+     */
+    private trackSubscribeRequest;
+    /**
+     * Cleans up the query execute request tracking data structures, deleting the tracked request and
+     * it's associated promise.
+     */
+    private cleanupQueryExecuteRequest;
+    /**
+     * Cleans up the mutation execute request tracking data structures, deleting the tracked request and
+     * it's associated promise.
+     */
+    private cleanupMutationExecuteRequest;
+    /**
+     * Cleans up the subscribe request tracking data structures, deleting the tracked request and
+     * it's associated promise.
+     */
+    private cleanupSubscribeRequest;
+    /**
+     * Tracks if the next message to be sent is the first message of the stream.
+     */
+    private isFirstStreamMessage;
+    /**
+     * Tracks the last auth token sent to the server.
+     * Used to detect if the token has changed and needs to be resent.
+     */
+    private lastSentAuthToken;
+    /**
+     * 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.
+     */
+    private get shouldIncludeAuth();
+    /**
+     * Called by the concrete transport implementation when the physical connection is ready.
+     */
+    protected onConnectionReady(): void;
+    /**
+     * Attempt to close the connection. Will only close if there are no active requests preventing it
+     * from doing so.
+     */
+    private attemptClose;
+    /**
+     * 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.
+     */
+    private prepareToCloseGracefully;
+    /**
+     * Cancel closing the connection.
+     */
+    private cancelClose;
+    /**
+     * 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.
+     */
+    private rejectAllActiveRequests;
+    /**
+     * Called by concrete implementations when the stream is successfully closed, gracefully or otherwise.
+     */
+    protected onStreamClose(code: number, reason: string): void;
+    /**
+     * 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
+     */
+    protected prepareMessage<Variables, StreamBody extends DataConnectStreamRequest<Variables>>(requestBody: StreamBody): StreamBody;
+    /**
+     * 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.
+     */
+    private sendRequestMessage;
+    /**
+     * Helper to generate a consistent string key for the tracking maps.
+     */
+    private getMapKey;
+    /**
+     * Recursively sorts the keys of an object.
+     */
+    private sortObjectKeys;
+    /**
+     * @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<Data, Variables>(queryName: string, variables?: Variables): Promise<DataConnectResponse<Data>>;
+    /**
+     * @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<Data, Variables>(mutationName: string, variables?: Variables): Promise<DataConnectResponse<Data>>;
+    /**
+     * @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<Data, Variables>(observer: SubscribeObserver<Data>, queryName: string, variables: Variables): void;
+    /**
+     * @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<Variables>(queryName: string, variables: Variables): void;
+    onAuthTokenChanged(newToken: string | null): void;
+    /**
+     * 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.
+     */
+    protected handleResponse<Data>(requestId: string, response: DataConnectResponse<Data>): Promise<void>;
+}

package/dist/src/network/stream/websocket.d.ts

@@ -0,0 +1,90 @@
+/**
+ * @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.
+ */
+import { DataConnectOptions, TransportOptions } from '../../api/DataConnect';
+import { AppCheckTokenProvider } from '../../core/AppCheckTokenProvider';
+import { AuthTokenProvider } from '../../core/FirebaseAuthProvider';
+import { CallerSdkType } from '../transport';
+import { AbstractDataConnectStreamTransport } from './streamTransport';
+import { DataConnectStreamRequest } from './wire';
+/**
+ * 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
+ */
+export declare function initializeWebSocket(webSocketImpl: typeof WebSocket): void;
+/**
+ * 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
+ */
+export declare 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
+ */
+export declare class WebSocketTransport extends AbstractDataConnectStreamTransport {
+    protected apiKey?: string | undefined;
+    protected appId?: (string | null) | undefined;
+    protected authProvider?: AuthTokenProvider | undefined;
+    protected appCheckProvider?: AppCheckTokenProvider | undefined;
+    protected _isUsingGen: boolean;
+    protected _callerSdkType: CallerSdkType;
+    get endpointUrl(): string;
+    /** Decodes binary WebSocket responses to strings */
+    private decoder;
+    /**
+     * Decodes a WebSocket response from a Uint8Array to a JSON object.
+     * Emulator does not send messages as Uint8Arrays, but prod does.
+     */
+    private decodeBinaryResponse;
+    /** The current connection to the server. Undefined if disconnected. */
+    private connection;
+    get streamIsReady(): boolean;
+    /**
+     * 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.
+     */
+    private connectionAttempt;
+    constructor(options: DataConnectOptions, apiKey?: string | undefined, appId?: (string | null) | undefined, authProvider?: AuthTokenProvider | undefined, appCheckProvider?: AppCheckTokenProvider | undefined, transportOptions?: TransportOptions | undefined, _isUsingGen?: boolean, _callerSdkType?: CallerSdkType);
+    protected ensureConnection(): Promise<void>;
+    protected openConnection(): Promise<void>;
+    protected closeConnection(code?: number, reason?: string): Promise<void>;
+    /**
+     * Handle a disconnection from the server. Initiates graceful clean up and reconnection attempts.
+     * @param ev the {@link CloseEvent} that closed the WebSocket.
+     */
+    private handleWebsocketDisconnect;
+    /**
+     * Handle an error that occurred on the WebSocket. Close the connection and reject all active requests.
+     */
+    private handleError;
+    protected sendMessage<Variables>(requestBody: DataConnectStreamRequest<Variables>): Promise<void>;
+    /**
+     * Handles incoming WebSocket messages.
+     * @param ev The {@link MessageEvent} from the WebSocket.
+     */
+    private handleWebSocketMessage;
+    /**
+     * 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.
+     */
+    private parseWebSocketData;
+}

package/dist/src/network/stream/wire.d.ts

@@ -0,0 +1,138 @@
+/**
+ * @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.
+ */
+import { Extensions } from '../index';
+/**
+ * Shape of response from the server.
+ * @internal
+ */
+export interface DataConnectStreamResponse<Data> {
+    requestId: string;
+    data: Data;
+    extensions: Extensions;
+    dataEtag: string;
+    errors: Error[];
+    cancelled: boolean;
+}
+/**
+ * Base interface for stream request payloads sent over the stream to the server.
+ * @internal
+ */
+export interface StreamRequest {
+    /** monotonically increasing request ID */
+    requestId: string;
+    /** connectorResourcePath - only required on initial connection */
+    name?: string;
+    /** optional headers for this request, for authentication + telemetry */
+    headers?: StreamRequestHeaders;
+    /** received from server on previous response, included to optimize bandwidth */
+    dataEtag?: string;
+}
+/**
+ * Optional headers for a stream request, for authentication + telemetry
+ * @internal
+ */
+export interface StreamRequestHeaders {
+    /** used to initially authenticate or re-authenticate */
+    authToken?: string;
+    /** used to initially authenticate or re-authenticate */
+    appCheckToken?: string;
+    /** SDK telemetry header */
+    'X-Goog-Api-Client'?: string;
+    /** firebase appid */
+    'x-firebase-gmpid'?: string;
+}
+/**
+ * Fields for an execute request payload.
+ * @internal
+ */
+interface ExecuteRequestKind<Variables> {
+    operationName: string;
+    variables?: Variables;
+}
+/**
+ * Fields for a subscribe request payload.
+ * @internal
+ */
+interface SubscribeRequestKind<Variables> {
+    operationName: string;
+    variables?: Variables;
+}
+/**
+ * Fields for a resume request payload.
+ * @internal
+ */
+interface ResumeRequestKind {
+}
+/**
+ * Fields for a cancel request payload.
+ * @internal
+ */
+interface CancelRequestKind {
+}
+/**
+ * Fields for a subscribe request payload.
+ * @internal
+ */
+export interface SubscribeStreamRequest<Variables> extends StreamRequest {
+    subscribe: SubscribeRequestKind<Variables>;
+    execute?: never;
+    resume?: never;
+    cancel?: never;
+}
+/**
+ * Fields for an execute request payload.
+ * @internal
+ */
+export interface ExecuteStreamRequest<Variables> extends StreamRequest {
+    execute: ExecuteRequestKind<Variables>;
+    subscribe?: never;
+    resume?: never;
+    cancel?: never;
+}
+/**
+ * Fields for a resume (subscribe) request payload.
+ * @internal
+ */
+export interface ResumeStreamRequest extends StreamRequest {
+    resume: ResumeRequestKind;
+    subscribe?: never;
+    execute?: never;
+    cancel?: never;
+}
+/**
+ * Fields for a cancel (unsubscribe) request payload.
+ * @internal
+ */
+export interface CancelStreamRequest extends StreamRequest {
+    cancel: CancelRequestKind;
+    subscribe?: never;
+    execute?: never;
+    resume?: never;
+}
+/**
+ * Shape of the request body to be sent over the stream to the server.
+ * @internal
+ */
+export type DataConnectStreamRequest<Variables> = ExecuteStreamRequest<Variables> | SubscribeStreamRequest<Variables> | ResumeStreamRequest | CancelStreamRequest;
+/**
+ * Determines whether the provided request to execute a query is an execution request or a resume
+ * request
+ * @returns true if the requestBody is a resume request
+ * @internal
+ */
+export declare function queryRequestIsResume<Variables>(requestBody: ExecuteStreamRequest<Variables> | ResumeStreamRequest): requestBody is ResumeStreamRequest;
+export {};

package/dist/src/network/transport.d.ts

@@ -0,0 +1,179 @@
+/**
+ * @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.
+ */
+import { DataConnectOptions, TransportOptions } from '../api/DataConnect';
+import { AppCheckTokenProvider } from '../core/AppCheckTokenProvider';
+import { AuthTokenProvider } from '../core/FirebaseAuthProvider';
+/**
+ * enum representing different flavors of the SDK used by developers
+ * use the CallerSdkType for type-checking, and the CallerSdkTypeEnum for value-checking/assigning
+ */
+export type CallerSdkType = 'Base' | 'Generated' | 'TanstackReactCore' | 'GeneratedReact' | 'TanstackAngularCore' | 'GeneratedAngular';
+export declare const CallerSdkTypeEnum: {
+    readonly Base: "Base";
+    readonly Generated: "Generated";
+    readonly TanstackReactCore: "TanstackReactCore";
+    readonly GeneratedReact: "GeneratedReact";
+    readonly TanstackAngularCore: "TanstackAngularCore";
+    readonly GeneratedAngular: "GeneratedAngular";
+};
+export interface DataConnectEntityArray {
+    entityIds: string[];
+}
+export interface DataConnectSingleEntity {
+    entityId: string;
+}
+export type DataConnectExtension = {
+    path: Array<string | number>;
+} & (DataConnectEntityArray | DataConnectSingleEntity);
+/** @internal */
+export interface DataConnectMaxAge {
+    maxAge: string;
+}
+/** @internal */
+export type DataConnectExtensionWithMaxAge = {
+    path: Array<string | number>;
+} & (DataConnectEntityArray | DataConnectSingleEntity | DataConnectMaxAge);
+export interface Extensions {
+    dataConnect?: DataConnectExtension[];
+}
+/** @internal */
+export interface ExtensionsWithMaxAge {
+    dataConnect?: DataConnectExtensionWithMaxAge[];
+}
+/** @internal */
+export interface DataConnectResponse<T> {
+    data: T;
+    errors: Error[];
+    extensions: Extensions;
+}
+/** @internal */
+export interface DataConnectResponseWithMaxAge<T> {
+    data: T;
+    errors: Error[];
+    extensions: ExtensionsWithMaxAge;
+}
+/**
+ * Observer defined by the Query Layer for receiving notifications from the Transport Layer.
+ * @internal
+ */
+export interface SubscribeObserver<Data> {
+    onData(response: DataConnectResponse<Data>): Promise<void> | void;
+    onDisconnect(code: string, reason: string): void;
+    onError(error: Error): void;
+}
+/**
+ * Interface defining the external API of the transport layer.
+ * @internal
+ */
+export interface DataConnectTransportInterface {
+    /**
+     * Invoke a query execution request.
+     * @param queryName The name of the query to execute.
+     * @param body The variables associated with the query.
+     * @returns A promise resolving to the DataConnectResponse.
+     */
+    invokeQuery<Data, Variables>(queryName: string, body?: Variables): Promise<DataConnectResponseWithMaxAge<Data>>;
+    /**
+     * Invoke a mutation execution request.
+     * @param queryName The name of the mutation to execute.
+     * @param body The variables associated with the mutation.
+     * @returns A promise resolving to the DataConnectResponse.
+     */
+    invokeMutation<Data, Variables>(queryName: string, body?: Variables): Promise<DataConnectResponse<Data>>;
+    /**
+     * Subscribes to a query to receive push notifications of updates.
+     * @param observer the observer passed to the transport layer to notify the query layer of events.
+     * @param queryName The name of the query to subscribe to.
+     * @param body The variables associated with the subscription.
+     */
+    invokeSubscribe<Data, Variables>(observer: SubscribeObserver<Data>, queryName: string, body?: Variables): void;
+    /**
+     * Unsubscribes from an active subscription.
+     * @param queryName The name of the query to unsubscribe from.
+     * @param body The variables associated with the subscription.
+     */
+    invokeUnsubscribe<Variables>(queryName: string, body?: Variables): void;
+    /**
+     * Configures the transport to use a local Data Connect emulator.
+     * @param host The host address of the emulator (e.g., '127.0.0.1').
+     * @param port The port number the emulator is listening on.
+     * @param sslEnabled Whether to use SSL (HTTPS/WSS) for the emulator connection.
+     */
+    useEmulator(host: string, port?: number, sslEnabled?: boolean): void;
+    /**
+     * Callback invoked when the Firebase Auth token is refreshed or changed. Note that this callback
+     * is called immediately asynchronously when the Auth Provider is initialized to provide
+     * the initial auth state.
+     * @param token The new access token or null if signed out.
+     */
+    onAuthTokenChanged: (token: string | null) => void;
+    /**
+     * Internal method to set the SDK type for metrics and logging purposes.
+     * @param callerSdkType The type of SDK making the call (e.g., generated vs base).
+     */
+    _setCallerSdkType(callerSdkType: CallerSdkType): void;
+}
+/**
+ * Type signature of a transport class constructor.
+ * @internal
+ */
+export type TransportClass = new (options: DataConnectOptions, apiKey?: string, appId?: string, authProvider?: AuthTokenProvider, appCheckProvider?: AppCheckTokenProvider, transportOptions?: TransportOptions, _isUsingGen?: boolean, _callerSdkType?: CallerSdkType) => DataConnectTransportInterface;
+/**
+ * Constructs the value for the X-Goog-Api-Client header
+ * @internal
+ */
+export declare function getGoogApiClientValue(isUsingGen: boolean, callerSdkType: CallerSdkType): string;
+/**
+ * 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
+ */
+export declare abstract class AbstractDataConnectTransport implements DataConnectTransportInterface {
+    protected apiKey?: string | undefined;
+    protected appId?: (string | null) | undefined;
+    protected authProvider?: AuthTokenProvider | undefined;
+    protected appCheckProvider?: AppCheckTokenProvider | undefined;
+    protected _isUsingGen: boolean;
+    protected _callerSdkType: CallerSdkType;
+    protected _host: string;
+    protected _port: number | undefined;
+    protected _location: string;
+    protected _connectorName: string;
+    /** The resource path for requests from this Data Connect instance. */
+    protected _connectorResourcePath: string;
+    protected _secure: boolean;
+    protected _project: string;
+    protected _serviceName: string;
+    protected _authToken: string | null;
+    protected _appCheckToken: string | null | undefined;
+    protected _lastToken: string | null;
+    protected _isUsingEmulator: boolean;
+    constructor(options: DataConnectOptions, apiKey?: string | undefined, appId?: (string | null) | undefined, authProvider?: AuthTokenProvider | undefined, appCheckProvider?: AppCheckTokenProvider | undefined, transportOptions?: TransportOptions | undefined, _isUsingGen?: boolean, _callerSdkType?: CallerSdkType);
+    /** Get the endpoint URL this transport should use to communicate with the backend. */
+    abstract get endpointUrl(): string;
+    useEmulator(host: string, port?: number, isSecure?: boolean): void;
+    getWithAuth(forceToken?: boolean): Promise<string | null>;
+    withRetry<T>(promiseFactory: () => Promise<DataConnectResponse<T>>, retry?: boolean): Promise<DataConnectResponse<T>>;
+    _setLastToken(lastToken: string | null): void;
+    abstract invokeQuery<Data, Variables>(queryName: string, body?: Variables): Promise<DataConnectResponseWithMaxAge<Data>>;
+    abstract invokeMutation<Data, Variables>(queryName: string, body?: Variables): Promise<DataConnectResponse<Data>>;
+    abstract invokeSubscribe<Data, Variables>(observer: SubscribeObserver<Data>, queryName: string, body?: Variables): void;
+    abstract invokeUnsubscribe<Variables>(queryName: string, variables: Variables): void;
+    abstract onAuthTokenChanged(newToken: string | null): void;
+    _setCallerSdkType(callerSdkType: CallerSdkType): void;
+}

package/dist/src/util/url.d.ts

@@ -16,5 +16,7 @@
  */
 import { DataConnectOptions, TransportOptions } from '../api/DataConnect';
 export declare const PROD_HOST = "firebasedataconnect.googleapis.com";
-export declare function urlBuilder(projectConfig: DataConnectOptions, transportOptions: TransportOptions): string;
+export declare const WEBSOCKET_PATH = "ws/google.firebase.dataconnect.v1.ConnectorStreamService";
+export declare function restUrlBuilder(projectConfig: DataConnectOptions, transportOptions: TransportOptions): string;
+export declare function websocketUrlBuilder(projectConfig: DataConnectOptions, transportOptions: TransportOptions): string;
 export declare function addToken(url: string, apiKey?: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@firebase/data-connect",
-  "version": "0.5.0",
+  "version": "0.6.0-20260408221811",
   "description": "",
   "author": "Firebase <firebase-support@google.com> (https://firebase.google.com/)",
   "main": "dist/index.node.cjs.js",