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

package/dist/adapters/ws.mjs

@@ -0,0 +1,343 @@
+import { T as TRPCError, t as transformTRPCResponse, c as callProcedure, g as getErrorFromUnknown } from '../transformTRPCResponse-ff424ff4.mjs';
+import { S as Subscription } from '../subscription-0d8a48ec.mjs';
+import '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', async (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();
+        }
+
+        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
+        });
+
+        if (!(result instanceof 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 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 = 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 = 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];
+        const promises = msgs.map(raw => parseMessage(raw, transformer)).map(handleRequest);
+        await Promise.all(promises);
+      } 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
+          })
+        });
+      }
+    });
+    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 = 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();
+        });
+      }
+    }
+
+    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);
+        }
+      }
+    }
+  };
+}
+
+export { applyWSSHandler };

package/dist/adapters/ws.ts.js

@@ -0,0 +1 @@
+

package/dist/{declarations/src/assertNotBrowser.d.ts → assertNotBrowser.d.ts}

@@ -1,2 +1,2 @@
-export declare function assertNotBrowser(): void;
+export declare function assertNotBrowser(): void;
 //# sourceMappingURL=assertNotBrowser.d.ts.map

package/dist/assertNotBrowser.d.ts.map

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

package/dist/{declarations/src/http → http}/ResponseMeta.d.ts

@@ -1,5 +1,5 @@
-export interface ResponseMeta {
-    status?: number;
-    headers?: Record<string, string>;
-}
+export interface ResponseMeta {
+    status?: number;
+    headers?: Record<string, string>;
+}
 //# sourceMappingURL=ResponseMeta.d.ts.map

package/dist/http/ResponseMeta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResponseMeta.d.ts","sourceRoot":"","sources":["../../src/http/ResponseMeta.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC"}

package/dist/{declarations/src/http → http}/index.d.ts

@@ -1,3 +1,3 @@
-export * from './resolveHTTPResponse';
-export * from './ResponseMeta';
+export * from './resolveHTTPResponse';
+export * from './ResponseMeta';
 //# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/http/index.ts"],"names":[],"mappings":"AAEA,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC"}

package/dist/{declarations/src/http → http}/internals/getHTTPStatusCode.d.ts

@@ -1,21 +1,21 @@
-import { TRPCResponse, TRPC_ERROR_CODES_BY_KEY } from '../../rpc';
-import { TRPCError } from '../../TRPCError';
-export declare const TRPC_ERROR_CODES_BY_NUMBER: {
-    [-32700]: "PARSE_ERROR";
-    [-32600]: "BAD_REQUEST";
-    [-32603]: "INTERNAL_SERVER_ERROR";
-    [-32001]: "UNAUTHORIZED";
-    [-32003]: "FORBIDDEN";
-    [-32004]: "NOT_FOUND";
-    [-32005]: "METHOD_NOT_SUPPORTED";
-    [-32008]: "TIMEOUT";
-    [-32012]: "PRECONDITION_FAILED";
-    [-32013]: "PAYLOAD_TOO_LARGE";
-    [-32099]: "CLIENT_CLOSED_REQUEST";
-};
-declare type ValueOf<T> = T[keyof T];
-export declare type TRPC_ERROR_CODE_NUMBER = ValueOf<typeof TRPC_ERROR_CODES_BY_KEY>;
-export declare function getHTTPStatusCode(json: TRPCResponse | TRPCResponse[]): any;
-export declare function getHTTPStatusCodeFromError(error: TRPCError): number;
-export {};
+import { TRPCError } from '../../TRPCError';
+import { TRPCResponse, TRPC_ERROR_CODES_BY_KEY } from '../../rpc';
+export declare const TRPC_ERROR_CODES_BY_NUMBER: {
+    [-32700]: "PARSE_ERROR";
+    [-32600]: "BAD_REQUEST";
+    [-32603]: "INTERNAL_SERVER_ERROR";
+    [-32001]: "UNAUTHORIZED";
+    [-32003]: "FORBIDDEN";
+    [-32004]: "NOT_FOUND";
+    [-32005]: "METHOD_NOT_SUPPORTED";
+    [-32008]: "TIMEOUT";
+    [-32012]: "PRECONDITION_FAILED";
+    [-32013]: "PAYLOAD_TOO_LARGE";
+    [-32099]: "CLIENT_CLOSED_REQUEST";
+};
+declare type ValueOf<T> = T[keyof T];
+export declare type TRPC_ERROR_CODE_NUMBER = ValueOf<typeof TRPC_ERROR_CODES_BY_KEY>;
+export declare function getHTTPStatusCode(json: TRPCResponse | TRPCResponse[]): any;
+export declare function getHTTPStatusCodeFromError(error: TRPCError): number;
+export {};
 //# sourceMappingURL=getHTTPStatusCode.d.ts.map

