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

package/dist/adapters/ws.js

@@ -0,0 +1,384 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var TRPCError = require('../TRPCError-ddec3395.js');
+var transformTRPCResponse = require('../transformTRPCResponse-333bed6c.js');
+var observable = require('../observable-3aa4d911.js');
+
+/* 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,
+      jsonrpc,
+      method
+    };
+  }
+
+  assertIsProcedureType(method);
+  assertIsObject(params);
+  const {
+    input: rawInput,
+    path
+  } = params;
+  assertIsString(path);
+  const input = transformer.input.deserialize(rawInput);
+  return {
+    id,
+    jsonrpc,
+    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)));
+    }
+
+    function stopSubscription(subscription, {
+      id,
+      jsonrpc
+    }) {
+      subscription.unsubscribe();
+      respond({
+        id,
+        jsonrpc,
+        result: {
+          type: 'stopped'
+        }
+      });
+    }
+
+    const ctxPromise = createContext === null || createContext === void 0 ? void 0 : createContext({
+      req,
+      res: client
+    });
+    let ctx = undefined;
+
+    async function handleRequest(msg) {
+      const {
+        id,
+        jsonrpc
+      } = msg;
+      /* istanbul ignore next */
+
+      if (id === null) {
+        throw new TRPCError.TRPCError({
+          code: 'BAD_REQUEST',
+          message: '`id` is required'
+        });
+      }
+
+      if (msg.method === 'subscription.stop') {
+        const sub = clientSubscriptions.get(id);
+
+        if (sub) {
+          stopSubscription(sub, {
+            id,
+            jsonrpc
+          });
+        }
+
+        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 (type === 'subscription') {
+          if (!observable.isObservable(result)) {
+            throw new TRPCError.TRPCError({
+              message: `Subscription ${path} did not return an observable`,
+              code: 'INTERNAL_SERVER_ERROR'
+            });
+          }
+        } else {
+          // send the value as data if the method is not a subscription
+          respond({
+            id,
+            jsonrpc,
+            result: {
+              type: 'data',
+              data: result
+            }
+          });
+          return;
+        }
+
+        const observable$1 = result;
+        const sub = observable$1.subscribe({
+          next(data) {
+            respond({
+              id,
+              jsonrpc,
+              result: {
+                type: 'data',
+                data
+              }
+            });
+          },
+
+          error(err) {
+            var _opts$onError;
+
+            const error = TRPCError.getErrorFromUnknown(err);
+            (_opts$onError = opts.onError) === null || _opts$onError === void 0 ? void 0 : _opts$onError.call(opts, {
+              error,
+              path,
+              type,
+              ctx,
+              req,
+              input
+            });
+            respond({
+              id,
+              jsonrpc,
+              error: router.getErrorShape({
+                error,
+                type,
+                path,
+                input,
+                ctx
+              })
+            });
+          },
+
+          complete() {
+            respond({
+              id,
+              jsonrpc,
+              result: {
+                type: 'stopped'
+              }
+            });
+          }
+
+        });
+        /* istanbul ignore next */
+
+        if (client.readyState !== client.OPEN) {
+          // if the client got disconnected whilst initializing the subscription
+          // no need to send stopped message if the client is disconnected
+          sub.unsubscribe();
+          return;
+        }
+        /* istanbul ignore next */
+
+
+        if (clientSubscriptions.has(id)) {
+          // duplicate request ids for client
+          stopSubscription(sub, {
+            id,
+            jsonrpc
+          });
+          throw new TRPCError.TRPCError({
+            message: `Duplicate id ${id}`,
+            code: 'BAD_REQUEST'
+          });
+        }
+
+        clientSubscriptions.set(id, sub);
+        respond({
+          id,
+          jsonrpc,
+          result: {
+            type: 'started'
+          }
+        });
+      } catch (cause)
+      /* istanbul ignore next */
+      {
+        var _opts$onError2;
+
+        // procedure threw an error
+        const error = TRPCError.getErrorFromUnknown(cause);
+        (_opts$onError2 = opts.onError) === null || _opts$onError2 === void 0 ? void 0 : _opts$onError2.call(opts, {
+          error,
+          path,
+          type,
+          ctx,
+          req,
+          input
+        });
+        respond({
+          id,
+          jsonrpc,
+          error: router.getErrorShape({
+            error,
+            type,
+            path,
+            input,
+            ctx
+          })
+        });
+      }
+    }
+
+    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 TRPCError.TRPCError({
+          code: 'PARSE_ERROR',
+          cause: TRPCError.getCauseFromUnknown(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.unsubscribe();
+      }
+
+      clientSubscriptions.clear();
+    });
+
+    async function createContextAsync() {
+      try {
+        ctx = await ctxPromise;
+      } catch (cause) {
+        var _opts$onError3, _global$setImmediate;
+
+        const error = TRPCError.getErrorFromUnknown(cause);
+        (_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({
+          id: null,
+          error: router.getErrorShape({
+            error,
+            type: 'unknown',
+            path: undefined,
+            input: undefined,
+            ctx
+          })
+        }); // 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;