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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/server",
-  "version": "10.0.0-alpha.2",
+  "version": "10.0.0-alpha.22",
   "description": "tRPC Server",
   "author": "KATT",
   "license": "MIT",
@@ -12,61 +12,117 @@
   },
   "eslintConfig": {
     "rules": {
-      "explicit-module-boundary-types": "off"
+      "explicit-module-boundary-types": "off",
+      "no-restricted-imports": [
+        "error",
+        "@trpc/server"
+      ]
     }
   },
-  "preconstruct": {
-    "entrypoints": [
-      "index.ts",
-      "adapters/express.ts",
-      "adapters/next.ts",
-      "adapters/node-http/index.ts",
-      "adapters/standalone.ts",
-      "adapters/ws.ts",
-      "ws/index.ts",
-      "rpc/index.ts"
-    ]
-  },
   "scripts": {
-    "test": "jest"
+    "test": "jest",
+    "build": "rollup -c"
+  },
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "typings": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./adapters/express": {
+      "import": "./dist/adapters/express.mjs",
+      "require": "./dist/adapters/express.js",
+      "default": "./dist/adapters/express.js"
+    },
+    "./adapters/next": {
+      "import": "./dist/adapters/next.mjs",
+      "require": "./dist/adapters/next.js",
+      "default": "./dist/adapters/next.js"
+    },
+    "./adapters/node-http": {
+      "import": "./dist/adapters/node-http/index.mjs",
+      "require": "./dist/adapters/node-http/index.js",
+      "default": "./dist/adapters/node-http/index.js"
+    },
+    "./adapters/standalone": {
+      "import": "./dist/adapters/standalone.mjs",
+      "require": "./dist/adapters/standalone.js",
+      "default": "./dist/adapters/standalone.js"
+    },
+    "./adapters/fastify": {
+      "import": "./dist/adapters/fastify/index.mjs",
+      "require": "./dist/adapters/fastify/index.js",
+      "default": "./dist/adapters/fastify/index.js"
+    },
+    "./adapters/ws": {
+      "import": "./dist/adapters/ws.mjs",
+      "require": "./dist/adapters/ws.js",
+      "default": "./dist/adapters/ws.js"
+    },
+    "./adapters/fetch": {
+      "import": "./dist/adapters/fetch/index.mjs",
+      "require": "./dist/adapters/fetch/index.js",
+      "default": "./dist/adapters/fetch/index.js"
+    },
+    "./rpc": {
+      "import": "./dist/rpc/index.mjs",
+      "require": "./dist/rpc/index.js",
+      "default": "./dist/rpc/index.js"
+    },
+    "./observable": {
+      "import": "./dist/observable/index.mjs",
+      "require": "./dist/observable/index.js",
+      "default": "./dist/observable/index.js"
+    },
+    "./subscription": {
+      "import": "./dist/subscription.mjs",
+      "require": "./dist/subscription.js",
+      "default": "./dist/subscription.js"
+    }
   },
-  "main": "dist/trpc-server.cjs.js",
-  "module": "dist/trpc-server.esm.js",
-  "typings": "dist/trpc-server.cjs.d.ts",
   "files": [
     "README.md",
     "dist",
     "adapters",
-    "ws",
     "rpc",
+    "observable",
     "src"
   ],
   "publishConfig": {
     "access": "public"
   },
   "devDependencies": {
-    "@testing-library/jest-dom": "^5.14.1",
-    "@testing-library/react": "^12.0.0",
-    "@testing-library/user-event": "^13.2.1",
+    "@cloudflare/workers-types": "^3.8.0",
+    "@miniflare/core": "^2.4.0",
     "@types/express": "^4.17.12",
     "@types/hash-sum": "^1.0.0",
     "@types/ws": "^8.2.0",
+    "abort-controller": "^3.0.0",
     "devalue": "^2.0.1",
+    "esbuild": "^0.14.38",
     "express": "^4.17.1",
-    "fastify": "^3.17.0",
+    "fastify": "^3.27.1",
+    "fastify-plugin": "^3.0.1",
+    "fastify-websocket": "^4.0.0",
     "hash-sum": "^2.0.0",
     "jest": "^27.1.0",
+    "jest-environment-miniflare": "^2.4.0",
     "konn": "^0.7.0",
+    "miniflare": "^2.4.0",
     "myzod": "^1.3.1",
-    "next": "^12.0.1",
+    "next": "^12.1.6",
+    "node-fetch": "^2.6.1",
     "superstruct": "^0.15.2",
     "typescript": "4.4.4",
     "ws": "^8.0.0",
     "yup": "^0.32.8",
     "zod": "^3.0.0"
   },
