@hashtree/dexie 0.1.1 → 0.1.4

package/README.md

@@ -0,0 +1,49 @@
+# @hashtree/dexie
+
+IndexedDB storage adapter for hashtree using Dexie.
+
+## Install
+
+```bash
+npm install @hashtree/dexie
+```
+
+## Usage
+
+```typescript
+import { DexieStore } from '@hashtree/dexie';
+import { HashTree } from '@hashtree/core';
+
+const store = new DexieStore('my-hashtree-db');
+const tree = new HashTree({ store });
+
+// Store persists to IndexedDB
+await tree.putFile(data);
+```
+
+## Features
+
+- Persistent browser storage
+- LRU eviction support
+- Automatic schema migrations
+
+## API
+
+```typescript
+const store = new DexieStore(dbName?: string);
+
+await store.get(hash);
+await store.put(hash, data);
+await store.has(hash);
+await store.delete(hash);
+await store.keys();
+await store.clear();
+await store.count();
+await store.totalBytes();
+await store.evict(maxBytes);
+store.close();
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -5,7 +5,12 @@ import type { Store, Hash } from '@hashtree/core';
  */
 export declare class DexieStore implements Store {
     private db;
+    private pendingLastAccessUpdates;
+    private lastAccessFlushPromise;
+    private lastAccessFlushTimer;
     constructor(dbName?: string);
+    private scheduleLastAccessTouch;
+    private flushPendingLastAccessUpdates;
     put(hash: Hash, data: Uint8Array): Promise<boolean>;
     get(hash: Hash): Promise<Uint8Array | null>;
     has(hash: Hash): Promise<boolean>;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAkClD;;;GAGG;AACH,qBAAa,UAAW,YAAW,KAAK;IACtC,OAAO,CAAC,EAAE,CAAa;gBAEX,MAAM,GAAE,MAAmB;IAIjC,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC;IAYnD,GAAG,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IAyB3C,GAAG,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC;IAYjC,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC;IAe1C;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;IAW7B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ5B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;IAS9B;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;IAanC;;;OAGG;IACG,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IA4B9C;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;WACU,cAAc,CAAC,MAAM,GAAE,MAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;CAGxE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AA4DlD;;;GAGG;AACH,qBAAa,UAAW,YAAW,KAAK;IACtC,OAAO,CAAC,EAAE,CAAa;IACvB,OAAO,CAAC,wBAAwB,CAA6B;IAC7D,OAAO,CAAC,sBAAsB,CAA8B;IAC5D,OAAO,CAAC,oBAAoB,CAA8C;gBAE9D,MAAM,GAAE,MAAmB;IAIvC,OAAO,CAAC,uBAAuB;YAYjB,6BAA6B;IAyCrC,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC;IAiBnD,GAAG,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IAwB3C,GAAG,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC;IAYjC,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC;IAmB1C;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;IAW7B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAY5B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;IAS9B;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;IAanC;;;OAGG;IACG,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAiC9C;;OAEG;IACH,KAAK,IAAI,IAAI;IASb;;OAEG;WACU,cAAc,CAAC,MAAM,GAAE,MAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;CAGxE"}

package/dist/index.js

@@ -4,8 +4,10 @@
  */
 import Dexie from 'dexie';
 import { toHex, fromHex } from '@hashtree/core';
+const LAST_ACCESS_FLUSH_DELAY_MS = 50;
 class HashTreeDB extends Dexie {
     blobs;
+    accesses;
     constructor(dbName) {
         super(dbName);
         // Version 1: Original schema without lastAccess
@@ -22,6 +24,19 @@ class HashTreeDB extends Dexie {
                 blob.lastAccess = now;
             });
         });
+        // Version 3: Track access timestamps in a separate table so read hits
+        // don't need to rewrite blob payload rows.
+        this.version(3).stores({
+            blobs: '&hashHex, lastAccess',
+            accesses: '&hashHex, lastAccess',
+        }).upgrade(async (tx) => {
+            const blobs = await tx.table('blobs').toArray();
+            const accessesTable = tx.table('accesses');
+            await Promise.all(blobs.map((blob) => accessesTable.put({
+                hashHex: blob.hashHex,
+                lastAccess: blob.lastAccess ?? Date.now(),
+            })));
+        });
     }
 }
 /**
@@ -30,14 +45,63 @@ class HashTreeDB extends Dexie {
  */
 export class DexieStore {
     db;
+    pendingLastAccessUpdates = new Map();
+    lastAccessFlushPromise = null;
+    lastAccessFlushTimer = null;
     constructor(dbName = 'hashtree') {
         this.db = new HashTreeDB(dbName);
     }
+    scheduleLastAccessTouch(hashHex) {
+        this.pendingLastAccessUpdates.set(hashHex, Date.now());
+        if (this.lastAccessFlushTimer !== null) {
+            return;
+        }
+        this.lastAccessFlushTimer = setTimeout(() => {
+            this.lastAccessFlushTimer = null;
+            void this.flushPendingLastAccessUpdates();
+        }, LAST_ACCESS_FLUSH_DELAY_MS);
+    }
+    async flushPendingLastAccessUpdates() {
+        if (this.lastAccessFlushTimer !== null) {
+            clearTimeout(this.lastAccessFlushTimer);
+            this.lastAccessFlushTimer = null;
+        }
+        if (this.lastAccessFlushPromise) {
+            await this.lastAccessFlushPromise;
+            if (this.pendingLastAccessUpdates.size === 0) {
+                return;
+            }
+        }
+        if (this.pendingLastAccessUpdates.size === 0) {
+            return;
+        }
+        const updates = Array.from(this.pendingLastAccessUpdates, ([hashHex, lastAccess]) => ({ hashHex, lastAccess }));
+        this.pendingLastAccessUpdates.clear();
+        const pending = this.db.accesses
+            .bulkPut(updates)
+            .then(() => undefined)
+            .catch((e) => {
+            console.error('[DexieStore] lastAccess flush error:', e);
+        })
+            .finally(() => {
+            this.lastAccessFlushPromise = null;
+        });
+        this.lastAccessFlushPromise = pending;
+        await pending;
+        if (this.pendingLastAccessUpdates.size > 0) {
+            await this.flushPendingLastAccessUpdates();
+        }
+    }
     async put(hash, data) {
         const hashHex = toHex(hash);
+        const lastAccess = Date.now();
         try {
-            // Store directly - IDB will clone the data internally
-            await this.db.blobs.put({ hashHex, data, lastAccess: Date.now() });
+            await this.flushPendingLastAccessUpdates();
+            await this.db.transaction('rw', this.db.blobs, this.db.accesses, async () => {
+                // Store directly - IDB will clone the data internally
+                await this.db.blobs.put({ hashHex, data, lastAccess });
+                await this.db.accesses.put({ hashHex, lastAccess });
+            });
             return true;
         }
         catch (e) {
@@ -53,9 +117,8 @@ export class DexieStore {
             const entry = await this.db.blobs.get(hashHex);
             if (!entry)
                 return null;
-            // Update lastAccess timestamp for LRU tracking (fire-and-forget)
-            // We need to re-put the entry to avoid fake-indexeddb corruption issues with partial updates
-            this.db.blobs.put({ ...entry, lastAccess: Date.now() }).catch(() => { });
+            // Batch LRU touch updates so hot read paths stay read-heavy.
+            this.scheduleLastAccessTouch(hashHex);
             // Return directly - IDB returns a fresh copy already
             // Only slice if the view doesn't match the buffer (rare edge case)
             const data = entry.data;
@@ -85,9 +148,13 @@ export class DexieStore {
     async delete(hash) {
         const hashHex = toHex(hash);
         try {
+            await this.flushPendingLastAccessUpdates();
             const existed = await this.has(hash);
             if (existed) {
-                await this.db.blobs.delete(hashHex);
+                await this.db.transaction('rw', this.db.blobs, this.db.accesses, async () => {
+                    await this.db.blobs.delete(hashHex);
+                    await this.db.accesses.delete(hashHex);
+                });
                 return true;
             }
             return false;
@@ -116,7 +183,11 @@ export class DexieStore {
      */
     async clear() {
         try {
-            await this.db.blobs.clear();
+            await this.flushPendingLastAccessUpdates();
+            await this.db.transaction('rw', this.db.blobs, this.db.accesses, async () => {
+                await this.db.blobs.clear();
+                await this.db.accesses.clear();
+            });
         }
         catch (e) {
             console.error('[DexieStore] clear error:', e);
@@ -157,19 +228,24 @@ export class DexieStore {
      */
     async evict(maxBytes) {
         try {
+            await this.flushPendingLastAccessUpdates();
             const currentBytes = await this.totalBytes();
             if (currentBytes <= maxBytes)
                 return 0;
-            // Get entries sorted by lastAccess (oldest first)
-            const entries = await this.db.blobs.orderBy('lastAccess').toArray();
+            // Get entries sorted by lastAccess (oldest first) from the lightweight access table.
+            const entries = await this.db.accesses.orderBy('lastAccess').toArray();
             let bytesRemoved = 0;
             let entriesRemoved = 0;
             const targetRemoval = currentBytes - maxBytes;
             for (const entry of entries) {
                 if (bytesRemoved >= targetRemoval)
                     break;
-                await this.db.blobs.delete(entry.hashHex);
-                bytesRemoved += entry.data.byteLength;
+                const blob = await this.db.blobs.get(entry.hashHex);
+                await this.db.transaction('rw', this.db.blobs, this.db.accesses, async () => {
+                    await this.db.blobs.delete(entry.hashHex);
+                    await this.db.accesses.delete(entry.hashHex);
+                });
+                bytesRemoved += blob?.data.byteLength ?? 0;
                 entriesRemoved++;
             }
             console.log(`[DexieStore] Evicted ${entriesRemoved} entries (${bytesRemoved} bytes)`);
@@ -184,6 +260,11 @@ export class DexieStore {
      * Close the database connection
      */
     close() {
+        if (this.lastAccessFlushTimer !== null) {
+            clearTimeout(this.lastAccessFlushTimer);
+            this.lastAccessFlushTimer = null;
+        }
+        this.pendingLastAccessUpdates.clear();
         this.db.close();
     }
     /**

package/dist/index.test.js

@@ -212,6 +212,28 @@ describe('DexieStore', () => {
             expect(await store.has(hash2)).toBe(false);
             expect(await store.has(hash3)).toBe(true);
         });
+        it('should honor a recent get during eviction without waiting for background lastAccess writes', async () => {
+            const data1 = new Uint8Array(100);
+            const data2 = new Uint8Array(100);
+            const data3 = new Uint8Array(100);
+            data1[0] = 1;
+            data2[0] = 2;
+            data3[0] = 3;
+            const hash1 = makeHash(data1);
+            const hash2 = makeHash(data2);
+            const hash3 = makeHash(data3);
+            await store.put(hash1, data1);
+            await new Promise(r => setTimeout(r, 50));
+            await store.put(hash2, data2);
+            await new Promise(r => setTimeout(r, 50));
+            await store.put(hash3, data3);
+            await new Promise(r => setTimeout(r, 50));
+            await store.get(hash1);
+            await store.evict(200);
+            expect(await store.has(hash1)).toBe(true);
+            expect(await store.has(hash2)).toBe(false);
+            expect(await store.has(hash3)).toBe(true);
+        });
         it('should return 0 when store is empty', async () => {
             const evicted = await store.evict(100);
             expect(evicted).toBe(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hashtree/dexie",
-  "version": "0.1.1",
+  "version": "0.1.4",
   "description": "Dexie-based IndexedDB store for hashtree",
   "type": "module",
   "main": "dist/index.js",
@@ -25,11 +25,17 @@
   ],
   "author": "Martti Malmi",
   "license": "MIT",
+  "repository": "https://git.iris.to/#/npub1xdhnr9mrv47kkrn95k6cwecearydeh8e895990n3acntwvmgk2dsdeeycm/hashtree",
+  "homepage": "https://git.iris.to/#/npub1xdhnr9mrv47kkrn95k6cwecearydeh8e895990n3acntwvmgk2dsdeeycm/hashtree/ts/packages/hashtree-dexie",
+  "bugs": {
+    "url": "https://git.iris.to/#/npub1xdhnr9mrv47kkrn95k6cwecearydeh8e895990n3acntwvmgk2dsdeeycm/hashtree?tab=issues"
+  },
   "dependencies": {
     "dexie": "^4.2.1",
-    "@hashtree/core": "0.1.1"
+    "@hashtree/core": "0.1.4"
   },
   "devDependencies": {
+    "fake-indexeddb": "^6.2.5",
     "typescript": "^5.3.0",
     "vitest": "^2.0.0"
   },