@trpc/server 10.0.0-alpha.21 → 10.0.0-alpha.24

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/router.ts

@@ -15,13 +15,13 @@ import {
   createProcedure,
   inferProcedureFromOptions,
 } from './internals/procedure';
+import { Observable, inferObservableValue } from './observable';
 import {
   TRPCErrorShape,
   TRPC_ERROR_CODES_BY_KEY,
   TRPC_ERROR_CODE_KEY,
   TRPC_ERROR_CODE_NUMBER,
 } from './rpc';
-import { Subscription } from './subscription';
 import { CombinedDataTransformer, DataTransformerOptions } from './transformer';
 import { Prefixer, ThenArg, flatten } from './types';
 
@@ -87,10 +87,8 @@ export type inferProcedureOutput<
 export type inferSubscriptionOutput<
   TRouter extends AnyRouter,
   TPath extends keyof TRouter['_def']['subscriptions'],
-> = ReturnType<
-  inferAsyncReturnType<
-    TRouter['_def']['subscriptions'][TPath]['call']
-  >['output']
+> = inferObservableValue<
+  inferAsyncReturnType<TRouter['_def']['subscriptions'][TPath]['call']>
 >;
 
 function getDataTransformer(
@@ -292,7 +290,7 @@ export class Router<
     TContext,
     unknown,
     unknown,
-    Subscription<unknown>,
+    Observable<unknown, unknown>,
     unknown,
     unknown
   >,
@@ -489,7 +487,7 @@ export class Router<
     TPath extends string,
     TInput,
     TParsedInput,
-    TOutput extends Subscription<unknown>,
+    TOutput extends Observable<unknown, unknown>,
   >(
     path: TPath,
     procedure: Omit<
@@ -520,7 +518,7 @@ export class Router<
   public subscription<
     TPath extends string,
     TInput,
-    TOutput extends Subscription<unknown>,
+    TOutput extends Observable<unknown, unknown>,
   >(
     path: TPath,
     procedure: Omit<
@@ -543,7 +541,7 @@ export class Router<
    */
   public subscription<
     TPath extends string,
-    TOutput extends Subscription<unknown>,
+    TOutput extends Observable<unknown, unknown>,
   >(
     path: TPath,
     procedure: Omit<

package/src/rpc/envelopes.ts

@@ -1,31 +1,10 @@
+/* eslint-disable @typescript-eslint/no-namespace */
 import { ProcedureType } from '../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/subscription.ts

@@ -1,135 +1,17 @@
-import { EventEmitter } from 'events';
 import { getErrorFromUnknown } from './internals/errors';
+import { Observable, Observer, observable } from './observable';
 
-interface SubscriptionEvents<TOutput> {
-  data: (data: TOutput) => void;
-  destroy: () => void;
-  error: (error: Error) => void;
-}
-declare interface SubscriptionEventEmitter<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;
-}
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-class SubscriptionEventEmitter<TOutput> extends EventEmitter {}
-
-type UnsubscribeFn = () => void;
-type EmitFn<TOutput> = (data: TOutput) => void;
-
-export type SubscriptionEmit<TOutput> = {
-  data: EmitFn<TOutput>;
-  error: EmitFn<Error>;
-};
-export type SubscriptionCallback<TOutput> = (
-  emit: SubscriptionEmit<TOutput>,
-) => UnsubscribeFn | Promise<UnsubscribeFn>;
-
-/**
- * @beta
- */
-export class Subscription<TOutput = unknown> {
-  private readonly events: SubscriptionEventEmitter<TOutput>;
-  private callback;
-  private isDestroyed: boolean;
-
-  constructor(callback: SubscriptionCallback<TOutput>) {
-    this.isDestroyed = false;
-    this.events = new SubscriptionEventEmitter<TOutput>();
-    this.callback = callback;
-  }
-
-  public destroy() {
-    if (this.isDestroyed) {
-      return;
-    }
-    // debug('Subscription.destroy()', reason);
-    this.isDestroyed = true;
-    this.events.emit('destroy');
-    this.events.removeAllListeners();
-  }
-
-  public async start() {
-    /* istanbul ignore next */
-    if (this.isDestroyed) {
-      throw new Error('Called start() on a destroyed subscription');
-    }
-    try {
-      const emit: SubscriptionEmit<TOutput> = {
-        error: (err) => this.emitError(err),
-        data: (data) => this.emitOutput(data),
-      };
-      const cancel = await this.callback(emit);
-      if (
-        this.isDestroyed
-        /* istanbul ignore next */
-      ) {
-        cancel();
-      } else {
-        this.events.on('destroy', cancel);
-      }
-    } catch (
-      cause
-      /* istanbul ignore next */
-    ) {
-      this.emitError(getErrorFromUnknown(cause));
-    }
-  }
-
-  /* istanbul ignore next */
-  /**
-   * @deprecated This method is just here to help with `inferSubscriptionOutput` which I can't get working without it
-   */
-  public output(): TOutput {
-    throw new Error('Not in use');
-  }
-
-  /**
-   * Emit data
-   */
-  emitOutput(data: TOutput) {
-    this.events.emit('data', data);
-  }
-  /**
-   * Emit error
-   */
-  emitError(err: Error) {
-    this.events.emit('error', err);
-  }
-
-  on(...args: Parameters<SubscriptionEventEmitter<TOutput>['on']>) {
-    return this.events.on(...args);
-  }
-  off(...args: Parameters<SubscriptionEventEmitter<TOutput>['off']>) {
-    return this.events.off(...args);
-  }
-}
-
-/**
- * @alpha Might be removed
- */
 export function subscriptionPullFactory<TOutput>(opts: {
   /**
    * The interval of how often the function should run
    */
   intervalMs: number;
-  pull(emit: SubscriptionEmit<TOutput>): void | Promise<void>;
-}): Subscription<TOutput> {
+  pull(emit: Observer<TOutput, unknown>): void | Promise<void>;
+}): Observable<TOutput, unknown> {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   let timer: any;
   let stopped = false;
-  async function _pull(emit: SubscriptionEmit<TOutput>) {
+  async function _pull(emit: Observer<TOutput, unknown>) {
     /* istanbul ignore next */
     if (stopped) {
       return;
@@ -146,7 +28,7 @@ export function subscriptionPullFactory<TOutput>(opts: {
     }
   }
 
-  return new Subscription<TOutput>((emit) => {
+  return observable<TOutput>((emit) => {
     _pull(emit).catch((err) => emit.error(getErrorFromUnknown(err)));
     return () => {
       clearTimeout(timer);

package/src/types.ts

@@ -46,3 +46,10 @@ export type ThenArg<T> = T extends PromiseLike<infer U> ? ThenArg<U> : T;
  * @public
  */
 export type Dict<T> = Record<string, T | undefined>;
+
+/**
+ * @internal
+ * Creates a "lower-priority" type inference.
+ * https://github.com/microsoft/TypeScript/issues/14829#issuecomment-322267089
+ */
+export type InferLast<T> = T & { [K in keyof T]: T[K] };

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

@@ -1 +0,0 @@
-{"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/internals/wrapCallSafe.d.ts

@@ -1,16 +0,0 @@
-declare type AsyncFn<T> = () => Promise<T> | T;
-/**
- * Wrap a function in a safe wrapper that never throws
- * Returns a discriminated union
- */
-export declare function wrapCallSafe<T>(fn: AsyncFn<T>): Promise<{
-    ok: true;
-    data: T;
-    error?: undefined;
-} | {
-    ok: false;
-    error: unknown;
-    data?: undefined;
-}>;
-export {};
-//# sourceMappingURL=wrapCallSafe.d.ts.map

package/dist/internals/wrapCallSafe.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"wrapCallSafe.d.ts","sourceRoot":"","sources":["../../src/internals/wrapCallSafe.ts"],"names":[],"mappings":"AAAA,aAAK,OAAO,CAAC,CAAC,IAAI,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AACvC;;;GAGG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;GAanD"}