Flatten errors and use an error interface

Author: RobertLowe

src/resolvers/createOne.ts

@@ -1,6 +1,6 @@
 import type { Resolver, ObjectTypeComposer } from 'graphql-compose';
 import type { Model, Document } from 'mongoose';
-import { getOrCreateErrorPayload } from '../utils/getOrCreateErrorPayload';
+import { getOrCreateErrorInterface } from '../utils/getOrCreateErrorInterface';
 import { recordHelperArgs } from './helpers';
 import type { ExtendedResolveParams, GenResolverOpts } from './index';
 
@@ -30,7 +30,7 @@ export default function createOne<TSource = Document, TContext = any>(
     }
   }
 
-  getOrCreateErrorPayload(tc);
+  getOrCreateErrorInterface(tc);
 
   const outputTypeName = `CreateOne${tc.getTypeName()}Payload`;
   const outputType = tc.schemaComposer.getOrCreateOTC(outputTypeName, (t) => {
@@ -44,8 +44,8 @@ export default function createOne<TSource = Document, TContext = any>(
         description: 'Created document',
       },
       errors: {
-        type: '[ErrorPayload]',
-        description: 'Errors that may occur, typically validations',
+        type: '[ErrorInterface]',
+        description: 'Errors that may occur',
       },
     });
   });
@@ -81,16 +81,15 @@ export default function createOne<TSource = Document, TContext = any>(
       }
 
       const validationErrors = doc.validateSync();
-      let errors: {
+      const errors: {
         path: string;
-        messages: string[];
-      }[];
+        message: string;
+      }[] = [];
       if (validationErrors && validationErrors.errors) {
-        errors = [];
         Object.keys(validationErrors.errors).forEach((key) => {
           errors.push({
             path: key,
-            messages: [validationErrors.errors[key].message],
+            message: validationErrors.errors[key].message,
           });
         });
         return {

src/resolvers/updateById.ts

@@ -1,6 +1,6 @@
 import type { Resolver, ObjectTypeComposer } from 'graphql-compose';
 import type { Model, Document } from 'mongoose';
-import { getOrCreateErrorPayload } from '../utils/getOrCreateErrorPayload';
+import { getOrCreateErrorInterface } from '../utils/getOrCreateErrorInterface';
 import { recordHelperArgs } from './helpers/record';
 import findById from './findById';
 
@@ -21,9 +21,9 @@ export default function updateById<TSource = Document, TContext = any>(
     );
   }
 
-  const findByIdResolver = findById(model, tc);
+  getOrCreateErrorInterface(tc);
 
-  getOrCreateErrorPayload(tc);
+  const findByIdResolver = findById(model, tc);
 
   const outputTypeName = `UpdateById${tc.getTypeName()}Payload`;
   const outputType = tc.schemaComposer.getOrCreateOTC(outputTypeName, (t) => {
@@ -37,8 +37,8 @@ export default function updateById<TSource = Document, TContext = any>(
         description: 'Updated document',
       },
       errors: {
-        type: '[ErrorPayload]',
-        description: 'Errors that may occur, typically validations',
+        type: '[ErrorInterface]',
+        description: 'Errors that may occur',
       },
     });
   });

src/resolvers/updateOne.ts

@@ -1,7 +1,7 @@
 import type { Resolver, ObjectTypeComposer } from 'graphql-compose';
 import type { Model, Document } from 'mongoose';
 import type { ExtendedResolveParams, GenResolverOpts } from './index';
-import { getOrCreateErrorPayload } from '../utils/getOrCreateErrorPayload';
+import { getOrCreateErrorInterface } from '../utils/getOrCreateErrorInterface';
 import { skipHelperArgs, recordHelperArgs, filterHelperArgs, sortHelperArgs } from './helpers';
 import findOne from './findOne';
 
@@ -21,7 +21,7 @@ export default function updateOne<TSource = Document, TContext = any>(
 
   const findOneResolver = findOne(model, tc, opts);
 
-  getOrCreateErrorPayload(tc);
+  getOrCreateErrorInterface(tc);
 
   const outputTypeName = `UpdateOne${tc.getTypeName()}Payload`;
   const outputType = tc.schemaComposer.getOrCreateOTC(outputTypeName, (t) => {
@@ -35,8 +35,8 @@ export default function updateOne<TSource = Document, TContext = any>(
         description: 'Updated document',
       },
       errors: {
-        type: '[ErrorPayload]',
-        description: 'Errors that may occur, typically validations',
+        type: '[ErrorInterface]',
+        description: 'Errors that may occur',
       },
     });
   });

src/utils/getOrCreateErrorInterface.ts

@@ -0,0 +1,78 @@
+import type { ObjectTypeComposer, InterfaceTypeComposer } from 'graphql-compose';
+
+export function getOrCreateErrorInterface(tc: ObjectTypeComposer): InterfaceTypeComposer {
+  const errorInterface: InterfaceTypeComposer = tc.schemaComposer.getOrCreateIFTC(
+    'ErrorInterface',
+    (iftc: InterfaceTypeComposer) => {
+      iftc.addFields({
+        message: {
+          description: 'Generic error message',
+          type: 'String',
+        },
+      });
+    }
+  );
+
+  const validationErrorOTC: ObjectTypeComposer = tc.schemaComposer.getOrCreateOTC(
+    'ValidationError',
+    (otc: ObjectTypeComposer) => {
+      otc.addFields({
+        message: {
+          description: 'Validation error message',
+          type: 'String',
+        },
+        path: {
+          description: 'Source of the validation error from the model path',
+          type: 'String',
+        },
+      });
+      otc.addInterface(errorInterface);
+    }
+  );
+  tc.schemaComposer.addSchemaMustHaveType(validationErrorOTC);
+
+  const runtimeErrorOTC: ObjectTypeComposer = tc.schemaComposer.getOrCreateOTC(
+    'RuntimeError',
+    (otc: ObjectTypeComposer) => {
+      otc.addFields({
+        message: {
+          description: 'Runtime error message',
+          type: 'String',
+        },
+      });
+      otc.addInterface(errorInterface);
+    }
+  );
+  tc.schemaComposer.addSchemaMustHaveType(runtimeErrorOTC);
+
+  const mongoErrorOTC: ObjectTypeComposer = tc.schemaComposer.getOrCreateOTC(
+    'MongoError',
+    (otc: ObjectTypeComposer) => {
+      otc.addFields({
+        message: {
+          description: 'MongoDB error message',
+          type: 'String',
+        },
+        code: {
+          description: 'MongoDB error code',
+          type: 'String',
+        },
+      });
+      otc.addInterface(errorInterface);
+    }
+  );
+  tc.schemaComposer.addSchemaMustHaveType(mongoErrorOTC);
+
+  const resolveType = (value: any) => {
+    if (value) {
+      if (value.path) return 'ValidationError';
+      else if (value.code) return 'MongoError';
+      else return 'RuntimeError';
+    }
+    return null;
+  };
+
+  errorInterface.setResolveType(resolveType);
+
+  return errorInterface;
+}