@trpc/server 10.0.0-alpha.2 → 10.0.0-alpha.22

package/dist/adapters/ws.mjs

@@ -0,0 +1,380 @@
+import { T as TRPCError, g as getCauseFromUnknown, a as getErrorFromUnknown } from '../TRPCError-7971540a.mjs';
+import { t as transformTRPCResponse, c as callProcedure } from '../transformTRPCResponse-e0cba527.mjs';
+import { i as isObservable } from '../observable-137ea1bd.mjs';
+
+/* istanbul ignore next */
+function assertIsObject(obj) {
+  if (typeof obj !== 'object' || Array.isArray(obj) || !obj) {
+    throw new Error('Not an object');
+  }
+}
+/* istanbul ignore next */
+
+
+function assertIsProcedureType(obj) {
+  if (obj !== 'query' && obj !== 'subscription' && obj !== 'mutation') {
+    throw new Error('Invalid procedure type');
+  }
+}
+/* istanbul ignore next */
+
+
+function assertIsRequestId(obj) {
+  if (obj !== null && typeof obj === 'number' && isNaN(obj) && typeof obj !== 'string') {
+    throw new Error('Invalid request id');
+  }
+}
+/* istanbul ignore next */
+
+
+function assertIsString(obj) {
+  if (typeof obj !== 'string') {
+    throw new Error('Invalid string');
+  }
+}
+/* istanbul ignore next */
+
+
+function assertIsJSONRPC2OrUndefined(obj) {
+  if (typeof obj !== 'undefined' && obj !== '2.0') {
+    throw new Error('Must be JSONRPC 2.0');
+  }
+}
+
+function parseMessage(obj, transformer) {
+  assertIsObject(obj);
+  const {
+    method,
+    params,
+    id,
+    jsonrpc
+  } = obj;
+  assertIsRequestId(id);
+  assertIsJSONRPC2OrUndefined(jsonrpc);
+
+  if (method === 'subscription.stop') {
+    return {
+      id,
+      jsonrpc,
+      method
+    };
+  }
+
+  assertIsProcedureType(method);
+  assertIsObject(params);
+  const {
+    input: rawInput,
+    path
+  } = params;
+  assertIsString(path);
+  const input = transformer.input.deserialize(rawInput);
+  return {
+    id,
+    jsonrpc,
+    method,
+    params: {
+      input,
+      path
+    }
+  };
+}
+/**
+ * Web socket server handler
+ */
+
+
+function applyWSSHandler(opts) {
+  const {
+    wss,
+    createContext,
+    router
+  } = opts;
+  const {
+    transformer
+  } = router._def;
+  wss.on('connection', async (client, req) => {
+    const clientSubscriptions = new Map();
+
+    function respond(untransformedJSON) {
+      client.send(JSON.stringify(transformTRPCResponse(router, untransformedJSON)));
+    }
+
+    function stopSubscription(subscription, {
+      id,
+      jsonrpc
+    }) {
+      subscription.unsubscribe();
+      respond({
+        id,
+        jsonrpc,
+        result: {
+          type: 'stopped'
+        }
+      });
+    }
+
+    const ctxPromise = createContext === null || createContext === void 0 ? void 0 : createContext({
+      req,
+      res: client
+    });
+    let ctx = undefined;
+
+    async function handleRequest(msg) {
+      const {
+        id,
+        jsonrpc
+      } = msg;
+      /* istanbul ignore next */
+
+      if (id === null) {
+        throw new TRPCError({
+          code: 'BAD_REQUEST',
+          message: '`id` is required'
+        });
+      }
+
+      if (msg.method === 'subscription.stop') {
+        const sub = clientSubscriptions.get(id);
+
+        if (sub) {
+          stopSubscription(sub, {
+            id,
+            jsonrpc
+          });
+        }
+
+        clientSubscriptions.delete(id);
+        return;
+      }
+
+      const {
+        path,
+        input
+      } = msg.params;
+      const type = msg.method;
+
+      try {
+        await ctxPromise; // asserts context has been set
+
+        const result = await callProcedure({
+          path,
+          input,
+          type,
+          router,
+          ctx
+        });
+
+        if (type === 'subscription') {
+          if (!isObservable(result)) {
+            throw new TRPCError({
+              message: `Subscription ${path} did not return an observable`,
+              code: 'INTERNAL_SERVER_ERROR'
+            });
+          }
+        } else {
+          // send the value as data if the method is not a subscription
+          respond({
+            id,
+            jsonrpc,
+            result: {
+              type: 'data',
+              data: result
+            }
+          });
+          return;
+        }
+
+        const observable = result;
+        const sub = observable.subscribe({
+          next(data) {
+            respond({
+              id,
+              jsonrpc,
+              result: {
+                type: 'data',
+                data
+              }
+            });
+          },
+
+          error(err) {
+            var _opts$onError;
+
+            const error = getErrorFromUnknown(err);
+            (_opts$onError = opts.onError) === null || _opts$onError === void 0 ? void 0 : _opts$onError.call(opts, {
+              error,
+              path,
+              type,
+              ctx,
+              req,
+              input
+            });
+            respond({
+              id,
+              jsonrpc,
+              error: router.getErrorShape({
+                error,
+                type,
+                path,
+                input,
+                ctx
+              })
+            });
+          },
+
+          complete() {
+            respond({
+              id,
+              jsonrpc,
+              result: {
+                type: 'stopped'
+              }
+            });
+          }
+
+        });
+        /* istanbul ignore next */
+
+        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
+          sub.unsubscribe();
+          return;
+        }
+        /* istanbul ignore next */
+
+
+        if (clientSubscriptions.has(id)) {
+          // duplicate request ids for client
+          stopSubscription(sub, {
+            id,
+            jsonrpc
+          });
+          throw new TRPCError({
+            message: `Duplicate id ${id}`,
+            code: 'BAD_REQUEST'
+          });
+        }
+
+        clientSubscriptions.set(id, sub);
+        respond({
+          id,
+          jsonrpc,
+          result: {
+            type: 'started'
+          }
+        });
+      } catch (cause)
+      /* istanbul ignore next */
+      {
+        var _opts$onError2;
+
+        // procedure threw an error
+        const error = getErrorFromUnknown(cause);
+        (_opts$onError2 = opts.onError) === null || _opts$onError2 === void 0 ? void 0 : _opts$onError2.call(opts, {
+          error,
+          path,
+          type,
+          ctx,
+          req,
+          input
+        });
+        respond({
+          id,
+          jsonrpc,
+          error: router.getErrorShape({
+            error,
+            type,
+            path,
+            input,
+            ctx
+          })
+        });
+      }
+    }
+
+    client.on('message', async message => {
+      try {
+        const msgJSON = JSON.parse(message.toString());
+        const msgs = Array.isArray(msgJSON) ? msgJSON : [msgJSON];
+        const promises = msgs.map(raw => parseMessage(raw, transformer)).map(handleRequest);
+        await Promise.all(promises);
+      } catch (cause) {
+        const error = new TRPCError({
+          code: 'PARSE_ERROR',
+          cause: getCauseFromUnknown(cause)
+        });
+        respond({
+          id: null,
+          error: router.getErrorShape({
+            error,
+            type: 'unknown',
+            path: undefined,
+            input: undefined,
+            ctx: undefined
+          })
+        });
+      }
+    });
+    client.once('close', () => {
+      for (const sub of clientSubscriptions.values()) {
+        sub.unsubscribe();
+      }
+
+      clientSubscriptions.clear();
+    });
+
+    async function createContextAsync() {
+      try {
+        ctx = await ctxPromise;
+      } catch (cause) {
+        var _opts$onError3, _global$setImmediate;
+
+        const error = getErrorFromUnknown(cause);
+        (_opts$onError3 = opts.onError) === null || _opts$onError3 === void 0 ? void 0 : _opts$onError3.call(opts, {
+          error,
+          path: undefined,
+          type: 'unknown',
+          ctx,
+          req,
+          input: undefined
+        });
+        respond({
+          id: null,
+          error: router.getErrorShape({
+            error,
+            type: 'unknown',
+            path: undefined,
+            input: undefined,
+            ctx
+          })
+        }); // close in next tick
+
+        ((_global$setImmediate = global.setImmediate) !== null && _global$setImmediate !== void 0 ? _global$setImmediate : global.setTimeout)(() => {
+          client.close();
+        });
+      }
+    }
+
+    await createContextAsync();
+  });
+  return {
+    broadcastReconnectNotification: () => {
+      const response = {
+        id: null,
+        method: 'reconnect'
+      };
+      const data = JSON.stringify(response);
+
+      for (const client of wss.clients) {
+        if (client.readyState === 1
+        /* ws.OPEN */
+        ) {
+          client.send(data);
+        }
+      }
+    }
+  };
+}
+
+export { applyWSSHandler };

