add api level and endpoint level handlers for schema failures

Author: EskiMojo14

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

@@ -27,6 +27,8 @@ import type {
   QueryArgFrom,
   QueryDefinition,
   ResultTypeFrom,
+  SchemaFailureHandler,
+  SchemaFailureInfo,
 } from '../endpointDefinitions'
 import {
   calculateProvidedBy,
@@ -64,7 +66,7 @@ import {
   isRejectedWithValue,
   SHOULD_AUTOBATCH,
 } from './rtkImports'
-import { parseWithSchema } from '../standardSchema'
+import { parseWithSchema, NamedSchemaError } from '../standardSchema'
 
 export type BuildThunksApiEndpointQuery<
   Definition extends QueryDefinition<any, any, any, any, any>,
@@ -324,6 +326,7 @@ export function buildThunks<
   api,
   assertTagType,
   selectors,
+  onSchemaFailure,
 }: {
   baseQuery: BaseQuery
   reducerPath: ReducerPath
@@ -332,6 +335,7 @@ export function buildThunks<
   api: Api<BaseQuery, Definitions, ReducerPath, any>
   assertTagType: AssertTagTypes
   selectors: AllSelectors
+  onSchemaFailure: SchemaFailureHandler | undefined
 }) {
   type State = RootState<any, string, ReducerPath>
 
@@ -555,7 +559,11 @@ export function buildThunks<
           endpointDefinition
 
         if (argSchema) {
-          finalQueryArg = await parseWithSchema(argSchema, finalQueryArg)
+          finalQueryArg = await parseWithSchema(
+            argSchema,
+            finalQueryArg,
+            'argSchema',
+          )
         }
 
         if (forceQueryFn) {
@@ -614,7 +622,11 @@ export function buildThunks<
         let { data } = result
 
         if (rawResponseSchema) {
-          data = await parseWithSchema(rawResponseSchema, result.data)
+          data = await parseWithSchema(
+            rawResponseSchema,
+            result.data,
+            'rawResponseSchema',
+          )
         }
 
         let transformedResponse = await transformResponse(
@@ -627,6 +639,7 @@ export function buildThunks<
           transformedResponse = await parseWithSchema(
             responseSchema,
             transformedResponse,
+            'responseSchema',
           )
         }
 
@@ -723,6 +736,7 @@ export function buildThunks<
         finalQueryReturnValue.meta = await parseWithSchema(
           metaSchema,
           finalQueryReturnValue.meta,
+          'metaSchema',
         )
       }
 
@@ -735,59 +749,78 @@ export function buildThunks<
         }),
       )
     } catch (error) {
-      let caughtError = error
-      if (caughtError instanceof HandledError) {
-        let transformErrorResponse = getTransformCallbackForEndpoint(
-          endpointDefinition,
-          'transformErrorResponse',
-        )
-        const { rawErrorResponseSchema, errorResponseSchema } =
-          endpointDefinition
+      try {
+        let caughtError = error
+        if (caughtError instanceof HandledError) {
+          let transformErrorResponse = getTransformCallbackForEndpoint(
+            endpointDefinition,
+            'transformErrorResponse',
+          )
+          const { rawErrorResponseSchema, errorResponseSchema } =
+            endpointDefinition
 
-        let { value, meta } = caughtError
+          let { value, meta } = caughtError
 
-        if (rawErrorResponseSchema) {
-          value = await parseWithSchema(rawErrorResponseSchema, value)
-        }
+          if (rawErrorResponseSchema) {
+            value = await parseWithSchema(
+              rawErrorResponseSchema,
+              value,
+              'rawErrorResponseSchema',
+            )
+          }
 
-        if (metaSchema) {
-          meta = await parseWithSchema(metaSchema, meta)
-        }
+          if (metaSchema) {
+            meta = await parseWithSchema(metaSchema, meta, 'metaSchema')
+          }
 
-        try {
-          let transformedErrorResponse = await transformErrorResponse(
-            value,
-            meta,
-            arg.originalArgs,
-          )
-          if (errorResponseSchema) {
-            transformedErrorResponse = await parseWithSchema(
-              errorResponseSchema,
+          try {
+            let transformedErrorResponse = await transformErrorResponse(
+              value,
+              meta,
+              arg.originalArgs,
+            )
+            if (errorResponseSchema) {
+              transformedErrorResponse = await parseWithSchema(
+                errorResponseSchema,
+                transformedErrorResponse,
+                'errorResponseSchema',
+              )
+            }
+
+            return rejectWithValue(
               transformedErrorResponse,
+              addShouldAutoBatch({ baseQueryMeta: meta }),
             )
+          } catch (e) {
+            caughtError = e
           }
-
-          return rejectWithValue(
-            transformedErrorResponse,
-            addShouldAutoBatch({ baseQueryMeta: meta }),
-          )
-        } catch (e) {
-          caughtError = e
         }
-      }
-      if (
-        typeof process !== 'undefined' &&
-        process.env.NODE_ENV !== 'production'
-      ) {
-        console.error(
-          `An unhandled error occurred processing a request for the endpoint "${arg.endpointName}".
+        if (
+          typeof process !== 'undefined' &&
+          process.env.NODE_ENV !== 'production'
+        ) {
+          console.error(
+            `An unhandled error occurred processing a request for the endpoint "${arg.endpointName}".
 In the case of an unhandled error, no tags will be "provided" or "invalidated".`,
-          caughtError,
-        )
-      } else {
-        console.error(caughtError)
+            caughtError,
+          )
+        } else {
+          console.error(caughtError)
+        }
+        throw caughtError
+      } catch (error) {
+        if (error instanceof NamedSchemaError) {
+          const info: SchemaFailureInfo = {
+            endpoint: arg.endpointName,
+            arg: arg.originalArgs,
+            type: arg.type,
+            queryCacheKey: arg.type === 'query' ? arg.queryCacheKey : undefined,
+          }
+          endpointDefinition.onSchemaFailure?.(error, info)
+          onSchemaFailure?.(error, info)
+        }
+        throw error
       }
-      throw caughtError
     }
   }
 

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

@@ -515,6 +515,7 @@ export const coreModule = ({
       refetchOnFocus,
       refetchOnReconnect,
       invalidationBehavior,
+      onSchemaFailure,
     },
     context,
   ) {
@@ -581,6 +582,7 @@ export const coreModule = ({
       serializeQueryArgs,
       assertTagType,
       selectors,
+      onSchemaFailure,
     })
 
     const { reducer, actions: sliceActions } = buildSlice({

packages/toolkit/src/query/createApi.ts

@@ -6,6 +6,7 @@ import { defaultSerializeQueryArgs } from './defaultSerializeQueryArgs'
 import type {
   EndpointBuilder,
   EndpointDefinitions,
+  SchemaFailureHandler,
 } from './endpointDefinitions'
 import {
   DefinitionType,
@@ -212,6 +213,8 @@ export interface CreateApiOptions<
         NoInfer<TagTypes>,
         NoInfer<ReducerPath>
       >
+
+  onSchemaFailure?: SchemaFailureHandler
 }
 
 export type CreateApi<Modules extends ModuleName> = {

packages/toolkit/src/query/endpointDefinitions.ts

@@ -38,10 +38,23 @@ import type {
   UnwrapPromise,
 } from './tsHelpers'
 import { isNotNullish } from './utils'
+import type { NamedSchemaError } from './standardSchema'
 
 const resultType = /* @__PURE__ */ Symbol()
 const baseQuery = /* @__PURE__ */ Symbol()
 
+export interface SchemaFailureInfo {
+  endpoint: string
+  arg: any
+  type: 'query' | 'mutation'
+  queryCacheKey?: string
+}
+
+export type SchemaFailureHandler = (
+  error: NamedSchemaError,
+  info: SchemaFailureInfo,
+) => void
+
 type EndpointDefinitionWithQuery<
   QueryArg,
   BaseQuery extends BaseQueryFn,
@@ -222,6 +235,8 @@ export type BaseEndpointDefinition<
    */
   structuralSharing?: boolean
 
+  onSchemaFailure?: SchemaFailureHandler
+
   /* phantom type */
   [resultType]?: ResultType
   /* phantom type */

packages/toolkit/src/query/standardSchema.ts

@@ -1,12 +1,24 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec'
 import { SchemaError } from '@standard-schema/utils'
 
+export class NamedSchemaError extends SchemaError {
+  constructor(
+    issues: readonly StandardSchemaV1.Issue[],
+    public readonly value: any,
+    public readonly schemaName: string,
+  ) {
+    super(issues)
+  }
+}
+
 export async function parseWithSchema<Schema extends StandardSchemaV1>(
   schema: Schema,
   data: unknown,
+  schemaName: string,
 ): Promise<StandardSchemaV1.InferOutput<Schema>> {
-  let result = schema['~standard'].validate(data)
-  if (result instanceof Promise) result = await result
-  if (result.issues) throw new SchemaError(result.issues)
+  const result = await schema['~standard'].validate(data)
+  if (result.issues) {
+    throw new NamedSchemaError(result.issues, data, schemaName)
+  }
   return result.value
 }