@atproto/lex-schema 0.0.4 → 0.0.6

package/src/helpers.test.ts

@@ -0,0 +1,487 @@
+import { describe, test } from 'vitest'
+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,75 @@
+import { LexErrorData } from '@atproto/lex-data'
+import { Infer, Restricted, Schema } from './core.js'
+import {
+  InferPayload,
+  InferPayloadBody,
+  InferPayloadEncoding,
+  ObjectSchema,
+  OptionalSchema,
+  Payload,
+  Procedure,
+  Query,
+  StringSchema,
+  Subscription,
+} from './schema.js'
+
+export type Main<T> = T | { main: T }
+
+export function getMain<T extends object>(ns: Main<T>): T {
+  return 'main' in ns ? ns.main : ns
+}
+
+/**
+ * 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
+
+export const lexErrorData: Schema<LexErrorData> = new ObjectSchema({
+  error: new StringSchema({ minLength: 1 }),
+  message: new OptionalSchema(new StringSchema({})),
+})

package/src/schema/_parameters.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, it } from 'vitest'
 import { paramSchema, paramsSchema } from './_parameters.js'
 
 describe('paramSchema', () => {

package/src/schema/_parameters.ts

@@ -1,4 +1,4 @@
-import { Infer, Validator } from '../validation.js'
+import { Infer, Validator } from '../core.js'
 import { ArraySchema } from './array.js'
 import { BooleanSchema } from './boolean.js'
 import { DictSchema } from './dict.js'

package/src/schema/array.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, it } from 'vitest'
 import { ArraySchema } from './array.js'
 import { IntegerSchema } from './integer.js'
 import { ObjectSchema } from './object.js'

package/src/schema/array.ts

@@ -4,7 +4,7 @@ import {
   ValidationResult,
   Validator,
   ValidatorContext,
-} from '../validation.js'
+} from '../core.js'
 
 export type ArraySchemaOptions = {
   minLength?: number

package/src/schema/blob.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, it } from 'vitest'
 import { parseCid } from '@atproto/lex-data'
 import { BlobSchema } from './blob.js'
 
@@ -353,8 +354,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 +365,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

@@ -4,7 +4,7 @@ import {
   isBlobRef,
   isLegacyBlobRef,
 } from '@atproto/lex-data'
-import { Schema, ValidationResult, ValidatorContext } from '../validation.js'
+import { Schema, ValidationResult, ValidatorContext } from '../core.js'
 
 export type BlobSchemaOptions = {
   /**
@@ -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
 }