package/dist/adapters/ws.ts.js

@@ -0,0 +1 @@
+

package/dist/{declarations/src/assertNotBrowser.d.ts → assertNotBrowser.d.ts}

@@ -1,2 +1,2 @@
-export declare function assertNotBrowser(): void;
+export declare function assertNotBrowser(): void;
 //# sourceMappingURL=assertNotBrowser.d.ts.map

package/dist/assertNotBrowser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertNotBrowser.d.ts","sourceRoot":"","sources":["../src/assertNotBrowser.ts"],"names":[],"mappings":"AAEA,wBAAgB,gBAAgB,SAS/B"}

package/dist/{codes-e0df67c4.cjs.prod.js → envelopes-1deb2fa7.mjs}

@@ -1,5 +1,3 @@
-'use strict';
-
 function invert(obj) {
   const newObj = Object.create(null);
 
@@ -46,6 +44,8 @@ const TRPC_ERROR_CODES_BY_KEY = {
   // 405
   TIMEOUT: -32008,
   // 408
+  CONFLICT: -32009,
+  // 409
   PRECONDITION_FAILED: -32012,
   // 412
   PAYLOAD_TOO_LARGE: -32013,
@@ -55,6 +55,20 @@ const TRPC_ERROR_CODES_BY_KEY = {
 };
 const TRPC_ERROR_CODES_BY_NUMBER = /*#__PURE__*/invert(TRPC_ERROR_CODES_BY_KEY);
 
-exports.TRPC_ERROR_CODES_BY_KEY = TRPC_ERROR_CODES_BY_KEY;
-exports.TRPC_ERROR_CODES_BY_NUMBER = TRPC_ERROR_CODES_BY_NUMBER;
-exports.invert = invert;
+/* eslint-disable @typescript-eslint/no-namespace */
+
+/**
+ * Error response
+ */
+
+/**
+ * JSON-RPC 2.0 Specification
+ */
+let JSONRPC2;
+/**
+ * TRPC HTTP Envelopes
+ */
+
+(function (_JSONRPC) {})(JSONRPC2 || (JSONRPC2 = {}));
+
+export { JSONRPC2 as J, TRPC_ERROR_CODES_BY_KEY as T, TRPC_ERROR_CODES_BY_NUMBER as a, invert as i };

package/dist/{codes-33cef953.cjs.dev.js → envelopes-a953b930.js}

@@ -46,6 +46,8 @@ const TRPC_ERROR_CODES_BY_KEY = {
   // 405
   TIMEOUT: -32008,
   // 408
+  CONFLICT: -32009,
+  // 409
   PRECONDITION_FAILED: -32012,
   // 412
   PAYLOAD_TOO_LARGE: -32013,
@@ -55,6 +57,22 @@ const TRPC_ERROR_CODES_BY_KEY = {
 };
 const TRPC_ERROR_CODES_BY_NUMBER = /*#__PURE__*/invert(TRPC_ERROR_CODES_BY_KEY);
 
+/* eslint-disable @typescript-eslint/no-namespace */
+
+/**
+ * Error response
+ */
+
+/**
+ * JSON-RPC 2.0 Specification
+ */
+exports.JSONRPC2 = void 0;
+/**
+ * TRPC HTTP Envelopes
+ */
+
+(function (_JSONRPC) {})(exports.JSONRPC2 || (exports.JSONRPC2 = {}));
+
 exports.TRPC_ERROR_CODES_BY_KEY = TRPC_ERROR_CODES_BY_KEY;
 exports.TRPC_ERROR_CODES_BY_NUMBER = TRPC_ERROR_CODES_BY_NUMBER;
 exports.invert = invert;

package/dist/{declarations/src/http → http}/ResponseMeta.d.ts

@@ -1,5 +1,5 @@
-export interface ResponseMeta {
-    status?: number;
-    headers?: Record<string, string>;
-}
+export interface ResponseMeta {
+    status?: number;
+    headers?: Record<string, string>;
+}
 //# sourceMappingURL=ResponseMeta.d.ts.map

package/dist/http/ResponseMeta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResponseMeta.d.ts","sourceRoot":"","sources":["../../src/http/ResponseMeta.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC"}

package/dist/{declarations/src/http → http}/index.d.ts

@@ -1,3 +1,3 @@
-export * from './resolveHTTPResponse';
-export * from './ResponseMeta';
+export * from './resolveHTTPResponse';
+export * from './ResponseMeta';
 //# sourceMappingURL=index.d.ts.map

package/dist/http/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/http/index.ts"],"names":[],"mappings":"AAEA,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC"}

package/dist/{declarations/src/http → http}/internals/getHTTPStatusCode.d.ts

@@ -1,21 +1,22 @@
-import { TRPCResponse, TRPC_ERROR_CODES_BY_KEY } from '../../rpc';
-import { TRPCError } from '../../TRPCError';
-export declare const TRPC_ERROR_CODES_BY_NUMBER: {
-    [-32700]: "PARSE_ERROR";
-    [-32600]: "BAD_REQUEST";
-    [-32603]: "INTERNAL_SERVER_ERROR";
-    [-32001]: "UNAUTHORIZED";
-    [-32003]: "FORBIDDEN";
-    [-32004]: "NOT_FOUND";
-    [-32005]: "METHOD_NOT_SUPPORTED";
-    [-32008]: "TIMEOUT";
-    [-32012]: "PRECONDITION_FAILED";
-    [-32013]: "PAYLOAD_TOO_LARGE";
-    [-32099]: "CLIENT_CLOSED_REQUEST";
-};
-declare type ValueOf<T> = T[keyof T];
-export declare type TRPC_ERROR_CODE_NUMBER = ValueOf<typeof TRPC_ERROR_CODES_BY_KEY>;
-export declare function getHTTPStatusCode(json: TRPCResponse | TRPCResponse[]): any;
-export declare function getHTTPStatusCodeFromError(error: TRPCError): number;
-export {};
+import { TRPCError } from '../../TRPCError';
+import { TRPCResponse, TRPC_ERROR_CODES_BY_KEY } from '../../rpc';
+export declare const TRPC_ERROR_CODES_BY_NUMBER: {
+    [-32700]: "PARSE_ERROR";
+    [-32600]: "BAD_REQUEST";
+    [-32603]: "INTERNAL_SERVER_ERROR";
+    [-32001]: "UNAUTHORIZED";
+    [-32003]: "FORBIDDEN";
+    [-32004]: "NOT_FOUND";
+    [-32005]: "METHOD_NOT_SUPPORTED";
+    [-32008]: "TIMEOUT";
+    [-32009]: "CONFLICT";
+    [-32012]: "PRECONDITION_FAILED";
+    [-32013]: "PAYLOAD_TOO_LARGE";
+    [-32099]: "CLIENT_CLOSED_REQUEST";
+};
+declare type ValueOf<T> = T[keyof T];
+export declare type TRPC_ERROR_CODE_NUMBER = ValueOf<typeof TRPC_ERROR_CODES_BY_KEY>;
+export declare function getHTTPStatusCode(json: TRPCResponse | TRPCResponse[]): any;
+export declare function getHTTPStatusCodeFromError(error: TRPCError): number;
+export {};
 //# sourceMappingURL=getHTTPStatusCode.d.ts.map

package/dist/http/internals/getHTTPStatusCode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getHTTPStatusCode.d.ts","sourceRoot":"","sources":["../../../src/http/internals/getHTTPStatusCode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,OAAO,EAAE,YAAY,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AAElE,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;CAAkC,CAAC;AAC1E,aAAK,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AAE7B,oBAAY,sBAAsB,GAAG,OAAO,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAuB7E,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,YAAY,GAAG,YAAY,EAAE,OAuBpE;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,SAAS,UAI1D"}

package/dist/{declarations/src/http → http}/internals/types.d.ts

@@ -1,40 +1,41 @@
-/// <reference types="node" />
-import { AnyRouter, Dict, inferRouterContext, inferRouterError, ProcedureType, ResponseMeta, TRPCError } from '@trpc/server';
-import { URLSearchParams } from 'url';
-import { BaseHandlerOptions } from '../../internals/BaseHandlerOptions';
-import { TRPCResponse } from '../../rpc';
-export declare type HTTPHeaders = Dict<string | string[]>;
-export interface HTTPResponse {
-    status: number;
-    headers?: HTTPHeaders;
-    body?: string;
-}
-export interface HTTPRequest {
-    method: string;
-    query: URLSearchParams;
-    headers: HTTPHeaders;
-    body: unknown;
-}
-declare 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[];
-}) => ResponseMeta;
-/**
- * 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/caching
-     */
-    responseMeta?: ResponseMetaFn<TRouter>;
-}
-export {};
+import { TRPCError } from '../../TRPCError';
+import { BaseHandlerOptions } from '../../internals/BaseHandlerOptions';
+import { AnyRouter, ProcedureType, inferRouterContext, inferRouterError } from '../../router';
+import { TRPCResponse } from '../../rpc';
+import { Dict } from '../../types';
+import { ResponseMeta } from '../ResponseMeta';
+export declare type HTTPHeaders = Dict<string | string[]>;
+export interface HTTPResponse {
+    status: number;
+    headers?: HTTPHeaders;
+    body?: string;
+}
+export interface HTTPRequest {
+    method: string;
+    query: URLSearchParams;
+    headers: HTTPHeaders;
+    body: unknown;
+}
+declare 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[];
+}) => ResponseMeta;
+/**
+ * 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/caching
+     */
+    responseMeta?: ResponseMetaFn<TRouter>;
+}
+export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/http/internals/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/http/internals/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AACxE,OAAO,EACL,SAAS,EACT,aAAa,EACb,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACnC,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C,oBAAY,WAAW,GAAG,IAAI,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;AAElD,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,eAAe,CAAC;IACvB,OAAO,EAAE,WAAW,CAAC;IACrB,IAAI,EAAE,OAAO,CAAC;CACf;AAED,aAAK,cAAc,CAAC,OAAO,SAAS,SAAS,IAAI,CAAC,IAAI,EAAE;IACtD,IAAI,EAAE,YAAY,CAAC,OAAO,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC;IACzD,GAAG,CAAC,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC;IAClC;;QAEI;IACJ,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,aAAa,GAAG,SAAS,CAAC;IAChC,MAAM,EAAE,SAAS,EAAE,CAAC;CACrB,KAAK,YAAY,CAAC;AAEnB;;GAEG;AACH,MAAM,WAAW,sBAAsB,CAAC,OAAO,SAAS,SAAS,EAAE,QAAQ,CACzE,SAAQ,kBAAkB,CAAC,OAAO,EAAE,QAAQ,CAAC;IAC7C;;;;OAIG;IACH,YAAY,CAAC,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC;CACxC"}

