@atproto/tap 0.1.2 → 0.2.0

package/src/channel.ts

@@ -1,8 +1,9 @@
 import { ClientOptions } from 'ws'
-import { Deferrable, createDeferrable, isErrnoException } from '@atproto/common'
+import { Deferrable, createDeferrable } from '@atproto/common'
+import { lexParse } from '@atproto/lex'
 import { WebSocketKeepAlive } from '@atproto/ws-client'
 import { TapEvent, parseTapEvent } from './types'
-import { formatAdminAuthHeader } from './util'
+import { formatAdminAuthHeader, isCausedBySignal } from './util'
 
 export interface HandlerOpts {
   signal: AbortSignal
@@ -26,7 +27,7 @@ type BufferedAck = {
   defer: Deferrable
 }
 
-export class TapChannel {
+export class TapChannel implements AsyncDisposable {
   private ws: WebSocketKeepAlive
   private handler: TapHandler
 
@@ -94,38 +95,43 @@ export class TapChannel {
         await this.sendAck(ack.id)
         ack.defer.resolve()
         this.bufferedAcks = this.bufferedAcks.slice(1)
-      } catch (err) {
-        this.handler.onError(
-          new Error(`failed to send ack for event ${this.bufferedAcks[0]}`, {
-            cause: err,
-          }),
+      } catch (cause) {
+        const error = new Error(
+          `failed to send ack for event ${this.bufferedAcks[0]}`,
+          { cause },
         )
+        this.handler.onError(error)
         return
       }
     }
   }
 
   async start() {
+    this.abortController.signal.throwIfAborted()
     try {
       for await (const chunk of this.ws) {
         await this.processWsEvent(chunk)
       }
     } catch (err) {
-      if (isErrnoException(err) && err.name === 'AbortError') {
-        this.destroyDefer.resolve()
-      } else {
+      if (!isCausedBySignal(err, this.abortController.signal)) {
         throw err
       }
+    } finally {
+      this.destroyDefer.resolve()
     }
   }
 
   private async processWsEvent(chunk: Uint8Array) {
     let evt: TapEvent
     try {
-      const data = chunk.toString()
-      evt = parseTapEvent(JSON.parse(data))
-    } catch (err) {
-      this.handler.onError(new Error('Failed to parse message', { cause: err }))
+      const data = lexParse(chunk.toString(), {
+        // Reject invalid CIDs and blobs
+        strict: true,
+      })
+      evt = parseTapEvent(data)
+    } catch (cause) {
+      const error = new Error(`Failed to parse message`, { cause })
+      this.handler.onError(error)
       return
     }
 
@@ -136,11 +142,10 @@ export class TapChannel {
           await this.ackEvent(evt.id)
         },
       })
-    } catch (err) {
+    } catch (cause) {
       // Don't ack on error - let Tap retry
-      this.handler.onError(
-        new Error(`Failed to process event ${evt.id}`, { cause: err }),
-      )
+      const error = new Error(`Failed to process event ${evt.id}`, { cause })
+      this.handler.onError(error)
       return
     }
   }
@@ -149,4 +154,8 @@ export class TapChannel {
     this.abortController.abort()
     await this.destroyDefer.complete
   }
+
+  async [Symbol.asyncDispose](): Promise<void> {
+    await this.destroy()
+  }
 }

package/src/lex-indexer.ts

@@ -1,5 +1,5 @@
 import { Infer, Main, RecordSchema, getMain } from '@atproto/lex'
-import { AtUri } from '@atproto/syntax'
+import { AtUriString, NsidString } from '@atproto/syntax'
 import { HandlerOpts, TapHandler } from './channel'
 import { IdentityEvent, RecordEvent, TapEvent } from './types'
 
