@atproto/lex-schema 0.0.8 → 0.0.10

package/src/schema/string.test.ts

@@ -1,10 +1,11 @@
 import { describe, expect, it } from 'vitest'
-import { StringSchema } from './string.js'
-import { TokenSchema } from './token.js'
+import { string } from './string.js'
+import { token } from './token.js'
+import { withDefault } from './with-default.js'
 
 describe('StringSchema', () => {
   describe('basic validation', () => {
-    const schema = new StringSchema({})
+    const schema = string()
 
     it('validates plain strings', () => {
       const result = schema.safeParse('hello world')
@@ -49,7 +50,7 @@ describe('StringSchema', () => {
 
   describe('default values', () => {
     it('uses default value when no input provided', () => {
-      const schema = new StringSchema({ default: 'default value' })
+      const schema = withDefault(string(), 'default value')
       const result = schema.safeParse(undefined)
       expect(result.success).toBe(true)
       if (result.success) {
@@ -58,14 +59,14 @@ describe('StringSchema', () => {
     })
 
     it('validates default value against constraints', () => {
-      const schema = new StringSchema({ default: 'hi', minLength: 5 })
+      const schema = string({ default: 'hi', minLength: 5 })
       const result = schema.safeParse(undefined)
       expect(result.success).toBe(false)
     })
   })
 
   describe('minLength constraint', () => {
-    const schema = new StringSchema({ minLength: 5 })
+    const schema = string({ minLength: 5 })
 
     it('accepts strings meeting minimum length', () => {
       const result = schema.safeParse('hello')
@@ -89,7 +90,7 @@ describe('StringSchema', () => {
   })
 
   describe('maxLength constraint', () => {
-    const schema = new StringSchema({ maxLength: 10 })
+    const schema = string({ maxLength: 10 })
 
     it('accepts strings meeting maximum length', () => {
       const result = schema.safeParse('1234567890')
@@ -113,20 +114,20 @@ describe('StringSchema', () => {
 
     it('correctly handles UTF-8 multi-byte characters', () => {
       // Emoji takes 4 bytes in UTF-8
-      const schema = new StringSchema({ maxLength: 4 })
+      const schema = string({ maxLength: 4 })
       const result = schema.safeParse('😀')
       expect(result.success).toBe(true)
     })
 
     it('rejects when multi-byte characters exceed maxLength', () => {
-      const schema = new StringSchema({ maxLength: 3 })
+      const schema = string({ maxLength: 3 })
       const result = schema.safeParse('😀')
       expect(result.success).toBe(false)
     })
   })
 
   describe('combined min and max length', () => {
-    const schema = new StringSchema({ minLength: 3, maxLength: 10 })
+    const schema = string({ minLength: 3, maxLength: 10 })
 
     it('accepts strings within range', () => {
       const result = schema.safeParse('hello')
@@ -155,7 +156,7 @@ describe('StringSchema', () => {
   })
 
   describe('minGraphemes constraint', () => {
-    const schema = new StringSchema({ minGraphemes: 3 })
+    const schema = string({ minGraphemes: 3 })
 
     it('accepts strings meeting minimum graphemes', () => {
       const result = schema.safeParse('abc')
@@ -184,7 +185,7 @@ describe('StringSchema', () => {
   })
 
   describe('maxGraphemes constraint', () => {
-    const schema = new StringSchema({ maxGraphemes: 5 })
+    const schema = string({ maxGraphemes: 5 })
 
     it('accepts strings meeting maximum graphemes', () => {
       const result = schema.safeParse('hello')
@@ -213,7 +214,7 @@ describe('StringSchema', () => {
   })
 
   describe('combined grapheme constraints', () => {
-    const schema = new StringSchema({ minGraphemes: 2, maxGraphemes: 5 })
+    const schema = string({ minGraphemes: 2, maxGraphemes: 5 })
 
     it('accepts strings within grapheme range', () => {
       const result = schema.safeParse('hello')
@@ -242,7 +243,7 @@ describe('StringSchema', () => {
   })
 
   describe('format: datetime', () => {
-    const schema = new StringSchema({ format: 'datetime' })
+    const schema = string({ format: 'datetime' })
 
     it('accepts valid ISO datetime strings', () => {
       const result = schema.safeParse('2023-12-25T12:00:00Z')
@@ -266,7 +267,7 @@ describe('StringSchema', () => {
   })
 
   describe('format: uri', () => {
-    const schema = new StringSchema({ format: 'uri' })
+    const schema = string({ format: 'uri' })
 
     it('accepts valid HTTP URIs', () => {
       const result = schema.safeParse('https://example.com')
@@ -295,7 +296,7 @@ describe('StringSchema', () => {
   })
 
   describe('format: at-uri', () => {
-    const schema = new StringSchema({ format: 'at-uri' })
+    const schema = string({ format: 'at-uri' })
 
     it('accepts valid AT URI', () => {
       const result = schema.safeParse(
@@ -316,7 +317,7 @@ describe('StringSchema', () => {
   })
 
   describe('format: did', () => {
-    const schema = new StringSchema({ format: 'did' })
+    const schema = string({ format: 'did' })
 
     it('accepts valid DID with plc method', () => {
       const result = schema.safeParse('did:plc:abc123')
@@ -340,7 +341,7 @@ describe('StringSchema', () => {
   })
 
   describe('format: handle', () => {
-    const schema = new StringSchema({ format: 'handle' })
+    const schema = string({ format: 'handle' })
 
     it('accepts valid handle', () => {
       const result = schema.safeParse('user.bsky.social')
@@ -364,7 +365,7 @@ describe('StringSchema', () => {
   })
 
   describe('format: at-identifier', () => {
-    const schema = new StringSchema({ format: 'at-identifier' })
+    const schema = string({ format: 'at-identifier' })
 
     it('accepts valid DID as at-identifier', () => {
       const result = schema.safeParse('did:plc:abc123')
@@ -383,7 +384,7 @@ describe('StringSchema', () => {
   })
 
   describe('format: nsid', () => {
-    const schema = new StringSchema({ format: 'nsid' })
+    const schema = string({ format: 'nsid' })
 
     it('accepts valid NSID', () => {
       const result = schema.safeParse('app.bsky.feed.post')
@@ -407,7 +408,7 @@ describe('StringSchema', () => {
   })
 
   describe('format: cid', () => {
-    const schema = new StringSchema({ format: 'cid' })
+    const schema = string({ format: 'cid' })
 
     it('accepts valid CID v1', () => {
       const result = schema.safeParse(
@@ -428,7 +429,7 @@ describe('StringSchema', () => {
   })
 
   describe('format: language', () => {
-    const schema = new StringSchema({ format: 'language' })
+    const schema = string({ format: 'language' })
 
     it('accepts valid BCP 47 language code', () => {
       const result = schema.safeParse('en')
@@ -452,7 +453,7 @@ describe('StringSchema', () => {
   })
 
   describe('format: tid', () => {
-    const schema = new StringSchema({ format: 'tid' })
+    const schema = string({ format: 'tid' })
 
     it('accepts valid TID', () => {
       const result = schema.safeParse('3jzfcijpj2z2a')
@@ -471,7 +472,7 @@ describe('StringSchema', () => {
   })
 
   describe('format: record-key', () => {
-    const schema = new StringSchema({ format: 'record-key' })
+    const schema = string({ format: 'record-key' })
 
     it('accepts valid record key', () => {
       const result = schema.safeParse('3jzfcijpj2z2a')
@@ -495,7 +496,7 @@ describe('StringSchema', () => {
   })
 
   describe('type coercion', () => {
-    const schema = new StringSchema({})
+    const schema = string()
 
     it('coerces Date objects to ISO strings', () => {
       const date = new Date('2023-12-25T12:00:00Z')
@@ -531,17 +532,16 @@ describe('StringSchema', () => {
     })
 
     it('coerces TokenSchema instances to strings', () => {
-      const token = new TokenSchema('mytoken')
-      const result = schema.safeParse(token)
+      const result = schema.safeParse(token('my.to.ken', 'main'))
       expect(result.success).toBe(true)
       if (result.success) {
-        expect(result.value).toBe('mytoken')
+        expect(result.value).toBe('my.to.ken')
       }
     })
   })
 
   describe('combined constraints and format', () => {
-    const schema = new StringSchema({
+    const schema = string({
       format: 'handle',
       minLength: 5,
       maxLength: 50,
@@ -572,39 +572,39 @@ describe('StringSchema', () => {
 
   describe('edge cases', () => {
     it('handles strings with special characters', () => {
-      const schema = new StringSchema({})
+      const schema = string()
       const result = schema.safeParse('hello\nworld\ttab')
       expect(result.success).toBe(true)
     })
 
     it('handles strings with unicode characters', () => {
-      const schema = new StringSchema({})
+      const schema = string()
       const result = schema.safeParse('Hello 世界 🌍')
       expect(result.success).toBe(true)
     })
 
     it('handles very long strings', () => {
-      const schema = new StringSchema({ maxLength: 10000 })
+      const schema = string({ maxLength: 10000 })
       const longString = 'a'.repeat(10000)
       const result = schema.safeParse(longString)
       expect(result.success).toBe(true)
     })
 
     it('rejects very long strings exceeding maxLength', () => {
-      const schema = new StringSchema({ maxLength: 100 })
+      const schema = string({ maxLength: 100 })
       const longString = 'a'.repeat(101)
       const result = schema.safeParse(longString)
       expect(result.success).toBe(false)
     })
 
     it('handles zero as minLength', () => {
-      const schema = new StringSchema({ minLength: 0 })
+      const schema = string({ minLength: 0 })
       const result = schema.safeParse('')
       expect(result.success).toBe(true)
     })
 
     it('handles complex emoji sequences', () => {
-      const schema = new StringSchema({ maxGraphemes: 5 })
+      const schema = string({ maxGraphemes: 5 })
       // Family emoji is a single grapheme cluster
       const result = schema.safeParse('👨‍👩‍👧‍👦')
       expect(result.success).toBe(true)

package/src/schema/string.ts

@@ -3,14 +3,13 @@ import {
   InferStringFormat,
   Schema,
   StringFormat,
-  ValidationResult,
-  ValidatorContext,
-  assertStringFormat,
+  ValidationContext,
+  isStringFormat,
 } from '../core.js'
+import { memoizedOptions } from '../util/memoize.js'
 import { TokenSchema } from './token.js'
 
 export type StringSchemaOptions = {
-  default?: string
   format?: StringFormat
   minLength?: number
   maxLength?: number
@@ -18,26 +17,18 @@ export type StringSchemaOptions = {
   maxGraphemes?: number
 }
 
-export type StringSchemaOutput<Options> =
-  //
-  Options extends { format: infer F extends StringFormat }
+export class StringSchema<
+  const TOptions extends StringSchemaOptions = StringSchemaOptions,
+> extends Schema<
+  TOptions extends { format: infer F extends StringFormat }
     ? InferStringFormat<F>
     : string
-
-export class StringSchema<
-  const Options extends StringSchemaOptions = any,
-> extends Schema<StringSchemaOutput<Options>> {
-  constructor(readonly options: Options) {
+> {
+  constructor(readonly options?: TOptions) {
     super()
   }
 
-  validateInContext(
-    // @NOTE validation will be applied on the default value as well
-    input: unknown = this.options.default,
-    ctx: ValidatorContext,
-  ): ValidationResult<StringSchemaOutput<Options>> {
-    const { options } = this
-
+  validateInContext(input: unknown, ctx: ValidationContext) {
     const str = coerceToString(input)
     if (str == null) {
       return ctx.issueInvalidType(input, 'string')
@@ -45,14 +36,14 @@ export class StringSchema<
 
     let lazyUtf8Len: number
 
-    const { minLength } = options
+    const minLength = this.options?.minLength
     if (minLength != null) {
       if ((lazyUtf8Len ??= utf8Len(str)) < minLength) {
         return ctx.issueTooSmall(str, 'string', minLength, lazyUtf8Len)
       }
     }
 
-    const { maxLength } = options
+    const maxLength = this.options?.maxLength
     if (maxLength != null) {
       // Optimization: we can avoid computing the UTF-8 length if the maximum
       // possible length, in bytes, of the input JS string is smaller than the
@@ -66,7 +57,7 @@ export class StringSchema<
 
     let lazyGraphLen: number
 
-    const { minGraphemes } = options
+    const minGraphemes = this.options?.minGraphemes
     if (minGraphemes != null) {
       // Optimization: avoid counting graphemes if the length check already fails
       if (str.length < minGraphemes) {
@@ -76,25 +67,19 @@ export class StringSchema<
       }
     }
 
-    const { maxGraphemes } = options
+    const maxGraphemes = this.options?.maxGraphemes
     if (maxGraphemes != null) {
       if ((lazyGraphLen ??= graphemeLen(str)) > maxGraphemes) {
         return ctx.issueTooBig(str, 'grapheme', maxGraphemes, lazyGraphLen)
       }
     }
 
-    if (options.format !== undefined) {
-      try {
-        // @TODO optimize to avoid throw cost (requires re-writing utilities
-        // from @atproto/syntax)
-        assertStringFormat(str, options.format)
-      } catch (err) {
-        const message = err instanceof Error ? err.message : undefined
-        return ctx.issueInvalidFormat(str, options.format, message)
-      }
+    const format = this.options?.format
+    if (format != null && !isStringFormat(str, format)) {
+      return ctx.issueInvalidFormat(str, format)
     }
 
-    return ctx.success(str as StringSchemaOutput<Options>)
+    return ctx.success(str)
   }
 }
 
@@ -137,3 +122,9 @@ export function coerceToString(input: unknown): string | null {
       return null
   }
 }
+
+export const string = /*#__PURE__*/ memoizedOptions(function <
+  const O extends StringSchemaOptions = NonNullable<unknown>,
+>(options?: StringSchemaOptions & O) {
+  return new StringSchema<O>(options)
+})