@atproto/xrpc-server 0.11.4 → 0.11.6

package/tests/queries.test.ts

@@ -1,140 +0,0 @@
-import * as http from 'node:http'
-import { AddressInfo } from 'node:net'
-import { LexiconDoc } from '@atproto/lexicon'
-import { XrpcClient } from '@atproto/xrpc'
-import * as xrpcServer from '../src/index.js'
-import {
-  buildAddLexicons,
-  buildMethodLexicons,
-  closeServer,
-  createServer,
-} from './_util.js'
-
-const LEXICONS = [
-  {
-    lexicon: 1,
-    id: 'io.example.pingOne',
-    defs: {
-      main: {
-        type: 'query',
-        parameters: {
-          type: 'params',
-          properties: {
-            message: { type: 'string' },
-          },
-        },
-        output: {
-          encoding: 'text/plain',
-        },
-      },
-    },
-  },
-  {
-    lexicon: 1,
-    id: 'io.example.pingTwo',
-    defs: {
-      main: {
-        type: 'query',
-        parameters: {
-          type: 'params',
-          properties: {
-            message: { type: 'string' },
-          },
-        },
-        output: {
-          encoding: 'application/octet-stream',
-        },
-      },
-    },
-  },
-  {
-    lexicon: 1,
-    id: 'io.example.pingThree',
-    defs: {
-      main: {
-        type: 'query',
-        parameters: {
-          type: 'params',
-          properties: {
-            message: { type: 'string' },
-          },
-        },
-        output: {
-          encoding: 'application/json',
-          schema: {
-            type: 'object',
-            required: ['message'],
-            properties: { message: { type: 'string' } },
-          },
-        },
-      },
-    },
-  },
-] as const satisfies LexiconDoc[]
-
-const handlers = {
-  'io.example.pingOne': (ctx: xrpcServer.HandlerContext) => {
-    return { encoding: 'text/plain', body: ctx.params.message }
-  },
-  'io.example.pingTwo': (ctx: xrpcServer.HandlerContext) => {
-    return {
-      encoding: 'application/octet-stream',
-      body: new TextEncoder().encode(String(ctx.params.message)),
-    }
-  },
-  'io.example.pingThree': (ctx: xrpcServer.HandlerContext) => {
-    return {
-      encoding: 'application/json',
-      body: { message: ctx.params.message },
-      headers: { 'x-test-header-name': 'test-value' },
-    }
-  },
-}
-
-for (const buildServer of [buildMethodLexicons, buildAddLexicons]) {
-  describe(buildServer, () => {
-    let s: http.Server
-    let client: XrpcClient
-    let url: string
-    beforeAll(async () => {
-      const server = await buildServer(LEXICONS, handlers)
-      s = await createServer(server)
-      const { port } = s.address() as AddressInfo
-      url = `http://localhost:${port}`
-      client = new XrpcClient(url, LEXICONS)
-    })
-    afterAll(async () => {
-      if (s) await closeServer(s)
-    })
-
-    test('io.example.pingOne', async () => {
-      const res = await client.call('io.example.pingOne', {
-        message: 'hello world',
-      })
-      expect(res.success).toBeTruthy()
-      expect(res.headers['content-type']).toBe('text/plain; charset=utf-8')
-      expect(res.data).toBe('hello world')
-    })
-
-    test('io.example.pingTwo', async () => {
-      const res = await client.call('io.example.pingTwo', {
-        message: 'hello world',
-      })
-      expect(res.success).toBeTruthy()
-      expect(res.headers['content-type']).toBe('application/octet-stream')
-      expect(new TextDecoder().decode(res.data)).toBe('hello world')
-    })
-
-    test('io.example.pingThree', async () => {
-      const res = await client.call('io.example.pingThree', {
-        message: 'hello world',
-      })
-      expect(res.success).toBeTruthy()
-      expect(res.headers['content-type']).toBe(
-        'application/json; charset=utf-8',
-      )
-      expect(res.data?.message).toBe('hello world')
-      expect(res.headers['x-test-header-name']).toEqual('test-value')
-    })
-  })
-}

package/tests/rate-limiter.test.ts

