@atproto/xrpc-server 0.11.4 → 0.11.6

package/tests/parameters.test.ts

@@ -1,331 +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: LexiconDoc[] = [
-  {
-    lexicon: 1,
-    id: 'io.example.paramTest',
-    defs: {
-      main: {
-        type: 'query',
-        parameters: {
-          type: 'params',
-          required: ['str', 'int', 'bool', 'arr'],
-          properties: {
-            str: { type: 'string', minLength: 2, maxLength: 10 },
-            int: { type: 'integer', minimum: 2, maximum: 10 },
-            bool: { type: 'boolean' },
-            arr: { type: 'array', items: { type: 'integer' }, maxLength: 2 },
-            def: { type: 'integer', default: 0 },
-          },
-        },
-        output: {
-          encoding: 'application/json',
-        },
-      },
-    },
-  },
-]
-
-describe('Parameters', () => {
-  let s: http.Server
-  const server = xrpcServer.createServer(LEXICONS)
-  server.method('io.example.paramTest', (ctx) => ({
-    encoding: 'json',
-    body: ctx.params,
-  }))
-
-  let client: XrpcClient
-  beforeAll(async () => {
-    s = await createServer(server)
-    const { port } = s.address() as AddressInfo
-    client = new XrpcClient(
-      `http://localhost:${port}`,
-      structuredClone(LEXICONS),
-    )
-  })
-  afterAll(async () => {
-    await closeServer(s)
-  })
-
-  it('validates query params', async () => {
-    const res1 = await client.call('io.example.paramTest', {
-      str: 'valid',
-      int: 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.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',
-      bool: 'foo',
-      arr: '3',
-    })
-    expect(res2.success).toBeTruthy()
-    expect(res2.data.str).toBe('10')
-    expect(res2.data.int).toBe(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,
-        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,
-        bool: true,
-        arr: [1],
-      }),
-    ).rejects.toThrow('str must not be longer than 10 characters')
-    await expect(
-      client.call('io.example.paramTest', {
-        int: 5,
-        bool: true,
-        arr: [1],
-      }),
-    ).rejects.toThrow(`Params must have the property "str"`)
-
-    await expect(
-      client.call('io.example.paramTest', {
-        str: 'valid',
-        int: -1,
-        bool: true,
-        arr: [1],
-      }),
-    ).rejects.toThrow('int can not be less than 2')
-    await expect(
-      client.call('io.example.paramTest', {
-        str: 'valid',
-        int: 11,
-        bool: true,
-        arr: [1],
-      }),
-    ).rejects.toThrow('int can not be greater than 10')
-    await expect(
-      client.call('io.example.paramTest', {
-        str: 'valid',
-        bool: true,
-        arr: [1],
-      }),
-    ).rejects.toThrow(`Params must have the property "int"`)
-
-    await expect(
-      client.call('io.example.paramTest', {
-        str: 'valid',
-        int: 5,
-        arr: [1],
-      }),
-    ).rejects.toThrow(`Params must have the property "bool"`)
-
-    await expect(
-      client.call('io.example.paramTest', {
-        str: 'valid',
-        int: 5,
-        bool: true,
-        arr: [],
-      }),
-    ).rejects.toThrow('Error: Params must have the property "arr"')
-    await expect(
-      client.call('io.example.paramTest', {
-        str: 'valid',
-        int: 5,
-        bool: true,
-        arr: [1, 2, 3],
-      }),
-    ).rejects.toThrow('Error: arr must not have more than 2 elements')
-  })
-})
-
-const LOOSE_PARAMS_LEXICONS = [
-  {
-    lexicon: 1,
-    id: 'io.example.looseParamsTest',
-    defs: {
-      main: {
-        type: 'query',
-        parameters: {
-          type: 'params',
-          required: ['str'],
-          properties: {
-            str: { type: 'string' },
-            arr: { type: 'array', items: { type: 'string' } },
-          },
-        },
-        output: {
-          encoding: 'application/json',
-        },
-      },
-    },
-  },
-] as const satisfies LexiconDoc[]
-
-for (const buildServer of [buildMethodLexicons, buildAddLexicons]) {
-  describe(buildServer, () => {
-    let s: http.Server
-    let url: string
-
-    beforeAll(async () => {
-      const server = await buildServer(LOOSE_PARAMS_LEXICONS, {
-        'io.example.looseParamsTest': {
-          opts:
-            buildServer === buildAddLexicons
-              ? { paramsParseLoose: true }
-              : undefined,
-          handler: (ctx: xrpcServer.HandlerContext) => ({
-            encoding: 'application/json',
-            body: ctx.params,
-          }),
-        },
-      })
-      s = await createServer(server)
-      const { port } = s.address() as AddressInfo
-      url = `http://localhost:${port}`
-    })
-
-    afterAll(async () => {
-      await closeServer(s)
-    })
-
-    it('converts bracket[] array syntax to standard params', async () => {
-      const res = await fetch(
-        `${url}/xrpc/io.example.looseParamsTest?str=hello&arr[]=one&arr[]=two`,
-      )
-      expect(res.status).toBe(200)
-      const body = await res.json()
-      expect(body.str).toBe('hello')
-      expect(body.arr).toEqual(['one', 'two'])
-    })
-
-    it('converts bracket[n] array syntax to standard params', async () => {
-      const res = await fetch(
-        `${url}/xrpc/io.example.looseParamsTest?str=hello&arr[0]=one&arr[1]=two`,
-      )
-      expect(res.status).toBe(200)
-      const body = await res.json()
-      expect(body.str).toBe('hello')
-      expect(body.arr).toEqual(['one', 'two'])
-    })
-
-    it('ignores empty indices when using bracket[n] syntax', async () => {
-      const res = await fetch(
-        `${url}/xrpc/io.example.looseParamsTest?str=hello&arr[4]=one&arr[9]=two`,
-      )
-      expect(res.status).toBe(200)
-      const body = await res.json()
-      expect(body.str).toBe('hello')
-      expect(body.arr).toEqual(['one', 'two'])
-    })
-
-    it('still handles standard array syntax', async () => {
-      const res = await fetch(
-        `${url}/xrpc/io.example.looseParamsTest?str=hello&arr=one&arr=two`,
-      )
-      expect(res.status).toBe(200)
-      const body = await res.json()
-      expect(body.str).toBe('hello')
-      expect(body.arr).toEqual(['one', 'two'])
-    })
-
-    it('handles single bracket value', async () => {
-      const res = await fetch(
-        `${url}/xrpc/io.example.looseParamsTest?str=hello&arr[]=only`,
-      )
-      expect(res.status).toBe(200)
-      const body = await res.json()
-      expect(body.str).toBe('hello')
-      expect(body.arr).toEqual(['only'])
-    })
-
-    it('handles single indexed bracket value', async () => {
-      const res = await fetch(
-        `${url}/xrpc/io.example.looseParamsTest?str=hello&arr[0]=only`,
-      )
-      expect(res.status).toBe(200)
-      const body = await res.json()
-      expect(body.str).toBe('hello')
-      expect(body.arr).toEqual(['only'])
-    })
-  })
-}
-
-describe('paramsParseLoose option', () => {
-  it('throws when used with method()', () => {
-    const server = xrpcServer.createServer(
-      structuredClone(LOOSE_PARAMS_LEXICONS),
-    )
-    expect(() => {
-      server.method('io.example.looseParamsTest', {
-        opts: { paramsParseLoose: true },
-        handler: () => ({
-          encoding: 'application/json',
-          body: {},
-        }),
-      })
-    }).toThrow('paramsParseLoose is not supported with method()')
-    expect(() => {
-      server.method('io.example.looseParamsTest', {
-        opts: { paramsParseLoose: false },
-        handler: () => ({
-          encoding: 'application/json',
-          body: {},
-        }),
-      })
-    }).toThrow('paramsParseLoose is not supported with method()')
-  })
-})
-
-describe(buildAddLexicons, () => {
-  it('does not use loose parsing by default', async () => {
-    const server = await buildAddLexicons(LOOSE_PARAMS_LEXICONS, {
-      'io.example.looseParamsTest': (ctx: xrpcServer.HandlerContext) => ({
-        encoding: 'application/json',
-        body: ctx.params,
-      }),
-    })
-
-    await using httpServer = await createServer(server)
-    const { port } = httpServer.address() as AddressInfo
-    const url = `http://localhost:${port}`
-
-    // standard array syntax works
-    const res = await fetch(
-      `${url}/xrpc/io.example.looseParamsTest?str=hello&arr=one&arr=two`,
-    )
-    expect(res.status).toBe(200)
-    const body = await res.json()
-    expect(body.arr).toEqual(['one', 'two'])
-
-    // bracket syntax is not converted without paramsParseLoose
-    const bracketRes = await fetch(
-      `${url}/xrpc/io.example.looseParamsTest?str=hello&arr[]=one&arr[]=two`,
-    )
-    expect(bracketRes.status).toBe(200)
-    const bracketBody = await bracketRes.json()
-    expect(bracketBody.arr).toBeUndefined()
-  })
-})

