@lodestar/db 1.35.0-dev.f80d2d52da → 1.35.0-dev.fd1dac853d

package/src/controller/level.ts

@@ -0,0 +1,246 @@
+import {ClassicLevel} from "classic-level";
+import {Logger} from "@lodestar/utils";
+import {DatabaseController, DatabaseOptions, DbReqOpts, FilterOptions, KeyValue} from "./interface.js";
+import {LevelDbControllerMetrics} from "./metrics.js";
+
+enum Status {
+  started = "started",
+  closed = "closed",
+}
+
+export interface LevelDBOptions extends DatabaseOptions {
+  db?: ClassicLevel<Uint8Array, Uint8Array>;
+}
+
+export type LevelDbControllerModules = {
+  logger: Logger;
+  metrics?: LevelDbControllerMetrics | null;
+};
+
+const BUCKET_ID_UNKNOWN = "unknown";
+
+/** Time between capturing metric for db size, every few minutes is sufficient */
+const DB_SIZE_METRIC_INTERVAL_MS = 5 * 60 * 1000;
+
+/**
+ * The LevelDB implementation of DB
+ */
+export class LevelDbController implements DatabaseController<Uint8Array, Uint8Array> {
+  private status = Status.started;
+
+  private dbSizeMetricInterval?: NodeJS.Timeout;
+
+  constructor(
+    private readonly logger: Logger,
+    private readonly db: ClassicLevel<Uint8Array, Uint8Array>,
+    private metrics: LevelDbControllerMetrics | null
+  ) {
+    this.metrics = metrics ?? null;
+
+    if (this.metrics) {
+      this.collectDbSizeMetric();
+    }
+  }
+
+  static async create(opts: LevelDBOptions, {metrics, logger}: LevelDbControllerModules): Promise<LevelDbController> {
+    const db =
+      opts.db ||
+      new ClassicLevel(opts.name || "beaconchain", {
+        keyEncoding: "binary",
+        valueEncoding: "binary",
+        multithreading: true,
+      });
+
+    try {
+      await db.open();
+    } catch (e) {
+      if ((e as LevelDbError).cause?.code === "LEVEL_LOCKED") {
+        throw new Error("Database already in use by another process");
+      }
+      throw e;
+    }
+
+    return new LevelDbController(logger, db, metrics ?? null);
+  }
+
+  async close(): Promise<void> {
+    if (this.status === Status.closed) return;
+    this.status = Status.closed;
+
+    if (this.dbSizeMetricInterval) {
+      clearInterval(this.dbSizeMetricInterval);
+    }
+
+    await this.db.close();
+  }
+
+  /** To inject metrics after CLI initialization */
+  setMetrics(metrics: LevelDbControllerMetrics): void {
+    if (this.metrics !== null) {
+      throw Error("metrics can only be set once");
+    }
+
+    this.metrics = metrics;
+    if (this.status === Status.started) {
+      this.collectDbSizeMetric();
+    }
+  }
+
+  async clear(): Promise<void> {
+    await this.db.clear();
+  }
+
+  async get(key: Uint8Array, opts?: DbReqOpts): Promise<Uint8Array | null> {
+    try {
+      this.metrics?.dbReadReq.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, 1);
+      this.metrics?.dbReadItems.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, 1);
+      return (await this.db.get(key)) as Uint8Array | null;
+    } catch (e) {
+      if ((e as LevelDbError).code === "LEVEL_NOT_FOUND") {
+        return null;
+      }
+      throw e;
+    }
+  }
+
+  /**
+   * Return the multiple items in the order of the given keys
+   * Will return `null` for the keys which does not exists
+   *
+   * https://github.com/Level/abstract-level?tab=readme-ov-file#dbgetmanykeys-options
+   */
+  async getMany(keys: Uint8Array[], opts?: DbReqOpts): Promise<(Uint8Array | undefined)[]> {
+    this.metrics?.dbReadReq.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, 1);
+    this.metrics?.dbReadItems.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, keys.length);
+    return await this.db.getMany(keys);
+  }
+
+  put(key: Uint8Array, value: Uint8Array, opts?: DbReqOpts): Promise<void> {
+    this.metrics?.dbWriteReq.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, 1);
+    this.metrics?.dbWriteItems.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, 1);
+
+    return this.db.put(key, value);
+  }
+
+  delete(key: Uint8Array, opts?: DbReqOpts): Promise<void> {
+    this.metrics?.dbWriteReq.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, 1);
+    this.metrics?.dbWriteItems.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, 1);
+
+    return this.db.del(key);
+  }
+
+  batchPut(items: KeyValue<Uint8Array, Uint8Array>[], opts?: DbReqOpts): Promise<void> {
+    this.metrics?.dbWriteReq.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, 1);
+    this.metrics?.dbWriteItems.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, items.length);
+
+    return this.db.batch(items.map((item) => ({type: "put", key: item.key, value: item.value})));
+  }
+
+  batchDelete(keys: Uint8Array[], opts?: DbReqOpts): Promise<void> {
+    this.metrics?.dbWriteReq.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, 1);
+    this.metrics?.dbWriteItems.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, keys.length);
+
+    return this.db.batch(keys.map((key) => ({type: "del", key: key})));
+  }
+
+  keysStream(opts: FilterOptions<Uint8Array> = {}): AsyncIterable<Uint8Array> {
+    return this.metricsIterator(this.db.keys(opts), (key) => key, opts.bucketId ?? BUCKET_ID_UNKNOWN);
+  }
+
+  valuesStream(opts: FilterOptions<Uint8Array> = {}): AsyncIterable<Uint8Array> {
+    return this.metricsIterator(this.db.values(opts), (value) => value, opts.bucketId ?? BUCKET_ID_UNKNOWN);
+  }
+
+  entriesStream(opts: FilterOptions<Uint8Array> = {}): AsyncIterable<KeyValue<Uint8Array, Uint8Array>> {
+    return this.metricsIterator(
+      this.db.iterator(opts),
+      (entry) => ({key: entry[0], value: entry[1]}),
+      opts.bucketId ?? BUCKET_ID_UNKNOWN
+    );
+  }
+
+  keys(opts: FilterOptions<Uint8Array> = {}): Promise<Uint8Array[]> {
+    return this.metricsAll(this.db.keys(opts).all(), opts.bucketId ?? BUCKET_ID_UNKNOWN);
+  }
+
+  values(opts: FilterOptions<Uint8Array> = {}): Promise<Uint8Array[]> {
+    return this.metricsAll(this.db.values(opts).all(), opts.bucketId ?? BUCKET_ID_UNKNOWN);
+  }
+
+  async entries(opts: FilterOptions<Uint8Array> = {}): Promise<KeyValue<Uint8Array, Uint8Array>[]> {
+    const entries = await this.metricsAll(this.db.iterator(opts).all(), opts.bucketId ?? BUCKET_ID_UNKNOWN);
+    return entries.map((entry) => ({key: entry[0], value: entry[1]}));
+  }
+
+  /**
+   * Get the approximate number of bytes of file system space used by the range [start..end).
+   * The result might not include recently written data.
+   */
+  approximateSize(start: Uint8Array, end: Uint8Array): Promise<number> {
+    return this.db.approximateSize(start, end);
+  }
+
+  /**
+   * Manually trigger a database compaction in the range [start..end].
+   */
+  compactRange(start: Uint8Array, end: Uint8Array): Promise<void> {
+    return this.db.compactRange(start, end);
+  }
+
+  /** Capture metrics for db.iterator, db.keys, db.values .all() calls */
+  private async metricsAll<T>(promise: Promise<T[]>, bucket: string): Promise<T[]> {
+    this.metrics?.dbReadReq.inc({bucket}, 1);
+    const items = await promise;
+    this.metrics?.dbReadItems.inc({bucket}, items.length);
+    return items;
+  }
+
+  /** Capture metrics for db.iterator, db.keys, db.values AsyncIterable calls */
+  private async *metricsIterator<T, K>(
+    iterator: AsyncIterable<T>,
+    getValue: (item: T) => K,
+    bucket: string
+  ): AsyncIterable<K> {
+    this.metrics?.dbReadReq.inc({bucket}, 1);
+
+    let itemsRead = 0;
+
+    for await (const item of iterator) {
+      // Count metrics after done condition
+      itemsRead++;
+
+      yield getValue(item);
+    }
+
+    this.metrics?.dbReadItems.inc({bucket}, itemsRead);
+  }
+
+  /** Start interval to capture metric for db size */
+  private collectDbSizeMetric(): void {
+    this.dbSizeMetric();
+    this.dbSizeMetricInterval = setInterval(this.dbSizeMetric.bind(this), DB_SIZE_METRIC_INTERVAL_MS);
+  }
+
+  /** Capture metric for db size */
+  private dbSizeMetric(): void {
+    const timer = this.metrics?.dbApproximateSizeTime.startTimer();
+    const minKey = Buffer.from([0x00]);
+    const maxKey = Buffer.from([0xff]);
+
+    this.approximateSize(minKey, maxKey)
+      .then((dbSize) => {
+        this.metrics?.dbSizeTotal.set(dbSize);
+      })
+      .catch((e) => {
+        this.logger.debug("Error approximating db size", {}, e);
+      })
+      .finally(timer);
+  }
+
+  static async destroy(location: string): Promise<void> {
+    return ClassicLevel.destroy(location);
+  }
+}
+
+/** From https://www.npmjs.com/package/level */
+type LevelDbError = {code: "LEVEL_NOT_FOUND"; cause?: {code: "LEVEL_LOCKED"}};

