@ariestools/sdk 7.0.6 → 7.0.8

package/dist/_pkg/fetch/neutral/index.mjs

@@ -1,364 +0,0 @@
-// src/FetchError.ts
-var fetchErrorMarker = "$$xylabs-fetch-error";
-var codeTypes = {
-  ENOTFOUND: "dns",
-  EAI_AGAIN: "dns",
-  ECONNREFUSED: "connection-refused",
-  ECONNRESET: "connection-reset",
-  EPIPE: "connection-reset",
-  ETIMEDOUT: "connection-timeout",
-  UND_ERR_CONNECT_TIMEOUT: "connection-timeout",
-  UND_ERR_HEADERS_TIMEOUT: "timeout",
-  UND_ERR_BODY_TIMEOUT: "timeout",
-  EHOSTUNREACH: "unreachable",
-  ENETUNREACH: "unreachable",
-  CERT_HAS_EXPIRED: "tls",
-  DEPTH_ZERO_SELF_SIGNED_CERT: "tls",
-  UNABLE_TO_VERIFY_LEAF_SIGNATURE: "tls",
-  SELF_SIGNED_CERT_IN_CHAIN: "tls",
-  ERR_TLS_CERT_ALTNAME_INVALID: "tls"
-};
-function findErrorCode(error) {
-  let current = error;
-  for (let depth = 0; depth < 8 && current instanceof Error; depth++) {
-    const code = current.code;
-    if (typeof code === "string") return code;
-    current = current.cause;
-  }
-  return void 0;
-}
-function typeFromCode(code) {
-  if (Object.hasOwn(codeTypes, code)) return codeTypes[code];
-  if (code.startsWith("CERT_") || code.startsWith("ERR_TLS_")) return "tls";
-  return void 0;
-}
-function classifyFetchError(error) {
-  if (error instanceof Error) {
-    if (error.name === "TimeoutError") return { type: "timeout" };
-    if (error.name === "AbortError") return { type: "aborted" };
-  }
-  const code = findErrorCode(error);
-  if (code !== void 0) {
-    const type = typeFromCode(code);
-    if (type !== void 0) return { type, code };
-    return { type: "unknown", code };
-  }
-  if (error instanceof TypeError && /fetch failed|failed to fetch|network/i.test(error.message)) {
-    return { type: "network" };
-  }
-  return { type: "unknown" };
-}
-var FetchError = class extends Error {
-  __fetchErrorMarker = fetchErrorMarker;
-  body;
-  code;
-  method;
-  response;
-  status;
-  statusText;
-  type;
-  url;
-  constructor(message, context = {}) {
-    super(message, { cause: context.cause });
-    this.name = "FetchError";
-    this.type = context.type ?? "unknown";
-    this.code = context.code;
-    this.url = context.url;
-    this.method = context.method;
-    this.status = context.status;
-    this.statusText = context.statusText;
-    this.response = context.response;
-    this.body = context.body;
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      type: this.type,
-      code: this.code,
-      url: this.url,
-      method: this.method,
-      status: this.status,
-      statusText: this.statusText
-    };
-  }
-};
-function isFetchError(value) {
-  return value instanceof FetchError || typeof value === "object" && value !== null && value.__fetchErrorMarker === fetchErrorMarker;
-}
-function toFetchError(error, context = {}) {
-  if (isFetchError(error)) return error;
-  const { type, code } = classifyFetchError(error);
-  const message = error instanceof Error ? error.message : String(error);
-  return new FetchError(message, {
-    ...context,
-    type,
-    code,
-    cause: error
-  });
-}
-
-// src/fetchCompress.ts
-async function gzipString(body) {
-  const blob = new Blob([body]);
-  const stream = blob.stream().pipeThrough(new CompressionStream("gzip"));
-  const response = new Response(stream);
-  return response.arrayBuffer();
-}
-async function fetchCompress(url, options = {}) {
-  const { compressMinLength = 1024, ...init } = options;
-  try {
-    if (init.body !== void 0 && init.body !== null) {
-      const bodyStr = typeof init.body === "string" ? init.body : JSON.stringify(init.body);
-      if (bodyStr.length > compressMinLength) {
-        const headers = new Headers(init.headers);
-        headers.set("Content-Encoding", "gzip");
-        return await fetch(url, {
-          ...init,
-          body: await gzipString(bodyStr),
-          headers
-        });
-      }
-    }
-    return await fetch(url, init);
-  } catch (error) {
-    throw toFetchError(error, { url: url.toString(), method: init.method });
-  }
-}
-
-// src/parseJson.ts
-async function parseJsonResponse(response, context = {}) {
-  let text;
-  try {
-    text = await response.text();
-  } catch (error) {
-    throw toFetchError(error, context);
-  }
-  if (text.trim() === "") return null;
-  try {
-    return JSON.parse(text);
-  } catch (error) {
-    throw new FetchError("Failed to parse response body as JSON", {
-      type: "parse",
-      url: context.url,
-      method: context.method,
-      status: response.status,
-      statusText: response.statusText,
-      body: text,
-      cause: error
-    });
-  }
-}
-async function tryParseJson(response) {
-  try {
-    const text = await response.text();
-    if (text.trim() === "") return null;
-    return JSON.parse(text);
-  } catch {
-    return null;
-  }
-}
-
-// src/FetchClient.ts
-var FetchClientError = class extends FetchError {
-  config;
-  constructor(message, response, config) {
-    super(message, {
-      type: "http-status",
-      url: config.url,
-      method: config.method,
-      status: response.status,
-      statusText: response.statusText,
-      response
-    });
-    this.name = "FetchClientError";
-    this.config = config;
-  }
-};
-function buildHeaders(custom, includeContentType = false) {
-  const headers = new Headers();
-  headers.set("Accept", "application/json, text/plain, *.*");
-  if (includeContentType) {
-    headers.set("Content-Type", "application/json");
-  }
-  if (custom) {
-    const merged = new Headers(custom);
-    for (const [key, value] of merged.entries()) headers.set(key, value);
-  }
-  return headers;
-}
-function buildURL(config) {
-  const base = config.baseURL ?? "";
-  const path = config.url ?? "";
-  const url = base === "" ? new URL(path) : new URL(path, base);
-  if (config.params) {
-    for (const [key, value] of Object.entries(config.params)) {
-      url.searchParams.set(key, value);
-    }
-  }
-  return url.href;
-}
-var FetchClient = class _FetchClient {
-  defaults;
-  constructor(defaults = {}) {
-    this.defaults = defaults;
-  }
-  static create(config) {
-    return new _FetchClient(config);
-  }
-  delete(url, config) {
-    return this.request({
-      ...config,
-      url,
-      method: "DELETE"
-    });
-  }
-  get(url, config) {
-    return this.request({
-      ...config,
-      url,
-      method: "GET"
-    });
-  }
-  patch(url, data, config) {
-    return this.request({
-      ...config,
-      url,
-      data,
-      method: "PATCH"
-    });
-  }
-  post(url, data, config) {
-    return this.request({
-      ...config,
-      url,
-      data,
-      method: "POST"
-    });
-  }
-  put(url, data, config) {
-    return this.request({
-      ...config,
-      url,
-      data,
-      method: "PUT"
-    });
-  }
-  async request(config) {
-    const merged = { ...this.defaults, ...config };
-    const url = buildURL(merged);
-    const init = {
-      method: merged.method ?? "GET",
-      headers: buildHeaders(merged.headers, merged.data !== void 0),
-      compressMinLength: merged.compressMinLength,
-      signal: merged.timeout !== void 0 && merged.timeout !== 0 ? AbortSignal.timeout(merged.timeout) : merged.signal
-    };
-    if (merged.data !== void 0) {
-      init.body = JSON.stringify(merged.data);
-    }
-    const response = await fetchCompress(url, init);
-    const data = response.ok ? await parseJsonResponse(response, { url, method: merged.method }) : await tryParseJson(response);
-    const result = {
-      data,
-      headers: response.headers,
-      response,
-      status: response.status,
-      statusText: response.statusText
-    };
-    const validateStatus = merged.validateStatus === void 0 ? (s) => s >= 200 && s < 300 : merged.validateStatus;
-    if (validateStatus && !validateStatus(response.status)) {
-      throw new FetchClientError(
-        `Request failed with status ${response.status} ${response.statusText}`,
-        result,
-        { ...merged, url }
-      );
-    }
-    return result;
-  }
-};
-
-// src/fetchJson.ts
-function buildHeaders2(custom, includeContentType = false) {
-  const headers = new Headers();
-  headers.set("Accept", "application/json, text/plain, *.*");
-  if (includeContentType) {
-    headers.set("Content-Type", "application/json");
-  }
-  if (custom) {
-    const merged = new Headers(custom);
-    for (const [key, value] of merged.entries()) headers.set(key, value);
-  }
-  return headers;
-}
-async function fetchJson(url, options = {}) {
-  const { headers: customHeaders, ...rest } = options;
-  const response = await fetchCompress(url, {
-    ...rest,
-    headers: buildHeaders2(customHeaders, rest.body !== void 0 && rest.body !== null)
-  });
-  const data = response.ok ? await parseJsonResponse(response, { url, method: rest.method }) : await tryParseJson(response);
-  return {
-    data,
-    headers: response.headers,
-    response,
-    status: response.status,
-    statusText: response.statusText
-  };
-}
-
-// src/FetchJsonClient.ts
-var FetchJsonClient = class _FetchJsonClient extends FetchClient {
-  constructor(config) {
-    super(config);
-  }
-  static create(config) {
-    return new _FetchJsonClient(config);
-  }
-};
-var fetchJsonClient = new FetchJsonClient();
-
-// src/methods.ts
-function fetchJsonGet(url, options) {
-  return fetchJson(url, { ...options, method: "GET" });
-}
-function fetchJsonPost(url, data, options) {
-  return fetchJson(url, {
-    ...options,
-    body: JSON.stringify(data),
-    method: "POST"
-  });
-}
-function fetchJsonPut(url, data, options) {
-  return fetchJson(url, {
-    ...options,
-    body: JSON.stringify(data),
-    method: "PUT"
-  });
-}
-function fetchJsonPatch(url, data, options) {
-  return fetchJson(url, {
-    ...options,
-    body: JSON.stringify(data),
-    method: "PATCH"
-  });
-}
-function fetchJsonDelete(url, options) {
-  return fetchJson(url, { ...options, method: "DELETE" });
-}
-export {
-  FetchClient,
-  FetchClientError,
-  FetchError,
-  FetchJsonClient,
-  classifyFetchError,
-  fetchCompress,
-  fetchJson,
-  fetchJsonClient,
-  fetchJsonDelete,
-  fetchJsonGet,
-  fetchJsonPatch,
-  fetchJsonPost,
-  fetchJsonPut,
-  isFetchError,
-  toFetchError
-};

