@pikku/fetch 0.12.2 → 0.12.4

package/CHANGELOG.md

@@ -1,3 +1,25 @@
+## 0.12.4
+
+### Patch Changes
+
+- ade6f0b: `subscribeToSSE`: call `onError` when the stream closes cleanly without the caller having called `close()`. Previously a server-side connection drop (or any clean EOF before the terminal event) exited the read loop silently, leaving the caller's `runPhase` stuck at `'running'` indefinitely with no way to recover.
+
+## 0.12.3
+
+### Patch Changes
+
+- 409ec80: feat(console): Tests page with live SSE streaming and function test harness
+  - `@pikku/addon-console`: add `streamFunctionTests` SSE function that runs the
+    cucumber/c8 test harness and streams structured per-scenario events
+    (scenario-start, step, scenario-done, done)
+  - `@pikku/console`: TestsPage live run view — renders scenario names and step
+    status in real time during a test run via SSE; adds `usePikkuSSE` hook and
+    `showRunButton` prop
+  - `@pikku/fetch`: add `subscribePikkuSSE` helper for typed server-sent event
+    streams
+  - `@pikku/cli`: wire SSE-returning functions through the console serialiser and
+    RPC wrapper so the stream route is included in generated clients
+
 ## 0.12.2
 
 ### Patch Changes

package/dist/cjs/core-pikku-fetch.d.ts

@@ -98,6 +98,17 @@ export declare class CorePikkuFetch {
      * @throws {Response} - Throws the response if the status code is greater than 400.
      */
     api(uri: string, method: HTTPMethod, data: any, options?: RequestInit): Promise<any>;
+    /**
+     * Opens an SSE stream to the given path and calls `handler` for each parsed
+     * JSON event. Returns a handle with a `close()` method that aborts the stream.
+     *
+     * @param path - Server-relative path (e.g. `/function-tests/stream`)
+     * @param handler - Called with each decoded JSON event
+     * @param onError - Called once if the stream errors (and is not already closed)
+     */
+    subscribeToSSE<T = unknown>(path: string, handler: (event: T) => void, onError?: (err: unknown) => void): {
+        close: () => void;
+    };
     /**
      * Makes a raw fetch request with the specified URI, method, and data.
      *

package/dist/cjs/core-pikku-fetch.js

@@ -166,6 +166,81 @@ class CorePikkuFetch {
             }
         });
     }
+    /**
+     * Opens an SSE stream to the given path and calls `handler` for each parsed
+     * JSON event. Returns a handle with a `close()` method that aborts the stream.
+     *
+     * @param path - Server-relative path (e.g. `/function-tests/stream`)
+     * @param handler - Called with each decoded JSON event
+     * @param onError - Called once if the stream errors (and is not already closed)
+     */
+    subscribeToSSE(path, handler, onError) {
+        this.verifyServerUrlSet();
+        const url = path.startsWith('/')
+            ? `${this.options.serverUrl}${path}`
+            : `${this.options.serverUrl}/${path}`;
+        const controller = new AbortController();
+        let closed = false;
+        const run = () => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield (0, pikku_fetch_js_1.corePikkuFetch)(url, null, {
+                    method: 'GET',
+                    mode: this.options.mode,
+                    credentials: this.options.credentials,
+                    headers: Object.assign(Object.assign({}, this.getHeaders()), { Accept: 'text/event-stream' }),
+                    signal: controller.signal,
+                });
+                if (!response.ok || !response.body) {
+                    throw new Error(`SSE request failed: ${response.status}`);
+                }
+                const reader = response.body
+                    .pipeThrough(new TextDecoderStream())
+                    .getReader();
+                let buffer = '';
+                while (!closed) {
+                    const { done, value } = yield reader.read();
+                    if (done)
+                        break;
+                    buffer += value;
+                    let sep;
+                    while ((sep = buffer.indexOf('\n\n')) !== -1) {
+                        const raw = buffer.slice(0, sep);
+                        buffer = buffer.slice(sep + 2);
+                        const data = raw
+                            .split('\n')
+                            .filter((l) => l.startsWith('data:'))
+                            .map((l) => l.slice(5).trimStart())
+                            .join('\n');
+                        if (!data)
+                            continue;
+                        let parsed;
+                        try {
+                            parsed = JSON.parse(data);
+                        }
+                        catch (_a) {
+                            /* ignore malformed event */
+                            continue;
+                        }
+                        handler(parsed);
+                    }
+                }
+                // Clean EOF before caller called close() = unexpected stream termination.
+                if (!closed)
+                    throw new Error('SSE stream closed unexpectedly');
+            }
+            catch (err) {
+                if (!closed)
+                    onError === null || onError === void 0 ? void 0 : onError(err);
+            }
+        });
+        run();
+        return {
+            close: () => {
+                closed = true;
+                controller.abort();
+            },
+        };
+    }
     /**
      * Makes a raw fetch request with the specified URI, method, and data.
      *

package/dist/esm/core-pikku-fetch.d.ts

@@ -98,6 +98,17 @@ export declare class CorePikkuFetch {
      * @throws {Response} - Throws the response if the status code is greater than 400.
      */
     api(uri: string, method: HTTPMethod, data: any, options?: RequestInit): Promise<any>;
