@trpc/server 11.0.0-rc.361 → 11.0.0-rc.362

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

@@ -4,6 +4,8 @@ var getErrorShape = require('../error/getErrorShape.js');
 var TRPCError = require('../error/TRPCError.js');
 var router = require('../router.js');
 var transformer = require('../transformer.js');
+var batchStreamFormatter = require('./batchStreamFormatter.js');
+var contentType = require('./contentType.js');
 var getHTTPStatusCode = require('./getHTTPStatusCode.js');
 
 const HTTP_METHOD_PROCEDURE_TYPE_MAP = {
@@ -11,25 +13,45 @@ const HTTP_METHOD_PROCEDURE_TYPE_MAP = {
     POST: 'mutation'
 };
 function initResponse(initOpts) {
-    const { ctx , paths , type , responseMeta , untransformedJSON , errors =[] ,  } = initOpts;
+    const { ctx , info , type , responseMeta , untransformedJSON , errors =[] ,  } = initOpts;
     let status = untransformedJSON ? getHTTPStatusCode.getHTTPStatusCode(untransformedJSON) : 200;
-    const headers = {
-        'Content-Type': 'application/json'
-    };
+    const headers = new Headers([
+        [
+            'Content-Type',
+            'application/json'
+        ]
+    ]);
     const eagerGeneration = !untransformedJSON;
     const data = eagerGeneration ? [] : Array.isArray(untransformedJSON) ? untransformedJSON : [
         untransformedJSON
     ];
     const meta = responseMeta?.({
         ctx,
-        paths,
+        info,
+        paths: info?.calls.map((call)=>call.path),
         type,
         data,
         errors,
         eagerGeneration
     }) ?? {};
-    for (const [key, value] of Object.entries(meta.headers ?? {})){
-        headers[key] = value;
+    if (meta.headers) {
+        if (meta.headers instanceof Headers) {
+            for (const [key, value] of meta.headers.entries()){
+                headers.append(key, value);
+            }
+        } 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);
+                    }
+                } else if (typeof value1 === 'string') {
+                    headers.set(key1, value1);
+                }
+            }
+        }
     }
     if (meta.status) {
         status = meta.status;
@@ -68,79 +90,54 @@ function caughtErrorToData(cause, errorOpts) {
         body
     };
 }
