added string-handler

Author: arpitkuriyal

src/error-handlers/maxLength.js

@@ -0,0 +1,64 @@
+import { getSchema } from "@hyperjump/json-schema/experimental";
+import * as Schema from "@hyperjump/browser";
+import * as Instance from "@hyperjump/json-schema/instance/experimental";
+
+/**
+ * @import { StringConstraints } from "../localization.js"
+ * @import { ErrorHandler } from "../index.d.ts"
+ */
+
+/** @type ErrorHandler */
+const stringHandler = async (normalizedErrors, instance, localization) => {
+  /** @type StringConstraints */
+  const constraints = {};
+
+  /** @type string[] */
+  const failedSchemaLocations = [];
+
+  for (const schemaLocation in normalizedErrors["https://json-schema.org/keyword/minLength"]) {
+    if (!normalizedErrors["https://json-schema.org/keyword/minLength"][schemaLocation]) {
+      failedSchemaLocations.push(schemaLocation);
+    }
+
+    const keyword = await getSchema(schemaLocation);
+    /** @type number */
+    const minLength = Schema.value(keyword);
+    constraints.minLength = Math.max(constraints.minLength ?? Number.MIN_VALUE, minLength);
+  }
+
+  for (const schemaLocation in normalizedErrors["https://json-schema.org/keyword/maxLength"]) {
+    if (!normalizedErrors["https://json-schema.org/keyword/maxLength"][schemaLocation]) {
+      failedSchemaLocations.push(schemaLocation);
+    }
+
+    const keyword = await getSchema(schemaLocation);
+    /** @type number */
+    const maxLength = Schema.value(keyword);
+    constraints.maxLength = Math.min(constraints.maxLength ?? Number.MAX_VALUE, maxLength);
+  }
+
+  for (const schemaLocation in normalizedErrors["https://json-schema.org/keyword/pattern"]) {
+    if (!normalizedErrors["https://json-schema.org/keyword/pattern"][schemaLocation]) {
+      failedSchemaLocations.push(schemaLocation);
+    }
+
+    const keyword = await getSchema(schemaLocation);
+    /** @type string */
+    const pattern = Schema.value(keyword);
+    constraints.pattern = pattern;
+  }
+
+  if (failedSchemaLocations.length > 0) {
+    return [
+      {
+        message: localization.getStringErrorMessage(constraints),
+        instanceLocation: Instance.uri(instance),
+        schemaLocation: failedSchemaLocations.length > 1 ? failedSchemaLocations : failedSchemaLocations[0]
+      }
+    ];
+  }
+
+  return [];
+};
+
+export default stringHandler;

src/error-handlers/minLength.js

@@ -55,15 +55,13 @@ import maxItemsErrorHandler from "./error-handlers/maxItems.js";
 import minItemsErrorHandler from "./error-handlers/minItems.js";
 import maxPropertiesErrorHandler from "./error-handlers/maxProperties.js";
 import minPropertiesErrorHandler from "./error-handlers/minProperties.js";
-import minLengthErrorHandler from "./error-handlers/minLength.js";
 import multipleOfErrorHandler from "./error-handlers/multipleOf.js";
 import notErrorHandler from "./error-handlers/not.js";
 import numberRangeHandler from "./error-handlers/number-range-handler.js";
-import patternErrorHandler from "./error-handlers/pattern.js";
 import requiredErrorHandler from "./error-handlers/required.js";
 import typeErrorHandler from "./error-handlers/type.js";
 import uniqueItemsErrorHandler from "./error-handlers/uniqueItems.js";
-import maxLengthErrorHandler from "./error-handlers/maxLength.js";
+import stringHandler from "./error-handlers/string-handler.js";
 
 /**
  * @import { betterJsonSchemaErrors } from "./index.d.ts"
@@ -127,15 +125,13 @@ addErrorHandler(maxItemsErrorHandler);
 addErrorHandler(minItemsErrorHandler);
 addErrorHandler(maxPropertiesErrorHandler);
 addErrorHandler(minPropertiesErrorHandler);
-addErrorHandler(minLengthErrorHandler);
-addErrorHandler(maxLengthErrorHandler);
 addErrorHandler(multipleOfErrorHandler);
 addErrorHandler(notErrorHandler);
 addErrorHandler(numberRangeHandler);
-addErrorHandler(patternErrorHandler);
 addErrorHandler(requiredErrorHandler);
 addErrorHandler(typeErrorHandler);
 addErrorHandler(uniqueItemsErrorHandler);
+addErrorHandler(stringHandler);
 
 export { setNormalizationHandler } from "./normalized-output.js";
 export { addErrorHandler } from "./error-handling.js";

src/error-handlers/pattern.js

@@ -39,7 +39,7 @@ describe("Error messages", async () => {
     expect(result.errors).to.eql([{
       schemaLocation: "https://example.com/main#/minLength",
       instanceLocation: "#",
-      message: localization.getMinLengthErrorMessage(3)
+      message: localization.getStringErrorMessage({ minLength: 3 })
     }]);
   });
 
@@ -66,7 +66,7 @@ describe("Error messages", async () => {
     expect(result.errors).to.eql([{
       schemaLocation: "https://example.com/main#/maxLength",
       instanceLocation: "#",
-      message: localization.getMaxLengthErrorMessage(3)
+      message: localization.getStringErrorMessage({ maxLength: 3 })
     }]);
   });
 
@@ -614,7 +614,7 @@ describe("Error messages", async () => {
       {
         schemaLocation: "https://example.com/main#/pattern",
         instanceLocation: "#",
-        message: localization.getPatternErrorMessage("^[a-z]+$")
+        message: localization.getStringErrorMessage({ pattern: "^[a-z]+$" })
       }
     ]);
   });
@@ -822,7 +822,7 @@ describe("Error messages", async () => {
       {
         schemaLocation: `https://example.com/main#/anyOf/0/minLength`,
         instanceLocation: "#",
-        message: localization.getMinLengthErrorMessage(5)
+        message: localization.getStringErrorMessage({ minLength: 5 })
       }
     ]);
   });
@@ -883,7 +883,7 @@ describe("Error messages", async () => {
       {
         schemaLocation: "https://example.com/main#/anyOf/1/properties/ID/pattern",
         instanceLocation: "#/ID",
-        message: localization.getPatternErrorMessage("^[0-9\\-]+$")
+        message: localization.getStringErrorMessage({ pattern: "^[0-9\\-]+$" })
       }
     ]);
   });
@@ -1229,7 +1229,7 @@ describe("Error messages", async () => {
     expect(result.errors).to.eql([
       {
         instanceLocation: "#/Foo",
-        message: localization.getPatternErrorMessage("^[a-z]*$"),
+        message: localization.getStringErrorMessage({ pattern: "^[a-z]*$" }),
         schemaLocation: "https://example.com/main#/propertyNames/pattern"
       }
     ]);
@@ -1256,7 +1256,7 @@ describe("Error messages", async () => {
     expect(result.errors).to.eql([
       {
         instanceLocation: "#/Foo",
-        message: localization.getPatternErrorMessage("^[a-z]*$"),
+        message: localization.getStringErrorMessage({ pattern: "^[a-z]*$" }),
         schemaLocation: "https://example.com/main#/propertyNames/pattern"
       }
     ]);
@@ -1283,7 +1283,7 @@ describe("Error messages", async () => {
     expect(result.errors).to.eql([
       {
         instanceLocation: "#*/Foo",
