@wener/common 1.0.5 → 2.0.1

package/src/resource/schema/types.ts

@@ -0,0 +1,105 @@
+import { isValid } from 'date-fns';
+import dayjs from 'dayjs';
+import { z } from 'zod/v4';
+
+const TypeIdSchema = z
+	.string()
+	.regex(/^[a-zA-Z0-9]+_[a-zA-Z0-9]+$/, {
+		error: 'ID格式错误',
+	})
+	.describe('ID');
+
+/*
+XXX-XXX-XXXX
+National: (XXX) XXX-XXXX
+Human: XXX.XXX.XXXX xXXX
+International: +XX (XXX) XXX-XXXX
+
+中国
+XXX XXXX XXXX
+XXX-XXXX-XXXX
+XXXXXXXXXXX
++86 XXX XXXX XXXX
++86 XXXXXXXXXXX
+
+0XX-XXXXXXXX
+0XXX-XXXXXXXX
+(0XX) XXXXXXXX
+0XX XXXX XXXX
+0XXXXXXXX
+
+https://uibakery.io/regex-library/phone-number
+https://fakerjs.dev/api/phone
+ */
+
+const PhoneNumberSchema = z
+	.string()
+	.trim()
+	.max(20)
+	.regex(/(^$)|(^[0-9]*$)/, {
+		error: '电话号码只能包含数字',
+	})
+	.meta({
+		format: 'phone',
+	});
+
+function resourceIdOf(entity: string) {
+	return rz.resourceId.meta({ 'x-ref-entity': entity });
+}
+
+// allow empty string
+const JsonDateSchema = z.coerce
+	.string()
+	.trim()
+	.overwrite((v) => {
+		if (v && !/^\d{4}-\d{2}-\d{2}$/.test(v)) {
+			let val = dayjs(v);
+			if (val.isValid()) {
+				return val.format('YYYY-MM-DD');
+			}
+		}
+		return v;
+	})
+	.regex(/(^$)|(^\d{4}-\d{2}-\d{2}$)/, { error: '错误的日期格式' })
+	.refine((value) => !value || isValid(new Date(value)), {
+		error: '错误的日期',
+	})
+	.nullish()
+	.overwrite((v) => v || undefined)
+	.meta({ format: 'date' });
+
+const JsonDateTimeSchema = z.coerce.date().meta({ format: 'date-time', type: 'string' });
+
+const LoginNameSchema = z
+	.string()
+	.trim()
+	.regex(/^[a-z0-9]{3,16}$/, { error: '登录名只能包含小写字母和数字，长度为3-16位' });
+
+// maybe check valid cjk
+const FriendlyNameSchema = z
+	.string()
+	.trim()
+	.max(50)
+	.refine((v) => !/\p{C}/u.test(v), { message: '包含无效字符' })
+	.describe('名称');
+
+const PasswordSchema = z
+	.string()
+	.min(6, { error: '密码长度至少 6 位' })
+	.max(36, { error: '密码长度最多 36 位' })
+	.regex(/^\S*$/, { error: '密码不能包含空格' })
+	.describe('密码')
+	.meta({ sensitive: true });
+
+export const rz = {
+	resourceIdOf: resourceIdOf,
+	date: JsonDateSchema,
+	dateTime: JsonDateTimeSchema,
+	resourceId: TypeIdSchema,
+	phoneNumber: PhoneNumberSchema,
+	loginName: LoginNameSchema,
+	password: PasswordSchema,
+	friendlyName: FriendlyNameSchema,
+} as const;
+
+export type EnumValues<T> = T[Exclude<keyof T, '__proto__'>];

package/src/schema/TypeSchema.d.ts

@@ -0,0 +1,32 @@
+import type {
+	TSchema,
+	StaticDecode as TypeBoxStaticDecode,
+	StaticEncode as TypeBoxStaticEncode,
+} from '@sinclair/typebox';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { z } from 'zod/v4';
+import type { JsonSchemaDef } from '../jsonschema';
+
+export type TypeSchema<I = unknown, O = I> = TSchema | z.ZodSchema<O, I> | JsonSchemaDef | StandardSchemaV1<I, O>;
+
+export type SchemaOutput<S extends TypeSchema> =
+	S extends StandardSchemaV1<infer I, infer O>
+		? O
+		: S extends z.ZodSchema<infer O, infer I>
+			? O
+			: S extends TSchema
+				? TypeBoxStaticEncode<S>
+				: S extends JsonSchemaDef<infer I, infer O>
+					? O
+					: never;
+
+export type SchemaInput<S extends TypeSchema> =
+	S extends StandardSchemaV1<infer I, infer O>
+		? I
+		: S extends z.ZodSchema<infer O, infer I>
+			? I
+			: S extends TSchema
+				? TypeBoxStaticDecode<S>
+				: S extends JsonSchemaDef<infer I, infer O>
+					? I
+					: never;

