@atproto/lex-schema 0.0.8 → 0.0.10

package/src/schema/null.test.ts

@@ -1,9 +1,9 @@
 import { describe, expect, it } from 'vitest'
-import { NullSchema } from './null.js'
+import { nullSchema } from './null.js'
 
 describe('NullSchema', () => {
   describe('basic validation', () => {
-    const schema = new NullSchema()
+    const schema = nullSchema()
 
     it('validates null', () => {
       const result = schema.safeParse(null)
@@ -50,7 +50,7 @@ describe('NullSchema', () => {
   })
 
   describe('edge cases', () => {
-    const schema = new NullSchema()
+    const schema = nullSchema()
 
     it('rejects falsy values', () => {
       const result = schema.safeParse(0)

package/src/schema/null.ts

@@ -1,14 +1,8 @@
-import { Schema, ValidationResult, ValidatorContext } from '../core.js'
+import { Schema, ValidationContext } from '../core.js'
+import { memoizedOptions } from '../util/memoize.js'
 
 export class NullSchema extends Schema<null> {
-  constructor() {
-    super()
-  }
-
-  validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<null> {
+  validateInContext(input: unknown, ctx: ValidationContext) {
     if (input !== null) {
       return ctx.issueInvalidType(input, 'null')
     }
@@ -16,3 +10,9 @@ export class NullSchema extends Schema<null> {
     return ctx.success(null)
   }
 }
+
+export const nullSchema = /*#__PURE__*/ memoizedOptions(function () {
+  return new NullSchema()
+})
+
+export { nullSchema as null }

package/src/schema/nullable.test.ts

@@ -1,13 +1,14 @@
 import { describe, expect, it } from 'vitest'
-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'
+import { enumSchema } from './enum.js'
+import { integer } from './integer.js'
+import { nullable } from './nullable.js'
+import { object } from './object.js'
+import { string } from './string.js'
+import { withDefault } from './with-default.js'
 
 describe('NullableSchema', () => {
   describe('with StringSchema', () => {
-    const schema = new NullableSchema(new StringSchema({}))
+    const schema = nullable(string())
 
     it('validates null', () => {
       const result = schema.safeParse(null)
@@ -57,7 +58,7 @@ describe('NullableSchema', () => {
   })
 
   describe('with IntegerSchema', () => {
-    const schema = new NullableSchema(new IntegerSchema({}))
+    const schema = nullable(integer())
 
     it('validates null', () => {
       const result = schema.safeParse(null)
@@ -102,7 +103,7 @@ describe('NullableSchema', () => {
   })
 
   describe('with EnumSchema', () => {
-    const schema = new NullableSchema(new EnumSchema(['red', 'green', 'blue']))
+    const schema = nullable(enumSchema(['red', 'green', 'blue']))
 
     it('validates null', () => {
       const result = schema.safeParse(null)
@@ -135,9 +136,7 @@ describe('NullableSchema', () => {
   })
 
   describe('with constrained StringSchema', () => {
-    const schema = new NullableSchema(
-      new StringSchema({ minLength: 3, maxLength: 10 }),
-    )
+    const schema = nullable(string({ minLength: 3, maxLength: 10 }))
 
     it('validates null', () => {
       const result = schema.safeParse(null)
@@ -171,9 +170,7 @@ describe('NullableSchema', () => {
   })
 
   describe('with constrained IntegerSchema', () => {
-    const schema = new NullableSchema(
-      new IntegerSchema({ minimum: 0, maximum: 100 }),
-    )
+    const schema = nullable(integer({ minimum: 0, maximum: 100 }))
 
     it('validates null', () => {
       const result = schema.safeParse(null)
@@ -207,7 +204,7 @@ describe('NullableSchema', () => {
   })
 
   describe('with StringSchema having default value', () => {
-    const schema = new NullableSchema(new StringSchema({ default: 'default' }))
+    const schema = nullable(withDefault(string(), 'default'))
 
     it('validates null explicitly', () => {
       const result = schema.safeParse(null)
@@ -235,10 +232,10 @@ describe('NullableSchema', () => {
   })
 
   describe('with ObjectSchema', () => {
-    const schema = new NullableSchema(
-      new ObjectSchema({
-        name: new StringSchema({}),
-        age: new IntegerSchema({}),
+    const schema = nullable(
+      object({
+        name: string(),
+        age: integer(),
       }),
     )
 
@@ -277,7 +274,7 @@ describe('NullableSchema', () => {
   })
 
   describe('nested nullable schemas', () => {
-    const schema = new NullableSchema(new NullableSchema(new StringSchema({})))
+    const schema = nullable(nullable(string()))
 
     it('validates null at outer level', () => {
       const result = schema.safeParse(null)
@@ -307,7 +304,7 @@ describe('NullableSchema', () => {
   })
 
   describe('with StringSchema format constraints', () => {
-    const schema = new NullableSchema(new StringSchema({ format: 'uri' }))
+    const schema = nullable(string({ format: 'uri' }))
 
     it('validates null', () => {
       const result = schema.safeParse(null)
@@ -331,7 +328,7 @@ describe('NullableSchema', () => {
   })
 
   describe('edge cases', () => {
-    const stringSchema = new NullableSchema(new StringSchema({}))
+    const stringSchema = nullable(string())
 
     it('handles null correctly without coercion', () => {
       const result = stringSchema.safeParse(null)
@@ -366,7 +363,7 @@ describe('NullableSchema', () => {
 
   describe('type preservation', () => {
     it('preserves string type for valid strings', () => {
-      const schema = new NullableSchema(new StringSchema({}))
+      const schema = nullable(string())
       const result = schema.safeParse('test')
       expect(result.success).toBe(true)
       if (result.success) {
@@ -376,7 +373,7 @@ describe('NullableSchema', () => {
     })
 
     it('preserves number type for valid integers', () => {
-      const schema = new NullableSchema(new IntegerSchema({}))
+      const schema = nullable(integer())
       const result = schema.safeParse(42)
       expect(result.success).toBe(true)
       if (result.success) {
@@ -386,9 +383,7 @@ describe('NullableSchema', () => {
     })
 
     it('preserves object type for valid objects', () => {
-      const schema = new NullableSchema(
-        new ObjectSchema({ key: new StringSchema({}) }),
-      )
+      const schema = nullable(object({ key: string() }))
       const input = { key: 'value' }
       const result = schema.safeParse(input)
       expect(result.success).toBe(true)
@@ -399,7 +394,7 @@ describe('NullableSchema', () => {
     })
 
     it('preserves null type exactly', () => {
-      const schema = new NullableSchema(new StringSchema({}))
+      const schema = nullable(string())
       const result = schema.safeParse(null)
       expect(result.success).toBe(true)
       if (result.success) {
@@ -412,8 +407,8 @@ describe('NullableSchema', () => {
 
   describe('with complex wrapped schemas', () => {
     it('validates nullable enum with default', () => {
-      const schema = new NullableSchema(
-        new EnumSchema(['option1', 'option2'], { default: 'option1' }),
+      const schema = nullable(
+        withDefault(enumSchema(['option1', 'option2']), 'option1'),
       )
 
       expect(schema.safeParse(null).success).toBe(true)
@@ -424,9 +419,7 @@ describe('NullableSchema', () => {
     })
 
     it('handles nullable schema with grapheme constraints', () => {
-      const schema = new NullableSchema(
-        new StringSchema({ minGraphemes: 2, maxGraphemes: 5 }),
-      )
+      const schema = nullable(string({ minGraphemes: 2, maxGraphemes: 5 }))
 
       expect(schema.safeParse(null).success).toBe(true)
       expect(schema.safeParse('ab').success).toBe(true)
@@ -436,9 +429,7 @@ describe('NullableSchema', () => {
     })
 
     it('handles nullable integer with negative range', () => {
-      const schema = new NullableSchema(
-        new IntegerSchema({ minimum: -100, maximum: -10 }),
-      )
+      const schema = nullable(integer({ minimum: -100, maximum: -10 }))
 
       expect(schema.safeParse(null).success).toBe(true)
       expect(schema.safeParse(-50).success).toBe(true)
@@ -452,27 +443,25 @@ describe('NullableSchema', () => {
 
   describe('validation error behavior', () => {
     it('returns failure for wrapped schema validation errors', () => {
-      const schema = new NullableSchema(new IntegerSchema({ minimum: 10 }))
+      const schema = nullable(integer({ 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 schema = nullable(string())
       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 schema = nullable(string({ 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 }))
+      const schema = nullable(string({ 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

@@ -1,23 +1,31 @@
 import {
+  InferInput,
+  InferOutput,
   Schema,
-  ValidationResult,
+  ValidationContext,
   Validator,
-  ValidatorContext,
 } from '../core.js'
+import { memoizedTransformer } from '../util/memoize.js'
 
-export class NullableSchema<V> extends Schema<V | null> {
-  constructor(readonly schema: Validator<V>) {
+export class NullableSchema<const TValidator extends Validator> extends Schema<
+  InferInput<TValidator> | null,
+  InferOutput<TValidator> | null
+> {
+  constructor(readonly validator: TValidator) {
     super()
   }
 
-  validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<V | null> {
+  validateInContext(input: unknown, ctx: ValidationContext) {
     if (input === null) {
       return ctx.success(null)
     }
 
-    return ctx.validate(input, this.schema)
+    return ctx.validate(input, this.validator)
   }
 }
+
+export const nullable = /*#__PURE__*/ memoizedTransformer(function <
+  const TValidator extends Validator,
+>(validator: TValidator) {
+  return new NullableSchema<TValidator>(validator)
+})

package/src/schema/object.test.ts

@@ -1,18 +1,16 @@
 import { describe, expect, it } from 'vitest'
-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'
+import { enumSchema } from './enum.js'
+import { integer } from './integer.js'
+import { nullable } from './nullable.js'
+import { object } from './object.js'
+import { optional } from './optional.js'
+import { string } from './string.js'
 
 describe('ObjectSchema', () => {
-  const schema = new ObjectSchema({
-    name: new StringSchema({}),
-    age: new OptionalSchema(new IntegerSchema({})),
-    gender: new OptionalSchema(
-      new NullableSchema(new EnumSchema(['male', 'female'])),
-    ),
+  const schema = object({
+    name: string(),
+    age: optional(integer()),
+    gender: optional(nullable(enumSchema(['male', 'female']))),
   })
 
   it('validates plain objects', () => {

package/src/schema/object.ts

@@ -1,25 +1,27 @@
 import { isPlainObject } from '@atproto/lex-data'
 import {
-  Infer,
+  InferInput,
+  InferOutput,
   Schema,
-  ValidationResult,
+  ValidationContext,
   Validator,
-  ValidatorContext,
   WithOptionalProperties,
 } from '../core.js'
 import { lazyProperty } from '../util/lazy-property.js'
 
 export type ObjectSchemaShape = Record<string, Validator>
 
-export type ObjectSchemaOutput<Shape extends ObjectSchemaShape> =
+export class ObjectSchema<
+  const TShape extends ObjectSchemaShape = any,
+> extends Schema<
+  WithOptionalProperties<{
+    [K in keyof TShape]: InferInput<TShape[K]>
+  }>,
   WithOptionalProperties<{
-    [K in keyof Shape]: Infer<Shape[K]>
+    [K in keyof TShape]: InferOutput<TShape[K]>
   }>
-
-export class ObjectSchema<
-  const Shape extends ObjectSchemaShape = any,
-> extends Schema<ObjectSchemaOutput<Shape>> {
-  constructor(readonly shape: Shape) {
+> {
+  constructor(readonly shape: TShape) {
     super()
   }
 
@@ -29,10 +31,7 @@ export class ObjectSchema<
     return lazyProperty(this, 'validatorsMap', map)
   }
 
-  validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<ObjectSchemaOutput<Shape>> {
+  validateInContext(input: unknown, ctx: ValidationContext) {
     if (!isPlainObject(input)) {
       return ctx.issueInvalidType(input, 'object')
     }
@@ -56,14 +55,24 @@ export class ObjectSchema<
         continue
       }
 
-      if (result.value !== input[key]) {
+      if (!Object.is(result.value, input[key])) {
+        if (ctx.options.mode === 'validate') {
+          // In "validate" mode, we can't modify the input, so we issue an error
+          return ctx.issueInvalidPropertyValue(input, key, [result.value])
+        }
+
         copy ??= { ...input }
         copy[key] = result.value
       }
     }
 
-    const output = (copy ?? input) as ObjectSchemaOutput<Shape>
-
-    return ctx.success(output)
+    return ctx.success(copy ?? input)
   }
 }
+
+/*@__NO_SIDE_EFFECTS__*/
+export function object<const TShape extends ObjectSchemaShape>(
+  properties: TShape,
+) {
+  return new ObjectSchema<TShape>(properties)
+}

package/src/schema/optional.test.ts

@@ -1,12 +1,13 @@
 import { describe, expect, it } from 'vitest'
-import { BooleanSchema } from './boolean.js'
-import { IntegerSchema } from './integer.js'
-import { OptionalSchema } from './optional.js'
-import { StringSchema } from './string.js'
+import { boolean } from './boolean.js'
+import { integer } from './integer.js'
+import { optional } from './optional.js'
+import { string } from './string.js'
+import { withDefault } from './with-default.js'
 
 describe('OptionalSchema', () => {
   describe('basic validation with string schema', () => {
-    const schema = new OptionalSchema(new StringSchema({}))
+    const schema = optional(string())
 
     it('validates defined string values', () => {
       const result = schema.safeParse('hello')
@@ -59,7 +60,7 @@ describe('OptionalSchema', () => {
   })
 
   describe('basic validation with integer schema', () => {
-    const schema = new OptionalSchema(new IntegerSchema({}))
+    const schema = optional(integer())
 
     it('validates defined integer values', () => {
       const result = schema.safeParse(42)
@@ -110,7 +111,7 @@ describe('OptionalSchema', () => {
   })
 
   describe('basic validation with boolean schema', () => {
-    const schema = new OptionalSchema(new BooleanSchema({}))
+    const schema = optional(boolean())
 
     it('validates true', () => {
       const result = schema.safeParse(true)
@@ -153,9 +154,7 @@ describe('OptionalSchema', () => {
   })
 
   describe('inner schema with constraints', () => {
-    const schema = new OptionalSchema(
-      new StringSchema({ minLength: 5, maxLength: 10 }),
-    )
+    const schema = optional(string({ minLength: 5, maxLength: 10 }))
 
     it('validates values meeting inner schema constraints', () => {
       const result = schema.safeParse('hello')
@@ -194,7 +193,7 @@ describe('OptionalSchema', () => {
   })
 
   describe('inner schema with default value', () => {
-    const schema = new OptionalSchema(new StringSchema({ default: 'default' }))
+    const schema = optional(withDefault(string(), 'default'))
 
     it('applies default value when undefined is provided', () => {
       const result = schema.safeParse(undefined)
@@ -222,9 +221,7 @@ describe('OptionalSchema', () => {
   })
 
   describe('inner schema with default value and constraints', () => {
-    const schema = new OptionalSchema(
-      new StringSchema({ default: 'default', minLength: 5 }),
-    )
+    const schema = optional(withDefault(string({ minLength: 5 }), 'default'))
 
     it('applies default value when undefined is provided', () => {
       const result = schema.safeParse(undefined)
@@ -246,9 +243,7 @@ describe('OptionalSchema', () => {
   })
 
   describe('inner schema with invalid default value', () => {
-    const schema = new OptionalSchema(
-      new StringSchema({ default: 'bad', minLength: 5 }),
-    )
+    const schema = optional(string({ default: 'bad', minLength: 5 }))
 
     it('returns undefined when default value violates constraints', () => {
       const result = schema.safeParse(undefined)
@@ -265,7 +260,7 @@ describe('OptionalSchema', () => {
   })
 
   describe('inner schema with integer default', () => {
-    const schema = new OptionalSchema(new IntegerSchema({ default: 42 }))
+    const schema = optional(withDefault(integer(), 42))
 
     it('applies default value when undefined is provided', () => {
       const result = schema.safeParse(undefined)
@@ -293,7 +288,7 @@ describe('OptionalSchema', () => {
   })
 
   describe('inner schema with boolean default', () => {
-    const schema = new OptionalSchema(new BooleanSchema({ default: true }))
+    const schema = optional(withDefault(boolean(), true))
 
     it('applies default value when undefined is provided', () => {
       const result = schema.safeParse(undefined)
@@ -321,7 +316,7 @@ describe('OptionalSchema', () => {
   })
 
   describe('edge cases', () => {
-    const schema = new OptionalSchema(new StringSchema({}))
+    const schema = optional(string())
 
     it('handles very long strings', () => {
       const longString = 'a'.repeat(10000)
@@ -356,7 +351,7 @@ describe('OptionalSchema', () => {
 
   describe('type distinctions', () => {
     it('distinguishes between zero and undefined for integers', () => {
-      const schema = new OptionalSchema(new IntegerSchema({}))
+      const schema = optional(integer())
 
       const zeroResult = schema.safeParse(0)
       expect(zeroResult.success).toBe(true)
@@ -372,7 +367,7 @@ describe('OptionalSchema', () => {
     })
 
     it('distinguishes between false and undefined for booleans', () => {
-      const schema = new OptionalSchema(new BooleanSchema({}))
+      const schema = optional(boolean())
 
       const falseResult = schema.safeParse(false)
       expect(falseResult.success).toBe(true)
@@ -388,7 +383,7 @@ describe('OptionalSchema', () => {
     })
 
     it('distinguishes between empty string and undefined for strings', () => {
-      const schema = new OptionalSchema(new StringSchema({}))
+      const schema = optional(string())
 
       const emptyResult = schema.safeParse('')
       expect(emptyResult.success).toBe(true)
@@ -405,7 +400,7 @@ describe('OptionalSchema', () => {
   })
 
   describe('nested optional schemas', () => {
-    const schema = new OptionalSchema(new OptionalSchema(new StringSchema({})))
+    const schema = optional(optional(string()))
 
     it('validates defined values through nested optionals', () => {
       const result = schema.safeParse('hello')
@@ -430,7 +425,7 @@ describe('OptionalSchema', () => {
   })
 
   describe('inner schema format constraints', () => {
-    const schema = new OptionalSchema(new StringSchema({ format: 'uri' }))
+    const schema = optional(string({ format: 'uri' }))
 
     it('validates values meeting format constraint', () => {
       const result = schema.safeParse('https://example.com')
@@ -449,9 +444,7 @@ describe('OptionalSchema', () => {
   })
 
   describe('integer constraint validation', () => {
-    const schema = new OptionalSchema(
-      new IntegerSchema({ minimum: 0, maximum: 100 }),
-    )
+    const schema = optional(integer({ minimum: 0, maximum: 100 }))
 
     it('validates values within range', () => {
       const result = schema.safeParse(50)

package/src/schema/optional.ts

@@ -1,22 +1,33 @@
 import {
+  InferInput,
+  InferOutput,
   Schema,
-  ValidationResult,
+  UnwrapValidator,
+  ValidationContext,
   Validator,
-  ValidatorContext,
 } from '../core.js'
+import { memoizedTransformer } from '../util/memoize.js'
+import { WithDefaultSchema } from './with-default.js'
 
-export class OptionalSchema<V> extends Schema<V | undefined> {
-  constructor(readonly schema: Validator<V>) {
+export class OptionalSchema<TValidator extends Validator> extends Schema<
+  InferInput<TValidator> | undefined,
+  UnwrapValidator<TValidator> extends WithDefaultSchema<infer TValidator>
+    ? InferOutput<TValidator>
+    : InferOutput<TValidator> | undefined
+> {
+  constructor(readonly validator: TValidator) {
     super()
   }
 
-  validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<V | undefined> {
+  validateInContext(input: unknown, ctx: ValidationContext) {
+    // Optimization: No need to apply child schema defaults in validation mode
+    if (input === undefined && ctx.options.mode === 'validate') {
+      return ctx.success(input)
+    }
+
     // @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)
+    // even if input is undefined.
+    const result = ctx.validate(input, this.validator)
 
     if (result.success) {
       return result
@@ -29,3 +40,9 @@ export class OptionalSchema<V> extends Schema<V | undefined> {
     return result
   }
 }
+
+export const optional = /*#__PURE__*/ memoizedTransformer(function <
+  const TValidator extends Validator,
+>(validator: TValidator) {
+  return new OptionalSchema<TValidator>(validator)
+})