@wildix/xbees-conversations-utils 1.1.76 → 1.1.78

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

@@ -1,14 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isStreamChannelLike = void 0;
+const stream_chat_1 = require("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';
+}
 function isStreamChannelLike(value) {
     if (typeof value !== 'object' || value === null) {
         return false;
     }
-    return (hasFunctionProperty(value, 'sendMessage') &&
+    if (value instanceof stream_chat_1.Channel) {
+        return true;
+    }
+    return (hasStringProperty(value, 'cid') &&
+        hasFunctionProperty(value, 'sendMessage') &&
         hasFunctionProperty(value, 'queryMembers') &&
         hasFunctionProperty(value, 'updatePartial'));
 }

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

@@ -2,38 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processStreamBudgetHeaders = void 0;
 const constants_1 = require("../constants");
+const headerUtils_1 = require("./headerUtils");
 const RedisCooldown_1 = require("./RedisCooldown");
-function parseHeaderNumber(value) {
-    if (typeof value === 'number' && Number.isFinite(value)) {
-        return value;
-    }
-    if (typeof value === 'string') {
-        const parsed = Number(value);
-        if (Number.isFinite(parsed)) {
-            return parsed;
-        }
-    }
-}
-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;
-        }
-    }
-}
 function extractBudgetHeaders(headers) {
     return {
-        limitMs: parseHeaderNumber(getHeaderCaseInsensitive(headers, 'x-budget-limit-ms')),
-        remainingMs: parseHeaderNumber(getHeaderCaseInsensitive(headers, 'x-budget-remaining-ms')),
-        usedMs: parseHeaderNumber(getHeaderCaseInsensitive(headers, 'x-budget-used-ms')),
+        limitMs: (0, headerUtils_1.parseHeaderNumber)(headers ?? {}, 'x-budget-limit-ms'),
+        remainingMs: (0, headerUtils_1.parseHeaderNumber)(headers ?? {}, 'x-budget-remaining-ms'),
+        usedMs: (0, headerUtils_1.parseHeaderNumber)(headers ?? {}, 'x-budget-used-ms'),
     };
 }
 function isBudgetThresholdReached(limitMs, remainingMs, usedMs) {
@@ -49,8 +24,20 @@ function isBudgetThresholdReached(limitMs, remainingMs, usedMs) {
     }
     return false;
 }
