@atproto/xrpc-server 0.6.0 → 0.6.1-rc.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/xrpc-server",
-  "version": "0.6.0",
+  "version": "0.6.1-rc.0",
   "license": "MIT",
   "description": "atproto HTTP API (XRPC) server library",
   "keywords": [
@@ -24,10 +24,10 @@
     "uint8arrays": "3.0.0",
     "ws": "^8.12.0",
     "zod": "^3.23.8",
-    "@atproto/common": "^0.4.1",
     "@atproto/crypto": "^0.4.0",
     "@atproto/lexicon": "^0.4.0",
-    "@atproto/xrpc": "^0.5.0"
+    "@atproto/common": "^0.4.1",
+    "@atproto/xrpc": "^0.5.1-rc.0"
   },
   "devDependencies": {
     "@types/express": "^4.17.13",

package/tests/auth.test.ts

@@ -7,7 +7,7 @@ import * as ui8 from 'uint8arrays'
 import { MINUTE } from '@atproto/common'
 import { Secp256k1Keypair } from '@atproto/crypto'
 import { LexiconDoc } from '@atproto/lexicon'
-import xrpc, { ServiceClient, XRPCError } from '@atproto/xrpc'
+import { XrpcClient, XRPCError } from '@atproto/xrpc'
 import * as xrpcServer from '../src'
 import {
   createServer,
@@ -62,13 +62,12 @@ describe('Auth', () => {
       }
     },
   })
-  xrpc.addLexicons(LEXICONS)
 
