schema-dsl 2.0.0 → 2.0.1

package/src/core/ConditionalRuntime.ts

@@ -1,28 +1,28 @@
-import type { JSONSchema } from '../types/schema.js'
-
-export const CONDITIONAL_RUNTIME_STATE: unique symbol = Symbol('schema-dsl.conditionalRuntimeState')
-
-export interface ConditionalRuntimeState {
-    conditions: unknown[]
-    elseSchema: string | JSONSchema | null | undefined
-    evaluateCondition: (conditionObj: unknown, data: unknown) => {
-        result: boolean
-        failedMessage?: string | null
-        requirementFailed?: boolean
-    }
-}
-
-export type ConditionalRuntimeSchema = JSONSchema & {
-    [CONDITIONAL_RUNTIME_STATE]?: ConditionalRuntimeState
-}
-
-export function attachConditionalRuntime(schema: JSONSchema, state: ConditionalRuntimeState): ConditionalRuntimeSchema {
-    Object.defineProperty(schema, CONDITIONAL_RUNTIME_STATE, {
-        value: state,
-        enumerable: false,
-        configurable: false,
-        writable: false,
-    })
-
-    return schema as ConditionalRuntimeSchema
+import type { JSONSchema } from '../types/schema.js'
+
+export const CONDITIONAL_RUNTIME_STATE: unique symbol = Symbol('schema-dsl.conditionalRuntimeState')
+
+export interface ConditionalRuntimeState {
+    conditions: unknown[]
+    elseSchema: string | JSONSchema | null | undefined
+    evaluateCondition: (conditionObj: unknown, data: unknown) => {
+        result: boolean
+        failedMessage?: string | null
+        requirementFailed?: boolean
+    }
+}
+
+export type ConditionalRuntimeSchema = JSONSchema & {
+    [CONDITIONAL_RUNTIME_STATE]?: ConditionalRuntimeState
+}
+
+export function attachConditionalRuntime(schema: JSONSchema, state: ConditionalRuntimeState): ConditionalRuntimeSchema {
+    Object.defineProperty(schema, CONDITIONAL_RUNTIME_STATE, {
+        value: state,
+        enumerable: false,
+        configurable: false,
+        writable: false,
+    })
+
+    return schema as ConditionalRuntimeSchema
 }

package/src/core/ConditionalValidator.ts

@@ -1,255 +1,255 @@
-import type { JSONSchema } from '../types/schema.js'
-import type { ValidateOptions, ValidationErrorItem, ValidationResult } from '../types/validate.js'
-import type { DslDefinition } from '../types/dsl.js'
-import { DslParser } from '../parser/DslParser.js'
-import { Locale } from './Locale.js'
-import { CONDITIONAL_RUNTIME_STATE, type ConditionalRuntimeState } from './ConditionalRuntime.js'
-
-const EMPTY_ERRORS: ValidationErrorItem[] = []
-
-export type ConditionalInternalSchema = JSONSchema & {
-    _required?: boolean
-    _label?: string
-    _customMessages?: Record<string, string>
-    _isConditional?: boolean
-    _runtimeOnlyConditional?: boolean
-    conditions?: Array<{ action?: string; message?: string; then?: unknown }>
-    _evaluateCondition?: (cond: unknown, data: unknown) => { result: boolean; failedMessage?: string; requirementFailed?: boolean }
-    else?: unknown
-    [CONDITIONAL_RUNTIME_STATE]?: ConditionalRuntimeState
-}
-
-interface ConditionalValidatorHooks {
-    validateSchema<T>(schema: JSONSchema, data: T, options: ValidateOptions): ValidationResult<T>
-    internalError<T>(error: unknown, data: T): ValidationResult<T>
-}
-
-export class ConditionalValidator {
-    constructor(private readonly hooks: ConditionalValidatorHooks) { }
-
-    hasAnyConditional(schema: ConditionalInternalSchema): boolean {
-        if (!schema.properties) return false
-        return Object.values(schema.properties).some((fieldSchema) => {
-            const fs = fieldSchema as ConditionalInternalSchema
-            if (fs._isConditional) return true
-            if (fs.properties) return this.hasAnyConditional(fs)
-            return false
-        })
-    }
-
-    validateWithConditionals<T>(
-        schema: ConditionalInternalSchema,
-        data: T,
-        options: ValidateOptions,
-        rootData?: Record<string, unknown>
-    ): ValidationResult<T> {
-        const errors: ValidationErrorItem[] = []
-        const effectiveRoot = rootData ?? (data as Record<string, unknown>)
-        const cleanSchema = JSON.parse(JSON.stringify(schema)) as ConditionalInternalSchema
-        const conditionalFields: Record<string, ConditionalInternalSchema> = {}
-        const nestedObjectFields: Record<string, ConditionalInternalSchema> = {}
-
-        for (const [fieldName, fieldSchema] of Object.entries(schema.properties ?? {})) {
-            const fs = fieldSchema as ConditionalInternalSchema
-            if (fs._isConditional) {
-                conditionalFields[fieldName] = fs
-                delete cleanSchema.properties?.[fieldName]
-
-                if (cleanSchema.required) {
-                    cleanSchema.required = cleanSchema.required.filter(r => r !== fieldName)
-                }
-            } else if (fs.properties && this.hasAnyConditional(fs)) {
-                nestedObjectFields[fieldName] = fs
-                delete cleanSchema.properties?.[fieldName]
-            }
-        }
-
-        const baseResult = this.hooks.validateSchema(cleanSchema, data, options)
-        if (!baseResult.valid) {
-            errors.push(...(baseResult.errors ?? []))
-        }
-
-        for (const [fieldName, conditionalSchema] of Object.entries(conditionalFields)) {
-            const dataRecord = data as Record<string, unknown>
-            const fieldResult = this.validateConditional(conditionalSchema, effectiveRoot, fieldName, dataRecord[fieldName], options)
-
-            if (!fieldResult.valid) {
-                for (const err of (fieldResult.errors ?? [])) {
-                    const errPath = (!err.path || err.path === 'value') ? fieldName : err.path
-                    errors.push({ ...err, path: errPath, field: errPath })
-                }
-            }
-        }
-
-        for (const [fieldName, nestedSchema] of Object.entries(nestedObjectFields)) {
-            const dataRecord = data as Record<string, unknown>
-            const nestedData = dataRecord[fieldName]
-
-            if (nestedData === undefined || nestedData === null) {
-                const partialSchema = JSON.parse(JSON.stringify(schema)) as ConditionalInternalSchema
-                partialSchema.properties = { [fieldName]: nestedSchema }
-                partialSchema.required = (schema.required ?? []).filter(r => r === fieldName)
-                const partialResult = this.hooks.validateSchema(partialSchema, data, options)
-                if (!partialResult.valid) {
-                    errors.push(...(partialResult.errors ?? []))
-                }
-                continue
-            }
-
-            const nestedResult = this.validateWithConditionals(nestedSchema, nestedData, options, effectiveRoot)
-            if (!nestedResult.valid) {
-                for (const err of (nestedResult.errors ?? [])) {
-                    const errPath = err.path ? `${fieldName}/${err.path}` : fieldName
-                    errors.push({ ...err, path: errPath, field: errPath })
-                }
-            }
-        }
-
-        if (errors.length === 0) return { valid: true, data, errors: EMPTY_ERRORS }
-        return { valid: false, data, errors, errorMessage: errors[0]?.message }
-    }
-
-    validateConditional<T>(
-        conditionalSchema: ConditionalInternalSchema,
-        data: Record<string, unknown>,
-        fieldName: string | null,
-        fieldValue: T,
-        options: ValidateOptions
-    ): ValidationResult<T> {
-        const locale = options.locale ?? Locale.getLocale()
-        const runtimeState = conditionalSchema[CONDITIONAL_RUNTIME_STATE]
-        const conditions = (runtimeState?.conditions ?? conditionalSchema.conditions ?? []) as Array<{ action?: string; message?: string; then?: unknown; type?: string }>
-
-        if (conditions.length === 0 && conditionalSchema._runtimeOnlyConditional) {
-            return {
-                valid: false,
-                data: fieldValue,
-                errors: [{
-                    message: '[schema-dsl] Function-based conditional schemas are runtime-only and cannot be restored from JSON serialization.',
-                    path: '',
-                    keyword: 'conditional',
-                    params: {},
-                }],
-                errorMessage: '[schema-dsl] Function-based conditional schemas are runtime-only and cannot be restored from JSON serialization.',
-            }
-        }
-
-        try {
-            for (const cond of conditions) {
-                const evaluation = runtimeState?.evaluateCondition(cond, data)
-                    ?? conditionalSchema._evaluateCondition?.(cond, data)
-                    ?? { result: false }
-                const matched = evaluation.result
-
-                if (cond.action === 'throw') {
-                    if (matched) {
-                        const errorMsg = evaluation.failedMessage ?? cond.message ?? 'Conditional validation failed'
-                        const message = Locale.getMessageText(errorMsg, (options.messages ?? {}) as Record<string, string>, locale)
-                        return {
-                            valid: false,
-                            data: fieldValue,
-                            errors: [{ message, path: '', keyword: 'conditional', params: { condition: (cond as Record<string, unknown>)['type'] } }],
-                            errorMessage: message,
-                        }
-                    }
-                    continue
-                }
-
-                if (matched) {
-                    const thenSchema = (cond as Record<string, unknown>)['then']
-                    if (thenSchema !== undefined && thenSchema !== null) {
-                        return this.executeThenBranch(thenSchema, data, fieldValue, fieldName, options)
-                    }
-                    return { valid: true, data: fieldValue, errors: EMPTY_ERRORS }
-                }
-
-                if (evaluation.requirementFailed) {
-                    const errorMsg = cond.message ?? 'Condition not met'
-                    const message = Locale.getMessageText(errorMsg, (options.messages ?? {}) as Record<string, string>, locale)
-                    return {
-                        valid: false,
-                        data: fieldValue,
-                        errors: [{ message, path: '', keyword: 'conditional', params: {} }],
-                        errorMessage: message,
-                    }
-                }
-            }
-
-            const elseSchema = runtimeState ? runtimeState.elseSchema : conditionalSchema.else
-            if (elseSchema !== undefined) {
-                if (elseSchema === null) return { valid: true, data: fieldValue, errors: EMPTY_ERRORS }
-                return this.executeThenBranch(elseSchema, data, fieldValue, fieldName, options)
-            }
-
-            return { valid: true, data: fieldValue, errors: EMPTY_ERRORS }
-        } catch (error) {
-            return this.hooks.internalError(error, fieldValue)
-        }
-    }
-
-    private executeThenBranch<T>(
-        thenSchema: unknown,
-        data: Record<string, unknown>,
-        fieldValue: T,
-        fieldName: string | null,
-        options: ValidateOptions
-    ): ValidationResult<T> {
-        let resolved = thenSchema
-
-        if (typeof resolved === 'string') {
-            resolved = DslParser.parseString(resolved)
-        }
-
-        if (resolved !== null && typeof resolved === 'object') {
-            const obj = resolved as Record<string, unknown>
-            if (typeof obj['toSchema'] === 'function') {
-                resolved = (obj['toSchema'] as () => JSONSchema)()
-            }
-        }
-
-        const resolvedSchema = resolved as ConditionalInternalSchema
-        if (resolvedSchema?._isConditional) {
-            return this.validateConditional(resolvedSchema, data, fieldName, fieldValue, options)
-        }
-
-        if (resolved !== null && typeof resolved === 'object' && !Array.isArray(resolved)) {
-            const obj = resolved as Record<string, unknown>
-            if (obj['type'] === undefined && obj['oneOf'] === undefined && obj['anyOf'] === undefined && obj['allOf'] === undefined) {
-                resolved = DslParser.parseObject(resolved as DslDefinition)
-            }
-        }
-
-        return this.validateFieldValue(resolved as JSONSchema, fieldValue, options)
-    }
-
-    private validateFieldValue<T>(schema: JSONSchema, fieldValue: T, options: ValidateOptions): ValidationResult<T> {
-        const internalSchema = schema as ConditionalInternalSchema
-        const isRequired = internalSchema._required === true
-
-        if (!isRequired && (fieldValue === undefined || fieldValue === '')) {
-            return { valid: true, data: fieldValue, errors: EMPTY_ERRORS }
-        }
-
-        if (isRequired && fieldValue === undefined) {
-            const locale = options.locale ?? Locale.getLocale()
-            const label = internalSchema._label ?? ''
-            const customMsgs = internalSchema._customMessages ?? {}
-            const allMsgs = { ...(options.messages ?? {}), ...customMsgs } as Record<string, string>
-            let message: string
-            if (allMsgs['required']) {
-                message = Locale.getMessageText(allMsgs['required'], allMsgs, locale)
-            } else {
-                message = Locale.getMessageText('required', allMsgs, locale)
-                if (label) message = `${label} ${message}`
-            }
-            return {
-                valid: false,
-                data: fieldValue,
-                errors: [{ message, path: '', keyword: 'required', params: {} }],
-                errorMessage: message,
-            }
-        }
-
-        return this.hooks.validateSchema(schema, fieldValue, options)
-    }
+import type { JSONSchema } from '../types/schema.js'
+import type { ValidateOptions, ValidationErrorItem, ValidationResult } from '../types/validate.js'
+import type { DslDefinition } from '../types/dsl.js'
+import { DslParser } from '../parser/DslParser.js'
+import { Locale } from './Locale.js'
+import { CONDITIONAL_RUNTIME_STATE, type ConditionalRuntimeState } from './ConditionalRuntime.js'
+
+const EMPTY_ERRORS: ValidationErrorItem[] = []
+
+export type ConditionalInternalSchema = JSONSchema & {
+    _required?: boolean
+    _label?: string
+    _customMessages?: Record<string, string>
+    _isConditional?: boolean
+    _runtimeOnlyConditional?: boolean
+    conditions?: Array<{ action?: string; message?: string; then?: unknown }>
+    _evaluateCondition?: (cond: unknown, data: unknown) => { result: boolean; failedMessage?: string; requirementFailed?: boolean }
+    else?: unknown
+    [CONDITIONAL_RUNTIME_STATE]?: ConditionalRuntimeState
+}
+
+interface ConditionalValidatorHooks {
+    validateSchema<T>(schema: JSONSchema, data: T, options: ValidateOptions): ValidationResult<T>
+    internalError<T>(error: unknown, data: T): ValidationResult<T>
+}
+
+export class ConditionalValidator {
+    constructor(private readonly hooks: ConditionalValidatorHooks) { }
+
+    hasAnyConditional(schema: ConditionalInternalSchema): boolean {
+        if (!schema.properties) return false
+        return Object.values(schema.properties).some((fieldSchema) => {
+            const fs = fieldSchema as ConditionalInternalSchema
+            if (fs._isConditional) return true
+            if (fs.properties) return this.hasAnyConditional(fs)
+            return false
+        })
+    }
+
+    validateWithConditionals<T>(
+        schema: ConditionalInternalSchema,
+        data: T,
+        options: ValidateOptions,
+        rootData?: Record<string, unknown>
+    ): ValidationResult<T> {
+        const errors: ValidationErrorItem[] = []
+        const effectiveRoot = rootData ?? (data as Record<string, unknown>)
+        const cleanSchema = JSON.parse(JSON.stringify(schema)) as ConditionalInternalSchema
+        const conditionalFields: Record<string, ConditionalInternalSchema> = {}
+        const nestedObjectFields: Record<string, ConditionalInternalSchema> = {}
+
+        for (const [fieldName, fieldSchema] of Object.entries(schema.properties ?? {})) {
+            const fs = fieldSchema as ConditionalInternalSchema
+            if (fs._isConditional) {
+                conditionalFields[fieldName] = fs
+                delete cleanSchema.properties?.[fieldName]
+
+                if (cleanSchema.required) {
+                    cleanSchema.required = cleanSchema.required.filter(r => r !== fieldName)
+                }
+            } else if (fs.properties && this.hasAnyConditional(fs)) {
+                nestedObjectFields[fieldName] = fs
+                delete cleanSchema.properties?.[fieldName]
+            }
+        }
+
+        const baseResult = this.hooks.validateSchema(cleanSchema, data, options)
+        if (!baseResult.valid) {
+            errors.push(...(baseResult.errors ?? []))
+        }
+
+        for (const [fieldName, conditionalSchema] of Object.entries(conditionalFields)) {
+            const dataRecord = data as Record<string, unknown>
+            const fieldResult = this.validateConditional(conditionalSchema, effectiveRoot, fieldName, dataRecord[fieldName], options)
+
+            if (!fieldResult.valid) {
+                for (const err of (fieldResult.errors ?? [])) {
+                    const errPath = (!err.path || err.path === 'value') ? fieldName : err.path
+                    errors.push({ ...err, path: errPath, field: errPath })
+                }
+            }
+        }
+
+        for (const [fieldName, nestedSchema] of Object.entries(nestedObjectFields)) {
+            const dataRecord = data as Record<string, unknown>
+            const nestedData = dataRecord[fieldName]
+
+            if (nestedData === undefined || nestedData === null) {
+                const partialSchema = JSON.parse(JSON.stringify(schema)) as ConditionalInternalSchema
+                partialSchema.properties = { [fieldName]: nestedSchema }
+                partialSchema.required = (schema.required ?? []).filter(r => r === fieldName)
+                const partialResult = this.hooks.validateSchema(partialSchema, data, options)
+                if (!partialResult.valid) {
+                    errors.push(...(partialResult.errors ?? []))
+                }
+                continue
+            }
+
+            const nestedResult = this.validateWithConditionals(nestedSchema, nestedData, options, effectiveRoot)
+            if (!nestedResult.valid) {
+                for (const err of (nestedResult.errors ?? [])) {
+                    const errPath = err.path ? `${fieldName}/${err.path}` : fieldName
+                    errors.push({ ...err, path: errPath, field: errPath })
+                }
+            }
+        }
+
+        if (errors.length === 0) return { valid: true, data, errors: EMPTY_ERRORS }
+        return { valid: false, data, errors, errorMessage: errors[0]?.message }
+    }
+
+    validateConditional<T>(
+        conditionalSchema: ConditionalInternalSchema,
+        data: Record<string, unknown>,
+        fieldName: string | null,
+        fieldValue: T,
+        options: ValidateOptions
+    ): ValidationResult<T> {
+        const locale = options.locale ?? Locale.getLocale()
+        const runtimeState = conditionalSchema[CONDITIONAL_RUNTIME_STATE]
+        const conditions = (runtimeState?.conditions ?? conditionalSchema.conditions ?? []) as Array<{ action?: string; message?: string; then?: unknown; type?: string }>
+
+        if (conditions.length === 0 && conditionalSchema._runtimeOnlyConditional) {
+            return {
+                valid: false,
+                data: fieldValue,
+                errors: [{
+                    message: '[schema-dsl] Function-based conditional schemas are runtime-only and cannot be restored from JSON serialization.',
+                    path: '',
+                    keyword: 'conditional',
+                    params: {},
+                }],
+                errorMessage: '[schema-dsl] Function-based conditional schemas are runtime-only and cannot be restored from JSON serialization.',
+            }
+        }
+
+        try {
+            for (const cond of conditions) {
+                const evaluation = runtimeState?.evaluateCondition(cond, data)
+                    ?? conditionalSchema._evaluateCondition?.(cond, data)
+                    ?? { result: false }
+                const matched = evaluation.result
+
+                if (cond.action === 'throw') {
+                    if (matched) {
+                        const errorMsg = evaluation.failedMessage ?? cond.message ?? 'Conditional validation failed'
+                        const message = Locale.getMessageText(errorMsg, (options.messages ?? {}) as Record<string, string>, locale)
+                        return {
+                            valid: false,
+                            data: fieldValue,
+                            errors: [{ message, path: '', keyword: 'conditional', params: { condition: (cond as Record<string, unknown>)['type'] } }],
+                            errorMessage: message,
+                        }
+                    }
+                    continue
+                }
+
+                if (matched) {
+                    const thenSchema = (cond as Record<string, unknown>)['then']
+                    if (thenSchema !== undefined && thenSchema !== null) {
+                        return this.executeThenBranch(thenSchema, data, fieldValue, fieldName, options)
+                    }
+                    return { valid: true, data: fieldValue, errors: EMPTY_ERRORS }
+                }
+
+                if (evaluation.requirementFailed) {
+                    const errorMsg = cond.message ?? 'Condition not met'
+                    const message = Locale.getMessageText(errorMsg, (options.messages ?? {}) as Record<string, string>, locale)
+                    return {
+                        valid: false,
+                        data: fieldValue,
+                        errors: [{ message, path: '', keyword: 'conditional', params: {} }],
+                        errorMessage: message,
+                    }
+                }
+            }
+
+            const elseSchema = runtimeState ? runtimeState.elseSchema : conditionalSchema.else
+            if (elseSchema !== undefined) {
+                if (elseSchema === null) return { valid: true, data: fieldValue, errors: EMPTY_ERRORS }
+                return this.executeThenBranch(elseSchema, data, fieldValue, fieldName, options)
+            }
+
+            return { valid: true, data: fieldValue, errors: EMPTY_ERRORS }
+        } catch (error) {
+            return this.hooks.internalError(error, fieldValue)
+        }
+    }
+
+    private executeThenBranch<T>(
+        thenSchema: unknown,
+        data: Record<string, unknown>,
+        fieldValue: T,
+        fieldName: string | null,
+        options: ValidateOptions
+    ): ValidationResult<T> {
+        let resolved = thenSchema
+
+        if (typeof resolved === 'string') {
+            resolved = DslParser.parseString(resolved)
+        }
+
+        if (resolved !== null && typeof resolved === 'object') {
+            const obj = resolved as Record<string, unknown>
+            if (typeof obj['toSchema'] === 'function') {
+                resolved = (obj['toSchema'] as () => JSONSchema)()
+            }
+        }
+
+        const resolvedSchema = resolved as ConditionalInternalSchema
+        if (resolvedSchema?._isConditional) {
+            return this.validateConditional(resolvedSchema, data, fieldName, fieldValue, options)
+        }
+
+        if (resolved !== null && typeof resolved === 'object' && !Array.isArray(resolved)) {
+            const obj = resolved as Record<string, unknown>
+            if (obj['type'] === undefined && obj['oneOf'] === undefined && obj['anyOf'] === undefined && obj['allOf'] === undefined) {
+                resolved = DslParser.parseObject(resolved as DslDefinition)
+            }
+        }
+
+        return this.validateFieldValue(resolved as JSONSchema, fieldValue, options)
+    }
+
+    private validateFieldValue<T>(schema: JSONSchema, fieldValue: T, options: ValidateOptions): ValidationResult<T> {
+        const internalSchema = schema as ConditionalInternalSchema
+        const isRequired = internalSchema._required === true
+
+        if (!isRequired && (fieldValue === undefined || fieldValue === '')) {
+            return { valid: true, data: fieldValue, errors: EMPTY_ERRORS }
+        }
+
+        if (isRequired && fieldValue === undefined) {
+            const locale = options.locale ?? Locale.getLocale()
+            const label = internalSchema._label ?? ''
+            const customMsgs = internalSchema._customMessages ?? {}
+            const allMsgs = { ...(options.messages ?? {}), ...customMsgs } as Record<string, string>
+            let message: string
+            if (allMsgs['required']) {
+                message = Locale.getMessageText(allMsgs['required'], allMsgs, locale)
+            } else {
+                message = Locale.getMessageText('required', allMsgs, locale)
+                if (label) message = `${label} ${message}`
+            }
+            return {
+                valid: false,
+                data: fieldValue,
+                errors: [{ message, path: '', keyword: 'required', params: {} }],
+                errorMessage: message,
+            }
+        }
+
+        return this.hooks.validateSchema(schema, fieldValue, options)
+    }
 }