@uploadista/client-browser 0.0.20 → 0.1.0-beta.5

package/src/services/create-browser-services.test.ts

@@ -0,0 +1,248 @@
+import { describe, expect, it } from "vitest";
+import { createBrowserServices, type BrowserServiceOptions } from "./create-browser-services";
+
+describe("createBrowserServices", () => {
+  it("should create a service container with default options", () => {
+    const services = createBrowserServices();
+
+    expect(services).toBeDefined();
+    expect(services.platform).toBeDefined();
+    expect(services.storage).toBeDefined();
+    expect(services.idGeneration).toBeDefined();
+    expect(services.httpClient).toBeDefined();
+    expect(services.fileReader).toBeDefined();
+    expect(services.websocket).toBeDefined();
+    expect(services.abortController).toBeDefined();
+    expect(services.checksumService).toBeDefined();
+    expect(services.fingerprintService).toBeDefined();
+  });
+
+  it("should create a service container with custom options", () => {
+    const options: BrowserServiceOptions = {
+      useLocalStorage: true,
+      connectionPooling: {
+        maxConnectionsPerHost: 10,
+        connectionTimeout: 60000,
+        keepAliveTimeout: 120000,
+        enableHttp2: true,
+        retryOnConnectionError: true,
+      },
+    };
+
+    const services = createBrowserServices(options);
+
+    expect(services).toBeDefined();
+    expect(services.platform).toBeDefined();
+    expect(services.storage).toBeDefined();
+  });
+
+  it("should use localStorage when useLocalStorage is true", () => {
+    const services = createBrowserServices({ useLocalStorage: true });
+
+    // Verify storage service is created
+    expect(services.storage).toBeDefined();
+    expect(services.storage.getItem).toBeDefined();
+    expect(services.storage.setItem).toBeDefined();
+    expect(services.storage.removeItem).toBeDefined();
+    expect(services.storage.find).toBeDefined();
+    expect(services.storage.findAll).toBeDefined();
+  });
+
+  it("should use localStorage as default when useLocalStorage is false", () => {
+    // Currently the implementation uses localStorage as fallback
+    const services = createBrowserServices({ useLocalStorage: false });
+
+    expect(services.storage).toBeDefined();
+    expect(services.storage.getItem).toBeDefined();
+  });
+
+  describe("platform service", () => {
+    it("should have all platform service methods", () => {
+      const services = createBrowserServices();
+      const platform = services.platform;
+
+      expect(platform.setTimeout).toBeDefined();
+      expect(platform.clearTimeout).toBeDefined();
+      expect(platform.isBrowser).toBeDefined();
+      expect(platform.isOnline).toBeDefined();
+      expect(platform.isFileLike).toBeDefined();
+      expect(platform.getFileName).toBeDefined();
+      expect(platform.getFileType).toBeDefined();
+      expect(platform.getFileSize).toBeDefined();
+      expect(platform.getFileLastModified).toBeDefined();
+    });
+  });
+
+  describe("storage service", () => {
+    it("should have all storage service methods", () => {
+      const services = createBrowserServices();
+      const storage = services.storage;
+
+      expect(typeof storage.getItem).toBe("function");
+      expect(typeof storage.setItem).toBe("function");
+      expect(typeof storage.removeItem).toBe("function");
+      expect(typeof storage.find).toBe("function");
+      expect(typeof storage.findAll).toBe("function");
+    });
+  });
+
+  describe("idGeneration service", () => {
+    it("should generate unique IDs", () => {
+      const services = createBrowserServices();
+      const id1 = services.idGeneration.generate();
+      const id2 = services.idGeneration.generate();
+
+      expect(id1).toBeDefined();
+      expect(id2).toBeDefined();
+      expect(id1).not.toBe(id2);
+    });
+  });
+
+  describe("httpClient", () => {
+    it("should have all HTTP client methods", () => {
+      const services = createBrowserServices();
+      const httpClient = services.httpClient;
+
+      expect(httpClient.request).toBeDefined();
+      expect(httpClient.getMetrics).toBeDefined();
+      expect(httpClient.getDetailedMetrics).toBeDefined();
+      expect(httpClient.warmupConnections).toBeDefined();
+      expect(httpClient.reset).toBeDefined();
+      expect(httpClient.close).toBeDefined();
+    });
+  });
+
+  describe("fileReader service", () => {
+    it("should have openFile method", () => {
+      const services = createBrowserServices();
+      const fileReader = services.fileReader;
+
+      expect(fileReader.openFile).toBeDefined();
+      expect(typeof fileReader.openFile).toBe("function");
+    });
+
+    it("should open a file", async () => {
+      const services = createBrowserServices();
+      const file = new File(["test content"], "test.txt", {
+        type: "text/plain",
+      });
+
+      const source = await services.fileReader.openFile(file, 1024);
+
+      expect(source).toBeDefined();
+      expect(source.size).toBe(file.size);
+      expect(source.name).toBe("test.txt");
+    });
+  });
+
+  describe("websocket factory", () => {
+    it("should have create method", () => {
+      const services = createBrowserServices();
+      const websocket = services.websocket;
+
+      expect(websocket.create).toBeDefined();
+      expect(typeof websocket.create).toBe("function");
+    });
+  });
+
+  describe("abortController factory", () => {
+    it("should have create method", () => {
+      const services = createBrowserServices();
+      const abortController = services.abortController;
+
+      expect(abortController.create).toBeDefined();
+      expect(typeof abortController.create).toBe("function");
+    });
+
+    it("should create working abort controllers", () => {
+      const services = createBrowserServices();
+      const controller = services.abortController.create();
+
+      expect(controller.signal.aborted).toBe(false);
+      controller.abort();
+      expect(controller.signal.aborted).toBe(true);
+    });
+  });
+
+  describe("checksumService", () => {
+    it("should compute checksums", async () => {
+      const services = createBrowserServices();
+      const data = new Uint8Array([1, 2, 3, 4, 5]);
+
+      const checksum = await services.checksumService.computeChecksum(data);
+
+      expect(checksum).toBeDefined();
+      expect(checksum).toHaveLength(64);
+      expect(checksum).toMatch(/^[a-f0-9]{64}$/);
+    });
+  });
+
+  describe("fingerprintService", () => {
+    it("should compute fingerprints", async () => {
+      const services = createBrowserServices();
+      const file = new File(["test content"], "test.txt", {
+        type: "text/plain",
+      });
+
+      const fingerprint = await services.fingerprintService.computeFingerprint(
+        file,
+        "https://api.example.com"
+      );
+
+      expect(fingerprint).toBeDefined();
+      expect(fingerprint).toHaveLength(64);
+      expect(fingerprint).toMatch(/^[a-f0-9]{64}$/);
+    });
+  });
+
+  describe("integration", () => {
+    it("should work together for a typical upload workflow", async () => {
+      const services = createBrowserServices();
+
+      // 1. Check if we're in browser
+      expect(services.platform.isBrowser()).toBe(true);
+
+      // 2. Generate an upload ID
+      const uploadId = services.idGeneration.generate();
+      expect(uploadId).toMatch(/^[0-9a-f-]{36}$/i);
+
+      // 3. Create a file and open it
+      const file = new File(["test file content"], "upload.txt", {
+        type: "text/plain",
+      });
+      const source = await services.fileReader.openFile(file, 1024);
+      expect(source.size).toBe(file.size);
+
+      // 4. Compute fingerprint for deduplication
+      const fingerprint = await services.fingerprintService.computeFingerprint(
+        file,
+        "https://api.example.com"
+      );
+      expect(fingerprint).toHaveLength(64);
+
+      // 5. Create an abort controller for cancellation
+      const controller = services.abortController.create();
+      expect(controller.signal.aborted).toBe(false);
+
+      // 6. Store upload state
+      await services.storage.setItem(
+        `upload:${uploadId}`,
+        JSON.stringify({
+          id: uploadId,
+          fingerprint,
+          status: "pending",
+        })
+      );
+
+      // 7. Retrieve stored state
+      const storedState = await services.storage.getItem(`upload:${uploadId}`);
+      expect(storedState).toBeDefined();
+      expect(JSON.parse(storedState!).id).toBe(uploadId);
+
+      // 8. Clean up
+      await services.storage.removeItem(`upload:${uploadId}`);
+      const removed = await services.storage.getItem(`upload:${uploadId}`);
+      expect(removed).toBeNull();
+    });
+  });
+});

