@blimu/client 0.7.0 → 1.1.1

package/dist/utils.js

@@ -21,9 +21,1080 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var utils_exports = {};
 __export(utils_exports, {
   listAll: () => listAll,
-  paginate: () => paginate
+  paginate: () => paginate,
+  parseNDJSONStream: () => parseNDJSONStream,
+  parseSSEStream: () => parseSSEStream
 });
 module.exports = __toCommonJS(utils_exports);
+
+// ../../node_modules/@blimu/fetch/dist/index.js
+var __defProp2 = Object.defineProperty;
+var __name = (target, value) => __defProp2(target, "name", { value, configurable: true });
+var FetchError = class _FetchError extends Error {
+  static {
+    __name(this, "FetchError");
+  }
+  status;
+  data;
+  headers;
+  constructor(message, status, data, headers) {
+    super(message), this.status = status, this.data = data, this.headers = headers;
+    this.name = "FetchError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _FetchError);
+    }
+  }
+};
+var ClientError = class extends FetchError {
+  static {
+    __name(this, "ClientError");
+  }
+  constructor(message, status, data, headers) {
+    super(message, status, data, headers);
+    this.name = "ClientError";
+  }
+};
+var ServerError = class extends FetchError {
+  static {
+    __name(this, "ServerError");
+  }
+  constructor(message, status, data, headers) {
+    super(message, status, data, headers);
+    this.name = "ServerError";
+  }
+};
+var BadRequestError = class extends ClientError {
+  static {
+    __name(this, "BadRequestError");
+  }
+  constructor(message = "Bad Request", data, headers) {
+    super(message, 400, data, headers);
+    this.name = "BadRequestError";
+  }
+};
+var UnauthorizedError = class extends ClientError {
+  static {
+    __name(this, "UnauthorizedError");
+  }
+  constructor(message = "Unauthorized", data, headers) {
+    super(message, 401, data, headers);
+    this.name = "UnauthorizedError";
+  }
+};
+var ForbiddenError = class extends ClientError {
+  static {
+    __name(this, "ForbiddenError");
+  }
+  constructor(message = "Forbidden", data, headers) {
+    super(message, 403, data, headers);
+    this.name = "ForbiddenError";
+  }
+};
+var NotFoundError = class extends ClientError {
+  static {
+    __name(this, "NotFoundError");
+  }
+  constructor(message = "Not Found", data, headers) {
+    super(message, 404, data, headers);
+    this.name = "NotFoundError";
+  }
+};
+var MethodNotAllowedError = class extends ClientError {
+  static {
+    __name(this, "MethodNotAllowedError");
+  }
+  constructor(message = "Method Not Allowed", data, headers) {
+    super(message, 405, data, headers);
+    this.name = "MethodNotAllowedError";
+  }
+};
+var ConflictError = class extends ClientError {
+  static {
+    __name(this, "ConflictError");
+  }
+  constructor(message = "Conflict", data, headers) {
+    super(message, 409, data, headers);
+    this.name = "ConflictError";
+  }
+};
+var UnprocessableEntityError = class extends ClientError {
+  static {
+    __name(this, "UnprocessableEntityError");
+  }
+  constructor(message = "Unprocessable Entity", data, headers) {
+    super(message, 422, data, headers);
+    this.name = "UnprocessableEntityError";
+  }
+};
+var TooManyRequestsError = class extends ClientError {
+  static {
+    __name(this, "TooManyRequestsError");
+  }
+  constructor(message = "Too Many Requests", data, headers) {
+    super(message, 429, data, headers);
+    this.name = "TooManyRequestsError";
+  }
+};
+var InternalServerError = class extends ServerError {
+  static {
+    __name(this, "InternalServerError");
+  }
+  constructor(message = "Internal Server Error", data, headers) {
+    super(message, 500, data, headers);
+    this.name = "InternalServerError";
+  }
+};
+var BadGatewayError = class extends ServerError {
+  static {
+    __name(this, "BadGatewayError");
+  }
+  constructor(message = "Bad Gateway", data, headers) {
+    super(message, 502, data, headers);
+    this.name = "BadGatewayError";
+  }
+};
+var ServiceUnavailableError = class extends ServerError {
+  static {
+    __name(this, "ServiceUnavailableError");
+  }
+  constructor(message = "Service Unavailable", data, headers) {
+    super(message, 503, data, headers);
+    this.name = "ServiceUnavailableError";
+  }
+};
+var GatewayTimeoutError = class extends ServerError {
+  static {
+    __name(this, "GatewayTimeoutError");
+  }
+  constructor(message = "Gateway Timeout", data, headers) {
+    super(message, 504, data, headers);
+    this.name = "GatewayTimeoutError";
+  }
+};
+function createFetchError(status, message, data, headers) {
+  const defaultMessage = message || `HTTP ${status}`;
+  switch (status) {
+    case 400:
+      return new BadRequestError(defaultMessage, data, headers);
+    case 401:
+      return new UnauthorizedError(defaultMessage, data, headers);
+    case 403:
+      return new ForbiddenError(defaultMessage, data, headers);
+    case 404:
+      return new NotFoundError(defaultMessage, data, headers);
+    case 405:
+      return new MethodNotAllowedError(defaultMessage, data, headers);
+    case 409:
+      return new ConflictError(defaultMessage, data, headers);
+    case 422:
+      return new UnprocessableEntityError(defaultMessage, data, headers);
+    case 429:
+      return new TooManyRequestsError(defaultMessage, data, headers);
+    // Generic 4xx
+    case 402:
+    case 406:
+    case 407:
+    case 408:
+    case 410:
+    case 411:
+    case 412:
+    case 413:
+    case 414:
+    case 415:
+    case 416:
+    case 417:
+    case 418:
+    case 421:
+    case 423:
+    case 424:
+    case 425:
+    case 426:
+    case 428:
+    case 431:
+    case 451:
+      return new ClientError(defaultMessage, status, data, headers);
+    // 5xx Server Errors
+    case 500:
+      return new InternalServerError(defaultMessage, data, headers);
+    case 502:
+      return new BadGatewayError(defaultMessage, data, headers);
+    case 503:
+      return new ServiceUnavailableError(defaultMessage, data, headers);
+    case 504:
+      return new GatewayTimeoutError(defaultMessage, data, headers);
+    // Generic 5xx
+    case 501:
+    case 505:
+    case 506:
+    case 507:
+    case 508:
+    case 510:
+    case 511:
+      return new ServerError(defaultMessage, status, data, headers);
+    default:
+      return new FetchError(defaultMessage, status, data, headers);
+  }
+}
+__name(createFetchError, "createFetchError");
+var HookRegistry = class {
+  static {
+    __name(this, "HookRegistry");
+  }
+  hooks = /* @__PURE__ */ new Map();
+  constructor(config) {
+    if (config) {
+      this.registerFromConfig(config);
+    }
+  }
+  /**
+  * Register hooks from a configuration object
+  */
+  registerFromConfig(config) {
+    for (const [stage, hooks] of Object.entries(config)) {
+      if (hooks && Array.isArray(hooks)) {
+        for (const hook of hooks) {
+          this.register(stage, hook);
+        }
+      }
+    }
+  }
+  /**
+  * Register a hook for a specific stage
+  */
+  register(stage, hook) {
+    if (!this.hooks.has(stage)) {
+      this.hooks.set(stage, []);
+    }
+    this.hooks.get(stage).push(hook);
+  }
+  /**
+  * Remove a specific hook from a stage
+  */
+  remove(stage, hook) {
+    const hooks = this.hooks.get(stage);
+    if (!hooks) {
+      return false;
+    }
+    const index = hooks.indexOf(hook);
+    if (index === -1) {
+      return false;
+    }
+    hooks.splice(index, 1);
+    return true;
+  }
+  /**
+  * Clear all hooks for a specific stage, or all hooks if no stage is provided
+  */
+  clear(stage) {
+    if (stage) {
+      this.hooks.delete(stage);
+    } else {
+      this.hooks.clear();
+    }
+  }
+  /**
+  * Get all hooks for a specific stage
+  */
+  get(stage) {
+    return this.hooks.get(stage) || [];
+  }
+  /**
+  * Execute all hooks for a specific stage in registration order
+  */
+  async execute(stage, context) {
+    const hooks = this.get(stage);
+    for (const hook of hooks) {
+      await hook(context);
+    }
+  }
+  /**
+  * Check if any hooks are registered for a stage
+  */
+  has(stage) {
+    return this.hooks.has(stage) && this.hooks.get(stage).length > 0;
+  }
+};
+var exponentialStrategy = /* @__PURE__ */ __name((attempt, baseBackoffMs) => {
+  return baseBackoffMs * Math.pow(2, attempt);
+}, "exponentialStrategy");
+var linearStrategy = /* @__PURE__ */ __name((attempt, baseBackoffMs) => {
+  return baseBackoffMs * (attempt + 1);
+}, "linearStrategy");
+function getRetryStrategy(strategy) {
+  if (typeof strategy === "function") {
+    return strategy;
+  }
+  switch (strategy) {
+    case "exponential":
+      return exponentialStrategy;
+    case "linear":
+      return linearStrategy;
+    default:
+      return exponentialStrategy;
+  }
+}
+__name(getRetryStrategy, "getRetryStrategy");
+function calculateRetryDelay(attempt, strategy, baseBackoffMs) {
+  const strategyFn = getRetryStrategy(strategy);
+  return strategyFn(attempt, baseBackoffMs);
+}
+__name(calculateRetryDelay, "calculateRetryDelay");
+async function* parseSSEStream(response) {
+  if (!response.body) {
+    return;
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, {
+        stream: true
+      });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      let currentEvent = {};
+      for (const line of lines) {
+        if (line.trim() === "") {
+          if (currentEvent.data !== void 0) {
+            yield currentEvent.data;
+          }
+          currentEvent = {};
+          continue;
+        }
+        const colonIndex = line.indexOf(":");
+        if (colonIndex === -1) continue;
+        const field = line.substring(0, colonIndex).trim();
+        const value2 = line.substring(colonIndex + 1).trim();
+        if (field === "data") {
+          currentEvent.data = currentEvent.data ? currentEvent.data + "\n" + value2 : value2;
+        } else if (field === "event") {
+          currentEvent.type = value2;
+        } else if (field === "id") {
+          currentEvent.id = value2;
+        }
+      }
+    }
+    if (buffer.trim()) {
+      const lines = buffer.split("\n");
+      let currentEvent = {};
+      for (const line of lines) {
+        if (line.trim() === "" && currentEvent.data !== void 0) {
+          yield currentEvent.data;
+          currentEvent = {};
+          continue;
+        }
+        const colonIndex = line.indexOf(":");
+        if (colonIndex !== -1) {
+          const field = line.substring(0, colonIndex).trim();
+          const value = line.substring(colonIndex + 1).trim();
+          if (field === "data") {
+            currentEvent.data = currentEvent.data ? currentEvent.data + "\n" + value : value;
+          }
+        }
+      }
+      if (currentEvent.data !== void 0) {
+        yield currentEvent.data;
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+__name(parseSSEStream, "parseSSEStream");
+async function* parseNDJSONStream(response) {
+  if (!response.body) {
+    return;
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, {
+        stream: true
+      });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed === "") continue;
+        try {
+          const parsed = JSON.parse(trimmed);
+          yield parsed;
+        } catch (error) {
+          console.warn("Skipping invalid JSON line:", trimmed);
+        }
+      }
+    }
+    if (buffer.trim()) {
+      try {
+        const parsed = JSON.parse(buffer.trim());
+        yield parsed;
+      } catch (error) {
+        console.warn("Skipping invalid JSON in buffer:", buffer.trim());
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+__name(parseNDJSONStream, "parseNDJSONStream");
+async function* parseChunkedStream(response) {
+  if (!response.body) {
+    return;
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      const chunk = decoder.decode(value, {
+        stream: true
+      });
+      yield chunk;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+__name(parseChunkedStream, "parseChunkedStream");
+function isBrowser() {
+  return typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined" && typeof globalThis.window.document !== "undefined";
+}
+__name(isBrowser, "isBrowser");
+function isNode() {
+  return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+}
+__name(isNode, "isNode");
+function encodeBase64(str) {
+  if (isBrowser()) {
+    if (typeof btoa !== "undefined") {
+      return btoa(str);
+    }
+    throw new Error("btoa is not available. This should not happen in a browser environment.");
+  } else {
+    if (typeof Buffer !== "undefined") {
+      return Buffer.from(str, "utf-8").toString("base64");
+    }
+    throw new Error("Buffer is not available. Please ensure you're running in Node.js or provide a polyfill.");
+  }
+}
+__name(encodeBase64, "encodeBase64");
+function isFetchAvailable() {
+  return typeof fetch !== "undefined";
+}
+__name(isFetchAvailable, "isFetchAvailable");
+function isAbortControllerAvailable() {
+  return typeof AbortController !== "undefined";
+}
+__name(isAbortControllerAvailable, "isAbortControllerAvailable");
+function getFetchErrorMessage() {
+  if (isBrowser()) {
+    return "fetch is not available in this browser. Please use a modern browser or provide a polyfill.";
+  } else {
+    return "fetch is not available. Node.js 22+ includes native fetch. For older versions, please provide a custom fetch implementation (e.g., from 'undici' or 'node-fetch').";
+  }
+}
+__name(getFetchErrorMessage, "getFetchErrorMessage");
+function serializeQueryParams(query) {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item !== void 0 && item !== null) {
+          params.append(key, String(item));
+        }
+      }
+    } else {
+      params.set(key, String(value));
+    }
+  }
+  return params;
+}
+__name(serializeQueryParams, "serializeQueryParams");
+function buildUrl(baseUrl, path, query) {
+  let normalizedPath = path || "";
+  if (normalizedPath.length > 1 && normalizedPath.endsWith("/")) {
+    normalizedPath = normalizedPath.slice(0, -1);
+  }
+  let normalizedBaseUrl = baseUrl || "";
+  if (normalizedBaseUrl) {
+    try {
+      const baseUrlObj = new URL(normalizedBaseUrl);
+      if (baseUrlObj.pathname && baseUrlObj.pathname !== "/" && !normalizedBaseUrl.endsWith("/")) {
+        normalizedBaseUrl = normalizedBaseUrl + "/";
+      }
+    } catch {
+    }
+  }
+  if (normalizedPath.startsWith("/")) {
+    normalizedPath = normalizedPath.slice(1);
+  }
+  const url = new URL(normalizedPath, normalizedBaseUrl);
+  if (query) {
+    const params = serializeQueryParams(query);
+    const keys = Array.from(new Set(params.keys()));
+    for (const key of keys) {
+      url.searchParams.delete(key);
+      for (const value of params.getAll(key)) {
+        url.searchParams.append(key, value);
+      }
+    }
+  }
+  return url;
+}
+__name(buildUrl, "buildUrl");
+function getContentType(body) {
+  if (body === null || body === void 0) {
+    return void 0;
+  }
+  if (body instanceof FormData) {
+    return void 0;
+  }
+  if (body instanceof URLSearchParams) {
+    return "application/x-www-form-urlencoded";
+  }
+  if (typeof body === "string") {
+    try {
+      JSON.parse(body);
+      return "application/json";
+    } catch {
+      return "text/plain";
+    }
+  }
+  if (typeof body === "object") {
+    return "application/json";
+  }
+  return void 0;
+}
+__name(getContentType, "getContentType");
+function serializeBody(body, contentType) {
+  if (body === null || body === void 0) {
+    return null;
+  }
+  if (typeof body === "string" || body instanceof FormData || body instanceof URLSearchParams || body instanceof Blob || body instanceof ArrayBuffer || ArrayBuffer.isView(body)) {
+    return body;
+  }
+  if (contentType === "application/x-www-form-urlencoded" && typeof body === "object" && body !== null && !Array.isArray(body)) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(body)) {
+      if (value !== null && value !== void 0) {
+        if (Array.isArray(value)) {
+          for (const item of value) {
+            params.append(key, String(item));
+          }
+        } else {
+          params.append(key, String(value));
+        }
+      }
+    }
+    return params;
+  }
+  if (typeof body === "object") {
+    return JSON.stringify(body);
+  }
+  return String(body);
+}
+__name(serializeBody, "serializeBody");
+async function parseResponse(response) {
+  const contentType = response.headers.get("content-type") || "";
+  if (contentType.includes("application/json")) {
+    return await response.json();
+  } else if (contentType.startsWith("text/")) {
+    return await response.text();
+  } else {
+    return await response.arrayBuffer();
+  }
+}
+__name(parseResponse, "parseResponse");
+function isSuccessResponse(response) {
+  return response.ok;
+}
+__name(isSuccessResponse, "isSuccessResponse");
+var FetchClient = class {
+  static {
+    __name(this, "FetchClient");
+  }
+  hookRegistry;
+  cfg;
+  constructor(config = {}) {
+    this.cfg = config;
+    if (!this.cfg.baseURL) {
+      this.cfg.baseURL = "";
+    }
+    this.hookRegistry = new HookRegistry(this.cfg.hooks);
+    if (!isFetchAvailable() && !this.cfg.fetch) {
+      throw new Error(getFetchErrorMessage());
+    }
+  }
+  /**
+  * Add an authentication strategy
+  */
+  addAuthStrategy(strategy) {
+    if (!this.cfg.auth) {
+      this.cfg.auth = {
+        strategies: []
+      };
+    }
+    this.cfg.auth.strategies.push(strategy);
+  }
+  /**
+  * Remove all authentication strategies
+  */
+  clearAuthStrategies() {
+    if (this.cfg.auth) {
+      this.cfg.auth.strategies = [];
+    }
+  }
+  /**
+  * Register a hook for a specific lifecycle stage
+  */
+  useHook(stage, hook) {
+    this.hookRegistry.register(stage, hook);
+  }
+  /**
+  * Remove a hook
+  */
+  removeHook(stage, hook) {
+    return this.hookRegistry.remove(stage, hook);
+  }
+  /**
+  * Clear hooks for a stage or all hooks
+  */
+  clearHooks(stage) {
+    this.hookRegistry.clear(stage);
+  }
+  /**
+  * Make an HTTP request
+  */
+  async request(init) {
+    let url = buildUrl(this.cfg.baseURL || "", init.path, init.query);
+    const headers = new Headers(this.cfg.headers || {});
+    if (init.headers) {
+      if (init.headers instanceof Headers) {
+        init.headers.forEach((value, key) => {
+          headers.set(key, value);
+        });
+      } else {
+        Object.entries(init.headers).forEach(([key, value]) => {
+          headers.set(key, String(value));
+        });
+      }
+    }
+    await this.applyAuthentication(headers, url);
+    let bodyContentType;
+    if (init.body !== void 0) {
+      bodyContentType = headers.get("Content-Type") || void 0;
+      if (!bodyContentType) {
+        bodyContentType = getContentType(init.body);
+        if (bodyContentType) {
+          headers.set("Content-Type", bodyContentType);
+        }
+      }
+    }
+    const retries = this.cfg.retry?.retries ?? 0;
+    const baseBackoff = this.cfg.retry?.backoffMs ?? 300;
+    const retryOn = this.cfg.retry?.retryOn ?? [
+      429,
+      500,
+      502,
+      503,
+      504
+    ];
+    const retryStrategy = this.cfg.retry?.strategy ?? "exponential";
+    let lastError;
+    for (let attempt = 0; attempt <= retries + 1; attempt++) {
+      try {
+        let attemptUrl = buildUrl(this.cfg.baseURL || "", init.path, init.query);
+        const attemptHeaders = new Headers(headers);
+        await this.applyAuthentication(attemptHeaders, attemptUrl);
+        return await this.doRequest(attemptUrl, init, attemptHeaders, attempt, bodyContentType);
+      } catch (err) {
+        lastError = err;
+        const shouldRetry = this.shouldRetry(err, attempt, retries, retryOn);
+        if (shouldRetry) {
+          if (this.hookRegistry.has("beforeRetry")) {
+            await this.hookRegistry.execute("beforeRetry", {
+              url: url.toString(),
+              init: {
+                ...init,
+                headers
+              },
+              attempt,
+              error: err,
+              retryCount: attempt
+            });
+          }
+          const delay = calculateRetryDelay(attempt, retryStrategy, baseBackoff);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          if (this.hookRegistry.has("afterRetry")) {
+            await this.hookRegistry.execute("afterRetry", {
+              url: url.toString(),
+              init: {
+                ...init,
+                headers
+              },
+              attempt,
+              error: err,
+              retryCount: attempt,
+              success: false
+            });
+          }
+          continue;
+        }
+        throw err;
+      }
+    }
+    throw lastError;
+  }
+  /**
+  * Make a streaming HTTP request
+  */
+  async *requestStream(init) {
+    let url = buildUrl(this.cfg.baseURL || "", init.path, init.query);
+    const headers = new Headers(this.cfg.headers || {});
+    if (init.headers) {
+      if (init.headers instanceof Headers) {
+        init.headers.forEach((value, key) => {
+          headers.set(key, value);
+        });
+      } else {
+        Object.entries(init.headers).forEach(([key, value]) => {
+          headers.set(key, String(value));
+        });
+      }
+    }
+    await this.applyAuthentication(headers, url);
+    let bodyContentType = headers.get("Content-Type") || void 0;
+    if (init.contentType && !bodyContentType) {
+      bodyContentType = init.contentType;
+      headers.set("Content-Type", bodyContentType);
+    }
+    const fetchInit = {
+      ...init,
+      headers,
+      body: serializeBody(init.body, bodyContentType)
+    };
+    if (this.cfg.credentials !== void 0) {
+      fetchInit.credentials = this.cfg.credentials;
+    }
+    if (this.hookRegistry.has("beforeRequest")) {
+      await this.hookRegistry.execute("beforeRequest", {
+        url: url.toString(),
+        init: fetchInit,
+        attempt: 0
+      });
+    }
+    let controller;
+    let timeoutId;
+    const existingSignal = fetchInit.signal;
+    if (this.cfg.timeoutMs && typeof AbortController !== "undefined") {
+      controller = new AbortController();
+      if (existingSignal) {
+        if (existingSignal.aborted) {
+          controller.abort();
+        } else {
+          existingSignal.addEventListener("abort", () => {
+            controller?.abort();
+          });
+        }
+      }
+      fetchInit.signal = controller.signal;
+      timeoutId = setTimeout(() => {
+        controller?.abort();
+        if (this.hookRegistry.has("onTimeout")) {
+          this.hookRegistry.execute("onTimeout", {
+            url: url.toString(),
+            init: fetchInit,
+            attempt: 0,
+            timeoutMs: this.cfg.timeoutMs
+          });
+        }
+      }, this.cfg.timeoutMs);
+    }
+    try {
+      const fetchFn = this.cfg.fetch || fetch;
+      const res = await fetchFn(url.toString(), fetchInit);
+      if (this.hookRegistry.has("afterRequest")) {
+        await this.hookRegistry.execute("afterRequest", {
+          url: url.toString(),
+          init: fetchInit,
+          attempt: 0,
+          response: res
+        });
+      }
+      if (!res.ok) {
+        const parsed = await parseResponse(res);
+        const error = createFetchError(res.status, parsed?.message || `HTTP ${res.status}`, parsed, res.headers);
+        if (this.hookRegistry.has("onError")) {
+          await this.hookRegistry.execute("onError", {
+            url: url.toString(),
+            init: fetchInit,
+            attempt: 0,
+            error
+          });
+        }
+        throw error;
+      }
+      if (this.hookRegistry.has("onStreamStart")) {
+        await this.hookRegistry.execute("onStreamStart", {
+          url: url.toString(),
+          init: fetchInit,
+          attempt: 0,
+          response: res
+        });
+      }
+      const streamingFormat = init.streamingFormat || "chunked";
+      if (streamingFormat === "sse") {
+        for await (const chunk of parseSSEStream(res)) {
+          let transformedChunk = chunk;
+          if (this.hookRegistry.has("onStreamChunk")) {
+            await this.hookRegistry.execute("onStreamChunk", {
+              url: url.toString(),
+              init: fetchInit,
+              attempt: 0,
+              chunk
+            });
+          }
+          yield transformedChunk;
+        }
+      } else if (streamingFormat === "ndjson") {
+        for await (const chunk of parseNDJSONStream(res)) {
+          let transformedChunk = chunk;
+          if (this.hookRegistry.has("onStreamChunk")) {
+            await this.hookRegistry.execute("onStreamChunk", {
+              url: url.toString(),
+              init: fetchInit,
+              attempt: 0,
+              chunk
+            });
+          }
+          yield transformedChunk;
+        }
+      } else {
+        for await (const chunk of parseChunkedStream(res)) {
+          let transformedChunk = chunk;
+          if (this.hookRegistry.has("onStreamChunk")) {
+            await this.hookRegistry.execute("onStreamChunk", {
+              url: url.toString(),
+              init: fetchInit,
+              attempt: 0,
+              chunk
+            });
+          }
+          yield transformedChunk;
+        }
+      }
+      if (this.hookRegistry.has("onStreamEnd")) {
+        await this.hookRegistry.execute("onStreamEnd", {
+          url: url.toString(),
+          init: fetchInit,
+          attempt: 0,
+          response: res
+        });
+      }
+    } catch (err) {
+      if (this.hookRegistry.has("onError")) {
+        await this.hookRegistry.execute("onError", {
+          url: url.toString(),
+          init: fetchInit,
+          attempt: 0,
+          error: err
+        });
+      }
+      throw err;
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    }
+  }
+  /**
+  * Internal method to execute a single request attempt
+  */
+  async doRequest(url, init, baseHeaders, attempt, contentType) {
+    const requestHeaders = baseHeaders;
+    const fetchInit = {
+      ...init,
+      headers: requestHeaders,
+      body: serializeBody(init.body, contentType)
+    };
+    if (this.cfg.credentials !== void 0) {
+      fetchInit.credentials = this.cfg.credentials;
+    }
+    if (this.hookRegistry.has("beforeRequest")) {
+      await this.hookRegistry.execute("beforeRequest", {
+        url: url.toString(),
+        init: fetchInit,
+        attempt
+      });
+    }
+    let controller;
+    let timeoutId;
+    const existingSignal = fetchInit.signal;
+    if (this.cfg.timeoutMs && typeof AbortController !== "undefined") {
+      controller = new AbortController();
+      if (existingSignal) {
+        if (existingSignal.aborted) {
+          controller.abort();
+        } else {
+          existingSignal.addEventListener("abort", () => {
+            controller?.abort();
+          });
+        }
+      }
+      fetchInit.signal = controller.signal;
+      timeoutId = setTimeout(() => {
+        controller?.abort();
+        if (this.hookRegistry.has("onTimeout")) {
+          this.hookRegistry.execute("onTimeout", {
+            url: url.toString(),
+            init: fetchInit,
+            attempt,
+            timeoutMs: this.cfg.timeoutMs
+          });
+        }
+      }, this.cfg.timeoutMs);
+    }
+    try {
+      const fetchFn = this.cfg.fetch || fetch;
+      const res = await fetchFn(url.toString(), fetchInit);
+      if (this.hookRegistry.has("afterRequest")) {
+        await this.hookRegistry.execute("afterRequest", {
+          url: url.toString(),
+          init: fetchInit,
+          attempt,
+          response: res
+        });
+      }
+      const parsed = await parseResponse(res);
+      if (this.hookRegistry.has("afterResponse")) {
+        await this.hookRegistry.execute("afterResponse", {
+          url: url.toString(),
+          init: fetchInit,
+          attempt,
+          response: res,
+          data: parsed
+        });
+      }
+      if (!isSuccessResponse(res)) {
+        const error = createFetchError(res.status, parsed?.message || `HTTP ${res.status}`, parsed, res.headers);
+        if (this.hookRegistry.has("onError")) {
+          await this.hookRegistry.execute("onError", {
+            url: url.toString(),
+            init: fetchInit,
+            attempt,
+            error
+          });
+        }
+        throw error;
+      }
+      return parsed;
+    } catch (err) {
+      if (this.hookRegistry.has("onError")) {
+        await this.hookRegistry.execute("onError", {
+          url: url.toString(),
+          init: fetchInit,
+          attempt,
+          error: err
+        });
+      }
+      if (err instanceof DOMException) {
+        throw err;
+      }
+      if (err instanceof FetchError) {
+        throw err;
+      }
+      const status = err?.status;
+      const statusCode = typeof status === "number" ? status : 0;
+      if (typeof err === "string") {
+        throw createFetchError(statusCode, err);
+      }
+      throw createFetchError(statusCode, err?.message || "Network error");
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    }
+  }
+  /**
+  * Apply authentication strategies
+  */
+  async applyAuthentication(headers, url) {
+    if (!this.cfg.auth?.strategies) {
+      return;
+    }
+    for (const strategy of this.cfg.auth.strategies) {
+      await this.applyAuthStrategy(strategy, headers, url);
+    }
+  }
+  /**
+  * Apply a single authentication strategy
+  */
+  async applyAuthStrategy(strategy, headers, url) {
+    switch (strategy.type) {
+      case "bearer": {
+        const token = typeof strategy.token === "function" ? await strategy.token() : strategy.token;
+        if (token != null) {
+          const headerName = strategy.headerName || "Authorization";
+          headers.set(headerName, `Bearer ${String(token)}`);
+        }
+        break;
+      }
+      case "basic": {
+        const encoded = encodeBase64(`${strategy.username}:${strategy.password}`);
+        headers.set("Authorization", `Basic ${encoded}`);
+        break;
+      }
+      case "apiKey": {
+        const key = typeof strategy.key === "function" ? await strategy.key() : strategy.key;
+        if (key != null) {
+          switch (strategy.location) {
+            case "header":
+              headers.set(strategy.name, String(key));
+              break;
+            case "query":
+              url.searchParams.set(strategy.name, String(key));
+              break;
+            case "cookie":
+              headers.set("Cookie", `${strategy.name}=${String(key)}`);
+              break;
+          }
+        }
+        break;
+      }
+      case "custom":
+        await strategy.apply(headers, url);
+        break;
+    }
+  }
+  /**
+  * Determine if an error should be retried
+  */
+  shouldRetry(error, attempt, maxRetries, retryOn) {
+    if (attempt >= maxRetries) {
+      return false;
+    }
+    if (this.cfg.retry?.retryOnError) {
+      return this.cfg.retry.retryOnError(error);
+    }
+    if (error instanceof FetchError) {
+      return retryOn.includes(error.status);
+    }
+    return true;
+  }
+};
+
+// src/utils.ts
 async function* paginate(fetchPage, initialQuery = {}, pageSize = 100) {
   let offset = Number(initialQuery.offset ?? 0);
   const limit = Number(initialQuery.limit ?? pageSize);
@@ -40,11 +1111,15 @@ async function* paginate(fetchPage, initialQuery = {}, pageSize = 100) {
 }
 async function listAll(fetchPage, query = {}, pageSize = 100) {
   const out = [];
-  for await (const item of paginate(fetchPage, query, pageSize)) out.push(item);
+  for await (const item of paginate(fetchPage, query, pageSize))
+    out.push(item);
   return out;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   listAll,
-  paginate
+  paginate,
+  parseNDJSONStream,
+  parseSSEStream
 });
+//# sourceMappingURL=utils.js.map