@atproto/lex-schema 0.0.2 → 0.0.3

package/src/schema/unknown.test.ts

@@ -0,0 +1,312 @@
+import { UnknownSchema } from './unknown.js'
+
+describe('UnknownSchema', () => {
+  describe('basic validation', () => {
+    const schema = new UnknownSchema()
+
+    it('accepts strings', () => {
+      const result = schema.safeParse('hello')
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe('hello')
+      }
+    })
+
+    it('accepts numbers', () => {
+      const result = schema.safeParse(42)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(42)
+      }
+    })
+
+    it('accepts booleans', () => {
+      const result = schema.safeParse(true)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(true)
+      }
+    })
+
+    it('accepts null', () => {
+      const result = schema.safeParse(null)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(null)
+      }
+    })
+
+    it('accepts undefined', () => {
+      const result = schema.safeParse(undefined)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(undefined)
+      }
+    })
+
+    it('accepts plain objects', () => {
+      const obj = { key: 'value', nested: { prop: 123 } }
+      const result = schema.safeParse(obj)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toEqual(obj)
+      }
+    })
+
+    it('accepts arrays', () => {
+      const arr = [1, 2, 3, 'four', { five: 5 }]
+      const result = schema.safeParse(arr)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toEqual(arr)
+      }
+    })
+
+    it('accepts empty arrays', () => {
+      const result = schema.safeParse([])
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toEqual([])
+      }
+    })
+
+    it('accepts empty objects', () => {
+      const result = schema.safeParse({})
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toEqual({})
+      }
+    })
+  })
+
+  describe('edge cases', () => {
+    const schema = new UnknownSchema()
+
+    it('accepts zero', () => {
+      const result = schema.safeParse(0)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(0)
+      }
+    })
+
+    it('accepts empty string', () => {
+      const result = schema.safeParse('')
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe('')
+      }
+    })
+
+    it('accepts negative numbers', () => {
+      const result = schema.safeParse(-123)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(-123)
+      }
+    })
+
+    it('accepts floating point numbers', () => {
+      const result = schema.safeParse(3.14159)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(3.14159)
+      }
+    })
+
+    it('accepts NaN', () => {
+      const result = schema.safeParse(NaN)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBeNaN()
+      }
+    })
+
+    it('accepts Infinity', () => {
+      const result = schema.safeParse(Infinity)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(Infinity)
+      }
+    })
+
+    it('accepts -Infinity', () => {
+      const result = schema.safeParse(-Infinity)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(-Infinity)
+      }
+    })
+
+    it('accepts BigInt', () => {
+      const bigIntValue = BigInt(9007199254740991)
+      const result = schema.safeParse(bigIntValue)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(bigIntValue)
+      }
+    })
+
+    it('accepts functions', () => {
+      const fn = () => 'test'
+      const result = schema.safeParse(fn)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(fn)
+      }
+    })
+
+    it('accepts Date objects', () => {
+      const date = new Date('2023-01-01')
+      const result = schema.safeParse(date)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(date)
+      }
+    })
+
+    it('accepts RegExp objects', () => {
+      const regex = /test/gi
+      const result = schema.safeParse(regex)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(regex)
+      }
+    })
+
+    it('accepts Symbol', () => {
+      const sym = Symbol('test')
+      const result = schema.safeParse(sym)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(sym)
+      }
+    })
+
+    it('accepts Map objects', () => {
+      const map = new Map([['key', 'value']])
+      const result = schema.safeParse(map)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(map)
+      }
+    })
+
+    it('accepts Set objects', () => {
+      const set = new Set([1, 2, 3])
+      const result = schema.safeParse(set)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(set)
+      }
+    })
+
+    it('accepts WeakMap objects', () => {
+      const weakMap = new WeakMap()
+      const result = schema.safeParse(weakMap)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(weakMap)
+      }
+    })
+
+    it('accepts WeakSet objects', () => {
+      const weakSet = new WeakSet()
+      const result = schema.safeParse(weakSet)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(weakSet)
+      }
+    })
+
+    it('accepts class instances', () => {
+      class TestClass {
+        constructor(public value: string) {}
+      }
+      const instance = new TestClass('test')
+      const result = schema.safeParse(instance)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(instance)
+      }
+    })
+
+    it('accepts nested complex structures', () => {
+      const complex = {
+        array: [1, 'two', { three: 3 }],
+        nested: {
+          deep: {
+            value: [null, undefined, true],
+          },
+        },
+        fn: () => 'test',
+        date: new Date(),
+      }
+      const result = schema.safeParse(complex)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toEqual(complex)
+      }
+    })
+  })
+
+  describe('special JavaScript values', () => {
+    const schema = new UnknownSchema()
+
+    it('accepts objects with null prototype', () => {
+      const obj = Object.create(null)
+      obj.key = 'value'
+      const result = schema.safeParse(obj)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(obj)
+      }
+    })
+
+    it('accepts Proxy objects', () => {
+      const target = { value: 42 }
+      const proxy = new Proxy(target, {})
+      const result = schema.safeParse(proxy)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(proxy)
+      }
+    })
+
+    it('accepts typed arrays', () => {
+      const uint8Array = new Uint8Array([1, 2, 3])
+      const result = schema.safeParse(uint8Array)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(uint8Array)
+      }
+    })
+
+    it('accepts ArrayBuffer', () => {
+      const buffer = new ArrayBuffer(8)
+      const result = schema.safeParse(buffer)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(buffer)
+      }
+    })
+
+    it('accepts Promise objects', () => {
+      const promise = Promise.resolve(42)
+      const result = schema.safeParse(promise)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(promise)
+      }
+    })
+
+    it('accepts Error objects', () => {
+      const error = new Error('test error')
+      const result = schema.safeParse(error)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(error)
+      }
+    })
+  })
+})

