signal-sdk 0.0.9 → 0.1.0

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 {};

package/dist/__tests__/validators.test.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * Basic tests for validators
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const validators_1 = require("../validators");
+const errors_1 = require("../errors");
+describe('Validators', () => {
+    describe('validatePhoneNumber', () => {
+        it('should accept valid E.164 phone numbers', () => {
+            expect(() => (0, validators_1.validatePhoneNumber)('+33123456789')).not.toThrow();
+            expect(() => (0, validators_1.validatePhoneNumber)('+1234567890')).not.toThrow();
+            expect(() => (0, validators_1.validatePhoneNumber)('+49123456789012')).not.toThrow();
+        });
+        it('should reject invalid phone numbers', () => {
+            expect(() => (0, validators_1.validatePhoneNumber)('123456789')).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validatePhoneNumber)('+0123456789')).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validatePhoneNumber)('invalid')).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validatePhoneNumber)('')).toThrow(errors_1.ValidationError);
+        });
+        it('should reject non-string inputs', () => {
+            expect(() => (0, validators_1.validatePhoneNumber)(null)).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validatePhoneNumber)(undefined)).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validatePhoneNumber)(123)).toThrow(errors_1.ValidationError);
+        });
+    });
+    describe('validateGroupId', () => {
+        it('should accept non-empty strings', () => {
+            expect(() => (0, validators_1.validateGroupId)('abc123==')).not.toThrow();
+            expect(() => (0, validators_1.validateGroupId)('groupId')).not.toThrow();
+        });
+        it('should reject empty or invalid group IDs', () => {
+            expect(() => (0, validators_1.validateGroupId)('')).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateGroupId)(null)).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateGroupId)(undefined)).toThrow(errors_1.ValidationError);
+        });
+        it('should reject non-string group IDs', () => {
+            expect(() => (0, validators_1.validateGroupId)(123)).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateGroupId)({})).toThrow(errors_1.ValidationError);
+        });
+    });
+    describe('validateRecipient', () => {
+        it('should accept valid phone numbers', () => {
+            expect(() => (0, validators_1.validateRecipient)('+33123456789')).not.toThrow();
+        });
+        it('should accept usernames', () => {
+            expect(() => (0, validators_1.validateRecipient)('u:username.001')).not.toThrow();
+        });
+        it('should accept UUIDs', () => {
+            expect(() => (0, validators_1.validateRecipient)('12345678-1234-1234-1234-123456789012')).not.toThrow();
+            expect(() => (0, validators_1.validateRecipient)('PNI:12345678-1234-1234-1234-123456789012')).not.toThrow();
+        });
+        it('should reject invalid recipients', () => {
+            expect(() => (0, validators_1.validateRecipient)('')).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateRecipient)('u:')).toThrow(errors_1.ValidationError);
+        });
+        it('should reject non-string recipients', () => {
+            expect(() => (0, validators_1.validateRecipient)(null)).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateRecipient)(123)).toThrow(errors_1.ValidationError);
+        });
+    });
+    describe('validateMessage', () => {
+        it('should accept valid messages', () => {
+            expect(() => (0, validators_1.validateMessage)('Hello')).not.toThrow();
+            expect(() => (0, validators_1.validateMessage)('', 10)).not.toThrow();
+        });
+        it('should reject messages exceeding max length', () => {
+            expect(() => (0, validators_1.validateMessage)('Hello World', 5)).toThrow(errors_1.ValidationError);
+        });
+        it('should reject non-string messages', () => {
+            expect(() => (0, validators_1.validateMessage)(null)).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateMessage)(undefined)).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateMessage)(123)).toThrow(errors_1.ValidationError);
+        });
+    });
+    describe('validateAttachments', () => {
+        it('should accept valid attachment arrays', () => {
+            expect(() => (0, validators_1.validateAttachments)(['file1.txt', 'file2.jpg'])).not.toThrow();
+            expect(() => (0, validators_1.validateAttachments)([])).not.toThrow();
+        });
+        it('should reject non-array inputs', () => {
+            expect(() => (0, validators_1.validateAttachments)('not-an-array')).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateAttachments)(null)).toThrow(errors_1.ValidationError);
+        });
+        it('should reject non-string attachment paths', () => {
+            expect(() => (0, validators_1.validateAttachments)([123])).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateAttachments)([null])).toThrow(errors_1.ValidationError);
+        });
+        it('should reject empty attachment paths', () => {
+            expect(() => (0, validators_1.validateAttachments)([''])).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateAttachments)(['file1.txt', ''])).toThrow(errors_1.ValidationError);
+        });
+    });
+    describe('validateTimestamp', () => {
+        it('should accept valid timestamps', () => {
+            expect(() => (0, validators_1.validateTimestamp)(Date.now())).not.toThrow();
+            expect(() => (0, validators_1.validateTimestamp)(1234567890)).not.toThrow();
+        });
+        it('should reject invalid timestamps', () => {
+            expect(() => (0, validators_1.validateTimestamp)(0)).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateTimestamp)(-1)).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateTimestamp)(Infinity)).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateTimestamp)('123')).toThrow(errors_1.ValidationError);
+        });
+    });
+    describe('validateEmoji', () => {
+        it('should accept valid emojis', () => {
+            expect(() => (0, validators_1.validateEmoji)('👍')).not.toThrow();
+            expect(() => (0, validators_1.validateEmoji)('❤️')).not.toThrow();
+            expect(() => (0, validators_1.validateEmoji)('😀')).not.toThrow();
+        });
+        it('should reject invalid emojis', () => {
+            expect(() => (0, validators_1.validateEmoji)('')).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateEmoji)('this is too long')).toThrow(errors_1.ValidationError);
+        });
+        it('should reject non-string emojis', () => {
+            expect(() => (0, validators_1.validateEmoji)(null)).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateEmoji)(123)).toThrow(errors_1.ValidationError);
+        });
+    });
+    describe('validateDeviceId', () => {
+        it('should accept valid device IDs', () => {
+            expect(() => (0, validators_1.validateDeviceId)(1)).not.toThrow();
+            expect(() => (0, validators_1.validateDeviceId)(123)).not.toThrow();
+        });
+        it('should reject invalid device IDs', () => {
+            expect(() => (0, validators_1.validateDeviceId)(0)).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateDeviceId)(-1)).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateDeviceId)(1.5)).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateDeviceId)('1')).toThrow(errors_1.ValidationError);
+        });
+    });
+    describe('sanitizeInput', () => {
+        it('should remove null bytes', () => {
+            expect((0, validators_1.sanitizeInput)('hello\0world')).toBe('helloworld');
+            expect((0, validators_1.sanitizeInput)('test\0\0test')).toBe('testtest');
+        });
+        it('should handle non-string inputs', () => {
+            expect((0, validators_1.sanitizeInput)(null)).toBe('');
+            expect((0, validators_1.sanitizeInput)(undefined)).toBe('');
+            expect((0, validators_1.sanitizeInput)(123)).toBe('');
+        });
+        it('should preserve normal strings', () => {
+            expect((0, validators_1.sanitizeInput)('hello world')).toBe('hello world');
+        });
+    });
+});

