@reddb-io/client-bun 1.26.4 → 1.26.6

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @reddb-io/client-bun
 
+## 1.26.6
+
+## 1.26.5
+
+### Patch Changes
+
+- [#2478](https://github.com/reddb-io/reddb/pull/2478) [`5d41cee`](https://github.com/reddb-io/reddb/commit/5d41cee8f0d73e40e2620ef62c075b13073fd056) Thanks [@filipeforattini](https://github.com/filipeforattini)! - Accumulate fragmented RedWire input without repeated buffer concatenation and
+  copy completed payloads directly into owned result buffers. Release consumed
+  receive storage and reject pending/future queries on terminal framing, socket or
+  connection-close failures, while preserving per-query engine error recovery.
+
 ## 1.26.4
 
 ## 1.26.3

package/README.md

@@ -28,6 +28,27 @@ Run the shared SDK smoke test and this package's actual TCP-client regression:
 REDDB_BINARY_PATH=/absolute/path/to/red bun run test
 ```
 
+The receive path queues fragments and copies each completed payload into an owned
+buffer. A terminal framing/socket failure or connection close rejects pending and
+future queries. A server query error rejects its own query while the connection
+remains usable. The existing 16 MiB frame limit and query return shapes apply.
+
+From this directory in a repository checkout, compare receive processing against
+a baseline checkout using the installed Bun runtime:
+
+```sh
+REDDB_BENCH_BASELINE=/path/to/baseline REDDB_BENCH_OUTPUT=bun-receive.json \
+  bun run bench-receive.ts
+bun ../js-client/bench/summarize.mjs bun-receive.json
+```
+
+The benchmark alternates 20 paired samples of at least 20 ms. Scripted sockets
+exercise production query encoding, receive parsing, UTF-8 and Promise delivery.
+Input construction and exact response comparisons are outside timing. Separate
+copy probes count top-level Buffer operations without double counting. Network,
+database execution, the unchanged TCP callback ownership copy and total process
+memory are outside these measurements. Timings never gate CI.
+
 <!-- contract-matrix:begin -->
 ## Public-surface support
 

package/index.ts

@@ -64,7 +64,13 @@ export class RedDBError extends Error {
 export class RedDBConnection {
   private socket: ReturnType<typeof Bun.connect> extends Promise<infer T> ? T : never
   private pending: PendingRequest[] = []
-  private buffer = Buffer.alloc(0)
+  private chunks: (Buffer | null)[] = []
+  private chunkIndex = 0
+  private chunkOffset = 0
+  private bufferedBytes = 0
+  private frameLength = 0
+  private frameType = 0
+  private failure: Error | null = null
   private nextCorr = 1n
   private serverFeatures = 0
 
@@ -73,39 +79,111 @@ export class RedDBConnection {
   }
 
   _onData(chunk: Buffer) {
-    this.buffer = Buffer.concat([this.buffer, chunk])
+    if (this.failure || chunk.length === 0) return
+    this.chunks.push(chunk)
+    this.bufferedBytes += chunk.length
     this._tryResolve()
   }
 
+  _onClose() {
+    this._fail(new RedDBError('CONNECTION_CLOSED', 'redwire: connection closed'))
+  }
+
+  _onError(error: Error) {
+    this._fail(error)
+  }
+
   private _tryResolve() {
-    while (this.buffer.length >= FRAME_HEADER_SIZE && this.pending.length > 0) {
-      const totalLen = this.buffer.readUInt32LE(0)
-      if (totalLen < FRAME_HEADER_SIZE || totalLen > MAX_FRAME_SIZE) {
-        const { reject } = this.pending.shift()!
-        reject(new RedDBError('FRAME_INVALID_LENGTH', `length=${totalLen}`))
+    while (this.bufferedBytes >= FRAME_HEADER_SIZE && this.pending.length > 0) {
+      let payload: Buffer
+      let msgType: number
+      try {
+        if (this.frameLength === 0) this._readHeader()
+        if (this.bufferedBytes < this.frameLength) break
+        msgType = this.frameType
+        this._consume(FRAME_HEADER_SIZE)
+        payload = Buffer.allocUnsafe(this.frameLength - FRAME_HEADER_SIZE)
+        this._consume(payload.length, payload)
+        this.frameLength = 0
+      } catch (error) {
+        this._fail(error as Error)
         return
       }
-      if (this.buffer.length < totalLen) break
-
-      const msgType = this.buffer[4]
-      const payload = this.buffer.subarray(FRAME_HEADER_SIZE, totalLen)
-      this.buffer = this.buffer.subarray(totalLen)
-
       const { resolve, reject } = this.pending.shift()!
       if (msgType === MSG_ERROR || msgType === MSG_AUTH_FAIL) {
         reject(new RedDBError('ENGINE', payload.toString('utf8')))
       } else {
-        resolve({ type: msgType, payload: Buffer.from(payload) })
+        resolve({ type: msgType, payload })
       }
     }
   }
 
+  private _readHeader() {
+    const first = this.chunks[this.chunkIndex]!
+    let header = first
+    let offset = this.chunkOffset
+    if (first.length - offset < 5) {
+      // Only length and kind are needed; the rest of the 16-byte header is discarded later.
+      header = Buffer.allocUnsafe(5)
+      let written = 0
+      for (let index = this.chunkIndex; written < header.length; index++) {
+        const chunk = this.chunks[index]!
+        const start = index === this.chunkIndex ? this.chunkOffset : 0
+        const count = Math.min(header.length - written, chunk.length - start)
+        written += chunk.copy(header, written, start, start + count)
+      }
+      offset = 0
+    }
+    const length = header.readUInt32LE(offset)
+    if (length < FRAME_HEADER_SIZE || length > MAX_FRAME_SIZE) {
+      throw new RedDBError('FRAME_INVALID_LENGTH', `length=${length}`)
+    }
+    this.frameLength = length
+    this.frameType = header[offset + 4]
+  }
+
+  private _consume(length: number, output?: Buffer) {
+    if (length === 0) return
+    let written = 0
+    while (written < length) {
+      const chunk = this.chunks[this.chunkIndex]!
+      const count = Math.min(length - written, chunk.length - this.chunkOffset)
+      if (output) chunk.copy(output, written, this.chunkOffset, this.chunkOffset + count)
+      written += count
+      this.chunkOffset += count
+      if (this.chunkOffset === chunk.length) {
+        this.chunks[this.chunkIndex++] = null
+        this.chunkOffset = 0
+      }
+    }
+    this.bufferedBytes -= length
+    if (this.chunkIndex * 2 >= this.chunks.length) {
+      this.chunks = this.chunks.slice(this.chunkIndex)
+      this.chunkIndex = 0
+    }
+  }
+
+  private _fail(error: Error) {
+    if (this.failure) return
+    this.failure = error
+    this.chunks = []
+    this.chunkIndex = 0
+    this.chunkOffset = 0
+    this.bufferedBytes = 0
+    this.frameLength = 0
+    while (this.pending.length > 0) this.pending.shift()!.reject(error)
+    try { this.socket.end() } catch { /* The peer may already have closed the socket. */ }
+  }
+
   private _send(msgType: number, payload: Buffer): Promise<{ type: number; payload: Buffer }> {
+    if (this.failure) return Promise.reject(this.failure)
     return new Promise((resolve, reject) => {
-      this.pending.push({ resolve, reject })
       const corr = this.nextCorr
       this.nextCorr += 1n
-      this.socket.write(encodeFrame(msgType, corr, payload))
+      const request = encodeFrame(msgType, corr, payload)
+      this.pending.push({ resolve, reject })
+      try { this.socket.write(request) }
+      catch (error) { this._fail(error as Error) }
     })
   }
 
@@ -200,11 +278,12 @@ export class RedDBConnection {
   }
 
   close() {
+    if (this.failure) return
     try {
       this.socket.write(encodeFrame(MSG_BYE, this.nextCorr, Buffer.alloc(0)))
       this.nextCorr += 1n
     } finally {
-      this.socket.end()
+      this._onClose()
     }
   }
 }
@@ -232,6 +311,12 @@ async function connectWithOptions(addr: string, tls?: { ca?: string; rejectUnaut
   const [host, portStr] = addr.split(':')
   const port = parseInt(portStr, 10)
   let connRef: RedDBConnection | null = null
+  let earlyFailure: Error | null = null
+  const fail = (error: Error) => {
+    if (connRef) connRef._onError(error)
+    else earlyFailure ??= error
+  }
+  const closed = () => fail(new RedDBError('CONNECTION_CLOSED', 'redwire: connection closed'))
 
   const socket = await Bun.connect({
     hostname: host,
@@ -242,15 +327,18 @@ async function connectWithOptions(addr: string, tls?: { ca?: string; rejectUnaut
         connRef?._onData(Buffer.from(data))
       },
       error(_socket, error) {
-        console.error('RedDB wire error:', error)
+        fail(error)
       },
-      close() {},
+      close: closed,
+      end: closed,
       open() {},
     },
   })
 
   connRef = new RedDBConnection(socket)
-  await connRef._handshake()
+  if (earlyFailure) connRef._onError(earlyFailure)
+  try { await connRef._handshake() }
+  catch (error) { connRef._onError(error as Error); throw error }
   return connRef
 }
 

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "@reddb-io/client-bun",
-  "version": "1.26.4",
+  "version": "1.26.6",
   "description": "RedDB wire protocol client for Bun — ultra-fast native TCP",
   "main": "index.ts",
+  "files": [
+    "index.ts",
+    "README.md",
+    "CHANGELOG.md"
+  ],
   "license": "MIT",
   "keywords": [
     "reddb",
@@ -12,6 +17,6 @@
     "wire-protocol"
   ],
   "scripts": {
-    "test": "bun run params.test.ts && bun run wire-legacy.test.ts && bun run wire.test.ts"
+    "test": "bun test frame-reader.test.ts socket-close.test.ts && bun run params.test.ts && bun run wire-legacy.test.ts && bun run wire.test.ts"
   }
 }

package/bench.ts

@@ -1,66 +0,0 @@
-#!/usr/bin/env bun
-/**
- * RedDB Bun Wire Protocol Benchmark
- * Usage: bun run bench.ts [host:port]
- */
-import { connect } from './index'
-
-const ADDR = process.argv[2] || '127.0.0.1:5050'
-const N = 5000
-const POINT_LOOKUPS = 200
-const RANGE_QUERIES = 50
-const FILTER_QUERIES = 50
-
-function rng(seed: number) {
-  let s = seed
-  return () => { s = (s * 1103515245 + 12345) & 0x7fffffff; return s }
-}
-
-const rand = rng(42)
-const conn = await connect(ADDR)
-console.log(`Connected to ${ADDR}`)
-
-// Insert
-const records: string[] = []
-const cities = ['NYC', 'London', 'Tokyo', 'Paris', 'Berlin']
-for (let i = 0; i < N; i++) {
-  records.push(JSON.stringify({
-    fields: { id: i + 1, name: `User_${i}`, age: 18 + (rand() % 63), city: cities[rand() % 5], score: (rand() % 10000) / 100 }
-  }))
-}
-
-let t0 = performance.now()
-const count = await conn.bulkInsert('users', records)
-let ms = performance.now() - t0
-console.log(`  insert_bulk:     ${(N / ms * 1000).toFixed(0).padStart(8)} ops/sec (${ms.toFixed(0)}ms) [${count} rows]`)
-
-// Point lookups
-const lids = Array.from({ length: POINT_LOOKUPS }, () => 1 + (rand() % N))
-t0 = performance.now()
-for (const rid of lids) {
-  await conn.queryRaw(`SELECT * FROM users WHERE _entity_id = ${rid}`)
-}
-ms = performance.now() - t0
-console.log(`  select_point:    ${(POINT_LOOKUPS / ms * 1000).toFixed(0).padStart(8)} ops/sec (${ms.toFixed(0)}ms)`)
-
-// Range queries
-const rqs = Array.from({ length: RANGE_QUERIES }, () => {
-  const l = 18 + (rand() % 53); return [l, l + 10] as const
-})
-t0 = performance.now()
-for (const [l, h] of rqs) {
-  await conn.queryRaw(`SELECT * FROM users WHERE age BETWEEN ${l} AND ${h}`)
-}
-ms = performance.now() - t0
-console.log(`  select_range:    ${(RANGE_QUERIES / ms * 1000).toFixed(0).padStart(8)} ops/sec (${ms.toFixed(0)}ms)`)
-
-// Filtered queries
-const fqs = Array.from({ length: FILTER_QUERIES }, () => [cities[rand() % 5], 18 + (rand() % 43)] as const)
-t0 = performance.now()
-for (const [c, a] of fqs) {
-  await conn.queryRaw(`SELECT * FROM users WHERE city = '${c}' AND age > ${a}`)
-}
-ms = performance.now() - t0
-console.log(`  select_filtered: ${(FILTER_QUERIES / ms * 1000).toFixed(0).padStart(8)} ops/sec (${ms.toFixed(0)}ms)`)
-
-conn.close()

package/params.test.ts

@@ -1,73 +0,0 @@
-import { existsSync } from 'node:fs'
-import { dirname, resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-import { connect } from '../js/src/index.js'
-
-const HERE = dirname(fileURLToPath(import.meta.url))
-const DEFAULT_BINARY = resolve(HERE, '..', '..', 'target', 'debug', 'red')
-const BINARY = process.env.REDDB_BINARY_PATH || DEFAULT_BINARY
-
-function assert(condition: unknown, message: string): asserts condition {
-  if (!condition) throw new Error(message)
-}
-
-function assertEqual<T>(actual: T, expected: T, message: string) {
-  if (actual !== expected) {
-    throw new Error(
-      `${message}: expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`,
-    )
-  }
-}
-
-if (!existsSync(BINARY)) {
-  console.log(`SKIP: binary not found at ${BINARY}`)
-  process.exit(0)
-}
-
-const db = await connect('memory://', { binary: BINARY })
-try {
-  await db.query('CREATE TABLE bun_params (id INTEGER, name TEXT)')
-  await db.query('INSERT INTO bun_params (id, name) VALUES ($1, $2)', [1, 'Bun'])
-  await db.query('INSERT INTO bun_params (id, name) VALUES ($1, $2)', [2, 'Node'])
-
-  const selected = await db.query(
-    'SELECT * FROM bun_params WHERE id = $1 AND name = $2',
-    [1, 'Bun'],
-  )
-  assert(Array.isArray(selected.rows), 'SELECT rows should be an array')
-  assertEqual(selected.rows.length, 1, 'SELECT should match one row')
-  assertEqual(selected.rows[0].name, 'Bun', 'SELECT should bind text and int params')
-
-  await db.query(
-    'INSERT INTO bun_embeddings VECTOR (dense, content) VALUES ($1, $2)',
-    [new Float32Array([1.0, 0.0]), 'bun vector'],
-  )
-  await db.query(
-    'INSERT INTO bun_embeddings VECTOR (dense, content) VALUES ($1, $2)',
-    [new Float32Array([0.0, 1.0]), 'other vector'],
-  )
-
-  const similar = await db.query(
-    'SEARCH SIMILAR $1 COLLECTION bun_embeddings LIMIT 1',
-    [new Float32Array([1.0, 0.0])],
-  )
-  assert(Array.isArray(similar.rows), 'SEARCH rows should be an array')
-  assertEqual(similar.rows.length, 1, 'SEARCH should match one vector row')
-  assertEqual(similar.rows[0].score, 1, 'SEARCH should bind Float32Array vector')
-
-  const fractional = new Float32Array([0.8, 0.6])
-  await db.query('INSERT INTO fractional_vectors VECTOR (dense, content) VALUES ($1, $2)',
-    [fractional, 'fractional embedding'])
-  const fractionalMatch = await db.query('SEARCH SIMILAR $1 COLLECTION fractional_vectors LIMIT 1',
-    [fractional])
-  assertEqual(fractionalMatch.rows.length, 1, 'fractional vector should remain searchable')
-  assert(Math.abs(fractionalMatch.rows[0].score - 1) < 1e-6, 'identical fractional vectors should match')
-  const axisMatch = await db.query('SEARCH SIMILAR $1 COLLECTION fractional_vectors LIMIT 1',
-    [new Float32Array([1, 0])])
-  assert(Math.abs(axisMatch.rows[0].score - 0.8) < 1e-6, 'fractional coordinates survive binding')
-} finally {
-  await db.close()
-}
-
-console.log('ok shared SDK parameterized queries run under Bun')

package/wire-legacy.test.ts

@@ -1,66 +0,0 @@
-import { strict as assert } from 'node:assert'
-import { createServer } from 'node:net'
-import { connect, RedDBError } from './index'
-
-// The old protocol is intentionally summary-only. A small protocol peer lets
-// us exercise capability negotiation without installing an obsolete engine.
-const queries: number[] = []
-const server = createServer((socket) => {
-  socket.setTimeout(5_000, () => socket.destroy())
-  let input = Buffer.alloc(0)
-  let magicReceived = false
-  socket.on('data', (chunk) => {
-    input = Buffer.concat([input, chunk])
-    if (!magicReceived) {
-      if (input.length < 2) return
-      assert.deepEqual([...input.subarray(0, 2)], [0xfe, 1])
-      input = input.subarray(2)
-      magicReceived = true
-    }
-    while (input.length >= 16) {
-      const length = input.readUInt32LE(0)
-      assert(length >= 16 && length <= 16 * 1024 * 1024)
-      if (input.length < length) return
-      const frame = input.subarray(0, length)
-      input = input.subarray(length)
-      const kind = frame[4]
-      if (kind === 0x16) { socket.end(); return }
-      let responseKind: number
-      let body: object
-      if (kind === 0x10) {
-        responseKind = 0x11
-        body = { auth: 'anonymous', features: 0 }
-      } else if (kind === 0x13) {
-        responseKind = 0x14
-        body = { features: 0 }
-      } else {
-        queries.push(kind)
-        responseKind = 0x02
-        body = { ok: true, affected: 0, statement: 'select' }
-      }
-      const payload = Buffer.from(JSON.stringify(body))
-      const response = Buffer.alloc(16 + payload.length)
-      response.writeUInt32LE(response.length, 0)
-      response[4] = responseKind
-      frame.copy(response, 8, 8, 16)
-      payload.copy(response, 16)
-      socket.write(response)
-    }
-  })
-})
-await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve))
-const address = server.address()
-assert(address && typeof address === 'object')
-let db: Awaited<ReturnType<typeof connect>> | undefined
-try {
-  db = await connect(`127.0.0.1:${address.port}`)
-  assert.equal(db.supportsParams(), false)
-  assert.deepEqual(await db.queryParsed('SELECT 42'), { ok: true, affected: 0, statement: 'select' })
-  await assert.rejects(db.query('SELECT $1', [42]),
-    (error) => error instanceof RedDBError && error.code === 'PARAMS_UNSUPPORTED')
-  assert.deepEqual(queries, [0x01])
-  console.log('ok Bun legacy capability fallback')
-} finally {
-  db?.close()
-  await new Promise<void>((resolve) => server.close(() => resolve()))
-}

package/wire.test.ts

@@ -1,58 +0,0 @@
-import { strict as assert } from 'node:assert'
-import { mkdtempSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join, resolve } from 'node:path'
-import { createServer } from 'node:net'
-import { connect } from './index'
-
-// Exercise this package's TCP client against a real server. An absent binary
-// is a test failure: silently skipping hid the unbound-query regression.
-const binary = process.env.REDDB_BINARY_PATH || resolve(import.meta.dir, '../../target/debug/red')
-const reservation = createServer()
-await new Promise<void>((resolve, reject) => {
-  reservation.once('error', reject)
-  reservation.listen(0, '127.0.0.1', resolve)
-})
-const address = reservation.address()
-assert(address && typeof address === 'object')
-const endpoint = `127.0.0.1:${address.port}`
-await new Promise<void>((resolve) => reservation.close(() => resolve()))
-const directory = mkdtempSync(join(tmpdir(), 'reddb-bun-wire-'))
-const server = Bun.spawn([binary, 'server', '--path', join(directory, 'db.rdb'),
-  '--bind', endpoint, '--no-auth', '--no-log-file'], { stdout: 'ignore', stderr: 'inherit' })
-let db: Awaited<ReturnType<typeof connect>> | undefined
-try {
-  const deadline = Date.now() + 30_000
-  while (Date.now() < deadline) {
-    if (server.exitCode !== null) throw new Error(`server exited ${server.exitCode}`)
-    try {
-      const response = await fetch(`http://${endpoint}/health`, { signal: AbortSignal.timeout(500) })
-      if (response.ok) break
-    } catch {}
-    await Bun.sleep(100)
-  }
-  db = await connect(endpoint)
-  assert(db.supportsParams())
-  await db.query('CREATE TABLE wire_rows (id INTEGER, name TEXT)')
-  const inserted = await db.queryParsed("INSERT INTO wire_rows (id,name) VALUES (1,'Bun')")
-  assert.equal(inserted.affected_rows, 1)
-  const unbound = await db.queryParsed('SELECT id,name FROM wire_rows')
-  const bound = await db.queryParsed('SELECT id,name FROM wire_rows WHERE id=$1', [1])
-  assert.deepEqual(unbound.result.records.map((record: any) => record.values), [{ id: 1, name: 'Bun' }])
-  assert.deepEqual(unbound.result.records.map((record: any) => record.values), bound.result.records.map((record: any) => record.values))
-  assert.deepEqual((await db.queryParsed('SELECT id,name FROM wire_rows', [])).result.records.map((record: any) => record.values), bound.result.records.map((record: any) => record.values))
-  assert.deepEqual((await db.queryParsed('SELECT id FROM wire_rows WHERE id=2')).result.records, [])
-  await assert.rejects(db.query('SELECT * FROM absent_wire_table'))
-  const cli = Bun.spawnSync([binary, 'query', '--bind', endpoint, '--json',
-    "INSERT INTO wire_rows (id,name) VALUES (2,'CLI')"])
-  assert.equal(cli.exitCode, 0, cli.stderr.toString())
-  const insertedByCli = JSON.parse(cli.stdout.toString()).data
-  assert.equal(insertedByCli.affected, 1)
-  assert.equal(insertedByCli.statement, 'insert')
-  console.log('ok Bun wire bound/unbound result contract')
-} finally {
-  db?.close()
-  server.kill()
-  await server.exited
-  rmSync(directory, { recursive: true, force: true })
-}