Initial work on error payloads

Author: RobertLowe

src/__mocks__/userModel.ts

@@ -110,6 +110,18 @@ const UserSchema = new Schema(
       },
     },
 
+    // for error payloads tests
+    valid: {
+      type: String,
+      required: false,
+      validate: [
+        () => {
+          return false;
+        },
+        'this is a validate message',
+      ],
+    },
+
     // createdAt, created via option `timastamp: true` (see bottom)
     // updatedAt, created via option `timastamp: true` (see bottom)
   },

src/resolvers/__tests__/createOne-test.ts

@@ -89,6 +89,27 @@ describe('createOne() ->', () => {
       expect(result.record.id).toBe(result.recordId);
     });
 
+    it('should return payload.errors', async () => {
+      const result = await createOne(UserModel, UserTC).resolve({
+        args: {
+          record: { valid: 'AlwaysFails' },
+        },
+      });
+      expect(result.errors).toEqual([
+        { messages: ['Path `n` is required.'], path: 'n' },
+        { messages: ['this is a validate message'], path: 'valid' },
+      ]);
+    });
+
+    it('should return empty payload.errors', async () => {
+      const result = await createOne(UserModel, UserTC).resolve({
+        args: {
+          record: { n: 'foo' },
+        },
+      });
+      expect(result.errors).toEqual(null);
+    });
+
     it('should return mongoose document', async () => {
       const result = await createOne(UserModel, UserTC).resolve({
         args: { record: { name: 'NewUser' } },

src/resolvers/__tests__/updateById-test.ts

@@ -98,6 +98,24 @@ describe('updateById() ->', () => {
       expect(result.recordId).toBe(user1.id);
     });
 
+    it('should return empty payload.errors', async () => {
+      const result = await updateById(UserModel, UserTC).resolve({
+        args: {
+          record: { _id: user1.id, name: 'some name' },
+        },
+      });
+      expect(result.errors).toEqual(null);
+    });
+
+    it('should return payload.errors', async () => {
+      const result = await updateById(UserModel, UserTC).resolve({
+        args: {
+          record: { _id: user1.id, name: 'some name', valid: 'AlwaysFails' },
+        },
+      });
+      expect(result.errors).toEqual([{ messages: ['this is a validate message'], path: 'valid' }]);
+    });
+
     it('should change data via args.record in model', async () => {
       const result = await updateById(UserModel, UserTC).resolve({
         args: {

src/resolvers/__tests__/updateOne-test.ts

@@ -125,6 +125,24 @@ describe('updateOne() ->', () => {
       expect(result.record.id).toBe(user1.id);
     });
 
+    it('should return empty payload.errors', async () => {
+      const result = await updateOne(UserModel, UserTC).resolve({
+        args: { filter: { _id: user1.id } },
+      });
+      expect(result.errors).toEqual(null);
+    });
+
+    it('should return payload.errors', async () => {
+      const result = await updateOne(UserModel, UserTC).resolve({
+        args: {
+          filter: { _id: user1.id },
+          record: { valid: 'AlwaysFails' },
+        },
+      });
+
+      expect(result.errors).toEqual([{ messages: ['this is a validate message'], path: 'valid' }]);
+    });
+
     it('should skip records', async () => {
       const result1 = await updateOne(UserModel, UserTC).resolve({
         args: {

src/resolvers/createOne.ts

@@ -1,7 +1,9 @@
 import type { Resolver, ObjectTypeComposer } from 'graphql-compose';
 import type { Model, Document } from 'mongoose';
+import { getOrCreateErrorPayload } from '../utils/getOrCreateErrorPayload';
 import { recordHelperArgs } from './helpers';
 import type { ExtendedResolveParams, GenResolverOpts } from './index';
+import { MongoInstance } from 'mongodb-memory-server';
 
 export default function createOne<TSource = Document, TContext = any>(
   model: Model<any>,
@@ -29,6 +31,8 @@ export default function createOne<TSource = Document, TContext = any>(
     }
   }
 
+  getOrCreateErrorPayload(tc);
+
   const outputTypeName = `CreateOne${tc.getTypeName()}Payload`;
   const outputType = tc.schemaComposer.getOrCreateOTC(outputTypeName, (t) => {
     t.addFields({
@@ -40,6 +44,10 @@ export default function createOne<TSource = Document, TContext = any>(
         type: tc,
         description: 'Created document',
       },
+      errors: {
+        type: '[ErrorPayload]',
+        description: 'Errors that may occur, typically validations',
+      },
     });
   });
 
@@ -71,12 +79,33 @@ export default function createOne<TSource = Document, TContext = any>(
         doc = await resolveParams.beforeRecordMutate(doc, resolveParams);
         if (!doc) return null;
       }
-      await doc.save();
 
-      return {
-        record: doc,
-        recordId: tc.getRecordIdFn()(doc),
-      };
+      const validationErrors = doc.validateSync();
+      let errors: {
+        path: string;
+        messages: string[];
+      }[];
+      if (validationErrors && validationErrors.errors) {
+        errors = [];
+        Object.keys(validationErrors.errors).forEach((key) => {
+          errors.push({
+            path: key,
+            messages: [validationErrors.errors[key].properties.message],
+          });
+        });
+        return {
+          record: null,
+          recordId: null,
+          errors,
+        };
+      } else {
+        await doc.save();
+        return {
+          record: doc,
+          recordId: tc.getRecordIdFn()(doc),
+          errors: null,
+        };
+      }
     }) as any,
   });
 

src/resolvers/updateById.ts

@@ -1,5 +1,6 @@
 import type { Resolver, ObjectTypeComposer } from 'graphql-compose';
 import type { Model, Document } from 'mongoose';
+import { getOrCreateErrorPayload } from '../utils/getOrCreateErrorPayload';
 import { recordHelperArgs } from './helpers/record';
 import findById from './findById';
 
@@ -22,6 +23,8 @@ export default function updateById<TSource = Document, TContext = any>(
 
   const findByIdResolver = findById(model, tc);
 
+  getOrCreateErrorPayload(tc);
+
   const outputTypeName = `UpdateById${tc.getTypeName()}Payload`;
   const outputType = tc.schemaComposer.getOrCreateOTC(outputTypeName, (t) => {
     t.addFields({
@@ -33,6 +36,10 @@ export default function updateById<TSource = Document, TContext = any>(
         type: tc,
         description: 'Updated document',
       },
+      errors: {
+        type: '[ErrorPayload]',
+        description: 'Errors that may occur, typically validations',
+      },
     });
   });
 
@@ -90,12 +97,34 @@ export default function updateById<TSource = Document, TContext = any>(
 
       if (recordData) {
         doc.set(recordData);
+
+        const validationErrors = doc.validateSync();
+        let errors: { 
+          path: string,
+          messages: string[]
+        }[];
+        if (validationErrors && validationErrors.errors) {
+          errors = [];
+          Object.keys(validationErrors.errors).forEach((key) => {
+            errors.push({
+              path: key,
+              messages: [validationErrors.errors[key].properties.message],
+            });
+          });
+          return {
+            record: null,
+            recordId: null,
+            errors,
+          };
+        }
+
         await doc.save();
       }
 
       return {
         record: doc,
         recordId: tc.getRecordIdFn()(doc),
+        errors: null,
       };
     }) as any,
   });

src/resolvers/updateOne.ts

@@ -1,6 +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 { skipHelperArgs, recordHelperArgs, filterHelperArgs, sortHelperArgs } from './helpers';
 import findOne from './findOne';
 
@@ -20,6 +21,8 @@ export default function updateOne<TSource = Document, TContext = any>(
 
   const findOneResolver = findOne(model, tc, opts);
 
+  getOrCreateErrorPayload(tc);
+
   const outputTypeName = `UpdateOne${tc.getTypeName()}Payload`;
   const outputType = tc.schemaComposer.getOrCreateOTC(outputTypeName, (t) => {
     t.addFields({
@@ -31,6 +34,10 @@ export default function updateOne<TSource = Document, TContext = any>(
         type: tc,
         description: 'Updated document',
       },
+      errors: {
+        type: '[ErrorPayload]',
+        description: 'Errors that may occur, typically validations',
+      },
     });
   });
 
@@ -73,7 +80,6 @@ export default function updateOne<TSource = Document, TContext = any>(
           )
         );
       }
-
       // 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.
@@ -87,13 +93,32 @@ export default function updateOne<TSource = Document, TContext = any>(
 
       if (doc && recordData) {
         doc.set(recordData);
+
+        const validationErrors = doc.validateSync();
+        let errors = null;
+        if (validationErrors && validationErrors.errors) {
+          errors = [];
+          Object.keys(validationErrors.errors).forEach((key) => {
+            errors.push({
+              path: key,
+              messages: [validationErrors.errors[key].properties.message],
+            });
+          });
+          return {
+            record: null,
+            recordId: null,
+            errors,
+          };
+        }
+
         await doc.save();
       }
 
       if (doc) {
         return {
           record: doc,
           recordId: tc.getRecordIdFn()(doc),
+          errors: null,
         };
       }
 

src/utils/getOrCreateErrorPayload.ts

@@ -0,0 +1,16 @@
+import type { ObjectTypeComposer } from 'graphql-compose';
+
+export function getOrCreateErrorPayload(tc: ObjectTypeComposer) {
+  return tc.schemaComposer.getOrCreateOTC('ErrorPayload', (t) => {
+    t.addFields({
+      path: {
+        type: 'String',
+        description: 'Source of error, typically a model validation path',
+      },
+      messages: {
+        type: '[String]',
+        description: 'Error messages',
+      },
+    });
+  });
+}