z-schema 9.0.1 → 10.0.0

package/src/schemas/draft-06-schema.json

@@ -0,0 +1,155 @@
+{
+    "$schema": "http://json-schema.org/draft-06/schema#",
+    "$id": "http://json-schema.org/draft-06/schema#",
+    "title": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "nonNegativeInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "nonNegativeIntegerDefault0": {
+            "allOf": [
+                { "$ref": "#/definitions/nonNegativeInteger" },
+                { "default": 0 }
+            ]
+        },
+        "simpleTypes": {
+            "enum": [
+                "array",
+                "boolean",
+                "integer",
+                "null",
+                "number",
+                "object",
+                "string"
+            ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "uniqueItems": true,
+            "default": []
+        }
+    },
+    "type": ["object", "boolean"],
+    "properties": {
+        "$id": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$schema": {
+            "type": "string",
+            "format": "uri"
+        },
+        "$ref": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": {},
+        "examples": {
+            "type": "array",
+            "items": {}
+        },
+        "multipleOf": {
+            "type": "number",
+            "exclusiveMinimum": 0
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "number"
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "number"
+        },
+        "maxLength": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": { "$ref": "#" },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": {}
+        },
+        "maxItems": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "contains": { "$ref": "#" },
+        "maxProperties": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": { "$ref": "#" },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "propertyNames": { "format": "regex" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "propertyNames": { "$ref": "#" },
+        "const": {},
+        "enum": {
+            "type": "array",
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "format": { "type": "string" },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "default": {}
+}

package/src/utils/schema-regex.ts

