@atproto/lex-schema 0.0.3 → 0.0.5

package/src/helpers.test.ts

@@ -0,0 +1,486 @@
+import * as l from './external.js'
+
+class BinaryValue {
+  declare readonly ['__binaryValue']: BinaryValue
+}
+
+const expectType = <T>(_: T) => {}
+const binaryValue = new BinaryValue()
+
+describe('InferMethodParams', () => {
+  describe('query', () => {
+    test('infers parameter types', () => {
+      const query = l.query(
+        'com.example.query',
+        l.params({
+          feed: l.string({ format: 'at-uri' }),
+          limit: l.optional(l.integer()),
+        }),
+        l.payload('application/json', undefined),
+      )
+
+      type Params = l.InferMethodParams<typeof query>
+
+      expectType<Params>({
+        feed: 'at://did:plc:abc123/app.bsky.feed.post/xyz',
+        limit: 50,
+      })
+      // @ts-expect-error
+      expectType<Params>({ feed: 123, limit: 50 })
+      // @ts-expect-error
+      expectType<Params>({ limit: 50 })
+    })
+  })
+
+  describe('procedure', () => {
+    test('infers parameter types', () => {
+      const procedure = l.procedure(
+        'com.example.list',
+        l.params({ limit: l.string() }),
+        l.payload(undefined, undefined),
+        l.payload(undefined, undefined),
+        undefined,
+      )
+
+      type Params = l.InferMethodParams<typeof procedure>
+
+      expectType<Params>({ limit: '10' })
+      // @ts-expect-error
+      expectType<Params>({ limit: 10 })
+      // @ts-expect-error
+      expectType<Params>({ limit: binaryValue })
+      // @ts-expect-error
+      expectType<Params>(binaryValue)
+    })
+  })
+
+  describe('subscription', () => {
+    test('infers parameter types', () => {
+      const subscription = l.subscription(
+        'com.example.subscribe',
+        l.params({
+          cursor: l.optional(l.integer()),
+        }),
+        l.unknown(),
+      )
+
+      type Params = l.InferMethodParams<typeof subscription>
+
+      expectType<Params>({ cursor: 100 })
+      // @ts-expect-error
+      expectType<Params>({ cursor: '100' })
+      // @ts-expect-error
+      expectType<Params>({ cursor: binaryValue })
+    })
+  })
+})
+
+describe('InferMethodInput', () => {
+  describe('procedure', () => {
+    test('with payload schema', () => {
+      const procedure = l.procedure(
+        'com.example.create',
+        l.params({}),
+        l.payload('application/json', l.object({ text: l.string() })),
+        l.payload(undefined, undefined),
+        undefined,
+      )
+
+      type Input = l.InferMethodInput<typeof procedure, BinaryValue>
+
+      expectType<Input>({ encoding: 'application/json', body: { text: 'hi' } })
+      // @ts-expect-error
+      expectType<Input>({ encoding: 'application/json', body: { text: 123 } })
+      // @ts-expect-error
+      expectType<Input>({ encoding: 'text/plain', body: 'hello' })
+      // @ts-expect-error
+      expectType<Input>({ encoding: 'text/plain', body: new Uint8Array() })
+      // @ts-expect-error
+      expectType<Input>({ encoding: 'text/plain', body: binaryValue })
+    })
+
+    test('without payload schema', () => {
+      const procedure = l.procedure(
+        'com.example.create',
+        l.params({}),
+        l.payload('*/*', undefined),
+        l.payload(undefined, undefined),
+        undefined,
+      )
+
+      type Input = l.InferMethodInput<typeof procedure, BinaryValue>
+
+      expectType<Input>({ encoding: 'image/png', body: binaryValue })
+      // @ts-expect-error
+      expectType<Input>({ encoding: 'image/png', body: new Uint8Array() })
+      // @ts-expect-error
+      expectType<Input>({ encoding: 'image/png', body: [] })
+      // @ts-expect-error
+      expectType<Input>({ encoding: 'image/png', body: 'foo' })
+    })
+  })
+})
+
+describe('InferMethodInputBody', () => {
+  describe('procedure', () => {
+    test('with payload schema', () => {
+      const procedure = l.procedure(
+        'com.example.create',
+        l.params({}),
+        l.payload('application/json', l.object({ text: l.string() })),
+        l.payload(undefined, undefined),
+        undefined,
+      )
+
+      type InputBody = l.InferMethodInputBody<typeof procedure, BinaryValue>
+
+      expectType<InputBody>({ text: 'hello' })
+      // @ts-expect-error
+      expectType<InputBody>({ text: 123 })
+      // @ts-expect-error
+      expectType<InputBody>(binaryValue)
+    })
+
+    test('without payload schema', () => {
+      const procedure = l.procedure(
+        'com.example.upload',
+        l.params({}),
+        l.payload('*/*', undefined),
+        l.payload(undefined, undefined),
+        undefined,
+      )
+
+      type InputBody = l.InferMethodInputBody<typeof procedure, BinaryValue>
+
+      expectType<InputBody>(binaryValue)
+      // @ts-expect-error
+      expectType<InputBody>(new Uint8Array())
+      // @ts-expect-error
+      expectType<InputBody>({ text: 'hello' })
+    })
+  })
+})
+
+describe('InferMethodInputEncoding', () => {
+  describe('procedure', () => {
+    test('with payload schema', () => {
+      const procedure = l.procedure(
+        'com.example.create',
+        l.params({}),
+        l.payload('application/json', l.object({ text: l.string() })),
+        l.payload(undefined, undefined),
+        undefined,
+      )
+
+      type InputEncoding = l.InferMethodInputEncoding<typeof procedure>
+
+      expectType<InputEncoding>('application/json')
+      // @ts-expect-error
+      expectType<InputEncoding>('text/plain')
+      // @ts-expect-error
+      expectType<InputEncoding>(123)
+    })
+
+    test('without payload schema', () => {
+      const procedure = l.procedure(
+        'com.example.upload',
+        l.params({}),
+        l.payload('*/*', undefined),
+        l.payload(undefined, undefined),
+        undefined,
+      )
+
+      type InputEncoding = l.InferMethodInputEncoding<typeof procedure>
+
+      expectType<InputEncoding>('image/png')
+      expectType<InputEncoding>('application/octet-stream')
+      // @ts-expect-error
+      expectType<InputEncoding>(123)
+    })
+  })
+})
+
+describe('InferMethodOutput', () => {
+  describe('query', () => {
+    test('with payload schema', () => {
+      const query = l.query(
+        'com.example.query',
+        l.params({}),
+        l.payload('application/json', l.object({ items: l.array(l.string()) })),
+      )
+
+      type Output = l.InferMethodOutput<typeof query, BinaryValue>
+
+      expectType<Output>({ encoding: 'application/json', body: { items: [] } })
+      // @ts-expect-error
+      expectType<Output>({ encoding: 'application/json', body: { items: [1] } })
+      // @ts-expect-error
+      expectType<Output>({ encoding: 'text/plain', body: { items: [] } })
+    })
+
+    test('without payload schema', () => {
+      const query = l.query(
+        'com.example.query',
+        l.params({}),
+        l.payload('*/*', undefined),
+      )
+
+      type Output = l.InferMethodOutput<typeof query, BinaryValue>
+
+      expectType<Output>({ encoding: 'image/png', body: binaryValue })
+      // @ts-expect-error
+      expectType<Output>({ encoding: 'image/png', body: new Uint8Array() })
+      // @ts-expect-error
+      expectType<Output>({ encoding: 'image/png', body: 'string' })
+    })
+  })
+
+  describe('procedure', () => {
+    test('with payload schema', () => {
+      const procedure = l.procedure(
+        'com.example.create',
+        l.params({}),
+        l.payload(undefined, undefined),
+        l.payload(
+          'application/json',
+          l.object({ uri: l.string({ format: 'at-uri' }) }),
+        ),
+        undefined,
+      )
+
+      type Output = l.InferMethodOutput<typeof procedure, BinaryValue>
+
+      expectType<Output>({
+        encoding: 'application/json',
+        body: { uri: 'at://did:plc:abc/post/123' },
+      })
+      // @ts-expect-error
+      expectType<Output>({ encoding: 'application/json', body: { uri: 123 } })
+      // @ts-expect-error
+      expectType<Output>({ encoding: 'text/plain', body: { uri: 'at://...' } })
+      // @ts-expect-error
+      expectType<Output>({ encoding: 'text/plain', body: 'Hello' })
+    })
+
+    test('without payload schema', () => {
+      const procedure = l.procedure(
+        'com.example.export',
+        l.params({}),
+        l.payload(undefined, undefined),
+        l.payload('*/*', undefined),
+        undefined,
+      )
+
+      type Output = l.InferMethodOutput<typeof procedure, BinaryValue>
+
+      expectType<Output>({
+        encoding: 'application/zip',
+        body: binaryValue,
+      })
+      expectType<Output>({
+        encoding: 'application/zip',
+        // @ts-expect-error
+        body: new Uint8Array(),
+      })
+      // @ts-expect-error
+      expectType<Output>({ encoding: 'application/zip', body: 'string' })
+    })
+  })
+})
+
+describe('InferMethodOutputBody', () => {
+  describe('query', () => {
+    test('with payload schema', () => {
+      const query = l.query(
+        'com.example.query',
+        l.params({}),
+        l.payload(
+          'application/json',
+          l.object({
+            cursor: l.optional(l.string()),
+            feed: l.string({ format: 'at-uri' }),
+          }),
+        ),
+      )
+
+      type OutputBody = l.InferMethodOutputBody<typeof query, BinaryValue>
+
+      expectType<OutputBody>({
+        cursor: 'abc123',
+        feed: 'at://did:plc:abc123/app.bsky.feed.post/xyz',
+      })
+      // @ts-expect-error
+      expectType<OutputBody>({ cursor: 123, feed: 'at://...' })
+      // @ts-expect-error
+      expectType<OutputBody>({ feed: 123 })
+    })
+
+    test('without payload schema', () => {
+      const query = l.query(
+        'com.example.query',
+        l.params({}),
+        l.payload('*/*', undefined),
+      )
+
+      type OutputBody = l.InferMethodOutputBody<typeof query, BinaryValue>
+
+      expectType<OutputBody>(binaryValue)
+      // @ts-expect-error
+      expectType<OutputBody>(new Uint8Array())
+      // @ts-expect-error
+      expectType<OutputBody>({ data: 'foo' })
+    })
+  })
+
+  describe('procedure', () => {
+    test('with payload schema', () => {
+      const procedure = l.procedure(
+        'com.example.get',
+        l.params({}),
+        l.payload(undefined, undefined),
+        l.payload(
+          'application/json',
+          l.object({ uri: l.string({ format: 'at-uri' }) }),
+        ),
+        undefined,
+      )
+
+      type OutputBody = l.InferMethodOutputBody<typeof procedure, BinaryValue>
+
+      expectType<OutputBody>({ uri: 'at://did:plc:abc/post/123' })
+      // @ts-expect-error
+      expectType<OutputBody>({ uri: 123 })
+      // @ts-expect-error
+      expectType<OutputBody>(binaryValue)
+    })
+
+    test('without payload schema', () => {
+      const procedure = l.procedure(
+        'com.example.export',
+        l.params({}),
+        l.payload(undefined, undefined),
+        l.payload('*/*', undefined),
+        undefined,
+      )
+
+      type OutputBody = l.InferMethodOutputBody<typeof procedure, BinaryValue>
+
+      expectType<OutputBody>(binaryValue)
+      // @ts-expect-error
+      expectType<OutputBody>(new Uint8Array())
+      // @ts-expect-error
+      expectType<OutputBody>({ data: 'foo' })
+    })
+  })
+})
+
+describe('InferMethodOutputEncoding', () => {
+  describe('query', () => {
+    test('with payload schema', () => {
+      const query = l.query(
+        'com.example.query',
+        l.params({}),
+        l.payload('application/json', l.object({ data: l.string() })),
+      )
+
+      type OutputEncoding = l.InferMethodOutputEncoding<typeof query>
+
+      expectType<OutputEncoding>('application/json')
+      // @ts-expect-error
+      expectType<OutputEncoding>('text/plain')
+      // @ts-expect-error
+      expectType<OutputEncoding>(123)
+    })
+
+    test('without payload schema', () => {
+      const query = l.query(
+        'com.example.query',
+        l.params({}),
+        l.payload('*/*', undefined),
+      )
+
+      type OutputEncoding = l.InferMethodOutputEncoding<typeof query>
+
+      expectType<OutputEncoding>('image/png')
+      expectType<OutputEncoding>('application/octet-stream')
+      // @ts-expect-error
+      expectType<OutputEncoding>(123)
+    })
+  })
+
+  describe('procedure', () => {
+    test('with payload schema', () => {
+      const procedure = l.procedure(
+        'com.example.create',
+        l.params({}),
+        l.payload(undefined, undefined),
+        l.payload('application/json', l.object({ id: l.string() })),
+        undefined,
+      )
+
+      type OutputEncoding = l.InferMethodOutputEncoding<typeof procedure>
+
+      expectType<OutputEncoding>('application/json')
+      // @ts-expect-error
+      expectType<OutputEncoding>('text/plain')
+      // @ts-expect-error
+      expectType<OutputEncoding>(123)
+    })
+
+    test('without payload schema', () => {
+      const procedure = l.procedure(
+        'com.example.export',
+        l.params({}),
+        l.payload(undefined, undefined),
+        l.payload('*/*', undefined),
+        undefined,
+      )
+
+      type OutputEncoding = l.InferMethodOutputEncoding<typeof procedure>
+
+      expectType<OutputEncoding>('application/zip')
+      expectType<OutputEncoding>('application/octet-stream')
+      // @ts-expect-error
+      expectType<OutputEncoding>(123)
+    })
+  })
+})
+
+describe('InferMethodMessage', () => {
+  describe('subscription', () => {
+    test('with message schema', () => {
+      const subscription = l.subscription(
+        'com.example.subscribe',
+        l.params({}),
+        l.object({
+          seq: l.integer(),
+          event: l.string(),
+        }),
+      )
+
+      type Message = l.InferMethodMessage<typeof subscription>
+
+      expectType<Message>({ seq: 1, event: 'create' })
+      // @ts-expect-error
+      expectType<Message>({ seq: '1', event: 'create' })
+      // @ts-expect-error
+      expectType<Message>({ seq: 1 })
+      // @ts-expect-error
+      expectType<Message>(binaryValue)
+    })
+
+    test('without message schema', () => {
+      const subscription = l.subscription(
+        'com.example.subscribe',
+        l.params({}),
+        l.unknown(),
+      )
+
+      type Message = l.InferMethodMessage<typeof subscription>
+
+      expectType<Message>(undefined as unknown)
+      expectType<Message>({ any: 'value' })
+      expectType<Message>(123)
+    })
+  })
+})

