@band-ai/rest-client 0.0.113 → 0.0.118

package/dist/esm/core/fetcher/requestWithRetries.d.mts

@@ -0,0 +1 @@
+export declare function requestWithRetries(requestFn: () => Promise<Response>, maxRetries?: number): Promise<Response>;

package/dist/esm/core/fetcher/requestWithRetries.mjs

@@ -0,0 +1,67 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const INITIAL_RETRY_DELAY = 1000; // in milliseconds
+const MAX_RETRY_DELAY = 60000; // in milliseconds
+const DEFAULT_MAX_RETRIES = 2;
+const JITTER_FACTOR = 0.2; // 20% random jitter
+function isRetryableStatusCode(statusCode) {
+    return [408, 429].includes(statusCode) || statusCode >= 500;
+}
+function addPositiveJitter(delay) {
+    const jitterMultiplier = 1 + Math.random() * JITTER_FACTOR;
+    return delay * jitterMultiplier;
+}
+function addSymmetricJitter(delay) {
+    const jitterMultiplier = 1 + (Math.random() - 0.5) * JITTER_FACTOR;
+    return delay * jitterMultiplier;
+}
+function getRetryDelayFromHeaders(response, retryAttempt) {
+    const retryAfter = response.headers.get("Retry-After");
+    if (retryAfter) {
+        const retryAfterSeconds = parseInt(retryAfter, 10);
+        if (!Number.isNaN(retryAfterSeconds) && retryAfterSeconds > 0) {
+            return Math.min(retryAfterSeconds * 1000, MAX_RETRY_DELAY);
+        }
+        const retryAfterDate = new Date(retryAfter);
+        if (!Number.isNaN(retryAfterDate.getTime())) {
+            const delay = retryAfterDate.getTime() - Date.now();
+            if (delay > 0) {
+                return Math.min(Math.max(delay, 0), MAX_RETRY_DELAY);
+            }
+        }
+    }
+    const rateLimitReset = response.headers.get("X-RateLimit-Reset");
+    if (rateLimitReset) {
+        const resetTime = parseInt(rateLimitReset, 10);
+        if (!Number.isNaN(resetTime)) {
+            const delay = resetTime * 1000 - Date.now();
+            if (delay > 0) {
+                return addPositiveJitter(Math.min(delay, MAX_RETRY_DELAY));
+            }
+        }
+    }
+    return addSymmetricJitter(Math.min(INITIAL_RETRY_DELAY * Math.pow(2, retryAttempt), MAX_RETRY_DELAY));
+}
+export function requestWithRetries(requestFn_1) {
+    return __awaiter(this, arguments, void 0, function* (requestFn, maxRetries = DEFAULT_MAX_RETRIES) {
+        let response = yield requestFn();
+        for (let i = 0; i < maxRetries; ++i) {
+            if (isRetryableStatusCode(response.status)) {
+                const delay = getRetryDelayFromHeaders(response, i);
+                yield new Promise((resolve) => setTimeout(resolve, delay));
+                response = yield requestFn();
+            }
+            else {
+                break;
+            }
+        }
+        return response;
+    });
+}

package/dist/esm/core/fetcher/signals.d.mts

@@ -0,0 +1,5 @@
+export declare function getTimeoutSignal(timeoutMs: number): {
+    signal: AbortSignal;
+    abortId: ReturnType<typeof setTimeout>;
+};
+export declare function anySignal(...args: AbortSignal[] | [AbortSignal[]]): AbortSignal;

package/dist/esm/core/fetcher/signals.mjs

@@ -0,0 +1,20 @@
+const TIMEOUT = "timeout";
+export function getTimeoutSignal(timeoutMs) {
+    const controller = new AbortController();
+    const abortId = setTimeout(() => controller.abort(TIMEOUT), timeoutMs);
+    return { signal: controller.signal, abortId };
+}
+export function anySignal(...args) {
+    const signals = (args.length === 1 && Array.isArray(args[0]) ? args[0] : args);
+    const controller = new AbortController();
+    for (const signal of signals) {
+        if (signal.aborted) {
+            controller.abort(signal === null || signal === void 0 ? void 0 : signal.reason);
+            break;
+        }
+        signal.addEventListener("abort", () => controller.abort(signal === null || signal === void 0 ? void 0 : signal.reason), {
+            signal: controller.signal,
+        });
+    }
+    return controller.signal;
+}

package/dist/esm/core/headers.d.mts

