@redseat/api 0.4.2 → 0.4.3

package/dist/client.d.ts

@@ -152,10 +152,6 @@ export declare class RedseatClient {
      * Processes the SSE stream and emits events
      */
     private processSSEStream;
-    /**
-     * Parses the SSE buffer and extracts complete events
-     */
-    private parseSSEBuffer;
     /**
      * Handles SSE errors and triggers reconnection if appropriate
      */

package/dist/client.js

@@ -1,6 +1,7 @@
 import axios from 'axios';
 import { BehaviorSubject, Subject, filter, map } from 'rxjs';
 import { fetchServerToken } from './auth.js';
+import { parseSSEBuffer } from './sse-fetch.js';
 export class RedseatClient {
     /**
      * Creates a typed observable for a specific SSE event type.
@@ -607,8 +608,22 @@ export class RedseatClient {
                 // Data received - reset activity timeout
                 this.resetActivityTimeout();
                 buffer += decoder.decode(value, { stream: true });
-                const { events, remainingBuffer } = this.parseSSEBuffer(buffer);
+                const { events: rawEvents, remainingBuffer } = parseSSEBuffer(buffer);
                 buffer = remainingBuffer;
+                const events = rawEvents.map(raw => {
+                    let data = raw.data;
+                    try {
+                        data = JSON.parse(raw.data);
+                    }
+                    catch {
+                        this._sseError.next({
+                            type: 'parse',
+                            message: `Failed to parse SSE data: ${raw.data}`,
+                            timestamp: Date.now()
+                        });
+                    }
+                    return { event: raw.event, data, id: raw.id, retry: raw.retry };
+                });
                 for (const event of events) {
                     //console.log("event process", JSON.stringify(event))
                     this._sseEvents.next(event);
@@ -627,72 +642,6 @@ export class RedseatClient {
             reader.releaseLock();
         }
     }
-    /**
-     * Parses the SSE buffer and extracts complete events
-     */
-    parseSSEBuffer(buffer) {
-        const events = [];
-        const lines = buffer.split('\n');
-        let currentEvent = {};
-        let processedUpTo = 0;
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            // Check if this is an incomplete line (last line without newline)
-            if (i === lines.length - 1 && !buffer.endsWith('\n')) {
-                break;
-            }
-            processedUpTo += line.length + 1; // +1 for the newline
-            if (line === '') {
-                // Empty line marks end of event
-                if (currentEvent.event && currentEvent.data !== undefined) {
-                    events.push(currentEvent);
-                }
-                currentEvent = {};
-                continue;
-            }
-            if (line.startsWith(':')) {
-                // Comment, ignore
-                continue;
-            }
-            const colonIndex = line.indexOf(':');
-            if (colonIndex === -1) {
-                continue;
-            }
-            const field = line.slice(0, colonIndex);
-            // Value starts after colon, skip optional space after colon
-            let value = line.slice(colonIndex + 1);
-            if (value.startsWith(' ')) {
-                value = value.slice(1);
-            }
-            switch (field) {
-                case 'event':
-                    currentEvent.event = value;
-                    break;
-                case 'data':
-                    try {
-                        currentEvent.data = JSON.parse(value);
-                    }
-                    catch {
-                        this._sseError.next({
-                            type: 'parse',
-                            message: `Failed to parse SSE data: ${value}`,
-                            timestamp: Date.now()
-                        });
-                    }
-                    break;
-                case 'id':
-                    currentEvent.id = value;
-                    break;
-                case 'retry':
-                    currentEvent.retry = parseInt(value, 10);
-                    break;
-            }
-        }
-        return {
-            events,
-            remainingBuffer: buffer.slice(processedUpTo)
-        };
-    }
     /**
      * Handles SSE errors and triggers reconnection if appropriate
      */

package/dist/library.js

@@ -1,6 +1,7 @@
 import { filter, EMPTY } from 'rxjs';
 import { deriveKey, encryptText as encryptTextUtil, decryptText as decryptTextUtil, encryptBuffer, decryptBuffer, encryptFile as encryptFileUtil, decryptFile as decryptFileUtil, decryptFileThumb, encryptFilename as encryptFilenameUtil, getRandomIV as getRandomIVUtil } from './encryption.js';
 import { uint8ArrayFromBase64 } from './crypto.js';
+import { openFetchSSEStream } from './sse-fetch.js';
 export class LibraryApi {
     constructor(client, libraryId, library) {
         this.client = client;
@@ -97,48 +98,24 @@ export class LibraryApi {
         return `/libraries/${this.libraryId}${path}`;
     }
     openSearchStream(path, params, callbacks) {
-        const EventSourceCtor = globalThis.EventSource;
-        if (!EventSourceCtor) {
-            callbacks.onError?.(new Error('EventSource is not available in this runtime.'));
-            return () => undefined;
-        }
         const url = this.client.getFullUrl(path, {
             ...params,
             token: this.client.getAuthToken()
         });
-        const source = new EventSourceCtor(url);
-        let closed = false;
-        const close = () => {
-            if (closed) {
-                return;
-            }
-            closed = true;
-            source.removeEventListener('results', onResults);
-            source.removeEventListener('finished', onFinished);
-            source.onerror = null;
-            source.close();
-        };
-        const onResults = (event) => {
-            try {
-                const payload = JSON.parse(event.data);
-                callbacks.onResults?.(payload);
+        return openFetchSSEStream(url, (eventType, data) => {
+            if (eventType === 'results') {
+                try {
+                    const payload = JSON.parse(data);
+                    callbacks.onResults?.(payload);
+                }
+                catch (error) {
+                    callbacks.onError?.(error);
+                }
             }
-            catch (error) {
-                callbacks.onError?.(error);
-                close();
+            else if (eventType === 'finished') {
+                callbacks.onFinished?.();
             }
-        };
-        const onFinished = () => {
-            callbacks.onFinished?.();
-            close();
-        };
-        source.addEventListener('results', onResults);
-        source.addEventListener('finished', onFinished);
-        source.onerror = (error) => {
-            callbacks.onError?.(error);
-            close();
-        };
-        return close;
+        }, () => callbacks.onFinished?.(), (error) => callbacks.onError?.(error));
     }
     async getTags(query) {
         const params = {};

package/dist/sse-fetch.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Raw SSE event as received from the server (data is unparsed string).
+ */
+export interface RawSSEEvent {
+    event: string;
+    data: string;
+    id?: string;
+    retry?: number;
+}
+/**
+ * Parses a raw SSE buffer into discrete events, returning any incomplete trailing data.
+ * Follows the SSE spec: events are separated by blank lines, fields are `field: value`.
+ */
+export declare function parseSSEBuffer(buffer: string): {
+    events: RawSSEEvent[];
+    remainingBuffer: string;
+};
+/**
+ * Opens a one-shot fetch-based SSE stream (no reconnection).
+ * Suitable for search streams where a token is embedded in the URL.
+ *
+ * @param url     - Full URL including auth token as query param
+ * @param onEvent - Called for each complete event with (eventType, rawData)
+ * @param onDone  - Called when the stream ends normally
+ * @param onError - Called on network or parse errors
+ * @returns A cancel function that aborts the stream
+ */
+export declare function openFetchSSEStream(url: string, onEvent: (eventType: string, data: string) => void, onDone?: () => void, onError?: (error: unknown) => void): () => void;

package/dist/sse-fetch.js

@@ -0,0 +1,112 @@
+/**
+ * Parses a raw SSE buffer into discrete events, returning any incomplete trailing data.
+ * Follows the SSE spec: events are separated by blank lines, fields are `field: value`.
+ */
+export function parseSSEBuffer(buffer) {
+    const events = [];
+    const lines = buffer.split('\n');
+    let processedUpTo = 0;
+    let eventType = '';
+    let eventData = '';
+    let eventId;
+    let eventRetry;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Incomplete last line — keep in buffer
+        if (i === lines.length - 1 && !buffer.endsWith('\n')) {
+            break;
+        }
+        processedUpTo += line.length + 1; // +1 for '\n'
+        if (line === '') {
+            // Blank line = end of event
+            if (eventType) {
+                events.push({ event: eventType, data: eventData, id: eventId, retry: eventRetry });
+            }
+            eventType = '';
+            eventData = '';
+            eventId = undefined;
+            eventRetry = undefined;
+            continue;
+        }
+        if (line.startsWith(':'))
+            continue; // SSE comment
+        const colonIdx = line.indexOf(':');
+        if (colonIdx === -1)
+            continue;
+        const field = line.slice(0, colonIdx);
+        let value = line.slice(colonIdx + 1);
+        if (value.startsWith(' '))
+            value = value.slice(1);
+        switch (field) {
+            case 'event':
+                eventType = value;
+                break;
+            case 'data':
+                eventData = value;
+                break;
+            case 'id':
+                eventId = value;
+                break;
+            case 'retry':
+                eventRetry = parseInt(value, 10);
+                break;
+        }
+    }
+    return { events, remainingBuffer: buffer.slice(processedUpTo) };
+}
+/**
+ * Opens a one-shot fetch-based SSE stream (no reconnection).
+ * Suitable for search streams where a token is embedded in the URL.
+ *
+ * @param url     - Full URL including auth token as query param
+ * @param onEvent - Called for each complete event with (eventType, rawData)
+ * @param onDone  - Called when the stream ends normally
+ * @param onError - Called on network or parse errors
+ * @returns A cancel function that aborts the stream
+ */
+export function openFetchSSEStream(url, onEvent, onDone, onError) {
+    let aborted = false;
+    const controller = new AbortController();
+    const run = async () => {
+        try {
+            const response = await fetch(url, {
+                signal: controller.signal,
+                headers: { Accept: 'text/event-stream' }
+            });
+            if (!response.ok) {
+                onError?.(new Error(`HTTP error: ${response.status}`));
+                return;
+            }
+            const reader = response.body?.getReader();
+            if (!reader) {
+                onError?.(new Error('No response body'));
+                return;
+            }
+            const decoder = new TextDecoder();
+            let buffer = '';
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    onDone?.();
+                    break;
+                }
+                buffer += decoder.decode(value, { stream: true });
+                const { events, remainingBuffer } = parseSSEBuffer(buffer);
+                buffer = remainingBuffer;
+                for (const event of events) {
+                    onEvent(event.event, event.data);
+                }
+            }
+        }
+        catch (error) {
+            if (!aborted) {
+                onError?.(error);
+            }
+        }
+    };
+    run();
+    return () => {
+        aborted = true;
+        controller.abort();
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@redseat/api",
-    "version": "0.4.2",
+    "version": "0.4.3",
     "description": "TypeScript API client library for interacting with Redseat servers",
     "type": "module",
     "main": "./dist/index.js",