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

package/src/observable/observable.test.ts

@@ -0,0 +1,101 @@
+/* eslint-disable @typescript-eslint/no-empty-function */
+import { observable, share, tap } from '.';
+
+test('vanilla observable - complete()', () => {
+  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('vanilla observable - unsubscribe()', () => {
+  const obs$ = observable<number, Error>((observer) => {
+    observer.next(1);
+  });
+
+  const next = jest.fn();
+  const error = jest.fn();
+  const complete = jest.fn();
+  const sub = obs$.subscribe({
+    next,
+    error,
+    complete,
+  });
+  sub.unsubscribe();
+  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);
+});
+
+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/observable/observable.ts

@@ -0,0 +1,75 @@
+import { pipeFromArray } from './internals/pipe';
+import { Observable, Observer, OperatorFunction, TeardownLogic } from './types';
+
+export type inferObservableValue<
+  TObservable extends Observable<unknown, unknown>,
+> = TObservable extends Observable<infer TValue, unknown> ? TValue : never;
+
+export function isObservable(x: unknown): x is Observable<unknown, unknown> {
+  return typeof x === 'object' && x !== null && 'subscribe' in x;
+}
+
+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/observable/operators/index.ts

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

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

@@ -0,0 +1,92 @@
+import { EventEmitter } from 'events';
+import { expectTypeOf } from 'expect-type';
+import { map } from '.';
+import { observable } from '../observable';
+
+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/observable/operators/map.ts

@@ -0,0 +1,25 @@
+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/observable/operators/share.test.ts

@@ -0,0 +1,60 @@
+/* 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/observable/operators/share.ts

@@ -0,0 +1,67 @@
+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/observable/operators/tap.ts

@@ -0,0 +1,26 @@
+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?.();
+          },
+        });
+      },
+    };
+  };
+}

package/src/observable/types.ts

@@ -0,0 +1,69 @@
+export interface Unsubscribable {
+  unsubscribe(): void;
+}
+export type UnsubscribeFn = () => void;
+export interface Subscribable<TValue, TError> {
+  subscribe(observer: Partial<Observer<TValue, TError>>): Unsubscribable;
+}
+export interface Observable<TValue, TError>
+  extends Subscribable<TValue, TError> {
+  pipe(): Observable<TValue, TError>;
+  pipe<V1, E1>(
+    op1: OperatorFunction<TValue, TError, V1, E1>,
+  ): Observable<V1, E1>;
+  pipe<V1, E1, V2, E2>(
+    op1: OperatorFunction<TValue, TError, V1, E1>,
+    op2: OperatorFunction<V1, E1, V2, E2>,
+  ): Observable<V2, E2>;
+  pipe<V1, E1, V2, E2, V3, E3>(
+    op1: OperatorFunction<TValue, TError, V1, E1>,
+    op2: OperatorFunction<V1, E1, V2, E2>,
+    op3: OperatorFunction<V2, E2, V3, E3>,
+  ): Observable<V2, E2>;
+  pipe<V1, E1, V2, E2, V3, E3, V4, E4>(
+    op1: OperatorFunction<TValue, TError, V1, E1>,
+    op2: OperatorFunction<V1, E1, V2, E2>,
+    op3: OperatorFunction<V2, E2, V3, E3>,
+    op4: OperatorFunction<V3, E3, V4, E4>,
+  ): Observable<V2, E2>;
+  pipe<V1, E1, V2, E2, V3, E3, V4, E4, V5, E5>(
+    op1: OperatorFunction<TValue, TError, V1, E1>,
+    op2: OperatorFunction<V1, E1, V2, E2>,
+    op3: OperatorFunction<V2, E2, V3, E3>,
+    op4: OperatorFunction<V3, E3, V4, E4>,
+    op5: OperatorFunction<V4, E4, V5, E5>,
+  ): Observable<V2, E2>;
+}
+export interface SubscriptionLike extends Unsubscribable {
+  unsubscribe(): void;
+  readonly closed: boolean;
+}
+
+export interface Observer<TValue, TError> {
+  next: (value: TValue) => void;
+  error: (err: TError) => void;
+  complete: () => void;
+}
+
+export type TeardownLogic =
+  // | SubscriptionLike
+  Unsubscribable | UnsubscribeFn | void;
+
+export type UnaryFunction<T, R> = (source: T) => R;
+
+export type OperatorFunction<
+  TValueBefore,
+  TErrorBefore,
+  TValueAfter,
+  TErrorAfter,
+> = UnaryFunction<
+  Subscribable<TValueBefore, TErrorBefore>,
+  Subscribable<TValueAfter, TErrorAfter>
+>;
+
+export type MonoTypeOperatorFunction<TValue, TError> = OperatorFunction<
+  TValue,
+  TError,
+  TValue,
+  TError
+>;