@trpc/server 11.0.0-rc.592 → 11.0.0-rc.593

package/dist/unstable-core-do-not-import/http/resolveResponse.mjs

@@ -1,13 +1,24 @@
 import { isObservable, observableToAsyncIterable } from '../../observable/observable.mjs';
 import { getErrorShape } from '../error/getErrorShape.mjs';
-import { TRPCError, getTRPCErrorFromUnknown } from '../error/TRPCError.mjs';
+import { getTRPCErrorFromUnknown, TRPCError } from '../error/TRPCError.mjs';
 import { jsonlStreamProducer, isPromise } from '../stream/jsonl.mjs';
 import { sseStreamProducer, sseHeaders } from '../stream/sse.mjs';
 import { transformTRPCResponse } from '../transformer.mjs';
-import { abortSignalsAnyPonyfill, assert, isAsyncIterable, isObject } from '../utils.mjs';
+import { run, abortSignalsAnyPonyfill, isAsyncIterable, isObject } from '../utils.mjs';
 import { getRequestInfo } from './contentType.mjs';
 import { getHTTPStatusCode } from './getHTTPStatusCode.mjs';
 
+function errorToAsyncIterable(err) {
+    return {
+        [Symbol.asyncIterator]: ()=>{
+            return {
+                next () {
+                    throw err;
+                }
+            };
+        }
+    };
+}
 const TYPE_ACCEPTED_METHOD_MAP = {
     mutation: [
         'POST'
@@ -135,8 +146,62 @@ async function resolveResponse(opts) {
     }
     const allowBatching = opts.allowBatching ?? opts.batching?.enabled ?? true;
     const allowMethodOverride = (opts.allowMethodOverride ?? false) && req.method === 'POST';
-    let ctx = undefined;
-    let info = undefined;
+    const infoTuple = run(()=>{
+        try {
+            return [
+                undefined,
+                getRequestInfo({
+                    req,
+                    path: decodeURIComponent(opts.path),
+                    router,
+                    searchParams: url.searchParams,
+                    headers: opts.req.headers
+                })
+            ];
+        } catch (cause) {
+            return [
+                getTRPCErrorFromUnknown(cause),
+                undefined
+            ];
+        }
+    });
+    const ctxManager = run(()=>{
+        let result = undefined;
+        return {
+            valueOrUndefined: ()=>{
+                if (!result) {
+                    return undefined;
+                }
+                return result[1];
+            },
+            value: ()=>{
+                const [err, ctx] = result;
+                if (err) {
+                    throw err;
+                }
+                return ctx;
+            },
+            create: async (info)=>{
+                if (result) {
+                    throw new Error('This should only be called once - report a bug in tRPC');
+                }
+                try {
+                    const ctx = await opts.createContext({
+                        info
+                    });
+                    result = [
+                        undefined,
+                        ctx
+                    ];
+                } catch (cause) {
+                    result = [
+                        getTRPCErrorFromUnknown(cause),
+                        undefined
+                    ];
+                }
+            }
+        };
+    });
     const methodMapper = allowMethodOverride ? TYPE_ACCEPTED_METHOD_MAP_WITH_METHOD_OVERRIDE : TYPE_ACCEPTED_METHOD_MAP;
     /**
    * @deprecated
@@ -144,19 +209,9 @@ async function resolveResponse(opts) {
     const experimentalIterablesAndDeferreds = router._def._config.experimental?.iterablesAndDeferreds ?? true;
     const experimentalSSE = router._def._config.experimental?.sseSubscriptions?.enabled ?? true;
     try {
-        info = getRequestInfo({
-            req,
-            path: decodeURIComponent(opts.path),
-            router,
-            searchParams: url.searchParams,
-            headers: opts.req.headers
-        });
-        // we create context early so that error handlers may access context information
-        ctx = await opts.createContext({
-            info
-        });
-        if (opts.error) {
-            throw opts.error;
+        const [infoError, info] = infoTuple;
+        if (infoError) {
+            throw infoError;
         }
         if (info.isBatchCall && !allowBatching) {
             throw new TRPCError({
@@ -170,9 +225,13 @@ async function resolveResponse(opts) {
                 code: 'BAD_REQUEST'
             });
         }
+        await ctxManager.create(info);
         const rpcCalls = info.calls.map(async (call)=>{
             const proc = call.procedure;
             try {
+                if (opts.error) {
+                    throw opts.error;
+                }
                 if (!proc) {
                     throw new TRPCError({
                         code: 'NOT_FOUND',
@@ -185,7 +244,6 @@ async function resolveResponse(opts) {
                         message: `Unsupported ${req.method}-request to ${proc._def.type} procedure at path "${call.path}"`
                     });
                 }
-                let abortCtrl;
                 if (proc._def.type === 'subscription') {
                     /* istanbul ignore if -- @preserve */ if (info.isBatchCall) {
                         throw new TRPCError({
@@ -193,19 +251,20 @@ async function resolveResponse(opts) {
                             message: `Cannot batch subscription calls`
                         });
                     }
-                    abortCtrl = new AbortController();
                 }
+                const abortCtrl = new AbortController();
                 const data = await proc({
                     path: call.path,
                     getRawInput: call.getRawInput,
-                    ctx,
+                    ctx: ctxManager.value(),
                     type: proc._def.type,
-                    signal: abortCtrl ? abortSignalsAnyPonyfill([
+                    signal: abortSignalsAnyPonyfill([
                         opts.req.signal,
                         abortCtrl.signal
-                    ]) : opts.req.signal
+                    ])
                 });
                 return [
+                    undefined,
                     {
                         data,
                         abortCtrl
@@ -218,20 +277,20 @@ async function resolveResponse(opts) {
                     error,
                     path: call.path,
                     input,
-                    ctx,
+                    ctx: ctxManager.valueOrUndefined(),
                     type: call.procedure?._def.type ?? 'unknown',
                     req: opts.req
                 });
                 return [
-                    null,
-                    error
+                    error,
+                    undefined
                 ];
             }
         });
         // ----------- response handlers -----------
         if (!info.isBatchCall) {
             const [call] = info.calls;
-            const [result, error] = await rpcCalls[0];
+            const [error, result] = await rpcCalls[0];
             switch(info.type){
                 case 'unknown':
                 case 'mutation':
@@ -248,7 +307,7 @@ async function resolveResponse(opts) {
                         const res = error ? {
                             error: getErrorShape({
                                 config,
-                                ctx,
+                                ctx: ctxManager.valueOrUndefined(),
                                 error,
                                 input: call.result(),
                                 path: call.path,
@@ -260,7 +319,7 @@ async function resolveResponse(opts) {
                             }
                         };
                         const headResponse = initResponse({
-                            ctx,
+                            ctx: ctxManager.valueOrUndefined(),
                             info,
                             responseMeta: opts.responseMeta,
                             errors: error ? [
@@ -279,48 +338,49 @@ async function resolveResponse(opts) {
                 case 'subscription':
                     {
                         // httpSubscriptionLink
-                        if (!experimentalSSE) {
-                            throw new TRPCError({
-                                code: 'METHOD_NOT_SUPPORTED',
-                                message: 'Missing experimental flag "sseSubscriptions"'
-                            });
-                        }
-                        if (error) {
-                            throw error;
-                        }
-                        const { data , abortCtrl  } = result;
-                        assert(abortCtrl !== undefined, 'subscription type must have an AbortController');
-                        if (!isObservable(data) && !isAsyncIterable(data)) {
-                            throw new TRPCError({
-                                message: `Subscription ${call.path} did not return an observable or a AsyncGenerator`,
-                                code: 'INTERNAL_SERVER_ERROR'
-                            });
-                        }
-                        const dataAsIterable = isObservable(data) ? observableToAsyncIterable(data) : data;
+                        const iterable = run(()=>{
+                            if (error) {
+                                return errorToAsyncIterable(error);
+                            }
+                            if (!experimentalSSE) {
+                                return errorToAsyncIterable(new TRPCError({
+                                    code: 'METHOD_NOT_SUPPORTED',
+                                    message: 'Missing experimental flag "sseSubscriptions"'
+                                }));
+                            }
+                            if (!isObservable(result.data) && !isAsyncIterable(result.data)) {
+                                return errorToAsyncIterable(new TRPCError({
+                                    message: `Subscription ${call.path} did not return an observable or a AsyncGenerator`,
+                                    code: 'INTERNAL_SERVER_ERROR'
+                                }));
+                            }
+                            const dataAsIterable = isObservable(result.data) ? observableToAsyncIterable(result.data) : result.data;
+                            return dataAsIterable;
+                        });
                         const stream = sseStreamProducer({
                             ...config.experimental?.sseSubscriptions,
-                            data: dataAsIterable,
-                            abortCtrl,
+                            data: iterable,
+                            abortCtrl: result?.abortCtrl ?? new AbortController(),
                             serialize: (v)=>config.transformer.output.serialize(v),
                             formatError (errorOpts) {
                                 const error = getTRPCErrorFromUnknown(errorOpts.error);
                                 const input = call?.result();
                                 const path = call?.path;
                                 const type = call?.procedure?._def.type ?? 'unknown';
-                                const shape = getErrorShape({
-                                    config,
-                                    ctx,
+                                opts.onError?.({
                                     error,
-                                    input,
                                     path,
+                                    input,
+                                    ctx: ctxManager.valueOrUndefined(),
+                                    req: opts.req,
                                     type
                                 });
-                                opts.onError?.({
+                                const shape = getErrorShape({
+                                    config,
+                                    ctx: ctxManager.valueOrUndefined(),
                                     error,
-                                    path,
                                     input,
-                                    ctx,
-                                    req: opts.req,
+                                    path,
                                     type
                                 });
                                 return shape;
@@ -330,7 +390,7 @@ async function resolveResponse(opts) {
                             headers.set(key, value);
                         }
                         const headResponse1 = initResponse({
-                            ctx,
+                            ctx: ctxManager.valueOrUndefined(),
                             info,
                             responseMeta: opts.responseMeta,
                             errors: [],
@@ -350,7 +410,7 @@ async function resolveResponse(opts) {
             headers.set('content-type', 'application/json');
             headers.set('transfer-encoding', 'chunked');
             const headResponse2 = initResponse({
-                ctx,
+                ctx: ctxManager.valueOrUndefined(),
                 info,
                 responseMeta: opts.responseMeta,
                 errors: [],
@@ -372,13 +432,13 @@ async function resolveResponse(opts) {
          * }
          */ maxDepth: experimentalIterablesAndDeferreds ? 4 : 3,
                 data: rpcCalls.map(async (res)=>{
-                    const [result, error] = await res;
+                    const [error, result] = await res;
                     const call = info.calls[0];
                     if (error) {
                         return {
                             error: getErrorShape({
                                 config,
-                                ctx,
+                                ctx: ctxManager.valueOrUndefined(),
                                 error,
                                 input: call.result(),
                                 path: call.path,
@@ -386,14 +446,13 @@ async function resolveResponse(opts) {
                             })
                         };
                     }
-                    const { data  } = result;
                     /**
            * Not very pretty, but we need to wrap nested data in promises
            * Our stream producer will only resolve top-level async values or async values that are directly nested in another async value
-           */ const dataAsPromiseOrIterable = isObservable(data) ? observableToAsyncIterable(data) : Promise.resolve(data);
+           */ const iterable = isObservable(result.data) ? observableToAsyncIterable(result.data) : Promise.resolve(result.data);
                     return {
                         result: Promise.resolve({
-                            data: dataAsPromiseOrIterable
+                            data: iterable
                         })
                     };
                 }),
@@ -403,20 +462,25 @@ async function resolveResponse(opts) {
                         error: getTRPCErrorFromUnknown(cause),
                         path: undefined,
                         input: undefined,
-                        ctx,
+                        ctx: ctxManager.valueOrUndefined(),
                         req: opts.req,
                         type: info?.type ?? 'unknown'
                     });
                 },
                 formatError (errorOpts) {
                     const call = info?.calls[errorOpts.path[0]];
+                    const error = getTRPCErrorFromUnknown(errorOpts.error);
+                    const input = call?.result();
+                    const path = call?.path;
+                    const type = call?.procedure?._def.type ?? 'unknown';
+                    // no need to call `onError` here as it will be propagated through the stream itself
                     const shape = getErrorShape({
                         config,
-                        ctx,
-                        error: getTRPCErrorFromUnknown(errorOpts.error),
-                        input: call?.result(),
-                        path: call?.path,
-                        type: call?.procedure?._def.type ?? 'unknown'
+                        ctx: ctxManager.valueOrUndefined(),
+                        error,
+                        input,
+                        path,
+                        type
                     });
                     return shape;
                 }
@@ -434,28 +498,28 @@ async function resolveResponse(opts) {
      * - return a complete HTTPResponse
      */ headers.set('content-type', 'application/json');
         const results = (await Promise.all(rpcCalls)).map((res)=>{
-            const [result, error] = res;
+            const [error, result] = res;
             if (error) {
                 return res;
             }
             if (isDataStream(result.data)) {
                 return [
-                    null,
                     new TRPCError({
                         code: 'UNSUPPORTED_MEDIA_TYPE',
                         message: 'Cannot use stream-like response in non-streaming request - use httpBatchStreamLink'
-                    })
+                    }),
+                    undefined
                 ];
             }
             return res;
         });
-        const resultAsRPCResponse = results.map(([result, error], index)=>{
+        const resultAsRPCResponse = results.map(([error, result], index)=>{
             const call = info.calls[index];
             if (error) {
                 return {
                     error: getErrorShape({
                         config,
-                        ctx,
+                        ctx: ctxManager.valueOrUndefined(),
                         error,
                         input: call.result(),
                         path: call.path,
@@ -469,9 +533,9 @@ async function resolveResponse(opts) {
                 }
             };
         });
-        const errors = results.map(([_, error])=>error).filter(Boolean);
+        const errors = results.map(([error])=>error).filter(Boolean);
         const headResponse3 = initResponse({
-            ctx,
+            ctx: ctxManager.valueOrUndefined(),
             info,
             responseMeta: opts.responseMeta,
             untransformedJSON: resultAsRPCResponse,
@@ -483,6 +547,8 @@ async function resolveResponse(opts) {
             headers
         });
     } catch (cause) {
+        const [_infoError, info1] = infoTuple;
+        const ctx = ctxManager.valueOrUndefined();
         // we get here if
         // - batching is called when it's not enabled
         // - `createContext()` throws
@@ -492,12 +558,12 @@ async function resolveResponse(opts) {
         // - `errorFormatter` return value is malformed
         const { error: error1 , untransformedJSON , body  } = caughtErrorToData(cause, {
             opts,
-            ctx,
-            type: info?.type ?? 'unknown'
+            ctx: ctxManager.valueOrUndefined(),
+            type: info1?.type ?? 'unknown'
         });
         const headResponse4 = initResponse({
             ctx,
-            info,
+            info: info1,
             responseMeta: opts.responseMeta,
             untransformedJSON,
             errors: [

package/dist/unstable-core-do-not-import/stream/sse.d.ts

@@ -1,4 +1,5 @@
 import type { MaybePromise } from '../types';
+import type { EventSourceLike } from './sse.types';
 import type { inferTrackedOutput } from './tracked';
 type Serialize = (value: any) => any;
 type Deserialize = (value: any) => any;
@@ -44,41 +45,41 @@ export interface SSEStreamProducerOptions<TValue = unknown> {
  * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
  */
 export declare function sseStreamProducer<TValue = unknown>(opts: SSEStreamProducerOptions<TValue>): ReadableStream<string>;
-interface ConsumerStreamResultBase {
-    eventSource: EventSource;
+interface ConsumerStreamResultBase<TConfig extends ConsumerConfig> {
+    eventSource: InstanceType<TConfig['EventSource']>;
 }
-interface ConsumerStreamResultData<TData> extends ConsumerStreamResultBase {
+interface ConsumerStreamResultData<TConfig extends ConsumerConfig> extends ConsumerStreamResultBase<TConfig> {
     type: 'data';
-    data: inferTrackedOutput<TData>;
+    data: inferTrackedOutput<TConfig['data']>;
 }
-interface ConsumerStreamResultError extends ConsumerStreamResultBase {
-    type: 'error';
-    error: unknown;
+interface ConsumerStreamResultError<TConfig extends ConsumerConfig> extends ConsumerStreamResultBase<TConfig> {
+    type: 'serialized-error';
+    error: TConfig['error'];
 }
-interface ConsumerStreamResultOpened extends ConsumerStreamResultBase {
+interface ConsumerStreamResultOpened<TConfig extends ConsumerConfig> extends ConsumerStreamResultBase<TConfig> {
     type: 'opened';
 }
-interface ConsumerStreamResultConnecting extends ConsumerStreamResultBase {
+interface ConsumerStreamResultConnecting<TConfig extends ConsumerConfig> extends ConsumerStreamResultBase<TConfig> {
     type: 'connecting';
+    event: EventSourceLike.EventOf<TConfig['EventSource']> | null;
 }
-type ConsumerStreamResult<TData> = ConsumerStreamResultData<TData> | ConsumerStreamResultError | ConsumerStreamResultOpened | ConsumerStreamResultConnecting;
-export interface SSEStreamConsumerOptions {
+type ConsumerStreamResult<TConfig extends ConsumerConfig> = ConsumerStreamResultData<TConfig> | ConsumerStreamResultError<TConfig> | ConsumerStreamResultOpened<TConfig> | ConsumerStreamResultConnecting<TConfig>;
+export interface SSEStreamConsumerOptions<TConfig extends ConsumerConfig> {
     url: () => MaybePromise<string>;
-    init: () => MaybePromise<EventSourceInit> | undefined;
+    init: () => MaybePromise<EventSourceLike.InitDictOf<TConfig['EventSource']>> | undefined;
     signal: AbortSignal;
-    shouldRecreateOnError?: (opts: {
-        type: 'event';
-        event: Event;
-    } | {
-        type: 'serialized-error';
-        error: unknown;
-    }) => boolean | Promise<boolean>;
     deserialize?: Deserialize;
+    EventSource: TConfig['EventSource'];
+}
+interface ConsumerConfig {
+    data: unknown;
+    error: unknown;
+    EventSource: EventSourceLike.AnyConstructor;
 }
 /**
  * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
  */
-export declare function sseStreamConsumer<TData>(opts: SSEStreamConsumerOptions): AsyncIterable<ConsumerStreamResult<TData>>;
+export declare function sseStreamConsumer<TConfig extends ConsumerConfig>(opts: SSEStreamConsumerOptions<TConfig>): AsyncIterable<ConsumerStreamResult<TConfig>>;
 export declare const sseHeaders: {
     readonly 'Content-Type': "text/event-stream";
     readonly 'Cache-Control': "no-cache, no-transform";

package/dist/unstable-core-do-not-import/stream/sse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../../../src/unstable-core-do-not-import/stream/sse.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AASpD,KAAK,SAAS,GAAG,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC;AACrC,KAAK,WAAW,GAAG,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC;AAEvC;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,wBAAwB,CAAC,MAAM,GAAG,OAAO;IACxD,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC5B,SAAS,EAAE,eAAe,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO,CAAC;CACrD;AAUD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,GAAG,OAAO,EAChD,IAAI,EAAE,wBAAwB,CAAC,MAAM,CAAC,0BAkGvC;AAED,UAAU,wBAAwB;IAChC,WAAW,EAAE,WAAW,CAAC;CAC1B;AAED,UAAU,wBAAwB,CAAC,KAAK,CAAE,SAAQ,wBAAwB;IACxE,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,kBAAkB,CAAC,KAAK,CAAC,CAAC;CACjC;AAED,UAAU,yBAA0B,SAAQ,wBAAwB;IAClE,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,UAAU,0BAA2B,SAAQ,wBAAwB;IACnE,IAAI,EAAE,QAAQ,CAAC;CAChB;AAED,UAAU,8BAA+B,SAAQ,wBAAwB;IACvE,IAAI,EAAE,YAAY,CAAC;CACpB;AAED,KAAK,oBAAoB,CAAC,KAAK,IAC3B,wBAAwB,CAAC,KAAK,CAAC,GAC/B,yBAAyB,GACzB,0BAA0B,GAC1B,8BAA8B,CAAC;AAEnC,MAAM,WAAW,wBAAwB;IACvC,GAAG,EAAE,MAAM,YAAY,CAAC,MAAM,CAAC,CAAC;IAChC,IAAI,EAAE,MAAM,YAAY,CAAC,eAAe,CAAC,GAAG,SAAS,CAAC;IACtD,MAAM,EAAE,WAAW,CAAC;IACpB,qBAAqB,CAAC,EAAE,CACtB,IAAI,EACA;QACE,IAAI,EAAE,OAAO,CAAC;QACd,KAAK,EAAE,KAAK,CAAC;KACd,GACD;QACE,IAAI,EAAE,kBAAkB,CAAC;QACzB,KAAK,EAAE,OAAO,CAAC;KAChB,KACF,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAChC,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;AACD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EACrC,IAAI,EAAE,wBAAwB,GAC7B,aAAa,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC,CAkL5C;AAED,eAAO,MAAM,UAAU;;;;;CAKb,CAAC"}
+{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../../../src/unstable-core-do-not-import/stream/sse.ts"],"names":[],"mappings":"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"}