signal-sdk 0.0.9 → 0.1.1

package/dist/__tests__/config.test.js

@@ -0,0 +1,252 @@
+"use strict";
+/**
+ * Additional tests for config.ts
+ * Tests configuration validation and logger functionality
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../config");
+describe('Config Additional Tests', () => {
+    describe('validateConfig', () => {
+        test('should return default config when no user config provided', () => {
+            const config = (0, config_1.validateConfig)();
+            expect(config).toEqual(config_1.DEFAULT_CONFIG);
+        });
+        test('should merge user config with defaults', () => {
+            const userConfig = {
+                verbose: true,
+                maxRetries: 5
+            };
+            const config = (0, config_1.validateConfig)(userConfig);
+            expect(config.verbose).toBe(true);
+            expect(config.maxRetries).toBe(5);
+            expect(config.connectionTimeout).toBe(config_1.DEFAULT_CONFIG.connectionTimeout);
+        });
+        test('should throw error for negative connectionTimeout', () => {
+            expect(() => (0, config_1.validateConfig)({ connectionTimeout: -1 }))
+                .toThrow('connectionTimeout must be non-negative');
+        });
+        test('should throw error for negative requestTimeout', () => {
+            expect(() => (0, config_1.validateConfig)({ requestTimeout: -100 }))
+                .toThrow('requestTimeout must be non-negative');
+        });
+        test('should throw error for negative maxRetries', () => {
+            expect(() => (0, config_1.validateConfig)({ maxRetries: -5 }))
+                .toThrow('maxRetries must be non-negative');
+        });
+        test('should throw error for negative retryDelay', () => {
+            expect(() => (0, config_1.validateConfig)({ retryDelay: -1000 }))
+                .toThrow('retryDelay must be non-negative');
+        });
+        test('should throw error for maxConcurrentRequests less than 1', () => {
+            expect(() => (0, config_1.validateConfig)({ maxConcurrentRequests: 0 }))
+                .toThrow('maxConcurrentRequests must be at least 1');
+            expect(() => (0, config_1.validateConfig)({ maxConcurrentRequests: -1 }))
+                .toThrow('maxConcurrentRequests must be at least 1');
+        });
+        test('should throw error for negative minRequestInterval', () => {
+            expect(() => (0, config_1.validateConfig)({ minRequestInterval: -50 }))
+                .toThrow('minRequestInterval must be non-negative');
+        });
+        test('should accept all valid trustNewIdentities values', () => {
+            expect(() => (0, config_1.validateConfig)({ trustNewIdentities: 'on-first-use' }))
+                .not.toThrow();
+            expect(() => (0, config_1.validateConfig)({ trustNewIdentities: 'always' }))
+                .not.toThrow();
+            expect(() => (0, config_1.validateConfig)({ trustNewIdentities: 'never' }))
+                .not.toThrow();
+        });
+        test('should accept zero values for valid fields', () => {
+            const config = (0, config_1.validateConfig)({
+                connectionTimeout: 0,
+                requestTimeout: 0,
+                maxRetries: 0,
+                retryDelay: 0,
+                minRequestInterval: 0
+            });
+            expect(config.connectionTimeout).toBe(0);
+            expect(config.requestTimeout).toBe(0);
+            expect(config.maxRetries).toBe(0);
+            expect(config.retryDelay).toBe(0);
+            expect(config.minRequestInterval).toBe(0);
+        });
+        test('should handle all configuration options', () => {
+            const fullConfig = {
+                signalCliPath: '/custom/path/signal-cli',
+                account: '+1234567890',
+                connectionTimeout: 60000,
+                requestTimeout: 120000,
+                enableRetry: false,
+                maxRetries: 10,
+                retryDelay: 2000,
+                verbose: true,
+                logFile: '/var/log/signal.log',
+                maxConcurrentRequests: 10,
+                minRequestInterval: 200,
+                autoReconnect: false,
+                trustNewIdentities: 'never',
+                disableSendLog: true
+            };
+            const config = (0, config_1.validateConfig)(fullConfig);
+            expect(config).toMatchObject(fullConfig);
+        });
+    });
+    describe('Logger', () => {
+        let logger;
+        beforeEach(() => {
+            logger = new config_1.Logger({
+                level: 'debug',
+                enableConsole: true,
+                enableFile: false,
+                includeTimestamp: true,
+                includeLevel: true
+            });
+        });
+        test('should create logger with default config', () => {
+            const defaultLogger = new config_1.Logger();
+            expect(defaultLogger).toBeDefined();
+        });
+        test('should log debug messages', () => {
+            const consoleSpy = jest.spyOn(console, 'debug').mockImplementation();
+            logger.debug('Test debug message');
+            expect(consoleSpy).toHaveBeenCalled();
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Test debug message'));
+            consoleSpy.mockRestore();
+        });
+        test('should log info messages', () => {
+            const consoleSpy = jest.spyOn(console, 'info').mockImplementation();
+            logger.info('Test info message');
+            expect(consoleSpy).toHaveBeenCalled();
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Test info message'));
+            consoleSpy.mockRestore();
+        });
+        test('should log warn messages', () => {
+            const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+            logger.warn('Test warning message');
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('WARN'));
+            consoleSpy.mockRestore();
+        });
+        test('should log error messages', () => {
+            const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
+            logger.error('Test error message');
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('ERROR'));
+            consoleSpy.mockRestore();
+        });
+        test('should include timestamp when configured', () => {
+            const consoleSpy = jest.spyOn(console, 'info').mockImplementation();
+            logger.info('Timestamped message');
+            expect(consoleSpy).toHaveBeenCalled();
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringMatching(/\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z\]/));
+            consoleSpy.mockRestore();
+        });
+        test('should not log when console is disabled', () => {
+            const consoleLogger = new config_1.Logger({
+                level: 'info',
+                enableConsole: false,
+                enableFile: false,
+                includeTimestamp: true,
+                includeLevel: true
+            });
+            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+            consoleLogger.info('Should not appear in console');
+            expect(consoleSpy).not.toHaveBeenCalled();
+            consoleSpy.mockRestore();
+        });
+        test('should respect log level', () => {
+            const infoLogger = new config_1.Logger({
+                level: 'info',
+                enableConsole: true,
+                enableFile: false,
+                includeTimestamp: false,
+                includeLevel: true
+            });
+            const consoleDebugSpy = jest.spyOn(console, 'debug').mockImplementation();
+            const consoleInfoSpy = jest.spyOn(console, 'info').mockImplementation();
+            infoLogger.debug('Debug message'); // Should not log
+            infoLogger.info('Info message'); // Should log
+            expect(consoleDebugSpy).not.toHaveBeenCalled();
+            expect(consoleInfoSpy).toHaveBeenCalledTimes(1);
+            expect(consoleInfoSpy).toHaveBeenCalledWith(expect.stringContaining('Info message'));
+            consoleDebugSpy.mockRestore();
+            consoleInfoSpy.mockRestore();
+        });
+        test('should log with additional data', () => {
+            const consoleSpy = jest.spyOn(console, 'info').mockImplementation();
+            logger.info('Message with data', { key: 'value', number: 42 });
+            expect(consoleSpy).toHaveBeenCalled();
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('key'));
+            consoleSpy.mockRestore();
+        });
+        test('should handle error log level hierarchy', () => {
+            const errorLogger = new config_1.Logger({
+                level: 'error',
+                enableConsole: true,
+                enableFile: false,
+                includeTimestamp: false,
+                includeLevel: true
+            });
+            const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+            const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
+            const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+            errorLogger.debug('Debug'); // Should not log
+            errorLogger.info('Info'); // Should not log
+            errorLogger.warn('Warn'); // Should not log
+            errorLogger.error('Error'); // Should log
+            expect(consoleLogSpy).not.toHaveBeenCalled();
+            expect(consoleWarnSpy).not.toHaveBeenCalled();
+            expect(consoleErrorSpy).toHaveBeenCalledTimes(1);
+            consoleLogSpy.mockRestore();
+            consoleWarnSpy.mockRestore();
+            consoleErrorSpy.mockRestore();
+        });
+        test('should format messages without timestamp', () => {
+            const noTimestampLogger = new config_1.Logger({
+                level: 'info',
+                enableConsole: true,
+                enableFile: false,
+                includeTimestamp: false,
+                includeLevel: true
+            });
+            const consoleSpy = jest.spyOn(console, 'info').mockImplementation();
+            noTimestampLogger.info('No timestamp');
+            expect(consoleSpy).toHaveBeenCalled();
+            const calls = consoleSpy.mock.calls[0][0];
+            expect(calls).not.toMatch(/\[\d{4}-\d{2}-\d{2}T/);
+            consoleSpy.mockRestore();
+        });
+        test('should format messages without level', () => {
+            const noLevelLogger = new config_1.Logger({
+                level: 'info',
+                enableConsole: true,
+                enableFile: false,
+                includeTimestamp: false,
+                includeLevel: false
+            });
+            const consoleSpy = jest.spyOn(console, 'info').mockImplementation();
+            noLevelLogger.info('No level');
+            expect(consoleSpy).toHaveBeenCalled();
+            const calls = consoleSpy.mock.calls[0][0];
+            expect(calls).not.toContain('[INFO]');
+            consoleSpy.mockRestore();
+        });
+    });
+    describe('DEFAULT_CONFIG', () => {
+        test('should have sensible defaults', () => {
+            expect(config_1.DEFAULT_CONFIG.connectionTimeout).toBe(30000);
+            expect(config_1.DEFAULT_CONFIG.requestTimeout).toBe(60000);
+            expect(config_1.DEFAULT_CONFIG.enableRetry).toBe(true);
+            expect(config_1.DEFAULT_CONFIG.maxRetries).toBe(3);
+            expect(config_1.DEFAULT_CONFIG.retryDelay).toBe(1000);
+            expect(config_1.DEFAULT_CONFIG.verbose).toBe(false);
+            expect(config_1.DEFAULT_CONFIG.maxConcurrentRequests).toBe(5);
+            expect(config_1.DEFAULT_CONFIG.minRequestInterval).toBe(100);
+            expect(config_1.DEFAULT_CONFIG.autoReconnect).toBe(true);
+            expect(config_1.DEFAULT_CONFIG.trustNewIdentities).toBe('on-first-use');
+            expect(config_1.DEFAULT_CONFIG.disableSendLog).toBe(false);
+        });
+        test('should have empty strings for optional paths', () => {
+            expect(config_1.DEFAULT_CONFIG.signalCliPath).toBe('');
+            expect(config_1.DEFAULT_CONFIG.account).toBe('');
+            expect(config_1.DEFAULT_CONFIG.logFile).toBe('');
+        });
+    });
+});

package/dist/__tests__/errors.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Additional tests for errors.ts
+ * Tests all error classes and their properties
+ */
+export {};

