@wildix/xbees-conversations-utils 1.1.81 → 1.1.83

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

@@ -1,37 +0,0 @@
-import {createRateLimitExceededException} from './createRateLimitExceededException';
-
-function isStreamException(error) {
-  return (
-    typeof error === 'object' &&
-    error !== null &&
-    'metadata' in error &&
-    typeof error.metadata === 'object' &&
-    error.metadata !== null &&
-    'responseCode' in error.metadata
-  );
-}
-
-function isStreamAPIException(error) {
-  return typeof error === 'object' && !!error.code;
-}
-
-export function processStreamRateLimitException(error) {
-  if (isStreamException(error) && error.metadata?.responseCode === 429) {
-    const rateLimit = error.metadata?.rateLimit;
-    console.warn('Stream rate limit exceeded [StreamException]', {rateLimit});
-
-    return createRateLimitExceededException({rateLimit, message: error.message || 'Rate limit exceeded'});
-  }
-
-  if (isStreamAPIException(error) && (error.code === 429 || error.StatusCode === 429)) {
-    console.warn('Stream rate limit exceeded [StreamAPIException]', {code: error.code, StatusCode: error.StatusCode});
-
-    return createRateLimitExceededException({message: error.message || 'Rate limit exceeded'});
-  }
-
-  if (typeof error === 'object' && error !== null && 'status' in error && error.status === 429) {
-    console.warn('Stream rate limit exceeded [error.status === 429]');
-
-    return createRateLimitExceededException({message: 'Rate limit exceeded'});
-  }
-}

package/dist-es/rateLimits/executeStreamRequestWithRateLimitHandling.js

