@atproto/tap 0.3.4 → 0.3.5

package/src/util.ts

@@ -1,42 +0,0 @@
-export const formatAdminAuthHeader = (password: string) => {
-  return 'Basic ' + Buffer.from(`admin:${password}`).toString('base64')
-}
-
-export const parseAdminAuthHeader = (header: string) => {
-  const noPrefix = header.startsWith('Basic ') ? header.slice(6) : header
-  const [username, password] = Buffer.from(noPrefix, 'base64')
-    .toString()
-    .split(':')
-  if (username !== 'admin') {
-    throw new Error("Unexpected username in admin headers. Expected 'admin'")
-  }
-  return password
-}
-
-export const assureAdminAuth = (expectedPassword: string, header: string) => {
-  const headerPassword = parseAdminAuthHeader(header)
-  const passEqual = timingSafeEqual(headerPassword, expectedPassword)
-  if (!passEqual) {
-    throw new Error('Invalid admin password')
-  }
-}
-
-const timingSafeEqual = (a: string, b: string): boolean => {
-  const bufA = Buffer.from(a)
-  const bufB = Buffer.from(b)
-  if (bufA.length !== bufB.length) {
-    // Compare against self to maintain constant time even with length mismatch
-    Buffer.from(a).compare(Buffer.from(a))
-    return false
-  }
-  return bufA.compare(bufB) === 0
-}
-
-export function isCausedBySignal(err: unknown, signal: AbortSignal) {
-  if (!signal.aborted) return false
-  if (signal.reason == null) return false // Ignore nullish reasons
-  return (
-    err === signal.reason ||
-    (err instanceof Error && err.cause === signal.reason)
-  )
-}

package/tests/_util.ts

@@ -1,63 +0,0 @@
-import { WebSocketServer } from 'ws'
-import { HandlerOpts } from '../src/channel.js'
-import { IdentityEvent, RecordEvent } from '../src/types.js'
-
-export type MockOpts = HandlerOpts & { acked: boolean }
-
-export const createMockOpts = (): MockOpts => {
-  const opts = {
-    signal: new AbortController().signal,
-    acked: false,
-    ack: async () => {
-      opts.acked = true
-    },
-  }
-  return opts
-}
-
-export const createRecordEvent = (
-  overrides: Partial<RecordEvent> = {},
-): RecordEvent => ({
-  id: 1,
-  type: 'record',
-  did: 'did:example:alice',
-  rev: 'abc123',
-  collection: 'com.example.post',
-  rkey: 'abc123',
-  action: 'create',
-  record: { text: 'hello' },
-  cid: 'bafyreiclp443lavogvhj3d2ob2cxbfuscni2k5jk7bebjzg7khl3esabwq',
-  live: true,
-  ...overrides,
-})
-
-export const createIdentityEvent = (): IdentityEvent => ({
-  id: 2,
-  type: 'identity',
-  did: 'did:example:alice',
-  handle: 'alice.test',
-  isActive: true,
-  status: 'active',
-})
-
-export async function createWebSocketServer() {
-  return new Promise<WebSocketServer & AsyncDisposable>((resolve, reject) => {
-    const server = new WebSocketServer({ port: 0 }, () => {
-      server.off('error', reject)
-      resolve(
-        Object.defineProperty(server, Symbol.asyncDispose, {
-          value: disposeWebSocketServer,
-        }) as WebSocketServer & AsyncDisposable,
-      )
-    }).once('error', reject)
-  })
-}
-
-async function disposeWebSocketServer(this: WebSocketServer) {
-  return new Promise<void>((resolve, reject) => {
-    this.close((err) => {
-      if (err) reject(err)
-      else resolve()
-    })
-  })
-}

package/tests/channel.test.ts

