@uploadista/client-core 0.0.6 → 0.0.7

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@uploadista/client-core",
   "type": "module",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "Platform-agnostic core upload client logic for Uploadista",
   "license": "MIT",
   "author": "Uploadista",
@@ -26,12 +26,12 @@
   "dependencies": {
     "js-base64": "3.7.8",
     "zod": "4.1.12",
-    "@uploadista/core": "0.0.6"
+    "@uploadista/core": "0.0.7"
   },
   "devDependencies": {
     "tsdown": "0.15.9",
     "vitest": "3.2.4",
-    "@uploadista/typescript-config": "0.0.6"
+    "@uploadista/typescript-config": "0.0.7"
   },
   "scripts": {
     "build": "tsdown",

package/src/auth/__tests__/auth-http-client.test.ts

@@ -1,10 +1,10 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { HttpClient } from "../../http-client";
+import type { HttpClient } from "../../services";
 import { AuthHttpClient } from "../auth-http-client";
 import { DirectAuthManager } from "../direct-auth";
 import { NoAuthManager } from "../no-auth";
-import { SaasAuthManager } from "../saas-auth";
-import type { DirectAuthConfig, SaasAuthConfig } from "../types";
+import type { DirectAuthConfig, UploadistaCloudAuthConfig } from "../types";
+import { UploadistaCloudAuthManager } from "../uploadista-cloud-auth";
 
 // Mock fetch globally
 global.fetch = vi.fn();
@@ -74,10 +74,10 @@ describe("AuthHttpClient", () => {
 
       expect(mockHttpClient.request).toHaveBeenCalledWith(
         "https://api.example.com/upload",
-        {
+        expect.objectContaining({
           method: "POST",
           headers: { "Content-Type": "application/json" },
-        },
+        }),
       );
     });
   });
@@ -100,13 +100,13 @@ describe("AuthHttpClient", () => {
 
       expect(mockHttpClient.request).toHaveBeenCalledWith(
         "https://api.example.com/upload",
-        {
+        expect.objectContaining({
           method: "POST",
-          headers: {
+          headers: expect.objectContaining({
             "Content-Type": "application/json",
             Authorization: "Bearer direct-token",
-          },
-        },
+          }),
+        }),
       );
     });
 
@@ -125,27 +125,72 @@ describe("AuthHttpClient", () => {
 
       expect(mockHttpClient.request).toHaveBeenCalledWith(
         "https://api.example.com/upload",
-        {
+        expect.objectContaining({
           headers: { Authorization: "Bearer async-token" },
-        },
+        }),
       );
     });
   });
 
