@atproto/lex-schema 0.0.9 → 0.0.10

package/src/schema/enum.ts

@@ -1,27 +1,27 @@
-import { Schema, ValidationResult, ValidatorContext } from '../core.js'
-
-export type EnumSchemaOptions<T extends null | string | number | boolean> = {
-  default?: T
-}
+import { Schema, ValidationContext } from '../core.js'
 
 export class EnumSchema<
-  Output extends null | string | number | boolean = any,
-> extends Schema<Output> {
-  constructor(
-    readonly values: readonly Output[],
-    readonly options?: EnumSchemaOptions<Output>,
-  ) {
+  const TValue extends null | string | number | boolean,
+> extends Schema<TValue> {
+  constructor(readonly values: readonly TValue[]) {
     super()
   }
 
-  validateInContext(
-    input: unknown = this.options?.default,
-    ctx: ValidatorContext,
-  ): ValidationResult<Output> {
+  validateInContext(input: unknown, ctx: ValidationContext) {
     if (!(this.values as readonly unknown[]).includes(input)) {
       return ctx.issueInvalidValue(input, this.values)
     }
 
-    return ctx.success(input as Output)
+    return ctx.success(input as TValue)
   }
 }
+
+/*@__NO_SIDE_EFFECTS__*/
+export function enumSchema<const V extends null | string | number | boolean>(
+  value: readonly V[],
+) {
+  return new EnumSchema<V>(value)
+}
+
+// @NOTE "enum" is a reserved keyword in JS/TS
+export { enumSchema as enum }

package/src/schema/integer.test.ts

@@ -1,9 +1,10 @@
 import { describe, expect, it } from 'vitest'
-import { IntegerSchema } from './integer.js'
+import { integer } from './integer.js'
+import { withDefault } from './with-default.js'
 
 describe('IntegerSchema', () => {
   describe('basic validation', () => {
-    const schema = new IntegerSchema({})
+    const schema = integer()
 
     it('validates integers', () => {
       const result = schema.safeParse(42)
@@ -82,22 +83,22 @@ describe('IntegerSchema', () => {
   })
 
   describe('default value', () => {
-    const schema = new IntegerSchema({ default: 10 })
+    const schema = withDefault(integer(), 10)
 
     it('uses default when undefined is provided', () => {
       const result = schema.safeParse(undefined)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(10)
-      }
+      expect(result).toMatchObject({
+        success: true,
+        value: 10,
+      })
     })
 
     it('does not use default when explicit value is provided', () => {
       const result = schema.safeParse(20)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(20)
-      }
+      expect(result).toMatchObject({
+        success: true,
+        value: 20,
+      })
     })
 
     it('does not use default when zero is provided', () => {
@@ -110,7 +111,7 @@ describe('IntegerSchema', () => {
   })
 
   describe('minimum constraint', () => {
-    const schema = new IntegerSchema({ minimum: 10 })
+    const schema = integer({ minimum: 10 })
 
     it('accepts values equal to minimum', () => {
       const result = schema.safeParse(10)
@@ -139,7 +140,7 @@ describe('IntegerSchema', () => {
   })
 
   describe('maximum constraint', () => {
-    const schema = new IntegerSchema({ maximum: 100 })
+    const schema = integer({ maximum: 100 })
 
     it('accepts values equal to maximum', () => {
       const result = schema.safeParse(100)
@@ -168,7 +169,7 @@ describe('IntegerSchema', () => {
   })
 
   describe('minimum and maximum constraints', () => {
-    const schema = new IntegerSchema({ minimum: 10, maximum: 100 })
+    const schema = integer({ minimum: 10, maximum: 100 })
 
     it('accepts values within range', () => {
       const result = schema.safeParse(50)
@@ -197,7 +198,7 @@ describe('IntegerSchema', () => {
   })
 
   describe('negative range constraints', () => {
-    const schema = new IntegerSchema({ minimum: -100, maximum: -10 })
+    const schema = integer({ minimum: -100, maximum: -10 })
 
     it('accepts negative values within range', () => {
       const result = schema.safeParse(-50)
@@ -236,7 +237,7 @@ describe('IntegerSchema', () => {
   })
 
   describe('zero constraints', () => {
-    const schema = new IntegerSchema({ minimum: 0, maximum: 0 })
+    const schema = integer({ minimum: 0, maximum: 0 })
 
     it('accepts zero', () => {
       const result = schema.safeParse(0)
@@ -255,7 +256,7 @@ describe('IntegerSchema', () => {
   })
 
   describe('combined with default value', () => {
-    const schema = new IntegerSchema({ default: 50, minimum: 10, maximum: 100 })
+    const schema = withDefault(integer({ minimum: 10, maximum: 100 }), 50)
 
     it('uses default when undefined is provided', () => {
       const result = schema.safeParse(undefined)
@@ -278,21 +279,21 @@ describe('IntegerSchema', () => {
 
   describe('edge cases', () => {
     it('handles minimum of 0', () => {
-      const schema = new IntegerSchema({ minimum: 0 })
+      const schema = integer({ minimum: 0 })
       expect(schema.safeParse(0).success).toBe(true)
       expect(schema.safeParse(-1).success).toBe(false)
       expect(schema.safeParse(1).success).toBe(true)
     })
 
     it('handles maximum of 0', () => {
-      const schema = new IntegerSchema({ maximum: 0 })
+      const schema = integer({ maximum: 0 })
       expect(schema.safeParse(0).success).toBe(true)
       expect(schema.safeParse(1).success).toBe(false)
       expect(schema.safeParse(-1).success).toBe(true)
     })
 
     it('handles very large ranges', () => {
-      const schema = new IntegerSchema({
+      const schema = integer({
         minimum: Number.MIN_SAFE_INTEGER,
         maximum: Number.MAX_SAFE_INTEGER,
       })
@@ -302,7 +303,7 @@ describe('IntegerSchema', () => {
     })
 
     it('allows unconstrained schema', () => {
-      const schema = new IntegerSchema({})
+      const schema = integer()
       expect(schema.safeParse(Number.MIN_SAFE_INTEGER).success).toBe(true)
       expect(schema.safeParse(Number.MAX_SAFE_INTEGER).success).toBe(true)
       expect(schema.safeParse(0).success).toBe(true)

package/src/schema/integer.ts

@@ -1,29 +1,26 @@
-import { Schema, ValidationResult, ValidatorContext } from '../core.js'
+import { Schema, ValidationContext } from '../core.js'
+import { memoizedOptions } from '../util/memoize.js'
 
 export type IntegerSchemaOptions = {
-  default?: number
   minimum?: number
   maximum?: number
 }
 
 export class IntegerSchema extends Schema<number> {
-  constructor(readonly options: IntegerSchemaOptions = {}) {
+  constructor(readonly options?: IntegerSchemaOptions) {
     super()
   }
 
-  validateInContext(
-    input: unknown = this.options?.default,
-    ctx: ValidatorContext,
-  ): ValidationResult<number> {
+  validateInContext(input: unknown, ctx: ValidationContext) {
     if (!isInteger(input)) {
       return ctx.issueInvalidType(input, 'integer')
     }
 
-    if (this.options.minimum !== undefined && input < this.options.minimum) {
+    if (this.options?.minimum != null && input < this.options.minimum) {
       return ctx.issueTooSmall(input, 'integer', this.options.minimum, input)
     }
 
-    if (this.options.maximum !== undefined && input > this.options.maximum) {
+    if (this.options?.maximum != null && input > this.options.maximum) {
       return ctx.issueTooBig(input, 'integer', this.options.maximum, input)
     }
 
@@ -37,3 +34,9 @@ export class IntegerSchema extends Schema<number> {
 function isInteger(input: unknown): input is number {
   return Number.isSafeInteger(input)
 }
+
+export const integer = /*#__PURE__*/ memoizedOptions(function (
+  options?: IntegerSchemaOptions,
+) {
+  return new IntegerSchema(options)
+})

package/src/schema/intersection.test.ts

@@ -1,17 +1,17 @@
 import { describe, expect, it } from 'vitest'
-import { BooleanSchema } from './boolean.js'
-import { DictSchema } from './dict.js'
-import { EnumSchema } from './enum.js'
-import { IntersectionSchema } from './intersection.js'
-import { ObjectSchema } from './object.js'
-import { StringSchema } from './string.js'
+import { boolean } from './boolean.js'
+import { dict } from './dict.js'
+import { enumSchema } from './enum.js'
+import { intersection } from './intersection.js'
+import { object } from './object.js'
+import { string } from './string.js'
 
 describe('IntersectionSchema', () => {
-  const schema = new IntersectionSchema(
-    new ObjectSchema({
-      title: new StringSchema({}),
+  const schema = intersection(
+    object({
+      title: string(),
     }),
-    new DictSchema(new EnumSchema(['tag1', 'tag2']), new BooleanSchema({})),
+    dict(enumSchema(['tag1', 'tag2']), boolean()),
   )
 
   it('validates extra properties with the provided validator', () => {

package/src/schema/intersection.ts

@@ -1,9 +1,9 @@
 import {
-  Infer,
+  InferInput,
+  InferOutput,
   Schema,
   Simplify,
-  ValidationResult,
-  ValidatorContext,
+  ValidationContext,
 } from '../core.js'
 import { DictSchema } from './dict.js'
 import { ObjectSchema } from './object.js'
@@ -24,15 +24,13 @@ export type Intersect<A, B> = B[keyof B] extends never
       // index signature could return a value from either A or B
       A & { [K in keyof B]: B[K] | A[keyof A & K] }
 
-export type IntersectionSchemaOutput<
-  Left extends ObjectSchema,
-  Right extends DictSchema,
-> = Simplify<Intersect<Infer<Left>, Infer<Right>>>
-
 export class IntersectionSchema<
   const Left extends ObjectSchema = any,
   const Right extends DictSchema = any,
-> extends Schema<IntersectionSchemaOutput<Left, Right>> {
+> extends Schema<
+  Simplify<Intersect<InferInput<Left>, InferInput<Right>>>,
+  Simplify<Intersect<InferOutput<Left>, InferOutput<Right>>>
+> {
   constructor(
     protected readonly left: Left,
     protected readonly right: Right,
@@ -40,15 +38,20 @@ export class IntersectionSchema<
     super()
   }
 
-  validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<IntersectionSchemaOutput<Left, Right>> {
+  validateInContext(input: unknown, ctx: ValidationContext) {
     const leftResult = ctx.validate(input, this.left)
     if (!leftResult.success) return leftResult
 
     return this.right.validateInContext(leftResult.value, ctx, {
       ignoredKeys: this.left.validatorsMap,
-    }) as ValidationResult<IntersectionSchemaOutput<Left, Right>>
+    })
   }
 }
+
+/*@__NO_SIDE_EFFECTS__*/
+export function intersection<
+  const Left extends ObjectSchema,
+  const Right extends DictSchema,
+>(left: Left, right: Right) {
+  return new IntersectionSchema<Left, Right>(left, right)
+}

package/src/schema/literal.test.ts

@@ -1,9 +1,10 @@
 import { describe, expect, it } from 'vitest'
-import { LiteralSchema } from './literal.js'
+import { literal } from './literal.js'
+import { withDefault } from './with-default.js'
 
 describe('LiteralSchema', () => {
   describe('string literals', () => {
-    const schema = new LiteralSchema('hello')
+    const schema = literal('hello')
 
     it('validates exact string match', () => {
       const result = schema.safeParse('hello')
@@ -60,7 +61,7 @@ describe('LiteralSchema', () => {
   })
 
   describe('empty string literal', () => {
-    const schema = new LiteralSchema('')
+    const schema = literal('')
 
     it('validates empty string', () => {
       const result = schema.safeParse('')
@@ -87,7 +88,7 @@ describe('LiteralSchema', () => {
   })
 
   describe('number literals', () => {
-    const schema = new LiteralSchema(42)
+    const schema = literal(42)
 
     it('validates exact number match', () => {
       const result = schema.safeParse(42)
@@ -124,7 +125,7 @@ describe('LiteralSchema', () => {
   })
 
   describe('zero literal', () => {
-    const schema = new LiteralSchema(0)
+    const schema = literal(0)
 
     it('validates zero', () => {
       const result = schema.safeParse(0)
@@ -156,7 +157,7 @@ describe('LiteralSchema', () => {
   })
 
   describe('negative number literals', () => {
-    const schema = new LiteralSchema(-42)
+    const schema = literal(-42)
 
     it('validates exact negative number match', () => {
       const result = schema.safeParse(-42)
@@ -178,7 +179,7 @@ describe('LiteralSchema', () => {
   })
 
   describe('decimal number literals', () => {
-    const schema = new LiteralSchema(3.14)
+    const schema = literal(3.14)
 
     it('validates exact decimal match', () => {
       const result = schema.safeParse(3.14)
@@ -201,7 +202,7 @@ describe('LiteralSchema', () => {
 
   describe('boolean literals', () => {
     describe('true literal', () => {
-      const schema = new LiteralSchema(true)
+      const schema = literal(true)
 
       it('validates true', () => {
         const result = schema.safeParse(true)
@@ -238,7 +239,7 @@ describe('LiteralSchema', () => {
     })
 
     describe('false literal', () => {
-      const schema = new LiteralSchema(false)
+      const schema = literal(false)
 
       it('validates false', () => {
         const result = schema.safeParse(false)
@@ -271,7 +272,7 @@ describe('LiteralSchema', () => {
   })
 
   describe('null literal', () => {
-    const schema = new LiteralSchema(null)
+    const schema = literal(null)
 
     it('validates null', () => {
       const result = schema.safeParse(null)
@@ -309,7 +310,7 @@ describe('LiteralSchema', () => {
 
   describe('default values', () => {
     describe('string literal with default', () => {
-      const schema = new LiteralSchema('hello', { default: 'hello' })
+      const schema = withDefault(literal('hello'), 'hello')
 
       it('uses default value when undefined is provided', () => {
         const result = schema.safeParse(undefined)
@@ -334,7 +335,7 @@ describe('LiteralSchema', () => {
     })
 
     describe('number literal with default', () => {
-      const schema = new LiteralSchema(42, { default: 42 })
+      const schema = withDefault(literal(42), 42)
 
       it('uses default value when undefined is provided', () => {
         const result = schema.safeParse(undefined)
@@ -351,7 +352,7 @@ describe('LiteralSchema', () => {
     })
 
     describe('boolean literal with default', () => {
-      const schema = new LiteralSchema(true, { default: true })
+      const schema = withDefault(literal(true), true)
 
       it('uses default value when undefined is provided', () => {
         const result = schema.safeParse(undefined)
@@ -368,7 +369,7 @@ describe('LiteralSchema', () => {
     })
 
     describe('null literal with default', () => {
-      const schema = new LiteralSchema(null, { default: null })
+      const schema = withDefault(literal(null), null)
 
       it('uses default value when undefined is provided', () => {
         const result = schema.safeParse(undefined)
@@ -385,7 +386,7 @@ describe('LiteralSchema', () => {
     })
 
     describe('false literal with default', () => {
-      const schema = new LiteralSchema(false, { default: false })
+      const schema = withDefault(literal(false), false)
 
       it('uses default value when undefined is provided', () => {
         const result = schema.safeParse(undefined)
@@ -402,7 +403,7 @@ describe('LiteralSchema', () => {
     })
 
     describe('zero literal with default', () => {
-      const schema = new LiteralSchema(0, { default: 0 })
+      const schema = withDefault(literal(0), 0)
 
       it('uses default value when undefined is provided', () => {
         const result = schema.safeParse(undefined)
@@ -421,82 +422,82 @@ describe('LiteralSchema', () => {
 
   describe('edge cases', () => {
     it('handles special string characters', () => {
-      const schema = new LiteralSchema('hello\nworld')
+      const schema = literal('hello\nworld')
       expect(schema.safeParse('hello\nworld').success).toBe(true)
       expect(schema.safeParse('hello world').success).toBe(false)
     })
 
     it('handles unicode characters in strings', () => {
-      const schema = new LiteralSchema('Hello 世界 🌍')
+      const schema = literal('Hello 世界 🌍')
       expect(schema.safeParse('Hello 世界 🌍').success).toBe(true)
       expect(schema.safeParse('Hello world').success).toBe(false)
     })
 
     it('handles emoji literals', () => {
-      const schema = new LiteralSchema('🚀')
+      const schema = literal('🚀')
       expect(schema.safeParse('🚀').success).toBe(true)
       expect(schema.safeParse('🌟').success).toBe(false)
     })
 
     it('handles very long string literals', () => {
       const longString = 'a'.repeat(1000)
-      const schema = new LiteralSchema(longString)
+      const schema = literal(longString)
       expect(schema.safeParse(longString).success).toBe(true)
       expect(schema.safeParse(longString + 'b').success).toBe(false)
     })
 
     it('handles string with whitespace', () => {
-      const schema = new LiteralSchema('  hello  ')
+      const schema = literal('  hello  ')
       expect(schema.safeParse('  hello  ').success).toBe(true)
       expect(schema.safeParse('hello').success).toBe(false)
       expect(schema.safeParse('  hello').success).toBe(false)
     })
 
     it('handles Number.MAX_SAFE_INTEGER', () => {
-      const schema = new LiteralSchema(Number.MAX_SAFE_INTEGER)
+      const schema = literal(Number.MAX_SAFE_INTEGER)
       expect(schema.safeParse(Number.MAX_SAFE_INTEGER).success).toBe(true)
       expect(schema.safeParse(Number.MAX_SAFE_INTEGER - 1).success).toBe(false)
     })
 
     it('handles Number.MIN_SAFE_INTEGER', () => {
-      const schema = new LiteralSchema(Number.MIN_SAFE_INTEGER)
+      const schema = literal(Number.MIN_SAFE_INTEGER)
       expect(schema.safeParse(Number.MIN_SAFE_INTEGER).success).toBe(true)
       expect(schema.safeParse(Number.MIN_SAFE_INTEGER + 1).success).toBe(false)
     })
 
     it('rejects NaN', () => {
-      const schema = new LiteralSchema(42)
+      const schema = literal(42)
       expect(schema.safeParse(NaN).success).toBe(false)
     })
 
     it('rejects Infinity', () => {
-      const schema = new LiteralSchema(42)
+      const schema = literal(42)
       expect(schema.safeParse(Infinity).success).toBe(false)
     })
 
     it('rejects -Infinity', () => {
-      const schema = new LiteralSchema(42)
+      const schema = literal(42)
       expect(schema.safeParse(-Infinity).success).toBe(false)
     })
 
     it('rejects Boolean objects', () => {
-      const schema = new LiteralSchema(true)
+      const schema = literal(true)
       expect(schema.safeParse(new Boolean(true)).success).toBe(false)
     })
 
     it('rejects String objects', () => {
-      const schema = new LiteralSchema('hello')
+      const schema = literal('hello')
       expect(schema.safeParse(new String('hello')).success).toBe(false)
     })
 
     it('rejects Number objects', () => {
-      const schema = new LiteralSchema(42)
+      const schema = literal(42)
       expect(schema.safeParse(new Number(42)).success).toBe(false)
     })
 
     it('distinguishes between -0 and +0', () => {
-      const schemaPositive = new LiteralSchema(0)
-      const schemaNegative = new LiteralSchema(-0)
+      const schemaPositive = literal(0)
+      const schemaNegative = literal(-0)
       // In JavaScript, 0 === -0, so both should validate for both schemas
       expect(schemaPositive.safeParse(0).success).toBe(true)
       expect(schemaPositive.safeParse(-0).success).toBe(true)
@@ -505,7 +506,7 @@ describe('LiteralSchema', () => {
     })
 
     it('handles very small decimal differences', () => {
-      const schema = new LiteralSchema(0.1 + 0.2)
+      const schema = literal(0.1 + 0.2)
       // Note: 0.1 + 0.2 !== 0.3 in JavaScript due to floating point precision
       expect(schema.safeParse(0.1 + 0.2).success).toBe(true)
       expect(schema.safeParse(0.3).success).toBe(false)
@@ -514,13 +515,13 @@ describe('LiteralSchema', () => {
 
   describe('type safety', () => {
     it('accepts exact literal types in TypeScript', () => {
-      const schema = new LiteralSchema('specific' as const)
+      const schema = literal('specific' as const)
       const result = schema.safeParse('specific')
       expect(result.success).toBe(true)
     })
 
     it('preserves literal type in success result', () => {
-      const schema = new LiteralSchema(42)
+      const schema = literal(42)
       const result = schema.safeParse(42)
       expect(result.success).toBe(true)
       if (result.success) {

package/src/schema/literal.ts

@@ -1,23 +1,13 @@
-import { Schema, ValidationResult, ValidatorContext } from '../core.js'
-
-export type LiteralSchemaOptions<T extends null | string | number | boolean> = {
-  default?: T
-}
+import { Schema, ValidationContext } from '../core.js'
 
 export class LiteralSchema<
-  Output extends null | string | number | boolean = any,
-> extends Schema<Output> {
-  constructor(
-    readonly value: Output,
-    readonly options?: LiteralSchemaOptions<Output>,
-  ) {
+  const TValue extends null | string | number | boolean,
+> extends Schema<TValue> {
+  constructor(readonly value: TValue) {
     super()
   }
 
-  validateInContext(
-    input: unknown = this.options?.default,
-    ctx: ValidatorContext,
-  ): ValidationResult<Output> {
+  validateInContext(input: unknown, ctx: ValidationContext) {
     if (input !== this.value) {
       return ctx.issueInvalidValue(input, [this.value])
     }
@@ -25,3 +15,10 @@ export class LiteralSchema<
     return ctx.success(this.value)
   }
 }
+
+/*@__NO_SIDE_EFFECTS__*/
+export function literal<const V extends null | string | number | boolean>(
+  value: V,
+) {
+  return new LiteralSchema<V>(value)
+}

package/src/schema/never.test.ts

@@ -1,9 +1,9 @@
 import { describe, expect, it } from 'vitest'
-import { NeverSchema } from './never.js'
+import { never } from './never.js'
 
 describe('NeverSchema', () => {
   describe('basic validation', () => {
-    const schema = new NeverSchema()
+    const schema = never()
 
     it('rejects strings', () => {
       const result = schema.safeParse('string')
@@ -57,7 +57,7 @@ describe('NeverSchema', () => {
   })
 
   describe('edge cases', () => {
-    const schema = new NeverSchema()
+    const schema = never()
 
     it('rejects BigInt', () => {
       const result = schema.safeParse(BigInt(123))
@@ -114,7 +114,7 @@ describe('NeverSchema', () => {
   })
 
   describe('complex data types', () => {
-    const schema = new NeverSchema()
+    const schema = never()
 
     it('rejects class instances', () => {
       class TestClass {
@@ -150,7 +150,7 @@ describe('NeverSchema', () => {
   })
 
   describe('special number values', () => {
-    const schema = new NeverSchema()
+    const schema = never()
 
     it('rejects NaN', () => {
       const result = schema.safeParse(NaN)

package/src/schema/never.ts

@@ -1,7 +1,12 @@
-import { Schema, ValidationFailure, ValidatorContext } from '../core.js'
+import { Schema, ValidationContext } from '../core.js'
+import { memoizedOptions } from '../util/memoize.js'
 
 export class NeverSchema extends Schema<never> {
-  validateInContext(input: unknown, ctx: ValidatorContext): ValidationFailure {
+  validateInContext(input: unknown, ctx: ValidationContext) {
     return ctx.issueInvalidType(input, 'never')
   }
 }
+
+export const never = /*#__PURE__*/ memoizedOptions(function () {
+  return new NeverSchema()
+})