@zvndev/powdb-client 0.8.0 → 0.8.1

package/README.md

@@ -322,11 +322,12 @@ try {
 }
 ```
 
-If you abort with a custom reason (`ctrl.abort(myError)`) and that reason is
-an `Error`, it is thrown as-is instead. Otherwise the client throws a
-`PowDBError` with `code === "aborted"`.
+A plain `ctrl.abort()` throws a `PowDBError` with `code === "aborted"`. If you
+abort with a custom `Error` reason (`ctrl.abort(myError)`), that error is thrown
+as-is; any non-`Error` reason is wrapped in a `PowDBError` (`code === "aborted"`).
 
-The socket stays open — the server's reply is silently discarded so other in-flight queries keep working.
+The socket stays open — the aborted query's reply is silently discarded when it
+arrives, and every other in-flight query still receives its own result.
 
 ## API
 
@@ -361,6 +362,19 @@ Sends a PowQL query and returns a `Promise<QueryResult>`:
 
 Throws a `PowDBError` (see Structured errors above) on any failure.
 
+### `client.querySql(query, opts?)`
+
+Runs a statement through the server's **SQL frontend** and returns a
+`Promise<QueryResult>` — the same result shape as `query()`. The plain
+`query()` method stays PowQL for wire compatibility; `querySql()` sends the
+dedicated `QuerySql` wire message. Requires server ≥0.5.0 (the SQL frontend was
+added in 0.5.0); see `docs/SQL.md` for the supported subset. `opts.signal?:
+AbortSignal` cancels the query (see Cancellation above).
+
+```typescript
+const result = await client.querySql("SELECT name, age FROM User WHERE age > 27");
+```
+
 ### `client.queryTyped(query, schema, opts?)`
 
 Like `query()`, but coerces each row's string values to JS types using the

package/dist/index.d.ts

@@ -19,7 +19,7 @@ import { EventEmitter } from "node:events";
 import { type SyncRepairAction, type WireRetainedUnit, type WireSyncStatus } from "./protocol.js";
 import { type TypedRow, type TypedSchema } from "./typed.js";
 /** Client library version. Compared to the server's reported version. */
-export declare const CLIENT_VERSION = "0.8.0";
+export declare const CLIENT_VERSION = "0.8.1";
 export type QueryResult = {
     kind: "rows";
     columns: string[];

package/dist/index.js

@@ -21,7 +21,7 @@ import { encode, tryDecode, MAX_SYNC_PULL_BYTES, MAX_SYNC_PULL_UNITS, } from "./
 import { PowDBError } from "./errors.js";
 import { coerceRows, } from "./typed.js";
 /** Client library version. Compared to the server's reported version. */
-export const CLIENT_VERSION = "0.8.0";
+export const CLIENT_VERSION = "0.8.1";
 function socketChunkToBuffer(chunk) {
     return typeof chunk === "string" ? Buffer.from(chunk) : chunk;
 }
@@ -98,16 +98,19 @@ function majorOf(version) {
     return dot === -1 ? version : version.slice(0, dot);
 }
 /**
- * Build an AbortError. Prefers the caller-supplied `signal.reason` if it is
- * itself an `Error` (matches DOM semantics); otherwise wraps it in a
- * `PowDBError` with code `"aborted"` so catch-blocks can branch uniformly.
+ * Build an AbortError. A caller-supplied custom `Error` reason
+ * (`ctrl.abort(myError)`) passes through as-is to match DOM semantics. The
+ * default abort reason — Node's `DOMException` named `"AbortError"` — and any
+ * non-Error reason are wrapped in a `PowDBError` with code `"aborted"` so the
+ * common `ctrl.abort()` case branches uniformly on `err.code === "aborted"`.
  */
 function abortError(signal) {
     if (signal && signal.reason !== undefined) {
         const r = signal.reason;
-        if (r instanceof Error)
+        const isDefaultAbort = r instanceof DOMException && r.name === "AbortError";
+        if (r instanceof Error && !isDefaultAbort)
             return r;
-        return new PowDBError(String(r), "aborted");
+        return new PowDBError(isDefaultAbort ? "query was aborted" : String(r), "aborted");
     }
     return new PowDBError("query was aborted", "aborted");
 }
@@ -527,8 +530,17 @@ export class Client extends EventEmitter {
      * timeout so an unresponsive peer cannot make `close()` hang forever.
      */
     async close() {
-        if (this.closed)
+        if (this.closed) {
+            // Already torn down (e.g. an error in onData/onClose closed the client
+            // without destroying the socket). Ensure the socket is released so a
+            // post-teardown close() resolves instead of keeping the event loop
+            // alive. `writableEnded` distinguishes that case from a concurrent
+            // close() mid-graceful-shutdown, which must not be force-destroyed.
+            if (!this.socket.destroyed && !this.socket.writableEnded) {
+                this.socket.destroy();
+            }
             return;
+        }
         try {
             this.socket.write(encode({ type: "Disconnect" }));
         }
@@ -682,19 +694,18 @@ export class Client extends EventEmitter {
                 this.socket.write(encode({ type: "Pong" }));
                 continue;
             }
-            // Find the next non-settled pending entry and hand it the reply.
-            // Settled entries at the head were aborted by the caller but their
-            // reply is arriving now — drop it silently.
-            let entry = this.pending.shift();
-            while (entry && entry.settled) {
-                entry = this.pending.shift();
-            }
-            if (!entry) {
-                // Server sent an unsolicited frame (or we got extra after aborts
-                // with no replacement). Treat as protocol error.
+            // Replies are strictly FIFO: this frame belongs to exactly one pending
+            // entry — the head. Consume one entry per frame. If it was aborted
+            // (settled), its reply is arriving now; drop the frame and keep decoding
+            // rather than delivering it to a later, live query.
+            const entry = this.pending.shift();
+            if (entry === undefined) {
+                // No pending entry at all — the server sent an unsolicited frame.
                 this.onClose(new PowDBError("received unexpected frame from server", "protocol_error"));
                 return;
             }
+            if (entry.settled)
+                continue;
             entry.resolve(decoded.msg);
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zvndev/powdb-client",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "TypeScript client for PowDB (PowQL wire protocol)",
   "type": "module",
   "packageManager": "pnpm@10.29.3",
@@ -61,7 +61,7 @@
     "prepublishOnly": "npm run build"
   },
   "devDependencies": {
-    "@types/node": "^25",
+    "@types/node": "^26",
     "tsx": "^4",
     "typescript": "^6.0"
   }