@atproto/lex-schema 0.0.1 → 0.0.3

package/src/schema/discriminated-union.ts

@@ -1,8 +1,7 @@
 import { isPlainObject } from '@atproto/lex-data'
-import { ArrayContaining } from '../core.js'
 import {
-  ValidationError,
-  ValidationFailure,
+  Infer,
+  Schema,
   ValidationResult,
   Validator,
   ValidatorContext,
@@ -11,28 +10,23 @@ import { EnumSchema } from './enum.js'
 import { LiteralSchema } from './literal.js'
 import { ObjectSchema } from './object.js'
 
-export type DiscriminatedUnionSchemaVariant<Discriminator extends string> =
-  ObjectSchema<
-    { [_ in Discriminator]: Validator },
-    { required: ArrayContaining<Discriminator, string> }
-  >
+export type DiscriminatedUnionVariant<Discriminator extends string> =
+  ObjectSchema<Record<Discriminator, EnumSchema | LiteralSchema>>
 
-export type DiscriminatedUnionSchemaVariants<Discriminator extends string> =
+export type DiscriminatedUnionVariants<Discriminator extends string> =
   readonly [
-    DiscriminatedUnionSchemaVariant<Discriminator>,
-    ...DiscriminatedUnionSchemaVariant<Discriminator>[],
+    DiscriminatedUnionVariant<Discriminator>,
+    ...DiscriminatedUnionVariant<Discriminator>[],
   ]
 
 export type DiscriminatedUnionSchemaOutput<
-  Options extends readonly Validator[],
-> = Options extends readonly [Validator<infer V>]
-  ? V
-  : Options extends readonly [
-        Validator<infer V>,
-        ...infer Rest extends Validator[],
-      ]
-    ? V | DiscriminatedUnionSchemaOutput<Rest>
-    : never
+  Variants extends readonly Validator[],
+> = Variants extends readonly [
+  infer V extends Validator,
+  ...infer Rest extends readonly Validator[],
+]
+  ? Infer<V> | DiscriminatedUnionSchemaOutput<Rest>
+  : never
 
 /**
  * @note There is no discriminated union in Lexicon schemas. This is a custom
@@ -41,104 +35,83 @@ export type DiscriminatedUnionSchemaOutput<
  */
 export class DiscriminatedUnionSchema<
   const Discriminator extends string = any,
-  const Options extends DiscriminatedUnionSchemaVariants<Discriminator> = any,
-> extends Validator<DiscriminatedUnionSchemaOutput<Options>> {
+  const Variants extends DiscriminatedUnionVariants<Discriminator> = any,
+> extends Schema<DiscriminatedUnionSchemaOutput<Variants>> {
+  readonly variantsMap: Map<unknown, DiscriminatedUnionVariant<Discriminator>>
+
   constructor(
     readonly discriminator: Discriminator,
-    readonly variants: Options,
+    variants: Variants,
   ) {
     super()
-  }
-
-  /**
-   * If all variants have a literal or enum for the discriminator property,
-   * and there are no overlapping values, returns a map of discriminator values
-   * to variants. Otherwise, returns null.
-   */
-  protected get variantsMap() {
-    const map = new Map<
-      unknown,
-      DiscriminatedUnionSchemaVariant<Discriminator>
-    >()
-    for (const variant of this.variants) {
-      const schema = variant.validators[this.discriminator]
-      if (schema instanceof LiteralSchema) {
-        if (map.has(schema.value)) return null // overlapping value
-        map.set(schema.value, variant)
-      } else if (schema instanceof EnumSchema) {
-        for (const val of schema.values) {
-          if (map.has(val)) return null // overlapping value
-          map.set(val, variant)
-        }
-      } else {
-        return null // not a literal or enum
-      }
-    }
 
-    // Cache the map on the instance (to avoid re-computing)
-    Object.defineProperty(this, 'variantsMap', {
-      value: map,
-      writable: false,
-      enumerable: false,
-      configurable: true,
-    })
-
-    return map
+    // Although we usually try to avoid initialization work in constructors,
+    // here it is necessary to ensure that invalid discriminated throw from the
+    // place of construction, rather than later during validation.
+    this.variantsMap = buildVariantsMap(discriminator, variants)
   }
 
-  override validateInContext(
+  validateInContext(
     input: unknown,
     ctx: ValidatorContext,
-  ): ValidationResult<DiscriminatedUnionSchemaOutput<Options>> {
+  ): ValidationResult<DiscriminatedUnionSchemaOutput<Variants>> {
     if (!isPlainObject(input)) {
       return ctx.issueInvalidType(input, 'object')
     }
 
-    if (!Object.hasOwn(input, this.discriminator)) {
-      return ctx.issueRequiredKey(input, this.discriminator)
+    const { discriminator } = this
+
+    if (!Object.hasOwn(input, discriminator)) {
+      return ctx.issueRequiredKey(input, discriminator)
     }
 
-    // Fast path: if we have a mapping of discriminator values to variants,
-    // we can directly select the correct variant to validate against. This also
-    // outputs a better error (with a single failure issue) when the discriminator.
-    if (this.variantsMap) {
-      const variant = this.variantsMap.get(input[this.discriminator])
-      if (!variant) {
-        return ctx.issueInvalidPropertyValue(input, this.discriminator, [
-          ...this.variantsMap.keys(),
-        ])
-      }
+    const discriminatorValue = input[discriminator]
 
+    const variant = this.variantsMap.get(discriminatorValue)
+    if (variant) {
       return ctx.validate(input, variant) as ValidationResult<
-        DiscriminatedUnionSchemaOutput<Options>
+        DiscriminatedUnionSchemaOutput<Variants>
       >
     }
 
-    // Slow path: try validating against each variant and return the first
-    // successful one (or aggregate all failures if none match).
-    const failures: ValidationFailure[] = []
-
-    for (const variant of this.variants) {
-      const discSchema = variant.validators[this.discriminator]
-      const discResult = ctx.validateChild(
-        input,
-        this.discriminator,
-        discSchema,
-      )
+    return ctx.issueInvalidPropertyValue(input, discriminator, [
+      ...this.variantsMap.keys(),
+    ])
+  }
+}
 
-      if (!discResult.success) {
-        failures.push(discResult)
-        continue
+function buildVariantsMap<Discriminator extends string>(
+  discriminator: Discriminator,
+  variants: DiscriminatedUnionVariants<Discriminator>,
+) {
+  const variantsMap = new Map<
+    unknown,
+    DiscriminatedUnionVariant<Discriminator>
+  >()
+
+  for (const variant of variants) {
+    const schema = variant.shape[discriminator]
+    if (schema instanceof LiteralSchema) {
+      if (variantsMap.has(schema.value)) {
+        throw new TypeError(`Overlapping discriminator value: ${schema.value}`)
       }
+      variantsMap.set(schema.value, variant)
+    } else if (schema instanceof EnumSchema) {
+      for (const val of schema.values) {
+        if (variantsMap.has(val)) {
+          throw new TypeError(`Overlapping discriminator value: ${val}`)
+        }
+        variantsMap.set(val, variant)
+      }
+    } else {
+      // Only enumerable discriminator schemas are supported
 
-      return ctx.validate(input, variant) as ValidationResult<
-        DiscriminatedUnionSchemaOutput<Options>
-      >
-    }
-
-    return {
-      success: false,
-      error: ValidationError.fromFailures(failures),
+      // Should never happen if types are used correctly
+      throw new TypeError(
+        `Discriminator schema must be a LiteralSchema or EnumSchema`,
+      )
     }
   }
+
+  return variantsMap
 }

package/src/schema/enum.test.ts

@@ -0,0 +1,396 @@
+import { EnumSchema } from './enum.js'
+
+describe('EnumSchema', () => {
+  describe('with string values', () => {
+    const schema = new EnumSchema(['male', 'female', 'other'])
+
+    it('validates matching string values', () => {
+      const result = schema.safeParse('male')
+      expect(result.success).toBe(true)
+    })
+
+    it('validates all enum values', () => {
+      expect(schema.safeParse('male').success).toBe(true)
+      expect(schema.safeParse('female').success).toBe(true)
+      expect(schema.safeParse('other').success).toBe(true)
+    })
+
+    it('rejects non-matching string values', () => {
+      const result = schema.safeParse('unknown')
+      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 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: 'male' })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects arrays', () => {
+      const result = schema.safeParse(['male'])
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects empty string when not in enum', () => {
+      const result = schema.safeParse('')
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('with number values', () => {
+    const schema = new EnumSchema([1, 2, 3])
+
+    it('validates matching number values', () => {
+      const result = schema.safeParse(1)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates all enum values', () => {
+      expect(schema.safeParse(1).success).toBe(true)
+      expect(schema.safeParse(2).success).toBe(true)
+      expect(schema.safeParse(3).success).toBe(true)
+    })
+
+    it('rejects non-matching number values', () => {
+      const result = schema.safeParse(4)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects string numbers', () => {
+      const result = schema.safeParse('1')
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects zero when not in enum', () => {
+      const result = schema.safeParse(0)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects negative numbers when not in enum', () => {
+      const result = schema.safeParse(-1)
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('with boolean values', () => {
+    const schema = new EnumSchema([true, false])
+
+    it('validates true', () => {
+      const result = schema.safeParse(true)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates false', () => {
+      const result = schema.safeParse(false)
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects string booleans', () => {
+      expect(schema.safeParse('true').success).toBe(false)
+      expect(schema.safeParse('false').success).toBe(false)
+    })
+
+    it('rejects number booleans', () => {
+      expect(schema.safeParse(1).success).toBe(false)
+      expect(schema.safeParse(0).success).toBe(false)
+    })
+  })
+
+  describe('with single boolean value', () => {
+    const schema = new EnumSchema([true])
+
+    it('validates true', () => {
+      const result = schema.safeParse(true)
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects false when not in enum', () => {
+      const result = schema.safeParse(false)
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('with null value', () => {
+    const schema = new EnumSchema([null, 'value'])
+
+    it('validates null', () => {
+      const result = schema.safeParse(null)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates other enum values', () => {
+      const result = schema.safeParse('value')
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects undefined', () => {
+      const result = schema.safeParse(undefined)
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('with mixed type values', () => {
+    const schema = new EnumSchema(['string', 123, true, null])
+
+    it('validates string value', () => {
+      const result = schema.safeParse('string')
+      expect(result.success).toBe(true)
+    })
+
+    it('validates number value', () => {
+      const result = schema.safeParse(123)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates boolean value', () => {
+      const result = schema.safeParse(true)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates null value', () => {
+      const result = schema.safeParse(null)
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects non-matching values', () => {
+      expect(schema.safeParse('other').success).toBe(false)
+      expect(schema.safeParse(456).success).toBe(false)
+      expect(schema.safeParse(false).success).toBe(false)
+      expect(schema.safeParse(undefined).success).toBe(false)
+    })
+  })
+
+  describe('with default option', () => {
+    const schema = new EnumSchema(['red', 'green', 'blue'], { default: 'red' })
+
+    it('validates matching values', () => {
+      const result = schema.safeParse('green')
+      expect(result.success).toBe(true)
+    })
+
+    it('uses default when input is undefined', () => {
+      const result = schema.safeParse(undefined)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe('red')
+      }
+    })
+
+    it('uses default when no argument is passed', () => {
+      const result = schema.safeParse(undefined)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe('red')
+      }
+    })
+
+    it('does not use default for null', () => {
+      const result = schema.safeParse(null)
+      expect(result.success).toBe(false)
+    })
+
+    it('does not use default for invalid values', () => {
+      const result = schema.safeParse('yellow')
+      expect(result.success).toBe(false)
+    })
+
+    it('does not use default for empty string', () => {
+      const result = schema.safeParse('')
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('with default option as number', () => {
+    const schema = new EnumSchema([1, 2, 3], { default: 1 })
+
+    it('uses default when input is undefined', () => {
+      const result = schema.safeParse(undefined)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(1)
+      }
+    })
+
+    it('does not use default for zero', () => {
+      const result = schema.safeParse(0)
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('with default option as boolean', () => {
+    const schema = new EnumSchema([true, false], { default: false })
+
+    it('uses default when input is undefined', () => {
+      const result = schema.safeParse(undefined)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(false)
+      }
+    })
+
+    it('validates true even when default is false', () => {
+      const result = schema.safeParse(true)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(true)
+      }
+    })
+  })
+
+  describe('with default option as null', () => {
+    const schema = new EnumSchema([null, 'value'], { default: null })
+
+    it('uses default when input is undefined', () => {
+      const result = schema.safeParse(undefined)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(null)
+      }
+    })
+
+    it('validates explicit null', () => {
+      const result = schema.safeParse(null)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(null)
+      }
+    })
+  })
+
+  describe('with single value', () => {
+    const schema = new EnumSchema(['only'])
+
+    it('validates the single value', () => {
+      const result = schema.safeParse('only')
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects any other value', () => {
+      expect(schema.safeParse('other').success).toBe(false)
+      expect(schema.safeParse('').success).toBe(false)
+      expect(schema.safeParse(null).success).toBe(false)
+      expect(schema.safeParse(undefined).success).toBe(false)
+    })
+  })
+
+  describe('with empty string value', () => {
+    const schema = new EnumSchema(['', 'value'])
+
+    it('validates empty string', () => {
+      const result = schema.safeParse('')
+      expect(result.success).toBe(true)
+    })
+
+    it('validates other values', () => {
+      const result = schema.safeParse('value')
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects non-matching values', () => {
+      const result = schema.safeParse('other')
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('with zero value', () => {
+    const schema = new EnumSchema([0, 1, 2])
+
+    it('validates zero', () => {
+      const result = schema.safeParse(0)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates other values', () => {
+      expect(schema.safeParse(1).success).toBe(true)
+      expect(schema.safeParse(2).success).toBe(true)
+    })
+
+    it('rejects false even though zero is in enum', () => {
+      const result = schema.safeParse(false)
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('case sensitivity', () => {
+    const schema = new EnumSchema(['Value', 'VALUE', 'value'])
+
+    it('validates exact case matches', () => {
+      expect(schema.safeParse('Value').success).toBe(true)
+      expect(schema.safeParse('VALUE').success).toBe(true)
+      expect(schema.safeParse('value').success).toBe(true)
+    })
+
+    it('rejects case mismatches', () => {
+      expect(schema.safeParse('vaLue').success).toBe(false)
+      expect(schema.safeParse('VaLuE').success).toBe(false)
+    })
+  })
+
+  describe('with special string values', () => {
+    const schema = new EnumSchema([
+      'with space',
+      'with\ttab',
+      'with\nnewline',
+      '123',
+      'true',
+      'null',
+      'undefined',
+    ])
+
+    it('validates strings with spaces', () => {
+      const result = schema.safeParse('with space')
+      expect(result.success).toBe(true)
+    })
+
+    it('validates strings with tabs', () => {
+      const result = schema.safeParse('with\ttab')
+      expect(result.success).toBe(true)
+    })
+
+    it('validates strings with newlines', () => {
+      const result = schema.safeParse('with\nnewline')
+      expect(result.success).toBe(true)
+    })
+
+    it('validates number-like strings', () => {
+      const result = schema.safeParse('123')
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects actual numbers for number-like strings', () => {
+      const result = schema.safeParse(123)
+      expect(result.success).toBe(false)
+    })
+
+    it('validates keyword strings', () => {
+      expect(schema.safeParse('true').success).toBe(true)
+      expect(schema.safeParse('null').success).toBe(true)
+      expect(schema.safeParse('undefined').success).toBe(true)
+    })
+
+    it('rejects actual boolean/null/undefined for keyword strings', () => {
+      expect(schema.safeParse(true).success).toBe(false)
+      expect(schema.safeParse(null).success).toBe(false)
+      expect(schema.safeParse(undefined).success).toBe(false)
+    })
+  })
+})

package/src/schema/enum.ts

@@ -1,14 +1,21 @@
-import { ValidationResult, Validator, ValidatorContext } from '../validation.js'
+import { Schema, ValidationResult, ValidatorContext } from '../validation.js'
+
+export type EnumSchemaOptions<T extends null | string | number | boolean> = {
+  default?: T
+}
 
 export class EnumSchema<
   Output extends null | string | number | boolean = any,
-> extends Validator<Output> {
-  constructor(readonly values: readonly Output[]) {
+> extends Schema<Output> {
+  constructor(
+    readonly values: readonly Output[],
+    readonly options?: EnumSchemaOptions<Output>,
+  ) {
     super()
   }
 
-  override validateInContext(
-    input: unknown,
+  validateInContext(
+    input: unknown = this.options?.default,
     ctx: ValidatorContext,
   ): ValidationResult<Output> {
     if (!(this.values as readonly unknown[]).includes(input)) {