refactor(storage-service): Move getAllKeys/clear logic to adapters

- getAllKeys and clear now take namespace parameter
- Adapters handle filtering and clearing (allows platform-specific optimization)
- Removed internal key registry from core (simpler code)
- Renamed clearNamespace to clear (consistent with other methods)
- Use STORAGE_KEY_PREFIX constant ('storageService:') instead of hardcoded 'storage:'
- InMemoryAdapter implements filtering and clearing logic
- Mobile adapter can now be optimized per-platform

Benefits:
- Simpler core service (no registry maintenance)
- Platform-specific optimizations possible (IndexedDB can use IDBKeyRange)
- Clear adapter responsibilities (filtering, prefix handling)
- Consistent API (all methods take namespace first)

Tests: 100% coverage maintained, all tests passing

packages/storage-service/src/InMemoryStorageAdapter.test.ts

@@ -65,69 +65,72 @@
     it('does not throw when removing non-existent key', async () => {
       const adapter = new InMemoryStorageAdapter();
 
       await expect(adapter.removeItem('nonExistent')).resolves.toBeUndefined();
     });
   });
 
   describe('getAllKeys', () => {
-    it('returns all stored keys', async () => {
+    it('returns keys for a namespace', async () => {
       const adapter = new InMemoryStorageAdapter();
 
-      await adapter.setItem('key1', 'value1');
-      await adapter.setItem('key2', 'value2');
-      await adapter.setItem('key3', 'value3');
+      await adapter.setItem('storageService:TestController:key1', 'value1');
+      await adapter.setItem('storageService:TestController:key2', 'value2');
+      await adapter.setItem('storageService:OtherController:key3', 'value3');
 
-      const keys = await adapter.getAllKeys();
+      const keys = await adapter.getAllKeys('TestController');
 
-      expect(keys).toStrictEqual(expect.arrayContaining(['key1', 'key2', 'key3']));
-      expect(keys).toHaveLength(3);
+      expect(keys).toStrictEqual(expect.arrayContaining(['key1', 'key2']));
+      expect(keys).toHaveLength(2);
     });
 
-    it('returns empty array when no keys stored', async () => {
+    it('returns empty array when no keys for namespace', async () => {
       const adapter = new InMemoryStorageAdapter();
 
-      const keys = await adapter.getAllKeys();
+      const keys = await adapter.getAllKeys('EmptyNamespace');
 
       expect(keys).toStrictEqual([]);
     });
 
-    it('reflects removed keys', async () => {
+    it('strips prefix from returned keys', async () => {
       const adapter = new InMemoryStorageAdapter();
 
-      await adapter.setItem('key1', 'value1');
-      await adapter.setItem('key2', 'value2');
-      await adapter.removeItem('key1');
+      await adapter.setItem('storageService:TestController:my-key', 'value');
 
-      const keys = await adapter.getAllKeys();
+      const keys = await adapter.getAllKeys('TestController');
 
-      expect(keys).toStrictEqual(['key2']);
+      expect(keys).toStrictEqual(['my-key']);
+      expect(keys[0]).not.toContain('storage:');
+      expect(keys[0]).not.toContain('TestController:');
     });
   });
 
   describe('clear', () => {
-    it('removes all items', async () => {
+    it('removes all items for a namespace', async () => {
       const adapter = new InMemoryStorageAdapter();
 
-      await adapter.setItem('key1', 'value1');
-      await adapter.setItem('key2', 'value2');
-      await adapter.setItem('key3', 'value3');
+      await adapter.setItem('storageService:TestController:key1', 'value1');
+      await adapter.setItem('storageService:TestController:key2', 'value2');
+      await adapter.setItem('storageService:OtherController:key3', 'value3');
 
-      await adapter.clear();
+      await adapter.clear('TestController');
 
-      const keys = await adapter.getAllKeys();
+      const testKeys = await adapter.getAllKeys('TestController');
+      const otherKeys = await adapter.getAllKeys('OtherController');
 
-      expect(keys).toStrictEqual([]);
+      expect(testKeys).toStrictEqual([]);
+      expect(otherKeys).toStrictEqual(['key3']);
     });
 
-    it('makes all previously stored items return null', async () => {
+    it('does not affect other namespaces', async () => {
       const adapter = new InMemoryStorageAdapter();
 
-      await adapter.setItem('key1', 'value1');
-      await adapter.setItem('key2', 'value2');
-      await adapter.clear();
+      await adapter.setItem('storageService:Controller1:key', 'value1');
+      await adapter.setItem('storageService:Controller2:key', 'value2');
+
+      await adapter.clear('Controller1');
 
-      expect(await adapter.getItem('key1')).toBeNull();
-      expect(await adapter.getItem('key2')).toBeNull();
+      expect(await adapter.getItem('storageService:Controller1:key')).toBeNull();
+      expect(await adapter.getItem('storageService:Controller2:key')).toBe('value2');
     });
   });
 
@@ -151,14 +154,9 @@
       expect(typeof adapter.getItem).toBe('function');
       expect(typeof adapter.setItem).toBe('function');
       expect(typeof adapter.removeItem).toBe('function');
-    });
-
-    it('implements all optional methods', () => {
-      const adapter = new InMemoryStorageAdapter();
-
       expect(typeof adapter.getAllKeys).toBe('function');
       expect(typeof adapter.clear).toBe('function');
     });
   });
 });
 

packages/storage-service/src/InMemoryStorageAdapter.ts

@@ -1,4 +1,5 @@
 import type { StorageAdapter } from './types';
+import { STORAGE_KEY_PREFIX } from './types';
 
 /**
  * In-memory storage adapter (default fallback).
@@ -27,7 +28,7 @@
   /**
    * Internal storage map.
    */
   #storage: Map<string, string>;
 
   /**
    * Constructs a new InMemoryStorageAdapter.
@@ -66,19 +67,30 @@
   }
 
   /**
-   * Get all keys from in-memory storage.
+   * Get all keys for a namespace.
+   * Returns keys without the 'storage:namespace:' prefix.
    *
-   * @returns Array of all keys.
+   * @param namespace - The namespace to get keys for.
+   * @returns Array of keys (without prefix) for this namespace.
    */
-  async getAllKeys(): Promise<string[]> {
-    return Array.from(this.#storage.keys());
+  async getAllKeys(namespace: string): Promise<string[]> {
+    const prefix = `${STORAGE_KEY_PREFIX}${namespace}:`;
+    return Array.from(this.#storage.keys())
+      .filter((key) => key.startsWith(prefix))
+      .map((key) => key.slice(prefix.length));
   }
 
   /**
-   * Clear all items from in-memory storage.
+   * Clear all items for a namespace.
+   *
+   * @param namespace - The namespace to clear.
    */
-  async clear(): Promise<void> {
-    this.#storage.clear();
+  async clear(namespace: string): Promise<void> {
+    const prefix = `${STORAGE_KEY_PREFIX}${namespace}:`;
+    const keysToDelete = Array.from(this.#storage.keys()).filter((key) =>
+      key.startsWith(prefix),
+    );
+    keysToDelete.forEach((key) => this.#storage.delete(key));
   }
 }