@wildix/xbees-conversations-utils 1.1.57 → 1.1.58

package/dist-es/rateLimits/executeStreamRequestWithRateLimitHandling.js

@@ -1,71 +1,93 @@
-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';
+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);
+  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 { logger, 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, logger });
-        if (cooldownMs > 0) {
-            logger.warn('Skipping stream request due to active rate-limit cooldown', {
-                operation,
-                cooldown: cooldownMs,
-            });
-            throw createRateLimitExceededException({ operation, retryAfterMs: cooldownMs });
-        }
+  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, logger);
-            if (!rateLimitError) {
-                throw error;
-            }
-            const retryAfterMs = calculateRateLimitDelayMs(rateLimitError, maxDelayMs);
-            if (enableCooldown) {
-                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;
-        }
+  }
+
+  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/helpers/RedisCooldown.js

@@ -0,0 +1,52 @@
+import { STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX } from '../constants';
+export class RedisCooldown {
+    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;
+        }
+        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)
+
+        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) {
+            console.warn('Failed to write stream rate-limit cooldown to Redis', {
+                cooldownKey,
+                cooldownMs,
+                error,
+            });
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+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,
+    });
+}

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

@@ -0,0 +1,68 @@
+import { setTimeout as sleep } from 'node:timers/promises';
+import { DEFAULT_FIXED_RATE_LIMIT_DELAY_MS, DEFAULT_JITTER_MS, DEFAULT_RETRY_AFTER_MS, RETRY_AFTER_BUFFER_MS, } from '../constants';
+import { createRateLimitExceededException } from './createRateLimitExceededException';
+import { processStreamRateLimitException } from './processStreamRateLimitException';
+import { RedisCooldown } from './RedisCooldown';
+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);
+}
+export 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.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/helpers/isStreamChannelLike.js

@@ -0,0 +1,11 @@
+function hasFunctionProperty(value, key) {
+    return key in value && typeof value[key] === 'function';
+}
+export function isStreamChannelLike(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    return (hasFunctionProperty(value, 'sendMessage') &&
+        hasFunctionProperty(value, 'queryMembers') &&
+        hasFunctionProperty(value, 'updatePartial'));
+}

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

@@ -0,0 +1,27 @@
+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/helpers/splitCallArgsAndOptions.js

@@ -0,0 +1,17 @@
+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 +1,2 @@
 export * from './createRateLimitedStreamProxy';
+export * from './withStreamRateLimitOptions';

package/dist-es/rateLimits/types.js

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

package/dist-es/rateLimits/withStreamRateLimitOptions.js

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

package/dist-types/index.d.ts

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

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

@@ -1,5 +1,7 @@
-import { LoggerContext, RedisContext } from "./types";
+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>;
+  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,10 +1,8 @@
 import { StreamRateLimitRetryOptions } from './types';
 export declare const DEFAULT_FIXED_RATE_LIMIT_DELAY_MS = 15000;
-export declare const DEFAULT_MAX_DELAY_MS = 15000;
-export declare const DEFAULT_MAX_RETRYABLE_DELAY_MS = 5000;
 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 DEFAULT_RETRY_AFTER_MS = 10000;
-export declare const DEFAULT_OPTS_1_ATTEMPT_NO_COOLDOWN: StreamRateLimitRetryOptions;
-export declare const DEFAULT_OPTS_3_ATTEMPTS_WITH_COOLDOWN: StreamRateLimitRetryOptions;
+export declare const STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX = "stream-rate-limit-cooldown:";
+export declare const STREAM_RATE_LIMIT_OPTIONS_MARKER = "__xbsRateLimitOptions";
+export declare const DEFAULT_OPTIONS: StreamRateLimitRetryOptions;

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

@@ -1,15 +1,8 @@
 import { StreamChat } from 'stream-chat';
-import { LoggerContext, RedisContext } from './types';
-import { StreamRateLimitRetryOptions } from './types';
-import { StreamType } from "../stream";
-declare const STREAM_RATE_LIMIT_OPTIONS_MARKER = "__xbsRateLimitOptions";
-type StreamRateLimitOptionsToken = {
-    [STREAM_RATE_LIMIT_OPTIONS_MARKER]: Partial<StreamRateLimitRetryOptions>;
-};
-type MethodWithRateLimitOptions<T> = T extends (...args: infer Args) => infer Result ? T & ((...args: [...Args, StreamRateLimitOptionsToken?]) => Result) : T;
-export type RateLimited<T extends object> = {
-    [Key in keyof T]: MethodWithRateLimitOptions<T[Key]>;
-};
-export declare function withStreamRateLimitOptions(options: Partial<StreamRateLimitRetryOptions>): StreamRateLimitOptionsToken;
+import { StreamType } from '../stream';
+import { LoggerContext, RateLimited, RedisContext } from './types';
+/**
+ * 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>>;
-export {};

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

@@ -1,10 +1,12 @@
-import { RateLimitExceededException } from '@wildix/xbees-conversations-client';
-import { RateLimitsInfo } from 'stream-chat';
+import {RateLimitExceededException} from '@wildix/xbees-conversations-client';
+
+import {RateLimitsInfo} from 'stream-chat';
+
 type Options = {
-    rateLimit?: RateLimitsInfo;
-    message?: string;
-    operation?: string;
-    retryAfterMs?: number;
+  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,3 +1,8 @@
-import { RateLimitExceededException } from '@wildix/xbees-conversations-client';
-import { Logger } from '@aws-lambda-powertools/logger';
-export declare function processStreamRateLimitException(error: unknown, logger: Logger): RateLimitExceededException | undefined;
+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,2 +1,8 @@
-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>;
+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>;

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

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

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

@@ -0,0 +1,10 @@
+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/helpers/executeWithRateLimitHandling.d.ts

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

package/dist-types/rateLimits/helpers/isStreamChannelLike.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Detects Stream channel-like objects.
+ * These objects should be correctly wrapped to keep rate-limit behavior
+ * on methods returned from other proxied calls.
+ */
+export declare function isStreamChannelLike(value: unknown): value is object;

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

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

