Deduplicate endpoint type enum

Author: markerikson

packages/toolkit/src/query/core/buildInitiate.ts

@@ -11,6 +11,7 @@ import type { Api, ApiContext } from '../apiTypes'
 import type { BaseQueryError, QueryReturnValue } from '../baseQueryTypes'
 import type { InternalSerializeQueryArgs } from '../defaultSerializeQueryArgs'
 import {
+  ENDPOINT_QUERY,
   isQueryDefinition,
   type EndpointDefinition,
   type EndpointDefinitions,
@@ -393,7 +394,7 @@ You must add the middleware for RTK-Query to function correctly!`,
 
         const commonThunkArgs = {
           ...rest,
-          type: 'query' as const,
+          type: ENDPOINT_QUERY as 'query',
           subscribe,
           forceRefetch: forceRefetch,
           subscriptionOptions,

packages/toolkit/src/query/core/buildMiddleware/windowEventHandling.ts

@@ -6,7 +6,6 @@ import type {
   InternalHandlerBuilder,
   SubMiddlewareApi,
 } from './types'
-import { countObjectKeys } from '../../utils/countObjectKeys'
 
 export const buildWindowEventHandler: InternalHandlerBuilder = ({
   reducerPath,

packages/toolkit/src/query/core/buildSlice.ts

@@ -44,6 +44,7 @@ import type {
 } from './buildThunks'
 import { calculateProvidedByThunk } from './buildThunks'
 import {
+  ENDPOINT_QUERY,
   isInfiniteQueryDefinition,
   type AssertTagTypes,
   type EndpointDefinitions,
@@ -332,8 +333,8 @@ export function buildSlice({
               const { endpointName, arg, value } = entry
               const endpointDefinition = definitions[endpointName]
               const queryDescription: QueryThunkArg = {
-                type: 'query',
-                endpointName: endpointName,
+                type: ENDPOINT_QUERY as 'query',
+                endpointName,
                 originalArgs: entry.arg,
                 queryCacheKey: serializeQueryArgs({
                   queryArgs: arg,

packages/toolkit/src/query/core/buildThunks.ts

@@ -35,6 +35,7 @@ import type {
 } from '../endpointDefinitions'
 import {
   calculateProvidedBy,
+  ENDPOINT_QUERY,
   isInfiniteQueryDefinition,
   isQueryDefinition,
 } from '../endpointDefinitions'
@@ -509,6 +510,8 @@ export function buildThunks<
     const { metaSchema, skipSchemaValidation = globalSkipSchemaValidation } =
       endpointDefinition
 
+    const isQuery = arg.type === ENDPOINT_QUERY
+
     try {
       let transformResponse: TransformCallback = defaultTransformResponse
 
@@ -520,13 +523,11 @@ export function buildThunks<
         extra,
         endpoint: arg.endpointName,
         type: arg.type,
-        forced:
-          arg.type === 'query' ? isForcedQuery(arg, getState()) : undefined,
-        queryCacheKey: arg.type === 'query' ? arg.queryCacheKey : undefined,
+        forced: isQuery ? isForcedQuery(arg, getState()) : undefined,
+        queryCacheKey: isQuery ? arg.queryCacheKey : undefined,
       }
 
-      const forceQueryFn =
-        arg.type === 'query' ? arg[forceQueryFnSymbol] : undefined
+      const forceQueryFn = isQuery ? arg[forceQueryFnSymbol] : undefined
 
       let finalQueryReturnValue: QueryReturnValue
 
@@ -675,10 +676,7 @@ export function buildThunks<
         }
       }
 
-      if (
-        arg.type === 'query' &&
-        'infiniteQueryOptions' in endpointDefinition
-      ) {
+      if (isQuery && 'infiniteQueryOptions' in endpointDefinition) {
         // This is an infinite query endpoint
         const { infiniteQueryOptions } = endpointDefinition
 
@@ -843,7 +841,7 @@ export function buildThunks<
             endpoint: arg.endpointName,
             arg: arg.originalArgs,
             type: arg.type,
-            queryCacheKey: arg.type === 'query' ? arg.queryCacheKey : undefined,
+            queryCacheKey: isQuery ? arg.queryCacheKey : undefined,
           }
           endpointDefinition.onSchemaFailure?.(caughtError, info)
           onSchemaFailure?.(caughtError, info)

packages/toolkit/src/query/createApi.ts

@@ -12,6 +12,9 @@ import type {
 } from './endpointDefinitions'
 import {
   DefinitionType,
+  ENDPOINT_INFINITEQUERY,
+  ENDPOINT_MUTATION,
+  ENDPOINT_QUERY,
   isInfiniteQueryDefinition,
   isQueryDefinition,
 } from './endpointDefinitions'
@@ -439,10 +442,9 @@ export function buildCreateApi<Modules extends [Module<any>, ...Module<any>[]]>(
       inject: Parameters<typeof api.injectEndpoints>[0],
     ) {
       const evaluatedEndpoints = inject.endpoints({
-        query: (x) => ({ ...x, type: DefinitionType.query }) as any,
-        mutation: (x) => ({ ...x, type: DefinitionType.mutation }) as any,
-        infiniteQuery: (x) =>
-          ({ ...x, type: DefinitionType.infinitequery }) as any,
+        query: (x) => ({ ...x, type: ENDPOINT_QUERY }) as any,
+        mutation: (x) => ({ ...x, type: ENDPOINT_MUTATION }) as any,
+        infiniteQuery: (x) => ({ ...x, type: ENDPOINT_INFINITEQUERY }) as any,
       })
 
       for (const [endpointName, definition] of Object.entries(

packages/toolkit/src/query/endpointDefinitions.ts

@@ -488,12 +488,18 @@ export type BaseEndpointDefinition<
     { extraOptions?: BaseQueryExtraOptions<BaseQuery> }
   >
 
+// NOTE As with QueryStatus in `apiState.ts`, don't use this for real comparisons
+// at runtime, use the string constants defined below.
 export enum DefinitionType {
   query = 'query',
   mutation = 'mutation',
   infinitequery = 'infinitequery',
 }
 
+export const ENDPOINT_QUERY = DefinitionType.query
+export const ENDPOINT_MUTATION = DefinitionType.mutation
+export const ENDPOINT_INFINITEQUERY = DefinitionType.infinitequery
+
 type TagDescriptionArray<TagTypes extends string> = ReadonlyArray<
   TagDescription<TagTypes> | undefined | null
 >
@@ -1233,19 +1239,19 @@ export type EndpointDefinitions = Record<
 export function isQueryDefinition(
   e: EndpointDefinition<any, any, any, any, any, any, any>,
 ): e is QueryDefinition<any, any, any, any, any, any> {
-  return e.type === DefinitionType.query
+  return e.type === ENDPOINT_QUERY
 }
 
 export function isMutationDefinition(
   e: EndpointDefinition<any, any, any, any, any, any, any>,
 ): e is MutationDefinition<any, any, any, any, any, any> {
-  return e.type === DefinitionType.mutation
+  return e.type === ENDPOINT_MUTATION
 }
 
 export function isInfiniteQueryDefinition(
   e: EndpointDefinition<any, any, any, any, any, any, any>,
 ): e is InfiniteQueryDefinition<any, any, any, any, any, any, any> {
-  return e.type === DefinitionType.infinitequery
+  return e.type === ENDPOINT_INFINITEQUERY
 }
 
 export function isAnyQueryDefinition(