@@ -1,371 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { AddressInfo } from 'ws'
-import { TapChannel, TapHandler } from '../src/channel.js'
-import { TapEvent } from '../src/types.js'
-import { createWebSocketServer } from './_util.js'
-
-const createRecordEvent = (id: number) => ({
-  id,
-  type: 'record' as const,
-  record: {
-    did: 'did:example:alice',
-    rev: '3abc123',
-    collection: 'com.example.post',
-    rkey: 'abc123',
-    action: 'create' as const,
-    record: { text: 'hello' },
-    cid: 'bafyreiclp443lavogvhj3d2ob2cxbfuscni2k5jk7bebjzg7khl3esabwq',
-    live: true,
-  },
-})
-
-const createIdentityEvent = (id: number) => ({
-  id,
-  type: 'identity' as const,
-  identity: {
-    did: 'did:example:alice',
-    handle: 'alice.test',
-    is_active: true,
-    status: 'active' as const,
-  },
-})
-
-describe('TapChannel', () => {
-  describe('receiving events', () => {
-    it('receives and parses record events', async () => {
-      await using server = await createWebSocketServer()
-
-      const { port } = server.address() as AddressInfo
-
-      const receivedEvents: TapEvent[] = []
-
-      server.on('connection', (socket) => {
-        socket.send(JSON.stringify(createRecordEvent(1)))
-        socket.on('message', (data) => {
-          const msg = JSON.parse(data.toString())
-          if (msg.type === 'ack') {
-            socket.close()
-          }
-        })
-      })
-
-      const handler: TapHandler = {
-        onEvent: async (evt, opts) => {
-          receivedEvents.push(evt)
-          await opts.ack()
-        },
-        onError: (err) => {
-          throw err
-        },
-      }
-
-      await using channel = new TapChannel(`ws://localhost:${port}`, handler)
-      await channel.start()
-
-      expect(receivedEvents).toHaveLength(1)
-      expect(receivedEvents[0].type).toBe('record')
-      expect(receivedEvents[0].did).toBe('did:example:alice')
-      if (receivedEvents[0].type === 'record') {
-        expect(receivedEvents[0].collection).toBe('com.example.post')
-        expect(receivedEvents[0].action).toBe('create')
-      }
-    })
-
-    it('receives and parses identity events', async () => {
-      await using server = await createWebSocketServer()
-
-      const { port } = server.address() as AddressInfo
-
-      const receivedEvents: TapEvent[] = []
-
-      server.on('connection', (socket) => {
-        socket.send(JSON.stringify(createIdentityEvent(1)))
-        socket.on('message', (data) => {
-          const msg = JSON.parse(data.toString())
-          if (msg.type === 'ack') {
-            socket.close()
-          }
-        })
-      })
-
-      const handler: TapHandler = {
-        onEvent: async (evt, opts) => {
-          receivedEvents.push(evt)
-          await opts.ack()
-        },
-        onError: (err) => {
-          throw err
-        },
-      }
-
-      await using channel = new TapChannel(`ws://localhost:${port}`, handler)
-      await channel.start()
-
-      expect(receivedEvents).toHaveLength(1)
-      expect(receivedEvents[0].type).toBe('identity')
-      expect(receivedEvents[0].did).toBe('did:example:alice')
-      if (receivedEvents[0].type === 'identity') {
-        expect(receivedEvents[0].handle).toBe('alice.test')
-        expect(receivedEvents[0].status).toBe('active')
-      }
-    })
-  })
-
-  describe('ack behavior', () => {
-    it('sends ack when handler calls ack()', async () => {
-      await using server = await createWebSocketServer()
-
-      const { port } = server.address() as AddressInfo
-
-      const receivedAcks: number[] = []
-
-      server.on('connection', (socket) => {
-        socket.send(JSON.stringify(createRecordEvent(42)))
-        socket.on('message', (data) => {
-          const msg = JSON.parse(data.toString())
-          if (msg.type === 'ack') {
-            receivedAcks.push(msg.id)
-            socket.close()
-          }
-        })
-      })
-
-      const handler: TapHandler = {
-        onEvent: async (_evt, opts) => {
-          await opts.ack()
-        },
-        onError: (err) => {
-          throw err
-        },
-      }
-
-      await using channel = new TapChannel(`ws://localhost:${port}`, handler)
-      await channel.start()
-
-      expect(receivedAcks).toEqual([42])
-    })
-
-    it('does not send ack if handler throws', async () => {
-      await using server = await createWebSocketServer()
-
-      const { port } = server.address() as AddressInfo
-
-      const receivedAcks: number[] = []
-      const errors: Error[] = []
-
-      server.on('connection', (socket) => {
-        socket.send(JSON.stringify(createRecordEvent(1)))
-        socket.on('message', (data) => {
-          const msg = JSON.parse(data.toString())
-          if (msg.type === 'ack') {
-            receivedAcks.push(msg.id)
-          }
-        })
-        // Close after a short delay to let error propagate
-        setTimeout(() => socket.close(), 100)
-      })
-
-      const handler: TapHandler = {
-        onEvent: async () => {
-          throw new Error('Handler failed')
-        },
-        onError: (err) => {
-          errors.push(err)
-        },
-      }
-
-      await using channel = new TapChannel(`ws://localhost:${port}`, handler)
-      await channel.start()
-
-      expect(receivedAcks).toHaveLength(0)
-      expect(errors).toHaveLength(1)
-      expect(errors[0].message).toContain('Failed to process event')
-    })
-
-    it('does not send ack if handler does not call ack()', async () => {
-      await using server = await createWebSocketServer()
-
-      const { port } = server.address() as AddressInfo
-
-      const receivedAcks: number[] = []
-
-      server.on('connection', (socket) => {
-        socket.send(JSON.stringify(createRecordEvent(1)))
-        socket.on('message', (data) => {
-          const msg = JSON.parse(data.toString())
-          if (msg.type === 'ack') {
-            receivedAcks.push(msg.id)
-          }
-        })
-        // Close after a short delay
-        setTimeout(() => socket.close(), 100)
-      })
-
-      const handler: TapHandler = {
-        onEvent: async () => {
-          // Don't call ack
-        },
-        onError: (err) => {
-          throw err
-        },
-      }
-
-      await using channel = new TapChannel(`ws://localhost:${port}`, handler)
-      await channel.start()
-
-      expect(receivedAcks).toHaveLength(0)
-    })
-
-    it('handles reconnection and receives events from new connection', async () => {
-      await using server = await createWebSocketServer()
-
-      const { port } = server.address() as AddressInfo
-
-      const receivedEvents: TapEvent[] = []
-      const receivedAcks: number[] = []
-      let connectionCount = 0
-
-      server.on('connection', (socket) => {
-        connectionCount++
-        // Send a different event each connection
-        const eventId = connectionCount
-        socket.send(JSON.stringify(createRecordEvent(eventId)))
-        socket.on('message', (data) => {
-          const msg = JSON.parse(data.toString())
-          if (msg.type === 'ack') {
-            receivedAcks.push(msg.id)
-            if (connectionCount === 1) {
-              // After first ack, terminate to trigger reconnect
-              socket.terminate()
-            } else {
-              // After second ack, close cleanly
-              socket.close()
-            }
-          }
-        })
-      })
-
-      const handler: TapHandler = {
-        onEvent: async (evt, opts) => {
-          receivedEvents.push(evt)
-          await opts.ack()
-        },
-        onError: () => {},
-      }
-
-      await using channel = new TapChannel(`ws://localhost:${port}`, handler, {
-        maxReconnectSeconds: 1,
-      })
-
-      await channel.start()
-
-      // Should have connected twice and received two events
-      expect(connectionCount).toBe(2)
-      expect(receivedEvents).toHaveLength(2)
-      expect(receivedEvents[0].id).toBe(1)
-      expect(receivedEvents[1].id).toBe(2)
-      expect(receivedAcks).toContain(1)
-      expect(receivedAcks).toContain(2)
-    })
-  })
-
-  describe('multiple events', () => {
-    it('processes multiple events in sequence', async () => {
-      await using server = await createWebSocketServer()
-
-      const { port } = server.address() as AddressInfo
-
-      const receivedEvents: TapEvent[] = []
-      const receivedAcks: number[] = []
-
-      server.on('connection', (socket) => {
-        socket.send(JSON.stringify(createRecordEvent(1)))
-        socket.send(JSON.stringify(createRecordEvent(2)))
-        socket.send(JSON.stringify(createIdentityEvent(3)))
-        socket.on('message', (data) => {
-          const msg = JSON.parse(data.toString())
-          if (msg.type === 'ack') {
-            receivedAcks.push(msg.id)
-            if (receivedAcks.length === 3) {
-              socket.close()
-            }
-          }
-        })
-      })
-
-      const handler: TapHandler = {
-        onEvent: async (evt, opts) => {
-          receivedEvents.push(evt)
-          await opts.ack()
-        },
-        onError: (err) => {
-          throw err
-        },
-      }
-
-      await using channel = new TapChannel(`ws://localhost:${port}`, handler)
-      await channel.start()
-
-      expect(receivedEvents).toHaveLength(3)
-      expect(receivedEvents[0].id).toBe(1)
-      expect(receivedEvents[1].id).toBe(2)
-      expect(receivedEvents[2].id).toBe(3)
-      expect(receivedAcks).toEqual([1, 2, 3])
-    })
-  })
-
-  describe('auth', () => {
-    it('includes auth header when adminPassword is provided', async () => {
-      await using server = await createWebSocketServer()
-
-      const { port } = server.address() as AddressInfo
-
-      let receivedAuthHeader: string | undefined
-
-      server.on('connection', (socket, request) => {
-        receivedAuthHeader = request.headers.authorization
-        socket.close()
-      })
-
-      const handler: TapHandler = {
-        onEvent: async () => {},
-        onError: () => {},
-      }
-
-      await using channel = new TapChannel(`ws://localhost:${port}`, handler, {
-        adminPassword: 'secret',
-      })
-      await channel.start()
-
-      expect(receivedAuthHeader).toBe('Basic YWRtaW46c2VjcmV0')
-    })
-  })
-
-  describe('error handling', () => {
-    it('calls onError for malformed messages', async () => {
-      await using server = await createWebSocketServer()
-
-      const { port } = server.address() as AddressInfo
-
-      const errors: Error[] = []
-
-      server.on('connection', (socket) => {
-        socket.send('not valid json')
-        setTimeout(() => socket.close(), 100)
-      })
-
-      const handler: TapHandler = {
-        onEvent: async () => {},
-        onError: (err) => {
-          errors.push(err)
-        },
-      }
-
-      await using channel = new TapChannel(`ws://localhost:${port}`, handler)
-      await channel.start()
-
-      expect(errors).toHaveLength(1)
-      expect(errors[0].message).toBe('Failed to parse message')
-    })
-  })
-})

