@wener/common 1.0.2 → 1.0.4

package/src/jsonschema/JsonSchema.ts

@@ -8,190 +8,158 @@ import { match, P } from 'ts-pattern';
 import type { JsonSchemaDef } from './types';
 
 function _createAjv(opt: Options) {
-  const ajv = new Ajv(opt);
-  addKeywords(ajv);
-  addFormats(ajv);
-  return ajv;
+	const ajv = new Ajv(opt);
+	addKeywords(ajv);
+	addFormats(ajv);
+	return ajv;
 }
 
-type ValidateOptions = {
-  mutate?: boolean;
-  clone?: boolean;
-  ajv?: Ajv;
-};
+type ValidateOptions = { mutate?: boolean; clone?: boolean; ajv?: Ajv };
 
 type ValidateResult<T> =
-  | {
-      data: T;
-      success: true;
-      message: undefined;
-    }
-  | {
-      data: undefined;
-      success: false;
-      message: string;
-      errors: ErrorObject[];
-    };
-
-function validate({
-  schema,
-  data,
-  mutate,
-  clone,
-  ajv,
-}: ValidateOptions & {
-  schema: any;
-  data: any;
-}) {
-  let opts: Options = {
-    // strict: 'log',
-    strict: true,
-    strictSchema: 'log', // skip unknown keywords in schema
-  };
-
-  if (mutate) {
-    Object.assign(opts, {
-      removeAdditional: true,
-      useDefaults: true,
-      coerceTypes: true,
-      allErrors: true,
-    });
-  }
-
-  if (clone) {
-    data = structuredClone(data);
-  }
-
-  if (!ajv) {
-    ajv = JsonSchema.createAjv(opts);
-  }
-
-  const validate = ajv.compile(schema);
-
-  // consider reusing validate instance
-
-  const valid = validate(data);
-  const errors = validate.errors;
-  localize(errors);
-
-  return {
-    data,
-    success: valid,
-    message: ajv.errorsText(errors),
-    errors: errors,
-  };
+	| { data: T; success: true; message: undefined }
+	| { data: undefined; success: false; message: string; errors: ErrorObject[] };
+
+function validate({ schema, data, mutate, clone, ajv }: ValidateOptions & { schema: any; data: any }) {
+	let opts: Options = {
+		// strict: 'log',
+		strict: true,
+		strictSchema: 'log', // skip unknown keywords in schema
+	};
+
+	if (mutate) {
+		Object.assign(opts, { removeAdditional: true, useDefaults: true, coerceTypes: true, allErrors: true });
+	}
+
+	if (clone) {
+		data = structuredClone(data);
+	}
+
+	if (!ajv) {
+		ajv = JsonSchema.createAjv(opts);
+	}
+
+	const validate = ajv.compile(schema);
+
+	// consider reusing validate instance
+
+	const valid = validate(data);
+	const errors = validate.errors;
+	localize(errors);
+
+	return { data, success: valid, message: ajv.errorsText(errors), errors: errors };
 }
 
 type TypeOfSchema<S> = S extends TSchema ? Static<S> : any;
 
 export namespace JsonSchema {
-  export let schemas: JsonSchemaDef[] = [];
-
-  export const createAjv = _createAjv;
-
-  export function addSchema(
-    schema: JsonSchemaDef,
-    {
-      onConflict = 'throw',
-    }: {
-      onConflict?: 'throw' | 'ignore' | 'replace' | ((old: JsonSchemaDef, neo: JsonSchemaDef) => JsonSchemaDef);
-    } = {},
-  ) {
-    if (!schema.$id) throw new Error('Schema must have $id');
-    switch (onConflict) {
-      case 'ignore':
-        onConflict = (old) => old;
-        break;
-      case 'replace':
-        onConflict = (_, neo) => neo;
-        break;
-      case 'throw':
-        onConflict = (old, neo) => {
-          throw new Error(`Schema ${neo.$id} already exists`);
-        };
-        break;
-    }
-    let idx = schemas.findIndex((s) => s.$id === schema.$id);
-    if (idx >= 0) {
-      schemas[idx] = onConflict(schemas[idx], schema);
-    } else {
-      schemas.push(schema);
-    }
-  }
-
-  /**
-   * Check data is valid, will not use default
-   */
-  export function check<S>(schema: S, data: any): ValidateResult<TypeOfSchema<S>> {
-    return validate({ schema, data, mutate: false, clone: true }) as any;
-  }
-
-  /**
-   * Parse data with default value and coerceTypes
-   */
-  export function safeParse<S>(schema: S, data: any): ValidateResult<TypeOfSchema<S>> {
-    return validate({ schema, data, mutate: true, clone: true }) as any;
-  }
-
-  export function parse<S>(schema: S, data: any): TypeOfSchema<S> {
-    const { data: out, message, errors } = validate({ schema, data, mutate: true, clone: true });
-    if (errors) {
-      throw new Error(message);
-    }
-    return out;
-  }
-
-  export function create<S>(schema: S, data?: any): TypeOfSchema<S> {
-    // will not ensure value match the rule
-    return match(schema as JsonSchemaDef)
-      .returnType<any>()
-      .with({ const: P.select() }, (v) => v)
-      .with({ default: P.select() }, (v) => v)
-      .with({ anyOf: P.nonNullable }, (schema) => {
-        return create(schema.anyOf[0]);
-      })
-      .with({ oneOf: P.nonNullable }, (schema) => {
-        return create(schema.oneOf[0]);
-      })
-      .with({ type: 'string' }, (schema) => '')
-      .with({ type: P.union('number', 'integer') }, (schema) => 0)
-      .with({ type: 'object' }, (schema) => {
-        let out = validate({ schema, data: data ?? {}, mutate: true });
-        if (!out.success) {
-          // fallback
-          let obj = data || {};
-          schema.required?.forEach((key) => {
-            if (!(key in obj)) {
-              let last = obj[key];
-              let prop = schema.properties?.[key];
-              if (prop && isNil(last)) obj[key] = JsonSchema.create(prop, last);
-            }
-          });
-          out = validate({ schema, data: obj, mutate: true });
-          if (!out.success) {
-            console.warn(`Failed to create object with schema: ${out.message}`);
-          }
-        }
-        return out.data;
-      })
-      .with({ type: 'null' }, () => null)
-      .with({ type: 'boolean' }, (schema) => false)
-      .with({ type: 'array' }, (schema) => [])
-      .otherwise(() => {
-        return undefined;
-      });
-  }
-
-  export function isPrimitiveType(schema: any): boolean {
-    return match(schema as JsonSchemaDef)
-      .returnType<boolean>()
-      .with({ type: P.union('number', 'integer', 'string', 'boolean') }, () => true)
-      .with({ anyOf: P.nonNullable }, (schema) => {
-        return isPrimitiveType(schema.anyOf[0]);
-      })
-      .with({ oneOf: P.nonNullable }, (schema) => {
-        return isPrimitiveType(schema.oneOf[0]);
-      })
-      .otherwise(() => false);
-  }
+	export let schemas: JsonSchemaDef[] = [];
+
+	export const createAjv = _createAjv;
+
+	export function addSchema(
+		schema: JsonSchemaDef,
+		{
+			onConflict = 'throw',
+		}: {
+			onConflict?: 'throw' | 'ignore' | 'replace' | ((old: JsonSchemaDef, neo: JsonSchemaDef) => JsonSchemaDef);
+		} = {},
+	) {
+		if (!schema.$id) throw new Error('Schema must have $id');
+		switch (onConflict) {
+			case 'ignore':
+				onConflict = (old) => old;
+				break;
+			case 'replace':
+				onConflict = (_, neo) => neo;
+				break;
+			case 'throw':
+				onConflict = (old, neo) => {
+					throw new Error(`Schema ${neo.$id} already exists`);
+				};
+				break;
+		}
+		let idx = schemas.findIndex((s) => s.$id === schema.$id);
+		if (idx >= 0) {
+			schemas[idx] = onConflict(schemas[idx], schema);
+		} else {
+			schemas.push(schema);
+		}
+	}
+
+	/**
+	 * Check data is valid, will not use default
+	 */
+	export function check<S>(schema: S, data: any): ValidateResult<TypeOfSchema<S>> {
+		return validate({ schema, data, mutate: false, clone: true }) as any;
+	}
+
+	/**
+	 * Parse data with default value and coerceTypes
+	 */
+	export function safeParse<S>(schema: S, data: any): ValidateResult<TypeOfSchema<S>> {
+		return validate({ schema, data, mutate: true, clone: true }) as any;
+	}
+
+	export function parse<S>(schema: S, data: any): TypeOfSchema<S> {
+		const { data: out, message, errors } = validate({ schema, data, mutate: true, clone: true });
+		if (errors) {
+			throw new Error(message);
+		}
+		return out;
+	}
+
+	export function create<S>(schema: S, data?: any): TypeOfSchema<S> {
+		// will not ensure value match the rule
+		return match(schema as JsonSchemaDef)
+			.returnType<any>()
+			.with({ const: P.select() }, (v) => v)
+			.with({ default: P.select() }, (v) => v)
+			.with({ anyOf: P.nonNullable }, (schema) => {
+				return create(schema.anyOf[0]);
+			})
+			.with({ oneOf: P.nonNullable }, (schema) => {
+				return create(schema.oneOf[0]);
+			})
+			.with({ type: 'string' }, (schema) => '')
+			.with({ type: P.union('number', 'integer') }, (schema) => 0)
+			.with({ type: 'object' }, (schema) => {
+				let out = validate({ schema, data: data ?? {}, mutate: true });
+				if (!out.success) {
+					// fallback
+					let obj = data || {};
+					schema.required?.forEach((key) => {
+						if (!(key in obj)) {
+							let last = obj[key];
+							let prop = schema.properties?.[key];
+							if (prop && isNil(last)) obj[key] = JsonSchema.create(prop, last);
+						}
+					});
+					out = validate({ schema, data: obj, mutate: true });
+					if (!out.success) {
+						console.warn(`Failed to create object with schema: ${out.message}`);
+					}
+				}
+				return out.data;
+			})
+			.with({ type: 'null' }, () => null)
+			.with({ type: 'boolean' }, (schema) => false)
+			.with({ type: 'array' }, (schema) => [])
+			.otherwise(() => {
+				return undefined;
+			});
+	}
+
+	export function isPrimitiveType(schema: any): boolean {
+		return match(schema as JsonSchemaDef)
+			.returnType<boolean>()
+			.with({ type: P.union('number', 'integer', 'string', 'boolean') }, () => true)
+			.with({ anyOf: P.nonNullable }, (schema) => {
+				return isPrimitiveType(schema.anyOf[0]);
+			})
+			.with({ oneOf: P.nonNullable }, (schema) => {
+				return isPrimitiveType(schema.oneOf[0]);
+			})
+			.otherwise(() => false);
+	}
 }

package/src/jsonschema/types.d.ts

@@ -1,173 +1,163 @@
 type JsonSchemaTypeName =
-  | 'string' //
-  | 'number'
-  | 'integer'
-  | 'boolean'
-  | 'object'
-  | 'array'
-  | 'null';
+	| 'string' //
+	| 'number'
+	| 'integer'
+	| 'boolean'
+	| 'object'
+	| 'array'
+	| 'null';
 
 type JsonValue =
-  | string //
-  | number
-  | boolean
-  | {
-      [key: string]: JsonValue;
-    }
-  | JsonValue[]
-  | null;
+	| string //
+	| number
+	| boolean
+	| { [key: string]: JsonValue }
+	| JsonValue[]
+	| null;
 
 type JsonSchemaVersion =
-  | 'http://json-schema.org/schema' // latest
-  | 'https://json-schema.org/draft/2020-12/schema'
-  // draft-07
-  | 'http://json-schema.org/draft-07/schema#' //
-  | 'http://json-schema.org/draft-07/hyper-schema#';
+	| 'http://json-schema.org/schema' // latest
+	| 'https://json-schema.org/draft/2020-12/schema'
+	// draft-07
+	| 'http://json-schema.org/draft-07/schema#' //
+	| 'http://json-schema.org/draft-07/hyper-schema#';
 
 type JsonSchemaFormatName =
-  //
-  | 'date-time'
-  | 'date'
-  | 'time'
-  | 'duration'
-  //
-  | 'email'
-  | 'idn-email'
-  //
-  | 'hostname'
-  | 'idn-hostname'
-  | 'ipv4'
-  | 'ipv6'
-  //
-  | 'uri'
-  | 'uri-reference'
-  | 'iri'
-  | 'iri-reference'
-  | 'uuid'
-  | 'uri-template'
-  | 'regex'
-  | 'json-pointer'
-  | 'relative-json-pointer';
+	//
+	| 'date-time'
+	| 'date'
+	| 'time'
+	| 'duration'
+	//
+	| 'email'
+	| 'idn-email'
+	//
+	| 'hostname'
+	| 'idn-hostname'
+	| 'ipv4'
+	| 'ipv6'
+	//
+	| 'uri'
+	| 'uri-reference'
+	| 'iri'
+	| 'iri-reference'
+	| 'uuid'
+	| 'uri-template'
+	| 'regex'
+	| 'json-pointer'
+	| 'relative-json-pointer';
 
 export type JsonSchemaDef = {
-  $id?: string;
-  $ref?: string;
-  /**
-   * Meta schema
-   *
-   * Recommended values:
-   * - 'http://json-schema.org/schema#'
-   * - 'http://json-schema.org/hyper-schema#'
-   * - 'http://json-schema.org/draft-07/schema#'
-   * - 'http://json-schema.org/draft-07/hyper-schema#'
-   *
-   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
-   */
-  $schema?: JsonSchemaVersion | string;
-  $comment?: string;
-
-  $defs?: {
-    [key: string]: JsonSchemaDef;
-  };
-
-  type?: JsonSchemaTypeName | JsonSchemaTypeName[];
-  enum?: JsonValue[];
-  const?: JsonValue;
-
-  //region Numeric Validation
-
-  multipleOf?: number;
-  maximum?: number;
-  exclusiveMaximum?: number;
-  minimum?: number;
-  exclusiveMinimum?: number;
-
-  //endregion
-
-  //region String Validation
-
-  maxLength?: number;
-  minLength?: number;
-  pattern?: string;
-
-  //endregion
-
-  //region Array Validation
-
-  items?: JsonSchemaDef | JsonSchemaDef[];
-  additionalItems?: JsonSchemaDef;
-  maxItems?: number;
-  minItems?: number;
-  uniqueItems?: boolean;
-  contains?: JsonSchemaDef;
-  //endregion
-
-  //region Object Validation
-
-  maxProperties?: number;
-  minProperties?: number;
-  required?: string[];
-  properties?: {
-    [key: string]: JsonSchemaDef;
-  };
-  patternProperties?: {
-    [key: string]: JsonSchemaDef;
-  };
-  additionalProperties?: JsonSchemaDef;
-  dependencies?: {
-    [key: string]: JsonSchemaDef | string[];
-  };
-  propertyNames?: JsonSchemaDef;
-  //endregion
-
-  //region Conditional
-
-  if?: JsonSchemaDef;
-  then?: JsonSchemaDef;
-  else?: JsonSchemaDef;
-
-  //endregion
-
-  //region Boolean Logic
-
-  allOf?: JsonSchemaDef[];
-  anyOf?: JsonSchemaDef[];
-  oneOf?: JsonSchemaDef[];
-  not?: JsonSchemaDef;
-  //endregion
-
-  //region Semantic
-
-  format?: JsonSchemaFormatName | string;
-
-  //endregion
-
-  //region String-Encoding Non-JSON Data
-
-  contentMediaType?: string;
-  contentEncoding?: string;
-  contentSchema?: JsonSchemaDef;
-  //endregion
-
-  /**
-   * use {@link $defs} instead
-   */
-  definitions?: Record<string, JsonSchemaDef>;
-
-  //region Meta-Data Annotations
-  /**
-   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-10
-   */
-
-  title?: string;
-  description?: string;
-  default?: JsonValue;
-  readOnly?: boolean;
-  writeOnly?: boolean;
-  examples?: JsonValue;
-  deprecated?: boolean;
+	$id?: string;
+	$ref?: string;
+	/**
+	 * Meta schema
+	 *
+	 * Recommended values:
+	 * - 'http://json-schema.org/schema#'
+	 * - 'http://json-schema.org/hyper-schema#'
+	 * - 'http://json-schema.org/draft-07/schema#'
+	 * - 'http://json-schema.org/draft-07/hyper-schema#'
+	 *
+	 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
+	 */
+	$schema?: JsonSchemaVersion | string;
+	$comment?: string;
+
+	$defs?: { [key: string]: JsonSchemaDef };
+
+	type?: JsonSchemaTypeName | JsonSchemaTypeName[];
+	enum?: JsonValue[];
+	const?: JsonValue;
+
+	//region Numeric Validation
+
+	multipleOf?: number;
+	maximum?: number;
+	exclusiveMaximum?: number;
+	minimum?: number;
+	exclusiveMinimum?: number;
+
+	//endregion
+
+	//region String Validation
+
+	maxLength?: number;
+	minLength?: number;
+	pattern?: string;
+
+	//endregion
+
+	//region Array Validation
+
+	items?: JsonSchemaDef | JsonSchemaDef[];
+	additionalItems?: JsonSchemaDef;
+	maxItems?: number;
+	minItems?: number;
+	uniqueItems?: boolean;
+	contains?: JsonSchemaDef;
+	//endregion
+
+	//region Object Validation
+
+	maxProperties?: number;
+	minProperties?: number;
+	required?: string[];
+	properties?: { [key: string]: JsonSchemaDef };
+	patternProperties?: { [key: string]: JsonSchemaDef };
+	additionalProperties?: JsonSchemaDef;
+	dependencies?: { [key: string]: JsonSchemaDef | string[] };
+	propertyNames?: JsonSchemaDef;
+	//endregion
+
+	//region Conditional
+
+	if?: JsonSchemaDef;
+	then?: JsonSchemaDef;
+	else?: JsonSchemaDef;
+
+	//endregion
+
+	//region Boolean Logic
+
+	allOf?: JsonSchemaDef[];
+	anyOf?: JsonSchemaDef[];
+	oneOf?: JsonSchemaDef[];
+	not?: JsonSchemaDef;
+	//endregion
+
+	//region Semantic
+
+	format?: JsonSchemaFormatName | string;
+
+	//endregion
+
+	//region String-Encoding Non-JSON Data
+
+	contentMediaType?: string;
+	contentEncoding?: string;
+	contentSchema?: JsonSchemaDef;
+	//endregion
+
+	/**
+	 * use {@link $defs} instead
+	 */
+	definitions?: Record<string, JsonSchemaDef>;
+
+	//region Meta-Data Annotations
+	/**
+	 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-10
+	 */
+
+	title?: string;
+	description?: string;
+	default?: JsonValue;
+	readOnly?: boolean;
+	writeOnly?: boolean;
+	examples?: JsonValue;
+	deprecated?: boolean;
 
-  //endregion
+	//endregion
 
-  nullable?: boolean;
+	nullable?: boolean;
 };