@moluoxixi/zod3-to-rule 0.1.2 → 0.1.3

package/README.md

@@ -1,27 +1,27 @@
-# Zod 3 to Rule
-
-`@moluoxixi/zod3-to-rule` 提供可序列化校验规则与 Zod 3 之间的桥接，不依赖 Vue 或任何表单 UI。
-
-规则 JSON 是稳定协议。外部输入先通过 `parseRuleSet()` 严格解析，再使用 `compileRules()` 编译为 Zod schema、required 元数据和跨字段/custom validator。`rulesToZod()` 只编译单字段 Zod 能力。
-
-```ts
-import { compileRules, parseRuleSet } from '@moluoxixi/zod3-to-rule'
-
-const parsed = parseRuleSet({
-  version: 1,
-  base: { type: 'string' },
-  rules: [
-    { kind: 'required', message: '请输入邮箱' },
-    { kind: 'email', message: '邮箱格式不正确' },
-  ],
-})
-
-if (parsed.success) {
-  const compiled = compileRules(parsed.data)
-  compiled.schema.safeParse('user@example.com')
-}
-```
-
-支持的基础类型包括 string、number、boolean、date、enum 和 JSON primitive literal。内置规则覆盖字符串长度、regex、email、URL、UUID、数值范围、integer、finite、multipleOf、日期范围、required、基础跨字段比较和命名 custom validator。
-
-`zodToRules()` 是受限的最佳努力导出器。它支持上述基础类型和 Zod 3 内置 checks，并返回结构化 diagnostics。`refine`、`superRefine`、transform、preprocess、coerce、default 和其他无法由规则 JSON 等价表达的行为不会被静默丢弃；存在不可恢复的 effects 或 coercion 时不会返回 `ruleSet`。
+# Zod 3 to Rule
+
+`@moluoxixi/zod3-to-rule` 提供可序列化校验规则与 Zod 3 之间的桥接，不依赖 Vue 或任何表单 UI。
+
+规则 JSON 是稳定协议。外部输入先通过 `parseRuleSet()` 严格解析，再使用 `compileRules()` 编译为 Zod schema、required 元数据和跨字段/custom validator。`rulesToZod()` 只编译单字段 Zod 能力。
+
+```ts
+import { compileRules, parseRuleSet } from '@moluoxixi/zod3-to-rule'
+
+const parsed = parseRuleSet({
+  version: 1,
+  base: { type: 'string' },
+  rules: [
+    { kind: 'required', message: '请输入邮箱' },
+    { kind: 'email', message: '邮箱格式不正确' },
+  ],
+})
+
+if (parsed.success) {
+  const compiled = compileRules(parsed.data)
+  compiled.schema.safeParse('user@example.com')
+}
+```
+
+支持的基础类型包括 string、number、boolean、date、enum 和 JSON primitive literal。内置规则覆盖字符串长度、regex、email、URL、UUID、数值范围、integer、finite、multipleOf、日期范围、required、基础跨字段比较和命名 custom validator。
+
+`zodToRules()` 是受限的最佳努力导出器。它支持上述基础类型和 Zod 3 内置 checks，并返回结构化 diagnostics。`refine`、`superRefine`、transform、preprocess、coerce、default 和其他无法由规则 JSON 等价表达的行为不会被静默丢弃；存在不可恢复的 effects 或 coercion 时不会返回 `ruleSet`。

package/index.ts

