@atproto/lex-schema 0.0.9 → 0.0.10

package/src/helpers.test.ts

@@ -81,7 +81,7 @@ describe('InferMethodInput', () => {
     test('with payload schema', () => {
       const procedure = l.procedure(
         'com.example.create',
-        l.params({}),
+        l.params(),
         l.payload('application/json', l.object({ text: l.string() })),
         l.payload(undefined, undefined),
         undefined,
@@ -103,7 +103,7 @@ describe('InferMethodInput', () => {
     test('without payload schema', () => {
       const procedure = l.procedure(
         'com.example.create',
-        l.params({}),
+        l.params(),
         l.payload('*/*', undefined),
         l.payload(undefined, undefined),
         undefined,
@@ -127,7 +127,7 @@ describe('InferMethodInputBody', () => {
     test('with payload schema', () => {
       const procedure = l.procedure(
         'com.example.create',
-        l.params({}),
+        l.params(),
         l.payload('application/json', l.object({ text: l.string() })),
         l.payload(undefined, undefined),
         undefined,
@@ -145,7 +145,7 @@ describe('InferMethodInputBody', () => {
     test('without payload schema', () => {
       const procedure = l.procedure(
         'com.example.upload',
-        l.params({}),
+        l.params(),
         l.payload('*/*', undefined),
         l.payload(undefined, undefined),
         undefined,
@@ -167,7 +167,7 @@ describe('InferMethodInputEncoding', () => {
     test('with payload schema', () => {
       const procedure = l.procedure(
         'com.example.create',
-        l.params({}),
+        l.params(),
         l.payload('application/json', l.object({ text: l.string() })),
         l.payload(undefined, undefined),
         undefined,
@@ -185,7 +185,7 @@ describe('InferMethodInputEncoding', () => {
     test('without payload schema', () => {
       const procedure = l.procedure(
         'com.example.upload',
-        l.params({}),
+        l.params(),
         l.payload('*/*', undefined),
         l.payload(undefined, undefined),
         undefined,
@@ -206,7 +206,7 @@ describe('InferMethodOutput', () => {
     test('with payload schema', () => {
       const query = l.query(
         'com.example.query',
-        l.params({}),
+        l.params(),
         l.payload('application/json', l.object({ items: l.array(l.string()) })),
       )
 
@@ -222,7 +222,7 @@ describe('InferMethodOutput', () => {
     test('without payload schema', () => {
       const query = l.query(
         'com.example.query',
-        l.params({}),
+        l.params(),
         l.payload('*/*', undefined),
       )
 
@@ -240,7 +240,7 @@ describe('InferMethodOutput', () => {
     test('with payload schema', () => {
       const procedure = l.procedure(
         'com.example.create',
-        l.params({}),
+        l.params(),
         l.payload(undefined, undefined),
         l.payload(
           'application/json',
@@ -266,7 +266,7 @@ describe('InferMethodOutput', () => {
     test('without payload schema', () => {
       const procedure = l.procedure(
         'com.example.export',
-        l.params({}),
+        l.params(),
         l.payload(undefined, undefined),
         l.payload('*/*', undefined),
         undefined,
@@ -294,7 +294,7 @@ describe('InferMethodOutputBody', () => {
     test('with payload schema', () => {
       const query = l.query(
         'com.example.query',
-        l.params({}),
+        l.params(),
         l.payload(
           'application/json',
           l.object({
@@ -319,7 +319,7 @@ describe('InferMethodOutputBody', () => {
     test('without payload schema', () => {
       const query = l.query(
         'com.example.query',
-        l.params({}),
+        l.params(),
         l.payload('*/*', undefined),
       )
 
@@ -337,7 +337,7 @@ describe('InferMethodOutputBody', () => {
     test('with payload schema', () => {
       const procedure = l.procedure(
         'com.example.get',
-        l.params({}),
+        l.params(),
         l.payload(undefined, undefined),
         l.payload(
           'application/json',
@@ -358,7 +358,7 @@ describe('InferMethodOutputBody', () => {
     test('without payload schema', () => {
       const procedure = l.procedure(
         'com.example.export',
-        l.params({}),
+        l.params(),
         l.payload(undefined, undefined),
         l.payload('*/*', undefined),
         undefined,
@@ -380,7 +380,7 @@ describe('InferMethodOutputEncoding', () => {
     test('with payload schema', () => {
       const query = l.query(
         'com.example.query',
-        l.params({}),
+        l.params(),
         l.payload('application/json', l.object({ data: l.string() })),
       )
 
@@ -396,7 +396,7 @@ describe('InferMethodOutputEncoding', () => {
     test('without payload schema', () => {
       const query = l.query(
         'com.example.query',
-        l.params({}),
+        l.params(),
         l.payload('*/*', undefined),
       )
 
@@ -413,7 +413,7 @@ describe('InferMethodOutputEncoding', () => {
     test('with payload schema', () => {
       const procedure = l.procedure(
         'com.example.create',
-        l.params({}),
+        l.params(),
         l.payload(undefined, undefined),
         l.payload('application/json', l.object({ id: l.string() })),
         undefined,
@@ -431,7 +431,7 @@ describe('InferMethodOutputEncoding', () => {
     test('without payload schema', () => {
       const procedure = l.procedure(
         'com.example.export',
-        l.params({}),
+        l.params(),
         l.payload(undefined, undefined),
         l.payload('*/*', undefined),
         undefined,
@@ -452,7 +452,7 @@ describe('InferMethodMessage', () => {
     test('with message schema', () => {
       const subscription = l.subscription(
         'com.example.subscribe',
-        l.params({}),
+        l.params(),
         l.object({
           seq: l.integer(),
           event: l.string(),
@@ -473,13 +473,14 @@ describe('InferMethodMessage', () => {
     test('without message schema', () => {
       const subscription = l.subscription(
         'com.example.subscribe',
-        l.params({}),
+        l.params(),
         l.unknown(),
       )
 
       type Message = l.InferMethodMessage<typeof subscription>
 
-      expectType<Message>(undefined as unknown)
+      // @ts-expect-error "unknown" is turned into LexValue
+      expectType<Message>(undefined)
       expectType<Message>({ any: 'value' })
       expectType<Message>(123)
     })

package/src/helpers.ts

@@ -1,16 +1,16 @@
-import { LexErrorData } from '@atproto/lex-data'
-import { Infer, Restricted, Schema } from './core.js'
+import { LexErrorData, LexValue } from '@atproto/lex-data'
+import { InferOutput, Restricted, Schema } from './core.js'
 import {
   InferPayload,
   InferPayloadBody,
   InferPayloadEncoding,
-  ObjectSchema,
-  OptionalSchema,
   Payload,
   Procedure,
   Query,
-  StringSchema,
   Subscription,
+  object,
+  optional,
+  string,
 } from './schema.js'
 
 export type Main<T> = T | { main: T }
@@ -29,10 +29,8 @@ export function getMain<T extends object>(ns: Main<T>): T {
  */
 type BinaryData = Restricted<'Binary data'>
 
-export type InferMethodParams<
-  //
-  M extends Procedure | Query | Subscription,
-> = Infer<M['parameters']>
+export type InferMethodParams<M extends Procedure | Query | Subscription> =
+  InferOutput<M['parameters']>
 
 export type InferMethodInput<
   M extends Procedure | Query | Subscription,
@@ -67,9 +65,11 @@ export type InferMethodOutputEncoding<
 export type InferMethodMessage<
   //
   M extends Procedure | Query | Subscription,
-> = M extends { message: Schema } ? Infer<M['message']> : undefined
+> = M extends { message: Schema }
+  ? LexValue & InferOutput<M['message']>
+  : undefined
 
-export const lexErrorData: Schema<LexErrorData> = new ObjectSchema({
-  error: new StringSchema({ minLength: 1 }),
-  message: new OptionalSchema(new StringSchema({})),
-})
+export const lexErrorData = object({
+  error: string({ minLength: 1 }),
+  message: optional(string()),
+}) satisfies Schema<LexErrorData>

package/src/schema/array.test.ts

@@ -1,27 +1,27 @@
 import { describe, expect, it } from 'vitest'
-import { ArraySchema } from './array.js'
-import { IntegerSchema } from './integer.js'
-import { ObjectSchema } from './object.js'
-import { StringSchema } from './string.js'
+import { array } from './array.js'
+import { integer } from './integer.js'
+import { object } from './object.js'
+import { string } from './string.js'
 
 describe('ArraySchema', () => {
   it('validates arrays with string items', () => {
-    const schema = new ArraySchema(new StringSchema({}))
+    const schema = array(string())
     const result = schema.safeParse(['hello', 'world'])
     expect(result.success).toBe(true)
   })
 
   it('validates arrays with integer items', () => {
-    const schema = new ArraySchema(new IntegerSchema({}))
+    const schema = array(integer())
     const result = schema.safeParse([1, 2, 3])
     expect(result.success).toBe(true)
   })
 
   it('validates arrays with object items', () => {
-    const schema = new ArraySchema(
-      new ObjectSchema({
-        name: new StringSchema({}),
-        age: new IntegerSchema({}),
+    const schema = array(
+      object({
+        name: string(),
+        age: integer(),
       }),
     )
     const result = schema.safeParse([
@@ -32,74 +32,74 @@ describe('ArraySchema', () => {
   })
 
   it('validates empty arrays', () => {
-    const schema = new ArraySchema(new StringSchema({}))
+    const schema = array(string())
     const result = schema.safeParse([])
     expect(result.success).toBe(true)
   })
 
   it('rejects non-array values', () => {
-    const schema = new ArraySchema(new StringSchema({}))
+    const schema = array(string())
     const result = schema.safeParse('not an array')
     expect(result.success).toBe(false)
   })
 
   it('rejects null values', () => {
-    const schema = new ArraySchema(new StringSchema({}))
+    const schema = array(string())
     const result = schema.safeParse(null)
     expect(result.success).toBe(false)
   })
 
   it('rejects undefined values', () => {
-    const schema = new ArraySchema(new StringSchema({}))
+    const schema = array(string())
     const result = schema.safeParse(undefined)
     expect(result.success).toBe(false)
   })
 
   it('rejects objects that look like arrays', () => {
-    const schema = new ArraySchema(new StringSchema({}))
+    const schema = array(string())
     const result = schema.safeParse({ 0: 'a', 1: 'b', length: 2 })
     expect(result.success).toBe(false)
   })
 
   it('rejects arrays with invalid items', () => {
-    const schema = new ArraySchema(new IntegerSchema({}))
+    const schema = array(integer())
     const result = schema.safeParse([1, 2, 'three'])
     expect(result.success).toBe(false)
   })
 
   it('rejects arrays with some invalid items', () => {
-    const schema = new ArraySchema(new StringSchema({}))
+    const schema = array(string())
     const result = schema.safeParse(['valid', null, 'also valid'])
     expect(result.success).toBe(false)
   })
 
   describe('minLength constraint', () => {
     it('validates arrays meeting minLength', () => {
-      const schema = new ArraySchema(new StringSchema({}), { minLength: 2 })
+      const schema = array(string(), { minLength: 2 })
       const result = schema.safeParse(['a', 'b'])
       expect(result.success).toBe(true)
     })
 
     it('validates arrays exceeding minLength', () => {
-      const schema = new ArraySchema(new StringSchema({}), { minLength: 2 })
+      const schema = array(string(), { minLength: 2 })
       const result = schema.safeParse(['a', 'b', 'c'])
       expect(result.success).toBe(true)
     })
 
     it('rejects arrays below minLength', () => {
-      const schema = new ArraySchema(new StringSchema({}), { minLength: 3 })
+      const schema = array(string(), { minLength: 3 })
       const result = schema.safeParse(['a', 'b'])
       expect(result.success).toBe(false)
     })
 
     it('rejects empty arrays when minLength is set', () => {
-      const schema = new ArraySchema(new StringSchema({}), { minLength: 1 })
+      const schema = array(string(), { minLength: 1 })
       const result = schema.safeParse([])
       expect(result.success).toBe(false)
     })
 
     it('validates empty arrays when minLength is 0', () => {
-      const schema = new ArraySchema(new StringSchema({}), { minLength: 0 })
+      const schema = array(string(), { minLength: 0 })
       const result = schema.safeParse([])
       expect(result.success).toBe(true)
     })
@@ -107,37 +107,37 @@ describe('ArraySchema', () => {
 
   describe('maxLength constraint', () => {
     it('validates arrays meeting maxLength', () => {
-      const schema = new ArraySchema(new StringSchema({}), { maxLength: 3 })
+      const schema = array(string(), { maxLength: 3 })
       const result = schema.safeParse(['a', 'b', 'c'])
       expect(result.success).toBe(true)
     })
 
     it('validates arrays below maxLength', () => {
-      const schema = new ArraySchema(new StringSchema({}), { maxLength: 3 })
+      const schema = array(string(), { maxLength: 3 })
       const result = schema.safeParse(['a', 'b'])
       expect(result.success).toBe(true)
     })
 
     it('rejects arrays exceeding maxLength', () => {
-      const schema = new ArraySchema(new StringSchema({}), { maxLength: 2 })
+      const schema = array(string(), { maxLength: 2 })
       const result = schema.safeParse(['a', 'b', 'c'])
       expect(result.success).toBe(false)
     })
 
     it('validates empty arrays with maxLength', () => {
-      const schema = new ArraySchema(new StringSchema({}), { maxLength: 5 })
+      const schema = array(string(), { maxLength: 5 })
       const result = schema.safeParse([])
       expect(result.success).toBe(true)
     })
 
     it('rejects empty arrays when maxLength is 0', () => {
-      const schema = new ArraySchema(new StringSchema({}), { maxLength: 0 })
+      const schema = array(string(), { maxLength: 0 })
       const result = schema.safeParse(['a'])
       expect(result.success).toBe(false)
     })
 
     it('validates empty arrays when maxLength is 0', () => {
-      const schema = new ArraySchema(new StringSchema({}), { maxLength: 0 })
+      const schema = array(string(), { maxLength: 0 })
       const result = schema.safeParse([])
       expect(result.success).toBe(true)
     })
@@ -145,7 +145,7 @@ describe('ArraySchema', () => {
 
   describe('minLength and maxLength together', () => {
     it('validates arrays within range', () => {
-      const schema = new ArraySchema(new StringSchema({}), {
+      const schema = array(string(), {
         minLength: 2,
         maxLength: 4,
       })
@@ -154,7 +154,7 @@ describe('ArraySchema', () => {
     })
 
     it('validates arrays at min boundary', () => {
-      const schema = new ArraySchema(new StringSchema({}), {
+      const schema = array(string(), {
         minLength: 2,
         maxLength: 4,
       })
@@ -163,7 +163,7 @@ describe('ArraySchema', () => {
     })
 
     it('validates arrays at max boundary', () => {
-      const schema = new ArraySchema(new StringSchema({}), {
+      const schema = array(string(), {
         minLength: 2,
         maxLength: 4,
       })
@@ -172,7 +172,7 @@ describe('ArraySchema', () => {
     })
 
     it('rejects arrays below minLength', () => {
-      const schema = new ArraySchema(new StringSchema({}), {
+      const schema = array(string(), {
         minLength: 2,
         maxLength: 4,
       })
@@ -181,7 +181,7 @@ describe('ArraySchema', () => {
     })
 
     it('rejects arrays above maxLength', () => {
-      const schema = new ArraySchema(new StringSchema({}), {
+      const schema = array(string(), {
         minLength: 2,
         maxLength: 4,
       })
@@ -190,7 +190,7 @@ describe('ArraySchema', () => {
     })
 
     it('validates single-length range', () => {
-      const schema = new ArraySchema(new StringSchema({}), {
+      const schema = array(string(), {
         minLength: 3,
         maxLength: 3,
       })
@@ -199,7 +199,7 @@ describe('ArraySchema', () => {
     })
 
     it('rejects arrays not matching exact length', () => {
-      const schema = new ArraySchema(new StringSchema({}), {
+      const schema = array(string(), {
         minLength: 3,
         maxLength: 3,
       })
@@ -210,7 +210,7 @@ describe('ArraySchema', () => {
 
   describe('nested arrays', () => {
     it('validates arrays of arrays', () => {
-      const schema = new ArraySchema(new ArraySchema(new StringSchema({})))
+      const schema = array(array(string()))
       const result = schema.safeParse([
         ['a', 'b'],
         ['c', 'd'],
@@ -219,7 +219,7 @@ describe('ArraySchema', () => {
     })
 
     it('rejects invalid nested arrays', () => {
-      const schema = new ArraySchema(new ArraySchema(new IntegerSchema({})))
+      const schema = array(array(integer()))
       const result = schema.safeParse([
         [1, 2],
         [3, 'four'],
@@ -228,9 +228,7 @@ describe('ArraySchema', () => {
     })
 
     it('validates deeply nested arrays', () => {
-      const schema = new ArraySchema(
-        new ArraySchema(new ArraySchema(new IntegerSchema({}))),
-      )
+      const schema = array(array(array(integer())))
       const result = schema.safeParse([[[1, 2], [3]], [[4, 5, 6]]])
       expect(result.success).toBe(true)
     })

package/src/schema/array.ts

@@ -1,30 +1,29 @@
 import {
-  Infer,
+  InferInput,
+  InferOutput,
   Schema,
-  ValidationResult,
+  ValidationContext,
   Validator,
-  ValidatorContext,
 } from '../core.js'
+import { memoizedTransformer } from '../util/memoize.js'
 
 export type ArraySchemaOptions = {
   minLength?: number
   maxLength?: number
 }
 
-export class ArraySchema<const T extends Validator> extends Schema<
-  Array<Infer<T>>
+export class ArraySchema<const TItem extends Validator> extends Schema<
+  Array<InferInput<TItem>>,
+  Array<InferOutput<TItem>>
 > {
   constructor(
-    readonly itemsSchema: T,
+    readonly validator: TItem,
     readonly options: ArraySchemaOptions = {},
   ) {
     super()
   }
 
-  validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<Array<Infer<T>>> {
+  validateInContext(input: unknown, ctx: ValidationContext) {
     if (!Array.isArray(input)) {
       return ctx.issueInvalidType(input, 'array')
     }
@@ -39,19 +38,42 @@ export class ArraySchema<const T extends Validator> extends Schema<
       return ctx.issueTooBig(input, 'array', maxLength, input.length)
     }
 
-    let copy: undefined | Array<Infer<T>>
+    let copy: undefined | unknown[]
 
     for (let i = 0; i < input.length; i++) {
-      const result = ctx.validateChild(input, i, this.itemsSchema)
+      const result = ctx.validateChild(input, i, this.validator)
       if (!result.success) return result
 
       if (result.value !== input[i]) {
+        if (ctx.options.mode === 'validate') {
+          // In "validate" mode, we can't modify the input, so we issue an error
+          return ctx.issueInvalidPropertyValue(input, i, [result.value])
+        }
+
         // Copy on write (but only if we did not already make a copy)
         copy ??= Array.from(input)
         copy[i] = result.value
       }
     }
 
-    return ctx.success(copy ?? input) as ValidationResult<Array<Infer<T>>>
+    return ctx.success(copy ?? input)
   }
 }
+
+/*@__NO_SIDE_EFFECTS__*/
+function arraySchema<const TValidator extends Validator>(
+  items: TValidator,
+  options?: ArraySchemaOptions,
+): ArraySchema<TValidator>
+function arraySchema<
+  const TValue,
+  const TValidator extends Validator<TValue> = Validator<TValue>,
+>(items: TValidator, options?: ArraySchemaOptions): ArraySchema<TValidator>
+function arraySchema<const TValidator extends Validator>(
+  items: TValidator,
+  options?: ArraySchemaOptions,
+) {
+  return new ArraySchema<TValidator>(items, options)
+}
+
+export const array = /*#__PURE__*/ memoizedTransformer(arraySchema)