@aztec/kv-store 0.0.1-commit.e3c1de76 → 0.0.1-commit.e57c76e

package/src/indexeddb/multi_map.ts

@@ -57,7 +57,7 @@ export class IndexedDBAztecMultiMap<K extends Key, V extends Value>
       false,
     );
     for await (const cursor of index.iterate(rangeQuery)) {
-      yield cursor.value.value as V;
+      yield this.restoreBuffers(cursor.value.value as V);
     }
   }
 
@@ -88,4 +88,18 @@ export class IndexedDBAztecMultiMap<K extends Key, V extends Value>
       await this.db.delete(fullKey);
     }
   }
+
+  override async delete(key: K): Promise<void> {
+    const index = this.db.index('keyCount');
+    const rangeQuery = IDBKeyRange.bound(
+      [this.container, this.normalizeKey(key), 0],
+      [this.container, this.normalizeKey(key), Number.MAX_SAFE_INTEGER],
+      false,
+      false,
+    );
+
+    for await (const cursor of index.iterate(rangeQuery)) {
+      await cursor.delete();
+    }
+  }
 }

package/src/indexeddb/singleton.ts

@@ -37,7 +37,7 @@ export class IndexedDBAztecSingleton<T extends Value> implements AztecAsyncSingl
     const result = await this.db.put({
       container: this.#container,
       slot: this.#slot,
-      key: this.#slot,
+      key: [this.#slot],
       keyCount: 1,
       value: val,
       hash: hash(val),

package/src/indexeddb/store.ts

@@ -20,7 +20,7 @@ import { IndexedDBAztecSingleton } from './singleton.js';
 export type StoredData<V extends Value> = {
   value: V;
   container: string;
-  key: string;
+  key: (string | number | Uint8Array)[];
   keyCount: number;
   slot: string;
   hash: string;
@@ -30,7 +30,12 @@ export interface AztecIDBSchema extends DBSchema {
   data: {
     value: StoredData<any>;
     key: string;
-    indexes: { container: string; key: string; keyCount: number; hash: string };
+    indexes: {
+      container: string;
+      key: any; // Runtime: (string | number | Uint8Array)[] - idb types don't support arrays
+      keyCount: number;
+      hash: string;
+    };
   };
 }
 
@@ -187,18 +192,20 @@ export class AztecIndexedDBStore implements AztecAsyncKVStore {
   }
 
   /** Deletes this store and removes the database */
-  delete() {
+  async delete() {
     this.#containers.clear();
+    await this.#txQueue.end();
     this.#rootDB.close();
-    return deleteDB(this.#name);
+    await deleteDB(this.#name);
   }
 
   estimateSize(): Promise<StoreSize> {
     return Promise.resolve({ mappingSize: 0, physicalFileSize: 0, actualSize: 0, numItems: 0 });
   }
 
-  close(): Promise<void> {
-    return Promise.resolve();
+  async close(): Promise<void> {
+    await this.#txQueue.end();
+    this.#rootDB.close();
   }
 
   backupTo(_dstPath: string, _compact?: boolean): Promise<void> {

package/src/interfaces/array_test_suite.ts

@@ -1,7 +1,5 @@
 import { toArray } from '@aztec/foundation/iterable';
 
-import { expect } from 'chai';
-
 import type { AztecArray, AztecAsyncArray } from './array.js';
 import type { AztecAsyncKVStore, AztecKVStore } from './store.js';
 import { isSyncStore } from './utils.js';
@@ -53,12 +51,12 @@ export function describeAztecArray(
       await arr.push(2);
       await arr.push(3);
 
-      expect(await length()).to.equal(3);
+      expect(await length()).toBe(3);
 
-      expect(await arr.pop()).to.equal(3);
-      expect(await arr.pop()).to.equal(2);
-      expect(await arr.pop()).to.equal(1);
-      expect(await arr.pop()).to.equal(undefined);
+      expect(await arr.pop()).toBe(3);
+      expect(await arr.pop()).toBe(2);
+      expect(await arr.pop()).toBe(1);
+      expect(await arr.pop()).toBe(undefined);
     });
 
     it('should be able to get values by index', async () => {
@@ -66,14 +64,14 @@ export function describeAztecArray(
       await arr.push(2);
       await arr.push(3);
 
-      expect(await at(0)).to.equal(1);
-      expect(await at(1)).to.equal(2);
-      expect(await at(2)).to.equal(3);
-      expect(await at(3)).to.equal(undefined);
-      expect(await at(-1)).to.equal(3);
-      expect(await at(-2)).to.equal(2);
-      expect(await at(-3)).to.equal(1);
-      expect(await at(-4)).to.equal(undefined);
+      expect(await at(0)).toBe(1);
+      expect(await at(1)).toBe(2);
+      expect(await at(2)).toBe(3);
+      expect(await at(3)).toBe(undefined);
+      expect(await at(-1)).toBe(3);
+      expect(await at(-2)).toBe(2);
+      expect(await at(-3)).toBe(1);
+      expect(await at(-4)).toBe(undefined);
     });
 
     it('should be able to set values by index', async () => {
@@ -81,27 +79,27 @@ export function describeAztecArray(
       await arr.push(2);
       await arr.push(3);
 
-      expect(await arr.setAt(0, 4)).to.equal(true);
-      expect(await arr.setAt(1, 5)).to.equal(true);
-      expect(await arr.setAt(2, 6)).to.equal(true);
+      expect(await arr.setAt(0, 4)).toBe(true);
+      expect(await arr.setAt(1, 5)).toBe(true);
+      expect(await arr.setAt(2, 6)).toBe(true);
 
-      expect(await arr.setAt(3, 7)).to.equal(false);
+      expect(await arr.setAt(3, 7)).toBe(false);
 
-      expect(await at(0)).to.equal(4);
-      expect(await at(1)).to.equal(5);
-      expect(await at(2)).to.equal(6);
-      expect(await at(3)).to.equal(undefined);
+      expect(await at(0)).toBe(4);
+      expect(await at(1)).toBe(5);
+      expect(await at(2)).toBe(6);
+      expect(await at(3)).toBe(undefined);
 
-      expect(await arr.setAt(-1, 8)).to.equal(true);
-      expect(await arr.setAt(-2, 9)).to.equal(true);
-      expect(await arr.setAt(-3, 10)).to.equal(true);
+      expect(await arr.setAt(-1, 8)).toBe(true);
+      expect(await arr.setAt(-2, 9)).toBe(true);
+      expect(await arr.setAt(-3, 10)).toBe(true);
 
-      expect(await arr.setAt(-4, 11)).to.equal(false);
+      expect(await arr.setAt(-4, 11)).toBe(false);
 
-      expect(await at(-1)).to.equal(8);
-      expect(await at(-2)).to.equal(9);
-      expect(await at(-3)).to.equal(10);
-      expect(await at(-4)).to.equal(undefined);
+      expect(await at(-1)).toBe(8);
+      expect(await at(-2)).toBe(9);
+      expect(await at(-3)).toBe(10);
+      expect(await at(-4)).toBe(undefined);
     });
 
     it('should be able to iterate over values', async () => {
@@ -109,8 +107,8 @@ export function describeAztecArray(
       await arr.push(2);
       await arr.push(3);
 
-      expect(await values()).to.deep.equal([1, 2, 3]);
-      expect(await entries()).to.deep.equal([
+      expect(await values()).toEqual([1, 2, 3]);
+      expect(await entries()).toEqual([
         [0, 1],
         [1, 2],
         [2, 3],
@@ -123,8 +121,8 @@ export function describeAztecArray(
       await arr.push(3);
 
       const arr2 = store.openArray<number>('test');
-      expect(await length(arr2)).to.equal(3);
-      expect(await values(arr2)).to.deep.equal(await values());
+      expect(await length(arr2)).toBe(3);
+      expect(await values(arr2)).toEqual(await values());
     });
   });
 }

package/src/interfaces/index.ts

@@ -6,4 +6,4 @@ export * from './store.js';
 export * from './set.js';
 export * from './multi_map.js';
 export { mapRange } from './common.js';
-export type { CustomRange, Range, StoreSize } from './common.js';
+export type { CustomRange, Key, Range, StoreSize } from './common.js';

package/src/interfaces/map_test_suite.ts

@@ -1,7 +1,5 @@
 import { toArray } from '@aztec/foundation/iterable';
 
-import { expect } from 'chai';
-
 import type { Key, Range } from './common.js';
 import type { AztecAsyncMap, AztecMap } from './map.js';
 import type { AztecAsyncKVStore, AztecKVStore } from './store.js';
@@ -59,9 +57,9 @@ export function describeAztecMap(
       await map.set('foo', 'bar');
       await map.set('baz', 'qux');
 
-      expect(await get('foo')).to.equal('bar');
-      expect(await get('baz')).to.equal('qux');
-      expect(await get('quux')).to.equal(undefined);
+      expect(await get('foo')).toBe('bar');
+      expect(await get('baz')).toBe('qux');
+      expect(await get('quux')).toBe(undefined);
     });
 
     it('should be able to set many values', async () => {
@@ -69,7 +67,7 @@ export function describeAztecMap(
       await map.setMany(pairs);
 
       for (const { key, value } of pairs) {
-        expect(await get(key)).to.equal(value);
+        expect(await get(key)).toBe(value);
       }
     });
 
@@ -77,14 +75,14 @@ export function describeAztecMap(
       await map.set('foo', 'bar');
       await map.set('foo', 'baz');
 
-      expect(await get('foo')).to.equal('baz');
+      expect(await get('foo')).toBe('baz');
     });
 
     it('should be able to set values if they do not exist', async () => {
-      expect(await map.setIfNotExists('foo', 'bar')).to.equal(true);
-      expect(await map.setIfNotExists('foo', 'baz')).to.equal(false);
+      expect(await map.setIfNotExists('foo', 'bar')).toBe(true);
+      expect(await map.setIfNotExists('foo', 'baz')).toBe(false);
 
-      expect(await get('foo')).to.equal('bar');
+      expect(await get('foo')).toBe('bar');
     });
 
     it('should be able to delete values', async () => {
@@ -93,29 +91,56 @@ export function describeAztecMap(
 
       await map.delete('foo');
 
-      expect(await get('foo')).to.equal(undefined);
-      expect(await get('baz')).to.equal('qux');
+      expect(await get('foo')).toBe(undefined);
+      expect(await get('baz')).toBe('qux');
     });
 
     it('should be able to return size of the map', async () => {
       await map.set('foo', 'bar');
-      expect(await size()).to.equal(1);
+      expect(await size()).toBe(1);
       await map.set('baz', 'qux');
-      expect(await size()).to.equal(2);
+      expect(await size()).toBe(2);
 
       await map.delete('foo');
-      expect(await size()).to.equal(1);
+      expect(await size()).toBe(1);
+    });
+
+    it('returns 0 for empty map size', async () => {
+      expect(await size()).toBe(0);
+    });
+
+    it('calculates size correctly across multiple operations', async () => {
+      expect(await size()).toBe(0);
+
+      // Add items
+      await map.set('a', 'value1');
+      await map.set('b', 'value2');
+      await map.set('c', 'value3');
+      expect(await size()).toBe(3);
+
+      // Update existing (size should not change)
+      await map.set('b', 'updated');
+      expect(await size()).toBe(3);
+
+      // Delete some
+      await map.delete('a');
+      expect(await size()).toBe(2);
+
+      // Delete all
+      await map.delete('b');
+      await map.delete('c');
+      expect(await size()).toBe(0);
     });
 
     it('should be able to iterate over entries when there are no keys', async () => {
-      expect(await entries()).to.deep.equal([]);
+      expect(await entries()).toEqual([]);
     });
 
     it('should be able to iterate over entries', async () => {
       await map.set('foo', 'bar');
       await map.set('baz', 'qux');
 
-      expect(await entries()).to.deep.equal([
+      expect(await entries()).toEqual([
         ['baz', 'qux'],
         ['foo', 'bar'],
       ]);
@@ -125,30 +150,31 @@ export function describeAztecMap(
       await map.set('foo', 'bar');
       await map.set('baz', 'quux');
 
-      expect(await values()).to.deep.equal(['quux', 'bar']);
+      expect(await values()).toEqual(['quux', 'bar']);
     });
 
     it('should be able to iterate over keys', async () => {
       await map.set('foo', 'bar');
       await map.set('baz', 'qux');
 
-      expect(await keys()).to.deep.equal(['baz', 'foo']);
+      expect(await keys()).toEqual(['baz', 'foo']);
     });
 
     it('should be able to iterate over string keys that represent numbers', async () => {
       await map.set('0x22', 'bar');
       await map.set('0x31', 'qux');
 
-      expect(await keys()).to.deep.equal(['0x22', '0x31']);
+      expect(await keys()).toEqual(['0x22', '0x31']);
     });
 
     for (const [name, data] of [
       ['chars', ['a', 'b', 'c', 'd']],
       ['numbers', [1, 2, 3, 4]],
-      // disabled because indexeddb sorts lexigographically
-      // ['negative numbers', [-4, -3, -2, -1]],
+      ['negative numbers', [-4, -3, -2, -1]],
       ['strings', ['aaa', 'bbb', 'ccc', 'ddd']],
       ['zero-based numbers', [0, 1, 2, 3]],
+      ['large numbers', [100, 999, 1000, 1001]],
+      ['mixed negative and positive', [-1000, -1, 1, 1000]],
     ]) {
       it(`supports range queries over ${name} keys`, async () => {
         const [a, b, c, d] = data;
@@ -158,14 +184,14 @@ export function describeAztecMap(
         await map.set(c, 'c');
         await map.set(d, 'd');
 
-        expect(await keys()).to.deep.equal([a, b, c, d]);
-        expect(await keys({ start: b, end: c })).to.deep.equal([b]);
-        expect(await keys({ start: b })).to.deep.equal([b, c, d]);
-        expect(await keys({ end: c })).to.deep.equal([a, b]);
-        expect(await keys({ start: b, end: c, reverse: true })).to.deep.equal([c]);
-        expect(await keys({ start: b, limit: 1 })).to.deep.equal([b]);
-        expect(await keys({ start: b, reverse: true })).to.deep.equal([d, c]);
-        expect(await keys({ end: b, reverse: true })).to.deep.equal([b, a]);
+        expect(await keys()).toEqual([a, b, c, d]);
+        expect(await keys({ start: b, end: c })).toEqual([b]);
+        expect(await keys({ start: b })).toEqual([b, c, d]);
+        expect(await keys({ end: c })).toEqual([a, b]);
+        expect(await keys({ start: b, end: c, reverse: true })).toEqual([c]);
+        expect(await keys({ start: b, limit: 1 })).toEqual([b]);
+        expect(await keys({ start: b, reverse: true })).toEqual([d, c]);
+        expect(await keys({ end: b, reverse: true })).toEqual([b, a]);
       });
     }
   });