@harkenapp/sdk-react-native 0.0.1-alpha.1 → 0.0.1-alpha.2

package/src/services/uploadQueueService.ts

@@ -13,22 +13,14 @@
  * - D6: Real progress tracking from expo-file-system
  */
 
-import * as FileSystem from 'expo-file-system/legacy';
-import NetInfo, {
-  NetInfoState,
-  NetInfoSubscription,
-} from '@react-native-community/netinfo';
-import { HarkenClient } from '../api/client';
-import { UploadQueueStorage } from './uploadQueueStorage';
-import {
-  QueueItem,
-  QueueStatus,
-  UploadPhase,
-  UploadProgress,
-  UploadRetryConfig,
-  DEFAULT_UPLOAD_RETRY_CONFIG,
-} from '../domain';
-import { generateUUID } from '../utils';
+import * as FileSystem from "expo-file-system/legacy";
+import type { NetInfoState, NetInfoSubscription } from "@react-native-community/netinfo";
+import NetInfo from "@react-native-community/netinfo";
+import type { HarkenClient } from "../api/client";
+import { UploadQueueStorage } from "./uploadQueueStorage";
+import type { QueueItem, QueueStatus, UploadProgress, UploadRetryConfig } from "../domain";
+import { UploadPhase, DEFAULT_UPLOAD_RETRY_CONFIG } from "../domain";
+import { generateUUID } from "../utils";
 
 // Callback types for event subscriptions
 type ProgressCallback = (progress: UploadProgress) => void;
