@trpc/client 11.2.1-canary.0 → 11.2.1-canary.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/client",
-  "version": "11.2.1-canary.0+836788f4f",
+  "version": "11.2.1-canary.3+46afe6590",
   "description": "The tRPC client library",
   "author": "KATT",
   "license": "MIT",
@@ -77,11 +77,11 @@
     "!**/__tests__"
   ],
   "peerDependencies": {
-    "@trpc/server": "11.2.1-canary.0+836788f4f",
+    "@trpc/server": "11.2.1-canary.3+46afe6590",
     "typescript": ">=5.7.2"
   },
   "devDependencies": {
-    "@trpc/server": "11.2.1-canary.0+836788f4f",
+    "@trpc/server": "11.2.1-canary.3+46afe6590",
     "@types/isomorphic-fetch": "^0.0.39",
     "@types/node": "^22.13.5",
     "dataloader": "^2.2.2",
@@ -101,5 +101,5 @@
   "funding": [
     "https://trpc.io/sponsor"
   ],
-  "gitHead": "836788f4fea787be31bbec1ab2e692fa38297ad0"
+  "gitHead": "46afe65907644bafaf7e60910db41a58dfa350fb"
 }

package/src/TRPCClientError.ts

@@ -19,15 +19,10 @@ export interface TRPCClientErrorBase<TShape extends DefaultErrorShape> {
 export type TRPCClientErrorLike<TInferrable extends InferrableClientTypes> =
   TRPCClientErrorBase<inferErrorShape<TInferrable>>;
 
-function isTRPCClientError(cause: unknown): cause is TRPCClientError<any> {
-  return (
-    cause instanceof TRPCClientError ||
-    /**
-     * @deprecated
-     * Delete in next major
-     */
-    (cause instanceof Error && cause.name === 'TRPCClientError')
-  );
+export function isTRPCClientError<TInferrable extends InferrableClientTypes>(
+  cause: unknown,
+): cause is TRPCClientError<TInferrable> {
+  return cause instanceof TRPCClientError;
 }
 
 function isTRPCErrorResponse(obj: unknown): obj is TRPCErrorResponse<any> {

package/src/internals/signals.ts

@@ -52,3 +52,19 @@ export function raceAbortSignals(
 
   return ac.signal;
 }
+
+export function abortSignalToPromise(signal: AbortSignal): Promise<never> {
+  return new Promise((_, reject) => {
+    if (signal.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    signal.addEventListener(
+      'abort',
+      () => {
+        reject(signal.reason);
+      },
+      { once: true },
+    );
+  });
+}

package/src/links/httpSubscriptionLink.ts

@@ -1,10 +1,5 @@
 import { behaviorSubject, observable } from '@trpc/server/observable';
-import type {
-  TRPC_ERROR_CODE_NUMBER,
-  TRPCErrorShape,
-  TRPCResult,
-} from '@trpc/server/rpc';
-import { TRPC_ERROR_CODES_BY_KEY } from '@trpc/server/rpc';
+import type { TRPCErrorShape, TRPCResult } from '@trpc/server/rpc';
 import type {
   AnyClientTypes,
   EventSourceLike,
@@ -12,6 +7,7 @@ import type {
   InferrableClientTypes,
 } from '@trpc/server/unstable-core-do-not-import';
 import {
+  retryableRpcCodes,
   run,
   sseStreamConsumer,
 } from '@trpc/server/unstable-core-do-not-import';
@@ -63,17 +59,6 @@ type HTTPSubscriptionLinkOptions<
 } & TransformerOptions<TRoot> &
   UrlOptionsWithConnectionParams;
 
-/**
- * tRPC error codes that are considered retryable
- * With out of the box SSE, the client will reconnect when these errors are encountered
- */
-const codes5xx: TRPC_ERROR_CODE_NUMBER[] = [
-  TRPC_ERROR_CODES_BY_KEY.BAD_GATEWAY,
-  TRPC_ERROR_CODES_BY_KEY.SERVICE_UNAVAILABLE,
-  TRPC_ERROR_CODES_BY_KEY.GATEWAY_TIMEOUT,
-  TRPC_ERROR_CODES_BY_KEY.INTERNAL_SERVER_ERROR,
-];
-
 /**
  * @see https://trpc.io/docs/client/links/httpSubscriptionLink
  */
@@ -190,7 +175,7 @@ export function httpSubscriptionLink<
               case 'serialized-error': {
                 const error = TRPCClientError.from({ error: chunk.error });
 
-                if (codes5xx.includes(chunk.error.code)) {
+                if (retryableRpcCodes.includes(chunk.error.code)) {
                   //
                   connectionState.next({
                     type: 'state',

package/src/links/localLink.ts

@@ -0,0 +1,277 @@
+import {
+  getTRPCErrorFromUnknown,
+  getTRPCErrorShape,
+  isTrackedEnvelope,
+} from '@trpc/server';
+import { behaviorSubject, observable } from '@trpc/server/observable';
+import { TRPC_ERROR_CODES_BY_KEY, type TRPCResult } from '@trpc/server/rpc';
+import {
+  callProcedure,
+  isAbortError,
+  isAsyncIterable,
+  iteratorResource,
+  makeResource,
+  retryableRpcCodes,
+  run,
+  type AnyRouter,
+  type ErrorHandlerOptions,
+  type inferClientTypes,
+  type inferRouterContext,
+} from '@trpc/server/unstable-core-do-not-import';
+import { inputWithTrackedEventId } from '../internals/inputWithTrackedEventId';
+import { abortSignalToPromise, raceAbortSignals } from '../internals/signals';
+import { getTransformer } from '../internals/transformer';
+import type { TransformerOptions } from '../internals/transformer';
+import { isTRPCClientError, TRPCClientError } from '../TRPCClientError';
+import type { TRPCConnectionState } from './internals/subscriptions';
+import type { TRPCLink } from './types';
+
+export type LocalLinkOptions<TRouter extends AnyRouter> = {
+  router: TRouter;
+  createContext: () => Promise<inferRouterContext<TRouter>>;
+  onError?: (opts: ErrorHandlerOptions<inferRouterContext<TRouter>>) => void;
+} & TransformerOptions<inferClientTypes<TRouter>>;
+
+/**
+ * localLink is a terminating link that allows you to make tRPC procedure calls directly in your application without going through HTTP.
+ *
+ * @see https://trpc.io/docs/links/localLink
+ */
+export function experimental_localLink<TRouter extends AnyRouter>(
+  opts: LocalLinkOptions<TRouter>,
+): TRPCLink<TRouter> {
+  const transformer = getTransformer(opts.transformer);
+
+  const transformChunk = (chunk: unknown) => {
+    if (opts.transformer) {
+      // assume transformer will do the right thing
+      return chunk;
+    }
+    // Special case for undefined, because `JSON.stringify(undefined)` throws
+    if (chunk === undefined) {
+      return chunk;
+    }
+    const serialized = JSON.stringify(transformer.input.serialize(chunk));
+    const deserialized = JSON.parse(transformer.output.deserialize(serialized));
+    return deserialized;
+  };
+
+  return () =>
+    ({ op }) =>
+      observable((observer) => {
+        let ctx: inferRouterContext<TRouter> | undefined = undefined;
+        const ac = new AbortController();
+
+        const signal = raceAbortSignals(op.signal, ac.signal);
+        const signalPromise = abortSignalToPromise(signal);
+
+        signalPromise.catch(() => {
+          // prevent unhandled rejection
+        });
+
+        let input = op.input;
+        async function runProcedure(newInput: unknown): Promise<unknown> {
+          input = newInput;
+
+          ctx = await opts.createContext();
+
+          return callProcedure({
+            router: opts.router,
+            path: op.path,
+            getRawInput: async () => newInput,
+            ctx,
+            type: op.type,
+            signal,
+          });
+        }
+
+        function onErrorCallback(cause: unknown) {
+          if (isAbortError(cause)) {
+            return;
+          }
+          opts.onError?.({
+            error: getTRPCErrorFromUnknown(cause),
+            type: op.type,
+            path: op.path,
+            input,
+            ctx,
+          });
+        }
+
+        function coerceToTRPCClientError(cause: unknown) {
+          if (isTRPCClientError<TRouter>(cause)) {
+            return cause;
+          }
+          const error = getTRPCErrorFromUnknown(cause);
+
+          const shape = getTRPCErrorShape({
+            config: opts.router._def._config,
+            ctx,
+            error,
+            input,
+            path: op.path,
+            type: op.type,
+          });
+          return TRPCClientError.from({
+            error: transformChunk(shape),
+          });
+        }
+
+        run(async () => {
+          switch (op.type) {
+            case 'query':
+            case 'mutation': {
+              const result = await runProcedure(op.input);
+              if (!isAsyncIterable(result)) {
+                observer.next({
+                  result: { data: transformChunk(result) },
+                });
+                observer.complete();
+                break;
+              }
+
+              observer.next({
+                result: {
+                  data: (async function* () {
+                    await using iterator = iteratorResource(result);
+                    using _finally = makeResource({}, () => {
+                      observer.complete();
+                    });
+                    try {
+                      while (true) {
+                        const res = await Promise.race([
+                          iterator.next(),
+                          signalPromise,
+                        ]);
+                        if (res.done) {
+                          return transformChunk(res.value);
+                        }
+                        yield transformChunk(res.value);
+                      }
+                    } catch (cause) {
+                      onErrorCallback(cause);
+                      throw coerceToTRPCClientError(cause);
+                    }
+                  })(),
+                },
+              });
+              break;
+            }
+            case 'subscription': {
+              const connectionState = behaviorSubject<
+                TRPCConnectionState<TRPCClientError<any>>
+              >({
+                type: 'state',
+                state: 'connecting',
+                error: null,
+              });
+
+              const connectionSub = connectionState.subscribe({
+                next(state) {
+                  observer.next({
+                    result: state,
+                  });
+                },
+              });
+              let lastEventId: string | undefined = undefined;
+
+              using _finally = makeResource({}, async () => {
+                observer.complete();
+
+                connectionState.next({
+                  type: 'state',
+                  state: 'idle',
+                  error: null,
+                });
+                connectionSub.unsubscribe();
+              });
+              while (true) {
+                const result = await runProcedure(
+                  inputWithTrackedEventId(op.input, lastEventId),
+                );
+                if (!isAsyncIterable(result)) {
+                  throw new Error('Expected an async iterable');
+                }
+                await using iterator = iteratorResource(result);
+
+                observer.next({
+                  result: {
+                    type: 'started',
+                  },
+                });
+                connectionState.next({
+                  type: 'state',
+                  state: 'pending',
+                  error: null,
+                });
+
+                // Use a while loop to handle errors and reconnects
+                while (true) {
+                  let res;
+                  try {
+                    res = await Promise.race([iterator.next(), signalPromise]);
+                  } catch (cause) {
+                    if (isAbortError(cause)) {
+                      return;
+                    }
+                    const error = getTRPCErrorFromUnknown(cause);
+
+                    if (
+                      !retryableRpcCodes.includes(
+                        TRPC_ERROR_CODES_BY_KEY[error.code],
+                      )
+                    ) {
+                      throw coerceToTRPCClientError(error);
+                    }
+
+                    onErrorCallback(error);
+                    connectionState.next({
+                      type: 'state',
+                      state: 'connecting',
+                      error: coerceToTRPCClientError(error),
+                    });
+
+                    break;
+                  }
+
+                  if (res.done) {
+                    return;
+                  }
+                  let chunk: TRPCResult<unknown>;
+                  if (isTrackedEnvelope(res.value)) {
+                    lastEventId = res.value[0];
+
+                    chunk = {
+                      id: res.value[0],
+                      data: {
+                        id: res.value[0],
+                        data: res.value[1],
+                      },
+                    };
+                  } else {
+                    chunk = {
+                      data: res.value,
+                    };
+                  }
+
+                  observer.next({
+                    result: {
+                      ...chunk,
+                      data: transformChunk(chunk.data),
+                    },
+                  });
+                }
+              }
+              break;
+            }
+          }
+        }).catch((cause) => {
+          onErrorCallback(cause);
+          observer.error(coerceToTRPCClientError(cause));
+        });
+
+        return () => {
+          ac.abort();
+        };
+      });
+}

package/src/links.ts

@@ -9,6 +9,7 @@ export * from './links/splitLink';
 export * from './links/wsLink/wsLink';
 export * from './links/httpSubscriptionLink';
 export * from './links/retryLink';
+export * from './links/localLink';
 
 // These are not public (yet) as we get this functionality from tanstack query
 // export * from './links/internals/dedupeLink';