Replace ApolloErrorProcessor class with processApolloError function

Allows error handling to be configured through an options object instead of by re-implementing the class.

Author: sgarner

src/error/ApolloErrorHandlerResult.ts

@@ -10,36 +10,38 @@ import {
 } from './types';
 
 export interface ApolloErrorHandlerResultInterface {
-  processedErrors: ProcessedApolloError[];
+  allErrors: ProcessedApolloError[];
   validationRuleViolations?: ValidationRuleViolation[];
 }
 
 export class ApolloErrorHandlerResult implements ApolloErrorHandlerResultInterface {
+  public readonly allErrors: ProcessedApolloError[];
+
   public constructor(
-    public readonly processedErrors: ProcessedApolloError[],
+    public readonly unhandledErrors: ProcessedApolloError[],
     public readonly handledErrors: ProcessedApolloError[],
-  ) {}
+  ) {
+    this.allErrors = [...unhandledErrors, ...handledErrors];
+  }
 
   public get networkErrors(): NetworkError[] {
-    return this.processedErrors.filter((e): e is NetworkError => e.type === ApolloErrorType.NETWORK_ERROR);
+    return this.allErrors.filter((e): e is NetworkError => e.type === ApolloErrorType.NETWORK_ERROR);
   }
 
   public get serverErrors(): ServerError[] {
-    return this.processedErrors.filter((e): e is ServerError => e.type === ApolloErrorType.SERVER_ERROR);
+    return this.allErrors.filter((e): e is ServerError => e.type === ApolloErrorType.SERVER_ERROR);
   }
 
   public get unauthorizedErrors(): UnauthorizedError[] {
-    return this.processedErrors.filter((e): e is UnauthorizedError => e.type === ApolloErrorType.UNAUTHORIZED_ERROR);
+    return this.allErrors.filter((e): e is UnauthorizedError => e.type === ApolloErrorType.UNAUTHORIZED_ERROR);
   }
 
   public get userInputErrors(): UserInputError[] {
-    return this.processedErrors.filter((e): e is UserInputError => e.type === ApolloErrorType.BAD_USER_INPUT);
+    return this.allErrors.filter((e): e is UserInputError => e.type === ApolloErrorType.BAD_USER_INPUT);
   }
 
   public get inputValidationErrors(): InputValidationError[] {
-    return this.processedErrors.filter(
-      (e): e is InputValidationError => e.type === ApolloErrorType.INPUT_VALIDATION_ERROR,
-    );
+    return this.allErrors.filter((e): e is InputValidationError => e.type === ApolloErrorType.INPUT_VALIDATION_ERROR);
   }
 
   public get validationRuleViolations(): ValidationRuleViolation[] {

src/error/ApolloErrorProcessor.ts

@@ -1,8 +1,8 @@
-import { ApolloErrorProcessor } from './ApolloErrorProcessor';
+import { processApolloError } from './processApolloError';
 import { ApolloOperationContext } from '../types';
 import { Vue } from 'vue/types/vue';
 import { ApolloError, ApolloOperationErrorHandlerFunction } from './types';
-import { ApolloErrorHandlerResultInterface } from './ApolloErrorHandlerResult';
+import { ApolloErrorHandlerResult, ApolloErrorHandlerResultInterface } from './ApolloErrorHandlerResult';
 
 /**
  * This is a simple example of an error handler function. You can copy this and implement your own in your application.
@@ -12,11 +12,22 @@ export const handleApolloError: ApolloOperationErrorHandlerFunction<ApolloError,
   app: Vue,
   context?: ApolloOperationContext,
 ): ApolloErrorHandlerResultInterface => {
-  const processor = new ApolloErrorProcessor(error, app, context ?? {});
+  const { unhandledErrors, handledErrors } = processApolloError(error, {
+    app,
+    context,
+    // Example of a handler function for a particular type of error:
+    onUnauthorizedError: error => {
+      console.warn('Unauthorized! Logging you out...', error);
+      //logout();
 
-  processor.showErrorNotifications();
+      // Returning true indicates to the processor that we've handled this error
+      return true;
+    },
+  });
 
-  return {
-    processedErrors: processor.processedErrors,
-  };
+  unhandledErrors.forEach(error => {
+    console.error(`${error.type}: ${error.message}`, error.error);
+  });
+
+  return new ApolloErrorHandlerResult(unhandledErrors, handledErrors);
 };

src/error/handleApolloError.ts

@@ -3,6 +3,6 @@
  */
 
 export * from './ApolloErrorHandlerResult';
-export * from './ApolloErrorProcessor';
 export * from './handleApolloError';
+export * from './processApolloError';
 export * from './types';