refactor: create helpers/validate and move all validation logic ther for reducing copy-paste & keeping resolver logic slim

Author: nodkz

src/errors/ManyValidationError.ts

@@ -1,11 +1,22 @@
 import { getValidationErrorOTC } from './ValidationError';
 import { SchemaComposer, ObjectTypeComposer } from 'graphql-compose';
 import { GraphQLError } from 'graphql';
+import { ValidationsWithMessage } from '../resolvers/helpers/validate';
 
-import { ValidationsWithMessage, ManyValidationsWithMessage } from './validationsForDocument';
+/**
+ * If we validating multiple documents, we are using array with nulls in some positions.
+ * It helps to indicate idx of input records which have validation errors; and `null` for records without errors.
+ * So keep strict order in this array with input records array.
+ */
+export type ManyValidationsByIdx = Array<ValidationsWithMessage | null>;
+
+export type ManyValidationsWithMessage = {
+  message: string;
+  errors: ManyValidationsByIdx;
+};
 
 export class ManyValidationError extends GraphQLError {
-  public errors: Array<ValidationsWithMessage | null>;
+  public errors: ManyValidationsByIdx;
 
   constructor(data: ManyValidationsWithMessage) {
     super(data.message, undefined, undefined, undefined, undefined, undefined, {

src/errors/ValidationError.ts

@@ -1,10 +1,9 @@
 import { SchemaComposer, ObjectTypeComposer } from 'graphql-compose';
 import { GraphQLError } from 'graphql';
-
-import type { Validations, ValidationsWithMessage } from './validationsForDocument';
+import type { ValidationErrorData, ValidationsWithMessage } from '../resolvers/helpers/validate';
 
 export class ValidationError extends GraphQLError {
-  public errors: Validations;
+  public errors: ValidationErrorData[];
 
   constructor(validation: ValidationsWithMessage) {
     super(validation.message, undefined, undefined, undefined, undefined, undefined, {

src/errors/index.ts

@@ -1,10 +1,14 @@
 import type { InterfaceTypeComposer, SchemaComposer } from 'graphql-compose';
 import { MongoError, getMongoErrorOTC } from './MongoError';
 import { ValidationError, getValidationErrorOTC } from './ValidationError';
-import { ManyValidationError, getManyValidationErrorOTC } from './ManyValidationError';
+import {
+  ManyValidationError,
+  getManyValidationErrorOTC,
+  ManyValidationsByIdx,
+} from './ManyValidationError';
 import { RuntimeError, getRuntimeErrorOTC } from './RuntimeError';
 
-export { MongoError, ValidationError, ManyValidationError, RuntimeError };
+export { MongoError, ValidationError, ManyValidationError, ManyValidationsByIdx, RuntimeError };
 
 export function getErrorInterface(schemaComposer: SchemaComposer<any>): InterfaceTypeComposer {
   const ErrorInterface = schemaComposer.getOrCreateIFTC('ErrorInterface', (iftc) => {

src/errors/validationsForDocument.ts

@@ -3,12 +3,7 @@ import type { Model, Document } from 'mongoose';
 import { recordHelperArgs } from './helpers';
 import type { GenResolverOpts } from './index';
 import { addManyErrorCatcherField } from './helpers/addErrorCatcherField';
-import { ManyValidationError } from '../errors';
-import {
-  validationsForDocument,
-  ValidationsWithMessage,
-  ManyValidations,
-} from '../errors/validationsForDocument';
+import { validateManyAndThrow } from './helpers/validate';
 
 export default function createMany<TSource = Document, TContext = any>(
   model: Model<any>,
@@ -89,30 +84,17 @@ export default function createMany<TSource = Document, TContext = any>(
         }
       }
 
-      const manyValidations: ManyValidations = [];
       const docs = [];
-
       for (const record of recordData) {
         // eslint-disable-next-line new-cap
         let doc: Document = new model(record);
         if (resolveParams.beforeRecordMutate) {
           doc = await resolveParams.beforeRecordMutate(doc, resolveParams);
         }
-
-        const validations: ValidationsWithMessage | null = await validationsForDocument(doc);
-
-        manyValidations.push(validations ? validations : null);
         docs.push(doc);
       }
 
-      const hasValidationError = !manyValidations.every((error) => error === null);
-      if (hasValidationError) {
-        throw new ManyValidationError({
-          message: 'Cannot execute createMany, some documents contain errors',
-          errors: manyValidations,
-        });
-      }
-
+      await validateManyAndThrow(docs);
       await model.create(docs, { validateBeforeSave: false });
 
       return {

src/resolvers/createMany.ts

@@ -3,8 +3,7 @@ import type { Model, Document } from 'mongoose';
 import { recordHelperArgs } from './helpers';
 import type { ExtendedResolveParams, GenResolverOpts } from './index';
 import { addErrorCatcherField } from './helpers/addErrorCatcherField';
-import { ValidationError } from '../errors';
-import { validationsForDocument, ValidationsWithMessage } from '../errors/validationsForDocument';
+import { validateAndThrow } from './helpers/validate';
 
 export default function createOne<TSource = Document, TContext = any>(
   model: Model<any>,
@@ -76,11 +75,7 @@ export default function createOne<TSource = Document, TContext = any>(
         if (!doc) return null;
       }
 
-      const validations: ValidationsWithMessage | null = await validationsForDocument(doc);
-      if (validations) {
-        throw new ValidationError(validations);
-      }
-
+      await validateAndThrow(doc);
       await doc.save({ validateBeforeSave: false });
       return {
         record: doc,

src/resolvers/createOne.ts

@@ -0,0 +1,76 @@
+import type { Error as MongooseError } from 'mongoose';
+import type { Document } from 'mongoose';
+import { ValidationError, ManyValidationError, ManyValidationsByIdx } from '../../errors';
+
+export type ValidationErrorData = {
+  path: string;
+  message: string;
+  value: any;
+};
+
+export type ValidationsWithMessage = {
+  message: string;
+  errors: Array<ValidationErrorData>;
+};
+
+export async function validateDoc(doc: Document): Promise<ValidationsWithMessage | null> {
+  const validations: MongooseError.ValidationError | null = await new Promise((resolve) => {
+    doc.validate(resolve);
+  });
+
+  return validations?.errors
+    ? {
+        message: validations.message,
+        errors: Object.keys(validations.errors).map((key) => {
+          // transform object to array[{ path, message, value }, {}, ...]
+          const { message, value } = validations.errors[key];
+          return {
+            path: key,
+            message,
+            value,
+          };
+        }),
+      }
+    : null;
+}
+
+/**
+ * Make async validation for mongoose document.
+ * And if it has validation errors then throw one Error with embedding all validation errors into it.
+ */
+export async function validateAndThrow(doc: Document): Promise<void> {
+  const validations: ValidationsWithMessage | null = await validateDoc(doc);
+  if (validations) {
+    throw new ValidationError(validations);
+  }
+}
+
+/**
+ * Make async validation for array of mongoose documents.
+ * And if they have validation errors then throw one Error with embedding
+ * all validation errors for every document separately.
+ * If document does not have error then in embedded errors' array will
+ * be `null` at the same idx position.
+ */
+export async function validateManyAndThrow(docs: Document[]): Promise<void> {
+  const manyValidations: ManyValidationsByIdx = [];
+  let hasValidationError = false;
+
+  for (const doc of docs) {
+    const validations: ValidationsWithMessage | null = await validateDoc(doc);
+
+    if (validations) {
+      manyValidations.push(validations);
+      hasValidationError = true;
+    } else {
+      manyValidations.push(null);
+    }
+  }
+
+  if (hasValidationError) {
+    throw new ManyValidationError({
+      message: 'Some documents contain validation errors',
+      errors: manyValidations,
+    });
+  }
+}

src/resolvers/helpers/validate.ts

@@ -4,8 +4,7 @@ import { recordHelperArgs } from './helpers/record';
 import findById from './findById';
 import { addErrorCatcherField } from './helpers/addErrorCatcherField';
 import type { ExtendedResolveParams, GenResolverOpts } from './index';
-import { validationsForDocument, ValidationsWithMessage } from '../errors/validationsForDocument';
-import { ValidationError } from '../errors';
+import { validateAndThrow } from './helpers/validate';
 
 export default function updateById<TSource = Document, TContext = any>(
   model: Model<any>,
@@ -96,12 +95,7 @@ export default function updateById<TSource = Document, TContext = any>(
       }
 
       doc.set(recordData);
-
-      const validations: ValidationsWithMessage | null = await validationsForDocument(doc);
-      if (validations) {
-        throw new ValidationError(validations);
-      }
-
+      await validateAndThrow(doc);
       await doc.save({ validateBeforeSave: false });
 
       return {

src/resolvers/updateById.ts

@@ -4,8 +4,7 @@ import type { ExtendedResolveParams, GenResolverOpts } from './index';
 import { skipHelperArgs, recordHelperArgs, filterHelperArgs, sortHelperArgs } from './helpers';
 import findOne from './findOne';
 import { addErrorCatcherField } from './helpers/addErrorCatcherField';
-import { ValidationError } from '../errors';
-import { validationsForDocument, ValidationsWithMessage } from '../errors/validationsForDocument';
+import { validateAndThrow } from './helpers/validate';
 
 export default function updateOne<TSource = Document, TContext = any>(
   model: Model<any>,
@@ -92,12 +91,7 @@ export default function updateOne<TSource = Document, TContext = any>(
 
       if (recordData) {
         doc.set(recordData);
-
-        const validations: ValidationsWithMessage | null = await validationsForDocument(doc);
-        if (validations) {
-          throw new ValidationError(validations);
-        }
-
+        await validateAndThrow(doc);
         await doc.save({ validateBeforeSave: false });
       }