copilot comments

Author: JiahuiWho

src/storage/__tests__/storage.test.ts

@@ -116,6 +116,27 @@ function runStorageTests(name: string, createStorage: () => StorageBackend, clea
       expect(await storage.count('pool_leaves')).toBe(1);
     });
 
+    it('numeric keys work for get and del', async () => {
+      await storage.put('pool_leaves', { index: 0, commitment: '0xabc' });
+      const result = await storage.get('pool_leaves', 0);
+      expect(result).toBeDefined();
+      expect(result.commitment).toBe('0xabc');
+      await storage.del('pool_leaves', 0);
+      expect(await storage.get('pool_leaves', 0)).toBeUndefined();
+    });
+
+    it('throws on unknown store name (write)', async () => {
+      await expect(storage.put('unknown_store', { id: 'a' })).rejects.toThrow('Unknown store');
+    });
+
+    it('throws on unknown store name (read)', async () => {
+      await expect(storage.get('unknown_store', 'a')).rejects.toThrow('Unknown store');
+    });
+
+    it('throws on missing key field', async () => {
+      await expect(storage.put('user_notes', { name: 'no id field' })).rejects.toThrow('Missing key field');
+    });
+
     it('mutations to returned records do not affect storage', async () => {
       await storage.put('user_notes', { id: 'a', amount: '100' });
       const record = await storage.get('user_notes', 'a');

src/storage/filesystem.ts

@@ -7,7 +7,10 @@ export class FileSystemStorage implements StorageBackend {
     mkdirSync(dirPath, { recursive: true });
   }
 
+  async init(): Promise<void> {}
+
   private filePath(store: string): string {
+    if (!STORE_KEYS[store]) throw new Error(`Unknown store: ${store}`);
     return join(this.dirPath, `${store}.json`);
   }
 
@@ -23,15 +26,16 @@ export class FileSystemStorage implements StorageBackend {
 
   private getKey(store: string, value: any): string {
     const keyField = STORE_KEYS[store];
-    if (keyField && value && typeof value === 'object') {
-      return String(value[keyField]);
-    }
-    return String(value?.id ?? value?.key ?? '');
+    if (!keyField) throw new Error(`Unknown store: ${store}`);
+    const key = value?.[keyField];
+    if (key === undefined || key === null) throw new Error(`Missing key field '${keyField}' in value for store '${store}'`);
+    return String(key);
   }
 
-  async get(store: string, key: string): Promise<any | undefined> {
+  async get(store: string, key: any): Promise<any | undefined> {
     const data = this.readStore(store);
-    return data[String(key)] ? structuredClone(data[String(key)]) : undefined;
+    const k = String(key);
+    return data[k] ? structuredClone(data[k]) : undefined;
   }
 
   async getAll(store: string): Promise<any[]> {
@@ -60,7 +64,7 @@ export class FileSystemStorage implements StorageBackend {
     this.writeStore(store, data);
   }
 
-  async del(store: string, key: string): Promise<void> {
+  async del(store: string, key: any): Promise<void> {
     const data = this.readStore(store);
     delete data[String(key)];
     this.writeStore(store, data);

src/storage/indexeddb.ts

@@ -6,7 +6,7 @@ const DB_VERSION = 1;
 export class IndexedDBStorage implements StorageBackend {
   private db: IDBDatabase | null = null;
 
-  async open(): Promise<void> {
+  async init(): Promise<void> {
     if (this.db) return;
     return new Promise((resolve, reject) => {
       const request = indexedDB.open(DB_NAME, DB_VERSION);
@@ -39,7 +39,7 @@ export class IndexedDBStorage implements StorageBackend {
     });
   }
 
-  async get(store: string, key: string): Promise<any | undefined> {
+  async get(store: string, key: any): Promise<any | undefined> {
     return this.req(this.tx(store, 'readonly').get(key));
   }
 
@@ -68,7 +68,7 @@ export class IndexedDBStorage implements StorageBackend {
     });
   }
 
-  async del(store: string, key: string): Promise<void> {
+  async del(store: string, key: any): Promise<void> {
     await this.req(this.tx(store, 'readwrite').delete(key));
   }
 

src/storage/memory.ts

@@ -1,9 +1,12 @@
 import { STORE_KEYS, type StorageBackend } from './storage.js';
 
 export class MemoryStorage implements StorageBackend {
-  private stores = new Map<string, Map<string, any>>();
+  private stores = new Map<string, Map<any, any>>();
 
-  private getStore(name: string): Map<string, any> {
+  async init(): Promise<void> {}
+
+  private getStore(name: string): Map<any, any> {
+    if (!STORE_KEYS[name]) throw new Error(`Unknown store: ${name}`);
     let store = this.stores.get(name);
     if (!store) {
       store = new Map();
@@ -12,16 +15,16 @@ export class MemoryStorage implements StorageBackend {
     return store;
   }
 
-  private getKey(storeName: string, value: any): string {
+  private getKey(storeName: string, value: any): any {
     const keyField = STORE_KEYS[storeName];
-    if (keyField && value && typeof value === 'object') {
-      return String(value[keyField]);
-    }
-    return String(value?.id ?? value?.key ?? '');
+    if (!keyField) throw new Error(`Unknown store: ${storeName}`);
+    const key = value?.[keyField];
+    if (key === undefined || key === null) throw new Error(`Missing key field '${keyField}' in value for store '${storeName}'`);
+    return key;
   }
 
-  async get(store: string, key: string): Promise<any | undefined> {
-    return structuredClone(this.getStore(store).get(String(key)));
+  async get(store: string, key: any): Promise<any | undefined> {
+    return structuredClone(this.getStore(store).get(key));
   }
 
   async getAll(store: string): Promise<any[]> {
@@ -49,8 +52,8 @@ export class MemoryStorage implements StorageBackend {
     }
   }
 
-  async del(store: string, key: string): Promise<void> {
-    this.getStore(store).delete(String(key));
+  async del(store: string, key: any): Promise<void> {
+    this.getStore(store).delete(key);
   }
 
   async clear(store: string): Promise<void> {

src/storage/storage.ts

@@ -32,12 +32,14 @@ export const STORE_KEYS: Record<string, string> = {
 };
 
 export interface StorageBackend {
-  get(store: string, key: string): Promise<any | undefined>;
+  /** Initialize the storage backend (e.g., open IndexedDB connection). No-op for backends that don't need it. */
+  init(): Promise<void>;
+  get(store: string, key: any): Promise<any | undefined>;
   getAll(store: string): Promise<any[]>;
   getAllByIndex(store: string, index: string, value: any): Promise<any[]>;
   put(store: string, value: any): Promise<void>;
   putAll(store: string, values: any[]): Promise<void>;
-  del(store: string, key: string): Promise<void>;
+  del(store: string, key: any): Promise<void>;
   clear(store: string): Promise<void>;
   clearAll(): Promise<void>;
   count(store: string): Promise<number>;