@atproto/xrpc-server 0.0.1

package/tests/errors.test.ts

@@ -0,0 +1,214 @@
+import * as http from 'http'
+import { createServer, closeServer } from './_util'
+import * as xrpcServer from '../src'
+import xrpc, {
+  Client,
+  XRPCError,
+  XRPCInvalidResponseError,
+} from '@atproto/xrpc'
+
+const LEXICONS = [
+  {
+    lexicon: 1,
+    id: 'io.example.error',
+    defs: {
+      main: {
+        type: 'query',
+        parameters: {
+          type: 'params',
+          properties: {
+            which: { type: 'string', default: 'foo' },
+          },
+        },
+        errors: [{ name: 'Foo' }, { name: 'Bar' }],
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'io.example.query',
+    defs: {
+      main: {
+        type: 'query',
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'io.example.procedure',
+    defs: {
+      main: {
+        type: 'procedure',
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'io.example.invalidResponse',
+    defs: {
+      main: {
+        type: 'query',
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['expectedValue'],
+            properties: {
+              expectedValue: { type: 'string' },
+            },
+          },
+        },
+      },
+    },
+  },
+]
+
+const MISMATCHED_LEXICONS = [
+  {
+    lexicon: 1,
+    id: 'io.example.query',
+    defs: {
+      main: {
+        type: 'procedure',
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'io.example.procedure',
+    defs: {
+      main: {
+        type: 'query',
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'io.example.doesNotExist',
+    defs: {
+      main: {
+        type: 'query',
+      },
+    },
+  },
+]
+
+describe('Errors', () => {
+  let s: http.Server
+  const server = xrpcServer.createServer(LEXICONS, { validateResponse: false }) // disable validateResponse to test client validation
+  server.method('io.example.error', (ctx: { params: xrpcServer.Params }) => {
+    if (ctx.params.which === 'foo') {
+      throw new xrpcServer.InvalidRequestError('It was this one!', 'Foo')
+    } else if (ctx.params.which === 'bar') {
+      return { status: 400, error: 'Bar', message: 'It was that one!' }
+    } else {
+      return { status: 400 }
+    }
+  })
+  server.method('io.example.query', () => {
+    return undefined
+  })
+  // @ts-ignore We're intentionally giving the wrong response! -prf
+  server.method('io.example.invalidResponse', () => {
+    return { encoding: 'json', body: { something: 'else' } }
+  })
+  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)
+  beforeAll(async () => {
+    s = await createServer(8893, server)
+  })
+  afterAll(async () => {
+    await closeServer(s)
+  })
+
+  it('serves requests', async () => {
+    try {
+      await client.call('io.example.error', {
+        which: 'foo',
+      })
+      throw new Error('Didnt throw')
+    } catch (e) {
+      expect(e instanceof XRPCError).toBeTruthy()
+      expect((e as XRPCError).success).toBeFalsy()
+      expect((e as XRPCError).error).toBe('Foo')
+      expect((e as XRPCError).message).toBe('It was this one!')
+    }
+    try {
+      await client.call('io.example.error', {
+        which: 'bar',
+      })
+      throw new Error('Didnt throw')
+    } catch (e) {
+      expect(e instanceof XRPCError).toBeTruthy()
+      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.error', {
+        which: 'other',
+      })
+      throw new Error('Didnt throw')
+    } catch (e) {
+      expect(e instanceof XRPCError).toBeTruthy()
+      expect((e as XRPCError).success).toBeFalsy()
+      expect((e as XRPCError).error).toBe('InvalidRequest')
+      expect((e as XRPCError).message).toBe('Invalid Request')
+    }
+    try {
+      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.success).toBeFalsy()
+      expect(e.error).toBe('Invalid Response')
+      expect(e.message).toBe(
+        'The server gave an invalid response and may be out of date.',
+      )
+      const err = e as XRPCInvalidResponseError
+      expect(err.validationError.message).toBe(
+        'Output must have the property "expectedValue"',
+      )
+      expect(err.responseBody).toStrictEqual({ something: 'else' })
+    }
+  })
+
+  it('serves error for missing/mismatch schemas', async () => {
+    await client.call('io.example.query') // No error
+    await client.call('io.example.procedure') // No error
+    try {
+      await badClient.call('io.example.query')
+      throw new Error('Didnt throw')
+    } catch (e: any) {
+      expect(e instanceof XRPCError).toBeTruthy()
+      expect(e.success).toBeFalsy()
+      expect(e.error).toBe('InvalidRequest')
+      expect(e.message).toBe('Incorrect HTTP method (POST) expected GET')
+    }
+    try {
+      await badClient.call('io.example.procedure')
+      throw new Error('Didnt throw')
+    } catch (e: any) {
+      expect(e instanceof XRPCError).toBeTruthy()
+      expect(e.success).toBeFalsy()
+      expect(e.error).toBe('InvalidRequest')
+      expect(e.message).toBe('Incorrect HTTP method (GET) expected POST')
+    }
+    try {
+      await badClient.call('io.example.doesNotExist')
+      throw new Error('Didnt throw')
+    } catch (e: any) {
+      expect(e instanceof XRPCError).toBeTruthy()
+      expect(e.success).toBeFalsy()
+      expect(e.error).toBe('MethodNotImplemented')
+      expect(e.message).toBe('Method Not Implemented')
+    }
+  })
+})

package/tests/parameters.test.ts

@@ -0,0 +1,189 @@
+import * as http from 'http'
+import { createServer, closeServer } from './_util'
+import * as xrpcServer from '../src'
+import xrpc from '@atproto/xrpc'
+
+const LEXICONS = [
+  {
+    lexicon: 1,
+    id: 'io.example.paramTest',
+    defs: {
+      main: {
+        type: 'query',
+        parameters: {
+          type: 'params',
+          required: ['str', 'int', 'num', '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 },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+        },
+      },
+    },
+  },
+]
+
+describe('Parameters', () => {
+  let s: http.Server
+  const server = xrpcServer.createServer(LEXICONS)
+  server.method(
+    'io.example.paramTest',
+    (ctx: { params: xrpcServer.Params }) => ({
+      encoding: 'json',
+      body: ctx.params,
+    }),
+  )
+  const client = xrpc.service(`http://localhost:8889`)
+  xrpc.addLexicons(LEXICONS)
+  beforeAll(async () => {
+    s = await createServer(8889, server)
+  })
+  afterAll(async () => {
+    await closeServer(s)
+  })
+
+  it('validates query params', async () => {
+    const res1 = await client.call('io.example.paramTest', {
+      str: 'valid',
+      int: 5,
+      num: 5.5,
+      bool: true,
+      arr: [1, 2],
+    })
+    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])
+
+    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])
+
+    await expect(
+      client.call('io.example.paramTest', {
+        str: 'n',
+        int: 5,
+        num: 5.5,
+        bool: true,
+        arr: [1],
+      }),
+    ).rejects.toThrow('str must not be shorter than 2 characters')
+    await expect(
+      client.call('io.example.paramTest', {
+        str: 'loooooooooooooong',
+        int: 5,
+        num: 5.5,
+        bool: true,
+        arr: [1],
+      }),
+    ).rejects.toThrow('str must not be longer than 10 characters')
+    await expect(
+      client.call('io.example.paramTest', {
+        int: 5,
+        num: 5.5,
+        bool: true,
+        arr: [1],
+      }),
+    ).rejects.toThrow(`Params must have the property "str"`)
+
+    await expect(
+      client.call('io.example.paramTest', {
+        str: 'valid',
+        int: -1,
+        num: 5.5,
+        bool: true,
+        arr: [1],
+      }),
+    ).rejects.toThrow('int can not be less than 2')
+    await expect(
+      client.call('io.example.paramTest', {
+        str: 'valid',
+        int: 11,
+        num: 5.5,
+        bool: true,
+        arr: [1],
+      }),
+    ).rejects.toThrow('int can not be greater than 10')
+    await expect(
+      client.call('io.example.paramTest', {
+        str: 'valid',
+        num: 5.5,
+        bool: true,
+        arr: [1],
+      }),
+    ).rejects.toThrow(`Params must have the property "int"`)
+
+    await expect(
+      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"`)
+
+    await expect(
+      client.call('io.example.paramTest', {
+        str: 'valid',
+        int: 5,
+        num: 5.5,
+        bool: true,
+        arr: [],
+      }),
+    ).rejects.toThrow('Error: Params must have the property "arr"')
+    await expect(
+      client.call('io.example.paramTest', {
+        str: 'valid',
+        int: 5,
+        num: 5.5,
+        bool: true,
+        arr: [1, 2, 3],
+      }),
+    ).rejects.toThrow('Error: arr must not have more than 2 elements')
+  })
+})

package/tests/procedures.test.ts

@@ -0,0 +1,165 @@
+import * as http from 'http'
+import { Readable } from 'stream'
+import xrpc from '@atproto/xrpc'
+import { createServer, closeServer } from './_util'
+import * as xrpcServer from '../src'
+
+const LEXICONS = [
+  {
+    lexicon: 1,
+    id: 'io.example.ping1',
+    defs: {
+      main: {
+        type: 'procedure',
+        parameters: {
+          type: 'params',
+          properties: {
+            message: { type: 'string' },
+          },
+        },
+        output: {
+          encoding: 'text/plain',
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'io.example.ping2',
+    defs: {
+      main: {
+        type: 'procedure',
+        input: {
+          encoding: 'text/plain',
+        },
+        output: {
+          encoding: 'text/plain',
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'io.example.ping3',
+    defs: {
+      main: {
+        type: 'procedure',
+        input: {
+          encoding: 'application/octet-stream',
+        },
+        output: {
+          encoding: 'application/octet-stream',
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'io.example.ping4',
+    defs: {
+      main: {
+        type: 'procedure',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['message'],
+            properties: { message: { type: 'string' } },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['message'],
+            properties: { message: { type: 'string' } },
+          },
+        },
+      },
+    },
+  },
+]
+
+describe('Procedures', () => {
+  let s: http.Server
+  const server = xrpcServer.createServer(LEXICONS)
+  server.method('io.example.ping1', (ctx: { params: xrpcServer.Params }) => {
+    return { encoding: 'text/plain', body: ctx.params.message }
+  })
+  server.method(
+    'io.example.ping2',
+    (ctx: { params: xrpcServer.Params; input?: xrpcServer.HandlerInput }) => {
+      return { encoding: 'text/plain', body: ctx.input?.body }
+    },
+  )
+  server.method(
+    'io.example.ping3',
+    async (ctx: {
+      params: xrpcServer.Params
+      input?: xrpcServer.HandlerInput
+    }) => {
+      if (!(ctx.input?.body instanceof Readable))
+        throw new Error('Input not readable')
+      const buffers: Buffer[] = []
+      for await (const data of ctx.input.body) {
+        buffers.push(data)
+      }
+      return {
+        encoding: 'application/octet-stream',
+        body: Buffer.concat(buffers),
+      }
+    },
+  )
+  server.method(
+    'io.example.ping4',
+    (ctx: { params: xrpcServer.Params; input?: xrpcServer.HandlerInput }) => {
+      return {
+        encoding: 'application/json',
+        body: { message: ctx.input?.body?.message },
+      }
+    },
+  )
+  const client = xrpc.service(`http://localhost:8891`)
+  xrpc.addLexicons(LEXICONS)
+  beforeAll(async () => {
+    s = await createServer(8891, server)
+  })
+  afterAll(async () => {
+    await closeServer(s)
+  })
+
+  it('serves requests', async () => {
+    const res1 = await client.call('io.example.ping1', {
+      message: 'hello world',
+    })
+    expect(res1.success).toBeTruthy()
+    expect(res1.headers['content-type']).toBe('text/plain; charset=utf-8')
+    expect(res1.data).toBe('hello world')
+
+    const res2 = await client.call('io.example.ping2', {}, 'hello world', {
+      encoding: 'text/plain',
+    })
+    expect(res2.success).toBeTruthy()
+    expect(res2.headers['content-type']).toBe('text/plain; charset=utf-8')
+    expect(res2.data).toBe('hello world')
+
+    const res3 = await client.call(
+      'io.example.ping3',
+      {},
+      new TextEncoder().encode('hello world'),
+      { encoding: 'application/octet-stream' },
+    )
+    expect(res3.success).toBeTruthy()
+    expect(res3.headers['content-type']).toBe('application/octet-stream')
+    expect(new TextDecoder().decode(res3.data)).toBe('hello world')
+
+    const res4 = await client.call(
+      'io.example.ping4',
+      {},
+      { message: 'hello world' },
+    )
+    expect(res4.success).toBeTruthy()
+    expect(res4.headers['content-type']).toBe('application/json; charset=utf-8')
+    expect(res4.data?.message).toBe('hello world')
+  })
+})

package/tests/queries.test.ts

@@ -0,0 +1,117 @@
+import * as http from 'http'
+import { createServer, closeServer } from './_util'
+import * as xrpcServer from '../src'
+import xrpc from '@atproto/xrpc'
+
+const LEXICONS = [
+  {
+    lexicon: 1,
+    id: 'io.example.ping1',
+    defs: {
+      main: {
+        type: 'query',
+        parameters: {
+          type: 'params',
+          properties: {
+            message: { type: 'string' },
+          },
+        },
+        output: {
+          encoding: 'text/plain',
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'io.example.ping2',
+    defs: {
+      main: {
+        type: 'query',
+        parameters: {
+          type: 'params',
+          properties: {
+            message: { type: 'string' },
+          },
+        },
+        output: {
+          encoding: 'application/octet-stream',
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'io.example.ping3',
+    defs: {
+      main: {
+        type: 'query',
+        parameters: {
+          type: 'params',
+          properties: {
+            message: { type: 'string' },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['message'],
+            properties: { message: { type: 'string' } },
+          },
+        },
+      },
+    },
+  },
+]
+
+describe('Queries', () => {
+  let s: http.Server
+  const server = xrpcServer.createServer(LEXICONS)
+  server.method('io.example.ping1', (ctx: { params: xrpcServer.Params }) => {
+    return { encoding: 'text/plain', body: ctx.params.message }
+  })
+  server.method('io.example.ping2', (ctx: { params: xrpcServer.Params }) => {
+    return {
+      encoding: 'application/octet-stream',
+      body: new TextEncoder().encode(String(ctx.params.message)),
+    }
+  })
+  server.method('io.example.ping3', (ctx: { params: xrpcServer.Params }) => {
+    return {
+      encoding: 'application/json',
+      body: { message: ctx.params.message },
+    }
+  })
+  const client = xrpc.service(`http://localhost:8890`)
+  xrpc.addLexicons(LEXICONS)
+  beforeAll(async () => {
+    s = await createServer(8890, server)
+  })
+  afterAll(async () => {
+    await closeServer(s)
+  })
+
+  it('serves requests', async () => {
+    const res1 = await client.call('io.example.ping1', {
+      message: 'hello world',
+    })
+    expect(res1.success).toBeTruthy()
+    expect(res1.headers['content-type']).toBe('text/plain; charset=utf-8')
+    expect(res1.data).toBe('hello world')
+
+    const res2 = await client.call('io.example.ping2', {
+      message: 'hello world',
+    })
+    expect(res2.success).toBeTruthy()
+    expect(res2.headers['content-type']).toBe('application/octet-stream')
+    expect(new TextDecoder().decode(res2.data)).toBe('hello world')
+
+    const res3 = await client.call('io.example.ping3', {
+      message: 'hello world',
+    })
+    expect(res3.success).toBeTruthy()
+    expect(res3.headers['content-type']).toBe('application/json; charset=utf-8')
+    expect(res3.data?.message).toBe('hello world')
+  })
+})

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["**/*.spec.ts", "**/*.test.ts"]
+}