@trpc/react-query 11.0.0-alpha-tmp-subscription-connection-state.488 → 11.0.0-alpha-tmp-12-06-react.665

package/src/shared/hooks/types.ts

@@ -1,6 +1,8 @@
 import type {
   DefinedUseQueryResult,
   DehydratedState,
+  FetchInfiniteQueryOptions,
+  FetchQueryOptions,
   InfiniteData,
   InfiniteQueryObserverSuccessResult,
   InitialDataFunction,
@@ -18,9 +20,7 @@ import type {
   UseSuspenseQueryResult,
 } from '@tanstack/react-query';
 import type {
-  ConnectionState,
   CreateTRPCClientOptions,
-  TRPCConnectionStateMessage,
   TRPCRequestOptions,
   TRPCUntypedClient,
 } from '@trpc/client';
@@ -28,7 +28,7 @@ import type {
   AnyRouter,
   DistributiveOmit,
 } from '@trpc/server/unstable-core-do-not-import';
-import type { ReactNode } from 'react';
+import type { JSX, ReactNode } from 'react';
 import type { TRPCContextProps } from '../../internals/context';
 import type { TRPCQueryKey } from '../../internals/getQueryKey';
 
@@ -75,6 +75,13 @@ export interface UseTRPCSuspenseQueryOptions<TOutput, TData, TError>
     >,
     TRPCUseQueryBaseOptions {}
 
+export interface UseTRPCPrefetchQueryOptions<TOutput, TData, TError>
+  extends DistributiveOmit<
+      FetchQueryOptions<TOutput, TError, TData, any>,
+      'queryKey'
+    >,
+    TRPCUseQueryBaseOptions {}
+
 /** @internal **/
 export interface DefinedUseTRPCQueryOptions<
   TOutput,
@@ -114,6 +121,21 @@ export interface UseTRPCInfiniteQueryOptions<TInput, TOutput, TError>
   initialCursor?: ExtractCursorType<TInput>;
 }
 
+export type UseTRPCPrefetchInfiniteQueryOptions<TInput, TOutput, TError> =
+  DistributiveOmit<
+    FetchInfiniteQueryOptions<
+      TOutput,
+      TError,
+      TOutput,
+      any,
+      ExtractCursorType<TInput>
+    >,
+    'queryKey' | 'initialPageParam'
+  > &
+    TRPCUseQueryBaseOptions & {
+      initialCursor?: ExtractCursorType<TInput>;
+    };
+
 export interface UseTRPCSuspenseInfiniteQueryOptions<TInput, TOutput, TError>
   extends DistributiveOmit<
       UseSuspenseInfiniteQueryOptions<
@@ -139,372 +161,69 @@ export interface UseTRPCMutationOptions<
     TRPCUseQueryBaseOptions {}
 
 export interface UseTRPCSubscriptionOptions<TOutput, TError> {
+  /**
+   * @deprecated
+   * use a `skipToken` from `@tanstack/react-query` instead
+   * this will be removed in v12
+   */
   enabled?: boolean;
-  onStarted?: () => void;
   /**
-   * @deprecated use onStateChange instead
+   * Called when the subscription is started
    */
-  onError?: (err: TError) => void;
-  onData: (data: TOutput) => void;
-  onStateChange?: (state: TRPCConnectionStateMessage<TError>) => void;
-}
-
-export interface restartSubscriptionOptionsBase {
+  onStarted?: () => void;
   /**
-   * Cancel the current subscription and re-establish a new one
-   * - Defaults to `true`
-   * - Set to `false` no new subscription will be established if there is already an active subscription
+   * Called when new data is received
    */
-  cancelSubscription?: boolean;
-}
-
-export interface restartSubscriptionOptionsWithLastEventId
-  extends restartSubscriptionOptionsBase {
+  onData?: (data: TOutput) => void;
   /**
-   * Defaults to `true` in case of failure or if the subscription is still active
-   * - When the susbscription has successfully completed, it will be set to `false`
+   * Called when an **unrecoverable error** occurs and the subscription is closed
    */
-  sendLastEventId?: boolean;
+  onError?: (err: TError) => void;
 }
 
