@trpc/server 10.11.1 → 10.13.0

package/dist/{resolveHTTPResponse-b831e644.mjs → resolveHTTPResponse-7a4f75b3.mjs}

@@ -1,4 +1,4 @@
-import { e as callProcedure, f as getHTTPStatusCode } from './config-4ca0221b.mjs';
+import { e as callProcedure, f as getHTTPStatusCode } from './config-cd794c2a.mjs';
 import { T as TRPCError, a as getTRPCErrorFromUnknown, g as getCauseFromUnknown } from './TRPCError-7de0a793.mjs';
 import { t as transformTRPCResponse } from './transformTRPCResponse-7a73a2df.mjs';
 
@@ -75,7 +75,7 @@ async function resolveHTTPResponse(opts) {
         if (isBatchCall && !batchingEnabled) {
             throw new Error(`Batching is not enabled on the server`);
         }
-        /* istanbul ignore if  */ if (type === 'subscription') {
+        /* istanbul ignore if -- @preserve */ if (type === 'subscription') {
             throw new TRPCError({
                 message: 'Subscriptions should use wsLink',
                 code: 'METHOD_NOT_SUPPORTED'
@@ -101,7 +101,7 @@ async function resolveHTTPResponse(opts) {
                     0: deserializeInputValue(rawInput)
                 };
             }
-            /* istanbul ignore if  */ if (rawInput == null || typeof rawInput !== 'object' || Array.isArray(rawInput)) {
+            /* istanbul ignore if -- @preserve */ if (rawInput == null || typeof rawInput !== 'object' || Array.isArray(rawInput)) {
                 throw new TRPCError({
                     code: 'BAD_REQUEST',
                     message: '"input" needs to be an object when doing a batch call'
@@ -180,6 +180,7 @@ async function resolveHTTPResponse(opts) {
         // - `createContext()` throws
         // - post body is too large
         // - input deserialization fails
+        // - `errorFormatter` return value is malformed
         const error = getTRPCErrorFromUnknown(cause);
         onError?.({
             error,

package/dist/resolveHTTPResponse-fed650e4.js

@@ -0,0 +1,205 @@
+import { e as callProcedure, f as getHTTPStatusCode } from './config-e8f70019.js';
+import { T as TRPCError, a as getTRPCErrorFromUnknown, g as getCauseFromUnknown } from './TRPCError-ef1ceb74.js';
+import { t as transformTRPCResponse } from './transformTRPCResponse-896669e0.js';
+
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+const HTTP_METHOD_PROCEDURE_TYPE_MAP = {
+    GET: 'query',
+    POST: 'mutation',
+};
+function getRawProcedureInputOrThrow(req) {
+    try {
+        if (req.method === 'GET') {
+            if (!req.query.has('input')) {
+                return undefined;
+            }
+            const raw = req.query.get('input');
+            return JSON.parse(raw);
+        }
+        if (typeof req.body === 'string') {
+            // A mutation with no inputs will have req.body === ''
+            return req.body.length === 0 ? undefined : JSON.parse(req.body);
+        }
+        return req.body;
+    }
+    catch (err) {
+        throw new TRPCError({
+            code: 'PARSE_ERROR',
+            cause: getCauseFromUnknown(err),
+        });
+    }
+}
+async function resolveHTTPResponse(opts) {
+    const { createContext, onError, router, req } = opts;
+    const batchingEnabled = opts.batching?.enabled ?? true;
+    if (req.method === 'HEAD') {
+        // can be used for lambda warmup
+        return {
+            status: 204,
+        };
+    }
+    const type = HTTP_METHOD_PROCEDURE_TYPE_MAP[req.method] ?? 'unknown';
+    let ctx = undefined;
+    let paths = undefined;
+    const isBatchCall = !!req.query.get('batch');
+    function endResponse(untransformedJSON, errors) {
+        let status = getHTTPStatusCode(untransformedJSON);
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        const meta = opts.responseMeta?.({
+            ctx,
+            paths,
+            type,
+            data: Array.isArray(untransformedJSON)
+                ? untransformedJSON
+                : [untransformedJSON],
+            errors,
+        }) ?? {};
+        for (const [key, value] of Object.entries(meta.headers ?? {})) {
+            headers[key] = value;
+        }
+        if (meta.status) {
+            status = meta.status;
+        }
+        const transformedJSON = transformTRPCResponse(router, untransformedJSON);
+        const body = JSON.stringify(transformedJSON);
+        return {
+            body,
+            status,
+            headers,
+        };
+    }
+    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 rawInput = getRawProcedureInputOrThrow(req);
+        paths = isBatchCall ? opts.path.split(',') : [opts.path];
+        ctx = await createContext();
+        const deserializeInputValue = (rawValue) => {
+            return typeof rawValue !== 'undefined'
+                ? router._def._config.transformer.input.deserialize(rawValue)
+                : rawValue;
+        };
+        const getInputs = () => {
+            if (!isBatchCall) {
+                return {
+                    0: deserializeInputValue(rawInput),
+                };
+            }
+            /* istanbul ignore if -- @preserve */
+            if (rawInput == null ||
+                typeof rawInput !== 'object' ||
+                Array.isArray(rawInput)) {
+                throw new TRPCError({
+                    code: 'BAD_REQUEST',
+                    message: '"input" needs to be an object when doing a batch call',
+                });
+            }
+            const input = {};
+            for (const key in rawInput) {
+                const k = key;
+                const rawValue = rawInput[k];
+                const value = deserializeInputValue(rawValue);
+                input[k] = value;
+            }
+            return input;
+        };
+        const inputs = getInputs();
+        const rawResults = await Promise.all(paths.map(async (path, index) => {
+            const input = inputs[index];
+            try {
+                const output = await callProcedure({
+                    procedures: router._def.procedures,
+                    path,
+                    rawInput: input,
+                    ctx,
+                    type,
+                });
+                return {
+                    input,
+                    path,
+                    data: output,
+                };
+            }
+            catch (cause) {
+                const error = getTRPCErrorFromUnknown(cause);
+                onError?.({ error, path, input, ctx, type: type, req });
+                return {
+                    input,
+                    path,
+                    error,
+                };
+            }
+        }));
+        const errors = rawResults.flatMap((obj) => (obj.error ? [obj.error] : []));
+        const resultEnvelopes = rawResults.map((obj) => {
+            const { path, input } = obj;
+            if (obj.error) {
+                return {
+                    error: router.getErrorShape({
+                        error: obj.error,
+                        type,
+                        path,
+                        input,
+                        ctx,
+                    }),
+                };
+            }
+            else {
+                return {
+                    result: {
+                        data: obj.data,
+                    },
+                };
+            }
+        });
+        const result = isBatchCall ? resultEnvelopes : resultEnvelopes[0];
+        return endResponse(result, errors);
+    }
+    catch (cause) {
+        // we get here if
+        // - batching is called when it's not enabled
+        // - `createContext()` throws
+        // - post body is too large
+        // - input deserialization fails
+        // - `errorFormatter` return value is malformed
+        const error = getTRPCErrorFromUnknown(cause);
+        onError?.({
+            error,
+            path: undefined,
+            input: undefined,
+            ctx,
+            type: type,
+            req,
+        });
+        return endResponse({
+            error: router.getErrorShape({
+                error,
+                type,
+                path: undefined,
+                input: undefined,
+                ctx,
+            }),
+        }, [error]);
+    }
+}
+
+export { resolveHTTPResponse as r };

package/dist/subscription.js

@@ -12,15 +12,15 @@ var observable = require('./observable-464116ac.js');
     let timer;
     let stopped = false;
     async function _pull(emit) {
-        /* istanbul ignore next */ if (stopped) {
+        /* istanbul ignore next -- @preserve */ if (stopped) {
             return;
         }
         try {
             await opts.pull(emit);
-        } catch (err /* istanbul ignore next */ ) {
+        } catch (err /* istanbul ignore next -- @preserve */ ) {
             emit.error(TRPCError.getTRPCErrorFromUnknown(err));
         }
-        /* istanbul ignore else */ if (!stopped) {
+        /* istanbul ignore else -- @preserve */ if (!stopped) {
             timer = setTimeout(()=>_pull(emit), opts.intervalMs);
         }
     }

package/dist/subscription.mjs

@@ -8,15 +8,15 @@ import { o as observable } from './observable-ade1bad8.mjs';
     let timer;
     let stopped = false;
     async function _pull(emit) {
-        /* istanbul ignore next */ if (stopped) {
+        /* istanbul ignore next -- @preserve */ if (stopped) {
             return;
         }
         try {
             await opts.pull(emit);
-        } catch (err /* istanbul ignore next */ ) {
+        } catch (err /* istanbul ignore next -- @preserve */ ) {
             emit.error(getTRPCErrorFromUnknown(err));
         }
-        /* istanbul ignore else */ if (!stopped) {
+        /* istanbul ignore else -- @preserve */ if (!stopped) {
             timer = setTimeout(()=>_pull(emit), opts.intervalMs);
         }
     }

package/dist/transformTRPCResponse-896669e0.js

@@ -0,0 +1,28 @@
+function transformTRPCResponseItem(router, item) {
+    if ('error' in item) {
+        return {
+            ...item,
+            error: router._def._config.transformer.output.serialize(item.error),
+        };
+    }
+    if ('data' in item.result) {
+        return {
+            ...item,
+            result: {
+                ...item.result,
+                data: router._def._config.transformer.output.serialize(item.result.data),
+            },
+        };
+    }
+    return item;
+}
+/**
+ * Takes a unserialized `TRPCResponse` and serializes it with the router's transformers
+ **/
+function transformTRPCResponse(router, itemOrItems) {
+    return Array.isArray(itemOrItems)
+        ? itemOrItems.map((item) => transformTRPCResponseItem(router, item))
+        : transformTRPCResponseItem(router, itemOrItems);
+}
+
+export { transformTRPCResponse as t };

package/dist/transformer.d.ts

@@ -1,23 +1,49 @@
 /**
  * @public
  */
-export declare type DataTransformer = {
+export interface DataTransformer {
     serialize(object: any): any;
     deserialize(object: any): any;
-};
+}
+interface InputDataTransformer extends DataTransformer {
+    /**
+     * This function runs **on the client** before sending the data to the server.
+     */
+    serialize(object: any): any;
+    /**
+     * This function runs **on the server** to transform the data before it is passed to the resolver
+     */
+    deserialize(object: any): any;
+}
+interface OutputDataTransformer extends DataTransformer {
+    /**
+     * This function runs **on the server** before sending the data to the client.
+     */
+    serialize(object: any): any;
+    /**
+     * This function runs **only on the client** to transform the data sent from the server.
+     */
+    deserialize(object: any): any;
+}
 /**
  * @public
  */
-export declare type CombinedDataTransformer = {
-    input: DataTransformer;
-    output: DataTransformer;
-};
+export interface CombinedDataTransformer {
+    /**
+     * Specify how the data sent from the client to the server should be transformed.
+     */
+    input: InputDataTransformer;
+    /**
+     * Specify how the data sent from the server to the client should be transformed.
+     */
+    output: OutputDataTransformer;
+}
 /**
  * @public
  */
 export declare type CombinedDataTransformerClient = {
-    input: Pick<DataTransformer, 'serialize'>;
-    output: Pick<DataTransformer, 'deserialize'>;
+    input: Pick<CombinedDataTransformer['input'], 'serialize'>;
+    output: Pick<CombinedDataTransformer['output'], 'deserialize'>;
 };
 /**
  * @public
@@ -41,4 +67,5 @@ export declare type DefaultDataTransformer = CombinedDataTransformer & {
  * @internal
  */
 export declare const defaultTransformer: DefaultDataTransformer;
+export {};
 //# sourceMappingURL=transformer.d.ts.map

package/dist/transformer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transformer.d.ts","sourceRoot":"","sources":["../src/transformer.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,eAAe,GAAG;IAC5B,SAAS,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,CAAC;IAC5B,WAAW,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,CAAC;CAC/B,CAAC;AAEF;;GAEG;AACH,oBAAY,uBAAuB,GAAG;IACpC,KAAK,EAAE,eAAe,CAAC;IACvB,MAAM,EAAE,eAAe,CAAC;CACzB,CAAC;AAEF;;GAEG;AACH,oBAAY,6BAA6B,GAAG;IAC1C,KAAK,EAAE,IAAI,CAAC,eAAe,EAAE,WAAW,CAAC,CAAC;IAC1C,MAAM,EAAE,IAAI,CAAC,eAAe,EAAE,aAAa,CAAC,CAAC;CAC9C,CAAC;AAEF;;GAEG;AACH,oBAAY,sBAAsB,GAAG,eAAe,GAAG,uBAAuB,CAAC;AAE/E;;GAEG;AACH,oBAAY,4BAA4B,GACpC,eAAe,GACf,6BAA6B,CAAC;AAElC;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,sBAAsB,GAClC,uBAAuB,CAKzB;AAED;;GAEG;AACH,oBAAY,sBAAsB,GAAG,uBAAuB,GAAG;IAC7D,QAAQ,EAAE,IAAI,CAAC;CAChB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,sBAIhC,CAAC"}
+{"version":3,"file":"transformer.d.ts","sourceRoot":"","sources":["../src/transformer.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,SAAS,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,CAAC;IAC5B,WAAW,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,CAAC;CAC/B;AAED,UAAU,oBAAqB,SAAQ,eAAe;IACpD;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,CAAC;IAC5B;;OAEG;IACH,WAAW,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,CAAC;CAC/B;AAED,UAAU,qBAAsB,SAAQ,eAAe;IACrD;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,CAAC;IAC5B;;OAEG;IACH,WAAW,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC;;OAEG;IACH,KAAK,EAAE,oBAAoB,CAAC;IAC5B;;OAEG;IACH,MAAM,EAAE,qBAAqB,CAAC;CAC/B;AAED;;GAEG;AACH,oBAAY,6BAA6B,GAAG;IAC1C,KAAK,EAAE,IAAI,CAAC,uBAAuB,CAAC,OAAO,CAAC,EAAE,WAAW,CAAC,CAAC;IAC3D,MAAM,EAAE,IAAI,CAAC,uBAAuB,CAAC,QAAQ,CAAC,EAAE,aAAa,CAAC,CAAC;CAChE,CAAC;AAEF;;GAEG;AACH,oBAAY,sBAAsB,GAAG,eAAe,GAAG,uBAAuB,CAAC;AAE/E;;GAEG;AACH,oBAAY,4BAA4B,GACpC,eAAe,GACf,6BAA6B,CAAC;AAElC;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,sBAAsB,GAClC,uBAAuB,CAKzB;AAED;;GAEG;AACH,oBAAY,sBAAsB,GAAG,uBAAuB,GAAG;IAC7D,QAAQ,EAAE,IAAI,CAAC;CAChB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,sBAIhC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/server",
-  "version": "10.11.1",
+  "version": "10.13.0",
   "description": "tRPC Server",
   "author": "KATT",
   "license": "MIT",
@@ -126,39 +126,35 @@
     "access": "public"
   },
   "devDependencies": {
-    "@cloudflare/workers-types": "^3.14.1",
-    "@fastify/websocket": "^5.0.0",
-    "@miniflare/core": "^2.9.0",
+    "@fastify/websocket": "^7.1.2",
     "@tanstack/react-query": "^4.3.8",
     "@types/aws-lambda": "^8.10.97",
     "@types/express": "^4.17.12",
     "@types/hash-sum": "^1.0.0",
     "@types/node": "^18.7.20",
-    "@types/node-fetch": "^2.5.11",
     "@types/react": "^18.0.9",
     "@types/ws": "^8.2.0",
     "aws-lambda": "^1.0.7",
-    "devalue": "^2.0.1",
+    "devalue": "^4.0.0",
     "eslint": "^8.30.0",
     "expect-type": "^0.15.0",
     "express": "^4.17.1",
-    "fastify": "^3.27.1",
-    "fastify-plugin": "^3.0.1",
+    "fastify": "^4.13.0",
+    "fastify-plugin": "^4.5.0",
     "hash-sum": "^2.0.0",
-    "miniflare": "^2.4.0",
     "myzod": "^1.3.1",
-    "next": "^13.0.0",
-    "node-fetch": "^2.6.1",
+    "next": "^13.2.1",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "rollup": "^2.79.1",
     "superjson": "^1.7.4",
-    "superstruct": "^0.16.0",
+    "superstruct": "^1.0.0",
     "tsx": "^3.9.0",
     "typescript": "^4.8.3",
+    "vitest": "^0.28.5",
     "ws": "^8.0.0",
-    "yup": "^0.32.8",
+    "yup": "^1.0.0",
     "zod": "^3.0.0"
   },
-  "gitHead": "cece9537d172ee576034cd04d49c417d3954d03c"
+  "gitHead": "1214c2d1d239c6864a32c7df24651899551be8f8"
 }

package/src/adapters/fastify/fastifyRequestHandler.ts

@@ -64,7 +64,7 @@ export async function fastifyRequestHandler<
     res.statusCode = result.status;
   }
   for (const [key, value] of Object.entries(result.headers ?? {})) {
-    /* istanbul ignore if  */
+    /* istanbul ignore if -- @preserve */
     if (typeof value === 'undefined') {
       continue;
     }

package/src/adapters/fetch/fetchRequestHandler.ts

@@ -39,7 +39,7 @@ export async function fetchRequestHandler<TRouter extends AnyRouter>(
   });
 
   for (const [key, value] of Object.entries(result.headers ?? {})) {
-    /* istanbul ignore if  */
+    /* istanbul ignore if -- @preserve */
     if (typeof value === 'undefined') {
       continue;
     }

package/src/adapters/ws.ts

@@ -23,19 +23,19 @@ import {
   NodeHTTPCreateContextOption,
 } from './node-http';
 
-/* istanbul ignore next */
+/* istanbul ignore next -- @preserve */
 function assertIsObject(obj: unknown): asserts obj is Record<string, unknown> {
   if (typeof obj !== 'object' || Array.isArray(obj) || !obj) {
     throw new Error('Not an object');
   }
 }
-/* istanbul ignore next */
+/* istanbul ignore next -- @preserve */
 function assertIsProcedureType(obj: unknown): asserts obj is ProcedureType {
   if (obj !== 'query' && obj !== 'subscription' && obj !== 'mutation') {
     throw new Error('Invalid procedure type');
   }
 }
-/* istanbul ignore next */
+/* istanbul ignore next -- @preserve */
 function assertIsRequestId(
   obj: unknown,
 ): asserts obj is number | string | null {
@@ -48,13 +48,13 @@ function assertIsRequestId(
     throw new Error('Invalid request id');
   }
 }
-/* istanbul ignore next */
+/* istanbul ignore next -- @preserve */
 function assertIsString(obj: unknown): asserts obj is string {
   if (typeof obj !== 'string') {
     throw new Error('Invalid string');
   }
 }
-/* istanbul ignore next */
+/* istanbul ignore next -- @preserve */
 function assertIsJSONRPC2OrUndefined(
   obj: unknown,
 ): asserts obj is '2.0' | undefined {
@@ -145,7 +145,7 @@ export function applyWSSHandler<TRouter extends AnyRouter>(
 
     async function handleRequest(msg: TRPCClientOutgoingMessage) {
       const { id, jsonrpc } = msg;
-      /* istanbul ignore next */
+      /* istanbul ignore next -- @preserve */
       if (id === null) {
         throw new TRPCError({
           code: 'BAD_REQUEST',
@@ -230,7 +230,7 @@ export function applyWSSHandler<TRouter extends AnyRouter>(
             });
           },
         });
-        /* istanbul ignore next */
+        /* istanbul ignore next -- @preserve */
         if (client.readyState !== client.OPEN) {
           // if the client got disconnected whilst initializing the subscription
           // no need to send stopped message if the client is disconnected
@@ -238,7 +238,7 @@ export function applyWSSHandler<TRouter extends AnyRouter>(
           return;
         }
 
-        /* istanbul ignore next */
+        /* istanbul ignore next -- @preserve */
         if (clientSubscriptions.has(id)) {
           // duplicate request ids for client
           stopSubscription(sub, { id, jsonrpc });
@@ -256,7 +256,7 @@ export function applyWSSHandler<TRouter extends AnyRouter>(
             type: 'started',
           },
         });
-      } catch (cause) /* istanbul ignore next */ {
+      } catch (cause) /* istanbul ignore next -- @preserve */ {
         // procedure threw an error
         const error = getTRPCErrorFromUnknown(cause);
         opts.onError?.({ error, path, type, ctx, req, input });

package/src/core/index.ts

@@ -15,6 +15,7 @@ export type {
   ProcedureArgs,
   ProcedureOptions,
 } from './procedure';
+export type { inferParser } from './parser';
 export { createInputMiddleware, createOutputMiddleware } from './middleware';
 
 export { initTRPC } from './initTRPC';

package/src/core/internals/config.ts

@@ -1,4 +1,5 @@
 import { ErrorFormatter } from '../../error/formatter';
+import type { TRPCErrorShape } from '../../rpc';
 
 /**
  * The initial generics that are used in the init function
@@ -18,7 +19,8 @@ export const isServerDefault: boolean =
   typeof window === 'undefined' ||
   'Deno' in window ||
   globalThis.process?.env?.NODE_ENV === 'test' ||
-  !!globalThis.process?.env?.JEST_WORKER_ID;
+  !!globalThis.process?.env?.JEST_WORKER_ID ||
+  !!globalThis.process?.env?.VITEST_WORKER_ID;
 
 /**
  * The runtime config that are used and actually represents real values underneath
@@ -34,7 +36,10 @@ export interface RuntimeConfig<TTypes extends RootConfigTypes> {
    * Use custom error formatting
    * @link https://trpc.io/docs/error-formatting
    */
-  errorFormatter: ErrorFormatter<TTypes['ctx'], any>;
+  errorFormatter: ErrorFormatter<
+    TTypes['ctx'],
+    TRPCErrorShape<number> & { [key: string]: any }
+  >;
   /**
    * Allow `@trpc/server` to run in non-server environments
    * @warning **Use with caution**, this should likely mainly be used within testing.

package/src/core/internals/procedureBuilder.ts

@@ -1,11 +1,6 @@
 import { TRPCError } from '../../error/TRPCError';
 import { getTRPCErrorFromUnknown } from '../../error/utils';
-import {
-  InferOptional,
-  MaybePromise,
-  Simplify,
-  UndefinedKeys,
-} from '../../types';
+import { MaybePromise, Simplify } from '../../types';
 import {
   MiddlewareBuilder,
   MiddlewareFunction,
@@ -68,19 +63,9 @@ export interface BuildProcedure<
       : TParams
   > {}
 
-type Merge<TType, TWith> = {
-  [TKey in keyof TType | keyof TWith]: TKey extends keyof TType
-    ? TKey extends keyof TWith
-      ? TType[TKey] & TWith[TKey]
-      : TType[TKey]
-    : TWith[TKey & keyof TWith];
-};
-
 type OverwriteIfDefined<TType, TWith> = UnsetMarker extends TType
   ? TWith
-  : Simplify<
-      InferOptional<Merge<TType, TWith>, UndefinedKeys<Merge<TType, TWith>>>
-    >;
+  : Simplify<TType & TWith>;
 
 type ErrorMessage<TMessage extends string> = TMessage;
 
@@ -104,9 +89,13 @@ export interface ProcedureBuilder<TParams extends ProcedureParams> {
   input<$Parser extends Parser>(
     schema: TParams['_input_out'] extends UnsetMarker
       ? $Parser
-      : inferParser<$Parser>['out'] extends Record<string, unknown>
-      ? TParams['_input_out'] extends Record<string, unknown>
-        ? $Parser
+      : inferParser<$Parser>['out'] extends Record<string, unknown> | undefined
+      ? TParams['_input_out'] extends Record<string, unknown> | undefined
+        ? undefined extends inferParser<$Parser>['out'] // if current is optional the previous must be too
+          ? undefined extends TParams['_input_out']
+            ? $Parser
+            : ErrorMessage<'Cannot chain an optional parser to a required parser'>
+          : $Parser
         : ErrorMessage<'All input parsers did not resolve to an object'>
       : ErrorMessage<'All input parsers did not resolve to an object'>,
   ): ProcedureBuilder<{

package/src/http/resolveHTTPResponse.ts

@@ -124,7 +124,7 @@ export async function resolveHTTPResponse<
     if (isBatchCall && !batchingEnabled) {
       throw new Error(`Batching is not enabled on the server`);
     }
-    /* istanbul ignore if  */
+    /* istanbul ignore if -- @preserve */
     if (type === 'subscription') {
       throw new TRPCError({
         message: 'Subscriptions should use wsLink',
@@ -154,7 +154,7 @@ export async function resolveHTTPResponse<
         };
       }
 
-      /* istanbul ignore if  */
+      /* istanbul ignore if -- @preserve */
       if (
         rawInput == null ||
         typeof rawInput !== 'object' ||
@@ -238,6 +238,7 @@ export async function resolveHTTPResponse<
     // - `createContext()` throws
     // - post body is too large
     // - input deserialization fails
+    // - `errorFormatter` return value is malformed
     const error = getTRPCErrorFromUnknown(cause);
 
     onError?.({

package/src/internals.ts

@@ -2,12 +2,11 @@
  * These types have to be exported so users can generate their own types definitions files
  */
 export type { DefaultErrorShape } from './error/formatter';
-export type { MergeRouters } from './core/internals/mergeRouters';
+export type { mergeRouters } from './core/internals/mergeRouters';
 export type { RootConfig, AnyRootConfig } from './core/internals/config';
 export type {
   ProcedureBuilder,
   BuildProcedure,
 } from './core/internals/procedureBuilder';
 export type { Overwrite, unsetMarker } from './core/internals/utils';
-export type { MiddlewareFunction } from './core/middleware';
-export type { Router, RouterDef } from './core/router';
+export type { MiddlewareFunction, MiddlewareBuilder } from './core/middleware';