Updates updateById and updateOne for new error handling

RobertLowe · RobertLowe · commit 33f665906423 · 2020-08-24T00:04:32.000-04:00
diff --git a/src/resolvers/__tests__/updateById-test.ts b/src/resolvers/__tests__/updateById-test.ts
@@ -114,8 +114,23 @@ describe('updateById() ->', () => {
         args: {
           record: { _id: user1.id, name: 'some name', valid: 'AlwaysFails' },
         },
+        projection: {
+          errors: true,
+        },
       });
-      expect(result.errors).toEqual([{ message: 'this is a validate message', path: 'valid' }]);
+      expect(result.errors).toEqual([
+        { message: 'this is a validate message', path: 'valid', value: 'AlwaysFails' },
+      ]);
+    });
+
+    it('should throw GraphQLError if client does not request errors field in payload', async () => {
+      await expect(
+        updateById(UserModel, UserTC).resolve({
+          args: {
+            record: { _id: user1.id, name: 'some name', valid: 'AlwaysFails' },
+          },
+        })
+      ).rejects.toThrowError('User validation failed: valid: this is a validate message');
     });
 
     it('should change data via args.record in model', async () => {
diff --git a/src/resolvers/__tests__/updateOne-test.ts b/src/resolvers/__tests__/updateOne-test.ts
@@ -147,9 +147,24 @@ describe('updateOne() ->', () => {
           filter: { _id: user1.id },
           record: { valid: 'AlwaysFails' },
         },
+        projection: {
+          errors: true,
+        },
       });
+      expect(result.errors).toEqual([
+        { message: 'this is a validate message', path: 'valid', value: 'AlwaysFails' },
+      ]);
+    });
 
-      expect(result.errors).toEqual([{ message: 'this is a validate message', path: 'valid' }]);
+    it('should throw GraphQLError if client does not request errors field in payload', async () => {
+      await expect(
+        updateOne(UserModel, UserTC).resolve({
+          args: {
+            filter: { _id: user1.id },
+            record: { valid: 'AlwaysFails' },
+          },
+        })
+      ).rejects.toThrowError('User validation failed: valid: this is a validate message');
     });
 
     it('should skip records', async () => {
diff --git a/src/resolvers/createOne.ts b/src/resolvers/createOne.ts
@@ -81,7 +81,9 @@ export default function createOne<TSource = Document, TContext = any>(
         if (!doc) return null;
       }
 
-      const validationErrors = doc.validateSync();
+      const validationErrors: any = await new Promise(function (resolve) {
+        doc.validate(null, null, resolve);
+      });
       const errors: {
         path: string;
         message: string;
diff --git a/src/resolvers/updateById.ts b/src/resolvers/updateById.ts
@@ -1,8 +1,9 @@
-import type { Resolver, ObjectTypeComposer } from 'graphql-compose';
+import { Resolver, ObjectTypeComposer, mapEachKey } from 'graphql-compose';
 import type { Model, Document } from 'mongoose';
 import { getOrCreateErrorInterface } from '../utils/getOrCreateErrorInterface';
 import { recordHelperArgs } from './helpers/record';
 import findById from './findById';
+import { GraphQLError } from 'graphql';
 
 import type { ExtendedResolveParams, GenResolverOpts } from './index';
 
@@ -81,6 +82,8 @@ export default function updateById<TSource = Document, TContext = any>(
       resolveParams.args._id = recordData._id;
       delete recordData._id;
 
+      // this feels weird
+      const requestsErrors: any = resolveParams?.projection?.errors;
       // We should get all data for document, cause Mongoose model may have hooks/middlewares
       // which required some fields which not in graphql projection
       // So empty projection returns all fields.
@@ -99,34 +102,60 @@ export default function updateById<TSource = Document, TContext = any>(
       if (recordData) {
         doc.set(recordData);
 
-        const validationErrors = doc.validateSync();
-        let errors: {
+        const validationErrors: any = await new Promise(function (resolve) {
+          doc.validate(null, null, resolve);
+        });
+        const errors: {
           path: string;
           message: string;
-        }[];
+          value: any;
+        }[] = [];
+
         if (validationErrors && validationErrors.errors) {
-          errors = [];
+          if (!requestsErrors) {
+            // if client does not request `errors` field we throw Exception on to level
+            throw new GraphQLError(
+              validationErrors.message,
+              undefined,
+              undefined,
+              undefined,
+              undefined,
+              undefined,
+              {
+                validationErrors: mapEachKey(validationErrors.errors, (e: any) => {
+                  return {
+                    path: e.path,
+                    message: e.message,
+                    value: e.value,
+                  };
+                }),
+              }
+            );
+          }
           Object.keys(validationErrors.errors).forEach((key) => {
+            const { message, value } = validationErrors.errors[key];
             errors.push({
               path: key,
-              message: validationErrors.errors[key].properties.message,
+              message,
+              value,
             });
           });
           return {
             record: null,
             recordId: null,
             errors,
           };
+        } else {
+          await doc.save();
+          return {
+            record: doc,
+            recordId: tc.getRecordIdFn()(doc),
+            errors: null,
+          };
         }
-
-        await doc.save();
       }
 
-      return {
-        record: doc,
-        recordId: tc.getRecordIdFn()(doc),
-        errors: null,
-      };
+      return null;
     }) as any,
   });
 
diff --git a/src/resolvers/updateOne.ts b/src/resolvers/updateOne.ts
@@ -1,9 +1,10 @@
-import type { Resolver, ObjectTypeComposer } from 'graphql-compose';
+import { Resolver, ObjectTypeComposer, mapEachKey } from 'graphql-compose';
 import type { Model, Document } from 'mongoose';
 import type { ExtendedResolveParams, GenResolverOpts } from './index';
 import { getOrCreateErrorInterface } from '../utils/getOrCreateErrorInterface';
 import { skipHelperArgs, recordHelperArgs, filterHelperArgs, sortHelperArgs } from './helpers';
 import findOne from './findOne';
+import { GraphQLError } from 'graphql';
 
 export default function updateOne<TSource = Document, TContext = any>(
   model: Model<any>,
@@ -82,6 +83,9 @@ export default function updateOne<TSource = Document, TContext = any>(
           )
         );
       }
