@atproto/lex-schema 0.0.2 → 0.0.3

package/src/schema/object.ts

@@ -1,134 +1,51 @@
 import { isPlainObject } from '@atproto/lex-data'
-import { Simplify } from '../core.js'
+import { WithOptionalProperties } from '../core.js'
+import { lazyProperty } from '../util/lazy-property.js'
 import {
   Infer,
+  Schema,
   ValidationResult,
   Validator,
   ValidatorContext,
 } from '../validation.js'
-import { DictSchema } from './dict.js'
 
-export type ObjectSchemaProperties = { [_ in string]: Validator<any> }
-export type ObjectSchemaOptions = {
-  required?: readonly string[]
-  nullable?: readonly string[]
-  unknownProperties?: 'strict' | DictSchema
-}
-
-export type ObjectSchemaNullValue<
-  O extends ObjectSchemaOptions,
-  K extends string,
-> = O extends { nullable: readonly (infer N extends string)[] }
-  ? K extends N
-    ? null
-    : never
-  : never
-
-export type ObjectSchemaPropertiesOutput<
-  P extends ObjectSchemaProperties,
-  O extends ObjectSchemaOptions,
-> = O extends { required: readonly (infer R extends string)[] }
-  ? {
-      -readonly [K in string & keyof P & R]-?:
-        | Infer<P[K]>
-        | ObjectSchemaNullValue<O, K>
-    } & {
-      -readonly [K in Exclude<string & keyof P, R>]?:
-        | Infer<P[K]>
-        | ObjectSchemaNullValue<O, K>
-    }
-  : {
-      -readonly [K in string & keyof P]?:
-        | Infer<P[K]>
-        | ObjectSchemaNullValue<O, K>
-    }
+export type ObjectSchemaShape = Record<string, Validator>
 
-/**
- * Allows to more accurately represent the intersection of two object types
- * where both types may share some keys, and one of them uses an index
- * signature.
- *
- * @see {@link https://www.typescriptlang.org/play/?#code/C4TwDgpgBAglC8UDeUBmB7dAuKByARgIYBOuUAvlAGTJQDaA+lAJYB2UAzsMWwOYC6OVgFcAtvgjEKAKGkATCAGMANiWiL0rLlEI4YsjVuBQA1hBA4uPVrwRQARBnT2Dm7QDdCy4dESE6ZiD8UAD0IVAi4pJQABQcABbowspyUBIORMT2AJSyEAAeYOjExqCQUACSrMCSHErAzJoAPNJQsFAFNaxyHFAASkrFck1WfAA0UMKsJqzoAO6sAHxjrVAAQh35XT39g8TDozYTUzPzSyuLdqtwVKttMYHoqO00j88bnRDdvawQ7pJ3NpQAD860BbRwSHBQLadAA0ix2G91oJ1vDggAfWABcxPF5QOH8aFtci5aRlaAwVDMfIQVKIKo1Yh1RQNZq0Jw4AgkMjkCYoRiIzjcPioyISKTkRayBQqNRQQzaQgAMRpdL01NpclcRignm8EFVWrsKrVchxQVC4XF0SxmSAA Playground link}
- */
-type Intersect<
-  A extends Record<string, unknown>,
-  B extends Record<string, unknown>,
-> = B[keyof B] extends never
-  ? A
-  : keyof A & keyof B extends never
-    ? // If A and B don't overlap, just return A & B
-      A & B
-    : // Otherwise, properly represent the fact that accessing using an
-      // index signature could return a value from either A or B
-      A & { [K in keyof B]: B[K] | A[keyof A & K] }
-
-export type ObjectSchemaOutput<
-  P extends ObjectSchemaProperties,
-  O extends ObjectSchemaOptions,
-> = O extends {
-  unknownProperties: Validator<infer D extends Record<string, unknown>>
-}
-  ? Simplify<Intersect<ObjectSchemaPropertiesOutput<P, O>, D>>
-  : Simplify<ObjectSchemaPropertiesOutput<P, O>>
+export type ObjectSchemaOutput<Shape extends ObjectSchemaShape> =
+  WithOptionalProperties<{
+    [K in keyof Shape]: Infer<Shape[K]>
+  }>
 
 export class ObjectSchema<
