@wildix/xbees-conversations-utils 1.1.93 → 1.2.1

package/dist-es/rateLimits/helpers/executeWithRateLimitHandling.js

@@ -1,140 +0,0 @@
-import { setTimeout as sleep } from 'node:timers/promises';
-import { BUDGET_COOLDOWN_SLEEP_CHUNK_MS, BUDGET_DELAY_MAX_MS, DEFAULT_JITTER_MS, DEFAULT_MAX_DELAY_MS, DEFAULT_RETRY_AFTER_MS, RETRY_AFTER_BUFFER_MS, STREAM_BUDGET_COOLDOWN_KEY, STREAM_BUDGET_COOLDOWN_KEY_PREFIX, STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX, STREAM_RATE_LIMIT_METADATA_KEY_SUFFIX, STREAM_RATE_LIMIT_SOFT_COOLDOWN_KEY, } from '../constants';
-import { createRateLimitExceededException } from './createRateLimitExceededException';
-import { processStreamRateLimitException } from './processStreamRateLimitException';
-import { parseRateLimitSnapshot, serializeRateLimitSnapshot } from './rateLimitSnapshot';
-import { RedisCooldown } from './RedisCooldown';
-function calculateRateLimitDelayMs(error, maxDelayMs) {
-    const retryAfterMs = typeof error.rateLimitReset === 'number' && error.rateLimitReset > 0 ? error.rateLimitReset : 0;
-    const hasServerRetryAfter = retryAfterMs > 0;
-    const baseDelayMs = hasServerRetryAfter ? retryAfterMs + RETRY_AFTER_BUFFER_MS : DEFAULT_RETRY_AFTER_MS;
-    if (baseDelayMs > 0) {
-        const jitterMs = Math.floor(Math.random() * DEFAULT_JITTER_MS);
-        const computedDelayMs = baseDelayMs + jitterMs;
-        if (hasServerRetryAfter) {
-            return computedDelayMs;
-        }
-        return Math.min(maxDelayMs, computedDelayMs);
-    }
-    return Math.min(maxDelayMs, DEFAULT_MAX_DELAY_MS);
-}
-function getRateLimitMetadataKey(operation) {
-    return `${operation}${STREAM_RATE_LIMIT_METADATA_KEY_SUFFIX}`;
-}
-function toCooldownRateLimit(snapshot, cooldownMs) {
-    return {
-        limit: snapshot.limit,
-        remaining: snapshot.remaining,
-        reset: Math.max(snapshot.reset, Date.now() + cooldownMs),
-    };
-}
-function toRateLimitSnapshot(error) {
-    const limit = Number(error.rateLimit);
-    const remaining = error.rateLimitRemaining;
-    const resetMs = error.rateLimitReset;
-    if (!Number.isFinite(limit) ||
-        typeof remaining !== 'number' ||
-        !Number.isFinite(remaining) ||
-        typeof resetMs !== 'number' ||
-        !Number.isFinite(resetMs) ||
-        resetMs <= 0) {
-        return;
-    }
-    return {
-        limit,
-        remaining,
-        reset: Date.now() + resetMs,
-    };
-}
-export async function executeWithRateLimitHandling(execute, operation, context, options) {
-    const { logger, redis } = context;
-    const { enableCooldown, maxAttempts, maxDelayMs, maxRetryableDelayMs } = options;
-    let attempt = 1;
-    if (enableCooldown) {
-        const cooldownMs = await RedisCooldown.getRemainingMs(operation, { redis, logger });
-        if (cooldownMs > 0) {
-            const rateLimitSnapshot = parseRateLimitSnapshot(await RedisCooldown.getValue(getRateLimitMetadataKey(operation), { redis, logger }));
-            logger.warn('Skipping stream request due to active rate-limit cooldown', {
-                operation,
-                cooldown: cooldownMs,
-                rateLimitSnapshot,
-            });
-            throw createRateLimitExceededException({
-                operation,
-                retryAfterMs: cooldownMs,
-                rateLimit: rateLimitSnapshot ? toCooldownRateLimit(rateLimitSnapshot, cooldownMs) : undefined,
-            });
-        }
-        const softCooldownMs = await RedisCooldown.getRemainingMs(STREAM_RATE_LIMIT_SOFT_COOLDOWN_KEY, { redis, logger }, { keyPrefix: STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX });
-        if (softCooldownMs > 0) {
-            logger.debug('Delaying stream request due to active soft rate-limit cooldown', {
-                operation,
-                cooldown: softCooldownMs,
-            });
-            await sleep(softCooldownMs);
-        }
-        const budgetCooldownMs = await RedisCooldown.getRemainingMs(STREAM_BUDGET_COOLDOWN_KEY, { redis, logger }, { keyPrefix: STREAM_BUDGET_COOLDOWN_KEY_PREFIX });
-        if (budgetCooldownMs > 0) {
-            logger.warn('Delaying stream request due to active budget cooldown', {
-                operation,
-                cooldown: budgetCooldownMs,
-            });
-            let totalBudgetWaitMs = 0;
-            for (;;) {
-                const waitMs = await RedisCooldown.getRemainingMs(STREAM_BUDGET_COOLDOWN_KEY, { redis, logger }, { keyPrefix: STREAM_BUDGET_COOLDOWN_KEY_PREFIX });
-                if (waitMs <= 0 || totalBudgetWaitMs >= BUDGET_DELAY_MAX_MS) {
-                    break;
-                }
-                const chunkMs = Math.min(waitMs, BUDGET_COOLDOWN_SLEEP_CHUNK_MS);
-                await sleep(chunkMs);
-                totalBudgetWaitMs += chunkMs;
-            }
-        }
-    }
-    for (;;) {
-        try {
-            return await execute();
-        }
-        catch (error) {
-            const rateLimitError = processStreamRateLimitException(error, logger);
-            if (!rateLimitError) {
-                throw error;
-            }
-            const retryAfterMs = calculateRateLimitDelayMs(rateLimitError, maxDelayMs);
-            if (enableCooldown) {
-                const rateLimitSnapshot = toRateLimitSnapshot(rateLimitError);
-                if (rateLimitSnapshot) {
-                    await RedisCooldown.setRemainingMsWithValue(operation, getRateLimitMetadataKey(operation), serializeRateLimitSnapshot(rateLimitSnapshot), retryAfterMs, { redis, logger });
-                }
-                else {
-                    await RedisCooldown.setRemainingMs(operation, retryAfterMs, { redis, logger });
-                }
-            }
-            if (attempt < maxAttempts && retryAfterMs <= maxRetryableDelayMs) {
-                logger.warn('Retrying stream request after rate limit', {
-                    operation,
-                    attempt,
-                    maxAttempts,
-                    retryAfterMs,
-                    rateLimit: rateLimitError.rateLimit,
-                    rateLimitRemaining: rateLimitError.rateLimitRemaining,
-                    rateLimitReset: rateLimitError.rateLimitReset,
-                });
-                await sleep(retryAfterMs);
-                attempt++;
-                continue;
-            }
-            logger.warn('Propagating stream rate limit w/o retry', {
-                operation,
-                attempt,
-                maxAttempts,
-                retryAfterMs,
-                maxRetryableDelayMs,
-                rateLimit: rateLimitError.rateLimit,
-                rateLimitRemaining: rateLimitError.rateLimitRemaining,
-                rateLimitReset: rateLimitError.rateLimitReset,
-            });
-            throw rateLimitError;
-        }
-    }
-}

