@atproto/lex-server 0.1.4 → 0.1.5

package/src/lib/drain-websocket.ts

@@ -1,34 +0,0 @@
-import { abortableSleep } from './sleep.js'
-
-/**
- * Performs polling based backpressure management for a WebSocket connection. If
- * the amount of buffered data exceeds the specified high water mark, this
- * function will wait until the buffered amount drops below the low water mark
- * before resolving. This is useful for preventing memory issues when sending
- * large amounts of data over a WebSocket connection.
- */
-export async function drainWebsocket(
-  socket: WebSocket,
-  signal: AbortSignal,
-  {
-    highWaterMark = 250_000, // 250 KB
-    lowWaterMark = 50_000, // 50 KB
-  }: {
-    highWaterMark?: number
-    lowWaterMark?: number
-  } = {},
-): Promise<void> {
-  if (socket.bufferedAmount > highWaterMark) {
-    // Once we exceed the high water mark, we wait until the buffered amount
-    // drops below the low water mark before allowing more data to be sent. This
-    // creates a hysteresis effect that prevents rapid toggling around the
-    // threshold.
-    while (
-      socket.readyState === 1 &&
-      socket.bufferedAmount !== 0 &&
-      socket.bufferedAmount > lowWaterMark
-    ) {
-      await abortableSleep(10, signal)
-    }
-  }
-}

package/src/lib/sleep.ts

@@ -1,25 +0,0 @@
-export async function abortableSleep(
-  ms: number,
-  signal: AbortSignal,
-): Promise<void> {
-  signal.throwIfAborted()
-
-  return new Promise((resolve, reject) => {
-    const cleanup = () => {
-      signal.removeEventListener('abort', onAbort)
-      clearTimeout(timeoutHandle)
-    }
-
-    const timeoutHandle = setTimeout(() => {
-      cleanup()
-      resolve()
-    }, ms)
-
-    const onAbort = () => {
-      cleanup()
-      reject(signal.reason)
-    }
-
-    signal.addEventListener('abort', onAbort)
-  })
-}

package/src/lib/www-authenticate.test.ts

@@ -1,134 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { formatWWWAuthenticateHeader } from './www-authenticate.js'
-
-describe(formatWWWAuthenticateHeader, () => {
-  describe('single scheme with params object', () => {
-    it('formats a Bearer challenge with params', () => {
-      const result = formatWWWAuthenticateHeader({
-        Bearer: { realm: 'api.example.com', error: 'InvalidToken' },
-      })
-      expect(result).toBe(
-        'Bearer realm="api.example.com", error="InvalidToken"',
-      )
-    })
-
-    it('omits undefined param values', () => {
-      const result = formatWWWAuthenticateHeader({
-        Bearer: { realm: 'api', error: undefined },
-      })
-      expect(result).toBe('Bearer realm="api"')
-    })
-
-    it('omits null param values', () => {
-      const result = formatWWWAuthenticateHeader({
-        Bearer: { realm: 'api', error: null as any },
-      })
-      expect(result).toBe('Bearer realm="api"')
-    })
-
-    it('outputs only the scheme when all params are undefined', () => {
-      const result = formatWWWAuthenticateHeader({
-        Bearer: {},
-      })
-      expect(result).toBe('Bearer')
-    })
-  })
-
-  describe('single scheme with token68 string', () => {
-    it('formats a token68 value', () => {
-      const result = formatWWWAuthenticateHeader({
-        Bearer: 'base64encodedvalue==',
-      })
-      expect(result).toBe('Bearer base64encodedvalue==')
-    })
-  })
-
-  describe('multiple schemes', () => {
-    it('joins multiple different schemes with a comma', () => {
-      const result = formatWWWAuthenticateHeader({
-        Bearer: { realm: 'api' },
-        Basic: { realm: 'api' },
-      })
-      expect(result).toBe('Bearer realm="api", Basic realm="api"')
-    })
-  })
-
-  describe('array of challenges for the same scheme (new feature)', () => {
-    it('emits one challenge per array element', () => {
-      const result = formatWWWAuthenticateHeader({
-        Bearer: [
-          { realm: 'first', error: 'TokenExpired' },
-          { realm: 'second', error: 'TokenRevoked' },
-        ],
-      })
-      expect(result).toBe(
-        'Bearer realm="first", error="TokenExpired", Bearer realm="second", error="TokenRevoked"',
-      )
-    })
-
-    it('handles an array mixing token68 strings and param objects', () => {
-      const result = formatWWWAuthenticateHeader({
-        Bearer: ['token68value', { realm: 'api', error: 'BadToken' }],
-      })
-      expect(result).toBe(
-        'Bearer token68value, Bearer realm="api", error="BadToken"',
-      )
-    })
-
-    it('handles an array of token68 strings', () => {
-      const result = formatWWWAuthenticateHeader({
-        Bearer: ['firstToken', 'secondToken'],
-      })
-      expect(result).toBe('Bearer firstToken, Bearer secondToken')
-    })
-
-    it('handles an array with a single element', () => {
-      const result = formatWWWAuthenticateHeader({
-        Bearer: [{ realm: 'api' }],
-      })
-      expect(result).toBe('Bearer realm="api"')
-    })
-
-    it('handles array challenges alongside other schemes', () => {
-      const result = formatWWWAuthenticateHeader({
-        Bearer: [
-          { realm: 'r1', error: 'Err1' },
-          { realm: 'r2', error: 'Err2' },
-        ],
-        Basic: { realm: 'fallback' },
-      })
-      expect(result).toBe(
-        'Bearer realm="r1", error="Err1", Bearer realm="r2", error="Err2", Basic realm="fallback"',
-      )
-    })
-  })
-
-  describe('null / undefined scheme values', () => {
-    it('skips schemes with null value', () => {
-      const result = formatWWWAuthenticateHeader({
-        Bearer: null as any,
-        Basic: { realm: 'api' },
-      })
-      expect(result).toBe('Basic realm="api"')
-    })
-
-    it('skips schemes with undefined value', () => {
-      const result = formatWWWAuthenticateHeader({
-        Bearer: undefined,
-        Basic: { realm: 'api' },
-      })
-      expect(result).toBe('Basic realm="api"')
-    })
-
-    it('returns an empty string when all schemes are null/undefined', () => {
-      const result = formatWWWAuthenticateHeader({
-        Bearer: undefined,
-      })
-      expect(result).toBe('')
-    })
-  })
-
-  it('returns an empty string for an empty object', () => {
-    expect(formatWWWAuthenticateHeader({})).toBe('')
-  })
-})