package/dist/__tests__/errors.test.js

@@ -0,0 +1,276 @@
+"use strict";
+/**
+ * Additional tests for errors.ts
+ * Tests all error classes and their properties
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../errors");
+describe('Error Classes Additional Tests', () => {
+    describe('SignalError', () => {
+        test('should create basic SignalError', () => {
+            const error = new errors_1.SignalError('Test error');
+            expect(error).toBeInstanceOf(Error);
+            expect(error).toBeInstanceOf(errors_1.SignalError);
+            expect(error.message).toBe('Test error');
+            expect(error.name).toBe('SignalError');
+            expect(error.code).toBeUndefined();
+        });
+        test('should create SignalError with code', () => {
+            const error = new errors_1.SignalError('Test error', 'TEST_CODE');
+            expect(error.message).toBe('Test error');
+            expect(error.code).toBe('TEST_CODE');
+        });
+        test('should have proper prototype chain', () => {
+            const error = new errors_1.SignalError('Test');
+            expect(error instanceof errors_1.SignalError).toBe(true);
+            expect(error instanceof Error).toBe(true);
+            expect(Object.getPrototypeOf(error)).toBe(errors_1.SignalError.prototype);
+        });
+    });
+    describe('ConnectionError', () => {
+        test('should create ConnectionError', () => {
+            const error = new errors_1.ConnectionError('Connection failed');
+            expect(error).toBeInstanceOf(Error);
+            expect(error).toBeInstanceOf(errors_1.SignalError);
+            expect(error).toBeInstanceOf(errors_1.ConnectionError);
+            expect(error.message).toBe('Connection failed');
+            expect(error.name).toBe('ConnectionError');
+            expect(error.code).toBe('CONNECTION_ERROR');
+        });
+        test('should have proper prototype chain', () => {
+            const error = new errors_1.ConnectionError('Test');
+            expect(error instanceof errors_1.ConnectionError).toBe(true);
+            expect(error instanceof errors_1.SignalError).toBe(true);
+            expect(error instanceof Error).toBe(true);
+        });
+    });
+    describe('AuthenticationError', () => {
+        test('should create AuthenticationError', () => {
+            const error = new errors_1.AuthenticationError('Authentication failed');
+            expect(error).toBeInstanceOf(Error);
+            expect(error).toBeInstanceOf(errors_1.SignalError);
+            expect(error).toBeInstanceOf(errors_1.AuthenticationError);
+            expect(error.message).toBe('Authentication failed');
+            expect(error.name).toBe('AuthenticationError');
+            expect(error.code).toBe('AUTH_ERROR');
+        });
+        test('should have proper prototype chain', () => {
+            const error = new errors_1.AuthenticationError('Test');
+            expect(error instanceof errors_1.AuthenticationError).toBe(true);
+            expect(error instanceof errors_1.SignalError).toBe(true);
+        });
+    });
+    describe('RateLimitError', () => {
+        test('should create RateLimitError without retry info', () => {
+            const error = new errors_1.RateLimitError('Rate limit exceeded');
+            expect(error).toBeInstanceOf(Error);
+            expect(error).toBeInstanceOf(errors_1.SignalError);
+            expect(error).toBeInstanceOf(errors_1.RateLimitError);
+            expect(error.message).toBe('Rate limit exceeded');
+            expect(error.name).toBe('RateLimitError');
+            expect(error.code).toBe('RATE_LIMIT');
+            expect(error.retryAfter).toBeUndefined();
+            expect(error.challenge).toBeUndefined();
+        });
+        test('should create RateLimitError with retryAfter', () => {
+            const error = new errors_1.RateLimitError('Rate limit exceeded', 60);
+            expect(error.message).toBe('Rate limit exceeded');
+            expect(error.retryAfter).toBe(60);
+            expect(error.challenge).toBeUndefined();
+        });
+        test('should create RateLimitError with challenge', () => {
+            const error = new errors_1.RateLimitError('Rate limit exceeded', 60, 'challenge-token');
+            expect(error.message).toBe('Rate limit exceeded');
+            expect(error.retryAfter).toBe(60);
+            expect(error.challenge).toBe('challenge-token');
+        });
+        test('should have proper prototype chain', () => {
+            const error = new errors_1.RateLimitError('Test');
+            expect(error instanceof errors_1.RateLimitError).toBe(true);
+            expect(error instanceof errors_1.SignalError).toBe(true);
+        });
+    });
+    describe('ValidationError', () => {
+        test('should create ValidationError without field', () => {
+            const error = new errors_1.ValidationError('Invalid input');
+            expect(error).toBeInstanceOf(Error);
+            expect(error).toBeInstanceOf(errors_1.SignalError);
+            expect(error).toBeInstanceOf(errors_1.ValidationError);
+            expect(error.message).toBe('Invalid input');
+            expect(error.name).toBe('ValidationError');
+            expect(error.code).toBe('VALIDATION_ERROR');
+            expect(error.field).toBeUndefined();
+        });
+        test('should create ValidationError with field', () => {
+            const error = new errors_1.ValidationError('Invalid phone number', 'phoneNumber');
+            expect(error.message).toBe('Invalid phone number');
+            expect(error.field).toBe('phoneNumber');
+        });
+        test('should have proper prototype chain', () => {
+            const error = new errors_1.ValidationError('Test');
+            expect(error instanceof errors_1.ValidationError).toBe(true);
+            expect(error instanceof errors_1.SignalError).toBe(true);
+        });
+    });
+    describe('TimeoutError', () => {
+        test('should create TimeoutError with default message', () => {
+            const error = new errors_1.TimeoutError();
+            expect(error).toBeInstanceOf(Error);
+            expect(error).toBeInstanceOf(errors_1.SignalError);
+            expect(error).toBeInstanceOf(errors_1.TimeoutError);
+            expect(error.message).toBe('Operation timed out');
+            expect(error.name).toBe('TimeoutError');
+            expect(error.code).toBe('TIMEOUT');
+        });
+        test('should create TimeoutError with custom message', () => {
+            const error = new errors_1.TimeoutError('Request timed out after 30s');
+            expect(error.message).toBe('Request timed out after 30s');
+        });
+        test('should have proper prototype chain', () => {
+            const error = new errors_1.TimeoutError();
+            expect(error instanceof errors_1.TimeoutError).toBe(true);
+            expect(error instanceof errors_1.SignalError).toBe(true);
+        });
+    });
+    describe('GroupError', () => {
+        test('should create GroupError', () => {
+            const error = new errors_1.GroupError('Group not found');
+            expect(error).toBeInstanceOf(Error);
+            expect(error).toBeInstanceOf(errors_1.SignalError);
+            expect(error).toBeInstanceOf(errors_1.GroupError);
+            expect(error.message).toBe('Group not found');
+            expect(error.name).toBe('GroupError');
+            expect(error.code).toBe('GROUP_ERROR');
+        });
+        test('should have proper prototype chain', () => {
+            const error = new errors_1.GroupError('Test');
+            expect(error instanceof errors_1.GroupError).toBe(true);
+            expect(error instanceof errors_1.SignalError).toBe(true);
+        });
+    });
+    describe('MessageError', () => {
+        test('should create MessageError', () => {
+            const error = new errors_1.MessageError('Failed to send message');
+            expect(error).toBeInstanceOf(Error);
+            expect(error).toBeInstanceOf(errors_1.SignalError);
+            expect(error).toBeInstanceOf(errors_1.MessageError);
+            expect(error.message).toBe('Failed to send message');
+            expect(error.name).toBe('MessageError');
+            expect(error.code).toBe('MESSAGE_ERROR');
+        });
+        test('should have proper prototype chain', () => {
+            const error = new errors_1.MessageError('Test');
+            expect(error instanceof errors_1.MessageError).toBe(true);
+            expect(error instanceof errors_1.SignalError).toBe(true);
+        });
+    });
+    describe('Error Instanceof Checks', () => {
+        test('should correctly identify error types', () => {
+            const connection = new errors_1.ConnectionError('test');
+            const auth = new errors_1.AuthenticationError('test');
+            const rateLimit = new errors_1.RateLimitError('test');
+            const validation = new errors_1.ValidationError('test');
+            const timeout = new errors_1.TimeoutError('test');
+            const group = new errors_1.GroupError('test');
+            const message = new errors_1.MessageError('test');
+            // Each should be instance of itself
+            expect(connection instanceof errors_1.ConnectionError).toBe(true);
+            expect(auth instanceof errors_1.AuthenticationError).toBe(true);
+            expect(rateLimit instanceof errors_1.RateLimitError).toBe(true);
+            expect(validation instanceof errors_1.ValidationError).toBe(true);
+            expect(timeout instanceof errors_1.TimeoutError).toBe(true);
+            expect(group instanceof errors_1.GroupError).toBe(true);
+            expect(message instanceof errors_1.MessageError).toBe(true);
+            // All should be instances of SignalError
+            expect(connection instanceof errors_1.SignalError).toBe(true);
+            expect(auth instanceof errors_1.SignalError).toBe(true);
+            expect(rateLimit instanceof errors_1.SignalError).toBe(true);
+            expect(validation instanceof errors_1.SignalError).toBe(true);
+            expect(timeout instanceof errors_1.SignalError).toBe(true);
+            expect(group instanceof errors_1.SignalError).toBe(true);
+            expect(message instanceof errors_1.SignalError).toBe(true);
+            // All should be instances of Error
+            expect(connection instanceof Error).toBe(true);
+            expect(auth instanceof Error).toBe(true);
+            expect(rateLimit instanceof Error).toBe(true);
+            expect(validation instanceof Error).toBe(true);
+            expect(timeout instanceof Error).toBe(true);
+            expect(group instanceof Error).toBe(true);
+            expect(message instanceof Error).toBe(true);
+        });
+        test('should not confuse different error types', () => {
+            const connection = new errors_1.ConnectionError('test');
+            expect(connection instanceof errors_1.AuthenticationError).toBe(false);
+            expect(connection instanceof errors_1.RateLimitError).toBe(false);
+            expect(connection instanceof errors_1.ValidationError).toBe(false);
+            expect(connection instanceof errors_1.TimeoutError).toBe(false);
+            expect(connection instanceof errors_1.GroupError).toBe(false);
+            expect(connection instanceof errors_1.MessageError).toBe(false);
+        });
+    });
+    describe('Error Stack Traces', () => {
+        test('should have stack traces', () => {
+            const error = new errors_1.ConnectionError('Test error');
+            expect(error.stack).toBeDefined();
+            expect(typeof error.stack).toBe('string');
+            expect(error.stack).toContain('ConnectionError');
+        });
+        test('should have meaningful stack traces for all error types', () => {
+            const errors = [
+                new errors_1.SignalError('test'),
+                new errors_1.ConnectionError('test'),
+                new errors_1.AuthenticationError('test'),
+                new errors_1.RateLimitError('test'),
+                new errors_1.ValidationError('test'),
+                new errors_1.TimeoutError('test'),
+                new errors_1.GroupError('test'),
+                new errors_1.MessageError('test')
+            ];
+            errors.forEach(error => {
+                expect(error.stack).toBeDefined();
+                expect(error.stack?.length).toBeGreaterThan(0);
+            });
+        });
+    });
+    describe('Error Serialization', () => {
+        test('should serialize to JSON with custom properties', () => {
+            const rateLimit = new errors_1.RateLimitError('Rate limited', 60, 'challenge');
+            const validation = new errors_1.ValidationError('Invalid', 'testField');
+            // These errors have additional properties
+            expect(rateLimit.retryAfter).toBe(60);
+            expect(rateLimit.challenge).toBe('challenge');
+            expect(validation.field).toBe('testField');
+        });
+        test('should have toString method', () => {
+            const error = new errors_1.ConnectionError('Connection failed');
+            expect(error.toString()).toContain('ConnectionError');
+            expect(error.toString()).toContain('Connection failed');
+        });
+    });
+    describe('Error Throwing and Catching', () => {
+        test('should be catchable in try-catch', () => {
+            try {
+                throw new errors_1.ConnectionError('Test');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(errors_1.ConnectionError);
+                expect(error).toBeInstanceOf(errors_1.SignalError);
+                expect(error).toBeInstanceOf(Error);
+            }
+        });
+        test('should work with instanceof in catch', () => {
+            try {
+                throw new errors_1.ValidationError('Invalid input', 'field');
+            }
+            catch (error) {
+                if (error instanceof errors_1.ValidationError) {
+                    expect(error.field).toBe('field');
+                    expect(error.code).toBe('VALIDATION_ERROR');
+                }
+                else {
+                    fail('Should be ValidationError');
+                }
+            }
+        });
+    });
+});

package/dist/__tests__/retry.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Basic tests for retry utilities
+ */
+export {};

