@bagelink/sdk 1.7.101 → 1.7.104

package/bin/index.ts

@@ -23,6 +23,22 @@ export async function loadTypes() {
 	const apiPath = join(bagelinkDir, 'api.ts')
 	await formatAndWriteCode(apiPath, code)
 
+	// Copy streamClient utilities to generated directory
+	const streamClientSource = join(__dirname, '../src/openAPITools/streamClient.ts')
+	const streamClientDest = join(bagelinkDir, 'streamClient.ts')
+	if (fs.existsSync(streamClientSource)) {
+		const streamClientCode = fs.readFileSync(streamClientSource, 'utf-8')
+		await formatAndWriteCode(streamClientDest, streamClientCode)
+	}
+
+	// Copy StreamController to generated directory
+	const streamControllerSource = join(__dirname, '../src/openAPITools/StreamController.ts')
+	const streamControllerDest = join(bagelinkDir, 'StreamController.ts')
+	if (fs.existsSync(streamControllerSource)) {
+		const streamControllerCode = fs.readFileSync(streamControllerSource, 'utf-8')
+		await formatAndWriteCode(streamControllerDest, streamControllerCode)
+	}
+
 	const indexPath = join(bagelinkDir, 'index.ts')
 	await formatAndWriteCode(indexPath, `export * from './api'\nexport * from './types.d'`)
 

package/dist/index.cjs

@@ -6,6 +6,26 @@ function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'defau
 
 const axios__default = /*#__PURE__*/_interopDefaultCompat(axios$1);
 
+function isSSEStream(operation) {
+  const description = operation.description?.toLowerCase() || "";
+  const summary = operation.summary?.toLowerCase() || "";
+  const hasSSEKeywords = description.includes("sse") || description.includes("server-sent events") || description.includes("event stream") || summary.includes("stream");
+  const responses = operation.responses || {};
+  const hasEventStreamContentType = Object.values(responses).some((response) => {
+    if ("content" in response) {
+      return "text/event-stream" in (response.content || {});
+    }
+    return false;
+  });
+  return hasSSEKeywords || hasEventStreamContentType;
+}
+function extractSSEEventTypes(operation) {
+  const description = operation.description || "";
+  const typeMatches = description.matchAll(/type:\s*"([^"]+)"/g);
+  const types = Array.from(typeMatches).map((match) => match[1]);
+  return types.length > 0 ? types : void 0;
+}
+
 function getPath(pathsObject, path) {
   return pathsObject ? pathsObject[path] : void 0;
 }
@@ -284,6 +304,7 @@ const primitiveTypes = [
 ];
 const functionsInventory = {};
 const pathOperations = [];
+const streamEventTypes = {};
 function collectTypeForImportStatement(typeName) {
   typeName = typeName.trim().replace("[]", "");
   if (typeName.includes("|")) {
@@ -447,6 +468,76 @@ function combineAllParams(parameters, requestBodyParam) {
   }).join(", ");
   return `{ ${destructuredNames} }: { ${typeDefinition} } = {}`;
 }