package/dist/{declarations/src/http → http}/resolveHTTPResponse.d.ts

@@ -1,13 +1,13 @@
-import { Maybe } from '@trpc/server';
-import { AnyRouter, inferRouterContext } from '../router';
-import { TRPCError } from '../TRPCError';
-import { HTTPRequest, HTTPResponse, HTTPBaseHandlerOptions } from './internals/types';
-interface ResolveHTTPRequestOptions<TRouter extends AnyRouter, TRequest extends HTTPRequest> extends HTTPBaseHandlerOptions<TRouter, TRequest> {
-    createContext: () => Promise<inferRouterContext<TRouter>>;
-    req: TRequest;
-    path: string;
-    error?: Maybe<TRPCError>;
-}
-export declare function resolveHTTPResponse<TRouter extends AnyRouter, TRequest extends HTTPRequest>(opts: ResolveHTTPRequestOptions<TRouter, TRequest>): Promise<HTTPResponse>;
-export {};
+import { TRPCError } from '../TRPCError';
+import { AnyRouter, inferRouterContext } from '../router';
+import { Maybe } from '../types';
+import { HTTPBaseHandlerOptions, HTTPRequest, HTTPResponse } from './internals/types';
+interface ResolveHTTPRequestOptions<TRouter extends AnyRouter, TRequest extends HTTPRequest> extends HTTPBaseHandlerOptions<TRouter, TRequest> {
+    createContext: () => Promise<inferRouterContext<TRouter>>;
+    req: TRequest;
+    path: string;
+    error?: Maybe<TRPCError>;
+}
+export declare function resolveHTTPResponse<TRouter extends AnyRouter, TRequest extends HTTPRequest>(opts: ResolveHTTPRequestOptions<TRouter, TRequest>): Promise<HTTPResponse>;
+export {};
 //# sourceMappingURL=resolveHTTPResponse.d.ts.map

