@atproto/lex-schema 0.1.5 → 0.1.6

package/src/helpers.test.ts

@@ -1,694 +0,0 @@
-import { describe, expect, expectTypeOf, it, 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(),
-        l.payload(),
-      )
-
-      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.lexMap(),
-      )
-
-      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.jsonPayload({ text: l.string() }),
-        l.payload(),
-      )
-
-      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: { text: 'hi' } })
-      // @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(),
-      )
-
-      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.jsonPayload({ text: l.string() }),
-        l.payload(),
-      )
-
-      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(),
-      )
-
-      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.jsonPayload({ text: l.string() }),
-        l.payload(),
-      )
-
-      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(),
-      )
-
-      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('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.jsonPayload({ 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('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(),
-        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(),
-        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('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',
-        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(),
-        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(),
-        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.jsonPayload({ 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(),
-        l.jsonPayload({ 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(),
-        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.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)
-    })
-  })
-})
-
-describe(l.atUri, () => {
-  describe('string collection', () => {
-    const did = 'did:example:alice'
-
-    it('builds a valid record URI', () => {
-      const uri = l.atUri(did, 'com.ex.foo', 'bar')
-      expect(uri).toBe('at://did:example:alice/com.ex.foo/bar')
-      expectTypeOf(uri).toEqualTypeOf<`at://did:example:alice/com.ex.foo/bar`>()
-    })
-
-    it('validates record key values', () => {
-      expect(() => {
-        // @ts-expect-error
-        l.atUri(did, 'com.ex.foo', '.')
-      }).toThrow()
-      expect(() => {
-        // @ts-expect-error
-        l.atUri(did, 'com.ex.foo', '..')
-      }).toThrow()
-    })
-
-    it('expects a second argument', () => {
-      expect(() => {
-        // @ts-expect-error
-        l.atUri(did, 'com.ex.foo')
-      }).toThrow()
-    })
-  })
-
-  describe('literal', () => {
-    const schema = l.record('literal:bar', 'com.ex.foo', l.object({}))
-    const did = 'did:example:alice'
-
-    it('allows omitting the record key for literal keys', () => {
-      const uri = l.atUri(did, schema)
-      expect(uri).toBe('at://did:example:alice/com.ex.foo/bar')
-      expectTypeOf(uri).toEqualTypeOf<`at://did:example:alice/com.ex.foo/bar`>()
-    })
-
-    it('still allows providing the record key for literal keys', () => {
-      expectTypeOf(
-        l.atUri(did, schema, 'bar'),
-      ).toEqualTypeOf<`at://did:example:alice/com.ex.foo/bar`>()
-    })
-
-    it('validates invalid record keys', () => {
-      expect(() => {
-        // @ts-expect-error
-        l.atUri(did, schema, 'wrong')
-      }).toThrow()
-    })
-  })
-
-  describe('tid', () => {
-    const schema = l.record('tid', 'com.ex.foo', l.object({}))
-    const did = 'did:example:alice'
-
-    it('builds a valid record URI', () => {
-      const uri = l.atUri(did, schema, '3jzfcijpj2z2a')
-      expectTypeOf(
-        uri,
-      ).toEqualTypeOf<`at://did:example:alice/com.ex.foo/3jzfcijpj2z2a`>()
-      expect(uri).toBe('at://did:example:alice/com.ex.foo/3jzfcijpj2z2a')
-    })
-
-    it('expects a second argument for non-literal keys', () => {
-      expect(() => {
-        // @ts-expect-error
-        l.atUri(did, schema)
-      }).toThrow()
-    })
-
-    it('validates the record key value', () => {
-      expect(() => {
-        l.atUri(did, schema, 'invalid-tid')
-      }).toThrow()
-    })
-  })
-
-  describe('any', () => {
-    const schema = l.record('any', 'com.ex.foo', l.object({}))
-    const did = 'did:example:alice'
-
-    it('builds a valid record URI valid keys', () => {
-      const uri = l.atUri(did, schema, 'customKey')
-      expect(uri).toBe('at://did:example:alice/com.ex.foo/customKey')
-      expectTypeOf(
-        uri,
-      ).toEqualTypeOf<`at://did:example:alice/com.ex.foo/customKey`>()
-    })
-
-    it('rejects invalid record key values', () => {
-      expect(() => {
-        // @ts-expect-error
-        l.atUri(did, schema, '.')
-      }).toThrow()
-      expect(() => {
-        // @ts-expect-error
-        l.atUri(did, schema, '..')
-      }).toThrow()
-    })
-
-    it('expects a second argument', () => {
-      expect(() => {
-        // @ts-expect-error
-        l.atUri(did, schema)
-      }).toThrow()
-    })
-
-    describe('edge cases', () => {
-      it('limits the record key to 512 characters', () => {
-        const uri = l.atUri(did, schema, 'a'.repeat(512))
-
-        expect(uri).toBe(`at://did:example:alice/com.ex.foo/${'a'.repeat(512)}`)
-        expectTypeOf(
-          uri,
-        ).toEqualTypeOf<`at://did:example:alice/com.ex.foo/${string}`>()
-        expect(() => {
-          l.atUri(did, schema, 'a'.repeat(513))
-        }).toThrow()
-      })
-    })
-  })
-})