@atproto/lex-schema 0.0.2 → 0.0.4

package/src/schema/custom.test.ts

@@ -0,0 +1,413 @@
+import { IssueCustom } from '../validation.js'
+import { CustomSchema } from './custom.js'
+
+describe('CustomSchema', () => {
+  describe('basic validation', () => {
+    it('validates input that passes custom assertion', () => {
+      const schema = new CustomSchema(
+        (input): input is string => typeof input === 'string',
+        'Must be a string',
+      )
+      const result = schema.safeParse('hello')
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe('hello')
+      }
+    })
+
+    it('rejects input that fails custom assertion', () => {
+      const schema = new CustomSchema(
+        (input): input is string => typeof input === 'string',
+        'Must be a string',
+      )
+      const result = schema.safeParse(123)
+      expect(result.success).toBe(false)
+    })
+
+    it('includes custom message in error', () => {
+      const schema = new CustomSchema(
+        (input): input is string => typeof input === 'string',
+        'Custom error message',
+      )
+      const result = schema.safeParse(123)
+      expect(result.success).toBe(false)
+      if (!result.success) {
+        expect(result.error.message).toContain('Custom error message')
+      }
+    })
+  })
+
+  describe('complex type guards', () => {
+    it('validates objects with specific properties', () => {
+      interface User {
+        name: string
+        age: number
+      }
+
+      const schema = new CustomSchema((input): input is User => {
+        return (
+          typeof input === 'object' &&
+          input !== null &&
+          'name' in input &&
+          'age' in input &&
+          typeof (input as any).name === 'string' &&
+          typeof (input as any).age === 'number'
+        )
+      }, 'Must be a valid User object')
+
+      expect(schema.matches({ name: 'Alice', age: 30 })).toBe(true)
+    })
+
+    it('rejects objects missing required properties', () => {
+      interface User {
+        name: string
+        age: number
+      }
+
+      const schema = new CustomSchema((input): input is User => {
+        return (
+          typeof input === 'object' &&
+          input !== null &&
+          'name' in input &&
+          'age' in input &&
+          typeof (input as any).name === 'string' &&
+          typeof (input as any).age === 'number'
+        )
+      }, 'Must be a valid User object')
+
+      expect(schema.matches({ name: 'Alice' })).toBe(false)
+    })
+
+    it('validates arrays with specific element types', () => {
+      const schema = new CustomSchema((input): input is number[] => {
+        return (
+          Array.isArray(input) &&
+          input.every((item) => typeof item === 'number')
+        )
+      }, 'Must be an array of numbers')
+
+      const result = schema.safeParse([1, 2, 3, 4])
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects arrays with mixed types', () => {
+      const schema = new CustomSchema((input): input is number[] => {
+        return (
+          Array.isArray(input) &&
+          input.every((item) => typeof item === 'number')
+        )
+      }, 'Must be an array of numbers')
+
+      const result = schema.safeParse([1, 'two', 3])
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('custom context usage', () => {
+    it('can add custom issues through context', () => {
+      const schema = new CustomSchema((input, ctx): input is string => {
+        if (typeof input !== 'string') {
+          ctx.addIssue({
+            code: 'invalid_type',
+            path: ctx.path,
+            input,
+            expected: ['string'],
+          } as any)
+          return false
+        }
+        return true
+      }, 'Must be a string')
+
+      const result = schema.safeParse(123)
+      expect(result.success).toBe(false)
+    })
+
+    it('accesses path from context', () => {
+      let capturedPath: any[] = []
+      const schema = new CustomSchema((input, ctx): input is string => {
+        capturedPath = [...ctx.path]
+        return typeof input === 'string'
+      }, 'Must be a string')
+
+      schema.safeParse('test')
+      expect(capturedPath).toEqual([])
+    })
+
+    it('validates with custom path', () => {
+      const schema = new CustomSchema(
+        (input): input is string => typeof input === 'string',
+        'Must be a string',
+        'customField',
+      )
+
+      const result = schema.safeParse(123)
+      expect(result.success).toBe(false)
+      if (!result.success) {
+        expect(result.error.message).toContain('customField')
+      }
+    })
+
+    it('validates with array of paths', () => {
+      const schema = new CustomSchema(
+        (input): input is string => typeof input === 'string',
+        'Must be a string',
+        ['nested', 'field'],
+      )
+
+      const result = schema.safeParse(123)
+      expect(result.success).toBe(false)
+      if (!result.success) {
+        expect(result.error.message).toContain('nested')
+        expect(result.error.message).toContain('field')
+      }
+    })
+  })
+
+  describe('business logic validation', () => {
+    it('validates email format', () => {
+      const schema = new CustomSchema((input): input is string => {
+        return (
+          typeof input === 'string' && /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(input)
+        )
+      }, 'Must be a valid email address')
+
+      const validResult = schema.safeParse('user@example.com')
+      expect(validResult.success).toBe(true)
+
+      const invalidResult = schema.safeParse('not-an-email')
+      expect(invalidResult.success).toBe(false)
+    })
+
+    it('validates password strength', () => {
+      const schema = new CustomSchema((input): input is string => {
+        if (typeof input !== 'string') return false
+        return (
+          input.length >= 8 &&
+          /[A-Z]/.test(input) &&
+          /[a-z]/.test(input) &&
+          /[0-9]/.test(input)
+        )
+      }, 'Password must be at least 8 characters with uppercase, lowercase, and numbers')
+
+      const validResult = schema.safeParse('MyPass123')
+      expect(validResult.success).toBe(true)
+
+      const weakResult = schema.safeParse('weak')
+      expect(weakResult.success).toBe(false)
+    })
+
+    it('validates age range', () => {
+      const schema = new CustomSchema((input): input is number => {
+        return typeof input === 'number' && input >= 18 && input <= 120
+      }, 'Age must be between 18 and 120')
+
+      const validResult = schema.safeParse(25)
+      expect(validResult.success).toBe(true)
+
+      const tooYoungResult = schema.safeParse(15)
+      expect(tooYoungResult.success).toBe(false)
+
+      const tooOldResult = schema.safeParse(150)
+      expect(tooOldResult.success).toBe(false)
+    })
+
+    it('validates positive numbers', () => {
+      const schema = new CustomSchema((input): input is number => {
+        return typeof input === 'number' && input > 0
+      }, 'Must be a positive number')
+
+      const validResult = schema.safeParse(5)
+      expect(validResult.success).toBe(true)
+
+      const zeroResult = schema.safeParse(0)
+      expect(zeroResult.success).toBe(false)
+
+      const negativeResult = schema.safeParse(-5)
+      expect(negativeResult.success).toBe(false)
+    })
+  })
+
+  describe('edge cases', () => {
+    it('handles null input', () => {
+      const schema = new CustomSchema(
+        (input): input is null => input === null,
+        'Must be null',
+      )
+
+      const validResult = schema.safeParse(null)
+      expect(validResult.success).toBe(true)
+
+      const invalidResult = schema.safeParse(undefined)
+      expect(invalidResult.success).toBe(false)
+    })
+
+    it('handles undefined input', () => {
+      const schema = new CustomSchema(
+        (input): input is undefined => input === undefined,
+        'Must be undefined',
+      )
+
+      const validResult = schema.safeParse(undefined)
+      expect(validResult.success).toBe(true)
+
+      const invalidResult = schema.safeParse(null)
+      expect(invalidResult.success).toBe(false)
+    })
+
+    it('handles empty string', () => {
+      const schema = new CustomSchema(
+        (input): input is string =>
+          typeof input === 'string' && input.length > 0,
+        'Must be a non-empty string',
+      )
+
+      const validResult = schema.safeParse('hello')
+      expect(validResult.success).toBe(true)
+
+      const invalidResult = schema.safeParse('')
+      expect(invalidResult.success).toBe(false)
+    })
+
+    it('handles empty array', () => {
+      const schema = new CustomSchema(
+        (input): input is any[] => Array.isArray(input) && input.length > 0,
+        'Must be a non-empty array',
+      )
+
+      const validResult = schema.safeParse([1, 2, 3])
+      expect(validResult.success).toBe(true)
+
+      const invalidResult = schema.safeParse([])
+      expect(invalidResult.success).toBe(false)
+    })
+
+    it('handles complex nested structures', () => {
+      interface ComplexType {
+        users: Array<{ name: string; email: string }>
+        metadata: { count: number }
+      }
+
+      const schema = new CustomSchema((input): input is ComplexType => {
+        if (typeof input !== 'object' || input === null) return false
+        const obj = input as any
+        return (
+          Array.isArray(obj.users) &&
+          obj.users.every(
+            (u: any) =>
+              typeof u === 'object' &&
+              typeof u.name === 'string' &&
+              typeof u.email === 'string',
+          ) &&
+          typeof obj.metadata === 'object' &&
+          typeof obj.metadata.count === 'number'
+        )
+      }, 'Must be a valid complex structure')
+
+      const validResult = schema.safeParse({
+        users: [
+          { name: 'Alice', email: 'alice@example.com' },
+          { name: 'Bob', email: 'bob@example.com' },
+        ],
+        metadata: { count: 2 },
+      })
+      expect(validResult.success).toBe(true)
+
+      const invalidResult = schema.safeParse({
+        users: [{ name: 'Alice' }], // missing email
+        metadata: { count: 1 },
+      })
+      expect(invalidResult.success).toBe(false)
+    })
+  })
+
+  describe('type narrowing', () => {
+    it('correctly narrows union types', () => {
+      type StringOrNumber = string | number
+
+      const schema = new CustomSchema(
+        (input): input is string => typeof input === 'string',
+        'Must be a string',
+      )
+
+      const input: StringOrNumber = 'hello'
+
+      const result = schema.safeParse(input)
+      expect(result.success).toBe(true)
+
+      if (result.success) {
+        // Type should be narrowed to string
+        const value: string = result.value
+        expect(typeof value).toBe('string')
+      }
+    })
+
+    it('validates discriminated unions', () => {
+      type Shape =
+        | { type: 'circle'; radius: number }
+        | { type: 'rectangle'; width: number; height: number }
+
+      const circleSchema = new CustomSchema((input): input is Shape => {
+        return (
+          typeof input === 'object' &&
+          input !== null &&
+          'type' in input &&
+          (input as any).type === 'circle' &&
+          'radius' in input &&
+          typeof (input as any).radius === 'number'
+        )
+      }, 'Must be a valid circle')
+
+      const validResult = circleSchema.safeParse({ type: 'circle', radius: 5 })
+      expect(validResult.success).toBe(true)
+
+      const invalidResult = circleSchema.safeParse({
+        type: 'rectangle',
+        width: 10,
+        height: 20,
+      })
+      expect(invalidResult.success).toBe(false)
+    })
+  })
+
+  describe('assertion context behavior', () => {
+    it('calls assertion with null as this', () => {
+      const assertion = jest.fn(function (
+        this: unknown,
+        input: unknown,
+      ): input is string {
+        expect(this).toBeNull()
+        return typeof input === 'string'
+      })
+
+      new CustomSchema(assertion as any, 'Must be a string').safeParse('test')
+
+      expect(assertion).toHaveBeenCalledTimes(1)
+    })
+
+    it('provides addIssue method in context', () => {
+      const schema = new CustomSchema((input, ctx): input is string => {
+        ctx.addIssue(new IssueCustom(ctx.path, input, 'This is a custom issue'))
+        return false
+      }, 'Must be a string')
+
+      expect(schema.safeParse('test')).toMatchObject({
+        success: false,
+        error: {
+          issues: [
+            { message: 'This is a custom issue' },
+            { message: 'Must be a string' },
+          ],
+        },
+      })
+    })
+
+    it('provides path array in context', () => {
+      const schema = new CustomSchema((input, ctx): input is string => {
+        expect(Array.isArray(ctx.path)).toBe(true)
+        return typeof input === 'string'
+      }, 'Must be a string')
+
+      schema.safeParse('test')
+    })
+  })
+})

package/src/schema/custom.ts

@@ -1,14 +1,15 @@
-import { PropertyKey } from '../validation/property-key.js'
 import {
-  ContextualIssue,
+  Issue,
+  IssueCustom,
+  PropertyKey,
+  Schema,
   ValidationResult,
-  Validator,
   ValidatorContext,
-} from '../validation/validator.js'
+} from '../validation.js'
 
 export type CustomAssertionContext = {
   path: PropertyKey[]
-  addIssue(issue: ContextualIssue): void
+  addIssue(issue: Issue): void
 }
 
 export type CustomAssertion<T = any> = (
@@ -17,7 +18,7 @@ export type CustomAssertion<T = any> = (
   ctx: CustomAssertionContext,
 ) => input is T
 
-export class CustomSchema<T = unknown> extends Validator<T> {
+export class CustomSchema<T = unknown> extends Schema<T> {
   constructor(
     private readonly assertion: CustomAssertion<T>,
     private readonly message: string,
@@ -26,11 +27,12 @@ export class CustomSchema<T = unknown> extends Validator<T> {
     super()
   }
 
-  override validateInContext(
+  validateInContext(
     input: unknown,
     ctx: ValidatorContext,
   ): ValidationResult<T> {
     if (this.assertion.call(null, input, ctx)) return ctx.success(input as T)
-    return ctx.custom(input, this.message, this.path)
+    const path = ctx.concatPath(this.path)
+    return ctx.failure(new IssueCustom(path, input, this.message))
   }
 }

package/src/schema/dict.test.ts

@@ -0,0 +1,198 @@
+import { BooleanSchema } from './boolean.js'
+import { DictSchema } from './dict.js'
+import { EnumSchema } from './enum.js'
+import { IntegerSchema } from './integer.js'
+import { StringSchema } from './string.js'
+
+describe('DictSchema', () => {
+  const schema = new DictSchema(new StringSchema({}), new IntegerSchema({}))
+
+  it('validates plain objects with valid keys and values', () => {
+    const result = schema.safeParse({
+      count: 42,
+      total: 100,
+      score: 85,
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('validates empty objects', () => {
+    const result = schema.safeParse({})
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects non-objects', () => {
+    const result = schema.safeParse('not an object')
+    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)
+  })
+
+  it('rejects invalid value types', () => {
+    const result = schema.safeParse({
+      count: 'not a number',
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects when one value is invalid', () => {
+    const result = schema.safeParse({
+      count: 42,
+      invalid: 'string',
+      total: 100,
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('validates with enum key schema', () => {
+    const enumKeySchema = new DictSchema(
+      new EnumSchema(['tag1', 'tag2', 'tag3']),
+      new BooleanSchema({}),
+    )
+
+    const result = enumKeySchema.safeParse({
+      tag1: true,
+      tag2: false,
+      tag3: true,
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects invalid keys with enum key schema', () => {
+    const enumKeySchema = new DictSchema(
+      new EnumSchema(['tag1', 'tag2']),
+      new BooleanSchema({}),
+    )
+
+    const result = enumKeySchema.safeParse({
+      tag1: true,
+      invalidTag: false,
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('validates nested dict schemas', () => {
+    const nestedSchema = new DictSchema(
+      new StringSchema({}),
+      new DictSchema(new StringSchema({}), new IntegerSchema({})),
+    )
+
+    const result = nestedSchema.safeParse({
+      group1: { count: 10, total: 20 },
+      group2: { score: 85 },
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('validates with string key schema constraints', () => {
+    const constrainedKeySchema = new DictSchema(
+      new StringSchema({ minLength: 3, maxLength: 10 }),
+      new IntegerSchema({}),
+    )
+
+    const result = constrainedKeySchema.safeParse({
+      abc: 1,
+      defghij: 2,
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects keys that do not meet key schema constraints', () => {
+    const constrainedKeySchema = new DictSchema(
+      new StringSchema({ minLength: 3 }),
+      new IntegerSchema({}),
+    )
+
+    const result = constrainedKeySchema.safeParse({
+      ab: 1, // too short
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('validates with value schema constraints', () => {
+    const constrainedValueSchema = new DictSchema(
+      new StringSchema({}),
+      new IntegerSchema({ minimum: 0, maximum: 100 }),
+    )
+
+    const result = constrainedValueSchema.safeParse({
+      score: 50,
+      total: 100,
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects values that do not meet value schema constraints', () => {
+    const constrainedValueSchema = new DictSchema(
+      new StringSchema({}),
+      new IntegerSchema({ minimum: 0, maximum: 100 }),
+    )
+
+    const result = constrainedValueSchema.safeParse({
+      score: 150, // too high
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('validates dict with string values', () => {
+    const stringValueSchema = new DictSchema(
+      new StringSchema({}),
+      new StringSchema({}),
+    )
+
+    const result = stringValueSchema.safeParse({
+      name: 'Alice',
+      city: 'New York',
+      country: 'USA',
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('validates dict with boolean values', () => {
+    const booleanValueSchema = new DictSchema(
+      new StringSchema({}),
+      new BooleanSchema({}),
+    )
+
+    const result = booleanValueSchema.safeParse({
+      enabled: true,
+      visible: false,
+      active: true,
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('handles objects with numeric string keys', () => {
+    const result = schema.safeParse({
+      '0': 1,
+      '1': 2,
+      '2': 3,
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('preserves the original object when no transformations occur', () => {
+    const input = { count: 42, total: 100 }
+    const result = schema.safeParse(input)
+
+    if (result.success) {
+      // The implementation returns the same object if no changes are needed
+      expect(result.value).toBe(input)
+    } else {
+      throw new Error('Expected validation to succeed')
+    }
+  })
+})

package/src/schema/dict.ts

@@ -1,18 +1,16 @@
 import { isPlainObject } from '@atproto/lex-data'
 import {
   Infer,
+  Schema,
   ValidationResult,
   Validator,
   ValidatorContext,
 } from '../validation.js'
 
 export type DictSchemaOutput<
-  KeySchema extends Validator,
+  KeySchema extends Validator<string>,
   ValueSchema extends Validator,
-> =
-  Infer<KeySchema> extends never
-    ? Record<string, never>
-    : Record<Infer<KeySchema> & string, Infer<ValueSchema>>
+> = Record<Infer<KeySchema>, Infer<ValueSchema>>
 
 /**
  * @note There is no dictionary in Lexicon schemas. This is a custom extension
@@ -20,9 +18,9 @@ export type DictSchemaOutput<
  * not code generated from a lexicon schema).
  */
 export class DictSchema<
-  const KeySchema extends Validator = any,
+  const KeySchema extends Validator<string> = any,
   const ValueSchema extends Validator = any,
-> extends Validator<DictSchemaOutput<KeySchema, ValueSchema>> {
+> extends Schema<DictSchemaOutput<KeySchema, ValueSchema>> {
   constructor(
     readonly keySchema: KeySchema,
     readonly valueSchema: ValueSchema,
@@ -30,7 +28,7 @@ export class DictSchema<
     super()
   }
 
-  override validateInContext(
+  validateInContext(
     input: unknown,
     ctx: ValidatorContext,
     options?: { ignoredKeys?: { has(k: string): boolean } },