@atproto/lex-schema 0.1.5 → 0.1.6

package/src/schema/blob.ts

@@ -1,150 +0,0 @@
-import {
-  BlobRef,
-  LegacyBlobRef,
-  TypedBlobRef,
-  getBlobSize,
-  isBlobRef,
-  isLegacyBlobRef,
-  isTypedBlobRef,
-} from '@atproto/lex-data'
-import { Schema, ValidationContext } from '../core.js'
-import { memoizedOptions } from '../util/memoize.js'
-
-/**
- * Configuration options for blob schema validation.
- */
-export type BlobSchemaOptions = {
-  /**
-   * List of accepted MIME types (supports wildcards like 'image/*' or '*\/*')
-   *
-   * @default undefined // accepts all MIME types
-   */
-  accept?: string[]
-
-  /**
-   * Maximum blob size in bytes
-   *
-   * @default undefined // no size limit
-   */
-  maxSize?: number
-}
-
-export type { BlobRef, LegacyBlobRef, TypedBlobRef }
-export { isBlobRef, isLegacyBlobRef, isTypedBlobRef }
-
-/**
- * Schema for validating blob references in AT Protocol.
- *
- * Validates BlobRef objects which contain a CID reference to binary data,
- * along with metadata like MIME type and size. Can optionally accept
- * legacy blob reference format.
- *
- * @template TOptions - The configuration options type
- *
- * @example
- * ```ts
- * const schema = new BlobSchema({ accept: ['image/*'], maxSize: 1000000 })
- * const result = schema.validate(blobRef)
- * ```
- */
-export class BlobSchema<
-  const TOptions extends BlobSchemaOptions = NonNullable<unknown>,
-> extends Schema<BlobRef> {
-  readonly type = 'blob' as const
-
-  constructor(readonly options?: TOptions) {
-    super()
-  }
-
-  validateInContext(input: unknown, ctx: ValidationContext) {
-    const blob = parseValue.call(ctx, input)
-    if (!blob) {
-      return ctx.issueUnexpectedType(input, 'blob')
-    }
-
-    // In non-strict mode, we allow blob refs to pass through without MIME
-    // type or size checks.
-    if (ctx.options.strict && this.options != null) {
-      const { accept } = this.options
-      if (accept && !matchesMime(blob.mimeType, accept)) {
-        return ctx.issueInvalidPropertyValue(blob, 'mimeType', accept)
-      }
-
-      const { maxSize } = this.options
-      if (maxSize != null) {
-        const size = getBlobSize(blob)
-        if (size === undefined) {
-          // Unable to enforce size constraint if size is not available (legacy
-          // blob ref), so we treat it as a validation failure in strict mode.
-          return ctx.issueInvalidPropertyType(blob, 'size' as any, 'integer')
-        } else if (size > maxSize) {
-          return ctx.issueTooBig(blob, 'blob', maxSize, size)
-        }
-      }
-    }
-
-    return ctx.success(blob)
-  }
-
-  matchesMime(mime: string): boolean {
-    const accept = this.options?.accept
-    if (!accept) return true
-    return matchesMime(mime, accept)
-  }
-}
-
-function parseValue(this: ValidationContext, input: unknown): BlobRef | null {
-  // If there is a $type property, we treat if as a potential TypedBlobRef and
-  // validate accordingly.
-  if ((input as any)?.$type !== undefined) {
-    // Use the context's option for the "strict" check
-    return isTypedBlobRef(input, this.options) ? input : null
-  }
-
-  // If there is no $type property, we may be dealing with a legacy blob ref. If
-  // legacy refs are allowed (non-strict mode), we check if the input matches
-  // the legacy format.
-  if (!this.options.strict) {
-    if (isLegacyBlobRef(input, this.options)) return input
-  }
-
-  return null
-}
-
-function matchesMime(mime: string, accepted: string[]): boolean {
-  if (accepted.includes('*/*')) return true
-  if (accepted.includes(mime)) return true
-  for (const value of accepted) {
-    if (value.endsWith('/*') && mime.startsWith(value.slice(0, -1))) {
-      return true
-    }
-  }
-  return false
-}
-
-/**
- * Creates a blob schema for validating blob references with optional constraints.
- *
- * Blob references are used in AT Protocol to reference binary data stored
- * separately from records. They contain a CID, MIME type, and size information.
- *
- * @param options - Optional configuration for MIME type filtering and size limits
- * @returns A new {@link BlobSchema} instance
- *
- * @example
- * ```ts
- * // Basic blob reference
- * const fileSchema = l.blob()
- *
- * // Image files only
- * const imageSchema = l.blob({ accept: ['image/png', 'image/jpeg', 'image/gif'] })
- *
- * // Any image type with size limit
- * const avatarSchema = l.blob({ accept: ['image/*'], maxSize: 1000000 })
- * ```
- */
-export const blob = /*#__PURE__*/ memoizedOptions(function <
-  O extends BlobSchemaOptions = NonNullable<unknown>,
->(options?: O) {
-  return new BlobSchema(options)
-})

