@wildix/xbees-conversations-utils 1.1.56 → 1.1.58

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeWithRateLimitHandling = void 0;
+const promises_1 = require("node:timers/promises");
+const constants_1 = require("../constants");
+const createRateLimitExceededException_1 = require("./createRateLimitExceededException");
+const processStreamRateLimitException_1 = require("./processStreamRateLimitException");
+const RedisCooldown_1 = require("./RedisCooldown");
+function calculateRateLimitDelayMs(error, maxDelayMs) {
+    const retryAfterMs = typeof error.retryAfter === 'number' ? error.retryAfter + constants_1.RETRY_AFTER_BUFFER_MS : constants_1.DEFAULT_RETRY_AFTER_MS;
+    if (retryAfterMs > 0) {
+        const jitterMs = Math.floor(Math.random() * constants_1.DEFAULT_JITTER_MS);
+        return Math.min(maxDelayMs, retryAfterMs + jitterMs);
+    }
+    return Math.min(maxDelayMs, constants_1.DEFAULT_FIXED_RATE_LIMIT_DELAY_MS);
+}
+async function executeWithRateLimitHandling(execute, operation, context, options) {
+    const { redis } = context;
+    const { enableCooldown, maxAttempts, maxDelayMs, maxRetryableDelayMs } = options;
+    let attempt = 1;
+    if (enableCooldown) {
+        const cooldownMs = await RedisCooldown_1.RedisCooldown.getRemainingMs(operation, { redis });
+        if (cooldownMs > 0) {
+            console.warn('Skipping stream request due to active rate-limit cooldown', {
+                operation,
+                cooldown: cooldownMs,
+            });
+            throw (0, createRateLimitExceededException_1.createRateLimitExceededException)({ operation, retryAfterMs: cooldownMs });
+        }
+    }
+    for (;;) {
+        try {
+            return await execute();
+        }
+        catch (error) {
+            const rateLimitError = (0, processStreamRateLimitException_1.processStreamRateLimitException)(error);
+            if (!rateLimitError) {
+                throw error;
+            }
+            const retryAfterMs = calculateRateLimitDelayMs(rateLimitError, maxDelayMs);
+            if (enableCooldown) {
+                await RedisCooldown_1.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 (0, promises_1.setTimeout)(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;
+        }
+    }
+}
+exports.executeWithRateLimitHandling = executeWithRateLimitHandling;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isStreamChannelLike = void 0;
+function hasFunctionProperty(value, key) {
+    return key in value && typeof value[key] === 'function';
+}
+function isStreamChannelLike(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    return (hasFunctionProperty(value, 'sendMessage') &&
+        hasFunctionProperty(value, 'queryMembers') &&
+        hasFunctionProperty(value, 'updatePartial'));
+}
+exports.isStreamChannelLike = isStreamChannelLike;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processStreamRateLimitException = void 0;
+const createRateLimitExceededException_1 = require("./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;
+}
+function processStreamRateLimitException(error) {
+    if (isStreamException(error) && error.metadata?.responseCode === 429) {
+        const rateLimit = error.metadata?.rateLimit;
+        console.warn('Stream rate limit exceeded [StreamException]', { rateLimit });
+        return (0, createRateLimitExceededException_1.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 (0, createRateLimitExceededException_1.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 (0, createRateLimitExceededException_1.createRateLimitExceededException)({ message: 'Rate limit exceeded' });
+    }
+}
+exports.processStreamRateLimitException = processStreamRateLimitException;

package/dist-cjs/rateLimits/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/rateLimits/index.js

@@ -2,3 +2,4 @@
 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/rateLimits/types.js

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

package/dist-cjs/rateLimits/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 './types';
 export * from './normalization';
-export * from './stream';
 export * from './rateLimits';
+export * from './stream';
+export * from './types';

package/dist-es/rateLimits/RedisCooldown.js

@@ -1,29 +1,36 @@
-import { STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX } from './constants';
+import {STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX} from './constants';
+
 export class RedisCooldown {
-    static async getRemainingMs(cooldownKey, context) {
-        const { redis, logger } = context;
-        try {
-            const ttlMs = await redis.pttl(`${STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX}${cooldownKey}`);
-            if (ttlMs > 0) {
-                return ttlMs;
-            }
-        }
-        catch (error) {
-            logger.warn('Failed to read stream rate-limit cooldown from Redis', {
-                cooldownKey,
-                error,
-            });
-        }
-        return 0;
+  static async getRemainingMs(cooldownKey, context) {
+    const {redis} = context;
+
+    try {
+      const ttlMs = await redis.pttl(`${STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX}${cooldownKey}`);
+
+      if (ttlMs > 0) {
+        return ttlMs;
+      }
+    } catch (error) {
+      console.warn('Failed to read stream rate-limit cooldown from Redis', {
+        cooldownKey,
+        error,
+      });
+    }
+
+    return 0;
+  }
+
+  static async setRemainingMs(cooldownKey, cooldownMs, context) {
+    if (cooldownMs <= 0) {
+      return;
     }
-    static async setRemainingMs(cooldownKey, cooldownMs, context) {
-        if (cooldownMs <= 0) {
-            return;
-        }
-        const { redis, logger } = context;
-        const redisKey = `${STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX}${cooldownKey}`;
-        try {
-            await redis.eval(`
+
+    const {redis} = context;
+    const redisKey = `${STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX}${cooldownKey}`;
+
+    try {
+      await redis.eval(
+        `
         local key = KEYS[1]
         local new_ttl = tonumber(ARGV[1])
         local current_ttl = redis.call('PTTL', key)
@@ -39,14 +46,17 @@ export class RedisCooldown {
         end
 
         return 0
-      `, 1, redisKey, cooldownMs.toString());
-        }
-        catch (error) {
-            logger.warn('Failed to write stream rate-limit cooldown to Redis', {
-                cooldownKey,
-                cooldownMs,
-                error,
-            });
-        }
+      `,
+        1,
+        redisKey,
+        cooldownMs.toString(),
+      );
+    } catch (error) {
+      console.warn('Failed to write stream rate-limit cooldown to Redis', {
+        cooldownKey,
+        cooldownMs,
+        error,
+      });
     }
+  }
 }

package/dist-es/rateLimits/constants.js

@@ -1,19 +1,12 @@
 export const DEFAULT_FIXED_RATE_LIMIT_DELAY_MS = 15000;
-export const DEFAULT_MAX_DELAY_MS = 15000;
-export const DEFAULT_MAX_RETRYABLE_DELAY_MS = 5000;
 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 DEFAULT_RETRY_AFTER_MS = 10000;
-export const DEFAULT_OPTS_1_ATTEMPT_NO_COOLDOWN = {
-    maxAttempts: 1,
-    enableCooldown: false,
-    maxDelayMs: DEFAULT_MAX_DELAY_MS,
-    maxRetryableDelayMs: DEFAULT_MAX_RETRYABLE_DELAY_MS,
-};
-export const DEFAULT_OPTS_3_ATTEMPTS_WITH_COOLDOWN = {
+export const STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX = 'stream-rate-limit-cooldown:';
+export const STREAM_RATE_LIMIT_OPTIONS_MARKER = '__xbsRateLimitOptions';
+export const DEFAULT_OPTIONS = {
     maxAttempts: 3,
     enableCooldown: true,
-    maxDelayMs: DEFAULT_MAX_DELAY_MS,
-    maxRetryableDelayMs: DEFAULT_MAX_RETRYABLE_DELAY_MS,
+    maxDelayMs: 15000,
+    maxRetryableDelayMs: 5000,
 };

package/dist-es/rateLimits/createRateLimitedStreamProxy.js

@@ -1,68 +1,33 @@
-import { DEFAULT_OPTS_3_ATTEMPTS_WITH_COOLDOWN } from './constants';
-import { executeStreamRequestWithRateLimitHandling } from './executeStreamRequestWithRateLimitHandling';
-const STREAM_RATE_LIMIT_OPTIONS_MARKER = '__xbsRateLimitOptions';
-const STREAM_RATE_LIMIT_PROXY_MARKER = Symbol('xbsStreamRateLimitProxy');
-const OPERATION_DEFAULT_OPTIONS = {
-    queryChannels: DEFAULT_OPTS_3_ATTEMPTS_WITH_COOLDOWN,
-};
-function isObject(value) {
-    return typeof value === 'object' && value !== null;
-}
-function hasFunctionProperty(value, key) {
-    return key in value && typeof value[key] === 'function';
-}
-function isStreamChannelLike(value) {
-    if (!isObject(value)) {
-        return false;
-    }
-    return (hasFunctionProperty(value, 'sendMessage') &&
-        hasFunctionProperty(value, 'queryMembers') &&
-        hasFunctionProperty(value, 'updatePartial'));
-}
-function isStreamRateLimitOptionsToken(value) {
-    return isObject(value) && STREAM_RATE_LIMIT_OPTIONS_MARKER in value;
-}
-function splitCallArgsAndOptions(args) {
-    if (args.length === 0) {
-        return { callArgs: args, callOptions: {} };
+import { DEFAULT_OPTIONS } from './constants';
+import { executeWithRateLimitHandling } from './helpers/executeWithRateLimitHandling';
+import { isStreamChannelLike } from './helpers/isStreamChannelLike';
+import { splitCallArgsAndOptions } from './helpers/splitCallArgsAndOptions';
+function normalizeStreamCallResult(result, dependencies) {
+    if (Array.isArray(result)) {
+        return result.map((item) => normalizeStreamCallResult(item, dependencies));
     }
-    const lastArg = args[args.length - 1];
-    if (isStreamRateLimitOptionsToken(lastArg)) {
-        return {
-            callArgs: args.slice(0, -1),
-            callOptions: lastArg[STREAM_RATE_LIMIT_OPTIONS_MARKER],
-        };
+    if (!isStreamChannelLike(result)) {
+        return result;
     }
-    return { callArgs: args, callOptions: {} };
-}
-export function withStreamRateLimitOptions(options) {
-    return {
-        [STREAM_RATE_LIMIT_OPTIONS_MARKER]: options,
+    return wrapTarget(result, dependencies);
+}
+function createRateLimitedMethodWrapper(target, value, operation, dependencies) {
+    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);
     };
 }
-function createRateLimitedProxy(target, context, cache) {
-    const cached = cache.get(target);
-    if (cached) {
-        return cached;
+function wrapTarget(target, dependencies) {
+    const cachedObject = dependencies.cache.get(target);
+    if (cachedObject) {
+        return cachedObject;
     }
-    const wrapResult = (result) => {
-        if (Array.isArray(result)) {
-            return result.map((item) => wrapResult(item));
-        }
-        if (!isStreamChannelLike(result)) {
-            return result;
-        }
-        const cachedResult = cache.get(result);
-        if (cachedResult) {
-            return cachedResult;
-        }
-        return createRateLimitedProxy(result, context, cache);
-    };
     const proxy = new Proxy(target, {
         get: (originalTarget, property, receiver) => {
-            if (property === STREAM_RATE_LIMIT_PROXY_MARKER) {
-                return true;
-            }
             const value = Reflect.get(originalTarget, property, receiver);
             if (typeof property !== 'string' || typeof value !== 'function') {
                 return value;
@@ -70,25 +35,18 @@ function createRateLimitedProxy(target, context, cache) {
             if (property === 'channel') {
                 return (...args) => {
                     const channel = Reflect.apply(value, originalTarget, args);
-                    return wrapResult(channel);
+                    return normalizeStreamCallResult(channel, dependencies);
                 };
             }
-            return async (...args) => {
-                const { callArgs, callOptions } = splitCallArgsAndOptions(args);
-                const operation = property;
-                const defaultOptions = OPERATION_DEFAULT_OPTIONS[operation] || {};
-                const result = await executeStreamRequestWithRateLimitHandling(() => Reflect.apply(value, originalTarget, callArgs), operation, context, {
-                    ...defaultOptions,
-                    ...callOptions,
-                });
-                return wrapResult(result);
-            };
+            return createRateLimitedMethodWrapper(originalTarget, value, property, dependencies);
         },
     });
-    cache.set(target, proxy);
+    dependencies.cache.set(target, proxy);
     return proxy;
 }
 export function createRateLimitedStreamProxy(stream, context) {
-    const cache = new WeakMap();
-    return createRateLimitedProxy(stream, context, cache);
+    return wrapTarget(stream, {
+        context,
+        cache: new WeakMap(),
+    });
 }

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

@@ -1,14 +1,17 @@
-import { RateLimitExceededException } from '@wildix/xbees-conversations-client';
-import { DEFAULT_RETRY_AFTER_MS } from '../constants';
+import {RateLimitExceededException} from '@wildix/xbees-conversations-client';
+
+import {DEFAULT_RETRY_AFTER_MS} from '../constants';
+
 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';
-    return new RateLimitExceededException({
-        $metadata: {},
-        message: message || defaultMessage,
-        rateLimitRemaining: rateLimit?.remaining || 0,
-        retryAfter: rateLimit?.reset ? rateLimit.reset - Date.now() : retryAfterMs,
-        rateLimit: rateLimit?.limit?.toString() || 'unknown',
-        rateLimitReset: rateLimit?.reset || Date.now() + retryAfterMs,
-    });
+  const {rateLimit, message, operation, retryAfterMs = DEFAULT_RETRY_AFTER_MS} = options;
+  const defaultMessage = operation ? `Rate limit exceeded for ${operation}` : 'Rate limit exceeded';
+
+  return new RateLimitExceededException({
+    $metadata: {},
+    message: message || defaultMessage,
+    rateLimitRemaining: rateLimit?.remaining || 0,
+    retryAfter: rateLimit?.reset ? rateLimit.reset - Date.now() : retryAfterMs,
+    rateLimit: rateLimit?.limit?.toString() || 'unknown',
+    rateLimitReset: rateLimit?.reset || Date.now() + retryAfterMs,
+  });
 }

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

@@ -1,27 +1,37 @@
-import { createRateLimitExceededException } from './createRateLimitExceededException';
+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);
+  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;
+  return typeof error === 'object' && !!error.code;
 }
-export function processStreamRateLimitException(error, logger) {
-    if (isStreamException(error) && error.metadata?.responseCode === 429) {
-        const rateLimit = error.metadata?.rateLimit;
-        logger.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)) {
-        logger.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) {
-        logger.warn('Stream rate limit exceeded [error.status === 429]');
-        return createRateLimitExceededException({ message: 'Rate limit exceeded' });
-    }
+
+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'});
+  }
 }