@atproto/xrpc-server 0.7.8 → 0.7.10

package/src/stream/frames.ts

@@ -1,13 +1,13 @@
 import * as uint8arrays from 'uint8arrays'
-import { cborEncode, cborDecodeMulti } from '@atproto/common'
+import { cborDecodeMulti, cborEncode } from '@atproto/common'
 import {
-  frameHeader,
+  ErrorFrameBody,
+  ErrorFrameHeader,
   FrameHeader,
   FrameType,
   MessageFrameHeader,
-  ErrorFrameHeader,
-  ErrorFrameBody,
   errorFrameBody,
+  frameHeader,
 } from './types'
 
 export abstract class Frame {

package/src/stream/server.ts

@@ -1,7 +1,7 @@
-import { IncomingMessage } from 'http'
-import { WebSocketServer, ServerOptions, WebSocket } from 'ws'
+import { IncomingMessage } from 'node:http'
+import { ServerOptions, WebSocket, WebSocketServer } from 'ws'
 import { ErrorFrame, Frame } from './frames'
-import logger from './logger'
+import { logger } from './logger'
 import { CloseCode, DisconnectError } from './types'
 
 export class XrpcStreamServer {

package/src/stream/stream.ts

@@ -1,6 +1,6 @@
-import { XRPCError, ResponseType } from '@atproto/xrpc'
-import { DuplexOptions } from 'stream'
-import { createWebSocketStream, WebSocket } from 'ws'
+import { DuplexOptions } from 'node:stream'
+import { WebSocket, createWebSocketStream } from 'ws'
+import { ResponseType, XRPCError } from '@atproto/xrpc'
 import { Frame, MessageFrame } from './frames'
 
 export function streamByteChunks(ws: WebSocket, options?: DuplexOptions) {

package/src/stream/subscription.ts

@@ -1,6 +1,6 @@
 import { ClientOptions } from 'ws'
-import { WebSocketKeepAlive } from './websocket-keepalive'
 import { ensureChunkIsMessage } from './stream'
+import { WebSocketKeepAlive } from './websocket-keepalive'
 
 export class Subscription<T = unknown> {
   constructor(

package/src/stream/websocket-keepalive.ts

@@ -1,5 +1,5 @@
+import { ClientOptions, WebSocket } from 'ws'
 import { SECOND, wait } from '@atproto/common'
-import { WebSocket, ClientOptions } from 'ws'
 import { streamByteChunks } from './stream'
 import { CloseCode, DisconnectError } from './types'
 

package/src/types.ts

@@ -1,14 +1,14 @@
+import { IncomingMessage } from 'node:http'
+import { Readable } from 'node:stream'
+import express from 'express'
+import { isHttpError } from 'http-errors'
+import { z } from 'zod'
 import {
   ResponseType,
   ResponseTypeNames,
   ResponseTypeStrings,
   XRPCError as XRPCClientError,
 } from '@atproto/xrpc'
-import express from 'express'
-import { IncomingMessage } from 'http'
-import { isHttpError } from 'http-errors'
-import { Readable } from 'stream'
-import zod from 'zod'
 
 export type CatchallHandler = (
   req: express.Request,
@@ -29,6 +29,17 @@ export type Options = {
     global?: ServerRateLimitDescription[]
     shared?: ServerRateLimitDescription[]
   }
+  /**
+   * By default, errors are converted to {@link XRPCError} using
+   * {@link XRPCError.fromError} before being rendered. If method handlers throw
+   * error objects that are not properly rendered in the HTTP response, this
+   * function can be used to properly convert them to {@link XRPCError}. The
+   * provided function will typically fallback to the default error conversion
+   * (`return XRPCError.fromError(err)`) if the error is not recognized.
+   *
+   * @note This function should not throw errors.
+   */
+  errorParser?: (err: unknown) => XRPCError
 }
 
 export type UndecodedParams = (typeof express.request)['query']
@@ -36,60 +47,56 @@ export type UndecodedParams = (typeof express.request)['query']
 export type Primitive = string | number | boolean
 export type Params = Record<string, Primitive | Primitive[] | undefined>
 
-export const handlerInput = zod.object({
-  encoding: zod.string(),
-  body: zod.any(),
+export const handlerInput = z.object({
+  encoding: z.string(),
+  body: z.any(),
 })
-export type HandlerInput = zod.infer<typeof handlerInput>
+export type HandlerInput = z.infer<typeof handlerInput>
 
-export const handlerAuth = zod.object({
-  credentials: zod.any(),
-  artifacts: zod.any(),
+export const handlerAuth = z.object({
+  credentials: z.any(),
+  artifacts: z.any(),
 })
-export type HandlerAuth = zod.infer<typeof handlerAuth>
+export type HandlerAuth = z.infer<typeof handlerAuth>
 
-export const headersSchema = zod.record(zod.string())
+export const headersSchema = z.record(z.string())
 
-export const handlerSuccess = zod.object({
-  encoding: zod.string(),
-  body: zod.any(),
+export const handlerSuccess = z.object({
+  encoding: z.string(),
+  body: z.any(),
   headers: headersSchema.optional(),
 })
-export type HandlerSuccess = zod.infer<typeof handlerSuccess>
+export type HandlerSuccess = z.infer<typeof handlerSuccess>
 
-export const handlerPipeThroughBuffer = zod.object({
-  encoding: zod.string(),
-  buffer: zod.instanceof(Buffer),
+export const handlerPipeThroughBuffer = z.object({
+  encoding: z.string(),
+  buffer: z.instanceof(Buffer),
   headers: headersSchema.optional(),
 })
 
-export type HandlerPipeThroughBuffer = zod.infer<
-  typeof handlerPipeThroughBuffer
->
+export type HandlerPipeThroughBuffer = z.infer<typeof handlerPipeThroughBuffer>
 
-export const handlerPipeThroughStream = zod.object({
-  encoding: zod.string(),
-  stream: zod.instanceof(Readable),
+export const handlerPipeThroughStream = z.object({
+  encoding: z.string(),
+  stream: z.instanceof(Readable),
   headers: headersSchema.optional(),
 })
 
-export type HandlerPipeThroughStream = zod.infer<
-  typeof handlerPipeThroughStream
->
+export type HandlerPipeThroughStream = z.infer<typeof handlerPipeThroughStream>
 
-export const handlerPipeThrough = zod.union([
+export const handlerPipeThrough = z.union([
   handlerPipeThroughBuffer,
   handlerPipeThroughStream,
 ])
 
-export type HandlerPipeThrough = zod.infer<typeof handlerPipeThrough>
+export type HandlerPipeThrough = z.infer<typeof handlerPipeThrough>
 
-export const handlerError = zod.object({
-  status: zod.number(),
-  error: zod.string().optional(),
-  message: zod.string().optional(),
+export const handlerError = z.object({
+  status: z.number(),
+  error: z.string().optional(),
+  message: z.string().optional(),
 })
-export type HandlerError = zod.infer<typeof handlerError>
+export type HandlerError = z.infer<typeof handlerError>
 
 export type HandlerOutput = HandlerSuccess | HandlerPipeThrough | HandlerError
 
@@ -212,6 +219,8 @@ export type XRPCStreamHandlerConfig = {
   handler: XRPCStreamHandler
 }
 
+export { ResponseType }
+
 export class XRPCError extends Error {
   constructor(
     public type: ResponseType,

package/src/util.ts

@@ -1,28 +1,27 @@
 import assert from 'node:assert'
-import { Duplex, pipeline, Readable } from 'node:stream'
 import { IncomingMessage } from 'node:http'
+import { Duplex, Readable, pipeline } from 'node:stream'
 import express from 'express'
 import mime from 'mime-types'
+import { MaxSizeChecker, createDecoders } from '@atproto/common'
 import {
-  jsonToLex,
-  Lexicons,
   LexXrpcProcedure,
   LexXrpcQuery,
   LexXrpcSubscription,
+  Lexicons,
+  jsonToLex,
 } from '@atproto/lexicon'
-import { createDecoders, MaxSizeChecker } from '@atproto/common'
 import { ResponseType } from '@atproto/xrpc'
-
 import {
-  UndecodedParams,
-  Params,
   HandlerInput,
   HandlerSuccess,
-  handlerSuccess,
-  InvalidRequestError,
   InternalServerError,
-  XRPCError,
+  InvalidRequestError,
+  Params,
   RouteOpts,
+  UndecodedParams,
+  XRPCError,
+  handlerSuccess,
 } from './types'
 
 export function decodeQueryParams(

package/tests/_util.ts

@@ -1,5 +1,5 @@
-import * as http from 'node:http'
 import { once } from 'node:events'
+import * as http from 'node:http'
 import express from 'express'
 import * as xrpc from '../src'
 import { AuthRequiredError } from '../src'

package/tests/auth.test.ts

@@ -1,5 +1,5 @@
-import * as http from 'node:http'
 import { KeyObject, createPrivateKey } from 'node:crypto'
+import * as http from 'node:http'
 import { AddressInfo } from 'node:net'
 import * as jose from 'jose'
 import KeyEncoder from 'key-encoder'
@@ -7,13 +7,13 @@ import * as ui8 from 'uint8arrays'
 import { MINUTE } from '@atproto/common'
 import { Secp256k1Keypair } from '@atproto/crypto'
 import { LexiconDoc } from '@atproto/lexicon'
-import { XrpcClient, XRPCError } from '@atproto/xrpc'
+import { XRPCError, XrpcClient } from '@atproto/xrpc'
 import * as xrpcServer from '../src'
 import {
-  createServer,
+  basicAuthHeaders,
   closeServer,
   createBasicAuth,
-  basicAuthHeaders,
+  createServer,
 } from './_util'
 
 const LEXICONS: LexiconDoc[] = [

package/tests/bodies.test.ts

@@ -2,13 +2,13 @@ import * as http from 'node:http'
 import { AddressInfo } from 'node:net'
 import { Readable } from 'node:stream'
 import { brotliCompressSync, deflateSync, gzipSync } from 'node:zlib'
-import { LexiconDoc } from '@atproto/lexicon'
-import { ResponseType, XrpcClient } from '@atproto/xrpc'
 import { cidForCbor } from '@atproto/common'
 import { randomBytes } from '@atproto/crypto'
-import { createServer, closeServer } from './_util'
+import { LexiconDoc } from '@atproto/lexicon'
+import { ResponseType, XrpcClient } from '@atproto/xrpc'
 import * as xrpcServer from '../src'
-import logger from '../src/logger'
+import { logger } from '../src/logger'
+import { closeServer, createServer } from './_util'
 
 const LEXICONS: LexiconDoc[] = [
   {

package/tests/errors.test.ts

@@ -2,8 +2,8 @@ import * as http from 'node:http'
 import { AddressInfo } from 'node:net'
 import { LexiconDoc } from '@atproto/lexicon'
 import { XRPCError, XRPCInvalidResponseError, XrpcClient } from '@atproto/xrpc'
-import { createServer, closeServer } from './_util'
 import * as xrpcServer from '../src'
+import { closeServer, createServer } from './_util'
 
 const LEXICONS: LexiconDoc[] = [
   {

package/tests/frames.test.ts

@@ -1,6 +1,6 @@
 import * as cborx from 'cbor-x'
 import * as uint8arrays from 'uint8arrays'
-import { MessageFrame, ErrorFrame, Frame, FrameType } from '../src'
+import { ErrorFrame, Frame, FrameType, MessageFrame } from '../src'
 
 describe('Frames', () => {
   it('creates and parses message frame.', async () => {

package/tests/ipld.test.ts

@@ -1,10 +1,10 @@
 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 { CID } from 'multiformats/cid'
-import { createServer, closeServer } from './_util'
 import * as xrpcServer from '../src'
+import { closeServer, createServer } from './_util'
 
 const LEXICONS: LexiconDoc[] = [
   {

package/tests/parameters.test.ts

@@ -2,8 +2,8 @@ import * as http from 'node:http'
 import { AddressInfo } from 'node:net'
 import { LexiconDoc } from '@atproto/lexicon'
 import { XrpcClient } from '@atproto/xrpc'
-import { createServer, closeServer } from './_util'
 import * as xrpcServer from '../src'
+import { closeServer, createServer } from './_util'
 
 const LEXICONS: LexiconDoc[] = [
   {

package/tests/procedures.test.ts

@@ -1,10 +1,10 @@
 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 { createServer, closeServer } from './_util'
 import * as xrpcServer from '../src'
-import { AddressInfo } from 'node:net'
+import { closeServer, createServer } from './_util'
 
 const LEXICONS: LexiconDoc[] = [
   {

package/tests/queries.test.ts

@@ -2,8 +2,8 @@ import * as http from 'node:http'
 import { AddressInfo } from 'node:net'
 import { LexiconDoc } from '@atproto/lexicon'
 import { XrpcClient } from '@atproto/xrpc'
-import { createServer, closeServer } from './_util'
 import * as xrpcServer from '../src'
+import { closeServer, createServer } from './_util'
 
 const LEXICONS: LexiconDoc[] = [
   {

package/tests/responses.test.ts

@@ -1,10 +1,10 @@
 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 { byteIterableToStream } from '@atproto/common'
-import { createServer, closeServer } from './_util'
 import * as xrpcServer from '../src'
+import { closeServer, createServer } from './_util'
 
 const LEXICONS: LexiconDoc[] = [
   {

package/tests/stream.test.ts

@@ -1,6 +1,6 @@
-import * as http from 'http'
-import { once } from 'events'
-import { AddressInfo } from 'net'
+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 {

package/tests/subscriptions.test.ts

@@ -1,17 +1,17 @@
 import * as http from 'node:http'
 import { AddressInfo } from 'node:net'
-import { WebSocket, WebSocketServer, createWebSocketStream } from 'ws'
 import getPort from 'get-port'
+import { WebSocket, WebSocketServer, createWebSocketStream } from 'ws'
 import { wait } from '@atproto/common'
 import { LexiconDoc } from '@atproto/lexicon'
-import { byFrame, MessageFrame, ErrorFrame, Frame, Subscription } from '../src'
+import { ErrorFrame, Frame, MessageFrame, Subscription, byFrame } from '../src'
+import * as xrpcServer from '../src'
 import {
-  createServer,
+  basicAuthHeaders,
   closeServer,
   createBasicAuth,
-  basicAuthHeaders,
+  createServer,
 } from './_util'
-import * as xrpcServer from '../src'
 
 const LEXICONS: LexiconDoc[] = [
   {