@wener/common 2.0.2 → 2.0.5

package/src/schema/formatZodError.test.ts

@@ -0,0 +1,197 @@
+import { describe, expect, it } from 'vitest';
+import { z } from 'zod/v4';
+import { formatZodError } from './formatZodError';
+
+describe('formatZodError', () => {
+	it('should format invalid_type error', () => {
+		const schema = z.object({
+			name: z.string(),
+			age: z.number(),
+		});
+
+		const result = schema.safeParse({ name: 123, age: 'not-a-number' });
+		expect(result.success).toBe(false);
+		if (!result.success) {
+			const formatted = formatZodError(result.error);
+			expect(formatted).toContain('name');
+			expect(formatted).toContain('age');
+		}
+	});
+
+	it('should format required field error', () => {
+		const schema = z.object({
+			name: z.string(),
+			email: z.string().email(),
+		});
+
+		const result = schema.safeParse({});
+		expect(result.success).toBe(false);
+		if (!result.success) {
+			const formatted = formatZodError(result.error);
+			expect(formatted).toContain('必填');
+		}
+	});
+
+	it('should format email validation error', () => {
+		const schema = z.object({
+			email: z.string().email(),
+		});
+
+		const result = schema.safeParse({ email: 'invalid-email' });
+		expect(result.success).toBe(false);
+		if (!result.success) {
+			const formatted = formatZodError(result.error);
+			expect(formatted).toContain('请输入有效的邮箱地址');
+		}
+	});
+
+	it('should format URL validation error', () => {
+		const schema = z.object({
+			url: z.string().url(),
+		});
+
+		const result = schema.safeParse({ url: 'not-a-url' });
+		expect(result.success).toBe(false);
+		if (!result.success) {
+			const formatted = formatZodError(result.error);
+			expect(formatted).toContain('请输入有效的 URL');
+		}
+	});
+
+	it('should format too_small error for string', () => {
+		const schema = z.object({
+			name: z.string().min(5),
+		});
+
+		const result = schema.safeParse({ name: 'abc' });
+		expect(result.success).toBe(false);
+		if (!result.success) {
+			const formatted = formatZodError(result.error);
+			expect(formatted).toContain('至少需要');
+		}
+	});
+
+	it('should format too_small error for number', () => {
+		const schema = z.object({
+			age: z.number().min(18),
+		});
+
+		const result = schema.safeParse({ age: 16 });
+		expect(result.success).toBe(false);
+		if (!result.success) {
+			const formatted = formatZodError(result.error);
+			expect(formatted).toContain('至少需要 18');
+		}
+	});
+
+	it('should format too_big error for string', () => {
+		const schema = z.object({
+			name: z.string().max(10),
+		});
+
+		const result = schema.safeParse({ name: 'this is too long' });
+		expect(result.success).toBe(false);
+		if (!result.success) {
+			const formatted = formatZodError(result.error);
+			expect(formatted).toContain('最多 10 个字符');
+		}
+	});
+
+	it('should format invalid_enum_value error', () => {
+		const schema = z.object({
+			status: z.enum(['active', 'inactive', 'pending']),
+		});
+
+		const result = schema.safeParse({ status: 'invalid' });
+		expect(result.success).toBe(false);
+		if (!result.success) {
+			const formatted = formatZodError(result.error);
+			expect(formatted).toContain('必须是以下值之一');
+		}
+	});
+
+	it('should format invalid_literal error', () => {
+		const schema = z.object({
+			type: z.literal('user'),
+		});
+
+		const result = schema.safeParse({ type: 'admin' });
+		expect(result.success).toBe(false);
+		if (!result.success) {
+			const formatted = formatZodError(result.error);
+			expect(formatted).toContain('必须是 user');
+		}
+	});
+
+	it('should format nested object errors', () => {
+		const schema = z.object({
+			user: z.object({
+				name: z.string(),
+				email: z.string().email(),
+			}),
+		});
+
+		const result = schema.safeParse({
+			user: {
+				name: '',
+				email: 'invalid',
+			},
+		});
+		expect(result.success).toBe(false);
+		if (!result.success) {
+			const formatted = formatZodError(result.error);
+			expect(formatted).toContain('user');
+			expect(formatted).toContain('email');
+		}
+	});
+
+	it('should format array errors', () => {
+		const schema = z.object({
+			tags: z.array(z.string()).min(1),
+		});
+
+		const result = schema.safeParse({ tags: [] });
+		expect(result.success).toBe(false);
+		if (!result.success) {
+			const formatted = formatZodError(result.error);
+			expect(formatted).toContain('至少需要 1 项');
+		}
+	});
+
+	it('should format multiple errors', () => {
+		const schema = z.object({
+			name: z.string().min(1),
+			email: z.string().email(),
+			age: z.number().min(18),
+		});
+
+		const result = schema.safeParse({
+			name: '',
+			email: 'invalid',
+			age: 15,
+		});
+		expect(result.success).toBe(false);
+		if (!result.success) {
+			const formatted = formatZodError(result.error);
+			// Should contain multiple error messages separated by '；'
+			const parts = formatted.split('；');
+			expect(parts.length).toBeGreaterThan(1);
+		}
+	});
+
+	it('should use schema description when available', () => {
+		const schema = z.object({
+			name: z.string().min(1).describe('姓名'),
+			email: z.string().email().describe('邮箱地址'),
+		});
+
+		// Use empty string for name (triggers min(1) error) and invalid email
+		const result = schema.safeParse({ name: '', email: 'invalid' });
+		expect(result.success).toBe(false);
+		if (!result.success) {
+			const formatted = formatZodError(result.error, schema);
+			expect(formatted).toContain('姓名');
+			expect(formatted).toContain('邮箱地址');
+		}
+	});
+});