package/dist-es/rateLimits/helpers/headerUtils.js

@@ -1,34 +0,0 @@
-export function getHeaderCaseInsensitive(headers, key) {
-    if (!headers) {
-        return;
-    }
-    const direct = headers[key];
-    if (direct !== undefined) {
-        return direct;
-    }
-    const normalizedKey = key.toLowerCase();
-    for (const [headerKey, headerValue] of Object.entries(headers)) {
-        if (headerKey.toLowerCase() === normalizedKey) {
-            return headerValue;
-        }
-    }
-}
-export function parseHeaderNumber(headers, key) {
-    const raw = getHeaderCaseInsensitive(headers, key);
-    if (typeof raw === 'number' && Number.isFinite(raw)) {
-        return raw;
-    }
-    if (typeof raw === 'string') {
-        const parsed = Number(raw);
-        if (Number.isFinite(parsed)) {
-            return parsed;
-        }
-    }
-}
-export function normalizeResetToEpochMs(reset) {
-    if (reset < 10000)
-        return Date.now() + Math.round(reset * 1000);
-    if (reset < 10000000000)
-        return Math.round(reset * 1000);
-    return Math.round(reset);
-}

package/dist-es/rateLimits/helpers/isStreamChannelLike.js

@@ -1,19 +0,0 @@
-import { Channel } from 'stream-chat';
-function hasFunctionProperty(value, key) {
-    return key in value && typeof value[key] === 'function';
-}
-function hasStringProperty(value, key) {
-    return key in value && typeof value[key] === 'string';
-}
-export function isStreamChannelLike(value) {
-    if (typeof value !== 'object' || value === null) {
-        return false;
-    }
-    if (value instanceof Channel) {
-        return true;
-    }
-    return (hasStringProperty(value, 'cid') &&
-        hasFunctionProperty(value, 'sendMessage') &&
-        hasFunctionProperty(value, 'queryMembers') &&
-        hasFunctionProperty(value, 'updatePartial'));
-}