@@ -120,7 +112,7 @@ export class UploadQueueService {
     this.debug = config.debug ?? false;
 
     if (this.isInitialized) {
-      this.log('Already initialized, updated client reference');
+      this.log("Already initialized, updated client reference");
       return;
     }
 
@@ -131,10 +123,7 @@ export class UploadQueueService {
     for (const item of persistedItems) {
       // Reset any "uploading" or "confirming" items to "queued"
       // (app was killed mid-upload)
-      if (
-        item.phase === UploadPhase.UPLOADING ||
-        item.phase === UploadPhase.CONFIRMING
-      ) {
+      if (item.phase === UploadPhase.UPLOADING || item.phase === UploadPhase.CONFIRMING) {
         item.phase = UploadPhase.QUEUED;
         item.progress = 0;
       }
@@ -176,7 +165,7 @@ export class UploadQueueService {
     queueItemId: string;
   }> {
     if (!this.client) {
-      throw new Error('UploadQueueService not initialized');
+      throw new Error("UploadQueueService not initialized");
     }
 
     // 1. Get presigned URL from server
@@ -236,19 +225,19 @@ export class UploadQueueService {
     this.clearRetryTimer();
 
     this.isProcessing = true;
-    this.log('Processing queue...');
+    this.log("Processing queue...");
 
     try {
       while (true) {
         // Find next item to process
         const item = this.getNextQueuedItem();
         if (!item) {
-          this.log('No more items to process');
+          this.log("No more items to process");
           break;
         }
 
         if (this.isPaused) {
-          this.log('Queue paused, stopping processing');
+          this.log("Queue paused, stopping processing");
           break;
         }
 
@@ -270,7 +259,7 @@ export class UploadQueueService {
     // Check if URL has expired
     if (new Date(item.uploadExpiresAt) < new Date()) {
       this.log(`URL expired for ${item.attachmentId}`);
-      await this.handleItemFailure(item, 'Upload URL expired');
+      await this.handleItemFailure(item, "Upload URL expired");
       return;
     }
 
@@ -314,8 +303,7 @@ export class UploadQueueService {
 
       this.log(`Completed upload for ${item.attachmentId}`);
     } catch (error) {
-      const errorMessage =
-        error instanceof Error ? error.message : 'Unknown error';
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
       this.log(`Upload failed for ${item.attachmentId}: ${errorMessage}`);
 
       if (item.attemptNumber < item.maxAttempts) {
@@ -346,11 +334,11 @@ export class UploadQueueService {
         item.uploadUrl,
         item.localUri,
         {
-          httpMethod: 'PUT',
+          httpMethod: "PUT",
           uploadType: FileSystem.FileSystemUploadType.BINARY_CONTENT,
           sessionType: FileSystem.FileSystemSessionType.BACKGROUND,
           headers: {
-            'Content-Type': item.mimeType,
+            "Content-Type": item.mimeType,
           },
         },
         (progress) => {
@@ -375,9 +363,7 @@ export class UploadQueueService {
           if (result && result.status >= 200 && result.status < 300) {
             resolve();
           } else {
-            reject(
-              new Error(`Upload failed with status ${result?.status ?? 'unknown'}`)
-            );
+            reject(new Error(`Upload failed with status ${result?.status ?? "unknown"}`));
           }
         })
         .catch((error) => {
@@ -493,29 +479,27 @@ export class UploadQueueService {
   // --- Network Monitoring (D5) ---
 
   private setupNetworkMonitoring(): void {
-    this.networkUnsubscribe = NetInfo.addEventListener(
-      (state: NetInfoState) => {
-        if (state.isConnected && this.isPaused) {
-          this.log('Network restored, resuming queue');
-          this.isPaused = false;
-          void this.processQueue();
-        } else if (!state.isConnected && !this.isPaused) {
-          this.log('Network lost, pausing queue');
-          this.isPaused = true;
-          // Cancel active uploads - they'll resume when back online
-          for (const [id, task] of this.activeTasks) {
-            void task.cancelAsync();
-            const item = this.items.get(id);
-            if (item) {
-              item.phase = UploadPhase.QUEUED;
-              item.progress = 0;
-            }
+    this.networkUnsubscribe = NetInfo.addEventListener((state: NetInfoState) => {
+      if (state.isConnected && this.isPaused) {
+        this.log("Network restored, resuming queue");
+        this.isPaused = false;
+        void this.processQueue();
+      } else if (!state.isConnected && !this.isPaused) {
+        this.log("Network lost, pausing queue");
+        this.isPaused = true;
+        // Cancel active uploads - they'll resume when back online
+        for (const [id, task] of this.activeTasks) {
+          void task.cancelAsync();
+          const item = this.items.get(id);
+          if (item) {
+            item.phase = UploadPhase.QUEUED;
+            item.progress = 0;
           }
-          this.activeTasks.clear();
-          void this.persistQueue();
         }
+        this.activeTasks.clear();
+        void this.persistQueue();
       }
-    );
+    });
   }
 
   // --- Event Emitters ---
@@ -622,7 +606,7 @@ export class UploadQueueService {
   async retryItem(attachmentId: string): Promise<void> {
     const item = this.getItemByAttachmentId(attachmentId);
     if (!item || item.phase !== UploadPhase.FAILED) {
-      throw new Error('Item not found or not in failed state');
+      throw new Error("Item not found or not in failed state");
     }
 
     item.phase = UploadPhase.QUEUED;
@@ -669,7 +653,7 @@ export class UploadQueueService {
       }
     }
     await this.persistQueue();
-    this.log('Cleared completed items');
+    this.log("Cleared completed items");
   }
 
   /**
@@ -682,7 +666,7 @@ export class UploadQueueService {
       }
     }
     await this.persistQueue();
-    this.log('Cleared failed items');
+    this.log("Cleared failed items");
   }
 
   // --- Internal Utilities ---

package/src/services/uploadQueueStorage.test.ts

@@ -0,0 +1,243 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { UploadQueueStorage } from "./uploadQueueStorage";
+import { UploadPhase } from "../domain";
+import type { QueueItem, PersistedQueue } from "../domain";
+import AsyncStorage from "@react-native-async-storage/async-storage";
+
+// Mock AsyncStorage
+vi.mock("@react-native-async-storage/async-storage", () => ({
+  default: {
+    getItem: vi.fn(),
+    setItem: vi.fn(),
+    removeItem: vi.fn(),
+  },
+}));
+
+const STORAGE_KEY = "@harkenapp/upload-queue";
+
+function createMockQueueItem(overrides: Partial<QueueItem> = {}): QueueItem {
+  return {
+    id: "queue_1",
+    attachmentId: "att_1",
+    localUri: "file:///path/to/file.png",
+    uploadUrl: "https://storage.example.com/upload",
+    uploadExpiresAt: "2024-01-01T01:00:00Z",
+    mimeType: "image/png",
+    fileName: "screenshot.png",
+    fileSize: 12345,
+    phase: UploadPhase.QUEUED,
+    progress: 0,
+    attemptNumber: 1,
+    maxAttempts: 3,
+    createdAt: "2024-01-01T00:00:00Z",
+    ...overrides,
+  };
+}
+
+describe("UploadQueueStorage", () => {
+  let storage: UploadQueueStorage;
+  const mockAsyncStorage = AsyncStorage as unknown as {
+    getItem: ReturnType<typeof vi.fn>;
+    setItem: ReturnType<typeof vi.fn>;
+    removeItem: ReturnType<typeof vi.fn>;
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    storage = new UploadQueueStorage();
+    mockAsyncStorage.getItem.mockResolvedValue(null);
+    mockAsyncStorage.setItem.mockResolvedValue(undefined);
+    mockAsyncStorage.removeItem.mockResolvedValue(undefined);
+  });
+
+  describe("loadQueue", () => {
+    it("returns empty array when no queue exists", async () => {
+      mockAsyncStorage.getItem.mockResolvedValue(null);
+
+      const items = await storage.loadQueue();
+
+      expect(items).toEqual([]);
+      expect(mockAsyncStorage.getItem).toHaveBeenCalledWith(STORAGE_KEY);
+    });
+
+    it("returns items from valid persisted queue", async () => {
+      const persistedQueue: PersistedQueue = {
+        version: 1,
+        items: [
+          createMockQueueItem({ id: "queue_1", attachmentId: "att_1" }),
+          createMockQueueItem({ id: "queue_2", attachmentId: "att_2" }),
+        ],
+      };
+      mockAsyncStorage.getItem.mockResolvedValue(JSON.stringify(persistedQueue));
+
+      const items = await storage.loadQueue();
+
+      expect(items).toHaveLength(2);
+      expect(items[0]!.attachmentId).toBe("att_1");
+      expect(items[1]!.attachmentId).toBe("att_2");
+    });
+
+    it("returns empty array for invalid JSON", async () => {
+      mockAsyncStorage.getItem.mockResolvedValue("not valid json {{{");
+
+      const items = await storage.loadQueue();
+
+      expect(items).toEqual([]);
+    });
+
+    it("returns empty array when storage throws", async () => {
+      mockAsyncStorage.getItem.mockRejectedValue(new Error("Storage error"));
+
+      const items = await storage.loadQueue();
+
+      expect(items).toEqual([]);
+    });
+
+    it("migrates and returns empty for unknown version", async () => {
+      const persistedQueue = {
+        version: 999,
+        items: [createMockQueueItem()],
+      };
+      mockAsyncStorage.getItem.mockResolvedValue(JSON.stringify(persistedQueue));
+
+      const consoleWarn = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+      const items = await storage.loadQueue();
+
+      expect(items).toEqual([]);
+      expect(consoleWarn).toHaveBeenCalledWith(
+        expect.stringContaining("Unknown queue version 999")
+      );
+
+      consoleWarn.mockRestore();
+    });
+  });
+
+  describe("saveQueue", () => {
+    it("saves queue items with version", async () => {
+      const items = [
+        createMockQueueItem({ id: "queue_1" }),
+        createMockQueueItem({ id: "queue_2" }),
+      ];
+
+      await storage.saveQueue(items);
+
+      expect(mockAsyncStorage.setItem).toHaveBeenCalledWith(STORAGE_KEY, expect.any(String));
+
+      const call = mockAsyncStorage.setItem.mock.calls[0];
+      expect(call).toBeDefined();
+      const savedData = JSON.parse(call![1]) as PersistedQueue;
+      expect(savedData.version).toBe(1);
+      expect(savedData.items).toHaveLength(2);
+    });
+
+    it("saves empty array correctly", async () => {
+      await storage.saveQueue([]);
+
+      const call = mockAsyncStorage.setItem.mock.calls[0];
+      expect(call).toBeDefined();
+      const savedData = JSON.parse(call![1]) as PersistedQueue;
+      expect(savedData.items).toEqual([]);
+    });
+
+    it("handles storage error gracefully", async () => {
+      mockAsyncStorage.setItem.mockRejectedValue(new Error("Storage error"));
+      const consoleError = vi.spyOn(console, "error").mockImplementation(() => {});
+
+      // Should not throw
+      await expect(storage.saveQueue([createMockQueueItem()])).resolves.not.toThrow();
+
+      expect(consoleError).toHaveBeenCalled();
+      consoleError.mockRestore();
+    });
+
+    it("preserves all queue item fields", async () => {
+      const item = createMockQueueItem({
+        id: "queue_123",
+        attachmentId: "att_456",
+        localUri: "file:///custom/path.png",
+        phase: UploadPhase.UPLOADING,
+        progress: 0.5,
+        attemptNumber: 2,
+        lastError: "Previous attempt failed",
+        startedAt: "2024-01-01T00:00:05Z",
+        scheduledRetryAt: "2024-01-01T00:01:00Z",
+      });
+
+      await storage.saveQueue([item]);
+
+      const call = mockAsyncStorage.setItem.mock.calls[0];
+      expect(call).toBeDefined();
+      const savedData = JSON.parse(call![1]) as PersistedQueue;
+      const savedItem = savedData.items[0]!;
+
+      expect(savedItem.id).toBe("queue_123");
+      expect(savedItem.attachmentId).toBe("att_456");
+      expect(savedItem.phase).toBe(UploadPhase.UPLOADING);
+      expect(savedItem.progress).toBe(0.5);
+      expect(savedItem.lastError).toBe("Previous attempt failed");
+      expect(savedItem.startedAt).toBe("2024-01-01T00:00:05Z");
+    });
+  });
+
+  describe("clearQueue", () => {
+    it("removes queue from storage", async () => {
+      await storage.clearQueue();
+
+      expect(mockAsyncStorage.removeItem).toHaveBeenCalledWith(STORAGE_KEY);
+    });
+
+    it("handles storage error gracefully", async () => {
+      mockAsyncStorage.removeItem.mockRejectedValue(new Error("Storage error"));
+      const consoleError = vi.spyOn(console, "error").mockImplementation(() => {});
+
+      // Should not throw
+      await expect(storage.clearQueue()).resolves.not.toThrow();
+
+      expect(consoleError).toHaveBeenCalled();
+      consoleError.mockRestore();
+    });
+  });
+
+  describe("round-trip persistence", () => {
+    it("can save and reload queue items", async () => {
+      // Set up mock to return saved data on next load
+      let savedData: string | null = null;
+      mockAsyncStorage.setItem.mockImplementation(async (key: string, value: string) => {
+        if (key === STORAGE_KEY) savedData = value;
+      });
+      mockAsyncStorage.getItem.mockImplementation(async (key: string) => {
+        if (key === STORAGE_KEY) return savedData;
+        return null;
+      });
+
+      const originalItems = [
+        createMockQueueItem({
+          id: "queue_1",
+          phase: UploadPhase.QUEUED,
+          progress: 0,
+        }),
+        createMockQueueItem({
+          id: "queue_2",
+          phase: UploadPhase.UPLOADING,
+          progress: 0.75,
+        }),
+        createMockQueueItem({
+          id: "queue_3",
+          phase: UploadPhase.FAILED,
+          progress: 0.3,
+          lastError: "Connection timeout",
+        }),
+      ];
+
+      await storage.saveQueue(originalItems);
+      const loadedItems = await storage.loadQueue();
+
+      expect(loadedItems).toHaveLength(3);
+      expect(loadedItems[0]!.id).toBe("queue_1");
+      expect(loadedItems[0]!.phase).toBe(UploadPhase.QUEUED);
+      expect(loadedItems[1]!.progress).toBe(0.75);
+      expect(loadedItems[2]!.lastError).toBe("Connection timeout");
+    });
+  });
+});

package/src/services/uploadQueueStorage.ts

@@ -4,10 +4,10 @@
  * Uses AsyncStorage to persist queue state across app restarts.
  */
 
-import AsyncStorage from '@react-native-async-storage/async-storage';
-import type { PersistedQueue, QueueItem } from '../domain';
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import type { PersistedQueue, QueueItem } from "../domain";
 
-const STORAGE_KEY = '@harkenapp/upload-queue';
+const STORAGE_KEY = "@harkenapp/upload-queue";
 const CURRENT_VERSION = 1;
 
 /**
@@ -34,7 +34,7 @@ export class UploadQueueStorage {
 
       return parsed.items;
     } catch (error) {
-      console.error('[UploadQueueStorage] Failed to load queue:', error);
+      console.error("[UploadQueueStorage] Failed to load queue:", error);
       return [];
     }
   }
@@ -50,7 +50,7 @@ export class UploadQueueStorage {
       };
       await AsyncStorage.setItem(STORAGE_KEY, JSON.stringify(data));
     } catch (error) {
-      console.error('[UploadQueueStorage] Failed to save queue:', error);
+      console.error("[UploadQueueStorage] Failed to save queue:", error);
     }
   }
 
@@ -61,7 +61,7 @@ export class UploadQueueStorage {
     try {
       await AsyncStorage.removeItem(STORAGE_KEY);
     } catch (error) {
-      console.error('[UploadQueueStorage] Failed to clear queue:', error);
+      console.error("[UploadQueueStorage] Failed to clear queue:", error);
     }
   }
 
@@ -70,9 +70,7 @@ export class UploadQueueStorage {
    * For now, unknown versions are reset to empty.
    */
   private migrateQueue(data: PersistedQueue): QueueItem[] {
-    console.warn(
-      `[UploadQueueStorage] Unknown queue version ${data.version}, resetting`
-    );
+    console.warn(`[UploadQueueStorage] Unknown queue version ${data.version}, resetting`);
     return [];
   }
 }

package/src/storage/IdentityStore.test.ts

@@ -0,0 +1,173 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { IdentityStore } from "./IdentityStore";
+import { STORAGE_KEYS } from "./types";
+import type { SecureStorage } from "./types";
+import * as utils from "../utils";
+
+// Mock generateUUID
+vi.mock("../utils", () => ({
+  generateUUID: vi.fn(),
+}));
+
+const mockGenerateUUID = vi.mocked(utils.generateUUID);
+
+function createMockStorage(): SecureStorage & { data: Map<string, string> } {
+  const data = new Map<string, string>();
+  return {
+    data,
+    getItem: vi.fn(async (key: string) => data.get(key) ?? null),
+    setItem: vi.fn(async (key: string, value: string) => {
+      data.set(key, value);
+    }),
+    deleteItem: vi.fn(async (key: string) => {
+      data.delete(key);
+    }),
+  };
+}
+
+describe("IdentityStore", () => {
+  let mockStorage: ReturnType<typeof createMockStorage>;
+  let identityStore: IdentityStore;
+  let uuidCounter: number;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockStorage = createMockStorage();
+    identityStore = new IdentityStore(mockStorage);
+
+    // Reset UUID counter and set up mock to return predictable values
+    uuidCounter = 0;
+    mockGenerateUUID.mockImplementation(() => {
+      uuidCounter++;
+      return `mock-uuid-${uuidCounter}`;
+    });
+  });
+
+  describe("getAnonymousId", () => {
+    it("generates and stores new ID when none exists", async () => {
+      const id = await identityStore.getAnonymousId();
+
+      expect(id).toBe("mock-uuid-1");
+      expect(mockStorage.setItem).toHaveBeenCalledWith(STORAGE_KEYS.ANON_ID, "mock-uuid-1");
+    });
+
+    it("returns existing ID from storage", async () => {
+      mockStorage.data.set(STORAGE_KEYS.ANON_ID, "12345678-1234-4123-8123-123456789012");
+
+      const id = await identityStore.getAnonymousId();
+
+      expect(id).toBe("12345678-1234-4123-8123-123456789012");
+      expect(mockStorage.setItem).not.toHaveBeenCalled();
+    });
+
+    it("caches ID after first retrieval", async () => {
+      const id1 = await identityStore.getAnonymousId();
+      const id2 = await identityStore.getAnonymousId();
+      const id3 = await identityStore.getAnonymousId();
+
+      expect(id1).toBe(id2);
+      expect(id2).toBe(id3);
+      // getItem should only be called once (during first retrieval)
+      expect(mockStorage.getItem).toHaveBeenCalledTimes(1);
+    });
+
+    it("handles concurrent calls correctly", async () => {
+      // Call getAnonymousId multiple times concurrently
+      const [id1, id2, id3] = await Promise.all([
+        identityStore.getAnonymousId(),
+        identityStore.getAnonymousId(),
+        identityStore.getAnonymousId(),
+      ]);
+
+      // All should return the same ID
+      expect(id1).toBe(id2);
+      expect(id2).toBe(id3);
+      // Storage should only be accessed once
+      expect(mockStorage.getItem).toHaveBeenCalledTimes(1);
+      expect(mockStorage.setItem).toHaveBeenCalledTimes(1);
+    });
+
+    it("generates new ID if stored value is invalid UUID", async () => {
+      mockStorage.data.set(STORAGE_KEYS.ANON_ID, "invalid-not-a-uuid");
+
+      const id = await identityStore.getAnonymousId();
+
+      // Should generate new valid UUID
+      expect(id).toBe("mock-uuid-1");
+      expect(mockStorage.setItem).toHaveBeenCalledWith(STORAGE_KEYS.ANON_ID, "mock-uuid-1");
+    });
+
+    it("generates fallback ID if storage throws", async () => {
+      mockStorage.getItem = vi.fn().mockRejectedValue(new Error("Storage error"));
+
+      const id = await identityStore.getAnonymousId();
+
+      // Should return a fallback UUID (not persisted)
+      expect(id).toBe("mock-uuid-1");
+      expect(mockStorage.setItem).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("clearAnonymousId", () => {
+    it("clears cached and stored ID", async () => {
+      // First, get an ID to populate cache
+      await identityStore.getAnonymousId();
+
+      // Clear it
+      await identityStore.clearAnonymousId();
+
+      expect(mockStorage.deleteItem).toHaveBeenCalledWith(STORAGE_KEYS.ANON_ID);
+    });
+
+    it("generates new ID after clear", async () => {
+      const id1 = await identityStore.getAnonymousId();
+      expect(id1).toBe("mock-uuid-1");
+
+      await identityStore.clearAnonymousId();
+
+      // After clear, getting ID again should generate a new one
+      const id2 = await identityStore.getAnonymousId();
+      expect(id2).toBe("mock-uuid-2");
+
+      // IDs should be different
+      expect(id1).not.toBe(id2);
+    });
+  });
+
+  describe("UUID validation", () => {
+    const validUUIDs = [
+      "12345678-1234-4123-8123-123456789012",
+      "a1b2c3d4-e5f6-4789-abcd-ef0123456789",
+      "AAAAAAAA-BBBB-4CCC-8DDD-EEEEEEEEEEEE",
+      "00000000-0000-4000-8000-000000000000",
+    ];
+
+    const invalidUUIDs = [
+      "", // empty
+      "not-a-uuid", // random string
+      "12345678-1234-1234-1234-123456789012", // version 1, not 4
+      "12345678-1234-4123-0123-123456789012", // invalid variant (0)
+      "12345678-1234-4123-c123-123456789012", // invalid variant (c)
+      "12345678-1234-4123-8123-12345678901", // too short
+      "12345678-1234-4123-8123-1234567890123", // too long
+      "12345678_1234_4123_8123_123456789012", // wrong separator
+    ];
+
+    validUUIDs.forEach((uuid) => {
+      it(`accepts valid UUID: ${uuid}`, async () => {
+        mockStorage.data.set(STORAGE_KEYS.ANON_ID, uuid);
+        const id = await identityStore.getAnonymousId();
+        expect(id).toBe(uuid);
+      });
+    });
+
+    invalidUUIDs.forEach((uuid) => {
+      it(`rejects invalid UUID: ${uuid || "(empty)"}`, async () => {
+        mockStorage.data.set(STORAGE_KEYS.ANON_ID, uuid);
+        const id = await identityStore.getAnonymousId();
+        // Should generate new UUID instead of using invalid one
+        expect(id).not.toBe(uuid);
+      });
+    });
+  });
+});

package/src/storage/IdentityStore.ts

@@ -1,6 +1,6 @@
-import type { SecureStorage } from './types';
-import { STORAGE_KEYS } from './types';
-import { generateUUID } from '../utils';
+import type { SecureStorage } from "./types";
+import { STORAGE_KEYS } from "./types";
+import { generateUUID } from "../utils";
 
 /**
  * Manages anonymous identity persistence.
@@ -82,8 +82,7 @@ export class IdentityStore {
    * Validate that a string is a valid UUID v4 format.
    */
   private isValidUUID(value: string): boolean {
-    const uuidRegex =
-      /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
     return uuidRegex.test(value);
   }
 }