@pikku/fetch 0.12.1 → 0.12.3

package/CHANGELOG.md

@@ -1,3 +1,26 @@
+## 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
+
+- 9060165: New realtime events system: `pikku realtime` generates a typed `PikkuRealtime` client that pairs with `PikkuRPC`. A `/events` channel can be scaffolded to fan out server events to subscribers over SSE. `pikku dev` wires `LocalEventHubService` automatically so realtime works out of the box locally. The React provider exposes `PikkuRealtime` alongside `PikkuRPC`.
+- 9060165: Fix `@pikku/addon-graph` package exports so generated bootstrap files can be imported correctly. The Node.js HTTP server adapter is unified across dev, standalone, and container deployments. Next.js gains a worker-RPC transport. Date values in fetch responses now deserialise correctly.
+
 ## 0.12.0
 
 ## 0.12.1

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

@@ -45,6 +45,11 @@ export declare class CorePikkuFetch {
      * @param {string} serverUrl - The server URL to be set.
      */
     setServerUrl(serverUrl: string): void;
+    /**
+     * Returns the configured base server URL (without trailing slash), or
+     * undefined if it hasn't been set yet.
+     */
+    getServerUrl(): string | undefined;
     /**
      * Sets the JWT for authorization.
      *
@@ -93,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

@@ -57,6 +57,13 @@ class CorePikkuFetch {
         }
         this.options.serverUrl = serverUrl;
     }
+    /**
+     * Returns the configured base server URL (without trailing slash), or
+     * undefined if it hasn't been set yet.
+     */
+    getServerUrl() {
+        return this.options.serverUrl;
+    }
     /**
      * Sets the JWT for authorization.
      *
@@ -159,6 +166,78 @@ 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);
+                    }
+                }
+            }
+            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.
      *
@@ -198,7 +277,7 @@ class CorePikkuFetch {
      * @returns {any} - The transformed data.
      */
     transformDates(data) {
-        if (!this.options.transformDate) {
+        if (this.options.transformDate === false) {
             return data;
         }
         return (0, transform_date_js_1.transformDates)(data);

package/dist/cjs/index.d.ts

@@ -6,5 +6,6 @@
  *
  * @module @pikku/fetch
  */
-export { CorePikkuFetch, CorePikkuFetchOptions, HTTPMethod, } from './core-pikku-fetch.js';
+export { CorePikkuFetch } from './core-pikku-fetch.js';
+export type { CorePikkuFetchOptions, HTTPMethod } from './core-pikku-fetch.js';
 export { corePikkuFetch } from './pikku-fetch.js';

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

@@ -45,6 +45,11 @@ export declare class CorePikkuFetch {
      * @param {string} serverUrl - The server URL to be set.
      */
     setServerUrl(serverUrl: string): void;
+    /**
+     * Returns the configured base server URL (without trailing slash), or
+     * undefined if it hasn't been set yet.
+     */
+    getServerUrl(): string | undefined;
     /**
      * Sets the JWT for authorization.
      *
@@ -93,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

@@ -46,6 +46,13 @@ export class CorePikkuFetch {
         }
         this.options.serverUrl = serverUrl;
     }
+    /**
+     * Returns the configured base server URL (without trailing slash), or
+     * undefined if it hasn't been set yet.
+     */
+    getServerUrl() {
+        return this.options.serverUrl;
+    }
     /**
      * Sets the JWT for authorization.
      *
@@ -137,6 +144,78 @@ 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);
+                    }
+                }
+            }
+            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.
      *
@@ -180,7 +259,7 @@ export class CorePikkuFetch {
      * @returns {any} - The transformed data.
      */
     transformDates(data) {
-        if (!this.options.transformDate) {
+        if (this.options.transformDate === false) {
             return data;
         }
         return transformDates(data);

package/dist/esm/index.d.ts

@@ -6,5 +6,6 @@
  *
  * @module @pikku/fetch
  */
-export { CorePikkuFetch, CorePikkuFetchOptions, HTTPMethod, } from './core-pikku-fetch.js';
+export { CorePikkuFetch } from './core-pikku-fetch.js';
+export type { CorePikkuFetchOptions, HTTPMethod } from './core-pikku-fetch.js';
 export { corePikkuFetch } from './pikku-fetch.js';

package/dist/esm/index.js

@@ -6,5 +6,5 @@
  *
  * @module @pikku/fetch
  */
-export { CorePikkuFetch, } from './core-pikku-fetch.js';
+export { CorePikkuFetch } from './core-pikku-fetch.js';
 export { corePikkuFetch } from './pikku-fetch.js';

package/package.json

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

package/src/core-pikku-fetch.ts

@@ -72,6 +72,14 @@ export class CorePikkuFetch {
     this.options.serverUrl = serverUrl
   }
 
+  /**
+   * Returns the configured base server URL (without trailing slash), or
+   * undefined if it hasn't been set yet.
+   */
+  public getServerUrl(): string | undefined {
+    return this.options.serverUrl
+  }
+
   /**
    * Sets the JWT for authorization.
    *
@@ -185,6 +193,81 @@ 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)
+          }
+        }
+      } 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.
    *
@@ -234,7 +317,7 @@ export class CorePikkuFetch {
    * @returns {any} - The transformed data.
    */
   private transformDates(data: any): any {
-    if (!this.options.transformDate) {
+    if (this.options.transformDate === false) {
       return data
     }
     return transformDates(data)

package/src/index.test.ts

@@ -0,0 +1,11 @@
+import assert from 'node:assert/strict'
+import { describe, test } from 'node:test'
+
+import { CorePikkuFetch, corePikkuFetch } from './index.js'
+
+describe('@pikku/fetch', () => {
+  test('exports the public fetch client API', () => {
+    assert.equal(typeof CorePikkuFetch, 'function')
+    assert.equal(typeof corePikkuFetch, 'function')
+  })
+})

package/src/index.ts

@@ -7,9 +7,6 @@
  * @module @pikku/fetch
  */
 
-export {
-  CorePikkuFetch,
-  CorePikkuFetchOptions,
-  HTTPMethod,
-} from './core-pikku-fetch.js'
+export { CorePikkuFetch } from './core-pikku-fetch.js'
+export type { CorePikkuFetchOptions, HTTPMethod } from './core-pikku-fetch.js'
 export { corePikkuFetch } from './pikku-fetch.js'