-export type restartSubscriptionOptions<TInput> = TInput extends {
-  lastEventId?: string | null;
-} | void
-  ? restartSubscriptionOptionsWithLastEventId
-  : restartSubscriptionOptionsBase;
-
-export type restartSubscriptionFn<TInput> = (
-  options?: restartSubscriptionOptions<TInput>,
-) => void;
-
-export interface TRPCSubscriptionBaseResult<_TInput, TOutput, TError> {
-  /**
-   * The last data received from the subscription
-   */
-  data: TOutput | null;
+export interface TRPCSubscriptionBaseResult<TOutput, TError> {
+  status: 'idle' | 'connecting' | 'pending' | 'error';
+  data: undefined | TOutput;
+  error: null | TError;
   /**
-   * The timestamp for when the connection was last (re-)established
+   * Reset the subscription
    */
-  connectionStartedAt: number;
-  /**
-   * The timestamp for when the connection was initially established
-   */
-  initialConnectionStartedAt: number;
-  /**
-   * The error that caused the subscription to stop
-   * - Defaults to `null`
-   * - Resets to `null` after the subscription is restarted and the connection is re-established
-   */
-  error: TError | null;
-  /**
-   * The timestamp for when the last error was captured
-   */
-  errorUpdatedAt: number;
-  /**
-   * The reason for the reconnection
-   * - Resets to `null` after the subscription is restarted and the connection is re-established
-   */
-  connectionError: TError | null;
-  /**
-   * Reconnection attempts since last successful connection
-   */
-  connectionAttemptCount: number;
-  /**
-   * The timestamp for when the last reconnection error was captured
-   */
-  connectionErrorUpdatedAt: number;
-  /**
-   * Is `true` when the subscription is establishing the initial connection
-   */
-  isStarting: boolean;
-  /**
-   * Is `true` when the subscription has successfully connected at least once
-   */
-  isStarted: boolean;
-  /**
-   * Is `true` if the subscription is (re-)establishing a connection
-   * - Alias for `status === 'connecting'`
-   */
-  isConnecting: boolean;
-  /**
-   * Is `true` when the subscription is connected and listening for data
-   * - Alias for `status === 'pending'`
-   */
-  isPending: boolean;
-  /**
-   * Is `true` if the subscription is re-establishing a connection
-   * - Alias for `status === 'connecting' && isStarted === true`
-   */
-  isReconnecting: boolean;
-  /**
-   * Is `true` if the subscription ended in an error state
-   * - Alias for `status === 'error'`
-   */
-  isError: boolean;
-  /**
-   * The current state of the subscription
-   * - Will be:
-   *  - `'idle'` when the subscription is not enabled
-   *  - `'connecting'` when the subscription is (re-)establishing the connection
-   *  - `'pending'` when the subscription is connected and receiving data
-   *  - `'error'` when the subscription has stopped due to an error
-   */
-  status: ConnectionState;
-  /**
-   * Restart the subscription
-   */
-  // restart: restartSubscriptionFn<TInput>;
+  reset: () => void;
 }
 
-export interface TRPCSubscriptionIdleResult<TInput, TOutput, TError>
-  extends TRPCSubscriptionBaseResult<TInput, TOutput, TError> {
-  data: null;
-  error: null;
-  errorUpdatedAt: 0;
-  connectionError: null;
-  isStarting: false;
-  isStarted: false;
-  isConnecting: false;
-  isPending: false;
-  isReconnecting: false;
-  isError: false;
-  connectionAttemptCount: 0;
-  connectionErrorUpdatedAt: 0;
-  connectionStartedAt: 0;
-  initialConnectionStartedAt: 0;
+export interface TRPCSubscriptionIdleResult<TOutput>
+  extends TRPCSubscriptionBaseResult<TOutput, null> {
   status: 'idle';
+  data: undefined;
+  error: null;
 }
 
-const defaultIdleResult: Omit<
-  TRPCSubscriptionIdleResult<unknown, unknown, unknown>,
-  'restart'
-> = {
-  data: null,
-  connectionStartedAt: 0,
-  initialConnectionStartedAt: 0,
-  error: null,
-  errorUpdatedAt: 0,
-  connectionError: null,
-  connectionAttemptCount: 0,
-  isStarting: false,
-  isStarted: false,
-  isConnecting: false,
-  isPending: false,
-  isReconnecting: false,
-  isError: false,
-  connectionErrorUpdatedAt: 0,
-  status: 'idle',
-};
-
-export const getIdleResult = <
-  TInput,
-  TOutput,
-  TError,
->(): //  restart: restartSubscriptionFn<TInput>,
-TRPCSubscriptionIdleResult<TInput, TOutput, TError> => {
-  return {
-    ...defaultIdleResult,
-    data: null,
-    //    restart,
-  };
-};
-
-export interface TRPCSubscriptionStartingResult<TInput, TOutput, TError>
-  extends TRPCSubscriptionBaseResult<TInput, TOutput, TError> {
-  connectionStartedAt: 0;
-  initialConnectionStartedAt: 0;
-  error: null;
-  data: null;
-  connectionError: TError | null;
-  isStarting: true;
-  isStarted: false;
-  isConnecting: true;
-  isPending: false;
-  isReconnecting: false;
-  isError: false;
+export interface TRPCSubscriptionConnectingResult<TOutput, TError>
+  extends TRPCSubscriptionBaseResult<TOutput, TError> {
   status: 'connecting';
+  data: undefined | TOutput;
+  error: TError | null;
 }
 
-export const getStartingResult = <TInput, TOutput, TError>(
-  // restart: restartSubscriptionFn<TInput>,
-  previous?:
-    | TRPCSubscriptionIdleResult<TInput, TOutput, TError>
-    | TRPCSubscriptionErrorResult<TInput, TOutput, TError>
-    | TRPCSubscriptionStartingResult<TInput, TOutput, TError>,
-  error?: TError | null,
-): TRPCSubscriptionStartingResult<TInput, TOutput, TError> => {
-  const now = Date.now();
-
-  if (previous) {
-    return {
-      ...defaultIdleResult,
-      ...previous,
-      data: null,
-      connectionError: error ?? null,
-      isStarting: true,
-      isConnecting: true,
-      errorUpdatedAt: 0,
-      connectionAttemptCount: previous.connectionAttemptCount + 1,
-      connectionErrorUpdatedAt: error ? now : 0,
-      connectionStartedAt: 0,
-      initialConnectionStartedAt: 0,
-      error: null,
-      isStarted: false,
-      isError: false,
-      status: 'connecting',
-    };
-  }
-
-  return {
-    ...getIdleResult(/*restart*/),
-    connectionError: error ?? null,
-    isStarting: true,
-    isConnecting: true,
-    errorUpdatedAt: 0,
-    connectionAttemptCount: 0,
-    connectionErrorUpdatedAt: error ? now : 0,
-    status: 'connecting',
-  };
-};
-
-export interface TRPCSubscriptionPendingResult<TInput, TOutput, TError>
-  extends TRPCSubscriptionBaseResult<TInput, TOutput, TError> {
-  error: null;
-  connectionError: null;
-  connectionAttemptCount: 0;
-  isStarting: false;
-  isStarted: true;
-  isConnecting: false;
-  isPending: true;
-  isReconnecting: false;
-  isError: false;
+export interface TRPCSubscriptionPendingResult<TOutput>
+  extends TRPCSubscriptionBaseResult<TOutput, undefined> {
   status: 'pending';
-}
-
-export const getPendingResult = <TInput, TOutput, TError>(
-  previous: UseTRPCSubscriptionResult<TInput, TOutput, TError>,
-  data?: TOutput,
-): TRPCSubscriptionPendingResult<TInput, TOutput, TError> => {
-  const time = Date.now();
-
-  if (previous.isStarting) {
-    return {
-      ...previous,
-      error: null,
-      isStarting: false,
-      isStarted: true,
-      isConnecting: false,
-      isReconnecting: false,
-      isPending: true,
-      status: 'pending',
-      connectionStartedAt: time,
-      connectionAttemptCount: 0,
-      connectionError: null,
-      initialConnectionStartedAt: time,
-    };
-  }
-
-  return {
-    ...previous,
-    data: data ?? previous.data,
-    error: null,
-    isError: false,
-    isStarting: false,
-    isStarted: true,
-    isConnecting: false,
-    isReconnecting: false,
-    isPending: true,
-    status: 'pending',
-    connectionStartedAt: time,
-    connectionAttemptCount: 0,
-    connectionError: null,
-  };
-};
-
-export interface TRPCSubscriptionReconnectingResult<TInput, TOutput, TError>
-  extends TRPCSubscriptionBaseResult<TInput, TOutput, TError> {
+  data: TOutput;
   error: null;
-  connectionError: TError;
-  isStarting: false;
-  isStarted: true;
-  isConnecting: true;
-  isPending: false;
-  isReconnecting: true;
-  isError: false;
-  status: 'connecting';
 }
 
-export const getReconnectingResult = <TInput, TOutput, TError>(
-  previous:
-    | TRPCSubscriptionPendingResult<TInput, TOutput, TError>
-    | TRPCSubscriptionReconnectingResult<TInput, TOutput, TError>,
-  error: TError,
-): TRPCSubscriptionReconnectingResult<TInput, TOutput, TError> => {
-  return {
-    ...previous,
-    isStarting: false,
-    isStarted: true,
-    isConnecting: true,
-    isReconnecting: true,
-    isPending: false,
-    status: 'connecting',
-    connectionError: error,
-    connectionAttemptCount: previous.connectionAttemptCount + 1,
-  };
-};
-
-export const getConnectingResult = <TInput, TOutput, TError>(
-  previous: UseTRPCSubscriptionResult<TInput, TOutput, TError>,
-  error: TError | null,
-): TRPCSubscriptionConnectingResult<TInput, TOutput, TError> => {
-  if (previous.isReconnecting || previous.isPending) {
-    if (!error) throw new Error('Reconnecting without error?');
-
-    return getReconnectingResult(previous, error);
-  }
-
-  return getStartingResult(/*previous.restart, */ previous, error);
-};
-
-export interface TRPCSubscriptionErrorResult<TInput, TOutput, TError>
-  extends TRPCSubscriptionBaseResult<TInput, TOutput, TError> {
-  error: TError;
-  isStarting: false;
-  isStarted: true; // Not sure about this one
-  isConnecting: false;
-  isPending: false;
-  isReconnecting: false;
-  isError: true;
+export interface TRPCSubscriptionErrorResult<TOutput, TError>
+  extends TRPCSubscriptionBaseResult<TOutput, TError> {
   status: 'error';
+  data: TOutput | undefined;
+  error: TError;
 }
 
-export const getErrorResult = <TInput, TOutput, TError>(
-  previous: UseTRPCSubscriptionResult<TInput, TOutput, TError>,
-  error: TError,
-): TRPCSubscriptionErrorResult<TInput, TOutput, TError> => {
-  return {
-    ...previous,
-    isStarting: false,
-    isStarted: true,
-    isConnecting: false,
-    isReconnecting: false,
-    isPending: false,
-    isError: true,
-    status: 'error',
-    error,
-    errorUpdatedAt: Date.now(),
-  };
-};
-
-export type TRPCSubscriptionConnectingResult<TInput, TOutput, TError> =
-  | TRPCSubscriptionStartingResult<TInput, TOutput, TError>
-  | TRPCSubscriptionReconnectingResult<TInput, TOutput, TError>;
-
-export type UseTRPCSubscriptionResult<TInput, TOutput, TError> =
-  | TRPCSubscriptionIdleResult<TInput, TOutput, TError>
-  | TRPCSubscriptionPendingResult<TInput, TOutput, TError>
-  | TRPCSubscriptionConnectingResult<TInput, TOutput, TError>
-  | TRPCSubscriptionErrorResult<TInput, TOutput, TError>;
+export type TRPCSubscriptionResult<TOutput, TError> =
+  | TRPCSubscriptionIdleResult<TOutput>
+  | TRPCSubscriptionConnectingResult<TOutput, TError>
+  | TRPCSubscriptionErrorResult<TOutput, TError>
+  | TRPCSubscriptionPendingResult<TOutput>;
 
 export interface TRPCProviderProps<TRouter extends AnyRouter, TSSRContext>
   extends TRPCContextProps<TRouter, TSSRContext> {
@@ -524,11 +243,8 @@ export type CreateClient<TRouter extends AnyRouter> = (
   opts: CreateTRPCClientOptions<TRouter>,
 ) => TRPCUntypedClient<TRouter>;
 
-type coerceAsyncIterableToArray<TValue> = TValue extends AsyncIterable<
-  infer $Inferred
->
-  ? $Inferred[]
-  : TValue;
+export type coerceAsyncIterableToArray<TValue> =
+  TValue extends AsyncIterable<infer $Inferred> ? $Inferred[] : TValue;
 
 /**
  * @internal

package/src/shared/polymorphism/mutationLike.ts

@@ -26,15 +26,17 @@ export type MutationLike<
  */
 export type InferMutationLikeInput<
   TMutationLike extends MutationLike<any, any>,
-> = TMutationLike extends MutationLike<any, infer $Procedure>
-  ? inferProcedureInput<$Procedure>
-  : never;
+> =
+  TMutationLike extends MutationLike<any, infer $Procedure>
+    ? inferProcedureInput<$Procedure>
+    : never;
 
 /**
  * Use to unwrap a MutationLike's data output
  */
 export type InferMutationLikeData<
   TMutationLike extends MutationLike<any, any>,
-> = TMutationLike extends MutationLike<infer TRoot, infer TProcedure>
-  ? inferTransformedProcedureOutput<TRoot, TProcedure>
-  : never;
+> =
+  TMutationLike extends MutationLike<infer TRoot, infer TProcedure>
+    ? inferTransformedProcedureOutput<TRoot, TProcedure>
+    : never;

package/src/shared/polymorphism/queryLike.ts

@@ -37,21 +37,19 @@ export type QueryLike<
 /**
  * Use to unwrap a QueryLike's input
  */
-export type InferQueryLikeInput<TQueryLike> = TQueryLike extends DecoratedQuery<
-  infer $Def
->
-  ? $Def['input']
-  : TQueryLike extends QueryLike<any, infer TProcedure>
-  ? inferProcedureInput<TProcedure>
-  : never;
+export type InferQueryLikeInput<TQueryLike> =
+  TQueryLike extends DecoratedQuery<infer $Def>
+    ? $Def['input']
+    : TQueryLike extends QueryLike<any, infer TProcedure>
+      ? inferProcedureInput<TProcedure>
+      : never;
 
 /**
  * Use to unwrap a QueryLike's data output
  */
-export type InferQueryLikeData<TQueryLike> = TQueryLike extends DecoratedQuery<
-  infer $Def
->
-  ? $Def['output']
-  : TQueryLike extends QueryLike<infer TRoot, infer TProcedure>
-  ? inferTransformedProcedureOutput<TRoot, TProcedure>
-  : never;
+export type InferQueryLikeData<TQueryLike> =
+  TQueryLike extends DecoratedQuery<infer $Def>
+    ? $Def['output']
+    : TQueryLike extends QueryLike<infer TRoot, infer TProcedure>
+      ? inferTransformedProcedureOutput<TRoot, TProcedure>
+      : never;

package/src/shared/polymorphism/routerLike.ts

@@ -23,10 +23,10 @@ export type RouterLikeInner<
     ? $Value extends RouterRecord
       ? RouterLikeInner<TRoot, $Value>
       : $Value extends AnyQueryProcedure
-      ? QueryLike<TRoot, $Value>
-      : $Value extends AnyMutationProcedure
-      ? MutationLike<TRoot, $Value>
-      : never
+        ? QueryLike<TRoot, $Value>
+        : $Value extends AnyMutationProcedure
+          ? MutationLike<TRoot, $Value>
+          : never
     : never;
 };
 

package/src/shared/proxy/useQueriesProxy.ts

@@ -44,8 +44,8 @@ export type UseQueriesProcedureRecord<
     ? $Value extends RouterRecord
       ? UseQueriesProcedureRecord<TRoot, $Value>
       : $Value extends AnyQueryProcedure
-      ? GetQueryOptions<TRoot, $Value>
-      : never
+        ? GetQueryOptions<TRoot, $Value>
+        : never
     : never;
 };
 
@@ -76,8 +76,8 @@ export type UseSuspenseQueriesProcedureRecord<
     ? $Value extends RouterRecord
       ? UseSuspenseQueriesProcedureRecord<TRoot, $Value>
       : $Value extends AnyQueryProcedure
-      ? GetSuspenseQueryOptions<TRoot, $Value>
-      : never
+        ? GetSuspenseQueryOptions<TRoot, $Value>
+        : never
     : never;
 };