@trpc/server 10.43.0 → 11.0.0-next.91

package/dist/unstableInternalsExport.d.ts

@@ -0,0 +1,11 @@
+/**
+ * These types have to be exported so users can generate their own types definitions files
+ *
+ * @remark Do not `import` anything here as it will be unreliable between minor versions of tRPC
+ */
+export { mergeRouters } from './core/internals/mergeRouters';
+export * from './core/internals/procedureBuilder';
+export * from './core/internals/utils';
+export type { MiddlewareFunction, MiddlewareBuilder } from './core/middleware';
+export * from './core/procedure';
+//# sourceMappingURL=unstableInternalsExport.d.ts.map

package/dist/unstableInternalsExport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unstableInternalsExport.d.ts","sourceRoot":"","sources":["../src/unstableInternalsExport.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAC7D,cAAc,mCAAmC,CAAC;AAClD,cAAc,wBAAwB,CAAC;AACvC,YAAY,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAC/E,cAAc,kBAAkB,CAAC"}

package/dist/unstableInternalsExport.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var unstableInternalsExport = require('./unstableInternalsExport-bf8496ea.js');
+require('./router-3c22fe56.js');
+require('./TRPCError-ae7b67e8.js');
+require('./index-784ff647.js');
+require('./codes-87f6824b.js');
+
+
+
+exports.createBuilder = unstableInternalsExport.createBuilder;
+exports.mergeRouters = unstableInternalsExport.mergeRouters;
+exports.middlewareMarker = unstableInternalsExport.middlewareMarker;
+exports.unsetMarker = unstableInternalsExport.unsetMarker;

package/dist/unstableInternalsExport.mjs

@@ -0,0 +1,5 @@
+export { c as createBuilder, m as mergeRouters, f as middlewareMarker, g as unsetMarker } from './unstableInternalsExport-10cc2bae.mjs';
+import './router-5274e533.mjs';
+import './TRPCError-816ff32e.mjs';
+import './index-f91d720c.mjs';
+import './codes-c924c3db.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/server",
-  "version": "10.43.0",
+  "version": "11.0.0-next.91+ca021e61",
   "description": "The tRPC server library",
   "author": "KATT",
   "license": "MIT",
@@ -118,6 +118,11 @@
       "import": "./dist/shared/index.mjs",
       "require": "./dist/shared/index.js",
       "default": "./dist/shared/index.js"
+    },
+    "./unstableInternalsExport": {
+      "import": "./dist/unstableInternalsExport.mjs",
+      "require": "./dist/unstableInternalsExport.js",
+      "default": "./dist/unstableInternalsExport.js"
     }
   },
   "files": [
@@ -131,6 +136,7 @@
     "observable",
     "subscription",
     "shared",
+    "unstableInternalsExport",
     "!**/*.test.*"
   ],
   "publishConfig": {
@@ -138,7 +144,7 @@
   },
   "devDependencies": {
     "@fastify/websocket": "^7.1.2",
-    "@tanstack/react-query": "^4.18.0",
+    "@tanstack/react-query": "^5.0.0",
     "@types/aws-lambda": "^8.10.97",
     "@types/express": "^4.17.17",
     "@types/hash-sum": "^1.0.0",
@@ -173,5 +179,5 @@
   "funding": [
     "https://trpc.io/sponsor"
   ],
-  "gitHead": "0d505fd7415f537bd3e263971686b13a78584167"
+  "gitHead": "ca021e61ba8e6eb6e1715f124489cda75a00b5aa"
 }

package/src/adapters/aws-lambda/index.ts

@@ -6,9 +6,13 @@ import type {
   Context as APIGWContext,
 } from 'aws-lambda';
 import { TRPCError } from '../..';
