@atproto/lex-schema 0.0.9 → 0.0.10

package/src/schema/typed-ref.ts

@@ -1,28 +1,31 @@
 import {
+  $Typed,
+  InferInput,
+  InferOutput,
   Schema,
-  ValidationResult,
+  ValidationContext,
   Validator,
-  ValidatorContext,
 } from '../core.js'
 
-// Basically a RecordSchema or TypedObjectSchema
-export type TypedRefSchemaValidator<V extends { $type?: string } = any> =
-  V extends { $type?: infer T extends string }
-    ? { $type: T } & Validator<V & { $type?: T }>
-    : never
-
-export type TypedRefGetter<V extends { $type?: string } = any> =
-  () => TypedRefSchemaValidator<V>
+export interface TypedObjectValidator<
+  TInput extends { $type?: string } = { $type?: string },
+  TOutput extends TInput = TInput,
+> extends Validator<TInput, TOutput> {
+  $type: NonNullable<TOutput['$type']>
+}
 
-export type TypedRefSchemaOutput<V extends { $type?: string } = any> =
-  V extends { $type?: infer T extends string } ? V & { $type: T } : never
+export type TypedRefGetter<out TValidator extends TypedObjectValidator> =
+  () => TValidator
 
-export class TypedRefSchema<V extends { $type?: string } = any> extends Schema<
-  TypedRefSchemaOutput<V>
+export class TypedRefSchema<
+  const TValidator extends TypedObjectValidator = TypedObjectValidator,
+> extends Schema<
+  $Typed<InferInput<TValidator>>,
+  $Typed<InferOutput<TValidator>>
 > {
-  #getter: TypedRefGetter<V>
+  #getter: TypedRefGetter<TValidator>
 
-  constructor(getter: TypedRefGetter<V>) {
+  constructor(getter: TypedRefGetter<TValidator>) {
     // @NOTE In order to avoid circular dependency issues, we don't resolve
     // the schema here. Instead, we resolve it lazily when first accessed.
 
@@ -31,43 +34,38 @@ export class TypedRefSchema<V extends { $type?: string } = any> extends Schema<
     this.#getter = getter
   }
 
-  get schema(): TypedRefSchemaValidator<V> {
-    const value = this.#getter.call(null)
-
-    // Prevents a getter from depending on itself recursively, also allows GC to
-    // clean up the getter function.
-    this.#getter = throwAlreadyCalled
-
-    // Cache the resolved schema on the instance
-    Object.defineProperty(this, 'schema', {
-      value,
-      writable: false,
-      enumerable: false,
-      configurable: true,
-    })
-
-    return value
+  get validator(): TValidator {
+    return this.#getter.call(null)
   }
 
-  get $type(): TypedRefSchemaOutput<V>['$type'] {
-    return this.schema.$type
+  get $type(): TValidator['$type'] {
+    return this.validator.$type
   }
 
-  validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<TypedRefSchemaOutput<V>> {
-    const result = ctx.validate(input, this.schema)
+  validateInContext(input: unknown, ctx: ValidationContext) {
+    const result = ctx.validate(input, this.validator)
     if (!result.success) return result
 
     if (result.value.$type !== this.$type) {
       return ctx.issueInvalidPropertyValue(result.value, '$type', [this.$type])
     }
 
-    return result as ValidationResult<TypedRefSchemaOutput<V>>
+    return result
   }
 }
 
-function throwAlreadyCalled(): never {
-  throw new Error('TypedRefSchema getter called multiple times')
+/*@__NO_SIDE_EFFECTS__*/
+export function typedRef<const TValidator extends TypedObjectValidator>(
+  get: TypedRefGetter<TValidator>,
+): TypedRefSchema<TValidator>
+export function typedRef<
+  TInput extends { $type?: string },
+  TOutput extends TInput = TInput,
+>(
+  get: TypedRefGetter<TypedObjectValidator<TInput, TOutput>>,
+): TypedRefSchema<TypedObjectValidator<TInput, TOutput>>
+export function typedRef<const TValidator extends TypedObjectValidator>(
+  get: TypedRefGetter<TValidator>,
+): TypedRefSchema<TValidator> {
+  return new TypedRefSchema<TValidator>(get)
 }

package/src/schema/typed-union.test.ts

@@ -1,42 +1,42 @@
 import { describe, expect, it } from 'vitest'
-import { IntegerSchema } from './integer.js'
-import { ObjectSchema } from './object.js'
-import { StringSchema } from './string.js'
-import { TypedObjectSchema } from './typed-object.js'
-import { TypedRefSchema } from './typed-ref.js'
-import { TypedUnionSchema } from './typed-union.js'
+import { integer } from './integer.js'
+import { object } from './object.js'
+import { string } from './string.js'
+import { typedObject } from './typed-object.js'
+import { typedRef } from './typed-ref.js'
+import { typedUnion } from './typed-union.js'
 
 describe('TypedUnionSchema', () => {
-  const personSchema = new TypedObjectSchema(
+  const personSchema = typedObject(
     'app.bsky.actor.person',
-    new ObjectSchema({
-      name: new StringSchema({}),
-      age: new IntegerSchema({}),
+    'main',
+    object({
+      name: string(),
+      age: integer(),
     }),
   )
 
-  const postSchema = new TypedObjectSchema(
+  const postSchema = typedObject(
     'app.bsky.feed.post',
-    new ObjectSchema({
-      text: new StringSchema({}),
-      createdAt: new StringSchema({}),
+    'main',
+    object({
+      text: string(),
+      createdAt: string(),
     }),
   )
 
-  const commentSchema = new TypedObjectSchema(
+  const commentSchema = typedObject(
     'app.bsky.feed.comment',
-    new ObjectSchema({
-      text: new StringSchema({}),
-      parentUri: new StringSchema({}),
+    'main',
+    object({
+      text: string(),
+      parentUri: string(),
     }),
   )
 
   describe('closed union', () => {
-    const schema = new TypedUnionSchema(
-      [
-        new TypedRefSchema(() => personSchema),
-        new TypedRefSchema(() => postSchema),
-      ],
+    const schema = typedUnion(
+      [typedRef(() => personSchema), typedRef(() => postSchema)],
       true,
     )
 
@@ -123,11 +123,8 @@ describe('TypedUnionSchema', () => {
   })
 
   describe('open union', () => {
-    const schema = new TypedUnionSchema(
-      [
-        new TypedRefSchema(() => personSchema),
-        new TypedRefSchema(() => postSchema),
-      ],
+    const schema = typedUnion(
+      [typedRef(() => personSchema), typedRef(() => postSchema)],
       false,
     )
 
@@ -208,11 +205,11 @@ describe('TypedUnionSchema', () => {
   })
 
   describe('with three types', () => {
-    const schema = new TypedUnionSchema(
+    const schema = typedUnion(
       [
-        new TypedRefSchema(() => personSchema),
-        new TypedRefSchema(() => postSchema),
-        new TypedRefSchema(() => commentSchema),
+        typedRef(() => personSchema),
+        typedRef(() => postSchema),
+        typedRef(() => commentSchema),
       ],
       true,
     )
@@ -254,10 +251,7 @@ describe('TypedUnionSchema', () => {
   })
 
   describe('with single type', () => {
-    const schema = new TypedUnionSchema(
-      [new TypedRefSchema(() => personSchema)],
-      true,
-    )
+    const schema = typedUnion([typedRef(() => personSchema)], true)
 
     it('validates the single type', () => {
       const result = schema.safeParse({
@@ -279,11 +273,8 @@ describe('TypedUnionSchema', () => {
   })
 
   describe('$types getter', () => {
-    const schema = new TypedUnionSchema(
-      [
-        new TypedRefSchema(() => personSchema),
-        new TypedRefSchema(() => postSchema),
-      ],
+    const schema = typedUnion(
+      [typedRef(() => personSchema), typedRef(() => postSchema)],
       true,
     )
 
@@ -296,16 +287,13 @@ describe('TypedUnionSchema', () => {
   })
 
   describe('refsMap getter', () => {
-    const schema = new TypedUnionSchema(
-      [
-        new TypedRefSchema(() => personSchema),
-        new TypedRefSchema(() => postSchema),
-      ],
+    const schema = typedUnion(
+      [typedRef(() => personSchema), typedRef(() => postSchema)],
       true,
     )
 
     it('returns map of $type to ref schema', () => {
-      const refsMap = schema.refsMap
+      const refsMap = schema.validatorsMap
       expect(refsMap.size).toBe(2)
       expect(refsMap.has('app.bsky.actor.person')).toBe(true)
       expect(refsMap.has('app.bsky.feed.post')).toBe(true)
@@ -313,11 +301,8 @@ describe('TypedUnionSchema', () => {
   })
 
   describe('edge cases', () => {
-    const schema = new TypedUnionSchema(
-      [
-        new TypedRefSchema(() => personSchema),
-        new TypedRefSchema(() => postSchema),
-      ],
+    const schema = typedUnion(
+      [typedRef(() => personSchema), typedRef(() => postSchema)],
       true,
     )
 
@@ -330,10 +315,7 @@ describe('TypedUnionSchema', () => {
     })
 
     it('validates object with $type as empty string in open union', () => {
-      const openSchema = new TypedUnionSchema(
-        [new TypedRefSchema(() => personSchema)],
-        false,
-      )
+      const openSchema = typedUnion([typedRef(() => personSchema)], false)
       const result = openSchema.safeParse({
         $type: '',
         someProperty: 'value',
@@ -361,18 +343,12 @@ describe('TypedUnionSchema', () => {
 
   describe('closed property', () => {
     it('exposes closed property as true', () => {
-      const schema = new TypedUnionSchema(
-        [new TypedRefSchema(() => personSchema)],
-        true,
-      )
+      const schema = typedUnion([typedRef(() => personSchema)], true)
       expect(schema.closed).toBe(true)
     })
 
     it('exposes closed property as false', () => {
-      const schema = new TypedUnionSchema(
-        [new TypedRefSchema(() => personSchema)],
-        false,
-      )
+      const schema = typedUnion([typedRef(() => personSchema)], false)
       expect(schema.closed).toBe(false)
     })
   })

package/src/schema/typed-union.ts

@@ -1,53 +1,28 @@
 import { isPlainObject } from '@atproto/lex-data'
 import {
-  Infer,
-  Restricted,
+  InferInput,
+  InferOutput,
   Schema,
-  ValidationResult,
-  ValidatorContext,
+  Unknown$TypedObject,
+  ValidationContext,
 } from '../core.js'
 import { lazyProperty } from '../util/lazy-property.js'
-import { TypedRefSchema, TypedRefSchemaOutput } from './typed-ref.js'
-
-export type TypedRef<T extends { $type?: string }> = TypedRefSchemaOutput<T>
-
-export type TypedObject = { $type: string } & {
-  // In order to prevent places that expect an open union from accepting an
-  // invalid version of the known typed objects, we need to prevent any other
-  // properties from being present.
-  //
-  // For example, if an open union expects:
-  // ```ts
-  // TypedObject | { $type: 'A'; a: number }
-  // ```
-  // we don't want it to accept:
-  // ```ts
-  // { $type: 'A' }
-  // ```
-  // Which would be the case as `{ $type: 'A' }` is a valid
-  // `TypedObject`. By adding an index signature that forbids any
-  // property, we ensure that only valid known typed objects can be used.
-  [K in string]: Restricted<'Unknown property'>
-}
-
-type TypedRefSchemasToUnion<T extends readonly TypedRefSchema[]> = {
-  [K in keyof T]: Infer<T[K]>
-}[number]
-
-export type TypedUnionSchemaOutput<
-  TypedRefs extends readonly TypedRefSchema[],
-  Closed extends boolean,
-> = Closed extends true
-  ? TypedRefSchemasToUnion<TypedRefs>
-  : TypedRefSchemasToUnion<TypedRefs> | TypedObject
+import { TypedRefSchema } from './typed-ref.js'
 
 export class TypedUnionSchema<
-  TypedRefs extends readonly TypedRefSchema[] = any,
-  Closed extends boolean = any,
-> extends Schema<TypedUnionSchemaOutput<TypedRefs, Closed>> {
+  const TValidators extends readonly TypedRefSchema[] = [],
+  const TClosed extends boolean = boolean,
+> extends Schema<
+  TClosed extends true
+    ? InferInput<TValidators[number]>
+    : InferInput<TValidators[number]> | Unknown$TypedObject,
+  TClosed extends true
+    ? InferOutput<TValidators[number]>
+    : InferOutput<TValidators[number]> | Unknown$TypedObject
+> {
   constructor(
-    protected readonly refs: TypedRefs,
-    public readonly closed: Closed,
+    protected readonly validators: TValidators,
+    public readonly closed: TClosed,
   ) {
     // @NOTE In order to avoid circular dependency issues, we don't access the
     // refs's schema (or $type) here. Instead, we access them lazily when first
@@ -56,42 +31,45 @@ export class TypedUnionSchema<
     super()
   }
 
-  get refsMap(): Map<unknown, TypedRefs[number]> {
-    const map = new Map<unknown, TypedRefs[number]>()
-    for (const ref of this.refs) map.set(ref.$type, ref)
+  get validatorsMap(): Map<unknown, TValidators[number]> {
+    const map = new Map<unknown, TValidators[number]>()
+    for (const ref of this.validators) map.set(ref.$type, ref)
 
-    return lazyProperty(this, 'refsMap', map)
+    return lazyProperty(this, 'validatorsMap', map)
   }
 
   get $types() {
-    return Array.from(this.refsMap.keys())
+    return Array.from(this.validatorsMap.keys())
   }
 
-  validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<TypedUnionSchemaOutput<TypedRefs, Closed>> {
+  validateInContext(input: unknown, ctx: ValidationContext) {
     if (!isPlainObject(input) || !('$type' in input)) {
       return ctx.issueInvalidType(input, '$typed')
     }
 
     const { $type } = input
 
-    const def = this.refsMap.get($type)
-    if (def) {
-      const result = ctx.validate(input, def)
-      return result as ValidationResult<
-        TypedUnionSchemaOutput<TypedRefs, Closed>
-      >
+    const validator = this.validatorsMap.get($type)
+    if (validator) {
+      return ctx.validate(input, validator)
     }
 
     if (this.closed) {
       return ctx.issueInvalidPropertyValue(input, '$type', this.$types)
     }
+
     if (typeof $type !== 'string') {
       return ctx.issueInvalidPropertyType(input, '$type', 'string')
     }
 
-    return ctx.success(input as TypedUnionSchemaOutput<TypedRefs, Closed>)
+    return ctx.success(input)
   }
 }
+
+/*@__NO_SIDE_EFFECTS__*/
+export function typedUnion<
+  const R extends readonly TypedRefSchema[],
+  const C extends boolean,
+>(refs: R, closed: C) {
+  return new TypedUnionSchema<R, C>(refs, closed)
+}

package/src/schema/union.test.ts

@@ -1,15 +1,12 @@
 import { describe, expect, it } from 'vitest'
-import { BooleanSchema } from './boolean.js'
-import { IntegerSchema } from './integer.js'
-import { ObjectSchema } from './object.js'
-import { StringSchema } from './string.js'
-import { UnionSchema } from './union.js'
+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 = new UnionSchema([
-    new StringSchema({}),
-    new IntegerSchema({}),
-  ])
+  const stringOrNumber = union([string(), integer()])
 
   it('validates string input', () => {
     const result = stringOrNumber.safeParse('hello')
@@ -47,14 +44,14 @@ describe('UnionSchema', () => {
   })
 
   describe('with object types', () => {
-    const schema = new UnionSchema([
-      new ObjectSchema({
-        type: new StringSchema({}),
-        name: new StringSchema({}),
+    const schema = union([
+      object({
+        type: string(),
+        name: string(),
       }),
-      new ObjectSchema({
-        type: new StringSchema({}),
-        age: new IntegerSchema({}),
+      object({
+        type: string(),
+        age: integer(),
       }),
     ])
 
@@ -91,11 +88,7 @@ describe('UnionSchema', () => {
   })
 
   describe('with three types', () => {
-    const schema = new UnionSchema([
-      new StringSchema({}),
-      new IntegerSchema({}),
-      new BooleanSchema({}),
-    ])
+    const schema = union([string(), integer(), boolean()])
 
     it('validates string input', () => {
       const result = schema.safeParse('text')
@@ -124,10 +117,7 @@ describe('UnionSchema', () => {
   })
 
   describe('with constrained types', () => {
-    const schema = new UnionSchema([
-      new StringSchema({ minLength: 5 }),
-      new IntegerSchema({ minimum: 100 }),
-    ])
+    const schema = union([string({ minLength: 5 }), integer({ minimum: 100 })])
 
     it('validates string meeting constraint', () => {
       const result = schema.safeParse('hello')
@@ -157,13 +147,13 @@ describe('UnionSchema', () => {
 
   describe('edge cases', () => {
     it('validates with single type in union', () => {
-      const schema = new UnionSchema([new StringSchema({})])
+      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 = new UnionSchema([new StringSchema({})])
+      const schema = union([string()])
       const result = schema.safeParse(123)
       expect(result.success).toBe(false)
     })

package/src/schema/union.ts

@@ -1,38 +1,42 @@
 import {
-  Infer,
+  InferInput,
+  InferOutput,
   Schema,
+  ValidationContext,
   ValidationError,
   ValidationFailure,
-  ValidationResult,
   Validator,
-  ValidatorContext,
 } from '../core.js'
 
 export type UnionSchemaValidators = readonly [Validator, ...Validator[]]
-export type UnionSchemaOutput<V extends readonly Validator[]> = Infer<V[number]>
 
-export class UnionSchema<V extends UnionSchemaValidators = any> extends Schema<
-  UnionSchemaOutput<V>
+export class UnionSchema<
+  const TValidators extends UnionSchemaValidators = any,
+> extends Schema<
+  InferInput<TValidators[number]>,
+  InferOutput<TValidators[number]>
 > {
-  constructor(protected readonly validators: V) {
+  constructor(protected readonly validators: TValidators) {
     super()
   }
 
-  validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<UnionSchemaOutput<V>> {
+  validateInContext(input: unknown, ctx: ValidationContext) {
     const failures: ValidationFailure[] = []
 
     for (const validator of this.validators) {
       const result = ctx.validate(input, validator)
-      if (result.success) {
-        return result as ValidationResult<UnionSchemaOutput<V>>
-      } else {
-        failures.push(result)
-      }
+      if (result.success) return result
+
+      failures.push(result)
     }
 
     return ctx.failure(ValidationError.fromFailures(failures))
   }
 }
+
+/*@__NO_SIDE_EFFECTS__*/
+export function union<const TValidators extends UnionSchemaValidators>(
+  validators: TValidators,
+) {
+  return new UnionSchema<TValidators>(validators)
+}

package/src/schema/unknown-object.test.ts

@@ -1,9 +1,9 @@
 import { describe, expect, it } from 'vitest'
-import { UnknownObjectSchema } from './unknown-object.js'
+import { unknownObject } from './unknown-object.js'
 
 describe('UnknownObjectSchema', () => {
   describe('basic validation', () => {
-    const schema = new UnknownObjectSchema()
+    const schema = unknownObject()
 
     it('accepts empty plain objects', () => {
       const result = schema.safeParse({})
@@ -106,7 +106,7 @@ describe('UnknownObjectSchema', () => {
   })
 
   describe('rejects non-plain-objects', () => {
-    const schema = new UnknownObjectSchema()
+    const schema = unknownObject()
 
     it('rejects strings', () => {
       const result = schema.safeParse('not an object')
@@ -208,7 +208,7 @@ describe('UnknownObjectSchema', () => {
   })
 
   describe('rejects invalid value types', () => {
-    const schema = new UnknownObjectSchema()
+    const schema = unknownObject()
 
     it('rejects objects with floating point numbers', () => {
       const result = schema.safeParse({ value: 3.14 })
@@ -288,7 +288,7 @@ describe('UnknownObjectSchema', () => {
   })
 
   describe('rejects invalid nested values', () => {
-    const schema = new UnknownObjectSchema()
+    const schema = unknownObject()
 
     it('rejects deeply nested invalid values', () => {
       const result = schema.safeParse({
@@ -335,7 +335,7 @@ describe('UnknownObjectSchema', () => {
   })
 
   describe('edge cases', () => {
-    const schema = new UnknownObjectSchema()
+    const schema = unknownObject()
 
     it('accepts objects with numeric string keys', () => {
       const obj = { '0': 'zero', '1': 'one', '2': 'two' }
@@ -500,7 +500,7 @@ describe('UnknownObjectSchema', () => {
   })
 
   describe('large objects', () => {
-    const schema = new UnknownObjectSchema()
+    const schema = unknownObject()
 
     it('accepts objects with many keys', () => {
       const obj: Record<string, number> = {}
@@ -538,7 +538,7 @@ describe('UnknownObjectSchema', () => {
   })
 
   describe('preservation of input', () => {
-    const schema = new UnknownObjectSchema()
+    const schema = unknownObject()
 
     it('preserves the original object reference', () => {
       const input = { key: 'value', count: 42 }

package/src/schema/unknown-object.ts

@@ -1,13 +1,11 @@
 import { LexMap, isLexMap } from '@atproto/lex-data'
-import { Schema, ValidationResult, ValidatorContext } from '../core.js'
+import { Schema, ValidationContext } from '../core.js'
+import { memoizedOptions } from '../util/memoize.js'
 
-export type UnknownObjectOutput = LexMap
+export type UnknownObject = LexMap
 
-export class UnknownObjectSchema extends Schema<UnknownObjectOutput> {
-  validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<UnknownObjectOutput> {
+export class UnknownObjectSchema extends Schema<UnknownObject> {
+  validateInContext(input: unknown, ctx: ValidationContext) {
     if (isLexMap(input)) {
       return ctx.success(input)
     }
@@ -15,3 +13,7 @@ export class UnknownObjectSchema extends Schema<UnknownObjectOutput> {
     return ctx.issueInvalidType(input, 'unknown')
   }
 }
+
+export const unknownObject = /*#__PURE__*/ memoizedOptions(function () {
+  return new UnknownObjectSchema()
+})