+
+      // this feels weird
+      const requestsErrors: any = resolveParams?.projection?.errors;
       // We should get all data for document, cause Mongoose model may have hooks/middlewares
       // which required some fields which not in graphql projection
       // So empty projection returns all fields.
@@ -93,30 +97,60 @@ export default function updateOne<TSource = Document, TContext = any>(
         doc = await resolveParams.beforeRecordMutate(doc, resolveParams);
       }
 
-      if (doc && recordData) {
+      if (recordData) {
         doc.set(recordData);
 
-        const validationErrors = doc.validateSync();
-        let errors: {
+        const validationErrors: any = await new Promise(function (resolve) {
+          doc.validate(null, null, resolve);
+        });
+        const errors: {
           path: string;
           message: string;
-        }[];
+          value: any;
+        }[] = [];
+
         if (validationErrors && validationErrors.errors) {
-          errors = [];
+          if (!requestsErrors) {
+            // if client does not request `errors` field we throw Exception on to level
+            throw new GraphQLError(
+              validationErrors.message,
+              undefined,
+              undefined,
+              undefined,
+              undefined,
+              undefined,
+              {
+                validationErrors: mapEachKey(validationErrors.errors, (e: any) => {
+                  return {
+                    path: e.path,
+                    message: e.message,
+                    value: e.value,
+                  };
+                }),
+              }
+            );
+          }
           Object.keys(validationErrors.errors).forEach((key) => {
+            const { message, value } = validationErrors.errors[key];
             errors.push({
               path: key,
-              message: validationErrors.errors[key].properties.message,
+              message,
+              value,
             });
           });
           return {
             record: null,
             recordId: null,
             errors,
           };
+        } else {
+          await doc.save();
+          return {
+            record: doc,
+            recordId: tc.getRecordIdFn()(doc),
+            errors: null,
+          };
         }
-
-        await doc.save();
       }
 
       if (doc) {