package/dist/http/internals/getHTTPStatusCode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getHTTPStatusCode.d.ts","sourceRoot":"","sources":["../../../src/http/internals/getHTTPStatusCode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,OAAO,EAAE,YAAY,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AAElE,eAAO,MAAM,0BAA0B;;;;;;;;;;;;CAAkC,CAAC;AAC1E,aAAK,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AAE7B,oBAAY,sBAAsB,GAAG,OAAO,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAsB7E,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,YAAY,GAAG,YAAY,EAAE,OAuBpE;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,SAAS,UAI1D"}

package/dist/{declarations/src/http → http}/internals/types.d.ts

@@ -1,40 +1,40 @@
-/// <reference types="node" />
-import { AnyRouter, Dict, inferRouterContext, inferRouterError, ProcedureType, ResponseMeta, TRPCError } from '@trpc/server';
-import { URLSearchParams } from 'url';
-import { BaseHandlerOptions } from '../../internals/BaseHandlerOptions';
-import { TRPCResponse } from '../../rpc';
-export declare type HTTPHeaders = Dict<string | string[]>;
-export interface HTTPResponse {
-    status: number;
-    headers?: HTTPHeaders;
-    body?: string;
-}
-export interface HTTPRequest {
-    method: string;
-    query: URLSearchParams;
-    headers: HTTPHeaders;
-    body: unknown;
-}
-declare type ResponseMetaFn<TRouter extends AnyRouter> = (opts: {
-    data: TRPCResponse<unknown, inferRouterError<TRouter>>[];
-    ctx?: inferRouterContext<TRouter>;
-    /**
-     * The different tRPC paths requested
-     **/
-    paths?: string[];
-    type: ProcedureType | 'unknown';
-    errors: TRPCError[];
-}) => ResponseMeta;
-/**
- * Base interface for anything using HTTP
- */
-export interface HTTPBaseHandlerOptions<TRouter extends AnyRouter, TRequest> extends BaseHandlerOptions<TRouter, TRequest> {
-    /**
-     * Add handler to be called before response is sent to the user
-     * Useful for setting cache headers
-     * @link https://trpc.io/docs/caching
-     */
-    responseMeta?: ResponseMetaFn<TRouter>;
-}
-export {};
+/// <reference types="node" />
+import { AnyRouter, Dict, ProcedureType, ResponseMeta, TRPCError, inferRouterContext, inferRouterError } from '@trpc/server';
+import { URLSearchParams } from 'url';
+import { BaseHandlerOptions } from '../../internals/BaseHandlerOptions';
+import { TRPCResponse } from '../../rpc';
+export declare type HTTPHeaders = Dict<string | string[]>;
+export interface HTTPResponse {
+    status: number;
+    headers?: HTTPHeaders;
+    body?: string;
+}
+export interface HTTPRequest {
+    method: string;
+    query: URLSearchParams;
+    headers: HTTPHeaders;
+    body: unknown;
+}
+declare type ResponseMetaFn<TRouter extends AnyRouter> = (opts: {
+    data: TRPCResponse<unknown, inferRouterError<TRouter>>[];
+    ctx?: inferRouterContext<TRouter>;
+    /**
+     * The different tRPC paths requested
+     **/
+    paths?: string[];
+    type: ProcedureType | 'unknown';
+    errors: TRPCError[];
+}) => ResponseMeta;
+/**
+ * Base interface for anything using HTTP
+ */
+export interface HTTPBaseHandlerOptions<TRouter extends AnyRouter, TRequest> extends BaseHandlerOptions<TRouter, TRequest> {
+    /**
+     * Add handler to be called before response is sent to the user
+     * Useful for setting cache headers
+     * @link https://trpc.io/docs/caching
+     */
+    responseMeta?: ResponseMetaFn<TRouter>;
+}
+export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/http/internals/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/http/internals/types.ts"],"names":[],"mappings":";AAAA,OAAO,EACL,SAAS,EACT,IAAI,EACJ,aAAa,EACb,YAAY,EACZ,SAAS,EACT,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,eAAe,EAAE,MAAM,KAAK,CAAC;AACtC,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAEzC,oBAAY,WAAW,GAAG,IAAI,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;AAElD,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,eAAe,CAAC;IACvB,OAAO,EAAE,WAAW,CAAC;IACrB,IAAI,EAAE,OAAO,CAAC;CACf;AAED,aAAK,cAAc,CAAC,OAAO,SAAS,SAAS,IAAI,CAAC,IAAI,EAAE;IACtD,IAAI,EAAE,YAAY,CAAC,OAAO,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC;IACzD,GAAG,CAAC,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC;IAClC;;QAEI;IACJ,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,aAAa,GAAG,SAAS,CAAC;IAChC,MAAM,EAAE,SAAS,EAAE,CAAC;CACrB,KAAK,YAAY,CAAC;AAEnB;;GAEG;AACH,MAAM,WAAW,sBAAsB,CAAC,OAAO,SAAS,SAAS,EAAE,QAAQ,CACzE,SAAQ,kBAAkB,CAAC,OAAO,EAAE,QAAQ,CAAC;IAC7C;;;;OAIG;IACH,YAAY,CAAC,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC;CACxC"}

