@atproto/lex-schema 0.0.1 → 0.0.3

package/src/schema/nullable.test.ts

@@ -0,0 +1,480 @@
+import { EnumSchema } from './enum.js'
+import { IntegerSchema } from './integer.js'
+import { NullableSchema } from './nullable.js'
+import { ObjectSchema } from './object.js'
+import { StringSchema } from './string.js'
+
+describe('NullableSchema', () => {
+  describe('with StringSchema', () => {
+    const schema = new NullableSchema(new StringSchema({}))
+
+    it('validates null', () => {
+      const result = schema.safeParse(null)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(null)
+      }
+    })
+
+    it('validates valid string values', () => {
+      const result = schema.safeParse('hello')
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe('hello')
+      }
+    })
+
+    it('validates empty strings', () => {
+      const result = schema.safeParse('')
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects undefined', () => {
+      const result = schema.safeParse(undefined)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects numbers', () => {
+      const result = schema.safeParse(123)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects booleans', () => {
+      const result = schema.safeParse(true)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects objects', () => {
+      const result = schema.safeParse({ value: 'test' })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects arrays', () => {
+      const result = schema.safeParse(['hello'])
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('with IntegerSchema', () => {
+    const schema = new NullableSchema(new IntegerSchema({}))
+
+    it('validates null', () => {
+      const result = schema.safeParse(null)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(null)
+      }
+    })
+
+    it('validates valid integer values', () => {
+      const result = schema.safeParse(42)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(42)
+      }
+    })
+
+    it('validates zero', () => {
+      const result = schema.safeParse(0)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates negative integers', () => {
+      const result = schema.safeParse(-42)
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects floats', () => {
+      const result = schema.safeParse(3.14)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects strings', () => {
+      const result = schema.safeParse('42')
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects undefined', () => {
+      const result = schema.safeParse(undefined)
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('with EnumSchema', () => {
+    const schema = new NullableSchema(new EnumSchema(['red', 'green', 'blue']))
+
+    it('validates null', () => {
+      const result = schema.safeParse(null)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(null)
+      }
+    })
+
+    it('validates valid enum values', () => {
+      expect(schema.safeParse('red').success).toBe(true)
+      expect(schema.safeParse('green').success).toBe(true)
+      expect(schema.safeParse('blue').success).toBe(true)
+    })
+
+    it('rejects invalid enum values', () => {
+      const result = schema.safeParse('yellow')
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects undefined', () => {
+      const result = schema.safeParse(undefined)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects empty string when not in enum', () => {
+      const result = schema.safeParse('')
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('with constrained StringSchema', () => {
+    const schema = new NullableSchema(
+      new StringSchema({ minLength: 3, maxLength: 10 }),
+    )
+
+    it('validates null', () => {
+      const result = schema.safeParse(null)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates strings within constraints', () => {
+      const result = schema.safeParse('hello')
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects strings below minimum length', () => {
+      const result = schema.safeParse('hi')
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects strings above maximum length', () => {
+      const result = schema.safeParse('hello world!')
+      expect(result.success).toBe(false)
+    })
+
+    it('accepts strings at minimum boundary', () => {
+      const result = schema.safeParse('abc')
+      expect(result.success).toBe(true)
+    })
+
+    it('accepts strings at maximum boundary', () => {
+      const result = schema.safeParse('1234567890')
+      expect(result.success).toBe(true)
+    })
+  })
+
+  describe('with constrained IntegerSchema', () => {
+    const schema = new NullableSchema(
+      new IntegerSchema({ minimum: 0, maximum: 100 }),
+    )
+
+    it('validates null', () => {
+      const result = schema.safeParse(null)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates integers within constraints', () => {
+      const result = schema.safeParse(50)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates minimum value', () => {
+      const result = schema.safeParse(0)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates maximum value', () => {
+      const result = schema.safeParse(100)
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects values below minimum', () => {
+      const result = schema.safeParse(-1)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects values above maximum', () => {
+      const result = schema.safeParse(101)
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('with StringSchema having default value', () => {
+    const schema = new NullableSchema(new StringSchema({ default: 'default' }))
+
+    it('validates null explicitly', () => {
+      const result = schema.safeParse(null)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(null)
+      }
+    })
+
+    it('uses default value when undefined is provided', () => {
+      const result = schema.safeParse(undefined)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe('default')
+      }
+    })
+
+    it('validates explicit string values', () => {
+      const result = schema.safeParse('custom')
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe('custom')
+      }
+    })
+  })
+
+  describe('with ObjectSchema', () => {
+    const schema = new NullableSchema(
+      new ObjectSchema({
+        name: new StringSchema({}),
+        age: new IntegerSchema({}),
+      }),
+    )
+
+    it('validates null', () => {
+      const result = schema.safeParse(null)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(null)
+      }
+    })
+
+    it('validates valid objects', () => {
+      const result = schema.safeParse({ name: 'Alice', age: 30 })
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects invalid objects with missing properties', () => {
+      const result = schema.safeParse({ name: 'Alice' })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects invalid objects with wrong types', () => {
+      const result = schema.safeParse({ name: 'Alice', age: 'thirty' })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects empty objects', () => {
+      const result = schema.safeParse({})
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects primitive values', () => {
+      const result = schema.safeParse('not an object')
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('nested nullable schemas', () => {
+    const schema = new NullableSchema(new NullableSchema(new StringSchema({})))
+
+    it('validates null at outer level', () => {
+      const result = schema.safeParse(null)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(null)
+      }
+    })
+
+    it('validates valid string values', () => {
+      const result = schema.safeParse('hello')
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe('hello')
+      }
+    })
+
+    it('rejects undefined', () => {
+      const result = schema.safeParse(undefined)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects invalid types', () => {
+      const result = schema.safeParse(123)
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('with StringSchema format constraints', () => {
+    const schema = new NullableSchema(new StringSchema({ format: 'uri' }))
+
+    it('validates null', () => {
+      const result = schema.safeParse(null)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates valid URIs', () => {
+      const result = schema.safeParse('https://example.com')
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects invalid URIs', () => {
+      const result = schema.safeParse('not a uri')
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects invalid format even with valid string', () => {
+      const result = schema.safeParse('just a string')
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('edge cases', () => {
+    const stringSchema = new NullableSchema(new StringSchema({}))
+
+    it('handles null correctly without coercion', () => {
+      const result = stringSchema.safeParse(null)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(null)
+        expect(result.value).not.toBe(undefined)
+        expect(result.value).not.toBe('')
+        expect(result.value).not.toBe(0)
+        expect(result.value).not.toBe(false)
+      }
+    })
+
+    it('distinguishes null from falsy values', () => {
+      expect(stringSchema.safeParse(null).success).toBe(true)
+      expect(stringSchema.safeParse(undefined).success).toBe(false)
+      expect(stringSchema.safeParse('').success).toBe(true)
+      expect(stringSchema.safeParse(0).success).toBe(false)
+      expect(stringSchema.safeParse(false).success).toBe(false)
+    })
+
+    it('handles NaN correctly', () => {
+      const result = stringSchema.safeParse(NaN)
+      expect(result.success).toBe(false)
+    })
+
+    it('handles Symbol correctly', () => {
+      const result = stringSchema.safeParse(Symbol('test'))
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('type preservation', () => {
+    it('preserves string type for valid strings', () => {
+      const schema = new NullableSchema(new StringSchema({}))
+      const result = schema.safeParse('test')
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(typeof result.value).toBe('string')
+        expect(result.value).toBe('test')
+      }
+    })
+
+    it('preserves number type for valid integers', () => {
+      const schema = new NullableSchema(new IntegerSchema({}))
+      const result = schema.safeParse(42)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(typeof result.value).toBe('number')
+        expect(result.value).toBe(42)
+      }
+    })
+
+    it('preserves object type for valid objects', () => {
+      const schema = new NullableSchema(
+        new ObjectSchema({ key: new StringSchema({}) }),
+      )
+      const input = { key: 'value' }
+      const result = schema.safeParse(input)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(typeof result.value).toBe('object')
+        expect(result.value).toEqual({ key: 'value' })
+      }
+    })
+
+    it('preserves null type exactly', () => {
+      const schema = new NullableSchema(new StringSchema({}))
+      const result = schema.safeParse(null)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(null)
+        expect(result.value === null).toBe(true)
+        expect(typeof result.value).toBe('object')
+      }
+    })
+  })
+
+  describe('with complex wrapped schemas', () => {
+    it('validates nullable enum with default', () => {
+      const schema = new NullableSchema(
+        new EnumSchema(['option1', 'option2'], { default: 'option1' }),
+      )
+
+      expect(schema.safeParse(null).success).toBe(true)
+      expect(schema.safeParse('option1').success).toBe(true)
+      expect(schema.safeParse('option2').success).toBe(true)
+      expect(schema.safeParse(undefined).success).toBe(true)
+      expect(schema.safeParse('invalid').success).toBe(false)
+    })
+
+    it('handles nullable schema with grapheme constraints', () => {
+      const schema = new NullableSchema(
+        new StringSchema({ minGraphemes: 2, maxGraphemes: 5 }),
+      )
+
+      expect(schema.safeParse(null).success).toBe(true)
+      expect(schema.safeParse('ab').success).toBe(true)
+      expect(schema.safeParse('hello').success).toBe(true)
+      expect(schema.safeParse('a').success).toBe(false)
+      expect(schema.safeParse('hello!').success).toBe(false)
+    })
+
+    it('handles nullable integer with negative range', () => {
+      const schema = new NullableSchema(
+        new IntegerSchema({ minimum: -100, maximum: -10 }),
+      )
+
+      expect(schema.safeParse(null).success).toBe(true)
+      expect(schema.safeParse(-50).success).toBe(true)
+      expect(schema.safeParse(-100).success).toBe(true)
+      expect(schema.safeParse(-10).success).toBe(true)
+      expect(schema.safeParse(0).success).toBe(false)
+      expect(schema.safeParse(-5).success).toBe(false)
+      expect(schema.safeParse(-150).success).toBe(false)
+    })
+  })
+
+  describe('validation error behavior', () => {
+    it('returns failure for wrapped schema validation errors', () => {
+      const schema = new NullableSchema(new IntegerSchema({ minimum: 10 }))
+      const result = schema.safeParse(5)
+      expect(result.success).toBe(false)
+    })
+
+    it('returns failure for type mismatches', () => {
+      const schema = new NullableSchema(new StringSchema({}))
+      const result = schema.safeParse(123)
+      expect(result.success).toBe(false)
+    })
+
+    it('returns success for null regardless of wrapped constraints', () => {
+      const schema = new NullableSchema(
+        new StringSchema({ minLength: 100, format: 'uri' }),
+      )
+      const result = schema.safeParse(null)
+      expect(result.success).toBe(true)
+    })
+
+    it('wrapped schema validation applies when value is not null', () => {
+      const schema = new NullableSchema(new StringSchema({ minLength: 5 }))
+      expect(schema.safeParse(null).success).toBe(true)
+      expect(schema.safeParse('hello').success).toBe(true)
+      expect(schema.safeParse('hi').success).toBe(false)
+    })
+  })
+})

package/src/schema/nullable.ts

@@ -0,0 +1,23 @@
+import {
+  Schema,
+  ValidationResult,
+  Validator,
+  ValidatorContext,
+} from '../validation.js'
+
+export class NullableSchema<V> extends Schema<V | null> {
+  constructor(readonly schema: Validator<V>) {
+    super()
+  }
+
+  validateInContext(
+    input: unknown,
+    ctx: ValidatorContext,
+  ): ValidationResult<V | null> {
+    if (input === null) {
+      return ctx.success(null)
+    }
+
+    return ctx.validate(input, this.schema)
+  }
+}

package/src/schema/object.test.ts

@@ -1,138 +1,70 @@
-import { BooleanSchema } from './boolean.js'
-import { DictSchema } from './dict.js'
 import { EnumSchema } from './enum.js'
 import { IntegerSchema } from './integer.js'
+import { NullableSchema } from './nullable.js'
 import { ObjectSchema } from './object.js'
+import { OptionalSchema } from './optional.js'
 import { StringSchema } from './string.js'
 
 describe('ObjectSchema', () => {
-  describe('simple schema', () => {
-    const schema = new ObjectSchema(
-      {
-        name: new StringSchema({}),
-        age: new IntegerSchema({}),
-        gender: new EnumSchema(['male', 'female']),
-      },
-      {
-        required: ['name'],
-        nullable: ['gender'],
-      },
-    )
-
-    it('validates plain objects', () => {
-      const result = schema.validate({
-        name: 'Alice',
-        age: 30,
-        gender: 'female',
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('rejects non-objects', () => {
-      const result = schema.validate('not an object')
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects missing properties', () => {
-      const result = schema.validate({
-        age: 30,
-        gender: 'female',
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('validates optional properties', () => {
-      const result = schema.validate({
-        name: 'Alice',
-      })
-      expect(result.success).toBe(true)
-    })
+  const schema = new ObjectSchema({
+    name: new StringSchema({}),
+    age: new OptionalSchema(new IntegerSchema({})),
+    gender: new OptionalSchema(
+      new NullableSchema(new EnumSchema(['male', 'female'])),
+    ),
+  })
 
-    it('validates nullable properties', () => {
-      const result = schema.validate({
-        name: 'Alice',
-        gender: null,
-      })
-      expect(result.success).toBe(true)
+  it('validates plain objects', () => {
+    const result = schema.safeParse({
+      name: 'Alice',
+      age: 30,
+      gender: 'female',
     })
+    expect(result.success).toBe(true)
+  })
 
-    it('rejects invalid property types', () => {
-      const result = schema.validate({
-        name: 'Alice',
-        age: 'thirty',
-      })
-      expect(result.success).toBe(false)
-    })
+  it('rejects non-objects', () => {
+    const result = schema.safeParse('not an object')
+    expect(result.success).toBe(false)
+  })
 
-    it('ignores extra properties', () => {
-      const result = schema.validate({
-        name: 'Alice',
-        age: 30,
-        extra: 'value',
-      })
-      expect(result.success).toBe(true)
+  it('rejects missing properties', () => {
+    const result = schema.safeParse({
+      age: 30,
+      gender: 'female',
     })
+    expect(result.success).toBe(false)
   })
 
-  describe('strict schema', () => {
-    const schema = new ObjectSchema(
-      {
-        id: new StringSchema({}),
-        score: new IntegerSchema({}),
-      },
-      {
-        required: ['id', 'score'],
-        unknownProperties: 'strict',
-      },
-    )
-
-    it('rejects extra properties in strict mode', () => {
-      const result = schema.validate({
-        id: 'item1',
-        score: 100,
-        extra: 'not allowed',
-      })
-      expect(result.success).toBe(false)
+  it('validates optional properties', () => {
+    const result = schema.safeParse({
+      name: 'Alice',
     })
+    expect(result.success).toBe(true)
+  })
 
-    it('accepts only defined properties in strict mode', () => {
-      const result = schema.validate({
-        id: 'item1',
-        score: 100,
-      })
-      expect(result.success).toBe(true)
+  it('validates nullable properties', () => {
+    const result = schema.safeParse({
+      name: 'Alice',
+      gender: null,
     })
+    expect(result.success).toBe(true)
   })
 
-  describe('schema with unknownProperties validator', () => {
-    const schema = new ObjectSchema(
-      {
-        title: new StringSchema({}),
-      },
-      {
-        required: ['title'],
-        unknownProperties: new DictSchema(
-          new EnumSchema(['tag1', 'tag2']),
-          new BooleanSchema({}),
-        ),
-      },
-    )
-
-    it('validates extra properties with the provided validator', () => {
-      const result = schema.validate({
-        title: 'My Post',
-        tag1: true,
-        tag2: false,
-      })
-      expect(result.success).toBe(true)
+  it('rejects invalid property types', () => {
+    const result = schema.safeParse({
+      name: 'Alice',
+      age: 'thirty',
     })
+    expect(result.success).toBe(false)
+  })
 
-    it('rejects extra properties that fail the provided validator', () => {
-      const result = schema.validate({
-        title: 'My Post',
-        tag1: 'not a boolean',
-      })
-      expect(result.success).toBe(false)
+  it('ignores extra properties', () => {
+    const result = schema.safeParse({
+      name: 'Alice',
+      age: 30,
+      extra: 'value',
     })
+    expect(result.success).toBe(true)
   })
 })