package/dist/_pkg/fetch/neutral/methods.d.ts

@@ -1,11 +0,0 @@
-import type { FetchJsonOptions, FetchJsonResponse } from './types.ts';
-/** JSON GET request. */
-export declare function fetchJsonGet<T>(url: string, options?: FetchJsonOptions): Promise<FetchJsonResponse<T>>;
-/** JSON POST request with a body. */
-export declare function fetchJsonPost<T>(url: string, data?: unknown, options?: FetchJsonOptions): Promise<FetchJsonResponse<T>>;
-/** JSON PUT request with a body. */
-export declare function fetchJsonPut<T>(url: string, data?: unknown, options?: FetchJsonOptions): Promise<FetchJsonResponse<T>>;
-/** JSON PATCH request with a body. */
-export declare function fetchJsonPatch<T>(url: string, data?: unknown, options?: FetchJsonOptions): Promise<FetchJsonResponse<T>>;
-/** JSON DELETE request. */
-export declare function fetchJsonDelete<T>(url: string, options?: FetchJsonOptions): Promise<FetchJsonResponse<T>>;

package/dist/_pkg/fetch/neutral/model.d.ts

@@ -1,4 +0,0 @@
-export type { FetchClientConfig, FetchClientRequestConfig, } from './FetchClient.ts';
-export type { FetchCompressOptions } from './fetchCompress.ts';
-export type { FetchErrorContext, FetchErrorJson, FetchErrorType, } from './FetchError.ts';
-export type * from './types.ts';