package/tests/parsing.test.ts

@@ -1,89 +0,0 @@
-import { parseUrlNsid } from '../src/util.js'
-
-const testValid = (url: string, expected: string) => {
-  expect(parseUrlNsid(url)).toBe(expected)
-}
-
-const testInvalid = (url: string, errorMessage = 'invalid xrpc path') => {
-  expect(() => parseUrlNsid(url)).toThrow(errorMessage)
-}
-
-describe('parseUrlNsid', () => {
-  it('should extract the NSID from the URL', () => {
-    testValid('/xrpc/blee.blah.bloo', 'blee.blah.bloo')
-    testValid('/xrpc/blee.blah.bloo?foo[]', 'blee.blah.bloo')
-    testValid('/xrpc/blee.blah.bloo?foo=bar', 'blee.blah.bloo')
-    testValid('/xrpc/com.example.nsid', 'com.example.nsid')
-    testValid('/xrpc/com.example.nsid?foo=bar', 'com.example.nsid')
-    testValid('/xrpc/com.example-domain.nsid', 'com.example-domain.nsid')
-  })
-
-  it('should allow a trailing slash', () => {
-    testValid('/xrpc/blee.blah.bloo/?', 'blee.blah.bloo')
-    testValid('/xrpc/blee.blah.bloo/?foo=', 'blee.blah.bloo')
-    testValid('/xrpc/blee.blah.bloo/?bool', 'blee.blah.bloo')
-    testValid('/xrpc/com.example.nsid/', 'com.example.nsid')
-  })
-
-  it('should throw an error if the URL is too short', () => {
-    testInvalid('/xrpc/a')
-  })
-
-  it('should throw an error if the URL is empty', () => {
-    testInvalid('')
-  })
-
-  it('should throw an error if the URL is missing the NSID', () => {
-    testInvalid('/xrpc/')
-    testInvalid('/xrpc/?')
-    testInvalid('/xrpc/?foo=bar')
-  })
-
-  it('should throw an error if the URL contains extra path segments', () => {
-    testInvalid('/xrpc/123/extra')
-    testInvalid('/xrpc/123/extra?foo=bar')
-  })
-
-  it('should throw an error if the URL is missing the XRPC path prefix', () => {
-    testInvalid('/foo/123')
-    testInvalid('/foo/com.example.nsid')
-  })
-
-  it('should throw an error if the NSID starts with a dot', () => {
-    testInvalid('/xrpc/.')
-    testInvalid('/xrpc/..')
-    testInvalid('/xrpc/....')
-    testInvalid('/xrpc/.com.example.nsid')
-    testInvalid('/xrpc/com..example.nsid')
-    testInvalid('/xrpc/com.example..nsid')
-    testInvalid('/xrpc/com.example.nsid.')
-    testInvalid('/xrpc/com.example.nsid./')
-    testInvalid('/xrpc/com.example.nsid.?foo=bar')
-    testInvalid('/xrpc/com.example.nsid./?foo=bar')
-  })
-
-  it('should throw an error if the NSID contains a misplaced dash', () => {
-    testInvalid('/xrpc/-')
-    testInvalid('/xrpc/com.example.-nsid')
-    testInvalid('/xrpc/com.example-.nsid')
-    testInvalid('/xrpc/com.-example.nsid')
-    testInvalid('/xrpc/com.-example-.nsid')
-    testInvalid('/xrpc/com.example.nsid-')
-    testInvalid('/xrpc/-com.example.nsid')
-    testInvalid('/xrpc/com.example--domain.nsid')
-  })
-
-  it('should throw an error if the URL starts with a space', () => {
-    testInvalid(' /xrpc/com.example.nsid')
-  })
-
-  it('should throw an error if the NSID contains invalid characters', () => {
-    testInvalid('/xrpc/com.example.nsid#')
-    testInvalid('/xrpc/com.example.nsid!')
-    testInvalid('/xrpc/com.example#?nsid')
-    testInvalid('/xrpc/!com.example.nsid')
-    testInvalid('/xrpc/com.example.nsid ')
-    testInvalid('/xrpc/ com.example.nsid')
-    testInvalid('/xrpc/com. example.nsid')
-  })
-})

