snapshot of https://github.com/RocketChat/Rocket.Chat.git (develop, 2026-09-16; blobs > 131072B omitted)

apps/meteor/client/providers/ServerProvider.tsx

@@ -0,0 +1,209 @@
+import type { Serialized } from '@rocket.chat/core-typings';
+import type {
+	ServerMethodName,
+	ServerMethodParameters,
+	ServerMethodReturn,
+	StreamerCallbackArgs,
+	StreamerEvents,
+	StreamNames,
+	StreamKeys,
+} from '@rocket.chat/ddp-client';
+import type { Method, PathFor, OperationParams, OperationResult, UrlParams, PathPattern } from '@rocket.chat/rest-typings';
+import type { UploadResult, ServerContextValue } from '@rocket.chat/ui-contexts';
+import { ServerContext } from '@rocket.chat/ui-contexts';
+import { Meteor } from 'meteor/meteor';
+import { compile } from 'path-to-regexp';
+import { useMemo, useSyncExternalStore, type ReactNode } from 'react';
+
+import { Info as info } from '../../app/utils/rocketchat.info';
+import { sdk } from '../lib/SDKClient';
+import { absoluteUrl } from '../lib/absoluteUrl';
+import { ensureConnectedAndAuthenticated, getDdpSdk } from '../lib/sdk/ddpSdk';
+import { isSdkTransportEnabled } from '../lib/sdk/sdkTransportEnabled';
+
+const sdkTransportEnabled = isSdkTransportEnabled();
+
+const callMethod = <MethodName extends ServerMethodName>(
+	methodName: MethodName,
+	...args: ServerMethodParameters<MethodName>
+): Promise<ServerMethodReturn<MethodName>> => sdk.call(methodName, ...(args as any)) as Promise<ServerMethodReturn<MethodName>>;
+
+const callEndpoint = <TMethod extends Method, TPathPattern extends PathPattern>({
+	method,
+	pathPattern,
+	keys,
+	params,
+	signal,
+}: {
+	method: TMethod;
+	pathPattern: TPathPattern;
+	keys: UrlParams<TPathPattern>;
+	params: OperationParams<TMethod, TPathPattern>;
+	signal?: AbortSignal;
+}): Promise<Serialized<OperationResult<TMethod, TPathPattern>>> => {
+	const compiledPath = compile(pathPattern, { encode: encodeURIComponent })(keys) as any;
+
+	switch (method) {
+		case 'GET':
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unnecessary-type-assertion
+			return sdk.rest.get(compiledPath, params as any, { signal }) as any;
+
+		case 'POST':
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unnecessary-type-assertion
+			return sdk.rest.post(compiledPath, params as any, { signal }) as any;
+
+		case 'PUT':
+			// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+			return sdk.rest.put(compiledPath, params as never, { signal }) as never;
+
+		case 'DELETE':
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unnecessary-type-assertion
+			return sdk.rest.delete(compiledPath, params as any, { signal }) as any;
+
+		default:
+			throw new Error('Invalid HTTP method');
+	}
+};
+
+const uploadToEndpoint = (endpoint: PathFor<'POST'>, formData: any): Promise<UploadResult> => sdk.rest.post(endpoint as any, formData);
+
+const getStream =
+	<N extends StreamNames>(
+		streamName: N,
+		_options?: {
+			retransmit?: boolean | undefined;
+			retransmitToSelf?: boolean | undefined;
+		},
+	) =>
+	<K extends StreamKeys<N>>(eventName: K, callback: (...args: StreamerCallbackArgs<N, K>) => void): (() => void) =>
+		sdk.stream(streamName, [eventName], callback).stop;
+
+const getStreamAll =
+	<N extends StreamNames>(streamName: N) =>
+	(callback: (eventName: string, args: StreamerEvents[N][number]['args']) => void): (() => void) =>
+		sdk.onAnyStreamEvent(streamName, callback).stop;
+
+const writeStream = <N extends StreamNames, K extends StreamKeys<N>>(streamName: N, streamKey: K, ...args: StreamerCallbackArgs<N, K>) =>
+	sdk.publish(streamName, [streamKey, ...args]);
+
+const disconnect = sdkTransportEnabled
+	? () => {
+			Meteor.disconnect();
+			try {
+				getDdpSdk().connection.close();
+			} catch {
+				// no-op — DDPSDK may not be connected yet
+			}
+		}
+	: () => Meteor.disconnect();
+
+const reconnect = sdkTransportEnabled
+	? () => {
+			Meteor.reconnect();
+			// ensureConnectedAndAuthenticated handles both 'connect' and loginWithToken,
+			// so reconnecting here also re-establishes the DDPSDK session with the
+			// same token Meteor resumes with.
+			void ensureConnectedAndAuthenticated();
+		}
+	: () => Meteor.reconnect();
+
+type CombinedStatus = ReturnType<typeof Meteor.status>;
+
+const sdkStatusToMeteor = (sdkStatus: string, meteor: CombinedStatus): CombinedStatus => {
+	const retry = { retryCount: meteor.retryCount, retryTime: meteor.retryTime };
+
+	switch (sdkStatus) {
+		case 'connected':
+			return { status: 'connected', connected: true, ...retry };
+		case 'connecting':
+			return { status: 'connecting', connected: false, ...retry };
+		case 'reconnecting':
+			return { status: 'connecting', connected: false, ...retry };
+		case 'failed':
+			return { status: 'failed', connected: false, ...retry };
+		case 'closed':
+		case 'disconnected':
+			return { status: 'waiting', connected: false, ...retry };
+		case 'idle':
+		default:
+			return { status: 'offline', connected: false, ...retry };
+	}
+};
+
+// With SDK transport on, combine Meteor's DDP status with DDPSDK's so the
+// ConnectionStatusBar / idle-connection hooks reflect the worst-case of both
+// transports. With the flag off, route status straight through Meteor —
+// `meteorBackedSdk` already bridges Meteor's `_stream` events into
+// `sdk.connection.on('connection')`, so the same subscription works in both
+// modes.
+const computeStatus: () => CombinedStatus = sdkTransportEnabled
+	? () => sdkStatusToMeteor(getDdpSdk().connection.status, Meteor.status())
+	: () => ({ ...Meteor.status() });
+
+const isStatusEqual = (a: CombinedStatus, b: CombinedStatus): boolean =>
+	a.status === b.status && a.connected === b.connected && a.retryCount === b.retryCount && a.retryTime === b.retryTime;
+
+let cachedStatus: CombinedStatus = computeStatus();
+const statusListeners = new Set<() => void>();
+let statusBridgeStarted = false;
+
+const ensureStatusBridge = (): void => {
+	if (statusBridgeStarted) return;
+	statusBridgeStarted = true;
+	getDdpSdk().connection.on('connection', () => {
+		const next = computeStatus();
+		if (isStatusEqual(cachedStatus, next)) return;
+		cachedStatus = next;
+		statusListeners.forEach((cb) => cb());
+	});
+};
+
+const subscribeStatus = (cb: () => void): (() => void) => {
+	ensureStatusBridge();
+	// Close the race between the cachedStatus computed at module load and the
+	// first event delivered through the bridge: status may have changed in
+	// between (e.g. the socket connected before <ServerProvider> mounted), and
+	// useSyncExternalStore would otherwise surface the stale snapshot until
+	// the next external transition.
+	const next = computeStatus();
+	if (!isStatusEqual(cachedStatus, next)) {
+		cachedStatus = next;
+		cb();
+	}
+	statusListeners.add(cb);
+	return () => {
+		statusListeners.delete(cb);
+	};
+};
+
+const getStatusSnapshot = (): CombinedStatus => cachedStatus;
+
+export type ServerProviderProps = { children?: ReactNode };
+
+const ServerProvider = ({ children }: ServerProviderProps) => {
+	const { connected, status, retryCount, retryTime } = useSyncExternalStore(subscribeStatus, getStatusSnapshot);
+
+	const value = useMemo(
+		(): ServerContextValue => ({
+			connected,
+			status,
+			retryCount,
+			retryTime,
+			info,
+			absoluteUrl,
+			callMethod,
+			callEndpoint,
+			uploadToEndpoint,
+			getStream,
+			getStreamAll,
+			writeStream,
+			disconnect,
+			reconnect,
+		}),
+		[connected, retryCount, retryTime, status],
+	);
+
+	return <ServerContext.Provider value={value}>{children}</ServerContext.Provider>;
+};
+
+export default ServerProvider;