@dev-crew-berlin/enter-js-utils 0.95.2 → 0.97.2

package/dist/api-client/api-base.d.ts

@@ -36,6 +36,8 @@ export default class APIBase {
         onLogout: (reason?: string) => void;
     });
     private static fetchResult;
+    private buildHeaders;
+    private fetchResponse;
     /**
      * @category Auth
      */
@@ -54,6 +56,7 @@ export default class APIBase {
         expires: Date;
     }>>;
     private fetchFromEnter;
+    protected stream<T>(endpoint: string, options?: FetchOptions): AsyncGenerator<T>;
     protected get<Path extends keyof paths>(endpoint: Path, options: FetchOptions): Promise<APIResult<ResponseType<Path, 'get'>>>;
     protected post<Path extends keyof paths>(endpoint: Path, data: RequestBody<Path, 'post'>, options: FetchOptions): Promise<APIResult<ResponseType<Path, 'post'>>>;
     protected put<Path extends keyof paths>(endpoint: Path, data: RequestBody<Path, 'put'>, options: FetchOptions): Promise<APIResult<ResponseType<Path, 'put'>>>;

package/dist/api-client/api-base.js

@@ -1,4 +1,5 @@
 import jws from 'jws';
+import { EventSourceParserStream } from 'eventsource-parser/stream';
 import { failure, success } from '../lib';
 export default class APIBase {
   constructor(args) {
@@ -16,6 +17,53 @@ export default class APIBase {
       return failure(e);
     }
   }
+  buildHeaders(extraHeaders = {}) {
+    return {
+      Authorization: `bearer ${this.credentials.accessToken}`,
+      'Content-Type': 'application/json',
+      'X-Enter-Device-Name': this.deviceName,
+      'X-Enter-Requester-Id': this.requesterId,
+      ...extraHeaders
+    };
+  }
+  async fetchResponse(endpoint, init) {
+    const res = await APIBase.fetchResult(`${this.credentials.url}${endpoint}`, init);
+    if (!res.success) {
+      return failure([{
+        type: 'network-error',
+        message: res.error.message,
+        endpoint
+      }]);
+    }
+    if (res.data.status === 401) {
+      if (this.isLoggedIn) this.logout();
+      return failure([{
+        type: 'http-error',
+        statusCode: 401,
+        endpoint,
+        message: res.data.statusText
+      }]);
+    }
+    if (res.data.status >= 300) {
+      try {
+        const error = await res.data.json();
+        return failure([{
+          type: 'http-error',
+          statusCode: res.data.status,
+          message: error.error ?? res.data.statusText,
+          endpoint
+        }]);
+      } catch {
+        return failure([{
+          type: 'http-error',
+          statusCode: res.data.status,
+          message: `invalid response from backend: ${res.data.status} (${res.data.statusText}) for: ${endpoint}`,
+          endpoint
+        }]);
+      }
+    }
+    return success(res.data);
+  }
 
   /**
    * @category Auth
@@ -74,58 +122,52 @@ export default class APIBase {
   }
   async fetchFromEnter(endpoint, method, data, options) {
     const body = data !== null ? JSON.stringify(data) : null;
-    const headers = {
-      Authorization: `bearer ${this.credentials.accessToken}`,
-      'Content-Type': 'application/json',
-      'X-Enter-Device-Name': this.deviceName,
-      'X-Enter-Requester-Id': this.requesterId
-    };
-    const res = await APIBase.fetchResult(`${this.credentials.url}${endpoint}`, {
+    const res = await this.fetchResponse(endpoint, {
       method: method.toUpperCase(),
-      headers,
+      headers: this.buildHeaders(),
       body,
       ...options
     });
-    if (!res.success) {
-      return failure([{
-        type: 'network-error',
-        message: res.error.message,
-        endpoint
-      }]);
-    }
-    if (res.data.status === 401) {
-      if (this.isLoggedIn) this.logout();
-      return failure([{
-        type: 'http-error',
-        statusCode: 401,
-        endpoint,
-        message: res.data.statusText
-      }]);
-    }
-    if (res.data.status >= 300) {
-      try {
-        const error = await res.data.json();
-        return failure([{
-          type: 'http-error',
-          statusCode: res.data.status,
-          message: error.error ?? res.data.statusText,
-          endpoint
-        }]);
-      } catch (e) {
-        return failure([{
-          type: 'http-error',
-          statusCode: res.data.status,
-          message: `invalid response from backend: ${res.data.status} (${res.data.statusText}) for: ${endpoint}`,
-          endpoint
-        }]);
-      }
-    }
+    if (!res.success) return res;
 
     // HTTP status 204 means no content so we can't parse it as json
     if (res.data.status === 204) return success(null);
     const json = await res.data.json();
     return success(json);
   }
+  async *stream(endpoint, options = {}) {
+    const res = await this.fetchResponse(endpoint, {
+      method: 'GET',
+      headers: this.buildHeaders({
+        Accept: 'text/event-stream'
+      }),
+      ...options
+    });
+    if (!res.success) {
+      throw new Error(res.error[0]?.message ?? 'Unknown error');
+    }
+    if (!res.data.body) {
+      throw new Error('Response body is null');
+    }
+    const reader = res.data.body.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream()).getReader();
+    try {
+      while (true) {
+        const {
+          done,
+          value: event
+        } = await reader.read();
+        if (done) break;
+        if (event.data === '[DONE]') return;
+        try {
+          yield JSON.parse(event.data);
+        } catch {
+          console.warn('[SSE] Failed to parse event data:', event.data);
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
   async get(endpoint, options) {
     const rawResponse = await this.fetchFromEnter(endpoint, 'get', undefined, options);
     if (!rawResponse.success) return rawResponse;

package/dist/api-client/index.d.ts

@@ -161,5 +161,20 @@ declare class API extends APIBase {
      * @category Events
      */
     createEvents(args: Event[], options?: FetchOptions): Promise<APIResult<null>>;
+    /**
+     * Subscribe to the SSE event stream. Yields events as they arrive.
+     * Use `for await` to consume events, and `break` or `return` to unsubscribe.
+     *
+     * @example
+     * for await (const event of api.subscribeToEvents({ instanceName: 'my-instance' })) {
+     *   console.log(event)
+     * }
+     *
+     * @category Events
+     */
+    subscribeToEvents(args: {
+        instanceName: string;
+        eventType?: string[];
+    }, options?: FetchOptions): AsyncGenerator<Event>;
 }
 export default API;

package/dist/api-client/index.js

@@ -221,5 +221,23 @@ class API extends APIBase {
   async createEvents(args, options = {}) {
     return this.post(`/events`, args, options);
   }
+
+  /**
+   * Subscribe to the SSE event stream. Yields events as they arrive.
+   * Use `for await` to consume events, and `break` or `return` to unsubscribe.
+   *
+   * @example
+   * for await (const event of api.subscribeToEvents({ instanceName: 'my-instance' })) {
+   *   console.log(event)
+   * }
+   *
+   * @category Events
+   */
+  async *subscribeToEvents(args, options = {}) {
+    const query = new URLSearchParams();
+    query.append('instance', args.instanceName);
+    args.eventType?.forEach(t => query.append('event_type', t));
+    yield* this.stream(`/events/stream?${query.toString()}`, options);
+  }
 }
 export default API;