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

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

@@ -1,51 +1,15 @@
 import { TRPCError } from '../error/TRPCError';
-import type { AnyRouter } from '../router';
-import type { Maybe } from '../types';
-import type { BaseContentTypeHandler } from './contentType';
-import type { HTTPBaseHandlerOptions, HTTPRequest, HTTPResponse, ResolveHTTPRequestOptionsContextFn, ResponseChunk } from './types';
-interface ResolveHTTPRequestOptions<TRouter extends AnyRouter, TRequest extends HTTPRequest> extends HTTPBaseHandlerOptions<TRouter, TRequest> {
+import { type AnyRouter } from '../router';
+import type { HTTPBaseHandlerOptions, ResolveHTTPRequestOptionsContextFn } from './types';
+interface ResolveHTTPRequestOptions<TRouter extends AnyRouter> extends HTTPBaseHandlerOptions<TRouter, Request> {
     createContext: ResolveHTTPRequestOptionsContextFn<TRouter>;
-    req: TRequest;
+    req: Request;
     path: string;
-    error?: Maybe<TRPCError>;
-    contentTypeHandler?: BaseContentTypeHandler<any>;
-    preprocessedBody?: boolean;
     /**
-     * Called as soon as the response head is known.
-     * When streaming, headers will have been generated
-     * **without** knowing the response body.
-     *
-     * Without this callback, streaming is disabled.
+     * If the request had an issue before reaching the handler
      */
-    unstable_onHead: (headResponse: Omit<HTTPResponse, 'body'>, isStreaming: boolean) => void;
-    /**
-     * Called for every procedure with `[index, result]`.
-     *
-     * Will be called a single time with `index = -1` if
-     * - response is an error
-     * - response is empty (HEAD request)
-     *
-     * Without this callback, streaming is disabled.
-     */
-    unstable_onChunk: (chunk: ResponseChunk) => void;
+    error: TRPCError | null;
 }
-/**
- * Since `resolveHTTPResponse` is a public API (community adapters),
- * let's give it a strong type signature to increase discoverability.
- */
-/**
- * Non-streaming signature for `resolveHTTPResponse`:
- * @param opts.unstable_onHead `undefined`
- * @param opts.unstable_onChunk `undefined`
- * @returns `Promise<HTTPResponse>`
- */
-export declare function resolveHTTPResponse<TRouter extends AnyRouter, TRequest extends HTTPRequest>(opts: Omit<ResolveHTTPRequestOptions<TRouter, TRequest>, 'unstable_onChunk' | 'unstable_onHead'>): Promise<HTTPResponse>;
-/**
- * Streaming signature for `resolveHTTPResponse`:
- * @param opts.unstable_onHead called as soon as the response head is known
- * @param opts.unstable_onChunk called for every procedure with `[index, result]`
- * @returns `Promise<void>` since the response is streamed
- */
-export declare function resolveHTTPResponse<TRouter extends AnyRouter, TRequest extends HTTPRequest>(opts: ResolveHTTPRequestOptions<TRouter, TRequest>): Promise<void>;
+export declare function resolveResponse<TRouter extends AnyRouter>(opts: ResolveHTTPRequestOptions<TRouter>): Promise<Response>;
 export {};
 //# sourceMappingURL=resolveHTTPResponse.d.ts.map

package/dist/unstable-core-do-not-import/http/resolveHTTPResponse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolveHTTPResponse.d.ts","sourceRoot":"","sources":["../../../src/unstable-core-do-not-import/http/resolveHTTPResponse.ts"],"names":[],"mappings":"AACA,OAAO,EAA2B,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAExE,OAAO,KAAK,EACV,SAAS,EAGV,MAAM,WAAW,CAAC;AAInB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAG5D,OAAO,KAAK,EACV,sBAAsB,EAEtB,WAAW,EACX,YAAY,EACZ,kCAAkC,EAClC,aAAa,EAEd,MAAM,SAAS,CAAC;AAoBjB,UAAU,yBAAyB,CACjC,OAAO,SAAS,SAAS,EACzB,QAAQ,SAAS,WAAW,CAC5B,SAAQ,sBAAsB,CAAC,OAAO,EAAE,QAAQ,CAAC;IACjD,aAAa,EAAE,kCAAkC,CAAC,OAAO,CAAC,CAAC;IAC3D,GAAG,EAAE,QAAQ,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IACzB,kBAAkB,CAAC,EAAE,sBAAsB,CAAC,GAAG,CAAC,CAAC;IACjD,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;;;OAMG;IACH,eAAe,EAAE,CACf,YAAY,EAAE,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,EACxC,WAAW,EAAE,OAAO,KACjB,IAAI,CAAC;IACV;;;;;;;;OAQG;IACH,gBAAgB,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;CAClD;AA4GD;;;GAGG;AAEH;;;;;GAKG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,SAAS,SAAS,EACzB,QAAQ,SAAS,WAAW,EAE5B,IAAI,EAAE,IAAI,CACR,yBAAyB,CAAC,OAAO,EAAE,QAAQ,CAAC,EAC5C,kBAAkB,GAAG,iBAAiB,CACvC,GACA,OAAO,CAAC,YAAY,CAAC,CAAC;AACzB;;;;;GAKG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,SAAS,SAAS,EACzB,QAAQ,SAAS,WAAW,EAC5B,IAAI,EAAE,yBAAyB,CAAC,OAAO,EAAE,QAAQ,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC"}
+{"version":3,"file":"resolveHTTPResponse.d.ts","sourceRoot":"","sources":["../../../src/unstable-core-do-not-import/http/resolveHTTPResponse.ts"],"names":[],"mappings":"AAEA,OAAO,EAA2B,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAExE,OAAO,EAEL,KAAK,SAAS,EAGf,MAAM,WAAW,CAAC;AAMnB,OAAO,KAAK,EACV,sBAAsB,EACtB,kCAAkC,EAEnC,MAAM,SAAS,CAAC;AAUjB,UAAU,yBAAyB,CAAC,OAAO,SAAS,SAAS,CAC3D,SAAQ,sBAAsB,CAAC,OAAO,EAAE,OAAO,CAAC;IAChD,aAAa,EAAE,kCAAkC,CAAC,OAAO,CAAC,CAAC;IAC3D,GAAG,EAAE,OAAO,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb;;OAEG;IACH,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;CACzB;AAuHD,wBAAsB,eAAe,CAAC,OAAO,SAAS,SAAS,EAC7D,IAAI,EAAE,yBAAyB,CAAC,OAAO,CAAC,GACvC,OAAO,CAAC,QAAQ,CAAC,CAkOnB"}

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

@@ -4,6 +4,7 @@ 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');
 
@@ -11,29 +12,46 @@ const HTTP_METHOD_PROCEDURE_TYPE_MAP = {
     GET: 'query',
     POST: 'mutation'
 };
-const fallbackContentTypeHandler = {
-    getInputs: contentType.getJsonContentTypeInputs
-};
 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;
@@ -72,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 contentTypeHandler = opts.contentTypeHandler ?? fallbackContentTypeHandler;
     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 {
+        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 (isBatchCall && !allowBatching) {
+        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'
             });
         }