package/dist-es/rateLimits/helpers/processStreamBudgetHeaders.js

@@ -1,89 +0,0 @@
-import { BUDGET_CLEAR_USAGE_THRESHOLD, BUDGET_DELAY_MAX_MS, BUDGET_DELAY_MIN_MS, BUDGET_MINIMAL_DELAY_MAX_MS, BUDGET_MINIMAL_DELAY_MIN_MS, BUDGET_RELAXED_DELAY_MAX_MS, BUDGET_RELAXED_DELAY_MIN_MS, BUDGET_RELAXED_USAGE_THRESHOLD, BUDGET_THRESHOLD, STREAM_BUDGET_COOLDOWN_KEY, STREAM_BUDGET_COOLDOWN_KEY_PREFIX, } from '../constants';
-import { parseHeaderNumber } from './headerUtils';
-import { RedisCooldown } from './RedisCooldown';
-function extractBudgetHeaders(headers) {
-    return {
-        limitMs: parseHeaderNumber(headers ?? {}, 'x-budget-limit-ms'),
-        remainingMs: parseHeaderNumber(headers ?? {}, 'x-budget-remaining-ms'),
-        usedMs: parseHeaderNumber(headers ?? {}, 'x-budget-used-ms'),
-    };
-}
-function isBudgetThresholdReached(limitMs, remainingMs, usedMs) {
-    if (limitMs <= 0) {
-        return false;
-    }
-    if (typeof usedMs === 'number' && usedMs / limitMs >= BUDGET_THRESHOLD) {
-        return true;
-    }
-    if (typeof remainingMs === 'number') {
-        const remainingThreshold = Math.ceil((1 - BUDGET_THRESHOLD) * limitMs);
-        return remainingMs <= remainingThreshold;
-    }
-    return false;
-}
-function getRandomDelayInRange(minMs, maxMs) {
-    return Math.round(minMs + Math.random() * (maxMs - minMs));
-}
-function getBudgetUsage(limitMs, remainingMs, usedMs) {
-    if (limitMs <= 0) {
-        return 0;
-    }
-    if (typeof usedMs === 'number' && Number.isFinite(usedMs) && usedMs >= 0) {
-        return usedMs / limitMs;
-    }
-    if (typeof remainingMs === 'number' && Number.isFinite(remainingMs)) {
-        return Math.max(0, 1 - remainingMs / limitMs);
-    }
-    return 0;
-}
-export async function processStreamBudgetHeaders(headers, context) {
-    const { logger } = context;
-    const { limitMs, remainingMs, usedMs } = extractBudgetHeaders(headers);
-    if (limitMs === undefined && remainingMs === undefined && usedMs === undefined) {
-        return;
-    }
-    if (typeof limitMs !== 'number' || !Number.isFinite(limitMs)) {
-        return;
-    }
-    const usage = getBudgetUsage(limitMs, remainingMs, usedMs);
-    const thresholdReached = isBudgetThresholdReached(limitMs, remainingMs, usedMs);
-    if (thresholdReached) {
-        const delayMs = getRandomDelayInRange(BUDGET_DELAY_MIN_MS, BUDGET_DELAY_MAX_MS);
-        await RedisCooldown.setRemainingMsExact(STREAM_BUDGET_COOLDOWN_KEY, delayMs, context, {
-            keyPrefix: STREAM_BUDGET_COOLDOWN_KEY_PREFIX,
-        });
-        logger.warn('Stream budget threshold reached, enabling cooldown', {
-            budgetLimitMs: limitMs,
-            budgetRemainingMs: remainingMs,
-            budgetUsedMs: usedMs,
-            budgetUsage: usage,
-            cooldownMs: delayMs,
-        });
-        return;
-    }
-    if (usage < BUDGET_CLEAR_USAGE_THRESHOLD) {
-        await RedisCooldown.clear(STREAM_BUDGET_COOLDOWN_KEY, context, {
-            keyPrefix: STREAM_BUDGET_COOLDOWN_KEY_PREFIX,
-        });
-        logger.info('Stream budget is low, clearing cooldown', {
-            budgetLimitMs: limitMs,
-            budgetRemainingMs: remainingMs,
-            budgetUsedMs: usedMs,
-            budgetUsage: usage,
-        });
-        return;
-    }
-    const delayMs = usage >= BUDGET_RELAXED_USAGE_THRESHOLD
-        ? getRandomDelayInRange(BUDGET_RELAXED_DELAY_MIN_MS, BUDGET_RELAXED_DELAY_MAX_MS)
-        : getRandomDelayInRange(BUDGET_MINIMAL_DELAY_MIN_MS, BUDGET_MINIMAL_DELAY_MAX_MS);
-    await RedisCooldown.setRemainingMsExact(STREAM_BUDGET_COOLDOWN_KEY, delayMs, context, {
-        keyPrefix: STREAM_BUDGET_COOLDOWN_KEY_PREFIX,
-    });
-    logger.info('Stream budget is below threshold, reducing cooldown', {
-        budgetLimitMs: limitMs,
-        budgetRemainingMs: remainingMs,
-        budgetUsedMs: usedMs,
-        budgetUsage: usage,
-        cooldownMs: delayMs,
-    });
-}

