feat: implement undefinedAsNull keyword for enum type (#175)

declarations/keywords/undefinedAsNull.d.ts

@@ -0,0 +1,15 @@
+export default addUndefinedAsNullKeyword;
+export type Ajv = import("ajv").default;
+export type SchemaValidateFunction = import("ajv").SchemaValidateFunction;
+export type AnySchemaObject = import("ajv").AnySchemaObject;
+export type ValidateFunction = import("ajv").ValidateFunction;
+/** @typedef {import("ajv").default} Ajv */
+/** @typedef {import("ajv").SchemaValidateFunction} SchemaValidateFunction */
+/** @typedef {import("ajv").AnySchemaObject} AnySchemaObject */
+/** @typedef {import("ajv").ValidateFunction} ValidateFunction */
+/**
+ *
+ * @param {Ajv} ajv
+ * @returns {Ajv}
+ */
+declare function addUndefinedAsNullKeyword(ajv: Ajv): Ajv;

declarations/validate.d.ts

@@ -8,6 +8,7 @@ export type Extend = {
   formatExclusiveMinimum?: string | undefined;
   formatExclusiveMaximum?: string | undefined;
   link?: string | undefined;
+  undefinedAsNull?: boolean | undefined;
 };
 export type Schema = (JSONSchema4 | JSONSchema6 | JSONSchema7) & Extend;
 export type SchemaUtilErrorObject = ErrorObject & {
@@ -33,6 +34,7 @@ export type ValidationErrorConfiguration = {
  * @property {string=} formatExclusiveMinimum
  * @property {string=} formatExclusiveMaximum
  * @property {string=} link
+ * @property {boolean=} undefinedAsNull
  */
 /** @typedef {(JSONSchema4 | JSONSchema6 | JSONSchema7) & Extend} Schema */
 /** @typedef {ErrorObject & { children?: Array<ErrorObject>}} SchemaUtilErrorObject */

src/ValidationError.js

@@ -543,9 +543,17 @@ class ValidationError extends Error {
     }
 
     if (schema.enum) {
-      return /** @type {Array<any>} */ (schema.enum)
-        .map((item) => JSON.stringify(item))
+      const enumValues = /** @type {Array<any>} */ (schema.enum)
+        .map((item) => {
+          if (item === null && schema.undefinedAsNull) {
+            return `${JSON.stringify(item)} | undefined`;
+          }
+
+          return JSON.stringify(item);
+        })
         .join(" | ");
+
+      return `${enumValues}`;
     }
 
     if (typeof schema.const !== "undefined") {

src/keywords/undefinedAsNull.js

@@ -0,0 +1,39 @@
+/** @typedef {import("ajv").default} Ajv */
+/** @typedef {import("ajv").SchemaValidateFunction} SchemaValidateFunction */
+/** @typedef {import("ajv").AnySchemaObject} AnySchemaObject */
+/** @typedef {import("ajv").ValidateFunction} ValidateFunction */
+
+/**
+ *
+ * @param {Ajv} ajv
+ * @returns {Ajv}
+ */
+function addUndefinedAsNullKeyword(ajv) {
+  ajv.addKeyword({
+    keyword: "undefinedAsNull",
+    before: "enum",
+    modifying: true,
+    /** @type {SchemaValidateFunction} */
+    validate(kwVal, data, metadata, dataCxt) {
+      if (
+        kwVal &&
+        dataCxt &&
+        metadata &&
+        typeof metadata.enum !== "undefined"
+      ) {
+        const idx = dataCxt.parentDataProperty;
+
+        if (typeof dataCxt.parentData[idx] === "undefined") {
+          // eslint-disable-next-line no-param-reassign
+          dataCxt.parentData[dataCxt.parentDataProperty] = null;
+        }
+      }
+
+      return true;
+    },
+  });
+
+  return ajv;
+}
+
+export default addUndefinedAsNullKeyword;

src/validate.js

@@ -1,4 +1,5 @@
 import addAbsolutePathKeyword from "./keywords/absolutePath";
+import addUndefinedAsNullKeyword from "./keywords/undefinedAsNull";
 
 import ValidationError from "./ValidationError";
 
@@ -48,8 +49,10 @@ const getAjv = memoize(() => {
 
   ajvKeywords(ajv, ["instanceof", "patternRequired"]);
   addFormats(ajv, { keywords: true });
+
   // Custom keywords
   addAbsolutePathKeyword(ajv);
+  addUndefinedAsNullKeyword(ajv);
 
   return ajv;
 });
@@ -66,6 +69,7 @@ const getAjv = memoize(() => {
  * @property {string=} formatExclusiveMinimum
  * @property {string=} formatExclusiveMaximum
  * @property {string=} link
+ * @property {boolean=} undefinedAsNull
  */
 
 /** @typedef {(JSONSchema4 | JSONSchema6 | JSONSchema7) & Extend} Schema */

test/fixtures/schema.json

@@ -3791,6 +3791,47 @@
       "format": "date",
       "formatMinimum": "2016-02-06",
       "formatExclusiveMaximum": "2016-12-27"
+    },
+    "enumKeywordAndUndefined": {
+      "undefinedAsNull": true,
+      "enum": [ 0, false, "", null ]
+    },
+    "arrayStringAndEnum": {
+      "description": "References to other configurations to depend on.",
+      "type": "array",
+      "items": {
+        "anyOf": [
+          {
+            "undefinedAsNull": true,
+            "enum": [ 0, false, "", null ]
+          },
+          {
+            "type": "string",
+            "minLength": 1
+          }
+        ]
+      }
+    },
+    "arrayStringAndEnumAndNoUndefined": {
+      "description": "References to other configurations to depend on.",
+      "type": "array",
+      "items": {
+        "anyOf": [
+          {
+            "undefinedAsNull": false,
+            "enum": [ 0, false, "", null ]
+          },
+          {
+            "type": "string",
+            "minLength": 1
+          }
+        ]
+      }
+    },
+    "stringTypeAndUndefinedAsNull": {
+      "description": "References to other configurations to depend on.",
+      "type": "string",
+      "undefinedAsNull": true
     }
   }
 }

test/index.test.js

@@ -314,6 +314,33 @@ describe("Validation", () => {
     },
   });
 
+  createSuccessTestCase("enum with undefinedAsNull", {
+    // eslint-disable-next-line no-undefined
+    enumKeywordAndUndefined: undefined,
+  });
+
+  createSuccessTestCase("enum with undefinedAsNull #2", {
+    enumKeywordAndUndefined: 0,
+  });
+
+  createSuccessTestCase("array with enum and undefinedAsNull", {
+    arrayStringAndEnum: ["a", "b", "c"],
+  });
+
+  createSuccessTestCase("array with enum and undefinedAsNull #2", {
+    // eslint-disable-next-line no-undefined
+    arrayStringAndEnum: [undefined, false, undefined, 0, "test", undefined],
+  });
+
+  createSuccessTestCase("array with enum and undefinedAsNull #3", {
+    // eslint-disable-next-line no-undefined
+    arrayStringAndEnum: [undefined, null, false, 0, ""],
+  });
+
+  createSuccessTestCase("string and undefinedAsNull #3", {
+    stringTypeAndUndefinedAsNull: "test",
+  });
+
   // The "name" option
   createFailedTestCase(
     "webpack name",
@@ -2987,4 +3014,46 @@ describe("Validation", () => {
     },
     (msg) => expect(msg).toMatchSnapshot()
   );
+
+  createFailedTestCase(
+    "enum and undefinedAsNull",
+    {
+      enumKeywordAndUndefined: "foo",
+    },
+    (msg) => expect(msg).toMatchSnapshot()
+  );
+
+  createFailedTestCase(
+    "array with enum and undefinedAsNull",
+    {
+      arrayStringAndEnum: ["foo", "bar", 1],
+    },
+    (msg) => expect(msg).toMatchSnapshot()
+  );
+
+  createFailedTestCase(
+    "array with enum and undefinedAsNull #2",
+    {
+      // eslint-disable-next-line no-undefined
+      arrayStringAndEnum: ["foo", "bar", undefined, 1],
+    },
+    (msg) => expect(msg).toMatchSnapshot()
+  );
+
+  createFailedTestCase(
+    "array with enum and undefinedAsNull #3",
+    {
+      // eslint-disable-next-line no-undefined
+      arrayStringAndEnumAndNoUndefined: ["foo", "bar", undefined],
+    },
+    (msg) => expect(msg).toMatchSnapshot()
+  );
+
+  createFailedTestCase(
+    "string and undefinedAsNull",
+    {
+      stringTypeAndUndefinedAsNull: 1,
+    },
+    (msg) => expect(msg).toMatchSnapshot()
+  );
 });