package/tests/procedures.test.ts

@@ -1,176 +0,0 @@
-import assert from 'node:assert'
-import * as http from 'node:http'
-import { AddressInfo } from 'node:net'
-import { Readable } from 'node:stream'
-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: 'procedure',
-        parameters: {
-          type: 'params',
-          properties: {
-            message: { type: 'string' },
-          },
-        },
-        output: {
-          encoding: 'text/plain',
-        },
-      },
-    },
-  },
-  {
-    lexicon: 1,
-    id: 'io.example.pingTwo',
-    defs: {
-      main: {
-        type: 'procedure',
-        input: {
-          encoding: 'text/plain',
-        },
-        output: {
-          encoding: 'text/plain',
-        },
-      },
-    },
-  },
-  {
-    lexicon: 1,
-    id: 'io.example.pingThree',
-    defs: {
-      main: {
-        type: 'procedure',
-        input: {
-          encoding: 'application/octet-stream',
-        },
-        output: {
-          encoding: 'application/octet-stream',
-        },
-      },
-    },
-  },
-  {
-    lexicon: 1,
-    id: 'io.example.pingFour',
-    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' } },
-          },
-        },
-      },
-    },
-  },
-] 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: 'text/plain', body: ctx.input?.body }
-  },
-  'io.example.pingThree': async (ctx: xrpcServer.HandlerContext) => {
-    assert(ctx.input?.body instanceof Readable, '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),
-    }
-  },
-  'io.example.pingFour': (ctx: xrpcServer.HandlerContext) => {
-    return {
-      encoding: 'application/json',
-      body: { message: ctx.input?.body?.['message'] },
-    }
-  },
-}
-
-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, structuredClone(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', {}, 'hello world', {
-        encoding: 'text/plain',
-      })
-      expect(res.success).toBeTruthy()
-      expect(res.headers['content-type']).toBe('text/plain; charset=utf-8')
-      expect(res.data).toBe('hello world')
-    })
-
-    test('io.example.pingThree', async () => {
-      const res = await client.call(
-        'io.example.pingThree',
-        {},
-        new TextEncoder().encode('hello world'),
-        { encoding: 'application/octet-stream' },
-      )
-      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.pingFour', async () => {
-      const res = await client.call(
-        'io.example.pingFour',
-        {},
-        { 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')
-    })
-  })
-}