@@ -0,0 +1,2 @@
+export declare function mergeHeaders(...headersArray: (Record<string, unknown> | null | undefined)[]): Record<string, unknown>;
+export declare function mergeOnlyDefinedHeaders(...headersArray: (Record<string, unknown> | null | undefined)[]): Record<string, unknown>;

package/dist/esm/core/headers.mjs

@@ -0,0 +1,27 @@
+export function mergeHeaders(...headersArray) {
+    const result = {};
+    for (const [key, value] of headersArray
+        .filter((headers) => headers != null)
+        .flatMap((headers) => Object.entries(headers))) {
+        const insensitiveKey = key.toLowerCase();
+        if (value != null) {
+            result[insensitiveKey] = value;
+        }
+        else if (insensitiveKey in result) {
+            delete result[insensitiveKey];
+        }
+    }
+    return result;
+}
+export function mergeOnlyDefinedHeaders(...headersArray) {
+    const result = {};
+    for (const [key, value] of headersArray
+        .filter((headers) => headers != null)
+        .flatMap((headers) => Object.entries(headers))) {
+        const insensitiveKey = key.toLowerCase();
+        if (value != null) {
+            result[insensitiveKey] = value;
+        }
+    }
+    return result;
+}

package/dist/esm/core/index.d.mts

@@ -0,0 +1,6 @@
+export * from "./auth/index.mjs";
+export * from "./base64.mjs";
+export * from "./fetcher/index.mjs";
+export * as logging from "./logging/index.mjs";
+export * from "./runtime/index.mjs";
+export * as url from "./url/index.mjs";

package/dist/esm/core/index.mjs

@@ -0,0 +1,6 @@
+export * from "./auth/index.mjs";
+export * from "./base64.mjs";
+export * from "./fetcher/index.mjs";
+export * as logging from "./logging/index.mjs";
+export * from "./runtime/index.mjs";
+export * as url from "./url/index.mjs";

package/dist/esm/core/json.d.mts

@@ -0,0 +1,15 @@
+/**
+ * Serialize a value to JSON
+ * @param value A JavaScript value, usually an object or array, to be converted.
+ * @param replacer A function that transforms the results.
+ * @param space Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.
+ * @returns JSON string
+ */
+export declare const toJson: (value: unknown, replacer?: (this: unknown, key: string, value: unknown) => unknown, space?: string | number) => string;
+/**
+ * Parse JSON string to object, array, or other type
+ * @param text A valid JSON string.
+ * @param reviver A function that transforms the results. This function is called for each member of the object. If a member contains nested objects, the nested objects are transformed before the parent object is.
+ * @returns Parsed object, array, or other type
+ */
+export declare function fromJson<T = unknown>(text: string, reviver?: (this: unknown, key: string, value: unknown) => unknown): T;

package/dist/esm/core/json.mjs

@@ -0,0 +1,19 @@
+/**
+ * Serialize a value to JSON
+ * @param value A JavaScript value, usually an object or array, to be converted.
+ * @param replacer A function that transforms the results.
+ * @param space Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.
+ * @returns JSON string
+ */
+export const toJson = (value, replacer, space) => {
+    return JSON.stringify(value, replacer, space);
+};
+/**
+ * Parse JSON string to object, array, or other type
+ * @param text A valid JSON string.
+ * @param reviver A function that transforms the results. This function is called for each member of the object. If a member contains nested objects, the nested objects are transformed before the parent object is.
+ * @returns Parsed object, array, or other type
+ */
+export function fromJson(text, reviver) {
+    return JSON.parse(text, reviver);
+}

package/dist/esm/core/logging/exports.d.mts

@@ -0,0 +1,18 @@
+import * as logger from "./logger.mjs";
+export declare namespace logging {
+    /**
+     * Configuration for logger instances.
+     */
+    type LogConfig = logger.LogConfig;
+    type LogLevel = logger.LogLevel;
+    const LogLevel: typeof logger.LogLevel;
+    type ILogger = logger.ILogger;
+    /**
+     * Console logger implementation that outputs to the console.
+     */
+    type ConsoleLogger = logger.ConsoleLogger;
+    /**
+     * Console logger implementation that outputs to the console.
+     */
+    const ConsoleLogger: typeof logger.ConsoleLogger;
+}

package/dist/esm/core/logging/exports.mjs

@@ -0,0 +1,9 @@
+import * as logger from "./logger.mjs";
+export var logging;
+(function (logging) {
+    logging.LogLevel = logger.LogLevel;
+    /**
+     * Console logger implementation that outputs to the console.
+     */
+    logging.ConsoleLogger = logger.ConsoleLogger;
+})(logging || (logging = {}));

