@atproto/lex-schema 0.0.9 → 0.0.11

package/src/schema/blob.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
 import { parseCid } from '@atproto/lex-data'
-import { BlobSchema } from './blob.js'
+import { blob } from './blob.js'
 
 // await cidForRawBytes(Buffer.from('Hello, World!'))
 const blobCid = parseCid(
@@ -13,7 +13,7 @@ const lexCid = parseCid(
 
 describe('BlobSchema', () => {
   describe('basic validation', () => {
-    const schema = new BlobSchema({})
+    const schema = blob({})
 
     it('validates valid blob references', () => {
       const result = schema.safeParse({
@@ -82,7 +82,7 @@ describe('BlobSchema', () => {
   })
 
   describe('BlobRef validation', () => {
-    const schema = new BlobSchema({})
+    const schema = blob({})
 
     it('rejects blob without $type', () => {
       const result = schema.safeParse({
@@ -214,7 +214,7 @@ describe('BlobSchema', () => {
   })
 
   describe('strict validation', () => {
-    const strictSchema = new BlobSchema({ strict: true })
+    const strictSchema = blob({ strict: true })
 
     it('accepts valid raw CID in strict mode', () => {
       const result = strictSchema.safeParse({
@@ -237,7 +237,7 @@ describe('BlobSchema', () => {
     })
 
     it('accepts non-raw CID in non-strict mode', () => {
-      const nonStrictSchema = new BlobSchema({ strict: false })
+      const nonStrictSchema = blob({ strict: false })
       const result = nonStrictSchema.safeParse({
         $type: 'blob',
         ref: lexCid,
@@ -250,7 +250,7 @@ describe('BlobSchema', () => {
 
   describe('legacy blob format', () => {
     it('rejects legacy format by default', () => {
-      const schema = new BlobSchema({})
+      const schema = blob({})
       const result = schema.safeParse({
         cid: blobCid.toString(),
         mimeType: 'image/jpeg',
@@ -259,7 +259,7 @@ describe('BlobSchema', () => {
     })
 
     it('accepts legacy format when allowLegacy is true', () => {
-      const schema = new BlobSchema({ allowLegacy: true })
+      const schema = blob({ allowLegacy: true })
       const result = schema.safeParse({
         cid: blobCid.toString(),
         mimeType: 'image/jpeg',
@@ -274,7 +274,7 @@ describe('BlobSchema', () => {
     })
 
     it('accepts legacy format with lexCid when allowLegacy is true', () => {
-      const schema = new BlobSchema({ allowLegacy: true })
+      const schema = blob({ allowLegacy: true })
       const result = schema.safeParse({
         cid: lexCid.toString(),
         mimeType: 'image/png',
@@ -283,7 +283,7 @@ describe('BlobSchema', () => {
     })
 
     it('rejects legacy format without cid', () => {
-      const schema = new BlobSchema({ allowLegacy: true })
+      const schema = blob({ allowLegacy: true })
       const result = schema.safeParse({
         mimeType: 'image/jpeg',
       })
@@ -291,7 +291,7 @@ describe('BlobSchema', () => {
     })
 
     it('rejects legacy format without mimeType', () => {
-      const schema = new BlobSchema({ allowLegacy: true })
+      const schema = blob({ allowLegacy: true })
       const result = schema.safeParse({
         cid: blobCid.toString(),
       })
@@ -299,7 +299,7 @@ describe('BlobSchema', () => {
     })
 
     it('rejects legacy format with invalid cid', () => {
-      const schema = new BlobSchema({ allowLegacy: true })
+      const schema = blob({ allowLegacy: true })
       const result = schema.safeParse({
         cid: 'invalid-cid',
         mimeType: 'image/jpeg',
@@ -308,7 +308,7 @@ describe('BlobSchema', () => {
     })
 
     it('rejects legacy format with numeric cid', () => {
-      const schema = new BlobSchema({ allowLegacy: true })
+      const schema = blob({ allowLegacy: true })
       const result = schema.safeParse({
         cid: 123,
         mimeType: 'image/jpeg',
@@ -317,7 +317,7 @@ describe('BlobSchema', () => {
     })
 
     it('rejects legacy format with extra properties', () => {
-      const schema = new BlobSchema({ allowLegacy: true })
+      const schema = blob({ allowLegacy: true })
       const result = schema.safeParse({
         cid: blobCid.toString(),
         mimeType: 'image/jpeg',
@@ -327,7 +327,7 @@ describe('BlobSchema', () => {
     })
 
     it('accepts both BlobRef and LegacyBlobRef formats when allowLegacy is true', () => {
-      const schema = new BlobSchema({ allowLegacy: true })
+      const schema = blob({ allowLegacy: true })
 
       const blobRefResult = schema.safeParse({
         $type: 'blob',
@@ -347,7 +347,7 @@ describe('BlobSchema', () => {
 
   describe('accept and maxSize options', () => {
     it('accepts blob with accept option (not enforced)', () => {
-      const schema = new BlobSchema({ accept: ['image/jpeg', 'image/png'] })
+      const schema = blob({ accept: ['image/jpeg', 'image/png'] })
       const result = schema.safeParse({
         $type: 'blob',
         ref: blobCid,
@@ -358,7 +358,7 @@ describe('BlobSchema', () => {
     })
 
     it('accepts blob with maxSize option (not enforced)', () => {
-      const schema = new BlobSchema({ maxSize: 1000 })
+      const schema = blob({ maxSize: 1000 })
       const result = schema.safeParse({
         $type: 'blob',
         ref: blobCid,
@@ -369,7 +369,7 @@ describe('BlobSchema', () => {
     })
 
     it('accepts blob matching accept constraint', () => {
-      const schema = new BlobSchema({ accept: ['image/jpeg', 'image/png'] })
+      const schema = blob({ accept: ['image/jpeg', 'image/png'] })
       const result = schema.safeParse({
         $type: 'blob',
         ref: blobCid,
@@ -380,7 +380,7 @@ describe('BlobSchema', () => {
     })
 
     it('accepts blob matching maxSize constraint', () => {
-      const schema = new BlobSchema({ maxSize: 20000 })
+      const schema = blob({ maxSize: 20000 })
       const result = schema.safeParse({
         $type: 'blob',
         ref: blobCid,
@@ -392,7 +392,7 @@ describe('BlobSchema', () => {
   })
 
   describe('edge cases', () => {
-    const schema = new BlobSchema({})
+    const schema = blob({})
 
     it('validates blob with large size', () => {
       const result = schema.safeParse({
@@ -457,7 +457,7 @@ describe('BlobSchema', () => {
 
   describe('combined options', () => {
     it('validates with strict and allowLegacy both true', () => {
-      const schema = new BlobSchema({ strict: true, allowLegacy: true })
+      const schema = blob({ strict: true, allowLegacy: true })
 
       // Should accept strict BlobRef
       const blobRefResult = schema.safeParse({
@@ -486,7 +486,7 @@ describe('BlobSchema', () => {
     })
 
     it('validates with all options combined', () => {
-      const schema = new BlobSchema({
+      const schema = blob({
         strict: true,
         allowLegacy: true,
         accept: ['image/jpeg'],

package/src/schema/blob.ts

@@ -5,7 +5,8 @@ import {
   isBlobRef,
   isLegacyBlobRef,
 } from '@atproto/lex-data'
-import { Schema, ValidationResult, ValidatorContext } from '../core.js'
+import { Schema, ValidationContext } from '../core.js'
+import { memoizedOptions } from '../util/memoize.js'
 
 export type BlobSchemaOptions = BlobRefCheckOptions & {
   /**
@@ -25,27 +26,22 @@ export type BlobSchemaOptions = BlobRefCheckOptions & {
 
 export type { BlobRef, LegacyBlobRef }
 
-export type BlobSchemaOutput<Options> = Options extends { allowLegacy: true }
-  ? BlobRef | LegacyBlobRef
-  : BlobRef
-
-export class BlobSchema<O extends BlobSchemaOptions> extends Schema<
-  BlobSchemaOutput<O>
+export class BlobSchema<
+  const TOptions extends BlobSchemaOptions = NonNullable<unknown>,
+> extends Schema<
+  TOptions extends { allowLegacy: true } ? BlobRef | LegacyBlobRef : BlobRef
 > {
-  constructor(readonly options: O) {
+  constructor(readonly options?: TOptions) {
     super()
   }
 
-  validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<BlobSchemaOutput<O>> {
+  validateInContext(input: unknown, ctx: ValidationContext) {
     const blob: null | BlobRef | LegacyBlobRef =
       (input as any)?.$type !== undefined
         ? isBlobRef(input, this.options)
           ? input
           : null
-        : this.options.allowLegacy === true && isLegacyBlobRef(input)
+        : this.options?.allowLegacy === true && isLegacyBlobRef(input)
           ? input
           : null
 
@@ -53,21 +49,21 @@ export class BlobSchema<O extends BlobSchemaOptions> extends Schema<
       return ctx.issueInvalidType(input, 'blob')
     }
 
-    const { accept } = this.options
+    const accept = this.options?.accept
     if (accept && !matchesMime(blob.mimeType, accept)) {
       return ctx.issueInvalidPropertyValue(blob, 'mimeType', accept)
     }
 
-    const { maxSize } = this.options
+    const maxSize = this.options?.maxSize
     if (maxSize != null && 'size' in blob && blob.size > maxSize) {
       return ctx.issueTooBig(blob, 'blob', maxSize, blob.size)
     }
 
-    return ctx.success(blob as BlobSchemaOutput<O>)
+    return ctx.success(blob)
   }
 
   matchesMime(mime: string): boolean {
-    const { accept } = this.options
+    const accept = this.options?.accept
     if (!accept) return true
     return matchesMime(mime, accept)
   }
@@ -83,3 +79,9 @@ function matchesMime(mime: string, accepted: string[]): boolean {
   }
   return false
 }
+
+export const blob = /*#__PURE__*/ memoizedOptions(function <
+  O extends BlobSchemaOptions = { allowLegacy?: false },
+>(options?: O) {
+  return new BlobSchema(options)
+})

package/src/schema/boolean.test.ts

@@ -1,9 +1,10 @@
 import { describe, expect, it } from 'vitest'
-import { BooleanSchema } from './boolean.js'
+import { boolean } from './boolean.js'
+import { withDefault } from './with-default.js'
 
 describe('BooleanSchema', () => {
   describe('basic validation', () => {
-    const schema = new BooleanSchema()
+    const schema = boolean()
 
     it('validates true', () => {
       const result = schema.safeParse(true)
@@ -54,7 +55,7 @@ describe('BooleanSchema', () => {
 
   describe('with default value', () => {
     it('uses default value of true when input is undefined', () => {
-      const schema = new BooleanSchema({ default: true })
+      const schema = withDefault(boolean(), true)
       const result = schema.safeParse(undefined)
       expect(result.success).toBe(true)
       if (result.success) {
@@ -63,7 +64,7 @@ describe('BooleanSchema', () => {
     })
 
     it('uses default value of false when input is undefined', () => {
-      const schema = new BooleanSchema({ default: false })
+      const schema = withDefault(boolean(), false)
       const result = schema.safeParse(undefined)
       expect(result.success).toBe(true)
       if (result.success) {
@@ -72,7 +73,7 @@ describe('BooleanSchema', () => {
     })
 
     it('overrides default value with explicit true', () => {
-      const schema = new BooleanSchema({ default: false })
+      const schema = withDefault(boolean(), false)
       const result = schema.safeParse(true)
       expect(result.success).toBe(true)
       if (result.success) {
@@ -81,7 +82,7 @@ describe('BooleanSchema', () => {
     })
 
     it('overrides default value with explicit false', () => {
-      const schema = new BooleanSchema({ default: true })
+      const schema = withDefault(boolean(), true)
       const result = schema.safeParse(false)
       expect(result.success).toBe(true)
       if (result.success) {
@@ -90,14 +91,14 @@ describe('BooleanSchema', () => {
     })
 
     it('rejects invalid types even with default', () => {
-      const schema = new BooleanSchema({ default: true })
+      const schema = withDefault(boolean(), true)
       const result = schema.safeParse('not a boolean')
       expect(result.success).toBe(false)
     })
   })
 
   describe('edge cases', () => {
-    const schema = new BooleanSchema()
+    const schema = boolean()
 
     it('rejects Boolean object', () => {
       const result = schema.safeParse(new Boolean(true))

package/src/schema/boolean.ts

@@ -1,18 +1,8 @@
-import { Schema, ValidationResult, ValidatorContext } from '../core.js'
-
-export type BooleanSchemaOptions = {
-  default?: boolean
-}
+import { Schema, ValidationContext } from '../core.js'
+import { memoizedOptions } from '../util/memoize.js'
 
 export class BooleanSchema extends Schema<boolean> {
-  constructor(readonly options?: BooleanSchemaOptions) {
-    super()
-  }
-
-  validateInContext(
-    input: unknown = this.options?.default,
-    ctx: ValidatorContext,
-  ): ValidationResult<boolean> {
+  validateInContext(input: unknown, ctx: ValidationContext) {
     if (typeof input === 'boolean') {
       return ctx.success(input)
     }
@@ -20,3 +10,7 @@ export class BooleanSchema extends Schema<boolean> {
     return ctx.issueInvalidType(input, 'boolean')
   }
 }
+
+export const boolean = /*#__PURE__*/ memoizedOptions(function () {
+  return new BooleanSchema()
+})

package/src/schema/bytes.test.ts

@@ -1,9 +1,9 @@
 import { describe, expect, it } from 'vitest'
-import { BytesSchema } from './bytes.js'
+import { bytes } from './bytes.js'
 
 describe('BytesSchema', () => {
   describe('basic validation', () => {
-    const schema = new BytesSchema({})
+    const schema = bytes({})
 
     it('validates Uint8Array', () => {
       const result = schema.safeParse(new Uint8Array([0, 1, 2, 3]))
@@ -72,7 +72,7 @@ describe('BytesSchema', () => {
   })
 
   describe('minLength constraint', () => {
-    const schema = new BytesSchema({ minLength: 3 })
+    const schema = bytes({ minLength: 3 })
 
     it('validates bytes at minimum length', () => {
       const result = schema.safeParse(new Uint8Array([0, 1, 2]))
@@ -96,7 +96,7 @@ describe('BytesSchema', () => {
   })
 
   describe('maxLength constraint', () => {
-    const schema = new BytesSchema({ maxLength: 5 })
+    const schema = bytes({ maxLength: 5 })
 
     it('validates bytes at maximum length', () => {
       const result = schema.safeParse(new Uint8Array([0, 1, 2, 3, 4]))
@@ -120,7 +120,7 @@ describe('BytesSchema', () => {
   })
 
   describe('minLength and maxLength constraints', () => {
-    const schema = new BytesSchema({ minLength: 2, maxLength: 5 })
+    const schema = bytes({ minLength: 2, maxLength: 5 })
 
     it('validates bytes within range', () => {
       const result = schema.safeParse(new Uint8Array([0, 1, 2]))
@@ -150,37 +150,37 @@ describe('BytesSchema', () => {
 
   describe('edge cases', () => {
     it('validates with minLength of 0', () => {
-      const schema = new BytesSchema({ minLength: 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 = new BytesSchema({ maxLength: 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 = new BytesSchema({ maxLength: 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 = new BytesSchema({})
+      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 = new BytesSchema({})
+      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 = new BytesSchema({})
+      const schema = bytes({})
       const largeArray = new Uint8Array(10000)
       const result = schema.safeParse(largeArray)
       expect(result.success).toBe(true)
@@ -188,7 +188,7 @@ describe('BytesSchema', () => {
   })
 
   describe('TypedArray coercion', () => {
-    const schema = new BytesSchema({})
+    const schema = bytes({})
 
     it('coerces Int8Array to Uint8Array', () => {
       const int8 = new Int8Array([1, 2, 3])
@@ -218,7 +218,7 @@ describe('BytesSchema', () => {
     })
 
     it('validates coerced TypedArray with length constraints', () => {
-      const schema = new BytesSchema({ minLength: 2, maxLength: 10 })
+      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,5 +1,6 @@
-import { asUint8Array } from '@atproto/lex-data'
-import { Schema, ValidationResult, ValidatorContext } from '../core.js'
+import { asUint8Array, ifUint8Array } from '@atproto/lex-data'
+import { Schema, ValidationContext } from '../core.js'
+import { memoizedOptions } from '../util/memoize.js'
 
 export type BytesSchemaOptions = {
   minLength?: number
@@ -11,12 +12,10 @@ export class BytesSchema extends Schema<Uint8Array> {
     super()
   }
 
-  validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<Uint8Array> {
-    // Coerce different binary formats into Uint8Array
-    const bytes = asUint8Array(input)
+  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.issueInvalidType(input, 'bytes')
     }
@@ -34,3 +33,9 @@ export class BytesSchema extends Schema<Uint8Array> {
     return ctx.success(bytes)
   }
 }
+
+export const bytes = /*#__PURE__*/ memoizedOptions(function (
+  options?: BytesSchemaOptions,
+) {
+  return new BytesSchema(options)
+})

package/src/schema/cid.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
 import { parseCid } from '@atproto/lex-data'
-import { CidSchema } from './cid.js'
+import { cid } from './cid.js'
 
 const cborCid = parseCid(
   'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
@@ -26,7 +26,7 @@ const sha512Cid = parseCid(
 
 describe('CidSchema', () => {
   describe('default mode (non-strict)', () => {
-    const schema = new CidSchema({})
+    const schema = cid({})
 
     it('validates CID v1 with DAG-CBOR codec and SHA-256', () => {
       const result = schema.safeParse(cborCid)
@@ -80,7 +80,7 @@ describe('CidSchema', () => {
   })
 
   describe('strict mode', () => {
-    const schema = new CidSchema({ flavor: 'dasl' })
+    const schema = cid({ flavor: 'dasl' })
 
     it('validates CID v1 with DAG-CBOR codec and SHA-256', () => {
       const result = schema.safeParse(cborCid)

package/src/schema/cid.ts

@@ -1,24 +1,19 @@
 import { CheckCidOptions, Cid, InferCheckedCid, isCid } from '@atproto/lex-data'
-import { Schema, ValidationResult, ValidatorContext } from '../core.js'
+import { Schema, ValidationContext } from '../core.js'
+import { memoizedOptions } from '../util/memoize.js'
 
 export type { Cid }
 
 export type CidSchemaOptions = CheckCidOptions
-export type CidSchemaOutput<
-  TOptions extends CidSchemaOptions = { flavor: undefined },
-> = InferCheckedCid<TOptions>
 
-export class CidSchema<TOptions extends CidSchemaOptions> extends Schema<
-  CidSchemaOutput<TOptions>
-> {
-  constructor(readonly options: TOptions) {
+export class CidSchema<
+  const TOptions extends CidSchemaOptions = { flavor: undefined },
+> extends Schema<InferCheckedCid<TOptions>> {
+  constructor(readonly options?: TOptions) {
     super()
   }
 
-  validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<CidSchemaOutput<TOptions>> {
+  validateInContext(input: unknown, ctx: ValidationContext) {
     if (!isCid(input, this.options)) {
       return ctx.issueInvalidType(input, 'cid')
     }
@@ -26,3 +21,9 @@ export class CidSchema<TOptions extends CidSchemaOptions> extends Schema<
     return ctx.success(input)
   }
 }
+
+export const cid = /*#__PURE__*/ memoizedOptions(function <
+  O extends CidSchemaOptions = NonNullable<unknown>,
+>(options?: O) {
+  return new CidSchema(options)
+})