package/dist-es/rateLimits/helpers/processStreamRateLimitException.js

@@ -1,59 +0,0 @@
-import { createRateLimitExceededException } from './createRateLimitExceededException';
-import { getHeaderCaseInsensitive, normalizeResetToEpochMs, parseHeaderNumber } from './headerUtils';
-function parseRetryAfterMs(headers) {
-    const retryAfter = getHeaderCaseInsensitive(headers, 'retry-after');
-    if (typeof retryAfter === 'number' && Number.isFinite(retryAfter) && retryAfter >= 0) {
-        return Math.round(retryAfter * 1000);
-    }
-    if (typeof retryAfter !== 'string') {
-        return;
-    }
-    const asSeconds = Number(retryAfter);
-    if (Number.isFinite(asSeconds) && asSeconds >= 0) {
-        return Math.round(asSeconds * 1000);
-    }
-    const asDateMs = Date.parse(retryAfter);
-    if (!Number.isNaN(asDateMs)) {
-        return Math.max(0, asDateMs - Date.now());
-    }
-}
-function getRateLimitFromHeaders(headers) {
-    const limit = parseHeaderNumber(headers, 'x-ratelimit-limit');
-    const remaining = parseHeaderNumber(headers, 'x-ratelimit-remaining');
-    const resetRaw = parseHeaderNumber(headers, 'x-ratelimit-reset');
-    if (limit === undefined || remaining === undefined || resetRaw === undefined) {
-        return;
-    }
-    return {
-        limit,
-        remaining,
-        reset: normalizeResetToEpochMs(resetRaw),
-    };
-}
-function isStreamHttpRateLimitError(error) {
-    return (typeof error === 'object' &&
-        error !== null &&
-        (('status' in error && error.status === 429) ||
-            ('response' in error &&
-                typeof error.response === 'object' &&
-                error.response !== null &&
-                error.response?.status === 429)));
-}
-export function processStreamRateLimitException(error, logger) {
-    if (isStreamHttpRateLimitError(error)) {
-        const headers = error.response?.headers ?? {};
-        const rateLimit = getRateLimitFromHeaders(headers);
-        const retryAfterMs = parseRetryAfterMs(headers);
-        const message = error.response?.data?.message || error.message || 'Rate limit exceeded';
-        logger.warn('Stream rate limit exceeded [HTTP 429]', {
-            status: error.status ?? error.response?.status,
-            retryAfterMs,
-            rateLimit,
-        });
-        return createRateLimitExceededException({
-            rateLimit,
-            retryAfterMs,
-            message,
-        });
-    }
-}

