@atproto/tap 0.3.3 → 0.3.5

package/src/types.ts

@@ -1,113 +0,0 @@
-import { LexMap, LexValue, l } from '@atproto/lex'
-import { DidString, HandleString, NsidString } from '@atproto/syntax'
-
-export const recordEventDataSchema = l.object({
-  did: l.string({ format: 'did' }),
-  rev: l.string(),
-  collection: l.string({ format: 'nsid' }),
-  rkey: l.string({ format: 'record-key' }),
-  action: l.enum(['create', 'update', 'delete']),
-  record: l.optional(l.lexMap()),
-  cid: l.optional(l.string({ format: 'cid' })),
-  live: l.boolean(),
-})
-
-export const identityEventDataSchema = l.object({
-  did: l.string({ format: 'did' }),
-  handle: l.string({ format: 'handle' }),
-  is_active: l.boolean(),
-  status: l.enum([
-    'active',
-    'takendown',
-    'suspended',
-    'deactivated',
-    'deleted',
-  ]),
-})
-
-export const recordEventSchema = l.object({
-  id: l.integer(),
-  type: l.literal('record'),
-  record: recordEventDataSchema,
-})
-
-export const identityEventSchema = l.object({
-  id: l.integer(),
-  type: l.literal('identity'),
-  identity: identityEventDataSchema,
-})
-
-export const tapEventSchema = l.discriminatedUnion('type', [
-  recordEventSchema,
-  identityEventSchema,
-])
-
-export type RecordEvent = {
-  id: number
-  type: 'record'
-  action: 'create' | 'update' | 'delete'
-  did: DidString
-  rev: string
-  collection: NsidString
-  rkey: string
-  record?: LexMap
-  cid?: string
-  live: boolean
-}
-
-export type IdentityEvent = {
-  id: number
-  type: 'identity'
-  did: DidString
-  handle: HandleString
-  isActive: boolean
-  status: RepoStatus
-}
-
-export type RepoStatus =
-  | 'active'
-  | 'takendown'
-  | 'suspended'
-  | 'deactivated'
-  | 'deleted'
-
-export type TapEvent = IdentityEvent | RecordEvent
-
-export const parseTapEvent = (data: LexValue): TapEvent => {
-  const parsed = tapEventSchema.parse(data)
-  if (parsed.type === 'identity') {
-    return {
-      id: parsed.id,
-      type: parsed.type,
-      did: parsed.identity.did,
-      handle: parsed.identity.handle,
-      isActive: parsed.identity.is_active,
-      status: parsed.identity.status,
-    }
-  } else {
-    return {
-      id: parsed.id,
-      type: parsed.type,
-      action: parsed.record.action,
-      did: parsed.record.did,
-      rev: parsed.record.rev,
-      collection: parsed.record.collection,
-      rkey: parsed.record.rkey,
-      record: parsed.record.record,
-      cid: parsed.record.cid,
-      live: parsed.record.live,
-    }
-  }
-}
-
-export const repoInfoSchema = l.object({
-  did: l.string(),
-  handle: l.string(),
-  state: l.string(),
-  rev: l.string(),
-  records: l.integer(),
-  error: l.optional(l.string()),
-  retries: l.optional(l.integer()),
-})
-
-export type RepoInfo = l.Infer<typeof repoInfoSchema>

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')
-    })
-  })
-})