@wener/common 2.0.2 → 2.0.3

package/src/schema/formatZodError.ts

@@ -0,0 +1,151 @@
+import { ZodError } from 'zod/v4';
+import { findJsonSchemaByPath } from './findJsonSchemaByPath';
+import type { TypeSchema } from './TypeSchema';
+
+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: ZodError['issues'][number], schema?: TypeSchema): string {
+	let message = issue.message;
+
+	// 处理常见的错误类型，生成更友好的消息
+	// Use string comparison to avoid TypeScript narrowing issues with Zod v4
+	const code = issue.code as string;
+	switch (code) {
+		case 'invalid_type': {
+			const invalidTypeIssue = issue as typeof issue & {
+				expected: string;
+				received: string;
+			};
+			if (invalidTypeIssue.received === 'undefined') {
+				message = '必填';
+			} else if (invalidTypeIssue.received === 'null') {
+				message = '不能为空';
+			} else {
+				message = issue.message || `期望类型 ${invalidTypeIssue.expected}，但收到 ${invalidTypeIssue.received}`;
+			}
+			break;
+		}
+		case 'invalid_string': {
+			const invalidStringIssue = issue as typeof issue & {
+				validation?: string;
+			};
+			if (invalidStringIssue.validation === 'email') {
+				message = '请输入有效的邮箱地址';
+			} else if (invalidStringIssue.validation === 'url') {
+				message = '请输入有效的 URL';
+			} else if (invalidStringIssue.validation === 'uuid') {
+				message = '请输入有效的 UUID';
+			} else if (invalidStringIssue.validation === 'date') {
+				message = '请输入有效的日期';
+			}
+			break;
+		}
+		case 'too_small': {
+			const tooSmallIssue = issue as typeof issue & {
+				type: string;
+				minimum: number;
+			};
+			if (tooSmallIssue.type === 'string' && tooSmallIssue.minimum === 1) {
+				message = '不能为空';
+			} else if (tooSmallIssue.type === 'number') {
+				message = `至少需要 ${tooSmallIssue.minimum}`;
+			} else if (tooSmallIssue.type === 'array') {
+				message = `至少需要 ${tooSmallIssue.minimum} 项`;
+			}
+			break;
+		}
+		case 'too_big': {
+			const tooBigIssue = issue as typeof issue & {
+				type: string;
+				maximum: number;
+			};
+			if (tooBigIssue.type === 'string') {
+				message = `最多 ${tooBigIssue.maximum} 个字符`;
+			} else if (tooBigIssue.type === 'number') {
+				message = `最多 ${tooBigIssue.maximum}`;
+			} else if (tooBigIssue.type === 'array') {
+				message = `最多 ${tooBigIssue.maximum} 项`;
+			}
+			break;
+		}
+		case 'invalid_enum_value': {
+			const enumIssue = issue as typeof issue & {
+				options: readonly unknown[];
+			};
+			message = `必须是以下值之一: ${enumIssue.options?.map(String).join(', ') || '未知选项'}`;
+			break;
+		}
+		case 'unrecognized_keys': {
+			const unrecognizedIssue = issue as typeof issue & {
+				keys: readonly string[];
+			};
+			message = `不支持的字段: ${unrecognizedIssue.keys?.join(', ') || '未知字段'}`;
+			break;
+		}
+		case 'invalid_union': {
+			message = '不符合任何允许的类型';
+			break;
+		}
+		case 'invalid_union_discriminator': {
+			const discriminatorIssue = issue as typeof issue & {
+				options: readonly unknown[];
+			};
+			message = `必须是以下值之一: ${discriminatorIssue.options?.map(String).join(', ') || '未知选项'}`;
+			break;
+		}
+		case 'invalid_literal': {
+			const literalIssue = issue as typeof issue & {
+				expected: unknown;
+			};
+			message = `必须是 ${String(literalIssue.expected)}`;
+			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/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,
+	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';