@trpc/server 11.0.0-alpha-tmp-subscription-connection-state.489 → 11.0.0-alpha-tmp-12-06-react.665

package/dist/adapters/node-http/nodeHTTPRequestHandler.js

@@ -1,9 +1,15 @@
 'use strict';
 
+var getErrorShape = require('../../unstable-core-do-not-import/error/getErrorShape.js');
 var TRPCError = require('../../unstable-core-do-not-import/error/TRPCError.js');
+var utils = require('../../unstable-core-do-not-import/utils.js');
 var resolveResponse = require('../../unstable-core-do-not-import/http/resolveResponse.js');
 require('../../unstable-core-do-not-import/rootConfig.js');
+var transformer = require('../../unstable-core-do-not-import/transformer.js');
+require('../../vendor/unpromise/unpromise.js');
+require('../../unstable-core-do-not-import/stream/utils/disposable.js');
 var incomingMessageToRequest = require('./incomingMessageToRequest.js');
+var writeResponse = require('./writeResponse.js');
 
 /**
  * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
@@ -14,70 +20,76 @@ var incomingMessageToRequest = require('./incomingMessageToRequest.js');
  * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
  * ```
  */ // @trpc/server
-async function nodeHTTPRequestHandler(opts) {
-    const handleViaMiddleware = opts.middleware ?? ((_req, _res, next)=>next());
-    return handleViaMiddleware(opts.req, opts.res, async (err)=>{
-        const req = incomingMessageToRequest.incomingMessageToRequest(opts.req, {
-            maxBodySize: opts.maxBodySize ?? null
+/**
+ * @internal
+ */ function internal_exceptionHandler(opts) {
+    return (cause)=>{
+        const { res, req } = opts;
+        const error = TRPCError.getTRPCErrorFromUnknown(cause);
+        const shape = getErrorShape.getErrorShape({
+            config: opts.router._def._config,
+            error,
+            type: 'unknown',
+            path: undefined,
+            input: undefined,
+            ctx: undefined
         });
-        // Build tRPC dependencies
-        const createContext = async (innerOpts)=>{
-            return await opts.createContext?.({
-                ...opts,
-                ...innerOpts
-            });
-        };
-        const response = await resolveResponse.resolveResponse({
-            ...opts,
+        opts.onError?.({
             req,
-            error: err ? TRPCError.getTRPCErrorFromUnknown(err) : null,
-            createContext,
-            onError (o) {
-                opts?.onError?.({
-                    ...o,
-                    req: opts.req
-                });
-            }
+            error,
+            type: 'unknown',
+            path: undefined,
+            input: undefined,
+            ctx: undefined
+        });
+        const transformed = transformer.transformTRPCResponse(opts.router._def._config, {
+            error: shape
         });
-        const { res  } = opts;
-        if (res.statusCode === 200) {
-            // if the status code is set, we assume that it's been manually overridden
-            res.statusCode = response.status;
-        }
-        for (const [key, value] of response.headers){
-            res.setHeader(key, value);
-        }
-        if (response.body) {
-            const reader = response.body.getReader();
-            const onAbort = ()=>{
-                // cancelling the reader will cause the whole stream to be cancelled
-                reader.cancel().catch(()=>{
-                // console.error('reader.cancel() error', err);
+        res.statusCode = shape.data.httpStatus;
+        res.end(JSON.stringify(transformed));
+    };
+}
+/**
+ * @remark the promise never rejects
+ */ async function nodeHTTPRequestHandler(opts) {
+    return new Promise((resolve)=>{
+        const handleViaMiddleware = opts.middleware ?? ((_req, _res, next)=>next());
+        opts.res.once('finish', ()=>{
+            resolve();
+        });
+        return handleViaMiddleware(opts.req, opts.res, (err)=>{
+            utils.run(async ()=>{
+                const request = incomingMessageToRequest.incomingMessageToRequest(opts.req, opts.res, {
+                    maxBodySize: opts.maxBodySize ?? null
                 });
-            };
-            req.signal.addEventListener('abort', onAbort, {
-                once: true
-            });
-            while(true){
-                const { done , value: value1  } = await reader.read();
-                if (done) {
-                    break;
-                }
-                if (!res.writable) {
-                    break;
-                }
-                if (res.write(value1) === false) {
-                    await new Promise((resolve)=>{
-                        res.once('drain', resolve);
+                // Build tRPC dependencies
+                const createContext = async (innerOpts)=>{
+                    return await opts.createContext?.({
+                        ...opts,
+                        ...innerOpts
                     });
-                }
-                // IMPORTANT - flush the response buffer, otherwise the client will not receive the data until `.end()`
-                res.flush?.();
-            }
-            req.signal.removeEventListener('abort', onAbort);
-        }
-        res.end();
+                };
+                const response = await resolveResponse.resolveResponse({
+                    ...opts,
+                    req: request,
+                    error: err ? TRPCError.getTRPCErrorFromUnknown(err) : null,
+                    createContext,
+                    onError (o) {
+                        opts?.onError?.({
+                            ...o,
+                            req: opts.req
+                        });
+                    }
+                });
+                await writeResponse.writeResponse({
+                    request,
+                    response,
+                    rawResponse: opts.res
+                });
+            }).catch(internal_exceptionHandler(opts));
+        });
     });
 }
 
+exports.internal_exceptionHandler = internal_exceptionHandler;
 exports.nodeHTTPRequestHandler = nodeHTTPRequestHandler;

package/dist/adapters/node-http/nodeHTTPRequestHandler.mjs

@@ -1,7 +1,13 @@
+import { getErrorShape } from '../../unstable-core-do-not-import/error/getErrorShape.mjs';
 import { getTRPCErrorFromUnknown } from '../../unstable-core-do-not-import/error/TRPCError.mjs';
+import { run } from '../../unstable-core-do-not-import/utils.mjs';
 import { resolveResponse } from '../../unstable-core-do-not-import/http/resolveResponse.mjs';
 import '../../unstable-core-do-not-import/rootConfig.mjs';
+import { transformTRPCResponse } from '../../unstable-core-do-not-import/transformer.mjs';
+import '../../vendor/unpromise/unpromise.mjs';
+import '../../unstable-core-do-not-import/stream/utils/disposable.mjs';
 import { incomingMessageToRequest } from './incomingMessageToRequest.mjs';
+import { writeResponse } from './writeResponse.mjs';
 
 /**
  * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
@@ -12,70 +18,75 @@ import { incomingMessageToRequest } from './incomingMessageToRequest.mjs';
  * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
  * ```
  */ // @trpc/server
-async function nodeHTTPRequestHandler(opts) {
-    const handleViaMiddleware = opts.middleware ?? ((_req, _res, next)=>next());
-    return handleViaMiddleware(opts.req, opts.res, async (err)=>{
-        const req = incomingMessageToRequest(opts.req, {
-            maxBodySize: opts.maxBodySize ?? null
+/**
+ * @internal
+ */ function internal_exceptionHandler(opts) {
+    return (cause)=>{
+        const { res, req } = opts;
+        const error = getTRPCErrorFromUnknown(cause);
+        const shape = getErrorShape({
+            config: opts.router._def._config,
+            error,
+            type: 'unknown',
+            path: undefined,
+            input: undefined,
+            ctx: undefined
         });
-        // Build tRPC dependencies
-        const createContext = async (innerOpts)=>{
-            return await opts.createContext?.({
-                ...opts,
-                ...innerOpts
-            });
-        };
-        const response = await resolveResponse({
-            ...opts,
+        opts.onError?.({
             req,
-            error: err ? getTRPCErrorFromUnknown(err) : null,
-            createContext,
-            onError (o) {
-                opts?.onError?.({
-                    ...o,
-                    req: opts.req
-                });
-            }
+            error,
+            type: 'unknown',
+            path: undefined,
+            input: undefined,
+            ctx: undefined
+        });
+        const transformed = transformTRPCResponse(opts.router._def._config, {
+            error: shape
         });
-        const { res  } = opts;
-        if (res.statusCode === 200) {
-            // if the status code is set, we assume that it's been manually overridden
-            res.statusCode = response.status;
-        }
-        for (const [key, value] of response.headers){
-            res.setHeader(key, value);
-        }
-        if (response.body) {
-            const reader = response.body.getReader();
-            const onAbort = ()=>{
-                // cancelling the reader will cause the whole stream to be cancelled
-                reader.cancel().catch(()=>{
-                // console.error('reader.cancel() error', err);
+        res.statusCode = shape.data.httpStatus;
+        res.end(JSON.stringify(transformed));
+    };
+}
+/**
+ * @remark the promise never rejects
+ */ async function nodeHTTPRequestHandler(opts) {
+    return new Promise((resolve)=>{
+        const handleViaMiddleware = opts.middleware ?? ((_req, _res, next)=>next());
+        opts.res.once('finish', ()=>{
+            resolve();
+        });
+        return handleViaMiddleware(opts.req, opts.res, (err)=>{
+            run(async ()=>{
+                const request = incomingMessageToRequest(opts.req, opts.res, {
+                    maxBodySize: opts.maxBodySize ?? null
                 });
-            };
-            req.signal.addEventListener('abort', onAbort, {
-                once: true
-            });
-            while(true){
-                const { done , value: value1  } = await reader.read();
-                if (done) {
-                    break;
-                }
-                if (!res.writable) {
-                    break;
-                }
-                if (res.write(value1) === false) {
-                    await new Promise((resolve)=>{
-                        res.once('drain', resolve);
+                // Build tRPC dependencies
+                const createContext = async (innerOpts)=>{
+                    return await opts.createContext?.({
+                        ...opts,
+                        ...innerOpts
                     });
-                }
-                // IMPORTANT - flush the response buffer, otherwise the client will not receive the data until `.end()`
-                res.flush?.();
-            }
-            req.signal.removeEventListener('abort', onAbort);
-        }
-        res.end();
+                };
+                const response = await resolveResponse({
+                    ...opts,
+                    req: request,
+                    error: err ? getTRPCErrorFromUnknown(err) : null,
+                    createContext,
+                    onError (o) {
+                        opts?.onError?.({
+                            ...o,
+                            req: opts.req
+                        });
+                    }
+                });
+                await writeResponse({
+                    request,
+                    response,
+                    rawResponse: opts.res
+                });
+            }).catch(internal_exceptionHandler(opts));
+        });
     });
 }
 
-export { nodeHTTPRequestHandler };
+export { internal_exceptionHandler, nodeHTTPRequestHandler };

package/dist/adapters/node-http/writeResponse.d.ts

@@ -0,0 +1,18 @@
+import type { NodeHTTPResponse } from './types';
+/**
+ * @internal
+ */
+export declare function writeResponseBody(opts: {
+    res: NodeHTTPResponse;
+    signal: AbortSignal;
+    body: NonNullable<Response['body']>;
+}): Promise<void>;
+/**
+ * @internal
+ */
+export declare function writeResponse(opts: {
+    request: Request;
+    response: Response;
+    rawResponse: NodeHTTPResponse;
+}): Promise<void>;
+//# sourceMappingURL=writeResponse.d.ts.map

package/dist/adapters/node-http/writeResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeResponse.d.ts","sourceRoot":"","sources":["../../../src/adapters/node-http/writeResponse.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AA4BhD;;GAEG;AAEH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE;IAC5C,GAAG,EAAE,gBAAgB,CAAC;IACtB,MAAM,EAAE,WAAW,CAAC;IACpB,IAAI,EAAE,WAAW,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;CACrC,iBAoBA;AACD;;GAEG;AAEH,wBAAsB,aAAa,CAAC,IAAI,EAAE;IACxC,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,QAAQ,CAAC;IACnB,WAAW,EAAE,gBAAgB,CAAC;CAC/B,iBA0BA"}

package/dist/adapters/node-http/writeResponse.js

@@ -0,0 +1,82 @@
+'use strict';
+
+var isAbortError = require('../../unstable-core-do-not-import/http/isAbortError.js');
+require('../../vendor/unpromise/unpromise.js');
+require('../../unstable-core-do-not-import/stream/utils/disposable.js');
+require('../../unstable-core-do-not-import/rootConfig.js');
+
+// eslint-disable-next-line no-restricted-imports
+async function writeResponseBodyChunk(res, chunk) {
+    // useful for debugging 🙃
+    // console.debug('writing', new TextDecoder().decode(chunk));
+    if (res.write(chunk) === false) {
+        await new Promise((resolve, reject)=>{
+            const onError = (err)=>{
+                reject(err);
+                cleanup();
+            };
+            const onDrain = ()=>{
+                resolve();
+                cleanup();
+            };
+            const cleanup = ()=>{
+                res.off('error', onError);
+                res.off('drain', onDrain);
+            };
+            res.once('error', onError);
+            res.once('drain', onDrain);
+        });
+    }
+}
+/**
+ * @internal
+ */ async function writeResponseBody(opts) {
+    const { res } = opts;
+    try {
+        const writableStream = new WritableStream({
+            async write (chunk) {
+                await writeResponseBodyChunk(res, chunk);
+                res.flush?.();
+            }
+        });
+        await opts.body.pipeTo(writableStream, {
+            signal: opts.signal
+        });
+    } catch (err) {
+        if (isAbortError.isAbortError(err)) {
+            return;
+        }
+        throw err;
+    }
+}
+/**
+ * @internal
+ */ async function writeResponse(opts) {
+    const { response, rawResponse } = opts;
+    // Only override status code if it hasn't been explicitly set in a procedure etc
+    if (rawResponse.statusCode === 200) {
+        rawResponse.statusCode = response.status;
+    }
+    for (const [key, value] of response.headers){
+        rawResponse.setHeader(key, value);
+    }
+    try {
+        if (response.body) {
+            await writeResponseBody({
+                res: rawResponse,
+                signal: opts.request.signal,
+                body: response.body
+            });
+        }
+    } catch (err) {
+        if (!rawResponse.headersSent) {
+            rawResponse.statusCode = 500;
+        }
+        throw err;
+    } finally{
+        rawResponse.end();
+    }
+}
+
+exports.writeResponse = writeResponse;
+exports.writeResponseBody = writeResponseBody;

package/dist/adapters/node-http/writeResponse.mjs

@@ -0,0 +1,79 @@
+import { isAbortError } from '../../unstable-core-do-not-import/http/isAbortError.mjs';
+import '../../vendor/unpromise/unpromise.mjs';
+import '../../unstable-core-do-not-import/stream/utils/disposable.mjs';
+import '../../unstable-core-do-not-import/rootConfig.mjs';
+
+// eslint-disable-next-line no-restricted-imports
+async function writeResponseBodyChunk(res, chunk) {
+    // useful for debugging 🙃
+    // console.debug('writing', new TextDecoder().decode(chunk));
+    if (res.write(chunk) === false) {
+        await new Promise((resolve, reject)=>{
+            const onError = (err)=>{
+                reject(err);
+                cleanup();
+            };
+            const onDrain = ()=>{
+                resolve();
+                cleanup();
+            };
+            const cleanup = ()=>{
+                res.off('error', onError);
+                res.off('drain', onDrain);
+            };
+            res.once('error', onError);
+            res.once('drain', onDrain);
+        });
+    }
+}
+/**
+ * @internal
+ */ async function writeResponseBody(opts) {
+    const { res } = opts;
+    try {
+        const writableStream = new WritableStream({
+            async write (chunk) {
+                await writeResponseBodyChunk(res, chunk);
+                res.flush?.();
+            }
+        });
+        await opts.body.pipeTo(writableStream, {
+            signal: opts.signal
+        });
+    } catch (err) {
+        if (isAbortError(err)) {
+            return;
+        }
+        throw err;
+    }
+}
+/**
+ * @internal
+ */ async function writeResponse(opts) {
+    const { response, rawResponse } = opts;
+    // Only override status code if it hasn't been explicitly set in a procedure etc
+    if (rawResponse.statusCode === 200) {
+        rawResponse.statusCode = response.status;
+    }
+    for (const [key, value] of response.headers){
+        rawResponse.setHeader(key, value);
+    }
+    try {
+        if (response.body) {
+            await writeResponseBody({
+                res: rawResponse,
+                signal: opts.request.signal,
+                body: response.body
+            });
+        }
+    } catch (err) {
+        if (!rawResponse.headersSent) {
+            rawResponse.statusCode = 500;
+        }
+        throw err;
+    } finally{
+        rawResponse.end();
+    }
+}
+
+export { writeResponse, writeResponseBody };

package/dist/adapters/standalone.d.ts

@@ -8,10 +8,13 @@
  * ```
  */
 import http from 'http';
-import type { AnyRouter } from '../@trpc/server';
+import { type AnyRouter } from '../@trpc/server';
 import type { NodeHTTPCreateContextFnOptions, NodeHTTPHandlerOptions } from './node-http';
 export type CreateHTTPHandlerOptions<TRouter extends AnyRouter> = NodeHTTPHandlerOptions<TRouter, http.IncomingMessage, http.ServerResponse>;
 export type CreateHTTPContextOptions = NodeHTTPCreateContextFnOptions<http.IncomingMessage, http.ServerResponse>;
-export declare function createHTTPHandler<TRouter extends AnyRouter>(opts: CreateHTTPHandlerOptions<TRouter>): (req: http.IncomingMessage, res: http.ServerResponse) => Promise<void>;
+/**
+ * @internal
+ */
+export declare function createHTTPHandler<TRouter extends AnyRouter>(opts: CreateHTTPHandlerOptions<TRouter>): http.RequestListener;
 export declare function createHTTPServer<TRouter extends AnyRouter>(opts: CreateHTTPHandlerOptions<TRouter>): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
 //# sourceMappingURL=standalone.d.ts.map

package/dist/adapters/standalone.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"standalone.d.ts","sourceRoot":"","sources":["../../src/adapters/standalone.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,IAAI,MAAM,MAAM,CAAC;AAExB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,OAAO,KAAK,EACV,8BAA8B,EAC9B,sBAAsB,EACvB,MAAM,aAAa,CAAC;AAGrB,MAAM,MAAM,wBAAwB,CAAC,OAAO,SAAS,SAAS,IAC5D,sBAAsB,CAAC,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;AAE7E,MAAM,MAAM,wBAAwB,GAAG,8BAA8B,CACnE,IAAI,CAAC,eAAe,EACpB,IAAI,CAAC,cAAc,CACpB,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,OAAO,SAAS,SAAS,EACzD,IAAI,EAAE,wBAAwB,CAAC,OAAO,CAAC,SAEpB,IAAI,CAAC,eAAe,OAAO,IAAI,CAAC,cAAc,mBAclE;AAED,wBAAgB,gBAAgB,CAAC,OAAO,SAAS,SAAS,EACxD,IAAI,EAAE,wBAAwB,CAAC,OAAO,CAAC,wEAIxC"}
+{"version":3,"file":"standalone.d.ts","sourceRoot":"","sources":["../../src/adapters/standalone.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,IAAI,MAAM,MAAM,CAAC;AAExB,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAGjD,OAAO,KAAK,EACV,8BAA8B,EAC9B,sBAAsB,EACvB,MAAM,aAAa,CAAC;AAOrB,MAAM,MAAM,wBAAwB,CAAC,OAAO,SAAS,SAAS,IAC5D,sBAAsB,CAAC,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;AAE7E,MAAM,MAAM,wBAAwB,GAAG,8BAA8B,CACnE,IAAI,CAAC,eAAe,EACpB,IAAI,CAAC,cAAc,CACpB,CAAC;AAEF;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,SAAS,SAAS,EACzD,IAAI,EAAE,wBAAwB,CAAC,OAAO,CAAC,GACtC,IAAI,CAAC,eAAe,CAyBtB;AAED,wBAAgB,gBAAgB,CAAC,OAAO,SAAS,SAAS,EACxD,IAAI,EAAE,wBAAwB,CAAC,OAAO,CAAC,wEAGxC"}

package/dist/adapters/standalone.js

@@ -1,27 +1,39 @@
 'use strict';
 
 var http = require('node:http');
-var toURL = require('../unstable-core-do-not-import/http/toURL.js');
+var utils = require('../unstable-core-do-not-import/utils.js');
+require('../vendor/unpromise/unpromise.js');
+require('../unstable-core-do-not-import/stream/utils/disposable.js');
 require('../unstable-core-do-not-import/rootConfig.js');
 var nodeHTTPRequestHandler = require('./node-http/nodeHTTPRequestHandler.js');
+var incomingMessageToRequest = require('./node-http/incomingMessageToRequest.js');
 
-function createHTTPHandler(opts) {
-    return async (req, res)=>{
-        const url = toURL.toURL(req.url);
-        // get procedure path and remove the leading slash
-        // /procedure -> procedure
-        const path = url.pathname.slice(1);
-        await nodeHTTPRequestHandler.nodeHTTPRequestHandler({
-            ...opts,
+/**
+ * @internal
+ */ function createHTTPHandler(opts) {
+    return (req, res)=>{
+        let path = '';
+        utils.run(async ()=>{
+            const url = incomingMessageToRequest.createURL(req);
+            // get procedure path and remove the leading slash
+            // /procedure -> procedure
+            path = url.pathname.slice(1);
+            await nodeHTTPRequestHandler.nodeHTTPRequestHandler({
+                ...opts,
+                req,
+                res,
+                path
+            });
+        }).catch(nodeHTTPRequestHandler.internal_exceptionHandler({
             req,
             res,
-            path
-        });
+            path,
+            ...opts
+        }));
     };
 }
 function createHTTPServer(opts) {
-    const handler = createHTTPHandler(opts);
-    return http.createServer(handler);
+    return http.createServer(createHTTPHandler(opts));
 }
 
 exports.createHTTPHandler = createHTTPHandler;

package/dist/adapters/standalone.mjs

@@ -1,25 +1,37 @@
 import http from 'node:http';
-import { toURL } from '../unstable-core-do-not-import/http/toURL.mjs';
+import { run } from '../unstable-core-do-not-import/utils.mjs';
+import '../vendor/unpromise/unpromise.mjs';
+import '../unstable-core-do-not-import/stream/utils/disposable.mjs';
 import '../unstable-core-do-not-import/rootConfig.mjs';
-import { nodeHTTPRequestHandler } from './node-http/nodeHTTPRequestHandler.mjs';
+import { nodeHTTPRequestHandler, internal_exceptionHandler } from './node-http/nodeHTTPRequestHandler.mjs';
+import { createURL } from './node-http/incomingMessageToRequest.mjs';
 
-function createHTTPHandler(opts) {
-    return async (req, res)=>{
-        const url = toURL(req.url);
-        // get procedure path and remove the leading slash
-        // /procedure -> procedure
-        const path = url.pathname.slice(1);
-        await nodeHTTPRequestHandler({
-            ...opts,
+/**
+ * @internal
+ */ function createHTTPHandler(opts) {
+    return (req, res)=>{
+        let path = '';
+        run(async ()=>{
+            const url = createURL(req);
+            // get procedure path and remove the leading slash
+            // /procedure -> procedure
+            path = url.pathname.slice(1);
+            await nodeHTTPRequestHandler({
+                ...opts,
+                req,
+                res,
+                path
+            });
+        }).catch(internal_exceptionHandler({
             req,
             res,
-            path
-        });
+            path,
+            ...opts
+        }));
     };
 }
 function createHTTPServer(opts) {
-    const handler = createHTTPHandler(opts);
-    return http.createServer(handler);
+    return http.createServer(createHTTPHandler(opts));
 }
 
 export { createHTTPHandler, createHTTPServer };

package/dist/adapters/ws.d.ts

@@ -3,7 +3,7 @@ import type ws from 'ws';
 import type { AnyRouter, CreateContextCallback, inferRouterContext } from '../@trpc/server';
 import { type BaseHandlerOptions } from '../@trpc/server/http';
 import { type MaybePromise } from '../unstable-core-do-not-import';
-import type { NodeHTTPCreateContextFnOptions } from './node-http';
+import { type NodeHTTPCreateContextFnOptions } from './node-http';
 /**
  * @public
  */
@@ -27,17 +27,27 @@ export type WSSHandlerOptions<TRouter extends AnyRouter> = WSConnectionHandlerOp
         enabled: boolean;
         /**
          * Heartbeat interval in milliseconds
-         * @default 30000
+         * @default 30_000
          */
         pingMs?: number;
         /**
          * Terminate the WebSocket if no pong is received after this many milliseconds
-         * @default 5000
+         * @default 5_000
          */
         pongWaitMs?: number;
     };
+    /**
+     * Disable responding to ping messages from the client
+     * **Not recommended** - this is mainly used for testing
+     * @default false
+     */
+    dangerouslyDisablePong?: boolean;
 };
-export declare function getWSConnectionHandler<TRouter extends AnyRouter>(opts: WSConnectionHandlerOptions<TRouter>): (client: ws.WebSocket, req: IncomingMessage) => Promise<void>;
+export declare function getWSConnectionHandler<TRouter extends AnyRouter>(opts: WSSHandlerOptions<TRouter>): (client: ws.WebSocket, req: IncomingMessage) => Promise<void>;
+/**
+ * Handle WebSocket keep-alive messages
+ */
+export declare function handleKeepAlive(client: ws.WebSocket, pingMs?: number, pongWaitMs?: number): void;
 export declare function applyWSSHandler<TRouter extends AnyRouter>(opts: WSSHandlerOptions<TRouter>): {
     broadcastReconnectNotification: () => void;
 };