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

package/src/observable/observable.ts

@@ -0,0 +1,78 @@
+import { pipeFromArray } from './internals/pipe';
+import { Observable, Observer, OperatorFunction, TeardownLogic } from './types';
+
+export type inferObservableValue<TObservable> = 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
+>;

package/src/rpc/codes.ts

@@ -1,4 +1,4 @@
-import { invert } from '../internals/invert';
+import { invert } from './internals/invert';
 
 // reference: https://www.jsonrpc.org/specification
 
@@ -28,6 +28,7 @@ export const TRPC_ERROR_CODES_BY_KEY = {
   NOT_FOUND: -32004, // 404
   METHOD_NOT_SUPPORTED: -32005, // 405
   TIMEOUT: -32008, // 408
+  CONFLICT: -32009, // 409
   PRECONDITION_FAILED: -32012, // 412
   PAYLOAD_TOO_LARGE: -32013, // 413
   CLIENT_CLOSED_REQUEST: -32099, // 499

package/src/rpc/envelopes.ts

@@ -1,31 +1,10 @@
-import { ProcedureType } from '../router';
+/* eslint-disable @typescript-eslint/no-namespace */
+import { ProcedureType } from '../deprecated/router';
 import { TRPC_ERROR_CODE_NUMBER } from './codes';
 
-type JSONRPC2RequestId = number | string | null;
-
 /**
- * All requests/responses extends this shape
+ * Error response
  */
-interface JSONRPC2BaseEnvelope {
-  id: JSONRPC2RequestId;
-  jsonrpc?: '2.0';
-}
-
-interface JSONRPC2BaseRequest<TMethod extends string = string>
-  extends JSONRPC2BaseEnvelope {
-  method: TMethod;
-}
-interface JSONRPC2Request<TMethod extends string = string, TParams = unknown>
-  extends JSONRPC2BaseRequest<TMethod> {
-  params: TParams;
-}
-
-interface JSONRPC2ResultResponse<TResult = unknown>
-  extends JSONRPC2BaseEnvelope {
-  result: TResult;
-}
-
-// inner types
 export interface TRPCErrorShape<
   TCode extends number = TRPC_ERROR_CODE_NUMBER,
   TData extends Record<string, unknown> = Record<string, unknown>,
@@ -36,74 +15,114 @@ export interface TRPCErrorShape<
 }
 
 /**
- * The result data wrapped
+ * JSON-RPC 2.0 Specification
  */
-export type TRPCResult<TData = unknown> =
-  | {
-      type: 'data';
-      data: TData;
-    }
-  | {
-      type: 'started';
-    }
-  | {
-      type: 'stopped';
-    };
+export namespace JSONRPC2 {
+  export type RequestId = number | string | null;
+
+  /**
+   * All requests/responses extends this shape
+   */
+  export interface BaseEnvelope {
+    id?: RequestId;
+    jsonrpc?: '2.0';
+  }
+
+  export interface BaseRequest<TMethod extends string = string>
+    extends BaseEnvelope {
+    method: TMethod;
+  }
+
+  export interface Request<TMethod extends string = string, TParams = unknown>
+    extends BaseRequest<TMethod> {
+    params: TParams;
+  }
+
+  export interface ResultResponse<TResult = unknown> extends BaseEnvelope {
+    result: TResult;
+  }
+
+  export interface ErrorResponse<TError extends TRPCErrorShape = TRPCErrorShape>
+    extends BaseEnvelope {
+    error: TError;
+  }
+}
 
 /**
- * Request envelope
+ * TRPC HTTP Envelopes
  */
-export type TRPCRequest =
-  | JSONRPC2Request<'subscription.stop'>
-  | JSONRPC2Request<
-      ProcedureType,
-      {
-        path: string;
-        input: unknown;
-      }
-    >;
+
+export type TRPCRequest = JSONRPC2.Request<
+  ProcedureType,
+  { path: string; input: unknown }
+>;
+
+export type TRPCResult<TData = unknown> = { data: TData };
+
+export type TRPCErrorResponse<TError extends TRPCErrorShape = TRPCErrorShape> =
+  JSONRPC2.ErrorResponse<TError>;
+
+export type TRPCResponse<
+  TResult = unknown,
+  TError extends TRPCErrorShape = TRPCErrorShape,
+> = JSONRPC2.ResultResponse<TRPCResult<TResult>> | TRPCErrorResponse<TError>;
 
 /**
- * OK response
+ * HTTP WS Envelopes
  */
