@aws-amplify/api-graphql 0.0.0-unstable-1ca644b-20260128091132

package/src/types/index.ts

@@ -0,0 +1,524 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { AmplifyClassV6, ResourcesConfig } from '@aws-amplify/core';
+import {
+	BaseClient,
+	ClientExtensions,
+	ClientExtensionsSSRCookies,
+	ClientExtensionsSSRRequest,
+	ClientInternals,
+	CustomHeaders,
+	ModelSortDirection,
+} from '@aws-amplify/data-schema/runtime';
+import { DocumentNode, GraphQLError, Source } from 'graphql';
+import { Observable } from 'rxjs';
+import {
+	DocumentType,
+	GraphQLAuthMode,
+} from '@aws-amplify/core/internals/utils';
+import { AmplifyServer } from '@aws-amplify/core/internals/adapter-core';
+
+import { CommonPublicClientOptions } from '../internals/types';
+
+export { OperationTypeNode } from 'graphql';
+
+export { CONTROL_MSG, ConnectionState } from './PubSub';
+
+export { SelectionSet } from '@aws-amplify/data-schema/runtime';
+
+export type { CommonPublicClientOptions };
+
+/**
+ * Loose/Unknown options for raw GraphQLAPICategory `graphql()`.
+ */
+export interface GraphQLOptions {
+	query: string | DocumentNode;
+	endpoint?: string;
+	variables?: Record<string, DocumentType>;
+	authMode?: GraphQLAuthMode;
+	authToken?: string;
+	apiKey?: string;
+	/**
+	 * @deprecated This property should not be used
+	 */
+	userAgentSuffix?: string;
+}
+
+export interface GraphQLResult<T = object | null> {
+	data: T;
+	errors?: GraphQLError[];
+	extensions?: Record<string, any>;
+}
+
+// Opaque type used for determining the graphql query type
+declare const queryType: unique symbol;
+
+export type GraphQLQuery<T> = T & { readonly [queryType]: 'query' };
+export type GraphQLSubscription<T> = T & {
+	readonly [queryType]: 'subscription';
+};
+
+/**
+ * Accepts a code generated model type and returns a supertype that
+ * can accept return values from the relevant graphql operations.
+ *
+ * For example:
+ *
+ * ```typescript
+ * import { GraphQLReturnType } from 'aws-amplify/api';
+ * import { MyModel } from './API';
+ * import { getMyModel } from './graphql/queries';
+ *
+ * const [item, setItem] = useState<GraphQLReturnType<MyModel>>();
+ * setItem(await client.graphql({ query: getMyModel }).data.getMyModel!)
+ * ```
+ *
+ * Trying to assign the result of a `getMyModel` operation directly to a
+ * `MyModel` variables won't necessarily work, because normally-required related
+ * models might not be part of the selection set.
+ *
+ * This util simply makes related model properties optional recursively.
+ */
+export type GraphQLReturnType<T> =
+	T extends Record<string, unknown>
+		? {
+				[K in keyof T]?: GraphQLReturnType<T[K]>;
+			}
+		: T;
+
+/**
+ * Describes a paged list result from AppSync, which can either
+ * live at the top query or property (e.g., related model) level.
+ */
+interface PagedList<T, TYPENAME> {
+	__typename: TYPENAME;
+	nextToken?: string | null | undefined;
+	items: T[];
+}
+
+/**
+ * Recursively looks through a result type and removes nulls and
+ * and undefined from `PagedList` types.
+ *
+ * Although a graphql response might contain empty values in an
+ * array, this will only be the case when we also have errors,
+ * which will then be *thrown*.
+ */
+type WithListsFixed<T> =
+	T extends PagedList<infer IT, infer NAME>
+		? PagedList<Exclude<IT, null | undefined>, NAME>
+		: T extends Record<string, unknown>
+			? {
+					[K in keyof T]: WithListsFixed<T[K]>;
+				}
+			: T;
+
+/**
+ * Returns an updated response type to always return a value.
+ */
+type NeverEmpty<T> = {
+	[K in keyof T]-?: Exclude<WithListsFixed<T[K]>, undefined | null>;
+};
+
+/**
+ * Replaces all list result types in a query result with types to exclude
+ * nulls and undefined from list member unions.
+ *
+ * If empty members are present, there will also be errors present,
+ * and the response will instead be *thrown*.
+ */
+type FixedQueryResult<T> =
+	Exclude<T[keyof T], null | undefined> extends PagedList<any, any>
+		? {
+				[K in keyof T]-?: WithListsFixed<Exclude<T[K], null | undefined>>;
+			}
+		: T;
+
+/**
+ * The return value from a `graphql({query})` call when `query` is a subscription.
+ *
+ * ```ts
+ * //               |-- You are here
+ * //               v
+ * const subResult: GraphqlSubscriptionResult<T> = client.graphql({
+ * 	query: onCreateWidget
+ * });
+ *
+ * const sub = subResult.subscribe({
+ * 	//
+ * 	//            |-- You are here
+ * 	//            v
+ * 	next(message: GraphqlSubscriptionMessage<OnCreateWidgetSubscription>) {
+ * 		handle(message.value);  // <-- type OnCreateWidgetSubscription
+ * 	}
+ * })
+ * ```
+ */
+export type GraphqlSubscriptionResult<T> = Observable<
+	GraphqlSubscriptionMessage<T>
+>;
+
+/**
+ * The shape of messages passed to `next()` from a graphql subscription. E.g.,
+ *
+ * ```ts
+ * const sub = client.graphql({
+ * 	query: onCreateWidget,
+ * }).subscribe({
+ * 	//
+ * 	//            |-- You are here
+ * 	//            v
+ * 	next(message: GraphqlSubscriptionMessage<OnCreateWidgetSubscription>) {
+ * 		handle(message.value);  // <-- type OnCreateWidgetSubscription
+ * 	}
+ * })
+ * ```
+ */
+export interface GraphqlSubscriptionMessage<T> {
+	data: T;
+}
+
+export interface AWSAppSyncRealTimeProviderOptions {
+	appSyncGraphqlEndpoint?: string;
+	authenticationType?: GraphQLAuthMode;
+	query?: string;
+	variables?: Record<string, unknown>;
+	apiKey?: string;
+	region?: string;
+	libraryConfigHeaders?(): () => Promise<Record<string, unknown> | Headers>;
+	additionalHeaders?: CustomHeaders;
+}
+
+export interface AWSAppSyncRealTimeProvider {
+	subscribe(
+		options?: AWSAppSyncRealTimeProviderOptions,
+	): Observable<Record<string, unknown>>;
+}
+
+export enum GraphQLAuthError {
+	NO_API_KEY = 'No api-key configured',
+	NO_CURRENT_USER = 'No current user',
+	NO_CREDENTIALS = 'No credentials',
+	NO_FEDERATED_JWT = 'No federated jwt',
+	NO_AUTH_TOKEN = 'No auth token specified',
+}
+
+/**
+ * GraphQLSource or string, the type of the parameter for calling graphql.parse
+ * @see: https://graphql.org/graphql-js/language/#parse
+ */
+export type GraphQLOperation = Source | string;
+
+/**
+ * API V6 `graphql({options})` type that can leverage branded graphql `query`
+ * objects and fallback types.
+ */
+export type GraphQLOptionsV6<
+	FALLBACK_TYPES = unknown,
+	TYPED_GQL_STRING extends string = string,
+	Options extends CommonPublicClientOptions = object,
+> = Options['endpoint'] extends string
+	? Options['apiKey'] extends string
+		? {
+				query: TYPED_GQL_STRING | DocumentNode;
+				variables?: GraphQLVariablesV6<FALLBACK_TYPES, TYPED_GQL_STRING>;
+				authMode?: GraphQLAuthMode;
+				apiKey?: string;
+				authToken?: string;
+				/**
+				 * @deprecated This property should not be used
+				 */
+				userAgentSuffix?: string;
+			}
+		:
+				| {
+						query: TYPED_GQL_STRING | DocumentNode;
+						variables?: GraphQLVariablesV6<FALLBACK_TYPES, TYPED_GQL_STRING>;
+						authMode?: never;
+						apiKey?: never;
+						authToken?: string;
+						/**
+						 * @deprecated This property should not be used
+						 */
+						userAgentSuffix?: string;
+				  }
+				| {
+						query: TYPED_GQL_STRING | DocumentNode;
+						variables?: GraphQLVariablesV6<FALLBACK_TYPES, TYPED_GQL_STRING>;
+						authMode: 'apiKey';
+						apiKey: string;
+						authToken?: string;
+						/**
+						 * @deprecated This property should not be used
+						 */
+						userAgentSuffix?: string;
+				  }
+				| {
+						query: TYPED_GQL_STRING | DocumentNode;
+						variables?: GraphQLVariablesV6<FALLBACK_TYPES, TYPED_GQL_STRING>;
+						authMode: Exclude<GraphQLAuthMode, 'apiKey'>;
+						apiKey?: never;
+						authToken?: string;
+						/**
+						 * @deprecated This property should not be used
+						 */
+						userAgentSuffix?: string;
+				  }
+	: {
+			query: TYPED_GQL_STRING | DocumentNode;
+			variables?: GraphQLVariablesV6<FALLBACK_TYPES, TYPED_GQL_STRING>;
+			authMode?: GraphQLAuthMode;
+			apiKey?: string;
+			authToken?: string;
+			/**
+			 * @deprecated This property should not be used
+			 */
+			userAgentSuffix?: string;
+		};
+
+/**
+ * Result type for `graphql()` operations that don't include any specific
+ * type information. The result could be either a `Promise` or `Subscription`.
+ *
+ * Invoking code should either cast the result or use `?` and `!` operators to
+ * navigate the result objects.
+ */
+export type UnknownGraphQLResponse =
+	| Promise<GraphQLResult<any>>
+	| GraphqlSubscriptionResult<any>;
+
+/**
+ * The expected type for `variables` in a V6 `graphql()` operation with
+ * respect to the given `FALLBACK_TYPES` and `TYPED_GQL_STRING`.
+ */
+export type GraphQLVariablesV6<
+	FALLBACK_TYPES = unknown,
+	TYPED_GQL_STRING extends string = string,
+> =
+	TYPED_GQL_STRING extends GeneratedQuery<infer IN, any>
+		? IN
+		: TYPED_GQL_STRING extends GeneratedMutation<infer IN, any>
+			? IN
+			: TYPED_GQL_STRING extends GeneratedSubscription<infer IN, any>
+				? IN
+				: FALLBACK_TYPES extends GraphQLOperationType<infer IN, any>
+					? IN
+					: any;
+
+/**
+ * The expected return type with respect to the given `FALLBACK_TYPE`
+ * and `TYPED_GQL_STRING`.
+ */
+export type GraphQLResponseV6<
+	FALLBACK_TYPE = unknown,
+	TYPED_GQL_STRING extends string = string,
+> =
+	TYPED_GQL_STRING extends GeneratedQuery<infer _, infer QUERY_OUT>
+		? Promise<GraphQLResult<FixedQueryResult<QUERY_OUT>>>
+		: TYPED_GQL_STRING extends GeneratedMutation<infer _, infer MUTATION_OUT>
+			? Promise<GraphQLResult<NeverEmpty<MUTATION_OUT>>>
+			: TYPED_GQL_STRING extends GeneratedSubscription<infer _, infer SUB_OUT>
+				? GraphqlSubscriptionResult<NeverEmpty<SUB_OUT>>
+				: FALLBACK_TYPE extends GraphQLQuery<infer _>
+					? Promise<GraphQLResult<FALLBACK_TYPE>>
+					: FALLBACK_TYPE extends GraphQLSubscription<infer _>
+						? GraphqlSubscriptionResult<FALLBACK_TYPE>
+						: FALLBACK_TYPE extends GraphQLOperationType<
+									infer _,
+									infer CUSTOM_OUT
+							  >
+							? CUSTOM_OUT
+							: UnknownGraphQLResponse;
+
+/**
+ * The shape customers can use to provide `T` to `graphql<T>()` to specify both
+ * `IN` and `OUT` types (the type of `variables` and the return type, respectively).
+ *
+ * I.E.,
+ *
+ * ```ts
+ * type MyVariablesType = { ... };
+ * type MyResultType = { ... };
+ * type MyOperationType = { variables: MyVariablesType, result: MyResultType };
+ *
+ * const result: MyResultType = graphql<MyOperationType>("graphql string", {
+ * 	variables: {
+ * 		// MyVariablesType
+ * 	}
+ * })
+ * ```
+ */
+export interface GraphQLOperationType<
+	IN extends Record<string, DocumentType>,
+	OUT extends Record<string, DocumentType>,
+> {
+	variables: IN;
+	result: OUT;
+}
+
+/**
+ * Nominal type for branding generated graphql query operation strings with
+ * input and output types.
+ *
+ * E.g.,
+ *
+ * ```ts
+ * export const getWidget = `...` as GeneratedQuery<
+ * 	GetWidgetQueryVariables,
+ * 	GetWidgetQuery
+ * >;
+ * ```
+ *
+ * This allows `graphql()` to extract `InputType` and `OutputType` to correctly
+ * assign types to the `variables` and result objects.
+ */
+export type GeneratedQuery<InputType, OutputType> = string & {
+	__generatedQueryInput: InputType;
+	__generatedQueryOutput: OutputType;
+};
+
+/**
+ * Nominal type for branding generated graphql mutation operation strings with
+ * input and output types.
+ *
+ * E.g.,
+ *
+ * ```ts
+ * export const createWidget = `...` as GeneratedQuery<
+ * 	CreateWidgetMutationVariables,
+ * 	CreateWidgetMutation
+ * >;
+ * ```
+ *
+ * This allows `graphql()` to extract `InputType` and `OutputType` to correctly
+ * assign types to the `variables` and result objects.
+ */
+export type GeneratedMutation<InputType, OutputType> = string & {
+	__generatedMutationInput: InputType;
+	__generatedMutationOutput: OutputType;
+};
+
+/**
+ * Nominal type for branding generated graphql mutation operation strings with
+ * input and output types.
+ *
+ * E.g.,
+ *
+ * ```ts
+ * export const createWidget = `...` as GeneratedMutation<
+ * 	CreateWidgetMutationVariables,
+ * 	CreateWidgetMutation
+ * >;
+ * ```
+ *
+ * This allows `graphql()` to extract `InputType` and `OutputType` to correctly
+ * assign types to the `variables` and result objects.
+ */
+export type GeneratedSubscription<InputType, OutputType> = string & {
+	__generatedSubscriptionInput: InputType;
+	__generatedSubscriptionOutput: OutputType;
+};
+
+export const __amplify = Symbol('amplify');
+export const __authMode = Symbol('authMode');
+export const __authToken = Symbol('authToken');
+export const __apiKey = Symbol('apiKey');
+export const __headers = Symbol('headers');
+export const __endpoint = Symbol('endpoint');
+
+export function getInternals(client: BaseClient): ClientInternals & {
+	apiKey?: string;
+	endpoint?: string;
+} {
+	const c = client as any;
+
+	return {
+		amplify: c[__amplify],
+		apiKey: c[__apiKey],
+		authMode: c[__authMode],
+		authToken: c[__authToken],
+		endpoint: c[__endpoint],
+		headers: c[__headers],
+	} as any;
+}
+
+export type ClientWithModels =
+	| V6Client
+	| V6ClientSSRRequest
+	| V6ClientSSRCookies;
+
+export type V6Client<
+	T extends Record<any, any> = never,
+	Options extends CommonPublicClientOptions = object,
+> = {
+	graphql: GraphQLMethod<Options>;
+	cancel(promise: Promise<any>, message?: string): boolean;
+	isCancelError(error: any): boolean;
+} & ClientExtensions<T>;
+
+export type V6ClientSSRRequest<
+	T extends Record<any, any> = never,
+	Options extends CommonPublicClientOptions = object,
+> = {
+	graphql: GraphQLMethodSSR<Options>;
+	cancel(promise: Promise<any>, message?: string): boolean;
+	isCancelError(error: any): boolean;
+} & ClientExtensionsSSRRequest<T>;
+
+export type V6ClientSSRCookies<
+	T extends Record<any, any> = never,
+	Options extends CommonPublicClientOptions = object,
+> = {
+	graphql: GraphQLMethod<Options>;
+	cancel(promise: Promise<any>, message?: string): boolean;
+	isCancelError(error: any): boolean;
+} & ClientExtensionsSSRCookies<T>;
+
+export type GraphQLMethod<Options extends CommonPublicClientOptions> = <
+	FALLBACK_TYPES = unknown,
+	TYPED_GQL_STRING extends string = string,
+>(
+	options: GraphQLOptionsV6<FALLBACK_TYPES, TYPED_GQL_STRING, Options>,
+	additionalHeaders?: CustomHeaders | undefined,
+) => GraphQLResponseV6<FALLBACK_TYPES, TYPED_GQL_STRING>;
+
+export type GraphQLMethodSSR<Options extends CommonPublicClientOptions> = <
+	FALLBACK_TYPES = unknown,
+	TYPED_GQL_STRING extends string = string,
+>(
+	contextSpec: AmplifyServer.ContextSpec,
+	options: GraphQLOptionsV6<FALLBACK_TYPES, TYPED_GQL_STRING, Options>,
+	additionalHeaders?: CustomHeaders | undefined,
+) => GraphQLResponseV6<FALLBACK_TYPES, TYPED_GQL_STRING>;
+
+/**
+ * @private
+ *
+ * The knobs available for configuring `server/generateClient` internally.
+ */
+export interface ServerClientGenerationParams {
+	amplify:
+		| null // null expected when used with `generateServerClient`
+		// closure expected with `generateServerClientUsingCookies`
+		| ((fn: (amplify: AmplifyClassV6) => Promise<any>) => Promise<any>);
+	// global env-sourced config use for retrieving modelIntro
+	config: ResourcesConfig;
+}
+
+export type QueryArgs = Record<string, unknown>;
+
+export interface ListArgs extends Record<string, unknown> {
+	selectionSet?: string[];
+	filter?: Record<string, unknown>;
+	sortDirection?: ModelSortDirection;
+	headers?: CustomHeaders;
+}
+
+export interface AuthModeParams extends Record<string, unknown> {
+	authMode?: GraphQLAuthMode;
+	authToken?: string;
+}
+
+export type GenerateServerClientParams = {
+	config: ResourcesConfig;
+} & CommonPublicClientOptions;