package/dist-es/rateLimits/helpers/processStreamRateLimitHeaders.js

@@ -1,46 +0,0 @@
-import { SOFT_THROTTLE_DELAY_HIGH_MS, SOFT_THROTTLE_DELAY_LOW_MS, SOFT_THROTTLE_DELAY_MEDIUM_MS, SOFT_THROTTLE_USAGE_HIGH, SOFT_THROTTLE_USAGE_LOW, SOFT_THROTTLE_USAGE_MEDIUM, STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX, STREAM_RATE_LIMIT_SOFT_COOLDOWN_KEY, } from '../constants';
-import { parseHeaderNumber } from './headerUtils';
-import { RedisCooldown } from './RedisCooldown';
-function computeSoftThrottleDelayMs(limit, remaining) {
-    if (limit <= 0) {
-        return 0;
-    }
-    const usage = 1 - remaining / limit;
-    if (usage >= SOFT_THROTTLE_USAGE_HIGH) {
-        return SOFT_THROTTLE_DELAY_HIGH_MS;
-    }
-    if (usage >= SOFT_THROTTLE_USAGE_MEDIUM) {
-        return SOFT_THROTTLE_DELAY_MEDIUM_MS;
-    }
-    if (usage >= SOFT_THROTTLE_USAGE_LOW) {
-        return SOFT_THROTTLE_DELAY_LOW_MS;
-    }
-    return 0;
-}
-export async function processStreamRateLimitHeaders(headers, context) {
-    const { logger } = context;
-    const limit = parseHeaderNumber(headers ?? {}, 'x-ratelimit-limit');
-    const remaining = parseHeaderNumber(headers ?? {}, 'x-ratelimit-remaining');
-    if (limit === undefined || remaining === undefined) {
-        return;
-    }
-    if (limit <= 0 || remaining < 0) {
-        return;
-    }
-    const delayMs = computeSoftThrottleDelayMs(limit, remaining);
-    if (delayMs > 0) {
-        await RedisCooldown.setRemainingMs(STREAM_RATE_LIMIT_SOFT_COOLDOWN_KEY, delayMs, context, {
-            keyPrefix: STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX,
-        });
-        logger.debug('Enabling soft stream rate-limit cooldown', {
-            rateLimit: limit,
-            rateLimitRemaining: remaining,
-            cooldownMs: delayMs,
-        });
-        return;
-    }
-    await RedisCooldown.clear(STREAM_RATE_LIMIT_SOFT_COOLDOWN_KEY, context, {
-        keyPrefix: STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX,
-    });
-    logger.debug('Clearing soft stream rate-limit cooldown');
-}

package/dist-es/rateLimits/helpers/rateLimitSnapshot.js