package/src/services/file-reader.test.ts

@@ -0,0 +1,171 @@
+import { describe, expect, it } from "vitest";
+import { createBrowserFileReaderService } from "./file-reader";
+
+describe("createBrowserFileReaderService", () => {
+  it("should create a file reader service", () => {
+    const service = createBrowserFileReaderService();
+    expect(service).toBeDefined();
+    expect(service.openFile).toBeDefined();
+    expect(typeof service.openFile).toBe("function");
+  });
+
+  describe("openFile", () => {
+    it("should open a File object", async () => {
+      const service = createBrowserFileReaderService();
+      const file = new File(["Hello, World!"], "test.txt", {
+        type: "text/plain",
+      });
+
+      const source = await service.openFile(file, 1024);
+
+      expect(source).toBeDefined();
+      expect(source.input).toBe(file);
+      expect(source.size).toBe(file.size);
+      expect(source.name).toBe("test.txt");
+      expect(source.type).toBe("text/plain");
+      expect(source.lastModified).toBeDefined();
+    });
+
+    it("should open a Blob object", async () => {
+      const service = createBrowserFileReaderService();
+      const blob = new Blob(["Hello, World!"], { type: "text/plain" });
+
+      const source = await service.openFile(blob, 1024);
+
+      expect(source).toBeDefined();
+      expect(source.input).toBe(blob);
+      expect(source.size).toBe(blob.size);
+      expect(source.name).toBeNull();
+      expect(source.type).toBeNull();
+      expect(source.lastModified).toBeNull();
+    });
+
+    it("should throw for invalid input", async () => {
+      const service = createBrowserFileReaderService();
+
+      await expect(
+        service.openFile("invalid" as unknown as Blob, 1024)
+      ).rejects.toThrow("source object may only be an instance of File, Blob");
+    });
+  });
+
+  describe("FileSource", () => {
+    describe("slice", () => {
+      it("should read a slice of data", async () => {
+        const service = createBrowserFileReaderService();
+        const content = "Hello, World!";
+        const file = new File([content], "test.txt", { type: "text/plain" });
+
+        const source = await service.openFile(file, 1024);
+        const result = await source.slice(0, 5);
+
+        expect(result.value).toBeInstanceOf(Uint8Array);
+        expect(result.size).toBe(5);
+        expect(result.done).toBe(false);
+
+        // Verify content
+        const text = new TextDecoder().decode(result.value);
+        expect(text).toBe("Hello");
+      });
+
+      it("should read the entire file", async () => {
+        const service = createBrowserFileReaderService();
+        const content = "Hello";
+        const file = new File([content], "test.txt", { type: "text/plain" });
+
+        const source = await service.openFile(file, 1024);
+        const result = await source.slice(0, file.size);
+
+        expect(result.value).toBeInstanceOf(Uint8Array);
+        expect(result.size).toBe(5);
+        expect(result.done).toBe(true);
+
+        const text = new TextDecoder().decode(result.value);
+        expect(text).toBe("Hello");
+      });
+
+      it("should read from middle of file", async () => {
+        const service = createBrowserFileReaderService();
+        const content = "Hello, World!";
+        const file = new File([content], "test.txt", { type: "text/plain" });
+
+        const source = await service.openFile(file, 1024);
+        const result = await source.slice(7, 12);
+
+        const text = new TextDecoder().decode(result.value);
+        expect(text).toBe("World");
+      });
+
+      it("should handle empty slice", async () => {
+        const service = createBrowserFileReaderService();
+        const content = "Hello";
+        const file = new File([content], "test.txt", { type: "text/plain" });
+
+        const source = await service.openFile(file, 1024);
+        const result = await source.slice(0, 0);
+
+        expect(result.size).toBe(0);
+      });
+
+      it("should handle binary data", async () => {
+        const service = createBrowserFileReaderService();
+        const binaryData = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+        const blob = new Blob([binaryData], { type: "application/octet-stream" });
+
+        const source = await service.openFile(blob, 1024);
+        const result = await source.slice(0, 5);
+
+        expect(result.value).toEqual(new Uint8Array([0, 1, 2, 3, 4]));
+      });
+    });
+
+    describe("close", () => {
+      it("should not throw when closing", async () => {
+        const service = createBrowserFileReaderService();
+        const file = new File(["Hello"], "test.txt", { type: "text/plain" });
+
+        const source = await service.openFile(file, 1024);
+
+        expect(() => source.close()).not.toThrow();
+      });
+    });
+  });
+
+  describe("chunked reading", () => {
+    it("should read file in chunks", async () => {
+      const service = createBrowserFileReaderService();
+      const content = "ABCDEFGHIJ"; // 10 bytes
+      const file = new File([content], "test.txt", { type: "text/plain" });
+      const chunkSize = 3;
+
+      const source = await service.openFile(file, chunkSize);
+      const chunks: Uint8Array[] = [];
+      let offset = 0;
+
+      while (offset < file.size) {
+        const end = Math.min(offset + chunkSize, file.size);
+        const result = await source.slice(offset, end);
+        chunks.push(result.value);
+        offset = end;
+
+        if (result.done) break;
+      }
+
+      // Should have 4 chunks: ABC, DEF, GHI, J
+      expect(chunks).toHaveLength(4);
+
+      // Verify combined content
+      const combined = new Uint8Array(
+        chunks.reduce((acc, chunk) => acc + chunk.length, 0)
+      );
+      let pos = 0;
+      for (const chunk of chunks) {
+        combined.set(chunk, pos);
+        pos += chunk.length;
+      }
+
+      const text = new TextDecoder().decode(combined);
+      expect(text).toBe(content);
+    });
+  });
+});