-  "gitHead": "4d72f1922cfb8a74e2bb03a29b39903418312728",
   "dependencies": {
     "tslib": "^2.1.0"
-  }
+  },
+  "gitHead": "d720eb2215f0fad6e70f4172a1bf084225d4d6de"
 }

package/rpc/dist/trpc-server-rpc.cjs.dev.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var codes = require('../../dist/codes-33cef953.cjs.dev.js');
+var codes = require('../../dist/codes-130e62df.cjs.dev.js');
 
 
 

package/rpc/dist/trpc-server-rpc.cjs.prod.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var codes = require('../../dist/codes-e0df67c4.cjs.prod.js');
+var codes = require('../../dist/codes-aff770a3.cjs.prod.js');
 
 
 

package/rpc/dist/trpc-server-rpc.esm.js

@@ -1 +1 @@
-export { T as TRPC_ERROR_CODES_BY_KEY, a as TRPC_ERROR_CODES_BY_NUMBER } from '../../dist/codes-fe07bf82.esm.js';
+export { T as TRPC_ERROR_CODES_BY_KEY, a as TRPC_ERROR_CODES_BY_NUMBER } from '../../dist/codes-5678cc97.esm.js';

package/rpc/index.d.ts

@@ -0,0 +1 @@
+export * from '../dist/rpc';

package/rpc/index.js

@@ -0,0 +1 @@
+module.exports = require('../dist/rpc/index');

package/src/TRPCError.ts

@@ -1,24 +1,16 @@
-import { TRPC_ERROR_CODE_KEY } from './rpc/codes';
 import { getMessageFromUnkownError } from './internals/errors';
