@atproto/xrpc-server 0.0.1 → 0.2.0

package/tests/errors.test.ts

@@ -1,8 +1,10 @@
 import * as http from 'http'
+import getPort from 'get-port'
 import { createServer, closeServer } from './_util'
 import * as xrpcServer from '../src'
 import xrpc, {
   Client,
+  ServiceClient,
   XRPCError,
   XRPCInvalidResponseError,
 } from '@atproto/xrpc'
@@ -24,6 +26,15 @@ const LEXICONS = [
       },
     },
   },
+  {
+    lexicon: 1,
+    id: 'io.example.throwFalsyValue',
+    defs: {
+      main: {
+        type: 'query',
+      },
+    },
+  },
   {
     lexicon: 1,
     id: 'io.example.query',
@@ -105,6 +116,9 @@ describe('Errors', () => {
       return { status: 400 }
     }
   })
+  server.method('io.example.throwFalsyValue', () => {
+    throw ''
+  })
   server.method('io.example.query', () => {
     return undefined
   })
@@ -115,13 +129,17 @@ describe('Errors', () => {
   server.method('io.example.procedure', () => {
     return undefined
   })
-  const client = xrpc.service(`http://localhost:8893`)
   xrpc.addLexicons(LEXICONS)
   const badXrpc = new Client()
-  const badClient = badXrpc.service(`http://localhost:8893`)
   badXrpc.addLexicons(MISMATCHED_LEXICONS)
+
+  let client: ServiceClient
+  let badClient: ServiceClient
   beforeAll(async () => {
-    s = await createServer(8893, server)
+    const port = await getPort()
+    s = await createServer(port, server)
+    client = xrpc.service(`http://localhost:${port}`)
+    badClient = badXrpc.service(`http://localhost:${port}`)
   })
   afterAll(async () => {
     await closeServer(s)
@@ -134,7 +152,7 @@ describe('Errors', () => {
       })
       throw new Error('Didnt throw')
     } catch (e) {
-      expect(e instanceof XRPCError).toBeTruthy()
+      expect(e).toBeInstanceOf(XRPCError)
       expect((e as XRPCError).success).toBeFalsy()
       expect((e as XRPCError).error).toBe('Foo')
       expect((e as XRPCError).message).toBe('It was this one!')
@@ -145,18 +163,27 @@ describe('Errors', () => {
       })
       throw new Error('Didnt throw')
     } catch (e) {
-      expect(e instanceof XRPCError).toBeTruthy()
+      expect(e).toBeInstanceOf(XRPCError)
       expect((e as XRPCError).success).toBeFalsy()
       expect((e as XRPCError).error).toBe('Bar')
       expect((e as XRPCError).message).toBe('It was that one!')
     }
+    try {
+      await client.call('io.example.throwFalsyValue')
+      throw new Error('Didnt throw')
+    } catch (e) {
+      expect(e instanceof XRPCError).toBeTruthy()
+      expect((e as XRPCError).success).toBeFalsy()
+      expect((e as XRPCError).error).toBe('InternalServerError')
+      expect((e as XRPCError).message).toBe('Internal Server Error')
+    }
     try {
       await client.call('io.example.error', {
         which: 'other',
       })
       throw new Error('Didnt throw')
     } catch (e) {
-      expect(e instanceof XRPCError).toBeTruthy()
+      expect(e).toBeInstanceOf(XRPCError)
       expect((e as XRPCError).success).toBeFalsy()
       expect((e as XRPCError).error).toBe('InvalidRequest')
       expect((e as XRPCError).message).toBe('Invalid Request')
@@ -165,8 +192,8 @@ describe('Errors', () => {
       await client.call('io.example.invalidResponse')
       throw new Error('Didnt throw')
     } catch (e: any) {
-      expect(e instanceof XRPCError).toBeTruthy()
-      expect(e instanceof XRPCInvalidResponseError).toBeTruthy()
+      expect(e).toBeInstanceOf(XRPCError)
+      expect(e).toBeInstanceOf(XRPCInvalidResponseError)
       expect(e.success).toBeFalsy()
       expect(e.error).toBe('Invalid Response')
       expect(e.message).toBe(
@@ -187,7 +214,7 @@ describe('Errors', () => {
       await badClient.call('io.example.query')
       throw new Error('Didnt throw')
     } catch (e: any) {
-      expect(e instanceof XRPCError).toBeTruthy()
+      expect(e).toBeInstanceOf(XRPCError)
       expect(e.success).toBeFalsy()
       expect(e.error).toBe('InvalidRequest')
       expect(e.message).toBe('Incorrect HTTP method (POST) expected GET')
@@ -196,7 +223,7 @@ describe('Errors', () => {
       await badClient.call('io.example.procedure')
       throw new Error('Didnt throw')
     } catch (e: any) {
-      expect(e instanceof XRPCError).toBeTruthy()
+      expect(e).toBeInstanceOf(XRPCError)
       expect(e.success).toBeFalsy()
       expect(e.error).toBe('InvalidRequest')
       expect(e.message).toBe('Incorrect HTTP method (GET) expected POST')
@@ -205,7 +232,7 @@ describe('Errors', () => {
       await badClient.call('io.example.doesNotExist')
       throw new Error('Didnt throw')
     } catch (e: any) {
-      expect(e instanceof XRPCError).toBeTruthy()
+      expect(e).toBeInstanceOf(XRPCError)
       expect(e.success).toBeFalsy()
       expect(e.error).toBe('MethodNotImplemented')
       expect(e.message).toBe('Method Not Implemented')

package/tests/frames.test.ts

@@ -0,0 +1,137 @@
+import * as cborx from 'cbor-x'
+import * as uint8arrays from 'uint8arrays'
+import { MessageFrame, ErrorFrame, Frame, FrameType } from '../src'
+
+describe('Frames', () => {
+  it('creates and parses message frame.', async () => {
+    const messageFrame = new MessageFrame(
+      { a: 'b', c: [1, 2, 3] },
+      { type: '#d' },
+    )
+
+    expect(messageFrame.header).toEqual({
+      op: FrameType.Message,
+      t: '#d',
+    })
+    expect(messageFrame.op).toEqual(FrameType.Message)
+    expect(messageFrame.type).toEqual('#d')
+    expect(messageFrame.body).toEqual({ a: 'b', c: [1, 2, 3] })
+
+    const bytes = messageFrame.toBytes()
+    expect(
+      uint8arrays.equals(
+        bytes,
+        new Uint8Array([
+          /*header*/ 162, 97, 116, 98, 35, 100, 98, 111, 112, 1, /*body*/ 162,
+          97, 97, 97, 98, 97, 99, 131, 1, 2, 3,
+        ]),
+      ),
+    ).toEqual(true)
+
+    const parsedFrame = Frame.fromBytes(bytes)
+    if (!(parsedFrame instanceof MessageFrame)) {
+      throw new Error('Did not parse as message frame')
+    }
+
+    expect(parsedFrame.header).toEqual(messageFrame.header)
+    expect(parsedFrame.op).toEqual(messageFrame.op)
+    expect(parsedFrame.type).toEqual(messageFrame.type)
+    expect(parsedFrame.body).toEqual(messageFrame.body)
+  })
+
+  it('creates and parses error frame.', async () => {
+    const errorFrame = new ErrorFrame({
+      error: 'BigOops',
+      message: 'Something went awry',
+    })
+
+    expect(errorFrame.header).toEqual({ op: FrameType.Error })
+    expect(errorFrame.op).toEqual(FrameType.Error)
+    expect(errorFrame.code).toEqual('BigOops')
+    expect(errorFrame.message).toEqual('Something went awry')
+    expect(errorFrame.body).toEqual({
+      error: 'BigOops',
+      message: 'Something went awry',
+    })
+
+    const bytes = errorFrame.toBytes()
+    expect(
+      uint8arrays.equals(
+        bytes,
+        new Uint8Array([
+          /*header*/ 161, 98, 111, 112, 32, /*body*/ 162, 101, 101, 114, 114,
+          111, 114, 103, 66, 105, 103, 79, 111, 112, 115, 103, 109, 101, 115,
+          115, 97, 103, 101, 115, 83, 111, 109, 101, 116, 104, 105, 110, 103,
+          32, 119, 101, 110, 116, 32, 97, 119, 114, 121,
+        ]),
+      ),
+    ).toEqual(true)
+
+    const parsedFrame = Frame.fromBytes(bytes)
+    if (!(parsedFrame instanceof ErrorFrame)) {
+      throw new Error('Did not parse as error frame')
+    }
+
+    expect(parsedFrame.header).toEqual(errorFrame.header)
+    expect(parsedFrame.op).toEqual(errorFrame.op)
+    expect(parsedFrame.code).toEqual(errorFrame.code)
+    expect(parsedFrame.message).toEqual(errorFrame.message)
+    expect(parsedFrame.body).toEqual(errorFrame.body)
+  })
+
+  it('parsing fails when frame is not CBOR.', async () => {
+    const bytes = Buffer.from('some utf8 bytes')
+    const emptyBytes = Buffer.from('')
+    expect(() => Frame.fromBytes(bytes)).toThrow('Unexpected end of CBOR data')
+    expect(() => Frame.fromBytes(emptyBytes)).toThrow(
+      'Unexpected end of CBOR data',
+    )
+  })
+
+  it('parsing fails when frame header is malformed.', async () => {
+    const bytes = uint8arrays.concat([
+      cborx.encode({ op: -2 }), // Unknown op
+      cborx.encode({ a: 'b', c: [1, 2, 3] }),
+    ])
+
+    expect(() => Frame.fromBytes(bytes)).toThrow('Invalid frame header:')
+  })
+
+  it('parsing fails when frame is missing body.', async () => {
+    const messageFrame = new MessageFrame(
+      { a: 'b', c: [1, 2, 3] },
+      { type: '#d' },
+    )
+
+    const headerBytes = cborx.encode(messageFrame.header)
+
+    expect(() => Frame.fromBytes(headerBytes)).toThrow('Missing frame body')
+  })
+
+  it('parsing fails when frame has too many data items.', async () => {
+    const messageFrame = new MessageFrame(
+      { a: 'b', c: [1, 2, 3] },
+      { type: '#d' },
+    )
+
+    const bytes = uint8arrays.concat([
+      messageFrame.toBytes(),
+      cborx.encode({ d: 'e', f: [4, 5, 6] }),
+    ])
+
+    expect(() => Frame.fromBytes(bytes)).toThrow(
+      'Too many CBOR data items in frame',
+    )
+  })
+
+  it('parsing fails when error frame has invalid body.', async () => {
+    const errorFrame = new ErrorFrame({ error: 'BadOops' })
+
+    const bytes = uint8arrays.concat([
+      cborx.encode(errorFrame.header),
+      cborx.encode({ blah: 1 }),
+    ])
+
+    expect(() => Frame.fromBytes(bytes)).toThrow('Invalid error frame body:')
+  })
+})

package/tests/ipld.test.ts

@@ -0,0 +1,96 @@
+import * as http from 'http'
+import xrpc, { ServiceClient } from '@atproto/xrpc'
+import { CID } from 'multiformats/cid'
+import getPort from 'get-port'
+import { createServer, closeServer } from './_util'
+import * as xrpcServer from '../src'
+
+const LEXICONS = [
+  {
+    lexicon: 1,
+    id: 'io.example.ipld',
+    defs: {
+      main: {
+        type: 'procedure',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              cid: {
+                type: 'cid-link',
+              },
+              bytes: {
+                type: 'bytes',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              cid: {
+                type: 'cid-link',
+              },
+              bytes: {
+                type: 'bytes',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+]
+
+describe('Ipld vals', () => {
+  let s: http.Server
+  const server = xrpcServer.createServer(LEXICONS)
+  server.method(
+    'io.example.ipld',
+    (ctx: { input?: xrpcServer.HandlerInput }) => {
+      const asCid = CID.asCID(ctx.input?.body.cid)
+      if (!(asCid instanceof CID)) {
+        throw new Error('expected cid')
+      }
+      const bytes = ctx.input?.body.bytes
+      if (!(bytes instanceof Uint8Array)) {
+        throw new Error('expected bytes')
+      }
+      return { encoding: 'application/json', body: ctx.input?.body }
+    },
+  )
+  xrpc.addLexicons(LEXICONS)
+
+  let client: ServiceClient
+  beforeAll(async () => {
+    const port = await getPort()
+    s = await createServer(port, server)
+    client = xrpc.service(`http://localhost:${port}`)
+  })
+  afterAll(async () => {
+    await closeServer(s)
+  })
+
+  it('can send and receive ipld vals', async () => {
+    const cid = CID.parse(
+      'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+    )
+    const bytes = new Uint8Array([0, 1, 2, 3])
+    const res = await client.call(
+      'io.example.ipld',
+      {},
+      {
+        cid,
+        bytes,
+      },
+      { encoding: 'application/json' },
+    )
+    expect(res.success).toBeTruthy()
+    expect(res.headers['content-type']).toBe('application/json; charset=utf-8')
+    expect(cid.equals(res.data.cid)).toBeTruthy()
+    expect(bytes).toEqual(res.data.bytes)
+  })
+})

package/tests/parameters.test.ts

@@ -1,7 +1,8 @@
 import * as http from 'http'
+import getPort from 'get-port'
+import xrpc, { ServiceClient } from '@atproto/xrpc'
 import { createServer, closeServer } from './_util'
 import * as xrpcServer from '../src'
-import xrpc from '@atproto/xrpc'
 
 const LEXICONS = [
   {
@@ -12,13 +13,13 @@ const LEXICONS = [
         type: 'query',
         parameters: {
           type: 'params',
-          required: ['str', 'int', 'num', 'bool', 'arr'],
+          required: ['str', 'int', 'bool', 'arr'],
           properties: {
             str: { type: 'string', minLength: 2, maxLength: 10 },
             int: { type: 'integer', minimum: 2, maximum: 10 },
-            num: { type: 'number', minimum: 2, maximum: 10 },
             bool: { type: 'boolean' },
             arr: { type: 'array', items: { type: 'integer' }, maxLength: 2 },
+            def: { type: 'integer', default: 0 },
           },
         },
         output: {
@@ -39,10 +40,13 @@ describe('Parameters', () => {
       body: ctx.params,
     }),
   )
-  const client = xrpc.service(`http://localhost:8889`)
   xrpc.addLexicons(LEXICONS)
+
+  let client: ServiceClient
   beforeAll(async () => {
-    s = await createServer(8889, server)
+    const port = await getPort()
+    s = await createServer(port, server)
+    client = xrpc.service(`http://localhost:${port}`)
   })
   afterAll(async () => {
     await closeServer(s)
@@ -52,36 +56,35 @@ describe('Parameters', () => {
     const res1 = await client.call('io.example.paramTest', {
       str: 'valid',
       int: 5,
-      num: 5.5,
       bool: true,
       arr: [1, 2],
+      def: 5,
     })
     expect(res1.success).toBeTruthy()
     expect(res1.data.str).toBe('valid')
     expect(res1.data.int).toBe(5)
-    expect(res1.data.num).toBe(5.5)
     expect(res1.data.bool).toBe(true)
     expect(res1.data.arr).toEqual([1, 2])
+    expect(res1.data.def).toEqual(5)
 
     const res2 = await client.call('io.example.paramTest', {
       str: 10,
       int: '5',
-      num: '5.5',
       bool: 'foo',
       arr: '3',
     })
     expect(res2.success).toBeTruthy()
     expect(res2.data.str).toBe('10')
     expect(res2.data.int).toBe(5)
-    expect(res2.data.num).toBe(5.5)
     expect(res2.data.bool).toBe(true)
     expect(res2.data.arr).toEqual([3])
+    expect(res2.data.def).toEqual(0)
 
+    // @TODO test sending blatantly bad types
     await expect(
       client.call('io.example.paramTest', {
         str: 'n',
         int: 5,
-        num: 5.5,
         bool: true,
         arr: [1],
       }),
@@ -90,7 +93,6 @@ describe('Parameters', () => {
       client.call('io.example.paramTest', {
         str: 'loooooooooooooong',
         int: 5,
-        num: 5.5,
         bool: true,
         arr: [1],
       }),
@@ -98,7 +100,6 @@ describe('Parameters', () => {
     await expect(
       client.call('io.example.paramTest', {
         int: 5,
-        num: 5.5,
         bool: true,
         arr: [1],
       }),
@@ -108,7 +109,6 @@ describe('Parameters', () => {
       client.call('io.example.paramTest', {
         str: 'valid',
         int: -1,
-        num: 5.5,
         bool: true,
         arr: [1],
       }),
@@ -117,7 +117,6 @@ describe('Parameters', () => {
       client.call('io.example.paramTest', {
         str: 'valid',
         int: 11,
-        num: 5.5,
         bool: true,
         arr: [1],
       }),
@@ -125,7 +124,6 @@ describe('Parameters', () => {
     await expect(
       client.call('io.example.paramTest', {
         str: 'valid',
-        num: 5.5,
         bool: true,
         arr: [1],
       }),
@@ -135,34 +133,6 @@ describe('Parameters', () => {
       client.call('io.example.paramTest', {
         str: 'valid',
         int: 5,
-        num: -5.5,
-        bool: true,
-        arr: [1],
-      }),
-    ).rejects.toThrow('num can not be less than 2')
-    await expect(
-      client.call('io.example.paramTest', {
-        str: 'valid',
-        int: 5,
-        num: 50.5,
-        bool: true,
-        arr: [1],
-      }),
-    ).rejects.toThrow('num can not be greater than 10')
-    await expect(
-      client.call('io.example.paramTest', {
-        str: 'valid',
-        int: 5,
-        bool: true,
-        arr: [1],
-      }),
-    ).rejects.toThrow(`Params must have the property "num"`)
-
-    await expect(
-      client.call('io.example.paramTest', {
-        str: 'valid',
-        int: 5,
-        num: 5.5,
         arr: [1],
       }),
     ).rejects.toThrow(`Params must have the property "bool"`)
@@ -171,7 +141,6 @@ describe('Parameters', () => {
       client.call('io.example.paramTest', {
         str: 'valid',
         int: 5,
-        num: 5.5,
         bool: true,
         arr: [],
       }),
@@ -180,7 +149,6 @@ describe('Parameters', () => {
       client.call('io.example.paramTest', {
         str: 'valid',
         int: 5,
-        num: 5.5,
         bool: true,
         arr: [1, 2, 3],
       }),

package/tests/procedures.test.ts

@@ -1,6 +1,7 @@
 import * as http from 'http'
 import { Readable } from 'stream'
-import xrpc from '@atproto/xrpc'
+import xrpc, { ServiceClient } from '@atproto/xrpc'
+import getPort from 'get-port'
 import { createServer, closeServer } from './_util'
 import * as xrpcServer from '../src'
 
@@ -119,10 +120,13 @@ describe('Procedures', () => {
       }
     },
   )
-  const client = xrpc.service(`http://localhost:8891`)
   xrpc.addLexicons(LEXICONS)
+
+  let client: ServiceClient
   beforeAll(async () => {
-    s = await createServer(8891, server)
+    const port = await getPort()
+    s = await createServer(port, server)
+    client = xrpc.service(`http://localhost:${port}`)
   })
   afterAll(async () => {
     await closeServer(s)

package/tests/queries.test.ts

@@ -1,7 +1,8 @@
 import * as http from 'http'
+import getPort from 'get-port'
+import xrpc, { ServiceClient } from '@atproto/xrpc'
 import { createServer, closeServer } from './_util'
 import * as xrpcServer from '../src'
-import xrpc from '@atproto/xrpc'
 
 const LEXICONS = [
   {
@@ -83,10 +84,13 @@ describe('Queries', () => {
       body: { message: ctx.params.message },
     }
   })
-  const client = xrpc.service(`http://localhost:8890`)
   xrpc.addLexicons(LEXICONS)
+
+  let client: ServiceClient
   beforeAll(async () => {
-    s = await createServer(8890, server)
+    const port = await getPort()
+    s = await createServer(port, server)
+    client = xrpc.service(`http://localhost:${port}`)
   })
   afterAll(async () => {
     await closeServer(s)