json-schema-library 10.5.4 → 11.0.1

package/src/types.ts

@@ -1,23 +1,18 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { Draft } from "./Draft";
 import { errors } from "./errors/errors";
 import { SchemaNode, isSchemaNode, GetNodeOptions } from "./SchemaNode";
+import { isObject } from "./utils/isObject";
 
 export type BooleanSchema = boolean;
 // eslint-disable-next-line @typescript-eslint/consistent-indexed-object-style
 export interface JsonSchema {
-    [keyword: string]: any; // eslint-disable-line @typescript-eslint/no-explicit-any
+    [keyword: string]: any;
 }
-export type JsonPointer = string;
-
-export type DefaultErrors = keyof typeof errors;
-export type ErrorConfig = Record<DefaultErrors | string, string | ((error: ErrorData) => void)>;
-export type OptionalNodeOrError = { node?: SchemaNode; error: undefined } | { node: undefined; error?: JsonError };
-export type NodeOrError = { node: SchemaNode; error: undefined } | { node: undefined; error: JsonError };
 
-export type { SchemaNode, GetNodeOptions, Draft };
-export { isSchemaNode };
+export type JsonPointer = string;
 
-export type ErrorData<T extends Record<string, unknown> = Record<string, unknown>> = T & {
+export type AnnotationData<D extends Record<string, unknown> = Record<string, unknown>> = D & {
     /* json-pointer to location of error */
     pointer: string;
     /* json-schema of error location */
@@ -26,23 +21,42 @@ export type ErrorData<T extends Record<string, unknown> = Record<string, unknown
     value: unknown;
 };
 
-export type JsonError<T extends ErrorData = ErrorData> = {
-    type: "error";
-    code: ErrorConfig | string;
+export type Annotation<T = string, D extends AnnotationData = AnnotationData, S = string> = {
+    type: T;
+    code: S;
     message: string;
-    data: T;
+    data: D;
     [p: string]: unknown;
 };
 
+export type DefaultErrors = keyof typeof errors;
+export type ErrorConfig = Record<DefaultErrors | string, string | ((error: AnnotationData) => void)>;
+export type OptionalNodeOrError = { node?: SchemaNode; error: undefined } | { node: undefined; error?: JsonError };
+export type NodeOrError = { node: SchemaNode; error: undefined } | { node: undefined; error: JsonError };
+export type JsonError<D extends AnnotationData = AnnotationData> = Annotation<"error", D, ErrorConfig | string>;
+export type JsonAnnotation<D extends AnnotationData = AnnotationData> = Annotation<"annotation", D>;
+
+export type { SchemaNode, GetNodeOptions, Draft };
+export { isSchemaNode };
+
+export function isAnnotation(value: any): value is Annotation {
+    return isObject(value) && (value?.type && value?.code && value?.data) != null;
+}
+
+/**
+ * ts type guard for json error
+ * @returns true if passed type is a JsonError
+ */
+export function isJsonAnnotation(error: unknown): error is JsonAnnotation {
+    return isObject(error) && error.type === "annotation";
+}
+
 /**
  * ts type guard for json error
  * @returns true if passed type is a JsonError
  */
 export function isJsonError(error: unknown): error is JsonError {
-    if (error && typeof error == "object") {
-        return (error as Record<string, unknown>).type === "error";
-    }
-    return false;
+    return isObject(error) && error.type === "error";
 }
 
 export function isNumber(value: unknown): value is number {

package/src/utils/sanitizeErrors.ts

@@ -1,12 +1,13 @@
-import { isJsonError, JsonError } from "../types";
-import { ValidationResult, JsonSchemaValidator } from "../Keyword";
-
-type MaybeNestedErrors = ReturnType<JsonSchemaValidator>;
+import { isAnnotation } from "../types";
+import { ValidationAnnotation, ValidationReturnType } from "../Keyword";
 
+/**
+ * Flattens nested validation array results and filters items to only include errors, annotations and promises
+ */
 export default function sanitizeErrors(
-    list: MaybeNestedErrors | MaybeNestedErrors[],
-    result: (JsonError | Promise<JsonError | undefined> | ValidationResult)[] = []
-): ValidationResult[] {
+    list: ValidationReturnType | ValidationReturnType[] | ValidationAnnotation[],
+    result: ValidationAnnotation[] = []
+) {
     if (!Array.isArray(list)) {
         if (list !== undefined) {
             return [list];
@@ -16,7 +17,7 @@ export default function sanitizeErrors(
     for (const item of list) {
         if (Array.isArray(item)) {
             sanitizeErrors(item, result);
-        } else if (isJsonError(item) || item instanceof Promise) {
+        } else if (isAnnotation(item) || item instanceof Promise) {
             result.push(item);
         }
     }

package/src/validateNode.ts

@@ -1,5 +1,5 @@
 import { BooleanSchema, JsonSchema, SchemaNode } from "./types";
-import { ValidationPath, ValidationResult } from "./Keyword";
+import { ValidationPath, ValidationReturnType } from "./Keyword";
 import sanitizeErrors from "./utils/sanitizeErrors";
 
 export function validateNode(node: SchemaNode, data: unknown, pointer: string, path: ValidationPath) {
@@ -17,7 +17,7 @@ export function validateNode(node: SchemaNode, data: unknown, pointer: string, p
             })
         ];
     }
-    const errors: (undefined | ValidationResult | ValidationResult | Promise<undefined>)[] = [];
+    const errors: ValidationReturnType = [];
     for (const validate of node.validators) {
         const result = validate({ node, data, pointer, path });
         if (Array.isArray(result)) {