-  const Validators extends ObjectSchemaProperties = any,
-  const Options extends ObjectSchemaOptions = any,
-  const Output extends ObjectSchemaOutput<
-    Validators,
-    Options
-  > = ObjectSchemaOutput<Validators, Options>,
-> extends Validator<Output> {
-  constructor(
-    readonly validators: Validators,
-    readonly options: Options,
-  ) {
+  const Shape extends ObjectSchemaShape = any,
+> extends Schema<ObjectSchemaOutput<Shape>> {
+  constructor(readonly shape: Shape) {
     super()
   }
 
   get validatorsMap(): Map<string, Validator> {
-    const map = new Map(Object.entries(this.validators))
-
-    // Cache the map on the instance (to avoid re-creating it)
-    Object.defineProperty(this, 'validatorsMap', {
-      value: map,
-      writable: false,
-      enumerable: false,
-      configurable: true,
-    })
+    const map = new Map(Object.entries(this.shape))
 
-    return map
+    return lazyProperty(this, 'validatorsMap', map)
   }
 
-  override validateInContext(
+  validateInContext(
     input: unknown,
     ctx: ValidatorContext,
-  ): ValidationResult<Output> {
+  ): ValidationResult<ObjectSchemaOutput<Shape>> {
     if (!isPlainObject(input)) {
-      return ctx.issueInvalidType(input, ['object'])
+      return ctx.issueInvalidType(input, 'object')
     }
 
     // Lazily copy value
     let copy: undefined | Record<string, unknown>
 
     for (const [key, propDef] of this.validatorsMap) {
-      if (input[key] === null && this.options.nullable?.includes(key)) {
-        continue
-      }
-
       const result = ctx.validateChild(input, key, propDef)
       if (!result.success) {
-        // Because default values are provided by child validators, we need to
-        // run the validator to get the default value and, in case of failure,
-        // ignore validation error that were caused by missing keys.
         if (!(key in input)) {
-          if (this.options.required?.includes(key)) {
-            // Transform into "required key" issue
-            return ctx.issueRequiredKey(input, key)
-          }
-
-          // Ignore missing non-required key
-          continue
+          // Transform into "required key" issue
+          return ctx.issueRequiredKey(input, key)
         }
 
         return result
@@ -136,11 +53,6 @@ export class ObjectSchema<
 
       // Skip copying if key is not present in input (and value is undefined)
       if (result.value === undefined && !(key in input)) {
-        // Except if the key is required
-        if (this.options.required?.includes(key)) {
-          return ctx.issueRequiredKey(input, key)
-        }
-
         continue
       }
 
@@ -150,23 +62,7 @@ export class ObjectSchema<
       }
     }
 
-    if (this.options.unknownProperties === 'strict') {
-      for (const key of Object.keys(input)) {
-        if (!this.validatorsMap.has(key)) {
-          return ctx.issueInvalidPropertyType(input, key, 'undefined')
-        }
-      }
-    } else if (this.options.unknownProperties) {
-      const result = this.options.unknownProperties.validateInContext(
-        copy ?? input,
-        ctx,
-        { ignoredKeys: this.validatorsMap },
-      )
-      if (!result.success) return result
-      if (result.value !== input) copy = result.value
-    }
-
-    const output = (copy ?? input) as Output
+    const output = (copy ?? input) as ObjectSchemaOutput<Shape>
 
     return ctx.success(output)
   }

package/src/schema/optional.test.ts

@@ -0,0 +1,485 @@
+import { BooleanSchema } from './boolean.js'
+import { IntegerSchema } from './integer.js'
+import { OptionalSchema } from './optional.js'
+import { StringSchema } from './string.js'
+
+describe('OptionalSchema', () => {
+  describe('basic validation with string schema', () => {
+    const schema = new OptionalSchema(new StringSchema({}))
+
+    it('validates defined 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)
+      if (result.success) {
+        expect(result.value).toBe('')
+      }
+    })
+
+    it('validates undefined', () => {
+      const result = schema.safeParse(undefined)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(undefined)
+      }
+    })
+
+    it('rejects invalid types for the inner schema', () => {
+      const result = schema.safeParse(123)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects null', () => {
+      const result = schema.safeParse(null)
+      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: 'hello' })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects arrays', () => {
+      const result = schema.safeParse(['hello'])
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('basic validation with integer schema', () => {
+    const schema = new OptionalSchema(new IntegerSchema({}))
+
+    it('validates defined 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)
+      if (result.success) {
+        expect(result.value).toBe(0)
+      }
+    })
+
+    it('validates negative integers', () => {
+      const result = schema.safeParse(-42)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(-42)
+      }
+    })
+
+    it('validates undefined', () => {
+      const result = schema.safeParse(undefined)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(undefined)
+      }
+    })
+
+    it('rejects invalid types for the inner schema', () => {
+      const result = schema.safeParse('not a number')
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects floats', () => {
+      const result = schema.safeParse(3.14)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects null', () => {
+      const result = schema.safeParse(null)
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('basic validation with boolean schema', () => {
+    const schema = new OptionalSchema(new BooleanSchema({}))
+
+    it('validates true', () => {
+      const result = schema.safeParse(true)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(true)
+      }
+    })
+
+    it('validates false', () => {
+      const result = schema.safeParse(false)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(false)
+      }
+    })
+
+    it('validates undefined', () => {
+      const result = schema.safeParse(undefined)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(undefined)
+      }
+    })
+
+    it('rejects strings', () => {
+      const result = schema.safeParse('true')
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects numbers', () => {
+      const result = schema.safeParse(1)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects null', () => {
+      const result = schema.safeParse(null)
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('inner schema with constraints', () => {
+    const schema = new OptionalSchema(
+      new StringSchema({ minLength: 5, maxLength: 10 }),
+    )
+
+    it('validates values meeting inner schema constraints', () => {
+      const result = schema.safeParse('hello')
+      expect(result.success).toBe(true)
+    })
+
+    it('validates values at minimum boundary', () => {
+      const result = schema.safeParse('abcde')
+      expect(result.success).toBe(true)
+    })
+
+    it('validates values at maximum boundary', () => {
+      const result = schema.safeParse('1234567890')
+      expect(result.success).toBe(true)
+    })
+
+    it('validates undefined', () => {
+      const result = schema.safeParse(undefined)
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects values violating inner schema minimum constraint', () => {
+      const result = schema.safeParse('hi')
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects values violating inner schema maximum constraint', () => {
+      const result = schema.safeParse('this is too long')
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects empty strings when inner schema has minLength', () => {
+      const result = schema.safeParse('')
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('inner schema with default value', () => {
+    const schema = new OptionalSchema(new StringSchema({ default: 'default' }))
+
+    it('applies 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('does not apply default when explicit value is provided', () => {
+      const result = schema.safeParse('explicit')
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe('explicit')
+      }
+    })
+
+    it('does not apply default when empty string is provided', () => {
+      const result = schema.safeParse('')
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe('')
+      }
+    })
+  })
+
+  describe('inner schema with default value and constraints', () => {
+    const schema = new OptionalSchema(
+      new StringSchema({ default: 'default', minLength: 5 }),
+    )
+
+    it('applies 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 values against constraints', () => {
+      const result = schema.safeParse('hello')
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects explicit values violating constraints', () => {
+      const result = schema.safeParse('hi')
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('inner schema with invalid default value', () => {
+    const schema = new OptionalSchema(
+      new StringSchema({ default: 'bad', minLength: 5 }),
+    )
+
+    it('returns undefined when default value violates constraints', () => {
+      const result = schema.safeParse(undefined)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(undefined)
+      }
+    })
+
+    it('still validates conforming explicit values', () => {
+      const result = schema.safeParse('valid')
+      expect(result.success).toBe(true)
+    })
+  })
+
+  describe('inner schema with integer default', () => {
+    const schema = new OptionalSchema(new IntegerSchema({ default: 42 }))
+
+    it('applies default value when undefined is provided', () => {
+      const result = schema.safeParse(undefined)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(42)
+      }
+    })
+
+    it('does not apply default when explicit value is provided', () => {
+      const result = schema.safeParse(100)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(100)
+      }
+    })
+
+    it('does not apply default when zero is provided', () => {
+      const result = schema.safeParse(0)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(0)
+      }
+    })
+  })
+
+  describe('inner schema with boolean default', () => {
+    const schema = new OptionalSchema(new BooleanSchema({ default: true }))
+
+    it('applies default value when undefined is provided', () => {
+      const result = schema.safeParse(undefined)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(true)
+      }
+    })
+
+    it('does not apply default when explicit true is provided', () => {
+      const result = schema.safeParse(true)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(true)
+      }
+    })
+
+    it('does not apply default when explicit false is provided', () => {
+      const result = schema.safeParse(false)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(false)
+      }
+    })
+  })
+
+  describe('edge cases', () => {
+    const schema = new OptionalSchema(new StringSchema({}))
+
+    it('handles very long strings', () => {
+      const longString = 'a'.repeat(10000)
+      const result = schema.safeParse(longString)
+      expect(result.success).toBe(true)
+    })
+
+    it('handles strings with special characters', () => {
+      const result = schema.safeParse('hello\nworld\ttab')
+      expect(result.success).toBe(true)
+    })
+
+    it('handles strings with unicode characters', () => {
+      const result = schema.safeParse('Hello 世界 🌍')
+      expect(result.success).toBe(true)
+    })
+
+    it('handles empty string distinctly from undefined', () => {
+      const emptyResult = schema.safeParse('')
+      expect(emptyResult.success).toBe(true)
+      if (emptyResult.success) {
+        expect(emptyResult.value).toBe('')
+      }
+
+      const undefinedResult = schema.safeParse(undefined)
+      expect(undefinedResult.success).toBe(true)
+      if (undefinedResult.success) {
+        expect(undefinedResult.value).toBe(undefined)
+      }
+    })
+  })
+
+  describe('type distinctions', () => {
+    it('distinguishes between zero and undefined for integers', () => {
+      const schema = new OptionalSchema(new IntegerSchema({}))
+
+      const zeroResult = schema.safeParse(0)
+      expect(zeroResult.success).toBe(true)
+      if (zeroResult.success) {
+        expect(zeroResult.value).toBe(0)
+      }
+
+      const undefinedResult = schema.safeParse(undefined)
+      expect(undefinedResult.success).toBe(true)
+      if (undefinedResult.success) {
+        expect(undefinedResult.value).toBe(undefined)
+      }
+    })
+
+    it('distinguishes between false and undefined for booleans', () => {
+      const schema = new OptionalSchema(new BooleanSchema({}))
+
+      const falseResult = schema.safeParse(false)
+      expect(falseResult.success).toBe(true)
+      if (falseResult.success) {
+        expect(falseResult.value).toBe(false)
+      }
+
+      const undefinedResult = schema.safeParse(undefined)
+      expect(undefinedResult.success).toBe(true)
+      if (undefinedResult.success) {
+        expect(undefinedResult.value).toBe(undefined)
+      }
+    })
+
+    it('distinguishes between empty string and undefined for strings', () => {
+      const schema = new OptionalSchema(new StringSchema({}))
+
+      const emptyResult = schema.safeParse('')
+      expect(emptyResult.success).toBe(true)
+      if (emptyResult.success) {
+        expect(emptyResult.value).toBe('')
+      }
+
+      const undefinedResult = schema.safeParse(undefined)
+      expect(undefinedResult.success).toBe(true)
+      if (undefinedResult.success) {
+        expect(undefinedResult.value).toBe(undefined)
+      }
+    })
+  })
+
+  describe('nested optional schemas', () => {
+    const schema = new OptionalSchema(new OptionalSchema(new StringSchema({})))
+
+    it('validates defined values through nested optionals', () => {
+      const result = schema.safeParse('hello')
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe('hello')
+      }
+    })
+
+    it('validates undefined through nested optionals', () => {
+      const result = schema.safeParse(undefined)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(undefined)
+      }
+    })
+
+    it('rejects invalid types through nested optionals', () => {
+      const result = schema.safeParse(123)
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('inner schema format constraints', () => {
+    const schema = new OptionalSchema(new StringSchema({ format: 'uri' }))
+
+    it('validates values meeting format constraint', () => {
+      const result = schema.safeParse('https://example.com')
+      expect(result.success).toBe(true)
+    })
+
+    it('validates undefined', () => {
+      const result = schema.safeParse(undefined)
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects values violating format constraint', () => {
+      const result = schema.safeParse('not a uri')
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('integer constraint validation', () => {
+    const schema = new OptionalSchema(
+      new IntegerSchema({ minimum: 0, maximum: 100 }),
+    )
+
+    it('validates values within range', () => {
+      const result = schema.safeParse(50)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates values at minimum boundary', () => {
+      const result = schema.safeParse(0)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates values at maximum boundary', () => {
+      const result = schema.safeParse(100)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates undefined', () => {
+      const result = schema.safeParse(undefined)
+      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)
+    })
+  })
+})

package/src/schema/optional.ts

@@ -0,0 +1,31 @@
+import {
+  Schema,
+  ValidationResult,
+  Validator,
+  ValidatorContext,
+} from '../validation.js'
+
+export class OptionalSchema<V> extends Schema<V | undefined> {
+  constructor(readonly schema: Validator<V>) {
+    super()
+  }
+
+  validateInContext(
+    input: unknown,
+    ctx: ValidatorContext,
+  ): ValidationResult<V | undefined> {
+    // @NOTE The inner schema might apply a default value so we need to run it
+    // first, even if input is undefined.
+    const result = ctx.validate(input, this.schema)
+
+    if (result.success) {
+      return result
+    }
+
+    if (input === undefined) {
+      return ctx.success(input)
+    }
+
+    return result
+  }
+}