@trpc/client 10.0.0-alpha.2 → 10.0.0-alpha.22

package/rx/operators/dist/trpc-client-rx-operators.esm.js

@@ -1,33 +0,0 @@
-export { s as share } from '../../../dist/share-ca585761.esm.js';
-export { t as tap } from '../../../dist/tap-606957cb.esm.js';
-import '@babel/runtime/helpers/createForOfIteratorHelper';
-
-function map(project) {
-  return function (originalObserver) {
-    return {
-      subscribe: function subscribe(observer) {
-        var index = 0;
-        var subscription = originalObserver.subscribe({
-          next: function next(value) {
-            var _observer$next;
-
-            (_observer$next = observer.next) === null || _observer$next === void 0 ? void 0 : _observer$next.call(observer, project(value, index++));
-          },
-          error: function error(_error) {
-            var _observer$error;
-
-            (_observer$error = observer.error) === null || _observer$error === void 0 ? void 0 : _observer$error.call(observer, _error);
-          },
-          complete: function complete() {
-            var _observer$complete;
-
-            (_observer$complete = observer.complete) === null || _observer$complete === void 0 ? void 0 : _observer$complete.call(observer);
-          }
-        });
-        return subscription;
-      }
-    };
-  };
-}
-
-export { map };

package/rx/operators/package.json

@@ -1,4 +0,0 @@
-{
-  "main": "dist/trpc-client-rx-operators.cjs.js",
-  "module": "dist/trpc-client-rx-operators.esm.js"
-}

package/rx/package.json

@@ -1,4 +0,0 @@
-{
-  "main": "dist/trpc-client-rx.cjs.js",
-  "module": "dist/trpc-client-rx.esm.js"
-}

package/src/internals/transformRPCResponse.ts

@@ -1,25 +0,0 @@
-import { TRPCResponse } from '@trpc/server/rpc';
-import { TRPCClientError } from '../TRPCClientError';
-import { LinkRuntime } from '../links/types';
-
-export function transformRPCResponse({
-  envelope,
-  runtime,
-}: {
-  envelope: TRPCResponse;
-  runtime: LinkRuntime;
-}) {
-  if ('error' in envelope) {
-    return TRPCClientError.from({
-      ...envelope,
-      error: runtime.transformer.deserialize(envelope.error),
-    });
-  }
-  if (envelope.result.type === 'data') {
-    return {
-      ...envelope.result,
-      data: runtime.transformer.deserialize(envelope.result.data),
-    };
-  }
-  return envelope.result;
-}

package/src/links/httpUtils.ts

@@ -1,94 +0,0 @@
-import { ProcedureType } from '@trpc/server';
-import { LinkRuntime, PromiseAndCancel } from './types';
-export interface HTTPLinkOptions {
-  url: string;
-}
-
-// https://github.com/trpc/trpc/pull/669
-function arrayToDict(array: unknown[]) {
-  const dict: Record<number, unknown> = {};
-  for (let index = 0; index < array.length; index++) {
-    const element = array[index];
-    dict[index] = element;
-  }
-  return dict;
-}
-const METHOD = {
-  query: 'GET',
-  mutation: 'POST',
-  subscription: 'PATCH',
-} as const;
-
-export interface ResponseShape {
-  json: unknown;
-  meta: {
-    response: Response;
-  };
-}
-export function httpRequest(
-  props: {
-    runtime: LinkRuntime;
-    type: ProcedureType;
-    path: string;
-    url: string;
-  } & ({ inputs: unknown[] } | { input: unknown }),
-): PromiseAndCancel<ResponseShape> {
-  const { type, runtime: rt, path } = props;
-  const ac = rt.AbortController ? new rt.AbortController() : null;
-
-  const input = 'input' in props ? props.input : arrayToDict(props.inputs);
-
-  function getUrl() {
-    let url = props.url + '/' + path;
-    const queryParts: string[] = [];
-    if ('inputs' in props) {
-      queryParts.push('batch=1');
-    }
-    if (type === 'query' && input !== undefined) {
-      queryParts.push(`input=${encodeURIComponent(JSON.stringify(input))}`);
-    }
-    if (queryParts.length) {
-      url += '?' + queryParts.join('&');
-    }
-    return url;
-  }
-  function getBody() {
-    if (type === 'query') {
-      return undefined;
-    }
-    return input !== undefined ? JSON.stringify(input) : undefined;
-  }
-
-  const promise = new Promise<ResponseShape>((resolve, reject) => {
-    const url = getUrl();
-
-    const meta = {} as any as ResponseShape['meta'];
-    Promise.resolve(rt.headers())
-      .then((headers) =>
-        rt.fetch(url, {
-          method: METHOD[type],
-          signal: ac?.signal,
-          body: getBody(),
-          headers: {
-            'content-type': 'application/json',
-            ...headers,
-          },
-        }),
-      )
-      .then((_res) => {
-        meta.response = _res;
-        return _res.json();
-      })
-      .then((json) => {
-        resolve({
-          json,
-          meta,
-        });
-      })
-      .catch(reject);
-  });
-  const cancel = () => {
-    ac?.abort();
-  };
-  return { promise, cancel };
-}