+function generateStreamTypeName(path) {
+  return `${toPascalCase(
+    path.split("/").filter((p) => p && !/\{|\}/.test(p)).join("_")
+  )}StreamEvents`;
+}
+function generateStreamFunction(method, path, formattedPath, allParams, requestBodyPayload, eventTypes) {
+  if (allParams === "undefined") {
+    allParams = "";
+  }
+  const bodyVar = requestBodyPayload || "{}";
+  const baseUrlRef = 'axios.defaults.baseURL || ""';
+  const streamTypeName = generateStreamTypeName(path);
+  if (eventTypes?.length) {
+    streamEventTypes[streamTypeName] = eventTypes;
+  }
+  const eventTypesComment = eventTypes?.length ? `
+   * Event types: ${eventTypes.map((t) => `"${t}"`).join(", ")}` : "";
+  const eventTypesExample = eventTypes?.length ? eventTypes.map((t) => `
+   *   .on('${t}', (data) => console.log(data))`).join("") : "\n   *   .on('message', (data) => console.log(data))";
+  const typeAnnotation = eventTypes?.length ? `StreamController<${streamTypeName}>` : "StreamController";
+  if (method === "post") {
+    return `{
+  /**
+   * Stream SSE events from this endpoint (returns StreamController)${eventTypesComment}
+   * 
+   * @example
+   * const stream = api.endpoint.stream(params)${eventTypesExample}
+   *   .on('error', (err) => console.error(err))
+   *   .on('complete', () => console.log('Done!'))
+   * 
+   * // Close stream when needed
+   * stream.close()
+   */
+  stream: (${allParams}, options?: SSEStreamOptions): ${typeAnnotation} => {
+    const url = \`\${${baseUrlRef}}${formattedPath}\`
+    return createSSEStreamPost<${streamTypeName}>(url, ${bodyVar}, options)
+  },
+  /**
+   * Regular POST request (non-streaming)
+   */
+  post: async (${allParams}): Promise<AxiosResponse<any>> => {
+    return axios.post(${formattedPath}, ${bodyVar})
+  }
+}`;
+  } else {
+    return `{
+  /**
+   * Stream SSE events from this endpoint (returns StreamController)${eventTypesComment}
+   * 
+   * @example
+   * const stream = api.endpoint.stream(params)${eventTypesExample}
+   *   .on('error', (err) => console.error(err))
+   *   .on('complete', () => console.log('Done!'))
+   * 
+   * // Close stream when needed
+   * stream.close()
+   */
+  stream: (${allParams}, options?: SSEStreamOptions): ${typeAnnotation} => {
+    const url = \`\${${baseUrlRef}}${formattedPath}\`
+    return createSSEStream<${streamTypeName}>(url, options)
+  },
+  /**
+   * Regular GET request (non-streaming)
+   */
+  get: async (${allParams}): Promise<AxiosResponse<any>> => {
+    return axios.get(${formattedPath})
+  }
+}`;
+  }
+}
 function generateAxiosFunction(method, formattedPath, allParams, responseTypeStr, parameters, requestBodyPayload) {
   if (allParams === "undefined") {
     allParams = "";
@@ -504,6 +595,7 @@ function generateFunctionForOperation(method, path, operation) {
   if (!operation) {
     return "";
   }
+  const isStream = isSSEStream(operation);
   const methodLower = method.toLowerCase();
   if (["get", "delete"].includes(methodLower) && operation.requestBody) {
     const requestBodyDeref = dereference(operation.requestBody);
@@ -532,6 +624,17 @@ function generateFunctionForOperation(method, path, operation) {
   const responseType = generateResponseType(operation.responses);
   const responseTypeStr = responseType ? `: Promise<AxiosResponse<${responseType}>>` : "";
   const functionComment = buildJSDocComment(operation, method, path);
+  if (isStream) {
+    const eventTypes = extractSSEEventTypes(operation);
+    return functionComment + generateStreamFunction(
+      method,
+      path,
+      formatPathWithParams(path),
+      allParams,
+      requestBodyPayload,
+      eventTypes
+    );
+  }
   return functionComment + generateAxiosFunction(
     method,
     formatPathWithParams(path),
@@ -627,10 +730,38 @@ export const ${parent} = ${JSON.stringify(object, void 0, 2)};
   });
   return fileTemplate(tsString, allTypes, baseUrl);
 }
+function generateStreamEventTypeDefinitions() {
+  if (Object.keys(streamEventTypes).length === 0) {
+    return "";
+  }
+  let typeDefs = "\n// ============================================================================\n";
+  typeDefs += "// Stream Event Type Definitions (Fully Typed!)\n";
+  typeDefs += "// ============================================================================\n\n";
+  for (const [typeName, events] of Object.entries(streamEventTypes)) {
+    typeDefs += `/**
+ * Event types for ${typeName.replace("StreamEvents", "")} stream
+`;
+    typeDefs += ` * Events: ${events.map((e) => `"${e}"`).join(", ")}
+ */
+`;
+    typeDefs += `export interface ${typeName} {
+`;
+    for (const event of events) {
+      typeDefs += `  /** ${event} event data */
+`;
+      typeDefs += `  ${event}: any // TODO: Define specific type from OpenAPI schema
+`;
+    }
+    typeDefs += "}\n\n";
+  }
+  return typeDefs;
+}
 function fileTemplate(tsString, typeForImport, baseURL) {
+  const streamTypeDefs = generateStreamEventTypeDefinitions();
   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';
 
 /**
  * Options for file upload operations
@@ -644,6 +775,24 @@ export interface UploadOptions {
 	tags?: string[]
 }
 
+/**
+ * Export SSE stream utilities for direct use
+ * 
+ * @example Chainable event handlers
+ * 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
  * @example
@@ -697,6 +846,430 @@ function generateTypes(schemas) {
   }).join("\n");
 }
 
+class StreamController {
+  constructor(streamFn) {
+    this.streamFn = streamFn;
+    this.abortController = new AbortController();
+    this.start();
+  }
+  handlers = /* @__PURE__ */ new Map();
+  errorHandlers = /* @__PURE__ */ new Set();
+  completeHandlers = /* @__PURE__ */ new Set();
+  abortController;
+  _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
+   * @param handler - Handler function (data type inferred from event)
+   * @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);
+    }
+    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)
+   * @returns this (for chaining)
+   */
+  once(event, handler) {
+    const wrappedHandler = (data) => {
+      handler(data);
+      this.off(event, wrappedHandler);
+    };
+    return this.on(event, wrappedHandler);
+  }
+  /**
+   * Remove an event handler (fully typed!)
+   * @param event - Event type
+   * @param handler - Handler to remove
+   * @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);
+    }
+    return this;
+  }
+  /**
+   * Remove all handlers for an event (or all events if no event specified)
+   */
+  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(event, data) {
+    const handlers = this.handlers.get(event);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(data);
+        } catch (error) {
+          console.error(`Error in handler for event "${event}":`, 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._closed = true;
+    }
+  }
+  /**
+   * Check if stream is closed
+   */
+  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;
+      });
+    }
+    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;
+      }
+    });
+    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;
+        }
+      }
+    } 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) => {
+            try {
+              const transformed = transform({ type: eventType, data });
+              onEvent({ type: eventType, data: transformed, raw: void 0 });
+            } 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 = "";
+            }
+          }
+        }
+      } catch (error) {
+        if (error instanceof Error && error.name !== "AbortError") {
+          onError(error);
+        }
+      }
+    }).catch((error) => {
+      if (error.name !== "AbortError") {
+        onError(error);
+      }
+    });
+    return () => {
+      controller.abort();
+    };
+  });
+}
+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 = "";
+            }
+          }
+        }
+      } catch (error) {
+        if (error instanceof Error && error.name !== "AbortError") {
+          onError(error);
+        }
+      }
+    }).catch((error) => {
+      if (error.name !== "AbortError") {
+        onError(error);
+      }
+    });
+    return () => {
+      controller.abort();
+    };
+  });
+}
+
 const basicAuthHeader = { Authorization: "Basic YmFnZWxfdXNlcm5hbWU6Tm90U2VjdXJlQGJhZ2Vs" };
 const index = async (openApiUrl, baseUrl) => {
   try {
@@ -1007,9 +1580,14 @@ class Bagel {
 }
 
 exports.Bagel = Bagel;
+exports.StreamController = StreamController;
+exports.createSSEStream = createSSEStream;
+exports.createSSEStreamPost = createSSEStreamPost;
 exports.dereference = dereference;
+exports.extractSSEEventTypes = extractSSEEventTypes;
 exports.formatAPIErrorMessage = formatAPIErrorMessage;
 exports.getPath = getPath;
 exports.isReferenceObject = isReferenceObject;
+exports.isSSEStream = isSSEStream;
 exports.isSchemaObject = isSchemaObject;
 exports.openAPI = index;