xitdb 0.8.0 → 0.9.0

package/README.md

@@ -59,27 +59,27 @@ const history = await WriteArrayList.create(db.rootCursor());
 await history.appendContext(await history.getSlot(-1), async (cursor) => {
   const moment = await WriteHashMap.create(cursor);
 
-  await moment.putByString('foo', new Bytes('foo'));
-  await moment.putByString('bar', new Bytes('bar'));
+  await moment.put('foo', new Bytes('foo'));
+  await moment.put('bar', new Bytes('bar'));
 
-  const fruitsCursor = await moment.putCursorByString('fruits');
+  const fruitsCursor = await moment.putCursor('fruits');
   const fruits = await WriteArrayList.create(fruitsCursor);
   await fruits.append(new Bytes('apple'));
   await fruits.append(new Bytes('pear'));
   await fruits.append(new Bytes('grape'));
 
-  const peopleCursor = await moment.putCursorByString('people');
+  const peopleCursor = await moment.putCursor('people');
   const people = await WriteArrayList.create(peopleCursor);
 
   const aliceCursor = await people.appendCursor();
   const alice = await WriteHashMap.create(aliceCursor);
-  await alice.putByString('name', new Bytes('Alice'));
-  await alice.putByString('age', new Uint(25));
+  await alice.put('name', new Bytes('Alice'));
+  await alice.put('age', new Uint(25));
 
   const bobCursor = await people.appendCursor();
   const bob = await WriteHashMap.create(bobCursor);
-  await bob.putByString('name', new Bytes('Bob'));
-  await bob.putByString('age', new Uint(42));
+  await bob.put('name', new Bytes('Bob'));
+  await bob.put('age', new Uint(42));
 });
 
 // get the most recent copy of the database, like a moment
@@ -89,13 +89,13 @@ const moment = await ReadHashMap.create(momentCursor!);
 
 // we can read the value of "foo" from the map by getting
 // the cursor to "foo" and then calling readBytes on it
-const fooCursor = await moment.getCursorByString('foo');
+const fooCursor = await moment.getCursor('foo');
 const fooValue = await fooCursor!.readBytes(MAX_READ_BYTES);
 expect(new TextDecoder().decode(fooValue)).toBe('foo');
 
 // to get the "fruits" list, we get the cursor to it and
 // then pass it to the ReadArrayList constructor
-const fruitsCursor = await moment.getCursorByString('fruits');
+const fruitsCursor = await moment.getCursor('fruits');
 const fruits = new ReadArrayList(fruitsCursor!);
 expect(await fruits.count()).toBe(3);
 
@@ -143,13 +143,13 @@ In xitdb, you can optionally store a format tag with a byte array. A format tag
 ```typescript
 const randomBytes = new Uint8Array(32);
 crypto.getRandomValues(randomBytes);
-await moment.putByString('random-number', new Bytes(randomBytes, new TextEncoder().encode('bi')));
+await moment.put('random-number', new Bytes(randomBytes, new TextEncoder().encode('bi')));
 ```
 
 Then, you can read it like this:
 
 ```typescript
-const randomNumberCursor = await moment.getCursorByString('random-number');
+const randomNumberCursor = await moment.getCursor('random-number');
 const randomNumber = await randomNumberCursor!.readBytesObject(MAX_READ_BYTES);
 expect(new TextDecoder().decode(randomNumber.formatTag!)).toBe('bi');
 const randomBigInt = randomNumber.value;
@@ -165,12 +165,12 @@ A powerful feature of immutable data is fast cloning. Any data structure can be
 await history.appendContext(await history.getSlot(-1), async (cursor) => {
   const moment = await WriteHashMap.create(cursor);
 
-  const fruitsCursor = await moment.getCursorByString('fruits');
+  const fruitsCursor = await moment.getCursor('fruits');
   const fruits = new ReadArrayList(fruitsCursor!);
 
   // create a new key called "food" whose initial value is
   // based on the "fruits" list
-  const foodCursor = await moment.putCursorByString('food');
+  const foodCursor = await moment.putCursor('food');
   await foodCursor.write(fruits.slot());
 
   const food = await WriteArrayList.create(foodCursor);
@@ -183,12 +183,12 @@ const momentCursor = await history.getCursor(-1);
 const moment = await ReadHashMap.create(momentCursor!);
 
 // the food list includes the fruits
-const foodCursor = await moment.getCursorByString('food');
+const foodCursor = await moment.getCursor('food');
 const food = new ReadArrayList(foodCursor!);
 expect(await food.count()).toBe(6);
 
 // ...but the fruits list hasn't been changed
-const fruitsCursor = await moment.getCursorByString('fruits');
+const fruitsCursor = await moment.getCursor('fruits');
 const fruits = new ReadArrayList(fruitsCursor!);
 expect(await fruits.count()).toBe(3);
 ```