package/src/schema/formatZodError.ts

@@ -0,0 +1,139 @@
+import type { core, ZodError } from 'zod/v4';
+import { findJsonSchemaByPath } from './findJsonSchemaByPath';
+import type { TypeSchema } from './TypeSchema';
+
+// Zod 4 issue types with proper typing
+type ZodIssue = core.$ZodIssue;
+type ZodIssueInvalidType = core.$ZodIssueInvalidType;
+type ZodIssueTooSmall = core.$ZodIssueTooSmall;
+type ZodIssueTooBig = core.$ZodIssueTooBig;
+type ZodIssueInvalidStringFormat = core.$ZodIssueInvalidStringFormat;
+type ZodIssueInvalidValue = core.$ZodIssueInvalidValue;
+type ZodIssueUnrecognizedKeys = core.$ZodIssueUnrecognizedKeys;
+
+export function formatZodError(error: ZodError, schema?: TypeSchema): string {
+	if (!error.issues || error.issues.length === 0) {
+		return error.message || '验证失败';
+	}
+
+	const messages: string[] = [];
+
+	// Iterate through issues and format each one
+	// We use manual iteration instead of error.format() to have better control
+	// over field name formatting with schema descriptions
+	for (const issue of error.issues) {
+		const formatted = formatIssueMessage(issue, schema);
+		if (formatted) {
+			const path = issue.path.map((p) => (typeof p === 'symbol' ? String(p) : p)) as (string | number)[];
+			let fieldName = formatPath(path);
+
+			// Try to get field description from schema
+			if (schema && path.length > 0) {
+				const fieldPath = path.map(String).join('.');
+				const fieldSchema = findJsonSchemaByPath(schema, fieldPath);
+				if (fieldSchema?.description) {
+					fieldName = fieldSchema.description;
+				}
+			}
+
+			messages.push(`${fieldName}: ${formatted}`);
+		}
+	}
+
+	return messages.join('；');
+}
+
+function formatIssueMessage(issue: ZodIssue, _schema?: TypeSchema): string {
+	let message = issue.message;
+
+	// 处理常见的错误类型，生成更友好的消息
+	switch (issue.code) {
+		case 'invalid_type': {
+			const i = issue as ZodIssueInvalidType;
+			// Zod v4 doesn't have 'received' field directly, extract from message
+			const match = issue.message.match(/received (\w+)/);
+			const received = match?.[1];
+			if (received === 'undefined') {
+				message = '必填';
+			} else if (received === 'null') {
+				message = '不能为空';
+			} else {
+				message = issue.message || `期望类型 ${i.expected}，但收到 ${received}`;
+			}
+			break;
+		}
+		case 'invalid_format': {
+			const i = issue as ZodIssueInvalidStringFormat;
+			if (i.format === 'email') {
+				message = '请输入有效的邮箱地址';
+			} else if (i.format === 'url') {
+				message = '请输入有效的 URL';
+			} else if (i.format === 'uuid') {
+				message = '请输入有效的 UUID';
+			} else if (i.format === 'date') {
+				message = '请输入有效的日期';
+			}
+			break;
+		}
+		case 'too_small': {
+			const i = issue as ZodIssueTooSmall;
+			if (i.origin === 'string' && i.minimum === 1) {
+				message = '不能为空';
+			} else if (i.origin === 'string') {
+				message = `至少需要 ${i.minimum} 个字符`;
+			} else if (i.origin === 'number' || i.origin === 'int') {
+				message = `至少需要 ${i.minimum}`;
+			} else if (i.origin === 'array') {
+				message = `至少需要 ${i.minimum} 项`;
+			}
+			break;
+		}
+		case 'too_big': {
+			const i = issue as ZodIssueTooBig;
+			if (i.origin === 'string') {
+				message = `最多 ${i.maximum} 个字符`;
+			} else if (i.origin === 'number' || i.origin === 'int') {
+				message = `最多 ${i.maximum}`;
+			} else if (i.origin === 'array') {
+				message = `最多 ${i.maximum} 项`;
+			}
+			break;
+		}
+		case 'invalid_value': {
+			const i = issue as ZodIssueInvalidValue;
+			if (i.values.length === 1) {
+				// Single value means it's a literal check
+				message = `必须是 ${String(i.values[0])}`;
+			} else {
+				message = `必须是以下值之一: ${i.values.map(String).join(', ')}`;
+			}
+			break;
+		}
+		case 'unrecognized_keys': {
+			const i = issue as ZodIssueUnrecognizedKeys;
+			message = `不支持的字段: ${i.keys.join(', ')}`;
+			break;
+		}
+		case 'invalid_union': {
+			message = '不符合任何允许的类型';
+			break;
+		}
+		case 'custom': {
+			// 保留自定义错误消息
+			message = issue.message;
+			break;
+		}
+		default:
+			// 保留原始消息
+			message = issue.message;
+	}
+
+	return message;
+}
+
+function formatPath(path: (string | number)[]): string {
+	if (path.length === 0) {
+		return '表单';
+	}
+	return path.map(String).join('.');
+}