package/dist/{declarations/src/http → http}/resolveHTTPResponse.d.ts

@@ -1,13 +1,13 @@
-import { Maybe } from '@trpc/server';
-import { AnyRouter, inferRouterContext } from '../router';
-import { TRPCError } from '../TRPCError';
-import { HTTPRequest, HTTPResponse, HTTPBaseHandlerOptions } from './internals/types';
-interface ResolveHTTPRequestOptions<TRouter extends AnyRouter, TRequest extends HTTPRequest> extends HTTPBaseHandlerOptions<TRouter, TRequest> {
-    createContext: () => Promise<inferRouterContext<TRouter>>;
-    req: TRequest;
-    path: string;
-    error?: Maybe<TRPCError>;
-}
-export declare function resolveHTTPResponse<TRouter extends AnyRouter, TRequest extends HTTPRequest>(opts: ResolveHTTPRequestOptions<TRouter, TRequest>): Promise<HTTPResponse>;
-export {};
+import { Maybe } from '@trpc/server';
+import { TRPCError } from '../TRPCError';
+import { AnyRouter, inferRouterContext } from '../router';
+import { HTTPBaseHandlerOptions, HTTPRequest, HTTPResponse } from './internals/types';
+interface ResolveHTTPRequestOptions<TRouter extends AnyRouter, TRequest extends HTTPRequest> extends HTTPBaseHandlerOptions<TRouter, TRequest> {
+    createContext: () => Promise<inferRouterContext<TRouter>>;
+    req: TRequest;
+    path: string;
+    error?: Maybe<TRPCError>;
+}
+export declare function resolveHTTPResponse<TRouter extends AnyRouter, TRequest extends HTTPRequest>(opts: ResolveHTTPRequestOptions<TRouter, TRequest>): Promise<HTTPResponse>;
+export {};
 //# sourceMappingURL=resolveHTTPResponse.d.ts.map

package/dist/http/resolveHTTPResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveHTTPResponse.d.ts","sourceRoot":"","sources":["../../src/http/resolveHTTPResponse.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACrC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAIzC,OAAO,EACL,SAAS,EAET,kBAAkB,EAEnB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,sBAAsB,EAEtB,WAAW,EACX,YAAY,EACb,MAAM,mBAAmB,CAAC;AA4B3B,UAAU,yBAAyB,CACjC,OAAO,SAAS,SAAS,EACzB,QAAQ,SAAS,WAAW,CAC5B,SAAQ,sBAAsB,CAAC,OAAO,EAAE,QAAQ,CAAC;IACjD,aAAa,EAAE,MAAM,OAAO,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAAC;IAC1D,GAAG,EAAE,QAAQ,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;CAC1B;AAED,wBAAsB,mBAAmB,CACvC,OAAO,SAAS,SAAS,EACzB,QAAQ,SAAS,WAAW,EAC5B,IAAI,EAAE,yBAAyB,CAAC,OAAO,EAAE,QAAQ,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAmM3E"}

package/dist/{declarations/src/index.d.ts → index.d.ts}

@@ -1,10 +1,8 @@
-export * from './assertNotBrowser';
-export * from './http';
-export * from './subscription';
-export * from './transformer';
-export * from './TRPCError';
-export * from './types';
-export * from './deprecated/createHttpServer';
-export * from './deprecated/requestHandler';
-export * from './deprecated/LegacyRouter';
+export * from './assertNotBrowser';
+export * from './http';
+export * from './subscription';
+export * from './transformer';
+export * from './TRPCError';
+export * from './types';
+export * from './router';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,QAAQ,CAAC;AACvB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC"}