Adds ManyValidationError and other changes

- Refactors some code
- Changes *ValidationError to be of GraphQLError
- Adds validationsForDocument for extracting validations

Author: RobertLowe

src/errors/ManyValidationError.ts

@@ -0,0 +1,34 @@
+import { getValidationErrorOTC } from './ValidationError';
+import { SchemaComposer, ObjectTypeComposer } from 'graphql-compose';
+import { GraphQLError } from 'graphql';
+
+import { ValidationsWithMessage, ManyValidationsWithMessage } from './validationsForDocument';
+
+export class ManyValidationError extends GraphQLError {
+  public errors: Array<ValidationsWithMessage | null>;
+
+  constructor(data: ManyValidationsWithMessage) {
+    super(data.message, undefined, undefined, undefined, undefined, undefined, {
+      validations: data.errors,
+    });
+
+    this.errors = data.errors;
+    (this as any).__proto__ = ManyValidationError.prototype;
+  }
+}
+
+export function getManyValidationErrorOTC(schemaComposer: SchemaComposer<any>): ObjectTypeComposer {
+  return schemaComposer.getOrCreateOTC('ManyValidationError', (otc) => {
+    const ValidationError: ObjectTypeComposer = getValidationErrorOTC(schemaComposer);
+    otc.addFields({
+      message: {
+        description: 'Combined error message from all validators',
+        type: 'String',
+      },
+      errors: {
+        description: 'List of validator errors',
+        type: ValidationError.List,
+      },
+    });
+  });
+}

src/errors/ValidationError.ts

@@ -1,61 +1,52 @@
-import type { Error as MongooseError } from 'mongoose';
 import { SchemaComposer, ObjectTypeComposer } from 'graphql-compose';
+import { GraphQLError } from 'graphql';
 
-interface Opts {
-  /** Adds prefix to error `path` property. It's useful for createMany resolver which shows `idx` of broken record */
-  pathPrefix?: string;
-}
+import type { Validations, ValidationsWithMessage } from './validationsForDocument';
 