@@ -1,26 +0,0 @@
-const RATE_LIMIT_SNAPSHOT_PARTS_COUNT = 3;
-export function serializeRateLimitSnapshot(snapshot) {
-    return `${snapshot.limit},${snapshot.remaining},${snapshot.reset}`;
-}
-export function parseRateLimitSnapshot(snapshot) {
-    if (typeof snapshot !== 'string' || snapshot.length === 0) {
-        return;
-    }
-    const parts = snapshot.split(',');
-    if (parts.length !== RATE_LIMIT_SNAPSHOT_PARTS_COUNT) {
-        return;
-    }
-    const [limitRaw, remainingRaw, resetRaw] = parts;
-    const limit = Number(limitRaw);
-    const remaining = Number(remainingRaw);
-    const reset = Number(resetRaw);
-    if (!Number.isFinite(limit) ||
-        !Number.isFinite(remaining) ||
-        !Number.isFinite(reset) ||
-        limit < 0 ||
-        remaining < 0 ||
-        reset <= 0) {
-        return;
-    }
-    return { limit, remaining, reset };
-}

package/dist-es/rateLimits/helpers/registerStreamBudgetInterceptors.js

@@ -1,44 +0,0 @@
-import { processStreamBudgetHeaders } from './processStreamBudgetHeaders';
-import { processStreamRateLimitHeaders } from './processStreamRateLimitHeaders';
-const attachedInterceptors = new WeakSet();
-function hasResponseInterceptors(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        typeof value.interceptors?.response?.use === 'function');
-}
-function resolveAxiosInstance(stream) {
-    if (hasResponseInterceptors(stream)) {
-        return stream;
-    }
-    if (typeof stream !== 'object' || stream === null) {
-        return;
-    }
-    const maybeStream = stream;
-    if (hasResponseInterceptors(maybeStream.axiosInstance)) {
-        return maybeStream.axiosInstance;
-    }
-    if (hasResponseInterceptors(maybeStream._client?.axiosInstance)) {
-        return maybeStream._client?.axiosInstance;
-    }
-}
-export function registerStreamBudgetInterceptors(stream, context) {
-    const { logger } = context;
-    const axiosInstance = resolveAxiosInstance(stream);
-    if (!axiosInstance || !axiosInstance.interceptors?.response?.use) {
-        logger.warn('Unable to register stream budget interceptor: axios instance not found');
-        return;
-    }
-    if (attachedInterceptors.has(axiosInstance)) {
-        return;
-    }
-    axiosInstance.interceptors.response.use(async (response) => {
-        await processStreamBudgetHeaders(response?.headers, context);
-        await processStreamRateLimitHeaders(response?.headers, context);
-        return response;
-    }, async (error) => {
-        await processStreamBudgetHeaders(error?.response?.headers, context);
-        await processStreamRateLimitHeaders(error?.response?.headers, context);
-        return Promise.reject(error);
-    });
-    attachedInterceptors.add(axiosInstance);
-}

package/dist-es/rateLimits/helpers/registerStreamInterceptors.js

@@ -1,54 +0,0 @@
-import { processStreamBudgetHeaders } from './processStreamBudgetHeaders';
-import { processStreamRateLimitHeaders } from './processStreamRateLimitHeaders';
-const attachedInterceptors = new WeakSet();
-function hasResponseInterceptors(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        typeof value.interceptors?.response?.use === 'function');
-}
-function resolveAxiosInstance(stream) {
-    if (hasResponseInterceptors(stream)) {
-        return stream;
-    }
-    if (typeof stream !== 'object' || stream === null) {
-        return;
-    }
-    const maybeStream = stream;
-    if (hasResponseInterceptors(maybeStream.axiosInstance)) {
-        return maybeStream.axiosInstance;
-    }
-    if (hasResponseInterceptors(maybeStream._client?.axiosInstance)) {
-        return maybeStream._client?.axiosInstance;
-    }
-}
-export function registerStreamInterceptors(stream, context) {
-    const { logger } = context;
-    const axiosInstance = resolveAxiosInstance(stream);
-    if (!axiosInstance || !axiosInstance.interceptors?.response?.use) {
-        logger.warn('Unable to register stream budget & rate limit interceptors: axios instance not found');
-        return;
-    }
-    if (attachedInterceptors.has(axiosInstance)) {
-        return;
-    }
-    attachedInterceptors.add(axiosInstance);
-    axiosInstance.interceptors.response.use(async (response) => {
-        try {
-            await processStreamBudgetHeaders(response?.headers, context);
-            await processStreamRateLimitHeaders(response?.headers, context);
-        }
-        catch (error) {
-            logger.warn('Failed to process Stream response headers in interceptor', { error });
-        }
-        return response;
-    }, async (error) => {
-        try {
-            await processStreamBudgetHeaders(error?.response?.headers, context);
-            await processStreamRateLimitHeaders(error?.response?.headers, context);
-        }
-        catch (interceptorError) {
-            logger.warn('Failed to process Stream error headers in interceptor', { error: interceptorError });
-        }
-        return Promise.reject(error);
-    });
-}