package/dist/esm/core/logging/index.d.mts

@@ -0,0 +1 @@
+export * from "./logger.mjs";

package/dist/esm/core/logging/index.mjs

@@ -0,0 +1 @@
+export * from "./logger.mjs";

package/dist/esm/core/logging/logger.d.mts

@@ -0,0 +1,126 @@
+export declare const LogLevel: {
+    readonly Debug: "debug";
+    readonly Info: "info";
+    readonly Warn: "warn";
+    readonly Error: "error";
+};
+export type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
+export interface ILogger {
+    /**
+     * Logs a debug message.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    debug(message: string, ...args: unknown[]): void;
+    /**
+     * Logs an info message.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    info(message: string, ...args: unknown[]): void;
+    /**
+     * Logs a warning message.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    warn(message: string, ...args: unknown[]): void;
+    /**
+     * Logs an error message.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    error(message: string, ...args: unknown[]): void;
+}
+/**
+ * Configuration for logger initialization.
+ */
+export interface LogConfig {
+    /**
+     * Minimum log level to output.
+     * @default LogLevel.Info
+     */
+    level?: LogLevel;
+    /**
+     * Logger implementation to use.
+     * @default new ConsoleLogger()
+     */
+    logger?: ILogger;
+    /**
+     * Whether logging should be silenced.
+     * @default true
+     */
+    silent?: boolean;
+}
+/**
+ * Default console-based logger implementation.
+ */
+export declare class ConsoleLogger implements ILogger {
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+}
+/**
+ * Logger class that provides level-based logging functionality.
+ */
+export declare class Logger {
+    private readonly level;
+    private readonly logger;
+    private readonly silent;
+    /**
+     * Creates a new logger instance.
+     * @param config - Logger configuration
+     */
+    constructor(config: Required<LogConfig>);
+    /**
+     * Checks if a log level should be output based on configuration.
+     * @param level - The log level to check
+     * @returns True if the level should be logged
+     */
+    shouldLog(level: LogLevel): boolean;
+    /**
+     * Checks if debug logging is enabled.
+     * @returns True if debug logs should be output
+     */
+    isDebug(): boolean;
+    /**
+     * Logs a debug message if debug logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    debug(message: string, ...args: unknown[]): void;
+    /**
+     * Checks if info logging is enabled.
+     * @returns True if info logs should be output
+     */
+    isInfo(): boolean;
+    /**
+     * Logs an info message if info logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    info(message: string, ...args: unknown[]): void;
+    /**
+     * Checks if warning logging is enabled.
+     * @returns True if warning logs should be output
+     */
+    isWarn(): boolean;
+    /**
+     * Logs a warning message if warning logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    warn(message: string, ...args: unknown[]): void;
+    /**
+     * Checks if error logging is enabled.
+     * @returns True if error logs should be output
+     */
+    isError(): boolean;
+    /**
+     * Logs an error message if error logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    error(message: string, ...args: unknown[]): void;
+}
+export declare function createLogger(config?: LogConfig | Logger): Logger;

package/dist/esm/core/logging/logger.mjs

@@ -0,0 +1,138 @@
+export const LogLevel = {
+    Debug: "debug",
+    Info: "info",
+    Warn: "warn",
+    Error: "error",
+};
+const logLevelMap = {
+    [LogLevel.Debug]: 1,
+    [LogLevel.Info]: 2,
+    [LogLevel.Warn]: 3,
+    [LogLevel.Error]: 4,
+};
+/**
+ * Default console-based logger implementation.
+ */
+export class ConsoleLogger {
+    debug(message, ...args) {
+        console.debug(message, ...args);
+    }
+    info(message, ...args) {
+        console.info(message, ...args);
+    }
+    warn(message, ...args) {
+        console.warn(message, ...args);
+    }
+    error(message, ...args) {
+        console.error(message, ...args);
+    }
+}
+/**
+ * Logger class that provides level-based logging functionality.
+ */
+export class Logger {
+    /**
+     * Creates a new logger instance.
+     * @param config - Logger configuration
+     */
+    constructor(config) {
+        this.level = logLevelMap[config.level];
+        this.logger = config.logger;
+        this.silent = config.silent;
+    }
+    /**
+     * Checks if a log level should be output based on configuration.
+     * @param level - The log level to check
+     * @returns True if the level should be logged
+     */
+    shouldLog(level) {
+        return !this.silent && this.level <= logLevelMap[level];
+    }
+    /**
+     * Checks if debug logging is enabled.
+     * @returns True if debug logs should be output
+     */
+    isDebug() {
+        return this.shouldLog(LogLevel.Debug);
+    }
+    /**
+     * Logs a debug message if debug logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    debug(message, ...args) {
+        if (this.isDebug()) {
+            this.logger.debug(message, ...args);
+        }
+    }
+    /**
+     * Checks if info logging is enabled.
+     * @returns True if info logs should be output
+     */
+    isInfo() {
+        return this.shouldLog(LogLevel.Info);
+    }
+    /**
+     * Logs an info message if info logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    info(message, ...args) {
+        if (this.isInfo()) {
+            this.logger.info(message, ...args);
+        }
+    }
+    /**
+     * Checks if warning logging is enabled.
+     * @returns True if warning logs should be output
+     */
+    isWarn() {
+        return this.shouldLog(LogLevel.Warn);
+    }
+    /**
+     * Logs a warning message if warning logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    warn(message, ...args) {
+        if (this.isWarn()) {
+            this.logger.warn(message, ...args);
+        }
+    }
+    /**
+     * Checks if error logging is enabled.
+     * @returns True if error logs should be output
+     */
+    isError() {
+        return this.shouldLog(LogLevel.Error);
+    }
+    /**
+     * Logs an error message if error logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    error(message, ...args) {
+        if (this.isError()) {
+            this.logger.error(message, ...args);
+        }
+    }
+}
+export function createLogger(config) {
+    var _a, _b, _c;
+    if (config == null) {
+        return defaultLogger;
+    }
+    if (config instanceof Logger) {
+        return config;
+    }
+    config = config !== null && config !== void 0 ? config : {};
+    (_a = config.level) !== null && _a !== void 0 ? _a : (config.level = LogLevel.Info);
+    (_b = config.logger) !== null && _b !== void 0 ? _b : (config.logger = new ConsoleLogger());
+    (_c = config.silent) !== null && _c !== void 0 ? _c : (config.silent = true);
+    return new Logger(config);
+}
+const defaultLogger = new Logger({
+    level: LogLevel.Info,
+    logger: new ConsoleLogger(),
+    silent: true,
+});

package/dist/esm/core/runtime/index.d.mts

@@ -0,0 +1 @@
+export { RUNTIME } from "./runtime.mjs";

package/dist/esm/core/runtime/index.mjs

@@ -0,0 +1 @@
+export { RUNTIME } from "./runtime.mjs";

package/dist/esm/core/runtime/runtime.d.mts

@@ -0,0 +1,9 @@
+/**
+ * A constant that indicates which environment and version the SDK is running in.
+ */
+export declare const RUNTIME: Runtime;
+export interface Runtime {
+    type: "browser" | "web-worker" | "deno" | "bun" | "node" | "react-native" | "unknown" | "workerd" | "edge-runtime";
+    version?: string;
+    parsedVersion?: number;
+}

package/dist/esm/core/runtime/runtime.mjs

@@ -0,0 +1,101 @@
+/**
+ * A constant that indicates which environment and version the SDK is running in.
+ */
+export const RUNTIME = evaluateRuntime();
+function evaluateRuntime() {
+    var _a, _b, _c, _d, _e;
+    /**
+     * A constant that indicates whether the environment the code is running is a Web Browser.
+     */
+    const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
+    if (isBrowser) {
+        return {
+            type: "browser",
+            version: window.navigator.userAgent,
+        };
+    }
+    /**
+     * A constant that indicates whether the environment the code is running is Cloudflare.
+     * https://developers.cloudflare.com/workers/runtime-apis/web-standards/#navigatoruseragent
+     */
+    const isCloudflare = typeof globalThis !== "undefined" && ((_a = globalThis === null || globalThis === void 0 ? void 0 : globalThis.navigator) === null || _a === void 0 ? void 0 : _a.userAgent) === "Cloudflare-Workers";
+    if (isCloudflare) {
+        return {
+            type: "workerd",
+        };
+    }
+    /**
+     * A constant that indicates whether the environment the code is running is Edge Runtime.
+     * https://vercel.com/docs/functions/runtimes/edge-runtime#check-if-you're-running-on-the-edge-runtime
+     */
+    const isEdgeRuntime = typeof EdgeRuntime === "string";
+    if (isEdgeRuntime) {
+        return {
+            type: "edge-runtime",
+        };
+    }
+    /**
+     * A constant that indicates whether the environment the code is running is a Web Worker.
+     */
+    const isWebWorker = typeof self === "object" &&
+        typeof (self === null || self === void 0 ? void 0 : self.importScripts) === "function" &&
+        (((_b = self.constructor) === null || _b === void 0 ? void 0 : _b.name) === "DedicatedWorkerGlobalScope" ||
+            ((_c = self.constructor) === null || _c === void 0 ? void 0 : _c.name) === "ServiceWorkerGlobalScope" ||
+            ((_d = self.constructor) === null || _d === void 0 ? void 0 : _d.name) === "SharedWorkerGlobalScope");
+    if (isWebWorker) {
+        return {
+            type: "web-worker",
+        };
+    }
+    /**
+     * A constant that indicates whether the environment the code is running is Deno.
+     * FYI Deno spoofs process.versions.node, see https://deno.land/std@0.177.0/node/process.ts?s=versions
+     */
+    const isDeno = typeof Deno !== "undefined" && typeof Deno.version !== "undefined" && typeof Deno.version.deno !== "undefined";
+    if (isDeno) {
+        return {
+            type: "deno",
+            version: Deno.version.deno,
+        };
+    }
+    /**
+     * A constant that indicates whether the environment the code is running is Bun.sh.
+     */
+    const isBun = typeof Bun !== "undefined" && typeof Bun.version !== "undefined";
+    if (isBun) {
+        return {
+            type: "bun",
+            version: Bun.version,
+        };
+    }
+    /**
+     * A constant that indicates whether the environment the code is running is in React-Native.
+     * This check should come before Node.js detection since React Native may have a process polyfill.
+     * https://github.com/facebook/react-native/blob/main/packages/react-native/Libraries/Core/setUpNavigator.js
+     */
+    const isReactNative = typeof navigator !== "undefined" && (navigator === null || navigator === void 0 ? void 0 : navigator.product) === "ReactNative";
+    if (isReactNative) {
+        return {
+            type: "react-native",
+        };
+    }
+    /**
+     * A constant that indicates whether the environment the code is running is Node.JS.
+     *
+     * We assign `process` to a local variable first to avoid being flagged by
+     * bundlers that perform static analysis on `process.versions` (e.g. Next.js
+     * Edge Runtime warns about Node.js APIs even when they are guarded).
+     */
+    const _process = typeof process !== "undefined" ? process : undefined;
+    const isNode = typeof _process !== "undefined" && typeof ((_e = _process.versions) === null || _e === void 0 ? void 0 : _e.node) === "string";
+    if (isNode) {
+        return {
+            type: "node",
+            version: _process.versions.node,
+            parsedVersion: Number(_process.versions.node.split(".")[0]),
+        };
+    }
+    return {
+        type: "unknown",
+    };
+}

package/dist/esm/core/url/QueryStringBuilder.d.mts

@@ -0,0 +1,47 @@
+/**
+ * Creates a fluent builder for constructing URL query strings.
+ *
+ * Each `.add()` call serializes its value immediately (like C#'s builder),
+ * so no format tracking is needed — the style is applied at add-time.
+ *
+ * Usage (generated code):
+ *
+ *     const qs = core.url.queryBuilder()
+ *         .add("limit", limit)
+ *         .add("tags", tags, { style: "comma" })   // explode: false
+ *         .mergeAdditional(requestOptions?.queryParams)
+ *         .build();
+ */
+export declare function queryBuilder(): QueryStringBuilder;
+declare class QueryStringBuilder {
+    private parts;
+    /**
+     * Adds a query parameter, serializing it immediately.
+     *
+     * By default arrays use "repeat" format (`key=a&key=b`).
+     * Pass `{ style: "comma" }` for OpenAPI `explode: false` parameters
+     * to get comma-separated values (`key=a,b,c`).
+     *
+     * Null / undefined values are silently skipped.
+     */
+    add(key: string, value: unknown, options?: {
+        style?: "comma";
+    }): this;
+    /**
+     * Adds multiple query parameters at once from a record.
+     * All parameters use the default "repeat" array format.
+     * Null / undefined values are silently skipped.
+     */
+    addMany(params: Record<string, unknown>): this;
+    /**
+     * Merges additional query parameters supplied at call-time via
+     * `requestOptions.queryParams`. Overrides existing keys (last-write-wins).
+     */
+    mergeAdditional(additionalParams?: Record<string, unknown>): this;
+    /**
+     * Returns the assembled query string (without the leading `?`).
+     * Returns an empty string when no parameters were added.
+     */
+    build(): string;
+}
+export {};