+import { TRPC_ERROR_CODE_KEY } from './rpc/codes';
 
 export class TRPCError extends Error {
-  /**
-   * @deprecated use `cause`
-   */
-  public readonly originalError?: unknown;
-  public readonly cause?: unknown;
+  public readonly cause?: Error | undefined;
   public readonly code;
 
   constructor(opts: {
     message?: string;
     code: TRPC_ERROR_CODE_KEY;
-    /**
-     * @deprecated use `cause`
-     */
-    originalError?: unknown;
-    cause?: unknown;
+    cause?: Error;
   }) {
-    const cause = opts.cause ?? opts.originalError;
+    const cause = opts.cause;
     const code = opts.code;
     const message = opts.message ?? getMessageFromUnkownError(cause, code);
 
@@ -27,7 +19,7 @@ export class TRPCError extends Error {
     super(message, { cause });
 
     this.code = code;
-    this.cause = this.originalError = cause;
+    this.cause = cause;
     this.name = 'TRPCError';
 
     Object.setPrototypeOf(this, new.target.prototype);

package/src/adapters/express.ts

@@ -15,10 +15,10 @@ export type CreateExpressContextOptions = NodeHTTPCreateContextFnOptions<
 export function createExpressMiddleware<TRouter extends AnyRouter>(
   opts: NodeHTTPHandlerOptions<TRouter, express.Request, express.Response>,
 ): express.Handler {
-  return (req, res) => {
-    const endpoint = req.path.substr(1);
+  return async (req, res) => {
+    const endpoint = req.path.slice(1);
 
-    nodeHTTPRequestHandler({
+    await nodeHTTPRequestHandler({
       ...opts,
       req,
       res,

package/src/adapters/fastify/fastifyRequestHandler.ts

@@ -0,0 +1,77 @@
+import { FastifyReply, FastifyRequest } from 'fastify';
+import { assertNotBrowser } from '../../assertNotBrowser';
+import {
+  HTTPBaseHandlerOptions,
+  HTTPRequest,
+} from '../../http/internals/types';
+import { resolveHTTPResponse } from '../../http/resolveHTTPResponse';
+import { AnyRouter, inferRouterContext } from '../../router';
+import { NodeHTTPCreateContextOption } from '../node-http';
+
+assertNotBrowser();
+
+export type FastifyHandlerOptions<
+  TRouter extends AnyRouter,
+  TRequest extends FastifyRequest,
+  TResponse extends FastifyReply,
+> = HTTPBaseHandlerOptions<TRouter, TRequest> &
+  NodeHTTPCreateContextOption<TRouter, TRequest, TResponse>;
+
+type FastifyRequestHandlerOptions<
+  TRouter extends AnyRouter,
+  TRequest extends FastifyRequest,
+  TResponse extends FastifyReply,
+> = {
+  req: TRequest;
+  res: TResponse;
+  path: string;
+} & FastifyHandlerOptions<TRouter, TRequest, TResponse>;
+
+export async function fastifyRequestHandler<
+  TRouter extends AnyRouter,
+  TRequest extends FastifyRequest,
+  TResponse extends FastifyReply,
+>(opts: FastifyRequestHandlerOptions<TRouter, TRequest, TResponse>) {
+  const createContext = async function _createContext(): Promise<
+    inferRouterContext<TRouter>
+  > {
+    return opts.createContext?.(opts);
+  };
+
+  const query = opts.req.query
+    ? new URLSearchParams(opts.req.query as any)
+    : new URLSearchParams(opts.req.url.split('?')[1]);
+
+  const req: HTTPRequest = {
+    query,
+    method: opts.req.method,
+    headers: opts.req.headers,
+    body: opts.req.body ?? 'null',
+  };
+
+  const result = await resolveHTTPResponse({
+    req,
+    createContext,
+    path: opts.path,
+    router: opts.router,
+    batching: opts.batching,
+    responseMeta: opts.responseMeta,
+    onError(o) {
+      opts?.onError?.({ ...o, req: opts.req });
+    },
+  });
+
+  const { res } = opts;
+
+  if ('status' in result && (!res.statusCode || res.statusCode === 200)) {
+    res.statusCode = result.status;
+  }
+  for (const [key, value] of Object.entries(result.headers ?? {})) {
+    if (typeof value === 'undefined') {
+      continue;
+    }
+
+    void res.header(key, value);
+  }
+  await res.send(result.body);
+}

package/src/adapters/fastify/fastifyTRPCPlugin.ts

@@ -0,0 +1,56 @@
+/// <reference types="fastify-websocket" />
+import { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify';
+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;
+  useWSS?: boolean;
+  trpcOptions: FastifyHandlerOptions<TRouter, FastifyRequest, FastifyReply>;
+}
+
+export type CreateFastifyContextOptions = NodeHTTPCreateContextFnOptions<
+  FastifyRequest,
+  FastifyReply
+>;
+
+export function fastifyTRPCPlugin<TRouter extends AnyRouter>(
+  fastify: FastifyInstance,
+  opts: FastifyTRPCPluginOptions<TRouter>,
+  done: (err?: Error) => void,
+) {
+  fastify.addContentTypeParser(
+    'application/json',
+    { parseAs: 'string' },
+    function (_, body, _done) {
+      _done(null, body);
+    },
+  );
+
+  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;
+    await fastifyRequestHandler({ ...opts.trpcOptions, req, res, path });
+  });
+
+  if (opts.useWSS) {
+    applyWSSHandler<TRouter>({
+      ...(opts.trpcOptions as WSSHandlerOptions<TRouter>),
+      wss: fastify.websocketServer,
+    });
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    fastify.get(prefix ?? '/', { websocket: true }, () => {});
+  }
+
+  done();
+}

package/src/adapters/fastify/index.ts

@@ -0,0 +1,2 @@
+export * from './fastifyRequestHandler';
+export * from './fastifyTRPCPlugin';

package/src/adapters/fetch/fetchRequestHandler.ts

@@ -0,0 +1,61 @@
+import { assertNotBrowser } from '../../assertNotBrowser';
+import { HTTPRequest } from '../../http/internals/types';
+import { resolveHTTPResponse } from '../../http/resolveHTTPResponse';
+import { AnyRouter } from '../../router';
+import { FetchHandlerOptions } from './types';
+
+assertNotBrowser();
+
+export type FetchHandlerRequestOptions<TRouter extends AnyRouter> = {
+  req: Request;
+  endpoint: string;
+} & FetchHandlerOptions<TRouter>;
+
+export async function fetchRequestHandler<TRouter extends AnyRouter>(
+  opts: FetchHandlerRequestOptions<TRouter>,
+): Promise<Response> {
+  const createContext = async () => {
+    return opts.createContext?.({ req: opts.req });
+  };
+
+  const url = new URL(opts.req.url);
+  const path = url.pathname.slice(opts.endpoint.length + 1);
+  const req: HTTPRequest = {
+    query: url.searchParams,
+    method: opts.req.method,
+    headers: Object.fromEntries(opts.req.headers),
+    body: await opts.req.text(),
+  };
+
+  const result = await resolveHTTPResponse({
+    req,
+    createContext,
+    path,
+    router: opts.router,
+    batching: opts.batching,
+    responseMeta: opts.responseMeta,
+    onError(o) {
+      opts?.onError?.({ ...o, req: opts.req });
+    },
+  });
+
+  const res = new Response(result.body, {
+    status: result.status,
+  });
+
+  for (const [key, value] of Object.entries(result.headers ?? {})) {
+    if (typeof value === 'undefined') {
+      continue;
+    }
+
+    if (typeof value === 'string') {
+      res.headers.set(key, value);
+      continue;
+    }
+
+    for (const v of value) {
+      res.headers.append(key, v);
+    }
+  }
+  return res;
+}

package/src/adapters/fetch/index.ts

@@ -0,0 +1,2 @@
+export * from './fetchRequestHandler';
+export * from './types';

package/src/adapters/fetch/types.ts

@@ -0,0 +1,28 @@
+import { HTTPBaseHandlerOptions } from '../../http/internals/types';
+import { AnyRouter, inferRouterContext } from '../../router';
+
+export type FetchCreateContextFnOptions = {
+  req: Request;
+};
+
+export type FetchCreateContextFn<TRouter extends AnyRouter> = (opts: {
+  req: Request;
+}) => inferRouterContext<TRouter> | Promise<inferRouterContext<TRouter>>;
+
+export type FetchCreateContextOption<TRouter extends AnyRouter> =
+  unknown extends inferRouterContext<TRouter>
+    ? {
+        /**
+         * @link https://trpc.io/docs/context
+         **/
+        createContext?: FetchCreateContextFn<TRouter>;
+      }
+    : {
+        /**
+         * @link https://trpc.io/docs/context
+         **/
+        createContext: FetchCreateContextFn<TRouter>;
+      };
+
+export type FetchHandlerOptions<TRouter extends AnyRouter> =
+  HTTPBaseHandlerOptions<TRouter, Request> & FetchCreateContextOption<TRouter>;

package/src/adapters/next.ts

@@ -1,9 +1,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-import type { NextApiHandler, NextApiRequest, NextApiResponse } from 'next';
-import { AnyRouter } from '../router';
-import { TRPCErrorResponse } from '../rpc';
+import type {
+  NextApiHandler,
+  NextApiRequest,
+  NextApiResponse,
+} from 'next/types';
 import { TRPCError } from '../TRPCError';
+import { AnyRouter } from '../router';
 import { nodeHTTPRequestHandler } from './node-http';
 import {
   NodeHTTPCreateContextFnOptions,
@@ -42,12 +45,11 @@ export function createNextApiHandler<TRouter extends AnyRouter>(
         path: undefined,
         input: undefined,
       });
-      const json: TRPCErrorResponse = {
+      res.statusCode = 500;
+      res.json({
         id: -1,
         error,
-      };
-      res.statusCode = 500;
-      res.json(json);
+      });
       return;
     }
 

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,14 @@
-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';
+import { AnyRouter, inferRouterContext } 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!.substr(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,
     });
   };
 }