@bagelink/sdk 1.7.101 → 1.8.3

package/dist/index.mjs

@@ -1,5 +1,111 @@
 import axios$1 from 'axios';
 
+function isSSEStream(operation) {
+  const responses = operation.responses || {};
+  for (const [statusCode, response] of Object.entries(responses)) {
+    if (!statusCode.startsWith("2")) continue;
+    if ("$ref" in response) continue;
+    const content = response.content || {};
+    const contentTypes = Object.keys(content);
+    if (contentTypes.length > 0) {
+      if ("text/event-stream" in content) {
+        return true;
+      }
+    }
+  }
+  const hasDefinedContentTypes = Object.entries(responses).some(([statusCode, response]) => {
+    if (!statusCode.startsWith("2")) return false;
+    if ("$ref" in response) return false;
+    const content = response.content || {};
+    return Object.keys(content).length > 0;
+  });
+  if (hasDefinedContentTypes) {
+    return false;
+  }
+  const description = operation.description?.toLowerCase() || "";
+  const summary = operation.summary?.toLowerCase() || "";
+  const hasExplicitSSEMention = /\bsse\b/.test(description) || /server-sent events/i.test(description) || /text\/event-stream/i.test(description) || /\bsse\b/.test(summary);
+  return hasExplicitSSEMention;
+}
+function extractSSEEventTypes(operation) {
+  const description = operation.description || "";
+  const types = /* @__PURE__ */ new Set();
+  const markdownMatches = description.matchAll(/^\d+\.\s+\*\*([a-z_]+)\*\*/gm);
+  for (const match of markdownMatches) {
+    types.add(match[1]);
+  }
+  const typeMatches = description.matchAll(/type:\s*"([^"]+)"/g);
+  for (const match of typeMatches) {
+    types.add(match[1]);
+  }
+  const responses = operation.responses || {};
+  for (const response of Object.values(responses)) {
+    if ("content" in response) {
+      const content = response.content || {};
+      const eventStream = content["text/event-stream"];
+      if (eventStream?.example) {
+        const exampleMatches = eventStream.example.matchAll(/^event:\s*([a-z_]+)/gm);
+        for (const match of exampleMatches) {
+          types.add(match[1]);
+        }
+      }
+    }
+  }
+  return types.size > 0 ? Array.from(types).sort() : void 0;
+}
+function extractSSEEventInfo(operation) {
+  const description = operation.description || "";
+  const eventInfos = [];
+  const eventSections = description.split(/(?=^\d+\.\s+\*\*)/m);
+  for (const section of eventSections) {
+    const eventMatch = section.match(/^\d+\.\s+\*\*([a-z_]+)\*\*:\s*([^\n]+)/m);
+    if (!eventMatch) continue;
+    const [, eventName, eventDescription] = eventMatch;
+    const fields = [];
+    const fieldMatches = section.matchAll(/^\s+[-*]\s+`([^`]+)`:\s*([^\n]+)/gm);
+    for (const fieldMatch of fieldMatches) {
+      const [, fieldName, fieldDescription] = fieldMatch;
+      fields.push({
+        name: fieldName,
+        description: fieldDescription.trim()
+      });
+    }
+    eventInfos.push({
+      name: eventName,
+      description: eventDescription,
+      fields: fields.length > 0 ? fields : void 0
+    });
+  }
+  if (eventInfos.length === 0) {
+    const responses = operation.responses || {};
+    for (const response of Object.values(responses)) {
+      if ("content" in response) {
+        const content = response.content || {};
+        const eventStream = content["text/event-stream"];
+        if (eventStream?.example) {
+          const exampleMatches = eventStream.example.matchAll(/data:\s*(\{[^}]+\})/g);
+          const seenEvents = /* @__PURE__ */ new Set();
+          for (const match of exampleMatches) {
+            try {
+              const data = JSON.parse(match[1]);
+              if (data.type && !seenEvents.has(data.type)) {
+                seenEvents.add(data.type);
+                const fields = Object.keys(data).filter((key) => key !== "type" && key !== "sequence").map((key) => ({ name: key }));
+                eventInfos.push({
+                  name: data.type,
+                  fields: fields.length > 0 ? fields : void 0
+                });
+              }
+            } catch {
+            }
+          }
+        }
+      }
+    }
+  }
+  return eventInfos.length > 0 ? eventInfos : void 0;
+}
+
 function getPath(pathsObject, path) {
   return pathsObject ? pathsObject[path] : void 0;
 }
@@ -278,6 +384,8 @@ const primitiveTypes = [
 ];
 const functionsInventory = {};
 const pathOperations = [];
+const streamEventTypes = {};
+const streamEventInfo = {};
 function collectTypeForImportStatement(typeName) {
   typeName = typeName.trim().replace("[]", "");
   if (typeName.includes("|")) {
@@ -441,6 +549,77 @@ 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";
+  const pathForUrl = formattedPath.startsWith("`") ? formattedPath.slice(1, -1) : formattedPath.slice(1, -1);
+  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}}${pathForUrl}\`
+    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}}${pathForUrl}\`
+    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 = "";
@@ -498,6 +677,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);
@@ -526,6 +706,22 @@ 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);
+    const eventInfo = extractSSEEventInfo(operation);
+    const streamTypeName = generateStreamTypeName(path);
+    if (eventInfo?.length) {
+      streamEventInfo[streamTypeName] = eventInfo;
+    }
+    return functionComment + generateStreamFunction(
+      method,
+      path,
+      formatPathWithParams(path),
+      allParams,
+      requestBodyPayload,
+      eventTypes
+    );
+  }
   return functionComment + generateAxiosFunction(
     method,
     formatPathWithParams(path),
@@ -621,10 +817,79 @@ 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)) {
+    const eventInfo = streamEventInfo[typeName];
+    typeDefs += `/**
+ * Event types for ${typeName.replace("StreamEvents", "")} stream
+`;
+    typeDefs += ` * Events: ${events.map((e) => `"${e}"`).join(", ")}
+`;
+    if (eventInfo?.length) {
+      typeDefs += ` *
+`;
+      for (const info of eventInfo) {
+        typeDefs += ` * - **${info.name}**: ${info.description || "Event data"}
+`;
+      }
+    }
+    typeDefs += ` */
+`;
+    typeDefs += `export interface ${typeName} {
+`;
+    if (eventInfo?.length) {
+      for (const info of eventInfo) {
+        typeDefs += `  /**
+   * ${info.description || info.name}
+`;
+        if (info.fields?.length) {
+          info.fields.forEach((field) => {
+            typeDefs += `   * - \`${field.name}\`: ${field.description || "Field data"}
+`;
+          });
+        }
+        typeDefs += `   */
+`;
+        if (info.fields?.length) {
+          typeDefs += `  ${info.name}: {
+`;
+          for (const field of info.fields) {
+            typeDefs += `    /** ${field.description || field.name} */
+`;
+            typeDefs += `    ${field.name}: any
+`;
+          }
+          typeDefs += `  }
+`;
+        } else {
+          typeDefs += `  ${info.name}: any
+`;
+        }
+      }
+    } else {
+      for (const event of events) {
+        typeDefs += `  /** ${event} event data */
+`;
+        typeDefs += `  ${event}: any
+`;
+      }
+    }
+    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
@@ -638,6 +903,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
@@ -691,6 +974,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 {
@@ -1000,4 +1707,4 @@ class Bagel {
   }
 }
 
-export { Bagel, dereference, formatAPIErrorMessage, getPath, isReferenceObject, isSchemaObject, index as openAPI };
+export { Bagel, StreamController, createSSEStream, createSSEStreamPost, dereference, extractSSEEventInfo, extractSSEEventTypes, formatAPIErrorMessage, getPath, isReferenceObject, isSSEStream, isSchemaObject, index as openAPI };