@trpc/server 10.0.0-alpha.5 → 10.0.0-alpha.52

package/dist/adapters/ws.mjs

@@ -1,342 +1,295 @@
-import { T as TRPCError, t as transformTRPCResponse, c as callProcedure, g as getErrorFromUnknown } from '../transformTRPCResponse-76e0c91e.mjs';
-import { S as Subscription } from '../subscription-e1d42e69.mjs';
-import 'events';
+import { T as TRPCError, a as getCauseFromUnknown, g as getErrorFromUnknown } from '../TRPCError-6f61762c.mjs';
+import { t as transformTRPCResponse } from '../transformTRPCResponse-c8138d5f.mjs';
+import { i as isObservable } from '../observable-e129ac9d.mjs';
 
-/* 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(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 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(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 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)) {
-          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({
+                    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 (!isObservable(result)) {
+                        throw new 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 = result;
+                const sub1 = observable.subscribe({
+                    next (data) {
+                        respond({
+                            id,
+                            jsonrpc,
+                            result: {
+                                type: 'data',
+                                data
+                            }
+                        });
+                    },
+                    error (err) {
+                        const error = 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({
+                        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 = 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 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({
+                    code: 'PARSE_ERROR',
+                    cause: 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 = 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'
+        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 = 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 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 = 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 = 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);
+                }
+            }
         }
-      }
-    }
-  };
+    };
 }
 
 export { applyWSSHandler };

package/dist/assertNotBrowser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assertNotBrowser.d.ts","sourceRoot":"","sources":["../src/assertNotBrowser.ts"],"names":[],"mappings":"AAEA,wBAAgB,gBAAgB,SAQ/B"}
+{"version":3,"file":"assertNotBrowser.d.ts","sourceRoot":"","sources":["../src/assertNotBrowser.ts"],"names":[],"mappings":"AAEA,wBAAgB,gBAAgB,SAS/B"}

package/dist/codes-1c24d919.js

@@ -0,0 +1,47 @@
+'use strict';
+
+/**
+ * @internal
+ */ /**
+ * @internal
+ */ function invert(obj) {
+    const newObj = Object.create(null);
+    for(const key in obj){
+        const v = obj[key];
+        newObj[v] = key;
+    }
+    return newObj;
+}
+
+// reference: https://www.jsonrpc.org/specification
+/**
+ * JSON-RPC 2.0 Error codes
+ *
+ * `-32000` to `-32099` are reserved for implementation-defined server-errors.
+ * For tRPC we're copying the last digits of HTTP 4XX errors.
+ */ const TRPC_ERROR_CODES_BY_KEY = {
+    /**
+   * Invalid JSON was received by the server.
+   * An error occurred on the server while parsing the JSON text.
+   */ PARSE_ERROR: -32700,
+    /**
+   * The JSON sent is not a valid Request object.
+   */ BAD_REQUEST: -32600,
+    /**
+   * Internal JSON-RPC error.
+   */ INTERNAL_SERVER_ERROR: -32603,
+    // Implementation specific errors
+    UNAUTHORIZED: -32001,
+    FORBIDDEN: -32003,
+    NOT_FOUND: -32004,
+    METHOD_NOT_SUPPORTED: -32005,
+    TIMEOUT: -32008,
+    CONFLICT: -32009,
+    PRECONDITION_FAILED: -32012,
+    PAYLOAD_TOO_LARGE: -32013,
+    CLIENT_CLOSED_REQUEST: -32099
+};
+const TRPC_ERROR_CODES_BY_NUMBER = invert(TRPC_ERROR_CODES_BY_KEY);
+
+exports.TRPC_ERROR_CODES_BY_KEY = TRPC_ERROR_CODES_BY_KEY;
+exports.TRPC_ERROR_CODES_BY_NUMBER = TRPC_ERROR_CODES_BY_NUMBER;