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

package/dist/{declarations/src/adapters → adapters}/node-http/types.d.ts

@@ -1,33 +1,33 @@
-/// <reference types="node" />
-import http from 'http';
-import qs from 'qs';
-import { inferRouterContext } from '../..';
-import { HTTPBaseHandlerOptions } from '../../http/internals/types';
-import { AnyRouter } from '../../router';
-export declare type NodeHTTPRequest = http.IncomingMessage & {
-    method?: string;
-    query?: qs.ParsedQs;
-    body?: unknown;
-};
-export declare type NodeHTTPResponse = http.ServerResponse;
-export declare type NodeHTTPCreateContextOption<TRouter extends AnyRouter, TRequest, TResponse> = unknown extends inferRouterContext<TRouter> ? {
-    /**
-     * @link https://trpc.io/docs/context
-     **/
-    createContext?: NodeHTTPCreateContextFn<TRouter, TRequest, TResponse>;
-} : {
-    /**
-     * @link https://trpc.io/docs/context
-     **/
-    createContext: NodeHTTPCreateContextFn<TRouter, TRequest, TResponse>;
-};
-export declare type NodeHTTPHandlerOptions<TRouter extends AnyRouter, TRequest extends NodeHTTPRequest, TResponse extends NodeHTTPResponse> = HTTPBaseHandlerOptions<TRouter, TRequest> & {
-    teardown?: () => Promise<void>;
-    maxBodySize?: number;
-} & NodeHTTPCreateContextOption<TRouter, TRequest, TResponse>;
-export declare type NodeHTTPCreateContextFnOptions<TRequest, TResponse> = {
-    req: TRequest;
-    res: TResponse;
-};
-export declare type NodeHTTPCreateContextFn<TRouter extends AnyRouter, TRequest, TResponse> = (opts: NodeHTTPCreateContextFnOptions<TRequest, TResponse>) => inferRouterContext<TRouter> | Promise<inferRouterContext<TRouter>>;
+/// <reference types="node" />
+import http from 'http';
+import qs from 'qs';
+import { inferRouterContext } from '../..';
+import { HTTPBaseHandlerOptions } from '../../http/internals/types';
+import { AnyRouter } from '../../router';
+export declare type NodeHTTPRequest = http.IncomingMessage & {
+    method?: string;
+    query?: qs.ParsedQs;
+    body?: unknown;
+};
+export declare type NodeHTTPResponse = http.ServerResponse;
+export declare type NodeHTTPCreateContextOption<TRouter extends AnyRouter, TRequest, TResponse> = unknown extends inferRouterContext<TRouter> ? {
+    /**
+     * @link https://trpc.io/docs/context
+     **/
+    createContext?: NodeHTTPCreateContextFn<TRouter, TRequest, TResponse>;
+} : {
+    /**
+     * @link https://trpc.io/docs/context
+     **/
+    createContext: NodeHTTPCreateContextFn<TRouter, TRequest, TResponse>;
+};
+export declare type NodeHTTPHandlerOptions<TRouter extends AnyRouter, TRequest extends NodeHTTPRequest, TResponse extends NodeHTTPResponse> = HTTPBaseHandlerOptions<TRouter, TRequest> & {
+    teardown?: () => Promise<void>;
+    maxBodySize?: number;
+} & NodeHTTPCreateContextOption<TRouter, TRequest, TResponse>;
+export declare type NodeHTTPCreateContextFnOptions<TRequest, TResponse> = {
+    req: TRequest;
+    res: TResponse;
+};
+export declare type NodeHTTPCreateContextFn<TRouter extends AnyRouter, TRequest, TResponse> = (opts: NodeHTTPCreateContextFnOptions<TRequest, TResponse>) => inferRouterContext<TRouter> | Promise<inferRouterContext<TRouter>>;
 //# sourceMappingURL=types.d.ts.map