-function getBudgetDelayMs() {
-    return Math.round(constants_1.BUDGET_DELAY_MIN_MS + Math.random() * (constants_1.BUDGET_DELAY_MAX_MS - constants_1.BUDGET_DELAY_MIN_MS));
+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;
 }
 async function processStreamBudgetHeaders(headers, context) {
     const { logger } = context;
@@ -61,27 +48,46 @@ async function processStreamBudgetHeaders(headers, context) {
     if (typeof limitMs !== 'number' || !Number.isFinite(limitMs)) {
         return;
     }
+    const usage = getBudgetUsage(limitMs, remainingMs, usedMs);
     const thresholdReached = isBudgetThresholdReached(limitMs, remainingMs, usedMs);
     if (thresholdReached) {
-        const delayMs = getBudgetDelayMs();
-        await RedisCooldown_1.RedisCooldown.setRemainingMs(constants_1.STREAM_BUDGET_COOLDOWN_KEY, delayMs, context, {
+        const delayMs = getRandomDelayInRange(constants_1.BUDGET_DELAY_MIN_MS, constants_1.BUDGET_DELAY_MAX_MS);
+        await RedisCooldown_1.RedisCooldown.setRemainingMsExact(constants_1.STREAM_BUDGET_COOLDOWN_KEY, delayMs, context, {
             keyPrefix: constants_1.STREAM_BUDGET_COOLDOWN_KEY_PREFIX,
         });
         logger.warn('Stream budget threshold reached, enabling cooldown', {
             budgetLimitMs: limitMs,
             budgetRemainingMs: remainingMs,
             budgetUsedMs: usedMs,
+            budgetUsage: usage,
             cooldownMs: delayMs,
         });
         return;
     }
-    await RedisCooldown_1.RedisCooldown.clear(constants_1.STREAM_BUDGET_COOLDOWN_KEY, context, {
+    if (usage < constants_1.BUDGET_CLEAR_USAGE_THRESHOLD) {
+        await RedisCooldown_1.RedisCooldown.clear(constants_1.STREAM_BUDGET_COOLDOWN_KEY, context, {
+            keyPrefix: constants_1.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 >= constants_1.BUDGET_RELAXED_USAGE_THRESHOLD
+        ? getRandomDelayInRange(constants_1.BUDGET_RELAXED_DELAY_MIN_MS, constants_1.BUDGET_RELAXED_DELAY_MAX_MS)
+        : getRandomDelayInRange(constants_1.BUDGET_MINIMAL_DELAY_MIN_MS, constants_1.BUDGET_MINIMAL_DELAY_MAX_MS);
+    await RedisCooldown_1.RedisCooldown.setRemainingMsExact(constants_1.STREAM_BUDGET_COOLDOWN_KEY, delayMs, context, {
         keyPrefix: constants_1.STREAM_BUDGET_COOLDOWN_KEY_PREFIX,
     });
-    logger.warn('Stream budget is below threshold, disabling cooldown', {
+    logger.info('Stream budget is below threshold, reducing cooldown', {
         budgetLimitMs: limitMs,
         budgetRemainingMs: remainingMs,
         budgetUsedMs: usedMs,
+        budgetUsage: usage,
+        cooldownMs: delayMs,
     });
 }
 exports.processStreamBudgetHeaders = processStreamBudgetHeaders;

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

@@ -2,20 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processStreamRateLimitException = void 0;
 const createRateLimitExceededException_1 = require("./createRateLimitExceededException");
-function parseHeaderNumber(headers, key) {
-    const raw = 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;
-        }
-    }
-}
+const headerUtils_1 = require("./headerUtils");
 function parseRetryAfterMs(headers) {
-    const retryAfter = headers['retry-after'];
+    const retryAfter = (0, headerUtils_1.getHeaderCaseInsensitive)(headers, 'retry-after');
     if (typeof retryAfter === 'number' && Number.isFinite(retryAfter) && retryAfter >= 0) {
         return Math.round(retryAfter * 1000);
     }
@@ -32,16 +21,16 @@ function parseRetryAfterMs(headers) {
     }
 }
 function getRateLimitFromHeaders(headers) {
-    const limit = parseHeaderNumber(headers, 'x-ratelimit-limit');
-    const remaining = parseHeaderNumber(headers, 'x-ratelimit-remaining');
-    const resetSeconds = parseHeaderNumber(headers, 'x-ratelimit-reset');
-    if (limit === undefined || remaining === undefined || resetSeconds === undefined) {
+    const limit = (0, headerUtils_1.parseHeaderNumber)(headers, 'x-ratelimit-limit');
+    const remaining = (0, headerUtils_1.parseHeaderNumber)(headers, 'x-ratelimit-remaining');
+    const resetRaw = (0, headerUtils_1.parseHeaderNumber)(headers, 'x-ratelimit-reset');
+    if (limit === undefined || remaining === undefined || resetRaw === undefined) {
         return;
     }
     return {
         limit,
         remaining,
-        reset: Math.round(resetSeconds * 1000),
+        reset: (0, headerUtils_1.normalizeResetToEpochMs)(resetRaw),
     };
 }
 function isStreamHttpRateLimitError(error) {
@@ -56,6 +45,7 @@ function isStreamHttpRateLimitError(error) {
 function processStreamRateLimitException(error, logger) {
     if (isStreamHttpRateLimitError(error)) {
         const headers = error.response?.headers ?? {};
+        logger.warn(`rate limit headers`, { headers });
         const rateLimit = getRateLimitFromHeaders(headers);
         const retryAfterMs = parseRetryAfterMs(headers);
         const message = error.response?.data?.message || error.message || 'Rate limit exceeded';

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

@@ -2,33 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processStreamRateLimitHeaders = void 0;
 const constants_1 = require("../constants");
+const headerUtils_1 = require("./headerUtils");
 const RedisCooldown_1 = require("./RedisCooldown");
-function parseHeaderNumber(value) {
-    if (typeof value === 'number' && Number.isFinite(value)) {
-        return value;
-    }
-    if (typeof value === 'string') {
-        const parsed = Number(value);
-        if (Number.isFinite(parsed)) {
-            return parsed;
-        }
-    }
-}
-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;
-        }
-    }
-}
 function computeSoftThrottleDelayMs(limit, remaining) {
     if (limit <= 0) {
         return 0;
@@ -47,8 +22,8 @@ function computeSoftThrottleDelayMs(limit, remaining) {
 }
 async function processStreamRateLimitHeaders(headers, context) {
     const { logger } = context;
-    const limit = parseHeaderNumber(getHeaderCaseInsensitive(headers, 'x-ratelimit-limit'));
-    const remaining = parseHeaderNumber(getHeaderCaseInsensitive(headers, 'x-ratelimit-remaining'));
+    const limit = (0, headerUtils_1.parseHeaderNumber)(headers ?? {}, 'x-ratelimit-limit');
+    const remaining = (0, headerUtils_1.parseHeaderNumber)(headers ?? {}, 'x-ratelimit-remaining');
     if (limit === undefined || remaining === undefined) {
         return;
     }
@@ -70,5 +45,6 @@ async function processStreamRateLimitHeaders(headers, context) {
     await RedisCooldown_1.RedisCooldown.clear(constants_1.STREAM_RATE_LIMIT_SOFT_COOLDOWN_KEY, context, {
         keyPrefix: constants_1.STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX,
     });
+    logger.debug('Clearing soft stream rate-limit cooldown');
 }
 exports.processStreamRateLimitHeaders = processStreamRateLimitHeaders;

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerStreamInterceptors = void 0;
+const processStreamBudgetHeaders_1 = require("./processStreamBudgetHeaders");
+const processStreamRateLimitHeaders_1 = require("./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;
+    }
+}
+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;
+    }
+    axiosInstance.interceptors.response.use(async (response) => {
+        await (0, processStreamBudgetHeaders_1.processStreamBudgetHeaders)(response?.headers, context);
+        await (0, processStreamRateLimitHeaders_1.processStreamRateLimitHeaders)(response?.headers, context);
+        return response;
+    }, async (error) => {
+        await (0, processStreamBudgetHeaders_1.processStreamBudgetHeaders)(error?.response?.headers, context);
+        await (0, processStreamRateLimitHeaders_1.processStreamRateLimitHeaders)(error?.response?.headers, context);
+        return Promise.reject(error);
+    });
+    attachedInterceptors.add(axiosInstance);
+}
+exports.registerStreamInterceptors = registerStreamInterceptors;

package/dist-es/rateLimits/constants.js

@@ -1,3 +1,4 @@
+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 const DEFAULT_MAX_DELAY_MS = 5000;
 export const DEFAULT_RETRY_AFTER_MS = 10000;
 export const DEFAULT_JITTER_MS = 150;
@@ -10,75 +11,22 @@ export const STREAM_BUDGET_COOLDOWN_KEY = 'stream-budget-global';
 export const BUDGET_THRESHOLD = 0.8;
 export const BUDGET_DELAY_MIN_MS = 30000;
 export const BUDGET_DELAY_MAX_MS = 60000;
+export const BUDGET_CLEAR_USAGE_THRESHOLD = 0.6;
+export const BUDGET_RELAXED_USAGE_THRESHOLD = 0.7;
+export const BUDGET_RELAXED_DELAY_MIN_MS = 5000;
+export const BUDGET_RELAXED_DELAY_MAX_MS = 10000;
+export const BUDGET_MINIMAL_DELAY_MIN_MS = 1000;
+export const BUDGET_MINIMAL_DELAY_MAX_MS = 2000;
+export const BUDGET_COOLDOWN_SLEEP_CHUNK_MS = 3000;
 export const SOFT_THROTTLE_USAGE_LOW = 0.7;
 export const SOFT_THROTTLE_USAGE_MEDIUM = 0.85;
 export const SOFT_THROTTLE_USAGE_HIGH = 0.95;
 export const SOFT_THROTTLE_DELAY_LOW_MS = 500;
 export const SOFT_THROTTLE_DELAY_MEDIUM_MS = 1500;
 export const SOFT_THROTTLE_DELAY_HIGH_MS = 3000;
-export const STREAM_SYNC_CHANNEL_RESULT_METHOD_NAMES = [
-    'channel',
-    'getChannelById',
-    'getChannelByMembers',
-    'hydrateActiveChannels',
-];
-export const STREAM_SYNC_METHOD_NAMES = [
-    '_addChannelConfig',
-    '_buildWSPayload',
-    '_callClientListeners',
-    '_deleteUserMessageReference',
-    '_enrichAxiosOptions',
-    '_getConnectionID',
-    '_getToken',
-    '_handleClientEvent',
-    '_handleUserEvent',
-    '_hasConnectionID',
-    '_isUsingServerAuth',
-    '_logApiError',
-    '_logApiRequest',
-    '_logApiResponse',
-    '_muteStatus',
-    '_normalizeDate',
-    '_normalizeExpiration',
-    '_sayHi',
-    '_setUser',
-    '_startCleaning',
-    '_updateMemberWatcherReferences',
-    '_updateUserMessageReferences',
-    '_updateUserReferences',
-    '_validateAndGetMessageId',
-    'createAbortControllerForNextRequest',
-    'createToken',
-    'devToken',
-    'dispatchEvent',
-    'errorFromResponse',
-    'getAuthType',
-    'getUserAgent',
-    'handleEvent',
-    'handleResponse',
-    'off',
-    'on',
-    'setBaseURL',
-    'setLocalDevice',
-    'setUserAgent',
-    'userMuteStatus',
-    'verifyWebhook',
-];
-export const CHANNEL_SYNC_METHOD_NAMES = [
-    '_channelURL',
-    'countUnread',
-    'countUnreadMentions',
-    'getConfig',
-    'lastMessage',
-    'lastRead',
-    'muteStatus',
-    'off',
-    'on',
-];
-export const CHANNEL_SYNC_PROXY_RESULT_METHOD_NAMES = ['getClient'];
 export const DEFAULT_OPTIONS = {
     maxAttempts: 3,
     enableCooldown: true,
-    maxDelayMs: DEFAULT_MAX_DELAY_MS,
+    maxDelayMs: 5000,
     maxRetryableDelayMs: 10000,
 };

package/dist-es/rateLimits/createRateLimitedStreamProxy.js

@@ -1,13 +1,26 @@
-import { CHANNEL_SYNC_METHOD_NAMES, CHANNEL_SYNC_PROXY_RESULT_METHOD_NAMES, DEFAULT_OPTIONS, STREAM_SYNC_CHANNEL_RESULT_METHOD_NAMES, STREAM_SYNC_METHOD_NAMES, } from './constants';
+import { CHANNEL_SYNC_METHOD_NAMES, CHANNEL_SYNC_PROXY_RESULT_METHOD_NAMES, DEFAULT_OPTIONS, STREAM_CHANNEL_RESULT_METHOD_NAMES, STREAM_SYNC_CHANNEL_RESULT_METHOD_NAMES, STREAM_SYNC_METHOD_NAMES, } from './constants';
 import { executeWithRateLimitHandling } from './helpers/executeWithRateLimitHandling';
 import { isStreamChannelLike } from './helpers/isStreamChannelLike';
-import { registerStreamBudgetInterceptors } from './helpers/registerStreamBudgetInterceptors';
+import { registerStreamInterceptors } from './helpers/registerStreamInterceptors';
 import { splitCallArgsAndOptions } from './helpers/splitCallArgsAndOptions';
 const STREAM_SYNC_METHODS = new Set(STREAM_SYNC_METHOD_NAMES);
+const STREAM_CHANNEL_RESULT_METHODS = new Set(STREAM_CHANNEL_RESULT_METHOD_NAMES);
 const STREAM_SYNC_CHANNEL_RESULT_METHODS = new Set(STREAM_SYNC_CHANNEL_RESULT_METHOD_NAMES);
 const CHANNEL_SYNC_METHODS = new Set(CHANNEL_SYNC_METHOD_NAMES);
 const CHANNEL_SYNC_PROXY_RESULT_METHODS = new Set(CHANNEL_SYNC_PROXY_RESULT_METHOD_NAMES);
-function normalizeStreamCallResult(result, dependencies) {
+function wrapKnownChannelResult(result, dependencies) {
+    if (Array.isArray(result)) {
+        return result.map((item) => wrapKnownChannelResult(item, dependencies));
+    }
+    if (typeof result !== 'object' || result === null) {
+        return result;
+    }
+    return wrapTarget(result, dependencies);
+}
+function normalizeStreamCallResult(result, dependencies, wrapAsChannelResult = false) {
+    if (wrapAsChannelResult) {
+        return wrapKnownChannelResult(result, dependencies);
+    }
     if (Array.isArray(result)) {
         return result.map((item) => normalizeStreamCallResult(item, dependencies));
     }
@@ -16,14 +29,14 @@ function normalizeStreamCallResult(result, dependencies) {
     }
     return wrapTarget(result, dependencies);
 }
-function createRateLimitedMethodWrapper(target, value, operation, dependencies) {
+function createRateLimitedMethodWrapper(target, value, operation, dependencies, wrapAsChannelResult) {
     return async (...args) => {
         const { callArgs, callOptions } = splitCallArgsAndOptions(args);
         const result = await executeWithRateLimitHandling(() => Reflect.apply(value, target, callArgs), operation, dependencies.context, {
             ...DEFAULT_OPTIONS,
             ...callOptions,
         });
-        return normalizeStreamCallResult(result, dependencies);
+        return normalizeStreamCallResult(result, dependencies, wrapAsChannelResult);
     };
 }
 function wrapTarget(target, dependencies) {
@@ -40,7 +53,7 @@ function wrapTarget(target, dependencies) {
             if (STREAM_SYNC_CHANNEL_RESULT_METHODS.has(property)) {
                 return (...args) => {
                     const result = Reflect.apply(value, originalTarget, args);
-                    return normalizeStreamCallResult(result, dependencies);
+                    return normalizeStreamCallResult(result, dependencies, true);
                 };
             }
             if (CHANNEL_SYNC_PROXY_RESULT_METHODS.has(property)) {
@@ -55,14 +68,14 @@ function wrapTarget(target, dependencies) {
             if (STREAM_SYNC_METHODS.has(property) || CHANNEL_SYNC_METHODS.has(property)) {
                 return (...args) => Reflect.apply(value, originalTarget, args);
             }
-            return createRateLimitedMethodWrapper(originalTarget, value, property, dependencies);
+            return createRateLimitedMethodWrapper(originalTarget, value, property, dependencies, STREAM_CHANNEL_RESULT_METHODS.has(property));
         },
     });
     dependencies.cache.set(target, proxy);
     return proxy;
 }
 export function createRateLimitedStreamProxy(stream, context) {
-    registerStreamBudgetInterceptors(stream, context);
+    registerStreamInterceptors(stream, context);
     return wrapTarget(stream, {
         context,
         cache: new WeakMap(),