package/src/schema/createSchemaData.ts

@@ -0,0 +1,81 @@
+import { match, P } from 'ts-pattern';
+import type { JsonSchemaDef } from '../jsonschema';
+import { toJsonSchema } from './toJsonSchema';
+import type { SchemaOutput, TypeSchema } from './TypeSchema';
+
+export function createSchemaData<S extends TypeSchema>(
+	ts: S,
+	options: CreateSchemaDataOptions = {},
+): Partial<SchemaOutput<S>> {
+	const schema = toJsonSchema(ts);
+	return createJsonSchemaData(schema, options);
+}
+
+type CreateSchemaDataOptions = Partial<CreateOptions> & {
+	all?: boolean;
+};
+
+function createJsonSchemaData(schema: JsonSchemaDef, options: CreateSchemaDataOptions): any {
+	let skip: CreateOptions['skip'] = (s, ctx) => Boolean(!ctx.required && s.nullable);
+	if (options.all) {
+		skip = () => false;
+	}
+	if (options.skip) {
+		skip = options.skip;
+	}
+	return _create(
+		schema,
+		{
+			skip,
+		},
+		{ required: false },
+	);
+}
+
+type CreateOptions = {
+	skip: (schema: JsonSchemaDef, ctx: { required: boolean }) => boolean;
+};
+
+function _create(schema: JsonSchemaDef, options: CreateOptions, ctx: { required: boolean }): any {
+	const { skip } = options;
+	if (skip(schema, ctx)) {
+		return schema.default;
+	}
+	if (schema.default !== undefined) {
+		return schema.default;
+	}
+	return match(schema as JsonSchemaDef)
+		.returnType<any>()
+		.with({ default: P.select() }, (v) => v)
+		.with({ const: P.nonNullable }, (v) => v.const)
+		.with({ anyOf: P.nonNullable }, (schema) => {
+			return _create(schema.anyOf[0], options, { required: false });
+		})
+		.with({ oneOf: P.nonNullable }, (schema) => {
+			return _create(schema.oneOf[0], options, { required: false });
+		})
+		.with({ type: 'string' }, (schema) => '')
+		.with({ type: P.union('number', 'integer') }, (schema) => 0)
+		.with({ type: 'object' }, () => {
+			const out: Record<string, any> = {};
+
+			let required = schema.required || [];
+			for (const [k, v] of Object.entries(schema.properties || {}) as [string, JsonSchemaDef][]) {
+				const value = _create(v, options, {
+					required: required.includes(k),
+				});
+				if (value === undefined) {
+					continue;
+				}
+				out[k] = value;
+			}
+
+			return out;
+		})
+		.with({ type: 'null' }, () => null)
+		.with({ type: 'boolean' }, (schema) => false)
+		.with({ type: 'array' }, (schema) => [])
+		.otherwise(() => {
+			return undefined;
+		});
+}

package/src/schema/findJsonSchemaByPath.ts

@@ -0,0 +1,37 @@
+import { firstOfMaybeArray } from '@wener/utils';
+import { toJsonSchema } from './toJsonSchema';
+import type { TypeSchema } from './TypeSchema';
+
+export function findJsonSchemaByPath(schema: TypeSchema, objectPath: string) {
+	schema = toJsonSchema(schema);
+	if (!objectPath || !schema) {
+		return undefined;
+	}
+
+	const segments = objectPath.split('.');
+	let currentSchema = schema;
+
+	for (const segment of segments) {
+		// 检查当前 schema 是否是对象类型且有 properties
+		if (
+			currentSchema
+			&& typeof currentSchema === 'object'
+			&& currentSchema.properties
+			&& currentSchema.properties[segment]
+		) {
+			currentSchema = currentSchema.properties[segment];
+			continue;
+		}
+
+		if (/^\d$/.test(segment) || segment === '[]') {
+			if (currentSchema.items) {
+				currentSchema = firstOfMaybeArray(currentSchema.items);
+				continue;
+			}
+		}
+
+		return undefined;
+	}
+
+	return currentSchema;
+}