package/src/links/transformerLink.ts

@@ -1,70 +0,0 @@
-import {
-  AnyRouter,
-  ClientDataTransformerOptions,
-  DataTransformer,
-} from '@trpc/server';
-import { observable } from '../rx/observable';
-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 observable((observer) => {
-        const next$ = props.next({ ...props.op, input }).subscribe({
-          next(value) {
-            const transformed = transformOperationResult(value, _transformer);
-            observer.next(transformed);
-          },
-          error: observer.error,
-          complete: observer.complete,
-        });
-        return next$;
-      });
-    };
-  };
-}

package/src/rx/index.ts

@@ -1,2 +0,0 @@
-export * from './observable';
-export * from './types';

package/src/rx/observable.test.ts

@@ -1,83 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-function */
-import { observable } from './observable';
-import { tap } from './operators';
-import { share } from './operators/share';
-
-test('vanilla observable', () => {
-  const obs = observable<number, Error>((observer) => {
-    observer.next(1);
-    observer.complete();
-  });
-
-  const next = jest.fn();
-  const error = jest.fn();
-  const complete = jest.fn();
-  obs.subscribe({
-    next,
-    error,
-    complete,
-  });
-  expect(next.mock.calls).toHaveLength(1);
-  expect(complete.mock.calls).toHaveLength(1);
-  expect(error.mock.calls).toHaveLength(0);
-  expect(next.mock.calls[0][0]).toBe(1);
-});
-
-test('pipe - combine operators', () => {
-  const taps = {
-    next: jest.fn(),
-    complete: jest.fn(),
-    error: jest.fn(),
-  };
-  const obs = observable<number, Error>((observer) => {
-    observer.next(1);
-  }).pipe(
-    // operators:
-    share(),
-    tap(taps),
-  );
-  {
-    const next = jest.fn();
-    const error = jest.fn();
-    const complete = jest.fn();
-    obs.subscribe({
-      next,
-      error,
-      complete,
-    });
-    expect(next.mock.calls).toHaveLength(1);
-    expect(complete.mock.calls).toHaveLength(0);
-    expect(error.mock.calls).toHaveLength(0);
-    expect(next.mock.calls[0][0]).toBe(1);
-  }
-
-  {
-    const next = jest.fn();
-    const error = jest.fn();
-    const complete = jest.fn();
-    obs.subscribe({
-      next,
-      error,
-      complete,
-    });
-    expect(next.mock.calls).toHaveLength(0);
-    expect(complete.mock.calls).toHaveLength(0);
-    expect(error.mock.calls).toHaveLength(0);
-  }
-
-  expect({
-    next: taps.next.mock.calls,
-    error: taps.error.mock.calls,
-    complete: taps.complete.mock.calls,
-  }).toMatchInlineSnapshot(`
-    Object {
-      "complete": Array [],
-      "error": Array [],
-      "next": Array [
-        Array [
-          1,
-        ],
-      ],
-    }
-  `);
-});

package/src/rx/observable.ts

