@trpc/server 10.0.0-alpha.4 → 10.0.0-alpha.42

package/dist/adapters/ws.mjs

@@ -1,6 +1,6 @@
-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-97212592.mjs';
+import { t as transformTRPCResponse } from '../transformTRPCResponse-747b9a68.mjs';
+import { i as isObservable } from '../observable-cfedfa30.mjs';
 
 /* istanbul ignore next */
 function assertIsObject(obj) {
@@ -55,8 +55,8 @@ function parseMessage(obj, transformer) {
   if (method === 'subscription.stop') {
     return {
       id,
-      method,
-      params: undefined
+      jsonrpc,
+      method
     };
   }
 
@@ -69,8 +69,8 @@ function parseMessage(obj, transformer) {
   assertIsString(path);
   const input = transformer.input.deserialize(rawInput);
   return {
-    jsonrpc,
     id,
+    jsonrpc,
     method,
     params: {
       input,
@@ -92,13 +92,27 @@ function applyWSSHandler(opts) {
   const {
     transformer
   } = router._def;
-  wss.on('connection', (client, req) => {
+  wss.on('connection', async (client, req) => {
     const clientSubscriptions = new Map();
 
     function respond(untransformedJSON) {
       client.send(JSON.stringify(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
@@ -107,7 +121,8 @@ function applyWSSHandler(opts) {
 
     async function handleRequest(msg) {
       const {
-        id
+        id,
+        jsonrpc
       } = msg;
       /* istanbul ignore next */
 
@@ -122,7 +137,10 @@ function applyWSSHandler(opts) {
         const sub = clientSubscriptions.get(id);
 
         if (sub) {
-          sub.destroy();
+          stopSubscription(sub, {
+            id,
+            jsonrpc
+          });
         }
 
         clientSubscriptions.delete(id);
@@ -138,17 +156,21 @@ function applyWSSHandler(opts) {
       try {
         await ctxPromise; // asserts context has been set
 
-        const result = await callProcedure({
-          path,
-          input,
-          type,
-          router,
-          ctx
-        });
+        const caller = router.createCaller(ctx);
+        const result = await caller[type](path, input);
 
-        if (!(result instanceof Subscription)) {
+        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
@@ -157,12 +179,61 @@ function applyWSSHandler(opts) {
           return;
         }
 
-        const sub = result;
+        const observable = result;
+        const sub = observable.subscribe({
+          next(data) {
+            respond({
+              id,
+              jsonrpc,
+              result: {
+                type: 'data',
+                data
+              }
+            });
+          },
+
+          error(err) {
+            var _opts$onError;
+
+            const error = 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
-          sub.destroy();
+          // no need to send stopped message if the client is disconnected
+          sub.unsubscribe();
           return;
         }
         /* istanbul ignore next */
@@ -170,7 +241,10 @@ function applyWSSHandler(opts) {
 
         if (clientSubscriptions.has(id)) {
           // duplicate request ids for client
-          sub.destroy();
+          stopSubscription(sub, {
+            id,
+            jsonrpc
+          });
           throw new TRPCError({
             message: `Duplicate id ${id}`,
             code: 'BAD_REQUEST'
@@ -178,54 +252,13 @@ function applyWSSHandler(opts) {
         }
 
         clientSubscriptions.set(id, sub);
-        sub.on('data', data => {
-          respond({
-            id,
-            result: {
-              type: 'data',
-              data
-            }
-          });
-        });
-        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'
-            }
-          });
-        });
         respond({
           id,
+          jsonrpc,
           result: {
             type: 'started'
           }
         });
-        await sub.start();
       } catch (cause)
       /* istanbul ignore next */
       {
@@ -233,13 +266,6 @@ function applyWSSHandler(opts) {
 
         // 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,
@@ -250,7 +276,14 @@ function applyWSSHandler(opts) {
         });
         respond({
           id,
-          error: json
+          jsonrpc,
+          error: router.getErrorShape({
+            error,
+            type,
+            path,
+            input,
+            ctx
+          })
         });
       }
     }
@@ -259,11 +292,12 @@ function applyWSSHandler(opts) {
       try {
         const msgJSON = JSON.parse(message.toString());
         const msgs = Array.isArray(msgJSON) ? msgJSON : [msgJSON];
-        msgs.map(raw => parseMessage(raw, transformer)).map(handleRequest);
+        const promises = msgs.map(raw => parseMessage(raw, transformer)).map(handleRequest);
+        await Promise.all(promises);
       } catch (cause) {
         const error = new TRPCError({
           code: 'PARSE_ERROR',
-          cause
+          cause: getCauseFromUnknown(cause)
         });
         respond({
           id: null,
@@ -279,7 +313,7 @@ function applyWSSHandler(opts) {
     });
     client.once('close', () => {
       for (const sub of clientSubscriptions.values()) {
-        sub.destroy();
+        sub.unsubscribe();
       }
 
       clientSubscriptions.clear();
@@ -292,16 +326,6 @@ function applyWSSHandler(opts) {
         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,
@@ -310,7 +334,16 @@ function applyWSSHandler(opts) {
           req,
           input: undefined
         });
-        respond(json); // close in next tick
+        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();
@@ -318,7 +351,7 @@ function applyWSSHandler(opts) {
       }
     }
 
-    createContextAsync();
+    await createContextAsync();
   });
   return {
     broadcastReconnectNotification: () => {

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/core/index.d.ts

@@ -0,0 +1,6 @@
+export type { AnyRouter, ProcedureRouterRecord } from './router';
+export { callProcedure } from './router';
+export type { Procedure, ProcedureParams, ProcedureArgs, ProcedureOptions, } from './procedure';
+export { initTRPC } from './initTRPC';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,SAAS,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,YAAY,EACV,SAAS,EACT,eAAe,EACf,aAAa,EACb,gBAAgB,GACjB,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,cAAc,SAAS,CAAC"}

package/dist/core/initTRPC.d.ts

@@ -0,0 +1,87 @@
+import { mergeRoutersGeneric } from './internals/__generated__/mergeRoutersGeneric';
+import { DefaultErrorShape, ErrorFormatter, ErrorFormatterShape } from '../error/formatter';
+import { CombinedDataTransformer, DataTransformerOptions, DefaultDataTransformer } from '../transformer';
+import { InitGenerics, InitOptions } from './internals/config';
+import { PickFirstDefined, ValidateShape } from './internals/utils';
+export declare function initTRPC<TParams extends Partial<InitGenerics> = {}>(): <TOptions extends Partial<InitOptions<{
+    ctx: TParams['ctx'] extends undefined ? {} : NonNullable<TParams['ctx']>;
+    meta: TParams['meta'] extends undefined ? {} : NonNullable<TParams['meta']>;
+}>>>(options?: ValidateShape<TOptions, Partial<InitOptions<{
+    ctx: TParams['ctx'] extends undefined ? {} : NonNullable<TParams['ctx']>;
+    meta: TParams['meta'] extends undefined ? {} : NonNullable<TParams['meta']>;
+}>>> | undefined) => {
+    /**
+     * These are just types, they can't be used
+     * @internal
+     */
+    _config: {
+        ctx: TParams["ctx"] extends undefined ? {} : NonNullable<TParams["ctx"]>;
+        meta: PickFirstDefined<TParams["meta"] extends undefined ? {} : NonNullable<TParams["meta"]>, undefined>;
+        errorShape: ErrorFormatterShape<PickFirstDefined<TOptions["errorFormatter"], ErrorFormatter<TParams["ctx"] extends undefined ? {} : NonNullable<TParams["ctx"]>, DefaultErrorShape>>>;
+        transformer: TOptions["transformer"] extends DataTransformerOptions ? TOptions["transformer"] extends DataTransformerOptions ? CombinedDataTransformer : DefaultDataTransformer : DefaultDataTransformer;
+    };
+    /**
+     * Builder object for creating procedures
+     */
+    procedure: import("./internals/procedureBuilder").ProcedureBuilder<{
+        _config: {
+            ctx: TParams["ctx"] extends undefined ? {} : NonNullable<TParams["ctx"]>;
+            meta: PickFirstDefined<TParams["meta"] extends undefined ? {} : NonNullable<TParams["meta"]>, undefined>;
+            errorShape: ErrorFormatterShape<PickFirstDefined<TOptions["errorFormatter"], ErrorFormatter<TParams["ctx"] extends undefined ? {} : NonNullable<TParams["ctx"]>, DefaultErrorShape>>>;
+            transformer: TOptions["transformer"] extends DataTransformerOptions ? TOptions["transformer"] extends DataTransformerOptions ? CombinedDataTransformer : DefaultDataTransformer : DefaultDataTransformer;
+        };
+        _ctx_in: TParams["ctx"] extends undefined ? {} : NonNullable<TParams["ctx"]>;
+        _ctx_out: TParams["ctx"] extends undefined ? {} : NonNullable<TParams["ctx"]>;
+        _input_in: typeof import("./internals/utils").unsetMarker;
+        _input_out: typeof import("./internals/utils").unsetMarker;
+        _output_in: typeof import("./internals/utils").unsetMarker;
+        _output_out: typeof import("./internals/utils").unsetMarker;
+        _meta: PickFirstDefined<TParams["meta"] extends undefined ? {} : NonNullable<TParams["meta"]>, undefined>;
+    }>;
+    /**
+     * Create reusable middlewares
+     */
+    middleware: <$TNewParams extends import("./procedure").ProcedureParams<{
+        transformer: CombinedDataTransformer;
+        errorShape: DefaultErrorShape;
+        ctx: Record<string, unknown>;
+        meta: Record<string, unknown>;
+    }, unknown, unknown, unknown, unknown, unknown, unknown, unknown>>(fn: import("./middleware").MiddlewareFunction<{
+        _config: {
+            ctx: TParams["ctx"] extends undefined ? {} : NonNullable<TParams["ctx"]>;
+            meta: PickFirstDefined<TParams["meta"] extends undefined ? {} : NonNullable<TParams["meta"]>, undefined>;
+            errorShape: ErrorFormatterShape<PickFirstDefined<TOptions["errorFormatter"], ErrorFormatter<TParams["ctx"] extends undefined ? {} : NonNullable<TParams["ctx"]>, DefaultErrorShape>>>;
+            transformer: TOptions["transformer"] extends DataTransformerOptions ? TOptions["transformer"] extends DataTransformerOptions ? CombinedDataTransformer : DefaultDataTransformer : DefaultDataTransformer;
+        };
+        _ctx_in: TParams["ctx"] extends undefined ? {} : NonNullable<TParams["ctx"]>;
+        _ctx_out: TParams["ctx"] extends undefined ? {} : NonNullable<TParams["ctx"]>;
+        _input_out: unknown;
+        _input_in: unknown;
+        _output_in: unknown;
+        _output_out: unknown;
+        _meta: PickFirstDefined<TParams["meta"] extends undefined ? {} : NonNullable<TParams["meta"]>, undefined>;
+    }, $TNewParams>) => import("./middleware").MiddlewareFunction<{
+        _config: {
+            ctx: TParams["ctx"] extends undefined ? {} : NonNullable<TParams["ctx"]>;
+            meta: PickFirstDefined<TParams["meta"] extends undefined ? {} : NonNullable<TParams["meta"]>, undefined>;
+            errorShape: ErrorFormatterShape<PickFirstDefined<TOptions["errorFormatter"], ErrorFormatter<TParams["ctx"] extends undefined ? {} : NonNullable<TParams["ctx"]>, DefaultErrorShape>>>;
+            transformer: TOptions["transformer"] extends DataTransformerOptions ? TOptions["transformer"] extends DataTransformerOptions ? CombinedDataTransformer : DefaultDataTransformer : DefaultDataTransformer;
+        };
+        _ctx_in: TParams["ctx"] extends undefined ? {} : NonNullable<TParams["ctx"]>;
+        _ctx_out: TParams["ctx"] extends undefined ? {} : NonNullable<TParams["ctx"]>;
+        _input_out: unknown;
+        _input_in: unknown;
+        _output_in: unknown;
+        _output_out: unknown;
+        _meta: PickFirstDefined<TParams["meta"] extends undefined ? {} : NonNullable<TParams["meta"]>, undefined>;
+    }, $TNewParams>;
+    /**
+     * Create a router
+     */
+    router: <TProcRouterRecord extends import("./router").ProcedureRouterRecord>(opts: TProcRouterRecord) => import("./router").Router<import("./router").RouterDef<TParams["ctx"] extends undefined ? {} : NonNullable<TParams["ctx"]>, ErrorFormatterShape<PickFirstDefined<TOptions["errorFormatter"], ErrorFormatter<TParams["ctx"] extends undefined ? {} : NonNullable<TParams["ctx"]>, DefaultErrorShape>>>, PickFirstDefined<TParams["meta"] extends undefined ? {} : NonNullable<TParams["meta"]>, undefined>, TProcRouterRecord>> & TProcRouterRecord;
+    /**
+     * Merge Routers
+     */
+    mergeRouters: typeof mergeRoutersGeneric;
+};
+//# sourceMappingURL=initTRPC.d.ts.map

package/dist/core/initTRPC.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initTRPC.d.ts","sourceRoot":"","sources":["../../src/core/initTRPC.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,+CAA+C,CAAC;AACpF,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,mBAAmB,EAEpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,uBAAuB,EACvB,sBAAsB,EACtB,sBAAsB,EAGvB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAGL,YAAY,EACZ,WAAW,EACZ,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAIpE,wBAAgB,QAAQ,CAAC,OAAO,SAAS,OAAO,CAAC,YAAY,CAAC,GAAG,EAAE;SAE1D,OAAO,CAAC,KAAK,CAAC,SAAS,SAAS,GAAG,EAAE,GAAG,YAAY,OAAO,CAAC,KAAK,CAAC,CAAC;UAClE,OAAO,CAAC,MAAM,CAAC,SAAS,SAAS,GAAG,EAAE,GAAG,YAAY,OAAO,CAAC,MAAM,CAAC,CAAC;;SADtE,OAAO,CAAC,KAAK,CAAC,SAAS,SAAS,GAAG,EAAE,GAAG,YAAY,OAAO,CAAC,KAAK,CAAC,CAAC;UAClE,OAAO,CAAC,MAAM,CAAC,SAAS,SAAS,GAAG,EAAE,GAAG,YAAY,OAAO,CAAC,MAAM,CAAC,CAAC;;IAuCzE;;;OAGG;;;;;;;IAEH;;OAEG;;;;;;;;;;;;;;;;IAEH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEH;;OAEG;;IAKH;;OAEG;;EAIR"}