@hyperjump/json-schema 1.16.5 → 1.17.0

package/formats/handlers/iri.js

@@ -0,0 +1,7 @@
+import { isIri } from "@hyperjump/json-schema-formats";
+
+
+export default {
+  id: "https://json-schema.org/format/iri",
+  handler: (uri) => typeof uri !== "string" || isIri(uri)
+};

package/formats/handlers/json-pointer.js

@@ -0,0 +1,7 @@
+import { isJsonPointer } from "@hyperjump/json-schema-formats";
+
+
+export default {
+  id: "https://json-schema.org/format/json-pointer",
+  handler: (pointer) => typeof pointer !== "string" || isJsonPointer(pointer)
+};

package/formats/handlers/regex.js

@@ -0,0 +1,7 @@
+import { isRegex } from "@hyperjump/json-schema-formats";
+
+
+export default {
+  id: "https://json-schema.org/format/regex",
+  handler: (regex) => typeof regex !== "string" || isRegex(regex)
+};

package/formats/handlers/relative-json-pointer.js

@@ -0,0 +1,7 @@
+import { isRelativeJsonPointer } from "@hyperjump/json-schema-formats";
+
+
+export default {
+  id: "https://json-schema.org/format/relative-json-pointer",
+  handler: (pointer) => typeof pointer !== "string" || isRelativeJsonPointer(pointer)
+};

package/formats/handlers/time.js

@@ -0,0 +1,7 @@
+import { isTime } from "@hyperjump/json-schema-formats";
+
+
+export default {
+  id: "https://json-schema.org/format/time",
+  handler: (time) => typeof time !== "string" || isTime(time)
+};

package/formats/handlers/uri-reference.js

@@ -0,0 +1,7 @@
+import { isUriReference } from "@hyperjump/json-schema-formats";
+
+
+export default {
+  id: "https://json-schema.org/format/uri-reference",
+  handler: (uri) => typeof uri !== "string" || isUriReference(uri)
+};

package/formats/handlers/uri-template.js

@@ -0,0 +1,7 @@
+import { isUriTemplate } from "@hyperjump/json-schema-formats";
+
+
+export default {
+  id: "https://json-schema.org/format/uri-template",
+  handler: (uriTemplate) => typeof uriTemplate !== "string" || isUriTemplate(uriTemplate)
+};

package/formats/handlers/uri.js

@@ -0,0 +1,7 @@
+import { isUri } from "@hyperjump/json-schema-formats";
+
+
+export default {
+  id: "https://json-schema.org/format/uri",
+  handler: (uri) => typeof uri !== "string" || isUri(uri)
+};

package/formats/handlers/uuid.js

@@ -0,0 +1,7 @@
+import { isUuid } from "@hyperjump/json-schema-formats";
+
+
+export default {
+  id: "https://json-schema.org/format/uuid",
+  handler: (uuid) => typeof uuid !== "string" || isUuid(uuid)
+};

package/formats/index.js

@@ -0,0 +1,12 @@
+import { addFormat } from "../lib/keywords.js";
+
+import idnEmail from "./handlers/idn-email.js";
+import hostname from "./handlers/hostname.js";
+import idnHostname from "./handlers/idn-hostname.js";
+
+
+addFormat(idnEmail);
+addFormat(hostname);
+addFormat(idnHostname);
+
+export * from "./lite.js";

package/formats/lite.js