+    /**
+     * Opens an SSE stream to the given path and calls `handler` for each parsed
+     * JSON event. Returns a handle with a `close()` method that aborts the stream.
+     *
+     * @param path - Server-relative path (e.g. `/function-tests/stream`)
+     * @param handler - Called with each decoded JSON event
+     * @param onError - Called once if the stream errors (and is not already closed)
+     */
+    subscribeToSSE<T = unknown>(path: string, handler: (event: T) => void, onError?: (err: unknown) => void): {
+        close: () => void;
+    };
     /**
      * Makes a raw fetch request with the specified URI, method, and data.
      *

package/dist/esm/core-pikku-fetch.js

@@ -144,6 +144,81 @@ export class CorePikkuFetch {
             return;
         }
     }
+    /**
+     * Opens an SSE stream to the given path and calls `handler` for each parsed
+     * JSON event. Returns a handle with a `close()` method that aborts the stream.
+     *
+     * @param path - Server-relative path (e.g. `/function-tests/stream`)
+     * @param handler - Called with each decoded JSON event
+     * @param onError - Called once if the stream errors (and is not already closed)
+     */
+    subscribeToSSE(path, handler, onError) {
+        this.verifyServerUrlSet();
+        const url = path.startsWith('/')
+            ? `${this.options.serverUrl}${path}`
+            : `${this.options.serverUrl}/${path}`;
+        const controller = new AbortController();
+        let closed = false;
+        const run = async () => {
+            try {
+                const response = await corePikkuFetch(url, null, {
+                    method: 'GET',
+                    mode: this.options.mode,
+                    credentials: this.options.credentials,
+                    headers: { ...this.getHeaders(), Accept: 'text/event-stream' },
+                    signal: controller.signal,
+                });
+                if (!response.ok || !response.body) {
+                    throw new Error(`SSE request failed: ${response.status}`);
+                }
+                const reader = response.body
+                    .pipeThrough(new TextDecoderStream())
+                    .getReader();
+                let buffer = '';
+                while (!closed) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += value;
+                    let sep;
+                    while ((sep = buffer.indexOf('\n\n')) !== -1) {
+                        const raw = buffer.slice(0, sep);
+                        buffer = buffer.slice(sep + 2);
+                        const data = raw
+                            .split('\n')
+                            .filter((l) => l.startsWith('data:'))
+                            .map((l) => l.slice(5).trimStart())
+                            .join('\n');
+                        if (!data)
+                            continue;
+                        let parsed;
+                        try {
+                            parsed = JSON.parse(data);
+                        }
+                        catch {
+                            /* ignore malformed event */
+                            continue;
+                        }
+                        handler(parsed);
+                    }
+                }
+                // Clean EOF before caller called close() = unexpected stream termination.
+                if (!closed)
+                    throw new Error('SSE stream closed unexpectedly');
+            }
+            catch (err) {
+                if (!closed)
+                    onError?.(err);
+            }
+        };
+        run();
+        return {
+            close: () => {
+                closed = true;
+                controller.abort();
+            },
+        };
+    }
     /**
      * Makes a raw fetch request with the specified URI, method, and data.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/fetch",
-  "version": "0.12.2",
+  "version": "0.12.4",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "type": "module",

package/src/core-pikku-fetch.ts

@@ -193,6 +193,83 @@ export class CorePikkuFetch {
     }
   }
 
+  /**
+   * Opens an SSE stream to the given path and calls `handler` for each parsed
+   * JSON event. Returns a handle with a `close()` method that aborts the stream.
+   *
+   * @param path - Server-relative path (e.g. `/function-tests/stream`)
+   * @param handler - Called with each decoded JSON event
+   * @param onError - Called once if the stream errors (and is not already closed)
+   */
+  public subscribeToSSE<T = unknown>(
+    path: string,
+    handler: (event: T) => void,
+    onError?: (err: unknown) => void
+  ): { close: () => void } {
+    this.verifyServerUrlSet()
+    const url = path.startsWith('/')
+      ? `${this.options.serverUrl}${path}`
+      : `${this.options.serverUrl}/${path}`
+
+    const controller = new AbortController()
+    let closed = false
+
+    const run = async () => {
+      try {
+        const response = await corePikkuFetch(url, null, {
+          method: 'GET',
+          mode: this.options.mode,
+          credentials: this.options.credentials,
+          headers: { ...this.getHeaders(), Accept: 'text/event-stream' },
+          signal: controller.signal,
+        })
+        if (!response.ok || !response.body) {
+          throw new Error(`SSE request failed: ${response.status}`)
+        }
+        const reader = response.body
+          .pipeThrough(new TextDecoderStream())
+          .getReader()
+        let buffer = ''
+        while (!closed) {
+          const { done, value } = await reader.read()
+          if (done) break
+          buffer += value
+          let sep: number
+          while ((sep = buffer.indexOf('\n\n')) !== -1) {
+            const raw = buffer.slice(0, sep)
+            buffer = buffer.slice(sep + 2)
+            const data = raw
+              .split('\n')
+              .filter((l) => l.startsWith('data:'))
+              .map((l) => l.slice(5).trimStart())
+              .join('\n')
+            if (!data) continue
+            let parsed: T
+            try {
+              parsed = JSON.parse(data) as T
+            } catch {
+              /* ignore malformed event */
+              continue
+            }
+            handler(parsed)
+          }
+        }
+        // Clean EOF before caller called close() = unexpected stream termination.
+        if (!closed) throw new Error('SSE stream closed unexpectedly')
+      } catch (err) {
+        if (!closed) onError?.(err)
+      }
+    }
+
+    run()
+    return {
+      close: () => {
+        closed = true
+        controller.abort()
+      },
+    }
+  }
+
   /**
    * Makes a raw fetch request with the specified URI, method, and data.
    *