@trpc/client 9.20.1 → 10.0.0-alpha.10

package/src/links/splitLink.test.ts

@@ -0,0 +1,56 @@
+/* eslint-disable @typescript-eslint/no-empty-function */
+import { AnyRouter } from '../../../server/src';
+import { createChain } from '../links/internals/createChain';
+import { splitLink } from '../links/splitLink';
+import { OperationLink, TRPCLink } from '../links/types';
+import { Observable } from 'rxjs';
+
+test('splitLink', () => {
+  const wsLinkSpy = jest.fn();
+  const wsLink: TRPCLink<any> = () => () =>
+    new Observable(() => {
+      wsLinkSpy();
+    });
+  const httpLinkSpy = jest.fn();
+  const httpLink: TRPCLink<any> = () => () =>
+    new Observable(() => {
+      httpLinkSpy();
+    });
+  const links: OperationLink<AnyRouter, any, any>[] = [
+    // "dedupe link"
+    splitLink({
+      condition(op) {
+        return op.type === 'subscription';
+      },
+      true: wsLink,
+      false: [httpLink],
+    })(null as any),
+  ];
+
+  createChain({
+    links,
+    op: {
+      type: 'query',
+      input: null,
+      path: '.',
+      id: 0,
+      context: {},
+    },
+  }).subscribe({});
+  expect(httpLinkSpy).toHaveBeenCalledTimes(1);
+  expect(wsLinkSpy).toHaveBeenCalledTimes(0);
+  jest.resetAllMocks();
+
+  createChain({
+    links,
+    op: {
+      type: 'subscription',
+      input: null,
+      path: '.',
+      id: 0,
+      context: {},
+    },
+  }).subscribe({});
+  expect(httpLinkSpy).toHaveBeenCalledTimes(0);
+  expect(wsLinkSpy).toHaveBeenCalledTimes(1);
+});

package/src/links/splitLink.ts

@@ -1,45 +1,30 @@
 import { AnyRouter } from '@trpc/server';
-import { TRPCLink, Operation } from './core';
+import { Observable } from 'rxjs';
+import { TRPCLink, Operation } from './types';
+import { createChain } from './internals/createChain';
 
