@atproto/tap 0.3.3 → 0.3.5

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

package/tests/lex-indexer.test.ts

@@ -1,343 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { l } from '@atproto/lex'
-import {
-  CreateEvent,
-  DeleteEvent,
-  LexIndexer,
-  UpdateEvent,
-} from '../src/lex-indexer.js'
-import { IdentityEvent, RecordEvent } from '../src/types.js'
-import {
-  createIdentityEvent,
-  createMockOpts,
-  createRecordEvent as baseCreateRecordEvent,
-} from './_util.js'
-
-// Test lexicon definitions
-const postNsid = 'com.example.post'
-type Post = {
-  $type: 'com.example.post'
-  text: string
-}
-const post = {
-  main: l.record<'tid', Post>('tid', postNsid, l.object({ text: l.string() })),
-}
-
-const likeNsid = 'com.example.like'
-type Like = {
-  $type: 'com.example.like'
-  subject: string
-}
-const like = {
-  main: l.record<'tid', Like>(
-    'tid',
-    likeNsid,
-    l.object({ subject: l.string() }),
-  ),
-}
-
-const createRecordEvent = (overrides: Partial<RecordEvent> = {}): RecordEvent =>
-  baseCreateRecordEvent({
-    collection: postNsid,
-    record: { $type: postNsid, text: 'hello' },
-    ...overrides,
-  })
-
-describe('LexIndexer', () => {
-  describe('handler registration', () => {
-    it('registers create handler', async () => {
-      const indexer = new LexIndexer()
-      const received: CreateEvent<Post>[] = []
-
-      indexer.create(post, async (evt) => {
-        received.push(evt)
-      })
-
-      const opts = createMockOpts()
-      await indexer.onEvent(createRecordEvent(), opts)
-
-      expect(received).toHaveLength(1)
-      expect(received[0].action).toBe('create')
-      expect(received[0].record.text).toBe('hello')
-      expect(received[0].cid).toBe(
-        'bafyreiclp443lavogvhj3d2ob2cxbfuscni2k5jk7bebjzg7khl3esabwq',
-      )
-    })
-
-    it('registers update handler', async () => {
-      const indexer = new LexIndexer()
-      const received: UpdateEvent<Post>[] = []
-
-      indexer.update(post, async (evt) => {
-        received.push(evt)
-      })
-
-      const opts = createMockOpts()
-      await indexer.onEvent(
-        createRecordEvent({
-          action: 'update',
-          record: { $type: postNsid, text: 'updated' },
-        }),
-        opts,
-      )
-
-      expect(received).toHaveLength(1)
-      expect(received[0].action).toBe('update')
-      expect(received[0].record.text).toBe('updated')
-    })
-
-    it('registers delete handler', async () => {
-      const indexer = new LexIndexer()
-      const received: DeleteEvent[] = []
-
-      indexer.delete(post, async (evt) => {
-        received.push(evt)
-      })
-
-      const opts = createMockOpts()
-      await indexer.onEvent(
-        createRecordEvent({
-          action: 'delete',
-          record: undefined,
-          cid: undefined,
-        }),
-        opts,
-      )
-
-      expect(received).toHaveLength(1)
-      expect(received[0].action).toBe('delete')
-    })
-
-    it('registers put handler for both create and update', async () => {
-      const indexer = new LexIndexer()
-      const received: Array<{ action: string; text: string }> = []
-
-      indexer.put(post, async (evt) => {
-        received.push({ action: evt.action, text: evt.record.text })
-      })
-
-      const opts1 = createMockOpts()
-      await indexer.onEvent(createRecordEvent({ action: 'create' }), opts1)
-
-      const opts2 = createMockOpts()
-      await indexer.onEvent(
-        createRecordEvent({
-          action: 'update',
-          record: { $type: postNsid, text: 'updated' },
-        }),
-        opts2,
-      )
-
-      expect(received).toHaveLength(2)
-      expect(received[0].action).toBe('create')
-      expect(received[1].action).toBe('update')
-    })
-  })
-
-  describe('handler routing', () => {
-    it('routes to correct handler by collection', async () => {
-      const indexer = new LexIndexer()
-      const postEvents: CreateEvent<Post>[] = []
-      const likeEvents: CreateEvent<Like>[] = []
-
-      indexer.create(post, async (evt) => {
-        postEvents.push(evt)
-      })
-      indexer.create(like, async (evt) => {
-        likeEvents.push(evt)
-      })
-
-      const opts1 = createMockOpts()
-      await indexer.onEvent(createRecordEvent(), opts1)
-
-      const opts2 = createMockOpts()
-      await indexer.onEvent(
-        createRecordEvent({
-          collection: likeNsid,
-          record: { $type: likeNsid, subject: 'at://did:example:bob/post/123' },
-        }),
-        opts2,
-      )
-
-      expect(postEvents).toHaveLength(1)
-      expect(likeEvents).toHaveLength(1)
-    })
-
-    it('routes to other handler for unregistered collections', async () => {
-      const indexer = new LexIndexer()
-      const otherEvents: RecordEvent[] = []
-
-      indexer.create(post, async () => {})
-      indexer.other(async (evt) => {
-        otherEvents.push(evt)
-      })
-
-      const opts = createMockOpts()
-      await indexer.onEvent(
-        createRecordEvent({ collection: 'com.example.unknown' }),
-        opts,
-      )
-
-      expect(otherEvents).toHaveLength(1)
-      expect(otherEvents[0].collection).toBe('com.example.unknown')
-    })
-
-    it('routes to other handler for unregistered actions', async () => {
-      const indexer = new LexIndexer()
-      const otherEvents: RecordEvent[] = []
-
-      indexer.create(post, async () => {})
-      indexer.other(async (evt) => {
-        otherEvents.push(evt)
-      })
-
-      const opts = createMockOpts()
-      await indexer.onEvent(createRecordEvent({ action: 'delete' }), opts)
-
-      expect(otherEvents).toHaveLength(1)
-      expect(otherEvents[0].action).toBe('delete')
-    })
-
-    it('routes identity events to identity handler', async () => {
-      const indexer = new LexIndexer()
-      const received: IdentityEvent[] = []
-
-      indexer.identity(async (evt) => {
-        received.push(evt)
-      })
-
-      const opts = createMockOpts()
-      await indexer.onEvent(createIdentityEvent(), opts)
-
-      expect(received).toHaveLength(1)
-      expect(received[0].handle).toBe('alice.test')
-    })
-  })
-
-  describe('duplicate registration', () => {
-    it('throws on duplicate create handler', () => {
-      const indexer = new LexIndexer()
-      indexer.create(post, async () => {})
-
-      expect(() => indexer.create(post, async () => {})).toThrow(
-        'Handler already registered',
-      )
-    })
-
-    it('throws on duplicate update handler', () => {
-      const indexer = new LexIndexer()
-      indexer.update(post, async () => {})
-
-      expect(() => indexer.update(post, async () => {})).toThrow(
-        'Handler already registered',
-      )
-    })
-
-    it('throws on duplicate delete handler', () => {
-      const indexer = new LexIndexer()
-      indexer.delete(post, async () => {})
-
-      expect(() => indexer.delete(post, async () => {})).toThrow(
-        'Handler already registered',
-      )
-    })
-
-    it('throws when put conflicts with create', () => {
-      const indexer = new LexIndexer()
-      indexer.create(post, async () => {})
-
-      expect(() => indexer.put(post, async () => {})).toThrow(
-        'Handler already registered',
-      )
-    })
-
-    it('throws when create conflicts with put', () => {
-      const indexer = new LexIndexer()
-      indexer.put(post, async () => {})
-
-      expect(() => indexer.create(post, async () => {})).toThrow(
-        'Handler already registered',
-      )
-    })
-  })
-
-  describe('schema validation', () => {
-    it('validates record on create', async () => {
-      const indexer = new LexIndexer()
-      indexer.create(post, async () => {})
-
-      const opts = createMockOpts()
-      await expect(
-        indexer.onEvent(createRecordEvent({ record: { text: 123 } }), opts),
-      ).rejects.toThrow('Record validation failed')
-    })
-
-    it('validates record on update', async () => {
-      const indexer = new LexIndexer()
-      indexer.update(post, async () => {})
-
-      const opts = createMockOpts()
-      await expect(
-        indexer.onEvent(
-          createRecordEvent({ action: 'update', record: { invalid: true } }),
-          opts,
-        ),
-      ).rejects.toThrow('Record validation failed')
-    })
-  })
-
-  describe('ack behavior', () => {
-    it('calls ack after handler completes', async () => {
-      const indexer = new LexIndexer()
-      indexer.create(post, async () => {})
-
-      const opts = createMockOpts()
-      await indexer.onEvent(createRecordEvent(), opts)
-
-      expect(opts.acked).toBe(true)
-    })
-
-    it('calls ack when routed to other handler', async () => {
-      const indexer = new LexIndexer()
-      indexer.other(async () => {})
-
-      const opts = createMockOpts()
-      await indexer.onEvent(createRecordEvent(), opts)
-
-      expect(opts.acked).toBe(true)
-    })
-
-    it('calls ack even when no handler matches', async () => {
-      const indexer = new LexIndexer()
-
-      const opts = createMockOpts()
-      await indexer.onEvent(createRecordEvent(), opts)
-
-      expect(opts.acked).toBe(true)
-    })
-  })
-
-  describe('error handling', () => {
-    it('calls error handler when provided', () => {
-      const indexer = new LexIndexer()
-      const errors: Error[] = []
-
-      indexer.error((err) => {
-        errors.push(err)
-      })
-
-      const testError = new Error('test error')
-      indexer.onError(testError)
-
-      expect(errors).toHaveLength(1)
-      expect(errors[0]).toBe(testError)
-    })
-
-    it('throws when no error handler is registered', () => {
-      const indexer = new LexIndexer()
-      const testError = new Error('test error')
-
-      expect(() => indexer.onError(testError)).toThrow('test error')
-    })
-  })
-})