package/dist/_pkg/fetch/neutral/parseJson.d.ts

@@ -1,15 +0,0 @@
-/**
- * Reads and JSON-parses a response body. An empty or whitespace-only body resolves to `null`
- * (so 204/304/HEAD and other empty responses are not treated as failures). A non-empty body that
- * cannot be parsed throws a FetchError of type `parse` carrying the raw body and status. A failure
- * while reading the body stream (e.g. a dropped connection) is classified as a network FetchError.
- */
-export declare function parseJsonResponse<T>(response: Response, context?: {
-    method?: string;
-    url?: string;
-}): Promise<T | null>;
-/**
- * Best-effort JSON parse for non-success responses: returns `null` on any failure
- * (empty body, malformed body, or read error) so the response can still be surfaced for inspection.
- */
-export declare function tryParseJson<T>(response: Response): Promise<T | null>;

package/dist/_pkg/fetch/neutral/types.d.ts

@@ -1,11 +0,0 @@
-import type { FetchCompressOptions } from './fetchCompress.ts';
-/** Fetch request options extended with an optional gzip compression threshold. */
-export type FetchJsonOptions = FetchCompressOptions;
-/** Structured response from a fetchJson call. */
-export interface FetchJsonResponse<T> {
-    data: T | null;
-    headers: Headers;
-    response: Response;
-    status: number;
-    statusText: string;
-}