-        message: localization.getPatternErrorMessage("^[a-z]*$"),
+        message: localization.getStringErrorMessage({ pattern: "^[a-z]*$" }),
         schemaLocation: "https://example.com/main#/propertyNames/pattern"
       }
     ]);
@@ -1371,4 +1371,47 @@ describe("Error messages", async () => {
       }
     ]);
   });
+
+  test("minLength/maxLength and pattern test", async () => {
+    registerSchema({
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      allOf: [
+        { minLength: 3 },
+        { maxLength: 5 },
+        { pattern: "^[a-z]+$" }
+      ]
+    }, schemaUri);
+
+    const instance = "AAAAAAA";
+
+    /** @type OutputFormat */
+    const output = {
+      valid: false,
+      errors: [
+        {
+          absoluteKeywordLocation: "https://example.com/main#/allOf/0/minLength",
+          instanceLocation: "#"
+        },
+        {
+          absoluteKeywordLocation: "https://example.com/main#/allOf/1/maxLength",
+          instanceLocation: "#"
+        },
+        {
+          absoluteKeywordLocation: "https://example.com/main#/allOf/2/pattern",
+          instanceLocation: "#"
+        }
+      ]
+    };
+
+    const result = await betterJsonSchemaErrors(output, schemaUri, instance);
+    expect(result.errors).to.eql([{
+      schemaLocation: [
+        "https://example.com/main#/allOf/0/minLength",
+        "https://example.com/main#/allOf/1/maxLength",
+        "https://example.com/main#/allOf/2/pattern"
+      ],
+      instanceLocation: "#",
+      message: localization.getStringErrorMessage({ minLength: 3, maxLength: 5, pattern: "^[a-z]+$" })
+    }]);
+  });
 });

src/error-handlers/string-handler.js

@@ -14,6 +14,14 @@ import { FluentBundle, FluentResource } from "@fluent/bundle";
  * }} NumberConstraints
  */
 
+/**
+ * @typedef {{
+ *   minLength?: number;
+ *   maxLength?: number;
+ *   pattern?: string;
+ * }} StringConstraints
+ */
+
 export class Localization {
   /**
    * @param {string} locale
@@ -65,16 +73,6 @@ export class Localization {
     });
   }
 
-  /** @type (limit: number) => string */
-  getMinLengthErrorMessage(limit) {
-    return this._formatMessage("min-length-error", { limit });
-  }
-
-  /** @type (limit: number) => string */
-  getMaxLengthErrorMessage(limit) {
-    return this._formatMessage("max-length-error", { limit });
-  }
-
   /** @type (constraints: NumberConstraints) => string */
   getNumberErrorMessage(constraints) {
     /** @type string[] */
@@ -101,6 +99,28 @@ export class Localization {
     });
   }
 
+  /** @type (constraints: StringConstraints) => string */
+  getStringErrorMessage(constraints) {
+    /** @type string[] */
+    const messages = [];
+
+    if (constraints.minLength) {
+      messages.push(this._formatMessage("string-error-minLength", constraints));
+    }
+
+    if (constraints.maxLength) {
+      messages.push(this._formatMessage("string-error-maxLength", constraints));
+    }
+
+    if (constraints.pattern) {
+      messages.push(this._formatMessage("string-error-pattern", constraints));
+    }
+
+    return this._formatMessage("string-error", {
+      constraints: new Intl.ListFormat(this.locale, { type: "conjunction" }).format(messages)
+    });
+  }
+
   /** @type (instanceLocation: string, missingProperties: string[]) => string */
   getRequiredErrorMessage(instanceLocation, missingProperties) {
     return this._formatMessage("required-error", {
@@ -149,11 +169,6 @@ export class Localization {
     return this._formatMessage("format-error", { format });
   }
 
-  /** @type (pattern: string) => string */
-  getPatternErrorMessage(pattern) {
-    return this._formatMessage("pattern-error", { pattern });
-  }
-
   /** @type () => string */
   getContainsErrorMessage() {
     return this._formatMessage("contains-error");