-export function splitLink<TRouter extends AnyRouter = AnyRouter>(
-  opts: {
-    condition: (op: Operation) => boolean;
-  } & (
-    | {
-        /**
-         * The link to execute next if the test function returns `true`.
-         */
-        left: TRPCLink<TRouter>;
-        /**
-         * The link to execute next if the test function returns `false`.
-         */
-        right: TRPCLink<TRouter>;
-      }
-    | {
-        /**
-         * The link to execute next if the test function returns `true`.
-         */
-        true: TRPCLink<TRouter>;
-        /**
-         * The link to execute next if the test function returns `false`.
-         */
-        false: TRPCLink<TRouter>;
-      }
-  ),
-): TRPCLink<TRouter> {
+function asArray<T>(value: T | T[]) {
+  return Array.isArray(value) ? value : [value];
+}
+export function splitLink<TRouter extends AnyRouter = AnyRouter>(opts: {
+  condition: (op: Operation) => boolean;
+  /**
+   * The link to execute next if the test function returns `true`.
+   */
+  true: TRPCLink<TRouter> | TRPCLink<TRouter>[];
+  /**
+   * The link to execute next if the test function returns `false`.
+   */
+  false: TRPCLink<TRouter> | TRPCLink<TRouter>[];
+}): TRPCLink<TRouter> {
   return (rt) => {
-    const links =
-      'left' in opts
-        ? {
-            true: opts.left,
-            false: opts.right,
-          }
-        : opts;
-
-    const yes = links.true(rt);
-    const no = links.false(rt);
+    const yes = asArray(opts.true).map((link) => link(rt));
+    const no = asArray(opts.false).map((link) => link(rt));
     return (props) => {
-      opts.condition(props.op) ? yes(props) : no(props);
+      return new Observable((observer) => {
+        const links = opts.condition(props.op) ? yes : no;
+        return createChain({ op: props.op, links }).subscribe(observer);
+      });
     };
   };
 }

package/src/links/transformerLink.ts

@@ -0,0 +1,74 @@
+import {
+  AnyRouter,
+  ClientDataTransformerOptions,
+  DataTransformer,
+} from '@trpc/server';
+import { Observable } from 'rxjs';
+import { OperationResult, TRPCLink } from './types';
+
+/**
+ * @internal
+ */
+function transformOperationResult<TResult extends OperationResult<any, any>>(
+  result: TResult,
+  transformer: DataTransformer,
+) {
+  if ('error' in result.data) {
+    return {
+      ...result,
+      data: {
+        ...result.data,
+        error: transformer.deserialize(result.data.error),
+      },
+    };
+  }
+  if (result.data.result.type !== 'data') {
+    return result;
+  }
+  return {
+    ...result,
+    data: {
+      ...result.data,
+      result: {
+        ...result.data.result,
+        data: transformer.deserialize(result.data.result.data),
+      },
+    },
+  };
+}
+export function transformerLink<TRouter extends AnyRouter = AnyRouter>(
+  transformer: ClientDataTransformerOptions,
+): TRPCLink<TRouter> {
+  const _transformer: DataTransformer = transformer
+    ? 'input' in transformer
+      ? {
+          serialize: transformer.input.serialize,
+          deserialize: transformer.output.deserialize,
+        }
+      : transformer
+    : {
+        serialize: (data) => data,
+        deserialize: (data) => data,
+      };
+
+  return () => {
+    return (props) => {
+      const input = _transformer.serialize(props.op.input);
+      return new Observable((observer) => {
+        const subscription = props.next({ ...props.op, input }).subscribe({
+          next(value) {
+            const transformed = transformOperationResult(value, _transformer);
+            observer.next(transformed);
+          },
+          error(err) {
+            observer.error(err);
+          },
+          complete() {
+            observer.complete();
+          },
+        });
+        return subscription;
+      });
+    };
+  };
+}

package/src/links/types.ts

@@ -0,0 +1,64 @@
+import { AnyRouter, inferRouterError, Dict } from '@trpc/server';
+import { TRPCResponse } from '@trpc/server/rpc';
+import { Observable, Observer } from 'rxjs';
+
+export type CancelFn = () => void;
+
+export type PromiseAndCancel<TValue> = {
+  promise: Promise<TValue>;
+  cancel: CancelFn;
+};
+
+export type OperationContext = Record<string, unknown>;
+export type Operation<TInput = unknown> = {
+  id: number;
+  type: 'query' | 'mutation' | 'subscription';
+  input: TInput;
+  path: string;
+  context?: OperationContext;
+};
+
+export type HTTPHeaders = Dict<string | string[]>;
+
+/**
+ * The default `fetch` implementation has an overloaded signature. By convention this library
+ * only uses the overload taking a string and options object.
+ */
+export type TRPCFetch = (
+  url: string,
+  options?: RequestInit,
+) => Promise<Response>;
+
+export interface LinkRuntime {
+  headers: () => HTTPHeaders | Promise<HTTPHeaders>;
+  fetch: TRPCFetch;
+  AbortController?: typeof AbortController;
+}
+
+export interface OperationResult<TRouter extends AnyRouter, TOutput> {
+  data: TRPCResponse<TOutput, inferRouterError<TRouter>>;
+  context?: OperationContext;
+}
+
+export type OperationResultObservable<
+  TRouter extends AnyRouter,
+  TOutput,
+> = Observable<OperationResult<TRouter, TOutput>>;
+
+export type OperationResultObserver<
+  TRouter extends AnyRouter,
+  TOutput,
+> = Observer<OperationResult<TRouter, TOutput>>;
+
+export type OperationLink<
+  TRouter extends AnyRouter,
+  TInput = unknown,
+  TOutput = unknown,
+> = (opts: {
+  op: Operation<TInput>;
+  next: (op: Operation<TInput>) => OperationResultObservable<TRouter, TOutput>;
+}) => OperationResultObservable<TRouter, TOutput>;
+
+export type TRPCLink<TRouter extends AnyRouter> = (
+  opts: LinkRuntime,
+) => OperationLink<TRouter>;

package/src/links/wsLink.ts

@@ -4,20 +4,14 @@ import {
   TRPCClientIncomingRequest,
   TRPCRequest,
   TRPCResponse,
-  TRPCResult,
 } from '@trpc/server/rpc';
-import { TRPCErrorResponse } from '@trpc/server/rpc';
-import { ObservableCallbacks, UnsubscribeFn } from '../internals/observable';
 import { retryDelay } from '../internals/retryDelay';
+
+import { Observable } from 'rxjs';
 import { TRPCClientError } from '../TRPCClientError';
-import { TRPCLink } from './core';
+import { Operation, OperationResultObserver, TRPCLink } from './types';
 
-type Operation = {
-  id: number | string;
-  type: ProcedureType;
-  input: unknown;
-  path: string;
-};
+type UnsubscribeFn = () => void;
 export interface WebSocketClientOptions {
   url: string;
   WebSocket?: WebSocket;
@@ -42,10 +36,7 @@ export function createWSClient(opts: WebSocketClientOptions) {
   /**
    * pending outgoing requests that are awaiting callback
    */
-  type TCallbacks = ObservableCallbacks<
-    TRPCResult,
-    TRPCClientError<AnyRouter> | TRPCErrorResponse
-  >;
+  type TCallbacks = OperationResultObserver<AnyRouter, unknown>;
   type TRequest = {
     /**
      * Reference to the WebSocket instance this request was made to
@@ -151,18 +142,14 @@ export function createWSClient(opts: WebSocketClientOptions) {
         }
       }
     };
-    const handleIncomingResponse = (res: TRPCResponse) => {
-      const req = res.id !== null && pendingRequests[res.id];
+    const handleIncomingResponse = (data: TRPCResponse) => {
+      const req = data.id !== null && pendingRequests[data.id];
       if (!req) {
         // do something?
         return;
       }
-      if ('error' in res) {
-        req.callbacks.onError?.(res);
-        return;
-      }
 
-      req.callbacks.onNext?.(res.result);
+      req.callbacks.next?.({ data });
       if (req.ws !== activeConnection && conn === activeConnection) {
         const oldWs = req.ws;
         // gracefully replace old connection with this
@@ -170,8 +157,12 @@ export function createWSClient(opts: WebSocketClientOptions) {
         closeIfNoPending(oldWs);
       }
 
-      if (res.result.type === 'stopped' && conn === activeConnection) {
-        req.callbacks.onDone?.();
+      if (
+        'result' in data &&
+        data.result.type === 'stopped' &&
+        conn === activeConnection
+      ) {
+        req.callbacks.complete();
       }
     };
     conn.addEventListener('message', ({ data }) => {
@@ -199,14 +190,14 @@ export function createWSClient(opts: WebSocketClientOptions) {
         if (req.ws !== conn) {
           continue;
         }
-        req.callbacks.onError?.(
+        req.callbacks.error?.(
           TRPCClientError.from(
             new TRPCWebSocketClosedError('WebSocket closed prematurely'),
           ),
         );
         if (req.type !== 'subscription') {
           delete pendingRequests[key];
-          req.callbacks.onDone?.();
+          req.callbacks.complete?.();
         } else if (state !== 'closed') {
           // request restart of sub with next connection
           resumeSubscriptionOnReconnect(req);
@@ -243,7 +234,7 @@ export function createWSClient(opts: WebSocketClientOptions) {
       delete pendingRequests[id];
       outgoing = outgoing.filter((msg) => msg.id !== id);
 
-      callbacks?.onDone?.();
+      callbacks?.complete?.();
       if (op.type === 'subscription') {
         outgoing.push({
           id,
@@ -289,63 +280,52 @@ class TRPCSubscriptionEndedError extends Error {
 export function wsLink<TRouter extends AnyRouter>(
   opts: WebSocketLinkOptions,
 ): TRPCLink<TRouter> {
-  // initialized config
-  return (rt) => {
+  return () => {
     const { client } = opts;
+    return ({ op }) => {
+      return new Observable((observer) => {
+        const { type, input, path, id, context } = op;
 
-    return ({ op, prev, onDestroy }) => {
-      const { type, input: rawInput, path, id } = op;
-      const input = rt.transformer.serialize(rawInput);
-      let isDone = false;
-      const unsub = client.request(
-        { type, path, input, id },
-        {
-          onNext(result) {
-            if (isDone) {
-              return;
-            }
-            if ('data' in result) {
-              const data = rt.transformer.deserialize(result.data);
-              prev({ type: 'data', data });
-            } else {
-              prev(result);
-            }
-
-            if (op.type !== 'subscription') {
-              // if it isn't a subscription we don't care about next response
+        let isDone = false;
+        const unsub = client.request(
+          { type, path, input, id, context },
+          {
+            error(err) {
               isDone = true;
+              observer.error(err);
               unsub();
-            }
-          },
-          onError(err) {
-            if (isDone) {
-              return;
-            }
-            prev(
-              err instanceof Error
-                ? err
-                : TRPCClientError.from({
-                    ...err,
-                    error: rt.transformer.deserialize(err.error),
-                  }),
-            );
-          },
-          onDone() {
-            if (isDone) {
-              return;
-            }
-            const result = new TRPCSubscriptionEndedError(
-              'Operation ended prematurely',
-            );
+            },
+            complete() {
+              if (!isDone) {
+                isDone = true;
+                observer.error(
+                  TRPCClientError.from(
+                    new TRPCSubscriptionEndedError(
+                      'Operation ended prematurely',
+                    ),
+                  ),
+                );
+              } else {
+                observer.complete();
+              }
+            },
+            next(result) {
+              observer.next(result);
 
-            prev(TRPCClientError.from(result, { isDone: true }));
-            isDone = true;
+              if (op.type !== 'subscription') {
+                // if it isn't a subscription we don't care about next response
+
+                isDone = true;
+                unsub();
+                observer.complete();
+              }
+            },
           },
-        },
-      );
-      onDestroy(() => {
-        isDone = true;
-        unsub();
+        );
+        return () => {
+          isDone = true;
+          unsub();
+        };
       });
     };
   };

package/src/rx.ts

@@ -0,0 +1,50 @@
+import { Observable } from 'rxjs';
+
+export type inferObservableValue<TObservable extends Observable<any>> =
+  TObservable extends Observable<infer TValue> ? TValue : never;
+
+export class ObservableAbortError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'ObservableAbortError';
+    Object.setPrototypeOf(this, ObservableAbortError.prototype);
+  }
+}
+
+/** @internal */
+export function observableToPromise<TValue>(observable: Observable<TValue>) {
+  let abort: () => void;
+  const promise = new Promise<TValue>((resolve, reject) => {
+    let isDone = false;
+    function onDone() {
+      if (isDone) {
+        return;
+      }
+      isDone = true;
+      reject(new ObservableAbortError('This operation was cancelled.'));
+      subscription.unsubscribe();
+    }
+    const subscription = observable.subscribe({
+      next(data) {
+        isDone = true;
+        resolve(data);
+        onDone();
+      },
+      error(data) {
+        isDone = true;
+        reject(data);
+        onDone();
+      },
+      complete() {
+        isDone = true;
+        onDone();
+      },
+    });
+    abort = onDone;
+  });
+  return {
+    promise,
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    abort: abort!,
+  };
+}

package/dist/TRPCClientError-09b8a26b.esm.js

@@ -1,77 +0,0 @@
-import _objectSpread from '@babel/runtime/helpers/esm/objectSpread2';
-import _classCallCheck from '@babel/runtime/helpers/esm/classCallCheck';
-import _createClass from '@babel/runtime/helpers/esm/createClass';
-import _assertThisInitialized from '@babel/runtime/helpers/esm/assertThisInitialized';
-import _inherits from '@babel/runtime/helpers/esm/inherits';
-import _createSuper from '@babel/runtime/helpers/esm/createSuper';
-import _wrapNativeSuper from '@babel/runtime/helpers/esm/wrapNativeSuper';
-
-var TRPCClientError = /*#__PURE__*/function (_Error) {
-  _inherits(TRPCClientError, _Error);
-
-  var _super = /*#__PURE__*/_createSuper(TRPCClientError);
-
-  /**
-   * @deprecated use `cause`
-   */
-
-  /**
-   * Fatal error - expect no more results after this error
-   * Used for when WebSockets disconnect prematurely.
-   */
-  function TRPCClientError(message, opts) {
-    var _opts$cause, _opts$isDone, _opts$result, _opts$result2;
-
-    var _this;
-
-    _classCallCheck(this, TRPCClientError);
-
-    var cause = (_opts$cause = opts.cause) !== null && _opts$cause !== void 0 ? _opts$cause : opts.originalError; // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore https://github.com/tc39/proposal-error-cause
-
-    _this = _super.call(this, message, {
-      cause: cause
-    });
-    _this.originalError = void 0;
-    _this.cause = void 0;
-    _this.shape = void 0;
-    _this.data = void 0;
-    _this.isDone = void 0;
-    _this.isDone = (_opts$isDone = opts.isDone) !== null && _opts$isDone !== void 0 ? _opts$isDone : false;
-    _this.cause = _this.originalError = cause;
-    _this.shape = (_opts$result = opts.result) === null || _opts$result === void 0 ? void 0 : _opts$result.error;
-    _this.data = (_opts$result2 = opts.result) === null || _opts$result2 === void 0 ? void 0 : _opts$result2.error.data;
-    _this.name = 'TRPCClientError';
-    Object.setPrototypeOf(_assertThisInitialized(_this), TRPCClientError.prototype);
-    return _this;
-  }
-
-  _createClass(TRPCClientError, null, [{
-    key: "from",
-    value: function from(result) {
-      var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-
-      if (!(result instanceof Error)) {
-        var _message;
-
-        return new TRPCClientError((_message = result.error.message) !== null && _message !== void 0 ? _message : '', _objectSpread(_objectSpread({}, opts), {}, {
-          cause: null,
-          result: result
-        }));
-      }
-
-      if (result.name === 'TRPCClientError') {
-        return result;
-      }
-
-      return new TRPCClientError(result.message, _objectSpread(_objectSpread({}, opts), {}, {
-        cause: result,
-        result: null
-      }));
-    }
-  }]);
-
-  return TRPCClientError;
-}( /*#__PURE__*/_wrapNativeSuper(Error));
-
-export { TRPCClientError as T };

package/dist/TRPCClientError-bfee2bf5.cjs.dev.js

@@ -1,79 +0,0 @@
-'use strict';
-
-var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
-var _classCallCheck = require('@babel/runtime/helpers/classCallCheck');
-var _createClass = require('@babel/runtime/helpers/createClass');
-var _assertThisInitialized = require('@babel/runtime/helpers/assertThisInitialized');
-var _inherits = require('@babel/runtime/helpers/inherits');
-var _createSuper = require('@babel/runtime/helpers/createSuper');
-var _wrapNativeSuper = require('@babel/runtime/helpers/wrapNativeSuper');
-
-var TRPCClientError = /*#__PURE__*/function (_Error) {
-  _inherits(TRPCClientError, _Error);
-
-  var _super = /*#__PURE__*/_createSuper(TRPCClientError);
-
-  /**
-   * @deprecated use `cause`
-   */
-
-  /**
-   * Fatal error - expect no more results after this error
-   * Used for when WebSockets disconnect prematurely.
-   */
-  function TRPCClientError(message, opts) {
-    var _opts$cause, _opts$isDone, _opts$result, _opts$result2;
-
-    var _this;
-
-    _classCallCheck(this, TRPCClientError);
-
-    var cause = (_opts$cause = opts.cause) !== null && _opts$cause !== void 0 ? _opts$cause : opts.originalError; // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore https://github.com/tc39/proposal-error-cause
-
-    _this = _super.call(this, message, {
-      cause: cause
-    });
-    _this.originalError = void 0;
-    _this.cause = void 0;
-    _this.shape = void 0;
-    _this.data = void 0;
-    _this.isDone = void 0;
-    _this.isDone = (_opts$isDone = opts.isDone) !== null && _opts$isDone !== void 0 ? _opts$isDone : false;
-    _this.cause = _this.originalError = cause;
-    _this.shape = (_opts$result = opts.result) === null || _opts$result === void 0 ? void 0 : _opts$result.error;
-    _this.data = (_opts$result2 = opts.result) === null || _opts$result2 === void 0 ? void 0 : _opts$result2.error.data;
-    _this.name = 'TRPCClientError';
-    Object.setPrototypeOf(_assertThisInitialized(_this), TRPCClientError.prototype);
-    return _this;
-  }
-
-  _createClass(TRPCClientError, null, [{
-    key: "from",
-    value: function from(result) {
-      var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-
-      if (!(result instanceof Error)) {
-        var _message;
-
-        return new TRPCClientError((_message = result.error.message) !== null && _message !== void 0 ? _message : '', _objectSpread(_objectSpread({}, opts), {}, {
-          cause: null,
-          result: result
-        }));
-      }
-
-      if (result.name === 'TRPCClientError') {
-        return result;
-      }
-
-      return new TRPCClientError(result.message, _objectSpread(_objectSpread({}, opts), {}, {
-        cause: result,
-        result: null
-      }));
-    }
-  }]);
-
-  return TRPCClientError;
-}( /*#__PURE__*/_wrapNativeSuper(Error));
-
-exports.TRPCClientError = TRPCClientError;