@@ -1,70 +0,0 @@
-import { pipeFromArray } from './util/pipe';
-import { Observable, Observer, OperatorFunction, TeardownLogic } from './types';
-
-export type inferObservableValue<TObservable extends Observable<any, any>> =
-  TObservable extends Observable<infer TValue, any> ? TValue : never;
-
-export function observable<TValue, TError = unknown>(
-  subscribe: (observer: Observer<TValue, TError>) => TeardownLogic,
-): Observable<TValue, TError> {
-  const self: Observable<TValue, TError> = {
-    subscribe(observer) {
-      let teardownRef: TeardownLogic | null = null;
-      let isDone = false;
-      let unsubscribed = false;
-      let teardownImmediately = false;
-      function unsubscribe() {
-        if (teardownRef === null) {
-          teardownImmediately = true;
-          return;
-        }
-        if (unsubscribed) {
-          return;
-        }
-        unsubscribed = true;
-
-        if (typeof teardownRef === 'function') {
-          teardownRef();
-        } else if (teardownRef) {
-          teardownRef.unsubscribe();
-        }
-      }
-      teardownRef = subscribe({
-        next(value) {
-          if (isDone) {
-            return;
-          }
-          observer.next?.(value);
-        },
-        error(err) {
-          if (isDone) {
-            return;
-          }
-          isDone = true;
-          observer.error?.(err);
-          unsubscribe();
-        },
-        complete() {
-          if (isDone) {
-            return;
-          }
-          isDone = true;
-          observer.complete?.();
-          unsubscribe();
-        },
-      });
-      if (teardownImmediately) {
-        unsubscribe();
-      }
-      return {
-        unsubscribe,
-      };
-    },
-    pipe(
-      ...operations: OperatorFunction<any, any, any, any>[]
-    ): Observable<any, any> {
-      return pipeFromArray(operations)(self) as any;
-    },
-  };
-  return self;
-}

package/src/rx/operators/index.ts

@@ -1,3 +0,0 @@
-export * from './share';
-export * from './map';
-export * from './tap';

package/src/rx/operators/map.test.ts

@@ -1,92 +0,0 @@
-import { expectTypeOf } from 'expect-type';
-import { observable } from '../observable';
-import { map } from '.';
-import { EventEmitter } from 'events';
-
-interface SubscriptionEvents<TOutput> {
-  data: (data: TOutput) => void;
-}
-
-declare interface CustomEventEmitter<TOutput> {
-  on<U extends keyof SubscriptionEvents<TOutput>>(
-    event: U,
-    listener: SubscriptionEvents<TOutput>[U],
-  ): this;
-
-  once<U extends keyof SubscriptionEvents<TOutput>>(
-    event: U,
-    listener: SubscriptionEvents<TOutput>[U],
-  ): this;
-
-  emit<U extends keyof SubscriptionEvents<TOutput>>(
-    event: U,
-    ...args: Parameters<SubscriptionEvents<TOutput>[U]>
-  ): boolean;
-}
-class CustomEventEmitter<TOutput>
-  extends EventEmitter
-  implements CustomEventEmitter<TOutput> {}
-test('map', () => {
-  type EventShape = { num: number };
-  const ee = new CustomEventEmitter<EventShape>();
-  const eventObservable = observable<EventShape, unknown>((observer) => {
-    const callback = (data: EventShape) => {
-      observer.next(data);
-    };
-    ee.on('data', callback);
-
-    return () => {
-      ee.off('data', callback);
-    };
-  });
-  const pipeCalls = jest.fn();
-  const piped = eventObservable.pipe(
-    map((...args) => {
-      pipeCalls(...args);
-      const [value] = args;
-      return value.num;
-    }),
-  );
-
-  const next = jest.fn();
-  const subscription = piped.subscribe({
-    next(value) {
-      expectTypeOf<number>(value);
-      next(value);
-    },
-  });
-  expect(next).not.toHaveBeenCalled();
-  ee.emit('data', { num: 1 });
-  ee.emit('data', { num: 2 });
-  expect(next).toHaveBeenCalledTimes(2);
-  expect(next.mock.calls).toMatchInlineSnapshot(`
-    Array [
-      Array [
-        1,
-      ],
-      Array [
-        2,
-      ],
-    ]
-  `);
-  expect(pipeCalls.mock.calls).toMatchInlineSnapshot(`
-    Array [
-      Array [
-        Object {
-          "num": 1,
-        },
-        0,
-      ],
-      Array [
-        Object {
-          "num": 2,
-        },
-        1,
-      ],
-    ]
-  `);
-
-  expect(ee.listeners('data')).toHaveLength(1);
-  subscription.unsubscribe();
-  expect(ee.listeners('data')).toHaveLength(0);
-});

package/src/rx/operators/map.ts

@@ -1,25 +0,0 @@
-import { OperatorFunction } from '../types';
-
-export function map<TValueBefore, TError, TValueAfter>(
-  project: (value: TValueBefore, index: number) => TValueAfter,
-): OperatorFunction<TValueBefore, TError, TValueAfter, TError> {
-  return (originalObserver) => {
-    return {
-      subscribe(observer) {
-        let index = 0;
-        const subscription = originalObserver.subscribe({
-          next(value) {
-            observer.next?.(project(value, index++));
-          },
-          error(error) {
-            observer.error?.(error);
-          },
-          complete() {
-            observer.complete?.();
-          },
-        });
-        return subscription;
-      },
-    };
-  };
-}

