@atproto/lex-schema 0.0.2 → 0.0.3

package/src/schema/bytes.test.ts

@@ -0,0 +1,226 @@
+import { BytesSchema } from './bytes.js'
+
+describe('BytesSchema', () => {
+  describe('basic validation', () => {
+    const schema = new BytesSchema({})
+
+    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 = new BytesSchema({ 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 = new BytesSchema({ 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 = new BytesSchema({ 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 = new BytesSchema({ minLength: 0 })
+      const result = schema.safeParse(new Uint8Array([]))
+      expect(result.success).toBe(true)
+    })
+
+    it('validates with maxLength of 0', () => {
+      const schema = new BytesSchema({ maxLength: 0 })
+      const result = schema.safeParse(new Uint8Array([]))
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects non-empty bytes with maxLength of 0', () => {
+      const schema = new BytesSchema({ maxLength: 0 })
+      const result = schema.safeParse(new Uint8Array([0]))
+      expect(result.success).toBe(false)
+    })
+
+    it('validates bytes with all zeros', () => {
+      const schema = new BytesSchema({})
+      const result = schema.safeParse(new Uint8Array([0, 0, 0, 0]))
+      expect(result.success).toBe(true)
+    })
+
+    it('validates bytes with all 255s', () => {
+      const schema = new BytesSchema({})
+      const result = schema.safeParse(new Uint8Array([255, 255, 255, 255]))
+      expect(result.success).toBe(true)
+    })
+
+    it('validates large byte arrays', () => {
+      const schema = new BytesSchema({})
+      const largeArray = new Uint8Array(10000)
+      const result = schema.safeParse(largeArray)
+      expect(result.success).toBe(true)
+    })
+  })
+
+  describe('TypedArray coercion', () => {
+    const schema = new BytesSchema({})
+
+    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 = new BytesSchema({ 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,19 +1,17 @@
 import { asUint8Array } from '@atproto/lex-data'
-import { ValidationResult, Validator, ValidatorContext } from '../validation.js'
+import { Schema, ValidationResult, ValidatorContext } from '../validation.js'
 
 export type BytesSchemaOptions = {
   minLength?: number
   maxLength?: number
 }
 
-export class BytesSchema extends Validator<Uint8Array> {
-  readonly lexiconType = 'bytes' as const
-
-  constructor(readonly options: BytesSchemaOptions) {
+export class BytesSchema extends Schema<Uint8Array> {
+  constructor(readonly options: BytesSchemaOptions = {}) {
     super()
   }
 
-  override validateInContext(
+  validateInContext(
     input: unknown,
     ctx: ValidatorContext,
   ): ValidationResult<Uint8Array> {

package/src/schema/cid.test.ts

@@ -0,0 +1,155 @@
+import { parseCid } from '@atproto/lex-data'
+import { CidSchema } from './cid.js'
+
+describe('CidSchema', () => {
+  describe('default mode (non-strict)', () => {
+    const schema = new CidSchema()
+
+    it('validates CID v1 with DAG-CBOR codec and SHA-256', () => {
+      const cid = parseCid(
+        'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+      )
+      const result = schema.safeParse(cid)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates CID v1 with raw binary codec', () => {
+      const cid = parseCid(
+        'bafkreifjjcie6lypi6ny7amxnfftagclbuxndqonfipmb64f2km2devei4',
+      )
+      const result = schema.safeParse(cid)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates CID v0', () => {
+      const cid = parseCid('QmPZ9gcCEpqKTo6aq61g2nXGUhM4iCL3ewB6LDXZCtioEB')
+      const result = schema.safeParse(cid)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates multiple different CIDs', () => {
+      const cids = [
+        parseCid('bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a'),
+        parseCid('bafyreigoxt64qghytzkr6ik7qvtzc7lyytiq5xbbrokbxjows2wp7vmo6q'),
+        parseCid('bafyreiaizynclnqiolq7byfpjjtgqzn4sfrsgn7z2hhf6bo4utdwkin7ke'),
+        parseCid('bafyreifd4w4tcr5tluxz7osjtnofffvtsmgdqcfrfi6evjde4pl27lrjpy'),
+      ]
+
+      for (const cid of cids) {
+        const result = schema.safeParse(cid)
+        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(
+        'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+      )
+      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 = new CidSchema({ strict: true })
+
+    it('validates CID v1 with DAG-CBOR codec and SHA-256', () => {
+      const cid = parseCid(
+        'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+      )
+      const result = schema.safeParse(cid)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates CID v1 with raw binary codec and SHA-256', () => {
+      const cid = parseCid(
+        'bafkreifjjcie6lypi6ny7amxnfftagclbuxndqonfipmb64f2km2devei4',
+      )
+      const result = schema.safeParse(cid)
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects CID v0', () => {
+      const cid = parseCid('QmPZ9gcCEpqKTo6aq61g2nXGUhM4iCL3ewB6LDXZCtioEB')
+      const result = schema.safeParse(cid)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects CID v1 with non-standard codec', () => {
+      // Using git-raw codec (0x78) instead of DAG-CBOR or raw binary
+      const cid = parseCid(
+        'bafybeigvgzoolc3drupxhlevdp2ugqcrbcsqfmcek2zxiw5wctk3xjpjwy',
+      )
+      const result = schema.safeParse(cid)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects CID v1 with non-SHA-256 hash', () => {
+      // Using SHA-512 (0x13) instead of SHA-256
+      const cid = parseCid(
+        'bafybgqfcn3rz4mdzywp2jb6mjvpdq24rxjvbmdcmizrjdgx2ujjpvj4kxf4d62ywrzm6njk44cxhha4pj3bkvqz2esfgrm7mdkdcqcxjibf7c',
+      )
+      const result = schema.safeParse(cid)
+      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(
+        'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+      )
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects null', () => {
+      const result = schema.safeParse(null)
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('options', () => {
+    it('stores the provided options', () => {
+      const options = { strict: true }
+      const schema = new CidSchema(options)
+      expect(schema.options).toEqual(options)
+    })
+
+    it('defaults to empty options', () => {
+      const schema = new CidSchema()
+      expect(schema.options).toEqual({})
+    })
+  })
+})

package/src/schema/cid.ts

@@ -1,23 +1,29 @@
-import { CID, isCid } from '@atproto/lex-data'
-import { ValidationResult, Validator, ValidatorContext } from '../validation.js'
+import { Cid, isCid } from '@atproto/lex-data'
+import { Schema, ValidationResult, ValidatorContext } from '../validation.js'
 
-export { CID }
+export type { Cid }
 
 export type CidSchemaOptions = {
+  /**
+   * In strict mode, only CID with the following properties are accepted:
+   * - version: 1
+   * - codec: raw binary (0x55) or DAG-CBOR (0x71)
+   * - hash function: SHA-256 (0x12)
+   *
+   * @default false
+   */
   strict?: boolean
 }
 
-export class CidSchema extends Validator<CID> {
-  readonly lexiconType = 'cid-link' as const
-
+export class CidSchema extends Schema<Cid> {
   constructor(readonly options: CidSchemaOptions = {}) {
     super()
   }
 
-  override validateInContext(
+  validateInContext(
     input: unknown,
     ctx: ValidatorContext,
-  ): ValidationResult<CID> {
+  ): ValidationResult<Cid> {
     if (!isCid(input, this.options)) {
       return ctx.issueInvalidType(input, 'cid')
     }