@@ -1,312 +0,0 @@
-import * as http from 'node:http'
-import { AddressInfo } from 'node:net'
-import { MINUTE } from '@atproto/common'
-import { LexiconDoc } from '@atproto/lexicon'
-import { XrpcClient } from '@atproto/xrpc'
-import * as xrpcServer from '../src/index.js'
-import { MemoryRateLimiter } from '../src/index.js'
-import { closeServer, createServer } from './_util.js'
-
-const LEXICONS: LexiconDoc[] = [
-  {
-    lexicon: 1,
-    id: 'io.example.routeLimit',
-    defs: {
-      main: {
-        type: 'query',
-        parameters: {
-          type: 'params',
-          required: ['str'],
-          properties: {
-            str: { type: 'string' },
-          },
-        },
-        output: {
-          encoding: 'application/json',
-        },
-      },
-    },
-  },
-  {
-    lexicon: 1,
-    id: 'io.example.routeLimitReset',
-    defs: {
-      main: {
-        type: 'query',
-        parameters: {
-          type: 'params',
-          required: ['count'],
-          properties: {
-            count: { type: 'integer' },
-          },
-        },
-        output: {
-          encoding: 'application/json',
-        },
-      },
-    },
-  },
-  {
-    lexicon: 1,
-    id: 'io.example.sharedLimitOne',
-    defs: {
-      main: {
-        type: 'query',
-        parameters: {
-          type: 'params',
-          required: ['points'],
-          properties: {
-            points: { type: 'integer' },
-          },
-        },
-        output: {
-          encoding: 'application/json',
-        },
-      },
-    },
-  },
-  {
-    lexicon: 1,
-    id: 'io.example.sharedLimitTwo',
-    defs: {
-      main: {
-        type: 'query',
-        parameters: {
-          type: 'params',
-          required: ['points'],
-          properties: {
-            points: { type: 'integer' },
-          },
-        },
-        output: {
-          encoding: 'application/json',
-        },
-      },
-    },
-  },
-  {
-    lexicon: 1,
-    id: 'io.example.toggleLimit',
-    defs: {
-      main: {
-        type: 'query',
-        parameters: {
-          type: 'params',
-          properties: {
-            shouldCount: { type: 'boolean' },
-          },
-        },
-        output: {
-          encoding: 'application/json',
-        },
-      },
-    },
-  },
-  {
-    lexicon: 1,
-    id: 'io.example.noLimit',
-    defs: {
-      main: {
-        type: 'query',
-        output: {
-          encoding: 'application/json',
-        },
-      },
-    },
-  },
-  {
-    lexicon: 1,
-    id: 'io.example.nonExistent',
-    defs: {
-      main: {
-        type: 'query',
-        output: {
-          encoding: 'application/json',
-        },
-      },
-    },
-  },
-]
-
-describe('Parameters', () => {
-  let s: http.Server
-  const server = xrpcServer.createServer(LEXICONS, {
-    rateLimits: {
-      creator: (opts) => new MemoryRateLimiter(opts),
-      bypass: ({ req }) => req.headers['x-ratelimit-bypass'] === 'bypass',
-      shared: [
-        {
-          name: 'shared-limit',
-          durationMs: 5 * MINUTE,
-          points: 6,
-        },
-      ],
-      global: [
-        {
-          name: 'global-ip',
-          durationMs: 5 * MINUTE,
-          points: 100,
-        },
-      ],
-    },
-  })
-  server.method('io.example.routeLimit', {
-    rateLimit: {
-      durationMs: 5 * MINUTE,
-      points: 5,
-      calcKey: ({ params }) => params.str as string,
-    },
-    handler: (ctx) => ({
-      encoding: 'json',
-      body: ctx.params,
-    }),
-  })
-  server.method('io.example.routeLimitReset', {
-    rateLimit: {
-      durationMs: 5 * MINUTE,
-      points: 2,
-    },
-    handler: (ctx) => {
-      if (ctx.params.count === 1) {
-        ctx.resetRouteRateLimits()
-      }
-
-      return {
-        encoding: 'json',
-        body: {},
-      }
-    },
-  })
-  server.method('io.example.sharedLimitOne', {
-    rateLimit: {
-      name: 'shared-limit',
-      calcPoints: ({ params }) => params.points as number,
-    },
-    handler: (ctx) => ({
-      encoding: 'json',
-      body: ctx.params,
-    }),
-  })
-  server.method('io.example.sharedLimitTwo', {
-    rateLimit: {
-      name: 'shared-limit',
-      calcPoints: ({ params }) => params.points as number,
-    },
-    handler: (ctx) => ({
-      encoding: 'json',
-      body: ctx.params,
-    }),
-  })
-  server.method('io.example.toggleLimit', {
-    rateLimit: [
-      {
-        durationMs: 5 * MINUTE,
-        points: 5,
-        calcPoints: ({ params }) => (params.shouldCount ? 1 : 0),
-      },
-      {
-        durationMs: 5 * MINUTE,
-        points: 10,
-      },
-    ],
-    handler: (ctx) => ({
-      encoding: 'json',
-      body: ctx.params,
-    }),
-  })
-  server.method('io.example.noLimit', {
-    handler: () => ({
-      encoding: 'json',
-      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('rate limits a given route', async () => {
-    const makeCall = () => client.call('io.example.routeLimit', { str: 'test' })
-    for (let i = 0; i < 5; i++) {
-      await makeCall()
-    }
-    await expect(makeCall).rejects.toThrow('Rate Limit Exceeded')
-  })
-
-  it('can reset route rate limits', async () => {
-    // Limit is 2.
-    // Call 0 is OK (1/2).
-    // Call 1 is OK (2/2), and resets the limit.
-    // Call 2 is OK (1/2).
-    // Call 3 is OK (2/2).
-    for (let i = 0; i < 4; i++) {
-      await client.call('io.example.routeLimitReset', { count: i })
-    }
-
-    // Call 4 exceeds the limit (3/2).
-    await expect(
-      client.call('io.example.routeLimitReset', { count: 4 }),
-    ).rejects.toThrow('Rate Limit Exceeded')
-  })
-
-  it('rate limits on a shared route', async () => {
-    await client.call('io.example.sharedLimitOne', { points: 1 })
-    await client.call('io.example.sharedLimitTwo', { points: 1 })
-    await client.call('io.example.sharedLimitOne', { points: 2 })
-    await client.call('io.example.sharedLimitTwo', { points: 2 })
-    await expect(
-      client.call('io.example.sharedLimitOne', { points: 1 }),
-    ).rejects.toThrow('Rate Limit Exceeded')
-    await expect(
-      client.call('io.example.sharedLimitTwo', { points: 1 }),
-    ).rejects.toThrow('Rate Limit Exceeded')
-  })
-
-  it('applies multiple rate-limits', async () => {
-    const makeCall = (shouldCount: boolean) =>
-      client.call('io.example.toggleLimit', { shouldCount })
-    for (let i = 0; i < 5; i++) {
-      await makeCall(true)
-    }
-    await expect(() => makeCall(true)).rejects.toThrow('Rate Limit Exceeded')
-    for (let i = 0; i < 4; i++) {
-      await makeCall(false)
-    }
-    await expect(() => makeCall(false)).rejects.toThrow('Rate Limit Exceeded')
-  })
-
-  it('applies global limits', async () => {
-    const makeCall = () => client.call('io.example.noLimit')
-    const calls: Promise<unknown>[] = []
-    for (let i = 0; i < 110; i++) {
-      calls.push(makeCall())
-    }
-    await expect(Promise.all(calls)).rejects.toThrow('Rate Limit Exceeded')
-  })
-
-  it('applies global limits to xrpc catchall', async () => {
-    const makeCall = () => client.call('io.example.nonExistent')
-    await expect(makeCall()).rejects.toThrow('Rate Limit Exceeded')
-  })
-
-  it('can bypass rate limits', async () => {
-    const makeCall = () =>
-      client.call(
-        'io.example.noLimit',
-        {},
-        {},
-        { headers: { 'X-RateLimit-Bypass': 'bypass' } },
-      )
-    const calls: Promise<unknown>[] = []
-    for (let i = 0; i < 110; i++) {
-      calls.push(makeCall())
-    }
-    await Promise.all(calls)
-  })
-})

package/tests/responses.test.ts

@@ -1,72 +0,0 @@
-import * as http from 'node:http'
-import { AddressInfo } from 'node:net'
-import { byteIterableToStream } from '@atproto/common'
-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.readableStream',
-    defs: {
-      main: {
-        type: 'query',
-        parameters: {
-          type: 'params',
-          properties: {
-            shouldErr: { type: 'boolean' },
-          },
-        },
-        output: {
-          encoding: 'application/vnd.ipld.car',
-        },
-      },
-    },
-  },
-]
-
-describe('Responses', () => {
-  let s: http.Server
-  const server = xrpcServer.createServer(LEXICONS)
-  server.method('io.example.readableStream', async (ctx) => {
-    async function* iter(): AsyncIterable<Uint8Array> {
-      for (let i = 0; i < 5; i++) {
-        yield new Uint8Array([i])
-      }
-      if (ctx.params.shouldErr) {
-        throw new Error('error')
-      }
-    }
-    return {
-      encoding: 'application/vnd.ipld.car',
-      body: byteIterableToStream(iter()),
-    }
-  })
-
-  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('returns readable streams of bytes', async () => {
-    const res = await client.call('io.example.readableStream', {
-      shouldErr: false,
-    })
-    const expected = new Uint8Array([0, 1, 2, 3, 4])
-    expect(res.data).toEqual(expected)
-  })
-
-  it('handles errs on readable streams of bytes', async () => {
-    const attempt = client.call('io.example.readableStream', {
-      shouldErr: true,
-    })
-    await expect(attempt).rejects.toThrow()
-  })
-})

package/tests/stream.test.ts

@@ -1,169 +0,0 @@
-import { once } from 'node:events'
-import * as http from 'node:http'
-import { AddressInfo } from 'node:net'
-import { WebSocket } from 'ws'
-import { XRPCError } from '@atproto/xrpc'
-import {
-  ErrorFrame,
-  Frame,
-  MessageFrame,
-  XrpcStreamServer,
-  byFrame,
-  byMessage,
-} from '../src/index.js'
-
-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()
-    })
-  })
-})