package/src/rx/operators/share.test.ts

@@ -1,60 +0,0 @@
-/* eslint-disable no-var */
-import { observable } from '../observable';
-import { share } from './share';
-
-test('share', () => {
-  const obs = share()(
-    observable<number, Error>((observer) => {
-      observer.next(1);
-    }),
-  );
-
-  {
-    const next = jest.fn();
-    const error = jest.fn();
-    const complete = jest.fn();
-    var subscription1 = obs.subscribe({
-      next,
-      error,
-      complete,
-    });
-    expect(next.mock.calls).toHaveLength(1);
-    expect(complete.mock.calls).toHaveLength(0);
-    expect(error.mock.calls).toHaveLength(0);
-    expect(next.mock.calls[0][0]).toBe(1);
-  }
-
-  {
-    // subscribe again - it's shared so should not propagate any results
-    const next = jest.fn();
-    const error = jest.fn();
-    const complete = jest.fn();
-    var subscription2 = obs.subscribe({
-      next,
-      error,
-      complete,
-    });
-    expect(next.mock.calls).toHaveLength(0);
-    expect(complete.mock.calls).toHaveLength(0);
-    expect(error.mock.calls).toHaveLength(0);
-  }
-
-  subscription1.unsubscribe();
-  subscription2.unsubscribe();
-  // now it should be reset so we can do a new subscription
-  {
-    const next = jest.fn();
-    const error = jest.fn();
-    const complete = jest.fn();
-    var subscription3 = obs.subscribe({
-      next,
-      error,
-      complete,
-    });
-    expect(next.mock.calls).toHaveLength(1);
-    expect(complete.mock.calls).toHaveLength(0);
-    expect(error.mock.calls).toHaveLength(0);
-    expect(next.mock.calls[0][0]).toBe(1);
-    subscription3.unsubscribe();
-  }
-});

package/src/rx/operators/share.ts

@@ -1,67 +0,0 @@
-import { MonoTypeOperatorFunction, Observer, Unsubscribable } from '../types';
-
-/* eslint-disable @typescript-eslint/no-empty-interface */
-interface ShareConfig {}
-export function share<TValue, TError>(
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  _opts?: ShareConfig,
-): MonoTypeOperatorFunction<TValue, TError> {
-  return (originalObserver) => {
-    let refCount = 0;
-
-    let subscription: Unsubscribable | null = null;
-    const observers: Partial<Observer<TValue, TError>>[] = [];
-
-    function startIfNeeded() {
-      if (subscription) {
-        return;
-      }
-      subscription = originalObserver.subscribe({
-        next(value) {
-          for (const observer of observers) {
-            observer.next?.(value);
-          }
-        },
-        error(error) {
-          for (const observer of observers) {
-            observer.error?.(error);
-          }
-        },
-        complete() {
-          for (const observer of observers) {
-            observer.complete?.();
-          }
-        },
-      });
-    }
-    function resetIfNeeded() {
-      // "resetOnRefCountZero"
-      if (refCount === 0 && subscription) {
-        const _sub = subscription;
-        subscription = null;
-        _sub.unsubscribe();
-      }
-    }
-
-    return {
-      subscribe(observer) {
-        refCount++;
-
-        observers.push(observer);
-        startIfNeeded();
-        return {
-          unsubscribe() {
-            refCount--;
-            resetIfNeeded();
-
-            const index = observers.findIndex((v) => v === observer);
-
-            if (index > -1) {
-              observers.splice(index, 1);
-            }
-          },
-        };
-      },
-    };
-  };
-}

package/src/rx/operators/tap.ts

@@ -1,26 +0,0 @@
-import { MonoTypeOperatorFunction, Observer } from '../types';
-
-export function tap<TValue, TError>(
-  observer: Partial<Observer<TValue, TError>>,
-): MonoTypeOperatorFunction<TValue, TError> {
-  return (originalObserver) => {
-    return {
-      subscribe(observer2) {
-        return originalObserver.subscribe({
-          next(v) {
-            observer.next?.(v);
-            observer2.next?.(v);
-          },
-          error(v) {
-            observer.error?.(v);
-            observer2.error?.(v);
-          },
-          complete() {
-            observer.complete?.();
-            observer2.complete?.();
-          },
-        });
-      },
-    };
-  };
-}