@aztec/kv-store 0.0.1-commit.f504929 → 0.0.1-commit.f5a9928

package/src/{indexeddb → deprecated/indexeddb}/multi_map.ts

@@ -1,7 +1,9 @@
+import { first } from '@aztec/foundation/iterable';
+
 import { hash } from 'ohash';
 
-import type { Key, Value } from '../interfaces/common.js';
-import type { AztecAsyncMultiMap } from '../interfaces/multi_map.js';
+import type { Key, Value } from '../../interfaces/common.js';
+import type { AztecAsyncMultiMap } from '../../interfaces/multi_map.js';
 import { IndexedDBAztecMap } from './map.js';
 
 /**
@@ -35,7 +37,7 @@ export class IndexedDBAztecMultiMap<K extends Key, V extends Value>
     // Instead, we iterate in reverse order to get the last inserted entry
     const index = this.db.index('keyCount');
     const rangeQuery = IDBKeyRange.upperBound([this.container, this.normalizeKey(key), Number.MAX_SAFE_INTEGER]);
-    const maxEntry = (await index.iterate(rangeQuery, 'prevunique').next()).value;
+    const maxEntry = await first(index.iterate(rangeQuery, 'prevunique'));
     const count = maxEntry?.value?.keyCount ?? 0;
     await this.db.put({
       value: val,

package/src/{indexeddb → deprecated/indexeddb}/set.ts

@@ -1,7 +1,7 @@
 import type { IDBPDatabase, IDBPObjectStore } from 'idb';
 
-import type { Key, Range } from '../interfaces/common.js';
-import type { AztecAsyncSet } from '../interfaces/set.js';
+import type { Key, Range } from '../../interfaces/common.js';
+import type { AztecAsyncSet } from '../../interfaces/set.js';
 import { IndexedDBAztecMap } from './map.js';
 import type { AztecIDBSchema } from './store.js';
 

package/src/{indexeddb → deprecated/indexeddb}/singleton.ts

@@ -1,8 +1,8 @@
 import type { IDBPDatabase, IDBPObjectStore } from 'idb';
 import { hash } from 'ohash';
 
-import type { Value } from '../interfaces/common.js';
-import type { AztecAsyncSingleton } from '../interfaces/singleton.js';
+import type { Value } from '../../interfaces/common.js';
+import type { AztecAsyncSingleton } from '../../interfaces/singleton.js';
 import type { AztecIDBSchema } from './store.js';
 
 /**

package/src/{indexeddb → deprecated/indexeddb}/store.ts

@@ -3,14 +3,14 @@ import { SerialQueue } from '@aztec/foundation/queue';
 
 import { type DBSchema, type IDBPDatabase, deleteDB, openDB } from 'idb';
 
-import type { AztecAsyncArray } from '../interfaces/array.js';
-import type { Key, StoreSize, Value } from '../interfaces/common.js';
-import type { AztecAsyncCounter } from '../interfaces/counter.js';
-import type { AztecAsyncMap } from '../interfaces/map.js';
-import type { AztecAsyncMultiMap } from '../interfaces/multi_map.js';
-import type { AztecAsyncSet } from '../interfaces/set.js';
-import type { AztecAsyncSingleton } from '../interfaces/singleton.js';
-import type { AztecAsyncKVStore } from '../interfaces/store.js';
+import type { AztecAsyncArray } from '../../interfaces/array.js';
+import type { Key, StoreSize, Value } from '../../interfaces/common.js';
+import type { AztecAsyncCounter } from '../../interfaces/counter.js';
+import type { AztecAsyncMap } from '../../interfaces/map.js';
+import type { AztecAsyncMultiMap } from '../../interfaces/multi_map.js';
+import type { AztecAsyncSet } from '../../interfaces/set.js';
+import type { AztecAsyncSingleton } from '../../interfaces/singleton.js';
+import type { AztecAsyncKVStore } from '../../interfaces/store.js';
 import { IndexedDBAztecArray } from './array.js';
 import { IndexedDBAztecMap } from './map.js';
 import { IndexedDBAztecMultiMap } from './multi_map.js';
@@ -41,8 +41,9 @@ export interface AztecIDBSchema extends DBSchema {
 
 /**
  * A key-value store backed by IndexedDB.
+ *
+ * @deprecated The IndexedDB backend is being retired. Use `@aztec/kv-store/sqlite-opfs` instead.
  */
-
 export class AztecIndexedDBStore implements AztecAsyncKVStore {
   #rootDB: IDBPDatabase<AztecIDBSchema>;
   #name: string;

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,56 +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()).to.equal(0);
+      expect(await size()).toBe(0);
     });
 
     it('calculates size correctly across multiple operations', async () => {
-      expect(await size()).to.equal(0);
+      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()).to.equal(3);
+      expect(await size()).toBe(3);
 
       // Update existing (size should not change)
       await map.set('b', 'updated');
-      expect(await size()).to.equal(3);
+      expect(await size()).toBe(3);
 
       // Delete some
       await map.delete('a');
-      expect(await size()).to.equal(2);
+      expect(await size()).toBe(2);
 
       // Delete all
       await map.delete('b');
       await map.delete('c');
-      expect(await size()).to.equal(0);
+      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'],
       ]);
@@ -152,21 +150,21 @@ 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 [
@@ -186,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]);
       });
     }
   });