@trpc/client 11.2.0 → 11.2.1-canary.1

package/dist/links/localLink.d.ts

@@ -0,0 +1,15 @@
+import { type AnyRouter, type ErrorHandlerOptions, type inferClientTypes, type inferRouterContext } from '@trpc/server/unstable-core-do-not-import';
+import type { TransformerOptions } from '../internals/transformer';
+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 declare function experimental_localLink<TRouter extends AnyRouter>(opts: LocalLinkOptions<TRouter>): TRPCLink<TRouter>;
+//# sourceMappingURL=localLink.d.ts.map

package/dist/links/localLink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localLink.d.ts","sourceRoot":"","sources":["../../src/links/localLink.ts"],"names":[],"mappings":"AAOA,OAAO,EAQL,KAAK,SAAS,EACd,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACxB,MAAM,0CAA0C,CAAC;AAIlD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAGnE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,MAAM,MAAM,gBAAgB,CAAC,OAAO,SAAS,SAAS,IAAI;IACxD,MAAM,EAAE,OAAO,CAAC;IAChB,aAAa,EAAE,MAAM,OAAO,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAAC;IAC1D,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,mBAAmB,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,KAAK,IAAI,CAAC;CAC5E,GAAG,kBAAkB,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC;AAElD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,SAAS,SAAS,EAC9D,IAAI,EAAE,gBAAgB,CAAC,OAAO,CAAC,GAC9B,QAAQ,CAAC,OAAO,CAAC,CA2OnB"}

package/dist/links/localLink.js

@@ -0,0 +1,333 @@
+'use strict';
+
+var server = require('@trpc/server');
+var observable = require('@trpc/server/observable');
+var rpc = require('@trpc/server/rpc');
+var unstableCoreDoNotImport = require('@trpc/server/unstable-core-do-not-import');
+var inputWithTrackedEventId = require('../internals/inputWithTrackedEventId.js');
+var signals = require('../internals/signals.js');
+var transformer = require('../internals/transformer.js');
+var TRPCClientError = require('../TRPCClientError.js');
+
+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$1 = 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$1.input.serialize(chunk));
+        const deserialized = JSON.parse(transformer$1.output.deserialize(serialized));
+        return deserialized;
+    };
+    return ()=>({ op })=>observable.observable((observer)=>{
+                let ctx = undefined;
+                const ac = new AbortController();
+                const signal = signals.raceAbortSignals(op.signal, ac.signal);
+                const signalPromise = signals.abortSignalToPromise(signal);
+                signalPromise.catch(()=>{
+                // prevent unhandled rejection
+                });
+                let input = op.input;
+                async function runProcedure(newInput) {
+                    input = newInput;
+                    ctx = await opts.createContext();
+                    return unstableCoreDoNotImport.callProcedure({
+                        router: opts.router,
+                        path: op.path,
+                        getRawInput: async ()=>newInput,
+                        ctx,
+                        type: op.type,
+                        signal
+                    });
+                }
+                function onErrorCallback(cause) {
+                    if (unstableCoreDoNotImport.isAbortError(cause)) {
+                        return;
+                    }
+                    opts.onError?.({
+                        error: server.getTRPCErrorFromUnknown(cause),
+                        type: op.type,
+                        path: op.path,
+                        input,
+                        ctx
+                    });
+                }
+                function coerceToTRPCClientError(cause) {
+                    if (TRPCClientError.isTRPCClientError(cause)) {
+                        return cause;
+                    }
+                    const error = server.getTRPCErrorFromUnknown(cause);
+                    const shape = server.getTRPCErrorShape({
+                        config: opts.router._def._config,
+                        ctx,
+                        error,
+                        input,
+                        path: op.path,
+                        type: op.type
+                    });
+                    return TRPCClientError.TRPCClientError.from({
+                        error: transformChunk(shape)
+                    });
+                }
+                unstableCoreDoNotImport.run(async ()=>{
+                    switch(op.type){
+                        case 'query':
+                        case 'mutation':
+                            {
+                                const result = await runProcedure(op.input);
+                                if (!unstableCoreDoNotImport.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, unstableCoreDoNotImport.iteratorResource(result), true);
+                                                ;
+                                                const _finally = _ts_add_disposable_resource(env, unstableCoreDoNotImport.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 = observable.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, unstableCoreDoNotImport.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.inputWithTrackedEventId(op.input, lastEventId));
+                                            if (!unstableCoreDoNotImport.isAsyncIterable(result)) {
+                                                throw new Error('Expected an async iterable');
+                                            }
+                                            const iterator = _ts_add_disposable_resource(env, unstableCoreDoNotImport.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 (unstableCoreDoNotImport.isAbortError(cause)) {
+                                                        return;
+                                                    }
+                                                    const error = server.getTRPCErrorFromUnknown(cause);
+                                                    if (!unstableCoreDoNotImport.retryableRpcCodes.includes(rpc.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 (server.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();
+                };
+            });
+}
+
+exports.experimental_localLink = experimental_localLink;