schema-dsl 1.2.5 → 2.0.0

package/src/core/ConditionalBuilder.ts

@@ -0,0 +1,382 @@
+/**
+ * ConditionalBuilder — chainable condition builder.
+ *
+ * v2 fixes:
+ *   C-03: assert() throws ValidationError instead of plain Error
+ *   C-Y01: elseIf semantics correct
+ *   C-Y02: build() as toSchema() alias (IConditionalBuilder interface compat)
+ */
+
+import type { JSONSchema } from '../types/schema.js'
+import type { IConditionalBuilder } from '../types/conditional.js'
+import type { ValidateOptions, ValidationResult } from '../types/validate.js'
+import { ValidationError } from '../errors/ValidationError.js'
+import { Validator } from './Validator.js'
+import { Locale } from './Locale.js'
+import { attachConditionalRuntime } from './ConditionalRuntime.js'
+
+const RUNTIME_ONLY_VALIDATE_OPTION_KEYS = new Set(['locale', 'messages', 'format'])
+
+// ==================== Internal Data Structures ====================
+
+type ConditionFn = (data: unknown) => boolean
+
+interface CombinedCondition {
+  op: 'root' | 'and' | 'or'
+  fn: ConditionFn
+  message: string | null
+}
+
+interface ConditionEntry {
+  type: 'if' | 'elseIf'
+  condition: ConditionFn
+  combinedConditions: CombinedCondition[]
+  message?: string
+  action?: 'throw'
+  then?: string | JSONSchema | null
+}
+
+interface EvaluateResult {
+  result: boolean
+  failedMessage: string | null
+  requirementFailed?: boolean
+}
+
+// ==================== ConditionalBuilder ====================
+
+export class ConditionalBuilder implements IConditionalBuilder {
+  private _conditions: ConditionEntry[]
+  private _elseSchema: string | JSONSchema | null | undefined
+
+  constructor() {
+    this._conditions = []
+    this._elseSchema = undefined
+  }
+
+  // ==================== Condition Chain Methods ====================
+
+  if(conditionFn: ConditionFn | string): this {
+    // v1 compat: accept string field name and convert to function
+    if (typeof conditionFn === 'string') {
+      const fieldName = conditionFn
+      conditionFn = ((data: unknown) => Boolean((data as Record<string, unknown>)[fieldName])) as ConditionFn
+    }
+    if (typeof conditionFn !== 'function') {
+      throw new Error('[schema-dsl] Condition must be a function')
+    }
+    this._conditions.push({
+      type: 'if',
+      condition: conditionFn,
+      combinedConditions: [{ op: 'root', fn: conditionFn, message: null }],
+    })
+    return this
+  }
+
+  and(conditionFn: ConditionFn): this {
+    if (typeof conditionFn !== 'function') {
+      throw new Error('[schema-dsl] Condition must be a function')
+    }
+    const last = this._conditions[this._conditions.length - 1]
+    if (!last) throw new Error('[schema-dsl] .and() must follow .if() or .elseIf()')
+    last.combinedConditions.push({ op: 'and', fn: conditionFn, message: null })
+    return this
+  }
+
+  /**
+   * require(field) — v1 compat: require the specified field to be truthy.
+   * Equivalent to .and(data => Boolean(data[field])).
+   * BC-5 fix.
+   */
+  require(field: string): this {
+    return this.and((data: unknown) => Boolean((data as Record<string, unknown>)[field]))
+  }
+
+  or(conditionFn: ConditionFn): this {
+    if (typeof conditionFn !== 'function') {
+      throw new Error('[schema-dsl] Condition must be a function')
+    }
+    const last = this._conditions[this._conditions.length - 1]
+    if (!last) throw new Error('[schema-dsl] .or() must follow .if() or .elseIf()')
+    last.combinedConditions.push({ op: 'or', fn: conditionFn, message: null })
+    return this
+  }
+
+  elseIf(conditionFn: ConditionFn): this {
+    if (typeof conditionFn !== 'function') {
+      throw new Error('[schema-dsl] Condition must be a function')
+    }
+    if (this._conditions.length === 0) {
+      throw new Error('[schema-dsl] .elseIf() must follow .if()')
+    }
+    this._conditions.push({
+      type: 'elseIf',
+      condition: conditionFn,
+      combinedConditions: [{ op: 'root', fn: conditionFn, message: null }],
+    })
+    return this
+  }
+
+  message(msg: string): this {
+    if (typeof msg !== 'string') {
+      throw new Error('[schema-dsl] Message must be a string')
+    }
+    const last = this._conditions[this._conditions.length - 1]
+    if (!last) throw new Error('[schema-dsl] .message() must follow .if() or .elseIf()')
+
+    const lastCombined = last.combinedConditions[last.combinedConditions.length - 1]
+    if (lastCombined) {
+      lastCombined.message = msg
+    }
+    last.message = msg
+    last.action = 'throw'
+    return this
+  }
+
+  then(schema: string | JSONSchema | null): this {
+    const last = this._conditions[this._conditions.length - 1]
+    if (!last) throw new Error('[schema-dsl] .then() must follow .if() or .elseIf()')
+    last.then = schema
+    return this
+  }
+
+  else(schema: string | JSONSchema | null): this {
+    this._elseSchema = schema
+    return this
+  }
+
+  // ==================== Output Methods ====================
+
+  /**
+   * Produce a schema object carrying serialisable conditional metadata plus non-enumerable runtime state.
+   */
+  toSchema(): JSONSchema {
+    return attachConditionalRuntime({
+      _isConditional: true,
+      _runtimeOnlyConditional: true,
+      else: this._elseSchema,
+    } as unknown as JSONSchema, {
+      conditions: this._conditions,
+      elseSchema: this._elseSchema,
+      evaluateCondition: (conditionObj: unknown, data: unknown) =>
+        this._evaluateCondition(conditionObj as ConditionEntry, data),
+    }) as unknown as JSONSchema
+  }
+
+  /**
+   * build() — alias for toSchema() (IConditionalBuilder interface compat).
+   */
+  build(): JSONSchema {
+    return this.toSchema()
+  }
+
+  // ==================== Validation Methods ====================
+
+  private readonly _validatorCache = new Map<string, Validator>()
+  private static readonly _VALIDATOR_CACHE_MAX = 20
+
+  validate(data: unknown, options: Record<string, unknown> = {}): ValidationResult<unknown> {
+    const validator = this._getValidator(options)
+    return validator.validate(this.toSchema(), data, options)
+  }
+
+  async validateAsync(data: unknown, options: Record<string, unknown> = {}): Promise<ValidationResult<unknown>> {
+    const validator = this._getValidator(options)
+    // validator.validateAsync() throws ValidationError on failure and returns data on success.
+    // Adapt to the ValidationResult contract expected by ConditionalBuilder callers.
+    try {
+      const resultData = await validator.validateAsync(this.toSchema(), data, options)
+      return { valid: true, data: resultData as unknown, errors: [] }
+    } catch (err) {
+      if (err instanceof ValidationError) {
+        return { valid: false, errors: err.errors, data: undefined }
+      }
+      throw err
+    }
+  }
+
+  /**
+   * assert() — synchronous assertion; throws ValidationError on failure (fixes C-03: v1 threw plain Error).
+   * Evaluates conditions synchronously without going through Validator (which is async).
+   */
+  assert(data: unknown, options: Record<string, unknown> = {}): unknown {
+    const locale = (options.locale as string) ?? null
+    for (const cond of this._conditions) {
+      const { result: matched, failedMessage } = this._evaluateCondition(cond, data)
+      if (matched && cond.action === 'throw') {
+        const rawMsg = failedMessage ?? cond.message ?? 'Condition failed'
+        const message = Locale.getMessageText(rawMsg, {}, locale)
+        throw new ValidationError(
+          [{ message, path: '', keyword: 'conditional', params: {} }],
+          data,
+        )
+      }
+    }
+    return data
+  }
+
+  check(data: unknown): boolean {
+    try {
+      const conditions = this._conditions
+      for (const cond of conditions) {
+        const { result: matched } = this._evaluateCondition(cond, data)
+        if (matched && cond.action === 'throw') return false
+      }
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  // ==================== Static Factory Methods ====================
+
+  static start(conditionFn: ConditionFn | string): ConditionalBuilder {
+    return new ConditionalBuilder().if(conditionFn)
+  }
+
+  // ==================== Internal Evaluation Logic ====================
+
+  private _evaluateCondition(conditionObj: ConditionEntry, data: unknown): EvaluateResult {
+    try {
+      const isMessageMode = conditionObj.action === 'throw'
+      const hasOrConditions = conditionObj.combinedConditions.some(c => c.op === 'or')
+
+      // Chain check mode (v1 compat): message mode + root has own message
+      // Each condition checked left-to-right, first TRUE = fail with its message
+      const rootHasMessage = conditionObj.combinedConditions[0]?.message !== null
+      const isChainCheckMode = isMessageMode && rootHasMessage
+
+      if (isChainCheckMode) {
+        for (const combined of conditionObj.combinedConditions) {
+          try {
+            const conditionResult = combined.fn(data)
+            if (conditionResult) {
+              return { result: true, failedMessage: combined.message ?? conditionObj.message ?? null }
+            }
+          } catch {
+            // Condition threw — treat as not matched
+          }
+        }
+        return { result: false, failedMessage: null }
+      }
+
+      // Message mode with AND only (no OR, shared message, root has no own message):
+      // ALL conditions must be true to trigger
+      if (isMessageMode && !hasOrConditions && conditionObj.combinedConditions.length > 1) {
+        let allTrue = true
+        for (const combined of conditionObj.combinedConditions) {
+          if (!combined.fn(data)) {
+            allTrue = false
+            break
+          }
+        }
+        if (allTrue) {
+          return { result: true, failedMessage: conditionObj.message ?? null }
+        }
+        return { result: false, failedMessage: null }
+      }
+
+      // Message mode with OR (and possibly AND, shared message): AND/OR boolean with precedence
+      if (isMessageMode && hasOrConditions) {
+        let andGroupResult = true
+        let finalResult = false
+        for (const combined of conditionObj.combinedConditions) {
+          const conditionResult = combined.fn(data)
+          if (combined.op === 'root' || combined.op === 'and') {
+            andGroupResult = andGroupResult && conditionResult
+          } else if (combined.op === 'or') {
+            finalResult = finalResult || andGroupResult
+            andGroupResult = conditionResult
+          }
+        }
+        finalResult = finalResult || andGroupResult
+        if (finalResult) {
+          return { result: true, failedMessage: conditionObj.message ?? null }
+        }
+        return { result: false, failedMessage: null }
+      }
+
+      // Message mode without AND/OR (single condition)
+      if (isMessageMode) {
+        const root = conditionObj.combinedConditions[0]
+        if (root && root.fn(data)) {
+          return { result: true, failedMessage: root.message ?? conditionObj.message ?? null }
+        }
+        return { result: false, failedMessage: null }
+      }
+
+      // Non-message (then/else) mode: standard AND/OR boolean evaluation
+      let andGroupResult = true
+      let finalResult = false
+      for (const combined of conditionObj.combinedConditions) {
+        const conditionResult = combined.fn(data)
+        if (combined.op === 'root' || combined.op === 'and') {
+          andGroupResult = andGroupResult && conditionResult
+        } else if (combined.op === 'or') {
+          finalResult = finalResult || andGroupResult
+          andGroupResult = conditionResult
+        }
+      }
+      const result = finalResult || andGroupResult
+      return { result, failedMessage: null }
+    } catch {
+      return { result: false, failedMessage: null }
+    }
+  }
+
+  private _getValidator(options: Record<string, unknown>): Validator {
+    const constructorOptions = this._getConstructorOptions(options)
+    const cacheKey = this._getValidatorCacheKey(constructorOptions)
+
+    let validator = this._validatorCache.get(cacheKey)
+    if (!validator) {
+      if (this._validatorCache.size >= ConditionalBuilder._VALIDATOR_CACHE_MAX) {
+        const firstKey = this._validatorCache.keys().next().value
+        if (firstKey !== undefined) this._validatorCache.delete(firstKey)
+      }
+      validator = new Validator(constructorOptions)
+      this._validatorCache.set(cacheKey, validator)
+    }
+
+    return validator
+  }
+
+  private _getConstructorOptions(options: Record<string, unknown>): ValidateOptions {
+    const constructorOptions: Record<string, unknown> = {}
+
+    for (const [key, value] of Object.entries(options)) {
+      if (!RUNTIME_ONLY_VALIDATE_OPTION_KEYS.has(key)) {
+        constructorOptions[key] = value
+      }
+    }
+
+    return constructorOptions as ValidateOptions
+  }
+
+  private _getValidatorCacheKey(options: ValidateOptions): string {
+    return JSON.stringify(this._normalizeOptionValue(options))
+  }
+
+  private _normalizeOptionValue(value: unknown): unknown {
+    if (Array.isArray(value)) {
+      return value.map(item => this._normalizeOptionValue(item))
+    }
+
+    if (value && typeof value === 'object') {
+      return Object.fromEntries(
+        Object.entries(value as Record<string, unknown>)
+          .sort(([left], [right]) => left.localeCompare(right))
+          .map(([key, nestedValue]) => [key, this._normalizeOptionValue(nestedValue)])
+      )
+    }
+
+    if (typeof value === 'function') {
+      return `__fn__:${value.name || 'anonymous'}`
+    }
+
+    if (typeof value === 'bigint') {
+      return `__bigint__:${value.toString()}`
+    }
+
+    return value
+  }
+}

package/src/core/ConditionalRuntime.ts

@@ -0,0 +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
+}

package/src/core/ConditionalValidator.ts

@@ -0,0 +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)
+    }
+}