package/tests/simple-indexer.test.ts

@@ -1,161 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { HandlerOpts } from '../src/channel.js'
-import { SimpleIndexer } from '../src/simple-indexer.js'
-import { IdentityEvent, RecordEvent } from '../src/types.js'
-import {
-  createIdentityEvent,
-  createMockOpts,
-  createRecordEvent,
-} from './_util.js'
-
-describe('SimpleIndexer', () => {
-  describe('event routing', () => {
-    it('routes record events to record handler', async () => {
-      const indexer = new SimpleIndexer()
-      const receivedEvents: RecordEvent[] = []
-
-      indexer.record(async (evt) => {
-        receivedEvents.push(evt)
-      })
-
-      const opts = createMockOpts()
-      await indexer.onEvent(createRecordEvent(), opts)
-
-      expect(receivedEvents).toHaveLength(1)
-      expect(receivedEvents[0].type).toBe('record')
-      expect(receivedEvents[0].collection).toBe('com.example.post')
-    })
-
-    it('routes identity events to identity handler', async () => {
-      const indexer = new SimpleIndexer()
-      const receivedEvents: IdentityEvent[] = []
-
-      indexer.identity(async (evt) => {
-        receivedEvents.push(evt)
-      })
-
-      const opts = createMockOpts()
-      await indexer.onEvent(createIdentityEvent(), opts)
-
-      expect(receivedEvents).toHaveLength(1)
-      expect(receivedEvents[0].type).toBe('identity')
-      expect(receivedEvents[0].handle).toBe('alice.test')
-    })
-
-    it('does not call identity handler for record events', async () => {
-      const indexer = new SimpleIndexer()
-      let identityCalled = false
-      let recordCalled = false
-
-      indexer.identity(async () => {
-        identityCalled = true
-      })
-      indexer.record(async () => {
-        recordCalled = true
-      })
-
-      const opts = createMockOpts()
-      await indexer.onEvent(createRecordEvent(), opts)
-
-      expect(recordCalled).toBe(true)
-      expect(identityCalled).toBe(false)
-    })
-
-    it('does not call record handler for identity events', async () => {
-      const indexer = new SimpleIndexer()
-      let identityCalled = false
-      let recordCalled = false
-
-      indexer.identity(async () => {
-        identityCalled = true
-      })
-      indexer.record(async () => {
-        recordCalled = true
-      })
-
-      const opts = createMockOpts()
-      await indexer.onEvent(createIdentityEvent(), opts)
-
-      expect(identityCalled).toBe(true)
-      expect(recordCalled).toBe(false)
-    })
-  })
-
-  describe('ack behavior', () => {
-    it('calls ack after handler completes', async () => {
-      const indexer = new SimpleIndexer()
-      indexer.record(async () => {})
-
-      const opts = createMockOpts()
-      await indexer.onEvent(createRecordEvent(), opts)
-
-      expect(opts.acked).toBe(true)
-    })
-
-    it('calls ack even when no handler is registered', async () => {
-      const indexer = new SimpleIndexer()
-      // No handlers registered
-
-      const opts = createMockOpts()
-      await indexer.onEvent(createRecordEvent(), opts)
-
-      expect(opts.acked).toBe(true)
-    })
-  })
-
-  describe('error handling', () => {
-    it('calls error handler when provided', () => {
-      const indexer = new SimpleIndexer()
-      const errors: Error[] = []
-
-      indexer.error((err) => {
-        errors.push(err)
-      })
-
-      const testError = new Error('test error')
-      indexer.onError(testError)
-
-      expect(errors).toHaveLength(1)
-      expect(errors[0]).toBe(testError)
-    })
-
-    it('throws when no error handler is registered', () => {
-      const indexer = new SimpleIndexer()
-      const testError = new Error('test error')
-
-      expect(() => indexer.onError(testError)).toThrow('test error')
-    })
-  })
-
-  describe('handler opts passthrough', () => {
-    it('passes opts to record handler', async () => {
-      const indexer = new SimpleIndexer()
-      let receivedOpts: HandlerOpts | undefined
-
-      indexer.record(async (_evt, opts) => {
-        receivedOpts = opts
-      })
-
-      const opts = createMockOpts()
-      await indexer.onEvent(createRecordEvent(), opts)
-
-      expect(receivedOpts).toBeDefined()
-      expect(receivedOpts?.signal).toBe(opts.signal)
-    })
-
-    it('passes opts to identity handler', async () => {
-      const indexer = new SimpleIndexer()
-      let receivedOpts: HandlerOpts | undefined
-
-      indexer.identity(async (_evt, opts) => {
-        receivedOpts = opts
-      })
-
-      const opts = createMockOpts()
-      await indexer.onEvent(createIdentityEvent(), opts)
-
-      expect(receivedOpts).toBeDefined()
-      expect(receivedOpts?.signal).toBe(opts.signal)
-    })
-  })
-})