@@ -0,0 +1,43 @@
+import { addFormat } from "../lib/keywords.js";
+
+import draft04Hostname from "./handlers/draft-04/hostname.js";
+import dateTime from "./handlers/date-time.js";
+import date from "./handlers/date.js";
+import time from "./handlers/time.js";
+import duration from "./handlers/duration.js";
+import email from "./handlers/email.js";
+import ipv4 from "./handlers/ipv4.js";
+import ipv6 from "./handlers/ipv6.js";
+import uri from "./handlers/uri.js";
+import uriReference from "./handlers/uri-reference.js";
+import iri from "./handlers/iri.js";
+import iriReference from "./handlers/iri-reference.js";
+import uuid from "./handlers/uuid.js";
+import uriTemplate from "./handlers/uri-template.js";
+import jsonPointer from "./handlers/json-pointer.js";
+import relativeJsonPointer from "./handlers/relative-json-pointer.js";
+import regex from "./handlers/regex.js";
+
+
+addFormat(draft04Hostname);
+addFormat(dateTime);
+addFormat(date);
+addFormat(time);
+addFormat(duration);
+addFormat(email);
+addFormat(ipv4);
+addFormat(ipv6);
+addFormat(uri);
+addFormat(uriReference);
+addFormat(iri);
+addFormat(iriReference);
+addFormat(uuid);
+addFormat(uriTemplate);
+addFormat(jsonPointer);
+addFormat(relativeJsonPointer);
+addFormat(regex);
+
+export {
+  getShouldValidateFormat,
+  setShouldValidateFormat
+} from "../lib/configuration.js";

package/lib/configuration.js

@@ -1,12 +1,17 @@
 let metaSchemaOutputFormat;
-let shouldValidateSchema = true;
-
 export const getMetaSchemaOutputFormat = () => metaSchemaOutputFormat;
 export const setMetaSchemaOutputFormat = (format) => {
   metaSchemaOutputFormat = format;
 };
 
+let shouldValidateSchema = true;
 export const getShouldValidateSchema = () => shouldValidateSchema;
 export const setShouldValidateSchema = (isEnabled) => {
   shouldValidateSchema = isEnabled;
 };
+
+let shouldValidateFormat;
+export const getShouldValidateFormat = () => shouldValidateFormat;
+export const setShouldValidateFormat = (isEnabled) => {
+  shouldValidateFormat = isEnabled;
+};

package/lib/experimental.d.ts

@@ -61,11 +61,19 @@ export const getKeywordName: (dialectId: string, keywordId: string) => string;
 export const getKeyword: <A>(id: string) => Keyword<A>;
 export const getKeywordByName: <A>(keywordName: string, dialectId: string) => Keyword<A>;
 export const getKeywordId: (keywordName: string, dialectId: string) => string;
+export const addFormat: (format: Format) => void;
+export const setFormatHandler: (keywordUri: string, formatName: string, formatUri: string) => void;
+export const removeFormatHandler: (keywordUri: string, formatName: string) => void;
 export const defineVocabulary: (id: string, keywords: Record<string, string>) => void;
 export const loadDialect: (dialectId: string, dialect: Record<string, boolean>, allowUnknownKeywords?: boolean) => void;
 export const unloadDialect: (dialectId: string) => void;
 export const hasDialect: (dialectId: string) => boolean;
 