package/src/services/fingerprint-service.test.ts

@@ -0,0 +1,123 @@
+import { describe, expect, it } from "vitest";
+import { createFingerprintService } from "./fingerprint-service";
+
+describe("createFingerprintService", () => {
+  it("should create a fingerprint service", () => {
+    const service = createFingerprintService();
+    expect(service).toBeDefined();
+    expect(service.computeFingerprint).toBeDefined();
+    expect(typeof service.computeFingerprint).toBe("function");
+  });
+
+  describe("computeFingerprint", () => {
+    it("should compute fingerprint for a File", async () => {
+      const service = createFingerprintService();
+      const file = new File(["Hello, World!"], "test.txt", {
+        type: "text/plain",
+      });
+
+      const fingerprint = await service.computeFingerprint(
+        file,
+        "https://api.example.com"
+      );
+
+      // Should return a 64-character hex string (SHA-256)
+      expect(fingerprint).toHaveLength(64);
+      expect(fingerprint).toMatch(/^[a-f0-9]{64}$/);
+    });
+
+    it("should compute fingerprint for a Blob", async () => {
+      const service = createFingerprintService();
+      const blob = new Blob(["Test content"], { type: "text/plain" });
+
+      const fingerprint = await service.computeFingerprint(
+        blob,
+        "https://api.example.com"
+      );
+
+      expect(fingerprint).toHaveLength(64);
+      expect(fingerprint).toMatch(/^[a-f0-9]{64}$/);
+    });
+
+    it("should return same fingerprint for identical files", async () => {
+      const service = createFingerprintService();
+      const content = "Same content";
+      const file1 = new File([content], "file1.txt", { type: "text/plain" });
+      const file2 = new File([content], "file2.txt", { type: "text/plain" });
+
+      const fingerprint1 = await service.computeFingerprint(
+        file1,
+        "https://api.example.com"
+      );
+      const fingerprint2 = await service.computeFingerprint(
+        file2,
+        "https://api.example.com"
+      );
+
+      expect(fingerprint1).toBe(fingerprint2);
+    });
+
+    it("should return different fingerprint for different files", async () => {
+      const service = createFingerprintService();
+      const file1 = new File(["Content A"], "file1.txt", { type: "text/plain" });
+      const file2 = new File(["Content B"], "file2.txt", { type: "text/plain" });
+
+      const fingerprint1 = await service.computeFingerprint(
+        file1,
+        "https://api.example.com"
+      );
+      const fingerprint2 = await service.computeFingerprint(
+        file2,
+        "https://api.example.com"
+      );
+
+      expect(fingerprint1).not.toBe(fingerprint2);
+    });
+
+    it("should return same fingerprint regardless of endpoint", async () => {
+      const service = createFingerprintService();
+      const file = new File(["Test content"], "test.txt", {
+        type: "text/plain",
+      });
+
+      const fingerprint1 = await service.computeFingerprint(
+        file,
+        "https://api1.example.com"
+      );
+      const fingerprint2 = await service.computeFingerprint(
+        file,
+        "https://api2.example.com"
+      );
+
+      // The current implementation ignores the endpoint
+      expect(fingerprint1).toBe(fingerprint2);
+    });
+
+    it("should handle empty file", async () => {
+      const service = createFingerprintService();
+      const file = new File([], "empty.txt", { type: "text/plain" });
+
+      const fingerprint = await service.computeFingerprint(
+        file,
+        "https://api.example.com"
+      );
+
+      expect(fingerprint).toHaveLength(64);
+      expect(fingerprint).toMatch(/^[a-f0-9]{64}$/);
+    });
+
+    it("should handle binary content", async () => {
+      const service = createFingerprintService();
+      const binaryData = new Uint8Array([0, 1, 2, 255, 254, 253]);
+      const blob = new Blob([binaryData], { type: "application/octet-stream" });
+
+      const fingerprint = await service.computeFingerprint(
+        blob,
+        "https://api.example.com"
+      );
+
+      expect(fingerprint).toHaveLength(64);
+      expect(fingerprint).toMatch(/^[a-f0-9]{64}$/);
+    });
+  });
+});