package/src/utils/ConnectionStateMonitor.ts

@@ -0,0 +1,195 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { Observable, Observer, SubscriptionLike, filter, map } from 'rxjs';
+
+import { ConnectionState } from '../types/PubSub';
+
+import { ReachabilityMonitor } from './ReachabilityMonitor';
+
+// Internal types for tracking different connection states
+type LinkedConnectionState = 'connected' | 'disconnected';
+type LinkedHealthState = 'healthy' | 'unhealthy';
+interface LinkedConnectionStates {
+	networkState: LinkedConnectionState;
+	connectionState: LinkedConnectionState | 'connecting';
+	intendedConnectionState: LinkedConnectionState;
+	keepAliveState: LinkedHealthState;
+}
+
+export const CONNECTION_CHANGE = {
+	KEEP_ALIVE_MISSED: { keepAliveState: 'unhealthy' },
+	KEEP_ALIVE: { keepAliveState: 'healthy' },
+	CONNECTION_ESTABLISHED: { connectionState: 'connected' },
+	CONNECTION_FAILED: {
+		intendedConnectionState: 'disconnected',
+		connectionState: 'disconnected',
+	},
+	CLOSING_CONNECTION: { intendedConnectionState: 'disconnected' },
+	OPENING_CONNECTION: {
+		intendedConnectionState: 'connected',
+		connectionState: 'connecting',
+	},
+	CLOSED: { connectionState: 'disconnected' },
+	ONLINE: { networkState: 'connected' },
+	OFFLINE: { networkState: 'disconnected' },
+} as const;
+
+export class ConnectionStateMonitor {
+	/**
+	 * @private
+	 */
+	private _linkedConnectionState: LinkedConnectionStates;
+	private _linkedConnectionStateObservable: Observable<LinkedConnectionStates>;
+	private _linkedConnectionStateObserver:
+		| Observer<LinkedConnectionStates>
+		| undefined;
+
+	private _networkMonitoringSubscription?: SubscriptionLike;
+	private _initialNetworkStateSubscription?: SubscriptionLike;
+
+	constructor() {
+		this._networkMonitoringSubscription = undefined;
+		this._linkedConnectionState = {
+			networkState: 'connected',
+			connectionState: 'disconnected',
+			intendedConnectionState: 'disconnected',
+			keepAliveState: 'healthy',
+		};
+
+		// Attempt to update the state with the current actual network state
+		this._initialNetworkStateSubscription = ReachabilityMonitor().subscribe(
+			({ online }) => {
+				this.record(
+					online ? CONNECTION_CHANGE.ONLINE : CONNECTION_CHANGE.OFFLINE,
+				);
+				this._initialNetworkStateSubscription?.unsubscribe();
+			},
+		);
+
+		this._linkedConnectionStateObservable =
+			new Observable<LinkedConnectionStates>(connectionStateObserver => {
+				connectionStateObserver.next(this._linkedConnectionState);
+				this._linkedConnectionStateObserver = connectionStateObserver;
+			});
+	}
+
+	/**
+	 * Turn network state monitoring on if it isn't on already
+	 */
+	private enableNetworkMonitoring() {
+		// If no initial network state was discovered, stop trying
+		this._initialNetworkStateSubscription?.unsubscribe();
+
+		// Maintain the network state based on the reachability monitor
+		if (this._networkMonitoringSubscription === undefined) {
+			this._networkMonitoringSubscription = ReachabilityMonitor().subscribe(
+				({ online }) => {
+					this.record(
+						online ? CONNECTION_CHANGE.ONLINE : CONNECTION_CHANGE.OFFLINE,
+					);
+				},
+			);
+		}
+	}
+
+	/**
+	 * Turn network state monitoring off if it isn't off already
+	 */
+	private disableNetworkMonitoring() {
+		this._networkMonitoringSubscription?.unsubscribe();
+		this._networkMonitoringSubscription = undefined;
+	}
+
+	/**
+	 * Get the observable that allows us to monitor the connection state
+	 *
+	 * @returns {Observable<ConnectionState>} - The observable that emits ConnectionState updates
+	 */
+	public get connectionStateObservable(): Observable<ConnectionState> {
+		let previous: ConnectionState;
+
+		// The linked state aggregates state changes to any of the network, connection,
+		// intendedConnection and keepAliveHealth. Some states will change these independent
+		// states without changing the overall connection state.
+
+		// After translating from linked states to ConnectionState, then remove any duplicates
+		return this._linkedConnectionStateObservable
+			.pipe(
+				map(value => {
+					return this.connectionStatesTranslator(value);
+				}),
+			)
+			.pipe(
+				filter(current => {
+					const toInclude = current !== previous;
+					previous = current;
+
+					return toInclude;
+				}),
+			);
+	}
+
+	/*
+	 * Updates local connection state and emits the full state to the observer.
+	 */
+	record(statusUpdates: Partial<LinkedConnectionStates>) {
+		// Maintain the network monitor
+		if (statusUpdates.intendedConnectionState === 'connected') {
+			this.enableNetworkMonitoring();
+		} else if (statusUpdates.intendedConnectionState === 'disconnected') {
+			this.disableNetworkMonitoring();
+		}
+
+		// Maintain the socket state
+		const newSocketStatus = {
+			...this._linkedConnectionState,
+			...statusUpdates,
+		};
+
+		this._linkedConnectionState = { ...newSocketStatus };
+
+		this._linkedConnectionStateObserver?.next(this._linkedConnectionState);
+	}
+
+	/*
+	 * Translate the ConnectionState structure into a specific ConnectionState string literal union
+	 */
+	private connectionStatesTranslator({
+		connectionState,
+		networkState,
+		intendedConnectionState,
+		keepAliveState,
+	}: LinkedConnectionStates): ConnectionState {
+		if (connectionState === 'connected' && networkState === 'disconnected')
+			return ConnectionState.ConnectedPendingNetwork;
+
+		if (
+			connectionState === 'connected' &&
+			intendedConnectionState === 'disconnected'
+		)
+			return ConnectionState.ConnectedPendingDisconnect;
+
+		if (
+			connectionState === 'disconnected' &&
+			intendedConnectionState === 'connected' &&
+			networkState === 'disconnected'
+		)
+			return ConnectionState.ConnectionDisruptedPendingNetwork;
+
+		if (
+			connectionState === 'disconnected' &&
+			intendedConnectionState === 'connected'
+		)
+			return ConnectionState.ConnectionDisrupted;
+
+		if (connectionState === 'connected' && keepAliveState === 'unhealthy')
+			return ConnectionState.ConnectedPendingKeepAlive;
+
+		// All remaining states directly correspond to the connection state
+		if (connectionState === 'connecting') return ConnectionState.Connecting;
+		if (connectionState === 'disconnected') return ConnectionState.Disconnected;
+
+		return ConnectionState.Connected;
+	}
+}