@atproto/lex-schema 0.0.9 → 0.0.10

package/src/schema/refine.test.ts

@@ -1,12 +1,12 @@
 import { describe, expect, it } from 'vitest'
-import { IntegerSchema } from './integer.js'
-import { ObjectSchema } from './object.js'
+import { integer } from './integer.js'
+import { object } from './object.js'
 import { refine } from './refine.js'
-import { StringSchema } from './string.js'
+import { string } from './string.js'
 
 describe('refine', () => {
   describe('basic refinement checks', () => {
-    const schema = refine(new IntegerSchema({}), {
+    const schema = refine(integer(), {
       check: (value) => value > 0,
       message: 'Value must be positive',
     })
@@ -33,7 +33,7 @@ describe('refine', () => {
   })
 
   describe('refinement with type assertions', () => {
-    const schema = refine(new IntegerSchema({}), {
+    const schema = refine(integer(), {
       check: (value): value is 42 => value === 42,
       message: 'Value must be 42',
     })
@@ -50,7 +50,7 @@ describe('refine', () => {
   })
 
   describe('refinement with string schema', () => {
-    const schema = refine(new StringSchema({}), {
+    const schema = refine(string(), {
       check: (value) => value.includes('@'),
       message: 'String must contain @ symbol',
     })
@@ -72,7 +72,7 @@ describe('refine', () => {
   })
 
   describe('refinement with base schema constraints', () => {
-    const schema = refine(new IntegerSchema({ minimum: 0, maximum: 100 }), {
+    const schema = refine(integer({ minimum: 0, maximum: 100 }), {
       check: (value) => value % 2 === 0,
       message: 'Value must be even',
     })
@@ -100,7 +100,7 @@ describe('refine', () => {
 
   describe('multiple refinements chained', () => {
     const schema = refine(
-      refine(new IntegerSchema({}), {
+      refine(integer(), {
         check: (value) => value > 0,
         message: 'Value must be positive',
       }),
@@ -135,7 +135,7 @@ describe('refine', () => {
   })
 
   describe('refinement with custom path', () => {
-    const schema = refine(new IntegerSchema({}), {
+    const schema = refine(integer(), {
       check: (value) => value > 0,
       message: 'Value must be positive',
       path: 'customField',
@@ -153,7 +153,7 @@ describe('refine', () => {
   })
 
   describe('refinement with array path', () => {
-    const schema = refine(new IntegerSchema({}), {
+    const schema = refine(integer(), {
       check: (value) => value > 0,
       message: 'Value must be positive',
       path: ['nested', 'field'],
@@ -171,12 +171,12 @@ describe('refine', () => {
   })
 
   describe('refinement on object properties', () => {
-    const schema = new ObjectSchema({
-      age: refine(new IntegerSchema({}), {
+    const schema = object({
+      age: refine(integer(), {
         check: (value) => value >= 18,
         message: 'Age must be at least 18',
       }),
-      email: refine(new StringSchema({}), {
+      email: refine(string(), {
         check: (value) => value.includes('@'),
         message: 'Email must contain @ symbol',
       }),
@@ -216,7 +216,7 @@ describe('refine', () => {
   })
 
   describe('complex refinement logic', () => {
-    const schema = refine(new StringSchema({}), {
+    const schema = refine(string(), {
       check: (value) => {
         const hasLowerCase = /[a-z]/.test(value)
         const hasUpperCase = /[A-Z]/.test(value)
@@ -253,7 +253,7 @@ describe('refine', () => {
   })
 
   describe('refinement with comparison logic', () => {
-    const schema = refine(new IntegerSchema({}), {
+    const schema = refine(integer(), {
       check: (value) => {
         // Check if value is a prime number
         if (value <= 1) return false
@@ -285,7 +285,7 @@ describe('refine', () => {
   })
 
   describe('refinement with string length logic', () => {
-    const schema = refine(new StringSchema({ minLength: 1, maxLength: 50 }), {
+    const schema = refine(string({ minLength: 1, maxLength: 50 }), {
       check: (value) => value.trim().length > 0,
       message: 'String must not be only whitespace',
     })
@@ -317,7 +317,7 @@ describe('refine', () => {
   })
 
   describe('refinement preserves original schema', () => {
-    const originalSchema = new IntegerSchema({ minimum: 0 })
+    const originalSchema = integer({ minimum: 0 })
     const refinedSchema = refine(originalSchema, {
       check: (value) => value % 2 === 0,
       message: 'Value must be even',
@@ -343,7 +343,7 @@ describe('refine', () => {
   })
 
   describe('refinement with boundary conditions', () => {
-    const schema = refine(new IntegerSchema({ minimum: 0, maximum: 100 }), {
+    const schema = refine(integer({ minimum: 0, maximum: 100 }), {
       check: (value) => value !== 50,
       message: 'Value must not be 50',
     })
@@ -373,7 +373,7 @@ describe('refine', () => {
   })
 
   describe('refinement with regex patterns', () => {
-    const schema = refine(new StringSchema({}), {
+    const schema = refine(string(), {
       check: (value) => /^[A-Z][a-zA-Z0-9]*$/.test(value),
       message: 'Must start with uppercase letter',
     })
@@ -405,7 +405,7 @@ describe('refine', () => {
   })
 
   describe('refinement with custom error messages', () => {
-    const schema = refine(new IntegerSchema({}), {
+    const schema = refine(integer(), {
       check: (value) => value >= 1 && value <= 10,
       message: 'Value must be between 1 and 10 (inclusive)',
     })
@@ -428,7 +428,7 @@ describe('refine', () => {
 
   describe('edge cases', () => {
     it('handles refinement that always returns true', () => {
-      const schema = refine(new IntegerSchema({}), {
+      const schema = refine(integer(), {
         check: () => true,
         message: 'This should never fail',
       })
@@ -437,7 +437,7 @@ describe('refine', () => {
     })
 
     it('handles refinement that always returns false', () => {
-      const schema = refine(new IntegerSchema({}), {
+      const schema = refine(integer(), {
         check: () => false,
         message: 'This always fails',
       })
@@ -446,7 +446,7 @@ describe('refine', () => {
     })
 
     it('handles empty string refinement', () => {
-      const schema = refine(new StringSchema({}), {
+      const schema = refine(string(), {
         check: (value) => value === '',
         message: 'Value must be empty string',
       })
@@ -458,7 +458,7 @@ describe('refine', () => {
     })
 
     it('handles zero value refinement', () => {
-      const schema = refine(new IntegerSchema({}), {
+      const schema = refine(integer(), {
         check: (value) => value === 0,
         message: 'Value must be zero',
       })
@@ -470,7 +470,7 @@ describe('refine', () => {
     })
 
     it('handles negative value refinement', () => {
-      const schema = refine(new IntegerSchema({}), {
+      const schema = refine(integer(), {
         check: (value) => value < 0,
         message: 'Value must be negative',
       })
@@ -483,7 +483,7 @@ describe('refine', () => {
   })
 
   describe('refinement with combined string constraints', () => {
-    const schema = refine(new StringSchema({ minLength: 8, maxLength: 20 }), {
+    const schema = refine(string({ minLength: 8, maxLength: 20 }), {
       check: (value) => {
         const hasSpecialChar = /[!@#$%^&*(),.?":{}|<>]/.test(value)
         const hasLetter = /[a-zA-Z]/.test(value)
@@ -519,7 +519,7 @@ describe('refine', () => {
   })
 
   describe('refinement inheritance', () => {
-    const baseSchema = new IntegerSchema({ minimum: 0, maximum: 1000 })
+    const baseSchema = integer({ minimum: 0, maximum: 1000 })
     const refinedOnce = refine(baseSchema, {
       check: (value) => value % 10 === 0,
       message: 'Must be divisible by 10',
@@ -551,7 +551,7 @@ describe('refine', () => {
   })
 
   describe('refinement with string format validation', () => {
-    const schema = refine(new StringSchema({ format: 'uri' }), {
+    const schema = refine(string({ format: 'uri' }), {
       check: (value) => value.startsWith('https://'),
       message: 'Must be HTTPS URI',
     })

package/src/schema/refine.ts

@@ -1,10 +1,10 @@
 import {
-  Infer,
+  InferInput,
   IssueCustom,
   PropertyKey,
+  ValidationContext,
   ValidationResult,
   Validator,
-  ValidatorContext,
 } from '../core.js'
 import { CustomAssertionContext } from './custom.js'
 
@@ -48,23 +48,26 @@ export type Refinement<T = any, Out extends T = T> =
  * // result.success === false
  * ```
  */
-export function refine<S extends Validator, Out extends Infer<S>>(
-  schema: S,
-  refinement: RefinementAssertion<Infer<S>, Out>,
-): S & Validator<Out>
-export function refine<S extends Validator>(
-  schema: S,
-  refinement: RefinementCheck<Infer<S>>,
-): S
 export function refine<
-  R extends Refinement,
-  S extends Validator<InferRefinement<R>>,
->(schema: S, refinement: R): S
+  const TValidator extends Validator,
+  TInput extends InferInput<TValidator>,
+>(
+  schema: TValidator,
+  refinement: RefinementAssertion<InferInput<TValidator>, TInput>,
+): TValidator & Validator<TInput>
+export function refine<const TValidator extends Validator>(
+  schema: TValidator,
+  refinement: RefinementCheck<InferInput<TValidator>>,
+): TValidator
+export function refine<
+  TRefinement extends Refinement,
+  const TValidator extends Validator<InferRefinement<TRefinement>>,
+>(schema: TValidator, refinement: TRefinement): TValidator
 /*@__NO_SIDE_EFFECTS__*/
-export function refine<S extends Validator>(
-  schema: S,
-  refinement: Refinement<Infer<S>>,
-): S {
+export function refine<const TValidator extends Validator>(
+  schema: TValidator,
+  refinement: Refinement<unknown>,
+): TValidator {
   // This is basically the same as monkey patching the "validateInContext"
   // method to the schema, but done in a way that does not mutate the original
   // schema. This is safe to do because Validators don't update their internal
@@ -84,11 +87,11 @@ export function refine<S extends Validator>(
 function validateInContextUnbound<S extends Validator>(
   this: {
     schema: S
-    refinement: Refinement<Infer<S>>
+    refinement: Refinement<InferInput<S>>
   },
   input: unknown,
-  ctx: ValidatorContext,
-): ValidationResult<Infer<S>> {
+  ctx: ValidationContext,
+): ValidationResult<InferInput<S>> {
   const result = ctx.validate(input, this.schema)
   if (!result.success) return result
 

package/src/schema/regexp.test.ts

@@ -1,9 +1,9 @@
 import { describe, expect, it } from 'vitest'
-import { RegexpSchema } from './regexp.js'
+import { regexp } from './regexp.js'
 
 describe('RegexpSchema', () => {
   describe('basic validation', () => {
-    const schema = new RegexpSchema(/^[a-z]+$/)
+    const schema = regexp(/^[a-z]+$/)
 
     it('validates strings matching the pattern', () => {
       const result = schema.safeParse('hello')
@@ -57,7 +57,7 @@ describe('RegexpSchema', () => {
   })
 
   describe('numeric patterns', () => {
-    const schema = new RegexpSchema(/^\d+$/)
+    const schema = regexp(/^\d+$/)
 
     it('validates numeric strings', () => {
       const result = schema.safeParse('12345')
@@ -81,9 +81,7 @@ describe('RegexpSchema', () => {
   })
 
   describe('email pattern', () => {
-    const schema = new RegexpSchema(
-      /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/,
-    )
+    const schema = regexp(/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/)
 
     it('validates simple email addresses', () => {
       const result = schema.safeParse('user@example.com')
@@ -117,7 +115,7 @@ describe('RegexpSchema', () => {
   })
 
   describe('URL pattern', () => {
-    const schema = new RegexpSchema(/^https?:\/\/[^\s/$.?#].[^\s]*$/)
+    const schema = regexp(/^https?:\/\/[^\s/$.?#].[^\s]*$/)
 
     it('validates HTTP URLs', () => {
       const result = schema.safeParse('http://example.com')
@@ -151,7 +149,7 @@ describe('RegexpSchema', () => {
   })
 
   describe('phone number pattern', () => {
-    const schema = new RegexpSchema(/^\+?[1-9]\d{1,14}$/)
+    const schema = regexp(/^\+?[1-9]\d{1,14}$/)
 
     it('validates simple phone numbers', () => {
       const result = schema.safeParse('1234567890')
@@ -185,7 +183,7 @@ describe('RegexpSchema', () => {
   })
 
   describe('hex color pattern', () => {
-    const schema = new RegexpSchema(/^#[0-9A-Fa-f]{6}$/)
+    const schema = regexp(/^#[0-9A-Fa-f]{6}$/)
 
     it('validates 6-digit hex colors', () => {
       const result = schema.safeParse('#FF5733')
@@ -219,7 +217,7 @@ describe('RegexpSchema', () => {
   })
 
   describe('alphanumeric pattern', () => {
-    const schema = new RegexpSchema(/^[a-zA-Z0-9]+$/)
+    const schema = regexp(/^[a-zA-Z0-9]+$/)
 
     it('validates alphanumeric strings', () => {
       const result = schema.safeParse('abc123')
@@ -253,7 +251,7 @@ describe('RegexpSchema', () => {
   })
 
   describe('case-insensitive pattern', () => {
-    const schema = new RegexpSchema(/^hello$/i)
+    const schema = regexp(/^hello$/i)
 
     it('validates lowercase match', () => {
       const result = schema.safeParse('hello')
@@ -277,7 +275,7 @@ describe('RegexpSchema', () => {
   })
 
   describe('multiline pattern', () => {
-    const schema = new RegexpSchema(/^line\d+$/m)
+    const schema = regexp(/^line\d+$/m)
 
     it('validates single line matching pattern', () => {
       const result = schema.safeParse('line1')
@@ -296,7 +294,7 @@ describe('RegexpSchema', () => {
   })
 
   describe('optional character pattern', () => {
-    const schema = new RegexpSchema(/^colou?r$/)
+    const schema = regexp(/^colou?r$/)
 
     it('validates with optional character present', () => {
       const result = schema.safeParse('colour')
@@ -315,7 +313,7 @@ describe('RegexpSchema', () => {
   })
 
   describe('character range pattern', () => {
-    const schema = new RegexpSchema(/^[0-5]+$/)
+    const schema = regexp(/^[0-5]+$/)
 
     it('validates strings within range', () => {
       const result = schema.safeParse('012345')
@@ -334,7 +332,7 @@ describe('RegexpSchema', () => {
   })
 
   describe('quantifier pattern', () => {
-    const schema = new RegexpSchema(/^a{3}$/)
+    const schema = regexp(/^a{3}$/)
 
     it('validates exact repetition count', () => {
       const result = schema.safeParse('aaa')
@@ -353,7 +351,7 @@ describe('RegexpSchema', () => {
   })
 
   describe('range quantifier pattern', () => {
-    const schema = new RegexpSchema(/^a{2,4}$/)
+    const schema = regexp(/^a{2,4}$/)
 
     it('validates minimum repetition count', () => {
       const result = schema.safeParse('aa')
@@ -382,7 +380,7 @@ describe('RegexpSchema', () => {
   })
 
   describe('alternation pattern', () => {
-    const schema = new RegexpSchema(/^(cat|dog|bird)$/)
+    const schema = regexp(/^(cat|dog|bird)$/)
 
     it('validates first alternative', () => {
       const result = schema.safeParse('cat')
@@ -406,7 +404,7 @@ describe('RegexpSchema', () => {
   })
 
   describe('word boundary pattern', () => {
-    const schema = new RegexpSchema(/\bword\b/)
+    const schema = regexp(/\bword\b/)
 
     it('validates word with boundaries', () => {
       const result = schema.safeParse('word')
@@ -425,7 +423,7 @@ describe('RegexpSchema', () => {
   })
 
   describe('lookahead pattern', () => {
-    const schema = new RegexpSchema(/^(?=.*[A-Z])(?=.*[0-9]).{8,}$/)
+    const schema = regexp(/^(?=.*[A-Z])(?=.*[0-9]).{8,}$/)
 
     it('validates string meeting all lookahead conditions', () => {
       const result = schema.safeParse('Password1')
@@ -454,7 +452,7 @@ describe('RegexpSchema', () => {
   })
 
   describe('unicode pattern', () => {
-    const schema = new RegexpSchema(/^[\u4e00-\u9fa5]+$/)
+    const schema = regexp(/^[\u4e00-\u9fa5]+$/)
 
     it('validates Chinese characters', () => {
       const result = schema.safeParse('你好')
@@ -478,7 +476,7 @@ describe('RegexpSchema', () => {
   })
 
   describe('empty string pattern', () => {
-    const schema = new RegexpSchema(/^$/)
+    const schema = regexp(/^$/)
 
     it('validates empty strings', () => {
       const result = schema.safeParse('')
@@ -497,7 +495,7 @@ describe('RegexpSchema', () => {
   })
 
   describe('wildcard pattern', () => {
-    const schema = new RegexpSchema(/^.*$/)
+    const schema = regexp(/^.*$/)
 
     it('validates empty strings', () => {
       const result = schema.safeParse('')
@@ -522,58 +520,56 @@ describe('RegexpSchema', () => {
 
   describe('edge cases', () => {
     it('handles pattern with escape sequences', () => {
-      const schema = new RegexpSchema(/^\d{3}\.\d{3}\.\d{3}\.\d{3}$/)
+      const schema = regexp(/^\d{3}\.\d{3}\.\d{3}\.\d{3}$/)
       const result = schema.safeParse('192.168.001.001')
       expect(result.success).toBe(true)
     })
 
     it('handles pattern with special regex characters', () => {
-      const schema = new RegexpSchema(/^\$\d+\.\d{2}$/)
+      const schema = regexp(/^\$\d+\.\d{2}$/)
       const result = schema.safeParse('$99.99')
       expect(result.success).toBe(true)
     })
 
     it('handles very long strings', () => {
-      const schema = new RegexpSchema(/^[a-z]+$/)
+      const schema = regexp(/^[a-z]+$/)
       const longString = 'a'.repeat(10000)
       const result = schema.safeParse(longString)
       expect(result.success).toBe(true)
     })
 
     it('handles strings with newlines', () => {
-      const schema = new RegexpSchema(/^hello\nworld$/)
+      const schema = regexp(/^hello\nworld$/)
       const result = schema.safeParse('hello\nworld')
       expect(result.success).toBe(true)
     })
 
     it('handles strings with tabs', () => {
-      const schema = new RegexpSchema(/^hello\tworld$/)
+      const schema = regexp(/^hello\tworld$/)
       const result = schema.safeParse('hello\tworld')
       expect(result.success).toBe(true)
     })
 
     it('handles emoji patterns', () => {
-      const schema = new RegexpSchema(/^[\u{1F600}-\u{1F64F}]+$/u)
+      const schema = regexp(/^[\u{1F600}-\u{1F64F}]+$/u)
       const result = schema.safeParse('😀😃😄')
       expect(result.success).toBe(true)
     })
 
     it('handles global flag in pattern', () => {
-      const schema = new RegexpSchema(/test/g)
+      const schema = regexp(/test/g)
       const result = schema.safeParse('test')
       expect(result.success).toBe(true)
     })
 
     it('handles pattern matching anywhere in string', () => {
-      const schema = new RegexpSchema(/test/)
+      const schema = regexp(/test/)
       const result = schema.safeParse('this is a test string')
       expect(result.success).toBe(true)
     })
 
     it('handles complex nested groups', () => {
-      const schema = new RegexpSchema(
-        /^((https?|ftp):\/\/)?([a-z0-9]+\.)+[a-z]{2,}$/,
-      )
+      const schema = regexp(/^((https?|ftp):\/\/)?([a-z0-9]+\.)+[a-z]{2,}$/)
       const result = schema.safeParse('https://example.com')
       expect(result.success).toBe(true)
     })

package/src/schema/regexp.ts

@@ -1,14 +1,13 @@
-import { Schema, ValidationResult, ValidatorContext } from '../core.js'
+import { Schema, ValidationContext } from '../core.js'
 
-export class RegexpSchema<T extends string> extends Schema<T> {
+export class RegexpSchema<
+  TValue extends string = string,
+> extends Schema<TValue> {
   constructor(public readonly pattern: RegExp) {
     super()
   }
 
-  validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<T> {
+  validateInContext(input: unknown, ctx: ValidationContext) {
     if (typeof input !== 'string') {
       return ctx.issueInvalidType(input, 'string')
     }
@@ -17,6 +16,11 @@ export class RegexpSchema<T extends string> extends Schema<T> {
       return ctx.issueInvalidFormat(input, this.pattern.toString())
     }
 
-    return ctx.success(input as T)
+    return ctx.success(input as TValue)
   }
 }
+
+/*@__NO_SIDE_EFFECTS__*/
+export function regexp<TInput extends string = string>(pattern: RegExp) {
+  return new RegexpSchema<TInput>(pattern)
+}