@trpc/server 11.0.0-alpha-tmp-export-from-main.218 → 11.0.0-alpha-tmp-export-from-main-nuke-core.239

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

@@ -0,0 +1,295 @@
+'use strict';
+
+var getErrorShape = require('../error/getErrorShape.js');
+var TRPCError = require('../error/TRPCError.js');
+var router = require('../router.js');
+var transformer = require('../transformer.js');
+var contentType = require('./contentType.js');
+var getHTTPStatusCode = require('./getHTTPStatusCode.js');
+
+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;
+    let status = untransformedJSON ? getHTTPStatusCode.getHTTPStatusCode(untransformedJSON) : 200;
+    const headers = {
+        'Content-Type': 'application/json'
+    };
+    const eagerGeneration = !untransformedJSON;
+    const data = eagerGeneration ? [] : Array.isArray(untransformedJSON) ? untransformedJSON : [
+        untransformedJSON
+    ];
+    const meta = responseMeta?.({
+        ctx,
+        paths,
+        type,
+        data,
+        errors,
+        eagerGeneration
+    }) ?? {};
+    for (const [key, value] of Object.entries(meta.headers ?? {})){
+        headers[key] = value;
+    }
+    if (meta.status) {
+        status = meta.status;
+    }
+    return {
+        status,
+        headers
+    };
+}
+async function inputToProcedureCall(procedureOpts) {
+    const { opts , ctx , type , input , path  } = procedureOpts;
+    try {
+        const data = await router.callProcedure({
+            procedures: opts.router._def.procedures,
+            path,
+            getRawInput: async ()=>input,
+            ctx,
+            type
+        });
+        return {
+            result: {
+                data
+            }
+        };
+    } catch (cause) {
+        const error = TRPCError.getTRPCErrorFromUnknown(cause);
+        opts.onError?.({
+            error,
+            path,
+            input,
+            ctx,
+            type: type,
+            req: opts.req
+        });
+        return {
+            error: getErrorShape.getErrorShape({
+                config: opts.router._def._config,
+                error,
+                type,
+                path,
+                input,
+                ctx
+            })
+        };
+    }
+}
+function caughtErrorToData(cause, errorOpts) {
+    const { router , req , onError  } = errorOpts.opts;
+    const error = TRPCError.getTRPCErrorFromUnknown(cause);
+    onError?.({
+        error,
+        path: errorOpts.path,
+        input: errorOpts.input,
+        ctx: errorOpts.ctx,
+        type: errorOpts.type,
+        req
+    });
+    const untransformedJSON = {
+        error: getErrorShape.getErrorShape({
+            config: router._def._config,
+            error,
+            type: errorOpts.type,
+            path: errorOpts.path,
+            input: errorOpts.input,
+            ctx: errorOpts.ctx
+        })
+    };
+    const transformedJSON = transformer.transformTRPCResponse(router._def._config, untransformedJSON);
+    const body = JSON.stringify(transformedJSON);
+    return {
+        error,
+        untransformedJSON,
+        body
+    };
+}
+// implementation
+async function resolveHTTPResponse(opts) {
+    const { router , req , unstable_onHead , unstable_onChunk  } = opts;
+    if (req.method === 'HEAD') {
+        // can be used for lambda warmup
+        const headResponse = {
+            status: 204
+        };
+        unstable_onHead?.(headResponse, false);
+        unstable_onChunk?.([
+            -1,
+            ''
+        ]);
+        return headResponse;
+    }
+    const contentTypeHandler = opts.contentTypeHandler ?? fallbackContentTypeHandler;
+    const batchingEnabled = opts.batching?.enabled ?? true;
+    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';
+    try {
+        if (opts.error) {
+            throw opts.error;
+        }
+        if (isBatchCall && !batchingEnabled) {
+            throw new Error(`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,
+            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 promises = paths.map((path, index)=>inputToProcedureCall({
+                opts,
+                ctx,
+                type,
+                input: inputs[index],
+                path
+            }));
+        if (!isStreamCall) {
+            /**
+       * Non-streaming response:
+       * - await all responses in parallel, blocking on the slowest one
+       * - create headers with known response body
+       * - return a complete HTTPResponse
+       */ const untransformedJSON = await Promise.all(promises);
+            const errors = untransformedJSON.flatMap((response)=>'error' in response ? [
+                    response.error
+                ] : []);
+            const headResponse1 = initResponse({
+                ctx,
+                paths,
+                type,
+                responseMeta: opts.responseMeta,
+                untransformedJSON,
+                errors
+            });
+            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 transformedJSON = transformer.transformTRPCResponse(router._def._config, result);
+            const body = JSON.stringify(transformedJSON);
+            unstable_onChunk?.([
+                -1,
+                body
+            ]);
+            return {
+                status: headResponse1.status,
+                headers: headResponse1.headers,
+                body
+            };
+        }
+        /**
+     * 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({
+            ctx,
+            paths,
+            type,
+            responseMeta: opts.responseMeta
+        });
+        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._def._config, untransformedJSON1);
+                const body1 = JSON.stringify(transformedJSON1);
+                unstable_onChunk([
+                    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
+                ]);
+            }
+        }
+        return;
+    } catch (cause1) {
+        // we get here if
+        // - batching is called when it's not enabled
+        // - `createContext()` throws
+        // - `router._def._config.transformer.output.serialize()` throws
+        // - post body is too large
+        // - input deserialization fails
+        // - `errorFormatter` return value is malformed
+        const { error , untransformedJSON: untransformedJSON2 , body: body3  } = caughtErrorToData(cause1, {
+            opts,
+            ctx,
+            type
+        });
+        const headResponse3 = initResponse({
+            ctx,
+            paths,
+            type,
+            responseMeta: opts.responseMeta,
+            untransformedJSON: untransformedJSON2,
+            errors: [
+                error
+            ]
+        });
+        unstable_onHead?.(headResponse3, false);
+        unstable_onChunk?.([
+            -1,
+            body3
+        ]);
+        return {
+            status: headResponse3.status,
+            headers: headResponse3.headers,
+            body: body3
+        };
+    }
+}
+
+exports.resolveHTTPResponse = resolveHTTPResponse;

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

@@ -0,0 +1,293 @@
+import { getErrorShape } from '../error/getErrorShape.mjs';
+import { TRPCError, getTRPCErrorFromUnknown } from '../error/TRPCError.mjs';
+import { callProcedure } from '../router.mjs';
+import { transformTRPCResponse } from '../transformer.mjs';
+import { getJsonContentTypeInputs } from './contentType.mjs';
+import { getHTTPStatusCode } from './getHTTPStatusCode.mjs';
+
+const HTTP_METHOD_PROCEDURE_TYPE_MAP = {
+    GET: 'query',
+    POST: 'mutation'
+};
+const fallbackContentTypeHandler = {
+    getInputs: getJsonContentTypeInputs
+};
+function initResponse(initOpts) {
+    const { ctx , paths , type , responseMeta , untransformedJSON , errors =[] ,  } = initOpts;
+    let status = untransformedJSON ? getHTTPStatusCode(untransformedJSON) : 200;
+    const headers = {
+        'Content-Type': 'application/json'
+    };
+    const eagerGeneration = !untransformedJSON;
+    const data = eagerGeneration ? [] : Array.isArray(untransformedJSON) ? untransformedJSON : [
+        untransformedJSON
+    ];
+    const meta = responseMeta?.({
+        ctx,
+        paths,
+        type,
+        data,
+        errors,
+        eagerGeneration
+    }) ?? {};
+    for (const [key, value] of Object.entries(meta.headers ?? {})){
+        headers[key] = value;
+    }
+    if (meta.status) {
+        status = meta.status;
+    }
+    return {
+        status,
+        headers
+    };
+}
+async function inputToProcedureCall(procedureOpts) {
+    const { opts , ctx , type , input , path  } = procedureOpts;
+    try {
+        const data = await callProcedure({
+            procedures: opts.router._def.procedures,
+            path,
+            getRawInput: async ()=>input,
+            ctx,
+            type
+        });
+        return {
+            result: {
+                data
+            }
+        };
+    } catch (cause) {
+        const error = getTRPCErrorFromUnknown(cause);
+        opts.onError?.({
+            error,
+            path,
+            input,
+            ctx,
+            type: type,
+            req: opts.req
+        });
+        return {
+            error: getErrorShape({
+                config: opts.router._def._config,
+                error,
+                type,
+                path,
+                input,
+                ctx
+            })
+        };
+    }
+}
+function caughtErrorToData(cause, errorOpts) {
+    const { router , req , onError  } = errorOpts.opts;
+    const error = getTRPCErrorFromUnknown(cause);
+    onError?.({
+        error,
+        path: errorOpts.path,
+        input: errorOpts.input,
+        ctx: errorOpts.ctx,
+        type: errorOpts.type,
+        req
+    });
+    const untransformedJSON = {
+        error: getErrorShape({
+            config: router._def._config,
+            error,
+            type: errorOpts.type,
+            path: errorOpts.path,
+            input: errorOpts.input,
+            ctx: errorOpts.ctx
+        })
+    };
+    const transformedJSON = transformTRPCResponse(router._def._config, untransformedJSON);
+    const body = JSON.stringify(transformedJSON);
+    return {
+        error,
+        untransformedJSON,
+        body
+    };
+}
+// implementation
+async function resolveHTTPResponse(opts) {
+    const { router , req , unstable_onHead , unstable_onChunk  } = opts;
+    if (req.method === 'HEAD') {
+        // can be used for lambda warmup
+        const headResponse = {
+            status: 204
+        };
+        unstable_onHead?.(headResponse, false);
+        unstable_onChunk?.([
+            -1,
+            ''
+        ]);
+        return headResponse;
+    }
+    const contentTypeHandler = opts.contentTypeHandler ?? fallbackContentTypeHandler;
+    const batchingEnabled = opts.batching?.enabled ?? true;
+    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';
+    try {
+        if (opts.error) {
+            throw opts.error;
+        }
+        if (isBatchCall && !batchingEnabled) {
+            throw new Error(`Batching is not enabled on the server`);
+        }
+        /* istanbul ignore if -- @preserve */ if (type === 'subscription') {
+            throw new TRPCError({
+                message: 'Subscriptions should use wsLink',
+                code: 'METHOD_NOT_SUPPORTED'
+            });
+        }
+        if (type === 'unknown') {
+            throw new TRPCError({
+                message: `Unexpected request method ${req.method}`,
+                code: 'METHOD_NOT_SUPPORTED'
+            });
+        }
+        const inputs = await contentTypeHandler.getInputs({
+            isBatchCall,
+            req,
+            router,
+            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 promises = paths.map((path, index)=>inputToProcedureCall({
+                opts,
+                ctx,
+                type,
+                input: inputs[index],
+                path
+            }));
+        if (!isStreamCall) {
+            /**
+       * Non-streaming response:
+       * - await all responses in parallel, blocking on the slowest one
+       * - create headers with known response body
+       * - return a complete HTTPResponse
+       */ const untransformedJSON = await Promise.all(promises);
+            const errors = untransformedJSON.flatMap((response)=>'error' in response ? [
+                    response.error
+                ] : []);
+            const headResponse1 = initResponse({
+                ctx,
+                paths,
+                type,
+                responseMeta: opts.responseMeta,
+                untransformedJSON,
+                errors
+            });
+            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 transformedJSON = transformTRPCResponse(router._def._config, result);
+            const body = JSON.stringify(transformedJSON);
+            unstable_onChunk?.([
+                -1,
+                body
+            ]);
+            return {
+                status: headResponse1.status,
+                headers: headResponse1.headers,
+                body
+            };
+        }
+        /**
+     * 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({
+            ctx,
+            paths,
+            type,
+            responseMeta: opts.responseMeta
+        });
+        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 = transformTRPCResponse(router._def._config, untransformedJSON1);
+                const body1 = JSON.stringify(transformedJSON1);
+                unstable_onChunk([
+                    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
+                ]);
+            }
+        }
+        return;
+    } catch (cause1) {
+        // we get here if
+        // - batching is called when it's not enabled
+        // - `createContext()` throws
+        // - `router._def._config.transformer.output.serialize()` throws
+        // - post body is too large
+        // - input deserialization fails
+        // - `errorFormatter` return value is malformed
+        const { error , untransformedJSON: untransformedJSON2 , body: body3  } = caughtErrorToData(cause1, {
+            opts,
+            ctx,
+            type
+        });
+        const headResponse3 = initResponse({
+            ctx,
+            paths,
+            type,
+            responseMeta: opts.responseMeta,
+            untransformedJSON: untransformedJSON2,
+            errors: [
+                error
+            ]
+        });
+        unstable_onHead?.(headResponse3, false);
+        unstable_onChunk?.([
+            -1,
+            body3
+        ]);
+        return {
+            status: headResponse3.status,
+            headers: headResponse3.headers,
+            body: body3
+        };
+    }
+}
+
+export { resolveHTTPResponse };

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

@@ -0,0 +1,96 @@
+import type { TRPCError } from '../error/TRPCError';
+import type { ProcedureType } from '../procedure';
+import type { AnyRouter, inferRouterContext, inferRouterError } from '../router';
+import type { TRPCResponse } from '../rpc';
+import type { Dict } from '../types';
+export type HTTPHeaders = Dict<string[] | string>;
+export interface HTTPResponse {
+    status: number;
+    headers?: HTTPHeaders;
+    body?: string;
+}
+export type ResponseChunk = [procedureIndex: number, responseBody: string];
+export interface ResponseMeta {
+    status?: number;
+    headers?: HTTPHeaders;
+}
+/**
+ * @internal
+ */
+export type ResponseMetaFn<TRouter extends AnyRouter> = (opts: {
+    data: TRPCResponse<unknown, inferRouterError<TRouter>>[];
+    ctx?: inferRouterContext<TRouter>;
+    /**
+     * The different tRPC paths requested
+     **/
+    paths?: string[];
+    type: ProcedureType | 'unknown';
+    errors: TRPCError[];
+    /**
+     * `true` if the `ResponseMeta` are being
+     * generated without knowing the response data
+     * (e.g. for streaming requests).
+     */
+    eagerGeneration?: boolean;
+}) => ResponseMeta;
+export interface HTTPRequest {
+    method: string;
+    query: URLSearchParams;
+    headers: HTTPHeaders;
+    body: unknown;
+}
+/**
+ * Base interface for anything using HTTP
+ */
+export interface HTTPBaseHandlerOptions<TRouter extends AnyRouter, TRequest> extends BaseHandlerOptions<TRouter, TRequest> {
+    /**
+     * Add handler to be called before response is sent to the user
+     * Useful for setting cache headers
+     * @link https://trpc.io/docs/v11/caching
+     */
+    responseMeta?: ResponseMetaFn<TRouter>;
+}
+/** @internal */
+export type ProcedureCall = {
+    type: ProcedureType;
+    input?: unknown;
+    path: string;
+};
+/**
+ * Information about the incoming request
+ * @internal
+ */
+export type TRPCRequestInfo = {
+    isBatchCall: boolean;
+    calls: ProcedureCall[];
+};
+/**
+ * Inner createContext function for `resolveHTTPResponse` used to forward `TRPCRequestInfo` to `createContext`
+ * @internal
+ */
+export type ResolveHTTPRequestOptionsContextFn<TRouter extends AnyRouter> = (opts: {
+    info: TRPCRequestInfo;
+}) => Promise<inferRouterContext<TRouter>>;
+/**
+ * @internal
+ */
+export type OnErrorFunction<TRouter extends AnyRouter, TRequest> = (opts: {
+    error: TRPCError;
+    type: ProcedureType | 'unknown';
+    path: string | undefined;
+    req: TRequest;
+    input: unknown;
+    ctx: inferRouterContext<TRouter> | undefined;
+}) => void;
+/**
+ * Base interface for any response handler
+ * @internal
+ */
+export interface BaseHandlerOptions<TRouter extends AnyRouter, TRequest> {
+    onError?: OnErrorFunction<TRouter, TRequest>;
+    batching?: {
+        enabled: boolean;
+    };
+    router: TRouter;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/unstable-core-do-not-import/http/types.ts"],"names":[],"mappings":"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"}