package/src/controller/level_bun.ts

@@ -0,0 +1,288 @@
+import {
+  DB,
+  dbBatchDelete,
+  dbBatchPut,
+  dbClose,
+  dbDelete,
+  dbDestroy,
+  dbGet,
+  dbIterator,
+  dbOpen,
+  dbPut,
+  iteratorDestroy,
+  iteratorKey,
+  iteratorNext,
+  iteratorSeek,
+  iteratorSeekToFirst,
+  iteratorValid,
+  iteratorValue,
+} from "@lodestar/bun";
+import {Logger} from "@lodestar/utils";
+import {DatabaseController, DatabaseOptions, DbReqOpts, FilterOptions, KeyValue} from "./interface.js";
+import {LevelDbControllerMetrics} from "./metrics.js";
+
+export type LevelDbControllerModules = {
+  logger: Logger;
+  metrics?: LevelDbControllerMetrics | null;
+};
+
+export enum Status {
+  started = "started",
+  closed = "closed",
+}
+
+const BUCKET_ID_UNKNOWN = "unknown";
+
+export class LevelDbController implements DatabaseController<Uint8Array, Uint8Array> {
+  private status = Status.started;
+
+  constructor(
+    private readonly db: DB,
+    private metrics: LevelDbControllerMetrics | null
+  ) {}
+
+  static async create(options: DatabaseOptions, {metrics}: LevelDbControllerModules): Promise<LevelDbController> {
+    const db = dbOpen(options.name, {create_if_missing: true});
+    return new LevelDbController(db, metrics ?? null);
+  }
+
+  static async destroy(location: string): Promise<void> {
+    dbDestroy(location);
+  }
+
+  async close(): Promise<void> {
+    if (this.status === Status.closed) {
+      return;
+    }
+    this.status = Status.closed;
+
+    dbClose(this.db);
+  }
+
+  setMetrics(metrics: LevelDbControllerMetrics): void {
+    if (this.metrics !== null) {
+      throw new Error("Metrics already set");
+    }
+    this.metrics = metrics;
+  }
+
+  async get(key: Uint8Array, opts?: DbReqOpts): Promise<Uint8Array | null> {
+    this.metrics?.dbReadReq.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, 1);
+    this.metrics?.dbReadItems.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, 1);
+
+    return dbGet(this.db, key);
+  }
+
+  async getMany(keys: Uint8Array[], opts?: DbReqOpts): Promise<(Uint8Array | undefined)[]> {
+    this.metrics?.dbReadReq.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, 1);
+    this.metrics?.dbReadItems.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, keys.length);
+
+    return keys.map((key) => dbGet(this.db, key) ?? undefined);
+  }
+
+  async put(key: Uint8Array, value: Uint8Array, opts?: DbReqOpts): Promise<void> {
+    this.metrics?.dbWriteReq.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, 1);
+    this.metrics?.dbWriteItems.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, 1);
+
+    dbPut(this.db, key, value);
+  }
+
+  async delete(key: Uint8Array, opts?: DbReqOpts): Promise<void> {
+    this.metrics?.dbWriteReq.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, 1);
+    this.metrics?.dbWriteItems.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, 1);
+
+    dbDelete(this.db, key);
+  }
+
+  async batchPut(items: KeyValue<Uint8Array, Uint8Array>[], opts?: DbReqOpts): Promise<void> {
+    this.metrics?.dbWriteReq.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, 1);
+    this.metrics?.dbWriteItems.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, items.length);
+
+    dbBatchPut(this.db, items);
+  }
+
+  async batchDelete(keys: Uint8Array[], opts?: DbReqOpts): Promise<void> {
+    this.metrics?.dbWriteReq.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, 1);
+    this.metrics?.dbWriteItems.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, keys.length);
+
+    dbBatchDelete(this.db, keys);
+  }
+
+  keysStream(opts: FilterOptions<Uint8Array> = {}): AsyncIterable<Uint8Array> {
+    const iterator = dbIterator(this.db);
+    if (opts.gt) {
+      iteratorSeek(iterator, opts.gt);
+      iteratorNext(iterator);
+    } else if (opts.gte) {
+      iteratorSeek(iterator, opts.gte);
+    } else {
+      iteratorSeekToFirst(iterator);
+    }
+    const bucket = opts.bucketId ?? BUCKET_ID_UNKNOWN;
+    const metrics = this.metrics;
+    metrics?.dbReadReq.inc({bucket}, 1);
+    let itemsRead = 0;
+    return (async function* () {
+      try {
+        while (iteratorValid(iterator)) {
+          const key = iteratorKey(iterator);
+          if (opts.lt && Buffer.compare(key, opts.lt) >= 0) break;
+          if (opts.lte && Buffer.compare(key, opts.lte) > 0) break;
+          itemsRead++;
+          yield key;
+          iteratorNext(iterator);
+        }
+      } finally {
+        metrics?.dbReadItems.inc({bucket}, itemsRead);
+        iteratorDestroy(iterator);
+      }
+    })();
+  }
+
+  async keys(opts: FilterOptions<Uint8Array> = {}): Promise<Uint8Array[]> {
+    const iterator = dbIterator(this.db);
+    if (opts.gt) {
+      iteratorSeek(iterator, opts.gt);
+      iteratorNext(iterator);
+    } else if (opts.gte) {
+      iteratorSeek(iterator, opts.gte);
+    } else {
+      iteratorSeekToFirst(iterator);
+    }
+    const keys = [];
+    this.metrics?.dbReadReq.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, 1);
+    try {
+      while (iteratorValid(iterator)) {
+        const key = iteratorKey(iterator);
+        if (opts.lt && Buffer.compare(key, opts.lt) >= 0) break;
+        if (opts.lte && Buffer.compare(key, opts.lte) > 0) break;
+        keys.push(key);
+        iteratorNext(iterator);
+      }
+      return keys;
+    } finally {
+      this.metrics?.dbReadItems.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, keys.length);
+      iteratorDestroy(iterator);
+    }
+  }
+
+  valuesStream(opts: FilterOptions<Uint8Array> = {}): AsyncIterable<Uint8Array> {
+    const iterator = dbIterator(this.db);
+    if (opts.gt) {
+      iteratorSeek(iterator, opts.gt);
+      iteratorNext(iterator);
+    } else if (opts.gte) {
+      iteratorSeek(iterator, opts.gte);
+    } else {
+      iteratorSeekToFirst(iterator);
+    }
+    const bucket = opts.bucketId ?? BUCKET_ID_UNKNOWN;
+    const metrics = this.metrics;
+    metrics?.dbReadReq.inc({bucket}, 1);
+    let itemsRead = 0;
+    return (async function* () {
+      try {
+        while (iteratorValid(iterator)) {
+          const key = iteratorKey(iterator);
+          if (opts.lt && Buffer.compare(key, opts.lt) >= 0) break;
+          if (opts.lte && Buffer.compare(key, opts.lte) > 0) break;
+          itemsRead++;
+          const value = iteratorValue(iterator);
+          yield value;
+          iteratorNext(iterator);
+        }
+      } finally {
+        metrics?.dbReadItems.inc({bucket}, itemsRead);
+        iteratorDestroy(iterator);
+      }
+    })();
+  }
+
+  async values(opts: FilterOptions<Uint8Array> = {}): Promise<Uint8Array[]> {
+    const iterator = dbIterator(this.db);
+    if (opts.gt) {
+      iteratorSeek(iterator, opts.gt);
+      iteratorNext(iterator);
+    } else if (opts.gte) {
+      iteratorSeek(iterator, opts.gte);
+    } else {
+      iteratorSeekToFirst(iterator);
+    }
+    const values = [];
+    this.metrics?.dbReadReq.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, 1);
+    try {
+      while (iteratorValid(iterator)) {
+        const key = iteratorKey(iterator);
+        if (opts.lt && Buffer.compare(key, opts.lt) >= 0) break;
+        if (opts.lte && Buffer.compare(key, opts.lte) > 0) break;
+        const value = iteratorValue(iterator);
+        values.push(value);
+        iteratorNext(iterator);
+      }
+      return values;
+    } finally {
+      this.metrics?.dbReadItems.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, values.length);
+      iteratorDestroy(iterator);
+    }
+  }
+
+  entriesStream(opts: FilterOptions<Uint8Array> = {}): AsyncIterable<KeyValue<Uint8Array, Uint8Array>> {
+    const iterator = dbIterator(this.db);
+    if (opts.gt) {
+      iteratorSeek(iterator, opts.gt);
+      iteratorNext(iterator);
+    } else if (opts.gte) {
+      iteratorSeek(iterator, opts.gte);
+    } else {
+      iteratorSeekToFirst(iterator);
+    }
+    const bucket = opts.bucketId ?? BUCKET_ID_UNKNOWN;
+    const metrics = this.metrics;
+    metrics?.dbReadReq.inc({bucket}, 1);
+    let itemsRead = 0;
+    return (async function* () {
+      try {
+        while (iteratorValid(iterator)) {
+          const key = iteratorKey(iterator);
+          if (opts.lt && Buffer.compare(key, opts.lt) >= 0) break;
+          if (opts.lte && Buffer.compare(key, opts.lte) > 0) break;
+          itemsRead++;
+          const value = iteratorValue(iterator);
+          yield {key, value};
+          iteratorNext(iterator);
+        }
+      } finally {
+        metrics?.dbReadItems.inc({bucket}, itemsRead);
+        iteratorDestroy(iterator);
+      }
+    })();
+  }
+
+  async entries(opts: FilterOptions<Uint8Array> = {}): Promise<KeyValue<Uint8Array, Uint8Array>[]> {
+    const iterator = dbIterator(this.db);
+    if (opts.gt) {
+      iteratorSeek(iterator, opts.gt);
+      iteratorNext(iterator);
+    } else if (opts.gte) {
+      iteratorSeek(iterator, opts.gte);
+    } else {
+      iteratorSeekToFirst(iterator);
+    }
+    const entries = [];
+    this.metrics?.dbReadReq.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, 1);
+    try {
+      while (iteratorValid(iterator)) {
+        const key = iteratorKey(iterator);
+        if (opts.lt && Buffer.compare(key, opts.lt) >= 0) break;
+        if (opts.lte && Buffer.compare(key, opts.lte) > 0) break;
+        const value = iteratorValue(iterator);
+        entries.push({key, value});
+        iteratorNext(iterator);
+      }
+      return entries;
+    } finally {
+      this.metrics?.dbReadItems.inc({bucket: opts?.bucketId ?? BUCKET_ID_UNKNOWN}, entries.length);
+      iteratorDestroy(iterator);
+    }
+  }
+}

