@atproto/lex-client 0.0.17 → 0.0.18

package/src/response.ts

@@ -13,8 +13,7 @@ import {
   XrpcAuthenticationError,
   XrpcInvalidResponseError,
   XrpcResponseError,
-  XrpcUpstreamError,
-  isXrpcErrorPayload,
+  XrpcResponseValidationError,
 } from './errors.js'
 import {
   EncodingString,
@@ -58,7 +57,7 @@ export type XrpcResponseBody<M extends Procedure | Query> =
   M['output'] extends Payload<infer TEncoding, infer TSchema>
     ? TEncoding extends string
       ? InferBodyType<TEncoding, TSchema>
-      : undefined
+      : undefined | LexValue | Uint8Array
     : never
 
 /**
@@ -75,7 +74,9 @@ export type XrpcResponsePayload<M extends Procedure | Query> =
           encoding: InferEncodingType<TEncoding>
           body: InferBodyType<TEncoding, TSchema>
         }
-      : undefined
+      : // If the schema does not specify an output encoding, anything could be
+        // returned, including no payload at all (undefined).
+        undefined | { body: LexValue | Uint8Array; encoding: string }
     : never
 
 export type XrpcResponseOptions = {
@@ -170,7 +171,7 @@ export class XrpcResponse<M extends Procedure | Query>
    * {@link XrpcResponseError.matchesSchemaErrors} to narrow the error type based on
    * the method's declared error schema. This can be narrowed further as a
    * {@link XrpcAuthenticationError} if the error is an authentication error.
-   * @throws {XrpcUpstreamError} when the response is not a valid XRPC
+   * @throws {XrpcInvalidResponseError} when the response is not a valid XRPC
    * response, or if the response does not conform to the method's schema.
    */
   static async fromFetchResponse<const M extends Procedure | Query>(
@@ -182,63 +183,62 @@ export class XrpcResponse<M extends Procedure | Query>
     // Since nothing should cause an exception before "readPayload" is
     // called, we can safely not use a try/finally here.
 
-    // @NOTE redirect is set to 'follow', so we shouldn't get 3xx responses here
-    if (response.status < 200 || response.status >= 300) {
-      // Always parse json for error responses
+    // Always turn 4xx/5xx responses into XrpcResponseError
+    if (response.status >= 400) {
       const payload = await readPayload(method, response, {
-        parse: { strict: options?.strictResponseProcessing ?? true },
+        // Always parse errors in non-strict mode
+        parse: { strict: false },
       })
 
-      // Properly formatted XRPC error response ?
-      if (response.status >= 400 && isXrpcErrorPayload(payload)) {
-        throw response.status === 401
-          ? new XrpcAuthenticationError<M>(method, response, payload)
-          : new XrpcResponseError<M>(method, response, payload)
+      if (response.status === 401) {
+        throw new XrpcAuthenticationError<M>(method, response, payload)
       }
 
-      // Invalid XRPC response (we probably did not hit an XRPC implementation)
-      throw new XrpcUpstreamError(
+      throw new XrpcResponseError<M>(method, response, payload)
+    }
+
+    // @NOTE redirect is set to 'follow', so we shouldn't get 3xx responses here
+    if (response.status < 200 || response.status >= 300) {
+      await response.body?.cancel()
+
+      throw new XrpcInvalidResponseError(
         method,
         response,
-        payload,
-        response.status >= 500
-          ? 'Upstream server encountered an error'
-          : response.status >= 400
-            ? 'Invalid response payload'
-            : 'Invalid response status code',
+        undefined,
+        `Unexpected status code ${response.status}`,
       )
     }
 
     const payload = await readPayload(method, response, {
-      // Only parse json if the schema expects it
-      parse: method.output.encoding === CONTENT_TYPE_JSON && {
-        strict: options?.strictResponseProcessing ?? true,
-      },
+      // Parse response if there is a schema, or if the encoding is
+      // "application/json"
+      parse:
+        method.output.schema || method.output.encoding === CONTENT_TYPE_JSON
+          ? { strict: options?.strictResponseProcessing ?? true }
+          : // If there is no declared output encoding, we'll parse the output (in loose mode)
+            method.output.encoding == null
+            ? { strict: false }
+            : false,
     })
 
+    if (!method.output.matchesEncoding(payload?.encoding)) {
+      throw new XrpcInvalidResponseError(
+        method,
+        response,
+        payload,
+        `Expected ${stringifyEncoding(method.output.encoding)} response (got ${stringifyEncoding(payload?.encoding)})`,
+      )
+    }
+
     // Response is successful (2xx). Validate payload (data and encoding) against schema.
-    if (method.output.encoding == null) {
-      // Schema expects no payload
-      if (payload) {
-        throw new XrpcUpstreamError(
-          method,
-          response,
-          payload,
-          `Expected response with no body, got ${payload.encoding}`,
-        )
-      }
-    } else {
-      // Schema expects a payload
-      if (!payload || !method.output.matchesEncoding(payload.encoding)) {
-        throw new XrpcUpstreamError(
-          method,
-          response,
-          payload,
-          payload
-            ? `Expected ${method.output.encoding} response, got ${payload.encoding}`
-            : `Expected non-empty response with content-type ${method.output.encoding}`,
-        )
-      }
+    if (method.output.encoding != null) {
+      // If the schema specifies an output, verify that the response properly
+      // matches the expected format (encoding and schema, if present). If no
+      // output is specified, any payload could be returned.
+
+      // Needed for type safety. Should never happen since matchesEncoding()
+      // should return not succeed if there is a schema encoding but no payload.
+      if (!payload) throw new Error('Expected payload')
 
       // Assert valid response body.
       if (method.output.schema && options?.validateResponse !== false) {
@@ -247,7 +247,7 @@ export class XrpcResponse<M extends Procedure | Query>
         })
 
         if (!result.success) {
-          throw new XrpcInvalidResponseError(
+          throw new XrpcResponseValidationError(
             method,
             response,
             payload,
@@ -343,12 +343,16 @@ async function readPayload(
   } catch (cause) {
     const message = 'Unable to parse response payload'
     const messageDetail = cause instanceof TypeError ? cause.message : undefined
-    throw new XrpcUpstreamError(
+    throw new XrpcInvalidResponseError(
       method,
       response,
-      null,
+      undefined,
       messageDetail ? `${message}: ${messageDetail}` : message,
       { cause },
     )
   }
 }
+
+function stringifyEncoding(encoding: string | undefined) {
+  return encoding ? `"${encoding}"` : 'no payload'
+}

package/src/xrpc.test.ts

@@ -9,7 +9,7 @@ import {
   XrpcInternalError,
   XrpcInvalidResponseError,
   XrpcResponseError,
-  XrpcUpstreamError,
+  XrpcResponseValidationError,
 } from './errors.js'
 import { XrpcResponse } from './response.js'
 import { xrpc, xrpcSafe } from './xrpc.js'
@@ -221,6 +221,17 @@ describe(xrpc, () => {
       expect(response.success).toBe(true)
       expect(response.body).toEqual({ value: 'ok' })
     })
+
+    it('ignores output for no-output queries', async () => {
+      const fetchHandler = vi.fn<FetchHandler>(async () => {
+        return Response.json({ unexpected: 'data' })
+      })
+
+      const response = await xrpc(fetchHandler, testNoOutputQuery)
+
+      expect(response.success).toBe(true)
+      expect(response.body).toStrictEqual({ unexpected: 'data' })
+    })
   })
 
   describe('error handling', () => {
@@ -271,7 +282,7 @@ describe(xrpc, () => {
         ).rejects.toSatisfy((err) => {
           assert(err instanceof XrpcResponseError)
           expect(err.status).toBe(400)
-          expect(err.body).toEqual({
+          expect(err.toJSON()).toEqual({
             error: 'TestError',
             message: 'bad request',
           })
@@ -297,7 +308,7 @@ describe(xrpc, () => {
         })
       })
 
-      it('throws XrpcUpstreamError for non-XRPC error response', async () => {
+      it('throws XrpcResponseError for non-XRPC error response', async () => {
         const fetchHandler = vi.fn<FetchHandler>(async () => {
           return new Response('Not Found', {
             status: 404,
@@ -308,13 +319,13 @@ describe(xrpc, () => {
         await expect(
           xrpc(fetchHandler, testQuery, { params: { limit: 10 } }),
         ).rejects.toSatisfy((err) => {
-          assert(err instanceof XrpcUpstreamError)
-          expect(err.message).toBe('Invalid response payload')
+          assert(err instanceof XrpcResponseError)
+          expect(err.message).toBe('Upstream server responded with a 404 error')
           return true
         })
       })
 
-      it('throws XrpcUpstreamError for 500 without valid error payload', async () => {
+      it('throws XrpcResponseError for 500 without valid error payload', async () => {
         const fetchHandler = vi.fn<FetchHandler>(async () => {
           return new Response('Internal Server Error', {
             status: 500,
@@ -325,8 +336,8 @@ describe(xrpc, () => {
         await expect(
           xrpc(fetchHandler, testQuery, { params: { limit: 10 } }),
         ).rejects.toSatisfy((err) => {
-          assert(err instanceof XrpcUpstreamError)
-          expect(err.message).toBe('Upstream server encountered an error')
+          assert(err instanceof XrpcResponseError)
+          expect(err.message).toBe('Upstream server responded with a 500 error')
           return true
         })
       })
@@ -344,7 +355,7 @@ describe(xrpc, () => {
         ).rejects.toSatisfy((err) => {
           assert(err instanceof XrpcResponseError)
           expect(err.status).toBe(502)
-          expect(err.body).toEqual({
+          expect(err.toJSON()).toEqual({
             error: 'ServerError',
             message: 'Something went wrong',
           })
@@ -354,7 +365,7 @@ describe(xrpc, () => {
     })
 
     describe('invalid response errors', () => {
-      it('throws XrpcInvalidResponseError when response body fails validation', async () => {
+      it('throws XrpcResponseValidationError when response body fails validation', async () => {
         // Schema expects { value: string } but we return { value: 123 }
         const fetchHandler = vi.fn<FetchHandler>(async () => {
           return Response.json({ value: 123 })
@@ -363,14 +374,14 @@ describe(xrpc, () => {
         await expect(
           xrpc(fetchHandler, testQuery, { params: { limit: 10 } }),
         ).rejects.toSatisfy((err) => {
-          assert(err instanceof XrpcInvalidResponseError)
-          expect(err).toBeInstanceOf(XrpcUpstreamError)
+          assert(err instanceof XrpcResponseValidationError)
+          expect(err).toBeInstanceOf(XrpcInvalidResponseError)
           expect(err.cause).toBeInstanceOf(Error)
           return true
         })
       })
 
-      it('throws XrpcUpstreamError when response has wrong content-type', async () => {
+      it('throws XrpcInvalidResponseError when response has wrong content-type', async () => {
         const fetchHandler = vi.fn<FetchHandler>(async () => {
           return new Response('binary data', {
             status: 200,
@@ -381,7 +392,7 @@ describe(xrpc, () => {
         await expect(
           xrpc(fetchHandler, testQuery, { params: { limit: 10 } }),
         ).rejects.toSatisfy((err) => {
-          assert(err instanceof XrpcUpstreamError)
+          assert(err instanceof XrpcInvalidResponseError)
           expect(err.message).toContain('application/json')
           return true
         })
@@ -408,7 +419,7 @@ describe(xrpc, () => {
     })
 
     describe('response payload parsing', () => {
-      it('throws XrpcUpstreamError when error response body cannot be parsed', async () => {
+      it('throws XrpcInvalidResponseError when error response body cannot be parsed', async () => {
         const fetchHandler = vi.fn<FetchHandler>(async () => {
           return new Response('not valid json', {
             status: 400,
@@ -419,7 +430,7 @@ describe(xrpc, () => {
         await expect(
           xrpc(fetchHandler, testQuery, { params: { limit: 10 } }),
         ).rejects.toSatisfy((err) => {
-          assert(err instanceof XrpcUpstreamError)
+          assert(err instanceof XrpcInvalidResponseError)
           expect(err.message).toMatch('Unable to parse response payload')
           assert(err.cause instanceof Error)
           expect(err.cause.message).toContain('Unexpected token')
@@ -427,7 +438,7 @@ describe(xrpc, () => {
         })
       })
 
-      it('throws XrpcUpstreamError when success response body cannot be parsed', async () => {
+      it('throws XrpcInvalidResponseError when success response body cannot be parsed', async () => {
         const fetchHandler = vi.fn<FetchHandler>(async () => {
           return new Response('not valid json', {
             status: 200,
@@ -438,7 +449,7 @@ describe(xrpc, () => {
         await expect(
           xrpc(fetchHandler, testQuery, { params: { limit: 10 } }),
         ).rejects.toSatisfy((err) => {
-          assert(err instanceof XrpcUpstreamError)
+          assert(err instanceof XrpcInvalidResponseError)
           expect(err.message).toMatch('Unable to parse response payload')
           assert(err.cause instanceof Error)
           expect(err.cause.message).toContain('Unexpected token')
@@ -446,21 +457,7 @@ describe(xrpc, () => {
         })
       })
 
-      it('throws XrpcUpstreamError when schema expects no payload but got one', async () => {
-        const fetchHandler = vi.fn<FetchHandler>(async () => {
-          return Response.json({ unexpected: 'data' })
-        })
-
-        await expect(xrpc(fetchHandler, testNoOutputQuery)).rejects.toSatisfy(
-          (err) => {
-            assert(err instanceof XrpcUpstreamError)
-            expect(err.message).toContain('no body')
-            return true
-          },
-        )
-      })
-
-      it('throws XrpcUpstreamError when schema expects payload but response is empty', async () => {
+      it('throws XrpcInvalidResponseError when schema expects payload but response is empty', async () => {
         const fetchHandler = vi.fn<FetchHandler>(async () => {
           return new Response(null, { status: 200 })
         })
@@ -468,8 +465,8 @@ describe(xrpc, () => {
         await expect(
           xrpc(fetchHandler, testQuery, { params: { limit: 10 } }),
         ).rejects.toSatisfy((err) => {
-          assert(err instanceof XrpcUpstreamError)
-          expect(err.message).toContain('non-empty response')
+          assert(err instanceof XrpcInvalidResponseError)
+          expect(err.message).toContain('got no payload')
           return true
         })
       })
@@ -516,15 +513,15 @@ describe(xrpc, () => {
     })
 
     describe('non-2xx non-4xx/5xx responses', () => {
-      it('throws XrpcUpstreamError for 3xx status codes', async () => {
+      it('throws XrpcInvalidResponseError for 3xx status codes', async () => {
         const fetchHandler: FetchHandler = async () =>
           Response.json({ value: 'redirect' }, { status: 302 })
 
         await expect(
           xrpc(fetchHandler, testQuery, { params: { limit: 10 } }),
         ).rejects.toSatisfy((err) => {
-          assert(err instanceof XrpcUpstreamError)
-          expect(err.message).toBe('Invalid response status code')
+          assert(err instanceof XrpcInvalidResponseError)
+          expect(err.message).toBe('Unexpected status code 302')
           return true
         })
       })
@@ -606,8 +603,8 @@ describe(xrpc, () => {
       await expect(
         xrpc(fetchHandler, testQuery, { params: { limit: 10 } }),
       ).rejects.toSatisfy((err) => {
-        assert(err instanceof XrpcInvalidResponseError)
-        expect(err).toBeInstanceOf(XrpcUpstreamError)
+        assert(err instanceof XrpcResponseValidationError)
+        expect(err).toBeInstanceOf(XrpcInvalidResponseError)
         return true
       })
     })
@@ -660,7 +657,7 @@ describe(xrpc, () => {
       await expect(
         xrpc(validWithFloatHandler, testQuery, { params: { limit: 10 } }),
       ).rejects.toSatisfy((err) => {
-        assert(err instanceof XrpcUpstreamError)
+        assert(err instanceof XrpcInvalidResponseError)
         expect(err.message).toMatch('Unable to parse response payload')
         expect(err.cause).toBeInstanceOf(TypeError)
         return true
@@ -683,7 +680,7 @@ describe(xrpc, () => {
           strictResponseProcessing: true,
         }),
       ).rejects.toSatisfy((err) => {
-        assert(err instanceof XrpcUpstreamError)
+        assert(err instanceof XrpcInvalidResponseError)
         expect(err.message).toMatch('Unable to parse response payload')
         expect(err.cause).toBeInstanceOf(TypeError)
         return true
@@ -693,8 +690,8 @@ describe(xrpc, () => {
     it('rejects error response with invalid lex data by default', async () => {
       await expect(xrpc(errorWithFloatHandler, testQuery)).rejects.toSatisfy(
         (err) => {
-          assert(err instanceof XrpcUpstreamError)
-          expect(err.message).toMatch('Unable to parse response payload')
+          assert(err instanceof XrpcResponseError)
+          expect(err.message).toBe('test-error-description')
           return true
         },
       )
@@ -710,7 +707,7 @@ describe(xrpc, () => {
         // Error response is still an error, but it should be parsed successfully
         assert(err instanceof XrpcResponseError)
         expect(err.status).toBe(400)
-        expect(err.payload.body).toEqual({
+        expect(err.payload?.body).toEqual({
           error: 'TestError',
           message: 'test-error-description',
           extra: 1.5,
@@ -731,8 +728,8 @@ describe(xrpc, () => {
           validateResponse: true,
         }),
       ).rejects.toSatisfy((err) => {
-        assert(err instanceof XrpcInvalidResponseError)
-        expect(err).toBeInstanceOf(XrpcUpstreamError)
+        assert(err instanceof XrpcResponseValidationError)
+        expect(err).toBeInstanceOf(XrpcInvalidResponseError)
         return true
       })
     })
@@ -778,7 +775,7 @@ describe(xrpc, () => {
           validateResponse: false,
         }),
       ).rejects.toSatisfy((err) => {
-        assert(err instanceof XrpcUpstreamError)
+        assert(err instanceof XrpcInvalidResponseError)
         expect(err.message).toMatch('Unable to parse response payload')
         return true
       })
@@ -925,8 +922,8 @@ describe(xrpcSafe, () => {
 
         assert(!result.success)
         assert(result instanceof XrpcResponseError)
-        expect(result.status).toBe(400)
-        expect(result.body).toEqual({
+        expect(result.response.status).toBe(400)
+        expect(result.toJSON()).toEqual({
           error: 'TestError',
           message: 'bad request',
         })
@@ -946,10 +943,10 @@ describe(xrpcSafe, () => {
         assert(!result.success)
         assert(result instanceof XrpcResponseError)
         expect(result).toBeInstanceOf(XrpcAuthenticationError)
-        expect(result.status).toBe(401)
+        expect(result.response.status).toBe(401)
       })
 
-      it('returns XrpcUpstreamError for non-XRPC error response', async () => {
+      it('returns XrpcResponseError for non-XRPC error response', async () => {
         const fetchHandler: FetchHandler = async () =>
           new Response('Not Found', {
             status: 404,
@@ -961,10 +958,10 @@ describe(xrpcSafe, () => {
         })
 
         assert(!result.success)
-        expect(result).toBeInstanceOf(XrpcUpstreamError)
+        expect(result).toBeInstanceOf(XrpcResponseError)
       })
 
-      it('returns XrpcUpstreamError for 500 without valid error payload', async () => {
+      it('returns XrpcResponseError for 500 without valid error payload', async () => {
         const fetchHandler: FetchHandler = async () =>
           new Response('Internal Server Error', {
             status: 500,
@@ -976,12 +973,16 @@ describe(xrpcSafe, () => {
         })
 
         assert(!result.success)
-        expect(result).toBeInstanceOf(XrpcUpstreamError)
+        expect(result).toBeInstanceOf(XrpcResponseError)
+        expect(result.error).toBe('InternalServerError')
+        expect(result.message).toMatch(
+          'Upstream server responded with a 500 error',
+        )
       })
     })
 
     describe('invalid response errors', () => {
-      it('returns XrpcInvalidResponseError when response body fails validation', async () => {
+      it('returns XrpcResponseValidationError when response body fails validation', async () => {
         const fetchHandler: FetchHandler = async () =>
           Response.json({ value: 123 })
 
@@ -990,11 +991,11 @@ describe(xrpcSafe, () => {
         })
 
         assert(!result.success)
+        expect(result).toBeInstanceOf(XrpcResponseValidationError)
         expect(result).toBeInstanceOf(XrpcInvalidResponseError)
-        expect(result).toBeInstanceOf(XrpcUpstreamError)
       })
 
-      it('returns XrpcUpstreamError when response has wrong content-type', async () => {
+      it('returns XrpcInvalidResponseError when response has wrong content-type', async () => {
         const fetchHandler: FetchHandler = async () =>
           new Response('binary data', {
             status: 200,
@@ -1006,7 +1007,7 @@ describe(xrpcSafe, () => {
         })
 
         assert(!result.success)
-        expect(result).toBeInstanceOf(XrpcUpstreamError)
+        expect(result).toBeInstanceOf(XrpcInvalidResponseError)
       })
     })
 
@@ -1042,6 +1043,7 @@ describe(xrpcSafe, () => {
       assert(!result.success)
       expect(result).toBeInstanceOf(XrpcInternalError)
       expect(result).not.toBeInstanceOf(XrpcFetchError)
+      expect(fetchHandler).not.toHaveBeenCalled()
     })
 
     it('returns XrpcInternalError for invalid body when enabled', async () => {
@@ -1088,7 +1090,7 @@ describe(xrpcSafe, () => {
   })
 
   describe('validateResponse', () => {
-    it('returns XrpcInvalidResponseError for invalid body by default', async () => {
+    it('returns XrpcResponseValidationError for invalid body by default', async () => {
       const fetchHandler = vi.fn<FetchHandler>(async () => {
         return Response.json({ value: 123 })
       })
@@ -1098,8 +1100,8 @@ describe(xrpcSafe, () => {
       })
 
       assert(!result.success)
+      expect(result).toBeInstanceOf(XrpcResponseValidationError)
       expect(result).toBeInstanceOf(XrpcInvalidResponseError)
-      expect(result).toBeInstanceOf(XrpcUpstreamError)
     })
 
     it('accepts invalid response body when disabled', async () => {
@@ -1164,7 +1166,7 @@ describe(xrpcSafe, () => {
 
       const result = await xrpcSafe(fetchHandler, testQueryGetBlobRef)
       assert(!result.success)
-      expect(result).toBeInstanceOf(XrpcUpstreamError)
+      expect(result).toBeInstanceOf(XrpcInvalidResponseError)
       expect(result.message).toMatch('Unable to parse response payload')
       assert(result.cause instanceof TypeError)
       expect(result.cause.message).toBe('Invalid blob object')
@@ -1187,7 +1189,7 @@ describe(xrpcSafe, () => {
 
       const result = await xrpcSafe(fetchHandler, testQueryGetBlobRef)
       assert(!result.success)
-      expect(result).toBeInstanceOf(XrpcUpstreamError)
+      expect(result).toBeInstanceOf(XrpcInvalidResponseError)
       expect(result.message).toMatch('Unable to parse response payload')
       assert(result.cause instanceof TypeError)
       expect(result.cause.message).toBe('Invalid blob object')
@@ -1209,9 +1211,9 @@ describe(xrpcSafe, () => {
 
       const result = await xrpcSafe(fetchHandler, testQueryGetBlobRef)
       assert(!result.success)
-      expect(result).toBeInstanceOf(XrpcUpstreamError)
+      expect(result).toBeInstanceOf(XrpcInvalidResponseError)
       expect(result.message).toBe(
-        'Invalid response: Expected "image/png" (got "invalid/mime") at $.blobRef.mimeType',
+        'Invalid response payload: Expected "image/png" (got "invalid/mime") at $.blobRef.mimeType',
       )
     })
 
@@ -1231,9 +1233,9 @@ describe(xrpcSafe, () => {
 
       const result = await xrpcSafe(fetchHandler, testQueryGetBlobRef)
       assert(!result.success)
-      expect(result).toBeInstanceOf(XrpcUpstreamError)
+      expect(result).toBeInstanceOf(XrpcInvalidResponseError)
       expect(result.message).toBe(
-        'Invalid response: blob too big (maximum 10, got 100) at $.blobRef',
+        'Invalid response payload: blob too big (maximum 10, got 100) at $.blobRef',
       )
     })
 
@@ -1342,7 +1344,7 @@ describe(xrpcSafe, () => {
       })
 
       assert(!result.success)
-      expect(result).toBeInstanceOf(XrpcUpstreamError)
+      expect(result).toBeInstanceOf(XrpcInvalidResponseError)
       expect(result.message).toMatch('Unable to parse response payload')
       assert(result.cause instanceof TypeError)
       expect(result.cause.message).toBe('Invalid non-integer number: 1.5')
@@ -1369,7 +1371,7 @@ describe(xrpcSafe, () => {
       })
 
       assert(!result.success)
-      expect(result).toBeInstanceOf(XrpcUpstreamError)
+      expect(result).toBeInstanceOf(XrpcInvalidResponseError)
       expect(result.message).toMatch('Unable to parse response payload')
       assert(result.cause instanceof TypeError)
       expect(result.cause.message).toBe('Invalid non-integer number: 1.5')
@@ -1383,10 +1385,8 @@ describe(xrpcSafe, () => {
       })
 
       assert(!result.success)
-      expect(result).toBeInstanceOf(XrpcUpstreamError)
-      expect(result.message).toMatch('Unable to parse response payload')
-      assert(result.cause instanceof TypeError)
-      expect(result.cause.message).toBe('Invalid non-integer number: 1.5')
+      expect(result).toBeInstanceOf(XrpcResponseError)
+      expect(result.message).toBe('test-error-description')
     })
 
     it('parses error response with invalid lex data when strict processing is disabled', async () => {
@@ -1399,7 +1399,7 @@ describe(xrpcSafe, () => {
 
       assert(!result.success)
       assert(result instanceof XrpcResponseError)
-      expect(result.status).toBe(400)
+      expect(result.response.status).toBe(400)
       expect(result.message).toBe('test-error-description')
     })
 
@@ -1415,8 +1415,8 @@ describe(xrpcSafe, () => {
       })
 
       assert(!result.success)
+      expect(result).toBeInstanceOf(XrpcResponseValidationError)
       expect(result).toBeInstanceOf(XrpcInvalidResponseError)
-      expect(result).toBeInstanceOf(XrpcUpstreamError)
     })
 
     it('with strictResponseProcessing: false and validateResponse: false, schema validation is skipped', async () => {
@@ -1444,7 +1444,7 @@ describe(xrpcSafe, () => {
       })
 
       assert(!result.success)
-      expect(result).toBeInstanceOf(XrpcUpstreamError)
+      expect(result).toBeInstanceOf(XrpcInvalidResponseError)
       expect(result.message).toMatch('Unable to parse response payload')
       assert(result.cause instanceof TypeError)
       expect(result.cause.message).toBe('Invalid non-integer number: 1.5')

package/src/xrpc.ts

@@ -360,9 +360,7 @@ function buildPayload(
 ): null | { body: BodyInit; encoding: string } {
   if (schema.encoding === undefined) {
     if (body !== undefined) {
-      throw new TypeError(
-        `Cannot send a ${typeof body} body with undefined encoding`,
-      )
+      throw new TypeError(`Endpoint expects no payload`)
     }
 
     return null