Clean up Compiler and Schema Validators

Author: sinclairzx81

example/index.ts

@@ -6,65 +6,6 @@ import Schema from 'typebox/schema'
 import Value from 'typebox/value'
 import Type from 'typebox'
 
-// ------------------------------------------------------------------
-// Settings
-// ------------------------------------------------------------------
+const X = Schema.Compile(Type.String())
 
-System.Settings.Set({ enumerableKind: false })
-
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-
-const A = Guard.GraphemeCount('type-📦')      // 6
-const B = Guard.HasPropertyKey({ x: 1 }, 'x') // true
-
-// ------------------------------------------------------------------
-// Type
-// ------------------------------------------------------------------
-
-const T = Type.Object({
-  x: Type.Number(),
-  y: Type.Number(),
-  z: Type.Number()
-})
-
-// ------------------------------------------------------------------
-// Script
-// ------------------------------------------------------------------
-
-const S = Type.Script({ T }, `{
-  [K in keyof T]: T[K] | null
-}`)
-
-// ------------------------------------------------------------------
-// Infer
-// ------------------------------------------------------------------
-
-type T = Type.Static<typeof T>
-type S = Type.Static<typeof S>
-
-// ------------------------------------------------------------------
-// Parse
-// ------------------------------------------------------------------
-
-const R = Value.Parse(T, { x: 1, y: 2, z: 3 })
-
-// ------------------------------------------------------------------
-// Compile
-// ------------------------------------------------------------------
-const C = Compile(S)
-
-const X = C.Parse({ x: 1, y: 2, z: 3 })
-
-// ------------------------------------------------------------------
-// Format
-// ------------------------------------------------------------------
-
-const E = Format.IsEmail('user@domain.com')
-
-// ------------------------------------------------------------------
-// Schema
-// ------------------------------------------------------------------
-
-const D = Schema.Parse({ const: 'hello' }, 'hello')
+console.log(X)

src/compile/code.ts