-  describe("with SaasAuthManager", () => {
-    it("should attach JWT token from SaasAuthManager", async () => {
-      const config: SaasAuthConfig = {
-        mode: "saas",
+  describe("with UploadistaCloudAuthManager", () => {
+    let uploadAuthMockHttpClient: HttpClient;
+
+    beforeEach(() => {
+      // Create a separate mock HTTP client for auth requests
+      uploadAuthMockHttpClient = {
+        request: vi.fn(),
+        getMetrics: vi.fn(() => ({
+          activeConnections: 0,
+          totalConnections: 0,
+          reuseRate: 0,
+          averageConnectionTime: 0,
+        })),
+        getDetailedMetrics: vi.fn(() => ({
+          activeConnections: 0,
+          totalConnections: 0,
+          reuseRate: 0,
+          averageConnectionTime: 0,
+          health: {
+            status: "healthy" as const,
+            score: 100,
+            issues: [],
+            recommendations: [],
+          },
+          requestsPerSecond: 0,
+          errorRate: 0,
+          timeouts: 0,
+          retries: 0,
+          fastConnections: 0,
+          slowConnections: 0,
+          http2Info: {
+            supported: true,
+            detected: false,
+            version: "h2",
+            multiplexingActive: false,
+          },
+        })),
+        reset: vi.fn(),
+        close: vi.fn(async () => {}),
+        warmupConnections: vi.fn(async () => {}),
+      };
+    });
+
+    it("should attach JWT token from UploadistaCloudAuthManager", async () => {
+      const config: UploadistaCloudAuthConfig = {
+        mode: "uploadista-cloud",
         authServerUrl: "https://auth.example.com/token",
-        getCredentials: () => ({ username: "user", password: "pass" }),
+        clientId: "client-id-123",
       };
 
-      vi.mocked(global.fetch).mockResolvedValueOnce({
+      vi.mocked(uploadAuthMockHttpClient.request).mockResolvedValueOnce({
         ok: true,
         json: async () => ({ token: "jwt-token-123" }),
-      } as Response);
+      } as any);
 
-      const authManager = new SaasAuthManager(config);
+      const authManager = new UploadistaCloudAuthManager(
+        config,
+        uploadAuthMockHttpClient,
+      );
       const authClient = new AuthHttpClient(mockHttpClient, authManager);
 
       await authClient.request("https://api.example.com/upload", {
@@ -155,29 +200,32 @@ describe("AuthHttpClient", () => {
 
       expect(mockHttpClient.request).toHaveBeenCalledWith(
         "https://api.example.com/upload",
-        {
+        expect.objectContaining({
           method: "POST",
-          headers: {
+          headers: expect.objectContaining({
             "Content-Type": "application/json",
             Authorization: "Bearer jwt-token-123",
-          },
-        },
+          }),
+        }),
       );
     });
 
     it("should extract job ID from upload URL", async () => {
-      const config: SaasAuthConfig = {
-        mode: "saas",
+      const config: UploadistaCloudAuthConfig = {
+        mode: "uploadista-cloud",
         authServerUrl: "https://auth.example.com/token",
-        getCredentials: () => ({ username: "user", password: "pass" }),
+        clientId: "client-id-123",
       };
 
-      vi.mocked(global.fetch).mockResolvedValueOnce({
+      vi.mocked(uploadAuthMockHttpClient.request).mockResolvedValueOnce({
         ok: true,
         json: async () => ({ token: "jwt-token-for-upload-123" }),
-      } as Response);
+      } as any);
 
-      const authManager = new SaasAuthManager(config);
+      const authManager = new UploadistaCloudAuthManager(
+        config,
+        uploadAuthMockHttpClient,
+      );
       const authClient = new AuthHttpClient(mockHttpClient, authManager);
 
       await authClient.request(
@@ -191,18 +239,21 @@ describe("AuthHttpClient", () => {
     });
 
     it("should extract job ID from flow URL", async () => {
-      const config: SaasAuthConfig = {
-        mode: "saas",
+      const config: UploadistaCloudAuthConfig = {
+        mode: "uploadista-cloud",
         authServerUrl: "https://auth.example.com/token",
-        getCredentials: () => ({ username: "user", password: "pass" }),
+        clientId: "client-id-123",
       };
 
-      vi.mocked(global.fetch).mockResolvedValueOnce({
+      vi.mocked(uploadAuthMockHttpClient.request).mockResolvedValueOnce({
         ok: true,
         json: async () => ({ token: "jwt-token-for-flow-456" }),
-      } as Response);
+      } as any);
 
-      const authManager = new SaasAuthManager(config);
+      const authManager = new UploadistaCloudAuthManager(
+        config,
+        uploadAuthMockHttpClient,
+      );
       const authClient = new AuthHttpClient(mockHttpClient, authManager);
 
       await authClient.request(
@@ -216,18 +267,21 @@ describe("AuthHttpClient", () => {
     });
 
     it("should extract job ID from jobs URL", async () => {
-      const config: SaasAuthConfig = {
-        mode: "saas",
+      const config: UploadistaCloudAuthConfig = {
+        mode: "uploadista-cloud",
         authServerUrl: "https://auth.example.com/token",
-        getCredentials: () => ({ username: "user", password: "pass" }),
+        clientId: "client-id-123",
       };
 
-      vi.mocked(global.fetch).mockResolvedValueOnce({
+      vi.mocked(uploadAuthMockHttpClient.request).mockResolvedValueOnce({
         ok: true,
         json: async () => ({ token: "jwt-token-for-job-789" }),
-      } as Response);
+      } as any);
 
-      const authManager = new SaasAuthManager(config);
+      const authManager = new UploadistaCloudAuthManager(
+        config,
+        uploadAuthMockHttpClient,
+      );
       const authClient = new AuthHttpClient(mockHttpClient, authManager);
 
       await authClient.request(

package/src/auth/__tests__/{saas-auth.test.ts → uploadista-cloud-auth.test.ts}

@@ -1,35 +1,70 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import { SaasAuthManager } from "../saas-auth";
-import type { SaasAuthConfig } from "../types";
+import type { HttpClient } from "../../services";
+import type { UploadistaCloudAuthConfig } from "../types";
+import { UploadistaCloudAuthManager } from "../uploadista-cloud-auth";
 
-// Mock fetch globally
-global.fetch = vi.fn();
+describe("UploadistaCloudAuthManager", () => {
+  let mockHttpClient: HttpClient;
 
-describe("SaasAuthManager", () => {
   beforeEach(() => {
     vi.clearAllMocks();
+
+    // Create mock HTTP client
+    mockHttpClient = {
+      request: vi.fn(),
+      getMetrics: vi.fn(() => ({
+        activeConnections: 0,
+        totalConnections: 0,
+        reuseRate: 0,
+        averageConnectionTime: 0,
+      })),
+      getDetailedMetrics: vi.fn(() => ({
+        activeConnections: 0,
+        totalConnections: 0,
+        reuseRate: 0,
+        averageConnectionTime: 0,
+        health: {
+          status: "healthy" as const,
+          score: 100,
+          issues: [],
+          recommendations: [],
+        },
+        requestsPerSecond: 0,
+        errorRate: 0,
+        timeouts: 0,
+        retries: 0,
+        fastConnections: 0,
+        slowConnections: 0,
+        http2Info: {
+          supported: true,
+          detected: false,
+          version: "h2",
+          multiplexingActive: false,
+        },
+      })),
+      reset: vi.fn(),
+      close: vi.fn(async () => {}),
+      warmupConnections: vi.fn(async () => {}),
+    };
   });
 
   describe("fetchToken", () => {
     it("should fetch token from auth server", async () => {
-      const config: SaasAuthConfig = {
-        mode: "saas",
+      const config: UploadistaCloudAuthConfig = {
+        mode: "uploadista-cloud",
         authServerUrl: "https://auth.example.com/token",
-        getCredentials: () => ({
-          username: "user",
-          password: "pass",
-        }),
+        clientId: "client-id-123",
       };
 
-      vi.mocked(global.fetch).mockResolvedValueOnce({
+      vi.mocked(mockHttpClient.request).mockResolvedValueOnce({
         ok: true,
         json: async () => ({
           token: "jwt-token-123",
           expiresIn: 3600,
         }),
-      });
+      } as any);
 
-      const manager = new SaasAuthManager(config);
+      const manager = new UploadistaCloudAuthManager(config, mockHttpClient);
       const result = await manager.fetchToken();
 
       expect(result).toEqual({
@@ -37,48 +72,50 @@ describe("SaasAuthManager", () => {
         expiresIn: 3600,
       });
 
-      expect(global.fetch).toHaveBeenCalledWith(
-        "https://auth.example.com/token",
+      expect(mockHttpClient.request).toHaveBeenCalledWith(
+        "https://auth.example.com/token/client-id-123",
         {
-          method: "POST",
+          method: "GET",
           headers: {
             "Content-Type": "application/json",
           },
-          body: JSON.stringify({ username: "user", password: "pass" }),
         },
       );
     });
 
     it("should handle auth server errors", async () => {
-      const config: SaasAuthConfig = {
-        mode: "saas",
+      const config: UploadistaCloudAuthConfig = {
+        mode: "uploadista-cloud",
         authServerUrl: "https://auth.example.com/token",
-        getCredentials: () => ({ username: "user", password: "wrong" }),
+        clientId: "client-id-123",
       };
 
-      vi.mocked(global.fetch).mockResolvedValueOnce({
+      vi.mocked(mockHttpClient.request).mockResolvedValueOnce({
         ok: false,
         status: 401,
+        statusText: "Unauthorized",
         text: async () => JSON.stringify({ error: "Invalid credentials" }),
-      });
+      } as any);
 
-      const manager = new SaasAuthManager(config);
+      const manager = new UploadistaCloudAuthManager(config, mockHttpClient);
 
       await expect(manager.fetchToken()).rejects.toThrow(
-        "Failed to fetch auth token: Invalid credentials",
+        "Failed to fetch auth token",
       );
     });
 
     it("should handle network errors", async () => {
-      const config: SaasAuthConfig = {
-        mode: "saas",
+      const config: UploadistaCloudAuthConfig = {
+        mode: "uploadista-cloud",
         authServerUrl: "https://auth.example.com/token",
-        getCredentials: () => ({ username: "user", password: "pass" }),
+        clientId: "client-id-123",
       };
 
-      vi.mocked(global.fetch).mockRejectedValueOnce(new Error("Network error"));
+      vi.mocked(mockHttpClient.request).mockRejectedValueOnce(
+        new Error("Network error"),
+      );
 
-      const manager = new SaasAuthManager(config);
+      const manager = new UploadistaCloudAuthManager(config, mockHttpClient);
 
       await expect(manager.fetchToken()).rejects.toThrow(
         "Failed to fetch auth token: Network error",
@@ -86,18 +123,18 @@ describe("SaasAuthManager", () => {
     });
 
     it("should validate token response format", async () => {
-      const config: SaasAuthConfig = {
-        mode: "saas",
+      const config: UploadistaCloudAuthConfig = {
+        mode: "uploadista-cloud",
         authServerUrl: "https://auth.example.com/token",
-        getCredentials: () => ({ username: "user", password: "pass" }),
+        clientId: "client-id-123",
       };
 
-      vi.mocked(global.fetch).mockResolvedValueOnce({
+      vi.mocked(mockHttpClient.request).mockResolvedValueOnce({
         ok: true,
         json: async () => ({ noToken: "here" }), // Missing token field
-      });
+      } as any);
 
-      const manager = new SaasAuthManager(config);
+      const manager = new UploadistaCloudAuthManager(config, mockHttpClient);
 
       await expect(manager.fetchToken()).rejects.toThrow(
         "Auth server response missing 'token' field",
@@ -107,18 +144,18 @@ describe("SaasAuthManager", () => {
 
   describe("attachToken", () => {
     it("should attach token as Bearer header", async () => {
-      const config: SaasAuthConfig = {
-        mode: "saas",
+      const config: UploadistaCloudAuthConfig = {
+        mode: "uploadista-cloud",
         authServerUrl: "https://auth.example.com/token",
-        getCredentials: () => ({ username: "user", password: "pass" }),
+        clientId: "client-id-123",
       };
 
-      vi.mocked(global.fetch).mockResolvedValueOnce({
+      vi.mocked(mockHttpClient.request).mockResolvedValueOnce({
         ok: true,
         json: async () => ({ token: "jwt-token-123" }),
-      });
+      } as any);
 
-      const manager = new SaasAuthManager(config);
+      const manager = new UploadistaCloudAuthManager(config, mockHttpClient);
       const result = await manager.attachToken({
         "Content-Type": "application/json",
       });
@@ -130,46 +167,46 @@ describe("SaasAuthManager", () => {
     });
 
     it("should cache token and reuse it", async () => {
-      const config: SaasAuthConfig = {
-        mode: "saas",
+      const config: UploadistaCloudAuthConfig = {
+        mode: "uploadista-cloud",
         authServerUrl: "https://auth.example.com/token",
-        getCredentials: () => ({ username: "user", password: "pass" }),
+        clientId: "client-id-123",
       };
 
-      vi.mocked(global.fetch).mockResolvedValueOnce({
+      vi.mocked(mockHttpClient.request).mockResolvedValueOnce({
         ok: true,
         json: async () => ({ token: "jwt-token-123" }),
-      });
+      } as any);
 
-      const manager = new SaasAuthManager(config);
+      const manager = new UploadistaCloudAuthManager(config, mockHttpClient);
 
       // First call - should fetch token
       await manager.attachToken();
-      expect(global.fetch).toHaveBeenCalledTimes(1);
+      expect(mockHttpClient.request).toHaveBeenCalledTimes(1);
 
       // Second call - should use cached token
       await manager.attachToken();
-      expect(global.fetch).toHaveBeenCalledTimes(1); // Still 1, not 2
+      expect(mockHttpClient.request).toHaveBeenCalledTimes(1); // Still 1, not 2
     });
 
     it("should cache tokens per job ID", async () => {
-      const config: SaasAuthConfig = {
-        mode: "saas",
+      const config: UploadistaCloudAuthConfig = {
+        mode: "uploadista-cloud",
         authServerUrl: "https://auth.example.com/token",
-        getCredentials: () => ({ username: "user", password: "pass" }),
+        clientId: "client-id-123",
       };
 
-      vi.mocked(global.fetch)
+      vi.mocked(mockHttpClient.request)
         .mockResolvedValueOnce({
           ok: true,
           json: async () => ({ token: "jwt-token-1" }),
-        })
+        } as any)
         .mockResolvedValueOnce({
           ok: true,
           json: async () => ({ token: "jwt-token-2" }),
-        });
+        } as any);
 
-      const manager = new SaasAuthManager(config);
+      const manager = new UploadistaCloudAuthManager(config, mockHttpClient);
 
       // Fetch token for job 1
       const result1 = await manager.attachToken({}, "job-1");
@@ -184,31 +221,31 @@ describe("SaasAuthManager", () => {
       expect(result3.Authorization).toBe("Bearer jwt-token-1");
 
       // Should have fetched twice (once per job)
-      expect(global.fetch).toHaveBeenCalledTimes(2);
+      expect(mockHttpClient.request).toHaveBeenCalledTimes(2);
     });
 
     it("should refetch expired tokens", async () => {
-      const config: SaasAuthConfig = {
-        mode: "saas",
+      const config: UploadistaCloudAuthConfig = {
+        mode: "uploadista-cloud",
         authServerUrl: "https://auth.example.com/token",
-        getCredentials: () => ({ username: "user", password: "pass" }),
+        clientId: "client-id-123",
       };
 
       // First token expires in 1 second
-      vi.mocked(global.fetch)
+      vi.mocked(mockHttpClient.request)
         .mockResolvedValueOnce({
           ok: true,
           json: async () => ({
             token: "jwt-token-old",
             expiresIn: 0.001, // Expires very soon
           }),
-        })
+        } as any)
         .mockResolvedValueOnce({
           ok: true,
           json: async () => ({ token: "jwt-token-new" }),
-        });
+        } as any);
 
-      const manager = new SaasAuthManager(config);
+      const manager = new UploadistaCloudAuthManager(config, mockHttpClient);
 
       // First call - fetch initial token
       await manager.attachToken();
@@ -219,66 +256,66 @@ describe("SaasAuthManager", () => {
       // Second call - should fetch new token because old one expired
       const result = await manager.attachToken();
       expect(result.Authorization).toBe("Bearer jwt-token-new");
-      expect(global.fetch).toHaveBeenCalledTimes(2);
+      expect(mockHttpClient.request).toHaveBeenCalledTimes(2);
     });
   });
 
   describe("clearToken", () => {
     it("should clear cached token for specific job", async () => {
-      const config: SaasAuthConfig = {
-        mode: "saas",
+      const config: UploadistaCloudAuthConfig = {
+        mode: "uploadista-cloud",
         authServerUrl: "https://auth.example.com/token",
-        getCredentials: () => ({ username: "user", password: "pass" }),
+        clientId: "client-id-123",
       };
 
-      vi.mocked(global.fetch)
+      vi.mocked(mockHttpClient.request)
         .mockResolvedValueOnce({
           ok: true,
           json: async () => ({ token: "jwt-token-1" }),
-        })
+        } as any)
         .mockResolvedValueOnce({
           ok: true,
           json: async () => ({ token: "jwt-token-2" }),
-        });
+        } as any);
 
-      const manager = new SaasAuthManager(config);
+      const manager = new UploadistaCloudAuthManager(config, mockHttpClient);
 
       // Cache token for job
       await manager.attachToken({}, "job-1");
-      expect(global.fetch).toHaveBeenCalledTimes(1);
+      expect(mockHttpClient.request).toHaveBeenCalledTimes(1);
 
       // Clear token
       manager.clearToken("job-1");
 
       // Next call should fetch new token
       await manager.attachToken({}, "job-1");
-      expect(global.fetch).toHaveBeenCalledTimes(2);
+      expect(mockHttpClient.request).toHaveBeenCalledTimes(2);
     });
   });
 
   describe("clearAllTokens", () => {
     it("should clear all cached tokens", async () => {
-      const config: SaasAuthConfig = {
-        mode: "saas",
+      const config: UploadistaCloudAuthConfig = {
+        mode: "uploadista-cloud",
         authServerUrl: "https://auth.example.com/token",
-        getCredentials: () => ({ username: "user", password: "pass" }),
+        clientId: "client-id-123",
       };
 
-      vi.mocked(global.fetch)
+      vi.mocked(mockHttpClient.request)
         .mockResolvedValueOnce({
           ok: true,
           json: async () => ({ token: "jwt-token-1" }),
-        })
+        } as any)
         .mockResolvedValueOnce({
           ok: true,
           json: async () => ({ token: "jwt-token-2" }),
-        })
+        } as any)
         .mockResolvedValueOnce({
           ok: true,
           json: async () => ({ token: "jwt-token-3" }),
-        });
+        } as any);
 
-      const manager = new SaasAuthManager(config);
+      const manager = new UploadistaCloudAuthManager(config, mockHttpClient);
 
       // Cache tokens for multiple jobs
       await manager.attachToken({}, "job-1");
@@ -289,33 +326,33 @@ describe("SaasAuthManager", () => {
 
       // Next calls should fetch new tokens
       await manager.attachToken();
-      expect(global.fetch).toHaveBeenCalledTimes(3);
+      expect(mockHttpClient.request).toHaveBeenCalledTimes(3);
     });
   });
 
   describe("getCacheStats", () => {
     it("should return cache statistics", async () => {
-      const config: SaasAuthConfig = {
-        mode: "saas",
+      const config: UploadistaCloudAuthConfig = {
+        mode: "uploadista-cloud",
         authServerUrl: "https://auth.example.com/token",
-        getCredentials: () => ({ username: "user", password: "pass" }),
+        clientId: "client-id-123",
       };
 
-      vi.mocked(global.fetch)
+      vi.mocked(mockHttpClient.request)
         .mockResolvedValueOnce({
           ok: true,
           json: async () => ({ token: "jwt-token-1" }),
-        })
+        } as any)
         .mockResolvedValueOnce({
           ok: true,
           json: async () => ({ token: "jwt-token-2" }),
-        })
+        } as any)
         .mockResolvedValueOnce({
           ok: true,
           json: async () => ({ token: "jwt-token-3" }),
-        });
+        } as any);
 
-      const manager = new SaasAuthManager(config);
+      const manager = new UploadistaCloudAuthManager(config, mockHttpClient);
 
       // Initially empty
       expect(manager.getCacheStats()).toEqual({