@atproto/lex-schema 0.0.11 → 0.0.13

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.lexMap(),
       )
 
       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,
@@ -27,51 +26,81 @@ export function getMain<T extends object>(ns: Main<T>): T {
  * `ReadableStream`, etc.). This type is a placeholder to represent binary data
  * when not explicitly provided.
  */
-type BinaryData = Restricted<'Binary data'>
+export type BinaryData = Restricted<'Binary data'>
 
-export type InferMethodParams<M extends Procedure | Query | Subscription> =
-  InferOutput<M['parameters']>
+export type InferMethodParams<
+  M extends Procedure | Query | Subscription = Procedure | Query | Subscription,
+> =
+  M extends Procedure<any, infer TParams, any, any, any>
+    ? InferOutput<TParams>
+    : M extends Query<any, infer TParams, any, any>
+      ? InferOutput<TParams>
+      : M extends Subscription<any, infer TParams, any, any>
+        ? InferOutput<TParams>
+        : never
 
 export type InferMethodInput<
-  M extends Procedure | Query | Subscription,
+  M extends Procedure | Query | Subscription = Procedure | Query | Subscription,
   B = BinaryData,
-> = M extends { input: Payload } ? InferPayload<M['input'], B> : undefined
+> =
+  M extends Procedure<any, any, infer TInput, any, any>
+    ? InferPayload<TInput, B>
+    : undefined
 
 export type InferMethodInputBody<
-  M extends Procedure | Query | Subscription,
+  M extends Procedure | Query | Subscription = Procedure | Query | Subscription,
   B = BinaryData,
-> = M extends { input: Payload } ? InferPayloadBody<M['input'], B> : undefined
+> =
+  M extends Procedure<any, any, infer TInput, any, any>
+    ? InferPayloadBody<TInput, B>
+    : undefined
 
 export type InferMethodInputEncoding<
-  M extends Procedure | Query | Subscription,
-> = M extends { input: Payload } ? InferPayloadEncoding<M['input']> : undefined
+  M extends Procedure | Query | Subscription = Procedure | Query | Subscription,
+> =
+  M extends Procedure<any, any, infer TInput, any, any>
+    ? InferPayloadEncoding<TInput>
+    : undefined
 
 export type InferMethodOutput<
-  M extends Procedure | Query | Subscription,
+  M extends Procedure | Query | Subscription = Procedure | Query | Subscription,
   B = BinaryData,
-> = M extends { output: Payload } ? InferPayload<M['output'], B> : undefined
+> =
+  M extends Procedure<any, any, any, infer TOutput, any>
+    ? InferPayload<TOutput, B>
+    : M extends Query<any, any, infer TOutput, any>
+      ? InferPayload<TOutput, B>
+      : undefined
 
 export type InferMethodOutputBody<
-  M extends Procedure | Query | Subscription,
+  M extends Procedure | Query | Subscription = Procedure | Query | Subscription,
   B = BinaryData,
-> = M extends { output: Payload } ? InferPayloadBody<M['output'], B> : undefined
+> =
+  M extends Procedure<any, any, any, infer TOutput, any>
+    ? InferPayloadBody<TOutput, B>
+    : M extends Query<any, any, infer TOutput, any>
+      ? InferPayloadBody<TOutput, B>
+      : undefined
 
 export type InferMethodOutputEncoding<
-  M extends Procedure | Query | Subscription,
-> = M extends { output: Payload }
-  ? InferPayloadEncoding<M['output']>
-  : undefined
+  M extends Procedure | Query | Subscription = Procedure | Query | Subscription,
+> =
+  M extends Procedure<any, any, any, infer TOutput, any>
+    ? InferPayloadEncoding<TOutput>
+    : M extends Query<any, any, infer TOutput, any>
+      ? InferPayloadEncoding<TOutput>
+      : undefined
 
 export type InferMethodMessage<
-  //
-  M extends Procedure | Query | Subscription,
-> = M extends { message: Schema }
-  ? LexValue & InferOutput<M['message']>
-  : undefined
+  M extends Procedure | Query | Subscription = Procedure | Query | Subscription,
+> =
+  M extends Subscription<any, any, infer TMessage, any>
+    ? InferOutput<TMessage>
+    : undefined
 
 export type InferMethodError<
   //
-  M extends Procedure | Query | Subscription,
+  M extends Procedure | Query | Subscription = Procedure | Query | Subscription,
 > = M extends { errors: readonly (infer E extends string)[] } ? E : never
 
 export const lexErrorDataSchema = object({