@atproto/lex-schema 0.0.9 → 0.0.10

package/src/schema/ref.test.ts

@@ -1,39 +1,44 @@
 import { describe, expect, it } from 'vitest'
-import { Schema } from '../core.js'
-import { IntegerSchema } from './integer.js'
-import { ObjectSchema } from './object.js'
-import { OptionalSchema } from './optional.js'
-import { RefSchema } from './ref.js'
-import { StringSchema } from './string.js'
+import { Schema, Validator } from '../core.js'
+import { integer } from './integer.js'
+import { object } from './object.js'
+import { optional } from './optional.js'
+import { ref } from './ref.js'
+import { string } from './string.js'
 
 describe('RefSchema', () => {
   describe('basic validation', () => {
     it('validates through a simple string reference', () => {
-      const schema = new RefSchema(() => new StringSchema({}))
+      const schema = ref(() => innerSchema)
+      const innerSchema = string()
       const result = schema.safeParse('hello')
       expect(result.success).toBe(true)
     })
 
     it('validates through an integer reference', () => {
-      const schema = new RefSchema(() => new IntegerSchema({}))
+      const schema = ref(() => innerSchema)
+      const innerSchema = integer()
       const result = schema.safeParse(42)
       expect(result.success).toBe(true)
     })
 
     it('rejects invalid input through reference', () => {
-      const schema = new RefSchema(() => new StringSchema({}))
+      const schema = ref(() => innerSchema)
+      const innerSchema = string()
       const result = schema.safeParse(123)
       expect(result.success).toBe(false)
     })
 
     it('validates null rejection through reference', () => {
-      const schema = new RefSchema(() => new StringSchema({}))
+      const schema = ref(() => innerSchema)
+      const innerSchema = string()
       const result = schema.safeParse(null)
       expect(result.success).toBe(false)
     })
 
     it('validates undefined rejection through reference', () => {
-      const schema = new RefSchema(() => new IntegerSchema({}))
+      const schema = ref(() => innerSchema)
+      const innerSchema = integer()
       const result = schema.safeParse(undefined)
       expect(result.success).toBe(false)
     })
@@ -42,9 +47,9 @@ describe('RefSchema', () => {
   describe('lazy schema resolution', () => {
     it('does not call getter until first validation', () => {
       let getterCalled = false
-      const schema = new RefSchema(() => {
+      const schema = ref(() => {
         getterCalled = true
-        return new StringSchema({})
+        return string()
       })
       expect(getterCalled).toBe(false)
 
@@ -52,31 +57,18 @@ describe('RefSchema', () => {
       expect(getterCalled).toBe(true)
     })
 
-    it('caches the resolved schema', () => {
-      let callCount = 0
-      const schema = new RefSchema(() => {
-        callCount++
-        return new StringSchema({})
-      })
-
-      schema.safeParse('first')
-      schema.safeParse('second')
-      schema.safeParse('third')
-
-      expect(callCount).toBe(1)
-    })
-
     it('throws error if getter is called multiple times', () => {
-      const schema = new RefSchema(() => new StringSchema({}))
+      const schema = ref(() => innerSchema)
+      const innerSchema = string()
 
       // Access schema property to resolve it
-      schema.schema
+      schema.validator
 
       // Try to access the original getter again (which should throw)
       // This is internal behavior, but we're testing the protection mechanism
       expect(() => {
         // Force access to the cached schema property
-        const schemaValue = schema.schema
+        const schemaValue = schema.validator
         // This should work fine as it's now cached
         expect(schemaValue).toBeDefined()
       }).not.toThrow()
@@ -85,28 +77,28 @@ describe('RefSchema', () => {
 
   describe('with object schemas', () => {
     it('validates objects through reference', () => {
-      const schema = new RefSchema(
-        () =>
-          new ObjectSchema({
-            name: new StringSchema({}),
-            age: new IntegerSchema({}),
-          }),
-      )
-      const result = schema.safeParse({
-        name: 'Alice',
-        age: 30,
+      const schema = ref(() => innerSchema)
+      const innerSchema = object({
+        name: string(),
+        age: integer(),
+      })
+
+      expect(
+        schema.safeValidate({
+          name: 'Alice',
+          age: 30,
+        }),
+      ).toMatchObject({
+        success: true,
       })
-      expect(result.success).toBe(true)
     })
 
     it('rejects invalid objects through reference', () => {
-      const schema = new RefSchema(
-        () =>
-          new ObjectSchema({
-            name: new StringSchema({}),
-            age: new IntegerSchema({}),
-          }),
-      )
+      const schema = ref(() => innerSchema)
+      const innerSchema = object({
+        name: string(),
+        age: integer(),
+      })
       const result = schema.safeParse({
         name: 'Alice',
         age: 'thirty',
@@ -115,13 +107,11 @@ describe('RefSchema', () => {
     })
 
     it('rejects objects with missing properties through reference', () => {
-      const schema = new RefSchema(
-        () =>
-          new ObjectSchema({
-            name: new StringSchema({}),
-            age: new IntegerSchema({}),
-          }),
-      )
+      const schema = ref(() => innerSchema)
+      const innerSchema = object({
+        name: string(),
+        age: integer(),
+      })
       const result = schema.safeParse({
         name: 'Alice',
       })
@@ -131,52 +121,35 @@ describe('RefSchema', () => {
 
   describe('with constrained schemas', () => {
     it('validates string with minLength constraint through reference', () => {
-      const schema = new RefSchema(() => new StringSchema({ minLength: 5 }))
+      const schema = ref(() => innerSchema)
+      const innerSchema = string({ minLength: 5 })
       const result = schema.safeParse('hello')
       expect(result.success).toBe(true)
     })
 
     it('rejects string violating minLength through reference', () => {
-      const schema = new RefSchema(() => new StringSchema({ minLength: 5 }))
+      const schema = ref(() => innerSchema)
+      const innerSchema = string({ minLength: 5 })
       const result = schema.safeParse('hi')
       expect(result.success).toBe(false)
     })
 
     it('validates integer with range constraints through reference', () => {
-      const schema = new RefSchema(
-        () => new IntegerSchema({ minimum: 0, maximum: 100 }),
-      )
+      const schema = ref(() => innerSchema)
+      const innerSchema = integer({ minimum: 0, maximum: 100 })
       const result = schema.safeParse(50)
       expect(result.success).toBe(true)
     })
 
     it('rejects integer violating constraints through reference', () => {
-      const schema = new RefSchema(
-        () => new IntegerSchema({ minimum: 0, maximum: 100 }),
-      )
+      const schema = ref(() => innerSchema)
+      const innerSchema = integer({ minimum: 0, maximum: 100 })
       const result = schema.safeParse(150)
       expect(result.success).toBe(false)
     })
   })
 
   describe('circular references', () => {
-    it('prevents recursive getter calls', () => {
-      // Create a schema that would cause infinite recursion if not protected
-      let schema: RefSchema<any>
-
-      // eslint-disable-next-line prefer-const
-      schema = new RefSchema(() => {
-        // This would normally cause infinite recursion
-        // but the getter protection should prevent it
-        return schema.schema
-      })
-
-      // The first access causes stack overflow before the protection can kick in
-      expect(() => {
-        schema.safeParse('test')
-      }).toThrow()
-    })
-
     it('supports indirect circular references', () => {
       // Create two schemas that reference each other
       // This demonstrates forward references are possible
@@ -184,14 +157,14 @@ describe('RefSchema', () => {
       type A = { value: string; ref?: B }
       type B = { value: number; ref?: A }
 
-      const schemaA: Schema<A> = new ObjectSchema({
-        value: new StringSchema({}),
-        ref: new OptionalSchema(new RefSchema<B>((() => schemaB) as any)),
+      const schemaA: Schema<A> = object({
+        value: string(),
+        ref: optional(ref<Validator<B>>((() => schemaB) as any)),
       })
 
-      const schemaB: Schema<B> = new ObjectSchema({
-        value: new IntegerSchema({}),
-        ref: new OptionalSchema(new RefSchema<A>((() => schemaA) as any)),
+      const schemaB: Schema<B> = object({
+        value: integer(),
+        ref: optional(ref<Validator<A>>((() => schemaA) as any)),
       })
 
       expect(
@@ -222,7 +195,8 @@ describe('RefSchema', () => {
 
   describe('multiple validations', () => {
     it('validates multiple inputs correctly', () => {
-      const schema = new RefSchema(() => new StringSchema({ minLength: 3 }))
+      const schema = ref(() => innerSchema)
+      const innerSchema = string({ minLength: 3 })
 
       const result1 = schema.safeParse('hello')
       expect(result1.success).toBe(true)
@@ -238,12 +212,11 @@ describe('RefSchema', () => {
     })
 
     it('handles different types of validation failures', () => {
-      const schema = new RefSchema(
-        () =>
-          new ObjectSchema({
-            name: new StringSchema({ minLength: 2 }),
-            age: new IntegerSchema({ minimum: 0 }),
-          }),
+      const schema = ref(() =>
+        object({
+          name: string({ minLength: 2 }),
+          age: integer({ minimum: 0 }),
+        }),
       )
 
       const result1 = schema.safeParse({ name: 'A', age: 25 })
@@ -259,43 +232,50 @@ describe('RefSchema', () => {
 
   describe('edge cases', () => {
     it('handles empty string validation', () => {
-      const schema = new RefSchema(() => new StringSchema({}))
+      const schema = ref(() => innerSchema)
+      const innerSchema = string()
       const result = schema.safeParse('')
       expect(result.success).toBe(true)
     })
 
     it('handles zero validation', () => {
-      const schema = new RefSchema(() => new IntegerSchema({}))
+      const schema = ref(() => innerSchema)
+      const innerSchema = integer()
       const result = schema.safeParse(0)
       expect(result.success).toBe(true)
     })
 
     it('rejects NaN through integer reference', () => {
-      const schema = new RefSchema(() => new IntegerSchema({}))
+      const schema = ref(() => innerSchema)
+      const innerSchema = integer()
       const result = schema.safeParse(NaN)
       expect(result.success).toBe(false)
     })
 
     it('rejects Infinity through integer reference', () => {
-      const schema = new RefSchema(() => new IntegerSchema({}))
+      const schema = ref(() => innerSchema)
+      const innerSchema = integer()
       const result = schema.safeParse(Infinity)
       expect(result.success).toBe(false)
     })
 
     it('rejects arrays when expecting string', () => {
-      const schema = new RefSchema(() => new StringSchema({}))
+      const schema = ref(() => innerSchema)
+      const innerSchema = string()
       const result = schema.safeParse(['array'])
       expect(result.success).toBe(false)
     })
 
     it('rejects objects when expecting string', () => {
-      const schema = new RefSchema(() => new StringSchema({}))
+      const schema = ref(() => innerSchema)
+      const innerSchema = string()
       const result = schema.safeParse({ key: 'value' })
       expect(result.success).toBe(false)
     })
 
     it('rejects booleans when expecting string', () => {
-      const schema = new RefSchema(() => new StringSchema({}))
+      const schema = ref(() => innerSchema)
+      const innerSchema = string()
       const result = schema.safeParse(true)
       expect(result.success).toBe(false)
     })
@@ -303,25 +283,28 @@ describe('RefSchema', () => {
 
   describe('nested references', () => {
     it('validates through nested RefSchema', () => {
-      const innerRef = new RefSchema(() => new StringSchema({ minLength: 3 }))
-      const outerRef = new RefSchema(() => innerRef)
+      const innerRef = ref(() => innerSchema)
+      const innerSchema = string({ minLength: 3 })
+      const outerRef = ref(() => innerRef)
 
       const result = outerRef.safeParse('hello')
       expect(result.success).toBe(true)
     })
 
     it('rejects invalid input through nested RefSchema', () => {
-      const innerRef = new RefSchema(() => new StringSchema({ minLength: 3 }))
-      const outerRef = new RefSchema(() => innerRef)
+      const innerRef = ref(() => innerSchema)
+      const innerSchema = string({ minLength: 3 })
+      const outerRef = ref(() => innerRef)
 
       const result = outerRef.safeParse('hi')
       expect(result.success).toBe(false)
     })
 
     it('validates with deeply nested references', () => {
-      const level3 = new RefSchema(() => new IntegerSchema({ minimum: 0 }))
-      const level2 = new RefSchema(() => level3)
-      const level1 = new RefSchema(() => level2)
+      const level3 = ref(() => innerSchema)
+      const innerSchema = integer({ minimum: 0 })
+      const level2 = ref(() => level3)
+      const level1 = ref(() => level2)
 
       const result = level1.safeParse(42)
       expect(result.success).toBe(true)
@@ -330,20 +313,20 @@ describe('RefSchema', () => {
 
   describe('schema property access', () => {
     it('allows direct access to resolved schema', () => {
-      const innerSchema = new StringSchema({ minLength: 5 })
-      const refSchema = new RefSchema(() => innerSchema)
+      const innerSchema = string({ minLength: 5 })
+      const refSchema = ref(() => innerSchema)
 
-      const resolved = refSchema.schema
+      const resolved = refSchema.validator
       expect(resolved).toBe(innerSchema)
     })
 
     it('returns same instance on multiple schema property accesses', () => {
-      const innerSchema = new StringSchema({})
-      const refSchema = new RefSchema(() => innerSchema)
+      const innerSchema = string()
+      const refSchema = ref(() => innerSchema)
 
-      const first = refSchema.schema
-      const second = refSchema.schema
-      const third = refSchema.schema
+      const first = refSchema.validator
+      const second = refSchema.validator
+      const third = refSchema.validator
 
       expect(first).toBe(second)
       expect(second).toBe(third)
@@ -351,14 +334,14 @@ describe('RefSchema', () => {
 
     it('resolves schema before validation', () => {
       let resolved = false
-      const refSchema = new RefSchema(() => {
+      const refSchema = ref(() => {
         resolved = true
-        return new StringSchema({})
+        return string()
       })
 
       expect(resolved).toBe(false)
 
-      const schemaValue = refSchema.schema
+      const schemaValue = refSchema.validator
       expect(resolved).toBe(true)
       expect(schemaValue).toBeDefined()
     })

package/src/schema/ref.ts

@@ -1,16 +1,25 @@
 import {
+  InferInput,
+  InferOutput,
   Schema,
-  ValidationResult,
+  ValidationContext,
   Validator,
-  ValidatorContext,
+  WrappedValidator,
 } from '../core.js'
 
-export type RefSchemaGetter<V> = () => Validator<V>
+export type RefSchemaGetter<out TValidator extends Validator> = () => TValidator
 
-export class RefSchema<V = any> extends Schema<V> {
-  #getter: RefSchemaGetter<V>
+export class RefSchema<const TValidator extends Validator>
+  extends Schema<
+    InferInput<TValidator>,
+    InferOutput<TValidator>,
+    TValidator['__lex']
+  >
+  implements WrappedValidator<TValidator>
+{
+  #getter: RefSchemaGetter<TValidator>
 
-  constructor(getter: RefSchemaGetter<V>) {
+  constructor(getter: RefSchemaGetter<TValidator>) {
     // @NOTE In order to avoid circular dependency issues, we don't resolve
     // the schema here. Instead, we resolve it lazily when first accessed.
 
@@ -19,32 +28,28 @@ export class RefSchema<V = any> extends Schema<V> {
     this.#getter = getter
   }
 
-  get schema(): Validator<V> {
-    const value = this.#getter.call(null)
-
-    // Prevents a getter from depending on itself recursively, also allows GC to
-    // clean up the getter function.
-    this.#getter = throwAlreadyCalled
-
-    // Disable the getter and cache the resolved schema on the instance
-    Object.defineProperty(this, 'schema', {
-      value,
-      writable: false,
-      enumerable: false,
-      configurable: true,
-    })
+  get validator(): TValidator {
+    return this.#getter.call(null)
+  }
 
-    return value
+  unwrap(): TValidator {
+    return this.validator
   }
 
-  validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<V> {
-    return ctx.validate(input, this.schema)
+  validateInContext(input: unknown, ctx: ValidationContext) {
+    return ctx.validate(input, this.validator)
   }
 }
 
-function throwAlreadyCalled(): never {
-  throw new Error('RefSchema getter called multiple times')
+/*@__NO_SIDE_EFFECTS__*/
+export function ref<const TValidator extends Validator>(
+  get: RefSchemaGetter<TValidator>,
+): RefSchema<TValidator>
+export function ref<TInput, TOutput extends TInput = TInput>(
+  get: RefSchemaGetter<Validator<TInput, TOutput>>,
+): RefSchema<Validator<TInput, TOutput>>
+export function ref<const TValidator extends Validator>(
+  get: RefSchemaGetter<TValidator>,
+) {
+  return new RefSchema<TValidator>(get)
 }