@trpc/server 10.12.0 → 10.13.1

package/dist/observable-a1c2103f.js

@@ -0,0 +1,83 @@
+function identity(x) {
+    return x;
+}
+
+/** @internal */
+function pipeFromArray(fns) {
+    if (fns.length === 0) {
+        return identity;
+    }
+    if (fns.length === 1) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return fns[0];
+    }
+    return function piped(input) {
+        return fns.reduce((prev, fn) => fn(prev), input);
+    };
+}
+
+function isObservable(x) {
+    return typeof x === 'object' && x !== null && 'subscribe' in x;
+}
+function observable(subscribe) {
+    const self = {
+        subscribe(observer) {
+            let teardownRef = null;
+            let isDone = false;
+            let unsubscribed = false;
+            let teardownImmediately = false;
+            function unsubscribe() {
+                if (teardownRef === null) {
+                    teardownImmediately = true;
+                    return;
+                }
+                if (unsubscribed) {
+                    return;
+                }
+                unsubscribed = true;
+                if (typeof teardownRef === 'function') {
+                    teardownRef();
+                }
+                else if (teardownRef) {
+                    teardownRef.unsubscribe();
+                }
+            }
+            teardownRef = subscribe({
+                next(value) {
+                    if (isDone) {
+                        return;
+                    }
+                    observer.next?.(value);
+                },
+                error(err) {
+                    if (isDone) {
+                        return;
+                    }
+                    isDone = true;
+                    observer.error?.(err);
+                    unsubscribe();
+                },
+                complete() {
+                    if (isDone) {
+                        return;
+                    }
+                    isDone = true;
+                    observer.complete?.();
+                    unsubscribe();
+                },
+            });
+            if (teardownImmediately) {
+                unsubscribe();
+            }
+            return {
+                unsubscribe,
+            };
+        },
+        pipe(...operations) {
+            return pipeFromArray(operations)(self);
+        },
+    };
+    return self;
+}
+
+export { isObservable as i, observable as o };

package/dist/resolveHTTPResponse-39258d19.js

@@ -0,0 +1,205 @@
+import { e as callProcedure, f as getHTTPStatusCode } from './config-69ee2314.js';
+import { T as TRPCError, a as getTRPCErrorFromUnknown, g as getCauseFromUnknown } from './TRPCError-ed16b3b7.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/{resolveHTTPResponse-64517f5d.mjs → resolveHTTPResponse-8e9dd846.mjs}

@@ -1,5 +1,5 @@
-import { e as callProcedure, f as getHTTPStatusCode } from './config-4ca0221b.mjs';
-import { T as TRPCError, a as getTRPCErrorFromUnknown, g as getCauseFromUnknown } from './TRPCError-7de0a793.mjs';
+import { e as callProcedure, f as getHTTPStatusCode } from './config-fb5f49a1.mjs';
+import { T as TRPCError, a as getTRPCErrorFromUnknown, g as getCauseFromUnknown } from './TRPCError-e7333eae.mjs';
 import { t as transformTRPCResponse } from './transformTRPCResponse-7a73a2df.mjs';
 
 const HTTP_METHOD_PROCEDURE_TYPE_MAP = {
@@ -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'

package/dist/{resolveHTTPResponse-5e0173eb.js → resolveHTTPResponse-cbfdc43d.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var config = require('./config-d356ff77.js');
-var TRPCError = require('./TRPCError-bd37df84.js');
+var config = require('./config-bd759464.js');
+var TRPCError = require('./TRPCError-4cbab0d0.js');
 var transformTRPCResponse = require('./transformTRPCResponse-d2700b72.js');
 
 const HTTP_METHOD_PROCEDURE_TYPE_MAP = {
@@ -77,7 +77,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.TRPCError({
                 message: 'Subscriptions should use wsLink',
                 code: 'METHOD_NOT_SUPPORTED'
@@ -103,7 +103,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.TRPCError({
                     code: 'BAD_REQUEST',
                     message: '"input" needs to be an object when doing a batch call'

package/dist/subscription.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var TRPCError = require('./TRPCError-bd37df84.js');
+var TRPCError = require('./TRPCError-4cbab0d0.js');
 var observable = require('./observable-464116ac.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

@@ -1,4 +1,4 @@
-import { a as getTRPCErrorFromUnknown } from './TRPCError-7de0a793.mjs';
+import { a as getTRPCErrorFromUnknown } from './TRPCError-e7333eae.mjs';
 import { o as observable } from './observable-ade1bad8.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.12.0",
+  "version": "10.13.1",
   "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",
-    "tsx": "^3.9.0",
+    "superstruct": "^1.0.0",
+    "tsx": "^3.12.3",
     "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": "5f5d1f937dcae4addd850d320f3c0273559fd2ab"
+  "gitHead": "861a1f60359e1a5dffbcbfa6c0e55f4944138a25"
 }

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

@@ -6,8 +6,8 @@ import {
   callProcedure,
   inferRouterContext,
 } from '../core';
-import { TRPCError } from '../error/TRPCError';
-import { getCauseFromUnknown, getTRPCErrorFromUnknown } from '../error/utils';
+import { TRPCError, getTRPCErrorFromUnknown } from '../error/TRPCError';
+import { getCauseFromUnknown } from '../error/utils';
 import { transformTRPCResponse } from '../internals/transformTRPCResponse';
 import { BaseHandlerOptions } from '../internals/types';
 import { Unsubscribable, isObservable } from '../observable';
@@ -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';