@@ -1,93 +0,0 @@
-import {setTimeout as sleep} from 'node:timers/promises';
-
-import {
-  DEFAULT_FIXED_RATE_LIMIT_DELAY_MS,
-  DEFAULT_JITTER_MS,
-  DEFAULT_OPTS_1_ATTEMPT_NO_COOLDOWN,
-  DEFAULT_RETRY_AFTER_MS,
-  RETRY_AFTER_BUFFER_MS,
-} from './constants';
-import {createRateLimitExceededException} from './exception/createRateLimitExceededException';
-import {processStreamRateLimitException} from './exception/processStreamRateLimitException';
-import {RedisCooldown} from './RedisCooldown';
-
-/** Computes actual backoff delay from rate-limit error and configured caps. */
-function calculateRateLimitDelayMs(error, maxDelayMs) {
-  const retryAfterMs =
-    typeof error.retryAfter === 'number' ? error.retryAfter + RETRY_AFTER_BUFFER_MS : DEFAULT_RETRY_AFTER_MS;
-
-  if (retryAfterMs > 0) {
-    const jitterMs = Math.floor(Math.random() * DEFAULT_JITTER_MS);
-
-    return Math.min(maxDelayMs, retryAfterMs + jitterMs);
-  }
-
-  return Math.min(maxDelayMs, DEFAULT_FIXED_RATE_LIMIT_DELAY_MS);
-}
-
-/** Executes Stream request with cooldown check, retry policy and rate-limit normalization. */
-export async function executeStreamRequestWithRateLimitHandling(execute, operation, context, options = {}) {
-  const {redis} = context;
-  const {enableCooldown, maxAttempts, maxDelayMs, maxRetryableDelayMs} = {
-    ...DEFAULT_OPTS_1_ATTEMPT_NO_COOLDOWN,
-    ...options,
-  };
-  let attempt = 1;
-
-  if (enableCooldown) {
-    const cooldownMs = await RedisCooldown.getRemainingMs(operation, {redis});
-
-    if (cooldownMs > 0) {
-      console.warn('Skipping stream request due to active rate-limit cooldown', {
-        operation,
-        cooldown: cooldownMs,
-      });
-      throw createRateLimitExceededException({operation, retryAfterMs: cooldownMs});
-    }
-  }
-
-  for (;;) {
-    try {
-      return await execute();
-    } catch (error) {
-      const rateLimitError = processStreamRateLimitException(error);
-
-      if (!rateLimitError) {
-        throw error;
-      }
-
-      const retryAfterMs = calculateRateLimitDelayMs(rateLimitError, maxDelayMs);
-
-      if (enableCooldown) {
-        await RedisCooldown.setRemainingMs(operation, retryAfterMs, {redis});
-      }
-
-      if (attempt < maxAttempts && retryAfterMs <= maxRetryableDelayMs) {
-        console.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;
-      }
-
-      console.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/generatedMethodNames.js

@@ -1,317 +0,0 @@
-export const STREAM_METHOD_NAMES = [
-    '_addChannelConfig',
-    '_buildWSPayload',
-    '_callClientListeners',
-    '_createImport',
-    '_createImportURL',
-    '_deleteUserMessageReference',
-    '_enrichAxiosOptions',
-    '_getConnectionID',
-    '_getImport',
-    '_getToken',
-    '_handleClientEvent',
-    '_handleUserEvent',
-    '_hasConnectionID',
-    '_isUsingServerAuth',
-    '_listImports',
-    '_logApiError',
-    '_logApiRequest',
-    '_logApiResponse',
-    '_muteStatus',
-    '_normalizeDate',
-    '_normalizeExpiration',
-    '_queryFlagReports',
-    '_queryFlags',
-    '_reviewFlagReport',
-    '_sayHi',
-    '_setToken',
-    '_setupConnection',
-    '_setUser',
-    '_startCleaning',
-    '_unblockMessage',
-    '_updateMemberWatcherReferences',
-    '_updateUserMessageReferences',
-    '_updateUserReferences',
-    '_validateAndGetMessageId',
-    'addDevice',
-    'banUser',
-    'channel',
-    'closeConnection',
-    'commitMessage',
-    'connect',
-    'connectAnonymousUser',
-    'connectUser',
-    'createAbortControllerForNextRequest',
-    'createBlockList',
-    'createCampaign',
-    'createChannelType',
-    'createCommand',
-    'createPermission',
-    'createRole',
-    'createSegment',
-    'createToken',
-    'deactivateUser',
-    'deactivateUsers',
-    'delete',
-    'deleteBlockList',
-    'deleteCampaign',
-    'deleteChannels',
-    'deleteChannelType',
-    'deleteCommand',
-    'deleteMessage',
-    'deletePermission',
-    'deletePushProvider',
-    'deleteRole',
-    'deleteSegment',
-    'deleteUser',
-    'deleteUsers',
-    'devToken',
-    'disconnect',
-    'disconnectUser',
-    'dispatchEvent',
-    'doAxiosRequest',
-    'enrichURL',
-    'errorFromResponse',
-    'exportChannel',
-    'exportChannels',
-    'exportUser',
-    'exportUsers',
-    'flagMessage',
-    'flagUser',
-    'get',
-    'getAppSettings',
-    'getAuthType',
-    'getBlockList',
-    'getCallToken',
-    'getChannelById',
-    'getChannelByMembers',
-    'getChannelType',
-    'getCommand',
-    'getDevices',
-    'getExportChannelStatus',
-    'getMessage',
-    'getPermission',
-    'getRateLimits',
-    'getTask',
-    'getUnreadCount',
-    'getUserAgent',
-    'handleEvent',
-    'handleResponse',
-    'hydrateActiveChannels',
-    'listBlockLists',
-    'listChannelTypes',
-    'listCommands',
-    'listPermissions',
-    'listPushProviders',
-    'listRoles',
-    'markAllRead',
-    'markChannelsRead',
-    'muteUser',
-    'off',
-    'on',
-    'openConnection',
-    'partialUpdateMessage',
-    'partialUpdateUser',
-    'partialUpdateUsers',
-    'patch',
-    'pinMessage',
-    'post',
-    'put',
-    'queryBannedUsers',
-    'queryCampaigns',
-    'queryChannels',
-    'queryMessageFlags',
-    'queryRecipients',
-    'querySegments',
-    'queryUsers',
-    'reactivateUser',
-    'reactivateUsers',
-    'recoverState',
-    'removeDevice',
-    'removeShadowBan',
-    'restoreUsers',
-    'resumeCampaign',
-    'revokeTokens',
-    'revokeUsersToken',
-    'revokeUserToken',
-    'scheduleCampaign',
-    'search',
-    'sendFile',
-    'sendUserCustomEvent',
-    'setAnonymousUser',
-    'setBaseURL',
-    'setGuestUser',
-    'setLocalDevice',
-    'setUser',
-    'setUserAgent',
-    'shadowBan',
-    'stopCampaign',
-    'sync',
-    'testCampaign',
-    'testPushSettings',
-    'testSQSSettings',
-    'translateMessage',
-    'unbanUser',
-    'unblockMessage',
-    'unflagMessage',
-    'unflagUser',
-    'unmuteUser',
-    'unpinMessage',
-    'updateAppSettings',
-    'updateBlockList',
-    'updateCampaign',
-    'updateChannelType',
-    'updateCommand',
-    'updateMessage',
-    'updatePermission',
-    'updateSegment',
-    'updateUser',
-    'updateUsers',
-    'upsertPushProvider',
-    'upsertUser',
-    'upsertUsers',
-    'userMuteStatus',
-    'verifyWebhook',
-];
-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 STREAM_CHANNEL_RESULT_METHOD_NAMES = [
-    'channel',
-    'getChannelById',
-    'getChannelByMembers',
-    'hydrateActiveChannels',
-    'queryChannels',
-];
-export const STREAM_SYNC_CHANNEL_RESULT_METHOD_NAMES = [
-    'channel',
-    'getChannelById',
-    'getChannelByMembers',
-    'hydrateActiveChannels',
-];
-export const CHANNEL_METHOD_NAMES = [
-    '_callChannelListeners',
-    '_channelURL',
-    '_checkInitialized',
-    '_countMessageAsUnread',
-    '_disconnect',
-    '_extendEventWithOwnReactions',
-    '_handleChannelEvent',
-    '_initializeState',
-    '_update',
-    'acceptInvite',
-    'addMembers',
-    'addModerators',
-    'assignRoles',
-    'banUser',
-    'clean',
-    'countUnread',
-    'countUnreadMentions',
-    'create',
-    'createCall',
-    'delete',
-    'deleteFile',
-    'deleteImage',
-    'deleteReaction',
-    'demoteModerators',
-    'disableSlowMode',
-    'enableSlowMode',
-    'getClient',
-    'getConfig',
-    'getMessagesById',
-    'getPinnedMessages',
-    'getReactions',
-    'getReplies',
-    'hide',
-    'inviteMembers',
-    'keystroke',
-    'lastMessage',
-    'lastRead',
-    'markRead',
-    'markUnread',
-    'mute',
-    'muteStatus',
-    'off',
-    'on',
-    'query',
-    'queryMembers',
-    'rejectInvite',
-    'removeMembers',
-    'removeShadowBan',
-    'search',
-    'sendAction',
-    'sendEvent',
-    'sendFile',
-    'sendImage',
-    'sendMessage',
-    'sendReaction',
-    'shadowBan',
-    'show',
-    'stopTyping',
-    'stopWatching',
-    'truncate',
-    'unbanUser',
-    'unmute',
-    'update',
-    'updatePartial',
-    'watch',
-];
-export const CHANNEL_SYNC_METHOD_NAMES = [
-    '_callChannelListeners',
-    '_channelURL',
-    '_checkInitialized',
-    '_countMessageAsUnread',
-    '_disconnect',
-    '_extendEventWithOwnReactions',
-    '_handleChannelEvent',
-    '_initializeState',
-    'clean',
-    'countUnread',
-    'countUnreadMentions',
-    'getConfig',
-    'lastMessage',
-    'lastRead',
-    'muteStatus',
-    'off',
-    'on',
-];
-export const CHANNEL_SYNC_PROXY_RESULT_METHOD_NAMES = ['getClient'];

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

@@ -1,170 +0,0 @@
-import { STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX } from '../constants';
-export class RedisCooldown {
-    static resolveRedisKey(cooldownKey, options) {
-        const keyPrefix = options?.keyPrefix ?? STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX;
-        return `${keyPrefix}${cooldownKey}`;
-    }
-    static async getRemainingMs(cooldownKey, context, options) {
-        const { redis, logger } = context;
-        try {
-            const ttlMs = await redis.pttl(RedisCooldown.resolveRedisKey(cooldownKey, options));
-            if (ttlMs > 0) {
-                return ttlMs;
-            }
-        }
-        catch (error) {
-            logger.warn('Failed to read stream rate-limit cooldown from Redis', {
-                cooldownKey,
-                error,
-            });
-        }
-        return 0;
-    }
-    static async setRemainingMs(cooldownKey, cooldownMs, context, options) {
-        if (cooldownMs <= 0) {
-            return;
-        }
-        const { redis, logger } = context;
-        const redisKey = RedisCooldown.resolveRedisKey(cooldownKey, options);
-        try {
-            await redis.eval(`
-        local key = KEYS[1]
-        local new_ttl = tonumber(ARGV[1])
-        local current_ttl = redis.call('PTTL', key)
-
-        if current_ttl == -2 then
-          redis.call('SET', key, '1', 'PX', new_ttl)
-          return 1
-        end
-
-        if current_ttl == -1 or current_ttl < new_ttl then
-          redis.call('PEXPIRE', key, new_ttl)
-          return 2
-        end
-
-        return 0
-      `, 1, redisKey, cooldownMs.toString());
-        }
-        catch (error) {
-            logger.warn('Failed to write stream rate-limit cooldown to Redis', {
-                cooldownKey,
-                cooldownMs,
-                error,
-            });
-        }
-    }
-    static async setRemainingMsExact(cooldownKey, cooldownMs, context, options) {
-        if (cooldownMs <= 0) {
-            return;
-        }
-        const { redis, logger } = context;
-        try {
-            await redis.set(RedisCooldown.resolveRedisKey(cooldownKey, options), '1', 'PX', cooldownMs);
-        }
-        catch (error) {
-            logger.warn('Failed to write exact stream rate-limit cooldown to Redis', {
-                cooldownKey,
-                cooldownMs,
-                error,
-            });
-        }
-    }
-    static async getValue(cooldownKey, context, options) {
-        const { redis, logger } = context;
-        try {
-            const value = await redis.get(RedisCooldown.resolveRedisKey(cooldownKey, options));
-            if (typeof value === 'string' && value.length > 0) {
-                return value;
-            }
-        }
-        catch (error) {
-            logger.warn('Failed to read stream rate-limit metadata from Redis', {
-                cooldownKey,
-                error,
-            });
-        }
-    }
-    static async setValueWithRemainingMs(cooldownKey, value, cooldownMs, context, options) {
-        if (value.length === 0 || cooldownMs <= 0) {
-            return;
-        }
-        const { redis, logger } = context;
-        try {
-            await redis.eval(`
-        local key = KEYS[1]
-        local value = ARGV[1]
-        local new_ttl = tonumber(ARGV[2])
-        local current_ttl = redis.call('PTTL', key)
-
-        if current_ttl == -2 then
-          redis.call('SET', key, value, 'PX', new_ttl)
-          return 1
-        end
-
-        if current_ttl == -1 or current_ttl < new_ttl then
-          redis.call('SET', key, value, 'PX', new_ttl)
-          return 2
-        end
-
-        redis.call('SET', key, value, 'KEEPTTL')
-        return 0
-      `, 1, RedisCooldown.resolveRedisKey(cooldownKey, options), value, cooldownMs.toString());
-        }
-        catch (error) {
-            logger.warn('Failed to write stream rate-limit metadata to Redis', {
-                cooldownKey,
-                cooldownMs,
-                error,
-            });
-        }
-    }
-    static async setRemainingMsWithValue(cooldownKey, valueKey, value, cooldownMs, context, options) {
-        if (value.length === 0 || cooldownMs <= 0) {
-            return;
-        }
-        const { redis, logger } = context;
-        const cooldownRedisKey = RedisCooldown.resolveRedisKey(cooldownKey, options);
-        const valueRedisKey = RedisCooldown.resolveRedisKey(valueKey, options);
-        try {
-            await redis.eval(`
-        local cooldown_key = KEYS[1]
-        local value_key = KEYS[2]
-        local value = ARGV[1]
-        local new_ttl = tonumber(ARGV[2])
-        local current_ttl = redis.call('PTTL', cooldown_key)
-        local final_ttl = new_ttl
-
-        if current_ttl == -2 then
-          redis.call('SET', cooldown_key, '1', 'PX', new_ttl)
-        elseif current_ttl == -1 or current_ttl < new_ttl then
-          redis.call('PEXPIRE', cooldown_key, new_ttl)
-        else
-          final_ttl = current_ttl
-        end
-
-        redis.call('SET', value_key, value, 'PX', final_ttl)
-        return final_ttl
-      `, 2, cooldownRedisKey, valueRedisKey, value, cooldownMs.toString());
-        }
-        catch (error) {
-            logger.warn('Failed to write stream rate-limit cooldown and metadata to Redis', {
-                cooldownKey,
-                valueKey,
-                cooldownMs,
-                error,
-            });
-        }
-    }
-    static async clear(cooldownKey, context, options) {
-        const { redis, logger } = context;
-        try {
-            await redis.del(RedisCooldown.resolveRedisKey(cooldownKey, options));
-        }
-        catch (error) {
-            logger.warn('Failed to clear stream rate-limit cooldown from Redis', {
-                cooldownKey,
-                error,
-            });
-        }
-    }
-}

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

@@ -1,28 +0,0 @@
-import { RateLimitExceededException } from '@wildix/xbees-conversations-client';
-import { DEFAULT_RETRY_AFTER_MS } from '../constants';
-const RETRY_AFTER_HEADER_PADDING_MS = 3000;
-function toPositiveMilliseconds(milliseconds) {
-    return Math.max(0, Math.ceil(milliseconds));
-}
-function toEpochSecondsFromNow(delayMs) {
-    return Math.ceil((Date.now() + toPositiveMilliseconds(delayMs)) / 1000);
-}
-export function createRateLimitExceededException(options = {}) {
-    const { rateLimit, message, operation, retryAfterMs = DEFAULT_RETRY_AFTER_MS } = options;
-    const defaultMessage = operation ? `Rate limit exceeded for ${operation}` : 'Rate limit exceeded';
-    const retryAfterFromResetMs = rateLimit?.reset ? rateLimit.reset - Date.now() : undefined;
-    const effectiveRetryAfterMs = retryAfterFromResetMs ?? retryAfterMs;
-    const retryAfterMilliseconds = toPositiveMilliseconds(effectiveRetryAfterMs);
-    const rateLimitResetMilliseconds = rateLimit?.reset
-        ? toPositiveMilliseconds(retryAfterFromResetMs ?? 0)
-        : retryAfterMilliseconds;
-    const retryAfterEpochSeconds = toEpochSecondsFromNow(effectiveRetryAfterMs + RETRY_AFTER_HEADER_PADDING_MS);
-    return new RateLimitExceededException({
-        $metadata: {},
-        message: message || defaultMessage,
-        rateLimitRemaining: rateLimit?.remaining || 0,
-        retryAfter: retryAfterEpochSeconds,
-        rateLimit: rateLimit?.limit?.toString() || 'unknown',
-        rateLimitReset: rateLimitResetMilliseconds,
-    });
-}