@hyperjump/json-schema 1.16.4 → 1.17.0

package/formats/handlers/iri-reference.js

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

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/openapi-3-1/index.d.ts

@@ -180,18 +180,55 @@ type ExternalDocumentation = {
   url: string;
 };
 
-type Parameter = {
+export type Parameter = {
   name: string;
-  in: "query" | "header" | "path" | "cookie";
   description?: string;
   required?: boolean;
   deprecated?: boolean;
   allowEmptyValue?: boolean;
-  style?: "matrix" | "label" | "form" | "simple" | "spaceDelimited" | "pipeDelimited" | "deepObject";
+} & (
+  (
+    {
+      in: "path";
+      required: true;
+    } & (
+      ({ style?: "matrix" | "label" | "simple" } & SchemaParameter)
+      | ContentParameter
+    )
+  ) | (
+    {
+      in: "query";
+    } & (
+      ({ style?: "form" | "spaceDelimited" | "pipeDelimited" | "deepObject" } & SchemaParameter)
+      | ContentParameter
+    )
+  ) | (
+    {
+      in: "header";
+    } & (
+      ({ style?: "simple" } & SchemaParameter)
+      | ContentParameter
+    )
+  ) | (
+    {
+      in: "cookie";
+    } & (
+      ({ style?: "form" } & SchemaParameter)
+      | ContentParameter
+    )
+  )
+);
+
+type ContentParameter = {
+  schema?: never;
+  content: Record<string, MediaType | Reference>;
+};
+
+type SchemaParameter = {
   explode?: boolean;
   allowReserved?: boolean;
-  schema?: OasSchema31;
-  content?: Content;
+  schema: OasSchema32;
+  content?: never;
 } & Examples;
 
 type RequestBody = {
@@ -237,7 +274,7 @@ type Link = {
   parameters?: Record<string, string>;
   requestBody?: Json;
   description?: string;
-  body?: Server;
+  server?: Server;
 };
 
 type Header = {
@@ -259,25 +296,37 @@ type Tag = {
 type Reference = {
   $ref: string;
   summary?: string;
-  descriptions?: string;
+  description?: string;
 };
 
 type SecurityScheme = {
-  type: "apiKey" | "http" | "mutualTLS" | "oauth2" | "openIdConnect";
+  type: "apiKey";
   description?: string;
-  name?: string;
-  in?: "query" | "header" | "cookie";
-  scheme?: string;
+  name: string;
+  in: "query" | "header" | "cookie";
+} | {
+  type: "http";
+  description?: string;
+  scheme: string;
   bearerFormat?: string;
-  flows?: OauthFlows;
-  openIdConnectUrl?: string;
+} | {
+  type: "mutualTLS";
+  description?: string;
+} | {
+  type: "oauth2";
+  description?: string;
+  flows: OauthFlows;
+} | {
+  type: "openIdConnect";
+  description?: string;
+  openIdConnectUrl: string;
 };
 
 type OauthFlows = {
-  implicit: Implicit;
-  Password: Password;
-  clientCredentials: ClientCredentials;
-  authorizationCode: AuthorizationCode;
+  implicit?: Implicit;
+  password?: Password;
+  clientCredentials?: ClientCredentials;
+  authorizationCode?: AuthorizationCode;
 };
 
 type Implicit = {

package/openapi-3-1/schema-draft-2019-09.js

@@ -23,7 +23,7 @@ export default {
     "dialect": { "const": "https://json-schema.org/draft/2019-09/schema" },
 
     "schema": {
-      "$dynamicanchor": "meta",
+      "$dynamicAnchor": "meta",
       "$ref": "https://spec.openapis.org/oas/3.1/dialect/base",
       "properties": {
         "$schema": { "$ref": "#/$defs/dialect" }

package/openapi-3-1/schema-draft-2020-12.js

@@ -23,7 +23,7 @@ export default {
     "dialect": { "const": "https://json-schema.org/draft/2020-12/schema" },
 
     "schema": {
-      "$dynamicanchor": "meta",
+      "$dynamicAnchor": "meta",
       "$ref": "https://spec.openapis.org/oas/3.1/dialect/base",
       "properties": {
         "$schema": { "$ref": "#/$defs/dialect" }

package/openapi-3-2/dialect/base.js

@@ -13,10 +13,10 @@ export default {
   "$dynamicAnchor": "meta",
 
   "title": "OpenAPI 3.2 Schema Object Dialect",
-  "description": "A JSON Schema dialect describing schemas found in OpenAPI v3.2 Descriptions",
+  "description": "A JSON Schema dialect describing schemas found in OpenAPI v3.2.x Descriptions",
 
   "allOf": [
     { "$ref": "https://json-schema.org/draft/2020-12/schema" },
-    { "$ref": "https://spec.openapis.org/oas/3.2/meta/base" }
+    { "$ref": "https://spec.openapis.org/oas/3.2/meta" }
   ]
 };