@@ -4,9 +4,11 @@
 export function compileSchemaRegex(
   pattern: string
 ): { ok: true; value: RegExp } | { ok: false; error: { pattern: string; message: string } } {
-  // Detect Unicode property escapes
-  const unicodeEscape = /\\[pP]{/;
-  const needsUnicode = unicodeEscape.test(pattern);
+  const unicodePropertyEscape = /\\[pP]{/;
+  const nonBmpCharacter = /[\u{10000}-\u{10FFFF}]/u;
+  const surrogatePairEscape = /\\uD[89AB][0-9A-Fa-f]{2}\\uD[CDEF][0-9A-Fa-f]{2}/;
+  const needsUnicode =
+    unicodePropertyEscape.test(pattern) || nonBmpCharacter.test(pattern) || surrogatePairEscape.test(pattern);
   // Try compiling without 'u' flag if not needed
   if (needsUnicode) {
     // Try compiling with 'u' flag only

package/src/utils/what-is.ts

@@ -42,5 +42,9 @@ export const whatIs = (what: unknown): WHAT_IS => {
 };
 
 export function isObject(value: unknown): value is Record<any, any> {
-  return whatIs(value) === 'object';
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+export function isInteger(value: unknown): value is number {
+  return typeof value === 'number' && Number.isFinite(value) && value % 1 === 0;
 }

package/src/z-schema-base.ts

@@ -1,12 +1,12 @@
 import type { ValidateError } from './errors.js';
 import type { FormatValidatorFn } from './format-validators.js';
-import type { JsonSchemaVersion } from './json-schema.js';
+import type { JsonSchema, JsonSchemaInternal, JsonSchemaVersion } from './json-schema-versions.js';
 import type { SchemaErrorDetail } from './report.js';
 import type { ZSchemaOptions } from './z-schema-options.js';
 
 import { type Errors, getValidateError } from './errors.js';
 import { getSupportedFormats } from './format-validators.js';
-import { type JsonSchema, type JsonSchemaInternal, VERSION_SCHEMA_URL_MAPPING } from './json-schema.js';
+import { VERSION_SCHEMA_URL_MAPPING } from './json-schema-versions.js';
 import { validate as validateJson } from './json-validation.js';
 import { Report } from './report.js';
 import { SchemaCache } from './schema-cache.js';
@@ -16,7 +16,7 @@ import { deepClone } from './utils/clone.js';
 import { get, sortedKeys } from './utils/json.js';
 import { copyProp } from './utils/properties.js';
 import { getRemotePath } from './utils/uri.js';
-import { whatIs } from './utils/what-is.js';
+import { isObject, whatIs } from './utils/what-is.js';
 import { defaultOptions, normalizeOptions } from './z-schema-options.js';
 
 export interface ValidateOptions {
@@ -74,10 +74,9 @@ export class ZSchemaBase {
 
     this.validateOptions = options;
 
-    const schemaType = whatIs(schema);
-    if (schemaType !== 'string' && schemaType !== 'object') {
+    if (typeof schema !== 'string' && typeof schema !== 'boolean' && !isObject(schema)) {
       const e = new Error(
-        'Invalid .validate call - schema must be a string or object but ' + schemaType + ' was passed!'
+        'Invalid .validate call - schema must be a string or object but ' + whatIs(schema) + ' was passed!'
       );
       if (callback) {
         setTimeout(function () {

package/src/z-schema-options.ts

@@ -1,7 +1,7 @@
 import type { FormatValidatorFn } from './format-validators.js';
-import type { JsonSchemaVersion } from './json-schema.js';
 import type { Report } from './report.js';
 
+import { CURRENT_DEFAULT_SCHEMA_VERSION, type JsonSchemaVersion } from './json-schema-versions.js';
 import { shallowClone } from './utils/clone.js';
 
 export interface ZSchemaOptions {
@@ -32,7 +32,8 @@ export interface ZSchemaOptions {
 }
 
 export const defaultOptions: ZSchemaOptions = {
-  version: 'draft-04',
+  // default version to validate against
+  version: CURRENT_DEFAULT_SCHEMA_VERSION,
   // default timeout for all async tasks
   asyncTimeout: 2000,
   // force additionalProperties and additionalItems to be defined on "object" and "array" types

package/src/z-schema-reader.ts

@@ -1,4 +1,4 @@
-import type { JsonSchema } from './json-schema.js';
+import type { JsonSchema } from './json-schema-versions.js';
 
 // a sync function that loads schemas for future use, for example from schemas directory, during server startup
 export type SchemaReader = (uri: string) => JsonSchema;

package/src/z-schema-versions.ts

@@ -0,0 +1,38 @@
+// import schemas so they don't have to be downloaded for validation purposes
+import type { JsonSchema, JsonSchemaInternal } from './json-schema-versions.js';
+import type { ZSchemaOptions } from './z-schema-options.js';
+
+import { SchemaCache } from './schema-cache.js';
+import { normalizeOptions } from './z-schema-options.js';
+
+import _Draft4HyperSchema from './schemas/draft-04-hyper-schema.json' with { type: 'json' };
+import _Draft4Schema from './schemas/draft-04-schema.json' with { type: 'json' };
+import _Draft6HyperSchema from './schemas/draft-06-hyper-schema.json' with { type: 'json' };
+import _Draft6Links from './schemas/draft-06-links.json' with { type: 'json' };
+import _Draft6Schema from './schemas/draft-06-schema.json' with { type: 'json' };
+
+const Draft4Schema: JsonSchema = _Draft4Schema;
+const Draft4HyperSchema: JsonSchema = _Draft4HyperSchema;
+const Draft6Schema: JsonSchema = _Draft6Schema;
+const Draft6HyperSchema: JsonSchema = _Draft6HyperSchema;
+const Draft6Links: JsonSchema = _Draft6Links;
+
+const registerRemoteReference = (uri: string, schema: JsonSchema, validationOptions?: ZSchemaOptions) => {
+  const preparedSchema = schema as JsonSchemaInternal;
+
+  if (!preparedSchema.id) {
+    preparedSchema.id = uri;
+  }
+
+  if (validationOptions) {
+    preparedSchema.__$validationOptions = normalizeOptions(validationOptions);
+  }
+
+  SchemaCache.cacheSchemaByUri(uri, preparedSchema);
+};
+
+registerRemoteReference('http://json-schema.org/draft-04/schema', Draft4Schema, { version: 'none' });
+registerRemoteReference('http://json-schema.org/draft-04/hyper-schema', Draft4HyperSchema, { version: 'none' });
+registerRemoteReference('http://json-schema.org/draft-06/schema', Draft6Schema, { version: 'none' });
+registerRemoteReference('http://json-schema.org/draft-06/hyper-schema', Draft6HyperSchema, { version: 'none' });
+registerRemoteReference('http://json-schema.org/draft-06/links', Draft6Links, { version: 'none' });

package/src/z-schema.ts

@@ -1,10 +1,12 @@
 import type { ValidateError } from './errors.js';
 import type { FormatValidatorFn } from './format-validators.js';
-import type { JsonSchema, JsonSchemaInternal } from './json-schema.js';
+import type { JsonSchema, JsonSchemaInternal } from './json-schema-versions.js';
 import type { ValidateOptions, ValidateResponse } from './z-schema-base.js';
 import type { ZSchemaOptions } from './z-schema-options.js';
 import type { SchemaReader } from './z-schema-reader.js';
 
+import './z-schema-versions.js';
+
 import { getRegisteredFormats, registerFormat, unregisterFormat } from './format-validators.js';
 import { SchemaCache } from './schema-cache.js';
 import { deepClone } from './utils/clone.js';
@@ -13,11 +15,12 @@ import { ZSchemaBase } from './z-schema-base.js';
 import { defaultOptions, normalizeOptions } from './z-schema-options.js';
 import { getSchemaReader, setSchemaReader } from './z-schema-reader.js';
 
-// import schemas so they don't have to be downloaded for validation purposes
-import _Draft4HyperSchema from './schemas/draft-04-hyper-schema.json' with { type: 'json' };
-import _Draft4Schema from './schemas/draft-04-schema.json' with { type: 'json' };
-
 export class ZSchema extends ZSchemaBase {
+  /** @deprecated Use ZSchema.create() instead. */
+  private constructor(options?: ZSchemaOptions) {
+    super(options);
+  }
+
   // ----- static methods start -----
 
   // class scoped format functions
@@ -85,14 +88,18 @@ export class ZSchema extends ZSchemaBase {
     delete options.safe;
     (options as any).__called_from_factory__ = true;
     if (isAsync && isSafe) {
+      // @ts-expect-error Factory can use private/deprecated constructor
       return new ZSchemaAsyncSafe(options);
     }
     if (isAsync) {
+      // @ts-expect-error Factory can use private/deprecated constructor
       return new ZSchemaAsync(options);
     }
     if (isSafe) {
+      // @ts-expect-error Factory can use private/deprecated constructor
       return new ZSchemaSafe(options);
     }
+    // Factory can use private/deprecated constructor
     return new ZSchema(options);
   }
 
@@ -148,6 +155,11 @@ export class ZSchema extends ZSchemaBase {
 }
 
 export class ZSchemaSafe extends ZSchemaBase {
+  /** @deprecated Use ZSchema.create() instead. */
+  private constructor(options?: ZSchemaOptions) {
+    super(options);
+  }
+
   validate(json: unknown, schema: JsonSchema | string, options: ValidateOptions = {}): ValidateResponse {
     try {
       this._validate(json, schema, options);
@@ -168,6 +180,11 @@ export class ZSchemaSafe extends ZSchemaBase {
 }
 
 export class ZSchemaAsync extends ZSchemaBase {
+  /** @deprecated Use ZSchema.create() instead. */
+  private constructor(options?: ZSchemaOptions) {
+    super(options);
+  }
+
   validate(json: unknown, schema: JsonSchema | string, options: ValidateOptions = {}): Promise<true> {
     return new Promise((resolve, reject) => {
       try {
@@ -184,6 +201,11 @@ export class ZSchemaAsync extends ZSchemaBase {
 }
 
 export class ZSchemaAsyncSafe extends ZSchemaBase {
+  /** @deprecated Use ZSchema.create() instead. */
+  private constructor(options?: ZSchemaOptions) {
+    super(options);
+  }
+
   validate(json: unknown, schema: JsonSchema | string, options: ValidateOptions = {}): Promise<ValidateResponse> {
     return new Promise((resolve) => {
       try {
@@ -205,9 +227,3 @@ export class ZSchemaAsyncSafe extends ZSchemaBase {
     }
   }
 }
-
-const Draft4Schema: JsonSchema = _Draft4Schema;
-const Draft4HyperSchema: JsonSchema = _Draft4HyperSchema;
-
-ZSchema.setRemoteReference('http://json-schema.org/draft-04/schema', Draft4Schema, { version: 'none' });
-ZSchema.setRemoteReference('http://json-schema.org/draft-04/hyper-schema', Draft4HyperSchema, { version: 'none' });