@atproto/xrpc-server 0.0.1 → 0.1.0

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 = [
   {
@@ -16,9 +17,10 @@ const LEXICONS = [
           properties: {
             str: { type: 'string', minLength: 2, maxLength: 10 },
             int: { type: 'integer', minimum: 2, maximum: 10 },
-            num: { type: 'number', minimum: 2, maximum: 10 },
+            num: { type: 'float', minimum: 2, maximum: 10 },
             bool: { type: 'boolean' },
             arr: { type: 'array', items: { type: 'integer' }, maxLength: 2 },
+            def: { type: 'integer', default: 0 },
           },
         },
         output: {
@@ -39,10 +41,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)
@@ -55,6 +60,7 @@ describe('Parameters', () => {
       num: 5.5,
       bool: true,
       arr: [1, 2],
+      def: 5,
     })
     expect(res1.success).toBeTruthy()
     expect(res1.data.str).toBe('valid')
@@ -62,6 +68,7 @@ describe('Parameters', () => {
     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,
@@ -76,7 +83,9 @@ describe('Parameters', () => {
     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',

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)

package/tests/stream.test.ts

@@ -0,0 +1,169 @@
+import * as http from 'http'
+import { once } from 'events'
+import { AddressInfo } from 'net'
+import { WebSocket } from 'ws'
+import { XRPCError } from '@atproto/xrpc'
+import {
+  ErrorFrame,
+  Frame,
+  MessageFrame,
+  XrpcStreamServer,
+  byFrame,
+  byMessage,
+} from '../src'
+
+describe('Stream', () => {
+  const wait = (ms) => new Promise((res) => setTimeout(res, ms))
+  it('streams message and info frames.', async () => {
+    const httpServer = http.createServer()
+    const server = new XrpcStreamServer({
+      server: httpServer,
+      handler: async function* () {
+        await wait(1)
+        yield new MessageFrame(1)
+        await wait(1)
+        yield new MessageFrame(2)
+        await wait(1)
+        yield new MessageFrame(3)
+        return
+      },
+    })
+
+    await once(httpServer.listen(), 'listening')
+    const { port } = server.wss.address() as AddressInfo
+
+    const ws = new WebSocket(`ws://localhost:${port}`)
+    const frames: Frame[] = []
+    for await (const frame of byFrame(ws)) {
+      frames.push(frame)
+    }
+
+    expect(frames).toEqual([
+      new MessageFrame(1),
+      new MessageFrame(2),
+      new MessageFrame(3),
+    ])
+
+    httpServer.close()
+  })
+
+  it('kills handler and closes on error frame.', async () => {
+    let proceededAfterError = false
+    const httpServer = http.createServer()
+    const server = new XrpcStreamServer({
+      server: httpServer,
+      handler: async function* () {
+        await wait(1)
+        yield new MessageFrame(1)
+        await wait(1)
+        yield new MessageFrame(2)
+        await wait(1)
+        yield new ErrorFrame({ error: 'BadOops' })
+        proceededAfterError = true
+        await wait(1)
+        yield new MessageFrame(3)
+        return
+      },
+    })
+
+    await once(httpServer.listen(), 'listening')
+    const { port } = server.wss.address() as AddressInfo
+
+    const ws = new WebSocket(`ws://localhost:${port}`)
+    const frames: Frame[] = []
+    for await (const frame of byFrame(ws)) {
+      frames.push(frame)
+    }
+
+    await wait(5) // Ensure handler hasn't kept running
+    expect(proceededAfterError).toEqual(false)
+
+    expect(frames).toEqual([
+      new MessageFrame(1),
+      new MessageFrame(2),
+      new ErrorFrame({ error: 'BadOops' }),
+    ])
+
+    httpServer.close()
+  })
+
+  it('kills handler and closes client disconnect.', async () => {
+    const httpServer = http.createServer()
+    let i = 1
+    const server = new XrpcStreamServer({
+      server: httpServer,
+      handler: async function* () {
+        while (true) {
+          await wait(0)
+          yield new MessageFrame(i++)
+        }
+      },
+    })
+
+    await once(httpServer.listen(), 'listening')
+    const { port } = server.wss.address() as AddressInfo
+
+    const ws = new WebSocket(`ws://localhost:${port}`)
+    const frames: Frame[] = []
+    for await (const frame of byFrame(ws)) {
+      frames.push(frame)
+      if (frame.body === 3) ws.terminate()
+    }
+
+    // Grace period to let close take place on the server
+    await wait(5)
+    // Ensure handler hasn't kept running
+    const currentCount = i
+    await wait(5)
+    expect(i).toBe(currentCount)
+
+    httpServer.close()
+  })
+
+  describe('byMessage()', () => {
+    it('kills handler and closes client disconnect on error frame.', async () => {
+      const httpServer = http.createServer()
+      const server = new XrpcStreamServer({
+        server: httpServer,
+        handler: async function* () {
+          await wait(1)
+          yield new MessageFrame(1)
+          await wait(1)
+          yield new MessageFrame(2)
+          await wait(1)
+          yield new ErrorFrame({
+            error: 'BadOops',
+            message: 'That was a bad one',
+          })
+          await wait(1)
+          yield new MessageFrame(3)
+          return
+        },
+      })
+      await once(httpServer.listen(), 'listening')
+      const { port } = server.wss.address() as AddressInfo
+
+      const ws = new WebSocket(`ws://localhost:${port}`)
+      const frames: Frame[] = []
+
+      let error
+      try {
+        for await (const frame of byMessage(ws)) {
+          frames.push(frame)
+        }
+      } catch (err) {
+        error = err
+      }
+
+      expect(ws.readyState).toEqual(ws.CLOSING)
+      expect(frames).toEqual([new MessageFrame(1), new MessageFrame(2)])
+      expect(error).toBeInstanceOf(XRPCError)
+      if (error instanceof XRPCError) {
+        expect(error.error).toEqual('BadOops')
+        expect(error.message).toEqual('That was a bad one')
+      }
+
+      httpServer.close()
+    })
+  })
+})