@evolu/common 6.0.1-preview.0 → 6.0.1-preview.10

package/dist/src/Evolu/Protocol.js

@@ -7,31 +7,47 @@
  * relays with each other.
  *
  * Evolu Protocol is designed for SQLite but can be extended to any database. It
- * implements [Range-Based Set Reconciliation](https://arxiv.org/abs/2212.13567)
- * by Aljoscha Meyer.
- *
- * To learn how RBSR works, check
- * [Negentropy](https://logperiodic.com/rbsr.html). Evolu Protocol is similar to
- * Negentropy but uses different encoding and also provides data transfer and
- * ownership.
+ * implements [Range-Based Set
+ * Reconciliation](https://arxiv.org/abs/2212.13567). To learn how RBSR works,
+ * check [Negentropy](https://logperiodic.com/rbsr.html). Evolu Protocol is
+ * similar to Negentropy but uses different encoding and also provides data
+ * transfer and ownership.
  *
  * ### Message Structure
  *
- * | Field                          | Notes                      |
- * | :----------------------------- | :------------------------- |
- * | **Header**                     |                            |
- * | - {@link protocolVersion}      |                            |
- * | - {@link OwnerId}              |                            |
- * | - {@link ProtocolErrorCode}    | In non-initiator response. |
- * | **Messages**                   |                            |
- * | - {@link NonNegativeInt}       | A number of messages.      |
- * | - {@link EncryptedCrdtMessage} |                            |
- * | - {@link WriteKey}             | In initiator request.      |
- * | **Ranges**                     |                            |
- * | - {@link NonNegativeInt}       | Number of ranges.          |
- * | - {@link Range}                |                            |
+ * | Field                          | Notes                     |
+ * | :----------------------------- | :------------------------ |
+ * | **Header**                     |                           |
+ * | - {@link protocolVersion}      |                           |
+ * | - {@link OwnerId}              | {@link Owner}             |
+ * | **Initiator**                  |                           |
+ * | - {@link WriteKeyMode}         |                           |
+ * | - {@link WriteKey}             | If WriteKeyMode >= 1      |
+ * | - {@link WriteKey}             | If WriteKeyMode = 2 (new) |
+ * | **Non-initiator**              |                           |
+ * | - {@link ProtocolErrorCode}    |                           |
+ * | **Messages**                   |                           |
+ * | - {@link NonNegativeInt}       | A number of messages.     |
+ * | - {@link EncryptedCrdtMessage} |                           |
+ * | **Ranges**                     |                           |
+ * | - {@link NonNegativeInt}       | Number of ranges.         |
+ * | - {@link Range}                |                           |
+ *
+ * ### WriteKey Validation
+ *
+ * The initiator sends WriteKeyMode and optionally one or two WriteKeys. One key
+ * for write operations and two for key rotation (current and new). Note that
+ * it's ok to not send any key if initiator is going to be synced with readonly
+ * owner. The non-initiator validates them immediately after parsing the
+ * initiator header, before processing any messages or ranges.
+ *
+ * ### WriteKey Rotation
+ *
+ * When initiator's {@link WriteKeyMode} is `Rotation`, two WriteKeys are
+ * present:
  *
- * Every protocol message belongs to an owner.
+ * 1. Current WriteKey (for validation)
+ * 2. New WriteKey (to be stored)
  *
  * ### Synchronization
  *
@@ -48,21 +64,34 @@
  * Both **Messages** and **Ranges** are optional, allowing each side to send,
  * sync, or only subscribe data as needed.
  *
- * When the initiator sends data, the {@link WriteKey} is **required** in
- * **Messages** as a secure token proving the initiator can write changes. The
- * non-initiator responds without a {@link WriteKey}, since the initiator’s
- * request already signals it wants data. If the non-initiator detects an issue
- * (e.g., an invalid {@link WriteKey} causing a {@link ProtocolWriteKeyError}, or
- * a write failure causing a {@link ProtocolWriteError}), it sends an error code
- * via the `Error` field in the header back to the initiator. In relay-to-relay
- * or P2P sync, both sides may require the {@link WriteKey} depending on who is
- * the initiator.
+ * When the initiator sends data, the {@link WriteKey} is required in Messages as
+ * a secure token proving the initiator can write changes. The non-initiator
+ * responds without a {@link WriteKey}, since the initiator’s request already
+ * signals it wants data. If the non-initiator detects an issue, it sends an
+ * error code via the `Error` field in the header back to the initiator. In
+ * relay-to-relay or P2P sync, both sides may require the {@link WriteKey}
+ * depending on who is the initiator.
+ *
+ * ### Protocol Errors
+ *
+ * The protocol uses error codes in the header to signal issues:
+ *
+ * - {@link ProtocolWriteKeyError}: The provided WriteKey is invalid or missing.
+ * - {@link ProtocolWriteError}: A write operation failed (e.g., due to storage
+ *   limits or billing).
+ * - {@link ProtocolSyncError}: A generic or unexpected synchronization failure
+ *   occurred.
+ * - {@link ProtocolUnsupportedVersionError}: Protocol version mismatch.
+ * - {@link ProtocolInvalidDataError}: The message is malformed or corrupted.
+ *
+ * All protocol errors except `ProtocolInvalidDataError` include the `ownerId`
+ * to allow clients to associate errors with the correct owner.
  *
  * ### Message Size Limit
  *
  * The protocol enforces a strict maximum size for all messages, defined by
- * {@link maxProtocolMessageSize}. This ensures every `ProtocolMessage` is less
- * than or equal to this limit, eliminating the need for applications to
+ * {@link maxProtocolMessageSize}. This ensures every {@link ProtocolMessage} is
+ * less than or equal to this limit, eliminating the need for applications to
  * fragment and reconstruct messages during transmission.
  *
  * ### Why Binary?
@@ -88,11 +117,24 @@
  *
  * ### Versioning
  *
- * The initiator sends a versioned `ProtocolMessage`. If the non-initiator uses
- * a different version, it responds with a message containing only its protocol
- * version—**without an `ownerId`**. This allows the initiator to check protocol
- * compatibility, for example, by sending version-only messages to multiple
- * relays before starting synchronization.
+ * Evolu Protocol uses explicit versioning to ensure compatibility between
+ * clients and relays (or peers). Each protocol message begins with a version
+ * number and an `ownerId` in its header.
+ *
+ * **How version negotiation works:**
+ *
+ * - The initiator (usually a client) sends a `ProtocolMessage` that includes its
+ *   protocol version and the `ownerId`.
+ * - The non-initiator (usually a relay or peer) checks the version.
+ *
+ *   - If the versions match, synchronization proceeds as normal.
+ *   - If the versions do not match, the non-initiator responds with a message
+ *       containing **its own protocol version and the same `ownerId`**.
+ * - The initiator can then detect the version mismatch for that specific owner
+ *   and handle it appropriately (e.g., prompt for an update or halt sync).
+ *
+ * Version negotiation is per-owner, allowing Evolu Protocol to evolve safely
+ * over time and provide clear feedback about version mismatches.
  *
  * @module
  */
@@ -100,13 +142,14 @@ import { sha256 } from "@noble/hashes/sha2";
 import { pack, unpack, unpackMultiple } from "msgpackr";
 import { isNonEmptyReadonlyArray } from "../Array.js";
 import { assert } from "../Assert.js";
-import { BufferError, bytesToHex, bytesToUtf8, concatBytes, createBuffer, hexToBytes, utf8ToBytes, } from "../Buffer.js";
+import { bytesToHex, bytesToUtf8, createBuffer, hexToBytes, utf8ToBytes, } from "../Buffer.js";
 import { padmePaddingLength, } from "../Crypto.js";
 import { eqArrayNumber } from "../Eq.js";
 import { computeBalancedBuckets } from "../Number.js";
 import { objectToEntries } from "../Object.js";
 import { err, ok } from "../Result.js";
-import { Base64Url, DateIsoString, idTypeValueLength, JsonValueFromString, maxLength, NonNegativeInt, Number, } from "../Type.js";
+import { SqliteValue } from "../Sqlite.js";
+import { Base64Url, DateIsoString, Id, idTypeValueLength, JsonValueFromString, maxLength, NonNegativeInt, Number, object, record, } from "../Type.js";
 import { writeKeyLength, } from "./Owner.js";
 import { binaryTimestampToTimestamp, Counter, Millis, timestampToBinaryTimestamp, } from "./Timestamp.js";
 /** Maximum size of the entire protocol message in bytes. */
@@ -124,6 +167,25 @@ export const ProtocolErrorCode = {
     /** A code for {@link ProtocolSyncError}. */
     SyncError: 3,
 };
+export const WriteKeyMode = {
+    None: 0,
+    Single: 1,
+    Rotation: 2,
+};
+/**
+ * Base64Url string with maximum length of 256 characters. Encoding strings as
+ * Base64UrlString saves up to 25% in size compared to regular strings.
+ */
+export const Base64Url256 = maxLength(256)(Base64Url);
+/**
+ * A DbChange is a change to a table row. Together with a unique
+ * {@link Timestamp}, it forms a {@link CrdtMessage}.
+ */
+export const DbChange = object({
+    table: Base64Url256,
+    id: Id,
+    values: record(Base64Url256, SqliteValue),
+});
 export const RangeType = {
     Fingerprint: 1,
     Skip: 0,
@@ -142,6 +204,7 @@ export const zeroFingerprint = new Uint8Array(fingerprintSize);
  */
 export const createProtocolMessageFromCrdtMessages = (deps) => (owner, messages, maxSize) => {
     const buffer = createProtocolMessageBuffer(owner.id, {
+        type: "initiator",
         totalMaxSize: maxSize ?? maxProtocolMessageSize,
         writeKey: owner.writeKey,
     });
@@ -185,7 +248,7 @@ export const createProtocolMessageFromCrdtMessages = (deps) => (owner, messages,
 };
 /** Creates a {@link ProtocolMessage} for sync. */
 export const createProtocolMessageForSync = (deps) => (ownerId) => {
-    const buffer = createProtocolMessageBuffer(ownerId);
+    const buffer = createProtocolMessageBuffer(ownerId, { type: "initiator" });
     const binaryOwnerId = ownerIdToBinaryOwnerId(ownerId);
     const size = deps.storage.getSize(binaryOwnerId);
     // Errors are handled by the storage.
@@ -194,8 +257,16 @@ export const createProtocolMessageForSync = (deps) => (ownerId) => {
     splitRange(deps)(binaryOwnerId, 0, size, InfiniteUpperBound, buffer);
     return buffer.unwrap();
 };
-export const createProtocolMessageBuffer = (ownerId, options = {}) => {
-    const { errorCode, writeKey, totalMaxSize = maxProtocolMessageSize, rangesMaxSize = maxProtocolMessageRangesSize, version = protocolVersion, } = options;
+/** Creates a ProtocolMessage for {@link WriteKey} rotation. */
+export const createProtocolMessageForWriteKeyRotation = (ownerId, currentWriteKey, newWriteKey) => {
+    const buffer = createProtocolMessageBuffer(ownerId, {
+        type: "initiator",
+        writeKey: [currentWriteKey, newWriteKey],
+    });
+    return buffer.unwrap();
+};
+export const createProtocolMessageBuffer = (ownerId, options) => {
+    const { totalMaxSize = maxProtocolMessageSize, rangesMaxSize = maxProtocolMessageRangesSize, version = protocolVersion, } = options;
     const buffers = {
         header: createBuffer(),
         messages: {
@@ -210,17 +281,29 @@ export const createProtocolMessageBuffer = (ownerId, options = {}) => {
     };
     encodeNonNegativeInt(buffers.header, version);
     buffers.header.extend(ownerIdToBinaryOwnerId(ownerId));
-    if (errorCode != null)
-        buffers.header.extend([errorCode]);
+    if (options.type === "initiator") {
+        if (!options.writeKey) {
+            buffers.header.extend([WriteKeyMode.None]);
+        }
+        else if (!Array.isArray(options.writeKey)) {
+            buffers.header.extend([WriteKeyMode.Single]);
+            buffers.header.extend(options.writeKey);
+        }
+        else {
+            buffers.header.extend([WriteKeyMode.Rotation]);
+            buffers.header.extend(options.writeKey[0]); // current
+            buffers.header.extend(options.writeKey[1]); // new
+        }
+    }
+    else {
+        buffers.header.extend([options.errorCode]);
+    }
     let isLastRangeInfinite = false;
     const isWithinSizeLimits = () => getSize() <= totalMaxSize;
     const getSize = () => (getHeaderAndMessagesSize() + getRangesSize());
     const getHeaderAndMessagesSize = () => buffers.header.getLength() +
         buffers.messages.timestamps.getLength() +
-        buffers.messages.dbChanges.getLength() +
-        (buffers.messages.timestamps.getCount() > 0 && writeKey
-            ? writeKeyLength
-            : 0);
+        buffers.messages.dbChanges.getLength();
     const getRangesSize = () => buffers.ranges.timestamps.getCount() > 0
         ? buffers.ranges.timestamps.getLength() +
             buffers.ranges.types.getLength() +
@@ -306,8 +389,6 @@ export const createProtocolMessageBuffer = (ownerId, options = {}) => {
             }
             buffers.messages.timestamps.append(buffers.header);
             buffers.header.extend(buffers.messages.dbChanges.unwrap());
-            if (buffers.messages.timestamps.getCount() > 0 && writeKey)
-                buffers.header.extend(writeKey);
             if (buffers.ranges.timestamps.getCount() > 0) {
                 buffers.ranges.timestamps.append(buffers.header);
                 buffers.header.extend(buffers.ranges.types.unwrap());
@@ -386,36 +467,39 @@ const createRunLengthEncoder = (encodeValue) => {
     };
 };
 export const applyProtocolMessageAsClient = (deps) => (inputMessage, { getWriteKey, version = protocolVersion, totalMaxSize, rangesMaxSize, } = {}) => tryDecodeProtocolData(inputMessage, (input) => {
-    const requestedVersion = decodeNonNegativeInt(input);
+    const [requestedVersion, ownerId] = decodeVersionAndOwner(input);
     if (requestedVersion !== version) {
         return err({
             type: "ProtocolUnsupportedVersionError",
             unsupportedVersion: requestedVersion,
             isInitiator: version < requestedVersion,
+            ownerId,
         });
     }
-    const ownerId = decodeOwnerId(input);
-    const binaryOwnerId = ownerIdToBinaryOwnerId(ownerId);
     const errorCode = input.shift();
     if (errorCode !== ProtocolErrorCode.NoError) {
         switch (errorCode) {
             case ProtocolErrorCode.WriteKeyError:
                 return err({
                     type: "ProtocolWriteKeyError",
+                    ownerId,
                 });
             case ProtocolErrorCode.WriteError:
                 return err({
                     type: "ProtocolWriteError",
+                    ownerId,
                 });
             case ProtocolErrorCode.SyncError:
                 return err({
                     type: "ProtocolSyncError",
+                    ownerId,
                 });
             default:
                 throw new ProtocolDecodeError(`Invalid ProtocolErrorCode: ${errorCode}`);
         }
     }
     const messages = decodeMessages(input);
+    const binaryOwnerId = ownerIdToBinaryOwnerId(ownerId);
     if (isNonEmptyReadonlyArray(messages) &&
         !deps.storage.writeMessages(binaryOwnerId, messages)) {
         return ok(null);
@@ -426,6 +510,7 @@ export const applyProtocolMessageAsClient = (deps) => (inputMessage, { getWriteK
     if (writeKey == null)
         return ok(null);
     const output = createProtocolMessageBuffer(ownerId, {
+        type: "initiator",
         writeKey,
         totalMaxSize,
         rangesMaxSize,
@@ -435,36 +520,78 @@ export const applyProtocolMessageAsClient = (deps) => (inputMessage, { getWriteK
 export const applyProtocolMessageAsRelay = (deps) => (inputMessage, { subscribe, broadcast, totalMaxSize, rangesMaxSize, } = {}, 
 /** For testing purposes only; should not be used in production. */
 version = protocolVersion) => tryDecodeProtocolData(inputMessage, (input) => {
-    const requestedVersion = decodeNonNegativeInt(input);
+    const [requestedVersion, ownerId] = decodeVersionAndOwner(input);
+    const binaryOwnerId = ownerIdToBinaryOwnerId(ownerId);
     if (requestedVersion !== version) {
-        // Non-initiator responds with its version.
+        // Non-initiator responds with its version and ownerId.
         const output = createBuffer();
         encodeNonNegativeInt(output, version);
+        output.extend(binaryOwnerId);
         return ok(output.unwrap());
     }
-    const ownerId = decodeOwnerId(input);
-    const binaryOwnerId = ownerIdToBinaryOwnerId(ownerId);
     subscribe?.(ownerId);
+    const writeKeyMode = input.shift();
+    let writeKey;
+    let newWriteKey;
+    if (writeKeyMode !== WriteKeyMode.None) {
+        writeKey = input.shiftN(writeKeyLength);
+        switch (writeKeyMode) {
+            case WriteKeyMode.Single:
+                break;
+            case WriteKeyMode.Rotation:
+                newWriteKey = input.shiftN(writeKeyLength);
+                break;
+            default:
+                throw new ProtocolDecodeError(`Invalid WriteKeyMode: ${writeKeyMode}`);
+        }
+    }
+    if (writeKey) {
+        const isValid = deps.storage.validateWriteKey(binaryOwnerId, writeKey);
+        if (!isValid) {
+            return ok(createProtocolMessageBuffer(ownerId, {
+                type: "non-initiator",
+                errorCode: ProtocolErrorCode.WriteKeyError,
+            }).unwrap());
+        }
+        if (newWriteKey) {
+            const rotationSuccess = deps.storage.setWriteKey(binaryOwnerId, newWriteKey);
+            if (!rotationSuccess) {
+                return ok(createProtocolMessageBuffer(ownerId, {
+                    type: "non-initiator",
+                    errorCode: ProtocolErrorCode.WriteError,
+                }).unwrap());
+            }
+        }
+    }
     const messages = decodeMessages(input);
     if (isNonEmptyReadonlyArray(messages)) {
-        const messagesEnd = inputMessage.length - input.getLength();
-        const writeKey = input.shiftN(writeKeyLength);
-        const writeKeyIsValid = deps.storage.validateWriteKey(binaryOwnerId, writeKey);
-        if (!writeKeyIsValid)
+        if (!writeKey)
             return ok(createProtocolMessageBuffer(ownerId, {
+                type: "non-initiator",
                 errorCode: ProtocolErrorCode.WriteKeyError,
             }).unwrap());
-        if (broadcast) {
-            // Instead of encoding a new protocol message, we reuse the inputMessage.
-            const broadcastMessage = concatBytes(inputMessage.slice(0, 17), new Uint8Array([ProtocolErrorCode.NoError]), inputMessage.slice(17, messagesEnd));
-            broadcast(ownerId, broadcastMessage);
+        // Only broadcast if there's no ranges.
+        if (broadcast && input.getLength() === 0) {
+            const broadcastBuffer = createProtocolMessageBuffer(ownerId, {
+                type: "non-initiator",
+                errorCode: ProtocolErrorCode.NoError,
+                totalMaxSize,
+                rangesMaxSize,
+                version,
+            });
+            for (const message of messages) {
+                broadcastBuffer.addMessage(message);
+            }
+            broadcast(ownerId, broadcastBuffer.unwrap());
         }
         if (!deps.storage.writeMessages(binaryOwnerId, messages))
             return ok(createProtocolMessageBuffer(ownerId, {
+                type: "non-initiator",
                 errorCode: ProtocolErrorCode.WriteError,
             }).unwrap());
     }
     const output = createProtocolMessageBuffer(ownerId, {
+        type: "non-initiator",
         errorCode: ProtocolErrorCode.NoError,
         totalMaxSize,
         rangesMaxSize,
@@ -481,15 +608,22 @@ const tryDecodeProtocolData = (data, callback) => {
         return callback(createBuffer(data));
     }
     catch (error) {
-        if (error instanceof ProtocolDecodeError || error instanceof BufferError)
-            return err({
-                type: "ProtocolInvalidDataError",
-                data,
-                error,
-            });
-        throw error;
+        return err({
+            type: "ProtocolInvalidDataError",
+            data,
+            error,
+        });
     }
 };
+const decodeVersionAndOwner = (input) => {
+    // This structure must never change across protocol versions. The version
+    // and owner ID must always be the first two fields in every protocol message
+    // to enable version negotiation and owner identification before any other
+    // processing occurs.
+    const version = decodeNonNegativeInt(input);
+    const ownerId = decodeOwnerId(input);
+    return [version, ownerId];
+};
 /**
  * Error thrown for internal protocol validation failures, such as invalid data
  * or type errors.
@@ -525,6 +659,7 @@ const sync = (deps) => (role, input, output, ownerId) => {
             return ok(null);
         }
         const message = createProtocolMessageBuffer(binaryOwnerId, {
+            type: "non-initiator",
             errorCode: ProtocolErrorCode.SyncError,
         });
         return ok(message.unwrap());
@@ -807,11 +942,6 @@ export const idToBinaryId = (id) => base64Url256ToBytes(id);
 export const binaryIdToId = (binaryId) => decodeId(createBuffer(binaryId));
 export const ownerIdToBinaryOwnerId = (ownerId) => base64Url256ToBytes(ownerId);
 export const binaryOwnerIdToOwnerId = (binaryOwnerId) => decodeOwnerId(createBuffer(binaryOwnerId));
-/**
- * Base64Url string with maximum length of 256 characters. Encoding strings as
- * Base64UrlString saves up to 25% in size compared to regular strings.
- */
-export const Base64Url256 = maxLength(256)(Base64Url);
 /**
  * Alphabet used for Base64Url encoding. This is copied from the `nanoid`
  * library to avoid dependency on a specific version of `nanoid`.
@@ -1149,3 +1279,23 @@ export const decodeSqliteValue = (buffer) => {
             throw new ProtocolDecodeError("invalid ProtocolValueType");
     }
 };
+/**
+ * Decodes a ProtocolMessage into a readable JSON object for debugging.
+ *
+ * Note: This is a stub for future implementation. It should use:
+ *
+ * - DecodeVersionAndOwner
+ * - DecodeError or decodeWriteKeys (depending on context)
+ * - DecodeMessages
+ * - DecodeRanges
+ *
+ * If you want to help, please contribute to this function.
+ */
+export const decodeProtocolMessageToJson = (_protocolMessage, _isInitiator) => {
+    // TODO: Implement using
+    // - decodeVersionAndOwner
+    // -- decodeError or decodeWriteKeys (should be refactored out),
+    // -- decodeMessages, and decodeRanges.
+    // This is a stub for PRs and community contributions.
+    throw new Error("decodeProtocolMessageToJson is not implemented yet.");
+};

package/dist/src/Evolu/Relay.d.ts

@@ -1,4 +1,5 @@
 import { ConsoleConfig } from "../Console.js";
+import { TimingSafeEqualDep } from "../Crypto.js";
 import { Result } from "../Result.js";
 import { SqliteError } from "../Sqlite.js";
 import { SimpleName } from "../Type.js";
@@ -9,5 +10,6 @@ export interface Relay extends Disposable {
 export interface RelayConfig extends ConsoleConfig {
     readonly name?: SimpleName;
 }
-export declare const createRelayStorage: (deps: SqliteStorageDeps) => (options: CreateSqliteStorageBaseOptions) => Result<Storage, SqliteError>;
+export type RelaySqliteStorageDeps = SqliteStorageDeps & TimingSafeEqualDep;
+export declare const createRelayStorage: (deps: RelaySqliteStorageDeps) => (options: CreateSqliteStorageBaseOptions) => Result<Storage, SqliteError>;
 //# sourceMappingURL=Relay.d.ts.map

package/dist/src/Evolu/Relay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Relay.d.ts","sourceRoot":"","sources":["../../../src/Evolu/Relay.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAE9C,OAAO,EAAM,MAAM,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAO,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,OAAO,EAAqB,OAAO,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,EAEL,8BAA8B,EAC9B,iBAAiB,EAClB,MAAM,cAAc,CAAC;AAGtB,MAAM,WAAW,KAAM,SAAQ,UAAU;CAAG;AAE5C,MAAM,WAAW,WAAY,SAAQ,aAAa;IAChD,QAAQ,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC;CAC5B;AAED,eAAO,MAAM,kBAAkB,GAC5B,MAAM,iBAAiB,MACvB,SAAS,8BAA8B,KAAG,MAAM,CAAC,OAAO,EAAE,WAAW,CAsHrE,CAAC"}
+{"version":3,"file":"Relay.d.ts","sourceRoot":"","sources":["../../../src/Evolu/Relay.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAW,MAAM,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAO,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,OAAO,EAAqB,OAAO,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,EAEL,8BAA8B,EAC9B,iBAAiB,EAClB,MAAM,cAAc,CAAC;AAGtB,MAAM,WAAW,KAAM,SAAQ,UAAU;CAAG;AAE5C,MAAM,WAAW,WAAY,SAAQ,aAAa;IAChD,QAAQ,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC;CAC5B;AAED,MAAM,MAAM,sBAAsB,GAAG,iBAAiB,GAAG,kBAAkB,CAAC;AAE5E,eAAO,MAAM,kBAAkB,GAC5B,MAAM,sBAAsB,MAC5B,SAAS,8BAA8B,KAAG,MAAM,CAAC,OAAO,EAAE,WAAW,CA6JrE,CAAC"}

package/dist/src/Evolu/Relay.js

@@ -1,6 +1,5 @@
 import { isNonEmptyReadonlyArray } from "../Array.js";
-import { eqArrayNumber } from "../Eq.js";
-import { ok } from "../Result.js";
+import { err, ok } from "../Result.js";
 import { sql } from "../Sqlite.js";
 import { createSqliteStorageBase, } from "./Storage.js";
 import { timestampToBinaryTimestamp } from "./Timestamp.js";
@@ -64,7 +63,20 @@ export const createRelayStorage = (deps) => (options) => {
                 }
                 return true;
             }
-            return eqArrayNumber(rows[0].writeKey, writeKey);
+            return deps.timingSafeEqual(rows[0].writeKey, writeKey);
+        },
+        setWriteKey: (ownerId, writeKey) => {
+            const upsertWriteKey = deps.sqlite.exec(sql `
+          insert into evolu_writeKey (ownerId, writeKey)
+          values (${ownerId}, ${writeKey})
+          on conflict (ownerId) do update
+            set writeKey = excluded.writeKey;
+        `);
+            if (!upsertWriteKey.ok) {
+                options.onStorageError(upsertWriteKey.error);
+                return false;
+            }
+            return true;
         },
         writeMessages: (ownerId, messages) => {
             const result = deps.sqlite.transaction(() => {
@@ -105,5 +117,29 @@ export const createRelayStorage = (deps) => (options) => {
             }
             return result.value.rows[0]?.change;
         },
+        deleteOwner: (ownerId) => {
+            const result = deps.sqlite.transaction(() => {
+                const del1 = deps.sqlite.exec(sql `
+            delete from evolu_writeKey where ownerId = ${ownerId};
+          `);
+                if (!del1.ok)
+                    return del1;
+                const del2 = deps.sqlite.exec(sql `
+            delete from evolu_message where ownerId = ${ownerId};
+          `);
+                if (!del2.ok)
+                    return del2;
+                const del3 = sqliteStorageBase.value.deleteOwner(ownerId);
+                if (!del3)
+                    return err(null);
+                return ok();
+            });
+            if (!result.ok) {
+                if (result.error)
+                    options.onStorageError(result.error);
+                return false;
+            }
+            return true;
+        },
     });
 };