package/dist/http/resolveHTTPResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveHTTPResponse.d.ts","sourceRoot":"","sources":["../../src/http/resolveHTTPResponse.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAIzC,OAAO,EACL,SAAS,EAET,kBAAkB,EAEnB,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEjC,OAAO,EACL,sBAAsB,EAEtB,WAAW,EACX,YAAY,EACb,MAAM,mBAAmB,CAAC;AA4B3B,UAAU,yBAAyB,CACjC,OAAO,SAAS,SAAS,EACzB,QAAQ,SAAS,WAAW,CAC5B,SAAQ,sBAAsB,CAAC,OAAO,EAAE,QAAQ,CAAC;IACjD,aAAa,EAAE,MAAM,OAAO,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAAC;IAC1D,GAAG,EAAE,QAAQ,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;CAC1B;AAED,wBAAsB,mBAAmB,CACvC,OAAO,SAAS,SAAS,EACzB,QAAQ,SAAS,WAAW,EAC5B,IAAI,EAAE,yBAAyB,CAAC,OAAO,EAAE,QAAQ,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CA+L3E"}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './assertNotBrowser';
+export * from './http';
+export * from './transformer';
+export * from './TRPCError';
+export * from './types';
+export * from './router';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,QAAQ,CAAC;AACvB,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC"}