@atproto/xrpc-server 0.11.4 → 0.11.6

package/tests/errors.test.ts

@@ -1,299 +0,0 @@
-import * as http from 'node:http'
-import { AddressInfo } from 'node:net'
-import { LexiconDoc } from '@atproto/lexicon'
-import { XRPCError, XRPCInvalidResponseError, XrpcClient } from '@atproto/xrpc'
-import * as xrpcServer from '../src/index.js'
-import { closeServer, createServer } from './_util.js'
-
-const UPSTREAM_LEXICONS: LexiconDoc[] = [
-  {
-    lexicon: 1,
-    id: 'io.example.upstreamInvalidResponse',
-    defs: {
-      main: {
-        type: 'query',
-        output: {
-          encoding: 'application/json',
-          schema: {
-            type: 'object',
-            required: ['expectedValue'],
-            properties: {
-              expectedValue: { type: 'string' },
-            },
-          },
-        },
-      },
-    },
-  },
-]
-
-const LEXICONS: LexiconDoc[] = [
-  {
-    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.throwFalsyValue',
-    defs: {
-      main: {
-        type: 'query',
-      },
-    },
-  },
-  {
-    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' },
-            },
-          },
-        },
-      },
-    },
-  },
-  {
-    lexicon: 1,
-    id: 'io.example.invalidUpstreamResponse',
-    defs: {
-      main: {
-        type: 'query',
-      },
-    },
-  },
-]
-
-const MISMATCHED_LEXICONS: LexiconDoc[] = [
-  {
-    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 upstreamS: http.Server
-  const upstreamServer = xrpcServer.createServer(UPSTREAM_LEXICONS, {
-    validateResponse: false,
-  }) // disable validateResponse to test client validation
-  upstreamServer.method('io.example.upstreamInvalidResponse', () => {
-    return { encoding: 'json', body: { something: 'else' } }
-  })
-
-  let upstreamClient: XrpcClient
-
-  let s: http.Server
-  const server = xrpcServer.createServer(LEXICONS, { validateResponse: false }) // disable validateResponse to test client validation
-  server.method('io.example.error', (ctx) => {
-    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.throwFalsyValue', () => {
-    throw ''
-  })
-  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.invalidUpstreamResponse', async () => {
-    await upstreamClient.call('io.example.upstreamInvalidResponse')
-    return {
-      encoding: 'json',
-    }
-  })
-  server.method('io.example.procedure', () => {
-    return undefined
-  })
-
-  let client: XrpcClient
-  let badClient: XrpcClient
-  beforeAll(async () => {
-    upstreamS = await createServer(upstreamServer)
-    const { port: upstreamPort } = upstreamS.address() as AddressInfo
-    upstreamClient = new XrpcClient(
-      `http://localhost:${upstreamPort}`,
-      UPSTREAM_LEXICONS,
-    )
-
-    s = await createServer(server)
-    const { port } = s.address() as AddressInfo
-    client = new XrpcClient(`http://localhost:${port}`, LEXICONS)
-    badClient = new XrpcClient(`http://localhost:${port}`, MISMATCHED_LEXICONS)
-  })
-  afterAll(async () => {
-    await closeServer(s)
-    await closeServer(upstreamS)
-  })
-
-  it('serves requests', async () => {
-    try {
-      await client.call('io.example.error', {
-        which: 'foo',
-      })
-      throw new Error('Didnt throw')
-    } catch (e) {
-      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!')
-    }
-    try {
-      await client.call('io.example.error', {
-        which: 'bar',
-      })
-      throw new Error('Didnt throw')
-    } catch (e) {
-      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).toBeInstanceOf(XRPCError)
-      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).toBeInstanceOf(XRPCError)
-      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).toBeInstanceOf(XRPCError)
-      expect(e).toBeInstanceOf(XRPCInvalidResponseError)
-      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' })
-    }
-    try {
-      await client.call('io.example.invalidUpstreamResponse')
-      throw new Error('Didnt throw')
-    } catch (e: any) {
-      expect(e).toBeInstanceOf(XRPCError)
-      expect((e as XRPCError).status).toBe(500)
-      expect((e as XRPCError).success).toBeFalsy()
-      expect((e as XRPCError).error).toBe('InternalServerError')
-      expect((e as XRPCError).message).toBe('Internal Server Error')
-    }
-  })
-
-  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).toBeInstanceOf(XRPCError)
-      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).toBeInstanceOf(XRPCError)
-      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).toBeInstanceOf(XRPCError)
-      expect(e.success).toBeFalsy()
-      expect(e.error).toBe('MethodNotImplemented')
-      expect(e.message).toBe('Method Not Implemented')
-    }
-  })
-})

package/tests/frames.test.ts

@@ -1,135 +0,0 @@
-import { encode } from '@atproto/lex-cbor'
-import { ui8Equals } from '@atproto/lex-data'
-import { ErrorFrame, Frame, FrameType, MessageFrame } from '../src/index.js'
-
-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(
-      ui8Equals(
-        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(
-      ui8Equals(
-        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.alloc(0)
-    expect(() => Frame.fromBytes(bytes)).toThrow()
-    expect(() => Frame.fromBytes(emptyBytes)).toThrow()
-  })
-
-  it('parsing fails when frame header is malformed.', async () => {
-    const bytes = Buffer.concat([
-      encode({ op: -2 }), // Unknown op
-      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 = 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 = Buffer.concat([
-      messageFrame.toBytes(),
-      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 = Buffer.concat([
-      encode(errorFrame.header),
-      encode({ blah: 1 }),
-    ])
-
-    expect(() => Frame.fromBytes(bytes)).toThrow('Invalid error frame body:')
-  })
-})

package/tests/ipld.test.ts

@@ -1,97 +0,0 @@
-import assert from 'node:assert'
-import * as http from 'node:http'
-import { AddressInfo } from 'node:net'
-import { CID } from 'multiformats/cid'
-import { LexiconDoc } from '@atproto/lexicon'
-import { XrpcClient } from '@atproto/xrpc'
-import * as xrpcServer from '../src/index.js'
-import { closeServer, createServer } from './_util.js'
-
-const LEXICONS: LexiconDoc[] = [
-  {
-    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) => {
-    assert(ctx.input?.body, 'expected input body')
-    assert(typeof ctx.input.body === 'object', 'expected input body')
-
-    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 }
-  })
-
-  let client: XrpcClient
-  beforeAll(async () => {
-    s = await createServer(server)
-    const { port } = s.address() as AddressInfo
-    client = new XrpcClient(`http://localhost:${port}`, LEXICONS)
-  })
-  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)
-  })
-})