package/src/services/id-generation/id-generation.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import { createBrowserIdGenerationService } from "./id-generation";
+
+describe("createBrowserIdGenerationService", () => {
+  it("should create an ID generation service", () => {
+    const service = createBrowserIdGenerationService();
+    expect(service).toBeDefined();
+    expect(service.generate).toBeDefined();
+    expect(typeof service.generate).toBe("function");
+  });
+
+  describe("generate", () => {
+    it("should generate a UUID v4 string", () => {
+      const service = createBrowserIdGenerationService();
+      const id = service.generate();
+
+      // UUID v4 format: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
+      expect(id).toMatch(
+        /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
+      );
+    });
+
+    it("should generate unique IDs", () => {
+      const service = createBrowserIdGenerationService();
+      const ids = new Set<string>();
+
+      for (let i = 0; i < 100; i++) {
+        ids.add(service.generate());
+      }
+
+      // All 100 IDs should be unique
+      expect(ids.size).toBe(100);
+    });
+
+    it("should have correct UUID v4 version byte", () => {
+      const service = createBrowserIdGenerationService();
+      const id = service.generate();
+
+      // The 13th character (index 14 after hyphens) should be '4' for v4
+      const parts = id.split("-");
+      expect(parts[2][0]).toBe("4");
+    });
+
+    it("should have correct UUID v4 variant byte", () => {
+      const service = createBrowserIdGenerationService();
+      const id = service.generate();
+
+      // The variant byte should be 8, 9, a, or b
+      const parts = id.split("-");
+      const variantChar = parts[3][0].toLowerCase();
+      expect(["8", "9", "a", "b"]).toContain(variantChar);
+    });
+  });
+});