@trpc/server 10.0.0-alpha.1 → 10.0.0-alpha.12

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-17b64c0e.js');
+require('../resolveHTTPResponse-087ce86a.js');
+require('../transformTRPCResponse-bd24f548.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-17a5e0dd.mjs';
+import '../resolveHTTPResponse-9604d47d.mjs';
+import '../transformTRPCResponse-76e0c91e.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;AACpB,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAIrE,OAAO,EAAE,SAAS,EAAqC,MAAM,WAAW,CAAC;AAUzE,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;;EAgNjC"}

package/dist/adapters/ws.js

@@ -0,0 +1,346 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var transformTRPCResponse = require('../transformTRPCResponse-bd24f548.js');
+var subscription = require('../subscription-5b7e1eba.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', (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];
+        msgs.map(raw => parseMessage(raw, transformer)).map(handleRequest);
+      } 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();
+        });
+      }
+    }
+
+    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;