fix(validation): properly validate nullable items array (#1329)

Co-authored-by: Michał Lytek <michal.wojciech.lytek@gmail.com>
MichalLytek · Aug 17, 2022 · 643087b · 643087b
1 parent 82e056d
commit 643087b
Show file tree

Hide file tree

Showing 3 changed files with 65 additions and 3 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -4,6 +4,7 @@
 <!-- here goes all the unreleased changes descriptions -->
 ### Fixes
 - support overwriting fields of extended types (#1109)
+- properly execute args validation for nullable items array (#1328)
 
 ## v1.2.0-rc.1
 ### Features

diff --git a/src/resolvers/validate-arg.ts b/src/resolvers/validate-arg.ts
@@ -4,14 +4,17 @@ import { TypeValue } from "../decorators/types";
 import { ArgumentValidationError } from "../errors/ArgumentValidationError";
 import { ValidateSettings } from "../schema/build-context";
 
+const shouldArgBeValidated = (argValue: unknown): boolean =>
+  argValue !== null && typeof argValue === "object";
+
 export async function validateArg<T extends object>(
   argValue: T | undefined,
   argType: TypeValue,
   globalValidate: ValidateSettings,
   argValidate: ValidateSettings | undefined,
 ): Promise<T | undefined> {
   const validate = argValidate !== undefined ? argValidate : globalValidate;
-  if (validate === false || argValue == null || typeof argValue !== "object") {
+  if (validate === false || !shouldArgBeValidated(argValue)) {
     return argValue;
   }
 
@@ -32,9 +35,13 @@ export async function validateArg<T extends object>(
   const { validateOrReject } = await import("class-validator");
   try {
     if (Array.isArray(argValue)) {
-      await Promise.all(argValue.map(argItem => validateOrReject(argItem, validatorOptions)));
+      await Promise.all(
+        argValue
+          .filter(shouldArgBeValidated)
+          .map(argItem => validateOrReject(argItem, validatorOptions)),
+      );
     } else {
-      await validateOrReject(argValue, validatorOptions);
+      await validateOrReject(argValue as T, validatorOptions);
     }
     return argValue;
   } catch (err) {

diff --git a/tests/functional/validation.ts b/tests/functional/validation.ts
@@ -98,6 +98,15 @@ describe("Validation", () => {
           argInput = inputs;
           return {};
         }
+
+        @Mutation()
+        mutationWithOptionalInputsArray(
+          @Arg("inputs", type => [SampleInput], { nullable: "items" })
+          inputs: Array<SampleInput | null>,
+        ): SampleObject {
+          argInput = inputs;
+          return {};
+        }
       }
       sampleResolver = SampleResolver;
 
@@ -230,6 +239,51 @@ describe("Validation", () => {
       expect(validationError.validationErrors[0].property).toEqual("numberField");
     });
 
+    it("should not throw error when one of optional items in the input array is null", async () => {
+      const mutation = `mutation {
+        mutationWithOptionalInputsArray(inputs: [
+          null,
+          {
+            stringField: "12345",
+            numberField: 5
+          },
+        ]) {
+          field
+        }
+      }`;
+
+      const result = await graphql(schema, mutation);
+      expect(result.errors).toBeUndefined();
+      expect(result.data).toEqual({ mutationWithOptionalInputsArray: { field: null } });
+    });
+
+    it("should properly validate arg array when one of optional items in the input array is incorrect", async () => {
+      const mutation = `mutation {
+        mutationWithOptionalInputsArray(inputs: [
+          null,
+          {
+            stringField: "12345",
+            numberField: 5
+          },
+          {
+            stringField: "12345",
+            numberField: 15,
+          },
+        ]) {
+          field
+        }
+      }`;
+
+      const result = await graphql(schema, mutation);
+      expect(result.data).toBeNull();
+      expect(result.errors).toHaveLength(1);
+
+      const validationError = result.errors![0].originalError! as ArgumentValidationError;
+      expect(validationError).toBeInstanceOf(ArgumentValidationError);
+      expect(validationError.validationErrors).toHaveLength(1);
+      expect(validationError.validationErrors[0].property).toEqual("numberField");
+    });
+
     it("should throw validation error when optional input field is incorrect", async () => {
       const mutation = `mutation {
         sampleMutation(input: {