@pineliner/odb-client 1.5.4 → 1.5.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pineliner/odb-client",
-  "version": "1.5.4",
+  "version": "1.5.5",
   "description": "Isomorphic client for ODB-Lite with postgres.js-like template string SQL support",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",

package/src/database/adapters/odblite-socket.ts

@@ -2,6 +2,12 @@ import type { BackendType, Connection, DatabaseAdapter, PreparedStatement, Query
 import { ODBLiteAdapter } from './odblite'
 import { SocketClient, InteractiveTxConnectionLostError, type SocketTarget } from './socket/client'
 import { runInTransactionContext, ambientTx } from './tx-context'
+
+// An ambient-tx JOIN whose target transaction already committed/reaped surfaces as "stream not open" — the
+// write is now inherently standalone, so query/execute fall back to autocommit. Matches the server wording.
+function isStreamClosed(e: any): boolean {
+  return /stream .*(not open|already ended|never opened)/i.test(String(e?.message ?? ''))
+}
 import {
   toHrana,
   fromHrana,
@@ -115,7 +121,13 @@ class OdbliteSocketConnection implements Connection {
     const p = typeof sql === 'string' ? params : (sql.args ?? [])
     if (this.streamId != null) return (await this.streamExec(s, p)) as QueryResult<T>
     const amb = ambientTx(this.tenant) // autocommit conn, but inside a tx for my tenant? → join it (see execute)
-    if (amb && amb !== this) return amb.query<T>(s, p)
+    if (amb && amb !== this) {
+      try {
+        return await amb.query<T>(s, p)
+      } catch (e: any) {
+        if (!isStreamClosed(e)) throw e // tx we tried to join already closed → run standalone (autocommit) below
+      }
+    }
     return toQueryResult(await this.one([{ type: 'execute', stmt: { sql: s, args: p.map(toHrana) } }])) as QueryResult<T>
   }
 
@@ -130,7 +142,19 @@ class OdbliteSocketConnection implements Connection {
     // fresh autocommit write that would deadlock behind the tx on the writer slot. Same tenant key on both
     // sides (this.tenant), so no auth/database-hash translation for a caller to get wrong.
     const amb = ambientTx(this.tenant)
-    if (amb && amb !== this) return amb.execute(s, p)
+    if (amb && amb !== this) {
+      try {
+        return await amb.execute(s, p)
+      } catch (e: any) {
+        // GENERIC ROBUSTNESS: the ambient tx we tried to JOIN has already committed/reaped, so its stream is
+        // gone ("stream not open"). The write is inherently post-commit now — fall back to a fresh autocommit
+        // connection instead of throwing. This makes a non-awaited publish inside a tx degrade gracefully
+        // (decoupled) rather than crash, so callers don't strictly need publishAsync to avoid errors — it
+        // stays only as the way to express DETERMINISTIC decoupling. Scoped to the JOIN path: a tx's OWN
+        // statements still surface the error (we never silently split a real transaction).
+        if (!isStreamClosed(e)) throw e
+      }
+    }
     return toQueryResult(await this.one([{ type: 'execute', stmt: { sql: s, args: p.map(toHrana) } }]))
   }