@bagelink/sdk 1.8.14 → 1.8.16

package/bin/index.ts

@@ -23,28 +23,7 @@ export async function loadTypes() {
 	const apiPath = join(bagelinkDir, 'api.ts')
 	await formatAndWriteCode(apiPath, code)
 
-	// Copy streamClient utilities to generated directory
-	const srcDir = join(__dirname, '..', 'src', 'openAPITools')
-	const streamClientSource = join(srcDir, 'streamClient.ts')
-	const streamControllerSource = join(srcDir, 'StreamController.ts')
-
-	if (fs.existsSync(streamClientSource)) {
-		const streamClientCode = fs.readFileSync(streamClientSource, 'utf-8')
-		const streamClientDest = join(bagelinkDir, 'streamClient.ts')
-		await formatAndWriteCode(streamClientDest, streamClientCode)
-		console.log('✅ Generated streamClient.ts')
-	} else {
-		console.warn('⚠️  streamClient.ts not found at:', streamClientSource)
-	}
-
-	if (fs.existsSync(streamControllerSource)) {
-		const streamControllerCode = fs.readFileSync(streamControllerSource, 'utf-8')
-		const streamControllerDest = join(bagelinkDir, 'StreamController.ts')
-		await formatAndWriteCode(streamControllerDest, streamControllerCode)
-		console.log('✅ Generated StreamController.ts')
-	} else {
-		console.warn('⚠️  StreamController.ts not found at:', streamControllerSource)
-	}
+	console.log('ℹ️  Stream utilities are imported from @bagelink/sdk (no need to copy)')
 
 	// Optionally split into organized files
 	if (shouldSplitFiles) {

package/dist/index.cjs

@@ -899,7 +899,7 @@ function fileTemplate(tsString, typeForImport, baseURL) {
   const templateCode = `import ax from 'axios';
 import type { AxiosResponse } from 'axios';
 import type { ${typeForImport.join(", ")} } from './types.d';
-import { createSSEStream, createSSEStreamPost, StreamController, type SSEStreamOptions, type SSEEvent } from './streamClient';
+import { createSSEStream, createSSEStreamPost, StreamController, type SSEStreamOptions, type SSEEvent } from '@bagelink/sdk';
 
 /**
  * Options for file upload operations
@@ -914,22 +914,15 @@ export interface UploadOptions {
 }
 
 /**
- * Export SSE stream utilities for direct use
+ * Stream utilities are exported from @bagelink/sdk
  * 
  * @example Chainable event handlers
+ * import { createSSEStream } from '@bagelink/sdk'
+ * 
  * const stream = createSSEStream(url)
  *   .on('token', (data) => console.log(data))
  *   .on('done', () => console.log('Complete!'))
- * 
- * @example Async iteration
- * for await (const event of createSSEStream(url)) {
- *   console.log(event.type, event.data)
- * }
- * 
- * @example Promise-based
- * const result = await createSSEStream(url).toPromise()
  */
-export { createSSEStream, createSSEStreamPost, StreamController, type SSEStreamOptions, type SSEEvent } from './streamClient';
 ${streamTypeDefs}
 /**
  * Configured axios instance for API requests
@@ -985,36 +978,13 @@ function generateTypes(schemas) {
 }
 
 class StreamController {
-  constructor(streamFn) {
-    this.streamFn = streamFn;
-    this.abortController = new AbortController();
-    this.start();
+  constructor(cleanup) {
+    this.cleanup = cleanup;
+    this.controller = new AbortController();
   }
   handlers = /* @__PURE__ */ new Map();
-  errorHandlers = /* @__PURE__ */ new Set();
-  completeHandlers = /* @__PURE__ */ new Set();
-  abortController;
+  controller;
   _closed = false;
-  _promise = null;
-  _resolvePromise = null;
-  _rejectPromise = null;
-  start() {
-    const cleanup = this.streamFn(
-      (event) => {
-        this.emit(event.type, event.data);
-      },
-      (error) => {
-        this.emitError(error);
-      },
-      () => {
-        this.emitComplete();
-      }
-    );
-    this.abortController.signal.addEventListener("abort", () => {
-      cleanup();
-      this._closed = true;
-    });
-  }
   /**
    * Register an event handler (fully typed!)
    * @param event - Event type to listen for
@@ -1022,22 +992,16 @@ class StreamController {
    * @returns this (for chaining)
    */
   on(event, handler) {
-    if (event === "error") {
-      this.errorHandlers.add(handler);
-    } else if (event === "complete") {
-      this.completeHandlers.add(handler);
-    } else {
-      if (!this.handlers.has(event)) {
-        this.handlers.set(event, /* @__PURE__ */ new Set());
-      }
-      this.handlers.get(event).add(handler);
+    if (!this.handlers.has(event)) {
+      this.handlers.set(event, /* @__PURE__ */ new Set());
     }
+    this.handlers.get(event).add(handler);
     return this;
   }
   /**
    * Register a one-time event handler (fully typed!)
    * @param event - Event type to listen for
-   * @param handler - Handler function (called once then removed, data type inferred from event)
+   * @param handler - Handler function (called once then removed)
    * @returns this (for chaining)
    */
   once(event, handler) {
@@ -1054,13 +1018,7 @@ class StreamController {
    * @returns this (for chaining)
    */
   off(event, handler) {
-    if (event === "error") {
-      this.errorHandlers.delete(handler);
-    } else if (event === "complete") {
-      this.completeHandlers.delete(handler);
-    } else {
-      this.handlers.get(event)?.delete(handler);
-    }
+    this.handlers.get(event)?.delete(handler);
     return this;
   }
   /**
@@ -1069,17 +1027,15 @@ class StreamController {
   removeAllListeners(event) {
     if (event === void 0) {
       this.handlers.clear();
-      this.errorHandlers.clear();
-      this.completeHandlers.clear();
-    } else if (event === "error") {
-      this.errorHandlers.clear();
-    } else if (event === "complete") {
-      this.completeHandlers.clear();
     } else {
       this.handlers.delete(event);
     }
     return this;
   }
+  /**
+   * Emit an event to all registered handlers
+   * @internal
+   */
   emit(event, data) {
     const handlers = this.handlers.get(event);
     if (handlers) {
@@ -1087,41 +1043,18 @@ class StreamController {
         try {
           handler(data);
         } catch (error) {
-          console.error(`Error in handler for event "${event}":`, error);
+          console.error(`Error in ${event} handler:`, error);
         }
       });
     }
-    if (event === "done" && this._resolvePromise) {
-      this._resolvePromise(data);
-    }
-  }
-  emitError(error) {
-    this.errorHandlers.forEach((handler) => {
-      try {
-        handler(error);
-      } catch (err) {
-        console.error("Error in error handler:", err);
-      }
-    });
-    if (this._rejectPromise) {
-      this._rejectPromise(error);
-    }
-  }
-  emitComplete() {
-    this.completeHandlers.forEach((handler) => {
-      try {
-        handler();
-      } catch (error) {
-        console.error("Error in complete handler:", error);
-      }
-    });
   }
   /**
    * Close the stream
    */
   close() {
     if (!this._closed) {
-      this.abortController.abort();
+      this.controller.abort();
+      this.cleanup();
       this._closed = true;
     }
   }
@@ -1131,281 +1064,131 @@ class StreamController {
   get closed() {
     return this._closed;
   }
-  /**
-   * Convert stream to a Promise that resolves when 'done' event fires
-   * @returns Promise that resolves with the 'done' event data
-   */
-  toPromise() {
-    if (!this._promise) {
-      this._promise = new Promise((resolve, reject) => {
-        this._resolvePromise = resolve;
-        this._rejectPromise = reject;
-      });
+}
+
+function createSSEStream(url, options = {}) {
+  const { headers = {}, withCredentials = true } = options;
+  const controller = new AbortController();
+  const stream = new StreamController(() => {
+    controller.abort();
+  });
+  fetch(url, {
+    method: "GET",
+    headers: {
+      Accept: "text/event-stream",
+      ...headers
+    },
+    credentials: withCredentials ? "include" : "same-origin",
+    signal: controller.signal
+  }).then(async (response) => {
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
-    return this._promise;
-  }
-  /**
-   * Make the stream async iterable
-   * Usage: for await (const event of stream) { ... }
-   */
-  async *[Symbol.asyncIterator]() {
-    const events = [];
-    let resolveNext = null;
-    let done = false;
-    const eventHandler = (type) => (data) => {
-      const event = { type, data };
-      if (resolveNext) {
-        resolveNext(event);
-        resolveNext = null;
-      } else {
-        events.push(event);
-      }
-    };
-    const originalEmit = this.emit.bind(this);
-    const capturedEvents = [];
-    this.emit = (event, data) => {
-      if (!capturedEvents.includes(event)) {
-        capturedEvents.push(event);
-        this.on(event, eventHandler(event));
-      }
-      originalEmit(event, data);
-    };
-    this.on("complete", () => {
-      done = true;
-      if (resolveNext) {
-        resolveNext(null);
-        resolveNext = null;
-      }
-    });
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
     try {
-      while (!done) {
-        if (events.length > 0) {
-          const event = events.shift();
-          if (event) yield event;
-        } else {
-          const event = await new Promise((resolve) => {
-            resolveNext = resolve;
-          });
-          if (event === null) break;
-          yield event;
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          stream.emit("complete", {});
+          break;
         }
-      }
-    } finally {
-      this.close();
-    }
-  }
-  /**
-   * Collect all events into an array until stream completes
-   * @returns Promise<SSEEvent[]>
-   */
-  async toArray() {
-    const events = [];
-    for await (const event of this) {
-      events.push(event);
-    }
-    return events;
-  }
-  /**
-   * Pipe stream events through a transform function
-   */
-  map(transform) {
-    const mappedController = new StreamController(
-      (onEvent, onError, onComplete) => {
-        this.on("error", onError);
-        this.on("complete", onComplete);
-        this.handlers.forEach((_, eventType) => {
-          this.on(eventType, (data) => {
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        let eventData = "";
+        for (const line of lines) {
+          if (line.startsWith("data:")) {
+            eventData = line.slice(5).trim();
+          } else if (line === "" && eventData) {
             try {
-              const transformed = transform({ type: eventType, data });
-              onEvent({ type: eventType, data: transformed, raw: void 0 });
+              const data = JSON.parse(eventData);
+              stream.emit(data.type || "message", data);
             } catch (error) {
-              onError(error);
-            }
-          });
-        });
-        return () => {
-          this.close();
-        };
-      }
-    );
-    return mappedController;
-  }
-  /**
-   * Filter events based on a predicate
-   */
-  filter(predicate) {
-    const filteredController = new StreamController(
-      (onEvent, onError, onComplete) => {
-        this.on("error", onError);
-        this.on("complete", onComplete);
-        this.handlers.forEach((_, eventType) => {
-          this.on(eventType, (data) => {
-            const event = { type: eventType, data };
-            if (predicate(event)) {
-              onEvent(event);
-            }
-          });
-        });
-        return () => {
-          this.close();
-        };
-      }
-    );
-    return filteredController;
-  }
-}
-
-function createSSEStream(url, options = {}) {
-  const { headers = {}, withCredentials = true } = options;
-  return new StreamController((onEvent, onError, onComplete) => {
-    const controller = new AbortController();
-    const { signal } = controller;
-    fetch(url, {
-      method: "GET",
-      headers: {
-        Accept: "text/event-stream",
-        ...headers
-      },
-      credentials: withCredentials ? "include" : "same-origin",
-      signal
-    }).then(async (response) => {
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-      }
-      if (!response.body) {
-        throw new Error("Response body is null");
-      }
-      const reader = response.body.getReader();
-      const decoder = new TextDecoder();
-      let buffer = "";
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) {
-            onComplete();
-            break;
-          }
-          buffer += decoder.decode(value, { stream: true });
-          const lines = buffer.split("\n");
-          buffer = lines.pop() || "";
-          let eventType = "";
-          let eventData = "";
-          for (const line of lines) {
-            if (line.startsWith("event:")) {
-              eventType = line.slice(6).trim();
-            } else if (line.startsWith("data:")) {
-              eventData = line.slice(5).trim();
-            } else if (line === "" && eventData) {
-              try {
-                const parsedData = JSON.parse(eventData);
-                onEvent({
-                  type: eventType || "message",
-                  data: parsedData,
-                  raw: eventData
-                });
-              } catch {
-                onEvent({
-                  type: eventType || "message",
-                  data: eventData,
-                  raw: eventData
-                });
-              }
-              eventType = "";
-              eventData = "";
+              console.error("Failed to parse SSE event:", error);
             }
+            eventData = "";
           }
         }
-      } catch (error) {
-        if (error instanceof Error && error.name !== "AbortError") {
-          onError(error);
-        }
       }
-    }).catch((error) => {
-      if (error.name !== "AbortError") {
-        onError(error);
+    } catch (error) {
+      if (error instanceof Error && error.name !== "AbortError") {
+        stream.emit("error", error);
       }
-    });
-    return () => {
-      controller.abort();
-    };
+    }
+  }).catch((error) => {
+    if (error.name !== "AbortError") {
+      stream.emit("error", error);
+    }
   });
+  return stream;
 }
 function createSSEStreamPost(url, body, options = {}) {
   const { headers = {}, withCredentials = true } = options;
-  return new StreamController((onEvent, onError, onComplete) => {
-    const controller = new AbortController();
-    const { signal } = controller;
-    fetch(url, {
-      method: "POST",
-      headers: {
-        "Accept": "text/event-stream",
-        "Content-Type": "application/json",
-        ...headers
-      },
-      credentials: withCredentials ? "include" : "same-origin",
-      body: JSON.stringify(body),
-      signal
-    }).then(async (response) => {
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-      }
-      if (!response.body) {
-        throw new Error("Response body is null");
-      }
-      const reader = response.body.getReader();
-      const decoder = new TextDecoder();
-      let buffer = "";
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) {
-            onComplete();
-            break;
-          }
-          buffer += decoder.decode(value, { stream: true });
-          const lines = buffer.split("\n");
-          buffer = lines.pop() || "";
-          let eventType = "";
-          let eventData = "";
-          for (const line of lines) {
-            if (line.startsWith("event:")) {
-              eventType = line.slice(6).trim();
-            } else if (line.startsWith("data:")) {
-              eventData = line.slice(5).trim();
-            } else if (line === "" && eventData) {
-              try {
-                const parsedData = JSON.parse(eventData);
-                onEvent({
-                  type: eventType || "message",
-                  data: parsedData,
-                  raw: eventData
-                });
-              } catch {
-                onEvent({
-                  type: eventType || "message",
-                  data: eventData,
-                  raw: eventData
-                });
-              }
-              eventType = "";
-              eventData = "";
+  const controller = new AbortController();
+  const stream = new StreamController(() => {
+    controller.abort();
+  });
+  fetch(url, {
+    method: "POST",
+    headers: {
+      "Accept": "text/event-stream",
+      "Content-Type": "application/json",
+      ...headers
+    },
+    credentials: withCredentials ? "include" : "same-origin",
+    body: JSON.stringify(body),
+    signal: controller.signal
+  }).then(async (response) => {
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          stream.emit("complete", {});
+          break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        let eventData = "";
+        for (const line of lines) {
+          if (line.startsWith("data:")) {
+            eventData = line.slice(5).trim();
+          } else if (line === "" && eventData) {
+            try {
+              const data = JSON.parse(eventData);
+              stream.emit(data.type || "message", data);
+            } catch (error) {
+              console.error("Failed to parse SSE event:", error);
             }
+            eventData = "";
           }
         }
-      } catch (error) {
-        if (error instanceof Error && error.name !== "AbortError") {
-          onError(error);
-        }
       }
-    }).catch((error) => {
-      if (error.name !== "AbortError") {
-        onError(error);
+    } catch (error) {
+      if (error instanceof Error && error.name !== "AbortError") {
+        stream.emit("error", error);
       }
-    });
-    return () => {
-      controller.abort();
-    };
+    }
+  }).catch((error) => {
+    if (error.name !== "AbortError") {
+      stream.emit("error", error);
+    }
   });
+  return stream;
 }
 
 const basicAuthHeader = { Authorization: "Basic YmFnZWxfdXNlcm5hbWU6Tm90U2VjdXJlQGJhZ2Vs" };