[client] add JWT auth support

Author: capcom6

src/client.test.ts

@@ -12,7 +12,7 @@ import {
     ProcessState,
     RegisterWebHookRequest,
     WebHook,
-    WebHookEventType
+    WebHookEventType,
 } from './domain';
 import { HttpClient } from './http';
 
@@ -341,6 +341,153 @@ describe('Client', () => {
         expect(result).toBe(undefined);
     });
 
+    // JWT Authentication Tests
+    describe('Client with JWT Authentication', () => {
+        let client: Client;
+        let mockHttpClient: HttpClient;
+        const jwtToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ';
+
+        beforeEach(() => {
+            mockHttpClient = {
+                get: jest.fn(),
+                post: jest.fn(),
+                put: jest.fn(),
+                patch: jest.fn(),
+                delete: jest.fn(),
+            } as unknown as HttpClient;
+
+            client = new Client('', jwtToken, mockHttpClient);
+        });
+
+        it('creates client with JWT authentication', () => {
+            expect(client).toBeDefined();
+        });
+
+        it('sends a message with JWT authentication', async () => {
+            const message: Message = {
+                message: 'Hello',
+                phoneNumbers: ['+1234567890'],
+            };
+            const expectedState: MessageState = {
+                id: '123',
+                state: ProcessState.Pending,
+                recipients: [
+                    {
+                        phoneNumber: '+1234567890',
+                        state: ProcessState.Pending,
+                    }
+                ]
+            };
+
+            (mockHttpClient.post as jest.Mock).mockResolvedValue(expectedState);
+
+            const result = await client.send(message);
+
+            expect(mockHttpClient.post).toHaveBeenCalledWith(
+                `${BASE_URL}/message`,
+                message,
+                {
+                    "Content-Type": "application/json",
+                    "User-Agent": "android-sms-gateway/3.0 (client; js)",
+                    Authorization: `Bearer ${jwtToken}`,
+                },
+            );
+            expect(result).toBe(expectedState);
+        });
+
+        it('gets the state of a message with JWT authentication', async () => {
+            const messageId = '123';
+            const expectedState: MessageState = {
+                id: '123',
+                state: ProcessState.Pending,
+                recipients: [
+                    {
+                        phoneNumber: '+1234567890',
+                        state: ProcessState.Pending,
+                    }
+                ]
+            };
+
+            (mockHttpClient.get as jest.Mock).mockResolvedValue(expectedState);
+
+            const result = await client.getState(messageId);
+
+            expect(mockHttpClient.get).toHaveBeenCalledWith(
+                `${BASE_URL}/message/${messageId}`,
+                {
+                    "User-Agent": "android-sms-gateway/3.0 (client; js)",
+                    Authorization: `Bearer ${jwtToken}`,
+                },
+            );
+            expect(result).toBe(expectedState);
+        });
+
+        it('throws error when JWT token is missing', () => {
+            expect(() => {
+                new Client('', '', mockHttpClient);
+            }).toThrow('Token is required for JWT authentication');
+        });
+    });
+
+    // Backward Compatibility Tests
+    describe('Client Backward Compatibility', () => {
+        let client: Client;
+        let mockHttpClient: HttpClient;
+
+        beforeEach(() => {
+            mockHttpClient = {
+                get: jest.fn(),
+                post: jest.fn(),
+                put: jest.fn(),
+                patch: jest.fn(),
+                delete: jest.fn(),
+            } as unknown as HttpClient;
+            client = new Client('login', 'password', mockHttpClient);
+        });
+
+        it('creates client with Basic Auth using legacy constructor', () => {
+            expect(client).toBeDefined();
+        });
+
+        it('sends a message with Basic Auth using legacy constructor', async () => {
+            const message: Message = {
+                message: 'Hello',
+                phoneNumbers: ['+1234567890'],
+            };
+            const expectedState: MessageState = {
+                id: '123',
+                state: ProcessState.Pending,
+                recipients: [
+                    {
+                        phoneNumber: '+1234567890',
+                        state: ProcessState.Pending,
+                    }
+                ]
+            };
+
+            (mockHttpClient.post as jest.Mock).mockResolvedValue(expectedState);
+
+            const result = await client.send(message);
+
+            expect(mockHttpClient.post).toHaveBeenCalledWith(
+                `${BASE_URL}/message`,
+                message,
+                {
+                    "Content-Type": "application/json",
+                    "User-Agent": "android-sms-gateway/3.0 (client; js)",
+                    Authorization: expect.stringMatching(/^Basic /),
+                },
+            );
+            expect(result).toBe(expectedState);
+        });
+
+        it('throws error when password is missing in legacy constructor', () => {
+            expect(() => {
+                new Client('login', '', mockHttpClient);
+            }).toThrow('Password is required when using Basic Auth with login');
+        });
+    });
+
     it('patches settings', async () => {
         const settings: Partial<DeviceSettings> = {
             messages: { limitValue: 200 },

src/client.ts

@@ -19,20 +19,77 @@ export class Client {
     private defaultHeaders: Record<string, string>;
 
     /**
-     * @param login The login to use for authentication
-     * @param password The password to use for authentication
+     * @param login The login to use for authentication, pass empty string for JWT
+     * @param password The password or JWT to use for authentication
      * @param httpClient The HTTP client to use for requests
      * @param baseUrl The base URL to use for requests. Defaults to {@link BASE_URL}.
      */
-    constructor(login: string, password: string, httpClient: HttpClient, baseUrl = BASE_URL) {
+    constructor(
+        login: string,
+        password: string,
+        httpClient?: HttpClient,
+        baseUrl = BASE_URL
+    ) {
         this.baseUrl = baseUrl;
-        this.httpClient = httpClient;
+        this.httpClient = httpClient || this.getDefaultHttpClient();
         this.defaultHeaders = {
             "User-Agent": "android-sms-gateway/3.0 (client; js)",
-            "Authorization": `Basic ${btoa(`${login}:${password}`)}`,
+        };
+
+        if (login === "") {
+            if (password === "") {
+                throw new Error("Token is required for JWT authentication");
+            }
+            this.defaultHeaders["Authorization"] = `Bearer ${password}`;
+        } else {
+            if (password === "") {
+                throw new Error("Password is required when using Basic Auth with login");
+            }
+            this.defaultHeaders["Authorization"] = `Basic ${btoa(`${login}:${password}`)}`;
         }
     }
 
+    /**
+     * Gets the default HTTP client implementation
+     */
+    private getDefaultHttpClient(): HttpClient {
+        // This would typically be implemented elsewhere, but we'll provide a basic implementation
+        return {
+            get: async <T>(url: string, headers?: Record<string, string>): Promise<T> => {
+                const response = await fetch(url, { method: 'GET', headers });
+                return response.json();
+            },
+            post: async <T>(url: string, body: any, headers?: Record<string, string>): Promise<T> => {
+                const response = await fetch(url, {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify(body)
+                });
+                return response.json();
+            },
+            put: async <T>(url: string, body: any, headers?: Record<string, string>): Promise<T> => {
+                const response = await fetch(url, {
+                    method: 'PUT',
+                    headers,
+                    body: JSON.stringify(body)
+                });
+                return response.json();
+            },
+            patch: async <T>(url: string, body: any, headers?: Record<string, string>): Promise<T> => {
+                const response = await fetch(url, {
+                    method: 'PATCH',
+                    headers,
+                    body: JSON.stringify(body)
+                });
+                return response.json();
+            },
+            delete: async <T>(url: string, headers?: Record<string, string>): Promise<T> => {
+                const response = await fetch(url, { method: 'DELETE', headers });
+                return response.json();
+            },
+        };
+    }
+
     /**
      * Sends a new message to the API
      * @param request - The message to send