@atproto/lex-schema 0.1.5 → 0.1.6

package/src/schema/cid.test.ts

@@ -1,125 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { parseCid } from '@atproto/lex-data'
-import { cid } from './cid.js'
-
-const cborCid = parseCid(
-  'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
-  { flavor: 'cbor' },
-)
-
-const rawCid = parseCid(
-  'bafkreifjjcie6lypi6ny7amxnfftagclbuxndqonfipmb64f2km2devei4',
-  { flavor: 'raw' },
-)
-
-const v0Cid = parseCid('QmPZ9gcCEpqKTo6aq61g2nXGUhM4iCL3ewB6LDXZCtioEB')
-
-// Using git-raw codec (0x78) instead of DAG-CBOR or raw binary
-const gitRawCid = parseCid(
-  'bafybeigvgzoolc3drupxhlevdp2ugqcrbcsqfmcek2zxiw5wctk3xjpjwy',
-)
-
-// Using SHA-512 (0x13) instead of SHA-256
-const sha512Cid = parseCid(
-  'bafybgqfcn3rz4mdzywp2jb6mjvpdq24rxjvbmdcmizrjdgx2ujjpvj4kxf4d62ywrzm6njk44cxhha4pj3bkvqz2esfgrm7mdkdcqcxjibf7c',
-)
-
-describe('CidSchema', () => {
-  describe('default mode (non-strict)', () => {
-    const schema = cid({})
-
-    it('validates CID v1 with DAG-CBOR codec and SHA-256', () => {
-      const result = schema.safeParse(cborCid)
-      expect(result.success).toBe(true)
-    })
-
-    it('validates CID v1 with raw binary codec', () => {
-      const result = schema.safeParse(rawCid)
-      expect(result.success).toBe(true)
-    })
-
-    it('validates CID v0', () => {
-      const result = schema.safeParse(v0Cid)
-      expect(result.success).toBe(true)
-    })
-
-    it('rejects non-CID objects', () => {
-      const result = schema.safeParse({ not: 'a cid' })
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects strings', () => {
-      const result = schema.safeParse(cborCid.toString())
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects numbers', () => {
-      const result = schema.safeParse(123)
-      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 arrays', () => {
-      const result = schema.safeParse([])
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects booleans', () => {
-      const result = schema.safeParse(true)
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('strict mode', () => {
-    const schema = cid({ flavor: 'dasl' })
-
-    it('validates CID v1 with DAG-CBOR codec and SHA-256', () => {
-      const result = schema.safeParse(cborCid)
-      expect(result.success).toBe(true)
-    })
-
-    it('validates CID v1 with raw binary codec and SHA-256', () => {
-      const result = schema.safeParse(rawCid)
-      expect(result.success).toBe(true)
-    })
-
-    it('rejects CID v0', () => {
-      const result = schema.safeParse(v0Cid)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects CID v1 with non-standard codec', () => {
-      const result = schema.safeParse(gitRawCid)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects CID v1 with non-SHA-256 hash', () => {
-      const result = schema.safeParse(sha512Cid)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects non-CID objects', () => {
-      const result = schema.safeParse({ not: 'a cid' })
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects strings', () => {
-      const result = schema.safeParse(cborCid.toString())
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects null', () => {
-      const result = schema.safeParse(null)
-      expect(result.success).toBe(false)
-    })
-  })
-})

package/src/schema/cid.ts

@@ -1,69 +0,0 @@
-import { CheckCidOptions, Cid, InferCheckedCid, isCid } from '@atproto/lex-data'
-import { Schema, ValidationContext } from '../core.js'
-import { memoizedOptions } from '../util/memoize.js'
-
-export type { Cid }
-
-/**
- * Configuration options for CID schema validation.
- *
- * @see CheckCidOptions from @atproto/lex-data for available options
- */
-export type CidSchemaOptions = CheckCidOptions
-
-/**
- * Schema for validating Content Identifiers (CIDs).
- *
- * CIDs are self-describing content-addressed identifiers used in AT Protocol
- * to reference data by its cryptographic hash. This schema validates that
- * the input is a valid CID object.
- *
- * @template TOptions - The configuration options type
- *
- * @example
- * ```ts
- * const schema = new CidSchema()
- * const result = schema.validate(someCid)
- * ```
- */
-export class CidSchema<
-  const TOptions extends CidSchemaOptions = { flavor: undefined },
-> extends Schema<InferCheckedCid<TOptions>> {
-  readonly type = 'cid' as const
-
-  constructor(readonly options?: TOptions) {
-    super()
-  }
-
-  validateInContext(input: unknown, ctx: ValidationContext) {
-    if (!isCid(input, this.options)) {
-      return ctx.issueUnexpectedType(input, 'cid')
-    }
-
-    return ctx.success(input)
-  }
-}
-
-/**
- * Creates a CID schema for validating Content Identifiers.
- *
- * CIDs are used throughout AT Protocol to reference content by its hash.
- * This is commonly used for referencing blobs, commits, and other data.
- *
- * @param options - Optional configuration for CID validation
- * @returns A new {@link CidSchema} instance
- *
- * @example
- * ```ts
- * // Basic CID validation
- * const cidSchema = l.cid()
- *
- * // Validate a CID from a blob reference
- * const result = cidSchema.validate(blobRef.ref)
- * ```
- */
-export const cid = /*#__PURE__*/ memoizedOptions(function <
-  O extends CidSchemaOptions = NonNullable<unknown>,
->(options?: O) {
-  return new CidSchema(options)
-})

package/src/schema/custom.test.ts

@@ -1,414 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import { IssueCustom } from '../core.js'
-import { custom } from './custom.js'
-
-describe('CustomSchema', () => {
-  describe('basic validation', () => {
-    it('validates input that passes custom assertion', () => {
-      const schema = custom(
-        (input): input is string => typeof input === 'string',
-        'Must be a string',
-      )
-      const result = schema.safeParse('hello')
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe('hello')
-      }
-    })
-
-    it('rejects input that fails custom assertion', () => {
-      const schema = custom(
-        (input): input is string => typeof input === 'string',
-        'Must be a string',
-      )
-      const result = schema.safeParse(123)
-      expect(result.success).toBe(false)
-    })
-
-    it('includes custom message in error', () => {
-      const schema = custom(
-        (input): input is string => typeof input === 'string',
-        'Custom error message',
-      )
-      const result = schema.safeParse(123)
-      expect(result.success).toBe(false)
-      if (!result.success) {
-        expect(result.reason.message).toContain('Custom error message')
-      }
-    })
-  })
-
-  describe('complex type guards', () => {
-    it('validates objects with specific properties', () => {
-      interface User {
-        name: string
-        age: number
-      }
-
-      const schema = custom((input): input is User => {
-        return (
-          typeof input === 'object' &&
-          input !== null &&
-          'name' in input &&
-          'age' in input &&
-          typeof (input as any).name === 'string' &&
-          typeof (input as any).age === 'number'
-        )
-      }, 'Must be a valid User object')
-
-      expect(schema.matches({ name: 'Alice', age: 30 })).toBe(true)
-    })
-
-    it('rejects objects missing required properties', () => {
-      interface User {
-        name: string
-        age: number
-      }
-
-      const schema = custom((input): input is User => {
-        return (
-          typeof input === 'object' &&
-          input !== null &&
-          'name' in input &&
-          'age' in input &&
-          typeof (input as any).name === 'string' &&
-          typeof (input as any).age === 'number'
-        )
-      }, 'Must be a valid User object')
-
-      expect(schema.matches({ name: 'Alice' })).toBe(false)
-    })
-
-    it('validates arrays with specific element types', () => {
-      const schema = custom((input): input is number[] => {
-        return (
-          Array.isArray(input) &&
-          input.every((item) => typeof item === 'number')
-        )
-      }, 'Must be an array of numbers')
-
-      const result = schema.safeParse([1, 2, 3, 4])
-      expect(result.success).toBe(true)
-    })
-
-    it('rejects arrays with mixed types', () => {
-      const schema = custom((input): input is number[] => {
-        return (
-          Array.isArray(input) &&
-          input.every((item) => typeof item === 'number')
-        )
-      }, 'Must be an array of numbers')
-
-      const result = schema.safeParse([1, 'two', 3])
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('custom context usage', () => {
-    it('can add custom issues through context', () => {
-      const schema = custom((input, ctx): input is string => {
-        if (typeof input !== 'string') {
-          ctx.addIssue({
-            code: 'invalid_type',
-            path: ctx.path,
-            input,
-            expected: ['string'],
-          } as any)
-          return false
-        }
-        return true
-      }, 'Must be a string')
-
-      const result = schema.safeParse(123)
-      expect(result.success).toBe(false)
-    })
-
-    it('accesses path from context', () => {
-      let capturedPath: any[] = []
-      const schema = custom((input, ctx): input is string => {
-        capturedPath = [...ctx.path]
-        return typeof input === 'string'
-      }, 'Must be a string')
-
-      schema.safeParse('test')
-      expect(capturedPath).toEqual([])
-    })
-
-    it('validates with custom path', () => {
-      const schema = custom(
-        (input): input is string => typeof input === 'string',
-        'Must be a string',
-        'customField',
-      )
-
-      const result = schema.safeParse(123)
-      expect(result.success).toBe(false)
-      if (!result.success) {
-        expect(result.reason.message).toContain('customField')
-      }
-    })
-
-    it('validates with array of paths', () => {
-      const schema = custom(
-        (input): input is string => typeof input === 'string',
-        'Must be a string',
-        ['nested', 'field'],
-      )
-
-      const result = schema.safeParse(123)
-      expect(result.success).toBe(false)
-      if (!result.success) {
-        expect(result.reason.message).toContain('nested')
-        expect(result.reason.message).toContain('field')
-      }
-    })
-  })
-
-  describe('business logic validation', () => {
-    it('validates email format', () => {
-      const schema = custom((input): input is string => {
-        return (
-          typeof input === 'string' && /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(input)
-        )
-      }, 'Must be a valid email address')
-
-      const validResult = schema.safeParse('user@example.com')
-      expect(validResult.success).toBe(true)
-
-      const invalidResult = schema.safeParse('not-an-email')
-      expect(invalidResult.success).toBe(false)
-    })
-
-    it('validates password strength', () => {
-      const schema = custom((input): input is string => {
-        if (typeof input !== 'string') return false
-        return (
-          input.length >= 8 &&
-          /[A-Z]/.test(input) &&
-          /[a-z]/.test(input) &&
-          /[0-9]/.test(input)
-        )
-      }, 'Password must be at least 8 characters with uppercase, lowercase, and numbers')
-
-      const validResult = schema.safeParse('MyPass123')
-      expect(validResult.success).toBe(true)
-
-      const weakResult = schema.safeParse('weak')
-      expect(weakResult.success).toBe(false)
-    })
-
-    it('validates age range', () => {
-      const schema = custom((input): input is number => {
-        return typeof input === 'number' && input >= 18 && input <= 120
-      }, 'Age must be between 18 and 120')
-
-      const validResult = schema.safeParse(25)
-      expect(validResult.success).toBe(true)
-
-      const tooYoungResult = schema.safeParse(15)
-      expect(tooYoungResult.success).toBe(false)
-
-      const tooOldResult = schema.safeParse(150)
-      expect(tooOldResult.success).toBe(false)
-    })
-
-    it('validates positive numbers', () => {
-      const schema = custom((input): input is number => {
-        return typeof input === 'number' && input > 0
-      }, 'Must be a positive number')
-
-      const validResult = schema.safeParse(5)
-      expect(validResult.success).toBe(true)
-
-      const zeroResult = schema.safeParse(0)
-      expect(zeroResult.success).toBe(false)
-
-      const negativeResult = schema.safeParse(-5)
-      expect(negativeResult.success).toBe(false)
-    })
-  })
-
-  describe('edge cases', () => {
-    it('handles null input', () => {
-      const schema = custom(
-        (input): input is null => input === null,
-        'Must be null',
-      )
-
-      const validResult = schema.safeParse(null)
-      expect(validResult.success).toBe(true)
-
-      const invalidResult = schema.safeParse(undefined)
-      expect(invalidResult.success).toBe(false)
-    })
-
-    it('handles undefined input', () => {
-      const schema = custom(
-        (input): input is undefined => input === undefined,
-        'Must be undefined',
-      )
-
-      const validResult = schema.safeParse(undefined)
-      expect(validResult.success).toBe(true)
-
-      const invalidResult = schema.safeParse(null)
-      expect(invalidResult.success).toBe(false)
-    })
-
-    it('handles empty string', () => {
-      const schema = custom(
-        (input): input is string =>
-          typeof input === 'string' && input.length > 0,
-        'Must be a non-empty string',
-      )
-
-      const validResult = schema.safeParse('hello')
-      expect(validResult.success).toBe(true)
-
-      const invalidResult = schema.safeParse('')
-      expect(invalidResult.success).toBe(false)
-    })
-
-    it('handles empty array', () => {
-      const schema = custom(
-        (input): input is any[] => Array.isArray(input) && input.length > 0,
-        'Must be a non-empty array',
-      )
-
-      const validResult = schema.safeParse([1, 2, 3])
-      expect(validResult.success).toBe(true)
-
-      const invalidResult = schema.safeParse([])
-      expect(invalidResult.success).toBe(false)
-    })
-
-    it('handles complex nested structures', () => {
-      interface ComplexType {
-        users: Array<{ name: string; email: string }>
-        metadata: { count: number }
-      }
-
-      const schema = custom((input): input is ComplexType => {
-        if (typeof input !== 'object' || input === null) return false
-        const obj = input as any
-        return (
-          Array.isArray(obj.users) &&
-          obj.users.every(
-            (u: any) =>
-              typeof u === 'object' &&
-              typeof u.name === 'string' &&
-              typeof u.email === 'string',
-          ) &&
-          typeof obj.metadata === 'object' &&
-          typeof obj.metadata.count === 'number'
-        )
-      }, 'Must be a valid complex structure')
-
-      const validResult = schema.safeParse({
-        users: [
-          { name: 'Alice', email: 'alice@example.com' },
-          { name: 'Bob', email: 'bob@example.com' },
-        ],
-        metadata: { count: 2 },
-      })
-      expect(validResult.success).toBe(true)
-
-      const invalidResult = schema.safeParse({
-        users: [{ name: 'Alice' }], // missing email
-        metadata: { count: 1 },
-      })
-      expect(invalidResult.success).toBe(false)
-    })
-  })
-
-  describe('type narrowing', () => {
-    it('correctly narrows union types', () => {
-      type StringOrNumber = string | number
-
-      const schema = custom(
-        (input): input is string => typeof input === 'string',
-        'Must be a string',
-      )
-
-      const input: StringOrNumber = 'hello'
-
-      const result = schema.safeParse(input)
-      expect(result.success).toBe(true)
-
-      if (result.success) {
-        // Type should be narrowed to string
-        const value: string = result.value
-        expect(typeof value).toBe('string')
-      }
-    })
-
-    it('validates discriminated unions', () => {
-      type Shape =
-        | { type: 'circle'; radius: number }
-        | { type: 'rectangle'; width: number; height: number }
-
-      const circleSchema = custom((input): input is Shape => {
-        return (
-          typeof input === 'object' &&
-          input !== null &&
-          'type' in input &&
-          (input as any).type === 'circle' &&
-          'radius' in input &&
-          typeof (input as any).radius === 'number'
-        )
-      }, 'Must be a valid circle')
-
-      const validResult = circleSchema.safeParse({ type: 'circle', radius: 5 })
-      expect(validResult.success).toBe(true)
-
-      const invalidResult = circleSchema.safeParse({
-        type: 'rectangle',
-        width: 10,
-        height: 20,
-      })
-      expect(invalidResult.success).toBe(false)
-    })
-  })
-
-  describe('assertion context behavior', () => {
-    it('calls assertion with null as this', () => {
-      const assertion = vi.fn(function (
-        this: unknown,
-        input: unknown,
-      ): input is string {
-        expect(this).toBeNull()
-        return typeof input === 'string'
-      })
-
-      custom(assertion as any, 'Must be a string').safeParse('test')
-
-      expect(assertion).toHaveBeenCalledTimes(1)
-    })
-
-    it('provides addIssue method in context', () => {
-      const schema = custom((input, ctx): input is string => {
-        ctx.addIssue(new IssueCustom(ctx.path, input, 'This is a custom issue'))
-        return false
-      }, 'Must be a string')
-
-      expect(schema.safeParse('test')).toMatchObject({
-        success: false,
-        reason: {
-          issues: [
-            { message: 'This is a custom issue' },
-            { message: 'Must be a string' },
-          ],
-        },
-      })
-    })
-
-    it('provides path array in context', () => {
-      const schema = custom((input, ctx): input is string => {
-        expect(Array.isArray(ctx.path)).toBe(true)
-        return typeof input === 'string'
-      }, 'Must be a string')
-
-      schema.safeParse('test')
-    })
-  })
-})

package/src/schema/custom.ts

@@ -1,106 +0,0 @@
-import { Issue, IssueCustom, Schema, ValidationContext } from '../core.js'
-
-/**
- * Context object provided to custom assertion functions.
- *
- * @property path - Current validation path as an array of property keys
- * @property addIssue - Function to add additional validation issues
- */
-export type CustomAssertionContext = {
-  path: PropertyKey[]
-  addIssue(issue: Issue): void
-}
-
-/**
- * Type guard function for custom schema validation.
- *
- * @template TValue - The type to validate/narrow to
- */
-export type CustomAssertion<TValue> = (
-  this: null,
-  input: unknown,
-  ctx: CustomAssertionContext,
-) => input is TValue
-
-/**
- * Schema with a custom validation function.
- *
- * Allows defining completely custom validation logic using a type guard
- * assertion function. The function receives the input and validation context,
- * and must return whether the input is valid.
- *
- * @template TValue - The validated output type
- *
- * @example
- * ```ts
- * const schema = new CustomSchema(
- *   (input): input is Date => input instanceof Date,
- *   'Expected a Date instance'
- * )
- * ```
- */
-export class CustomSchema<out TValue = unknown> extends Schema<TValue> {
-  readonly type = 'custom' as const
-
-  constructor(
-    private readonly assertion: CustomAssertion<TValue>,
-    private readonly message: string,
-    private readonly path?: PropertyKey | readonly PropertyKey[],
-  ) {
-    super()
-  }
-
-  validateInContext(input: unknown, ctx: ValidationContext) {
-    if (!this.assertion.call(null, input, ctx)) {
-      const path = ctx.concatPath(this.path)
-      return ctx.issue(new IssueCustom(path, input, this.message))
-    }
-    return ctx.success(input as TValue)
-  }
-}
-
-/**
- * Creates a custom schema with a user-defined validation function.
- *
- * Use this when the built-in schemas don't cover your validation needs.
- * The assertion function must be a type guard that narrows the input type.
- *
- * @param assertion - Type guard function that validates the input
- * @param message - Error message when validation fails
- * @param path - Optional path to associate with validation errors
- * @returns A new {@link CustomSchema} instance
- *
- * @example
- * ```ts
- * // Validate Date instances
- * const dateSchema = l.custom(
- *   (input): input is Date => input instanceof Date && !isNaN(input.getTime()),
- *   'Expected a valid Date'
- * )
- *
- * // Validate specific object shape
- * const pointSchema = l.custom(
- *   (input): input is { x: number; y: number } =>
- *     typeof input === 'object' &&
- *     input !== null &&
- *     typeof (input as any).x === 'number' &&
- *     typeof (input as any).y === 'number',
- *   'Expected a point with x and y coordinates'
- * )
- *
- * // With custom path
- * const validConfig = l.custom(
- *   (input): input is Config => validateConfig(input),
- *   'Invalid configuration',
- *   ['config']
- * )
- * ```
- */
-/*@__NO_SIDE_EFFECTS__*/
-export function custom<TValue>(
-  assertion: CustomAssertion<TValue>,
-  message: string,
-  path?: PropertyKey | readonly PropertyKey[],
-) {
-  return new CustomSchema<TValue>(assertion, message, path)
-}