-        const inputs = await contentTypeHandler.getInputs({
-            isBatchCall,
-            req,
-            router: router$1,
-            preprocessedBody: opts.preprocessedBody ?? false
-        });
-        paths = isBatchCall ? decodeURIComponent(opts.path).split(',') : [
-            opts.path
-        ];
-        const info = {
-            isBatchCall,
-            calls: paths.map((path, idx)=>({
-                    path,
-                    type,
-                    input: inputs[idx] ?? undefined
-                }))
-        };
-        ctx = await opts.createContext({
-            info
-        });
         const errors = [];
-        const promises = paths.map(async (path, index)=>{
-            const input = inputs[index];
+        const promises = info.calls.map(async (call)=>{
             try {
                 const data = await router.callProcedure({
                     procedures: opts.router._def.procedures,
-                    path,
-                    getRawInput: async ()=>input,
+                    path: call.path,
+                    getRawInput: call.getRawInput,
                     ctx,
                     type,
                     allowMethodOverride
@@ -157,9 +150,10 @@ async function resolveHTTPResponse(opts) {
             } catch (cause) {
                 const error = TRPCError.getTRPCErrorFromUnknown(cause);
                 errors.push(error);
+                const input = call.result();
                 opts.onError?.({
                     error,
-                    path,
+                    path: call.path,
                     input,
                     ctx,
                     type: type,
@@ -170,7 +164,7 @@ async function resolveHTTPResponse(opts) {
                         config: opts.router._def._config,
                         error,
                         type,
-                        path,
+                        path: call.path,
                         input,
                         ctx
                     })
@@ -184,76 +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 = inputs[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
@@ -261,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;