package/dist-es/rateLimits/helpers/splitCallArgsAndOptions.js

@@ -1,17 +0,0 @@
-import { STREAM_RATE_LIMIT_OPTIONS_MARKER } from '../constants';
-function isStreamRateLimitOptionsToken(value) {
-    return typeof value === 'object' && value !== null && STREAM_RATE_LIMIT_OPTIONS_MARKER in value;
-}
-export function splitCallArgsAndOptions(args) {
-    if (args.length === 0) {
-        return { callArgs: args, callOptions: {} };
-    }
-    const lastArg = args[args.length - 1];
-    if (isStreamRateLimitOptionsToken(lastArg)) {
-        return {
-            callArgs: args.slice(0, -1),
-            callOptions: lastArg[STREAM_RATE_LIMIT_OPTIONS_MARKER],
-        };
-    }
-    return { callArgs: args, callOptions: {} };
-}

package/dist-es/rateLimits/index.js

@@ -1,4 +0,0 @@
-export * from './createRateLimitedStreamProxy';
-export * from './helpers/createRateLimitExceededException';
-export * from './helpers/processStreamRateLimitException';
-export * from './withStreamRateLimitOptions';

package/dist-es/rateLimits/types.js

@@ -1 +0,0 @@
-import { STREAM_RATE_LIMIT_OPTIONS_MARKER } from './constants';

package/dist-es/rateLimits/withStreamRateLimitOptions.js

@@ -1,6 +0,0 @@
-import { STREAM_RATE_LIMIT_OPTIONS_MARKER } from './constants';
-export function withStreamRateLimitOptions(options) {
-    return {
-        [STREAM_RATE_LIMIT_OPTIONS_MARKER]: options,
-    };
-}

package/dist-types/rateLimits/RedisCooldown.d.ts

@@ -1,7 +0,0 @@
-import {LoggerContext, RedisContext} from './types';
-
-export declare class RedisCooldown {
-  static getRemainingMs(cooldownKey: string, context: RedisContext & LoggerContext): Promise<number>;
-
-  static setRemainingMs(cooldownKey: string, cooldownMs: number, context: RedisContext & LoggerContext): Promise<void>;
-}

package/dist-types/rateLimits/constants.d.ts