-import { AnyRouter, inferRouterContext } from '../../core';
-import { HTTPRequest, resolveHTTPResponse } from '../../http';
-import { HTTPResponse } from '../../http/internals/types';
+import { AnyRouter } from '../../core';
+import {
+  HTTPRequest,
+  ResolveHTTPRequestOptionsContextFn,
+  resolveHTTPResponse,
+} from '../../http';
+import type { HTTPResponse } from '../../http/internals/types';
 import {
   APIGatewayEvent,
   APIGatewayResult,
@@ -92,10 +96,10 @@ export function awsLambdaRequestHandler<
   return async (event, context) => {
     const req = lambdaEventToHTTPRequest(event);
     const path = getPath(event);
-    const createContext = async function _createContext(): Promise<
-      inferRouterContext<TRouter>
-    > {
-      return await opts.createContext?.({ event, context });
+    const createContext: ResolveHTTPRequestOptionsContextFn<TRouter> = async (
+      innerOpts,
+    ) => {
+      return await opts.createContext?.({ event, context, ...innerOpts });
     };
 
     const response = await resolveHTTPResponse({

package/src/adapters/aws-lambda/utils.ts

@@ -7,6 +7,7 @@ import type {
 } from 'aws-lambda';
 import type { AnyRouter, inferRouterContext } from '../../core';
 import { TRPCError } from '../../error/TRPCError';
+import { TRPCRequestInfo } from '../../http';
 import type { HTTPHeaders, ResponseMetaFn } from '../../http/internals/types';
 import { OnErrorFunction } from '../../internals/types';
 
@@ -18,6 +19,7 @@ export type APIGatewayResult =
 export type CreateAWSLambdaContextOptions<TEvent extends APIGatewayEvent> = {
   event: TEvent;
   context: APIGWContext;
+  info: TRPCRequestInfo;
 };
 export type AWSLambdaCreateContextFn<
   TRouter extends AnyRouter,
@@ -25,6 +27,7 @@ export type AWSLambdaCreateContextFn<
 > = ({
   event,
   context,
+  info,
 }: CreateAWSLambdaContextOptions<TEvent>) =>
   | inferRouterContext<TRouter>
   | Promise<inferRouterContext<TRouter>>;

package/src/adapters/fastify/fastifyRequestHandler.ts

@@ -1,10 +1,11 @@
 import { Readable } from 'node:stream';
 import { FastifyReply, FastifyRequest } from 'fastify';
-import { AnyRouter, inferRouterContext } from '../../core';
+import { AnyRouter } from '../../core';
 import {
   getBatchStreamFormatter,
   HTTPBaseHandlerOptions,
   HTTPRequest,
+  ResolveHTTPRequestOptionsContextFn,
 } from '../../http';
 import { HTTPResponse, ResponseChunk } from '../../http/internals/types';
 import { resolveHTTPResponse } from '../../http/resolveHTTPResponse';
@@ -32,10 +33,13 @@ export async function fastifyRequestHandler<
   TRequest extends FastifyRequest,
   TResponse extends FastifyReply,
 >(opts: FastifyRequestHandlerOptions<TRouter, TRequest, TResponse>) {
-  const createContext = async function _createContext(): Promise<
-    inferRouterContext<TRouter>
-  > {
-    return opts.createContext?.(opts);
+  const createContext: ResolveHTTPRequestOptionsContextFn<TRouter> = async (
+    innerOpts,
+  ) => {
+    return await opts.createContext?.({
+      ...opts,
+      ...innerOpts,
+    });
   };
 
   const query = opts.req.query

package/src/adapters/fetch/fetchRequestHandler.ts

@@ -1,5 +1,9 @@
 import { AnyRouter } from '../../core';
-import { getBatchStreamFormatter, HTTPRequest } from '../../http';
+import {
+  getBatchStreamFormatter,
+  HTTPRequest,
+  ResolveHTTPRequestOptionsContextFn,
+} from '../../http';
 import { HTTPResponse, ResponseChunk } from '../../http/internals/types';
 import { resolveHTTPResponse } from '../../http/resolveHTTPResponse';
 import { FetchHandlerOptions } from './types';
@@ -15,8 +19,10 @@ export async function fetchRequestHandler<TRouter extends AnyRouter>(
 ): Promise<Response> {
   const resHeaders = new Headers();
 
-  const createContext = async () => {
-    return opts.createContext?.({ req: opts.req, resHeaders });
+  const createContext: ResolveHTTPRequestOptionsContextFn<TRouter> = async (
+    innerOpts,
+  ) => {
+    return opts.createContext?.({ req: opts.req, resHeaders, ...innerOpts });
   };
 
   const url = new URL(opts.req.url);

package/src/adapters/fetch/types.ts

@@ -1,9 +1,10 @@
 import { AnyRouter, inferRouterContext } from '../../core';
-import { HTTPBaseHandlerOptions } from '../../http';
+import { HTTPBaseHandlerOptions, TRPCRequestInfo } from '../../http';
 
 export type FetchCreateContextFnOptions = {
   req: Request;
   resHeaders: Headers;
+  info: TRPCRequestInfo;
 };
 
 export type FetchCreateContextFn<TRouter extends AnyRouter> = (

package/src/adapters/node-http/nodeHTTPRequestHandler.ts

@@ -1,7 +1,10 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { AnyRouter } from '../../core';
-import { inferRouterContext } from '../../core/types';
-import { getBatchStreamFormatter, HTTPRequest } from '../../http';
+import {
+  getBatchStreamFormatter,
+  HTTPRequest,
+  ResolveHTTPRequestOptionsContextFn,
+} from '../../http';
 import { HTTPResponse, ResponseChunk } from '../../http/internals/types';
 import { resolveHTTPResponse } from '../../http/resolveHTTPResponse';
 import { nodeHTTPJSONContentTypeHandler } from './content-type/json';
@@ -24,8 +27,16 @@ export async function nodeHTTPRequestHandler<
   return handleViaMiddleware(opts.req, opts.res, async (err) => {
     if (err) throw err;
 
-    const createContext = async (): Promise<inferRouterContext<TRouter>> => {
-      return await opts.createContext?.(opts);
+    //
+    // Build tRPC dependencies
+
+    const createContext: ResolveHTTPRequestOptionsContextFn<TRouter> = async (
+      innerOpts,
+    ) => {
+      return await opts.createContext?.({
+        ...opts,
+        ...innerOpts,
+      });
     };
 
     const query = opts.req.query

package/src/adapters/node-http/types.ts

@@ -1,6 +1,6 @@
 import { IncomingMessage, ServerResponse } from 'http';
 import { AnyRouter, inferRouterContext } from '../../core';
-import { HTTPBaseHandlerOptions } from '../../http';
+import { HTTPBaseHandlerOptions, TRPCRequestInfo } from '../../http';
 import { MaybePromise } from '../../types';
 import { NodeHTTPContentTypeHandler } from './internals/contentType';
 
@@ -93,6 +93,7 @@ export type NodeHTTPRequestHandlerOptions<
 export type NodeHTTPCreateContextFnOptions<TRequest, TResponse> = {
   req: TRequest;
   res: TResponse;
+  info: TRPCRequestInfo;
 };
 export type NodeHTTPCreateContextFn<
   TRouter extends AnyRouter,

package/src/adapters/standalone.ts

@@ -19,14 +19,9 @@ export function createHTTPHandler<TRouter extends AnyRouter>(
   opts: CreateHTTPHandlerOptions<TRouter>,
 ) {
   return async (req: http.IncomingMessage, res: http.ServerResponse) => {
-    // if no hostname, set a dummy one
-    const href = req.url!.startsWith('/')
-      ? `http://127.0.0.1${req.url}`
-      : req.url!;
-
-    // get procedure path and remove the leading slash
-    // /procedure -> procedure
-    const path = new URL(href).pathname.slice(1);
+    // Get procedure path and remove the leading slash, `/procedure -> procedure`
+    // Use dummy hostname if one is not provided.
+    const path = new URL(req.url!, 'http://127.0.0.1').pathname.slice(1);
 
     await nodeHTTPRequestHandler({
       ...opts,
@@ -41,18 +36,5 @@ export function createHTTPServer<TRouter extends AnyRouter>(
   opts: CreateHTTPHandlerOptions<TRouter>,
 ) {
   const handler = createHTTPHandler(opts);
-  const server = http.createServer((req, res) => handler(req, res));
-
-  return {
-    server,
-    listen: (port?: number, hostname?: string) => {
-      server.listen(port, hostname);
-      const actualPort =
-        port === 0 ? ((server.address() as any).port as number) : port;
-
-      return {
-        port: actualPort,
-      };
-    },
-  };
+  return http.createServer((req, res) => handler(req, res));
 }

package/src/adapters/ws.ts

@@ -1,22 +1,111 @@
 import { IncomingMessage } from 'http';
 import ws from 'ws';
-import { AnyRouter, callProcedure, inferRouterContext } from '../core';
+import {
+  AnyRouter,
+  callProcedure,
+  inferRouterContext,
+  ProcedureType,
+} from '../core';
 import { getTRPCErrorFromUnknown, TRPCError } from '../error/TRPCError';
 import { BaseHandlerOptions } from '../internals/types';
 import { isObservable, Unsubscribable } from '../observable';
 import {
   JSONRPC2,
-  parseTRPCMessage,
   TRPCClientOutgoingMessage,
   TRPCReconnectNotification,
   TRPCResponseMessage,
 } from '../rpc';
 import { getErrorShape } from '../shared/getErrorShape';
 import { transformTRPCResponse } from '../shared/transformTRPCResponse';
-import {
-  NodeHTTPCreateContextFnOptions,
-  NodeHTTPCreateContextOption,
-} from './node-http';
+import { CombinedDataTransformer } from '../transformer';
+import { MaybePromise } from '../types';
+import { NodeHTTPCreateContextFnOptions } from './node-http';
+
+/* 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 -- @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 -- @preserve */
+function assertIsRequestId(
+  obj: unknown,
+): asserts obj is number | string | null {
+  if (
+    obj !== null &&
+    typeof obj === 'number' &&
+    isNaN(obj) &&
+    typeof obj !== 'string'
+  ) {
+    throw new Error('Invalid request id');
+  }
+}
+/* istanbul ignore next -- @preserve */
+function assertIsString(obj: unknown): asserts obj is string {
+  if (typeof obj !== 'string') {
+    throw new Error('Invalid string');
+  }
+}
+/* istanbul ignore next -- @preserve */
+function assertIsJSONRPC2OrUndefined(
+  obj: unknown,
+): asserts obj is '2.0' | undefined {
+  if (typeof obj !== 'undefined' && obj !== '2.0') {
+    throw new Error('Must be JSONRPC 2.0');
+  }
+}
+export function parseMessage(
+  obj: unknown,
+  transformer: CombinedDataTransformer,
+): TRPCClientOutgoingMessage {
+  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,
+    },
+  };
+}
+
+/**
+ * @public
+ */
+export type CreateWSSContextFnOptions = Omit<
+  NodeHTTPCreateContextFnOptions<IncomingMessage, ws>,
+  'info'
+>;
+
+/**
+ * @public
+ */
+export type CreateWSSContextFn<TRouter extends AnyRouter> = (
+  opts: CreateWSSContextFnOptions,
+) => MaybePromise<inferRouterContext<TRouter>>;
 
 /**
  * Web socket server handler
@@ -25,16 +114,23 @@ export type WSSHandlerOptions<TRouter extends AnyRouter> = BaseHandlerOptions<
   TRouter,
   IncomingMessage
 > &
-  NodeHTTPCreateContextOption<TRouter, IncomingMessage, ws> & {
+  (object extends inferRouterContext<TRouter>
+    ? {
+        /**
+         * @link https://trpc.io/docs/context
+         **/
+        createContext?: CreateWSSContextFn<TRouter>;
+      }
+    : {
+        /**
+         * @link https://trpc.io/docs/context
+         **/
+        createContext: CreateWSSContextFn<TRouter>;
+      }) & {
     wss: ws.Server;
     process?: NodeJS.Process;
   };
 
-export type CreateWSSContextFnOptions = NodeHTTPCreateContextFnOptions<
-  IncomingMessage,
-  ws
->;
-
 export function applyWSSHandler<TRouter extends AnyRouter>(
   opts: WSSHandlerOptions<TRouter>,
 ) {
@@ -95,7 +191,7 @@ export function applyWSSHandler<TRouter extends AnyRouter>(
         const result = await callProcedure({
           procedures: router._def.procedures,
           path,
-          rawInput: input,
+          getRawInput: async () => input,
           ctx,
           type,
         });
@@ -208,7 +304,7 @@ export function applyWSSHandler<TRouter extends AnyRouter>(
         const msgJSON: unknown = JSON.parse(message.toString());
         const msgs: unknown[] = Array.isArray(msgJSON) ? msgJSON : [msgJSON];
         const promises = msgs
-          .map((raw) => parseTRPCMessage(raw, transformer))
+          .map((raw) => parseMessage(raw, transformer))
           .map(handleRequest);
         await Promise.all(promises);
       } catch (cause) {

package/src/core/index.ts

@@ -12,6 +12,7 @@ export type {
   AnyQueryProcedure,
   AnyMutationProcedure,
   AnySubscriptionProcedure,
+  AnyProcedureParams,
   ProcedureParams,
   ProcedureArgs,
   ProcedureOptions,

package/src/core/internals/builderTypes.ts

@@ -0,0 +1,11 @@
+import { AnyRootConfig } from './config';
+
+export type AnyProcedureBuilderParams = {
+  _config: AnyRootConfig;
+  _meta: unknown;
+  _ctx_out: unknown;
+  _input_in: unknown;
+  _input_out: unknown;
+  _output_in: unknown;
+  _output_out: unknown;
+};

package/src/core/internals/getParseFn.ts

@@ -41,16 +41,3 @@ export function getParseFn<TType>(procedureParser: Parser): ParseFn<TType> {
 
   throw new Error('Could not find a validator fn');
 }
-
-/**
- * @deprecated only for backwards compat
- * @internal
- */
-export function getParseFnOrPassThrough<TType>(
-  procedureParser: Parser | undefined,
-): ParseFn<TType> {
-  if (!procedureParser) {
-    return (v) => v as TType;
-  }
-  return getParseFn(procedureParser);
-}

package/src/core/internals/mergeRouters.ts

@@ -30,10 +30,6 @@ export type MergeRouters<
         router: true;
         procedures: Head['_def']['procedures'] & TRouterDef['procedures'];
         record: Head['_def']['record'] & TRouterDef['record'];
-        queries: Head['_def']['queries'] & TRouterDef['queries'];
-        mutations: Head['_def']['mutations'] & TRouterDef['mutations'];
-        subscriptions: Head['_def']['subscriptions'] &
-          TRouterDef['subscriptions'];
       }
     >
   : Router<TRouterDef> & TRouterDef['record'];