package/src/schema/getSchemaOptions.ts

@@ -1,13 +1,13 @@
 import { deepFreeze } from '@wener/utils';
 import { getSchemaCache } from './getSchemaCache';
-import { SchemaRegistry } from './SchemaRegistry.mod';
+import { SchemaRegistry } from './SchemaRegistry';
 import type { TypeSchema } from './TypeSchema';
 
 export function getSchemaOptions(s: TypeSchema): Array<{ value: string; label: string }> {
 	let js = SchemaRegistry.get(s);
 	return getSchemaCache(s, 'options', () => {
 		let out =
-			(js.anyOf || js.oneOf)?.map((v) => {
+			(js.anyOf || js.oneOf)?.map((v: any) => {
 				let value = v.const;
 				return {
 					label: String(v.description || v.title || value),

package/src/schema/index.ts

@@ -4,4 +4,4 @@ export { getSchemaOptions, getSchemaOptionLabel } from './getSchemaOptions';
 export { toJsonSchema } from './toJsonSchema';
 export { findJsonSchemaByPath } from './findJsonSchemaByPath';
 export { createSchemaData } from './createSchemaData';
-export { SchemaRegistry } from './SchemaRegistry.mod';
+export { SchemaRegistry } from './SchemaRegistry';

package/src/schema/toJsonSchema.ts

@@ -33,7 +33,7 @@ export function toJsonSchema(schema: TypeSchema): JsonSchemaDef {
 							// prefer nullable
 							match(js)
 								.with({ anyOf: [P.select(), { type: 'null' }] }, (select) => {
-									delete js['anyOf'];
+									delete js.anyOf;
 									Object.assign(js, select);
 									js.nullable = true;
 								})
@@ -70,9 +70,9 @@ function visit(js: JsonSchemaDef, f: (js: JsonSchemaDef) => void) {
 	const _visit = (
 		js: JsonSchemaDef,
 		f: (js: JsonSchemaDef) => void,
-		parent: JsonSchemaDef | undefined,
+		_parent: JsonSchemaDef | undefined,
 		path: string[],
-		k?: string,
+		_k?: string,
 	) => {
 		if (!js) {
 			return;
@@ -109,9 +109,9 @@ function visit(js: JsonSchemaDef, f: (js: JsonSchemaDef) => void) {
 	_visit(js, f, undefined, []);
 }
 
-function resolveJsonSchemaDef(
+function _resolveJsonSchemaDef(
 	js: JsonSchemaDef,
-	ctx?: {
+	_ctx?: {
 		parent: JsonSchemaDef;
 		key: string;
 	},
@@ -129,7 +129,7 @@ function resolveJsonSchemaDef(
 			for (const key in schema.properties) {
 				const prop = schema.properties[key];
 				if (prop) {
-					schema.properties[key] = resolveJsonSchemaDef(prop, { parent: schema, key });
+					schema.properties[key] = _resolveJsonSchemaDef(prop, { parent: schema, key });
 				}
 			}
 			return schema;

package/src/schema/validate.ts

@@ -107,7 +107,7 @@ export function parseData<S extends TypeSchema>(schema: S, data: unknown): Schem
 	);
 }
 
-function formatIssues(schema: TypeSchema, issues: Array<ValidationIssue>): string {
+function _formatIssues(_schema: TypeSchema, _issues: Array<ValidationIssue>): string {
 	return '';
 }
 

package/src/utils/buildBaseUrl.ts

@@ -0,0 +1,12 @@
+function joinUrl(baseUrl: string, maybeUrl: string): string {
+	const sanitizedBase = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+	const sanitizedEndpoint = maybeUrl.startsWith('/') ? maybeUrl.slice(1) : maybeUrl;
+	return `${sanitizedBase}/${sanitizedEndpoint}`;
+}
+
+export function buildBaseUrl(url: string, baseUrl: string | undefined | null): string {
+	if (!baseUrl || /^https?:/.test(url)) {
+		return url;
+	}
+	return joinUrl(baseUrl, url);
+}

package/src/utils/buildRedactorFormSchema.ts

@@ -0,0 +1,85 @@
+import { forEachJsonSchema, type JsonSchemaDef } from '../jsonschema';
+import { toJsonSchema, type TypeSchema } from '../schema';
+
+export const RedactedText = '[redacted]';
+
+export function buildRedactorFormSchema(
+	ts: TypeSchema,
+	{
+		shouldRedact = (schema) => schema['x-sensitive'] === true,
+		replacer = () => RedactedText,
+	}: {
+		shouldRedact?: (schema: JsonSchemaDef) => boolean;
+		replacer?: (key: string, value: any) => any;
+	},
+) {
+	let js = toJsonSchema(ts);
+
+	let paths: string[][] = [];
+
+	forEachJsonSchema(js, (js, { path }) => {
+		if (shouldRedact(js)) {
+			paths.push(path);
+		}
+	});
+	const vis = (root: any, path: string[]) => {
+		switch (root) {
+			case null:
+			case undefined:
+				return;
+		}
+
+		let c = root;
+		for (let i = 0; i < path.length; i++) {
+			let k = path[i];
+			if (c && typeof c === 'object' && k in c) {
+				let v = c[k];
+				if (path.length === 1) {
+					c[k] = replacer(k, v);
+				} else if (Array.isArray(v)) {
+					for (let vv of v) {
+						vis(vv, path.slice(i + 1));
+					}
+				} else {
+					vis(v, path.slice(i + 1));
+				}
+			}
+		}
+	};
+
+	return (root: any) => {
+		if (!paths.length) {
+			return root;
+		}
+
+		paths.forEach((path) => {
+			vis(root, path);
+		});
+
+		return root;
+	};
+}
+
+function _buildReversibleRedactText({
+	id,
+	type: _type,
+	key: _key,
+	timestamp,
+}: {
+	id?: string | number;
+	type?: string;
+	key?: string;
+	timestamp?: number | boolean;
+} = {}) {
+	if (!id) {
+		return RedactedText;
+	}
+	if (timestamp === true) {
+		timestamp = Date.now();
+	}
+	return `[redacted ${id}]`;
+}
+
+export function isRedactedText(v: any) {
+	return v === RedactedText || (typeof v === 'string' && v.startsWith('[redacted ') && v.endsWith(']'));
+}

package/src/utils/index.ts

@@ -1 +1,5 @@
 export { getEstimateProcessTime } from './getEstimateProcessTime';
+
+export { buildRedactorFormSchema } from './buildRedactorFormSchema';
+
+export { buildBaseUrl } from './buildBaseUrl';

package/src/utils/resolveFeatureOptions.ts

@@ -0,0 +1,14 @@
+import { maybeFunction, type MaybeFunction } from '@wener/utils';
+
+export function resolveFeatureOptions<T>(
+	value: boolean | T | undefined | null,
+	defaultValue: MaybeFunction<T>,
+): T | undefined {
+	if (value === false) {
+		return undefined;
+	}
+	if (value === true || value === undefined || value === null) {
+		return maybeFunction(defaultValue);
+	}
+	return value;
+}

package/src/cn/ChineseResidentIdNo.mod.ts

@@ -1,7 +0,0 @@
-export {
-	ChineseResidentIdNoRegex as regex,
-	parseChineseResidentIdNo as parse,
-	formatChineseResidentIdNo as format,
-	type ParsedChineseResidentIdNo as Result,
-	ParsedChineseResidentIdNoSchema as ResultSchema,
-} from './ChineseResidentIdNo';

package/src/cn/DivisionCode.mod.ts

@@ -1,7 +0,0 @@
-export {
-	DivisionCodeRegex as regex,
-	type ParsedDivisionCode as Result,
-	ParsedDivisionCodeSchema as ResultSchema,
-	parseDivisionCode as parse,
-	formatDivisionCode as format,
-} from './DivisionCode';

package/src/cn/UnifiedSocialCreditCode.mod.ts

@@ -1,7 +0,0 @@
-export {
-	type ParsedUnifiedSocialCreditCode as Result,
-	UnifiedSocialCreditCodeRegex as regex,
-	ParsedUnifiedSocialCreditCodeSchema as ResultSchema,
-	parseUnifiedSocialCreditCode as parse,
-	formatUnifiedSocialCreditCode as format,
-} from './UnifiedSocialCreditCode';

package/src/cn/mod.ts

@@ -1,3 +0,0 @@
-export * as ChineseResidentIdNo from './ChineseResidentIdNo.mod';
-export * as UnifiedSocialCreditCode from './UnifiedSocialCreditCode.mod';
-export * as DivisionCode from './DivisionCode.mod';

package/src/schema/SchemaRegistry.mod.ts

@@ -1 +0,0 @@
-export * as SchemaRegistry from './SchemaRegistry';