package/dist/adapters/node-http/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/adapters/node-http/types.ts"],"names":[],"mappings":";AAAA,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,EAAE,MAAM,IAAI,CAAC;AACpB,OAAO,EAAE,kBAAkB,EAAE,MAAM,OAAO,CAAC;AAC3C,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,oBAAY,eAAe,GAAG,IAAI,CAAC,eAAe,GAAG;IACnD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,EAAE,CAAC,QAAQ,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB,CAAC;AACF,oBAAY,gBAAgB,GAAG,IAAI,CAAC,cAAc,CAAC;AAEnD,oBAAY,2BAA2B,CACrC,OAAO,SAAS,SAAS,EACzB,QAAQ,EACR,SAAS,IACP,OAAO,SAAS,kBAAkB,CAAC,OAAO,CAAC,GAC3C;IACE;;QAEI;IACJ,aAAa,CAAC,EAAE,uBAAuB,CAAC,OAAO,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;CACvE,GACD;IACE;;QAEI;IACJ,aAAa,EAAE,uBAAuB,CAAC,OAAO,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;CACtE,CAAC;AAEN,oBAAY,sBAAsB,CAChC,OAAO,SAAS,SAAS,EACzB,QAAQ,SAAS,eAAe,EAChC,SAAS,SAAS,gBAAgB,IAChC,sBAAsB,CAAC,OAAO,EAAE,QAAQ,CAAC,GAAG;IAC9C,QAAQ,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,GAAG,2BAA2B,CAAC,OAAO,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;AAE9D,oBAAY,8BAA8B,CAAC,QAAQ,EAAE,SAAS,IAAI;IAChE,GAAG,EAAE,QAAQ,CAAC;IACd,GAAG,EAAE,SAAS,CAAC;CAChB,CAAC;AACF,oBAAY,uBAAuB,CACjC,OAAO,SAAS,SAAS,EACzB,QAAQ,EACR,SAAS,IACP,CACF,IAAI,EAAE,8BAA8B,CAAC,QAAQ,EAAE,SAAS,CAAC,KACtD,kBAAkB,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAAC"}

package/dist/{declarations/src/adapters → adapters}/standalone.d.ts

@@ -1,14 +1,14 @@
-/// <reference types="node" />
-import http from 'http';
-import { AnyRouter } from '../router';
-import { NodeHTTPCreateContextFnOptions, NodeHTTPHandlerOptions } from './node-http';
-export declare type CreateHTTPHandlerOptions<TRouter extends AnyRouter> = NodeHTTPHandlerOptions<TRouter, http.IncomingMessage, http.ServerResponse>;
-export declare type CreateHTTPContextOptions = NodeHTTPCreateContextFnOptions<http.IncomingMessage, http.ServerResponse>;
-export declare function createHTTPHandler<TRouter extends AnyRouter>(opts: CreateHTTPHandlerOptions<TRouter>): (req: http.IncomingMessage, res: http.ServerResponse) => Promise<void>;
-export declare function createHTTPServer<TRouter extends AnyRouter>(opts: CreateHTTPHandlerOptions<TRouter>): {
-    server: http.Server;
-    listen(port?: number | undefined): {
-        port: number | undefined;
-    };
-};
+/// <reference types="node" />
+import http from 'http';
+import { AnyRouter } from '../router';
+import { NodeHTTPCreateContextFnOptions, NodeHTTPHandlerOptions } from './node-http';
+export declare type CreateHTTPHandlerOptions<TRouter extends AnyRouter> = NodeHTTPHandlerOptions<TRouter, http.IncomingMessage, http.ServerResponse>;
+export declare type CreateHTTPContextOptions = NodeHTTPCreateContextFnOptions<http.IncomingMessage, http.ServerResponse>;
+export declare function createHTTPHandler<TRouter extends AnyRouter>(opts: CreateHTTPHandlerOptions<TRouter>): (req: http.IncomingMessage, res: http.ServerResponse) => Promise<void>;
+export declare function createHTTPServer<TRouter extends AnyRouter>(opts: CreateHTTPHandlerOptions<TRouter>): {
+    server: http.Server;
+    listen(port?: number | undefined): {
+        port: number | undefined;
+    };
+};
 //# sourceMappingURL=standalone.d.ts.map

package/dist/adapters/standalone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standalone.d.ts","sourceRoot":"","sources":["../../src/adapters/standalone.ts"],"names":[],"mappings":";AAGA,OAAO,IAAI,MAAM,MAAM,CAAC;AAExB,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,EACL,8BAA8B,EAC9B,sBAAsB,EAEvB,MAAM,aAAa,CAAC;AAErB,oBAAY,wBAAwB,CAAC,OAAO,SAAS,SAAS,IAC5D,sBAAsB,CAAC,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;AAE7E,oBAAY,wBAAwB,GAAG,8BAA8B,CACnE,IAAI,CAAC,eAAe,EACpB,IAAI,CAAC,cAAc,CACpB,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,OAAO,SAAS,SAAS,EACzD,IAAI,EAAE,wBAAwB,CAAC,OAAO,CAAC,SAEpB,KAAK,eAAe,OAAO,KAAK,cAAc,mBASlE;AAED,wBAAgB,gBAAgB,CAAC,OAAO,SAAS,SAAS,EACxD,IAAI,EAAE,wBAAwB,CAAC,OAAO,CAAC;;;;;EAiBxC"}

package/dist/adapters/standalone.js

