@wildix/xbees-conversations-utils 1.1.85 → 1.1.86

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

@@ -0,0 +1,58 @@
+"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;
+    }
+    attachedInterceptors.add(axiosInstance);
+    axiosInstance.interceptors.response.use(async (response) => {
+        try {
+            await (0, processStreamBudgetHeaders_1.processStreamBudgetHeaders)(response?.headers, context);
+            await (0, processStreamRateLimitHeaders_1.processStreamRateLimitHeaders)(response?.headers, context);
+        }
+        catch (error) {
+            logger.warn('Failed to process Stream response headers in interceptor', { error });
+        }
+        return response;
+    }, async (error) => {
+        try {
+            await (0, processStreamBudgetHeaders_1.processStreamBudgetHeaders)(error?.response?.headers, context);
+            await (0, processStreamRateLimitHeaders_1.processStreamRateLimitHeaders)(error?.response?.headers, context);
+        }
+        catch (interceptorError) {
+            logger.warn('Failed to process Stream error headers in interceptor', { error: interceptorError });
+        }
+        return Promise.reject(error);
+    });
+}
+exports.registerStreamInterceptors = registerStreamInterceptors;

package/dist-cjs/streamRateLimitHandlingProxy/helpers/splitCallArgsAndOptions.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitCallArgsAndOptions = void 0;
+const constants_1 = require("../constants");
+function isStreamRateLimitOptionsToken(value) {
+    return typeof value === 'object' && value !== null && constants_1.STREAM_RATE_LIMIT_OPTIONS_MARKER in value;
+}
+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[constants_1.STREAM_RATE_LIMIT_OPTIONS_MARKER],
+        };
+    }
+    return { callArgs: args, callOptions: {} };
+}
+exports.splitCallArgsAndOptions = splitCallArgsAndOptions;

package/dist-cjs/streamRateLimitHandlingProxy/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./createRateLimitedStreamProxy"), exports);
+tslib_1.__exportStar(require("./withStreamRateLimitOptions"), exports);

package/dist-cjs/streamRateLimitHandlingProxy/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("./constants");

package/dist-cjs/streamRateLimitHandlingProxy/withStreamRateLimitOptions.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withStreamRateLimitOptions = void 0;
+const constants_1 = require("./constants");
+function withStreamRateLimitOptions(options) {
+    return {
+        [constants_1.STREAM_RATE_LIMIT_OPTIONS_MARKER]: options,
+    };
+}
+exports.withStreamRateLimitOptions = withStreamRateLimitOptions;

package/dist-es/index.js

@@ -1,4 +1,4 @@
 export * from './normalization';
-export * from './rateLimits';
+export * from './streamRateLimitHandlingProxy';
 export * from './stream';
 export * from './types';

package/dist-es/streamRateLimitHandlingProxy/constants.js

@@ -0,0 +1,33 @@
+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;
+export const RETRY_AFTER_BUFFER_MS = 1000;
+export const STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX = 'stream-rate-limit-cooldown:';
+export const STREAM_BUDGET_COOLDOWN_KEY_PREFIX = 'stream-budget-cooldown:';
+export const STREAM_RATE_LIMIT_OPTIONS_MARKER = '__xbsRateLimitOptions';
+export const STREAM_RATE_LIMIT_SOFT_COOLDOWN_KEY = 'stream-rate-limit-soft-global';
+export const STREAM_RATE_LIMIT_METADATA_KEY_SUFFIX = ':meta';
+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 DEFAULT_OPTIONS = {
+    maxAttempts: 3,
+    enableCooldown: true,
+    maxDelayMs: 5000,
+    maxRetryableDelayMs: 10000,
+};

package/dist-es/streamRateLimitHandlingProxy/createRateLimitedStreamProxy.js

@@ -0,0 +1,88 @@
+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 { 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 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));
+    }
+    if (!isStreamChannelLike(result)) {
+        return result;
+    }
+    return wrapTarget(result, 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, wrapAsChannelResult);
+    };
+}
+function wrapTarget(target, dependencies) {
+    const cachedObject = dependencies.cache.get(target);
+    if (cachedObject) {
+        return cachedObject;
+    }
+    const proxy = new Proxy(target, {
+        get: (originalTarget, property, receiver) => {
+            const value = Reflect.get(originalTarget, property, receiver);
+            if (typeof property !== 'string' || typeof value !== 'function') {
+                return value;
+            }
+            if (STREAM_SYNC_CHANNEL_RESULT_METHODS.has(property)) {
+                return (...args) => {
+                    const { callArgs } = splitCallArgsAndOptions(args);
+                    const result = Reflect.apply(value, originalTarget, callArgs);
+                    return normalizeStreamCallResult(result, dependencies, true);
+                };
+            }
+            if (CHANNEL_SYNC_PROXY_RESULT_METHODS.has(property)) {
+                return (...args) => {
+                    const { callArgs } = splitCallArgsAndOptions(args);
+                    const result = Reflect.apply(value, originalTarget, callArgs);
+                    if (typeof result === 'object' && result !== null) {
+                        return wrapTarget(result, dependencies);
+                    }
+                    return result;
+                };
+            }
+            if (STREAM_SYNC_METHODS.has(property) || CHANNEL_SYNC_METHODS.has(property)) {
+                return (...args) => {
+                    const { callArgs } = splitCallArgsAndOptions(args);
+                    return Reflect.apply(value, originalTarget, callArgs);
+                };
+            }
+            return createRateLimitedMethodWrapper(originalTarget, value, property, dependencies, STREAM_CHANNEL_RESULT_METHODS.has(property));
+        },
+    });
+    dependencies.cache.set(target, proxy);
+    return proxy;
+}
+export function createRateLimitedStreamProxy(stream, context) {
+    registerStreamInterceptors(stream, context);
+    return wrapTarget(stream, {
+        context,
+        cache: new WeakMap(),
+    });
+}

package/dist-es/streamRateLimitHandlingProxy/generatedMethodNames.js

@@ -0,0 +1,317 @@
+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'];