@trpc/server 10.0.0-alpha.25 → 10.0.0-alpha.28

package/src/adapters/express.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type * as express from 'express';
-import { AnyRouter } from '../router';
+import { AnyRouter } from '../core';
 import { nodeHTTPRequestHandler } from './node-http';
 import {
   NodeHTTPCreateContextFnOptions,

package/src/adapters/fastify/fastifyRequestHandler.ts

@@ -1,11 +1,11 @@
 import { FastifyReply, FastifyRequest } from 'fastify';
 import { assertNotBrowser } from '../../assertNotBrowser';
+import { AnyRouter, inferRouterContext } from '../../core';
 import {
   HTTPBaseHandlerOptions,
   HTTPRequest,
 } from '../../http/internals/types';
 import { resolveHTTPResponse } from '../../http/resolveHTTPResponse';
-import { AnyRouter, inferRouterContext } from '../../router';
 import { NodeHTTPCreateContextOption } from '../node-http';
 
 assertNotBrowser();

package/src/adapters/fastify/fastifyTRPCPlugin.ts

@@ -1,7 +1,7 @@
 /// <reference types="@fastify/websocket" />
 import { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify';
 import { FastifyHandlerOptions } from '.';
-import { AnyRouter } from '../..';
+import { AnyRouter } from '../../core';
 import { NodeHTTPCreateContextFnOptions } from '../node-http';
 import { WSSHandlerOptions, applyWSSHandler } from '../ws';
 import { fastifyRequestHandler } from './fastifyRequestHandler';
@@ -45,7 +45,7 @@ export function fastifyTRPCPlugin<TRouter extends AnyRouter>(
 
   if (opts.useWSS) {
     applyWSSHandler<TRouter>({
-      ...(opts.trpcOptions as WSSHandlerOptions<TRouter>),
+      ...(opts.trpcOptions as unknown as WSSHandlerOptions<TRouter>),
       wss: fastify.websocketServer,
     });
     // eslint-disable-next-line @typescript-eslint/no-empty-function

package/src/adapters/fetch/fetchRequestHandler.ts

@@ -1,7 +1,7 @@
 import { assertNotBrowser } from '../../assertNotBrowser';
+import { AnyRouter } from '../../core';
 import { HTTPRequest } from '../../http/internals/types';
 import { resolveHTTPResponse } from '../../http/resolveHTTPResponse';
-import { AnyRouter } from '../../router';
 import { FetchHandlerOptions } from './types';
 
 assertNotBrowser();

package/src/adapters/fetch/types.ts

@@ -1,5 +1,5 @@
+import { AnyRouter, inferRouterContext } from '../../core';
 import { HTTPBaseHandlerOptions } from '../../http/internals/types';
-import { AnyRouter, inferRouterContext } from '../../router';
 
 export type FetchCreateContextFnOptions = {
   req: Request;

package/src/adapters/lambda/index.ts

@@ -0,0 +1,18 @@
+import {
+  CreateAWSLambdaContextOptions,
+  awsLambdaRequestHandler,
+} from '../aws-lambda';
+import { APIGatewayEvent } from '../aws-lambda/utils';
+
+export * from '../aws-lambda';
+
+/**
+ * @deprecated use `aws-lambda` instead
+ */
+export type CreateLambdaContextOptions<T extends APIGatewayEvent> =
+  CreateAWSLambdaContextOptions<T>;
+
+/**
+ * @deprecated use `aws-lambda` instead
+ */
+export const lambdaRequestHandler = awsLambdaRequestHandler;

package/src/adapters/next.ts

@@ -5,8 +5,8 @@ import type {
   NextApiRequest,
   NextApiResponse,
 } from 'next/types';
-import { TRPCError } from '../TRPCError';
-import { AnyRouter } from '../router';
+import { AnyRouter } from '../core';
+import { TRPCError } from '../error/TRPCError';
 import { nodeHTTPRequestHandler } from './node-http';
 import {
   NodeHTTPCreateContextFnOptions,

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

@@ -1,4 +1,4 @@
-import { TRPCError } from '../../../TRPCError';
+import { TRPCError } from '../../../error/TRPCError';
 import { NodeHTTPRequest } from '../types';
 
 export async function getPostBody({

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

@@ -1,8 +1,9 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { assertNotBrowser } from '../../assertNotBrowser';
+import { AnyRouter } from '../../core';
+import { inferRouterParams } from '../../core/types';
 import { HTTPRequest } from '../../http/internals/types';
 import { resolveHTTPResponse } from '../../http/resolveHTTPResponse';
-import { AnyRouter, inferRouterContext } from '../../router';
 import { getPostBody } from './internals/getPostBody';
 import {
   NodeHTTPHandlerOptions,
@@ -28,7 +29,7 @@ export async function nodeHTTPRequestHandler<
   TResponse extends NodeHTTPResponse,
 >(opts: NodeHTTPRequestHandlerOptions<TRouter, TRequest, TResponse>) {
   const createContext = async function _createContext(): Promise<
-    inferRouterContext<TRouter>
+    inferRouterParams<TRouter>['_ctx']
   > {
     return await opts.createContext?.(opts);
   };

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

@@ -1,6 +1,7 @@
 import { IncomingMessage, ServerResponse } from 'http';
+import { AnyRouter, inferRouterContext } from '../../core';
+import { inferRouterParams } from '../../core';
 import { HTTPBaseHandlerOptions } from '../../http/internals/types';
-import { AnyRouter, inferRouterContext } from '../../router';
 
 interface ParsedQs {
   [key: string]: undefined | string | string[] | ParsedQs | ParsedQs[];
@@ -49,4 +50,6 @@ export type NodeHTTPCreateContextFn<
   TResponse,
 > = (
   opts: NodeHTTPCreateContextFnOptions<TRequest, TResponse>,
-) => inferRouterContext<TRouter> | Promise<inferRouterContext<TRouter>>;
+) =>
+  | inferRouterParams<TRouter>['_ctx']
+  | Promise<inferRouterParams<TRouter>['_ctx']>;

package/src/adapters/standalone.ts

@@ -2,7 +2,7 @@
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import http from 'http';
-import { AnyRouter } from '../router';
+import { AnyRouter } from '../core';
 import {
   NodeHTTPCreateContextFnOptions,
   NodeHTTPHandlerOptions,

package/src/adapters/ws.ts

@@ -1,12 +1,11 @@
 import { IncomingMessage } from 'http';
 import ws from 'ws';
-import { TRPCError } from '../TRPCError';
-import { BaseHandlerOptions } from '../internals/baseHandlerOptions';
-import { callProcedure } from '../internals/callProcedure';
-import { getCauseFromUnknown, getErrorFromUnknown } from '../internals/errors';
+import { AnyRouter, ProcedureType, inferRouterContext } from '../core';
+import { TRPCError } from '../error/TRPCError';
+import { getCauseFromUnknown, getErrorFromUnknown } from '../error/utils';
 import { transformTRPCResponse } from '../internals/transformTRPCResponse';
+import { BaseHandlerOptions } from '../internals/types';
 import { Unsubscribable, isObservable } from '../observable';
-import { AnyRouter, ProcedureType, inferRouterContext } from '../router';
 import {
   JSONRPC2,
   TRPCClientOutgoingMessage,
@@ -14,7 +13,10 @@ import {
   TRPCResponseMessage,
 } from '../rpc';
 import { CombinedDataTransformer } from '../transformer';
-import { NodeHTTPCreateContextOption } from './node-http';
+import {
+  NodeHTTPCreateContextFnOptions,
+  NodeHTTPCreateContextOption,
+} from './node-http';
 
 /* istanbul ignore next */
 function assertIsObject(obj: unknown): asserts obj is Record<string, unknown> {
@@ -98,6 +100,11 @@ export type WSSHandlerOptions<TRouter extends AnyRouter> = BaseHandlerOptions<
   process?: NodeJS.Process;
 } & NodeHTTPCreateContextOption<TRouter, IncomingMessage, ws>;
 
+export type CreateWSSContextFnOptions = NodeHTTPCreateContextFnOptions<
+  IncomingMessage,
+  ws
+>;
+
 export function applyWSSHandler<TRouter extends AnyRouter>(
   opts: WSSHandlerOptions<TRouter>,
 ) {
@@ -152,13 +159,9 @@ export function applyWSSHandler<TRouter extends AnyRouter>(
       const type = msg.method;
       try {
         await ctxPromise; // asserts context has been set
-        const result = await callProcedure({
-          path,
-          input,
-          type,
-          router,
-          ctx,
-        });
+
+        const caller = router.createCaller(ctx);
+        const result = await caller[type](path, input as any);
 
         if (type === 'subscription') {
           if (!isObservable(result)) {

package/src/core/index.ts

@@ -0,0 +1,5 @@
+export type { AnyRouter } from './router';
+export type { Procedure, ProcedureParams } from './procedure';
+
+export { initTRPC } from './initTRPC';
+export * from './types';

package/src/core/initTRPC.ts

@@ -0,0 +1,90 @@
+/* eslint-disable @typescript-eslint/ban-types */
+import {
+  DefaultErrorShape,
+  ErrorFormatter,
+  ErrorFormatterShape,
+  defaultFormatter,
+} from '../error/formatter';
+import {
+  CombinedDataTransformer,
+  DataTransformerOptions,
+  DefaultDataTransformer,
+  defaultTransformer,
+  getDataTransformer,
+} from '../transformer';
+import {
+  CreateInitGenerics,
+  CreateRootConfig,
+  InitGenerics,
+  InitOptions,
+} from './internals/config';
+import { mergeRoutersGeneric } from './internals/mergeRoutersGeneric';
+import { createBuilder } from './internals/procedureBuilder';
+import { PickFirstDefined, ValidateShape } from './internals/utils';
+import { createMiddlewareFactory } from './middleware';
+import { createRouterFactory } from './router';
+
+export function initTRPC<TParams extends Partial<InitGenerics> = {}>() {
+  type $Generics = CreateInitGenerics<{
+    ctx: TParams['ctx'] extends undefined ? {} : NonNullable<TParams['ctx']>;
+    meta: TParams['meta'] extends undefined ? {} : NonNullable<TParams['meta']>;
+  }>;
+
+  type $Context = $Generics['ctx'];
+  type $Meta = $Generics['meta'];
+  type $Options = Partial<InitOptions<$Generics>>;
+
+  return function initTRPCInner<TOptions extends $Options>(
+    options?: ValidateShape<TOptions, $Options>,
+  ) {
+    type $Formatter = PickFirstDefined<
+      TOptions['errorFormatter'],
+      ErrorFormatter<$Context, DefaultErrorShape>
+    >;
+    type $Transformer = TOptions['transformer'] extends DataTransformerOptions
+      ? TOptions['transformer'] extends undefined
+        ? DefaultDataTransformer
+        : CombinedDataTransformer
+      : DefaultDataTransformer;
+    type $ErrorShape = ErrorFormatterShape<$Formatter>;
+
+    type $Config = CreateRootConfig<{
+      ctx: $Context;
+      meta: $Meta;
+      errorShape: $ErrorShape;
+      transformer: $Transformer;
+    }>;
+
+    const errorFormatter = options?.errorFormatter ?? defaultFormatter;
+    const transformer = getDataTransformer(
+      options?.transformer ?? defaultTransformer,
+    );
+    return {
+      /**
+       * These are just types, they can't be used
+       * @internal
+       */
+      _config: null as unknown as $Config,
+      /**
+       * Builder object for creating procedures
+       */
+      procedure: createBuilder<$Context, $Meta>(),
+      /**
+       * Create reusable middlewares
+       */
+      middleware: createMiddlewareFactory<$Context, $Meta>(),
+      /**
+       * Create a router
+       * FIXME this should also use error formatter
+       */
+      router: createRouterFactory<$Config>({
+        errorFormatter,
+        transformer,
+      }),
+      /**
+       * Merge Routers
+       */
+      mergeRouters: mergeRoutersGeneric,
+    };
+  };
+}