@@ -76,8 +76,8 @@ function FunctionSection(build: BuildResult): string[] {
 // ------------------------------------------------------------------
 function ExportSection(build: BuildResult): string[] {
   const body = build.UseUnevaluated() 
-    ? `const context = new CheckContext({}, {}); return ${build.Call()}` 
-    : `return ${build.Call()}`
+    ? `const context = new CheckContext({}, {}); return ${build.Entry()}` 
+    : `return ${build.Entry()}`
   return [
     Separator(),
     TsIgnore(),

src/compile/validator.ts

@@ -30,11 +30,10 @@ THE SOFTWARE.
 
 import { Settings } from '../system/settings/index.ts'
 import { Arguments } from '../system/arguments/index.ts'
-import { Environment } from '../system/environment/index.ts'
 import { type TLocalizedValidationError } from '../error/index.ts'
 import { type StaticDecode, type StaticEncode, type TProperties, type TSchema, Base } from '../type/index.ts'
 import { Errors, Clean, Convert, Create, Default, Decode, Encode, HasCodec, Parser, ParseError } from '../value/index.ts'
-import { Build } from '../schema/index.ts'
+import { Build, BuildResult, EvaluateResult } from '../schema/index.ts'
 
 // ------------------------------------------------------------------
 // Validator<...>
@@ -43,121 +42,117 @@ export class Validator<Context extends TProperties = TProperties, Type extends T
   Encode extends unknown = StaticEncode<Type, Context>,
   Decode extends unknown = StaticDecode<Type, Context>
 > extends Base<Encode> {
-  private readonly context: Context
-  private readonly type: Type
-  private readonly isAccelerated: boolean
   private readonly hasCodec: boolean
-  private readonly code: string
-  private readonly check: (value: unknown) => boolean
+  private readonly buildResult: BuildResult
+  private readonly evaluateResult: EvaluateResult
   /** Constructs a Validator with the given Context and Type. */
   constructor(context: Context, type: Type)
   /** Constructs a Validator with the given arguments. */
-  constructor(context: Context, type: Type, isEvaluated: boolean, hasCodec: boolean, code: string, check: (value: unknown) => boolean)
+  constructor(hasCodec: boolean, buildResult: BuildResult, evaluateResult: EvaluateResult)
   /** Constructs a Validator. */
   constructor(...args: unknown[]) {
     super()
-    const matched: [Context, Type, boolean, boolean, string, (value: unknown) => boolean] | [Context, Type] = Arguments.Match(args, {
-      6: (context, type, isEvalulated, hasCodec, code, check) => [context, type, isEvalulated, hasCodec, code, check],
+    const matched: [boolean, BuildResult, EvaluateResult] | [Context, Type] = Arguments.Match(args, {
+      3: (hasCodec, buildResult, evaluateResult) => [hasCodec, buildResult, evaluateResult],
       2: (context, type) => [context, type]
     })
-    if(matched.length === 6) {
-      const [context, type, isEvaluated, hasCodec, code, check] = matched
-      this.context = context
-      this.type = type
-      this.isAccelerated = isEvaluated
+    // Note: The Base type requires this Validator to be Clone, but where we cannot safely clone
+    // the BuildResult or the EvaluateResult. For now we need pass the Validator constructor a 
+    // cloned instance of BuildResult and EvaluateResult such that the Validator clone shares 
+    // the same pre-compiled fields. We should remove this overload when Base is removed.
+    if(matched.length === 3 && matched[1] instanceof BuildResult && matched[2] instanceof EvaluateResult) {
+      const [hasCodec, buildResult, evaluateResult] = matched
       this.hasCodec = hasCodec
-      this.code = code
-      this.check = check
+      this.buildResult = buildResult
+      this.evaluateResult = evaluateResult
     } else {
       const [context, type] = matched as [Context, Type]
-      const result = Build(context, type).Evaluate()
       this.hasCodec = HasCodec(context, type)
-      this.context = context
-      this.type = type
-      this.isAccelerated = result.IsAccelerated
-      this.code = result.Code
-      this.check = result.Check as never
+      this.buildResult = Build(context, type)
+      this.evaluateResult = this.buildResult.Evaluate()
     }
   }
   // ----------------------------------------------------------------
   // IsAccelerated
   // ----------------------------------------------------------------
   /** Returns true if this Validator is using JIT acceleration. */
   public IsAccelerated(): boolean {
-    return this.isAccelerated
+    return this.evaluateResult.IsAccelerated()
   }
   // ----------------------------------------------------------------
-  // Context | Type
+  // Context & Type
   // ----------------------------------------------------------------
   /** Returns the Context for this validator. */
   public Context(): Context {
-    return this.context
+    return this.buildResult.Context() as never
   }
   /** Returns the underlying Type used to construct this Validator. */
   public Type(): Type {
-    return this.type
+    return this.buildResult.Schema() as never
   }
   // ----------------------------------------------------------------
   // Code
   // ----------------------------------------------------------------
   /** Returns the generated code for this validator. */
   public Code(): string {
-    return this.code
+    return this.evaluateResult.Code()
   }
   // ----------------------------------------------------------------
-  // Base<...>
+  // Standard Validator
   // ----------------------------------------------------------------
   /** Performs a type-guard check on the provided value. */
   public override Check(value: unknown): value is Encode {
-    return this.check(value)
+    return this.evaluateResult.Check(value)
+  }
+  /** Validates a value and returns it. Will throw if invalid. */
+  public Parse(value: unknown): Encode {
+    const checked = this.Check(value)
+    if(checked) return value as never
+    if(Settings.Get().correctiveParse) return Parser(this.Context(), this.Type(), value) as never
+    throw new ParseError(value, this.Errors(value))
   }
   /** Inspects a value and returns a detailed list of validation errors. */
   public override Errors(value: unknown): TLocalizedValidationError[] {
-    if (Environment.CanEvaluate() && this.check(value)) return []
-    return Errors(this.context, this.type, value)
+    if (this.IsAccelerated() && this.Check(value)) return []
+    return Errors(this.Context(), this.Type(), value)
   }
+  // ----------------------------------------------------------------
+  // Value.* Operations
+  // ----------------------------------------------------------------
   /** Cleans a value using the Validator type. */
   public override Clean(value: unknown): unknown {
-    return Clean(this.context, this.type, value)
+    return Clean(this.Context(), this.Type(), value)
   }
   /** Converts a value using the Validator type. */
   public override Convert(value: unknown): unknown {
-    return Convert(this.context, this.type, value)
+    return Convert(this.Context(), this.Type(), value)
   }
   /** Creates a value using the Validator type. */
   public override Create(): Encode {
-    return Create(this.context, this.type)
+    return Create(this.Context(), this.Type())
   }
   /** Creates defaults using the Validator type. */
   public override Default(value: unknown): unknown {
-    return Default(this.context, this.type, value)
-  }
-  /** Clones this validator. */
-  public override Clone(): Validator<Context, Type> {
-    return new Validator<Context, Type>(
-      this.context,
-      this.type, 
-      this.isAccelerated, 
-      this.hasCodec, 
-      this.code, 
-      this.check
-    )
-  }
-  /** Validates a value and returns it. Will throw if invalid. */
-  public Parse(value: unknown): Encode {
-    const checked = this.Check(value)
-    if(checked) return value as never
-    if(Settings.Get().correctiveParse) return Parser(this.context, this.type, value) as never
-    throw new ParseError(value, this.Errors(value))
+    return Default(this.Context(), this.Type(), value)
   }
   /** Decodes a value */
   public Decode(value: unknown): Decode {
-    const result = this.hasCodec ? Decode(this.context, this.type, value) : this.Parse(value)
+    const result = this.hasCodec ? Decode(this.Context(), this.Type(), value) : this.Parse(value)
     return result as never
   }
   /** Encodes a value */
   public Encode(value: unknown): Encode {
-    const result = this.hasCodec ? Encode(this.context, this.type, value) : this.Parse(value)
+    const result = this.hasCodec ? Encode(this.Context(), this.Type(), value) : this.Parse(value)
     return result as never
   }
+  // ----------------------------------------------------------------
+  // Deprecations
+  // ----------------------------------------------------------------
+  /** 
+   * @deprecated Validator instances should not support Clone because they are owners of JIT evaluated functions. This function will be 
+   * removed in the next version of TypeBox (relates to Type.Base deprecation)
+   */
+  public override Clone(): Validator<Context, Type> {
+    return new Validator<Context, Type>(this.hasCodec, this.buildResult, this.evaluateResult)
+  }
 }

src/schema/build.ts

@@ -44,8 +44,8 @@ import * as Schema from './types/index.ts'
 function CreateCode(build: BuildResult): string {
   const functions = build.Functions().join(';\n')
   const statements = build.UseUnevaluated()
-    ? ['const context = new CheckContext({}, {})', `return ${build.Call()}`]
-    : [`return ${build.Call()}`]
+    ? ['const context = new CheckContext({}, {})', `return ${build.Entry()}`]
+    : [`return ${build.Entry()}`]
   return `${functions}; return (value) => { ${statements.join('; ')} }`
 }
 // ------------------------------------------------------------------
@@ -79,10 +79,21 @@ export type CheckFunction = (value: unknown) => boolean
 // ------------------------------------------------------------------
 // EvaluateResult
 // ------------------------------------------------------------------
-export interface EvaluateResult {
-  IsAccelerated: boolean
-  Code: string
-  Check: CheckFunction
+export class EvaluateResult {
+  constructor(
+    private readonly isAccelerated: boolean,
+    private readonly code: string,
+    private readonly check: CheckFunction
+  ) {}
+  public IsAccelerated() {
+    return this.isAccelerated
+  }
+  public Code(): string {
+    return this.code
+  }
+  public Check(value: unknown): boolean {
+    return this.check(value)
+  }
 }
 // ------------------------------------------------------------------
 // BuildResult
@@ -93,7 +104,7 @@ export class BuildResult {
     private readonly schema: Schema.XSchema,
     private readonly external: Engine.TExternal,
     private readonly functions: string[],
-    private readonly call: string,
+    private readonly entry: string,
     private readonly useUnevaluated: boolean
   ) { }
   /** Returns the Context used for this build */
@@ -117,14 +128,14 @@ export class BuildResult {
     return this.functions
   }
   /** Return entry function call. */
-  public Call(): string {
-    return this.call
+  public Entry(): string {
+    return this.entry
   }
   /** Evaluates the build into a validation function */
   public Evaluate(): EvaluateResult {
-    const Code = CreateCode(this)
-    const Check = CreateCheck(this, Code)
-    return { IsAccelerated: Environment.CanEvaluate(), Code, Check }
+    const code = CreateCode(this)
+    const check = CreateCheck(this, code)
+    return new EvaluateResult(Environment.CanEvaluate(), code, check)
   }
 }
 // ------------------------------------------------------------------

src/schema/compile.ts

@@ -43,33 +43,33 @@ import { ParseError } from './parse.ts'
 export class Validator<const Schema extends Schema.XSchema = Schema.XSchema, 
   Value extends unknown = Static<Schema>
 >  {
-  readonly #buildResult: Build.BuildResult
-  readonly #evaluateResult: Build.EvaluateResult
+  private readonly buildResult: Build.BuildResult
+  private readonly evaluateResult: Build.EvaluateResult
   constructor(context: Record<string, Schema.XSchema>, schema: Schema) {
-    this.#buildResult = Build.Build(context, schema)
-    this.#evaluateResult = this.#buildResult.Evaluate()
+    this.buildResult = Build.Build(context, schema)
+    this.evaluateResult = this.buildResult.Evaluate()
   }
   /** Returns true if this Validator is using JIT acceleration. */
   public IsAccelerated(): boolean {
-    return this.#evaluateResult.IsAccelerated
+    return this.evaluateResult.IsAccelerated()
   }
   /** Returns the underlying Schema used to construct this Validator. */
   public Schema(): Schema {
-    return this.#buildResult.Schema() as never
+    return this.buildResult.Schema() as never
   }
   /** Performs a type-guard check on the provided value. */
   public Check(value: unknown): value is Value {
-    return this.#evaluateResult.Check(value)
+    return this.evaluateResult.Check(value)
   }
   /** Validates a value and returns it. Will throw if invalid. */
   public Parse(value: unknown): Value {
-    if(this.#evaluateResult.Check(value)) return value as never
-    const [_result, errors] = Errors(this.#buildResult.Context(), this.#buildResult.Schema(), value)
-    throw new ParseError(this.#buildResult.Schema(), value, errors)
+    if(this.evaluateResult.Check(value)) return value as never
+    const [_result, errors] = Errors(this.buildResult.Context(), this.buildResult.Schema(), value)
+    throw new ParseError(this.buildResult.Schema(), value, errors)
   }
   /** Inspects a value and returns a detailed list of validation errors. */
   public Errors(value: unknown): [result: boolean, errors: TLocalizedValidationError[]] {
-    return Errors(this.#buildResult.Context(), this.#buildResult.Schema(), value)
+    return Errors(this.buildResult.Context(), this.buildResult.Schema(), value)
   }
 }
 // ------------------------------------------------------------------

test/typebox/runtime/schema/additional.ts

@@ -13,13 +13,13 @@ const Test = Assert.Context('Schema.Additional')
 // When unevaluatedItems is present, prefixItems should register their indices.
 // This behavior is used for build-time optimization only.
 Test('Should Coverage 1', () => {
-  const check = Schema.Build({
+  const evaluateResult = Schema.Build({
     prefixItems: [{ const: 1 }, { const: 2 }],
     unevaluatedItems: false
-  }).Evaluate().Check
+  }).Evaluate()
 
-  Assert.IsTrue(check([1, 2]))
-  Assert.IsFalse(check([1, 2, 3]))
+  Assert.IsTrue(evaluateResult.Check([1, 2]))
+  Assert.IsFalse(evaluateResult.Check([1, 2, 3]))
 })
 
 // Test 2: Ensures unknown type values are handled correctly.