package/src/schema/getSchemaCache.ts

@@ -0,0 +1,21 @@
+import type { JsonSchemaDef } from '../jsonschema';
+import type { TypeSchema } from './TypeSchema';
+
+type SchemaCache = {
+	jsonschema?: JsonSchemaDef;
+	options?: Array<{ value: string; label: string }>;
+};
+const _cache = new WeakMap<any, SchemaCache>();
+
+export function getSchemaCache<K extends keyof SchemaCache>(
+	obj: TypeSchema,
+	key: K,
+	compute: () => NonNullable<SchemaCache[K]>,
+): NonNullable<SchemaCache[K]> {
+	let c = _cache.get(obj);
+	if (!c) {
+		c = {};
+		_cache.set(obj, c);
+	}
+	return (c[key] ??= compute());
+}

package/src/schema/getSchemaOptions.ts

@@ -0,0 +1,24 @@
+import { deepFreeze } from '@wener/utils';
+import { getSchemaCache } from './getSchemaCache';
+import { toJsonSchema } from './toJsonSchema';
+import type { TypeSchema } from './TypeSchema';
+
+export function getSchemaOptions(s: TypeSchema): Array<{ value: string; label: string }> {
+	let js = toJsonSchema(s);
+	return getSchemaCache(s, 'options', () => {
+		let out =
+			(js.anyOf || js.oneOf)?.map((v) => {
+				let value = v.const;
+				return {
+					label: String(v.description || v.title || value),
+					value: value ? String(value) : '',
+				};
+			}) || [];
+		out = deepFreeze(out);
+		return out;
+	});
+}
+
+export function getSchemaOptionLabel(schema: TypeSchema, value: string | undefined | null): string | undefined {
+	return getSchemaOptions(schema).find((v) => v.value === value)?.label;
+}

package/src/schema/index.ts

@@ -0,0 +1,6 @@
+export type * from './TypeSchema';
+export { isJsonSchema, isZodSchema, isTypeBoxSchema, validate, parseData, type ValidationResult } from './validate';
+export { getSchemaOptions, getSchemaOptionLabel } from './getSchemaOptions';
+export { toJsonSchema } from './toJsonSchema';
+export { findJsonSchemaByPath } from './findJsonSchemaByPath';
+export { createSchemaData } from './createSchemaData';

package/src/schema/toJsonSchema.test.ts

@@ -0,0 +1,37 @@
+import { inspect } from 'node:util';
+import { describe, expect, it } from 'vitest';
+import { z } from 'zod/v4';
+import { toJsonSchema } from './toJsonSchema';
+
+describe('toJsonSchema', () => {
+	it('should handle discriminatedUnion', () => {
+		console.log(
+			inspect(
+				toJsonSchema(
+					z.discriminatedUnion('type', [
+						z.object({
+							type: z.literal('string'),
+							value: z.string(),
+						}),
+						z.object({
+							type: z.literal('number'),
+							value: z.number(),
+						}),
+					]),
+				),
+				{
+					depth: 10,
+					colors: true,
+				},
+			),
+		);
+	});
+
+	it('should cache', () => {
+		let zs = z.object({
+			name: z.string(),
+		});
+
+		expect(toJsonSchema(zs)).toBe(toJsonSchema(zs));
+	});
+});

package/src/schema/toJsonSchema.ts

