@atproto/lex-schema 0.0.2 → 0.0.3

package/src/schema/blob.test.ts

@@ -0,0 +1,506 @@
+import { parseCid } from '@atproto/lex-data'
+import { BlobSchema } from './blob.js'
+
+// await cidForRawBytes(Buffer.from('Hello, World!'))
+const blobCid = parseCid(
+  'bafkreig77vqcdozl2wyk6z3cscaj5q5fggi53aoh64fewkdiri3cdauyn4',
+)
+// await cidForLex(Buffer.from('Hello, World!'))
+const lexCid = parseCid(
+  'bafyreic52vzks7wdklat4evp3vimohl55i2unzqpshz2ytka5omzr7exdy',
+)
+
+describe('BlobSchema', () => {
+  describe('basic validation', () => {
+    const schema = new BlobSchema({})
+
+    it('validates valid blob references', () => {
+      const result = schema.safeParse({
+        $type: 'blob',
+        ref: blobCid,
+        mimeType: 'image/jpeg',
+        size: 10000,
+      })
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value.$type).toBe('blob')
+        expect(result.value.mimeType).toBe('image/jpeg')
+        expect(result.value.size).toBe(10000)
+      }
+    })
+
+    it('validates blob with different mime types', () => {
+      const result = schema.safeParse({
+        $type: 'blob',
+        ref: blobCid,
+        mimeType: 'image/png',
+        size: 5000,
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('validates blob with size 0', () => {
+      const result = schema.safeParse({
+        $type: 'blob',
+        ref: blobCid,
+        mimeType: 'text/plain',
+        size: 0,
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects non-objects', () => {
+      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 arrays', () => {
+      const result = schema.safeParse([])
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects numbers', () => {
+      const result = schema.safeParse(123)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects booleans', () => {
+      const result = schema.safeParse(true)
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('BlobRef validation', () => {
+    const schema = new BlobSchema({})
+
+    it('rejects blob without $type', () => {
+      const result = schema.safeParse({
+        ref: blobCid,
+        mimeType: 'image/jpeg',
+        size: 10000,
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects blob with wrong $type', () => {
+      const result = schema.safeParse({
+        $type: 'notblob',
+        ref: blobCid,
+        mimeType: 'image/jpeg',
+        size: 10000,
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects blob without ref', () => {
+      const result = schema.safeParse({
+        $type: 'blob',
+        mimeType: 'image/jpeg',
+        size: 10000,
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects blob without mimeType', () => {
+      const result = schema.safeParse({
+        $type: 'blob',
+        ref: blobCid,
+        size: 10000,
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects blob without size', () => {
+      const result = schema.safeParse({
+        $type: 'blob',
+        ref: blobCid,
+        mimeType: 'image/jpeg',
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects blob with invalid ref type', () => {
+      const result = schema.safeParse({
+        $type: 'blob',
+        ref: 'not a cid',
+        mimeType: 'image/jpeg',
+        size: 10000,
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects blob with invalid mimeType type', () => {
+      const result = schema.safeParse({
+        $type: 'blob',
+        ref: blobCid,
+        mimeType: 123,
+        size: 10000,
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects blob with invalid size type', () => {
+      const result = schema.safeParse({
+        $type: 'blob',
+        ref: blobCid,
+        mimeType: 'image/jpeg',
+        size: '10000',
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects blob with negative size', () => {
+      const result = schema.safeParse({
+        $type: 'blob',
+        ref: blobCid,
+        mimeType: 'image/jpeg',
+        size: -1,
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects blob with decimal size', () => {
+      const result = schema.safeParse({
+        $type: 'blob',
+        ref: blobCid,
+        mimeType: 'image/jpeg',
+        size: 10000.5,
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects blob with extra properties', () => {
+      const result = schema.safeParse({
+        $type: 'blob',
+        ref: blobCid,
+        mimeType: 'image/jpeg',
+        size: 10000,
+        extra: 'not allowed',
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects blob with $link format for ref', () => {
+      const result = schema.safeParse({
+        $type: 'blob',
+        ref: { $link: blobCid.toString() },
+        mimeType: 'image/jpeg',
+        size: 10000,
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects blob with unknown properties', () => {
+      const result = schema.safeParse({
+        $type: 'blob',
+        ref: blobCid,
+        mimeType: 'image/jpeg',
+        size: 10000,
+        unknownProp: 42,
+      })
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('strict validation', () => {
+    const strictSchema = new BlobSchema({ strict: true })
+
+    it('accepts valid raw CID in strict mode', () => {
+      const result = strictSchema.safeParse({
+        $type: 'blob',
+        ref: blobCid,
+        mimeType: 'image/jpeg',
+        size: 10000,
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects non-raw CID in strict mode', () => {
+      const result = strictSchema.safeParse({
+        $type: 'blob',
+        ref: lexCid,
+        mimeType: 'image/jpeg',
+        size: 10000,
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('accepts non-raw CID in non-strict mode', () => {
+      const nonStrictSchema = new BlobSchema({ strict: false })
+      const result = nonStrictSchema.safeParse({
+        $type: 'blob',
+        ref: lexCid,
+        mimeType: 'image/jpeg',
+        size: 10000,
+      })
+      expect(result.success).toBe(true)
+    })
+  })
+
+  describe('legacy blob format', () => {
+    it('rejects legacy format by default', () => {
+      const schema = new BlobSchema({})
+      const result = schema.safeParse({
+        cid: blobCid.toString(),
+        mimeType: 'image/jpeg',
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('accepts legacy format when allowLegacy is true', () => {
+      const schema = new BlobSchema({ allowLegacy: true })
+      const result = schema.safeParse({
+        cid: blobCid.toString(),
+        mimeType: 'image/jpeg',
+      })
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect('cid' in result.value && result.value.cid).toBe(
+          blobCid.toString(),
+        )
+        expect(result.value.mimeType).toBe('image/jpeg')
+      }
+    })
+
+    it('accepts legacy format with lexCid when allowLegacy is true', () => {
+      const schema = new BlobSchema({ allowLegacy: true })
+      const result = schema.safeParse({
+        cid: lexCid.toString(),
+        mimeType: 'image/png',
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects legacy format without cid', () => {
+      const schema = new BlobSchema({ allowLegacy: true })
+      const result = schema.safeParse({
+        mimeType: 'image/jpeg',
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects legacy format without mimeType', () => {
+      const schema = new BlobSchema({ allowLegacy: true })
+      const result = schema.safeParse({
+        cid: blobCid.toString(),
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects legacy format with invalid cid', () => {
+      const schema = new BlobSchema({ allowLegacy: true })
+      const result = schema.safeParse({
+        cid: 'invalid-cid',
+        mimeType: 'image/jpeg',
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects legacy format with numeric cid', () => {
+      const schema = new BlobSchema({ allowLegacy: true })
+      const result = schema.safeParse({
+        cid: 123,
+        mimeType: 'image/jpeg',
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects legacy format with extra properties', () => {
+      const schema = new BlobSchema({ allowLegacy: true })
+      const result = schema.safeParse({
+        cid: blobCid.toString(),
+        mimeType: 'image/jpeg',
+        extra: 'not allowed',
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('accepts both BlobRef and LegacyBlobRef formats when allowLegacy is true', () => {
+      const schema = new BlobSchema({ allowLegacy: true })
+
+      const blobRefResult = schema.safeParse({
+        $type: 'blob',
+        ref: blobCid,
+        mimeType: 'image/jpeg',
+        size: 10000,
+      })
+      expect(blobRefResult.success).toBe(true)
+
+      const legacyResult = schema.safeParse({
+        cid: blobCid.toString(),
+        mimeType: 'image/jpeg',
+      })
+      expect(legacyResult.success).toBe(true)
+    })
+  })
+
+  describe('accept and maxSize options', () => {
+    it('accepts blob with accept option (not enforced)', () => {
+      const schema = new BlobSchema({ accept: ['image/jpeg', 'image/png'] })
+      const result = schema.safeParse({
+        $type: 'blob',
+        ref: blobCid,
+        mimeType: 'image/gif',
+        size: 10000,
+      })
+      // Accept constraints are not enforced (see comment in source)
+      expect(result.success).toBe(true)
+    })
+
+    it('accepts blob with maxSize option (not enforced)', () => {
+      const schema = new BlobSchema({ maxSize: 1000 })
+      const result = schema.safeParse({
+        $type: 'blob',
+        ref: blobCid,
+        mimeType: 'image/jpeg',
+        size: 10000,
+      })
+      // MaxSize constraints are not enforced (see comment in source)
+      expect(result.success).toBe(true)
+    })
+
+    it('accepts blob matching accept constraint', () => {
+      const schema = new BlobSchema({ accept: ['image/jpeg', 'image/png'] })
+      const result = schema.safeParse({
+        $type: 'blob',
+        ref: blobCid,
+        mimeType: 'image/jpeg',
+        size: 10000,
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('accepts blob matching maxSize constraint', () => {
+      const schema = new BlobSchema({ maxSize: 20000 })
+      const result = schema.safeParse({
+        $type: 'blob',
+        ref: blobCid,
+        mimeType: 'image/jpeg',
+        size: 10000,
+      })
+      expect(result.success).toBe(true)
+    })
+  })
+
+  describe('edge cases', () => {
+    const schema = new BlobSchema({})
+
+    it('validates blob with large size', () => {
+      const result = schema.safeParse({
+        $type: 'blob',
+        ref: blobCid,
+        mimeType: 'video/mp4',
+        size: Number.MAX_SAFE_INTEGER,
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects empty object', () => {
+      const result = schema.safeParse({})
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects object with only $type', () => {
+      const result = schema.safeParse({ $type: 'blob' })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects blob with empty mimeType', () => {
+      const result = schema.safeParse({
+        $type: 'blob',
+        ref: blobCid,
+        mimeType: '',
+        size: 10000,
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects blob with null ref', () => {
+      const result = schema.safeParse({
+        $type: 'blob',
+        ref: null,
+        mimeType: 'image/jpeg',
+        size: 10000,
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects blob with null mimeType', () => {
+      const result = schema.safeParse({
+        $type: 'blob',
+        ref: blobCid,
+        mimeType: null,
+        size: 10000,
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects blob with null size', () => {
+      const result = schema.safeParse({
+        $type: 'blob',
+        ref: blobCid,
+        mimeType: 'image/jpeg',
+        size: null,
+      })
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('combined options', () => {
+    it('validates with strict and allowLegacy both true', () => {
+      const schema = new BlobSchema({ strict: true, allowLegacy: true })
+
+      // Should accept strict BlobRef
+      const blobRefResult = schema.safeParse({
+        $type: 'blob',
+        ref: blobCid,
+        mimeType: 'image/jpeg',
+        size: 10000,
+      })
+      expect(blobRefResult.success).toBe(true)
+
+      // Should accept LegacyBlobRef
+      const legacyResult = schema.safeParse({
+        cid: blobCid.toString(),
+        mimeType: 'image/jpeg',
+      })
+      expect(legacyResult.success).toBe(true)
+
+      // Should reject non-raw CID in BlobRef format
+      const nonRawResult = schema.safeParse({
+        $type: 'blob',
+        ref: lexCid,
+        mimeType: 'image/jpeg',
+        size: 10000,
+      })
+      expect(nonRawResult.success).toBe(false)
+    })
+
+    it('validates with all options combined', () => {
+      const schema = new BlobSchema({
+        strict: true,
+        allowLegacy: true,
+        accept: ['image/jpeg'],
+        maxSize: 20000,
+      })
+
+      const result = schema.safeParse({
+        $type: 'blob',
+        ref: blobCid,
+        mimeType: 'image/jpeg',
+        size: 10000,
+      })
+      expect(result.success).toBe(true)
+    })
+  })
+})

package/src/schema/blob.ts

@@ -4,7 +4,7 @@ import {
   isBlobRef,
   isLegacyBlobRef,
 } from '@atproto/lex-data'
-import { ValidationResult, Validator, ValidatorContext } from '../validation.js'
+import { Schema, ValidationResult, ValidatorContext } from '../validation.js'
 
 export type BlobSchemaOptions = {
   /**
@@ -32,16 +32,14 @@ export type BlobSchemaOutput<Options> = Options extends { allowLegacy: true }
   ? BlobRef | LegacyBlobRef
   : BlobRef
 
-export class BlobSchema<O extends BlobSchemaOptions> extends Validator<
+export class BlobSchema<O extends BlobSchemaOptions> extends Schema<
   BlobSchemaOutput<O>
 > {
-  readonly lexiconType = 'blob' as const
-
   constructor(readonly options: O) {
     super()
   }
 
-  override validateInContext(
+  validateInContext(
     input: unknown,
     ctx: ValidatorContext,
   ): ValidationResult<BlobSchemaOutput<O>> {

package/src/schema/boolean.test.ts

@@ -0,0 +1,116 @@
+import { BooleanSchema } from './boolean.js'
+
+describe('BooleanSchema', () => {
+  describe('basic validation', () => {
+    const schema = new BooleanSchema()
+
+    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 = new BooleanSchema({ default: 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 = new BooleanSchema({ default: 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 = new BooleanSchema({ default: 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 = new BooleanSchema({ default: 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 = new BooleanSchema({ default: true })
+      const result = schema.safeParse('not a boolean')
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('edge cases', () => {
+    const schema = new BooleanSchema()
+
+    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,18 +1,16 @@
-import { ValidationResult, Validator, ValidatorContext } from '../validation.js'
+import { Schema, ValidationResult, ValidatorContext } from '../validation.js'
 
 export type BooleanSchemaOptions = {
   default?: boolean
 }
 
-export class BooleanSchema extends Validator<boolean> {
-  readonly lexiconType = 'boolean' as const
-
-  constructor(readonly options: BooleanSchemaOptions) {
+export class BooleanSchema extends Schema<boolean> {
+  constructor(readonly options?: BooleanSchemaOptions) {
     super()
   }
 
-  override validateInContext(
-    input: unknown = this.options.default,
+  validateInContext(
+    input: unknown = this.options?.default,
     ctx: ValidatorContext,
   ): ValidationResult<boolean> {
     if (typeof input === 'boolean') {