package/src/lib/www-authenticate.ts

@@ -1,111 +0,0 @@
-/**
- * Type representing the value of a WWW-Authenticate HTTP header.
- *
- * Supports multiple authentication schemes, each with optional parameters.
- * Parameters can be provided as a token68 string (for schemes like Bearer)
- * or as key-value pairs.
- *
- * @see {@link https://datatracker.ietf.org/doc/html/rfc7235#section-4.1 | RFC 7235 Section 4.1}
- *
- * @example Bearer scheme with parameters
- * ```typescript
- * const auth: WWWAuthenticate = {
- *   Bearer: {
- *     realm: 'api.example.com',
- *     error: 'InvalidToken',
- *     error_description: 'The token has expired'
- *   }
- * }
- * // Formats to: Bearer realm="api.example.com", error="InvalidToken", error_description="The token has expired"
- * ```
- *
- * @example Multiple schemes
- * ```typescript
- * const auth: WWWAuthenticate = {
- *   Bearer: { realm: 'api' },
- *   Basic: { realm: 'api' }
- * }
- * // Formats to: Bearer realm="api", Basic realm="api"
- * ```
- *
- * @example Token68 value (no parameters)
- * ```typescript
- * const auth: WWWAuthenticate = {
- *   Bearer: 'base64encodedvalue=='
- * }
- * // Formats to: Bearer base64encodedvalue==
- * ```
- */
-export type WWWAuthenticate = {
-  [authScheme in string]?:
-    | string // token68
-    | WWWAuthenticateParams
-    | (string | WWWAuthenticateParams)[]
-}
-
-export type WWWAuthenticateParams = { [authParam in string]?: string }
-
-/**
- * Formats a WWWAuthenticate object into an HTTP header string.
- *
- * Converts the structured authentication scheme and parameter data into
- * the proper WWW-Authenticate header format per RFC 7235.
- *
- * @param wwwAuthenticate - The authentication schemes and parameters
- * @returns Formatted header string ready for use in HTTP responses
- *
- * @example
- * ```typescript
- * const header = formatWWWAuthenticateHeader({
- *   Bearer: {
- *     realm: 'api.example.com',
- *     error: 'MissingToken'
- *   }
- * })
- * // Returns: 'Bearer realm="api.example.com", error="MissingToken"'
- * ```
- *
- * @example Empty or undefined values
- * ```typescript
- * const header = formatWWWAuthenticateHeader({
- *   Bearer: { realm: 'api', error: undefined }
- * })
- * // Returns: 'Bearer realm="api"' (undefined values are omitted)
- * ```
- */
-export function formatWWWAuthenticateHeader(
-  wwwAuthenticate: WWWAuthenticate,
-): string {
-  const challenges: string[] = []
-  for (const [scheme, params] of Object.entries(wwwAuthenticate)) {
-    if (params == null) continue
-
-    if (typeof params === 'string') {
-      challenges.push(formatWWWAuthenticateChallenge(scheme, params))
-    } else if (Array.isArray(params)) {
-      for (const p of params) {
-        challenges.push(formatWWWAuthenticateChallenge(scheme, p))
-      }
-    } else {
-      challenges.push(formatWWWAuthenticateChallenge(scheme, params))
-    }
-  }
-  return challenges.join(', ')
-}
-
-function formatWWWAuthenticateChallenge(
-  scheme: string,
-  params: string | WWWAuthenticateParams,
-): string {
-  const paramsStr =
-    typeof params === 'string' ? params : formatWWWAuthenticateParams(params)
-  return paramsStr?.length ? `${scheme} ${paramsStr}` : scheme
-}
-
-function formatWWWAuthenticateParams(params: WWWAuthenticateParams): string {
-  const parts: string[] = []
-  for (const [name, val] of Object.entries(params)) {
-    if (val != null) parts.push(`${name}=${JSON.stringify(val)}`)
-  }
-  return parts.join(', ')
-}