@@ -0,0 +1,46 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var http = require('http');
+var url = require('url');
+var nodeHTTPRequestHandler = require('../nodeHTTPRequestHandler-7d71ac09.js');
+require('../resolveHTTPResponse-c3777a47.js');
+require('../transformTRPCResponse-43a869de.js');
+require('../codes-7f46544e.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var http__default = /*#__PURE__*/_interopDefaultLegacy(http);
+var url__default = /*#__PURE__*/_interopDefaultLegacy(url);
+
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+function createHTTPHandler(opts) {
+  return async (req, res) => {
+    const endpoint = url__default["default"].parse(req.url).pathname.slice(1);
+    await nodeHTTPRequestHandler.nodeHTTPRequestHandler({ ...opts,
+      req,
+      res,
+      path: endpoint
+    });
+  };
+}
+function createHTTPServer(opts) {
+  const handler = createHTTPHandler(opts);
+  const server = http__default["default"].createServer((req, res) => handler(req, res));
+  return {
+    server,
+
+    listen(port) {
+      server.listen(port);
+      const actualPort = port === 0 ? server.address().port : port;
+      return {
+        port: actualPort
+      };
+    }
+
+  };
+}
+
+exports.createHTTPHandler = createHTTPHandler;
+exports.createHTTPServer = createHTTPServer;

package/dist/adapters/standalone.mjs

@@ -0,0 +1,36 @@
+import http from 'http';
+import url from 'url';
+import { n as nodeHTTPRequestHandler } from '../nodeHTTPRequestHandler-5fccb3bb.mjs';
+import '../resolveHTTPResponse-3292a84a.mjs';
+import '../transformTRPCResponse-ff424ff4.mjs';
+import '../codes-7a3d4f65.mjs';
+
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+function createHTTPHandler(opts) {
+  return async (req, res) => {
+    const endpoint = url.parse(req.url).pathname.slice(1);
+    await nodeHTTPRequestHandler({ ...opts,
+      req,
+      res,
+      path: endpoint
+    });
+  };
+}
+function createHTTPServer(opts) {
+  const handler = createHTTPHandler(opts);
+  const server = http.createServer((req, res) => handler(req, res));
+  return {
+    server,
+
+    listen(port) {
+      server.listen(port);
+      const actualPort = port === 0 ? server.address().port : port;
+      return {
+        port: actualPort
+      };
+    }
+
+  };
+}
+
+export { createHTTPHandler, createHTTPServer };

package/dist/adapters/standalone.ts.js

@@ -0,0 +1 @@
+

package/dist/{declarations/src/adapters → adapters}/ws.d.ts

@@ -1,17 +1,17 @@
-/// <reference types="node" />
-import http from 'http';
-import ws from 'ws';
-import { BaseHandlerOptions } from '../internals/BaseHandlerOptions';
-import { AnyRouter } from '../router';
-import { NodeHTTPCreateContextOption } from './node-http';
-/**
- * Web socket server handler
- */
-export declare type WSSHandlerOptions<TRouter extends AnyRouter> = BaseHandlerOptions<TRouter, http.IncomingMessage> & {
-    wss: ws.Server;
-    process?: NodeJS.Process;
-} & NodeHTTPCreateContextOption<TRouter, http.IncomingMessage, ws>;
-export declare function applyWSSHandler<TRouter extends AnyRouter>(opts: WSSHandlerOptions<TRouter>): {
-    broadcastReconnectNotification: () => void;
-};
+/// <reference types="node" />
+import http from 'http';
+import ws from 'ws';
+import { BaseHandlerOptions } from '../internals/BaseHandlerOptions';
+import { AnyRouter } from '../router';
+import { NodeHTTPCreateContextOption } from './node-http';
+/**
+ * Web socket server handler
+ */
+export declare type WSSHandlerOptions<TRouter extends AnyRouter> = BaseHandlerOptions<TRouter, http.IncomingMessage> & {
+    wss: ws.Server;
+    process?: NodeJS.Process;
+} & NodeHTTPCreateContextOption<TRouter, http.IncomingMessage, ws>;
+export declare function applyWSSHandler<TRouter extends AnyRouter>(opts: WSSHandlerOptions<TRouter>): {
+    broadcastReconnectNotification: () => void;
+};
 //# sourceMappingURL=ws.d.ts.map

package/dist/adapters/ws.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ws.d.ts","sourceRoot":"","sources":["../../src/adapters/ws.ts"],"names":[],"mappings":";AAAA,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,EAAE,MAAM,IAAI,CAAC;AAEpB,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAIrE,OAAO,EAAE,SAAS,EAAqC,MAAM,WAAW,CAAC;AASzE,OAAO,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAC;AAiE1D;;GAEG;AACH,oBAAY,iBAAiB,CAAC,OAAO,SAAS,SAAS,IAAI,kBAAkB,CAC3E,OAAO,EACP,IAAI,CAAC,eAAe,CACrB,GAAG;IACF,GAAG,EAAE,EAAE,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC,OAAO,CAAC;CAC1B,GAAG,2BAA2B,CAAC,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC;AAEnE,wBAAgB,eAAe,CAAC,OAAO,SAAS,SAAS,EACvD,IAAI,EAAE,iBAAiB,CAAC,OAAO,CAAC;;EAmNjC"}

package/dist/adapters/ws.js

@@ -0,0 +1,347 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var transformTRPCResponse = require('../transformTRPCResponse-43a869de.js');
+var subscription = require('../subscription-41611bc2.js');
+require('events');
+
+/* 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,
+      method,
+      params: undefined
+    };
+  }
+
+  assertIsProcedureType(method);
+  assertIsObject(params);
+  const {
+    input: rawInput,
+    path
+  } = params;
+  assertIsString(path);
+  const input = transformer.input.deserialize(rawInput);
+  return {
+    jsonrpc,
+    id,
+    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.transformTRPCResponse(router, untransformedJSON)));
+    }
+
+    const ctxPromise = createContext === null || createContext === void 0 ? void 0 : createContext({
+      req,
+      res: client
+    });
+    let ctx = undefined;
+
+    async function handleRequest(msg) {
+      const {
+        id
+      } = msg;
+      /* istanbul ignore next */
+
+      if (id === null) {
+        throw new transformTRPCResponse.TRPCError({
+          code: 'BAD_REQUEST',
+          message: '`id` is required'
+        });
+      }
+
+      if (msg.method === 'subscription.stop') {
+        const sub = clientSubscriptions.get(id);
+
+        if (sub) {
+          sub.destroy();
+        }
+
+        clientSubscriptions.delete(id);
+        return;
+      }
+
+      const {
+        path,
+        input
+      } = msg.params;
+      const type = msg.method;
+
+      try {
+        await ctxPromise; // asserts context has been set
+
+        const result = await transformTRPCResponse.callProcedure({
+          path,
+          input,
+          type,
+          router,
+          ctx
+        });
+
+        if (!(result instanceof subscription.Subscription)) {
+          respond({
+            id,
+            result: {
+              type: 'data',
+              data: result
+            }
+          });
+          return;
+        }
+
+        const sub = result;
+        /* istanbul ignore next */
+
+        if (client.readyState !== client.OPEN) {
+          // if the client got disconnected whilst initializing the subscription
+          sub.destroy();
+          return;
+        }
+        /* istanbul ignore next */
+
+
+        if (clientSubscriptions.has(id)) {
+          // duplicate request ids for client
+          sub.destroy();
+          throw new transformTRPCResponse.TRPCError({
+            message: `Duplicate id ${id}`,
+            code: 'BAD_REQUEST'
+          });
+        }
+
+        clientSubscriptions.set(id, sub);
+        sub.on('data', data => {
+          respond({
+            id,
+            result: {
+              type: 'data',
+              data
+            }
+          });
+        });
+        sub.on('error', _error => {
+          var _opts$onError;
+
+          const error = transformTRPCResponse.getErrorFromUnknown(_error);
+          const json = {
+            id,
+            error: router.getErrorShape({
+              error,
+              type,
+              path,
+              input,
+              ctx
+            })
+          };
+          (_opts$onError = opts.onError) === null || _opts$onError === void 0 ? void 0 : _opts$onError.call(opts, {
+            error,
+            path,
+            type,
+            ctx,
+            req,
+            input
+          });
+          respond(json);
+        });
+        sub.on('destroy', () => {
+          respond({
+            id,
+            result: {
+              type: 'stopped'
+            }
+          });
+        });
+        respond({
+          id,
+          result: {
+            type: 'started'
+          }
+        });
+        await sub.start();
+      } catch (cause)
+      /* istanbul ignore next */
+      {
+        var _opts$onError2;
+
+        // procedure threw an error
+        const error = transformTRPCResponse.getErrorFromUnknown(cause);
+        const json = router.getErrorShape({
+          error,
+          type,
+          path,
+          input,
+          ctx
+        });
+        (_opts$onError2 = opts.onError) === null || _opts$onError2 === void 0 ? void 0 : _opts$onError2.call(opts, {
+          error,
+          path,
+          type,
+          ctx,
+          req,
+          input
+        });
+        respond({
+          id,
+          error: json
+        });
+      }
+    }
+
+    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 transformTRPCResponse.TRPCError({
+          code: 'PARSE_ERROR',
+          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.destroy();
+      }
+
+      clientSubscriptions.clear();
+    });
+
+    async function createContextAsync() {
+      try {
+        ctx = await ctxPromise;
+      } catch (cause) {
+        var _opts$onError3, _global$setImmediate;
+
+        const error = transformTRPCResponse.getErrorFromUnknown(cause);
+        const json = {
+          id: null,
+          error: router.getErrorShape({
+            error,
+            type: 'unknown',
+            path: undefined,
+            input: undefined,
+            ctx
+          })
+        };
+        (_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(json); // 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);
+        }
+      }
+    }
+  };
+}
+
+exports.applyWSSHandler = applyWSSHandler;