[client] add JWT management methods

Author: capcom6

src/client.test.ts

@@ -11,6 +11,8 @@ import {
     MessageState,
     ProcessState,
     RegisterWebHookRequest,
+    TokenRequest,
+    TokenResponse,
     WebHook,
     WebHookEventType,
 } from './domain';
@@ -345,7 +347,7 @@ describe('Client', () => {
     describe('Client with JWT Authentication', () => {
         let client: Client;
         let mockHttpClient: HttpClient;
-        const jwtToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ';
+        const jwtToken = 'fake-token-123';
 
         beforeEach(() => {
             mockHttpClient = {
@@ -389,7 +391,7 @@ describe('Client', () => {
                 {
                     "Content-Type": "application/json",
                     "User-Agent": "android-sms-gateway/3.0 (client; js)",
-                    Authorization: `Bearer ${jwtToken}`,
+                    Authorization: `Bearer fake-token-123`,
                 },
             );
             expect(result).toBe(expectedState);
@@ -416,7 +418,7 @@ describe('Client', () => {
                 `${BASE_URL}/message/${messageId}`,
                 {
                     "User-Agent": "android-sms-gateway/3.0 (client; js)",
-                    Authorization: `Bearer ${jwtToken}`,
+                    Authorization: `Bearer fake-token-123`,
                 },
             );
             expect(result).toBe(expectedState);
@@ -508,4 +510,93 @@ describe('Client', () => {
         );
         expect(result).toBe(undefined);
     });
+
+    // JWT Token Management Tests
+    describe('JWT Token Management', () => {
+        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('generates a new token', async () => {
+            const tokenRequest: TokenRequest = {
+                scopes: ['read', 'write'],
+                ttl: 3600,
+            };
+            const expectedResponse: TokenResponse = {
+                access_token: 'fake-token-123',
+                token_type: 'Bearer',
+                id: 'token-id-123',
+                expires_at: '2024-12-31T23:59:59Z',
+            };
+
+            (mockHttpClient.post as jest.Mock).mockResolvedValue(expectedResponse);
+
+            const result = await client.generateToken(tokenRequest);
+
+            expect(mockHttpClient.post).toHaveBeenCalledWith(
+                `${BASE_URL}/auth/token`,
+                tokenRequest,
+                {
+                    "Content-Type": "application/json",
+                    "User-Agent": "android-sms-gateway/3.0 (client; js)",
+                    Authorization: expect.any(String),
+                },
+            );
+            expect(result).toBe(expectedResponse);
+        });
+
+        it('generates a new token without TTL', async () => {
+            const tokenRequest: TokenRequest = {
+                scopes: ['read'],
+            };
+            const expectedResponse: TokenResponse = {
+                access_token: 'fake-token-123',
+                token_type: 'Bearer',
+                id: 'token-id-456',
+                expires_at: '2024-12-31T23:59:59Z',
+            };
+
+            (mockHttpClient.post as jest.Mock).mockResolvedValue(expectedResponse);
+
+            const result = await client.generateToken(tokenRequest);
+
+            expect(mockHttpClient.post).toHaveBeenCalledWith(
+                `${BASE_URL}/auth/token`,
+                tokenRequest,
+                {
+                    "Content-Type": "application/json",
+                    "User-Agent": "android-sms-gateway/3.0 (client; js)",
+                    Authorization: expect.any(String),
+                },
+            );
+            expect(result).toBe(expectedResponse);
+        });
+
+        it('revokes a token', async () => {
+            const jti = 'token-id-123';
+
+            (mockHttpClient.delete as jest.Mock).mockResolvedValue(undefined);
+
+            const result = await client.revokeToken(jti);
+
+            expect(mockHttpClient.delete).toHaveBeenCalledWith(
+                `${BASE_URL}/auth/token/${jti}`,
+                {
+                    "User-Agent": "android-sms-gateway/3.0 (client; js)",
+                    Authorization: expect.any(String),
+                },
+            );
+            expect(result).toBe(undefined);
+        });
+    });
 });

src/client.ts

@@ -7,7 +7,9 @@ import {
     DeviceSettings,
     HealthResponse,
     LogEntry,
-    MessagesExportRequest
+    MessagesExportRequest,
+    TokenRequest,
+    TokenResponse
 } from "./domain";
 import { HttpClient } from "./http";
 
@@ -53,39 +55,56 @@ export class Client {
      * Gets the default HTTP client implementation
      */
     private getDefaultHttpClient(): HttpClient {
-        // This would typically be implemented elsewhere, but we'll provide a basic implementation
+        const handleResponse = async (response: Response): Promise<any> => {
+            if (response.status === 204) {
+                return null;
+            }
+
+            if (!response.ok) {
+                const text = await response.text();
+                throw new Error(`HTTP error ${response.status}: ${text}`);
+            }
+
+            const contentType = response.headers.get("Content-Type");
+            if (contentType && contentType.includes("application/json")) {
+                return await response.json();
+            } else {
+                return await response.text();
+            }
+        };
+
         return {
             get: async <T>(url: string, headers?: Record<string, string>): Promise<T> => {
                 const response = await fetch(url, { method: 'GET', headers });
-                return response.json();
+                return handleResponse(response);
             },
             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();
+                return handleResponse(response);
             },
             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();
+                return handleResponse(response);
             },
             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();
+                return handleResponse(response);
             },
             delete: async <T>(url: string, headers?: Record<string, string>): Promise<T> => {
                 const response = await fetch(url, { method: 'DELETE', headers });
-                return response.json();
+                return handleResponse(response);
             },
         };
     }
@@ -287,4 +306,32 @@ export class Client {
 
         return this.httpClient.patch<void>(url, settings, headers);
     }
+
+    /**
+     * Generate a new JWT token with specified scopes and TTL
+     * @param request - The token request parameters
+     * @returns The generated token response
+     */
+    async generateToken(request: TokenRequest): Promise<TokenResponse> {
+        const url = `${this.baseUrl}/auth/token`;
+        const headers = {
+            "Content-Type": "application/json",
+            ...this.defaultHeaders,
+        };
+
+        return this.httpClient.post<TokenResponse>(url, request, headers);
+    }
+
+    /**
+     * Revoke a JWT token by its ID
+     * @param jti - The JWT token ID to revoke
+     */
+    async revokeToken(jti: string): Promise<void> {
+        const url = `${this.baseUrl}/auth/token/${jti}`;
+        const headers = {
+            ...this.defaultHeaders,
+        };
+
+        return this.httpClient.delete<void>(url, headers);
+    }
 }

src/domain.ts

@@ -471,6 +471,46 @@ export interface MessagesExportRequest {
     until: Date;
 }
 
+/**
+ * Represents a request to generate a new JWT token.
+ */
+export interface TokenRequest {
+    /**
+     * The scopes to include in the token.
+     */
+    scopes: string[];
+
+    /**
+     * The time-to-live (TTL) of the token in seconds.
+     */
+    ttl?: number;
+}
+
+/**
+ * Represents a response containing a new JWT token.
+ */
+export interface TokenResponse {
+    /**
+     * The JWT access token.
+     */
+    access_token: string;
+
+    /**
+     * The type of the token.
+     */
+    token_type: string;
+
+    /**
+     * The unique identifier of the token.
+     */
+    id: string;
+
+    /**
+     * The expiration time of the token.
+     */
+    expires_at: string;
+}
+
 /**
  * Represents the payload of a webhook event.
  */