package/src/nodejs.test.ts

@@ -1,107 +0,0 @@
-import { AddressInfo } from 'node:net'
-import { scheduler } from 'node:timers/promises'
-import { afterAll, beforeAll, describe, expect, it } from 'vitest'
-import { Server, serve } from './nodejs.js'
-
-describe('Node.js RequestListener', () => {
-  let server: Server
-  let address: string
-
-  beforeAll(async () => {
-    server = await serve(async (request) => {
-      const { pathname } = new URL(request.url)
-      if (pathname === '/hello') {
-        return new Response('Hello, world!', {
-          status: 200,
-          headers: { 'Content-Type': 'text/plain' },
-        })
-      } else if (pathname === '/throw') {
-        throw new Error('Test error')
-      } else if (pathname === '/echo') {
-        return new Response(request.body, {
-          status: 200,
-          headers: { 'Content-Type': 'application/octet-stream' },
-        })
-      }
-      return new Response('Not Found', { status: 404 })
-    })
-    const { port } = server.address() as AddressInfo
-    address = `http://localhost:${port}`
-  })
-
-  afterAll(async () => {
-    await server.terminate()
-  })
-
-  it('should respond with Hello, world! on /hello', async () => {
-    const res = await fetch(new URL(`/hello`, address))
-    const text = await res.text()
-    expect(res.status).toBe(200)
-    expect(text).toBe('Hello, world!')
-  })
-
-  it('should respond with Not Found on unknown path', async () => {
-    const res = await fetch(new URL(`/unknown`, address))
-    const text = await res.text()
-    expect(res.status).toBe(404)
-    expect(text).toBe('Not Found')
-  })
-
-  it('should handle thrown errors and respond with 500', async () => {
-    const res = await fetch(new URL(`/throw`, address))
-    const text = await res.text()
-    expect(res.status).toBe(500)
-    expect(text).toBe('Internal Server Error')
-  })
-
-  it('should handle streaming bodies', async () => {
-    const totalSize = 1024 * 1024
-    const consumerSize = 42 * 1024
-
-    let sentBytes = 0
-    let receivedBytes = 0
-
-    const res = await fetch(new URL(`/echo`, address), {
-      method: 'POST',
-      // @ts-expect-error
-      duplex: 'half',
-      body: new ReadableStream({
-        async pull(controller) {
-          const chunkSize = Math.min(1024, totalSize - sentBytes)
-          controller.enqueue('A'.repeat(chunkSize))
-          sentBytes += chunkSize
-          await scheduler.wait(0) // Yield to event loop
-          if (sentBytes === totalSize) controller.close()
-        },
-      }),
-    })
-
-    const reader = res.body!.getReader()
-
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-      const result = await reader.read()
-      if (result.done) break
-      receivedBytes += Buffer.byteLength(result.value)
-      if (receivedBytes >= consumerSize) {
-        await reader.cancel()
-        break
-      }
-    }
-
-    expect(receivedBytes).toBeGreaterThanOrEqual(consumerSize)
-    expect(sentBytes).toBeGreaterThanOrEqual(consumerSize)
-    expect(sentBytes).toBeLessThan(totalSize)
-  })
-
-  it('should echo back request body on /echo', async () => {
-    const body = `Echo this back`
-    const res = await fetch(new URL(`/echo`, address), {
-      method: 'POST',
-      body,
-    })
-    const text = await res.text()
-    expect(res.status).toBe(200)
-    expect(text).toBe(body)
-  })
-})