@@ -1,29 +0,0 @@
-import { StreamRateLimitRetryOptions } from './types';
-export { CHANNEL_METHOD_NAMES, CHANNEL_SYNC_METHOD_NAMES, CHANNEL_SYNC_PROXY_RESULT_METHOD_NAMES, STREAM_CHANNEL_RESULT_METHOD_NAMES, STREAM_METHOD_NAMES, STREAM_SYNC_CHANNEL_RESULT_METHOD_NAMES, STREAM_SYNC_METHOD_NAMES, } from './generatedMethodNames';
-export declare const DEFAULT_MAX_DELAY_MS = 5000;
-export declare const DEFAULT_RETRY_AFTER_MS = 10000;
-export declare const DEFAULT_JITTER_MS = 150;
-export declare const RETRY_AFTER_BUFFER_MS = 1000;
-export declare const STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX = "stream-rate-limit-cooldown:";
-export declare const STREAM_BUDGET_COOLDOWN_KEY_PREFIX = "stream-budget-cooldown:";
-export declare const STREAM_RATE_LIMIT_OPTIONS_MARKER = "__xbsRateLimitOptions";
-export declare const STREAM_RATE_LIMIT_SOFT_COOLDOWN_KEY = "stream-rate-limit-soft-global";
-export declare const STREAM_RATE_LIMIT_METADATA_KEY_SUFFIX = ":meta";
-export declare const STREAM_BUDGET_COOLDOWN_KEY = "stream-budget-global";
-export declare const BUDGET_THRESHOLD = 0.8;
-export declare const BUDGET_DELAY_MIN_MS = 30000;
-export declare const BUDGET_DELAY_MAX_MS = 60000;
-export declare const BUDGET_CLEAR_USAGE_THRESHOLD = 0.6;
-export declare const BUDGET_RELAXED_USAGE_THRESHOLD = 0.7;
-export declare const BUDGET_RELAXED_DELAY_MIN_MS = 5000;
-export declare const BUDGET_RELAXED_DELAY_MAX_MS = 10000;
-export declare const BUDGET_MINIMAL_DELAY_MIN_MS = 1000;
-export declare const BUDGET_MINIMAL_DELAY_MAX_MS = 2000;
-export declare const BUDGET_COOLDOWN_SLEEP_CHUNK_MS = 3000;
-export declare const SOFT_THROTTLE_USAGE_LOW = 0.7;
-export declare const SOFT_THROTTLE_USAGE_MEDIUM = 0.85;
-export declare const SOFT_THROTTLE_USAGE_HIGH = 0.95;
-export declare const SOFT_THROTTLE_DELAY_LOW_MS = 500;
-export declare const SOFT_THROTTLE_DELAY_MEDIUM_MS = 1500;
-export declare const SOFT_THROTTLE_DELAY_HIGH_MS = 3000;
-export declare const DEFAULT_OPTIONS: StreamRateLimitRetryOptions;

package/dist-types/rateLimits/createRateLimitedStreamProxy.d.ts

@@ -1,11 +0,0 @@
-import { StreamChat } from 'stream-chat';
-import { StreamType } from '../stream';
-import { LoggerContext, MethodWithRateLimitOptions, RedisContext } from './types';
-export type RateLimited<T extends object> = {
-    [Key in keyof T]: MethodWithRateLimitOptions<T[Key]>;
-};
-/**
- * Creates a proxy around a Stream client that transparently applies rate-limit handling
- * to method calls and recursively wraps returned channel objects with the same behavior.
- */
-export declare function createRateLimitedStreamProxy(stream: StreamChat<StreamType>, context: LoggerContext & RedisContext): RateLimited<StreamChat<StreamType>>;

package/dist-types/rateLimits/exception/createRateLimitExceededException.d.ts

@@ -1,12 +0,0 @@
-import {RateLimitExceededException} from '@wildix/xbees-conversations-client';
-
-import {RateLimitsInfo} from 'stream-chat';
-
-type Options = {
-  rateLimit?: RateLimitsInfo;
-  message?: string;
-  operation?: string;
-  retryAfterMs?: number;
-};
-export declare function createRateLimitExceededException(options?: Options): RateLimitExceededException;
-export {};

package/dist-types/rateLimits/exception/processStreamRateLimitException.d.ts

@@ -1,8 +0,0 @@
-import {RateLimitExceededException} from '@wildix/xbees-conversations-client';
-
-import {Logger} from '@aws-lambda-powertools/logger';
-
-export declare function processStreamRateLimitException(
-  error: unknown,
-  logger: Logger,
-): RateLimitExceededException | undefined;

package/dist-types/rateLimits/executeStreamRequestWithRateLimitHandling.d.ts

@@ -1,8 +0,0 @@
-import {LoggerContext, RedisContext, StreamOperationType, StreamRateLimitRetryOptions} from './types';
-
-export declare function executeStreamRequestWithRateLimitHandling<T>(
-  execute: () => Promise<T>,
-  operation: StreamOperationType,
-  context: LoggerContext & RedisContext,
-  options?: Partial<StreamRateLimitRetryOptions>,
-): Promise<T>;