package/src/helpers.ts

@@ -0,0 +1,61 @@
+import { Restricted } from './core.js'
+import {
+  InferPayload,
+  InferPayloadBody,
+  InferPayloadEncoding,
+  Payload,
+  Procedure,
+  Query,
+  Subscription,
+} from './schema.js'
+import { Infer, Schema } from './validation.js'
+
+/**
+ * Every XRPC implementation should translate `application/json` and `text/*`
+ * payloads into their native equivalent ({@link LexValue} or string). Binary
+ * data payloads, however, can be represented differently depending on the
+ * environment and use case (e.g. `Uint8Array`, `Blob`, `Buffer`,
+ * `ReadableStream`, etc.). This type is a placeholder to represent binary data
+ * when not explicitly provided.
+ */
+type BinaryData = Restricted<'Binary data'>
+
+export type InferMethodParams<
+  //
+  M extends Procedure | Query | Subscription,
+> = Infer<M['parameters']>
+
+export type InferMethodInput<
+  M extends Procedure | Query | Subscription,
+  B = BinaryData,
+> = M extends { input: Payload } ? InferPayload<M['input'], B> : undefined
+
+export type InferMethodInputBody<
+  M extends Procedure | Query | Subscription,
+  B = BinaryData,
+> = M extends { input: Payload } ? InferPayloadBody<M['input'], B> : undefined
+
+export type InferMethodInputEncoding<
+  M extends Procedure | Query | Subscription,
+> = M extends { input: Payload } ? InferPayloadEncoding<M['input']> : undefined
+
+export type InferMethodOutput<
+  M extends Procedure | Query | Subscription,
+  B = BinaryData,
+> = M extends { output: Payload } ? InferPayload<M['output'], B> : undefined
+
+export type InferMethodOutputBody<
+  M extends Procedure | Query | Subscription,
+  B = BinaryData,
+> = M extends { output: Payload } ? InferPayloadBody<M['output'], B> : undefined
+
+export type InferMethodOutputEncoding<
+  M extends Procedure | Query | Subscription,
+> = M extends { output: Payload }
+  ? InferPayloadEncoding<M['output']>
+  : undefined
+
+export type InferMethodMessage<
+  //
+  M extends Procedure | Query | Subscription,
+> = M extends { message: Schema } ? Infer<M['message']> : undefined