-  let client: ServiceClient
+  let client: XrpcClient
   beforeAll(async () => {
     const port = await getPort()
     s = await createServer(port, server)
-    client = xrpc.service(`http://localhost:${port}`)
+    client = new XrpcClient(`http://localhost:${port}`, LEXICONS)
   })
 
   afterAll(async () => {

package/tests/bodies.test.ts

@@ -3,8 +3,8 @@ import { Readable } from 'stream'
 import { gzipSync } from 'zlib'
 import getPort from 'get-port'
 import { LexiconDoc } from '@atproto/lexicon'
-import xrpc, { ServiceClient } from '@atproto/xrpc'
-import { bytesToStream, cidForCbor } from '@atproto/common'
+import { XrpcClient } from '@atproto/xrpc'
+import { cidForCbor } from '@atproto/common'
 import { randomBytes } from '@atproto/crypto'
 import { createServer, closeServer } from './_util'
 import * as xrpcServer from '../src'
@@ -131,15 +131,14 @@ describe('Bodies', () => {
       }
     },
   )
-  xrpc.addLexicons(LEXICONS)
 
-  let client: ServiceClient
+  let client: XrpcClient
   let url: string
   beforeAll(async () => {
     const port = await getPort()
     s = await createServer(port, server)
     url = `http://localhost:${port}`
-    client = xrpc.service(url)
+    client = new XrpcClient(url, LEXICONS)
   })
   afterAll(async () => {
     await closeServer(s)
@@ -174,7 +173,65 @@ describe('Bodies', () => {
         { foo: 'hello', bar: 123 },
         { encoding: 'image/jpeg' },
       ),
+    ).rejects.toThrow(`Unable to encode object as image/jpeg data`)
+    await expect(
+      client.call(
+        'io.example.validationTest',
+        {},
+        // Does not need to be a valid jpeg
+        new Blob([randomBytes(123)], { type: 'image/jpeg' }),
+      ),
     ).rejects.toThrow(`Wrong request encoding (Content-Type): image/jpeg`)
+    await expect(
+      client.call(
+        'io.example.validationTest',
+        {},
+        (() => {
+          const formData = new FormData()
+          formData.append('foo', 'bar')
+          return formData
+        })(),
+      ),
+    ).rejects.toThrow(
+      `Wrong request encoding (Content-Type): multipart/form-data`,
+    )
+    await expect(
+      client.call(
+        'io.example.validationTest',
+        {},
+        new URLSearchParams([['foo', 'bar']]),
+      ),
+    ).rejects.toThrow(
+      `Wrong request encoding (Content-Type): application/x-www-form-urlencoded`,
+    )
+    await expect(
+      client.call(
+        'io.example.validationTest',
+        {},
+        new Blob([new Uint8Array([1])]),
+      ),
+    ).rejects.toThrow(
+      `Wrong request encoding (Content-Type): application/octet-stream`,
+    )
+    await expect(
+      client.call(
+        'io.example.validationTest',
+        {},
+        new ReadableStream({
+          pull(ctrl) {
+            ctrl.enqueue(new Uint8Array([1]))
+            ctrl.close()
+          },
+        }),
+      ),
+    ).rejects.toThrow(
+      `Wrong request encoding (Content-Type): application/octet-stream`,
+    )
+    await expect(
+      client.call('io.example.validationTest', {}, new Uint8Array([1])),
+    ).rejects.toThrow(
+      `Wrong request encoding (Content-Type): application/octet-stream`,
+    )
 
     // 500 responses don't include details, so we nab details from the logger.
     let error: string | undefined
@@ -201,6 +258,86 @@ describe('Bodies', () => {
     expect(bytesResponse.data.cid).toEqual(expectedCid.toString())
   })
 
+  it('supports empty payload on procedues with encoding', async () => {
+    const bytes = new Uint8Array(0)
+    const expectedCid = await cidForCbor(bytes)
+    const bytesResponse = await client.call('io.example.blobTest', {}, bytes)
+    expect(bytesResponse.data.cid).toEqual(expectedCid.toString())
+  })
+
+  it('supports upload of empty txt file', async () => {
+    const txtFile = new Blob([], { type: 'text/plain' })
+    const expectedCid = await cidForCbor(await txtFile.arrayBuffer())
+    const fileResponse = await client.call('io.example.blobTest', {}, txtFile)
+    expect(fileResponse.data.cid).toEqual(expectedCid.toString())
+  })
+
+  // This does not work because the xrpc-server will add a json middleware
+  // regardless of the "input" definition. This is probably a behavior that
+  // should be fixed in the xrpc-server.
+  it.skip('supports upload of json data', async () => {
+    const jsonFile = new Blob([Buffer.from(`{"foo":"bar","baz":[3, null]}`)], {
+      type: 'application/json',
+    })
+    const expectedCid = await cidForCbor(await jsonFile.arrayBuffer())
+    const fileResponse = await client.call('io.example.blobTest', {}, jsonFile)
+    expect(fileResponse.data.cid).toEqual(expectedCid.toString())
+  })
+
+  it('supports ArrayBufferView', async () => {
+    const bytes = randomBytes(1024)
+    const expectedCid = await cidForCbor(bytes)
+
+    const bufferResponse = await client.call(
+      'io.example.blobTest',
+      {},
+      Buffer.from(bytes),
+    )
+    expect(bufferResponse.data.cid).toEqual(expectedCid.toString())
+  })
+
+  it('supports Blob', async () => {
+    const bytes = randomBytes(1024)
+    const expectedCid = await cidForCbor(bytes)
+
+    const blobResponse = await client.call(
+      'io.example.blobTest',
+      {},
+      new Blob([bytes], { type: 'application/octet-stream' }),
+    )
+    expect(blobResponse.data.cid).toEqual(expectedCid.toString())
+  })
+
+  it('supports Blob without explicit type', async () => {
+    const bytes = randomBytes(1024)
+    const expectedCid = await cidForCbor(bytes)
+
+    const blobResponse = await client.call(
+      'io.example.blobTest',
+      {},
+      new Blob([bytes]),
+    )
+    expect(blobResponse.data.cid).toEqual(expectedCid.toString())
+  })
+
+  it('supports ReadableStream', async () => {
+    const bytes = randomBytes(1024)
+    const expectedCid = await cidForCbor(bytes)
+
+    const streamResponse = await client.call(
+      'io.example.blobTest',
+      {},
+      // ReadableStream.from not available in node < 20
+      new ReadableStream({
+        pull(ctrl) {
+          ctrl.enqueue(bytes)
+          ctrl.close()
+        },
+      }),
+    )
+    expect(streamResponse.data.cid).toEqual(expectedCid.toString())
+  })
+
   it('supports blobs and compression', async () => {
     const bytes = randomBytes(1024)
     const expectedCid = await cidForCbor(bytes)
@@ -230,10 +367,11 @@ describe('Bodies', () => {
   })
 
   it('supports empty payload', async () => {
-    const expectedCid = await cidForCbor(new Uint8Array(0))
+    const bytes = new Uint8Array(0)
+    const expectedCid = await cidForCbor(bytes)
 
     // Using "undefined" as body to avoid encoding as lexicon { $bytes: "<base64>" }
-    const result = await client.call('io.example.blobTest', {}, undefined, {
+    const result = await client.call('io.example.blobTest', {}, bytes, {
       encoding: 'text/plain',
     })
 
@@ -264,7 +402,7 @@ describe('Bodies', () => {
     await client.call(
       'io.example.blobTest',
       {},
-      bytesToStream(bytes.slice(0, BLOB_LIMIT)),
+      bytesToReadableStream(bytes.slice(0, BLOB_LIMIT)),
       {
         encoding: 'application/octet-stream',
       },
@@ -274,7 +412,7 @@ describe('Bodies', () => {
     const promise = client.call(
       'io.example.blobTest',
       {},
-      bytesToStream(bytes),
+      bytesToReadableStream(bytes),
       {
         encoding: 'application/octet-stream',
       },
@@ -310,3 +448,13 @@ describe('Bodies', () => {
     })
   })
 })
+
+const bytesToReadableStream = (bytes: Uint8Array): ReadableStream => {
+  // not using ReadableStream.from(), which lacks support in some contexts including nodejs v18.
+  return new ReadableStream({
+    pull(ctrl) {
+      ctrl.enqueue(bytes)
+      ctrl.close()
+    },
+  })
+}

package/tests/errors.test.ts

@@ -1,14 +1,9 @@
 import * as http from 'http'
 import getPort from 'get-port'
 import { LexiconDoc } from '@atproto/lexicon'
+import { XRPCError, XRPCInvalidResponseError, XrpcClient } from '@atproto/xrpc'
 import { createServer, closeServer } from './_util'
 import * as xrpcServer from '../src'
-import xrpc, {
-  Client,
-  ServiceClient,
-  XRPCError,
-  XRPCInvalidResponseError,
-} from '@atproto/xrpc'
 
 const LEXICONS: LexiconDoc[] = [
   {
@@ -130,17 +125,14 @@ describe('Errors', () => {
   server.method('io.example.procedure', () => {
     return undefined
   })
-  xrpc.addLexicons(LEXICONS)
-  const badXrpc = new Client()
-  badXrpc.addLexicons(MISMATCHED_LEXICONS)
 
-  let client: ServiceClient
-  let badClient: ServiceClient
+  let client: XrpcClient
+  let badClient: XrpcClient
   beforeAll(async () => {
     const port = await getPort()
     s = await createServer(port, server)
-    client = xrpc.service(`http://localhost:${port}`)
-    badClient = badXrpc.service(`http://localhost:${port}`)
+    client = new XrpcClient(`http://localhost:${port}`, LEXICONS)
+    badClient = new XrpcClient(`http://localhost:${port}`, MISMATCHED_LEXICONS)
   })
   afterAll(async () => {
     await closeServer(s)

package/tests/ipld.test.ts

@@ -1,6 +1,6 @@
 import * as http from 'http'
 import { LexiconDoc } from '@atproto/lexicon'
-import xrpc, { ServiceClient } from '@atproto/xrpc'
+import { XrpcClient } from '@atproto/xrpc'
 import { CID } from 'multiformats/cid'
 import getPort from 'get-port'
 import { createServer, closeServer } from './_util'
@@ -63,13 +63,12 @@ describe('Ipld vals', () => {
       return { encoding: 'application/json', body: ctx.input?.body }
     },
   )
-  xrpc.addLexicons(LEXICONS)
 
-  let client: ServiceClient
+  let client: XrpcClient
   beforeAll(async () => {
     const port = await getPort()
     s = await createServer(port, server)
-    client = xrpc.service(`http://localhost:${port}`)
+    client = new XrpcClient(`http://localhost:${port}`, LEXICONS)
   })
   afterAll(async () => {
     await closeServer(s)

package/tests/parameters.test.ts

@@ -1,7 +1,7 @@
 import * as http from 'http'
 import getPort from 'get-port'
 import { LexiconDoc } from '@atproto/lexicon'
-import xrpc, { ServiceClient } from '@atproto/xrpc'
+import { XrpcClient } from '@atproto/xrpc'
 import { createServer, closeServer } from './_util'
 import * as xrpcServer from '../src'
 
@@ -41,13 +41,12 @@ describe('Parameters', () => {
       body: ctx.params,
     }),
   )
-  xrpc.addLexicons(LEXICONS)
 
-  let client: ServiceClient
+  let client: XrpcClient
   beforeAll(async () => {
     const port = await getPort()
     s = await createServer(port, server)
-    client = xrpc.service(`http://localhost:${port}`)
+    client = new XrpcClient(`http://localhost:${port}`, LEXICONS)
   })
   afterAll(async () => {
     await closeServer(s)

package/tests/procedures.test.ts

@@ -1,7 +1,7 @@
 import * as http from 'http'
 import { Readable } from 'stream'
 import { LexiconDoc } from '@atproto/lexicon'
-import xrpc, { ServiceClient } from '@atproto/xrpc'
+import { XrpcClient } from '@atproto/xrpc'
 import getPort from 'get-port'
 import { createServer, closeServer } from './_util'
 import * as xrpcServer from '../src'
@@ -121,13 +121,12 @@ describe('Procedures', () => {
       }
     },
   )
-  xrpc.addLexicons(LEXICONS)
 
-  let client: ServiceClient
+  let client: XrpcClient
   beforeAll(async () => {
     const port = await getPort()
     s = await createServer(port, server)
-    client = xrpc.service(`http://localhost:${port}`)
+    client = new XrpcClient(`http://localhost:${port}`, LEXICONS)
   })
   afterAll(async () => {
     await closeServer(s)

package/tests/queries.test.ts

@@ -1,7 +1,7 @@
 import * as http from 'http'
 import getPort from 'get-port'
 import { LexiconDoc } from '@atproto/lexicon'
-import xrpc, { ServiceClient } from '@atproto/xrpc'
+import { XrpcClient } from '@atproto/xrpc'
 import { createServer, closeServer } from './_util'
 import * as xrpcServer from '../src'
 
@@ -89,13 +89,12 @@ describe('Queries', () => {
       }
     },
   )
-  xrpc.addLexicons(LEXICONS)
 
-  let client: ServiceClient
+  let client: XrpcClient
   beforeAll(async () => {
     const port = await getPort()
     s = await createServer(port, server)
-    client = xrpc.service(`http://localhost:${port}`)
+    client = new XrpcClient(`http://localhost:${port}`, LEXICONS)
   })
   afterAll(async () => {
     await closeServer(s)

package/tests/rate-limiter.test.ts

@@ -1,7 +1,7 @@
 import * as http from 'http'
 import getPort from 'get-port'
 import { LexiconDoc } from '@atproto/lexicon'
-import xrpc, { ServiceClient } from '@atproto/xrpc'
+import { XrpcClient } from '@atproto/xrpc'
 import { createServer, closeServer } from './_util'
 import * as xrpcServer from '../src'
 import { RateLimiter } from '../src'
@@ -190,13 +190,11 @@ describe('Parameters', () => {
     }),
   })
 
-  xrpc.addLexicons(LEXICONS)
-
-  let client: ServiceClient
+  let client: XrpcClient
   beforeAll(async () => {
     const port = await getPort()
     s = await createServer(port, server)
-    client = xrpc.service(`http://localhost:${port}`)
+    client = new XrpcClient(`http://localhost:${port}`, LEXICONS)
   })
   afterAll(async () => {
     await closeServer(s)

package/tests/responses.test.ts

@@ -1,7 +1,7 @@
 import * as http from 'http'
 import getPort from 'get-port'
 import { LexiconDoc } from '@atproto/lexicon'
-import xrpc, { ServiceClient } from '@atproto/xrpc'
+import { XrpcClient } from '@atproto/xrpc'
 import { byteIterableToStream } from '@atproto/common'
 import { createServer, closeServer } from './_util'
 import * as xrpcServer from '../src'
@@ -47,15 +47,12 @@ describe('Responses', () => {
       }
     },
   )
-  xrpc.addLexicons(LEXICONS)
 
-  let client: ServiceClient
-  let url: string
+  let client: XrpcClient
   beforeAll(async () => {
     const port = await getPort()
     s = await createServer(port, server)
-    url = `http://localhost:${port}`
-    client = xrpc.service(url)
+    client = new XrpcClient(`http://localhost:${port}`, LEXICONS)
   })
   afterAll(async () => {
     await closeServer(s)