@@ -73,12 +73,15 @@ export class LexIndexer implements TapHandler {
   private identityHandler: IdentityHandler | undefined
   private errorHandler: ErrorHandler | undefined
 
-  private handlerKey(collection: string, action: string): string {
+  private handlerKey(
+    collection: NsidString,
+    action: RecordEvent['action'],
+  ): string {
     return `${collection}:${action}`
   }
 
   private register<const T extends RecordSchema>(
-    action: string,
+    action: RecordEvent['action'],
     ns: Main<T>,
     handler: RecordHandler<Infer<T>>,
   ): this {
@@ -117,7 +120,8 @@ export class LexIndexer implements TapHandler {
     handler: PutHandler<Infer<T>>,
   ): this {
     this.register('create', ns, handler)
-    return this.register('update', ns, handler)
+    this.register('update', ns, handler)
+    return this
   }
 
   other(fn: UntypedHandler): this {
@@ -167,10 +171,12 @@ export class LexIndexer implements TapHandler {
     }
 
     if (action === 'create' || action === 'update') {
-      const match = registered.schema.matches(evt.record)
-      if (!match) {
-        const uriStr = AtUri.make(evt.did, evt.collection, evt.rkey).toString()
-        throw new Error(`Record validation failed for ${uriStr}`)
+      const match = registered.schema.safeValidate(evt.record)
+      if (!match.success) {
+        const uriStr: AtUriString = `at://${evt.did}/${evt.collection}/${evt.rkey}`
+        throw new Error(`Record validation failed for ${uriStr}`, {
+          cause: match.reason,
+        })
       }
     }
 

package/src/types.ts

@@ -1,21 +1,22 @@
-import { z } from 'zod'
+import { LexMap, LexValue, l } from '@atproto/lex'
+import { DidString, HandleString, NsidString } from '@atproto/syntax'
 
-export const recordEventDataSchema = z.object({
-  did: z.string(),
-  rev: z.string(),
-  collection: z.string(),
-  rkey: z.string(),
-  action: z.enum(['create', 'update', 'delete']),
-  record: z.record(z.string(), z.unknown()).optional(),
-  cid: z.string().optional(),
-  live: z.boolean(),
+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.unknownObject()),
+  cid: l.optional(l.string({ format: 'cid' })),
+  live: l.boolean(),
 })
 
-export const identityEventDataSchema = z.object({
-  did: z.string(),
-  handle: z.string(),
-  is_active: z.boolean(),
-  status: z.enum([
+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',
@@ -24,29 +25,32 @@ export const identityEventDataSchema = z.object({
   ]),
 })
 
-export const recordEventSchema = z.object({
-  id: z.number(),
-  type: z.literal('record'),
+export const recordEventSchema = l.object({
+  id: l.integer(),
+  type: l.literal('record'),
   record: recordEventDataSchema,
 })
 
-export const identityEventSchema = z.object({
-  id: z.number(),
-  type: z.literal('identity'),
+export const identityEventSchema = l.object({
+  id: l.integer(),
+  type: l.literal('identity'),
   identity: identityEventDataSchema,
 })
 
-export const tapEventSchema = z.union([recordEventSchema, identityEventSchema])
+export const tapEventSchema = l.discriminatedUnion('type', [
+  recordEventSchema,
+  identityEventSchema,
+])
 
 export type RecordEvent = {
   id: number
   type: 'record'
   action: 'create' | 'update' | 'delete'
-  did: string
+  did: DidString
   rev: string
-  collection: string
+  collection: NsidString
   rkey: string
-  record?: Record<string, unknown>
+  record?: LexMap
   cid?: string
   live: boolean
 }
@@ -54,8 +58,8 @@ export type RecordEvent = {
 export type IdentityEvent = {
   id: number
   type: 'identity'
-  did: string
-  handle: string
+  did: DidString
+  handle: HandleString
   isActive: boolean
   status: RepoStatus
 }
@@ -69,7 +73,7 @@ export type RepoStatus =
 
 export type TapEvent = IdentityEvent | RecordEvent
 
-export const parseTapEvent = (data: unknown): TapEvent => {
+export const parseTapEvent = (data: LexValue): TapEvent => {
   const parsed = tapEventSchema.parse(data)
   if (parsed.type === 'identity') {
     return {
@@ -96,14 +100,14 @@ export const parseTapEvent = (data: unknown): TapEvent => {
   }
 }
 
-export const repoInfoSchema = z.object({
-  did: z.string(),
-  handle: z.string(),
-  state: z.string(),
-  rev: z.string(),
-  records: z.number(),
-  error: z.string().optional(),
-  retries: z.number().optional(),
+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 = z.infer<typeof repoInfoSchema>
+export type RepoInfo = l.Infer<typeof repoInfoSchema>

package/src/util.ts

@@ -31,3 +31,12 @@ const timingSafeEqual = (a: string, b: string): boolean => {
   }
   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,3 +1,4 @@
+import { WebSocketServer } from 'ws'
 import { HandlerOpts } from '../src/channel'
 import { IdentityEvent, RecordEvent } from '../src/types'
 
@@ -25,7 +26,7 @@ export const createRecordEvent = (
   rkey: 'abc123',
   action: 'create',
   record: { text: 'hello' },
-  cid: 'bafyabc',
+  cid: 'bafyreiclp443lavogvhj3d2ob2cxbfuscni2k5jk7bebjzg7khl3esabwq',
   live: true,
   ...overrides,
 })
@@ -38,3 +39,25 @@ export const createIdentityEvent = (): IdentityEvent => ({
   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,7 +1,8 @@
-import getPort from 'get-port'
-import { WebSocketServer } from 'ws'
+import { describe, expect, it } from 'vitest'
+import { AddressInfo } from 'ws'
 import { TapChannel, TapHandler } from '../src/channel'
 import { TapEvent } from '../src/types'
+import { createWebSocketServer } from './_util'
 
 const createRecordEvent = (id: number) => ({
   id,
@@ -13,7 +14,7 @@ const createRecordEvent = (id: number) => ({
     rkey: 'abc123',
     action: 'create' as const,
     record: { text: 'hello' },
-    cid: 'bafyabc',
+    cid: 'bafyreiclp443lavogvhj3d2ob2cxbfuscni2k5jk7bebjzg7khl3esabwq',
     live: true,
   },
 })
@@ -32,8 +33,9 @@ const createIdentityEvent = (id: number) => ({
 describe('TapChannel', () => {
   describe('receiving events', () => {
     it('receives and parses record events', async () => {
-      const port = await getPort()
-      const server = new WebSocketServer({ port })
+      await using server = await createWebSocketServer()
+
+      const { port } = server.address() as AddressInfo
 
       const receivedEvents: TapEvent[] = []
 
@@ -57,7 +59,7 @@ describe('TapChannel', () => {
         },
       }
 
-      const channel = new TapChannel(`ws://localhost:${port}`, handler)
+      await using channel = new TapChannel(`ws://localhost:${port}`, handler)
       await channel.start()
 
       expect(receivedEvents).toHaveLength(1)
@@ -67,13 +69,12 @@ describe('TapChannel', () => {
         expect(receivedEvents[0].collection).toBe('com.example.post')
         expect(receivedEvents[0].action).toBe('create')
       }
-
-      server.close()
     })
 
     it('receives and parses identity events', async () => {
-      const port = await getPort()
-      const server = new WebSocketServer({ port })
+      await using server = await createWebSocketServer()
+
+      const { port } = server.address() as AddressInfo
 
       const receivedEvents: TapEvent[] = []
 
@@ -97,7 +98,7 @@ describe('TapChannel', () => {
         },
       }
 
-      const channel = new TapChannel(`ws://localhost:${port}`, handler)
+      await using channel = new TapChannel(`ws://localhost:${port}`, handler)
       await channel.start()
 
       expect(receivedEvents).toHaveLength(1)
@@ -107,15 +108,14 @@ describe('TapChannel', () => {
         expect(receivedEvents[0].handle).toBe('alice.test')
         expect(receivedEvents[0].status).toBe('active')
       }
-
-      server.close()
     })
   })
 
   describe('ack behavior', () => {
     it('sends ack when handler calls ack()', async () => {
-      const port = await getPort()
-      const server = new WebSocketServer({ port })
+      await using server = await createWebSocketServer()
+
+      const { port } = server.address() as AddressInfo
 
       const receivedAcks: number[] = []
 
@@ -139,17 +139,16 @@ describe('TapChannel', () => {
         },
       }
 
-      const channel = new TapChannel(`ws://localhost:${port}`, handler)
+      await using channel = new TapChannel(`ws://localhost:${port}`, handler)
       await channel.start()
 
       expect(receivedAcks).toEqual([42])
-
-      server.close()
     })
 
     it('does not send ack if handler throws', async () => {
-      const port = await getPort()
-      const server = new WebSocketServer({ port })
+      await using server = await createWebSocketServer()
+
+      const { port } = server.address() as AddressInfo
 
       const receivedAcks: number[] = []
       const errors: Error[] = []
@@ -175,19 +174,18 @@ describe('TapChannel', () => {
         },
       }
 
-      const channel = new TapChannel(`ws://localhost:${port}`, handler)
+      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')
-
-      server.close()
     })
 
     it('does not send ack if handler does not call ack()', async () => {
-      const port = await getPort()
-      const server = new WebSocketServer({ port })
+      await using server = await createWebSocketServer()
+
+      const { port } = server.address() as AddressInfo
 
       const receivedAcks: number[] = []
 
@@ -212,17 +210,16 @@ describe('TapChannel', () => {
         },
       }
 
-      const channel = new TapChannel(`ws://localhost:${port}`, handler)
+      await using channel = new TapChannel(`ws://localhost:${port}`, handler)
       await channel.start()
 
       expect(receivedAcks).toHaveLength(0)
-
-      server.close()
     })
 
     it('handles reconnection and receives events from new connection', async () => {
-      const port = await getPort()
-      const server = new WebSocketServer({ port })
+      await using server = await createWebSocketServer()
+
+      const { port } = server.address() as AddressInfo
 
       const receivedEvents: TapEvent[] = []
       const receivedAcks: number[] = []
@@ -256,7 +253,7 @@ describe('TapChannel', () => {
         onError: () => {},
       }
 
-      const channel = new TapChannel(`ws://localhost:${port}`, handler, {
+      await using channel = new TapChannel(`ws://localhost:${port}`, handler, {
         maxReconnectSeconds: 1,
       })
 
@@ -269,15 +266,14 @@ describe('TapChannel', () => {
       expect(receivedEvents[1].id).toBe(2)
       expect(receivedAcks).toContain(1)
       expect(receivedAcks).toContain(2)
-
-      server.close()
     })
   })
 
   describe('multiple events', () => {
     it('processes multiple events in sequence', async () => {
-      const port = await getPort()
-      const server = new WebSocketServer({ port })
+      await using server = await createWebSocketServer()
+
+      const { port } = server.address() as AddressInfo
 
       const receivedEvents: TapEvent[] = []
       const receivedAcks: number[] = []
@@ -307,7 +303,7 @@ describe('TapChannel', () => {
         },
       }
 
-      const channel = new TapChannel(`ws://localhost:${port}`, handler)
+      await using channel = new TapChannel(`ws://localhost:${port}`, handler)
       await channel.start()
 
       expect(receivedEvents).toHaveLength(3)
@@ -315,15 +311,14 @@ describe('TapChannel', () => {
       expect(receivedEvents[1].id).toBe(2)
       expect(receivedEvents[2].id).toBe(3)
       expect(receivedAcks).toEqual([1, 2, 3])
-
-      server.close()
     })
   })
 
   describe('auth', () => {
     it('includes auth header when adminPassword is provided', async () => {
-      const port = await getPort()
-      const server = new WebSocketServer({ port })
+      await using server = await createWebSocketServer()
+
+      const { port } = server.address() as AddressInfo
 
       let receivedAuthHeader: string | undefined
 
@@ -337,21 +332,20 @@ describe('TapChannel', () => {
         onError: () => {},
       }
 
-      const channel = new TapChannel(`ws://localhost:${port}`, handler, {
+      await using channel = new TapChannel(`ws://localhost:${port}`, handler, {
         adminPassword: 'secret',
       })
       await channel.start()
 
       expect(receivedAuthHeader).toBe('Basic YWRtaW46c2VjcmV0')
-
-      server.close()
     })
   })
 
   describe('error handling', () => {
     it('calls onError for malformed messages', async () => {
-      const port = await getPort()
-      const server = new WebSocketServer({ port })
+      await using server = await createWebSocketServer()
+
+      const { port } = server.address() as AddressInfo
 
       const errors: Error[] = []
 
@@ -367,13 +361,11 @@ describe('TapChannel', () => {
         },
       }
 
-      const channel = new TapChannel(`ws://localhost:${port}`, handler)
+      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')
-
-      server.close()
     })
   })
 })

package/tests/client.test.ts

@@ -1,7 +1,8 @@
 import { once } from 'node:events'
 import * as http from 'node:http'
+import { AddressInfo } from 'node:net'
 import { default as express } from 'express'
-import getPort from 'get-port'
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest'
 import { Tap } from '../src/client'
 
 describe('Tap client', () => {
@@ -40,7 +41,6 @@ describe('Tap client', () => {
     }[]
 
     beforeAll(async () => {
-      const port = await getPort()
       const app = express()
       app.use(express.json())
 
@@ -99,8 +99,9 @@ describe('Tap client', () => {
         })
       })
 
-      server = app.listen(port) as http.Server
+      server = app.listen()
       await once(server, 'listening')
+      const { port } = server.address() as AddressInfo
       tap = new Tap(`http://localhost:${port}`, { adminPassword: 'secret' })
     })
 
@@ -172,7 +173,6 @@ describe('Tap client', () => {
     let tap: Tap
 
     beforeAll(async () => {
-      const port = await getPort()
       const app = express()
       app.use(express.json())
 
@@ -184,8 +184,9 @@ describe('Tap client', () => {
         res.status(500).send('Internal Server Error')
       })
 
-      server = app.listen(port) as http.Server
+      server = app.listen()
       await once(server, 'listening')
+      const { port } = server.address() as AddressInfo
       tap = new Tap(`http://localhost:${port}`)
     })
 

package/tests/lex-indexer.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, it } from 'vitest'
 import { l } from '@atproto/lex'
 import {
   CreateEvent,
@@ -58,7 +59,9 @@ describe('LexIndexer', () => {
       expect(received).toHaveLength(1)
       expect(received[0].action).toBe('create')
       expect(received[0].record.text).toBe('hello')
-      expect(received[0].cid).toBe('bafyabc')
+      expect(received[0].cid).toBe(
+        'bafyreiclp443lavogvhj3d2ob2cxbfuscni2k5jk7bebjzg7khl3esabwq',
+      )
     })
 
     it('registers update handler', async () => {

package/tests/simple-indexer.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, it } from 'vitest'
 import { HandlerOpts } from '../src/channel'
 import { SimpleIndexer } from '../src/simple-indexer'
 import { IdentityEvent, RecordEvent } from '../src/types'

package/tests/util.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, it } from 'vitest'
 import {
   assureAdminAuth,
   formatAdminAuthHeader,

package/tsconfig.json

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

package/tsconfig.tests.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig/vitest.json",
+  "include": ["./tests", "./src/**/*.test.ts"],
+  "compilerOptions": {
+    "noImplicitAny": true,
+    "rootDir": "./",
+    "baseUrl": "./"
+  }
+}

package/vitest.config.ts

@@ -0,0 +1,5 @@
+import { defineProject } from 'vitest/config'
+
+export default defineProject({
+  test: {},
+})