package/src/controller/metrics.ts

@@ -0,0 +1,10 @@
+import {Counter, Gauge, Histogram} from "@lodestar/utils";
+
+export type LevelDbControllerMetrics = {
+  dbReadReq: Counter<{bucket: string}>;
+  dbReadItems: Counter<{bucket: string}>;
+  dbWriteReq: Counter<{bucket: string}>;
+  dbWriteItems: Counter<{bucket: string}>;
+  dbSizeTotal: Gauge;
+  dbApproximateSizeTime: Histogram;
+};

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from "./abstractPrefixedRepository.js";
+export * from "./abstractRepository.js";
+export * from "./const.js";
+export * from "./controller/index.js";
+export * from "./util.js";

package/src/util.ts

@@ -0,0 +1,50 @@
+import {bytesToInt, intToBytes} from "@lodestar/utils";
+import {BUCKET_LENGTH} from "./const.js";
+
+export const uintLen = 8;
+
+/**
+ * Encode a key for the db write/read, Prepend a bucket to a key
+ *
+ * The encoding of key is very important step that can cause failure of proper indexing and querying of data
+ *
+ * We are using LevelDB which have pluggable comparator support, so you can decide how to
+ * compare keys. But for NodeJS binding only default comparison algorithm is supported which
+ * uses lexicographical comparison of the raw bytes of the keys
+ *
+ * It is important to use **helpers implemented here** to encode db keys so that key comparison properly work.
+ */
+export function encodeKey(bucket: number, key: Uint8Array | string | number | bigint): Uint8Array {
+  let buf: Buffer;
+  const prefixLength = BUCKET_LENGTH;
+  //all keys are writen with prefixLength offet
+  if (typeof key === "string") {
+    buf = Buffer.alloc(key.length + prefixLength);
+    buf.write(key, prefixLength);
+  } else if (typeof key === "number" || typeof key === "bigint") {
+    buf = Buffer.alloc(uintLen + prefixLength);
+    intToBytes(BigInt(key), uintLen, "be").copy(buf, prefixLength);
+  } else {
+    buf = Buffer.alloc(key.length + prefixLength);
+    buf.set(key, prefixLength);
+  }
+  //bucket prefix on position 0
+  buf.set(intToBytes(bucket, BUCKET_LENGTH, "le"), 0);
+  return buf;
+}
+
+export function encodeNumberForDbKey(value: number, byteSize: number): Uint8Array {
+  return intToBytes(value, byteSize, "be");
+}
+
+export function decodeNumberForDbKey(value: Uint8Array, byteSize: number): number {
+  return bytesToInt(value.slice(0, byteSize), "be");
+}
+
+export function encodeStringForDbKey(value: string): Uint8Array {
+  return Buffer.from(value, "utf-8");
+}
+
+export function decodeStringForDbKey(value: Uint8Array): string {
+  return Buffer.from(value).toString("utf8");
+}