@@ -205,14 +205,14 @@ There's one catch you'll run into when cloning. If we try cloning a data structu
 await history.appendContext(await history.getSlot(-1), async (cursor) => {
   const moment = await WriteHashMap.create(cursor);
 
-  const bigCitiesCursor = await moment.putCursorByString('big-cities');
+  const bigCitiesCursor = await moment.putCursor('big-cities');
   const bigCities = await WriteArrayList.create(bigCitiesCursor);
   await bigCities.append(new Bytes('New York, NY'));
   await bigCities.append(new Bytes('Los Angeles, CA'));
 
   // create a new key called "cities" whose initial value is
   // based on the "big-cities" list
-  const citiesCursor = await moment.putCursorByString('cities');
+  const citiesCursor = await moment.putCursor('cities');
   await citiesCursor.write(bigCities.slot());
 
   const cities = await WriteArrayList.create(citiesCursor);
@@ -224,12 +224,12 @@ const momentCursor = await history.getCursor(-1);
 const moment = await ReadHashMap.create(momentCursor!);
 
 // the cities list contains all four
-const citiesCursor = await moment.getCursorByString('cities');
+const citiesCursor = await moment.getCursor('cities');
 const cities = new ReadArrayList(citiesCursor!);
 expect(await cities.count()).toBe(4);
 
 // ..but so does big-cities! we did not intend to mutate this
-const bigCitiesCursor = await moment.getCursorByString('big-cities');
+const bigCitiesCursor = await moment.getCursor('big-cities');
 const bigCities = new ReadArrayList(bigCitiesCursor!);
 expect(await bigCities.count()).toBe(4);
 ```
@@ -248,7 +248,7 @@ This time, after making the "big cities" list, we call `freeze`, which tells xit
 await history.appendContext(await history.getSlot(-1), async (cursor) => {
   const moment = await WriteHashMap.create(cursor);
 
-  const bigCitiesCursor = await moment.putCursorByString('big-cities');
+  const bigCitiesCursor = await moment.putCursor('big-cities');
   const bigCities = await WriteArrayList.create(bigCitiesCursor);
   await bigCities.append(new Bytes('New York, NY'));
   await bigCities.append(new Bytes('Los Angeles, CA'));
@@ -258,7 +258,7 @@ await history.appendContext(await history.getSlot(-1), async (cursor) => {
 
   // create a new key called "cities" whose initial value is
   // based on the "big-cities" list
-  const citiesCursor = await moment.putCursorByString('cities');
+  const citiesCursor = await moment.putCursor('cities');
   await citiesCursor.write(bigCities.slot());
 
   const cities = await WriteArrayList.create(citiesCursor);
@@ -270,12 +270,12 @@ const momentCursor = await history.getCursor(-1);
 const moment = await ReadHashMap.create(momentCursor!);
 
 // the cities list contains all four
-const citiesCursor = await moment.getCursorByString('cities');
+const citiesCursor = await moment.getCursor('cities');
 const cities = new ReadArrayList(citiesCursor!);
 expect(await cities.count()).toBe(4);
 
 // and big-cities only contains the original two
-const bigCitiesCursor = await moment.getCursorByString('big-cities');
+const bigCitiesCursor = await moment.getCursor('big-cities');
 const bigCities = new ReadArrayList(bigCitiesCursor!);
 expect(await bigCities.count()).toBe(2);
 ```
@@ -285,7 +285,7 @@ expect(await bigCities.count()).toBe(2);
 When reading and writing large byte arrays, you probably don't want to have all of their contents in memory at once. To incrementally write to a byte array, just get a writer from a cursor:
 
 ```typescript
-const longTextCursor = await moment.putCursorByString('long-text');
+const longTextCursor = await moment.putCursor('long-text');
 const cursorWriter = await longTextCursor.writer();
 for (let i = 0; i < 50; i++) {
   await cursorWriter.write(new TextEncoder().encode('hello, world\n'));
@@ -298,7 +298,7 @@ If you need to set a format tag for the byte array, put it in the `formatTag` fi
 To read a byte array incrementally, get a reader from a cursor:
 
 ```typescript
-const longTextCursor = await moment.getCursorByString('long-text');
+const longTextCursor = await moment.getCursor('long-text');
 const cursorReader = await longTextCursor!.reader();
 let lineCount = 0, line: number[] = [];
 const buf = new Uint8Array(1024);
@@ -317,7 +317,7 @@ expect(lineCount).toBe(50);
 All data structures support iteration. Here's an example of iterating over an `ArrayList` and printing all of the keys and values of each `HashMap` contained in it:
 
 ```typescript
-const peopleCursor = await moment.getCursorByString('people');
+const peopleCursor = await moment.getCursor('people');
 const people = new ReadArrayList(peopleCursor!);
 
 const peopleIter = await people.iterator();
@@ -356,7 +356,7 @@ The iteration of the `HashMap` looks the same with `HashSet`, `CountedHashMap`,
 
 ## Hashing
 
-The hashing data structures will create the hash for you when you call methods like `putByString` or `getCursorByString` and provide the key as a string. If you want to do the hashing yourself, there are methods like `put` and `getCursor` that take a `Uint8Array` as the key, which should be the hash that you computed.
+The hashing data structures will create the hash for you when you call methods like `put` or `getCursor` and provide the key as a string or `Bytes`. If you want to do the hashing yourself, there is an overload of those methods that take a `Uint8Array` as the key, which should be the hash that you computed.
 
 When initializing a database, you tell xitdb how to hash with the `Hasher`. If you're using SHA-1, it will look like this:
 

package/dist/index.js

@@ -3243,59 +3243,24 @@ class ReadHashMap {
   async* [Symbol.asyncIterator]() {
     yield* this.cursor;
   }
-  async getCursorByString(key) {
-    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-    return this.getCursor(hash);
-  }
-  async getSlotByString(key) {
-    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-    return this.getSlot(hash);
-  }
-  async getKeyCursorByString(key) {
-    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-    return this.getKeyCursor(hash);
-  }
-  async getKeySlotByString(key) {
-    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-    return this.getKeySlot(hash);
-  }
-  async getKeyValuePairByString(key) {
-    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-    return this.getKeyValuePair(hash);
-  }
-  async getCursorByBytes(key) {
-    const hash = await this.cursor.db.hasher.digest(key.value);
-    return this.getCursor(hash);
-  }
-  async getSlotByBytes(key) {
-    const hash = await this.cursor.db.hasher.digest(key.value);
-    return this.getSlot(hash);
-  }
-  async getKeyCursorByBytes(key) {
-    const hash = await this.cursor.db.hasher.digest(key.value);
-    return this.getKeyCursor(hash);
-  }
-  async getKeySlotByBytes(key) {
-    const hash = await this.cursor.db.hasher.digest(key.value);
-    return this.getKeySlot(hash);
-  }
-  async getKeyValuePairByBytes(key) {
-    const hash = await this.cursor.db.hasher.digest(key.value);
-    return this.getKeyValuePair(hash);
-  }
-  async getCursor(hash) {
+  async getCursor(key) {
+    const hash = await this.resolveHash(key);
     return this.cursor.readPath([new HashMapGet(new HashMapGetValue(hash))]);
   }
-  async getSlot(hash) {
+  async getSlot(key) {
+    const hash = await this.resolveHash(key);
     return this.cursor.readPathSlot([new HashMapGet(new HashMapGetValue(hash))]);
   }
-  async getKeyCursor(hash) {
+  async getKeyCursor(key) {
+    const hash = await this.resolveHash(key);
     return this.cursor.readPath([new HashMapGet(new HashMapGetKey(hash))]);
   }
-  async getKeySlot(hash) {
+  async getKeySlot(key) {
+    const hash = await this.resolveHash(key);
     return this.cursor.readPathSlot([new HashMapGet(new HashMapGetKey(hash))]);
   }
-  async getKeyValuePair(hash) {
+  async getKeyValuePair(key) {
+    const hash = await this.resolveHash(key);
     const cursor = await this.cursor.readPath([new HashMapGet(new HashMapGetKVPair(hash))]);
     if (cursor === null) {
       return null;
@@ -3303,6 +3268,15 @@ class ReadHashMap {
       return cursor.readKeyValuePair();
     }
   }
+  async resolveHash(key) {
+    if (key instanceof Uint8Array) {
+      return key;
+    } else if (typeof key === "string") {
+      return this.cursor.db.hasher.digest(new TextEncoder().encode(key));
+    } else {
+      return this.cursor.db.hasher.digest(key.value);
+    }
+  }
 }
 // src/write-hash-map.ts
 class WriteHashMap extends ReadHashMap {
@@ -3321,83 +3295,74 @@ class WriteHashMap extends ReadHashMap {
   async* [Symbol.asyncIterator]() {
     yield* this.cursor;
   }
-  async putByString(key, data) {
-    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-    await this.putKey(hash, new Bytes(key));
-    await this.put(hash, data);
-  }
-  async putCursorByString(key) {
-    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-    await this.putKey(hash, new Bytes(key));
-    return this.putCursor(hash);
-  }
-  async putKeyByString(key, data) {
-    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-    await this.putKey(hash, data);
-  }
-  async putKeyCursorByString(key) {
-    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-    return this.putKeyCursor(hash);
-  }
-  async removeByString(key) {
-    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-    return this.remove(hash);
-  }
-  async putByBytes(key, data) {
-    const hash = await this.cursor.db.hasher.digest(key.value);
-    await this.putKey(hash, key);
-    await this.put(hash, data);
-  }
-  async putCursorByBytes(key) {
-    const hash = await this.cursor.db.hasher.digest(key.value);
-    await this.putKey(hash, key);
-    return this.putCursor(hash);
+  async put(key, data) {
+    if (typeof key === "string") {
+      const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
+      await this.putKeyInternal(hash, new Bytes(key));
+      await this.putInternal(hash, data);
+    } else if (key instanceof Bytes) {
+      const hash = await this.cursor.db.hasher.digest(key.value);
+      await this.putKeyInternal(hash, key);
+      await this.putInternal(hash, data);
+    } else {
+      await this.putInternal(key, data);
+    }
+  }
+  async putCursor(key) {
+    if (typeof key === "string") {
+      const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
+      await this.putKeyInternal(hash, new Bytes(key));
+      return this.putCursorInternal(hash);
+    } else if (key instanceof Bytes) {
+      const hash = await this.cursor.db.hasher.digest(key.value);
+      await this.putKeyInternal(hash, key);
+      return this.putCursorInternal(hash);
+    } else {
+      return this.putCursorInternal(key);
+    }
   }
-  async putKeyByBytes(key, data) {
-    const hash = await this.cursor.db.hasher.digest(key.value);
-    await this.putKey(hash, data);
+  async putKey(key, data) {
+    const hash = await this.resolveHash(key);
+    await this.putKeyInternal(hash, data);
   }
-  async putKeyCursorByBytes(key) {
-    const hash = await this.cursor.db.hasher.digest(key.value);
-    return this.putKeyCursor(hash);
+  async putKeyCursor(key) {
+    const hash = await this.resolveHash(key);
+    return this.putKeyCursorInternal(hash);
   }
-  async removeByBytes(key) {
-    const hash = await this.cursor.db.hasher.digest(key.value);
-    return this.remove(hash);
+  async remove(key) {
+    const hash = await this.resolveHash(key);
+    try {
+      await this.cursor.writePath([new HashMapRemove(hash)]);
+    } catch (e) {
+      if (e instanceof KeyNotFoundException) {
+        return false;
+      }
+      throw e;
+    }
+    return true;
   }
-  async put(hash, data) {
+  async putInternal(hash, data) {
     await this.cursor.writePath([
       new HashMapGet(new HashMapGetValue(hash)),
       new WriteData(data)
     ]);
   }
-  async putCursor(hash) {
+  async putCursorInternal(hash) {
     return this.cursor.writePath([
       new HashMapGet(new HashMapGetValue(hash))
     ]);
   }
-  async putKey(hash, data) {
+  async putKeyInternal(hash, data) {
     const cursor = await this.cursor.writePath([
       new HashMapGet(new HashMapGetKey(hash))
     ]);
     await cursor.writeIfEmpty(data);
   }
-  async putKeyCursor(hash) {
+  async putKeyCursorInternal(hash) {
     return this.cursor.writePath([
       new HashMapGet(new HashMapGetKey(hash))
     ]);
   }
-  async remove(hash) {
-    try {
-      await this.cursor.writePath([new HashMapRemove(hash)]);
-    } catch (e) {
-      if (e instanceof KeyNotFoundException) {
-        return false;
-      }
-      throw e;
-    }
-    return true;
-  }
 }
 // src/read-hash-set.ts
 class ReadHashSet {
@@ -3425,28 +3390,23 @@ class ReadHashSet {
   async* [Symbol.asyncIterator]() {
     yield* this.cursor;
   }
-  async getCursorByString(key) {
-    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-    return this.getCursor(hash);
-  }
-  async getSlotByString(key) {
-    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-    return this.getSlot(hash);
-  }
-  async getCursorByBytes(key) {
-    const hash = await this.cursor.db.hasher.digest(key.value);
-    return this.getCursor(hash);
-  }
-  async getSlotByBytes(key) {
-    const hash = await this.cursor.db.hasher.digest(key.value);
-    return this.getSlot(hash);
-  }
-  async getCursor(hash) {
+  async getCursor(key) {
+    const hash = await this.resolveHash(key);
     return this.cursor.readPath([new HashMapGet(new HashMapGetKey(hash))]);
   }
-  async getSlot(hash) {
+  async getSlot(key) {
+    const hash = await this.resolveHash(key);
     return this.cursor.readPathSlot([new HashMapGet(new HashMapGetKey(hash))]);
   }
+  async resolveHash(key) {
+    if (key instanceof Uint8Array) {
+      return key;
+    } else if (typeof key === "string") {
+      return this.cursor.db.hasher.digest(new TextEncoder().encode(key));
+    } else {
+      return this.cursor.db.hasher.digest(key.value);
+    }
+  }
 }
 // src/write-hash-set.ts
 class WriteHashSet extends ReadHashSet {
@@ -3465,43 +3425,24 @@ class WriteHashSet extends ReadHashSet {
   async* [Symbol.asyncIterator]() {
     yield* this.cursor;
   }
-  async putByString(key) {
-    const bytes = new TextEncoder().encode(key);
-    const hash = await this.cursor.db.hasher.digest(bytes);
-    await this.put(hash, new Bytes(bytes));
-  }
-  async putCursorByString(key) {
-    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-    return this.putCursor(hash);
-  }
-  async removeByString(key) {
-    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-    return this.remove(hash);
-  }
-  async putByBytes(key) {
-    const hash = await this.cursor.db.hasher.digest(key.value);
-    await this.put(hash, key);
-  }
-  async putCursorByBytes(key) {
-    const hash = await this.cursor.db.hasher.digest(key.value);
-    return this.putCursor(hash);
-  }
-  async removeByBytes(key) {
-    const hash = await this.cursor.db.hasher.digest(key.value);
-    return this.remove(hash);
-  }
-  async put(hash, data) {
-    const cursor = await this.cursor.writePath([
-      new HashMapGet(new HashMapGetKey(hash))
-    ]);
-    await cursor.writeIfEmpty(data);
+  async put(key, data) {
+    if (typeof key === "string") {
+      const bytes = new TextEncoder().encode(key);
+      const hash = await this.cursor.db.hasher.digest(bytes);
+      await this.putInternal(hash, new Bytes(bytes));
+    } else if (key instanceof Bytes) {
+      const hash = await this.cursor.db.hasher.digest(key.value);
+      await this.putInternal(hash, key);
+    } else {
+      await this.putInternal(key, data);
+    }
   }
-  async putCursor(hash) {
-    return this.cursor.writePath([
-      new HashMapGet(new HashMapGetKey(hash))
-    ]);
+  async putCursor(key) {
+    const hash = await this.resolveHash(key);
+    return this.putCursorInternal(hash);
   }
-  async remove(hash) {
+  async remove(key) {
+    const hash = await this.resolveHash(key);
     try {
       await this.cursor.writePath([new HashMapRemove(hash)]);
     } catch (e) {
@@ -3512,6 +3453,17 @@ class WriteHashSet extends ReadHashSet {
     }
     return true;
   }
+  async putInternal(hash, data) {
+    const cursor = await this.cursor.writePath([
+      new HashMapGet(new HashMapGetKey(hash))
+    ]);
+    await cursor.writeIfEmpty(data);
+  }
+  async putCursorInternal(hash) {
+    return this.cursor.writePath([
+      new HashMapGet(new HashMapGetKey(hash))
+    ]);
+  }
 }
 // src/read-linked-array-list.ts
 class ReadLinkedArrayList {

package/dist/read-hash-map.d.ts

@@ -9,19 +9,20 @@ export declare class ReadHashMap implements Slotted {
     slot(): Slot;
     iterator(): Promise<CursorIterator>;
     [Symbol.asyncIterator](): AsyncIterator<ReadCursor>;
-    getCursorByString(key: string): Promise<ReadCursor | null>;
-    getSlotByString(key: string): Promise<Slot | null>;
-    getKeyCursorByString(key: string): Promise<ReadCursor | null>;
-    getKeySlotByString(key: string): Promise<Slot | null>;
-    getKeyValuePairByString(key: string): Promise<KeyValuePairCursor | null>;
-    getCursorByBytes(key: Bytes): Promise<ReadCursor | null>;
-    getSlotByBytes(key: Bytes): Promise<Slot | null>;
-    getKeyCursorByBytes(key: Bytes): Promise<ReadCursor | null>;
-    getKeySlotByBytes(key: Bytes): Promise<Slot | null>;
-    getKeyValuePairByBytes(key: Bytes): Promise<KeyValuePairCursor | null>;
+    getCursor(key: string): Promise<ReadCursor | null>;
+    getCursor(key: Bytes): Promise<ReadCursor | null>;
     getCursor(hash: Uint8Array): Promise<ReadCursor | null>;
+    getSlot(key: string): Promise<Slot | null>;
+    getSlot(key: Bytes): Promise<Slot | null>;
     getSlot(hash: Uint8Array): Promise<Slot | null>;
+    getKeyCursor(key: string): Promise<ReadCursor | null>;
+    getKeyCursor(key: Bytes): Promise<ReadCursor | null>;
     getKeyCursor(hash: Uint8Array): Promise<ReadCursor | null>;
+    getKeySlot(key: string): Promise<Slot | null>;
+    getKeySlot(key: Bytes): Promise<Slot | null>;
     getKeySlot(hash: Uint8Array): Promise<Slot | null>;
+    getKeyValuePair(key: string): Promise<KeyValuePairCursor | null>;
+    getKeyValuePair(key: Bytes): Promise<KeyValuePairCursor | null>;
     getKeyValuePair(hash: Uint8Array): Promise<KeyValuePairCursor | null>;
+    protected resolveHash(key: string | Bytes | Uint8Array): Promise<Uint8Array>;
 }

package/dist/read-hash-set.d.ts

@@ -9,10 +9,11 @@ export declare class ReadHashSet implements Slotted {
     slot(): Slot;
     iterator(): Promise<CursorIterator>;
     [Symbol.asyncIterator](): AsyncIterator<ReadCursor>;
-    getCursorByString(key: string): Promise<ReadCursor | null>;
-    getSlotByString(key: string): Promise<Slot | null>;
-    getCursorByBytes(key: Bytes): Promise<ReadCursor | null>;
-    getSlotByBytes(key: Bytes): Promise<Slot | null>;
+    getCursor(key: string): Promise<ReadCursor | null>;
+    getCursor(key: Bytes): Promise<ReadCursor | null>;
     getCursor(hash: Uint8Array): Promise<ReadCursor | null>;
+    getSlot(key: string): Promise<Slot | null>;
+    getSlot(key: Bytes): Promise<Slot | null>;
     getSlot(hash: Uint8Array): Promise<Slot | null>;
+    protected resolveHash(key: string | Bytes | Uint8Array): Promise<Uint8Array>;
 }

package/dist/write-hash-map.d.ts

@@ -7,19 +7,23 @@ export declare class WriteHashMap extends ReadHashMap {
     static create(cursor: WriteCursor): Promise<WriteHashMap>;
     iterator(): Promise<WriteCursorIterator>;
     [Symbol.asyncIterator](): AsyncIterator<WriteCursor>;
-    putByString(key: string, data: WriteableData): Promise<void>;
-    putCursorByString(key: string): Promise<WriteCursor>;
-    putKeyByString(key: string, data: WriteableData): Promise<void>;
-    putKeyCursorByString(key: string): Promise<WriteCursor>;
-    removeByString(key: string): Promise<boolean>;
-    putByBytes(key: Bytes, data: WriteableData): Promise<void>;
-    putCursorByBytes(key: Bytes): Promise<WriteCursor>;
-    putKeyByBytes(key: Bytes, data: WriteableData): Promise<void>;
-    putKeyCursorByBytes(key: Bytes): Promise<WriteCursor>;
-    removeByBytes(key: Bytes): Promise<boolean>;
+    put(key: string, data: WriteableData): Promise<void>;
+    put(key: Bytes, data: WriteableData): Promise<void>;
     put(hash: Uint8Array, data: WriteableData): Promise<void>;
+    putCursor(key: string): Promise<WriteCursor>;
+    putCursor(key: Bytes): Promise<WriteCursor>;
     putCursor(hash: Uint8Array): Promise<WriteCursor>;
+    putKey(key: string, data: WriteableData): Promise<void>;
+    putKey(key: Bytes, data: WriteableData): Promise<void>;
     putKey(hash: Uint8Array, data: WriteableData): Promise<void>;
+    putKeyCursor(key: string): Promise<WriteCursor>;
+    putKeyCursor(key: Bytes): Promise<WriteCursor>;
     putKeyCursor(hash: Uint8Array): Promise<WriteCursor>;
+    remove(key: string): Promise<boolean>;
+    remove(key: Bytes): Promise<boolean>;
     remove(hash: Uint8Array): Promise<boolean>;
+    private putInternal;
+    private putCursorInternal;
+    private putKeyInternal;
+    private putKeyCursorInternal;
 }

package/dist/write-hash-set.d.ts

@@ -7,13 +7,15 @@ export declare class WriteHashSet extends ReadHashSet {
     static create(cursor: WriteCursor): Promise<WriteHashSet>;
     iterator(): Promise<WriteCursorIterator>;
     [Symbol.asyncIterator](): AsyncIterator<WriteCursor>;
-    putByString(key: string): Promise<void>;
-    putCursorByString(key: string): Promise<WriteCursor>;
-    removeByString(key: string): Promise<boolean>;
-    putByBytes(key: Bytes): Promise<void>;
-    putCursorByBytes(key: Bytes): Promise<WriteCursor>;
-    removeByBytes(key: Bytes): Promise<boolean>;
+    put(key: string): Promise<void>;
+    put(key: Bytes): Promise<void>;
     put(hash: Uint8Array, data: WriteableData): Promise<void>;
+    putCursor(key: string): Promise<WriteCursor>;
+    putCursor(key: Bytes): Promise<WriteCursor>;
     putCursor(hash: Uint8Array): Promise<WriteCursor>;
+    remove(key: string): Promise<boolean>;
+    remove(key: Bytes): Promise<boolean>;
     remove(hash: Uint8Array): Promise<boolean>;
+    private putInternal;
+    private putCursorInternal;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xitdb",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "An immutable database",
   "license": "MIT",
   "repository": {