@trpc/server 10.0.0-alpha.19 → 10.0.0-alpha.21

package/src/adapters/fastify/fastifyTRPCPlugin.ts

@@ -1,10 +1,10 @@
 /// <reference types="fastify-websocket" />
 import { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify';
-import { fastifyRequestHandler } from './fastifyRequestHandler';
-import { NodeHTTPCreateContextFnOptions } from '../node-http';
-import { applyWSSHandler, WSSHandlerOptions } from '../ws';
 import { FastifyHandlerOptions } from '.';
 import { AnyRouter } from '../..';
+import { NodeHTTPCreateContextFnOptions } from '../node-http';
+import { WSSHandlerOptions, applyWSSHandler } from '../ws';
+import { fastifyRequestHandler } from './fastifyRequestHandler';
 
 export interface FastifyTRPCPluginOptions<TRouter extends AnyRouter> {
   prefix?: string;
@@ -30,9 +30,17 @@ export function fastifyTRPCPlugin<TRouter extends AnyRouter>(
     },
   );
 
-  fastify.all(`${opts.prefix ?? ''}/:path`, (req, res) => {
+  let prefix = opts.prefix ?? '';
+
+  // https://github.com/fastify/fastify-plugin/blob/fe079bef6557a83794bf437e14b9b9edb8a74104/plugin.js#L11
+  // @ts-expect-error property 'default' does not exists on type ...
+  if (typeof fastifyTRPCPlugin.default !== 'function') {
+    prefix = ''; // handled by fastify internally
+  }
+
+  fastify.all(`${prefix}/:path`, async (req, res) => {
     const path = (req.params as any).path;
-    fastifyRequestHandler({ ...opts.trpcOptions, req, res, path });
+    await fastifyRequestHandler({ ...opts.trpcOptions, req, res, path });
   });
 
   if (opts.useWSS) {
@@ -41,7 +49,7 @@ export function fastifyTRPCPlugin<TRouter extends AnyRouter>(
       wss: fastify.websocketServer,
     });
     // eslint-disable-next-line @typescript-eslint/no-empty-function
-    fastify.get(opts.prefix ?? '/', { websocket: true }, () => {});
+    fastify.get(prefix ?? '/', { websocket: true }, () => {});
   }
 
   done();

package/src/adapters/next.ts

@@ -1,9 +1,13 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-import type { NextApiHandler, NextApiRequest, NextApiResponse } from 'next';
+import type {
+  NextApiHandler,
+  NextApiRequest,
+  NextApiResponse,
+} from 'next/types';
+import { TRPCError } from '../TRPCError';
 import { AnyRouter } from '../router';
 import { TRPCErrorResponse } from '../rpc';
-import { TRPCError } from '../TRPCError';
 import { nodeHTTPRequestHandler } from './node-http';
 import {
   NodeHTTPCreateContextFnOptions,

package/src/adapters/node-http/internals/getPostBody.test.ts

@@ -1,5 +1,6 @@
-import { getPostBody } from './getPostBody';
 import { EventEmitter } from 'events';
+import { getPostBody } from './getPostBody';
+
 test('has body', async () => {
   const body = {};
   const resolvedBody = await getPostBody({ req: { body } } as any);

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

@@ -1,15 +1,14 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
-import { URLSearchParams } from 'url';
 import { assertNotBrowser } from '../../assertNotBrowser';
+import { HTTPRequest } from '../../http/internals/types';
+import { resolveHTTPResponse } from '../../http/resolveHTTPResponse';
+import { AnyRouter, inferRouterContext } from '../../router';
+import { getPostBody } from './internals/getPostBody';
 import {
+  NodeHTTPHandlerOptions,
   NodeHTTPRequest,
   NodeHTTPResponse,
-  NodeHTTPHandlerOptions,
 } from './types';
-import { AnyRouter, inferRouterContext } from '../../router';
-import { getPostBody } from './internals/getPostBody';
-import { HTTPRequest } from '../../http/internals/types';
-import { resolveHTTPResponse } from '../../http/resolveHTTPResponse';
 
 assertNotBrowser();
 

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

@@ -1,15 +1,15 @@
-import http from 'http';
+import { IncomingMessage, ServerResponse } from 'http';
 import qs from 'qs';
 import { inferRouterContext } from '../..';
 import { HTTPBaseHandlerOptions } from '../../http/internals/types';
 import { AnyRouter } from '../../router';
 
-export type NodeHTTPRequest = http.IncomingMessage & {
+export type NodeHTTPRequest = IncomingMessage & {
   method?: string;
   query?: qs.ParsedQs;
   body?: unknown;
 };
-export type NodeHTTPResponse = http.ServerResponse;
+export type NodeHTTPResponse = ServerResponse;
 
 export type NodeHTTPCreateContextOption<
   TRouter extends AnyRouter,

package/src/adapters/standalone.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
+
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import http from 'http';
-import url from 'url';
 import { AnyRouter } from '../router';
 import {
   NodeHTTPCreateContextFnOptions,
@@ -21,12 +21,20 @@ export function createHTTPHandler<TRouter extends AnyRouter>(
   opts: CreateHTTPHandlerOptions<TRouter>,
 ) {
   return async (req: http.IncomingMessage, res: http.ServerResponse) => {
-    const endpoint = url.parse(req.url!).pathname!.slice(1);
+    // 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);
+
     await nodeHTTPRequestHandler({
       ...opts,
       req,
       res,
-      path: endpoint,
+      path,
     });
   };
 }

package/src/adapters/ws.ts

@@ -1,10 +1,11 @@
-import http from 'http';
+import { IncomingMessage } from 'http';
 import ws from 'ws';
+import { TRPCError } from '../TRPCError';
 import { BaseHandlerOptions } from '../internals/BaseHandlerOptions';
 import { callProcedure } from '../internals/callProcedure';
-import { getErrorFromUnknown } from '../internals/errors';
+import { getCauseFromUnknown, getErrorFromUnknown } from '../internals/errors';
 import { transformTRPCResponse } from '../internals/transformTRPCResponse';
-import { AnyRouter, inferRouterContext, ProcedureType } from '../router';
+import { AnyRouter, ProcedureType, inferRouterContext } from '../router';
 import {
   TRPCErrorResponse,
   TRPCReconnectNotification,
@@ -13,7 +14,6 @@ import {
 } from '../rpc';
 import { Subscription } from '../subscription';
 import { CombinedDataTransformer } from '../transformer';
-import { TRPCError } from '../TRPCError';
 import { NodeHTTPCreateContextOption } from './node-http';
 
 /* istanbul ignore next */
@@ -84,11 +84,11 @@ function parseMessage(
  */
 export type WSSHandlerOptions<TRouter extends AnyRouter> = BaseHandlerOptions<
   TRouter,
-  http.IncomingMessage
+  IncomingMessage
 > & {
   wss: ws.Server;
   process?: NodeJS.Process;
-} & NodeHTTPCreateContextOption<TRouter, http.IncomingMessage, ws>;
+} & NodeHTTPCreateContextOption<TRouter, IncomingMessage, ws>;
 
 export function applyWSSHandler<TRouter extends AnyRouter>(
   opts: WSSHandlerOptions<TRouter>,
@@ -96,7 +96,7 @@ export function applyWSSHandler<TRouter extends AnyRouter>(
   const { wss, createContext, router } = opts;
 
   const { transformer } = router._def;
-  wss.on('connection', (client, req) => {
+  wss.on('connection', async (client, req) => {
     const clientSubscriptions = new Map<
       number | string,
       Subscription<TRouter>
@@ -232,7 +232,7 @@ export function applyWSSHandler<TRouter extends AnyRouter>(
       } catch (cause) {
         const error = new TRPCError({
           code: 'PARSE_ERROR',
-          cause,
+          cause: getCauseFromUnknown(cause),
         });
 
         respond({
@@ -285,7 +285,7 @@ export function applyWSSHandler<TRouter extends AnyRouter>(
         });
       }
     }
-    createContextAsync();
+    await createContextAsync();
   });
 
   return {

package/src/assertNotBrowser.ts

@@ -3,6 +3,7 @@
 export function assertNotBrowser() {
   if (
     typeof window !== 'undefined' &&
+    !('Deno' in window) &&
     process.env.NODE_ENV !== 'test' &&
     process.env.JEST_WORKER_ID === undefined
   ) {

package/src/http/internals/getHTTPStatusCode.ts

@@ -1,6 +1,6 @@
-import { TRPCResponse, TRPC_ERROR_CODES_BY_KEY } from '../../rpc';
 import { TRPCError } from '../../TRPCError';
 import { invert } from '../../internals/invert';
+import { TRPCResponse, TRPC_ERROR_CODES_BY_KEY } from '../../rpc';
 
 export const TRPC_ERROR_CODES_BY_NUMBER = invert(TRPC_ERROR_CODES_BY_KEY);
 type ValueOf<T> = T[keyof T];
@@ -17,6 +17,7 @@ const JSONRPC2_TO_HTTP_CODE: Record<
   UNAUTHORIZED: 401,
   FORBIDDEN: 403,
   TIMEOUT: 408,
+  CONFLICT: 409,
   CLIENT_CLOSED_REQUEST: 499,
   PRECONDITION_FAILED: 412,
   PAYLOAD_TOO_LARGE: 413,

package/src/http/internals/types.ts

@@ -1,15 +1,14 @@
+import { TRPCError } from '../../TRPCError';
+import { BaseHandlerOptions } from '../../internals/BaseHandlerOptions';
 import {
   AnyRouter,
-  Dict,
+  ProcedureType,
   inferRouterContext,
   inferRouterError,
-  ProcedureType,
-  ResponseMeta,
-  TRPCError,
-} from '@trpc/server';
-import { URLSearchParams } from 'url';
-import { BaseHandlerOptions } from '../../internals/BaseHandlerOptions';
+} from '../../router';
 import { TRPCResponse } from '../../rpc';
+import { Dict } from '../../types';
+import { ResponseMeta } from '../ResponseMeta';
 
 export type HTTPHeaders = Dict<string | string[]>;
 

package/src/http/resolveHTTPResponse.ts

@@ -1,22 +1,22 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
-import { Maybe } from '@trpc/server';
+import { TRPCError } from '../TRPCError';
 import { callProcedure } from '../internals/callProcedure';
-import { getErrorFromUnknown } from '../internals/errors';
+import { getCauseFromUnknown, getErrorFromUnknown } from '../internals/errors';
 import { transformTRPCResponse } from '../internals/transformTRPCResponse';
 import {
   AnyRouter,
+  ProcedureType,
   inferRouterContext,
   inferRouterError,
-  ProcedureType,
 } from '../router';
 import { TRPCErrorResponse, TRPCResponse, TRPCResultResponse } from '../rpc';
-import { TRPCError } from '../TRPCError';
+import { Maybe } from '../types';
 import { getHTTPStatusCode } from './internals/getHTTPStatusCode';
 import {
+  HTTPBaseHandlerOptions,
   HTTPHeaders,
   HTTPRequest,
   HTTPResponse,
-  HTTPBaseHandlerOptions,
 } from './internals/types';
 
 const HTTP_METHOD_PROCEDURE_TYPE_MAP: Record<
@@ -37,10 +37,10 @@ function getRawProcedureInputOrThrow(req: HTTPRequest) {
       return JSON.parse(raw!);
     }
     return typeof req.body === 'string' ? JSON.parse(req.body) : req.body;
-  } catch (cause) {
+  } catch (err) {
     throw new TRPCError({
       code: 'PARSE_ERROR',
-      cause,
+      cause: getCauseFromUnknown(err),
     });
   }
 }

package/src/internals/BaseHandlerOptions.ts

@@ -1,5 +1,5 @@
-import { OnErrorFunction } from './OnErrorFunction';
 import { AnyRouter } from '../router';
+import { OnErrorFunction } from './OnErrorFunction';
 
 /**
  * Base interface for any response handler

package/src/internals/OnErrorFunction.ts

@@ -1,5 +1,5 @@
-import { AnyRouter, inferRouterContext, ProcedureType } from '../router';
 import { TRPCError } from '../TRPCError';
+import { AnyRouter, ProcedureType, inferRouterContext } from '../router';
 
 export type OnErrorFunction<TRouter extends AnyRouter, TRequest> = (opts: {
   error: TRPCError;

package/src/internals/errors.ts

@@ -20,14 +20,30 @@ export function getErrorFromUnknown(cause: unknown): TRPCError {
   if (cause instanceof Error && cause.name === 'TRPCError') {
     return cause as TRPCError;
   }
+
+  let errorCause: Error | undefined = undefined;
+  let stack: string | undefined = undefined;
+
+  if (cause instanceof Error) {
+    errorCause = cause;
+    // take stack trace from cause
+    stack = cause.stack;
+  }
+
   const err = new TRPCError({
     code: 'INTERNAL_SERVER_ERROR',
-    cause,
+    cause: errorCause,
   });
 
-  // take stack trace from cause
+  err.stack = stack;
+
+  return err;
+}
+
+export function getCauseFromUnknown(cause: unknown) {
   if (cause instanceof Error) {
-    err.stack = cause.stack;
+    return cause;
   }
-  return err;
+
+  return undefined;
 }

package/src/internals/middlewares.ts

@@ -1,5 +1,5 @@
-import { ProcedureType } from '../router';
 import { TRPCError } from '../TRPCError';
+import { ProcedureType } from '../router';
 
 export const middlewareMarker = Symbol('middlewareMarker');
 interface MiddlewareResultBase<TContext> {
@@ -27,11 +27,12 @@ export type MiddlewareResult<TContext> =
   | MiddlewareOKResult<TContext>
   | MiddlewareErrorResult<TContext>;
 
-export type MiddlewareFunction<TInputContext, TContext> = (opts: {
+export type MiddlewareFunction<TInputContext, TContext, TMeta> = (opts: {
   ctx: TInputContext;
   type: ProcedureType;
   path: string;
   rawInput: unknown;
+  meta?: TMeta;
   next: {
     (): Promise<MiddlewareResult<TInputContext>>;
     <T>(opts: { ctx: T }): Promise<MiddlewareResult<T>>;