From 90cec4ec74810e3bbcf0c3c1fbf9781f17611f52 Mon Sep 17 00:00:00 2001
From: MrLoh <flojoto@hotmail.com>
Date: Mon, 28 Sep 2020 13:12:51 -0500
Subject: [PATCH 1/2] use discriminating union for query result type

---
 src/core/queryObserver.ts |  2 +-
 src/core/types.ts         | 76 +++++++++++++++++++++++++++++++--------
 2 files changed, 63 insertions(+), 15 deletions(-)

diff --git a/src/core/queryObserver.ts b/src/core/queryObserver.ts
index 775111521b..b8eeeb26de 100644
--- a/src/core/queryObserver.ts
+++ b/src/core/queryObserver.ts
@@ -274,7 +274,7 @@ export class QueryObserver<TResult, TError> {
       refetch: this.refetch,
       remove: this.remove,
       updatedAt,
-    }
+    } as QueryResult<TResult, TError>
   }
 
   private updateQuery(): void {
diff --git a/src/core/types.ts b/src/core/types.ts
index af7c9879cf..63c6ab8635 100644
--- a/src/core/types.ts
+++ b/src/core/types.ts
@@ -185,44 +185,92 @@ export enum QueryStatus {
   Success = 'success',
 }
 
-export interface QueryResultBase<TResult, TError = unknown> {
+interface QueryResultBaseCommon<TResult> {
   canFetchMore: boolean | undefined
   clear: () => void
-  data: TResult | undefined
-  error: TError | null
   failureCount: number
   fetchMore: (
     fetchMoreVariable?: unknown,
     options?: FetchMoreOptions
   ) => Promise<TResult | undefined>
-  isError: boolean
   isFetched: boolean
   isFetchedAfterMount: boolean
   isFetching: boolean
   isFetchingMore?: IsFetchingMoreValue
-  isIdle: boolean
   isInitialData: boolean
-  isLoading: boolean
   isPreviousData: boolean
   isStale: boolean
-  isSuccess: boolean
   refetch: (options?: RefetchOptions) => Promise<TResult | undefined>
   remove: () => void
-  status: QueryStatus
   updatedAt: number
 }
 
-export interface QueryResult<TResult, TError = unknown>
-  extends QueryResultBase<TResult, TError> {}
+interface QueryResultBaseIdle<TResult> extends QueryResultBaseCommon<TResult> {
+  status: QueryStatus.Idle
+  isIdle: true
+  isLoading: false
+  isSuccess: false
+  isError: false
+  data?: undefined
+  error: null
+}
+
+interface QueryResultBaseLoading<TResult>
+  extends QueryResultBaseCommon<TResult> {
+  status: QueryStatus.Loading
+  isIdle: false
+  isLoading: true
+  isSuccess: false
+  isError: false
+  data?: undefined
+  error: null
+}
+
+interface QueryResultBaseSuccess<TResult>
+  extends QueryResultBaseCommon<TResult> {
+  status: QueryStatus.Success
+  isIdle: false
+  isLoading: false
+  isSuccess: true
+  isError: false
+  data: TResult
+  error: null
+}
+
+interface QueryResultBaseError<TResult, TError = unknown>
+  extends QueryResultBaseCommon<TResult> {
+  status: QueryStatus.Error
+  isIdle: false
+  isLoading: false
+  isSuccess: false
+  isError: true
+  data?: undefined
+  error: TError
+}
 
-export interface PaginatedQueryResult<TResult, TError = unknown>
-  extends QueryResultBase<TResult, TError> {
+export type QueryResultBase<TResult, TError = unknown> =
+  | QueryResultBaseIdle<TResult>
+  | QueryResultBaseLoading<TResult>
+  | QueryResultBaseSuccess<TResult>
+  | QueryResultBaseError<TResult, TError>
+
+export type QueryResult<TResult, TError = unknown> = QueryResultBase<
+  TResult,
+  TError
+>
+
+export type PaginatedQueryResult<TResult, TError = unknown> = QueryResultBase<
+  TResult,
+  TError
+> & {
   resolvedData: TResult | undefined
   latestData: TResult | undefined
 }
 
-export interface InfiniteQueryResult<TResult, TError = unknown>
-  extends QueryResultBase<TResult[], TError> {}
+export type InfiniteQueryResult<TResult, TError = unknown> = QueryResultBase<
+  TResult[],
+  TError
+>
 
 export interface MutateConfig<
   TResult,

From c3c5f15cf68b0fbaeba38ad61341ceb30d97aecc Mon Sep 17 00:00:00 2001
From: MrLoh <flojoto@hotmail.com>
Date: Mon, 28 Sep 2020 19:07:56 -0500
Subject: [PATCH 2/2] use discriminating union for mutation result type

---
 src/core/types.ts        | 50 +++++++++++++++++++++++++++++++++-------
 src/react/useMutation.ts |  5 +---
 2 files changed, 43 insertions(+), 12 deletions(-)

diff --git a/src/core/types.ts b/src/core/types.ts
index 63c6ab8635..e9b93a67db 100644
--- a/src/core/types.ts
+++ b/src/core/types.ts
@@ -327,16 +327,50 @@ export type MutationResultPair<TResult, TError, TVariables, TSnapshot> = [
   MutationResult<TResult, TError>
 ]
 
-export interface MutationResult<TResult, TError = unknown> {
-  status: QueryStatus
-  data: TResult | undefined
-  error: TError | null
-  isIdle: boolean
-  isLoading: boolean
-  isSuccess: boolean
-  isError: boolean
+interface MutationResultCommon {
   reset: () => void
 }
+interface MutationResultIdle extends MutationResultCommon {
+  status: QueryStatus.Idle
+  data?: undefined
+  error?: null
+  isIdle: true
+  isLoading: false
+  isSuccess: false
+  isError: false
+}
+interface MutationResultLoading extends MutationResultCommon {
+  status: QueryStatus.Loading
+  data?: undefined
+  error?: null
+  isIdle: false
+  isLoading: true
+  isSuccess: false
+  isError: false
+}
+interface MutationResultSuccess<TResult> extends MutationResultCommon {
+  status: QueryStatus
+  data: TResult
+  error?: null
+  isIdle: false
+  isLoading: false
+  isSuccess: true
+  isError: false
+}
+interface MutationResultError<TError> extends MutationResultCommon {
+  status: QueryStatus
+  data?: undefined
+  error: TError
+  isIdle: false
+  isLoading: false
+  isSuccess: true
+  isError: false
+}
+export type MutationResult<TResult, TError = unknown> =
+  | MutationResultIdle
+  | MutationResultLoading
+  | MutationResultSuccess<TResult>
+  | MutationResultError<TError>
 
 export interface ReactQueryConfig<TResult = unknown, TError = unknown> {
   queries?: ReactQueryQueriesConfig<TResult, TError>
diff --git a/src/react/useMutation.ts b/src/react/useMutation.ts
index 2d0a313101..734321b819 100644
--- a/src/react/useMutation.ts
+++ b/src/react/useMutation.ts
@@ -199,10 +199,7 @@ export function useMutation<
     dispatch({ type: ActionType.Reset })
   }, [dispatch])
 
-  const result: MutationResult<TResult, TError> = {
-    ...state,
-    reset,
-  }
+  const result = { ...state, reset } as MutationResult<TResult, TError>
 
   return [mutate, result]
 }