package/dist/_pkg/forget/neutral/ForgetConfig.d.ts

@@ -1,20 +0,0 @@
-/**
- * Configuration options for fire-and-forget promises.
- */
-export interface ForgetConfig<T = any> {
-    /** Optional name for identifying the forgotten promise in logs. */
-    name?: string;
-    /** Called when the configured timeout elapses before the promise settles. The promise keeps running. */
-    onCancel?: () => void;
-    /** Called when the promise completes, with a tuple of [result, error]. */
-    onComplete?: (result: [T | undefined, Error | undefined]) => void;
-    /** Called when an exception occurs outside the promise itself. */
-    onException?: (error: Error) => void;
-    /**
-     * Timeout in milliseconds after which `onCancel` and `timeoutHandler` run.
-     * This does not abort the promise; `activeForgets` stays elevated until it settles.
-     */
-    timeout?: number;
-}
-/** Default forget configuration with a 30-second timeout. */
-export declare const defaultForgetConfig: ForgetConfig<unknown>;

package/dist/_pkg/forget/neutral/ForgetNodeConfig.d.ts

@@ -1,12 +0,0 @@
-import { type ForgetConfig } from './ForgetConfig.ts';
-/**
- * Node.js-specific forget configuration that extends ForgetConfig with process termination options.
- */
-export interface ForgetNodeConfig<T = any> extends ForgetConfig<T> {
-    /** Terminate the process on an exception that happens outside of the promise being forgotten. */
-    terminateOnException?: boolean;
-    /** Terminate the process if the promise times out. */
-    terminateOnTimeout?: boolean;
-}
-/** Default Node.js forget configuration with termination disabled. */
-export declare const defaultForgetNodeConfig: ForgetNodeConfig<unknown>;

package/dist/_pkg/forget/neutral/ForgetPromise.d.ts