@@ -0,0 +1,200 @@
+import { omit, remove } from 'es-toolkit';
+import { match, P } from 'ts-pattern';
+import { z } from 'zod/v4';
+import type { JsonSchemaDef } from '../jsonschema';
+import { getSchemaCache } from './getSchemaCache';
+import type { TypeSchema } from './TypeSchema';
+import { isTypeBoxSchema, isZodSchema } from './validate';
+
+export function toJsonSchema(schema: TypeSchema): JsonSchemaDef {
+	if (isZodSchema(schema)) {
+		return getSchemaCache(schema, 'jsonschema', () => {
+			// zod v4
+			let js = z.toJSONSchema(schema, {
+				unrepresentable: 'any',
+				override: ({ zodSchema, jsonSchema: js }) => {
+					const def = zodSchema._zod.def;
+					const meta = z.globalRegistry.get(zodSchema);
+					if (meta) {
+						Object.assign(js, meta);
+					}
+					switch (def.type) {
+						case 'union':
+							if (zodSchema._zod.traits.has('ZodDiscriminatedUnion')) {
+								resolveDiscriminator(js as JsonSchemaDef);
+							}
+							break;
+						case 'nonoptional':
+							// js._ref maybe true
+							js.nullable = false;
+							break;
+						case 'nullable':
+						case 'optional':
+							// prefer nullable
+							match(js)
+								.with({ anyOf: [P.select(), { type: 'null' }] }, (select) => {
+									delete js['anyOf'];
+									Object.assign(js, select);
+									js.nullable = true;
+								})
+								.otherwise((js) => {
+									js.nullable = true;
+								});
+							break;
+					}
+				},
+			}) as JsonSchemaDef;
+
+			// remove redundant nullable, ensure required is sorted
+			visit(js, (v) => {
+				if (v.nullable === false) {
+					delete v.nullable;
+				}
+				if (v.required) {
+					v.required.sort();
+				}
+			});
+			// maybe freeze
+			return js;
+		});
+	}
+
+	if (isTypeBoxSchema(schema)) {
+		return schema as JsonSchemaDef;
+	}
+
+	return schema as JsonSchemaDef;
+}
+
+function visit(js: JsonSchemaDef, f: (js: JsonSchemaDef) => void) {
+	const _visit = (
+		js: JsonSchemaDef,
+		f: (js: JsonSchemaDef) => void,
+		parent: JsonSchemaDef | undefined,
+		path: string[],
+		k?: string,
+	) => {
+		if (!js) {
+			return;
+		}
+		f(js);
+		if (js.properties) {
+			for (const [k, v] of Object.entries(js.properties)) {
+				if (v) {
+					_visit(v, f, js, path.concat(k), 'properties');
+				}
+			}
+		} else if (js.items) {
+			if (Array.isArray(js.items)) {
+				for (const v of js.items) {
+					_visit(v, f, js, path, 'items');
+				}
+			} else {
+				_visit(js.items, f, js, path, 'items');
+			}
+		} else if (js.anyOf) {
+			for (const v of js.anyOf) {
+				_visit(v, f, js, path, 'anyOf');
+			}
+		} else if (js.oneOf) {
+			for (const v of js.oneOf) {
+				_visit(v, f, js, path, 'oneOf');
+			}
+		} else if (js.allOf) {
+			for (const v of js.allOf) {
+				_visit(v, f, js, path, 'allOf');
+			}
+		}
+	};
+	_visit(js, f, undefined, []);
+}
+
+function resolveJsonSchemaDef(
+	js: JsonSchemaDef,
+	ctx?: {
+		parent: JsonSchemaDef;
+		key: string;
+	},
+) {
+	return match(js)
+		.with(
+			{
+				anyOf: [P.select(), { type: 'null' }],
+			},
+			(select) => {
+				return { ...omit(js, ['anyOf']), ...select, nullable: true };
+			},
+		)
+		.with({ properties: P.nonNullable }, (schema: JsonSchemaDef) => {
+			for (const key in schema.properties) {
+				const prop = schema.properties[key];
+				if (prop) {
+					schema.properties[key] = resolveJsonSchemaDef(prop, { parent: schema, key });
+				}
+			}
+			return schema;
+		})
+		.otherwise(() => {
+			return js;
+		});
+}
+
+function resolveDiscriminator(jsd: JsonSchemaDef) {
+	if (!(jsd.anyOf && jsd.anyOf.length > 1)) {
+		return;
+	}
+	if (jsd.discriminator) {
+		return;
+	}
+
+	let names: string[] = [];
+	{
+		// candidate for discriminator
+		const v = jsd.anyOf[0];
+		if (v && v.type === 'object' && v.properties) {
+			if (Array.isArray(v.required)) {
+				for (const k of v.required) {
+					if (v.properties[k].const !== undefined) {
+						names.push(k);
+					}
+				}
+			}
+		}
+	}
+	if (names.length >= 1) {
+		for (let i = 0; i < jsd.anyOf.length; i++) {
+			if (i === 0) {
+				// skip first
+				continue;
+			}
+			if (!names.length) {
+				break;
+			}
+
+			const v = jsd.anyOf[i];
+			if (v && v.type === 'object' && v.properties) {
+				const props = v.properties;
+				remove(names, (k) => {
+					// dont care the mapping
+					let p = props[k];
+					switch (typeof p.const) {
+						case 'string':
+						case 'number':
+						case 'boolean':
+							return false;
+						default:
+							return true;
+					}
+				});
+			} else {
+				names = [];
+				break;
+			}
+		}
+	}
+	if (names.length === 1) {
+		jsd.discriminator = {
+			propertyName: names[0],
+		};
+	}
+}

