@atproto/tap 0.0.2

package/tests/simple-indexer.test.ts

@@ -0,0 +1,188 @@
+import { HandlerOpts } from '../src/channel'
+import { SimpleIndexer } from '../src/simple-indexer'
+import { IdentityEvent, RecordEvent } from '../src/types'
+
+const createMockOpts = (): HandlerOpts & { acked: boolean } => {
+  const opts = {
+    signal: new AbortController().signal,
+    acked: false,
+    ack: async () => {
+      opts.acked = true
+    },
+  }
+  return opts
+}
+
+const createRecordEvent = (): RecordEvent => ({
+  id: 1,
+  type: 'record',
+  did: 'did:example:alice',
+  rev: 'abc123',
+  collection: 'com.example.post',
+  rkey: 'abc123',
+  action: 'create',
+  record: { text: 'hello' },
+  cid: 'bafyabc',
+  live: true,
+})
+
+const createIdentityEvent = (): IdentityEvent => ({
+  id: 2,
+  type: 'identity',
+  did: 'did:example:alice',
+  handle: 'alice.test',
+  isActive: true,
+  status: 'active',
+})
+
+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)
+    })
+  })
+})

package/tests/util.test.ts

@@ -0,0 +1,88 @@
+import {
+  assureAdminAuth,
+  formatAdminAuthHeader,
+  parseAdminAuthHeader,
+} from '../src'
+
+describe('util', () => {
+  describe('formatAdminAuthHeader', () => {
+    it('formats password as Basic auth header', () => {
+      const header = formatAdminAuthHeader('secret')
+      expect(header).toBe('Basic YWRtaW46c2VjcmV0')
+    })
+
+    it('uses admin as username', () => {
+      const header = formatAdminAuthHeader('secret')
+      const decoded = Buffer.from(
+        header.replace('Basic ', ''),
+        'base64',
+      ).toString()
+      expect(decoded).toBe('admin:secret')
+    })
+  })
+
+  describe('parseAdminAuthHeader', () => {
+    it('parses Basic auth header and returns password', () => {
+      const header = 'Basic YWRtaW46c2VjcmV0' // admin:secret
+      const password = parseAdminAuthHeader(header)
+      expect(password).toBe('secret')
+    })
+
+    it('handles header without Basic prefix', () => {
+      const header = 'YWRtaW46c2VjcmV0' // admin:secret (no prefix)
+      const password = parseAdminAuthHeader(header)
+      expect(password).toBe('secret')
+    })
+
+    it('throws if username is not admin', () => {
+      const header = 'Basic ' + Buffer.from('user:secret').toString('base64')
+      expect(() => parseAdminAuthHeader(header)).toThrow(
+        "Unexpected username in admin headers. Expected 'admin'",
+      )
+    })
+  })
+
+  describe('assureAdminAuth', () => {
+    it('does not throw when password matches', () => {
+      const header = formatAdminAuthHeader('secret')
+      expect(() => assureAdminAuth('secret', header)).not.toThrow()
+    })
+
+    it('throws when password does not match', () => {
+      const header = formatAdminAuthHeader('wrong')
+      expect(() => assureAdminAuth('secret', header)).toThrow(
+        'Invalid admin password',
+      )
+    })
+
+    it('throws when header has invalid username', () => {
+      const header =
+        'Basic ' + Buffer.from('notadmin:secret').toString('base64')
+      expect(() => assureAdminAuth('secret', header)).toThrow()
+    })
+
+    it('is timing-safe (does not leak password length)', () => {
+      // This is a basic sanity check - true timing attack tests require statistical analysis
+      const header = formatAdminAuthHeader('a')
+      const start1 = performance.now()
+      try {
+        assureAdminAuth('b', header)
+      } catch {
+        // do nothing
+      }
+      const time1 = performance.now() - start1
+
+      const longHeader = formatAdminAuthHeader('a'.repeat(1000))
+      const start2 = performance.now()
+      try {
+        assureAdminAuth('b'.repeat(1000), longHeader)
+      } catch {
+        // do nothing
+      }
+      const time2 = performance.now() - start2
+
+      // Times should be in the same order of magnitude (not a rigorous test)
+      expect(Math.abs(time1 - time2)).toBeLessThan(50)
+    })
+  })
+})

package/tsconfig.build.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig/node.json",
+  "compilerOptions": {
+    "noImplicitAny": true,
+    "rootDir": "./src",
+    "outDir": "./dist"
+  },
+  "include": ["./src"]
+}

package/tsconfig.build.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./src/channel.ts","./src/client.ts","./src/index.ts","./src/simple-indexer.ts","./src/types.ts","./src/util.ts"],"version":"5.8.3"}

package/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "include": [],
+  "references": [{ "path": "./tsconfig.build.json" }]
+}