@atproto/lex-schema 0.0.1 → 0.0.3

package/src/schema/typed-ref.ts

@@ -1,4 +1,9 @@
-import { ValidationResult, Validator, ValidatorContext } from '../validation.js'
+import {
+  Schema,
+  ValidationResult,
+  Validator,
+  ValidatorContext,
+} from '../validation.js'
 
 // Basically a RecordSchema or TypedObjectSchema
 export type TypedRefSchemaValidator<V extends { $type?: string } = any> =
@@ -12,9 +17,9 @@ export type TypedRefGetter<V extends { $type?: string } = any> =
 export type TypedRefSchemaOutput<V extends { $type?: string } = any> =
   V extends { $type?: infer T extends string } ? V & { $type: T } : never
 
-export class TypedRefSchema<
-  V extends { $type?: string } = any,
-> extends Validator<TypedRefSchemaOutput<V>> {
+export class TypedRefSchema<V extends { $type?: string } = any> extends Schema<
+  TypedRefSchemaOutput<V>
+> {
   #getter: TypedRefGetter<V>
 
   constructor(getter: TypedRefGetter<V>) {
@@ -48,7 +53,7 @@ export class TypedRefSchema<
     return this.schema.$type
   }
 
-  override validateInContext(
+  validateInContext(
     input: unknown,
     ctx: ValidatorContext,
   ): ValidationResult<TypedRefSchemaOutput<V>> {

package/src/schema/typed-union.test.ts

@@ -0,0 +1,378 @@
+import { IntegerSchema } from './integer.js'
+import { ObjectSchema } from './object.js'
+import { StringSchema } from './string.js'
+import { TypedObjectSchema } from './typed-object.js'
+import { TypedRefSchema } from './typed-ref.js'
+import { TypedUnionSchema } from './typed-union.js'
+
+describe('TypedUnionSchema', () => {
+  const personSchema = new TypedObjectSchema(
+    'app.bsky.actor.person',
+    new ObjectSchema({
+      name: new StringSchema({}),
+      age: new IntegerSchema({}),
+    }),
+  )
+
+  const postSchema = new TypedObjectSchema(
+    'app.bsky.feed.post',
+    new ObjectSchema({
+      text: new StringSchema({}),
+      createdAt: new StringSchema({}),
+    }),
+  )
+
+  const commentSchema = new TypedObjectSchema(
+    'app.bsky.feed.comment',
+    new ObjectSchema({
+      text: new StringSchema({}),
+      parentUri: new StringSchema({}),
+    }),
+  )
+
+  describe('closed union', () => {
+    const schema = new TypedUnionSchema(
+      [
+        new TypedRefSchema(() => personSchema),
+        new TypedRefSchema(() => postSchema),
+      ],
+      true,
+    )
+
+    it('validates first type in union', () => {
+      const result = schema.safeParse({
+        $type: 'app.bsky.actor.person',
+        name: 'Alice',
+        age: 30,
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('validates second type in union', () => {
+      const result = schema.safeParse({
+        $type: 'app.bsky.feed.post',
+        text: 'Hello world',
+        createdAt: '2023-01-01T00:00:00Z',
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects unknown $type in closed union', () => {
+      const result = schema.safeParse({
+        $type: 'app.bsky.feed.like',
+        subject: 'some-uri',
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects object without $type', () => {
+      const result = schema.safeParse({
+        name: 'Alice',
+        age: 30,
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects object with invalid property for the $type', () => {
+      const result = schema.safeParse({
+        $type: 'app.bsky.actor.person',
+        name: 'Alice',
+        age: 'thirty',
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects object missing required properties', () => {
+      const result = schema.safeParse({
+        $type: 'app.bsky.actor.person',
+        name: 'Alice',
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects non-object input', () => {
+      const result = schema.safeParse('not an object')
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects null', () => {
+      const result = schema.safeParse(null)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects undefined', () => {
+      const result = schema.safeParse(undefined)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects array', () => {
+      const result = schema.safeParse([])
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects number', () => {
+      const result = schema.safeParse(42)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects boolean', () => {
+      const result = schema.safeParse(true)
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('open union', () => {
+    const schema = new TypedUnionSchema(
+      [
+        new TypedRefSchema(() => personSchema),
+        new TypedRefSchema(() => postSchema),
+      ],
+      false,
+    )
+
+    it('validates known type', () => {
+      const result = schema.safeParse({
+        $type: 'app.bsky.actor.person',
+        name: 'Alice',
+        age: 30,
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('validates unknown $type with valid structure', () => {
+      const result = schema.safeParse({
+        $type: 'app.bsky.feed.like',
+        subject: 'some-uri',
+        createdAt: '2023-01-01T00:00:00Z',
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('accepts any properties for unknown $type', () => {
+      const result = schema.safeParse({
+        $type: 'unknown.nsid.type',
+        anyProperty: 'any value',
+        anotherProperty: 123,
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects unknown $type with non-string $type', () => {
+      const result = schema.safeParse({
+        $type: 123,
+        someProperty: 'value',
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects unknown $type with null $type', () => {
+      const result = schema.safeParse({
+        $type: null,
+        someProperty: 'value',
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects object without $type', () => {
+      const result = schema.safeParse({
+        name: 'Alice',
+        age: 30,
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects non-object input', () => {
+      const result = schema.safeParse('not an object')
+      expect(result.success).toBe(false)
+    })
+
+    it('validates known type with extra properties', () => {
+      const result = schema.safeParse({
+        $type: 'app.bsky.actor.person',
+        name: 'Alice',
+        age: 30,
+        extraProperty: 'extra',
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects known type with invalid property types', () => {
+      const result = schema.safeParse({
+        $type: 'app.bsky.actor.person',
+        name: 123,
+        age: 30,
+      })
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('with three types', () => {
+    const schema = new TypedUnionSchema(
+      [
+        new TypedRefSchema(() => personSchema),
+        new TypedRefSchema(() => postSchema),
+        new TypedRefSchema(() => commentSchema),
+      ],
+      true,
+    )
+
+    it('validates first type', () => {
+      const result = schema.safeParse({
+        $type: 'app.bsky.actor.person',
+        name: 'Alice',
+        age: 30,
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('validates second type', () => {
+      const result = schema.safeParse({
+        $type: 'app.bsky.feed.post',
+        text: 'Hello',
+        createdAt: '2023-01-01T00:00:00Z',
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('validates third type', () => {
+      const result = schema.safeParse({
+        $type: 'app.bsky.feed.comment',
+        text: 'Nice post!',
+        parentUri: 'at://did:plc:xyz/app.bsky.feed.post/123',
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects unknown type', () => {
+      const result = schema.safeParse({
+        $type: 'app.bsky.feed.like',
+        subject: 'some-uri',
+      })
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('with single type', () => {
+    const schema = new TypedUnionSchema(
+      [new TypedRefSchema(() => personSchema)],
+      true,
+    )
+
+    it('validates the single type', () => {
+      const result = schema.safeParse({
+        $type: 'app.bsky.actor.person',
+        name: 'Alice',
+        age: 30,
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects different type', () => {
+      const result = schema.safeParse({
+        $type: 'app.bsky.feed.post',
+        text: 'Hello',
+        createdAt: '2023-01-01T00:00:00Z',
+      })
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('$types getter', () => {
+    const schema = new TypedUnionSchema(
+      [
+        new TypedRefSchema(() => personSchema),
+        new TypedRefSchema(() => postSchema),
+      ],
+      true,
+    )
+
+    it('returns array of valid $type values', () => {
+      const types = schema.$types
+      expect(types).toContain('app.bsky.actor.person')
+      expect(types).toContain('app.bsky.feed.post')
+      expect(types.length).toBe(2)
+    })
+  })
+
+  describe('refsMap getter', () => {
+    const schema = new TypedUnionSchema(
+      [
+        new TypedRefSchema(() => personSchema),
+        new TypedRefSchema(() => postSchema),
+      ],
+      true,
+    )
+
+    it('returns map of $type to ref schema', () => {
+      const refsMap = schema.refsMap
+      expect(refsMap.size).toBe(2)
+      expect(refsMap.has('app.bsky.actor.person')).toBe(true)
+      expect(refsMap.has('app.bsky.feed.post')).toBe(true)
+    })
+  })
+
+  describe('edge cases', () => {
+    const schema = new TypedUnionSchema(
+      [
+        new TypedRefSchema(() => personSchema),
+        new TypedRefSchema(() => postSchema),
+      ],
+      true,
+    )
+
+    it('rejects object with $type as empty string in closed union', () => {
+      const result = schema.safeParse({
+        $type: '',
+        name: 'Alice',
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('validates object with $type as empty string in open union', () => {
+      const openSchema = new TypedUnionSchema(
+        [new TypedRefSchema(() => personSchema)],
+        false,
+      )
+      const result = openSchema.safeParse({
+        $type: '',
+        someProperty: 'value',
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects plain object with only $type', () => {
+      const result = schema.safeParse({
+        $type: 'app.bsky.actor.person',
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('handles object with $type and undefined properties', () => {
+      const result = schema.safeParse({
+        $type: 'app.bsky.actor.person',
+        name: 'Alice',
+        age: 30,
+        extra: undefined,
+      })
+      expect(result.success).toBe(true)
+    })
+  })
+
+  describe('closed property', () => {
+    it('exposes closed property as true', () => {
+      const schema = new TypedUnionSchema(
+        [new TypedRefSchema(() => personSchema)],
+        true,
+      )
+      expect(schema.closed).toBe(true)
+    })
+
+    it('exposes closed property as false', () => {
+      const schema = new TypedUnionSchema(
+        [new TypedRefSchema(() => personSchema)],
+        false,
+      )
+      expect(schema.closed).toBe(false)
+    })
+  })
+})

package/src/schema/typed-union.ts

@@ -1,9 +1,10 @@
 import { isPlainObject } from '@atproto/lex-data'
 import { Restricted, UnknownString } from '../core.js'
+import { lazyProperty } from '../util/lazy-property.js'
 import {
   Infer,
+  Schema,
   ValidationResult,
-  Validator,
   ValidatorContext,
 } from '../validation.js'
 import { TypedRefSchema, TypedRefSchemaOutput } from './typed-ref.js'
@@ -43,9 +44,7 @@ export type TypedUnionSchemaOutput<
 export class TypedUnionSchema<
   TypedRefs extends readonly TypedRefSchema[] = any,
   Closed extends boolean = any,
-> extends Validator<TypedUnionSchemaOutput<TypedRefs, Closed>> {
-  readonly lexiconType = 'union' as const
-
+> extends Schema<TypedUnionSchemaOutput<TypedRefs, Closed>> {
   constructor(
     protected readonly refs: TypedRefs,
     public readonly closed: Closed,
@@ -57,26 +56,18 @@ export class TypedUnionSchema<
     super()
   }
 
-  protected get refsMap() {
+  get refsMap(): Map<unknown, TypedRefs[number]> {
     const map = new Map<unknown, TypedRefs[number]>()
     for (const ref of this.refs) map.set(ref.$type, ref)
 
-    // Cache the map on the instance
-    Object.defineProperty(this, 'refsMap', {
-      value: map,
-      writable: false,
-      enumerable: false,
-      configurable: true,
-    })
-
-    return map
+    return lazyProperty(this, 'refsMap', map)
   }
 
   get $types() {
     return Array.from(this.refsMap.keys())
   }
 
-  override validateInContext(
+  validateInContext(
     input: unknown,
     ctx: ValidatorContext,
   ): ValidationResult<TypedUnionSchemaOutput<TypedRefs, Closed>> {

package/src/schema/union.test.ts

@@ -0,0 +1,200 @@
+import { BooleanSchema } from './boolean.js'
+import { IntegerSchema } from './integer.js'
+import { ObjectSchema } from './object.js'
+import { StringSchema } from './string.js'
+import { UnionSchema } from './union.js'
+
+describe('UnionSchema', () => {
+  const stringOrNumber = new UnionSchema([
+    new StringSchema({}),
+    new IntegerSchema({}),
+  ])
+
+  it('validates string input', () => {
+    const result = stringOrNumber.safeParse('hello')
+    expect(result.success).toBe(true)
+  })
+
+  it('validates number input', () => {
+    const result = stringOrNumber.safeParse(42)
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects boolean input', () => {
+    const result = stringOrNumber.safeParse(true)
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects null input', () => {
+    const result = stringOrNumber.safeParse(null)
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects undefined input', () => {
+    const result = stringOrNumber.safeParse(undefined)
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects object input when not in union', () => {
+    const result = stringOrNumber.safeParse({ key: 'value' })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects array input when not in union', () => {
+    const result = stringOrNumber.safeParse([1, 2, 3])
+    expect(result.success).toBe(false)
+  })
+
+  describe('with object types', () => {
+    const schema = new UnionSchema([
+      new ObjectSchema({
+        type: new StringSchema({}),
+        name: new StringSchema({}),
+      }),
+      new ObjectSchema({
+        type: new StringSchema({}),
+        age: new IntegerSchema({}),
+      }),
+    ])
+
+    it('validates first object variant', () => {
+      const result = schema.safeParse({
+        type: 'person',
+        name: 'Alice',
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('validates second object variant', () => {
+      const result = schema.safeParse({
+        type: 'record',
+        age: 30,
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects object missing required properties', () => {
+      const result = schema.safeParse({
+        type: 'person',
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects object with invalid property types', () => {
+      const result = schema.safeParse({
+        type: 'record',
+        age: 'thirty',
+      })
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('with three types', () => {
+    const schema = new UnionSchema([
+      new StringSchema({}),
+      new IntegerSchema({}),
+      new BooleanSchema({}),
+    ])
+
+    it('validates string input', () => {
+      const result = schema.safeParse('text')
+      expect(result.success).toBe(true)
+    })
+
+    it('validates number input', () => {
+      const result = schema.safeParse(123)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates boolean input', () => {
+      const result = schema.safeParse(false)
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects null input', () => {
+      const result = schema.safeParse(null)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects array input', () => {
+      const result = schema.safeParse([])
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('with constrained types', () => {
+    const schema = new UnionSchema([
+      new StringSchema({ minLength: 5 }),
+      new IntegerSchema({ minimum: 100 }),
+    ])
+
+    it('validates string meeting constraint', () => {
+      const result = schema.safeParse('hello')
+      expect(result.success).toBe(true)
+    })
+
+    it('validates number meeting constraint', () => {
+      const result = schema.safeParse(150)
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects string not meeting constraint', () => {
+      const result = schema.safeParse('hi')
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects number not meeting constraint', () => {
+      const result = schema.safeParse(50)
+      expect(result.success).toBe(false)
+    })
+
+    it('validates first matching type even if later types could match', () => {
+      const result = schema.safeParse('valid')
+      expect(result.success).toBe(true)
+    })
+  })
+
+  describe('edge cases', () => {
+    it('validates with single type in union', () => {
+      const schema = new UnionSchema([new StringSchema({})])
+      const result = schema.safeParse('test')
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects when single type in union does not match', () => {
+      const schema = new UnionSchema([new StringSchema({})])
+      const result = schema.safeParse(123)
+      expect(result.success).toBe(false)
+    })
+
+    it('validates empty string', () => {
+      const result = stringOrNumber.safeParse('')
+      expect(result.success).toBe(true)
+    })
+
+    it('validates zero', () => {
+      const result = stringOrNumber.safeParse(0)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates negative numbers', () => {
+      const result = stringOrNumber.safeParse(-42)
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects NaN', () => {
+      const result = stringOrNumber.safeParse(NaN)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects Infinity', () => {
+      const result = stringOrNumber.safeParse(Infinity)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects -Infinity', () => {
+      const result = stringOrNumber.safeParse(-Infinity)
+      expect(result.success).toBe(false)
+    })
+  })
+})

package/src/schema/union.ts

@@ -1,5 +1,6 @@
 import {
   Infer,
+  Schema,
   ValidationError,
   ValidationFailure,
   ValidationResult,
@@ -10,14 +11,14 @@ import {
 export type UnionSchemaValidators = readonly [Validator, ...Validator[]]
 export type UnionSchemaOutput<V extends readonly Validator[]> = Infer<V[number]>
 
-export class UnionSchema<
-  V extends UnionSchemaValidators = any,
-> extends Validator<UnionSchemaOutput<V>> {
+export class UnionSchema<V extends UnionSchemaValidators = any> extends Schema<
+  UnionSchemaOutput<V>
+> {
   constructor(protected readonly validators: V) {
     super()
   }
 
-  override validateInContext(
+  validateInContext(
     input: unknown,
     ctx: ValidatorContext,
   ): ValidationResult<UnionSchemaOutput<V>> {