package/src/schema/boolean.test.ts

@@ -1,118 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { boolean } from './boolean.js'
-import { withDefault } from './with-default.js'
-
-describe('BooleanSchema', () => {
-  describe('basic validation', () => {
-    const schema = boolean()
-
-    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('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)
-    })
-
-    it('rejects undefined', () => {
-      const result = schema.safeParse(undefined)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects objects', () => {
-      const result = schema.safeParse({})
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects arrays', () => {
-      const result = schema.safeParse([])
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('with default value', () => {
-    it('uses default value of true when input is undefined', () => {
-      const schema = withDefault(boolean(), true)
-      const result = schema.safeParse(undefined)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(true)
-      }
-    })
-
-    it('uses default value of false when input is undefined', () => {
-      const schema = withDefault(boolean(), false)
-      const result = schema.safeParse(undefined)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(false)
-      }
-    })
-
-    it('overrides default value with explicit true', () => {
-      const schema = withDefault(boolean(), false)
-      const result = schema.safeParse(true)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(true)
-      }
-    })
-
-    it('overrides default value with explicit false', () => {
-      const schema = withDefault(boolean(), true)
-      const result = schema.safeParse(false)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(false)
-      }
-    })
-
-    it('rejects invalid types even with default', () => {
-      const schema = withDefault(boolean(), true)
-      const result = schema.safeParse('not a boolean')
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('edge cases', () => {
-    const schema = boolean()
-
-    it('rejects Boolean object', () => {
-      const result = schema.safeParse(new Boolean(true))
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects truthy values', () => {
-      const result = schema.safeParse('truthy')
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects falsy values', () => {
-      const result = schema.safeParse(0)
-      expect(result.success).toBe(false)
-    })
-  })
-})

package/src/schema/boolean.ts

@@ -1,46 +0,0 @@
-import { Schema, ValidationContext } from '../core.js'
-import { memoizedOptions } from '../util/memoize.js'
-
-/**
- * Schema for validating boolean values.
- *
- * Only accepts JavaScript `true` or `false` values. Does not perform
- * any coercion from strings or numbers.
- *
- * @example
- * ```ts
- * const schema = new BooleanSchema()
- * schema.validate(true)  // success
- * schema.validate(false) // success
- * schema.validate('true') // fails - no string coercion
- * ```
- */
-export class BooleanSchema extends Schema<boolean> {
-  readonly type = 'boolean' as const
-
-  validateInContext(input: unknown, ctx: ValidationContext) {
-    if (typeof input === 'boolean') {
-      return ctx.success(input)
-    }
-
-    return ctx.issueUnexpectedType(input, 'boolean')
-  }
-}
-
-/**
- * Creates a boolean schema that validates true/false values.
- *
- * @returns A new {@link BooleanSchema} instance
- *
- * @example
- * ```ts
- * const enabledSchema = l.boolean()
- *
- * enabledSchema.parse(true)   // true
- * enabledSchema.parse(false)  // false
- * enabledSchema.parse('true') // throws - strings not accepted
- * ```
- */
-export const boolean = /*#__PURE__*/ memoizedOptions(function () {
-  return new BooleanSchema()
-})

package/src/schema/bytes.test.ts

@@ -1,227 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { bytes } from './bytes.js'
-
-describe('BytesSchema', () => {
-  describe('basic validation', () => {
-    const schema = bytes({})
-
-    it('validates Uint8Array', () => {
-      const result = schema.safeParse(new Uint8Array([0, 1, 2, 3]))
-      expect(result.success).toBe(true)
-    })
-
-    it('validates empty Uint8Array', () => {
-      const result = schema.safeParse(new Uint8Array([]))
-      expect(result.success).toBe(true)
-    })
-
-    it('validates ArrayBuffer', () => {
-      const buffer = new ArrayBuffer(4)
-      const result = schema.safeParse(buffer)
-      expect(result.success).toBe(true)
-    })
-
-    it('validates TypedArray views', () => {
-      const int8 = new Int8Array([1, 2, 3])
-      const result = schema.safeParse(int8)
-      expect(result.success).toBe(true)
-    })
-
-    it('validates Uint16Array', () => {
-      const uint16 = new Uint16Array([1, 2, 3])
-      const result = schema.safeParse(uint16)
-      expect(result.success).toBe(true)
-    })
-
-    it('validates DataView', () => {
-      const buffer = new ArrayBuffer(4)
-      const dataView = new DataView(buffer)
-      const result = schema.safeParse(dataView)
-      expect(result.success).toBe(true)
-    })
-
-    it('rejects strings', () => {
-      const result = schema.safeParse('not bytes')
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects numbers', () => {
-      const result = schema.safeParse(123)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects objects', () => {
-      const result = schema.safeParse({ data: [1, 2, 3] })
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects arrays', () => {
-      const result = schema.safeParse([1, 2, 3])
-      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)
-    })
-  })
-
-  describe('minLength constraint', () => {
-    const schema = bytes({ minLength: 3 })
-
-    it('validates bytes at minimum length', () => {
-      const result = schema.safeParse(new Uint8Array([0, 1, 2]))
-      expect(result.success).toBe(true)
-    })
-
-    it('validates bytes above minimum length', () => {
-      const result = schema.safeParse(new Uint8Array([0, 1, 2, 3, 4]))
-      expect(result.success).toBe(true)
-    })
-
-    it('rejects bytes below minimum length', () => {
-      const result = schema.safeParse(new Uint8Array([0, 1]))
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects empty bytes when minLength is set', () => {
-      const result = schema.safeParse(new Uint8Array([]))
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('maxLength constraint', () => {
-    const schema = bytes({ maxLength: 5 })
-
-    it('validates bytes at maximum length', () => {
-      const result = schema.safeParse(new Uint8Array([0, 1, 2, 3, 4]))
-      expect(result.success).toBe(true)
-    })
-
-    it('validates bytes below maximum length', () => {
-      const result = schema.safeParse(new Uint8Array([0, 1, 2]))
-      expect(result.success).toBe(true)
-    })
-
-    it('validates empty bytes when only maxLength is set', () => {
-      const result = schema.safeParse(new Uint8Array([]))
-      expect(result.success).toBe(true)
-    })
-
-    it('rejects bytes above maximum length', () => {
-      const result = schema.safeParse(new Uint8Array([0, 1, 2, 3, 4, 5]))
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('minLength and maxLength constraints', () => {
-    const schema = bytes({ minLength: 2, maxLength: 5 })
-
-    it('validates bytes within range', () => {
-      const result = schema.safeParse(new Uint8Array([0, 1, 2]))
-      expect(result.success).toBe(true)
-    })
-
-    it('validates bytes at minimum length', () => {
-      const result = schema.safeParse(new Uint8Array([0, 1]))
-      expect(result.success).toBe(true)
-    })
-
-    it('validates bytes at maximum length', () => {
-      const result = schema.safeParse(new Uint8Array([0, 1, 2, 3, 4]))
-      expect(result.success).toBe(true)
-    })
-
-    it('rejects bytes below minimum length', () => {
-      const result = schema.safeParse(new Uint8Array([0]))
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects bytes above maximum length', () => {
-      const result = schema.safeParse(new Uint8Array([0, 1, 2, 3, 4, 5]))
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('edge cases', () => {
-    it('validates with minLength of 0', () => {
-      const schema = bytes({ minLength: 0 })
-      const result = schema.safeParse(new Uint8Array([]))
-      expect(result.success).toBe(true)
-    })
-
-    it('validates with maxLength of 0', () => {
-      const schema = bytes({ maxLength: 0 })
-      const result = schema.safeParse(new Uint8Array([]))
-      expect(result.success).toBe(true)
-    })
-
-    it('rejects non-empty bytes with maxLength of 0', () => {
-      const schema = bytes({ maxLength: 0 })
-      const result = schema.safeParse(new Uint8Array([0]))
-      expect(result.success).toBe(false)
-    })
-
-    it('validates bytes with all zeros', () => {
-      const schema = bytes({})
-      const result = schema.safeParse(new Uint8Array([0, 0, 0, 0]))
-      expect(result.success).toBe(true)
-    })
-
-    it('validates bytes with all 255s', () => {
-      const schema = bytes({})
-      const result = schema.safeParse(new Uint8Array([255, 255, 255, 255]))
-      expect(result.success).toBe(true)
-    })
-
-    it('validates large byte arrays', () => {
-      const schema = bytes({})
-      const largeArray = new Uint8Array(10000)
-      const result = schema.safeParse(largeArray)
-      expect(result.success).toBe(true)
-    })
-  })
-
-  describe('TypedArray coercion', () => {
-    const schema = bytes({})
-
-    it('coerces Int8Array to Uint8Array', () => {
-      const int8 = new Int8Array([1, 2, 3])
-      const result = schema.safeParse(int8)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBeInstanceOf(Uint8Array)
-      }
-    })
-
-    it('coerces Uint16Array to Uint8Array', () => {
-      const uint16 = new Uint16Array([256, 512])
-      const result = schema.safeParse(uint16)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBeInstanceOf(Uint8Array)
-      }
-    })
-
-    it('coerces Float32Array to Uint8Array', () => {
-      const float32 = new Float32Array([1.5, 2.5])
-      const result = schema.safeParse(float32)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBeInstanceOf(Uint8Array)
-      }
-    })
-
-    it('validates coerced TypedArray with length constraints', () => {
-      const schema = bytes({ minLength: 2, maxLength: 10 })
-      const int16 = new Int16Array([1, 2, 3]) // 6 bytes
-      const result = schema.safeParse(int16)
-      expect(result.success).toBe(true)
-    })
-  })
-})

package/src/schema/bytes.ts

@@ -1,81 +0,0 @@
-import { asUint8Array, ifUint8Array } from '@atproto/lex-data'
-import { Schema, ValidationContext } from '../core.js'
-import { memoizedOptions } from '../util/memoize.js'
-
-/**
- * Configuration options for bytes schema validation.
- *
- * @property minLength - Minimum length in bytes
- * @property maxLength - Maximum length in bytes
- */
-export type BytesSchemaOptions = {
-  minLength?: number
-  maxLength?: number
-}
-
-/**
- * Schema for validating binary data as Uint8Array with optional length constraints.
- *
- * In "parse" mode, coerces various binary formats (Buffer, ArrayBuffer, etc.)
- * into Uint8Array. In "validate" mode, only accepts Uint8Array directly.
- *
- * @example
- * ```ts
- * const schema = new BytesSchema({ maxLength: 1024 })
- * const result = schema.validate(new Uint8Array([1, 2, 3]))
- * ```
- */
-export class BytesSchema extends Schema<Uint8Array> {
-  readonly type = 'bytes' as const
-
-  constructor(readonly options: BytesSchemaOptions = {}) {
-    super()
-  }
-
-  validateInContext(input: unknown, ctx: ValidationContext) {
-    // In "parse" mode, coerce different binary formats into Uint8Array
-    const bytes =
-      ctx.options.mode === 'parse' ? asUint8Array(input) : ifUint8Array(input)
-    if (!bytes) {
-      return ctx.issueUnexpectedType(input, 'bytes')
-    }
-
-    const { minLength } = this.options
-    if (minLength != null && bytes.length < minLength) {
-      return ctx.issueTooSmall(bytes, 'bytes', minLength, bytes.length)
-    }
-
-    const { maxLength } = this.options
-    if (maxLength != null && bytes.length > maxLength) {
-      return ctx.issueTooBig(bytes, 'bytes', maxLength, bytes.length)
-    }
-
-    return ctx.success(bytes)
-  }
-}
-
-/**
- * Creates a bytes schema for validating binary data with optional length constraints.
- *
- * Validates Uint8Array values and can coerce other binary formats in parse mode.
- *
- * @param options - Optional configuration for minimum and maximum byte length
- * @returns A new {@link BytesSchema} instance
- *
- * @example
- * ```ts
- * // Basic bytes schema
- * const dataSchema = l.bytes()
- *
- * // With size constraints
- * const avatarSchema = l.bytes({ maxLength: 1000000 }) // 1MB max
- *
- * // With minimum size
- * const hashSchema = l.bytes({ minLength: 32, maxLength: 32 }) // Exactly 32 bytes
- * ```
- */
-export const bytes = /*#__PURE__*/ memoizedOptions(function (
-  options?: BytesSchemaOptions,
-) {
-  return new BytesSchema(options)
-})