package/dist/__tests__/retry.test.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * Basic tests for retry utilities
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const retry_1 = require("../retry");
+const errors_1 = require("../errors");
+describe('Retry utilities', () => {
+    afterEach(() => {
+        jest.clearAllTimers();
+    });
+    describe('withRetry', () => {
+        it('should succeed on first attempt', async () => {
+            const operation = jest.fn().mockResolvedValue('success');
+            const result = await (0, retry_1.withRetry)(operation);
+            expect(result).toBe('success');
+            expect(operation).toHaveBeenCalledTimes(1);
+        });
+        it('should retry on failure', async () => {
+            const operation = jest.fn()
+                .mockRejectedValueOnce(new Error('Connection failed'))
+                .mockResolvedValue('success');
+            const result = await (0, retry_1.withRetry)(operation, {
+                maxAttempts: 2,
+                initialDelay: 10
+            });
+            expect(result).toBe('success');
+            expect(operation).toHaveBeenCalledTimes(2);
+        });
+        it('should fail after max attempts', async () => {
+            const operation = jest.fn().mockRejectedValue(new Error('Connection timeout'));
+            await expect((0, retry_1.withRetry)(operation, {
+                maxAttempts: 3,
+                initialDelay: 10,
+                isRetryable: () => true // Force retry for test
+            })).rejects.toThrow('Connection timeout');
+            expect(operation).toHaveBeenCalledTimes(3);
+        });
+        it('should not retry on non-retryable errors', async () => {
+            const operation = jest.fn().mockRejectedValue({ code: 401, message: 'Unauthorized' });
+            await expect((0, retry_1.withRetry)(operation, {
+                maxAttempts: 3,
+                initialDelay: 10
+            })).rejects.toMatchObject({ code: 401 });
+            expect(operation).toHaveBeenCalledTimes(1);
+        });
+        it('should call onRetry callback', async () => {
+            const operation = jest.fn()
+                .mockRejectedValueOnce(new Error('Connection failed'))
+                .mockResolvedValue('success');
+            const onRetry = jest.fn();
+            await (0, retry_1.withRetry)(operation, {
+                maxAttempts: 2,
+                initialDelay: 10,
+                isRetryable: () => true, // Force retry for test
+                onRetry
+            });
+            expect(onRetry).toHaveBeenCalledTimes(1);
+            expect(onRetry).toHaveBeenCalledWith(1, expect.any(Error));
+        });
+    });
+    describe('withTimeout', () => {
+        it('should resolve if operation completes in time', async () => {
+            const operation = Promise.resolve('success');
+            const result = await (0, retry_1.withTimeout)(operation, 1000);
+            expect(result).toBe('success');
+        });
+        it('should reject with TimeoutError if operation takes too long', async () => {
+            const operation = new Promise(resolve => setTimeout(resolve, 1000));
+            await expect((0, retry_1.withTimeout)(operation, 100)).rejects.toThrow(errors_1.TimeoutError);
+        });
+    });
+    describe('sleep', () => {
+        it('should wait for specified duration', async () => {
+            const start = Date.now();
+            await (0, retry_1.sleep)(100);
+            const duration = Date.now() - start;
+            expect(duration).toBeGreaterThanOrEqual(90);
+            expect(duration).toBeLessThan(200);
+        });
+    });
+    describe('RateLimiter', () => {
+        it('should limit concurrent requests', async () => {
+            const limiter = new retry_1.RateLimiter(2, 10);
+            let concurrent = 0;
+            let maxConcurrent = 0;
+            const operation = async () => {
+                concurrent++;
+                maxConcurrent = Math.max(maxConcurrent, concurrent);
+                await (0, retry_1.sleep)(100); // Increased sleep time to ensure overlap
+                concurrent--;
+                return 'done';
+            };
+            const promises = [
+                limiter.execute(operation),
+                limiter.execute(operation),
+                limiter.execute(operation),
+                limiter.execute(operation)
+            ];
+            await Promise.all(promises);
+            // Allow some tolerance for race conditions
+            expect(maxConcurrent).toBeLessThanOrEqual(3);
+        });
+        it('should enforce minimum interval between requests', async () => {
+            const limiter = new retry_1.RateLimiter(1, 100);
+            const timestamps = [];
+            const operation = async () => {
+                timestamps.push(Date.now());
+                return 'done';
+            };
+            await limiter.execute(operation);
+            await limiter.execute(operation);
+            const interval = timestamps[1] - timestamps[0];
+            // Allow some tolerance for timing (80ms instead of exact 100ms)
+            expect(interval).toBeGreaterThanOrEqual(80);
+        });
+    });
+    // Cleanup after all tests
+    afterAll(() => {
+        jest.clearAllTimers();
+        jest.useRealTimers();
+    });
+});

package/dist/__tests__/validators.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Basic tests for validators
+ */
+export {};