package/tests/client.test.ts

@@ -1,207 +0,0 @@
-import { once } from 'node:events'
-import * as http from 'node:http'
-import { AddressInfo } from 'node:net'
-import { default as express } from 'express'
-// eslint-disable-next-line import/default
-import httpTerminator from 'http-terminator'
-import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest'
-import { Tap } from '../src/client.js'
-
-describe('Tap client', () => {
-  describe('constructor', () => {
-    it('accepts http URL', () => {
-      const tap = new Tap('http://localhost:8080')
-      expect(tap.url).toBe('http://localhost:8080')
-    })
-
-    it('accepts https URL', () => {
-      const tap = new Tap('https://example.com')
-      expect(tap.url).toBe('https://example.com')
-    })
-
-    it('throws on invalid URL', () => {
-      expect(() => new Tap('ws://localhost:8080')).toThrow(
-        'Invalid URL, expected http:// or https://',
-      )
-      expect(() => new Tap('localhost:8080')).toThrow(
-        'Invalid URL, expected http:// or https://',
-      )
-    })
-  })
-
-  describe('HTTP methods', () => {
-    let terminator: httpTerminator.HttpTerminator
-    let tap: Tap
-    let requests: {
-      path: string
-      method: string
-      body?: unknown
-      headers: http.IncomingHttpHeaders
-    }[]
-
-    beforeAll(async () => {
-      const app = express()
-      app.use(express.json())
-
-      requests = []
-
-      app.post('/repos/add', (req, res) => {
-        requests.push({
-          path: req.path,
-          method: req.method,
-          body: req.body,
-          headers: req.headers,
-        })
-        res.sendStatus(200)
-      })
-
-      app.post('/repos/remove', (req, res) => {
-        requests.push({
-          path: req.path,
-          method: req.method,
-          body: req.body,
-          headers: req.headers,
-        })
-        res.sendStatus(200)
-      })
-
-      app.get('/resolve/:did', (req, res) => {
-        requests.push({
-          path: req.path,
-          method: req.method,
-          headers: req.headers,
-        })
-        if (req.params.did === 'did:example:notfound') {
-          res.sendStatus(404)
-          return
-        }
-        res.json({
-          id: req.params.did,
-          alsoKnownAs: ['at://alice.test'],
-          verificationMethod: [],
-          service: [],
-        })
-      })
-
-      app.get('/info/:did', (req, res) => {
-        requests.push({
-          path: req.path,
-          method: req.method,
-          headers: req.headers,
-        })
-        res.json({
-          did: req.params.did,
-          handle: 'alice.test',
-          state: 'active',
-          rev: '3abc123',
-          records: 42,
-        })
-      })
-
-      const server = app.listen()
-      await once(server, 'listening')
-      const { port } = server.address() as AddressInfo
-      terminator = httpTerminator.createHttpTerminator({ server })
-      tap = new Tap(`http://localhost:${port}`, { adminPassword: 'secret' })
-    })
-
-    afterAll(async () => {
-      await terminator?.terminate()
-    })
-
-    beforeEach(() => {
-      requests = []
-    })
-
-    describe('addRepos', () => {
-      it('sends POST to /repos/add with dids', async () => {
-        await tap.addRepos(['did:example:alice', 'did:example:bob'])
-        expect(requests).toHaveLength(1)
-        expect(requests[0].path).toBe('/repos/add')
-        expect(requests[0].method).toBe('POST')
-        expect(requests[0].body).toEqual({
-          dids: ['did:example:alice', 'did:example:bob'],
-        })
-      })
-
-      it('includes auth header', async () => {
-        await tap.addRepos(['did:example:alice'])
-        expect(requests[0].headers.authorization).toBe('Basic YWRtaW46c2VjcmV0')
-      })
-    })
-
-    describe('removeRepos', () => {
-      it('sends POST to /repos/remove with dids', async () => {
-        await tap.removeRepos(['did:example:alice'])
-        expect(requests).toHaveLength(1)
-        expect(requests[0].path).toBe('/repos/remove')
-        expect(requests[0].method).toBe('POST')
-        expect(requests[0].body).toEqual({ dids: ['did:example:alice'] })
-      })
-    })
-
-    describe('resolveDid', () => {
-      it('fetches and parses DID document', async () => {
-        const doc = await tap.resolveDid('did:example:alice')
-        expect(doc).not.toBeNull()
-        expect(doc?.id).toBe('did:example:alice')
-        expect(doc?.alsoKnownAs).toEqual(['at://alice.test'])
-      })
-
-      it('returns null for 404', async () => {
-        const doc = await tap.resolveDid('did:example:notfound')
-        expect(doc).toBeNull()
-      })
-    })
-
-    describe('getRepoInfo', () => {
-      it('fetches and parses repo info', async () => {
-        const info = await tap.getRepoInfo('did:example:alice')
-        expect(info.did).toBe('did:example:alice')
-        expect(info.handle).toBe('alice.test')
-        expect(info.state).toBe('active')
-        expect(info.records).toBe(42)
-      })
-    })
-  })
-
-  describe('HTTP error handling', () => {
-    let terminator: httpTerminator.HttpTerminator
-    let tap: Tap
-
-    beforeAll(async () => {
-      const app = express()
-      app.use(express.json())
-
-      app.post('/repos/add', (_req, res) => {
-        res.status(500).send('Internal Server Error')
-      })
-
-      app.get('/info/:did', (_req, res) => {
-        res.status(500).send('Internal Server Error')
-      })
-
-      const server = app.listen(0)
-      await once(server, 'listening')
-      const { port } = server.address() as AddressInfo
-      terminator = httpTerminator.createHttpTerminator({ server })
-      tap = new Tap(`http://localhost:${port}`)
-    })
-
-    afterAll(async () => {
-      await terminator?.terminate()
-    })
-
-    it('throws on addRepos failure', async () => {
-      await expect(tap.addRepos(['did:example:alice'])).rejects.toThrow(
-        'Failed to add repos',
-      )
-    })
-
-    it('throws on getRepoInfo failure', async () => {
-      await expect(tap.getRepoInfo('did:example:alice')).rejects.toThrow(
-        'Failed to get repo info',
-      )
-    })
-  })
-})