refactor: improve createOne resolver which throws an error on top level if client does not requested errors in payload

Author: nodkz

src/__tests__/github_issues/248-test.ts

@@ -0,0 +1,132 @@
+/* eslint-disable no-await-in-loop */
+
+import mongoose from 'mongoose';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { schemaComposer, graphql } from 'graphql-compose';
+import { composeWithMongoose } from '../../index';
+
+let mongoServer: MongoMemoryServer;
+beforeAll(async () => {
+  mongoServer = new MongoMemoryServer();
+  const mongoUri = await mongoServer.getConnectionString();
+  await mongoose.connect(mongoUri, { useNewUrlParser: true, useUnifiedTopology: true });
+  // mongoose.set('debug', true);
+});
+
+afterAll(() => {
+  mongoose.disconnect();
+  mongoServer.stop();
+});
+
+// May require additional time for downloading MongoDB binaries
+jasmine.DEFAULT_TIMEOUT_INTERVAL = 60000;
+
+describe("issue #248 - payloads' errors", () => {
+  const UserSchema = new mongoose.Schema({
+    name: String,
+    someStrangeField: {
+      type: String,
+      validate: [
+        () => {
+          return false;
+        },
+        'this is a validate message',
+      ],
+    },
+  });
+
+  const User = mongoose.model('User', UserSchema);
+  const UserTC = composeWithMongoose(User);
+  schemaComposer.Query.addFields({
+    findMany: UserTC.getResolver('findMany'),
+  });
+  schemaComposer.Mutation.addFields({
+    createOne: UserTC.getResolver('createOne'),
+  });
+  const schema = schemaComposer.buildSchema();
+
+  it('check errors in payload if errors field requested', async () => {
+    const res = await graphql.graphql({
+      schema,
+      source: `
+        mutation { 
+          createOne(record: { name: "John", someStrangeField: "Test" }) { 
+            record { 
+              name
+            }
+            errors {
+              __typename
+              message
+              ... on ValidationError {
+                path
+                value
+              }
+            }
+          }
+        }
+      `,
+    });
+
+    expect(res).toEqual({
+      data: {
+        createOne: {
+          record: null,
+          errors: [
+            {
+              __typename: 'ValidationError',
+              message: 'this is a validate message',
+              path: 'someStrangeField',
+              value: 'Test',
+            },
+          ],
+        },
+      },
+    });
+  });
+
+  it('check errors on top-level if errors field is not requested in payload', async () => {
+    const res = await graphql.graphql({
+      schema,
+      source: `
+        mutation { 
+          createOne(record: { name: "John", someStrangeField: "Test" }) { 
+            record { 
+              name
+            }
+          }
+        }
+      `,
+    });
+
+    (res as any).errors[0] = convertToSimpleObject((res as any).errors[0]);
+
+    expect(res).toEqual({
+      data: {
+        createOne: null,
+      },
+      errors: [
+        expect.objectContaining({
+          message: 'User validation failed: someStrangeField: this is a validate message',
+          extensions: {
+            validationErrors: {
+              someStrangeField: {
+                message: 'this is a validate message',
+                path: 'someStrangeField',
+                value: 'Test',
+              },
+            },
+          },
+          path: ['createOne'],
+        }),
+      ],
+    });
+  });
+});
+
+function convertToSimpleObject(theClass: Error): Record<string, any> {
+  const keys = Object.getOwnPropertyNames(theClass);
+  return keys.reduce((classAsObj, key) => {
+    classAsObj[key] = (theClass as any)[key];
+    return classAsObj;
+  }, {} as Record<string, any>);
+}

src/resolvers/__tests__/createOne-test.ts

@@ -98,13 +98,28 @@ describe('createOne() ->', () => {
         args: {
           record: { valid: 'AlwaysFails', contacts: { email: 'mail' } },
         },
+        projection: {
+          errors: true,
+        },
       });
       expect(result.errors).toEqual([
-        { message: 'Path `n` is required.', path: 'n' },
-        { message: 'this is a validate message', path: 'valid' },
+        { message: 'Path `n` is required.', path: 'n', value: undefined },
+        { 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(
+        createOne(UserModel, UserTC).resolve({
+          args: {
+            record: { valid: 'AlwaysFails', contacts: { email: 'mail' } },
+          },
+        })
+      ).rejects.toThrowError(
+        'User validation failed: n: Path `n` is required., valid: this is a validate message'
+      );
+    });
+
     it('should return empty payload.errors', async () => {
       const result = await createOne(UserModel, UserTC).resolve({
         args: {

src/resolvers/createOne.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';
 import type { ExtendedResolveParams, GenResolverOpts } from './index';
+import { GraphQLError } from 'graphql';
 
 export default function createOne<TSource = Document, TContext = any>(
   model: Model<any>,
@@ -84,12 +85,36 @@ export default function createOne<TSource = Document, TContext = any>(
       const errors: {
         path: string;
         message: string;
+        value: any;
       }[] = [];
+
       if (validationErrors && validationErrors.errors) {
+        if (!resolveParams?.projection?.errors) {
+          // 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].message,
+            message,
+            value,
           });
         });
         return {

src/utils/getOrCreateErrorInterface.ts

@@ -25,6 +25,10 @@ export function getOrCreateErrorInterface(tc: ObjectTypeComposer): InterfaceType
           description: 'Source of the validation error from the model path',
           type: 'String',
         },
+        value: {
+          description: 'Field value which occurs the validation error',
+          type: 'JSON',
+        },
       });
       otc.addInterface(errorInterface);
     }