package/src/schema/validate.ts

@@ -0,0 +1,135 @@
+import { Kind as TypeBoxKind, type TSchema } from '@sinclair/typebox';
+import '@sinclair/typebox';
+import { TypeCompiler } from '@sinclair/typebox/compiler';
+import { ifPresent } from '@wener/utils';
+import { Ajv } from 'ajv';
+import addFormats from 'ajv-formats';
+import type { ZodType } from 'zod/v4';
+import type { JsonSchemaDef } from '../jsonschema';
+import type { SchemaOutput, TypeSchema } from './TypeSchema';
+
+/*
+https://github.com/react-hook-form/resolvers
+https://github.com/decs/typeschema/tree/main/packages
+*/
+
+export function validate<S extends TypeSchema>(schema: S, data: unknown): ValidationResult<SchemaOutput<S>> {
+	if (isZodSchema(schema)) {
+		const result = schema.safeParse(data);
+		if (result.success) {
+			return {
+				success: true,
+				data: result.data as any,
+			};
+		}
+
+		return {
+			issues: result.error.issues.map(({ message, path, code }) => ({ message, path, code })),
+			// message: z.prettifyError(result.error),
+			success: false,
+		};
+	}
+
+	if (isTypeBoxSchema(schema)) {
+		const checker = TypeCompiler.Compile(schema);
+		if (checker.Check(data)) {
+			return {
+				success: true,
+				data: data as any,
+			};
+		}
+		return {
+			issues: Array.from(checker.Errors(data)).map(({ message, path }) => {
+				return { message, path: [path] };
+			}),
+			// message: '',
+			success: false,
+		};
+	}
+
+	if (isJsonSchema(schema)) {
+		const ajv = new Ajv({
+			allErrors: true,
+			validateSchema: true,
+		});
+		addFormats(ajv);
+		const validator = ajv.compile(schema);
+		if (validator(data)) {
+			return {
+				data: data as any,
+				success: true,
+			};
+		}
+
+		const issues =
+			validator.errors?.map((error) => {
+				const message = error.message || 'Unknown error';
+				const path = error.instancePath
+					.split('/')
+					.filter(Boolean)
+					.map((p) => p as PropertyKey);
+				return { message, path };
+			}) || [];
+		return {
+			success: false,
+			// message: 'Invalid data',
+			issues,
+		};
+	}
+
+	return {
+		success: false,
+		// message: 'Invalid schema',
+		issues: [
+			{
+				message: 'Unknown schema type',
+			},
+		],
+	};
+}
+
+export function parseData<S extends TypeSchema>(schema: S, data: unknown): SchemaOutput<S> {
+	let result = validate(schema, data);
+	if (result.success) {
+		return result.data;
+	}
+	throw Object.assign(
+		new Error(
+			result.issues
+				.map((v) => {
+					return `${ifPresent(v.path?.join(), (v) => `[${v}]`)}: ${v.message}`;
+				})
+				.join('; '),
+		),
+		{
+			issues: result.issues,
+		},
+	);
+}
+
+function formatIssues(schema: TypeSchema, issues: Array<ValidationIssue>): string {
+	return '';
+}
+
+export function isZodSchema<I = any, O = any>(schema: any | TypeSchema<I, O>): schema is ZodType<O, I> {
+	return typeof schema === 'object' && 'parse' in schema;
+}
+
+export function isTypeBoxSchema(schema: any): schema is TSchema {
+	return typeof schema === 'object' && TypeBoxKind in schema;
+}
+
+export function isJsonSchema(schema: any): schema is JsonSchemaDef {
+	let sc: JsonSchemaDef = schema;
+	return typeof schema === 'object' && Boolean(sc.type || sc.properties || sc.anyOf || sc.oneOf || sc.$ref || sc.items);
+}
+
+export type ValidationIssue = {
+	message: string;
+	path?: Array<PropertyKey>;
+	code?: string;
+};
+
+export type ValidationResult<TOutput> =
+	| { success: true; data: TOutput }
+	| { success: false; issues: Array<ValidationIssue> };