use StoreName type for compile-time store name validation

Author: JiahuiWho

src/storage/__tests__/storage.test.ts

@@ -125,14 +125,6 @@ function runStorageTests(name: string, createStorage: () => StorageBackend, clea
       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');
     });

src/storage/filesystem.ts

@@ -1,6 +1,6 @@
 import { readFileSync, writeFileSync, mkdirSync, existsSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
-import { STORE_KEYS, type StorageBackend } from './storage.js';
+import { STORE_KEYS, type StorageBackend, type StoreName } from './storage.js';
 
 export class FileSystemStorage implements StorageBackend {
   constructor(private dirPath: string) {
@@ -9,53 +9,51 @@ export class FileSystemStorage implements StorageBackend {
 
   async init(): Promise<void> {}
 
-  private filePath(store: string): string {
-    if (!STORE_KEYS[store]) throw new Error(`Unknown store: ${store}`);
+  private filePath(store: StoreName): string {
     return join(this.dirPath, `${store}.json`);
   }
 
-  private readStore(store: string): Record<string, any> {
+  private readStore(store: StoreName): Record<string, any> {
     const path = this.filePath(store);
     if (!existsSync(path)) return {};
     return JSON.parse(readFileSync(path, 'utf-8'));
   }
 
-  private writeStore(store: string, data: Record<string, any>): void {
+  private writeStore(store: StoreName, data: Record<string, any>): void {
     writeFileSync(this.filePath(store), JSON.stringify(data, null, 2));
   }
 
-  private getKey(store: string, value: any): string {
+  private getKey(store: StoreName, value: any): string {
     const keyField = STORE_KEYS[store];
-    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: any): Promise<any | undefined> {
+  async get(store: StoreName, key: any): Promise<any | undefined> {
     const data = this.readStore(store);
     const k = String(key);
     return data[k] ? structuredClone(data[k]) : undefined;
   }
 
-  async getAll(store: string): Promise<any[]> {
+  async getAll(store: StoreName): Promise<any[]> {
     return Object.values(this.readStore(store)).map(v => structuredClone(v));
   }
 
-  async getAllByIndex(store: string, index: string, value: any): Promise<any[]> {
+  async getAllByIndex(store: StoreName, index: string, value: any): Promise<any[]> {
     return Object.values(this.readStore(store))
       .filter(record => record[index] === value)
       .map(v => structuredClone(v));
   }
 
-  async put(store: string, value: any): Promise<void> {
+  async put(store: StoreName, value: any): Promise<void> {
     const data = this.readStore(store);
     const key = this.getKey(store, value);
     data[key] = structuredClone(value);
     this.writeStore(store, data);
   }
 
-  async putAll(store: string, values: any[]): Promise<void> {
+  async putAll(store: StoreName, values: any[]): Promise<void> {
     const data = this.readStore(store);
     for (const value of values) {
       const key = this.getKey(store, value);
@@ -64,28 +62,28 @@ export class FileSystemStorage implements StorageBackend {
     this.writeStore(store, data);
   }
 
-  async del(store: string, key: any): Promise<void> {
+  async del(store: StoreName, key: any): Promise<void> {
     const data = this.readStore(store);
     delete data[String(key)];
     this.writeStore(store, data);
   }
 
-  async clear(store: string): Promise<void> {
+  async clear(store: StoreName): Promise<void> {
     this.writeStore(store, {});
   }
 
   async clearAll(): Promise<void> {
-    for (const storeName of Object.keys(STORE_KEYS)) {
+    for (const storeName of Object.keys(STORE_KEYS) as StoreName[]) {
       const path = this.filePath(storeName);
       if (existsSync(path)) rmSync(path);
     }
   }
 
-  async count(store: string): Promise<number> {
+  async count(store: StoreName): Promise<number> {
     return Object.keys(this.readStore(store)).length;
   }
 
-  async iterate(store: string, callback: (value: any) => boolean | void): Promise<void> {
+  async iterate(store: StoreName, callback: (value: any) => boolean | void): Promise<void> {
     for (const value of Object.values(this.readStore(store))) {
       if (callback(structuredClone(value)) === false) break;
     }

src/storage/indexeddb.ts

@@ -1,4 +1,4 @@
-import { STORE_KEYS, type StorageBackend } from './storage.js';
+import { STORE_KEYS, type StorageBackend, type StoreName } from './storage.js';
 
 const DB_NAME = 'private-payments-sdk';
 const DB_VERSION = 1;
@@ -12,7 +12,7 @@ export class IndexedDBStorage implements StorageBackend {
       const request = indexedDB.open(DB_NAME, DB_VERSION);
       request.onupgradeneeded = () => {
         const db = request.result;
-        for (const storeName of Object.keys(STORE_KEYS)) {
+        for (const storeName of Object.keys(STORE_KEYS) as StoreName[]) {
           if (!db.objectStoreNames.contains(storeName)) {
             db.createObjectStore(storeName, { keyPath: STORE_KEYS[storeName] });
           }
@@ -24,11 +24,11 @@ export class IndexedDBStorage implements StorageBackend {
   }
 
   private getDb(): IDBDatabase {
-    if (!this.db) throw new Error('IndexedDBStorage not opened. Call open() first.');
+    if (!this.db) throw new Error('IndexedDBStorage not initialized. Call init() first.');
     return this.db;
   }
 
-  private tx(store: string, mode: IDBTransactionMode): IDBObjectStore {
+  private tx(store: StoreName, mode: IDBTransactionMode): IDBObjectStore {
     return this.getDb().transaction(store, mode).objectStore(store);
   }
 
@@ -39,24 +39,24 @@ export class IndexedDBStorage implements StorageBackend {
     });
   }
 
-  async get(store: string, key: any): Promise<any | undefined> {
+  async get(store: StoreName, key: any): Promise<any | undefined> {
     return this.req(this.tx(store, 'readonly').get(key));
   }
 
-  async getAll(store: string): Promise<any[]> {
+  async getAll(store: StoreName): Promise<any[]> {
     return this.req(this.tx(store, 'readonly').getAll());
   }
 
-  async getAllByIndex(store: string, index: string, value: any): Promise<any[]> {
+  async getAllByIndex(store: StoreName, index: string, value: any): Promise<any[]> {
     const all = await this.getAll(store);
     return all.filter(record => record[index] === value);
   }
 
-  async put(store: string, value: any): Promise<void> {
+  async put(store: StoreName, value: any): Promise<void> {
     await this.req(this.tx(store, 'readwrite').put(value));
   }
 
-  async putAll(store: string, values: any[]): Promise<void> {
+  async putAll(store: StoreName, values: any[]): Promise<void> {
     const tx = this.getDb().transaction(store, 'readwrite');
     const objectStore = tx.objectStore(store);
     for (const value of values) {
@@ -68,25 +68,25 @@ export class IndexedDBStorage implements StorageBackend {
     });
   }
 
-  async del(store: string, key: any): Promise<void> {
+  async del(store: StoreName, key: any): Promise<void> {
     await this.req(this.tx(store, 'readwrite').delete(key));
   }
 
-  async clear(store: string): Promise<void> {
+  async clear(store: StoreName): Promise<void> {
     await this.req(this.tx(store, 'readwrite').clear());
   }
 
   async clearAll(): Promise<void> {
-    for (const storeName of Object.keys(STORE_KEYS)) {
+    for (const storeName of Object.keys(STORE_KEYS) as StoreName[]) {
       await this.clear(storeName);
     }
   }
 
-  async count(store: string): Promise<number> {
+  async count(store: StoreName): Promise<number> {
     return this.req(this.tx(store, 'readonly').count());
   }
 
-  async iterate(store: string, callback: (value: any) => boolean | void): Promise<void> {
+  async iterate(store: StoreName, callback: (value: any) => boolean | void): Promise<void> {
     return new Promise((resolve, reject) => {
       const request = this.tx(store, 'readonly').openCursor();
       request.onsuccess = () => {

src/storage/memory.ts

@@ -1,12 +1,11 @@
-import { STORE_KEYS, type StorageBackend } from './storage.js';
+import { STORE_KEYS, type StorageBackend, type StoreName } from './storage.js';
 
 export class MemoryStorage implements StorageBackend {
   private stores = new Map<string, Map<any, any>>();
 
   async init(): Promise<void> {}
 
-  private getStore(name: string): Map<any, any> {
-    if (!STORE_KEYS[name]) throw new Error(`Unknown store: ${name}`);
+  private getStore(name: StoreName): Map<any, any> {
     let store = this.stores.get(name);
     if (!store) {
       store = new Map();
@@ -15,23 +14,22 @@ export class MemoryStorage implements StorageBackend {
     return store;
   }
 
-  private getKey(storeName: string, value: any): any {
+  private getKey(storeName: StoreName, value: any): any {
     const keyField = STORE_KEYS[storeName];
-    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: any): Promise<any | undefined> {
+  async get(store: StoreName, key: any): Promise<any | undefined> {
     return structuredClone(this.getStore(store).get(key));
   }
 
-  async getAll(store: string): Promise<any[]> {
+  async getAll(store: StoreName): Promise<any[]> {
     return Array.from(this.getStore(store).values()).map(v => structuredClone(v));
   }
 
-  async getAllByIndex(store: string, index: string, value: any): Promise<any[]> {
+  async getAllByIndex(store: StoreName, index: string, value: any): Promise<any[]> {
     const results: any[] = [];
     for (const record of this.getStore(store).values()) {
       if (record[index] === value) {
@@ -41,34 +39,34 @@ export class MemoryStorage implements StorageBackend {
     return results;
   }
 
-  async put(store: string, value: any): Promise<void> {
+  async put(store: StoreName, value: any): Promise<void> {
     const key = this.getKey(store, value);
     this.getStore(store).set(key, structuredClone(value));
   }
 
-  async putAll(store: string, values: any[]): Promise<void> {
+  async putAll(store: StoreName, values: any[]): Promise<void> {
     for (const value of values) {
       await this.put(store, value);
     }
   }
 
-  async del(store: string, key: any): Promise<void> {
+  async del(store: StoreName, key: any): Promise<void> {
     this.getStore(store).delete(key);
   }
 
-  async clear(store: string): Promise<void> {
+  async clear(store: StoreName): Promise<void> {
     this.getStore(store).clear();
   }
 
   async clearAll(): Promise<void> {
     this.stores.clear();
   }
 
-  async count(store: string): Promise<number> {
+  async count(store: StoreName): Promise<number> {
     return this.getStore(store).size;
   }
 
-  async iterate(store: string, callback: (value: any) => boolean | void): Promise<void> {
+  async iterate(store: StoreName, callback: (value: any) => boolean | void): Promise<void> {
     for (const value of this.getStore(store).values()) {
       if (callback(structuredClone(value)) === false) break;
     }

src/storage/storage.ts

@@ -20,7 +20,7 @@
  * - retention_config: { rpcEndpoint (key), windowLedgers, detectedAt }
  */
 /** Primary key field for each store. Used by storage implementations to key records. */
-export const STORE_KEYS: Record<string, string> = {
+export const STORE_KEYS = {
   pool_leaves: 'index',
   pool_nullifiers: 'nullifier',
   pool_encrypted_outputs: 'commitment',
@@ -29,19 +29,21 @@ export const STORE_KEYS: Record<string, string> = {
   registered_public_keys: 'address',
   sync_metadata: 'network',
   retention_config: 'rpcEndpoint',
-};
+} as const;
+
+export type StoreName = keyof typeof STORE_KEYS;
 
 export interface StorageBackend {
   /** 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: any): Promise<void>;
-  clear(store: string): Promise<void>;
+  get(store: StoreName, key: any): Promise<any | undefined>;
+  getAll(store: StoreName): Promise<any[]>;
+  getAllByIndex(store: StoreName, index: string, value: any): Promise<any[]>;
+  put(store: StoreName, value: any): Promise<void>;
+  putAll(store: StoreName, values: any[]): Promise<void>;
+  del(store: StoreName, key: any): Promise<void>;
+  clear(store: StoreName): Promise<void>;
   clearAll(): Promise<void>;
-  count(store: string): Promise<number>;
-  iterate(store: string, callback: (value: any) => boolean | void): Promise<void>;
+  count(store: StoreName): Promise<number>;
+  iterate(store: StoreName, callback: (value: any) => boolean | void): Promise<void>;
 }