+export type Format = {
+  id: string;
+  handler: (value: Json) => boolean;
+};
+
 export type Keyword<A, Context extends ValidationContext = ValidationContext> = {
   id: string;
   compile: (schema: Browser<SchemaDocument>, ast: AST, parentSchema: Browser<SchemaDocument>) => Promise<A>;

package/lib/experimental.js

@@ -1,6 +1,7 @@
 export { compile, interpret, BASIC, DETAILED } from "./core.js";
 export {
   addKeyword, getKeyword, getKeywordByName, getKeywordName, getKeywordId,
+  addFormat, setFormatHandler, removeFormatHandler,
   defineVocabulary,
   loadDialect, unloadDialect, hasDialect
 } from "./keywords.js";

package/lib/keywords/dynamicRef.js

@@ -10,7 +10,7 @@ const compile = async (schema, ast) => {
   const self = await Browser.get(schema.document.baseUri, schema);
   await Validation.compile(self, ast);
 
-  return reference;
+  return reference.startsWith("#") ? reference.slice(1) : reference;
 };
 
 const interpret = (fragment, instance, context) => {

package/lib/keywords/format.js

@@ -1,10 +1,43 @@
 import * as Browser from "@hyperjump/browser";
+import * as Instance from "../instance.js";
+import { getFormatHandler } from "../keywords.js";
 
 
 const id = "https://json-schema.org/keyword/format";
 
 const compile = (schema) => Browser.value(schema);
-const interpret = () => true;
+
+const interpret = (format, instance) => {
+  const handler = getFormatHandler(formats[format]);
+  if (!handler) {
+    throw Error(`The '${format}' format is not supported.`);
+  }
+
+  return handler(Instance.value(instance));
+};
+
 const annotation = (format) => format;
 
-export default { id, compile, interpret, annotation };
+const formats = {
+  "date-time": "https://json-schema.org/format/date-time",
+  "date": "https://json-schema.org/format/date",
+  "time": "https://json-schema.org/format/time",
+  "duration": "https://json-schema.org/format/duration",
+  "email": "https://json-schema.org/format/email",
+  "idn-email": "https://json-schema.org/format/idn-email",
+  "hostname": "https://json-schema.org/format/hostname",
+  "idn-hostname": "https://json-schema.org/format/idn-hostname",
+  "ipv4": "https://json-schema.org/format/ipv4",
+  "ipv6": "https://json-schema.org/format/ipv6",
+  "uri": "https://json-schema.org/format/uri",
+  "uri-reference": "https://json-schema.org/format/uri-reference",
+  "iri": "https://json-schema.org/format/iri",
+  "iri-reference": "https://json-schema.org/format/iri-reference",
+  "uuid": "https://json-schema.org/format/uuid",
+  "uri-template": "https://json-schema.org/format/uri-template",
+  "json-pointer": "https://json-schema.org/format/json-pointer",
+  "relative-json-pointer": "https://json-schema.org/format/relative-json-pointer",
+  "regex": "https://json-schema.org/format/regex"
+};
+
+export default { id, compile, interpret, annotation, formats };

package/lib/keywords.js

@@ -34,6 +34,23 @@ export const defineVocabulary = (id, keywords) => {
   _vocabularies[id] = keywords;
 };
 
+const _formats = {};
+export const addFormat = (format) => {
+  _formats[format.id] = format.handler;
+};
+
+export const getFormatHandler = (formatUri) => {
+  return _formats[formatUri];
+};
+
+export const setFormatHandler = (keywordUri, formatName, formatUri) => {
+  _keywords[keywordUri].formats[formatName] = formatUri;
+};
+
+export const removeFormatHandler = (keywordUri, formatName) => {
+  delete _keywords[keywordUri].formats[formatName];
+};
+
 const _dialects = {};
 
 export const getKeywordId = (keyword, dialectId) => {
@@ -74,9 +91,14 @@ export const loadDialect = (dialectId, dialect, allowUnknownKeywords = false, is
     if (vocabularyId in _vocabularies) {
       for (const keyword in _vocabularies[vocabularyId]) {
         let keywordId = _vocabularies[vocabularyId][keyword];
-        if (!(keywordId in _keywords) && !dialect[vocabularyId]) {
-          // Allow keyword to be ignored
-          keywordId = `https://json-schema.org/keyword/unknown#${keyword}`;
+        if (!dialect[vocabularyId]) {
+          if (vocabularyId === "https://json-schema.org/draft/2019-09/vocab/format") {
+            // Handle inconsistent 2019-09 behavior
+            keywordId = "https://json-schema.org/keyword/draft-2019-09/format";
+          } else if (!(keywordId in _keywords)) {
+            // Allow keyword to be ignored
+            keywordId = `https://json-schema.org/keyword/unknown#${keyword}`;
+          }
         }
         _dialects[dialectId].keywords[keyword] = keywordId;
       }

package/openapi-3-0/index.js

@@ -38,7 +38,7 @@ defineVocabulary(jsonSchemaVersion, {
   "exclusiveMaximum": "https://json-schema.org/keyword/draft-04/exclusiveMaximum",
   "exclusiveMinimum": "https://json-schema.org/keyword/draft-04/exclusiveMinimum",
   "externalDocs": "https://spec.openapis.org/oas/3.0/keyword/externalDocs",
-  "format": "https://json-schema.org/keyword/format",
+  "format": "https://json-schema.org/keyword/draft-04/format",
   "items": "https://json-schema.org/keyword/draft-04/items",
   "maxItems": "https://json-schema.org/keyword/maxItems",
   "maxLength": "https://json-schema.org/keyword/maxLength",

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@hyperjump/json-schema",
-  "version": "1.16.5",
+  "version": "1.17.0",
   "description": "A JSON Schema validator with support for custom keywords, vocabularies, and dialects",
   "type": "module",
-  "main": "./stable/index.js",
+  "main": "./v1/index.js",
   "exports": {
-    ".": "./stable/index.js",
+    ".": "./v1/index.js",
     "./draft-04": "./draft-04/index.js",
     "./draft-06": "./draft-06/index.js",
     "./draft-07": "./draft-07/index.js",
@@ -18,11 +18,13 @@
     "./instance/experimental": "./lib/instance.js",
     "./annotations/experimental": "./annotations/index.js",
     "./annotated-instance/experimental": "./annotations/annotated-instance.js",
-    "./bundle": "./bundle/index.js"
+    "./bundle": "./bundle/index.js",
+    "./formats": "./formats/index.js",
+    "./formats-lite": "./formats/lite.js"
   },
   "scripts": {
     "clean": "xargs -a .gitignore rm -rf",
-    "lint": "eslint lib stable draft-* openapi-* bundle annotations",
+    "lint": "eslint lib v1 draft-* openapi-* bundle annotations",
     "test": "vitest --watch=false",
     "check-types": "tsc --noEmit"
   },
@@ -67,6 +69,7 @@
   },
   "dependencies": {
     "@hyperjump/json-pointer": "^1.1.0",
+    "@hyperjump/json-schema-formats": "^1.0.0",
     "@hyperjump/pact": "^1.2.0",
     "@hyperjump/uri": "^1.2.0",
     "content-type": "^1.0.4",

package/v1/extension-tests/conditional.json

@@ -0,0 +1,289 @@
+[
+    {
+        "description": "if - then",
+        "schema": {
+            "conditional": [
+                { "type": "string" },
+                { "maxLength": 5 }
+            ]
+        },
+        "tests": [
+            {
+                "description": "if passes, then passes",
+                "data": "foo",
+                "valid": true
+            },
+            {
+                "description": "if passes, then fails",
+                "data": "foobar",
+                "valid": false
+            },
+            {
+                "description": "if fails",
+                "data": 42,
+                "valid": true
+            }
+        ]
+    },
+    {
+        "description": "if - then - else",
+        "schema": {
+            "conditional": [
+                { "type": "string" },
+                { "maxLength": 5 },
+                { "type": "number" }
+            ]
+        },
+        "tests": [
+            {
+                "description": "if passes, then passes",
+                "data": "foo",
+                "valid": true
+            },
+            {
+                "description": "if passes, then fails",
+                "data": "foobar",
+                "valid": false
+            },
+            {
+                "description": "if fails, else passes",
+                "data": 42,
+                "valid": true
+            },
+            {
+                "description": "if fails, else fails",
+                "data": true,
+                "valid": false
+            }
+        ]
+    },
+    {
+        "description": "if - then - elseif - then",
+        "schema": {
+            "conditional": [
+                { "type": "string" },
+                { "maxLength": 5 },
+                { "type": "number" },
+                { "maximum": 50 }
+            ]
+        },
+        "tests": [
+            {
+                "description": "if passes, then passes",
+                "data": "foo",
+                "valid": true
+            },
+            {
+                "description": "if passes, then fails",
+                "data": "foobar",
+                "valid": false
+            },
+            {
+                "description": "if fails, elseif passes, then passes",
+                "data": 42,
+                "valid": true
+            },
+            {
+                "description": "if fails, elseif passes, then fails",
+                "data": 100,
+                "valid": false
+            },
+            {
+                "description": "if fails, elseif fails",
+                "data": true,
+                "valid": true
+            }
+        ]
+    },
+    {
+        "description": "if - then - elseif - then - else",
+        "schema": {
+            "conditional": [
+                { "type": "string" },
+                { "maxLength": 5 },
+                { "type": "number" },
+                { "maximum": 50 },
+                { "const": true }
+            ]
+        },
+        "tests": [
+            {
+                "description": "if passes, then passes",
+                "data": "foo",
+                "valid": true
+            },
+            {
+                "description": "if passes, then fails",
+                "data": "foobar",
+                "valid": false
+            },
+            {
+                "description": "if fails, elseif passes, then passes",
+                "data": 42,
+                "valid": true
+            },
+            {
+                "description": "if fails, elseif passes, then fails",
+                "data": 100,
+                "valid": false
+            },
+            {
+                "description": "if fails, elseif fails, else passes",
+                "data": true,
+                "valid": true
+            },
+            {
+                "description": "if fails, elseif fails, else fails",
+                "data": false,
+                "valid": false
+            }
+        ]
+    },
+    {
+        "description": "nested if - then - elseif - then - else",
+        "schema": {
+            "conditional": [
+                [
+                    { "type": "string" },
+                    { "maxLength": 5 }
+                ],
+                [
+                    { "type": "number" },
+                    { "maximum": 50 }
+                ],
+                { "const": true }
+            ]
+        },
+        "tests": [
+            {
+                "description": "if passes, then passes",
+                "data": "foo",
+                "valid": true
+            },
+            {
+                "description": "if passes, then fails",
+                "data": "foobar",
+                "valid": false
+            },
+            {
+                "description": "if fails, elseif passes, then passes",
+                "data": 42,
+                "valid": true
+            },
+            {
+                "description": "if fails, elseif passes, then fails",
+                "data": 100,
+                "valid": false
+            },
+            {
+                "description": "if fails, elseif fails, else passes",
+                "data": true,
+                "valid": true
+            },
+            {
+                "description": "if fails, elseif fails, else fails",
+                "data": false,
+                "valid": false
+            }
+        ]
+    },
+    {
+        "description": "if - then - else with unevaluatedProperties",
+        "schema": {
+            "allOf": [
+                {
+                    "properties": {
+                        "foo": {}
+                    },
+                    "conditional": [
+                        { "required": ["foo"] },
+                        {
+                            "properties": {
+                                "bar": {}
+                            }
+                        },
+                        {
+                            "properties": {
+                                "baz": {}
+                            }
+                        }
+                    ]
+                }
+            ],
+            "unevaluatedProperties": false
+        },
+        "tests": [
+            {
+                "description": "if foo, then bar is allowed",
+                "data": { "foo": 42, "bar": true },
+                "valid": true
+            },
+            {
+                "description": "if foo, then baz is not allowed",
+                "data": { "foo": 42, "baz": true },
+                "valid": false
+            },
+            {
+                "description": "if not foo, then baz is allowed",
+                "data": { "baz": true },
+                "valid": true
+            },
+            {
+                "description": "if not foo, then bar is not allowed",
+                "data": { "bar": true },
+                "valid": false
+            }
+        ]
+    },
+    {
+        "description": "if - then - else with unevaluatedItems",
+        "schema": {
+            "allOf": [
+                {
+                    "conditional": [
+                        { "prefixItems": [{ "const": "foo" }] },
+                        {
+                            "prefixItems": [{}, { "const": "bar" }]
+                        },
+                        {
+                            "prefixItems": [{}, { "const": "baz" }]
+                        }
+                    ]
+                }
+            ],
+            "unevaluatedItems": false
+        },
+        "tests": [
+            {
+                "description": "foo, bar",
+                "data": ["foo", "bar"],
+                "valid": true
+            },
+            {
+                "description": "foo, baz",
+                "data": ["foo", "baz"],
+                "valid": false
+            },
+            {
+                "description": "foo, bar, additional",
+                "data": ["foo", "bar", ""],
+                "valid": false
+            },
+            {
+                "description": "not-foo, baz",
+                "data": ["not-foo", "baz"],
+                "valid": true
+            },
+            {
+                "description": "not-foo, bar",
+                "data": ["not-foo", "bar"],
+                "valid": false
+            },
+            {
+                "description": "not-foo, baz, additional",
+                "data": ["not-foo", "baz", ""],
+                "valid": false
+            }
+        ]
+    }
+]