-export class ValidationError extends Error {
-  public errors: Array<{
-    path: string;
-    message: string;
-    value: any;
-  }>;
+export class ValidationError extends GraphQLError {
+  public errors: Validations;
 
-  constructor(data: MongooseError.ValidationError, opts?: Opts) {
-    super(data.message);
-    this.errors = [];
-    Object.keys(data.errors).forEach((key) => {
-      const e = data.errors[key];
-      this.errors.push({
-        path: opts?.pathPrefix ? `${opts?.pathPrefix}${e.path}` : e.path,
-        message: e.message,
-        value: e.value,
-      });
+  constructor(validation: ValidationsWithMessage) {
+    super(validation.message, undefined, undefined, undefined, undefined, undefined, {
+      validations: validation.errors,
     });
 
+    this.errors = validation.errors;
+
     (this as any).__proto__ = ValidationError.prototype;
   }
 }
 
-export function getValidationErrorOTC(schemaComposer: SchemaComposer<any>): ObjectTypeComposer {
-  return schemaComposer.getOrCreateOTC('ValidationError', (otc) => {
-    const ValidatorError = schemaComposer.getOrCreateOTC('ValidatorError', (otc) => {
-      otc.addFields({
-        message: {
-          description: 'Validation error message',
-          type: 'String',
-        },
-        path: {
-          description: 'Source of the validation error from the model path',
-          type: 'String',
-        },
-        value: {
-          description: 'Field value which occurs the validation error',
-          type: 'JSON',
-        },
-      });
+export function getValidationOTC(schemaComposer: SchemaComposer<any>): ObjectTypeComposer {
+  return schemaComposer.getOrCreateOTC('Validation', (otc) => {
+    otc.addFields({
+      message: {
+        description: 'Validation error message',
+        type: 'String',
+      },
+      path: {
+        description: 'Source of the validation error from the model path',
+        type: 'String',
+      },
+      value: {
+        description: 'Field value which occurs the validation error',
+        type: 'JSON',
+      },
     });
+  });
+}
 
+export function getValidationErrorOTC(schemaComposer: SchemaComposer<any>): ObjectTypeComposer {
+  return schemaComposer.getOrCreateOTC('ValidationError', (otc) => {
+    const Validation = getValidationOTC(schemaComposer);
     otc.addFields({
       message: {
         description: 'Combined error message from all validators',
         type: 'String',
       },
       errors: {
         description: 'List of validator errors',
-        type: ValidatorError.NonNull.List,
+        type: Validation.NonNull.List,
       },
     });
   });

src/errors/index.ts

@@ -1,9 +1,10 @@
 import type { InterfaceTypeComposer, SchemaComposer } from 'graphql-compose';
 import { MongoError, getMongoErrorOTC } from './MongoError';
 import { ValidationError, getValidationErrorOTC } from './ValidationError';
+import { ManyValidationError, getManyValidationErrorOTC } from './ManyValidationError';
 import { RuntimeError, getRuntimeErrorOTC } from './RuntimeError';
 
-export { MongoError, ValidationError, RuntimeError };
+export { MongoError, ValidationError, ManyValidationError, RuntimeError };
 
 export function getErrorInterface(schemaComposer: SchemaComposer<any>): InterfaceTypeComposer {
   const ErrorInterface = schemaComposer.getOrCreateIFTC('ErrorInterface', (iftc) => {
@@ -44,3 +45,43 @@ export function getErrorInterface(schemaComposer: SchemaComposer<any>): Interfac
 
   return ErrorInterface;
 }
+
+export function getManyErrorInterface(schemaComposer: SchemaComposer<any>): InterfaceTypeComposer {
+  const ErrorInterface = schemaComposer.getOrCreateIFTC('ManyErrorInterface', (iftc) => {
+    iftc.addFields({
+      message: {
+        description: 'Generic error message',
+        type: 'String',
+      },
+    });
+
+    const ManyValidationErrorOTC = getManyValidationErrorOTC(schemaComposer);
+    const MongoErrorOTC = getMongoErrorOTC(schemaComposer);
+    const RuntimeErrorOTC = getRuntimeErrorOTC(schemaComposer);
+
+    ManyValidationErrorOTC.addInterface(iftc);
+    MongoErrorOTC.addInterface(iftc);
+    RuntimeErrorOTC.addInterface(iftc);
+
+    schemaComposer.addSchemaMustHaveType(ManyValidationErrorOTC);
+    schemaComposer.addSchemaMustHaveType(MongoErrorOTC);
+    schemaComposer.addSchemaMustHaveType(RuntimeErrorOTC);
+
+    const ManyValidationErrorType = ManyValidationErrorOTC.getType();
+    const MongoErrorType = MongoErrorOTC.getType();
+    const RuntimeErrorType = RuntimeErrorOTC.getType();
+
+    iftc.setResolveType((value) => {
+      switch (value?.name) {
+        case 'ManyValidationError':
+          return ManyValidationErrorType;
+        case 'MongoError':
+          return MongoErrorType;
+        default:
+          return RuntimeErrorType;
+      }
+    });
+  });
+
+  return ErrorInterface;
+}

src/errors/validationsForDocument.ts

@@ -0,0 +1,46 @@
+import type { Error as MongooseError } from 'mongoose';
+import type { Document } from 'mongoose';
+
+export type Validation = {
+  path: string;
+  message: string;
+  value: any;
+};
+
+export type Validations = Array<Validation>;
+
+export type ValidationsWithMessage = {
+  message: string;
+  errors: Array<Validation>;
+};
+
+export type ManyValidations = Array<ValidationsWithMessage | null>;
+
+export type ManyValidationsWithMessage = {
+  message: string;
+  errors: ManyValidations;
+};
+
+export async function validationsForDocument(
+  doc: Document
+): Promise<ValidationsWithMessage | null> {
+  const validations: MongooseError.ValidationError | null = await new Promise(function (resolve) {
+    doc.validate(resolve);
+  });
+
+  return Promise.resolve(
+    validations && validations.errors
+      ? {
+          message: validations.message,
+          errors: Object.keys(validations.errors).map((key) => {
+            const { message, value } = validations.errors[key];
+            return {
+              path: key,
+              message,
+              value,
+            };
+          }),
+        }
+      : null
+  );
+}

src/resolvers/__tests__/createMany-test.ts

@@ -94,6 +94,7 @@ describe('createMany() ->', () => {
         args: {
           records: [{ name: 'newName', contacts: { email: 'mail' } }],
         },
+        projection: { error: true },
       });
       expect(result.recordIds).toBeTruthy();
     });
@@ -105,6 +106,7 @@ describe('createMany() ->', () => {
             { name: 'newName0', contacts: { email: 'mail' } },
             { name: 'newName1', contacts: { email: 'mail' } },
           ],
+          projection: { error: true },
         },
       });
       expect(result.createCount).toBe(2);
@@ -134,6 +136,7 @@ describe('createMany() ->', () => {
             { name: checkedName, contacts: { email: 'mail' } },
             { name: checkedName, contacts: { email: 'mail' } },
           ],
+          projection: { error: true },
         },
       });
 
@@ -147,6 +150,7 @@ describe('createMany() ->', () => {
       const result = await createMany(UserModel, UserTC).resolve({
         args: {
           records: [{ name: 'NewUser', contacts: { email: 'mail' } }],
+          projection: { error: true },
         },
       });
       expect(result.records[0]._id).toBe(result.recordIds[0]);
@@ -155,6 +159,7 @@ describe('createMany() ->', () => {
     it('should return mongoose documents', async () => {
       const result = await createMany(UserModel, UserTC).resolve({
         args: { records: [{ name: 'NewUser', contacts: { email: 'mail' } }] },
+        projection: { error: true },
       });
       expect(result.records[0]).toBeInstanceOf(UserModel);
     });
@@ -166,6 +171,7 @@ describe('createMany() ->', () => {
             { name: 'NewUser0', contacts: { email: 'mail' } },
             { name: 'NewUser1', contacts: { email: 'mail' } },
           ],
+          projection: { error: true },
         },
         context: { ip: '1.1.1.1' },
         beforeRecordMutate: (record: any, rp: ExtendedResolveParams) => {
@@ -203,6 +209,7 @@ describe('createMany() ->', () => {
             { name: 'NewUser0', contacts: { email: 'mail' } },
             { name: 'NewUser1', contacts: { email: 'mail' } },
           ],
+          projection: { error: true },
         },
         context: { ip: '1.1.1.1' },
         beforeRecordMutate: (record: any, rp: ExtendedResolveParams) => {

src/resolvers/__tests__/updateOne-test.ts

@@ -171,6 +171,7 @@ describe('updateOne() ->', () => {
       expect(result.error.message).toEqual(
         'User validation failed: valid: this is a validate message'
       );
+
       expect(result.error.errors).toEqual([
         {
           message: 'this is a validate message',