@atproto/lex-schema 0.0.8 → 0.0.10

package/src/schema/custom.test.ts

@@ -1,11 +1,11 @@
 import { describe, expect, it, vi } from 'vitest'
 import { IssueCustom } from '../core.js'
-import { CustomSchema } from './custom.js'
+import { custom } from './custom.js'
 
 describe('CustomSchema', () => {
   describe('basic validation', () => {
     it('validates input that passes custom assertion', () => {
-      const schema = new CustomSchema(
+      const schema = custom(
         (input): input is string => typeof input === 'string',
         'Must be a string',
       )
@@ -17,7 +17,7 @@ describe('CustomSchema', () => {
     })
 
     it('rejects input that fails custom assertion', () => {
-      const schema = new CustomSchema(
+      const schema = custom(
         (input): input is string => typeof input === 'string',
         'Must be a string',
       )
@@ -26,7 +26,7 @@ describe('CustomSchema', () => {
     })
 
     it('includes custom message in error', () => {
-      const schema = new CustomSchema(
+      const schema = custom(
         (input): input is string => typeof input === 'string',
         'Custom error message',
       )
@@ -45,7 +45,7 @@ describe('CustomSchema', () => {
         age: number
       }
 
-      const schema = new CustomSchema((input): input is User => {
+      const schema = custom((input): input is User => {
         return (
           typeof input === 'object' &&
           input !== null &&
@@ -65,7 +65,7 @@ describe('CustomSchema', () => {
         age: number
       }
 
-      const schema = new CustomSchema((input): input is User => {
+      const schema = custom((input): input is User => {
         return (
           typeof input === 'object' &&
           input !== null &&
@@ -80,7 +80,7 @@ describe('CustomSchema', () => {
     })
 
     it('validates arrays with specific element types', () => {
-      const schema = new CustomSchema((input): input is number[] => {
+      const schema = custom((input): input is number[] => {
         return (
           Array.isArray(input) &&
           input.every((item) => typeof item === 'number')
@@ -92,7 +92,7 @@ describe('CustomSchema', () => {
     })
 
     it('rejects arrays with mixed types', () => {
-      const schema = new CustomSchema((input): input is number[] => {
+      const schema = custom((input): input is number[] => {
         return (
           Array.isArray(input) &&
           input.every((item) => typeof item === 'number')
@@ -106,7 +106,7 @@ describe('CustomSchema', () => {
 
   describe('custom context usage', () => {
     it('can add custom issues through context', () => {
-      const schema = new CustomSchema((input, ctx): input is string => {
+      const schema = custom((input, ctx): input is string => {
         if (typeof input !== 'string') {
           ctx.addIssue({
             code: 'invalid_type',
@@ -125,7 +125,7 @@ describe('CustomSchema', () => {
 
     it('accesses path from context', () => {
       let capturedPath: any[] = []
-      const schema = new CustomSchema((input, ctx): input is string => {
+      const schema = custom((input, ctx): input is string => {
         capturedPath = [...ctx.path]
         return typeof input === 'string'
       }, 'Must be a string')
@@ -135,7 +135,7 @@ describe('CustomSchema', () => {
     })
 
     it('validates with custom path', () => {
-      const schema = new CustomSchema(
+      const schema = custom(
         (input): input is string => typeof input === 'string',
         'Must be a string',
         'customField',
@@ -149,7 +149,7 @@ describe('CustomSchema', () => {
     })
 
     it('validates with array of paths', () => {
-      const schema = new CustomSchema(
+      const schema = custom(
         (input): input is string => typeof input === 'string',
         'Must be a string',
         ['nested', 'field'],
@@ -166,7 +166,7 @@ describe('CustomSchema', () => {
 
   describe('business logic validation', () => {
     it('validates email format', () => {
-      const schema = new CustomSchema((input): input is string => {
+      const schema = custom((input): input is string => {
         return (
           typeof input === 'string' && /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(input)
         )
@@ -180,7 +180,7 @@ describe('CustomSchema', () => {
     })
 
     it('validates password strength', () => {
-      const schema = new CustomSchema((input): input is string => {
+      const schema = custom((input): input is string => {
         if (typeof input !== 'string') return false
         return (
           input.length >= 8 &&
@@ -198,7 +198,7 @@ describe('CustomSchema', () => {
     })
 
     it('validates age range', () => {
-      const schema = new CustomSchema((input): input is number => {
+      const schema = custom((input): input is number => {
         return typeof input === 'number' && input >= 18 && input <= 120
       }, 'Age must be between 18 and 120')
 
@@ -213,7 +213,7 @@ describe('CustomSchema', () => {
     })
 
     it('validates positive numbers', () => {
-      const schema = new CustomSchema((input): input is number => {
+      const schema = custom((input): input is number => {
         return typeof input === 'number' && input > 0
       }, 'Must be a positive number')
 
@@ -230,7 +230,7 @@ describe('CustomSchema', () => {
 
   describe('edge cases', () => {
     it('handles null input', () => {
-      const schema = new CustomSchema(
+      const schema = custom(
         (input): input is null => input === null,
         'Must be null',
       )
@@ -243,7 +243,7 @@ describe('CustomSchema', () => {
     })
 
     it('handles undefined input', () => {
-      const schema = new CustomSchema(
+      const schema = custom(
         (input): input is undefined => input === undefined,
         'Must be undefined',
       )
@@ -256,7 +256,7 @@ describe('CustomSchema', () => {
     })
 
     it('handles empty string', () => {
-      const schema = new CustomSchema(
+      const schema = custom(
         (input): input is string =>
           typeof input === 'string' && input.length > 0,
         'Must be a non-empty string',
@@ -270,7 +270,7 @@ describe('CustomSchema', () => {
     })
 
     it('handles empty array', () => {
-      const schema = new CustomSchema(
+      const schema = custom(
         (input): input is any[] => Array.isArray(input) && input.length > 0,
         'Must be a non-empty array',
       )
@@ -288,7 +288,7 @@ describe('CustomSchema', () => {
         metadata: { count: number }
       }
 
-      const schema = new CustomSchema((input): input is ComplexType => {
+      const schema = custom((input): input is ComplexType => {
         if (typeof input !== 'object' || input === null) return false
         const obj = input as any
         return (
@@ -325,7 +325,7 @@ describe('CustomSchema', () => {
     it('correctly narrows union types', () => {
       type StringOrNumber = string | number
 
-      const schema = new CustomSchema(
+      const schema = custom(
         (input): input is string => typeof input === 'string',
         'Must be a string',
       )
@@ -347,7 +347,7 @@ describe('CustomSchema', () => {
         | { type: 'circle'; radius: number }
         | { type: 'rectangle'; width: number; height: number }
 
-      const circleSchema = new CustomSchema((input): input is Shape => {
+      const circleSchema = custom((input): input is Shape => {
         return (
           typeof input === 'object' &&
           input !== null &&
@@ -380,13 +380,13 @@ describe('CustomSchema', () => {
         return typeof input === 'string'
       })
 
-      new CustomSchema(assertion as any, 'Must be a string').safeParse('test')
+      custom(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 => {
+      const schema = custom((input, ctx): input is string => {
         ctx.addIssue(new IssueCustom(ctx.path, input, 'This is a custom issue'))
         return false
       }, 'Must be a string')
@@ -403,7 +403,7 @@ describe('CustomSchema', () => {
     })
 
     it('provides path array in context', () => {
-      const schema = new CustomSchema((input, ctx): input is string => {
+      const schema = custom((input, ctx): input is string => {
         expect(Array.isArray(ctx.path)).toBe(true)
         return typeof input === 'string'
       }, 'Must be a string')

package/src/schema/custom.ts

@@ -3,8 +3,7 @@ import {
   IssueCustom,
   PropertyKey,
   Schema,
-  ValidationResult,
-  ValidatorContext,
+  ValidationContext,
 } from '../core.js'
 
 export type CustomAssertionContext = {
@@ -12,27 +11,35 @@ export type CustomAssertionContext = {
   addIssue(issue: Issue): void
 }
 
-export type CustomAssertion<T = any> = (
+export type CustomAssertion<TValue> = (
   this: null,
   input: unknown,
   ctx: CustomAssertionContext,
-) => input is T
+) => input is TValue
 
-export class CustomSchema<T = unknown> extends Schema<T> {
+export class CustomSchema<const TValue = unknown> extends Schema<TValue> {
   constructor(
-    private readonly assertion: CustomAssertion<T>,
+    private readonly assertion: CustomAssertion<TValue>,
     private readonly message: string,
     private readonly path?: PropertyKey | readonly PropertyKey[],
   ) {
     super()
   }
 
-  validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<T> {
-    if (this.assertion.call(null, input, ctx)) return ctx.success(input as T)
-    const path = ctx.concatPath(this.path)
-    return ctx.issue(new IssueCustom(path, input, this.message))
+  validateInContext(input: unknown, ctx: ValidationContext) {
+    if (!this.assertion.call(null, input, ctx)) {
+      const path = ctx.concatPath(this.path)
+      return ctx.issue(new IssueCustom(path, input, this.message))
+    }
+    return ctx.success(input as TValue)
   }
 }
+
+/*@__NO_SIDE_EFFECTS__*/
+export function custom<TValue>(
+  assertion: CustomAssertion<TValue>,
+  message: string,
+  path?: PropertyKey | readonly PropertyKey[],
+) {
+  return new CustomSchema<TValue>(assertion, message, path)
+}

package/src/schema/dict.test.ts

@@ -1,12 +1,12 @@
 import { describe, expect, it } from 'vitest'
-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'
+import { boolean } from './boolean.js'
+import { dict } from './dict.js'
+import { enumSchema } from './enum.js'
+import { integer } from './integer.js'
+import { string } from './string.js'
 
 describe('DictSchema', () => {
-  const schema = new DictSchema(new StringSchema({}), new IntegerSchema({}))
+  const schema = dict(string(), integer())
 
   it('validates plain objects with valid keys and values', () => {
     const result = schema.safeParse({
@@ -59,10 +59,7 @@ describe('DictSchema', () => {
   })
 
   it('validates with enum key schema', () => {
-    const enumKeySchema = new DictSchema(
-      new EnumSchema(['tag1', 'tag2', 'tag3']),
-      new BooleanSchema({}),
-    )
+    const enumKeySchema = dict(enumSchema(['tag1', 'tag2', 'tag3']), boolean())
 
     const result = enumKeySchema.safeParse({
       tag1: true,
@@ -73,10 +70,7 @@ describe('DictSchema', () => {
   })
 
   it('rejects invalid keys with enum key schema', () => {
-    const enumKeySchema = new DictSchema(
-      new EnumSchema(['tag1', 'tag2']),
-      new BooleanSchema({}),
-    )
+    const enumKeySchema = dict(enumSchema(['tag1', 'tag2']), boolean())
 
     const result = enumKeySchema.safeParse({
       tag1: true,
@@ -86,10 +80,7 @@ describe('DictSchema', () => {
   })
 
   it('validates nested dict schemas', () => {
-    const nestedSchema = new DictSchema(
-      new StringSchema({}),
-      new DictSchema(new StringSchema({}), new IntegerSchema({})),
-    )
+    const nestedSchema = dict(string(), dict(string(), integer()))
 
     const result = nestedSchema.safeParse({
       group1: { count: 10, total: 20 },
@@ -99,9 +90,9 @@ describe('DictSchema', () => {
   })
 
   it('validates with string key schema constraints', () => {
-    const constrainedKeySchema = new DictSchema(
-      new StringSchema({ minLength: 3, maxLength: 10 }),
-      new IntegerSchema({}),
+    const constrainedKeySchema = dict(
+      string({ minLength: 3, maxLength: 10 }),
+      integer(),
     )
 
     const result = constrainedKeySchema.safeParse({
@@ -112,10 +103,7 @@ describe('DictSchema', () => {
   })
 
   it('rejects keys that do not meet key schema constraints', () => {
-    const constrainedKeySchema = new DictSchema(
-      new StringSchema({ minLength: 3 }),
-      new IntegerSchema({}),
-    )
+    const constrainedKeySchema = dict(string({ minLength: 3 }), integer())
 
     const result = constrainedKeySchema.safeParse({
       ab: 1, // too short
@@ -124,9 +112,9 @@ describe('DictSchema', () => {
   })
 
   it('validates with value schema constraints', () => {
-    const constrainedValueSchema = new DictSchema(
-      new StringSchema({}),
-      new IntegerSchema({ minimum: 0, maximum: 100 }),
+    const constrainedValueSchema = dict(
+      string(),
+      integer({ minimum: 0, maximum: 100 }),
     )
 
     const result = constrainedValueSchema.safeParse({
@@ -137,9 +125,9 @@ describe('DictSchema', () => {
   })
 
   it('rejects values that do not meet value schema constraints', () => {
-    const constrainedValueSchema = new DictSchema(
-      new StringSchema({}),
-      new IntegerSchema({ minimum: 0, maximum: 100 }),
+    const constrainedValueSchema = dict(
+      string(),
+      integer({ minimum: 0, maximum: 100 }),
     )
 
     const result = constrainedValueSchema.safeParse({
@@ -149,10 +137,7 @@ describe('DictSchema', () => {
   })
 
   it('validates dict with string values', () => {
-    const stringValueSchema = new DictSchema(
-      new StringSchema({}),
-      new StringSchema({}),
-    )
+    const stringValueSchema = dict(string(), string())
 
     const result = stringValueSchema.safeParse({
       name: 'Alice',
@@ -163,10 +148,7 @@ describe('DictSchema', () => {
   })
 
   it('validates dict with boolean values', () => {
-    const booleanValueSchema = new DictSchema(
-      new StringSchema({}),
-      new BooleanSchema({}),
-    )
+    const booleanValueSchema = dict(string(), boolean())
 
     const result = booleanValueSchema.safeParse({
       enabled: true,

package/src/schema/dict.ts

@@ -1,38 +1,36 @@
 import { isPlainObject } from '@atproto/lex-data'
 import {
-  Infer,
+  InferInput,
+  InferOutput,
   Schema,
-  ValidationResult,
+  ValidationContext,
   Validator,
-  ValidatorContext,
 } from '../core.js'
 
-export type DictSchemaOutput<
-  KeySchema extends Validator<string>,
-  ValueSchema extends Validator,
-> = Record<Infer<KeySchema>, Infer<ValueSchema>>
-
 /**
  * @note There is no dictionary in Lexicon schemas. This is a custom extension
  * to allow map-like objects when using the lex library programmatically (i.e.
  * not code generated from a lexicon schema).
  */
 export class DictSchema<
-  const KeySchema extends Validator<string> = any,
-  const ValueSchema extends Validator = any,
-> extends Schema<DictSchemaOutput<KeySchema, ValueSchema>> {
+  const TKey extends Validator<string> = any,
+  const TValue extends Validator = any,
+> extends Schema<
+  Record<InferInput<TKey>, InferInput<TValue>>,
+  Record<InferInput<TKey>, InferOutput<TValue>>
+> {
   constructor(
-    readonly keySchema: KeySchema,
-    readonly valueSchema: ValueSchema,
+    readonly keySchema: TKey,
+    readonly valueSchema: TValue,
   ) {
     super()
   }
 
   validateInContext(
     input: unknown,
-    ctx: ValidatorContext,
+    ctx: ValidationContext,
     options?: { ignoredKeys?: { has(k: string): boolean } },
-  ): ValidationResult<DictSchemaOutput<KeySchema, ValueSchema>> {
+  ) {
     if (!isPlainObject(input)) {
       return ctx.issueInvalidType(input, 'dict')
     }
@@ -54,14 +52,25 @@ export class DictSchema<
       const valueResult = ctx.validateChild(input, key, this.valueSchema)
       if (!valueResult.success) return valueResult
 
-      if (valueResult.value !== input[key]) {
+      if (!Object.is(valueResult.value, input[key])) {
+        if (ctx.options.mode === 'validate') {
+          // In "validate" mode, we can't modify the input, so we issue an error
+          return ctx.issueInvalidPropertyValue(input, key, [valueResult.value])
+        }
+
         copy ??= { ...input }
         copy[key] = valueResult.value
       }
     }
 
-    return ctx.success(
-      (copy ?? input) as DictSchemaOutput<KeySchema, ValueSchema>,
-    )
+    return ctx.success(copy ?? input)
   }
 }
+
+/*@__NO_SIDE_EFFECTS__*/
+export function dict<
+  const TKey extends Validator<string>,
+  const TValue extends Validator,
+>(key: TKey, value: TValue) {
+  return new DictSchema<TKey, TValue>(key, value)
+}