@trpc/client 11.2.0 → 11.2.1-canary.1

package/dist/links/localLink.mjs

@@ -0,0 +1,331 @@
+import { getTRPCErrorFromUnknown, isTrackedEnvelope, getTRPCErrorShape } from '@trpc/server';
+import { observable, behaviorSubject } from '@trpc/server/observable';
+import { TRPC_ERROR_CODES_BY_KEY } from '@trpc/server/rpc';
+import { run, makeResource, isAsyncIterable, iteratorResource, isAbortError, retryableRpcCodes, callProcedure } from '@trpc/server/unstable-core-do-not-import';
+import { inputWithTrackedEventId } from '../internals/inputWithTrackedEventId.mjs';
+import { raceAbortSignals, abortSignalToPromise } from '../internals/signals.mjs';
+import { getTransformer } from '../internals/transformer.mjs';
+import { isTRPCClientError, TRPCClientError } from '../TRPCClientError.mjs';
+
+function _ts_add_disposable_resource(env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() {
+            try {
+                inner.call(this);
+            } catch (e) {
+                return Promise.reject(e);
+            }
+        };
+        env.stack.push({
+            value: value,
+            dispose: dispose,
+            async: async
+        });
+    } else if (async) {
+        env.stack.push({
+            async: true
+        });
+    }
+    return value;
+}
+function _ts_dispose_resources(env) {
+    var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+    return (_ts_dispose_resources = function _ts_dispose_resources(env) {
+        function fail(e) {
+            env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while(r = env.stack.pop()){
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+                            fail(e);
+                            return next();
+                        });
+                    } else s |= 1;
+                } catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    })(env);
+}
+/**
+ * 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
+ */ function experimental_localLink(opts) {
+    const transformer = getTransformer(opts.transformer);
+    const transformChunk = (chunk)=>{
+        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 = 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) {
+                    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) {
+                    if (isAbortError(cause)) {
+                        return;
+                    }
+                    opts.onError?.({
+                        error: getTRPCErrorFromUnknown(cause),
+                        type: op.type,
+                        path: op.path,
+                        input,
+                        ctx
+                    });
+                }
+                function coerceToTRPCClientError(cause) {
+                    if (isTRPCClientError(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*() {
+                                            const env = {
+                                                stack: [],
+                                                error: void 0,
+                                                hasError: false
+                                            };
+                                            try {
+                                                const iterator = _ts_add_disposable_resource(env, iteratorResource(result), true);
+                                                ;
+                                                const _finally = _ts_add_disposable_resource(env, makeResource({}, ()=>{
+                                                    observer.complete();
+                                                }), false);
+                                                ;
+                                                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);
+                                                }
+                                            } catch (e) {
+                                                env.error = e;
+                                                env.hasError = true;
+                                            } finally{
+                                                const result = _ts_dispose_resources(env);
+                                                if (result) await result;
+                                            }
+                                        }()
+                                    }
+                                });
+                                break;
+                            }
+                        case 'subscription':
+                            {
+                                const env = {
+                                    stack: [],
+                                    error: void 0,
+                                    hasError: false
+                                };
+                                try {
+                                    const connectionState = behaviorSubject({
+                                        type: 'state',
+                                        state: 'connecting',
+                                        error: null
+                                    });
+                                    const connectionSub = connectionState.subscribe({
+                                        next (state) {
+                                            observer.next({
+                                                result: state
+                                            });
+                                        }
+                                    });
+                                    let lastEventId = undefined;
+                                    const _finally = _ts_add_disposable_resource(env, makeResource({}, async ()=>{
+                                        observer.complete();
+                                        connectionState.next({
+                                            type: 'state',
+                                            state: 'idle',
+                                            error: null
+                                        });
+                                        connectionSub.unsubscribe();
+                                    }), false);
+                                    ;
+                                    while(true){
+                                        const env = {
+                                            stack: [],
+                                            error: void 0,
+                                            hasError: false
+                                        };
+                                        try {
+                                            const result = await runProcedure(inputWithTrackedEventId(op.input, lastEventId));
+                                            if (!isAsyncIterable(result)) {
+                                                throw new Error('Expected an async iterable');
+                                            }
+                                            const iterator = _ts_add_disposable_resource(env, iteratorResource(result), true);
+                                            ;
+                                            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;
+                                                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)
+                                                    }
+                                                });
+                                            }
+                                        } catch (e) {
+                                            env.error = e;
+                                            env.hasError = true;
+                                        } finally{
+                                            const result = _ts_dispose_resources(env);
+                                            if (result) await result;
+                                        }
+                                    }
+                                    break;
+                                } catch (e) {
+                                    env.error = e;
+                                    env.hasError = true;
+                                } finally{
+                                    _ts_dispose_resources(env);
+                                }
+                            }
+                    }
+                }).catch((cause)=>{
+                    onErrorCallback(cause);
+                    observer.error(coerceToTRPCClientError(cause));
+                });
+                return ()=>{
+                    ac.abort();
+                };
+            });
+}
+
+export { experimental_localLink };

package/dist/links.d.ts

@@ -8,4 +8,5 @@ export * from './links/splitLink';
 export * from './links/wsLink/wsLink';
 export * from './links/httpSubscriptionLink';
 export * from './links/retryLink';
+export * from './links/localLink';
 //# sourceMappingURL=links.d.ts.map

package/dist/links.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"links.d.ts","sourceRoot":"","sources":["../src/links.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAE9B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"links.d.ts","sourceRoot":"","sources":["../src/links.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAE9B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/client",
-  "version": "11.2.0",
+  "version": "11.2.1-canary.1+e54c2b3ee",
   "description": "The tRPC client library",
   "author": "KATT",
   "license": "MIT",
@@ -77,11 +77,11 @@
     "!**/__tests__"
   ],
   "peerDependencies": {
-    "@trpc/server": "11.2.0",
+    "@trpc/server": "11.2.1-canary.1+e54c2b3ee",
     "typescript": ">=5.7.2"
   },
   "devDependencies": {
-    "@trpc/server": "11.2.0",
+    "@trpc/server": "11.2.1-canary.1+e54c2b3ee",
     "@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": "f308110aeadbdf1a8f11ce9d60002729ccbb28c5"
+  "gitHead": "e54c2b3ee6d9559847e8f3a9710d629c809043ad"
 }

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',