@trpc/server 11.0.0-alpha-tmp-subscription-connection-state.489 → 11.0.0-alpha-tmp-12-06-react.665

package/src/adapters/ws.ts

@@ -13,7 +13,7 @@ import {
   TRPCError,
 } from '../@trpc/server';
 import type { TRPCRequestInfo } from '../@trpc/server/http';
-import { toURL, type BaseHandlerOptions } from '../@trpc/server/http';
+import { type BaseHandlerOptions } from '../@trpc/server/http';
 import { parseTRPCMessage } from '../@trpc/server/rpc';
 // @trpc/server/rpc
 import type {
@@ -24,8 +24,7 @@ import type {
   TRPCResultMessage,
 } from '../@trpc/server/rpc';
 import { parseConnectionParamsFromUnknown } from '../http';
-import { isObservable } from '../observable';
-import { observableToAsyncIterable } from '../observable/observable';
+import { isObservable, observableToAsyncIterable } from '../observable';
 // eslint-disable-next-line no-restricted-imports
 import {
   isAsyncIterable,
@@ -34,11 +33,14 @@ import {
   run,
   type MaybePromise,
 } from '../unstable-core-do-not-import';
-import type { NodeHTTPCreateContextFnOptions } from './node-http';
+// eslint-disable-next-line no-restricted-imports
+import { iteratorResource } from '../unstable-core-do-not-import/stream/utils/asyncIterable';
+import { Unpromise } from '../vendor/unpromise';
+import { createURL, type NodeHTTPCreateContextFnOptions } from './node-http';
 
 /**
  * Importing ws causes a build error
- * @link https://github.com/trpc/trpc/pull/5279
+ * @see https://github.com/trpc/trpc/pull/5279
  */
 const WEBSOCKET_OPEN = 1; /* ws.WebSocket.OPEN */
 
@@ -79,20 +81,26 @@ export type WSSHandlerOptions<TRouter extends AnyRouter> =
       enabled: boolean;
       /**
        * Heartbeat interval in milliseconds
-       * @default 30000
+       * @default 30_000
        */
       pingMs?: number;
       /**
        * Terminate the WebSocket if no pong is received after this many milliseconds
-       * @default 5000
+       * @default 5_000
        */
       pongWaitMs?: number;
     };
+    /**
+     * Disable responding to ping messages from the client
+     * **Not recommended** - this is mainly used for testing
+     * @default false
+     */
+    dangerouslyDisablePong?: boolean;
   };
 
 const unsetContextPromiseSymbol = Symbol('unsetContextPromise');
 export function getWSConnectionHandler<TRouter extends AnyRouter>(
-  opts: WSConnectionHandlerOptions<TRouter>,
+  opts: WSSHandlerOptions<TRouter>,
 ) {
   const { createContext, router } = opts;
   const { transformer } = router._def._config;
@@ -101,6 +109,11 @@ export function getWSConnectionHandler<TRouter extends AnyRouter>(
     const clientSubscriptions = new Map<number | string, AbortController>();
     const abortController = new AbortController();
 
+    if (opts.keepAlive?.enabled) {
+      const { pingMs, pongWaitMs } = opts.keepAlive;
+      handleKeepAlive(client, pingMs, pongWaitMs);
+    }
+
     function respond(untransformedJSON: TRPCResponseMessage) {
       client.send(
         JSON.stringify(
@@ -167,7 +180,7 @@ export function getWSConnectionHandler<TRouter extends AnyRouter>(
      * - if connection params are expected, they will be created once received
      */
     let ctxPromise =
-      toURL(req.url ?? '').searchParams.get('connectionParams') === '1'
+      createURL(req).searchParams.get('connectionParams') === '1'
         ? unsetContextPromiseSymbol
         : createCtxPromise(() => null);
 
@@ -203,12 +216,14 @@ export function getWSConnectionHandler<TRouter extends AnyRouter>(
         }
         await ctxPromise; // asserts context has been set
 
+        const abortController = new AbortController();
         const result = await callProcedure({
           procedures: router._def.procedures,
           path,
           getRawInput: async () => input,
           ctx,
           type,
+          signal: abortController.signal,
         });
 
         const isIterableResult =
@@ -259,20 +274,27 @@ export function getWSConnectionHandler<TRouter extends AnyRouter>(
         }
 
         const iterable = isObservable(result)
-          ? observableToAsyncIterable(result)
+          ? observableToAsyncIterable(result, abortController.signal)
           : result;
 
-        const iterator: AsyncIterator<unknown> =
-          iterable[Symbol.asyncIterator]();
-        const abortController = new AbortController();
+        run(async () => {
+          await using iterator = iteratorResource(iterable);
 
-        const abortPromise = new Promise<'abort'>((resolve) => {
-          abortController.signal.onabort = () => resolve('abort');
-        });
+          const abortPromise = new Promise<'abort'>((resolve) => {
+            abortController.signal.onabort = () => resolve('abort');
+          });
+          // We need those declarations outside the loop for garbage collection reasons. If they
+          // were declared inside, they would not be freed until the next value is present.
+          let next:
+            | null
+            | TRPCError
+            | Awaited<
+                typeof abortPromise | ReturnType<(typeof iterator)['next']>
+              >;
+          let result: null | TRPCResultMessage<unknown>['result'];
 
-        run(async () => {
           while (true) {
-            const next = await Promise.race([
+            next = await Unpromise.race([
               iterator.next().catch(getTRPCErrorFromUnknown),
               abortPromise,
             ]);
@@ -302,7 +324,7 @@ export function getWSConnectionHandler<TRouter extends AnyRouter>(
               break;
             }
 
-            const result: TRPCResultMessage<unknown>['result'] = {
+            result = {
               type: 'data',
               data: next.value,
             };
@@ -321,9 +343,12 @@ export function getWSConnectionHandler<TRouter extends AnyRouter>(
               jsonrpc,
               result,
             });
+
+            // free up references for garbage collection
+            next = null;
+            result = null;
           }
 
-          await iterator.return?.();
           respond({
             id,
             jsonrpc,
@@ -376,13 +401,24 @@ export function getWSConnectionHandler<TRouter extends AnyRouter>(
         });
       }
     }
-    client.on('message', async (message) => {
+    client.on('message', async (rawData) => {
+      // eslint-disable-next-line @typescript-eslint/no-base-to-string
+      const msgStr = rawData.toString();
+      if (msgStr === 'PONG') {
+        return;
+      }
+      if (msgStr === 'PING') {
+        if (!opts.dangerouslyDisablePong) {
+          client.send('PONG');
+        }
+        return;
+      }
       if (ctxPromise === unsetContextPromiseSymbol) {
         // If the ctxPromise wasn't created immediately, we're expecting the first message to be a TRPCConnectionParamsMessage
         ctxPromise = createCtxPromise(() => {
           let msg;
           try {
-            msg = JSON.parse(message.toString()) as TRPCConnectionParamsMessage;
+            msg = JSON.parse(msgStr) as TRPCConnectionParamsMessage;
 
             if (!isObject(msg)) {
               throw new Error('Message was not an object');
@@ -402,7 +438,7 @@ export function getWSConnectionHandler<TRouter extends AnyRouter>(
         return;
       }
       try {
-        const msgJSON: unknown = JSON.parse(message.toString());
+        const msgJSON: unknown = JSON.parse(msgStr);
         const msgs: unknown[] = Array.isArray(msgJSON) ? msgJSON : [msgJSON];
         const promises = msgs
           .map((raw) => parseTRPCMessage(raw, transformer))
@@ -452,8 +488,7 @@ export function getWSConnectionHandler<TRouter extends AnyRouter>(
     });
 
     if (ctxPromise !== unsetContextPromiseSymbol) {
-      // prevent unhandled promise rejection errors
-      await ctxPromise.catch(() => null);
+      await ctxPromise;
     }
   };
 }
@@ -461,50 +496,69 @@ export function getWSConnectionHandler<TRouter extends AnyRouter>(
 /**
  * Handle WebSocket keep-alive messages
  */
-function handleKeepAlive(
+export function handleKeepAlive(
   client: ws.WebSocket,
-  pingMs = 30000,
-  pongWaitMs = 5000,
+  pingMs = 30_000,
+  pongWaitMs = 5_000,
 ) {
-  let heartbeatTimeout: NodeJS.Timeout | undefined;
-  const heartbeatInterval = setInterval(() => {
-    if (client.readyState !== WEBSOCKET_OPEN) {
-      return;
-    }
-    // First we send a ping message and wait for a pong
-    client.ping();
-    // We set a timeout to close the connection if the pong is not received
-    heartbeatTimeout = setTimeout(() => {
-      client.terminate();
-      clearInterval(heartbeatInterval);
-    }, pongWaitMs);
-  }, pingMs).unref();
-  // When we receive a pong message, we clear the timeout
-  client.on('pong', () => {
-    heartbeatTimeout && clearTimeout(heartbeatTimeout);
-  });
-  // If the connection is closed, we clear the interval
+  let timeout: NodeJS.Timeout | undefined = undefined;
+  let ping: NodeJS.Timeout | undefined = undefined;
+
+  const schedulePing = () => {
+    const scheduleTimeout = () => {
+      timeout = setTimeout(() => {
+        client.terminate();
+      }, pongWaitMs);
+    };
+    ping = setTimeout(() => {
+      client.send('PING');
+
+      scheduleTimeout();
+    }, pingMs);
+  };
+
+  const onMessage = () => {
+    clearTimeout(ping);
+    clearTimeout(timeout);
+
+    schedulePing();
+  };
+
+  client.on('message', onMessage);
+
   client.on('close', () => {
-    clearInterval(heartbeatInterval);
+    clearTimeout(ping);
+    clearTimeout(timeout);
   });
+
+  schedulePing();
 }
 
 export function applyWSSHandler<TRouter extends AnyRouter>(
   opts: WSSHandlerOptions<TRouter>,
 ) {
-  const { wss, prefix, keepAlive } = opts;
-
   const onConnection = getWSConnectionHandler(opts);
-  wss.on('connection', async (client, req) => {
-    if (prefix && !req.url?.startsWith(prefix)) {
+  opts.wss.on('connection', (client, req) => {
+    if (opts.prefix && !req.url?.startsWith(opts.prefix)) {
       return;
     }
 
-    await onConnection(client, req);
-    if (keepAlive?.enabled) {
-      const { pingMs, pongWaitMs } = keepAlive;
-      handleKeepAlive(client, pingMs, pongWaitMs);
-    }
+    onConnection(client, req).catch((cause) => {
+      opts.onError?.({
+        error: new TRPCError({
+          code: 'INTERNAL_SERVER_ERROR',
+          cause,
+          message: 'Failed to handle WebSocket connection',
+        }),
+        req: req,
+        path: undefined,
+        type: 'unknown',
+        ctx: undefined,
+        input: undefined,
+      });
+
+      client.close();
+    });
   });
 
   return {
@@ -514,7 +568,7 @@ export function applyWSSHandler<TRouter extends AnyRouter>(
         method: 'reconnect',
       };
       const data = JSON.stringify(response);
-      for (const client of wss.clients) {
+      for (const client of opts.wss.clients) {
         if (client.readyState === WEBSOCKET_OPEN) {
           client.send(data);
         }

package/src/observable/behaviorSubject.ts

@@ -0,0 +1,55 @@
+import { observable } from './observable';
+import type { Observable, Observer } from './types';
+
+export interface BehaviorSubject<TValue> extends Observable<TValue, never> {
+  observable: Observable<TValue, never>;
+  next: (value: TValue) => void;
+  get: () => TValue;
+}
+
+export interface ReadonlyBehaviorSubject<TValue>
+  extends Omit<BehaviorSubject<TValue>, 'next'> {}
+
+/**
+ * @internal
+ * An observable that maintains and provides a "current value" to subscribers
+ * @see https://www.learnrxjs.io/learn-rxjs/subjects/behaviorsubject
+ */
+export function behaviorSubject<TValue>(
+  initialValue: TValue,
+): BehaviorSubject<TValue> {
+  let value: TValue = initialValue;
+
+  const observerList: Observer<TValue, never>[] = [];
+
+  const addObserver = (observer: Observer<TValue, never>) => {
+    if (value !== undefined) {
+      observer.next(value);
+    }
+    observerList.push(observer);
+  };
+  const removeObserver = (observer: Observer<TValue, never>) => {
+    observerList.splice(observerList.indexOf(observer), 1);
+  };
+
+  const obs = observable<TValue, never>((observer) => {
+    addObserver(observer);
+    return () => {
+      removeObserver(observer);
+    };
+  }) as BehaviorSubject<TValue>;
+
+  obs.next = (nextValue: TValue) => {
+    if (value === nextValue) {
+      return;
+    }
+    value = nextValue;
+    for (const observer of observerList) {
+      observer.next(nextValue);
+    }
+  };
+
+  obs.get = () => value;
+
+  return obs;
+}

package/src/observable/index.ts

@@ -1,6 +1,19 @@
-export type { inferObservableValue } from './observable';
-export { isObservable, observable, observableToPromise } from './observable';
-export { map, share, tap } from './operators';
+export {
+  isObservable,
+  observable,
+  observableToAsyncIterable,
+  observableToPromise,
+  type inferObservableValue,
+} from './observable';
+
+export {
+  distinctUntilChanged,
+  distinctUntilDeepChanged,
+  map,
+  share,
+  tap,
+} from './operators';
+
 export type {
   Observable,
   Observer,
@@ -8,3 +21,9 @@ export type {
   Unsubscribable,
   UnsubscribeFn,
 } from './types';
+
+export {
+  behaviorSubject,
+  type BehaviorSubject,
+  type ReadonlyBehaviorSubject,
+} from './behaviorSubject';

package/src/observable/observable.ts

@@ -1,3 +1,4 @@
+import type { Result } from '../unstable-core-do-not-import';
 import type {
   Observable,
   Observer,
@@ -8,12 +9,8 @@ import type {
 } from './types';
 
 /** @public */
-export type inferObservableValue<TObservable> = TObservable extends Observable<
-  infer TValue,
-  unknown
->
-  ? TValue
-  : never;
+export type inferObservableValue<TObservable> =
+  TObservable extends Observable<infer TValue, unknown> ? TValue : never;
 
 /** @public */
 export function isObservable(x: unknown): x is Observable<unknown, unknown> {
@@ -130,32 +127,49 @@ export function observableToPromise<TValue>(
  */
 function observableToReadableStream<TValue>(
   observable: Observable<TValue, unknown>,
-): ReadableStream<TValue> {
+  signal: AbortSignal,
+): ReadableStream<Result<TValue>> {
   let unsub: Unsubscribable | null = null;
-  return new ReadableStream<TValue>({
+
+  const onAbort = () => {
+    unsub?.unsubscribe();
+    unsub = null;
+    signal.removeEventListener('abort', onAbort);
+  };
+
+  return new ReadableStream<Result<TValue>>({
     start(controller) {
       unsub = observable.subscribe({
         next(data) {
-          controller.enqueue(data);
+          controller.enqueue({ ok: true, value: data });
         },
-        error(err) {
-          controller.error(err);
+        error(error) {
+          controller.enqueue({ ok: false, error });
+          controller.close();
         },
         complete() {
           controller.close();
         },
       });
+
+      if (signal.aborted) {
+        onAbort();
+      } else {
+        signal.addEventListener('abort', onAbort, { once: true });
+      }
     },
     cancel() {
-      unsub?.unsubscribe();
+      onAbort();
     },
   });
 }
 
+/** @internal */
 export function observableToAsyncIterable<TValue>(
   observable: Observable<TValue, unknown>,
+  signal: AbortSignal,
 ): AsyncIterable<TValue> {
-  const stream = observableToReadableStream(observable);
+  const stream = observableToReadableStream(observable, signal);
 
   const reader = stream.getReader();
   const iterator: AsyncIterator<TValue> = {
@@ -167,8 +181,12 @@ export function observableToAsyncIterable<TValue>(
           done: true,
         };
       }
+      const { value: result } = value;
+      if (!result.ok) {
+        throw result.error;
+      }
       return {
-        value: value.value,
+        value: result.value,
         done: false,
       };
     },

package/src/observable/operators.ts

@@ -112,3 +112,50 @@ export function tap<TValue, TError>(
     });
   };
 }
+
+const distinctUnsetMarker = Symbol();
+export function distinctUntilChanged<TValue, TError>(
+  compare: (a: TValue, b: TValue) => boolean = (a, b) => a === b,
+): MonoTypeOperatorFunction<TValue, TError> {
+  return (source) => {
+    return observable((destination) => {
+      let lastValue: TValue | typeof distinctUnsetMarker = distinctUnsetMarker;
+
+      return source.subscribe({
+        next(value) {
+          if (lastValue !== distinctUnsetMarker && compare(lastValue, value)) {
+            return;
+          }
+          lastValue = value;
+          destination.next(value);
+        },
+        error(error) {
+          destination.error(error);
+        },
+        complete() {
+          destination.complete();
+        },
+      });
+    });
+  };
+}
+
+const isDeepEqual = <T>(a: T, b: T): boolean => {
+  if (a === b) {
+    return true;
+  }
+  const bothAreObjects =
+    a && b && typeof a === 'object' && typeof b === 'object';
+
+  return (
+    !!bothAreObjects &&
+    Object.keys(a).length === Object.keys(b).length &&
+    Object.entries(a).every(([k, v]) => isDeepEqual(v, b[k as keyof T]))
+  );
+};
+export function distinctUntilDeepChanged<
+  TValue,
+  TError,
+>(): MonoTypeOperatorFunction<TValue, TError> {
+  return distinctUntilChanged(isDeepEqual);
+}

package/src/unstable-core-do-not-import/clientish/inference.ts

@@ -40,10 +40,10 @@ export type GetInferenceHelpers<
     ? $Value extends RouterRecord
       ? GetInferenceHelpers<TType, TRoot, $Value>
       : $Value extends AnyProcedure
-      ? TType extends 'input'
-        ? inferProcedureInput<$Value>
-        : inferTransformedProcedureOutput<TRoot, $Value>
-      : never
+        ? TType extends 'input'
+          ? inferProcedureInput<$Value>
+          : inferTransformedProcedureOutput<TRoot, $Value>
+        : never
     : never;
 };
 

package/src/unstable-core-do-not-import/clientish/inferrable.ts

@@ -41,9 +41,9 @@ export type inferClientTypes<TInferrable extends InferrableClientTypes> =
   TInferrable extends AnyClientTypes
     ? TInferrable
     : TInferrable extends RootConfigLike
-    ? TInferrable['$types']
-    : TInferrable extends InitLike
-    ? TInferrable['_config']['$types']
-    : TInferrable extends RouterLike
-    ? TInferrable['_def']['_config']['$types']
-    : never;
+      ? TInferrable['$types']
+      : TInferrable extends InitLike
+        ? TInferrable['_config']['$types']
+        : TInferrable extends RouterLike
+          ? TInferrable['_def']['_config']['$types']
+          : never;

package/src/unstable-core-do-not-import/clientish/serialize.ts

@@ -2,10 +2,10 @@
 import type { Simplify, WithoutIndexSignature } from '../types';
 
 /**
- * @link https://github.com/remix-run/remix/blob/2248669ed59fd716e267ea41df5d665d4781f4a9/packages/remix-server-runtime/serialize.ts
+ * @see https://github.com/remix-run/remix/blob/2248669ed59fd716e267ea41df5d665d4781f4a9/packages/remix-server-runtime/serialize.ts
  */
 type JsonPrimitive = boolean | number | string | null;
-// eslint-disable-next-line @typescript-eslint/ban-types
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
 type NonJsonPrimitive = Function | symbol | undefined;
 /*
  * `any` is the only type that can let you equate `0` with `1`
@@ -26,7 +26,7 @@ type IsRecord<T extends object> = keyof WithoutIndexSignature<T> extends never
 export type Serialize<T> =
   IsAny<T> extends true ? any :
   unknown extends T ? unknown :
-  T extends AsyncGenerator<infer $T, infer $Return, infer $Next> ? AsyncGenerator<Serialize<$T>, Serialize<$Return>, Serialize<$Next>> :
+  T extends AsyncIterable<infer $T, infer $Return, infer $Next> ? AsyncIterable<Serialize<$T>, Serialize<$Return>, Serialize<$Next>> :
   T extends JsonReturnable ? T :
   T extends Map<any, any> | Set<any> ? object :
   T extends NonJsonPrimitive ? never :
@@ -119,5 +119,5 @@ type UndefinedToOptional<T extends object> =
     (ExactOptionalPropertyTypes extends true
       ? HandleIndexSignature<T> & HandleUndefined<WithoutIndexSignature<T>>
       : HasIndexSignature<T> extends true
-      ? HandleIndexSignature<T>
-      : HandleUndefined<T>);
+        ? HandleIndexSignature<T>
+        : HandleUndefined<T>);

package/src/unstable-core-do-not-import/http/getHTTPStatusCode.ts

@@ -1,9 +1,10 @@
 import type { TRPCError } from '../error/TRPCError';
 import type { TRPC_ERROR_CODES_BY_KEY, TRPCResponse } from '../rpc';
 import { TRPC_ERROR_CODES_BY_NUMBER } from '../rpc';
+import type { InvertKeyValue, ValueOf } from '../types';
 import { isObject } from '../utils';
 
-const JSONRPC2_TO_HTTP_CODE: Record<
+export const JSONRPC2_TO_HTTP_CODE: Record<
   keyof typeof TRPC_ERROR_CODES_BY_KEY,
   number
 > = {
@@ -28,11 +29,42 @@ const JSONRPC2_TO_HTTP_CODE: Record<
   GATEWAY_TIMEOUT: 504,
 };
 
-function getStatusCodeFromKey(code: keyof typeof TRPC_ERROR_CODES_BY_KEY) {
+export const HTTP_CODE_TO_JSONRPC2: InvertKeyValue<
+  typeof JSONRPC2_TO_HTTP_CODE
+> = {
+  400: 'BAD_REQUEST',
+  401: 'UNAUTHORIZED',
+  403: 'FORBIDDEN',
+  404: 'NOT_FOUND',
+  405: 'METHOD_NOT_SUPPORTED',
+  408: 'TIMEOUT',
+  409: 'CONFLICT',
+  412: 'PRECONDITION_FAILED',
+  413: 'PAYLOAD_TOO_LARGE',
+  415: 'UNSUPPORTED_MEDIA_TYPE',
+  422: 'UNPROCESSABLE_CONTENT',
+  429: 'TOO_MANY_REQUESTS',
+  499: 'CLIENT_CLOSED_REQUEST',
+  500: 'INTERNAL_SERVER_ERROR',
+  501: 'NOT_IMPLEMENTED',
+  502: 'BAD_GATEWAY',
+  503: 'SERVICE_UNAVAILABLE',
+  504: 'GATEWAY_TIMEOUT',
+} as const;
+
+export function getStatusCodeFromKey(
+  code: keyof typeof TRPC_ERROR_CODES_BY_KEY,
+) {
   return JSONRPC2_TO_HTTP_CODE[code] ?? 500;
 }
 
-export function getHTTPStatusCode(json: TRPCResponse | TRPCResponse[]): number {
+export function getStatusKeyFromCode(
+  code: keyof typeof HTTP_CODE_TO_JSONRPC2,
+): ValueOf<typeof HTTP_CODE_TO_JSONRPC2> {
+  return HTTP_CODE_TO_JSONRPC2[code] ?? 'INTERNAL_SERVER_ERROR';
+}
+
+export function getHTTPStatusCode(json: TRPCResponse | TRPCResponse[]) {
   const arr = Array.isArray(json) ? json : [json];
   const httpStatuses = new Set<number>(
     arr.map((res) => {
@@ -53,7 +85,8 @@ export function getHTTPStatusCode(json: TRPCResponse | TRPCResponse[]): number {
 
   const httpStatus = httpStatuses.values().next().value;
 
-  return httpStatus;
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  return httpStatus!;
 }
 
 export function getHTTPStatusCodeFromError(error: TRPCError) {

package/src/unstable-core-do-not-import/http/isAbortError.ts

@@ -0,0 +1,7 @@
+import { isObject } from '../utils';
+
+export function isAbortError(
+  error: unknown,
+): error is DOMException | Error | { name: 'AbortError' } {
+  return isObject(error) && error['name'] === 'AbortError';
+}