@@ -1,7 +1,7 @@
-export * from './src/constants'
-export * from './src/diagnostics'
-export * from './src/from-zod'
-export * from './src/parse'
-export * from './src/rules'
-export * from './src/to-zod'
-export type * from './src/types'
+export * from './src/constants'
+export * from './src/diagnostics'
+export * from './src/from-zod'
+export * from './src/parse'
+export * from './src/rules'
+export * from './src/to-zod'
+export type * from './src/types'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@moluoxixi/zod3-to-rule",
   "type": "module",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "repository": {
     "type": "git",
     "url": "https://github.com/moluoxixi/vue-components",

package/src/constants.ts

@@ -1 +1 @@
-export const RULE_SET_VERSION = 1 as const
+export const RULE_SET_VERSION = 1 as const

package/src/diagnostics.ts

@@ -1,27 +1,27 @@
-import type { ZodIssue } from 'zod'
-import type { RuleDiagnostic, RuleDiagnosticSeverity } from './types'
-
-export function ruleDiagnostic(
-  code: string,
-  message: string,
-  path: (string | number)[] = [],
-  severity: RuleDiagnosticSeverity = 'error',
-  ruleIndex?: number,
-): RuleDiagnostic {
-  return { code, severity, path, message, ...(ruleIndex === undefined ? {} : { ruleIndex }) }
-}
-
-export function formatRuleZodIssues(issues: ZodIssue[]): RuleDiagnostic[] {
-  return issues.map(issue => ruleDiagnostic(
-    'RULE_DOCUMENT_INVALID',
-    issue.message,
-    issue.path,
-  ))
-}
-
-export class RuleCompileError extends Error {
-  constructor(public readonly diagnostics: RuleDiagnostic[]) {
-    super(diagnostics.map(diagnostic => diagnostic.message).join('; '))
-    this.name = 'RuleCompileError'
-  }
-}
+import type { ZodIssue } from 'zod'
+import type { RuleDiagnostic, RuleDiagnosticSeverity } from './types'
+
+export function ruleDiagnostic(
+  code: string,
+  message: string,
+  path: (string | number)[] = [],
+  severity: RuleDiagnosticSeverity = 'error',
+  ruleIndex?: number,
+): RuleDiagnostic {
+  return { code, severity, path, message, ...(ruleIndex === undefined ? {} : { ruleIndex }) }
+}
+
+export function formatRuleZodIssues(issues: ZodIssue[]): RuleDiagnostic[] {
+  return issues.map(issue => ruleDiagnostic(
+    'RULE_DOCUMENT_INVALID',
+    issue.message,
+    issue.path,
+  ))
+}
+
+export class RuleCompileError extends Error {
+  constructor(public readonly diagnostics: RuleDiagnostic[]) {
+    super(diagnostics.map(diagnostic => diagnostic.message).join('; '))
+    this.name = 'RuleCompileError'
+  }
+}

package/src/from-zod.ts

@@ -1,213 +1,213 @@
-import type { RuleDescriptor, RuleSet, ZodToRulesResult } from './types'
-import { z } from 'zod'
-import { RULE_SET_VERSION } from './constants'
-import { ruleDiagnostic } from './diagnostics'
-
-function messageFromCheck(check: { message?: string }): string | undefined {
-  return typeof check.message === 'string' ? check.message : undefined
-}
-
-function withMessage<T extends RuleDescriptor>(rule: T, check: { message?: string }): T {
-  const message = messageFromCheck(check)
-  return message ? { ...rule, message } as T : rule
-}
-
-function unsupported(message: string, path: (string | number)[] = []): ReturnType<typeof ruleDiagnostic> {
-  return ruleDiagnostic('ZOD_UNSUPPORTED', message, path, 'warning')
-}
-
-function unwrapSchema(schema: z.ZodTypeAny): {
-  schema: z.ZodTypeAny
-  optional: boolean
-  nullable: boolean
-  unsupported: boolean
-  diagnostics: ReturnType<typeof ruleDiagnostic>[]
-} {
-  let current = schema
-  let optional = false
-  let nullable = false
-  const diagnostics: ReturnType<typeof ruleDiagnostic>[] = []
-
-  while (true) {
-    if (current instanceof z.ZodOptional) {
-      optional = true
-      current = current.unwrap()
-      continue
-    }
-    if (current instanceof z.ZodNullable) {
-      nullable = true
-      current = current.unwrap()
-      continue
-    }
-    if (current instanceof z.ZodDefault) {
-      diagnostics.push(unsupported('Zod default values are not part of the rule format'))
-      current = current.removeDefault()
-      continue
-    }
-    if (current instanceof z.ZodEffects) {
-      diagnostics.push(unsupported('Zod effects/refine/transform cannot be represented as rules'))
-      return { schema: current, optional, nullable, unsupported: true, diagnostics }
-    }
-    break
-  }
-
-  return { schema: current, optional, nullable, unsupported: false, diagnostics }
-}
-
-function exportString(schema: z.ZodString): { rules: RuleDescriptor[], diagnostics: ReturnType<typeof ruleDiagnostic>[] } {
-  const rules: RuleDescriptor[] = []
-  const diagnostics: ReturnType<typeof ruleDiagnostic>[] = []
-  const checks = schema._def.checks
-  for (const check of checks) {
-    const kind = check.kind
-    switch (kind) {
-      case 'min':
-        rules.push(withMessage({ kind: 'minLength', value: check.value }, check))
-        break
-      case 'max':
-        rules.push(withMessage({ kind: 'maxLength', value: check.value }, check))
-        break
-      case 'length':
-        rules.push(withMessage({ kind: 'length', value: check.value }, check))
-        break
-      case 'email':
-        rules.push(withMessage({ kind: 'email' }, check))
-        break
-      case 'url':
-        rules.push(withMessage({ kind: 'url' }, check))
-        break
-      case 'uuid':
-        rules.push(withMessage({ kind: 'uuid' }, check))
-        break
-      case 'regex': {
-        const regex = check.regex
-        if (regex instanceof RegExp)
-          rules.push(withMessage({ kind: 'regex', source: regex.source, flags: regex.flags }, check))
-        else
-          diagnostics.push(unsupported('Zod regex check does not contain a RegExp'))
-        break
-      }
-      default:
-        diagnostics.push(unsupported(`Zod string check is not supported: ${String(kind)}`))
-    }
-  }
-  return { rules, diagnostics }
-}
-
-function exportNumber(schema: z.ZodNumber): { rules: RuleDescriptor[], diagnostics: ReturnType<typeof ruleDiagnostic>[] } {
-  const rules: RuleDescriptor[] = []
-  const diagnostics: ReturnType<typeof ruleDiagnostic>[] = []
-  const checks = schema._def.checks
-  for (const check of checks) {
-    const kind = check.kind
-    switch (kind) {
-      case 'min':
-        rules.push(withMessage({ kind: 'min', value: check.value, inclusive: check.inclusive }, check))
-        break
-      case 'max':
-        rules.push(withMessage({ kind: 'max', value: check.value, inclusive: check.inclusive }, check))
-        break
-      case 'int':
-        rules.push(withMessage({ kind: 'integer' }, check))
-        break
-      case 'finite':
-        rules.push(withMessage({ kind: 'finite' }, check))
-        break
-      case 'multipleOf':
-        rules.push(withMessage({ kind: 'multipleOf', value: check.value }, check))
-        break
-      default:
-        diagnostics.push(unsupported(`Zod number check is not supported: ${String(kind)}`))
-    }
-  }
-  return { rules, diagnostics }
-}
-
-function exportDate(schema: z.ZodDate): { rules: RuleDescriptor[], diagnostics: ReturnType<typeof ruleDiagnostic>[] } {
-  const rules: RuleDescriptor[] = []
-  const diagnostics: ReturnType<typeof ruleDiagnostic>[] = []
-  const checks = schema._def.checks
-  for (const check of checks) {
-    const value = new Date(check.value)
-    if (Number.isNaN(value.getTime())) {
-      diagnostics.push(unsupported('Zod date check does not contain a valid date value'))
-      continue
-    }
-    if (check.kind === 'min')
-      rules.push(withMessage({ kind: 'dateMin', value: value.toISOString() }, check))
-    else
-      rules.push(withMessage({ kind: 'dateMax', value: value.toISOString() }, check))
-  }
-  return { rules, diagnostics }
-}
-
-export function zodToRules(schema: z.ZodTypeAny): ZodToRulesResult {
-  const unwrapped = unwrapSchema(schema)
-  const diagnostics = [...unwrapped.diagnostics]
-  if (unwrapped.unsupported)
-    return { diagnostics }
-
-  if (
-    (unwrapped.schema instanceof z.ZodString
-      || unwrapped.schema instanceof z.ZodNumber
-      || unwrapped.schema instanceof z.ZodBoolean
-      || unwrapped.schema instanceof z.ZodDate)
-    && unwrapped.schema._def.coerce
-  ) {
-    diagnostics.push(unsupported('Zod coercion cannot be represented as rules'))
-    return { diagnostics }
-  }
-
-  let base: RuleSet['base']
-  let rules: RuleDescriptor[] = []
-
-  if (unwrapped.schema instanceof z.ZodString) {
-    base = { type: 'string' }
-    const exported = exportString(unwrapped.schema)
-    rules = exported.rules
-    diagnostics.push(...exported.diagnostics)
-  }
-  else if (unwrapped.schema instanceof z.ZodNumber) {
-    base = { type: 'number' }
-    const exported = exportNumber(unwrapped.schema)
-    rules = exported.rules
-    diagnostics.push(...exported.diagnostics)
-  }
-  else if (unwrapped.schema instanceof z.ZodBoolean) {
-    base = { type: 'boolean' }
-  }
-  else if (unwrapped.schema instanceof z.ZodDate) {
-    base = { type: 'date' }
-    const exported = exportDate(unwrapped.schema)
-    rules = exported.rules
-    diagnostics.push(...exported.diagnostics)
-  }
-  else if (unwrapped.schema instanceof z.ZodEnum) {
-    const values = unwrapped.schema.options
-    base = { type: 'enum', values: values as [string, ...string[]] }
-  }
-  else if (unwrapped.schema instanceof z.ZodLiteral) {
-    const value = unwrapped.schema.value
-    if (typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean' && value !== null) {
-      diagnostics.push(unsupported('Zod literal value is not JSON-safe'))
-      return { diagnostics }
-    }
-    base = { type: 'literal', value }
-  }
-  else {
-    const definition = unwrapped.schema._def as unknown as { typeName?: unknown }
-    diagnostics.push(unsupported(`Zod schema type is not supported: ${String(definition.typeName ?? 'unknown')}`))
-    return { diagnostics }
-  }
-
-  return {
-    ruleSet: {
-      version: RULE_SET_VERSION,
-      base,
-      rules,
-      ...(unwrapped.optional ? { optional: true } : {}),
-      ...(unwrapped.nullable ? { nullable: true } : {}),
-    },
-    diagnostics,
-  }
-}
+import type { RuleDescriptor, RuleSet, ZodToRulesResult } from './types'
+import { z } from 'zod'
+import { RULE_SET_VERSION } from './constants'
+import { ruleDiagnostic } from './diagnostics'
+
+function messageFromCheck(check: { message?: string }): string | undefined {
+  return typeof check.message === 'string' ? check.message : undefined
+}
+
+function withMessage<T extends RuleDescriptor>(rule: T, check: { message?: string }): T {
+  const message = messageFromCheck(check)
+  return message ? { ...rule, message } as T : rule
+}
+
+function unsupported(message: string, path: (string | number)[] = []): ReturnType<typeof ruleDiagnostic> {
+  return ruleDiagnostic('ZOD_UNSUPPORTED', message, path, 'warning')
+}
+
+function unwrapSchema(schema: z.ZodTypeAny): {
+  schema: z.ZodTypeAny
+  optional: boolean
+  nullable: boolean
+  unsupported: boolean
+  diagnostics: ReturnType<typeof ruleDiagnostic>[]
+} {
+  let current = schema
+  let optional = false
+  let nullable = false
+  const diagnostics: ReturnType<typeof ruleDiagnostic>[] = []
+
+  while (true) {
+    if (current instanceof z.ZodOptional) {
+      optional = true
+      current = current.unwrap()
+      continue
+    }
+    if (current instanceof z.ZodNullable) {
+      nullable = true
+      current = current.unwrap()
+      continue
+    }
+    if (current instanceof z.ZodDefault) {
+      diagnostics.push(unsupported('Zod default values are not part of the rule format'))
+      current = current.removeDefault()
+      continue
+    }
+    if (current instanceof z.ZodEffects) {
+      diagnostics.push(unsupported('Zod effects/refine/transform cannot be represented as rules'))
+      return { schema: current, optional, nullable, unsupported: true, diagnostics }
+    }
+    break
+  }
+
+  return { schema: current, optional, nullable, unsupported: false, diagnostics }
+}
+
+function exportString(schema: z.ZodString): { rules: RuleDescriptor[], diagnostics: ReturnType<typeof ruleDiagnostic>[] } {
+  const rules: RuleDescriptor[] = []
+  const diagnostics: ReturnType<typeof ruleDiagnostic>[] = []
+  const checks = schema._def.checks
+  for (const check of checks) {
+    const kind = check.kind
+    switch (kind) {
+      case 'min':
+        rules.push(withMessage({ kind: 'minLength', value: check.value }, check))
+        break
+      case 'max':
+        rules.push(withMessage({ kind: 'maxLength', value: check.value }, check))
+        break
+      case 'length':
+        rules.push(withMessage({ kind: 'length', value: check.value }, check))
+        break
+      case 'email':
+        rules.push(withMessage({ kind: 'email' }, check))
+        break
+      case 'url':
+        rules.push(withMessage({ kind: 'url' }, check))
+        break
+      case 'uuid':
+        rules.push(withMessage({ kind: 'uuid' }, check))
+        break
+      case 'regex': {
+        const regex = check.regex
+        if (regex instanceof RegExp)
+          rules.push(withMessage({ kind: 'regex', source: regex.source, flags: regex.flags }, check))
+        else
+          diagnostics.push(unsupported('Zod regex check does not contain a RegExp'))
+        break
+      }
+      default:
+        diagnostics.push(unsupported(`Zod string check is not supported: ${String(kind)}`))
+    }
+  }
+  return { rules, diagnostics }
+}
+
+function exportNumber(schema: z.ZodNumber): { rules: RuleDescriptor[], diagnostics: ReturnType<typeof ruleDiagnostic>[] } {
+  const rules: RuleDescriptor[] = []
+  const diagnostics: ReturnType<typeof ruleDiagnostic>[] = []
+  const checks = schema._def.checks
+  for (const check of checks) {
+    const kind = check.kind
+    switch (kind) {
+      case 'min':
+        rules.push(withMessage({ kind: 'min', value: check.value, inclusive: check.inclusive }, check))
+        break
+      case 'max':
+        rules.push(withMessage({ kind: 'max', value: check.value, inclusive: check.inclusive }, check))
+        break
+      case 'int':
+        rules.push(withMessage({ kind: 'integer' }, check))
+        break
+      case 'finite':
+        rules.push(withMessage({ kind: 'finite' }, check))
+        break
+      case 'multipleOf':
+        rules.push(withMessage({ kind: 'multipleOf', value: check.value }, check))
+        break
+      default:
+        diagnostics.push(unsupported(`Zod number check is not supported: ${String(kind)}`))
+    }
+  }
+  return { rules, diagnostics }
+}
+
+function exportDate(schema: z.ZodDate): { rules: RuleDescriptor[], diagnostics: ReturnType<typeof ruleDiagnostic>[] } {
+  const rules: RuleDescriptor[] = []
+  const diagnostics: ReturnType<typeof ruleDiagnostic>[] = []
+  const checks = schema._def.checks
+  for (const check of checks) {
+    const value = new Date(check.value)
+    if (Number.isNaN(value.getTime())) {
+      diagnostics.push(unsupported('Zod date check does not contain a valid date value'))
+      continue
+    }
+    if (check.kind === 'min')
+      rules.push(withMessage({ kind: 'dateMin', value: value.toISOString() }, check))
+    else
+      rules.push(withMessage({ kind: 'dateMax', value: value.toISOString() }, check))
+  }
+  return { rules, diagnostics }
+}
+
+export function zodToRules(schema: z.ZodTypeAny): ZodToRulesResult {
+  const unwrapped = unwrapSchema(schema)
+  const diagnostics = [...unwrapped.diagnostics]
+  if (unwrapped.unsupported)
+    return { diagnostics }
+
+  if (
+    (unwrapped.schema instanceof z.ZodString
+      || unwrapped.schema instanceof z.ZodNumber
+      || unwrapped.schema instanceof z.ZodBoolean
+      || unwrapped.schema instanceof z.ZodDate)
+    && unwrapped.schema._def.coerce
+  ) {
+    diagnostics.push(unsupported('Zod coercion cannot be represented as rules'))
+    return { diagnostics }
+  }
+
+  let base: RuleSet['base']
+  let rules: RuleDescriptor[] = []
+
+  if (unwrapped.schema instanceof z.ZodString) {
+    base = { type: 'string' }
+    const exported = exportString(unwrapped.schema)
+    rules = exported.rules
+    diagnostics.push(...exported.diagnostics)
+  }
+  else if (unwrapped.schema instanceof z.ZodNumber) {
+    base = { type: 'number' }
+    const exported = exportNumber(unwrapped.schema)
+    rules = exported.rules
+    diagnostics.push(...exported.diagnostics)
+  }
+  else if (unwrapped.schema instanceof z.ZodBoolean) {
+    base = { type: 'boolean' }
+  }
+  else if (unwrapped.schema instanceof z.ZodDate) {
+    base = { type: 'date' }
+    const exported = exportDate(unwrapped.schema)
+    rules = exported.rules
+    diagnostics.push(...exported.diagnostics)
+  }
+  else if (unwrapped.schema instanceof z.ZodEnum) {
+    const values = unwrapped.schema.options
+    base = { type: 'enum', values: values as [string, ...string[]] }
+  }
+  else if (unwrapped.schema instanceof z.ZodLiteral) {
+    const value = unwrapped.schema.value
+    if (typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean' && value !== null) {
+      diagnostics.push(unsupported('Zod literal value is not JSON-safe'))
+      return { diagnostics }
+    }
+    base = { type: 'literal', value }
+  }
+  else {
+    const definition = unwrapped.schema._def as unknown as { typeName?: unknown }
+    diagnostics.push(unsupported(`Zod schema type is not supported: ${String(definition.typeName ?? 'unknown')}`))
+    return { diagnostics }
+  }
+
+  return {
+    ruleSet: {
+      version: RULE_SET_VERSION,
+      base,
+      rules,
+      ...(unwrapped.optional ? { optional: true } : {}),
+      ...(unwrapped.nullable ? { nullable: true } : {}),
+    },
+    diagnostics,
+  }
+}