-// implementation
-async function resolveHTTPResponse(opts) {
-    const { router: router$1 , req , unstable_onHead , unstable_onChunk  } = opts;
+async function resolveResponse(opts) {
+    const { router: router$1 , req  } = opts;
+    const url = new URL(req.url);
     if (req.method === 'HEAD') {
         // can be used for lambda warmup
-        const headResponse = {
+        return new Response(null, {
             status: 204
-        };
-        unstable_onHead?.(headResponse, false);
-        unstable_onChunk?.([
-            -1,
-            ''
-        ]);
-        return headResponse;
+        });
     }
     const allowBatching = opts.allowBatching ?? opts.batching?.enabled ?? true;
-    const allowMethodOverride = opts.allowMethodOverride ?? false;
+    const allowMethodOverride = (opts.allowMethodOverride ?? false) && req.method === 'POST';
     const type = HTTP_METHOD_PROCEDURE_TYPE_MAP[req.method] ?? 'unknown';
     let ctx = undefined;
-    let paths;
-    const isBatchCall = !!req.query.get('batch');
-    const isStreamCall = isBatchCall && unstable_onHead && unstable_onChunk && req.headers['trpc-batch-mode'] === 'stream';
+    let info = undefined;
+    const isStreamCall = req.headers.get('trpc-batch-mode') === 'stream';
     try {
-        if (isBatchCall && !allowBatching) {
+        info = contentType.getRequestInfo({
+            req,
+            path: decodeURIComponent(opts.path),
+            config: router$1._def._config,
+            searchParams: url.searchParams
+        });
+        // we create context early so that error handlers may access context information
+        ctx = await opts.createContext({
+            info
+        });
+        if (opts.error) {
+            throw opts.error;
+        }
+        if (info.isBatchCall && !allowBatching) {
             throw new TRPCError.TRPCError({
                 code: 'BAD_REQUEST',
                 message: `Batching is not enabled on the server`
             });
         }
-        /* istanbul ignore if -- @preserve */ if (type === 'subscription') {
-            throw new TRPCError.TRPCError({
-                message: 'Subscriptions should use wsLink',
-                code: 'METHOD_NOT_SUPPORTED'
-            });
-        }
         if (type === 'unknown') {
             throw new TRPCError.TRPCError({
                 message: `Unexpected request method ${req.method}`,
                 code: 'METHOD_NOT_SUPPORTED'
             });
         }
-        paths = isBatchCall ? decodeURIComponent(opts.path).split(',') : [
-            opts.path
-        ];
-        const info = {
-            isBatchCall,
-            calls: paths.map((path)=>({
-                    path,
-                    type
-                }))
-        };
-        ctx = await opts.createContext({
-            info
-        });
         const errors = [];
-        const promises = paths.map(async (path, index)=>{
-            async function getRawInput() {
-                return await opts.getInput({
-                    isBatchCall,
-                    batch: index
-                });
-            }
+        const promises = info.calls.map(async (call)=>{
             try {
-                if (opts.error) {
-                    // sometimes an error may be generated above this function in the stack
-                    // for instance a 405 error if the method is not supported
-                    // But we need to handle it here to ensure the error is formatted correctly
-                    throw opts.error;
-                }
                 const data = await router.callProcedure({
                     procedures: opts.router._def.procedures,
-                    path,
-                    getRawInput: getRawInput,
+                    path: call.path,
+                    getRawInput: call.getRawInput,
                     ctx,
                     type,
                     allowMethodOverride
@@ -153,16 +150,10 @@ async function resolveHTTPResponse(opts) {
             } catch (cause) {
                 const error = TRPCError.getTRPCErrorFromUnknown(cause);
                 errors.push(error);
-                let input;
-                try {
-                    input = await getRawInput();
-                } catch (e) {
-                    // if `getRawInput` fails, we can't include the input in the error
-                    input = undefined;
-                }
+                const input = call.result();
                 opts.onError?.({
                     error,
-                    path,
+                    path: call.path,
                     input,
                     ctx,
                     type: type,
@@ -173,7 +164,7 @@ async function resolveHTTPResponse(opts) {
                         config: opts.router._def._config,
                         error,
                         type,
-                        path,
+                        path: call.path,
                         input,
                         ctx
                     })
@@ -187,79 +178,79 @@ async function resolveHTTPResponse(opts) {
        * - create headers with known response body
        * - return a complete HTTPResponse
        */ const untransformedJSON = await Promise.all(promises);
-            const headResponse1 = initResponse({
+            const errors1 = untransformedJSON.flatMap((response)=>'error' in response ? [
+                    response.error
+                ] : []);
+            const headResponse = initResponse({
                 ctx,
-                paths,
+                info,
                 type,
                 responseMeta: opts.responseMeta,
                 untransformedJSON,
-                errors
+                errors: errors1
             });
-            unstable_onHead?.(headResponse1, false);
             // return body stuff
-            const result = isBatchCall ? untransformedJSON : untransformedJSON[0]; // eslint-disable-line @typescript-eslint/no-non-null-assertion -- `untransformedJSON` should be the length of `paths` which should be at least 1 otherwise there wouldn't be a request at all
+            const result = info.isBatchCall ? untransformedJSON : untransformedJSON[0];
             const transformedJSON = transformer.transformTRPCResponse(router$1._def._config, result);
             const body = JSON.stringify(transformedJSON);
-            unstable_onChunk?.([
-                -1,
-                body
-            ]);
-            return {
-                status: headResponse1.status,
-                headers: headResponse1.headers,
-                body
-            };
+            return new Response(body, {
+                status: headResponse.status,
+                headers: headResponse.headers
+            });
         }
         /**
      * Streaming response:
      * - block on none, call `onChunk` as soon as each response is ready
      * - create headers with minimal data (cannot know the response body in advance)
      * - return void
-     */ const headResponse2 = initResponse({
+     */ const headResponse1 = initResponse({
             ctx,
-            paths,
+            info,
             type,
-            responseMeta: opts.responseMeta
+            responseMeta: opts.responseMeta,
+            errors: []
         });
-        unstable_onHead(headResponse2, true);
-        const indexedPromises = new Map(promises.map((promise, index)=>[
-                index,
-                promise.then((r)=>[
-                        index,
-                        r
-                    ])
-            ]));
-        for (const _ of paths){
-            const [index, untransformedJSON1] = await Promise.race(indexedPromises.values());
-            indexedPromises.delete(index);
-            try {
-                const transformedJSON1 = transformer.transformTRPCResponse(router$1._def._config, untransformedJSON1);
-                const body1 = JSON.stringify(transformedJSON1);
-                unstable_onChunk([
+        const encoder = new TextEncoderStream();
+        const stream = encoder.readable;
+        const controller = encoder.writable.getWriter();
+        async function exec() {
+            const indexedPromises = new Map(promises.map((promise, index)=>[
                     index,
-                    body1
-                ]);
-            } catch (cause) {
-                const path = paths[index];
-                const input = await opts.getInput({
-                    isBatchCall,
-                    batch: index
-                });
-                const { body: body2  } = caughtErrorToData(cause, {
-                    opts,
-                    ctx,
-                    type,
-                    path,
-                    input
-                });
-                unstable_onChunk([
-                    index,
-                    body2
-                ]);
+                    promise.then((r)=>[
+                            index,
+                            r
+                        ])
+                ]));
+            const formatter = batchStreamFormatter.getBatchStreamFormatter();
+            while(indexedPromises.size > 0){
+                const [index, untransformedJSON] = await Promise.race(indexedPromises.values());
+                indexedPromises.delete(index);
+                try {
+                    const transformedJSON = transformer.transformTRPCResponse(router$1._def._config, untransformedJSON);
+                    const body = JSON.stringify(transformedJSON);
+                    await controller.write(formatter(index, body));
+                } catch (cause) {
+                    const call = info.calls[index];
+                    const input = call.result();
+                    const { body: body1  } = caughtErrorToData(cause, {
+                        opts,
+                        ctx,
+                        type,
+                        path: call.path,
+                        input
+                    });
+                    await controller.write(formatter(index, body1));
+                }
             }
+            await controller.write(formatter.end());
+            await controller.close();
         }
-        return;
-    } catch (cause1) {
+        exec().catch((err)=>controller.abort(err));
+        return new Response(stream, {
+            headers: headResponse1.headers,
+            status: headResponse1.status
+        });
+    } catch (cause) {
         // we get here if
         // - batching is called when it's not enabled
         // - `createContext()` throws
@@ -267,32 +258,26 @@ async function resolveHTTPResponse(opts) {
         // - post body is too large
         // - input deserialization fails
         // - `errorFormatter` return value is malformed
-        const { error , untransformedJSON: untransformedJSON2 , body: body3  } = caughtErrorToData(cause1, {
+        const { error , untransformedJSON: untransformedJSON1 , body: body1  } = caughtErrorToData(cause, {
             opts,
             ctx,
             type
         });
-        const headResponse3 = initResponse({
+        const headResponse2 = initResponse({
             ctx,
-            paths,
+            info,
             type,
             responseMeta: opts.responseMeta,
-            untransformedJSON: untransformedJSON2,
+            untransformedJSON: untransformedJSON1,
             errors: [
                 error
             ]
         });
-        unstable_onHead?.(headResponse3, false);
-        unstable_onChunk?.([
-            -1,
-            body3
-        ]);
-        return {
-            status: headResponse3.status,
-            headers: headResponse3.headers,
-            body: body3
-        };
+        return new Response(body1, {
+            status: headResponse2.status,
+            headers: headResponse2.headers
+        });
     }
 }
 
-exports.resolveHTTPResponse = resolveHTTPResponse;
+exports.resolveResponse = resolveResponse;