@atproto/lex-schema 0.0.11 → 0.0.12

package/src/helpers.test.ts

@@ -38,9 +38,8 @@ describe('InferMethodParams', () => {
       const procedure = l.procedure(
         'com.example.list',
         l.params({ limit: l.string() }),
-        l.payload(undefined, undefined),
-        l.payload(undefined, undefined),
-        undefined,
+        l.payload(),
+        l.payload(),
       )
 
       type Params = l.InferMethodParams<typeof procedure>
@@ -62,7 +61,7 @@ describe('InferMethodParams', () => {
         l.params({
           cursor: l.optional(l.integer()),
         }),
-        l.unknown(),
+        l.unknownObject(),
       )
 
       type Params = l.InferMethodParams<typeof subscription>
@@ -82,9 +81,8 @@ describe('InferMethodInput', () => {
       const procedure = l.procedure(
         'com.example.create',
         l.params(),
-        l.payload('application/json', l.object({ text: l.string() })),
-        l.payload(undefined, undefined),
-        undefined,
+        l.jsonPayload({ text: l.string() }),
+        l.payload(),
       )
 
       type Input = l.InferMethodInput<typeof procedure, BinaryValue>
@@ -93,6 +91,8 @@ describe('InferMethodInput', () => {
       // @ts-expect-error
       expectType<Input>({ encoding: 'application/json', body: { text: 123 } })
       // @ts-expect-error
+      expectType<Input>({ encoding: 'text/plain', body: { text: 'hi' } })
+      // @ts-expect-error
       expectType<Input>({ encoding: 'text/plain', body: 'hello' })
       // @ts-expect-error
       expectType<Input>({ encoding: 'text/plain', body: new Uint8Array() })
@@ -105,8 +105,7 @@ describe('InferMethodInput', () => {
         'com.example.create',
         l.params(),
         l.payload('*/*', undefined),
-        l.payload(undefined, undefined),
-        undefined,
+        l.payload(),
       )
 
       type Input = l.InferMethodInput<typeof procedure, BinaryValue>
@@ -128,9 +127,8 @@ describe('InferMethodInputBody', () => {
       const procedure = l.procedure(
         'com.example.create',
         l.params(),
-        l.payload('application/json', l.object({ text: l.string() })),
-        l.payload(undefined, undefined),
-        undefined,
+        l.jsonPayload({ text: l.string() }),
+        l.payload(),
       )
 
       type InputBody = l.InferMethodInputBody<typeof procedure, BinaryValue>
@@ -147,8 +145,7 @@ describe('InferMethodInputBody', () => {
         'com.example.upload',
         l.params(),
         l.payload('*/*', undefined),
-        l.payload(undefined, undefined),
-        undefined,
+        l.payload(),
       )
 
       type InputBody = l.InferMethodInputBody<typeof procedure, BinaryValue>
@@ -168,9 +165,8 @@ describe('InferMethodInputEncoding', () => {
       const procedure = l.procedure(
         'com.example.create',
         l.params(),
-        l.payload('application/json', l.object({ text: l.string() })),
-        l.payload(undefined, undefined),
-        undefined,
+        l.jsonPayload({ text: l.string() }),
+        l.payload(),
       )
 
       type InputEncoding = l.InferMethodInputEncoding<typeof procedure>
@@ -187,8 +183,7 @@ describe('InferMethodInputEncoding', () => {
         'com.example.upload',
         l.params(),
         l.payload('*/*', undefined),
-        l.payload(undefined, undefined),
-        undefined,
+        l.payload(),
       )
 
       type InputEncoding = l.InferMethodInputEncoding<typeof procedure>
@@ -203,11 +198,42 @@ describe('InferMethodInputEncoding', () => {
 
 describe('InferMethodOutput', () => {
   describe('query', () => {
+    test('generic output', () => {
+      const query = l.query(
+        'com.example.query',
+        l.params(),
+        l.payload(),
+      ) as unknown as l.Query
+      const unknownValue = {} as unknown
+      const lexValue = {} as l.LexValue
+
+      type Output = l.InferMethodOutput<typeof query, BinaryValue>
+
+      expectType<Output>(undefined)
+      expectType<Output>({ body: binaryValue, encoding: 'text/plain' })
+      expectType<Output>({ body: lexValue, encoding: 'application/json' })
+
+      expectType<Output>({
+        // @ts-expect-error
+        body: unknownValue,
+        encoding: 'application/octet-stream',
+      })
+
+      class Foo {
+        constructor(readonly field: number = 3) {}
+      }
+      expectType<Output>({
+        // @ts-expect-error
+        body: new Foo(),
+        encoding: 'application/octet-stream',
+      })
+    })
+
     test('with payload schema', () => {
       const query = l.query(
         'com.example.query',
         l.params(),
-        l.payload('application/json', l.object({ items: l.array(l.string()) })),
+        l.jsonPayload({ items: l.array(l.string()) }),
       )
 
       type Output = l.InferMethodOutput<typeof query, BinaryValue>
@@ -237,11 +263,44 @@ describe('InferMethodOutput', () => {
   })
 
   describe('procedure', () => {
+    test('generic output', () => {
+      const procedure = l.procedure(
+        'com.example.procedure',
+        l.params(),
+        l.payload(),
+        l.payload(),
+      ) as unknown as l.Procedure
+      const unknownValue = {} as unknown
+      const lexValue = {} as l.LexValue
+
+      type Output = l.InferMethodOutput<typeof procedure, BinaryValue>
+
+      expectType<Output>(undefined)
+      expectType<Output>({ body: binaryValue, encoding: 'text/plain' })
+      expectType<Output>({ body: lexValue, encoding: 'application/json' })
+      expectType<Output>({ body: { foo: 'bar' }, encoding: 'application/json' })
+
+      expectType<Output>({
+        // @ts-expect-error
+        body: unknownValue,
+        encoding: 'application/octet-stream',
+      })
+
+      class Foo {
+        constructor(readonly field: number = 3) {}
+      }
+      expectType<Output>({
+        // @ts-expect-error
+        body: new Foo(),
+        encoding: 'application/octet-stream',
+      })
+    })
+
     test('with payload schema', () => {
       const procedure = l.procedure(
         'com.example.create',
         l.params(),
-        l.payload(undefined, undefined),
+        l.payload(),
         l.payload(
           'application/json',
           l.object({ uri: l.string({ format: 'at-uri' }) }),
@@ -267,7 +326,7 @@ describe('InferMethodOutput', () => {
       const procedure = l.procedure(
         'com.example.export',
         l.params(),
-        l.payload(undefined, undefined),
+        l.payload(),
         l.payload('*/*', undefined),
         undefined,
       )
@@ -291,6 +350,27 @@ describe('InferMethodOutput', () => {
 
 describe('InferMethodOutputBody', () => {
   describe('query', () => {
+    test('generic output', () => {
+      const query = l.query(
+        'com.example.query',
+        l.params(),
+        l.payload(),
+      ) as unknown as l.Query
+      const lexValue = {} as l.LexValue
+
+      type OutputBody = l.InferMethodOutputBody<typeof query, BinaryValue>
+
+      expectType<OutputBody>(undefined)
+      expectType<OutputBody>(binaryValue)
+      expectType<OutputBody>(lexValue)
+
+      class Foo {
+        constructor(readonly field: number = 3) {}
+      }
+      // @ts-expect-error
+      expectType<OutputBody>(new Foo())
+    })
+
     test('with payload schema', () => {
       const query = l.query(
         'com.example.query',
@@ -338,7 +418,7 @@ describe('InferMethodOutputBody', () => {
       const procedure = l.procedure(
         'com.example.get',
         l.params(),
-        l.payload(undefined, undefined),
+        l.payload(),
         l.payload(
           'application/json',
           l.object({ uri: l.string({ format: 'at-uri' }) }),
@@ -359,7 +439,7 @@ describe('InferMethodOutputBody', () => {
       const procedure = l.procedure(
         'com.example.export',
         l.params(),
-        l.payload(undefined, undefined),
+        l.payload(),
         l.payload('*/*', undefined),
         undefined,
       )
@@ -381,7 +461,7 @@ describe('InferMethodOutputEncoding', () => {
       const query = l.query(
         'com.example.query',
         l.params(),
-        l.payload('application/json', l.object({ data: l.string() })),
+        l.jsonPayload({ data: l.string() }),
       )
 
       type OutputEncoding = l.InferMethodOutputEncoding<typeof query>
@@ -414,8 +494,8 @@ describe('InferMethodOutputEncoding', () => {
       const procedure = l.procedure(
         'com.example.create',
         l.params(),
-        l.payload(undefined, undefined),
-        l.payload('application/json', l.object({ id: l.string() })),
+        l.payload(),
+        l.jsonPayload({ id: l.string() }),
         undefined,
       )
 
@@ -432,7 +512,7 @@ describe('InferMethodOutputEncoding', () => {
       const procedure = l.procedure(
         'com.example.export',
         l.params(),
-        l.payload(undefined, undefined),
+        l.payload(),
         l.payload('*/*', undefined),
         undefined,
       )
@@ -474,13 +554,14 @@ describe('InferMethodMessage', () => {
       const subscription = l.subscription(
         'com.example.subscribe',
         l.params(),
-        l.unknown(),
+        l.integer(),
       )
 
       type Message = l.InferMethodMessage<typeof subscription>
 
       // @ts-expect-error "unknown" is turned into LexValue
       expectType<Message>(undefined)
+      // @ts-expect-error Not a LexValue
       expectType<Message>({ any: 'value' })
       expectType<Message>(123)
     })

package/src/helpers.ts

@@ -1,10 +1,9 @@
-import { LexErrorData, LexValue } from '@atproto/lex-data'
+import { LexErrorData } from '@atproto/lex-data'
 import { InferOutput, Restricted, Schema } from './core.js'
 import {
   InferPayload,
   InferPayloadBody,
   InferPayloadEncoding,
-  Payload,
   Procedure,
   Query,
   Subscription,
@@ -35,39 +34,35 @@ export type InferMethodParams<M extends Procedure | Query | Subscription> =
 export type InferMethodInput<
   M extends Procedure | Query | Subscription,
   B = BinaryData,
-> = M extends { input: Payload } ? InferPayload<M['input'], B> : undefined
+> = M extends Procedure ? InferPayload<M['input'], B> : undefined
 
 export type InferMethodInputBody<
   M extends Procedure | Query | Subscription,
   B = BinaryData,
-> = M extends { input: Payload } ? InferPayloadBody<M['input'], B> : undefined
+> = M extends Procedure ? InferPayloadBody<M['input'], B> : undefined
 
 export type InferMethodInputEncoding<
   M extends Procedure | Query | Subscription,
-> = M extends { input: Payload } ? InferPayloadEncoding<M['input']> : undefined
+> = M extends Procedure ? InferPayloadEncoding<M['input']> : undefined
 
 export type InferMethodOutput<
   M extends Procedure | Query | Subscription,
   B = BinaryData,
-> = M extends { output: Payload } ? InferPayload<M['output'], B> : undefined
+> = M extends Procedure | Query ? InferPayload<M['output'], B> : undefined
 
 export type InferMethodOutputBody<
   M extends Procedure | Query | Subscription,
   B = BinaryData,
-> = M extends { output: Payload } ? InferPayloadBody<M['output'], B> : undefined
+> = M extends Procedure | Query ? InferPayloadBody<M['output'], B> : undefined
 
 export type InferMethodOutputEncoding<
   M extends Procedure | Query | Subscription,
-> = M extends { output: Payload }
-  ? InferPayloadEncoding<M['output']>
-  : undefined
+> = M extends Procedure | Query ? InferPayloadEncoding<M['output']> : undefined
 
 export type InferMethodMessage<
   //
-  M extends Procedure | Query | Subscription,
-> = M extends { message: Schema }
-  ? LexValue & InferOutput<M['message']>
-  : undefined
+  M extends Subscription,
+> = M extends Subscription ? InferOutput<M['message']> : undefined
 
 export type InferMethodError<
   //

package/src/schema/array.test.ts

@@ -5,103 +5,118 @@ import { object } from './object.js'
 import { string } from './string.js'
 
 describe('ArraySchema', () => {
-  it('validates arrays with string items', () => {
-    const schema = array(string())
-    const result = schema.safeParse(['hello', 'world'])
-    expect(result.success).toBe(true)
-  })
-
-  it('validates arrays with integer items', () => {
-    const schema = array(integer())
-    const result = schema.safeParse([1, 2, 3])
-    expect(result.success).toBe(true)
-  })
+  describe('validation', () => {
+    it('validates arrays with string items', () => {
+      const schema = array(string())
+      const result = schema.safeValidate(['hello', 'world'])
+      expect(result).toMatchObject({ success: true })
+    })
+
+    it('validates arrays with integer items', () => {
+      const schema = array(integer())
+      const result = schema.safeValidate([1, 2, 3])
+      expect(result).toMatchObject({ success: true })
+    })
+
+    it('validates arrays with object items', () => {
+      const schema = array(
+        object({
+          name: string(),
+          age: integer(),
+        }),
+      )
+      const result = schema.safeValidate([
+        { name: 'Alice', age: 30 },
+        { name: 'Bob', age: 25 },
+      ])
+      expect(result).toMatchObject({ success: true })
+    })
 
-  it('validates arrays with object items', () => {
-    const schema = array(
-      object({
-        name: string(),
-        age: integer(),
-      }),
-    )
-    const result = schema.safeParse([
-      { name: 'Alice', age: 30 },
-      { name: 'Bob', age: 25 },
-    ])
-    expect(result.success).toBe(true)
-  })
+    it('validates empty arrays', () => {
+      const schema = array(string())
+      const result = schema.safeValidate([])
+      expect(result).toMatchObject({ success: true })
+    })
 
-  it('validates empty arrays', () => {
-    const schema = array(string())
-    const result = schema.safeParse([])
-    expect(result.success).toBe(true)
-  })
+    it('rejects non-array values', () => {
+      const schema = array(string())
+      const result = schema.safeValidate('not an array')
+      expect(result).toMatchObject({ success: false })
+    })
 
-  it('rejects non-array values', () => {
-    const schema = array(string())
-    const result = schema.safeParse('not an array')
-    expect(result.success).toBe(false)
-  })
+    it('rejects null values', () => {
+      const schema = array(string())
+      const result = schema.safeValidate(null)
+      expect(result).toMatchObject({ success: false })
+    })
 
-  it('rejects null values', () => {
-    const schema = array(string())
-    const result = schema.safeParse(null)
-    expect(result.success).toBe(false)
-  })
+    it('rejects undefined values', () => {
+      const schema = array(string())
+      const result = schema.safeValidate(undefined)
+      expect(result).toMatchObject({ success: false })
+    })
 
-  it('rejects undefined values', () => {
-    const schema = array(string())
-    const result = schema.safeParse(undefined)
-    expect(result.success).toBe(false)
-  })
+    it('rejects objects that look like arrays', () => {
+      const schema = array(string())
+      const result = schema.safeValidate({ 0: 'a', 1: 'b', length: 2 })
+      expect(result).toMatchObject({ success: false })
+    })
 
-  it('rejects objects that look like arrays', () => {
-    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 = array(integer())
+      const result = schema.safeValidate([1, 2, 'three'])
+      expect(result).toMatchObject({ success: false })
+    })
 
-  it('rejects arrays with invalid items', () => {
-    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 = array(string())
+      const result = schema.safeValidate(['valid', null, 'also valid'])
+      expect(result).toMatchObject({ success: false })
+    })
 
-  it('rejects arrays with some invalid items', () => {
-    const schema = array(string())
-    const result = schema.safeParse(['valid', null, 'also valid'])
-    expect(result.success).toBe(false)
+    it('rejects single values', () => {
+      const schema = array(string())
+      const result = schema.safeValidate(3)
+      expect(result).toEqual({
+        success: false,
+        reason: expect.objectContaining({
+          message: expect.stringContaining(
+            'Expected array value type at $ (got integer)',
+          ),
+        }),
+      })
+    })
   })
 
   describe('minLength constraint', () => {
     it('validates arrays meeting minLength', () => {
       const schema = array(string(), { minLength: 2 })
       const result = schema.safeParse(['a', 'b'])
-      expect(result.success).toBe(true)
+      expect(result).toMatchObject({ success: true })
     })
 
     it('validates arrays exceeding minLength', () => {
       const schema = array(string(), { minLength: 2 })
       const result = schema.safeParse(['a', 'b', 'c'])
-      expect(result.success).toBe(true)
+      expect(result).toMatchObject({ success: true })
     })
 
     it('rejects arrays below minLength', () => {
       const schema = array(string(), { minLength: 3 })
       const result = schema.safeParse(['a', 'b'])
-      expect(result.success).toBe(false)
+      expect(result).toMatchObject({ success: false })
     })
 
     it('rejects empty arrays when minLength is set', () => {
       const schema = array(string(), { minLength: 1 })
       const result = schema.safeParse([])
-      expect(result.success).toBe(false)
+      expect(result).toMatchObject({ success: false })
     })
 
     it('validates empty arrays when minLength is 0', () => {
       const schema = array(string(), { minLength: 0 })
       const result = schema.safeParse([])
-      expect(result.success).toBe(true)
+      expect(result).toMatchObject({ success: true })
     })
   })
 
@@ -109,37 +124,37 @@ describe('ArraySchema', () => {
     it('validates arrays meeting maxLength', () => {
       const schema = array(string(), { maxLength: 3 })
       const result = schema.safeParse(['a', 'b', 'c'])
-      expect(result.success).toBe(true)
+      expect(result).toMatchObject({ success: true })
     })
 
     it('validates arrays below maxLength', () => {
       const schema = array(string(), { maxLength: 3 })
       const result = schema.safeParse(['a', 'b'])
-      expect(result.success).toBe(true)
+      expect(result).toMatchObject({ success: true })
     })
 
     it('rejects arrays exceeding maxLength', () => {
       const schema = array(string(), { maxLength: 2 })
       const result = schema.safeParse(['a', 'b', 'c'])
-      expect(result.success).toBe(false)
+      expect(result).toMatchObject({ success: false })
     })
 
     it('validates empty arrays with maxLength', () => {
       const schema = array(string(), { maxLength: 5 })
       const result = schema.safeParse([])
-      expect(result.success).toBe(true)
+      expect(result).toMatchObject({ success: true })
     })
 
     it('rejects empty arrays when maxLength is 0', () => {
       const schema = array(string(), { maxLength: 0 })
       const result = schema.safeParse(['a'])
-      expect(result.success).toBe(false)
+      expect(result).toMatchObject({ success: false })
     })
 
     it('validates empty arrays when maxLength is 0', () => {
       const schema = array(string(), { maxLength: 0 })
       const result = schema.safeParse([])
-      expect(result.success).toBe(true)
+      expect(result).toMatchObject({ success: true })
     })
   })
 
@@ -150,7 +165,7 @@ describe('ArraySchema', () => {
         maxLength: 4,
       })
       const result = schema.safeParse(['a', 'b', 'c'])
-      expect(result.success).toBe(true)
+      expect(result).toMatchObject({ success: true })
     })
 
     it('validates arrays at min boundary', () => {
@@ -159,7 +174,7 @@ describe('ArraySchema', () => {
         maxLength: 4,
       })
       const result = schema.safeParse(['a', 'b'])
-      expect(result.success).toBe(true)
+      expect(result).toMatchObject({ success: true })
     })
 
     it('validates arrays at max boundary', () => {
@@ -168,7 +183,7 @@ describe('ArraySchema', () => {
         maxLength: 4,
       })
       const result = schema.safeParse(['a', 'b', 'c', 'd'])
-      expect(result.success).toBe(true)
+      expect(result).toMatchObject({ success: true })
     })
 
     it('rejects arrays below minLength', () => {
@@ -177,7 +192,7 @@ describe('ArraySchema', () => {
         maxLength: 4,
       })
       const result = schema.safeParse(['a'])
-      expect(result.success).toBe(false)
+      expect(result).toMatchObject({ success: false })
     })
 
     it('rejects arrays above maxLength', () => {
@@ -186,7 +201,7 @@ describe('ArraySchema', () => {
         maxLength: 4,
       })
       const result = schema.safeParse(['a', 'b', 'c', 'd', 'e'])
-      expect(result.success).toBe(false)
+      expect(result).toMatchObject({ success: false })
     })
 
     it('validates single-length range', () => {
@@ -195,7 +210,7 @@ describe('ArraySchema', () => {
         maxLength: 3,
       })
       const result = schema.safeParse(['a', 'b', 'c'])
-      expect(result.success).toBe(true)
+      expect(result).toMatchObject({ success: true })
     })
 
     it('rejects arrays not matching exact length', () => {
@@ -204,7 +219,7 @@ describe('ArraySchema', () => {
         maxLength: 3,
       })
       const result = schema.safeParse(['a', 'b'])
-      expect(result.success).toBe(false)
+      expect(result).toMatchObject({ success: false })
     })
   })
 
@@ -215,7 +230,7 @@ describe('ArraySchema', () => {
         ['a', 'b'],
         ['c', 'd'],
       ])
-      expect(result.success).toBe(true)
+      expect(result).toMatchObject({ success: true })
     })
 
     it('rejects invalid nested arrays', () => {
@@ -224,13 +239,13 @@ describe('ArraySchema', () => {
         [1, 2],
         [3, 'four'],
       ])
-      expect(result.success).toBe(false)
+      expect(result).toMatchObject({ success: false })
     })
 
     it('validates deeply nested arrays', () => {
       const schema = array(array(array(integer())))
       const result = schema.safeParse([[[1, 2], [3]], [[4, 5, 6]]])
-      expect(result.success).toBe(true)
+      expect(result).toMatchObject({ success: true })
     })
   })
 })