@atproto/ws-client 0.1.3 → 0.1.4

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @atproto/ws-client
 
+## 0.1.4
+
+### 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 [[`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/common@0.6.5
+
 ## 0.1.3
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/ws-client",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "license": "MIT",
   "description": "Websocket client library",
   "keywords": [
@@ -13,12 +13,24 @@
     "url": "https://github.com/bluesky-social/atproto",
     "directory": "packages/ws-client"
   },
+  "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/common": "^0.6.5"
   },
   "devDependencies": {
     "@types/ws": "^8.5.4",
@@ -26,13 +38,6 @@
     "http-terminator": "^3.2.0",
     "jest": "^30.0.0"
   },
-  "type": "module",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    }
-  },
   "scripts": {
     "test": "NODE_OPTIONS=--experimental-vm-modules jest",
     "build": "tsgo --build tsconfig.build.json"

package/jest.config.cjs

@@ -1,21 +0,0 @@
-/** @type {import('jest').Config} */
-module.exports = {
-  displayName: 'WebSocket Client',
-  transform: {
-    '^.+\\.(t|j)s$': [
-      '@swc/jest',
-      {
-        jsc: {
-          parser: { syntax: 'typescript', importAttributes: true },
-          experimental: { keepImportAttributes: true },
-          transform: {},
-        },
-        module: { type: 'es6' },
-      },
-    ],
-  },
-  extensionsToTreatAsEsm: ['.ts'],
-  transformIgnorePatterns: [],
-  setupFiles: ['<rootDir>/../../test.setup.ts'],
-  moduleNameMapper: { '^(\\.\\.?\\/.+)\\.js$': ['$1.ts', '$1.js'] },
-}

package/src/index.ts

@@ -1,199 +0,0 @@
-import type { ClientOptions } from 'ws'
-import { WebSocket, createWebSocketStream } from 'ws'
-import { SECOND, isErrnoException, wait } from '@atproto/common'
-
-export class WebSocketKeepAlive {
-  public ws: WebSocket | null = null
-  public initialSetup = true
-  public reconnects: number | null = null
-
-  constructor(
-    public opts: ClientOptions & {
-      getUrl: () => Promise<string>
-      maxReconnectSeconds?: number
-      signal?: AbortSignal
-      heartbeatIntervalMs?: number
-      onReconnect?: () => void
-      onReconnectError?: (
-        error: unknown,
-        n: number,
-        initialSetup: boolean,
-      ) => void
-    },
-  ) {}
-
-  async *[Symbol.asyncIterator](): AsyncGenerator<Uint8Array> {
-    const maxReconnectMs = 1000 * (this.opts.maxReconnectSeconds ?? 64)
-    while (true) {
-      if (this.reconnects !== null) {
-        const duration = this.initialSetup
-          ? Math.min(1000, maxReconnectMs)
-          : backoffMs(this.reconnects++, maxReconnectMs)
-        await wait(duration)
-      }
-      const url = await this.opts.getUrl()
-      this.ws = new WebSocket(url, this.opts)
-      const ac = new AbortController()
-      if (this.opts.signal) {
-        forwardSignal(this.opts.signal, ac)
-      }
-      this.ws.once('open', () => {
-        if (!this.initialSetup && this.opts.onReconnect) {
-          this.opts.onReconnect()
-        }
-        this.initialSetup = false
-        this.reconnects = 0
-        if (this.ws) {
-          this.startHeartbeat(this.ws)
-        }
-      })
-      this.ws.once('close', (code, reason) => {
-        if (code === CloseCode.Abnormal) {
-          // Forward into an error to distinguish from a clean close
-          ac.abort(
-            new AbnormalCloseError(`Abnormal ws close: ${reason.toString()}`),
-          )
-        }
-      })
-
-      try {
-        const wsStream = createWebSocketStream(this.ws, {
-          signal: ac.signal,
-          readableObjectMode: true, // Ensures frame bytes don't get buffered/combined together
-        })
-        for await (const chunk of wsStream) {
-          yield chunk
-        }
-      } catch (_err) {
-        const err =
-          isErrnoException(_err) && _err.code === 'ABORT_ERR'
-            ? _err.cause
-            : _err
-        if (err instanceof DisconnectError) {
-          // We cleanly end the connection
-          this.ws?.close(err.wsCode)
-          break
-        }
-        this.ws?.close() // No-ops if already closed or closing
-        if (isReconnectable(err)) {
-          this.reconnects ??= 0 // Never reconnect with a null
-          this.opts.onReconnectError?.(err, this.reconnects, this.initialSetup)
-          continue
-        } else {
-          throw err
-        }
-      }
-      break // Other side cleanly ended stream and disconnected
-    }
-  }
-
-  send(data: string | Buffer): Promise<void> {
-    return new Promise((resolve, reject) => {
-      if (!this.ws || this.ws.readyState !== 1 /* OPEN */) {
-        reject(new Error('WebSocket is not connected'))
-        return
-      }
-      this.ws.send(data, (err) => {
-        if (err) {
-          reject(err)
-        } else {
-          resolve()
-        }
-      })
-    })
-  }
-
-  isConnected(): boolean {
-    return this.ws !== null && this.ws.readyState === 1
-  }
-
-  startHeartbeat(ws: WebSocket) {
-    let isAlive = true
-    let heartbeatInterval: NodeJS.Timeout | null = null
-
-    const checkAlive = () => {
-      if (!isAlive) {
-        return ws.terminate()
-      }
-      isAlive = false // expect websocket to no longer be alive unless we receive a "pong" within the interval
-      ws.ping()
-    }
-
-    checkAlive()
-    heartbeatInterval = setInterval(
-      checkAlive,
-      this.opts.heartbeatIntervalMs ?? 10 * SECOND,
-    )
-
-    ws.on('pong', () => {
-      isAlive = true
-    })
-    ws.once('close', () => {
-      if (heartbeatInterval) {
-        clearInterval(heartbeatInterval)
-        heartbeatInterval = null
-      }
-    })
-  }
-}
-
-export default WebSocketKeepAlive
-
-class AbnormalCloseError extends Error {
-  code = 'EWSABNORMALCLOSE'
-}
-
-export class DisconnectError extends Error {
-  constructor(
-    public wsCode: CloseCode = CloseCode.Policy,
-    public xrpcCode?: string,
-  ) {
-    super()
-  }
-}
-
-// https://www.rfc-editor.org/rfc/rfc6455#section-7.4.1
-export enum CloseCode {
-  Normal = 1000,
-  Abnormal = 1006,
-  Policy = 1008,
-}
-
-function isReconnectable(err: unknown): boolean {
-  // Network errors are reconnectable.
-  // AuthenticationRequired and InvalidRequest XRPCErrors are not reconnectable.
-  // @TODO method-specific XRPCErrors may be reconnectable, need to consider. Receiving
-  // an invalid message is not current reconnectable, but the user can decide to skip them.
-  if (isErrnoException(err) && typeof err.code === 'string') {
-    return networkErrorCodes.includes(err.code)
-  }
-  return false
-}
-
-const networkErrorCodes = [
-  'EWSABNORMALCLOSE',
-  'ECONNRESET',
-  'ECONNREFUSED',
-  'ECONNABORTED',
-  'EPIPE',
-  'ETIMEDOUT',
-  'ECANCELED',
-]
-
-function backoffMs(n: number, maxMs: number) {
-  const baseSec = Math.pow(2, n) // 1, 2, 4, ...
-  const randSec = Math.random() - 0.5 // Random jitter between -.5 and .5 seconds
-  const ms = 1000 * (baseSec + randSec)
-  return Math.min(ms, maxMs)
-}
-
-function forwardSignal(signal: AbortSignal, ac: AbortController) {
-  if (signal.aborted) {
-    return ac.abort(signal.reason)
-  } else {
-    signal.addEventListener('abort', () => ac.abort(signal.reason), {
-      // @ts-ignore https://github.com/DefinitelyTyped/DefinitelyTyped/pull/68625
-      signal: ac.signal,
-    })
-  }
-}

package/tests/keepalive.test.ts

@@ -1,62 +0,0 @@
-import { once } from 'node:events'
-import { createServer } from 'node:http'
-import { AddressInfo } from 'node:net'
-// eslint-disable-next-line import/default
-import httpTerminator from 'http-terminator'
-import { WebSocketServer } from 'ws'
-import { wait } from '@atproto/common'
-import { CloseCode, WebSocketKeepAlive } from '../src/index.js'
-
-describe('WebSocketKeepAlive', () => {
-  it('uses a heartbeat to reconnect if a connection is dropped', async () => {
-    // we run a server that, on first connection, pauses for longer than the heartbeat interval (doesn't return "pong"s)
-    // on second connection, it sends a message and then closes
-
-    const server = createServer()
-
-    // make sure to always close the server (even in case of test failure)
-    const { terminate } = httpTerminator.createHttpTerminator({ server })
-    await using _ = { [Symbol.asyncDispose]: async () => terminate() }
-
-    const wsServer = new WebSocketServer({ server })
-    let firstConnection = true
-    let firstWasClosed = false
-    wsServer.on('connection', async (socket) => {
-      if (firstConnection === true) {
-        firstConnection = false
-        socket.pause()
-        await wait(600)
-        // shouldn't send this message because the socket would be closed
-        socket.send(Buffer.from('error message'), (err) => {
-          if (err) throw err
-          socket.close(CloseCode.Normal)
-        })
-        socket.on('close', () => {
-          firstWasClosed = true
-        })
-      } else {
-        socket.send(Buffer.from('test message'), (err) => {
-          if (err) throw err
-          socket.close(CloseCode.Normal)
-        })
-      }
-    })
-
-    await once(server.listen(0), 'listening')
-    const port = (server.address() as AddressInfo).port
-
-    const wsKeepAlive = new WebSocketKeepAlive({
-      getUrl: async () => `ws://localhost:${port}`,
-      heartbeatIntervalMs: 500,
-    })
-
-    const messages: Uint8Array[] = []
-    for await (const msg of wsKeepAlive) {
-      messages.push(msg)
-    }
-
-    expect(messages).toHaveLength(1)
-    expect(Buffer.from(messages[0]).toString()).toBe('test message')
-    expect(firstWasClosed).toBe(true)
-  })
-})

package/tsconfig.build.json

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

package/tsconfig.build.tsbuildinfo

@@ -1 +0,0 @@
-{"version":"7.0.0-dev.20260614.1","root":["./src/index.ts"]}

package/tsconfig.json

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

package/tsconfig.tests.json

@@ -1,7 +0,0 @@
-{
-  "extends": "../../tsconfig/tests.json",
-  "compilerOptions": {
-    "rootDir": ".",
-  },
-  "include": ["./tests"],
-}