-export type TRPCResultResponse<TData = unknown> = JSONRPC2ResultResponse<
-  TRPCResult<TData>
->;
+
+export type TRPCRequestMessage = {
+  id: JSONRPC2.RequestId;
+} & TRPCRequest;
 
 /**
- * Generic response wrapper that is either a result or error
+ * The client asked the server to unsubscribe
  */
-export type TRPCResponse<
-  TData = unknown,
-  TError extends TRPCErrorShape = TRPCErrorShape,
-> = TRPCResultResponse<TData> | TRPCErrorResponse<TError>;
+export type TRPCSubscriptionStopNotification = {
+  id: null;
+} & JSONRPC2.BaseRequest<'subscription.stop'>;
 
 /**
- * Error response
+ * The client's outgoing request types
  */
-export interface TRPCErrorResponse<
+export type TRPCClientOutgoingRequest = TRPCSubscriptionStopNotification;
+
+/**
+ * The client's sent messages shape
+ */
+export type TRPCClientOutgoingMessage =
+  | TRPCRequestMessage
+  | ({ id: JSONRPC2.RequestId } & JSONRPC2.BaseRequest<'subscription.stop'>);
+
+export type TRPCResultMessage<TData = unknown> =
+  | ({ type: 'data' } & TRPCResult<TData>)
+  | { type: 'started' }
+  | { type: 'stopped' };
+
+export type TRPCResponseMessage<
+  TResult = unknown,
   TError extends TRPCErrorShape = TRPCErrorShape,
-> extends JSONRPC2BaseEnvelope {
-  error: TError;
-}
+> = { id: JSONRPC2.RequestId } & (
+  | JSONRPC2.ResultResponse<TRPCResultMessage<TResult>>
+  | TRPCErrorResponse<TError>
+);
 
 /**
  * The server asked the client to reconnect - useful when restarting/redeploying service
  */
-export interface TRPCReconnectNotification
-  extends JSONRPC2BaseRequest<'reconnect'> {
-  id: null;
-}
+export type TRPCReconnectNotification = {
+  id: JSONRPC2.RequestId;
+} & JSONRPC2.BaseRequest<'reconnect'>;
 
 /**
  * The client's incoming request types
  */
-export type TRPCClientIncomingRequest =
-  TRPCReconnectNotification /* could be extended in future */;
+export type TRPCClientIncomingRequest = TRPCReconnectNotification;
 
 /**
  * The client's received messages shape
  */
-export type TRPCClientIncomingMessage =
-  | TRPCResponse
-  | TRPCClientIncomingRequest;
+export type TRPCClientIncomingMessage<
+  TResult = unknown,
+  TError extends TRPCErrorShape = TRPCErrorShape,
+> = TRPCResponseMessage<TResult, TError> | TRPCClientIncomingRequest;

package/src/rpc/internals/invert.ts

@@ -0,0 +1,27 @@
+/**
+ * @internal
+ */
+type KeyFromValue<V, T extends Record<PropertyKey, PropertyKey>> = {
+  [K in keyof T]: V extends T[K] ? K : never;
+}[keyof T];
+
+/**
+ * @internal
+ */
+type Invert<T extends Record<PropertyKey, PropertyKey>> = {
+  [V in T[keyof T]]: KeyFromValue<V, T>;
+};
+
+/**
+ * @internal
+ */
+export function invert<T extends Record<PropertyKey, PropertyKey>>(
+  obj: T,
+): Invert<T> {
+  const newObj = Object.create(null) as any;
+  for (const key in obj) {
+    const v = obj[key];
+    newObj[v] = key;
+  }
+  return newObj;
+}