@trpc/server 10.0.0-alpha.8 → 10.0.0-proxy-alpha.53

package/dist/adapters/ws.js

@@ -2,345 +2,312 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var transformTRPCResponse = require('../transformTRPCResponse-bd24f548.js');
-var subscription = require('../subscription-5b7e1eba.js');
-require('events');
+var TRPCError = require('../TRPCError-bcb38a84.js');
+var transformTRPCResponse = require('../transformTRPCResponse-11ac69cc.js');
+var observable = require('../observable-b651bf11.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 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 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 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 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');
-  }
+/* 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') {
+    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,
-      method,
-      params: undefined
+        id,
+        jsonrpc,
+        method,
+        params: {
+            input,
+            path
+        }
     };
-  }
-
-  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();
+    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)));
         }
-
-        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
+        function stopSubscription(subscription, { id , jsonrpc  }) {
+            subscription.unsubscribe();
+            respond({
+                id,
+                jsonrpc,
+                result: {
+                    type: 'stopped'
+                }
+            });
+        }
+        const ctxPromise = createContext?.({
+            req,
+            res: client
         });
-
-        if (!(result instanceof subscription.Subscription)) {
-          respond({
-            id,
-            result: {
-              type: 'data',
-              data: result
+        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 caller = router.createCaller(ctx);
+                const result = await caller[type](path, input);
+                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 sub1 = observable$1.subscribe({
+                    next (data) {
+                        respond({
+                            id,
+                            jsonrpc,
+                            result: {
+                                type: 'data',
+                                data
+                            }
+                        });
+                    },
+                    error (err) {
+                        const error = TRPCError.getErrorFromUnknown(err);
+                        opts.onError?.({
+                            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
+                    sub1.unsubscribe();
+                    return;
+                }
+                /* istanbul ignore next */ if (clientSubscriptions.has(id)) {
+                    // duplicate request ids for client
+                    stopSubscription(sub1, {
+                        id,
+                        jsonrpc
+                    });
+                    throw new TRPCError.TRPCError({
+                        message: `Duplicate id ${id}`,
+                        code: 'BAD_REQUEST'
+                    });
+                }
+                clientSubscriptions.set(id, sub1);
+                respond({
+                    id,
+                    jsonrpc,
+                    result: {
+                        type: 'started'
+                    }
+                });
+            } catch (cause) /* istanbul ignore next */ {
+                // procedure threw an error
+                const error = TRPCError.getErrorFromUnknown(cause);
+                opts.onError?.({
+                    error,
+                    path,
+                    type,
+                    ctx,
+                    req,
+                    input
+                });
+                respond({
+                    id,
+                    jsonrpc,
+                    error: router.getErrorShape({
+                        error,
+                        type,
+                        path,
+                        input,
+                        ctx
+                    })
+                });
             }
-          });
-          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
+        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
+                    })
+                });
             }
-          });
         });
-        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);
+        // WebSocket errors should be handled, as otherwise unhandled exceptions will crash Node.js.
+        // This line was introduced after the following error brought down production systems:
+        // "RangeError: Invalid WebSocket frame: RSV2 and RSV3 must be clear"
+        // Here is the relevant discussion: https://github.com/websockets/ws/issues/1354#issuecomment-774616962
+        client.on('error', (cause)=>{
+            opts.onError?.({
+                ctx,
+                error: TRPCError.getErrorFromUnknown(cause),
+                input: undefined,
+                path: undefined,
+                type: 'unknown',
+                req
+            });
         });
-        sub.on('destroy', () => {
-          respond({
-            id,
-            result: {
-              type: 'stopped'
+        client.once('close', ()=>{
+            for (const sub of clientSubscriptions.values()){
+                sub.unsubscribe();
             }
-          });
-        });
-        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
-          })
+            clientSubscriptions.clear();
         });
-      }
-    });
-    client.once('close', () => {
-      for (const sub of clientSubscriptions.values()) {
-        sub.destroy();
-      }
-
-      clientSubscriptions.clear();
+        async function createContextAsync() {
+            try {
+                ctx = await ctxPromise;
+            } catch (cause) {
+                const error = TRPCError.getErrorFromUnknown(cause);
+                opts.onError?.({
+                    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.setTimeout)(()=>{
+                    client.close();
+                });
+            }
+        }
+        await createContextAsync();
     });
-
-    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);
+    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;