@atproto/lex-schema 0.1.5 → 0.1.6

package/src/schema/typed-ref.ts

@@ -1,126 +0,0 @@
-import {
-  $Typed,
-  InferInput,
-  InferOutput,
-  Schema,
-  ValidationContext,
-  Validator,
-} from '../core.js'
-
-/**
- * Interface for validators that have a $type property.
- *
- * Used by typed objects and records to identify their type in unions.
- *
- * @template TInput - The input type (with optional $type)
- * @template TOutput - The output type (with non-optional $type)
- */
-export interface TypedObjectValidator<
-  TInput extends { $type?: string } = { $type?: string },
-  TOutput extends TInput = TInput,
-> extends Validator<TInput, TOutput> {
-  $type: NonNullable<TOutput['$type']>
-}
-
-/**
- * Function type that returns a typed object validator, used for lazy resolution.
- *
- * @template TValidator - The typed object validator type
- */
-export type TypedRefGetter<out TValidator extends TypedObjectValidator> =
-  () => TValidator
-
-/**
- * Schema for referencing typed objects with lazy resolution.
- *
- * Used in typed unions to reference typed object schemas. Requires the
- * `$type` field to be present and match the referenced schema's type.
- * The referenced schema is resolved lazily to support circular references.
- *
- * @template TValidator - The referenced typed object validator type
- *
- * @example
- * ```ts
- * const ref = new TypedRefSchema(() => imageViewSchema)
- * // ref.$type === 'app.bsky.embed.images#view'
- * ```
- */
-export class TypedRefSchema<
-  const TValidator extends TypedObjectValidator = TypedObjectValidator,
-> extends Schema<
-  $Typed<InferInput<TValidator>>,
-  $Typed<InferOutput<TValidator>>
-> {
-  readonly type = 'typedRef' as const
-
-  #getter: TypedRefGetter<TValidator>
-
-  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.
-
-    super()
-
-    this.#getter = getter
-  }
-
-  get validator(): TValidator {
-    return this.#getter.call(null)
-  }
-
-  get $type(): TValidator['$type'] {
-    return this.validator.$type
-  }
-
-  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
-  }
-}
-
-/**
- * Creates a reference to a typed object schema for use in typed unions.
- *
- * Unlike regular `ref()`, this requires the referenced schema to have a
- * `$type` property, and validates that the input's `$type` matches.
- *
- * @param get - Function that returns the typed object validator
- * @returns A new {@link TypedRefSchema} instance
- *
- * @example
- * ```ts
- * // Reference to image embed view
- * const imageRef = l.typedRef(() => imageViewSchema)
- *
- * // Use in a typed union
- * const embedUnion = l.typedUnion([
- *   l.typedRef(() => imageViewSchema),
- *   l.typedRef(() => videoViewSchema),
- *   l.typedRef(() => externalViewSchema),
- * ], true) // closed union
- *
- * // The $type is accessible on the ref
- * console.log(imageRef.$type) // 'app.bsky.embed.images#view'
- * ```
- */
-/*@__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,355 +0,0 @@
-import { describe, expect, it } from 'vitest'
-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 = typedObject(
-    'app.bsky.actor.person',
-    'main',
-    object({
-      name: string(),
-      age: integer(),
-    }),
-  )
-
-  const postSchema = typedObject(
-    'app.bsky.feed.post',
-    'main',
-    object({
-      text: string(),
-      createdAt: string(),
-    }),
-  )
-
-  const commentSchema = typedObject(
-    'app.bsky.feed.comment',
-    'main',
-    object({
-      text: string(),
-      parentUri: string(),
-    }),
-  )
-
-  describe('closed union', () => {
-    const schema = typedUnion(
-      [typedRef(() => personSchema), typedRef(() => postSchema)],
-      true,
-    )
-
-    it('validates first type in union', () => {
-      const result = schema.safeParse({
-        $type: 'app.bsky.actor.person',
-        name: 'Alice',
-        age: 30,
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('validates second type in union', () => {
-      const result = schema.safeParse({
-        $type: 'app.bsky.feed.post',
-        text: 'Hello world',
-        createdAt: '2023-01-01T00:00:00Z',
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('rejects unknown $type in closed union', () => {
-      const result = schema.safeParse({
-        $type: 'app.bsky.feed.like',
-        subject: 'some-uri',
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects object without $type', () => {
-      const result = schema.safeParse({
-        name: 'Alice',
-        age: 30,
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects object with invalid property for the $type', () => {
-      const result = schema.safeParse({
-        $type: 'app.bsky.actor.person',
-        name: 'Alice',
-        age: 'thirty',
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects object missing required properties', () => {
-      const result = schema.safeParse({
-        $type: 'app.bsky.actor.person',
-        name: 'Alice',
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects non-object input', () => {
-      const result = schema.safeParse('not an object')
-      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 array', () => {
-      const result = schema.safeParse([])
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects number', () => {
-      const result = schema.safeParse(42)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects boolean', () => {
-      const result = schema.safeParse(true)
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('open union', () => {
-    const schema = typedUnion(
-      [typedRef(() => personSchema), typedRef(() => postSchema)],
-      false,
-    )
-
-    it('validates known type', () => {
-      const result = schema.safeParse({
-        $type: 'app.bsky.actor.person',
-        name: 'Alice',
-        age: 30,
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('validates unknown $type with valid structure', () => {
-      const result = schema.safeParse({
-        $type: 'app.bsky.feed.like',
-        subject: 'some-uri',
-        createdAt: '2023-01-01T00:00:00Z',
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('accepts any properties for unknown $type', () => {
-      const result = schema.safeParse({
-        $type: 'unknown.nsid.type',
-        anyProperty: 'any value',
-        anotherProperty: 123,
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('rejects unknown $type with non-string $type', () => {
-      const result = schema.safeParse({
-        $type: 123,
-        someProperty: 'value',
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects unknown $type with null $type', () => {
-      const result = schema.safeParse({
-        $type: null,
-        someProperty: 'value',
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects object without $type', () => {
-      const result = schema.safeParse({
-        name: 'Alice',
-        age: 30,
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects non-object input', () => {
-      const result = schema.safeParse('not an object')
-      expect(result.success).toBe(false)
-    })
-
-    it('validates known type with extra properties', () => {
-      const result = schema.safeParse({
-        $type: 'app.bsky.actor.person',
-        name: 'Alice',
-        age: 30,
-        extraProperty: 'extra',
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('rejects known type with invalid property types', () => {
-      const result = schema.safeParse({
-        $type: 'app.bsky.actor.person',
-        name: 123,
-        age: 30,
-      })
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('with three types', () => {
-    const schema = typedUnion(
-      [
-        typedRef(() => personSchema),
-        typedRef(() => postSchema),
-        typedRef(() => commentSchema),
-      ],
-      true,
-    )
-
-    it('validates first type', () => {
-      const result = schema.safeParse({
-        $type: 'app.bsky.actor.person',
-        name: 'Alice',
-        age: 30,
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('validates second type', () => {
-      const result = schema.safeParse({
-        $type: 'app.bsky.feed.post',
-        text: 'Hello',
-        createdAt: '2023-01-01T00:00:00Z',
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('validates third type', () => {
-      const result = schema.safeParse({
-        $type: 'app.bsky.feed.comment',
-        text: 'Nice post!',
-        parentUri: 'at://did:plc:xyz/app.bsky.feed.post/123',
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('rejects unknown type', () => {
-      const result = schema.safeParse({
-        $type: 'app.bsky.feed.like',
-        subject: 'some-uri',
-      })
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('with single type', () => {
-    const schema = typedUnion([typedRef(() => personSchema)], true)
-
-    it('validates the single type', () => {
-      const result = schema.safeParse({
-        $type: 'app.bsky.actor.person',
-        name: 'Alice',
-        age: 30,
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('rejects different type', () => {
-      const result = schema.safeParse({
-        $type: 'app.bsky.feed.post',
-        text: 'Hello',
-        createdAt: '2023-01-01T00:00:00Z',
-      })
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('$types getter', () => {
-    const schema = typedUnion(
-      [typedRef(() => personSchema), typedRef(() => postSchema)],
-      true,
-    )
-
-    it('returns array of valid $type values', () => {
-      const types = schema.$types
-      expect(types).toContain('app.bsky.actor.person')
-      expect(types).toContain('app.bsky.feed.post')
-      expect(types.length).toBe(2)
-    })
-  })
-
-  describe('refsMap getter', () => {
-    const schema = typedUnion(
-      [typedRef(() => personSchema), typedRef(() => postSchema)],
-      true,
-    )
-
-    it('returns map of $type to ref schema', () => {
-      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)
-    })
-  })
-
-  describe('edge cases', () => {
-    const schema = typedUnion(
-      [typedRef(() => personSchema), typedRef(() => postSchema)],
-      true,
-    )
-
-    it('rejects object with $type as empty string in closed union', () => {
-      const result = schema.safeParse({
-        $type: '',
-        name: 'Alice',
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('validates object with $type as empty string in open union', () => {
-      const openSchema = typedUnion([typedRef(() => personSchema)], false)
-      const result = openSchema.safeParse({
-        $type: '',
-        someProperty: 'value',
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('rejects plain object with only $type', () => {
-      const result = schema.safeParse({
-        $type: 'app.bsky.actor.person',
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('handles object with $type and undefined properties', () => {
-      const result = schema.safeParse({
-        $type: 'app.bsky.actor.person',
-        name: 'Alice',
-        age: 30,
-        extra: undefined,
-      })
-      expect(result.success).toBe(true)
-    })
-  })
-
-  describe('closed property', () => {
-    it('exposes closed property as true', () => {
-      const schema = typedUnion([typedRef(() => personSchema)], true)
-      expect(schema.closed).toBe(true)
-    })
-
-    it('exposes closed property as false', () => {
-      const schema = typedUnion([typedRef(() => personSchema)], false)
-      expect(schema.closed).toBe(false)
-    })
-  })
-})

package/src/schema/typed-union.ts

@@ -1,130 +0,0 @@
-import { isPlainObject } from '@atproto/lex-data'
-import {
-  InferInput,
-  InferOutput,
-  Schema,
-  Unknown$TypedObject,
-  ValidationContext,
-} from '../core.js'
-import { lazyProperty } from '../util/lazy-property.js'
-import { TypedObjectSchema } from './typed-object.js'
-import { TypedRefSchema } from './typed-ref.js'
-
-/**
- * Schema for Lexicon typed unions (unions discriminated by $type).
- *
- * Typed unions are collections of typed objects identified by their `$type`
- * field. Can be "open" (accept unknown types) or "closed" (only accept
- * known types).
- *
- * @template TValidators - Tuple of {@link TypedRefSchema} or {@link TypedObjectSchema} instances
- * @template TClosed - Whether the union is closed (rejects unknown $types)
- *
- * @example
- * ```ts
- * const embedUnion = new TypedUnionSchema([
- *   l.typedRef(() => imageSchema),
- *   l.typedRef(() => videoSchema),
- * ], true) // closed - only accepts images and videos
- * ```
- */
-export class TypedUnionSchema<
-  const TValidators extends readonly (
-    | TypedRefSchema
-    | TypedObjectSchema
-  )[] = [],
-  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
-> {
-  readonly type = 'typedUnion' as const
-
-  constructor(
-    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
-    // needed. The biggest issue with this strategy is that we can't throw
-    // early if the refs contain multiple refs with the same $type.
-
-    super()
-  }
-
-  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, 'validatorsMap', map)
-  }
-
-  get $types() {
-    return Array.from(this.validatorsMap.keys())
-  }
-
-  validateInContext(input: unknown, ctx: ValidationContext) {
-    if (!isPlainObject(input) || !('$type' in input)) {
-      return ctx.issueUnexpectedType(input, '$typed')
-    }
-
-    const { $type } = input
-
-    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)
-  }
-}
-
-/**
- * Creates a typed union schema for Lexicon unions.
- *
- * Typed unions discriminate variants by their `$type` field. Can be open
- * (accepts unknown types, useful for extensibility) or closed (strict).
- *
- * @param refs - Array of typed refs for the union variants
- * @param closed - Whether to reject unknown $type values
- * @returns A new {@link TypedUnionSchema} instance
- *
- * @example
- * ```ts
- * // Closed union - only accepts known types
- * const embedSchema = l.typedUnion([
- *   l.typedRef(() => imageViewSchema),
- *   l.typedRef(() => videoViewSchema),
- *   l.typedRef(() => externalViewSchema),
- * ], true)
- *
- * // Open union - accepts unknown types for forward compatibility
- * const feedItemSchema = l.typedUnion([
- *   l.typedRef(() => postSchema),
- *   l.typedRef(() => repostSchema),
- * ], false) // unknown types pass through
- *
- * // Get all known $types
- * console.log(embedSchema.$types)
- * // ['app.bsky.embed.images#view', 'app.bsky.embed.video#view', ...]
- * ```
- */
-/*@__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)
-}