package/dist-types/rateLimits/helpers/splitCallArgsAndOptions.d.ts

@@ -0,0 +1,6 @@
+import { ArgsAndOptions } from '../types';
+/**
+ * Splits original call args and optional rate-limit options token.
+ * If no token is provided, options fallback to an empty object.
+ */
+export declare function splitCallArgsAndOptions(args: unknown[]): ArgsAndOptions;

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

@@ -1 +1,2 @@
 export * from './createRateLimitedStreamProxy';
+export * from './withStreamRateLimitOptions';

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

@@ -1,7 +1,8 @@
-import { StreamChat } from 'stream-chat';
-import { StreamChannel, StreamType } from "../stream";
 import Redis from 'ioredis';
-import { Logger } from "@aws-lambda-powertools/logger";
+import { StreamChat } from 'stream-chat';
+import { StreamChannel, StreamType } from '../stream';
+import { STREAM_RATE_LIMIT_OPTIONS_MARKER } from './constants';
+import { Logger } from '@aws-lambda-powertools/logger';
 export type StreamOperationType = keyof StreamChat<StreamType> | keyof StreamChannel;
 export interface StreamRateLimitRetryOptions {
     maxAttempts: number;
@@ -9,9 +10,20 @@ export interface StreamRateLimitRetryOptions {
     maxRetryableDelayMs: number;
     enableCooldown: boolean;
 }
+export type StreamRateLimitOptionsToken = {
+    [STREAM_RATE_LIMIT_OPTIONS_MARKER]: Partial<StreamRateLimitRetryOptions>;
+};
+export type MethodWithRateLimitOptions<T> = T extends (...args: infer Args) => infer Result ? T & ((...args: [...Args, StreamRateLimitOptionsToken?]) => Result) : T;
+export type RateLimited<T extends object> = {
+    [Key in keyof T]: MethodWithRateLimitOptions<T[Key]>;
+};
 export type RedisContext = {
     redis: Redis;
 };
 export type LoggerContext = {
     logger: Logger;
 };
+export type ArgsAndOptions = {
+    callArgs: unknown[];
+    callOptions: Partial<StreamRateLimitRetryOptions>;
+};

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

@@ -0,0 +1,6 @@
+import { StreamRateLimitOptionsToken, StreamRateLimitRetryOptions } from './types';
+/**
+ * Creates a marker token that can be passed as the last argument to proxied Stream methods.
+ * The proxy strips this token from original method args and uses it as per-call retry options.
+ */
+export declare function withStreamRateLimitOptions(options: Partial<StreamRateLimitRetryOptions>): StreamRateLimitOptionsToken;

package/dist-types/types.d.ts

@@ -1,4 +1,4 @@
-import { Channel, ChannelMemberRole, ChannelMember, Message, Reaction, User } from "@wildix/xbees-conversations-client";
+import { Channel, ChannelMember, ChannelMemberRole, Message, Reaction, User } from '@wildix/xbees-conversations-client';
 export declare enum MessageDirection {
     INCOMING = "incoming",
     OUTGOING = "outgoing"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wildix/xbees-conversations-utils",
-  "version": "1.1.57",
+  "version": "1.1.58",
   "description": "",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",
@@ -13,7 +13,10 @@
     "build:types": "tsc -p tsconfig.types.json",
     "build:types:downlevel": "downlevel-dts dist-types dist-types/ts3.4",
     "build:api-extractor": "mkdir -p etc && api-extractor run --local --verbose",
+    "check-types": "tsc --noemit",
     "clean": "rimraf ./dist-* && rimraf *.tsbuildinfo",
+    "lint": "eslint . && npm run check-types",
+    "lint:fix": "eslint . --fix",
     "postpublish": "node ../../scripts/postpublish.js"
   },
   "engines": {
@@ -30,8 +33,10 @@
   "devDependencies": {
     "@tsconfig/node18": "18.2.4",
     "@tsconfig/recommended": "1.0.1",
+    "@wildix/eslint-config-style-guide": "1.2.1",
     "concurrently": "7.0.0",
     "downlevel-dts": "0.10.1",
+    "eslint": "8.57.1",
     "rimraf": "^3.0.0",
     "typescript": "~5.2.2"
   },