@atproto/tap 0.3.4 → 0.3.5

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @atproto/tap
 
+## 0.3.5
+
+### Patch Changes
+
+- [#5099](https://github.com/bluesky-social/atproto/pull/5099) [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Update TypeScript build to rely on references to composite internal projects
+
+- [#5099](https://github.com/bluesky-social/atproto/pull/5099) [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Bundle only necessary files in the NPM tarball, including the `CHANGELOG.md` and `README.md` files (if present).
+
+- [#5099](https://github.com/bluesky-social/atproto/pull/5099) [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Build with `noImplicitAny` enabled
+
+- Updated dependencies [[`28a0b58`](https://github.com/bluesky-social/atproto/commit/28a0b588147863eaef948cd2bb8fc0f19d08cda9), [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07), [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07), [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07), [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07)]:
+  - @atproto/syntax@0.6.4
+  - @atproto/ws-client@0.1.4
+  - @atproto/lex@0.1.7
+  - @atproto/common@0.6.5
+
 ## 0.3.4
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/tap",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "license": "MIT",
   "description": "atproto tap client",
   "keywords": [
@@ -16,15 +16,27 @@
     "url": "https://github.com/bluesky-social/atproto",
     "directory": "packages/tap"
   },
+  "files": [
+    "./dist",
+    "./README.md",
+    "./CHANGELOG.md"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
   "engines": {
     "node": ">=22"
   },
   "dependencies": {
     "ws": "^8.12.0",
-    "@atproto/common": "^0.6.4",
-    "@atproto/lex": "^0.1.6",
-    "@atproto/syntax": "^0.6.3",
-    "@atproto/ws-client": "^0.1.3"
+    "@atproto/common": "^0.6.5",
+    "@atproto/syntax": "^0.6.4",
+    "@atproto/lex": "^0.1.7",
+    "@atproto/ws-client": "^0.1.4"
   },
   "devDependencies": {
     "@types/express": "^4.17.17",
@@ -34,13 +46,6 @@
     "http-terminator": "^3.2.0",
     "vitest": "^4.0.16"
   },
-  "type": "module",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    }
-  },
   "scripts": {
     "build": "tsgo --build tsconfig.build.json",
     "test": "vitest run"

package/src/channel.ts

@@ -1,161 +0,0 @@
-import type { ClientOptions } from 'ws'
-import { Deferrable, createDeferrable } from '@atproto/common'
-import { lexParse } from '@atproto/lex'
-import { WebSocketKeepAlive } from '@atproto/ws-client'
-import { TapEvent, parseTapEvent } from './types.js'
-import { formatAdminAuthHeader, isCausedBySignal } from './util.js'
-
-export interface HandlerOpts {
-  signal: AbortSignal
-  ack: () => Promise<void>
-}
-
-export interface TapHandler {
-  onEvent: (evt: TapEvent, opts: HandlerOpts) => void | Promise<void>
-  onError: (err: Error) => void
-}
-
-export type TapWebsocketOptions = ClientOptions & {
-  adminPassword?: string
-  maxReconnectSeconds?: number
-  heartbeatIntervalMs?: number
-  onReconnectError?: (error: unknown, n: number, initialSetup: boolean) => void
-}
-
-type BufferedAck = {
-  id: number
-  defer: Deferrable
-}
-
-export class TapChannel implements AsyncDisposable {
-  private ws: WebSocketKeepAlive
-  private handler: TapHandler
-
-  private readonly abortController: AbortController = new AbortController()
-  private readonly destroyDefer: Deferrable = createDeferrable()
-
-  private bufferedAcks: BufferedAck[] = []
-
-  constructor(
-    url: string,
-    handler: TapHandler,
-    wsOpts: TapWebsocketOptions = {},
-  ) {
-    this.handler = handler
-    const { adminPassword, ...rest } = wsOpts
-    let headers = rest.headers
-    if (adminPassword) {
-      headers ??= {}
-      headers['Authorization'] = formatAdminAuthHeader(adminPassword)
-    }
-    this.ws = new WebSocketKeepAlive({
-      getUrl: async () => url,
-      onReconnect: () => {
-        this.flushBufferedAcks()
-      },
-      signal: this.abortController.signal,
-      ...rest,
-      headers,
-    })
-  }
-
-  async ackEvent(id: number): Promise<void> {
-    if (this.ws.isConnected()) {
-      try {
-        await this.sendAck(id)
-      } catch {
-        await this.bufferAndSendAck(id)
-      }
-    } else {
-      await this.bufferAndSendAck(id)
-    }
-  }
-
-  private async sendAck(id: number): Promise<void> {
-    await this.ws.send(JSON.stringify({ type: 'ack', id }))
-  }
-
-  // resolves after the ack has been actually sent
-  private async bufferAndSendAck(id: number): Promise<void> {
-    const defer = createDeferrable()
-    this.bufferedAcks.push({
-      id,
-      defer,
-    })
-    await defer.complete
-  }
-
-  private async flushBufferedAcks(): Promise<void> {
-    while (this.bufferedAcks.length > 0) {
-      try {
-        const ack = this.bufferedAcks.at(0)
-        if (!ack) {
-          return
-        }
-        await this.sendAck(ack.id)
-        ack.defer.resolve()
-        this.bufferedAcks = this.bufferedAcks.slice(1)
-      } 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 (!isCausedBySignal(err, this.abortController.signal)) {
-        throw err
-      }
-    } finally {
-      this.destroyDefer.resolve()
-    }
-  }
-
-  private async processWsEvent(chunk: Uint8Array) {
-    let evt: TapEvent
-    try {
-      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
-    }
-
-    try {
-      await this.handler.onEvent(evt, {
-        signal: this.abortController.signal,
-        ack: async () => {
-          await this.ackEvent(evt.id)
-        },
-      })
-    } catch (cause) {
-      // Don't ack on error - let Tap retry
-      const error = new Error(`Failed to process event ${evt.id}`, { cause })
-      this.handler.onError(error)
-      return
-    }
-  }
-
-  async destroy(): Promise<void> {
-    this.abortController.abort()
-    await this.destroyDefer.complete
-  }
-
-  async [Symbol.asyncDispose](): Promise<void> {
-    await this.destroy()
-  }
-}

package/src/client.ts

@@ -1,106 +0,0 @@
-import { DidDocument, didDocument } from '@atproto/common'
-import { TapChannel, TapHandler, TapWebsocketOptions } from './channel.js'
-import { RepoInfo, repoInfoSchema } from './types.js'
-import { formatAdminAuthHeader } from './util.js'
-
-export interface TapConfig {
-  adminPassword?: string
-}
-
-export class Tap {
-  url: string
-  private adminPassword?: string
-  private authHeader?: string
-
-  private addReposUrl: URL
-  private removeReposUrl: URL
-
-  constructor(url: string, config: TapConfig = {}) {
-    if (!url.startsWith('http://') && !url.startsWith('https://')) {
-      throw new Error('Invalid URL, expected http:// or https://')
-    }
-    this.url = url
-    this.adminPassword = config.adminPassword
-    if (this.adminPassword) {
-      this.authHeader = formatAdminAuthHeader(this.adminPassword)
-    }
-
-    this.addReposUrl = new URL('/repos/add', this.url)
-    this.removeReposUrl = new URL('/repos/remove', this.url)
-  }
-
-  private getHeaders(): Record<string, string> {
-    const headers: Record<string, string> = {
-      'Content-Type': 'application/json',
-    }
-    if (this.authHeader) {
-      headers['Authorization'] = this.authHeader
-    }
-    return headers
-  }
-
-  channel(handler: TapHandler, opts?: TapWebsocketOptions): TapChannel {
-    const url = new URL(this.url)
-    url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:'
-    url.pathname = '/channel'
-    return new TapChannel(url.toString(), handler, {
-      adminPassword: this.adminPassword,
-      ...opts,
-    })
-  }
-
-  async addRepos(dids: string[]): Promise<void> {
-    const response = await fetch(this.addReposUrl, {
-      method: 'POST',
-      headers: this.getHeaders(),
-      body: JSON.stringify({ dids }),
-    })
-    await response.body?.cancel() // expect empty body
-
-    if (!response.ok) {
-      throw new Error(`Failed to add repos: ${response.statusText}`)
-    }
-  }
-
-  async removeRepos(dids: string[]): Promise<void> {
-    const response = await fetch(this.removeReposUrl, {
-      method: 'POST',
-      headers: this.getHeaders(),
-      body: JSON.stringify({ dids }),
-    })
-    await response.body?.cancel() // expect empty body
-
-    if (!response.ok) {
-      throw new Error(`Failed to remove repos: ${response.statusText}`)
-    }
-  }
-
-  async resolveDid(did: string): Promise<DidDocument | null> {
-    const response = await fetch(new URL(`/resolve/${did}`, this.url), {
-      method: 'GET',
-      headers: this.getHeaders(),
-    })
-
-    if (response.status === 404) {
-      return null
-    } else if (!response.ok) {
-      await response.body?.cancel()
-      throw new Error(`Failed to resolve DID: ${response.statusText}`)
-    }
-    return didDocument.parse(await response.json())
-  }
-
-  async getRepoInfo(did: string): Promise<RepoInfo> {
-    const response = await fetch(new URL(`/info/${did}`, this.url), {
-      method: 'GET',
-      headers: this.getHeaders(),
-    })
-
-    if (!response.ok) {
-      await response.body?.cancel()
-      throw new Error(`Failed to get repo info: ${response.statusText}`)
-    }
-
-    return repoInfoSchema.parse(await response.json())
-  }
-}

package/src/index.ts

@@ -1,6 +0,0 @@
-export * from './types.js'
-export * from './client.js'
-export * from './channel.js'
-export * from './simple-indexer.js'
-export * from './lex-indexer.js'
-export * from './util.js'

package/src/lex-indexer.ts

@@ -1,193 +0,0 @@
-import { Infer, Main, RecordSchema, getMain } from '@atproto/lex'
-import { AtUriString, NsidString } from '@atproto/syntax'
-import { HandlerOpts, TapHandler } from './channel.js'
-import { IdentityEvent, RecordEvent, TapEvent } from './types.js'
-
-type BaseRecordEvent = Omit<RecordEvent, 'record' | 'action' | 'cid'>
-
-export type CreateEvent<R> = BaseRecordEvent & {
-  action: 'create'
-  record: R
-  cid: string
-}
-
-export type UpdateEvent<R> = BaseRecordEvent & {
-  action: 'update'
-  record: R
-  cid: string
-}
-
-export type PutEvent<R> = CreateEvent<R> | UpdateEvent<R>
-
-export type DeleteEvent = BaseRecordEvent & {
-  action: 'delete'
-}
-
-export type CreateHandler<R> = (
-  evt: CreateEvent<R>,
-  opts: HandlerOpts,
-) => Promise<void>
-
-export type UpdateHandler<R> = (
-  evt: UpdateEvent<R>,
-  opts: HandlerOpts,
-) => Promise<void>
-
-export type PutHandler<R> = (
-  evt: PutEvent<R>,
-  opts: HandlerOpts,
-) => Promise<void>
-
-export type DeleteHandler = (
-  evt: DeleteEvent,
-  opts: HandlerOpts,
-) => Promise<void>
-
-export type UntypedHandler = (
-  evt: RecordEvent,
-  opts: HandlerOpts,
-) => Promise<void>
-
-export type IdentityHandler = (
-  evt: IdentityEvent,
-  opts: HandlerOpts,
-) => Promise<void>
-
-export type ErrorHandler = (err: Error) => void
-
-export type RecordHandler<R> =
-  | CreateHandler<R>
-  | UpdateHandler<R>
-  | PutHandler<R>
-  | DeleteHandler
-
-interface RegisteredHandler {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  handler: RecordHandler<any>
-  schema: RecordSchema
-}
-
-export class LexIndexer implements TapHandler {
-  private handlers = new Map<string, RegisteredHandler>()
-  private otherHandler: UntypedHandler | undefined
-  private identityHandler: IdentityHandler | undefined
-  private errorHandler: ErrorHandler | undefined
-
-  private handlerKey(
-    collection: NsidString,
-    action: RecordEvent['action'],
-  ): string {
-    return `${collection}:${action}`
-  }
-
-  private register<const T extends RecordSchema>(
-    action: RecordEvent['action'],
-    ns: Main<T>,
-    handler: RecordHandler<Infer<T>>,
-  ): this {
-    const schema = getMain(ns)
-    const key = this.handlerKey(schema.$type, action)
-    if (this.handlers.has(key)) {
-      throw new Error(`Handler already registered for ${key}`)
-    }
-    this.handlers.set(key, { schema, handler })
-    return this
-  }
-
-  create<const T extends RecordSchema>(
-    ns: Main<T>,
-    handler: CreateHandler<Infer<T>>,
-  ): this {
-    return this.register('create', ns, handler)
-  }
-
-  update<const T extends RecordSchema>(
-    ns: Main<T>,
-    handler: UpdateHandler<Infer<T>>,
-  ): this {
-    return this.register('update', ns, handler)
-  }
-
-  delete<const T extends RecordSchema>(
-    ns: Main<T>,
-    handler: DeleteHandler,
-  ): this {
-    return this.register('delete', ns, handler)
-  }
-
-  put<const T extends RecordSchema>(
-    ns: Main<T>,
-    handler: PutHandler<Infer<T>>,
-  ): this {
-    this.register('create', ns, handler)
-    this.register('update', ns, handler)
-    return this
-  }
-
-  other(fn: UntypedHandler): this {
-    if (this.otherHandler) {
-      throw new Error(`Handler already registered for "other"`)
-    }
-    this.otherHandler = fn
-    return this
-  }
-
-  identity(fn: IdentityHandler): this {
-    if (this.identityHandler) {
-      throw new Error(`Handler already registered for "identity"`)
-    }
-    this.identityHandler = fn
-    return this
-  }
-
-  error(fn: ErrorHandler): this {
-    if (this.errorHandler) {
-      throw new Error(`Handler already registered for "error"`)
-    }
-    this.errorHandler = fn
-    return this
-  }
-
-  async onEvent(evt: TapEvent, opts: HandlerOpts): Promise<void> {
-    if (evt.type === 'identity') {
-      await this.identityHandler?.(evt, opts)
-    } else {
-      await this.handleRecordEvent(evt, opts)
-    }
-    await opts.ack()
-  }
-
-  private async handleRecordEvent(
-    evt: RecordEvent,
-    opts: HandlerOpts,
-  ): Promise<void> {
-    const { collection, action } = evt
-    const key = this.handlerKey(collection, action)
-    const registered = this.handlers.get(key)
-
-    if (!registered) {
-      await this.otherHandler?.(evt, opts)
-      return
-    }
-
-    if (action === 'create' || action === 'update') {
-      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,
-        })
-      }
-    }
-
-    await (registered.handler as UntypedHandler)(evt, opts)
-  }
-
-  onError(err: Error): void {
-    if (this.errorHandler) {
-      this.errorHandler(err)
-    } else {
-      throw err
-    }
-  }
-}

package/src/simple-indexer.ts

@@ -1,52 +0,0 @@
-import { HandlerOpts, TapHandler } from './channel.js'
-import { IdentityEvent, RecordEvent, TapEvent } from './types.js'
-
-type IdentityEventHandler = (
-  evt: IdentityEvent,
-  opts?: HandlerOpts,
-) => Promise<void>
-
-type RecordEventHandler = (
-  evt: RecordEvent,
-  opts?: HandlerOpts,
-) => Promise<void>
-
-type ErrorHandler = (err: Error) => void
-
-export class SimpleIndexer implements TapHandler {
-  private identityHandler: IdentityEventHandler | undefined
-  private recordHandler: RecordEventHandler | undefined
-  private errorHandler: ErrorHandler | undefined
-
-  identity(fn: IdentityEventHandler): this {
-    this.identityHandler = fn
-    return this
-  }
-
-  record(fn: RecordEventHandler): this {
-    this.recordHandler = fn
-    return this
-  }
-
-  error(fn: ErrorHandler): this {
-    this.errorHandler = fn
-    return this
-  }
-
-  async onEvent(evt: TapEvent, opts: HandlerOpts): Promise<void> {
-    if (evt.type === 'record') {
-      await this.recordHandler?.(evt, opts)
-    } else {
-      await this.identityHandler?.(evt, opts)
-    }
-    await opts.ack()
-  }
-
-  onError(err: Error) {
-    if (this.errorHandler) {
-      this.errorHandler(err)
-    } else {
-      throw err
-    }
-  }
-}

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>