package/dist/config.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Configuration management for Signal SDK
+ * Provides centralized configuration with validation
+ */
+export interface SignalCliConfig {
+    /** Path to signal-cli binary */
+    signalCliPath?: string;
+    /** Signal account phone number */
+    account?: string;
+    /** Connection timeout in milliseconds */
+    connectionTimeout?: number;
+    /** Request timeout in milliseconds */
+    requestTimeout?: number;
+    /** Enable retry on failures */
+    enableRetry?: boolean;
+    /** Maximum retry attempts */
+    maxRetries?: number;
+    /** Initial retry delay in milliseconds */
+    retryDelay?: number;
+    /** Enable detailed logging */
+    verbose?: boolean;
+    /** Log file path */
+    logFile?: string;
+    /** Rate limit: max concurrent requests */
+    maxConcurrentRequests?: number;
+    /** Rate limit: minimum interval between requests (ms) */
+    minRequestInterval?: number;
+    /** Auto-reconnect on connection loss */
+    autoReconnect?: boolean;
+    /** Trust new identities mode */
+    trustNewIdentities?: 'on-first-use' | 'always' | 'never';
+    /** Disable send log (for message resending) */
+    disableSendLog?: boolean;
+}
+export declare const DEFAULT_CONFIG: Required<SignalCliConfig>;
+/**
+ * Validates and merges configuration with defaults
+ * @param userConfig User-provided configuration
+ * @returns Validated configuration
+ */
+export declare function validateConfig(userConfig?: SignalCliConfig): Required<SignalCliConfig>;
+/**
+ * Logger configuration and utilities
+ */
+export interface LoggerConfig {
+    level: 'debug' | 'info' | 'warn' | 'error';
+    enableConsole: boolean;
+    enableFile: boolean;
+    filePath?: string;
+    includeTimestamp: boolean;
+    includeLevel: boolean;
+}
+export declare const DEFAULT_LOGGER_CONFIG: LoggerConfig;
+/**
+ * Simple logger implementation
+ */
+export declare class Logger {
+    private config;
+    private levels;
+    constructor(config?: Partial<LoggerConfig>);
+    private shouldLog;
+    private format;
+    debug(message: string, data?: any): void;
+    info(message: string, data?: any): void;
+    warn(message: string, data?: any): void;
+    error(message: string, data?: any): void;
+}