@atproto/lex-schema 0.1.5 → 0.1.6

package/src/schema/union.test.ts

@@ -1,191 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { boolean } from './boolean.js'
-import { integer } from './integer.js'
-import { object } from './object.js'
-import { string } from './string.js'
-import { union } from './union.js'
-
-describe('UnionSchema', () => {
-  const stringOrNumber = union([string(), integer()])
-
-  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 = union([
-      object({
-        type: string(),
-        name: string(),
-      }),
-      object({
-        type: string(),
-        age: integer(),
-      }),
-    ])
-
-    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 = union([string(), integer(), boolean()])
-
-    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 = union([string({ minLength: 5 }), integer({ 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 = union([string()])
-      const result = schema.safeParse('test')
-      expect(result.success).toBe(true)
-    })
-
-    it('rejects when single type in union does not match', () => {
-      const schema = union([string()])
-      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,89 +0,0 @@
-import {
-  InferInput,
-  InferOutput,
-  Issue,
-  LexValidationError,
-  Schema,
-  ValidationContext,
-  Validator,
-} from '../core.js'
-
-/**
- * Type representing a non-empty tuple of validators for union schemas.
- *
- * Requires at least one validator in the tuple.
- */
-export type UnionSchemaValidators = readonly [Validator, ...Validator[]]
-
-/**
- * Schema for validating values that match one of several possible schemas.
- *
- * Tries each validator in order until one succeeds. If all validators fail,
- * returns a combined error from all attempts.
- *
- * @template TValidators - Tuple type of the validators in the union
- *
- * @example
- * ```ts
- * const schema = new UnionSchema([l.string(), l.integer()])
- * schema.validate('hello') // success
- * schema.validate(42)      // success
- * schema.validate(true)    // fails
- * ```
- */
-export class UnionSchema<
-  const TValidators extends UnionSchemaValidators = any,
-> extends Schema<
-  InferInput<TValidators[number]>,
-  InferOutput<TValidators[number]>
-> {
-  readonly type = 'union' as const
-
-  constructor(protected readonly validators: TValidators) {
-    super()
-  }
-
-  validateInContext(input: unknown, ctx: ValidationContext) {
-    const issues: Issue[] = []
-
-    for (const validator of this.validators) {
-      const result = ctx.validate(input, validator)
-      if (result.success) return result
-
-      issues.push(...result.issues)
-    }
-
-    return new LexValidationError(issues)
-  }
-}
-
-/**
- * Creates a union schema that accepts values matching any of the provided schemas.
- *
- * Validators are tried in order. Use `discriminatedUnion()` for better
- * performance when discriminating on a known property.
- *
- * @param validators - Non-empty array of validators to try
- * @returns A new {@link UnionSchema} instance
- *
- * @example
- * ```ts
- * // String or number
- * const stringOrNumber = l.union([l.string(), l.integer()])
- *
- * // Nullable value
- * const nullableString = l.union([l.string(), l.null()])
- *
- * // Multiple object types
- * const mediaSchema = l.union([
- *   l.object({ type: l.literal('image'), url: l.string() }),
- *   l.object({ type: l.literal('video'), url: l.string(), duration: l.integer() }),
- * ])
- * ```
- */
-/*@__NO_SIDE_EFFECTS__*/
-export function union<const TValidators extends UnionSchemaValidators>(
-  validators: TValidators,
-) {
-  return new UnionSchema<TValidators>(validators)
-}

package/src/schema/unknown.test.ts

@@ -1,313 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { unknown } from './unknown.js'
-
-describe('UnknownSchema', () => {
-  describe('basic validation', () => {
-    const schema = unknown()
-
-    it('accepts strings', () => {
-      const result = schema.safeParse('hello')
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe('hello')
-      }
-    })
-
-    it('accepts numbers', () => {
-      const result = schema.safeParse(42)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(42)
-      }
-    })
-
-    it('accepts booleans', () => {
-      const result = schema.safeParse(true)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(true)
-      }
-    })
-
-    it('accepts null', () => {
-      const result = schema.safeParse(null)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(null)
-      }
-    })
-
-    it('accepts undefined', () => {
-      const result = schema.safeParse(undefined)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(undefined)
-      }
-    })
-
-    it('accepts plain objects', () => {
-      const obj = { key: 'value', nested: { prop: 123 } }
-      const result = schema.safeParse(obj)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toEqual(obj)
-      }
-    })
-
-    it('accepts arrays', () => {
-      const arr = [1, 2, 3, 'four', { five: 5 }]
-      const result = schema.safeParse(arr)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toEqual(arr)
-      }
-    })
-
-    it('accepts empty arrays', () => {
-      const result = schema.safeParse([])
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toEqual([])
-      }
-    })
-
-    it('accepts empty objects', () => {
-      const result = schema.safeParse({})
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toEqual({})
-      }
-    })
-  })
-
-  describe('edge cases', () => {
-    const schema = unknown()
-
-    it('accepts zero', () => {
-      const result = schema.safeParse(0)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(0)
-      }
-    })
-
-    it('accepts empty string', () => {
-      const result = schema.safeParse('')
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe('')
-      }
-    })
-
-    it('accepts negative numbers', () => {
-      const result = schema.safeParse(-123)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(-123)
-      }
-    })
-
-    it('accepts floating point numbers', () => {
-      const result = schema.safeParse(3.14159)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(3.14159)
-      }
-    })
-
-    it('accepts NaN', () => {
-      const result = schema.safeParse(NaN)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBeNaN()
-      }
-    })
-
-    it('accepts Infinity', () => {
-      const result = schema.safeParse(Infinity)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(Infinity)
-      }
-    })
-
-    it('accepts -Infinity', () => {
-      const result = schema.safeParse(-Infinity)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(-Infinity)
-      }
-    })
-
-    it('accepts BigInt', () => {
-      const bigIntValue = BigInt(9007199254740991)
-      const result = schema.safeParse(bigIntValue)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(bigIntValue)
-      }
-    })
-
-    it('accepts functions', () => {
-      const fn = () => 'test'
-      const result = schema.safeParse(fn)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(fn)
-      }
-    })
-
-    it('accepts Date objects', () => {
-      const date = new Date('2023-01-01')
-      const result = schema.safeParse(date)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(date)
-      }
-    })
-
-    it('accepts RegExp objects', () => {
-      const regex = /test/gi
-      const result = schema.safeParse(regex)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(regex)
-      }
-    })
-
-    it('accepts Symbol', () => {
-      const sym = Symbol('test')
-      const result = schema.safeParse(sym)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(sym)
-      }
-    })
-
-    it('accepts Map objects', () => {
-      const map = new Map([['key', 'value']])
-      const result = schema.safeParse(map)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(map)
-      }
-    })
-
-    it('accepts Set objects', () => {
-      const set = new Set([1, 2, 3])
-      const result = schema.safeParse(set)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(set)
-      }
-    })
-
-    it('accepts WeakMap objects', () => {
-      const weakMap = new WeakMap()
-      const result = schema.safeParse(weakMap)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(weakMap)
-      }
-    })
-
-    it('accepts WeakSet objects', () => {
-      const weakSet = new WeakSet()
-      const result = schema.safeParse(weakSet)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(weakSet)
-      }
-    })
-
-    it('accepts class instances', () => {
-      class TestClass {
-        constructor(public value: string) {}
-      }
-      const instance = new TestClass('test')
-      const result = schema.safeParse(instance)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(instance)
-      }
-    })
-
-    it('accepts nested complex structures', () => {
-      const complex = {
-        array: [1, 'two', { three: 3 }],
-        nested: {
-          deep: {
-            value: [null, undefined, true],
-          },
-        },
-        fn: () => 'test',
-        date: new Date(),
-      }
-      const result = schema.safeParse(complex)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toEqual(complex)
-      }
-    })
-  })
-
-  describe('special JavaScript values', () => {
-    const schema = unknown()
-
-    it('accepts objects with null prototype', () => {
-      const obj = Object.create(null)
-      obj.key = 'value'
-      const result = schema.safeParse(obj)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(obj)
-      }
-    })
-
-    it('accepts Proxy objects', () => {
-      const target = { value: 42 }
-      const proxy = new Proxy(target, {})
-      const result = schema.safeParse(proxy)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(proxy)
-      }
-    })
-
-    it('accepts typed arrays', () => {
-      const uint8Array = new Uint8Array([1, 2, 3])
-      const result = schema.safeParse(uint8Array)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(uint8Array)
-      }
-    })
-
-    it('accepts ArrayBuffer', () => {
-      const buffer = new ArrayBuffer(8)
-      const result = schema.safeParse(buffer)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(buffer)
-      }
-    })
-
-    it('accepts Promise objects', () => {
-      const promise = Promise.resolve(42)
-      const result = schema.safeParse(promise)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(promise)
-      }
-    })
-
-    it('accepts Error objects', () => {
-      const error = new Error('test error')
-      const result = schema.safeParse(error)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(error)
-      }
-    })
-  })
-})