package/src/schema/unknown.ts

@@ -1,7 +1,7 @@
-import { ValidationResult, Validator, ValidatorContext } from '../validation'
+import { Schema, ValidationResult, ValidatorContext } from '../validation'
 
-export class UnknownSchema extends Validator<unknown> {
-  override validateInContext(
+export class UnknownSchema extends Schema<unknown> {
+  validateInContext(
     input: unknown,
     ctx: ValidatorContext,
   ): ValidationResult<unknown> {

package/src/schema.ts

@@ -1,6 +1,9 @@
-// Utilities (that depend on *and* are used by schemas)
+// Global schemas
 export * from './schema/_parameters.js'
 
+// Utilities
+export * from './schema/refine.js'
+
 // Concrete Types
 export * from './schema/array.js'
 export * from './schema/blob.js'
@@ -14,6 +17,7 @@ export * from './schema/literal.js'
 export * from './schema/never.js'
 export * from './schema/null.js'
 export * from './schema/object.js'
+export * from './schema/regexp.js'
 export * from './schema/string.js'
 export * from './schema/unknown-object.js'
 export * from './schema/unknown.js'
@@ -22,6 +26,8 @@ export * from './schema/unknown.js'
 export * from './schema/custom.js'
 export * from './schema/discriminated-union.js'
 export * from './schema/intersection.js'
+export * from './schema/nullable.js'
+export * from './schema/optional.js'
 export * from './schema/ref.js'
 export * from './schema/union.js'
 

package/src/util/array-agg.ts

@@ -16,6 +16,7 @@
  * // result is [{ value: 1, sum: 2 }, { value: 2, sum: 4 }, { value: 3, sum: 6 }]
  * ```
  */
+/*@__NO_SIDE_EFFECTS__*/
 export function arrayAgg<T, O>(
   arr: readonly T[],
   cmp: (a: T, b: T) => boolean,

package/src/util/lazy-property.ts

@@ -0,0 +1,14 @@
+/*@__NO_SIDE_EFFECTS__*/
+export function lazyProperty<
+  O extends object,
+  const K extends keyof O,
+  const V extends O[K],
+>(obj: O, key: K, value: V): V {
+  Object.defineProperty(obj, key, {
+    value,
+    writable: false,
+    enumerable: false,
+    configurable: true,
+  })
+  return value
+}

package/src/validation/schema.ts

@@ -0,0 +1,92 @@
+import {
+  ValidationOptions,
+  ValidationResult,
+  Validator,
+  ValidatorContext,
+} from './validator.js'
+
+export abstract class Schema<Output> implements Validator<Output> {
+  declare readonly ['_lex']: { output: Output }
+
+  abstract validateInContext(
+    input: unknown,
+    ctx: ValidatorContext,
+  ): ValidationResult<Output>
+
+  assert(input: unknown): asserts input is Output {
+    const result = this.safeParse(input, { allowTransform: false })
+    if (!result.success) throw result.error
+  }
+
+  matches(input: unknown): input is Output {
+    const result = this.safeParse(input, { allowTransform: false })
+    return result.success
+  }
+
+  ifMatches<I>(input: I): (I & Output) | undefined {
+    return this.matches(input) ? input : undefined
+  }
+
+  parse<I>(
+    input: I,
+    options: ValidationOptions & { allowTransform: false },
+  ): I & Output
+  parse(input: unknown, options?: ValidationOptions): Output
+  parse(input: unknown, options?: ValidationOptions): Output {
+    const result = this.safeParse(input, options)
+    if (!result.success) throw result.error
+    return result.value
+  }
+
+  safeParse<I>(
+    input: I,
+    options: ValidationOptions & { allowTransform: false },
+  ): ValidationResult<I & Output>
+  safeParse(
+    input: unknown,
+    options?: ValidationOptions,
+  ): ValidationResult<Output>
+  safeParse(
+    input: unknown,
+    options?: ValidationOptions,
+  ): ValidationResult<Output> {
+    return ValidatorContext.validate(input, this, options)
+  }
+
+  // @NOTE The built lexicons namespaces will export utility functions that
+  // allow accessing the schema's methods without the need to specify ".main."
+  // as part of the namespace. This way, a utility for a particular record type
+  // can be called like "app.bsky.feed.post.<utility>()" instead of
+  // "app.bsky.feed.post.main.<utility>()". Because those utilities could
+  // conflict with other schemas (e.g. if there is a lexicon definition at
+  // "#<utility>"), those exported utilities will be prefixed with "$". In order
+  // to be able to consistently call the utilities, when using the "main" and
+  // non "main" definitions, we also expose the same methods with a "$" prefix.
+  // Thanks to this, both of the following call will be possible:
+  //
+  // - "app.bsky.feed.post.$parse(...)" // calls a utility function created by "lex build"
+  // - "app.bsky.feed.defs.postView.$parse(...)" // uses the alias defined below on the schema instance
+
+  $assert(input: unknown): asserts input is Output {
+    return this.assert(input)
+  }
+
+  $matches(input: unknown): input is Output {
+    return this.matches(input)
+  }
+
+  $ifMatches<I>(input: I): (I & Output) | undefined {
+    return this.ifMatches(input)
+  }
+
+  $parse(input: unknown, options?: ValidationOptions): Output {
+    return this.parse(input, options)
+  }
+
+  $safeParse(
+    input: unknown,
+    options?: ValidationOptions,
+  ): ValidationResult<Output> {
+    return this.safeParse(input, options)
+  }
+}

package/src/validation/validation-error.ts

@@ -1,18 +1,20 @@
 import { ResultFailure, failureError } from '../core.js'
+import { arrayAgg } from '../util/array-agg.js'
 import {
-  ValidationIssue,
-  aggregateIssues,
-  stringifyIssue,
+  Issue,
+  IssueInvalidType,
+  IssueInvalidValue,
 } from './validation-issue.js'
 
 export class ValidationError extends Error {
   name = 'ValidationError'
 
-  constructor(
-    readonly issues: ValidationIssue[],
-    options?: ErrorOptions,
-  ) {
-    super(issues.map(stringifyIssue).join(', '), options)
+  readonly issues: Issue[]
+
+  constructor(issues: Issue[], options?: ErrorOptions) {
+    const issuesAgg = aggregateIssues(issues)
+    super(issuesAgg.join(', '), options)
+    this.issues = issuesAgg
   }
 
   static fromFailures(
@@ -20,7 +22,7 @@ export class ValidationError extends Error {
   ): ValidationError {
     if (failures.length === 1) return failures[0].error
     const issues = failures.flatMap(extractFailureIssues)
-    return new ValidationError(aggregateIssues(issues), {
+    return new ValidationError(issues, {
       // Keep the original errors as the cause chain
       cause: failures.map(failureError),
     })
@@ -30,3 +32,52 @@ export class ValidationError extends Error {
 function extractFailureIssues(result: ResultFailure<ValidationError>) {
   return result.error.issues
 }
+
+function aggregateIssues(issues: Issue[]): Issue[] {
+  // Quick path for common cases
+  if (issues.length <= 1) return issues
+  if (issues.length === 2 && issues[0].code !== issues[1].code) return issues
+
+  return [
+    // Aggregate invalid_type with identical paths
+    ...arrayAgg(
+      issues.filter((issue) => issue instanceof IssueInvalidType),
+      (a, b) => comparePropertyPaths(a.path, b.path),
+      (issues) =>
+        new IssueInvalidType(
+          issues[0].path,
+          issues[0].input,
+          Array.from(new Set(issues.flatMap((iss) => iss.expected))),
+        ),
+    ),
+    // Aggregate invalid_value with identical paths
+    ...arrayAgg(
+      issues.filter((issue) => issue instanceof IssueInvalidValue),
+      (a, b) => comparePropertyPaths(a.path, b.path),
+      (issues) =>
+        new IssueInvalidValue(
+          issues[0].path,
+          issues[0].input,
+          Array.from(new Set(issues.flatMap((iss) => iss.values))),
+        ),
+    ),
+    // Pass through other issues
+    ...issues.filter(
+      (issue) =>
+        !(issue instanceof IssueInvalidType) &&
+        !(issue instanceof IssueInvalidValue),
+    ),
+  ]
+}
+
+/*@__NO_SIDE_EFFECTS__*/
+function comparePropertyPaths(
+  a: readonly PropertyKey[],
+  b: readonly PropertyKey[],
+) {
+  if (a.length !== b.length) return false
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false
+  }
+  return true
+}