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

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

@@ -10,6 +10,11 @@ var utils = require('../utils.js');
 var contentType = require('./contentType.js');
 var getHTTPStatusCode = require('./getHTTPStatusCode.js');
 
+function errorToAsyncIterable(err) {
+    return utils.run(async function*() {
+        throw err;
+    });
+}
 const TYPE_ACCEPTED_METHOD_MAP = {
     mutation: [
         'POST'
@@ -36,7 +41,7 @@ const TYPE_ACCEPTED_METHOD_MAP_WITH_METHOD_OVERRIDE = {
     ]
 };
 function initResponse(initOpts) {
-    const { ctx , info , responseMeta , untransformedJSON , errors =[] , headers ,  } = initOpts;
+    const { ctx, info, responseMeta, untransformedJSON, errors = [], headers } = initOpts;
     let status = untransformedJSON ? getHTTPStatusCode.getHTTPStatusCode(untransformedJSON) : 200;
     const eagerGeneration = !untransformedJSON;
     const data = eagerGeneration ? [] : Array.isArray(untransformedJSON) ? untransformedJSON : [
@@ -59,13 +64,13 @@ function initResponse(initOpts) {
         } else {
             /**
        * @deprecated, delete in v12
-       */ for (const [key1, value1] of Object.entries(meta.headers)){
-                if (Array.isArray(value1)) {
-                    for (const v of value1){
-                        headers.append(key1, v);
+       */ for (const [key, value] of Object.entries(meta.headers)){
+                if (Array.isArray(value)) {
+                    for (const v of value){
+                        headers.append(key, v);
                     }
-                } else if (typeof value1 === 'string') {
-                    headers.set(key1, value1);
+                } else if (typeof value === 'string') {
+                    headers.set(key, value);
                 }
             }
         }
@@ -78,7 +83,7 @@ function initResponse(initOpts) {
     };
 }
 function caughtErrorToData(cause, errorOpts) {
-    const { router , req , onError  } = errorOpts.opts;
+    const { router, req, onError } = errorOpts.opts;
     const error = TRPCError.getTRPCErrorFromUnknown(cause);
     onError?.({
         error,
@@ -120,7 +125,7 @@ function caughtErrorToData(cause, errorOpts) {
     return Object.values(v).some(jsonl.isPromise) || Object.values(v).some(utils.isAsyncIterable);
 }
 async function resolveResponse(opts) {
-    const { router , req  } = opts;
+    const { router, req } = opts;
     const headers = new Headers([
         [
             'vary',
@@ -137,28 +142,72 @@ 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 = utils.run(()=>{
+        try {
+            return [
+                undefined,
+                contentType.getRequestInfo({
+                    req,
+                    path: decodeURIComponent(opts.path),
+                    router,
+                    searchParams: url.searchParams,
+                    headers: opts.req.headers
+                })
+            ];
+        } catch (cause) {
+            return [
+                TRPCError.getTRPCErrorFromUnknown(cause),
+                undefined
+            ];
+        }
+    });
+    const ctxManager = utils.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 = [
+                        TRPCError.getTRPCErrorFromUnknown(cause),
+                        undefined
+                    ];
+                }
+            }
+        };
+    });
     const methodMapper = allowMethodOverride ? TYPE_ACCEPTED_METHOD_MAP_WITH_METHOD_OVERRIDE : TYPE_ACCEPTED_METHOD_MAP;
     /**
    * @deprecated
    */ const isStreamCall = req.headers.get('trpc-accept') === 'application/jsonl';
-    const experimentalIterablesAndDeferreds = router._def._config.experimental?.iterablesAndDeferreds ?? true;
-    const experimentalSSE = router._def._config.experimental?.sseSubscriptions?.enabled ?? true;
+    const experimentalIterablesAndDeferreds = config.iterablesAndDeferreds ?? true;
+    const experimentalSSE = config.sse?.enabled ?? true;
     try {
-        info = contentType.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.TRPCError({
@@ -172,9 +221,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.TRPCError({
                         code: 'NOT_FOUND',
@@ -187,20 +240,26 @@ async function resolveResponse(opts) {
                         message: `Unsupported ${req.method}-request to ${proc._def.type} procedure at path "${call.path}"`
                     });
                 }
-                /* istanbul ignore if -- @preserve */ if (proc._def.type === 'subscription' && info.isBatchCall) {
-                    throw new TRPCError.TRPCError({
-                        code: 'BAD_REQUEST',
-                        message: `Cannot batch subscription calls`
-                    });
+                if (proc._def.type === 'subscription') {
+                    /* istanbul ignore if -- @preserve */ if (info.isBatchCall) {
+                        throw new TRPCError.TRPCError({
+                            code: 'BAD_REQUEST',
+                            message: `Cannot batch subscription calls`
+                        });
+                    }
                 }
                 const data = await proc({
                     path: call.path,
                     getRawInput: call.getRawInput,
-                    ctx,
-                    type: proc._def.type
+                    ctx: ctxManager.value(),
+                    type: proc._def.type,
+                    signal: opts.req.signal
                 });
                 return [
-                    data
+                    undefined,
+                    {
+                        data
+                    }
                 ];
             } catch (cause) {
                 const error = TRPCError.getTRPCErrorFromUnknown(cause);
@@ -209,20 +268,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 [data, error] = await rpcCalls[0];
+            const [error, result] = await rpcCalls[0];
             switch(info.type){
                 case 'unknown':
                 case 'mutation':
@@ -230,7 +289,7 @@ async function resolveResponse(opts) {
                     {
                         // httpLink
                         headers.set('content-type', 'application/json');
-                        if (isDataStream(data)) {
+                        if (isDataStream(result?.data)) {
                             throw new TRPCError.TRPCError({
                                 code: 'UNSUPPORTED_MEDIA_TYPE',
                                 message: 'Cannot use stream-like response in non-streaming request - use httpBatchStreamLink'
@@ -239,7 +298,7 @@ async function resolveResponse(opts) {
                         const res = error ? {
                             error: getErrorShape.getErrorShape({
                                 config,
-                                ctx,
+                                ctx: ctxManager.valueOrUndefined(),
                                 error,
                                 input: call.result(),
                                 path: call.path,
@@ -247,11 +306,11 @@ async function resolveResponse(opts) {
                             })
                         } : {
                             result: {
-                                data
+                                data: result.data
                             }
                         };
                         const headResponse = initResponse({
-                            ctx,
+                            ctx: ctxManager.valueOrUndefined(),
                             info,
                             responseMeta: opts.responseMeta,
                             errors: error ? [
@@ -270,31 +329,49 @@ async function resolveResponse(opts) {
                 case 'subscription':
                     {
                         // httpSubscriptionLink
-                        if (!experimentalSSE) {
-                            throw new TRPCError.TRPCError({
-                                code: 'METHOD_NOT_SUPPORTED',
-                                message: 'Missing experimental flag "sseSubscriptions"'
-                            });
-                        }
-                        if (!observable.isObservable(data) && !utils.isAsyncIterable(data)) {
-                            throw new TRPCError.TRPCError({
-                                message: `Subscription ${call.path} did not return an observable or a AsyncGenerator`,
-                                code: 'INTERNAL_SERVER_ERROR'
-                            });
-                        }
-                        const dataAsIterable = observable.isObservable(data) ? observable.observableToAsyncIterable(data) : data;
+                        const iterable = utils.run(()=>{
+                            if (error) {
+                                return errorToAsyncIterable(error);
+                            }
+                            if (!experimentalSSE) {
+                                return errorToAsyncIterable(new TRPCError.TRPCError({
+                                    code: 'METHOD_NOT_SUPPORTED',
+                                    message: 'Missing experimental flag "sseSubscriptions"'
+                                }));
+                            }
+                            if (!observable.isObservable(result.data) && !utils.isAsyncIterable(result.data)) {
+                                return errorToAsyncIterable(new TRPCError.TRPCError({
+                                    message: `Subscription ${call.path} did not return an observable or a AsyncGenerator`,
+                                    code: 'INTERNAL_SERVER_ERROR'
+                                }));
+                            }
+                            const dataAsIterable = observable.isObservable(result.data) ? observable.observableToAsyncIterable(result.data, opts.req.signal) : result.data;
+                            return dataAsIterable;
+                        });
                         const stream = sse.sseStreamProducer({
-                            ...config.experimental?.sseSubscriptions,
-                            data: dataAsIterable,
+                            ...config.sse,
+                            data: iterable,
                             serialize: (v)=>config.transformer.output.serialize(v),
                             formatError (errorOpts) {
+                                const error = TRPCError.getTRPCErrorFromUnknown(errorOpts.error);
+                                const input = call?.result();
+                                const path = call?.path;
+                                const type = call?.procedure?._def.type ?? 'unknown';
+                                opts.onError?.({
+                                    error,
+                                    path,
+                                    input,
+                                    ctx: ctxManager.valueOrUndefined(),
+                                    req: opts.req,
+                                    type
+                                });
                                 const shape = getErrorShape.getErrorShape({
                                     config,
-                                    ctx,
-                                    error: TRPCError.getTRPCErrorFromUnknown(errorOpts.error),
-                                    input: call?.result(),
-                                    path: call?.path,
-                                    type: call?.procedure?._def.type ?? 'unknown'
+                                    ctx: ctxManager.valueOrUndefined(),
+                                    error,
+                                    input,
+                                    path,
+                                    type
                                 });
                                 return shape;
                             }
@@ -302,8 +379,8 @@ async function resolveResponse(opts) {
                         for (const [key, value] of Object.entries(sse.sseHeaders)){
                             headers.set(key, value);
                         }
-                        const headResponse1 = initResponse({
-                            ctx,
+                        const headResponse = initResponse({
+                            ctx: ctxManager.valueOrUndefined(),
                             info,
                             responseMeta: opts.responseMeta,
                             errors: [],
@@ -312,7 +389,7 @@ async function resolveResponse(opts) {
                         });
                         return new Response(stream, {
                             headers,
-                            status: headResponse1.status
+                            status: headResponse.status
                         });
                     }
             }
@@ -322,15 +399,15 @@ async function resolveResponse(opts) {
             // httpBatchStreamLink
             headers.set('content-type', 'application/json');
             headers.set('transfer-encoding', 'chunked');
-            const headResponse2 = initResponse({
-                ctx,
+            const headResponse = initResponse({
+                ctx: ctxManager.valueOrUndefined(),
                 info,
                 responseMeta: opts.responseMeta,
                 errors: [],
                 headers,
                 untransformedJSON: null
             });
-            const stream1 = jsonl.jsonlStreamProducer({
+            const stream = jsonl.jsonlStreamProducer({
                 /**
          * Example structure for `maxDepth: 4`:
          * {
@@ -345,13 +422,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.getErrorShape({
                                 config,
-                                ctx,
+                                ctx: ctxManager.valueOrUndefined(),
                                 error,
                                 input: call.result(),
                                 path: call.path,
@@ -362,10 +439,10 @@ async function resolveResponse(opts) {
                     /**
            * 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 data = observable.isObservable(result) ? observable.observableToAsyncIterable(result) : Promise.resolve(result);
+           */ const iterable = observable.isObservable(result.data) ? observable.observableToAsyncIterable(result.data, opts.req.signal) : Promise.resolve(result.data);
                     return {
                         result: Promise.resolve({
-                            data
+                            data: iterable
                         })
                     };
                 }),
@@ -375,27 +452,32 @@ async function resolveResponse(opts) {
                         error: TRPCError.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 = TRPCError.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.getErrorShape({
                         config,
-                        ctx,
-                        error: TRPCError.getTRPCErrorFromUnknown(errorOpts.error),
-                        input: call?.result(),
-                        path: call?.path,
-                        type: call?.procedure?._def.type ?? 'unknown'
+                        ctx: ctxManager.valueOrUndefined(),
+                        error,
+                        input,
+                        path,
+                        type
                     });
                     return shape;
                 }
             });
-            return new Response(stream1, {
+            return new Response(stream, {
                 headers,
-                status: headResponse2.status
+                status: headResponse.status
             });
         }
         // httpBatchLink
@@ -406,28 +488,28 @@ async function resolveResponse(opts) {
      * - return a complete HTTPResponse
      */ headers.set('content-type', 'application/json');
         const results = (await Promise.all(rpcCalls)).map((res)=>{
-            const [data, error] = res;
+            const [error, result] = res;
             if (error) {
                 return res;
             }
-            if (isDataStream(data)) {
+            if (isDataStream(result.data)) {
                 return [
-                    null,
                     new TRPCError.TRPCError({
                         code: 'UNSUPPORTED_MEDIA_TYPE',
                         message: 'Cannot use stream-like response in non-streaming request - use httpBatchStreamLink'
-                    })
+                    }),
+                    undefined
                 ];
             }
             return res;
         });
-        const resultAsRPCResponse = results.map(([data, error], index)=>{
+        const resultAsRPCResponse = results.map(([error, result], index)=>{
             const call = info.calls[index];
             if (error) {
                 return {
                     error: getErrorShape.getErrorShape({
                         config,
-                        ctx,
+                        ctx: ctxManager.valueOrUndefined(),
                         error,
                         input: call.result(),
                         path: call.path,
@@ -437,13 +519,13 @@ async function resolveResponse(opts) {
             }
             return {
                 result: {
-                    data
+                    data: result.data
                 }
             };
         });
-        const errors = results.map(([_, error])=>error).filter(Boolean);
-        const headResponse3 = initResponse({
-            ctx,
+        const errors = results.map(([error])=>error).filter(Boolean);
+        const headResponse = initResponse({
+            ctx: ctxManager.valueOrUndefined(),
             info,
             responseMeta: opts.responseMeta,
             untransformedJSON: resultAsRPCResponse,
@@ -451,10 +533,12 @@ async function resolveResponse(opts) {
             headers
         });
         return new Response(JSON.stringify(transformer.transformTRPCResponse(config, resultAsRPCResponse)), {
-            status: headResponse3.status,
+            status: headResponse.status,
             headers
         });
     } catch (cause) {
+        const [_infoError, info] = infoTuple;
+        const ctx = ctxManager.valueOrUndefined();
         // we get here if
         // - batching is called when it's not enabled
         // - `createContext()` throws
@@ -462,23 +546,23 @@ async function resolveResponse(opts) {
         // - post body is too large
         // - input deserialization fails
         // - `errorFormatter` return value is malformed
-        const { error: error1 , untransformedJSON , body  } = caughtErrorToData(cause, {
+        const { error, untransformedJSON, body } = caughtErrorToData(cause, {
             opts,
-            ctx,
+            ctx: ctxManager.valueOrUndefined(),
             type: info?.type ?? 'unknown'
         });
-        const headResponse4 = initResponse({
+        const headResponse = initResponse({
             ctx,
             info,
             responseMeta: opts.responseMeta,
             untransformedJSON,
             errors: [
-                error1
+                error
             ],
             headers
         });
         return new Response(body, {
-            status: headResponse4.status,
+            status: headResponse.status,
             headers
         });
     }