package/src/schema/unknown.ts

@@ -1,47 +0,0 @@
-import { Schema, ValidationContext } from '../core.js'
-import { memoizedOptions } from '../util/memoize.js'
-
-/**
- * Schema that accepts any value without validation.
- *
- * Passes through any input unchanged. Use sparingly as it bypasses
- * type safety. Useful for dynamic data or when the schema is not
- * known at compile time.
- *
- * @example
- * ```ts
- * const schema = new UnknownSchema()
- * schema.validate(anything) // always succeeds
- * ```
- */
-export class UnknownSchema extends Schema<unknown> {
-  readonly type = 'unknown' as const
-
-  validateInContext(input: unknown, ctx: ValidationContext) {
-    return ctx.success(input)
-  }
-}
-
-/**
- * Creates an unknown schema that accepts any value.
- *
- * The value passes through without any validation or transformation.
- * Use this when you need to accept arbitrary data.
- *
- * @returns A new {@link UnknownSchema} instance
- *
- * @example
- * ```ts
- * // Accept any value
- * const anyDataSchema = l.unknown()
- *
- * // In an object with a dynamic field
- * const flexibleSchema = l.object({
- *   type: l.string(),
- *   data: l.unknown(),
- * })
- * ```
- */
-export const unknown = /*#__PURE__*/ memoizedOptions(function () {
-  return new UnknownSchema()
-})