@evolu/common 6.0.1-preview.30 → 6.0.1-preview.32

package/src/Array.ts

@@ -20,9 +20,8 @@
  * const filtered = filterArray(readonly, (x) => x > 1); // ReadonlyArray<number>
  *
  * // ✅ NonEmptyArray enforces non-emptiness
- * const first = (items: NonEmptyReadonlyArray<string>) => items[0];
- * first([]); // ❌ Compiler error
- * first(["a"]); // ✅ Works
+ * const value = firstInArray(["a", "b"]); // "a"
+ * firstInArray([]); // ❌ Compiler error
  * ```
  *
  * @module
@@ -102,3 +101,48 @@ export const filterArray = <T>(
  * **Mutates** the original array. Use only with mutable arrays.
  */
 export const shiftArray = <T>(array: NonEmptyArray<T>): T => array.shift() as T;
+
+/**
+ * Returns the first element of a non-empty readonly array.
+ *
+ * Does not mutate the original array.
+ */
+export const firstInArray = <T>(array: NonEmptyReadonlyArray<T>): T => array[0];
+
+/**
+ * Returns the last element of a non-empty readonly array.
+ *
+ * Does not mutate the original array.
+ */
+export const lastInArray = <T>(array: NonEmptyReadonlyArray<T>): T =>
+  array[array.length - 1];
+
+/**
+ * Returns a new readonly array with duplicate items removed based on a key
+ * extractor function. Preserves the first occurrence of each distinct key.
+ *
+ * Accepts both mutable and readonly arrays. Does not mutate the original array.
+ */
+
+/**
+ * Deduplicates items in an array. If `by` is provided, it will be used to
+ * derive the key for uniqueness; otherwise values are used directly.
+ *
+ * Returns a new readonly array and does not mutate the input.
+ */
+export const dedupeArray = <T>(
+  array: ReadonlyArray<T>,
+  by?: (item: T) => unknown,
+): ReadonlyArray<T> => {
+  if (by == null) {
+    return Array.from(new Set(array)) as ReadonlyArray<T>;
+  }
+
+  const seen = new Set<unknown>();
+  return array.filter((item) => {
+    const key = by(item);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  }) as ReadonlyArray<T>;
+};

package/src/Evolu/Db.ts

@@ -198,6 +198,9 @@ export interface DbConfig extends ConsoleConfig, TimestampConfig {
   /**
    * Encryption key for the SQLite database.
    *
+   * Note: If an unencrypted SQLite database already exists and you provide an
+   * encryptionKey, SQLite will throw an error.
+   *
    * @experimental
    */
   readonly encryptionKey?: EncryptionKey;

package/src/Evolu/Evolu.ts

@@ -1,6 +1,10 @@
 import { pack } from "msgpackr";
-import { isNonEmptyArray, isNonEmptyReadonlyArray } from "../Array.js";
-import { assert, assertNonEmptyArray } from "../Assert.js";
+import {
+  dedupeArray,
+  isNonEmptyArray,
+  isNonEmptyReadonlyArray,
+} from "../Array.js";
+import { assert, assertNonEmptyReadonlyArray } from "../Assert.js";
 import { createCallbacks } from "../Callbacks.js";
 import { ConsoleDep } from "../Console.js";
 import { RandomBytesDep, SymmetricCryptoDecryptError } from "../Crypto.js";
@@ -611,10 +615,10 @@ const createEvoluInstance =
           const loadingPromisesQueries = loadingPromises.getQueries();
           loadingPromises.releaseUnsubscribedOnMutation();
 
-          const queries = [
-            // Dedupe
-            ...new Set([...loadingPromisesQueries, ...subscribedQueries.get()]),
-          ];
+          const queries = dedupeArray([
+            ...loadingPromisesQueries,
+            ...subscribedQueries.get(),
+          ]);
 
           if (isNonEmptyReadonlyArray(queries)) {
             dbWorker.postMessage({ type: "query", tabId: getTabId(), queries });
@@ -790,10 +794,9 @@ const createEvoluInstance =
           loadQueryMicrotaskQueue.push(query);
           if (loadQueryMicrotaskQueue.length === 1) {
             queueMicrotask(() => {
-              // Dedupe
-              const queries = [...new Set(loadQueryMicrotaskQueue)];
+              const queries = dedupeArray(loadQueryMicrotaskQueue);
               loadQueryMicrotaskQueue.length = 0;
-              assertNonEmptyArray(queries);
+              assertNonEmptyReadonlyArray(queries);
               deps.console.log("[evolu]", "loadQuery", { queries });
               dbWorker.postMessage({
                 type: "query",

package/src/Evolu/Owner.ts

@@ -18,7 +18,8 @@ import {
   Mnemonic,
   NonNegativeInt,
 } from "../Type.js";
-import type { Storage, EncryptedDbChange } from "./Storage.js";
+import type { EncryptedDbChange, Storage } from "./Storage.js";
+import { TimestampBytes } from "./Timestamp.js";
 
 /**
  * The Owner represents ownership of data in Evolu. Every database change is
@@ -390,11 +391,11 @@ export interface BaseOwnerError {
 /**
  * Usage data for an {@link OwnerId}.
  *
- * Tracks data consumption to monitor usage patterns and enforce quotas if
- * needed. Used by both relays and clients.
+ * Tracks storage usage to enforce quotas if needed, and some other stuff.
  *
- * Relays and clients must handle rate limiting, connection limits, and request
- * throttling separately with in-memory state.
+ * TODO:
+ *
+ * - Add transferredBytes for billing and monitoring network usage.
  */
 export interface OwnerUsage {
   /** The {@link Owner} this usage data belongs to. */
@@ -416,28 +417,13 @@ export interface OwnerUsage {
    */
   readonly storedBytes: NonNegativeInt;
 
-  // TODO: Decide how to use receivedBytes and sentBytes.
-  // /** Total bytes received. */
-  // readonly receivedBytes: NonNegativeInt;
-
-  // TODO: Decide how to use sentBytes.
-  // /** Total bytes sent. */
-  // readonly sentBytes: NonNegativeInt;
-
-  // TODO: Decide how to use firstTimestamp.
-  // /**
-  //  * The minimum {@link Timestamp}.
-  //  *
-  //  * Helps {@link Storage} choose faster algorithms.
-  //  */
-  // readonly firstTimestamp: TimestampBytes | null;
-
-  // TODO: Decide how to use lastTimestamp.
-  // /**
-  //  * The maximum {@link Timestamp}.
-  //  *
-  //  * Helps {@link Storage} choose faster algorithms. Free relays can use it to
-  //  * identify inactive accounts for cleanup or archival.
-  //  */
-  // readonly lastTimestamp: TimestampBytes | null;
+  /** Tracks the earliest timestamp for timestamp insertion strategies. */
+  readonly firstTimestamp: TimestampBytes | null;
+
+  /**
+   * Tracks the latest timestamp for timestamp insertion strategies.
+   *
+   * Free relays can use it to identify inactive accounts for cleanup.
+   */
+  readonly lastTimestamp: TimestampBytes | null;
 }

package/src/Evolu/Relay.ts

@@ -1,4 +1,9 @@
-import { filterArray, isNonEmptyReadonlyArray, mapArray } from "../Array.js";
+import {
+  filterArray,
+  firstInArray,
+  isNonEmptyReadonlyArray,
+  mapArray,
+} from "../Array.js";
 import { ConsoleConfig, ConsoleDep } from "../Console.js";
 import { TimingSafeEqualDep } from "../Crypto.js";
 import { LazyValue } from "../Function.js";
@@ -6,7 +11,7 @@ import { createInstances } from "../Instances.js";
 import { err, ok, Result } from "../Result.js";
 import { sql, SqliteDep, SqliteError } from "../Sqlite.js";
 import { createMutex, isAsync, MaybeAsync, Mutex } from "../Task.js";
-import { NonNegativeInt, PositiveInt, SimpleName } from "../Type.js";
+import { PositiveInt, SimpleName } from "../Type.js";
 import {
   OwnerId,
   ownerIdBytesToOwnerId,
@@ -18,10 +23,13 @@ import {
   createBaseSqliteStorage,
   CreateBaseSqliteStorageConfig,
   EncryptedDbChange,
+  getOwnerUsage,
+  getTimestampInsertStrategy,
   SqliteStorageDeps,
   Storage,
   StorageConfig,
   StorageQuotaError,
+  updateOwnerUsage,
 } from "./Storage.js";
 import { timestampToTimestampBytes } from "./Timestamp.js";
 
@@ -193,23 +201,20 @@ export const createRelaySqliteStorage =
               return ok();
             }
 
-            const storedBytesResult = deps.sqlite.exec<{
-              storedBytes: NonNegativeInt;
-            }>(sql`
-              select storedBytes
-              from evolu_usage
-              where ownerId = ${ownerIdBytes};
-            `);
-            if (!storedBytesResult.ok) return storedBytesResult;
-
-            const storedBytes =
-              storedBytesResult.value.rows[0]?.storedBytes ?? 0;
+            const usage = getOwnerUsage(deps)(
+              ownerIdBytes,
+              firstInArray(newMessages).timestamp,
+            );
+            if (!usage.ok) return usage;
+
+            const { storedBytes } = usage.value;
+
             const incomingBytes = newMessages.reduce(
               (sum, m) => sum + m.change.length,
               0,
             );
             const newStoredBytes = PositiveInt.orThrow(
-              storedBytes + incomingBytes,
+              (storedBytes ?? 0) + incomingBytes,
             );
 
             const withinQuotaResult = config.isOwnerWithinQuota(
@@ -223,11 +228,22 @@ export const createRelaySqliteStorage =
               return err({ type: "StorageQuotaError", ownerId });
             }
 
+            let { firstTimestamp, lastTimestamp } = usage.value;
+
             return deps.sqlite.transaction(() => {
               for (const { timestamp, change } of newMessages) {
+                let strategy;
+                [strategy, firstTimestamp, lastTimestamp] =
+                  getTimestampInsertStrategy(
+                    timestamp,
+                    firstTimestamp,
+                    lastTimestamp,
+                  );
+
                 const insertTimestampResult = sqliteStorageBase.insertTimestamp(
                   ownerIdBytes,
                   timestamp,
+                  strategy,
                 );
                 if (!insertTimestampResult.ok) return insertTimestampResult;
 
@@ -239,12 +255,12 @@ export const createRelaySqliteStorage =
                 if (!insertMessage.ok) return insertMessage;
               }
 
-              const updateUsage = deps.sqlite.exec(sql`
-                insert into evolu_usage ("ownerId", "storedBytes")
-                values (${ownerIdBytes}, ${newStoredBytes})
-                on conflict (ownerId) do update
-                  set storedBytes = ${newStoredBytes};
-              `);
+              const updateUsage = updateOwnerUsage(deps)(
+                ownerIdBytes,
+                newStoredBytes,
+                firstTimestamp,
+                lastTimestamp,
+              );
               if (!updateUsage.ok) return updateUsage;
 
               return ok();

package/src/Evolu/Storage.ts

@@ -1,5 +1,9 @@
 import { sha256 } from "@noble/hashes/sha2.js";
-import { NonEmptyReadonlyArray } from "../Array.js";
+import {
+  firstInArray,
+  isNonEmptyReadonlyArray,
+  NonEmptyReadonlyArray,
+} from "../Array.js";
 import { assert } from "../Assert.js";
 import { Brand } from "../Brand.js";
 import { concatBytes } from "../Buffer.js";
@@ -22,7 +26,6 @@ import {
   Owner,
   OwnerId,
   OwnerIdBytes,
-  ownerIdBytesToOwnerId,
   OwnerWriteKey,
 } from "./Owner.js";
 import { orderTimestampBytes, Timestamp, TimestampBytes } from "./Timestamp.js";
@@ -32,16 +35,16 @@ export interface StorageConfig {
    * Callback called before an attempt to write, to check if an {@link OwnerId}
    * has sufficient quota for the write.
    *
-   * The callback receives the {@link OwnerId} and the number of bytes required
-   * for the write, and returns a {@link MaybeAsync} boolean: `true` to allow the
-   * write, or `false` to deny it due to quota limits.
+   * The callback receives the {@link OwnerId} and the total bytes that would be
+   * stored after the write (current stored bytes plus incoming bytes), and
+   * returns a {@link MaybeAsync} boolean: `true` to allow the write, or `false`
+   * to deny it due to quota limits.
    *
    * The callback can be synchronous (for SQLite or in-memory checks) or
    * asynchronous (for calling remote APIs).
    *
-   * The callback returns a boolean rather than an error type because error
-   * handling and logging are the responsibility of the callback
-   * implementation.
+   * The callback returns a boolean rather than an error because error handling
+   * and logging are the responsibility of the callback implementation.
    *
    * ### Example
    *
@@ -299,16 +302,11 @@ export interface BaseSqliteStorage
     | "iterate"
     | "deleteOwner"
   > {
-  /**
-   * Inserts a timestamp for an owner into the skiplist-based storage.
-   *
-   * Must be idempotent - inserting the same timestamp multiple times has no
-   * effect after the first insertion. This is crucial for sync reliability as
-   * messages may be received and processed multiple times.
-   */
+  /** Inserts a timestamp for an owner into the skiplist-based storage. */
   readonly insertTimestamp: (
     ownerId: OwnerIdBytes,
     timestamp: TimestampBytes,
+    strategy: StorageInsertTimestampStrategy,
   ) => Result<void, SqliteError>;
 
   /**
@@ -331,19 +329,62 @@ export interface CreateBaseSqliteStorageConfig extends StorageConfig {
   onStorageError: (error: SqliteError) => void;
 }
 
+/**
+ * Creates a {@link BaseSqliteStorage} implementation.
+ *
+ * # Stateless Design
+ *
+ * This implementation is fully stateless - it requires no in-memory state
+ * between invocations. All necessary metadata (timestamp bounds for insertion
+ * strategy optimization) is persisted in the evolu_usage table. This makes
+ * Evolu Relay suitable for stateless serverless environments like AWS Lambda,
+ * Cloudflare Workers with Durable Objects, and other platforms where memory
+ * doesn't persist between requests. While not extensively tested in all these
+ * environments yet, the stateless design should work well across them.
+ */
 export const createBaseSqliteStorage =
   (deps: SqliteStorageDeps) =>
   (config: CreateBaseSqliteStorageConfig): BaseSqliteStorage => {
-    // TODO: Use evolu_usage table.
-    const ownerStats = new Map<
-      OwnerId,
-      {
-        minT: TimestampBytes;
-        maxT: TimestampBytes;
-      }
-    >();
-
     return {
+      insertTimestamp: (
+        ownerId: OwnerIdBytes,
+        timestamp: TimestampBytes,
+        strategy: StorageInsertTimestampStrategy,
+      ) => {
+        const level = randomSkiplistLevel(deps);
+        return insertTimestamp(deps)(ownerId, timestamp, level, strategy);
+      },
+
+      getExistingTimestamps: (ownerIdBytes, timestampsBytes) => {
+        const concatenatedTimestamps = concatBytes(...timestampsBytes);
+
+        const result = deps.sqlite.exec<{
+          timestampBytes: TimestampBytes;
+        }>(sql`
+          with recursive
+            split_timestamps(timestampBytes, pos) as (
+              select
+                substr(${concatenatedTimestamps}, 1, 16),
+                17 as pos
+              union all
+              select
+                substr(${concatenatedTimestamps}, pos, 16),
+                pos + 16
+              from split_timestamps
+              where pos <= length(${concatenatedTimestamps})
+            )
+          select s.timestampBytes
+          from
+            split_timestamps s
+            join evolu_timestamp t
+              on t.ownerId = ${ownerIdBytes} and s.timestampBytes = t.t;
+        `);
+
+        if (!result.ok) return result;
+
+        return ok(result.value.rows.map((row) => row.timestampBytes));
+      },
+
       getSize: (ownerId) => {
         const size = getSize(deps)(ownerId);
         if (!size.ok) {
@@ -439,75 +480,6 @@ export const createBaseSqliteStorage =
         }
         return true;
       },
-
-      insertTimestamp: (ownerId: OwnerIdBytes, timestamp: TimestampBytes) => {
-        const ownerIdString = ownerIdBytesToOwnerId(ownerId);
-        const level = randomSkiplistLevel(deps);
-
-        let stats = ownerStats.get(ownerIdString);
-
-        if (!stats) {
-          const result = deps.sqlite.exec<{
-            maxT: TimestampBytes | null;
-            minT: TimestampBytes | null;
-          }>(sql.prepared`
-            select min(t) as minT, max(t) as maxT
-            from evolu_timestamp
-            where ownerId = ${ownerId};
-          `);
-          if (!result.ok) return result;
-
-          stats = {
-            minT: result.value.rows[0].minT ?? timestamp,
-            maxT: result.value.rows[0].maxT ?? timestamp,
-          };
-          ownerStats.set(ownerIdString, stats);
-        }
-
-        let strategy: InsertTimestampStrategy;
-
-        if (orderTimestampBytes(timestamp, stats.maxT) === 1) {
-          strategy = "append";
-          stats.maxT = timestamp;
-        } else if (orderTimestampBytes(timestamp, stats.minT) === -1) {
-          strategy = "prepend";
-          stats.minT = timestamp;
-        } else {
-          strategy = "insert";
-        }
-
-        return insertTimestamp(deps)(ownerId, timestamp, level, strategy);
-      },
-
-      getExistingTimestamps: (ownerIdBytes, timestampsBytes) => {
-        const concatenatedTimestamps = concatBytes(...timestampsBytes);
-
-        const result = deps.sqlite.exec<{
-          timestampBytes: TimestampBytes;
-        }>(sql`
-          with recursive
-            split_timestamps(timestampBytes, pos) as (
-              select
-                substr(${concatenatedTimestamps}, 1, 16),
-                17 as pos
-              union all
-              select
-                substr(${concatenatedTimestamps}, pos, 16),
-                pos + 16
-              from split_timestamps
-              where pos <= length(${concatenatedTimestamps})
-            )
-          select s.timestampBytes
-          from
-            split_timestamps s
-            join evolu_timestamp t
-              on t.ownerId = ${ownerIdBytes} and s.timestampBytes = t.t;
-        `);
-
-        if (!result.ok) return result;
-
-        return ok(result.value.rows.map((row) => row.timestampBytes));
-      },
     };
   };
 
@@ -533,13 +505,7 @@ export const createBaseSqliteStorageTables = (
      * - `t` – TimestampBytes
      * - `h1`/`h2` – 12-byte fingerprint split into two integers for fast XOR
      * - `c` – incremental count
-     * - `l` – Skiplist level (1 to 32)
-     *
-     * For scaling or isolation, sharding is possible—each owner can have a
-     * separate SQLite database.
-     *
-     * Maybe we could use an integer surrogate key for ownerId, but it's fast
-     * enough even without it.
+     * - `l` – Skiplist level (1 to 10)
      */
     sql`
       create table evolu_timestamp (
@@ -572,20 +538,15 @@ export const createBaseSqliteStorageTables = (
      *
      * - `ownerId` – OwnerIdBytes (primary key)
      * - `storedBytes` – total bytes stored in database
-     * - `receivedBytes` – TODO: Decide how to use
-     * - `sentBytes` – TODO: Decide how to use
-     * - `firstTimestamp` – TODO: Decide how to use (nullable)
-     * - `lastTimestamp` – TODO: Decide how to use (nullable)
+     * - `firstTimestamp` – for timestamp insertion strategies
+     * - `lastTimestamp` – for timestamp insertion strategies
      */
     sql`
       create table evolu_usage (
         "ownerId" blob primary key,
-        "storedBytes" integer not null
-        -- TODO: Decide how to use receivedBytes, sentBytes, firstTimestamp, lastTimestamp
-        -- "receivedBytes" integer not null,
-        -- "sentBytes" integer not null,
-        -- "firstTimestamp" blob,
-        -- "lastTimestamp" blob
+        "storedBytes" integer not null,
+        "firstTimestamp" blob,
+        "lastTimestamp" blob
       )
       strict;
     `,
@@ -596,23 +557,53 @@ export const createBaseSqliteStorageTables = (
   return ok();
 };
 
-type InsertTimestampStrategy = "append" | "prepend" | "insert";
+export type StorageInsertTimestampStrategy = "append" | "prepend" | "insert";
+
+/**
+ * Determines the insertion strategy for a timestamp based on its position
+ * relative to the current first and last timestamps.
+ *
+ * Returns a tuple with the strategy and updated timestamp bounds.
+ */
+export const getTimestampInsertStrategy = (
+  timestamp: TimestampBytes,
+  firstTimestamp: TimestampBytes,
+  lastTimestamp: TimestampBytes,
+): [
+  strategy: StorageInsertTimestampStrategy,
+  firstTimestamp: TimestampBytes,
+  lastTimestamp: TimestampBytes,
+] => {
+  if (orderTimestampBytes(timestamp, lastTimestamp) === 1) {
+    return ["append", firstTimestamp, timestamp];
+  }
+  if (orderTimestampBytes(timestamp, firstTimestamp) === -1) {
+    return ["prepend", timestamp, lastTimestamp];
+  }
+  return ["insert", firstTimestamp, lastTimestamp];
+};
 
-// AFAIK, we can't do both insert and update in one query, and that's probably
-// why append is 2x faster than insert. Prepend also has to update parents, but
-// it's constantly fast. Insert degrades for reversed (yet LIMIT X magically
-// makes it much faster) but it's OK for append. It's probably because it's the
-// most complicated SQL, but I believe it can be simplified. If not, we can
-// optimize prepending by reversing the incoming timestamps if we detect that
-// they will prepend. They are always sorted in ascending order by the
-// Protocol.
+/**
+ * AFAIK, we can't do both insert and update in one query, and that's probably
+ * why append is 2x faster than insert. Prepend also has to update parents, but
+ * it's constantly fast. Insert degrades for reversed (yet LIMIT X magically
+ * fixes that) but it's OK for append.
+ *
+ * Note: SQL operations are idempotent (using `on conflict do nothing` and
+ * `changes() > 0`), but this is no longer required here since we use
+ * {@link BaseSqliteStorage.getExistingTimestamps} to filter out duplicates
+ * before insertion, which we need for quota checks anyway.
+ *
+ * TODO: Remove idempotency (`on conflict do nothing` and `changes() > 0`) since
+ * duplicates are now filtered before insertion.
+ */
 const insertTimestamp =
   (deps: SqliteDep) =>
   (
     ownerId: OwnerIdBytes,
     timestamp: TimestampBytes,
     level: PositiveInt,
-    strategy: InsertTimestampStrategy,
+    strategy: StorageInsertTimestampStrategy,
   ): Result<void, SqliteError> => {
     const [h1, h2] = fingerprintToSqliteFingerprint(
       timestampBytesToFingerprint(timestamp),
@@ -1612,3 +1603,76 @@ export const getTimestampByIndex =
     if (!result.ok) return result;
     return ok(result.value.rows[0].pt);
   };
+
+/** Retrieves usage information for an owner from the evolu_usage table. */
+export const getOwnerUsage =
+  (deps: SqliteDep) =>
+  (
+    ownerIdBytes: OwnerIdBytes,
+    initialTimestamp: TimestampBytes,
+  ): Result<
+    {
+      storedBytes: NonNegativeInt | null;
+      firstTimestamp: TimestampBytes;
+      lastTimestamp: TimestampBytes;
+    },
+    SqliteError
+  > => {
+    const result = deps.sqlite.exec<{
+      storedBytes: NonNegativeInt;
+      firstTimestamp: TimestampBytes | null;
+      lastTimestamp: TimestampBytes | null;
+    }>(sql`
+      select storedBytes, firstTimestamp, lastTimestamp
+      from evolu_usage
+      where ownerId = ${ownerIdBytes};
+    `);
+    if (!result.ok) return result;
+
+    if (!isNonEmptyReadonlyArray(result.value.rows)) {
+      return ok({
+        storedBytes: null,
+        firstTimestamp: initialTimestamp,
+        lastTimestamp: initialTimestamp,
+      });
+    }
+
+    const row = firstInArray(result.value.rows);
+    assert(row.firstTimestamp, "not null");
+    assert(row.lastTimestamp, "not null");
+
+    return ok({
+      storedBytes: row.storedBytes,
+      firstTimestamp: row.firstTimestamp,
+      lastTimestamp: row.lastTimestamp,
+    });
+  };
+
+/**
+ * Updates timestamp bounds in evolu_usage table.
+ *
+ * Used by both relay and client to maintain firstTimestamp/lastTimestamp after
+ * processing messages.
+ */
+export const updateOwnerUsage =
+  (deps: SqliteDep) =>
+  (
+    ownerIdBytes: OwnerIdBytes,
+    storedBytes: PositiveInt,
+    firstTimestamp: TimestampBytes,
+    lastTimestamp: TimestampBytes,
+  ): Result<void, SqliteError> => {
+    const result = deps.sqlite.exec(sql`
+      insert into evolu_usage
+        ("ownerId", "storedBytes", "firstTimestamp", "lastTimestamp")
+      values
+        (${ownerIdBytes}, ${storedBytes}, ${firstTimestamp}, ${lastTimestamp})
+      on conflict (ownerId) do update
+        set
+          storedBytes = ${storedBytes},
+          firstTimestamp = ${firstTimestamp},
+          lastTimestamp = ${lastTimestamp};
+    `);
+    if (!result.ok) return result;
+    return ok();
+  };