@@ -1,48 +0,0 @@
-import type { Logger } from '../../logger/neutral/index.ts';
-import type { Promisable, PromiseEx } from '../../promise/neutral/index.ts';
-import { type ForgetConfig } from './ForgetConfig.ts';
-/** A function that returns a promisable value. */
-type PromisableFunction<T> = () => Promisable<T>;
-/**
- * Manages fire-and-forget promises with tracking, timeouts, and error handling.
- *
- * Timeouts are observability hooks only: they invoke `onCancel` and `timeoutHandler` but do not
- * abort or await-cleanup the underlying promise. `activeForgets` therefore counts promises that
- * are still running (unsettled), not promises still inside their configured timeout window.
- */
-export declare class ForgetPromise {
-    /**
-     * Number of forgotten promises still running (not yet settled).
-     * Decremented only when the underlying promise fulfills or rejects — not when a timeout fires.
-     */
-    static activeForgets: number;
-    /** Number of forgotten promises that threw exceptions. */
-    static exceptedForgets: number;
-    /** Logger instance used for error and warning output. */
-    static logger: Logger;
-    /** Whether any forgotten promises are still running, including any that have exceeded their timeout. */
-    static get active(): boolean;
-    /**
-     * Waits until all forgotten promises have settled.
-     * @param interval - Polling interval in milliseconds.
-     * @param timeout - Optional maximum wait time in milliseconds.
-     * @returns `0` when every forgotten promise has settled; otherwise the number still running.
-     * A non-zero return after `timeout` elapses can include promises whose timeout callback already
-     * ran but whose work is still in flight.
-     */
-    static awaitInactive(interval?: number, timeout?: number): Promise<number>;
-    /** Handles exceptions from forgotten promises by logging error details. */
-    static exceptionHandler(error: Error, { name }: ForgetConfig, externalStackTrace?: string): void;
-    /**
-     * Used to explicitly launch an async function (or Promise) with awaiting it
-     * @param promise The promise to forget
-     * @param config Configuration of forget settings
-     */
-    static forget<T>(promise: Promise<T> | PromiseEx<T> | PromisableFunction<T> | T, config?: ForgetConfig<T>): void;
-    /**
-     * Handles timeout events for forgotten promises by logging timeout details.
-     * Does not terminate the underlying promise; it may continue running after this is called.
-     */
-    static timeoutHandler(time: number, { name }: ForgetConfig, externalStackTrace?: string): void;
-}
-export {};

package/dist/_pkg/forget/neutral/ForgetPromiseNode.d.ts

@@ -1,14 +0,0 @@
-import type { Promisable } from '../../promise/neutral/index.ts';
-import { type ForgetNodeConfig } from './ForgetNodeConfig.ts';
-import { ForgetPromise } from './ForgetPromise.ts';
-/**
- * Node.js extension of ForgetPromise that can terminate the process on exceptions or timeouts.
- */
-export declare class ForgetPromiseNode extends ForgetPromise {
-    /** Handles exceptions, optionally terminating the process based on config. */
-    static exceptionHandler(error: Error, config: ForgetNodeConfig, externalStackTrace?: string): void;
-    /** Forgets a promise using Node.js-specific configuration with process termination support. */
-    static forget<T>(promise: Promisable<T>, config?: ForgetNodeConfig<T>): void;
-    /** Handles timeouts, optionally terminating the process based on config. */
-    static timeoutHandler(time: number, config: ForgetNodeConfig, externalStackTrace?: string): void;
-}

package/dist/_pkg/forget/neutral/forget.d.ts

@@ -1,9 +0,0 @@
-import { type Promisable } from '../../promise/neutral/index.ts';
-import type { ForgetConfig } from './ForgetConfig.ts';
-/**
- * Explicitly launches an async function or promise without awaiting it (fire-and-forget).
- * @param promise - The promise or promisable value to forget.
- * @param config - Optional configuration for timeout notification, error handling, and completion callbacks.
- * Timeouts notify via `onCancel` but do not stop the underlying work; see `ForgetPromise.activeForgets`.
- */
-export declare const forget: <T>(promise: Promisable<T>, config?: ForgetConfig<T>) => void;

package/dist/_pkg/forget/neutral/forgetNode.d.ts

@@ -1,8 +0,0 @@
-import { type Promisable } from '../../promise/neutral/index.ts';
-import type { ForgetNodeConfig } from './ForgetNodeConfig.ts';
-/**
- * Node.js variant of forget that can optionally terminate the process on exceptions or timeouts.
- * @param promise - The promise or promisable value to forget.
- * @param config - Optional Node.js-specific configuration including process termination options.
- */
-export declare const forgetNode: <T>(promise: Promisable<T>, config?: ForgetNodeConfig<T>) => void;

package/dist/_pkg/forget/neutral/index.d.ts

@@ -1 +0,0 @@
-export * from './node/index.ts';