json-schema-library 5.2.1 → 6.1.0

package/lib/step.ts

@@ -2,13 +2,17 @@ import getTypeOf from "./getTypeOf";
 import createSchemaOf from "./createSchemaOf";
 import errors from "./validation/errors";
 import merge from "./utils/merge";
-import { JSONSchema, JSONPointer, JSONError } from "./types";
+import { JSONSchema, JSONPointer, JSONError, isJSONError } from "./types";
 import Core from "./cores/CoreInterface";
 
-
 const stepType = {
-
-    array: (core: Core, key: string|number, schema: JSONSchema, data: any, pointer: JSONPointer): JSONSchema|JSONError => {
+    array: (
+        core: Core,
+        key: string | number,
+        schema: JSONSchema,
+        data: any,
+        pointer: JSONPointer
+    ): JSONSchema | JSONError => {
         const itemsType = getTypeOf(schema.items);
 
         if (itemsType === "object") {
@@ -33,12 +37,29 @@ const stepType = {
         }
 
         if (itemsType === "array") {
+            // @draft >= 7 bool schema, items:[true, false]
+            if (schema.items[key] === true) {
+                return createSchemaOf(data[key]);
+            }
+            // @draft >= 7 bool schema, items:[true, false]
+            if (schema.items[key] === false) {
+                return errors.invalidDataError({
+                    key,
+                    value: data[key],
+                    pointer
+                });
+            }
+
             if (schema.items[key]) {
                 return core.resolveRef(schema.items[key]);
             }
 
             if (schema.additionalItems === false) {
-                return errors.additionalItemsError({ key, value: data[key], pointer });
+                return errors.additionalItemsError({
+                    key,
+                    value: data[key],
+                    pointer
+                });
             }
 
             if (schema.additionalItems === true || schema.additionalItems === undefined) {
@@ -49,7 +70,13 @@ const stepType = {
                 return schema.additionalItems;
             }
 
-            throw new Error(`Invalid schema ${JSON.stringify(schema, null, 4)} for ${JSON.stringify(data, null, 4)}`);
+            throw new Error(
+                `Invalid schema ${JSON.stringify(schema, null, 4)} for ${JSON.stringify(
+                    data,
+                    null,
+                    4
+                )}`
+            );
         }
 
         if (schema.additionalItems !== false && data[key]) {
@@ -61,14 +88,19 @@ const stepType = {
         return new Error(`Invalid array schema for ${key} at ${pointer}`) as JSONError;
     },
 
-    object: (core: Core, key: string|number, schema: JSONSchema, data: any, pointer: JSONPointer): JSONSchema|JSONError => {
-
+    object: (
+        core: Core,
+        key: string | number,
+        schema: JSONSchema,
+        data: any,
+        pointer: JSONPointer
+    ): JSONSchema | JSONError => {
         if (Array.isArray(schema.oneOf)) {
             // update current schema
             const oneOfSchema = core.resolveOneOf(data, schema, pointer);
             // resolveOneOf does currently not apply merge with base schema
             schema = merge(schema, oneOfSchema);
-            if (schema && schema.type === "error") {
+            if (isJSONError(schema)) {
                 return schema;
             }
         }
@@ -76,7 +108,7 @@ const stepType = {
         if (Array.isArray(schema.anyOf)) {
             // update current schema
             schema = core.resolveAnyOf(data, schema, pointer);
-            if (schema && schema.type === "error") {
+            if (isJSONError(schema)) {
                 return schema;
             }
         }
@@ -84,7 +116,7 @@ const stepType = {
         if (Array.isArray(schema.allOf)) {
             // update current schema
             schema = core.resolveAllOf(data, schema, pointer);
-            if (schema && schema.type === "error") {
+            if (isJSONError(schema)) {
                 return schema;
             }
         }
@@ -96,7 +128,7 @@ const stepType = {
             // @todo patternProperties also validate properties
 
             targetSchema = core.resolveRef(schema.properties[key]);
-            if (targetSchema && targetSchema.type === "error") {
+            if (isJSONError(targetSchema)) {
                 return targetSchema;
             }
 
@@ -104,9 +136,17 @@ const stepType = {
             if (targetSchema && Array.isArray(targetSchema.oneOf)) {
                 // @special case: this is a mix of a schema and optional definitions
                 // we resolve the schema here and add the original schema to `oneOfSchema`
-                let resolvedSchema = core.resolveOneOf(data[key], targetSchema, `${pointer}/${key}`);
+                let resolvedSchema = core.resolveOneOf(
+                    data[key],
+                    targetSchema,
+                    `${pointer}/${key}`
+                );
+
+                const oneOfIndex = targetSchema.oneOf.findIndex((s) => s === resolvedSchema);
+
                 resolvedSchema = JSON.parse(JSON.stringify(resolvedSchema));
                 resolvedSchema.variableSchema = true;
+                resolvedSchema.oneOfIndex = oneOfIndex;
                 resolvedSchema.oneOfSchema = targetSchema;
                 return resolvedSchema;
             }
@@ -117,6 +157,24 @@ const stepType = {
             }
         }
 
+        // @draft <= 07
+        const { dependencies } = schema;
+        if (getTypeOf(dependencies) === "object") {
+            const dependentProperties = Object.keys(dependencies).filter(
+                (propertyName) =>
+                    // data[propertyName] !== undefined &&
+                    getTypeOf(dependencies[propertyName]) === "object"
+            );
+
+            for (let i = 0, l = dependentProperties.length; i < l; i += 1) {
+                const dependentProperty = dependentProperties[i];
+                const schema = step(core, key, dependencies[dependentProperty], data);
+                if (!isJSONError(schema)) {
+                    return schema;
+                }
+            }
+        }
+
         // find matching property key
         if (getTypeOf(schema.patternProperties) === "object") {
             let regex;
@@ -134,14 +192,18 @@ const stepType = {
         }
 
         if (schema.additionalProperties === true) {
-            return createSchemaOf(data);
+            return createSchemaOf(data[key]);
         }
 
-        return errors.unknownPropertyError({ property: key, value: data, pointer });
+        return errors.unknownPropertyError({
+            property: key,
+            value: data,
+            // pointer: `${pointer}/${key}`,
+            pointer: `${pointer}`
+        });
     }
 };
 
-
 /**
  * Returns the json-schema of the given object property or array item.
  * e.g. it steps by one key into the data
@@ -149,15 +211,34 @@ const stepType = {
  *  This helper determines the location of the property within the schema (additional properties, oneOf, ...) and
  *  returns the correct schema.
  *
- * @param  core     - validator
- * @param  key      - property-name or array-index
- * @param  schema          - json schema of current data
+ * @param  core      - validator
+ * @param  key       - property-name or array-index
+ * @param  schema    - json schema of current data
  * @param  data      - parent of key
- * @param  [pointer]
+ * @param  [pointer] - pointer to schema and data (parent of key)
  * @return Schema or Error if failed resolving key
  */
-export default function step(core: Core, key: string|number, schema: JSONSchema, data?: any, pointer: JSONPointer = "#"):
-JSONSchema|JSONError {
+export default function step(
+    core: Core,
+    key: string | number,
+    schema: JSONSchema,
+    data?: any,
+    pointer: JSONPointer = "#"
+): JSONSchema | JSONError {
+    // @draft >= 4 ?
+    if (Array.isArray(schema.type)) {
+        const dataType = getTypeOf(data);
+        if (schema.type.includes(dataType)) {
+            return stepType[dataType](core, key, schema, data, pointer);
+        }
+        return core.errors.typeError({
+            value: data,
+            pointer,
+            expected: schema.type,
+            received: dataType
+        });
+    }
+
     const expectedType = schema.type || getTypeOf(data);
     if (stepType[expectedType]) {
         return stepType[expectedType](core, key, schema, data, pointer);

package/lib/types.ts

@@ -1,19 +1,36 @@
 import Core from "./cores/CoreInterface";
 
-
-export type JSONSchema = { [p:string]: any };
+export type JSONSchema = { [p: string]: any };
 
 export type JSONPointer = string;
 
 export type JSONError = {
-    type: "error"|"string";
+    type: "error";
     name: string;
     code: string;
     message: string;
     data?: { [p: string]: any };
     [p: string]: any;
+};
+
+/**
+ * ts type guard for json error
+ * @returns true if passed type is a JSONError
+ */
+export function isJSONError(error): error is JSONError {
+    return error?.type === "error";
 }
 
 export interface JSONValidator {
-    (core: Core, schema: JSONSchema, value: any, pointer: JSONPointer): void|undefined|JSONError|Array<JSONError>;
+    (core: Core, schema: JSONSchema, value: any, pointer: JSONPointer):
+        | void
+        | undefined
+        | JSONError
+        | JSONError[];
+}
+
+export interface JSONTypeValidator {
+    (core: Core, schema: JSONSchema, value: any, pointer: JSONPointer): Array<
+        void | undefined | JSONError | JSONError[]
+    >;
 }

package/lib/utils/filter.ts

@@ -1,15 +1,13 @@
+import { isJSONError } from "../types";
+
 export function isPromise(obj) {
     return obj instanceof Promise;
 }
 
-export function isError(obj) {
-    return obj && obj.type === "error";
-}
-
 export function errorOrPromise(error) {
-    return isError(error) || isPromise(error);
+    return isJSONError(error) || isPromise(error);
 }
 
 export function errorsOnly(error) {
-    return isError(error);
+    return isJSONError(error);
 }

package/lib/utils/merge.ts

@@ -1,3 +1,7 @@
 import deepmerge from "deepmerge";
 const overwriteMerge = (destinationArray, sourceArray) => sourceArray;
+
+/**
+ * returns a new json-schema, where properties are combined and arrays are replaced
+ */
 export default <T, K>(a: T, b: K): T & K => deepmerge(a, b, { arrayMerge: overwriteMerge });

package/lib/validate.ts

@@ -1,23 +1,22 @@
-import getTypeOf from "./getTypeOf";
+import getTypeOf, { JSType } from "./getTypeOf";
 import { errorOrPromise } from "./utils/filter";
 import flattenArray from "./utils/flattenArray";
-import { JSONSchema, JSONPointer, JSONError } from "./types";
+import { JSONSchema, JSONPointer, JSONError, isJSONError } from "./types";
 import Core from "./cores/CoreInterface";
+import equal from "fast-deep-equal";
 
-
-function getJsonSchemaType(value, expectedType) {
-    let jsType = getTypeOf(value);
-
+function getJsonSchemaType(value: unknown, expectedType: string | string[]): JSType | "integer" {
+    const jsType = getTypeOf(value);
     if (
-        jsType === "number" && (expectedType === "integer" ||
-        (Array.isArray(expectedType) && expectedType.includes("integer")))
+        jsType === "number" &&
+        (expectedType === "integer" ||
+            (Array.isArray(expectedType) && expectedType.includes("integer")))
     ) {
-        jsType = Number.isInteger(value) ? "integer" : "number";
+        return Number.isInteger(value) ? "integer" : "number";
     }
     return jsType;
 }
 
-
 /**
  * Validate data by a json schema
  *
@@ -27,18 +26,49 @@ function getJsonSchemaType(value, expectedType) {
  * @param [pointer] - json pointer pointing to value (used for error-messages only)
  * @return list of errors or empty
  */
-export default function validate(core: Core, value: any, schema: JSONSchema = core.rootSchema, pointer: JSONPointer = "#"): Array<JSONError> {
-    if (schema.type === "error") {
+export default function validate(
+    core: Core,
+    value: unknown,
+    schema: JSONSchema = core.rootSchema,
+    pointer: JSONPointer = "#"
+): Array<JSONError> {
+    schema = core.resolveRef(schema);
+
+    // this is a high level v7 schema validation
+    if (getTypeOf(schema) === "boolean") {
+        if (schema) {
+            return [];
+        }
+        return [core.errors.invalidDataError({ value, pointer })];
+    }
+
+    if (isJSONError(schema)) {
         return [schema as JSONError];
     }
 
-    schema = core.resolveRef(schema);
+    // @draft >= 6 const
+    if (schema.const !== undefined) {
+        if (equal(schema.const, value)) {
+            return [];
+        }
+        return [core.errors.constError({ value, expected: schema.const, pointer })];
+    }
 
     const receivedType = getJsonSchemaType(value, schema.type);
     const expectedType = schema.type || receivedType;
 
-    if (receivedType !== expectedType && (!Array.isArray(expectedType) || !expectedType.includes(receivedType))) {
-        return [core.errors.typeError({ received: receivedType, expected: expectedType, value, pointer })];
+    if (
+        receivedType !== expectedType &&
+        (!Array.isArray(expectedType) || !expectedType.includes(receivedType))
+    ) {
+        return [
+            core.errors.typeError({
+                received: receivedType,
+                expected: expectedType,
+                value,
+                pointer
+            })
+        ];
     }
 
     if (core.validateType[receivedType] == null) {

package/lib/validateAsync.ts

@@ -1,9 +1,8 @@
-import { isError, errorsOnly } from "./utils/filter";
+import { errorsOnly } from "./utils/filter";
 import flattenArray from "./utils/flattenArray";
-import { JSONSchema, JSONPointer, JSONError } from "./types";
+import { JSONSchema, JSONPointer, JSONError, isJSONError } from "./types";
 import Core from "./cores/CoreInterface";
 
-
 function createErrorNotification(onError: OnError) {
     return function notifyError(error) {
         if (Array.isArray(error)) {
@@ -11,14 +10,13 @@ function createErrorNotification(onError: OnError) {
             error.forEach(notifyError);
             return error;
         }
-        if (isError(error)) {
+        if (isJSONError(error)) {
             onError(error);
         }
         return error;
     };
 }
 
-
 export interface OnError {
     (error: JSONError): void;
 }
@@ -27,7 +25,7 @@ export type Options = {
     schema?: JSONSchema;
     pointer?: JSONPointer;
     onError?: OnError;
-}
+};
 
 /**
  * @async
@@ -41,7 +39,11 @@ export type Options = {
  * @param options.onError   - will be called for each error as soon as it is resolved
  * @return list of errors or empty
  */
-export default function validateAsync(core: Core, value: any, options?: Options): Promise<Array<JSONError>> {
+export default function validateAsync(
+    core: Core,
+    value: any,
+    options?: Options
+): Promise<Array<JSONError>> {
     const { schema, pointer, onError } = { schema: core.rootSchema, pointer: "#", ...options };
 
     let errors: Array<JSONError> = core.validate(value, schema, pointer);
@@ -51,17 +53,16 @@ export default function validateAsync(core: Core, value: any, options?: Options)
         for (let i = 0; i < errors.length; i += 1) {
             if (errors[i] instanceof Promise) {
                 errors[i].then(notifyError);
-            } else if (isError(errors[i])) {
+            } else if (isJSONError(errors[i])) {
                 onError(errors[i]);
             }
         }
     }
 
-    return Promise
-        .all(errors)
+    return Promise.all(errors)
         .then(flattenArray)
-        .then(resolvedErrors => resolvedErrors.filter(errorsOnly))
-        .catch(e => {
+        .then((resolvedErrors) => resolvedErrors.filter(errorsOnly))
+        .catch((e) => {
             console.log("Failed resolving promises", e.message);
             console.log(e.stack);
             throw e;

package/lib/validation/errors.ts

@@ -7,17 +7,30 @@ const errors: { [p: string]: CreateError } = {
     additionalPropertiesError: createCustomError("AdditionalPropertiesError"),
     anyOfError: createCustomError("AnyOfError"),
     allOfError: createCustomError("AllOfError"),
+    constError: createCustomError("ConstError"),
+    containsError: createCustomError("ContainsError"),
+    containsArrayError: createCustomError("ContainsArrayError"),
+    containsAnyError: createCustomError("ContainsAnyError"),
     enumError: createCustomError("EnumError"),
-    formatUrlError: createCustomError("FormatUrlError"),
-    formatUriError: createCustomError("FormatUriError"),
+    formatURLError: createCustomError("FormatURLError"),
+    formatURIError: createCustomError("FormatURIError"),
+    formatURIReferenceError: createCustomError("FormatURIReferenceError"),
+    formatURITemplateError: createCustomError("FormatURITemplateError"),
+    formatDateError: createCustomError("FormatDateaError"),
     formatDateTimeError: createCustomError("FormatDateTimeError"),
     formatEmailError: createCustomError("FormatEmailError"),
     formatHostnameError: createCustomError("FormatHostnameError"),
     formatIPV4Error: createCustomError("FormatIPV4Error"),
+    formatIPV4LeadingZeroError: createCustomError("FormatIPV4LeadingZeroError"),
     formatIPV6Error: createCustomError("FormatIPV6Error"),
+    formatIPV6LeadingZeroError: createCustomError("FormatIPV6LeadingZeroError"),
+    formatJSONPointerError: createCustomError("FormatJSONPointerError"),
     formatRegExError: createCustomError("FormatRegExError"),
+    formatTimeError: createCustomError("FormatTimeError"),
     invalidSchemaError: createCustomError("InvalidSchemaError"),
+    invalidDataError: createCustomError("InvalidDataError"),
     invalidTypeError: createCustomError("InvalidTypeError"),
+    invalidPropertyNameError: createCustomError("InvalidPropertyNameError"),
     maximumError: createCustomError("MaximumError"),
     maxItemsError: createCustomError("MaxItemsError"),
     maxLengthError: createCustomError("MaxLengthError"),

package/lib/validation/format.ts

@@ -1,17 +1,50 @@
-/* eslint-disable max-len */
+/* eslint-disable max-len, no-control-regex */
 import errors from "./errors";
 import validUrl from "valid-url";
 
+// referenced
+// https://github.com/cfworker/cfworker/blob/main/packages/json-schema/src/format.ts
+
 // https://gist.github.com/marcelotmelo/b67f58a08bee6c2468f8
 const isValidDateTime = new RegExp("^([0-9]+)-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])[Tt]([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)(\\.[0-9]+)?(([Zz])|([\\+|\\-]([01][0-9]|2[0-3]):[0-5][0-9]))$");
 const isValidIPV4 = /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/;
 const isValidIPV6 = /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i;
 const isValidHostname = /^(?=.{1,255}$)[0-9A-Za-z](?:(?:[0-9A-Za-z]|-){0,61}[0-9A-Za-z])?(?:\.[0-9A-Za-z](?:(?:[0-9A-Za-z]|-){0,61}[0-9A-Za-z])?)*\.?$/;
+const matchDate = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
+const matchTime = /^(\d\d):(\d\d):(\d\d)(\.\d+)?(z|[+-]\d\d(?::?\d\d)?)?$/i;
+const DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+
+const isValidJSONPointer = /^(?:\/(?:[^~/]|~0|~1)*)*$/;
+const isValidRelativeJSONPointer = /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/;
+const isValidURIRef = /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
+// uri-template: https://tools.ietf.org/html/rfc6570
+const isValidURITemplate = /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i;
 
 
 // Default JSON-Schema formats: date-time, email, hostname, ipv4, ipv6, uri, uriref
 export default {
 
+    date:  (core, schema, value, pointer) => {
+        if (typeof value !== "string") {
+            return undefined;
+        }
+        // https://github.com/cfworker/cfworker/blob/main/packages/json-schema/src/format.ts
+        // full-date from http://tools.ietf.org/html/rfc3339#section-5.6
+        const matches = value.match(matchDate);
+        if (!matches) {
+            return errors.formatDateTimeError({ value, pointer });
+        }
+        const year = +matches[1];
+        const month = +matches[2];
+        const day = +matches[3];
+        // https://tools.ietf.org/html/rfc3339#appendix-C
+        const isLeapYear = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+        if (month >= 1 && month <= 12 && day >= 1 && day <= (month == 2 && isLeapYear ? 29 : DAYS[month])) {
+            return undefined;
+        }
+        return errors.formatDateError({ value, pointer });
+    },
+
     "date-time": (core, schema, value, pointer) => {
         if (typeof value !== "string") {
             return undefined;
@@ -63,6 +96,10 @@ export default {
         if (typeof value !== "string" || value === "") {
             return undefined;
         }
+        if (value && value[0] === "0") {
+            // leading zeroes should be rejected, as they are treated as octals
+            return errors.formatIPV4LeadingZeroError({ value, pointer });
+        }
         if (value.length <= 15 && isValidIPV4.test(value)) {
             return undefined;
         }
@@ -73,27 +110,99 @@ export default {
         if (typeof value !== "string" || value === "") {
             return undefined;
         }
+        if (value && value[0] === "0") {
+            // leading zeroes should be rejected, as they are treated as octals
+            return errors.formatIPV6LeadingZeroError({ value, pointer });
+        }
         if (value.length <= 45 && isValidIPV6.test(value)) {
             return undefined;
         }
         return errors.formatIPV6Error({ value, pointer });
     },
 
+    "json-pointer": (core, schema, value, pointer) => {
+        if (typeof value !== "string" || value === "") {
+            return undefined;
+        }
+        if (isValidJSONPointer.test(value)) {
+            return undefined;
+        }
+        return errors.formatJSONPointerError({ value, pointer });
+    },
+
+    "relative-json-pointer": (core, schema, value, pointer) => {
+        if (typeof value !== "string" || value === "") {
+            return undefined;
+        }
+        if (isValidRelativeJSONPointer.test(value)) {
+            return undefined;
+        }
+        return errors.formatJSONPointerError({ value, pointer });
+    },
+
     regex: (core, schema, value, pointer) => {
         if (typeof value === "string" && /\\Z$/.test(value) === false) {
+            try {
+                new RegExp(value);
+                return undefined;
+            } catch (e) {} // eslint-disable-line no-empty
+
+            return errors.formatRegExError({ value, pointer });
+        }
+        // v7 tests, ignore non-regex values
+        if (typeof value === "object" || typeof value === "number" || Array.isArray(value)) {
             return undefined;
         }
         return errors.formatRegExError({ value, pointer });
     },
 
-    uri: (core, schema, value, pointer) => {
+    time: (core, schema, value, pointer) => {
         if (typeof value !== "string") {
             return undefined;
         }
-        if (value === "" || validUrl.isUri(value)) {
+        // https://github.com/cfworker/cfworker/blob/main/packages/json-schema/src/format.ts
+        const matches = value.match(matchTime);
+        if (!matches) {
+            return errors.formatDateTimeError({ value, pointer });
+        }
+        const hour = +matches[1];
+        const minute = +matches[2];
+        const second = +matches[3];
+        const timeZone = !!matches[5];
+        if (((hour <= 23 && minute <= 59 && second <= 59) || (hour == 23 && minute == 59 && second == 60)) && timeZone) {
+            return undefined
+        }
+        return errors.formatTimeError({ value, pointer });
+    },
+
+    uri: (core, schema, value, pointer) => {
+        if (typeof value !== "string" || value === "") {
+            return undefined;
+        }
+        if (validUrl.isUri(value)) {
+            return undefined;
+        }
+        return errors.formatURIError({ value, pointer });
+    },
+
+    "uri-reference": (core, schema, value, pointer) => {
+        if (typeof value !== "string" || value === "") {
+            return undefined;
+        }
+        if (isValidURIRef.test(value)) {
+            return undefined;
+        }
+        return errors.formatURIReferenceError({ value, pointer });
+    },
+
+    "uri-template": (core, schema, value, pointer) => {
+        if (typeof value !== "string" || value === "") {
+            return undefined;
+        }
+        if (isValidURITemplate.test(value)) {
             return undefined;
         }
-        return errors.formatUriError({ value, pointer });
+        return errors.formatURITemplateError({ value, pointer });
     },
 
     url: (core, schema, value, pointer) => {