@atproto/lex-schema 0.0.2 → 0.0.3

package/src/schema/_parameters.test.ts

@@ -0,0 +1,416 @@
+import { paramSchema, paramsSchema } from './_parameters.js'
+
+describe('paramSchema', () => {
+  describe('scalar values', () => {
+    it('validates boolean values', () => {
+      const result = paramSchema.safeParse(true)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates integer values', () => {
+      const result = paramSchema.safeParse(42)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates string values', () => {
+      const result = paramSchema.safeParse('hello')
+      expect(result.success).toBe(true)
+    })
+
+    it('validates empty strings', () => {
+      const result = paramSchema.safeParse('')
+      expect(result.success).toBe(true)
+    })
+
+    it('validates zero', () => {
+      const result = paramSchema.safeParse(0)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates negative integers', () => {
+      const result = paramSchema.safeParse(-50)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates false boolean', () => {
+      const result = paramSchema.safeParse(false)
+      expect(result.success).toBe(true)
+    })
+  })
+
+  describe('array values', () => {
+    it('validates arrays of booleans', () => {
+      const result = paramSchema.safeParse([true, false, true])
+      expect(result.success).toBe(true)
+    })
+
+    it('validates arrays of integers', () => {
+      const result = paramSchema.safeParse([1, 2, 3, 4])
+      expect(result.success).toBe(true)
+    })
+
+    it('validates arrays of strings', () => {
+      const result = paramSchema.safeParse(['foo', 'bar', 'baz'])
+      expect(result.success).toBe(true)
+    })
+
+    it('validates empty arrays', () => {
+      const result = paramSchema.safeParse([])
+      expect(result.success).toBe(true)
+    })
+
+    it('validates arrays with single element', () => {
+      const result = paramSchema.safeParse(['single'])
+      expect(result.success).toBe(true)
+    })
+
+    it('validates arrays with mixed scalar types', () => {
+      const result = paramSchema.safeParse([true, 42, 'text'])
+      expect(result.success).toBe(true)
+    })
+
+    it('validates arrays with negative integers', () => {
+      const result = paramSchema.safeParse([-1, -2, -3])
+      expect(result.success).toBe(true)
+    })
+
+    it('validates arrays with empty strings', () => {
+      const result = paramSchema.safeParse(['', 'non-empty', ''])
+      expect(result.success).toBe(true)
+    })
+
+    it('validates arrays with zero', () => {
+      const result = paramSchema.safeParse([0, 1, 2])
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects nested arrays', () => {
+      const result = paramSchema.safeParse([
+        [1, 2],
+        [3, 4],
+      ])
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects arrays with null values', () => {
+      const result = paramSchema.safeParse([1, null, 3])
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects arrays with undefined values', () => {
+      const result = paramSchema.safeParse([1, undefined, 3])
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects arrays with object values', () => {
+      const result = paramSchema.safeParse([1, { key: 'value' }, 3])
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects arrays with floating point numbers', () => {
+      const result = paramSchema.safeParse([1, 2.5, 3])
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects arrays with NaN', () => {
+      const result = paramSchema.safeParse([1, NaN, 3])
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects arrays with Infinity', () => {
+      const result = paramSchema.safeParse([1, Infinity, 3])
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('invalid values', () => {
+    it('rejects null values', () => {
+      const result = paramSchema.safeParse(null)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects undefined values', () => {
+      const result = paramSchema.safeParse(undefined)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects object values', () => {
+      const result = paramSchema.safeParse({ key: 'value' })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects floating point numbers', () => {
+      const result = paramSchema.safeParse(3.14)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects NaN', () => {
+      const result = paramSchema.safeParse(NaN)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects Infinity', () => {
+      const result = paramSchema.safeParse(Infinity)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects -Infinity', () => {
+      const result = paramSchema.safeParse(-Infinity)
+      expect(result.success).toBe(false)
+    })
+  })
+})
+
+describe('paramsSchema', () => {
+  it('validates empty object', () => {
+    const result = paramsSchema.safeParse({})
+    expect(result.success).toBe(true)
+  })
+
+  it('validates object with boolean parameters', () => {
+    const result = paramsSchema.safeParse({
+      enabled: true,
+      disabled: false,
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('validates object with integer parameters', () => {
+    const result = paramsSchema.safeParse({
+      limit: 10,
+      offset: 0,
+      count: 100,
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('validates object with string parameters', () => {
+    const result = paramsSchema.safeParse({
+      name: 'Alice',
+      query: 'search term',
+      cursor: 'abc123',
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('validates object with array parameters', () => {
+    const result = paramsSchema.safeParse({
+      tags: ['tag1', 'tag2', 'tag3'],
+      ids: [1, 2, 3, 4],
+      flags: [true, false, true],
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('validates object with mixed parameter types', () => {
+    const result = paramsSchema.safeParse({
+      name: 'Alice',
+      age: 30,
+      active: true,
+      tags: ['user', 'admin'],
+      limit: 50,
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('validates object with empty string parameters', () => {
+    const result = paramsSchema.safeParse({
+      query: '',
+      cursor: '',
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('validates object with negative integer parameters', () => {
+    const result = paramsSchema.safeParse({
+      offset: -10,
+      delta: -5,
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('validates object with empty array parameters', () => {
+    const result = paramsSchema.safeParse({
+      tags: [],
+      ids: [],
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('validates object with arrays of mixed scalar types', () => {
+    const result = paramsSchema.safeParse({
+      values: [true, 42, 'text'],
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('validates object with numeric string keys', () => {
+    const result = paramsSchema.safeParse({
+      '0': 'value0',
+      '1': 'value1',
+      '2': 'value2',
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects non-object values', () => {
+    const result = paramsSchema.safeParse('not an object')
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects null values', () => {
+    const result = paramsSchema.safeParse(null)
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects undefined values', () => {
+    const result = paramsSchema.safeParse(undefined)
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects arrays', () => {
+    const result = paramsSchema.safeParse([1, 2, 3])
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects object with null parameter values', () => {
+    const result = paramsSchema.safeParse({
+      name: 'Alice',
+      invalid: null,
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects object with floating point parameter values', () => {
+    const result = paramsSchema.safeParse({
+      value: 3.14,
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects object with NaN parameter values', () => {
+    const result = paramsSchema.safeParse({
+      value: NaN,
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects object with Infinity parameter values', () => {
+    const result = paramsSchema.safeParse({
+      value: Infinity,
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects object with object parameter values', () => {
+    const result = paramsSchema.safeParse({
+      nested: { key: 'value' },
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects object with nested array parameter values', () => {
+    const result = paramsSchema.safeParse({
+      nested: [
+        [1, 2],
+        [3, 4],
+      ],
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects object with arrays containing invalid values', () => {
+    const result = paramsSchema.safeParse({
+      tags: ['valid', null, 'also valid'],
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects object with arrays containing objects', () => {
+    const result = paramsSchema.safeParse({
+      items: [1, { key: 'value' }, 3],
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects object with arrays containing floating point numbers', () => {
+    const result = paramsSchema.safeParse({
+      values: [1, 2.5, 3],
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects when one parameter is invalid', () => {
+    const result = paramsSchema.safeParse({
+      valid1: 'string',
+      valid2: 42,
+      invalid: null,
+      valid3: true,
+    })
+    expect(result.success).toBe(false)
+  })
+
+  describe('edge cases', () => {
+    it('validates single parameter', () => {
+      const result = paramsSchema.safeParse({
+        single: 'value',
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('validates many parameters', () => {
+      const manyParams: Record<string, string> = {}
+      for (let i = 0; i < 100; i++) {
+        manyParams[`param${i}`] = `value${i}`
+      }
+      const result = paramsSchema.safeParse(manyParams)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates parameters with long string values', () => {
+      const result = paramsSchema.safeParse({
+        longString: 'a'.repeat(1000),
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('validates parameters with large integer values', () => {
+      const result = paramsSchema.safeParse({
+        largeInt: 2147483647,
+        negativeInt: -2147483648,
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('validates parameters with long arrays', () => {
+      const result = paramsSchema.safeParse({
+        longArray: Array.from({ length: 100 }, (_, i) => i),
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('validates parameters with special characters in keys', () => {
+      const result = paramsSchema.safeParse({
+        'key-with-dashes': 'value',
+        key_with_underscores: 'value',
+        'key.with.dots': 'value',
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('preserves original object when no transformations occur', () => {
+      const input = {
+        name: 'Alice',
+        age: 30,
+        tags: ['user'],
+      }
+      const result = paramsSchema.safeParse(input)
+
+      if (result.success) {
+        expect(result.value).toBe(input)
+      } else {
+        throw new Error('Expected validation to succeed')
+      }
+    })
+  })
+})

package/src/schema/array.test.ts

@@ -0,0 +1,237 @@
+import { ArraySchema } from './array.js'
+import { IntegerSchema } from './integer.js'
+import { ObjectSchema } from './object.js'
+import { StringSchema } from './string.js'
+
+describe('ArraySchema', () => {
+  it('validates arrays with string items', () => {
+    const schema = new ArraySchema(new StringSchema({}))
+    const result = schema.safeParse(['hello', 'world'])
+    expect(result.success).toBe(true)
+  })
+
+  it('validates arrays with integer items', () => {
+    const schema = new ArraySchema(new IntegerSchema({}))
+    const result = schema.safeParse([1, 2, 3])
+    expect(result.success).toBe(true)
+  })
+
+  it('validates arrays with object items', () => {
+    const schema = new ArraySchema(
+      new ObjectSchema({
+        name: new StringSchema({}),
+        age: new IntegerSchema({}),
+      }),
+    )
+    const result = schema.safeParse([
+      { name: 'Alice', age: 30 },
+      { name: 'Bob', age: 25 },
+    ])
+    expect(result.success).toBe(true)
+  })
+
+  it('validates empty arrays', () => {
+    const schema = new ArraySchema(new StringSchema({}))
+    const result = schema.safeParse([])
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects non-array values', () => {
+    const schema = new ArraySchema(new StringSchema({}))
+    const result = schema.safeParse('not an array')
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects null values', () => {
+    const schema = new ArraySchema(new StringSchema({}))
+    const result = schema.safeParse(null)
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects undefined values', () => {
+    const schema = new ArraySchema(new StringSchema({}))
+    const result = schema.safeParse(undefined)
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects objects that look like arrays', () => {
+    const schema = new ArraySchema(new StringSchema({}))
+    const result = schema.safeParse({ 0: 'a', 1: 'b', length: 2 })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects arrays with invalid items', () => {
+    const schema = new ArraySchema(new IntegerSchema({}))
+    const result = schema.safeParse([1, 2, 'three'])
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects arrays with some invalid items', () => {
+    const schema = new ArraySchema(new StringSchema({}))
+    const result = schema.safeParse(['valid', null, 'also valid'])
+    expect(result.success).toBe(false)
+  })
+
+  describe('minLength constraint', () => {
+    it('validates arrays meeting minLength', () => {
+      const schema = new ArraySchema(new StringSchema({}), { minLength: 2 })
+      const result = schema.safeParse(['a', 'b'])
+      expect(result.success).toBe(true)
+    })
+
+    it('validates arrays exceeding minLength', () => {
+      const schema = new ArraySchema(new StringSchema({}), { minLength: 2 })
+      const result = schema.safeParse(['a', 'b', 'c'])
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects arrays below minLength', () => {
+      const schema = new ArraySchema(new StringSchema({}), { minLength: 3 })
+      const result = schema.safeParse(['a', 'b'])
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects empty arrays when minLength is set', () => {
+      const schema = new ArraySchema(new StringSchema({}), { minLength: 1 })
+      const result = schema.safeParse([])
+      expect(result.success).toBe(false)
+    })
+
+    it('validates empty arrays when minLength is 0', () => {
+      const schema = new ArraySchema(new StringSchema({}), { minLength: 0 })
+      const result = schema.safeParse([])
+      expect(result.success).toBe(true)
+    })
+  })
+
+  describe('maxLength constraint', () => {
+    it('validates arrays meeting maxLength', () => {
+      const schema = new ArraySchema(new StringSchema({}), { maxLength: 3 })
+      const result = schema.safeParse(['a', 'b', 'c'])
+      expect(result.success).toBe(true)
+    })
+
+    it('validates arrays below maxLength', () => {
+      const schema = new ArraySchema(new StringSchema({}), { maxLength: 3 })
+      const result = schema.safeParse(['a', 'b'])
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects arrays exceeding maxLength', () => {
+      const schema = new ArraySchema(new StringSchema({}), { maxLength: 2 })
+      const result = schema.safeParse(['a', 'b', 'c'])
+      expect(result.success).toBe(false)
+    })
+
+    it('validates empty arrays with maxLength', () => {
+      const schema = new ArraySchema(new StringSchema({}), { maxLength: 5 })
+      const result = schema.safeParse([])
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects empty arrays when maxLength is 0', () => {
+      const schema = new ArraySchema(new StringSchema({}), { maxLength: 0 })
+      const result = schema.safeParse(['a'])
+      expect(result.success).toBe(false)
+    })
+
+    it('validates empty arrays when maxLength is 0', () => {
+      const schema = new ArraySchema(new StringSchema({}), { maxLength: 0 })
+      const result = schema.safeParse([])
+      expect(result.success).toBe(true)
+    })
+  })
+
+  describe('minLength and maxLength together', () => {
+    it('validates arrays within range', () => {
+      const schema = new ArraySchema(new StringSchema({}), {
+        minLength: 2,
+        maxLength: 4,
+      })
+      const result = schema.safeParse(['a', 'b', 'c'])
+      expect(result.success).toBe(true)
+    })
+
+    it('validates arrays at min boundary', () => {
+      const schema = new ArraySchema(new StringSchema({}), {
+        minLength: 2,
+        maxLength: 4,
+      })
+      const result = schema.safeParse(['a', 'b'])
+      expect(result.success).toBe(true)
+    })
+
+    it('validates arrays at max boundary', () => {
+      const schema = new ArraySchema(new StringSchema({}), {
+        minLength: 2,
+        maxLength: 4,
+      })
+      const result = schema.safeParse(['a', 'b', 'c', 'd'])
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects arrays below minLength', () => {
+      const schema = new ArraySchema(new StringSchema({}), {
+        minLength: 2,
+        maxLength: 4,
+      })
+      const result = schema.safeParse(['a'])
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects arrays above maxLength', () => {
+      const schema = new ArraySchema(new StringSchema({}), {
+        minLength: 2,
+        maxLength: 4,
+      })
+      const result = schema.safeParse(['a', 'b', 'c', 'd', 'e'])
+      expect(result.success).toBe(false)
+    })
+
+    it('validates single-length range', () => {
+      const schema = new ArraySchema(new StringSchema({}), {
+        minLength: 3,
+        maxLength: 3,
+      })
+      const result = schema.safeParse(['a', 'b', 'c'])
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects arrays not matching exact length', () => {
+      const schema = new ArraySchema(new StringSchema({}), {
+        minLength: 3,
+        maxLength: 3,
+      })
+      const result = schema.safeParse(['a', 'b'])
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('nested arrays', () => {
+    it('validates arrays of arrays', () => {
+      const schema = new ArraySchema(new ArraySchema(new StringSchema({})))
+      const result = schema.safeParse([
+        ['a', 'b'],
+        ['c', 'd'],
+      ])
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects invalid nested arrays', () => {
+      const schema = new ArraySchema(new ArraySchema(new IntegerSchema({})))
+      const result = schema.safeParse([
+        [1, 2],
+        [3, 'four'],
+      ])
+      expect(result.success).toBe(false)
+    })
+
+    it('validates deeply nested arrays', () => {
+      const schema = new ArraySchema(
+        new ArraySchema(new ArraySchema(new IntegerSchema({}))),
+      )
+      const result = schema.safeParse([[[1, 2], [3]], [[4, 5, 6]]])
+      expect(result.success).toBe(true)
+    })
+  })
+})

package/src/schema/array.ts

@@ -1,24 +1,30 @@
-import { ValidationResult, Validator, ValidatorContext } from '../validation.js'
+import {
+  Infer,
+  Schema,
+  ValidationResult,
+  Validator,
+  ValidatorContext,
+} from '../validation.js'
 
 export type ArraySchemaOptions = {
   minLength?: number
   maxLength?: number
 }
 
-export class ArraySchema<Item = any> extends Validator<Array<Item>> {
-  readonly lexiconType = 'array' as const
-
+export class ArraySchema<const T extends Validator> extends Schema<
+  Array<Infer<T>>
+> {
   constructor(
-    readonly items: Validator<Item>,
-    readonly options: ArraySchemaOptions,
+    readonly itemsSchema: T,
+    readonly options: ArraySchemaOptions = {},
   ) {
     super()
   }
 
-  override validateInContext(
+  validateInContext(
     input: unknown,
     ctx: ValidatorContext,
-  ): ValidationResult<Array<Item>> {
+  ): ValidationResult<Array<Infer<T>>> {
     if (!Array.isArray(input)) {
       return ctx.issueInvalidType(input, 'array')
     }
@@ -33,10 +39,10 @@ export class ArraySchema<Item = any> extends Validator<Array<Item>> {
       return ctx.issueTooBig(input, 'array', maxLength, input.length)
     }
 
-    let copy: undefined | Array<Item>
+    let copy: undefined | Array<Infer<T>>
 
     for (let i = 0; i < input.length; i++) {
-      const result = ctx.validateChild(input, i, this.items)
+      const result = ctx.validateChild(input, i, this.itemsSchema)
       if (!result.success) return result
 
       if (result.value !== input[i]) {
@@ -46,6 +52,6 @@ export class ArraySchema<Item = any> extends Validator<Array<Item>> {
       }
     }
 
-    return ctx.success(copy ?? input) as ValidationResult<Array<Item>>
+    return ctx.success(copy ?? input) as ValidationResult<Array<Infer<T>>>
   }
 }