@kubun/http-client 0.17.0 → 0.18.0

package/lib/index.d.ts

@@ -1,7 +1,21 @@
+import type { RequestCall } from '@enkaku/client';
 import { type ClientParams as BaseClientParams, KubunClient } from '@kubun/client';
-export type ClientParams = Omit<BaseClientParams, 'transport'> & {
+import type { ExecuteGraphParams, ExecuteGraphResult, ListGraphResult, LoadGraphParams, LoadGraphResult } from '@kubun/protocol';
+export type ClientParams = Omit<BaseClientParams, 'transport' | 'handleTransportError'> & {
     url: string;
 };
+export { GraphSubscriptionFailedError, GraphSubscriptionInterruptedError } from '@kubun/client';
+/**
+ * A Kubun client over HTTP. A network failure errors an Enkaku HTTP transport for good,
+ * so the client replaces it with a fresh one to the same URL; an HTTP error status or an
+ * error reply fails only its own request and keeps the transport. Reads (`graph/query`,
+ * `graph/load`, `graph/list`) whose transport died are sent once more on the new one;
+ * nothing else is, since a failed send does not tell whether the server ran it.
+ */
 export declare class HTTPClient extends KubunClient {
+    #private;
     constructor(params: ClientParams);
+    listGraphs(signal?: AbortSignal): RequestCall<ListGraphResult>;
+    loadGraph(param: LoadGraphParams, signal?: AbortSignal): RequestCall<LoadGraphResult>;
+    queryGraph<Data extends Record<string, unknown> = Record<string, unknown>>(param: ExecuteGraphParams, signal?: AbortSignal): RequestCall<ExecuteGraphResult<Data>>;
 }

package/lib/index.js

@@ -1,14 +1,68 @@
 import { ClientTransport } from '@enkaku/http-fetch';
 import { KubunClient } from '@kubun/client';
-export class HTTPClient extends KubunClient {
+export { GraphSubscriptionFailedError, GraphSubscriptionInterruptedError } from '@kubun/client';
+// The client swaps transports from its read loop, some turns after the failed send
+// rejects: one macrotask lets that settle before the swap is checked.
+const afterSwap = ()=>new Promise((resolve)=>setTimeout(resolve, 0));
+/**
+ * A Kubun client over HTTP. A network failure errors an Enkaku HTTP transport for good,
+ * so the client replaces it with a fresh one to the same URL; an HTTP error status or an
+ * error reply fails only its own request and keeps the transport. Reads (`graph/query`,
+ * `graph/load`, `graph/list`) whose transport died are sent once more on the new one;
+ * nothing else is, since a failed send does not tell whether the server ran it.
+ */ export class HTTPClient extends KubunClient {
+    #transport;
     constructor(params){
         const { url, ...rest } = params;
-        const transport = new ClientTransport({
-            url
-        });
+        const slot = {
+            current: new ClientTransport({
+                url
+            })
+        };
         super({
             ...rest,
-            transport
+            transport: slot.current,
+            // Runs only when the transport's readable failed: a send that never reached the
+            // server, or a dropped event-stream session. Nothing is sent from here, so a server
+            // that stays down costs one transport per failed call.
+            handleTransportError: ()=>{
+                const dead = slot.current;
+                slot.current = new ClientTransport({
+                    url
+                });
+                void dead.dispose().catch(()=>{});
+                return slot.current;
+            }
+        });
+        this.#transport = slot;
+    }
+    listGraphs(signal) {
+        return this.#repeatable(()=>super.listGraphs(signal));
+    }
+    loadGraph(param, signal) {
+        return this.#repeatable(()=>super.loadGraph(param, signal));
+    }
+    queryGraph(param, signal) {
+        // `graph/query` refuses mutation operations server-side, so it is a read.
+        return this.#repeatable(()=>super.queryGraph(param, signal));
+    }
+    #repeatable(send) {
+        const transport = this.#transport.current;
+        const first = send();
+        let current = first;
+        const result = first.catch(async (error)=>{
+            await afterSwap();
+            // Still the same transport: an HTTP status, an error reply, a timeout or an abort.
+            if (this.#transport.current === transport) throw error;
+            current = send();
+            return await current;
+        });
+        return Object.assign(result, {
+            id: first.id,
+            type: first.type,
+            procedure: first.procedure,
+            signal: first.signal,
+            abort: (reason)=>current.abort(reason)
         });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/http-client",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "keywords": [],
   "license": "see LICENSE.md",
   "sideEffects": false,
@@ -15,13 +15,19 @@
     "LICENSE.md"
   ],
   "dependencies": {
-    "@enkaku/http-fetch": "^0.21.0",
-    "@kubun/client": "^0.17.0"
+    "@enkaku/http-fetch": "^0.21.5",
+    "@kubun/client": "^0.18.0"
   },
   "devDependencies": {
-    "@kokuin/token": "^0.5.0",
-    "@kubun/logger": "^0.17.0",
-    "@kubun/protocol": "^0.17.0"
+    "@enkaku/client": "^0.21.5",
+    "@enkaku/http-serve": "^0.21.5",
+    "@kokuin/token": "^0.5.1",
+    "@kubun/engine": "^0.18.0",
+    "@kubun/logger": "^0.18.0",
+    "@kubun/plugin-service-server": "^0.18.0",
+    "@kubun/protocol": "^0.18.0",
+    "@kubun/service-graph-api": "^0.18.0",
+    "@kubun/test-utils": "^0.0.0"
   },
   "publishConfig": {
     "access": "public"