package/src/schema/blob.test.ts

@@ -353,8 +353,7 @@ describe('BlobSchema', () => {
         mimeType: 'image/gif',
         size: 10000,
       })
-      // Accept constraints are not enforced (see comment in source)
-      expect(result.success).toBe(true)
+      expect(result.success).toBe(false)
     })
 
     it('accepts blob with maxSize option (not enforced)', () => {
@@ -365,8 +364,7 @@ describe('BlobSchema', () => {
         mimeType: 'image/jpeg',
         size: 10000,
       })
-      // MaxSize constraints are not enforced (see comment in source)
-      expect(result.success).toBe(true)
+      expect(result.success).toBe(false)
     })
 
     it('accepts blob matching accept constraint', () => {

package/src/schema/blob.ts

@@ -43,38 +43,46 @@ export class BlobSchema<O extends BlobSchemaOptions> extends Schema<
     input: unknown,
     ctx: ValidatorContext,
   ): ValidationResult<BlobSchemaOutput<O>> {
-    if (!isBlob(input, this.options)) {
+    const blob: null | BlobRef | LegacyBlobRef =
+      (input as any)?.$type !== undefined
+        ? isBlobRef(input, this.options)
+          ? input
+          : null
+        : this.options.allowLegacy === true && isLegacyBlobRef(input)
+          ? input
+          : null
+
+    if (!blob) {
       return ctx.issueInvalidType(input, 'blob')
     }
 
-    // @NOTE Historically, we did not enforce constraints on blob references
-    // https://github.com/bluesky-social/atproto/blob/4c15fb47cec26060bff2e710e95869a90c9d7fdd/packages/lexicon/src/validators/blob.ts#L5-L19
-
-    // const { accept } = this.options
-    // if (accept && !accept.includes(input.mimeType)) {
-    //   return ctx.issueInvalidValue(input, accept)
-    // }
+    const { accept } = this.options
+    if (accept && !matchesMime(blob.mimeType, accept)) {
+      return ctx.issueInvalidPropertyValue(blob, 'mimeType', accept)
+    }
 
-    // const { maxSize } = this.options
-    // if (maxSize != null && input.size != -1 && input.size > maxSize) {
-    //   return ctx.issueTooBig(input, 'blob', maxSize, input.size)
-    // }
+    const { maxSize } = this.options
+    if (maxSize != null && 'size' in blob && blob.size > maxSize) {
+      return ctx.issueTooBig(blob, 'blob', maxSize, blob.size)
+    }
 
-    return ctx.success(input)
+    return ctx.success(blob as BlobSchemaOutput<O>)
   }
-}
 
-function isBlob<O extends BlobSchemaOptions>(
-  input: unknown,
-  options: O,
-): input is BlobSchemaOutput<O> {
-  if ((input as any)?.$type !== undefined) {
-    return isBlobRef(input, options)
+  matchesMime(mime: string): boolean {
+    const { accept } = this.options
+    if (!accept) return true
+    return matchesMime(mime, accept)
   }
+}
 
-  if (options.allowLegacy === true) {
-    return isLegacyBlobRef(input)
+function matchesMime(mime: string, accepted: string[]): boolean {
+  if (accepted.includes('*/*')) return true
+  if (accepted.includes(mime)) return true
+  for (const value of accepted) {
+    if (value.endsWith('/*') && mime.startsWith(value.slice(0, -1))) {
+      return true
+    }
   }
-
   return false
 }

package/src/schema/custom.test.ts

@@ -32,7 +32,7 @@ describe('CustomSchema', () => {
       const result = schema.safeParse(123)
       expect(result.success).toBe(false)
       if (!result.success) {
-        expect(result.error.message).toContain('Custom error message')
+        expect(result.reason.message).toContain('Custom error message')
       }
     })
   })
@@ -143,7 +143,7 @@ describe('CustomSchema', () => {
       const result = schema.safeParse(123)
       expect(result.success).toBe(false)
       if (!result.success) {
-        expect(result.error.message).toContain('customField')
+        expect(result.reason.message).toContain('customField')
       }
     })
 
@@ -157,8 +157,8 @@ describe('CustomSchema', () => {
       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')
+        expect(result.reason.message).toContain('nested')
+        expect(result.reason.message).toContain('field')
       }
     })
   })
@@ -392,7 +392,7 @@ describe('CustomSchema', () => {
 
       expect(schema.safeParse('test')).toMatchObject({
         success: false,
-        error: {
+        reason: {
           issues: [
             { message: 'This is a custom issue' },
             { message: 'Must be a string' },

package/src/schema/custom.ts

@@ -33,6 +33,6 @@ export class CustomSchema<T = unknown> extends Schema<T> {
   ): ValidationResult<T> {
     if (this.assertion.call(null, input, ctx)) return ctx.success(input as T)
     const path = ctx.concatPath(this.path)
-    return ctx.failure(new IssueCustom(path, input, this.message))
+    return ctx.issue(new IssueCustom(path, input, this.message))
   }
 }

package/src/schema/integer.ts

@@ -35,5 +35,5 @@ export class IntegerSchema extends Schema<number> {
  * Simple wrapper around {@link Number.isInteger} that acts as a type guard.
  */
 function isInteger(input: unknown): input is number {
-  return Number.isInteger(input)
+  return Number.isInteger(input) && Number.isSafeInteger(input)
 }