@evolu/common 6.0.1-preview.3 → 6.0.1-preview.31

package/dist/src/Evolu/Storage.js

@@ -1,75 +1,78 @@
+import { sha256 } from "@noble/hashes/sha2.js";
+import { firstInArray, isNonEmptyReadonlyArray, } from "../Array.js";
+import { assert } from "../Assert.js";
+import { concatBytes } from "../Buffer.js";
+import { decrement } from "../Number.js";
+import { ok } from "../Result.js";
+import { sql, SqliteValue } from "../Sqlite.js";
+import { Id, NonNegativeInt, object, PositiveInt, record, String, } from "../Type.js";
+import { orderTimestampBytes } from "./Timestamp.js";
+export const fingerprintSize = NonNegativeInt.orThrow(12);
+/** A fingerprint of an empty range. */
+export const zeroFingerprint = new Uint8Array(fingerprintSize);
+export const InfiniteUpperBound = Symbol("InfiniteUpperBound");
+export const RangeType = {
+    Fingerprint: 1,
+    Skip: 0,
+    Timestamps: 2,
+};
 /**
- * Evolu Storage for SQLite
- *
- * Evolu uses a Skiplist, which leverages SQLite indexes. The core logic is
- * implemented in SQL, so it doesn't have to make roundtrips to the DB.
- *
- * The ideal storage for a Relay should use a similar architecture to
- * [strfry](https://github.com/hoytech/strfry) (a KV storage), but with Skiplist
- * to ensure that insertion order doesn't matter (local-first apps can often
- * write in the past.)
- *
- * The ideal client implementation should probably use the SQLite extension
- * instead of SQL or even a KV storage, when such a thing for browsers/native
- * will exist and will be faster than SQLite.
- *
- * # Scaling
+ * 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: String,
+    id: Id,
+    values: record(String, SqliteValue),
+});
+/**
+ * Creates a {@link BaseSqliteStorage} implementation.
  *
- * The load can be distributed by deploying multiple relays, synchronized with
- * each other, if necessary. One relay should handle hundreds of thousands of
- * users, and when it goes down, nothing happens, because it will be
- * synchronized later.
+ * # Stateless Design
  *
- * @module
+ * 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.
  */
-import { assert } from "../Assert.js";
-import { decrement } from "../Number.js";
-import { ok } from "../Result.js";
-import { sql } from "../Sqlite.js";
-import { binaryOwnerIdToOwnerId, binaryTimestampToFingerprint, InfiniteUpperBound, RangeType, zeroFingerprint, } from "./Protocol.js";
-import { orderBinaryTimestamp } from "./Timestamp.js";
-export const createSqliteStorageBase = (deps) => (options) => {
-    const createTablesResult = createTables(deps);
-    if (!createTablesResult.ok)
-        return createTablesResult;
-    const ownerStats = new Map();
-    return ok({
-        insertTimestamp: (ownerId, timestamp) => {
-            const ownerIdString = binaryOwnerIdToOwnerId(ownerId);
+export const createBaseSqliteStorage = (deps) => (config) => {
+    return {
+        insertTimestamp: (ownerId, timestamp, strategy) => {
             const level = randomSkiplistLevel(deps);
-            let stats = ownerStats.get(ownerIdString);
-            if (!stats) {
-                const result = deps.sqlite.exec(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;
-            if (orderBinaryTimestamp(timestamp, stats.maxT) === 1) {
-                strategy = "append";
-                stats.maxT = timestamp;
-            }
-            else if (orderBinaryTimestamp(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(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) {
-                options.onStorageError(size.error);
+                config.onStorageError(size.error);
                 return null;
             }
             return size.value;
@@ -78,7 +81,7 @@ export const createSqliteStorageBase = (deps) => (options) => {
             assertBeginEnd(begin, end);
             const result = fingerprint(deps)(ownerId, begin, end);
             if (!result.ok) {
-                options.onStorageError(result.error);
+                config.onStorageError(result.error);
                 return null;
             }
             return result.value;
@@ -86,7 +89,7 @@ export const createSqliteStorageBase = (deps) => (options) => {
         fingerprintRanges: (ownerId, buckets, upperBound) => {
             const ranges = fingerprintRanges(deps)(ownerId, buckets, upperBound);
             if (!ranges.ok) {
-                options.onStorageError(ranges.error);
+                config.onStorageError(ranges.error);
                 return null;
             }
             return ranges.value;
@@ -94,7 +97,7 @@ export const createSqliteStorageBase = (deps) => (options) => {
         findLowerBound: (ownerId, begin, end, upperBound) => {
             const lowerBound = findLowerBound(deps)(ownerId, begin, end, upperBound);
             if (!lowerBound.ok) {
-                options.onStorageError(lowerBound.error);
+                config.onStorageError(lowerBound.error);
                 return null;
             }
             return lowerBound.value;
@@ -107,7 +110,7 @@ export const createSqliteStorageBase = (deps) => (options) => {
             // This is much faster than SQL limit with offset.
             const first = getTimestampByIndex(deps)(ownerId, begin);
             if (!first.ok) {
-                options.onStorageError(first.error);
+                config.onStorageError(first.error);
                 return;
             }
             if (!callback(first.value, begin))
@@ -132,21 +135,31 @@ export const createSqliteStorageBase = (deps) => (options) => {
           limit ${length - 1};
         `);
             if (!result.ok) {
-                options.onStorageError(result.error);
+                config.onStorageError(result.error);
                 return;
             }
             for (let i = 0; i < result.value.rows.length; i++) {
-                const index = (begin + 1 + i);
+                const index = NonNegativeInt.orThrow(begin + 1 + i);
                 if (!callback(result.value.rows[i].t, index))
                     return;
             }
         },
-    });
+        deleteOwner: (ownerId) => {
+            const result = deps.sqlite.exec(sql `
+          delete from evolu_timestamp where ownerId = ${ownerId};
+        `);
+            if (!result.ok) {
+                config.onStorageError(result.error);
+                return false;
+            }
+            return true;
+        },
+    };
 };
 const assertBeginEnd = (begin, end) => {
     assert(begin <= end, "invalid begin or end");
 };
-const createTables = (deps) => {
+export const createBaseSqliteStorageTables = (deps) => {
     for (const query of [
         /**
          * Creates the `evolu_timestamp` table for storing timestamps of multiple
@@ -159,19 +172,13 @@ const createTables = (deps) => {
          *
          * Columns:
          *
-         * - `t` – globally unique binary timestamp
+         * - `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 if not exists evolu_timestamp (
+      create table evolu_timestamp (
         "ownerId" blob not null,
         "t" blob not null,
         "h1" integer,
@@ -183,7 +190,7 @@ const createTables = (deps) => {
       strict;
     `,
         sql `
-      create index if not exists evolu_timestamp_index on evolu_timestamp (
+      create index evolu_timestamp_index on evolu_timestamp (
         "ownerId",
         "l",
         "t",
@@ -191,6 +198,25 @@ const createTables = (deps) => {
         "h2",
         "c"
       );
+    `,
+        /**
+         * Creates the `evolu_usage` table for tracking data consumption per owner.
+         *
+         * Columns:
+         *
+         * - `ownerId` – OwnerIdBytes (primary key)
+         * - `storedBytes` – total bytes stored in database
+         * - `firstTimestamp` – for timestamp insertion strategies
+         * - `lastTimestamp` – for timestamp insertion strategies
+         */
+        sql `
+      create table evolu_usage (
+        "ownerId" blob primary key,
+        "storedBytes" integer not null,
+        "firstTimestamp" blob,
+        "lastTimestamp" blob
+      )
+      strict;
     `,
     ]) {
         const result = deps.sqlite.exec(query);
@@ -199,16 +225,37 @@ const createTables = (deps) => {
     }
     return ok();
 };
-// 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.
+/**
+ * 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, firstTimestamp, lastTimestamp) => {
+    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
+ * 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) => (ownerId, timestamp, level, strategy) => {
-    const [h1, h2] = fingerprintToSqliteFingerprint(binaryTimestampToFingerprint(timestamp));
+    const [h1, h2] = fingerprintToSqliteFingerprint(timestampBytesToFingerprint(timestamp));
     let queries = [];
     switch (strategy) {
         case "append":
@@ -717,6 +764,10 @@ const insertTimestamp = (deps) => (ownerId, timestamp, level, strategy) => {
     }
     return ok();
 };
+export const timestampBytesToFingerprint = (timestamp) => {
+    const hash = sha256(timestamp).slice(0, fingerprintSize);
+    return hash;
+};
 /**
  * Generates a random skiplist level in the range [1, skiplistMaxLevel].
  * Probabilistic approach avoids the need for explicit tree balancing.
@@ -727,7 +778,7 @@ const randomSkiplistLevel = (deps) => {
         level < skiplistMaxLevel) {
         level += 1;
     }
-    return level;
+    return PositiveInt.orThrow(level);
 };
 /**
  * Probability used for generating Skiplist levels.
@@ -830,7 +881,7 @@ const findLowerBound = (deps) => (ownerId, begin, end, upperBound) => {
     if (!count.ok)
         return count;
     // `decrement` converts a count to an index.
-    return ok(decrement(count.value));
+    return ok(NonNegativeInt.orThrow(decrement(count.value)));
 };
 const getTimestampCount = (deps) => (ownerId, timestamp) => {
     const result = deps.sqlite.exec(sql.prepared `
@@ -1109,3 +1160,50 @@ export const getTimestampByIndex = (deps) => (ownerId, index) => {
         return result;
     return ok(result.value.rows[0].pt);
 };
+/** Retrieves usage information for an owner from the evolu_usage table. */
+export const getOwnerUsage = (deps) => (ownerIdBytes, initialTimestamp) => {
+    const result = deps.sqlite.exec(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) => (ownerIdBytes, storedBytes, firstTimestamp, lastTimestamp) => {
+    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();
+};

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

@@ -1,23 +1,77 @@
-import { ConsoleConfig, ConsoleDep } from "../Console.js";
-import { ProtocolMessage } from "./Protocol.js";
-import { Millis } from "./Timestamp.js";
-export interface Sync {
-    readonly send: (message: ProtocolMessage) => void;
+import { NonEmptyReadonlyArray } from "../Array.js";
+import { ConsoleDep } from "../Console.js";
+import { RandomBytesDep, SymmetricCryptoDecryptError, SymmetricCryptoDep } from "../Crypto.js";
+import { TransferableError } from "../Error.js";
+import { RandomDep } from "../Random.js";
+import { Result } from "../Result.js";
+import { SqliteDep, SqliteError } from "../Sqlite.js";
+import { TimeDep } from "../Time.js";
+import { CreateWebSocketDep } from "../WebSocket.js";
+import type { PostMessageDep } from "./Db.js";
+import { AppOwner, OwnerEncryptionKey, OwnerId, OwnerIdBytes, OwnerTransport, OwnerWriteKey } from "./Owner.js";
+import { ProtocolError, ProtocolInvalidDataError, ProtocolTimestampMismatchError } from "./Protocol.js";
+import { MutationChange } from "./Schema.js";
+import { BaseSqliteStorage, CrdtMessage, Storage, StorageInsertTimestampStrategy } from "./Storage.js";
+import { Millis, Timestamp, TimestampConfigDep, TimestampCounterOverflowError, TimestampDriftError, TimestampTimeOutOfRangeError } from "./Timestamp.js";
+export interface Sync extends Disposable {
+    /**
+     * Assigns or removes an owner to/from transports with reference counting.
+     *
+     * Owners are only "active" if assigned to at least one transport. Uses
+     * `owner.transports` or falls back to config transports. Multiple calls
+     * increment/decrement reference counts (useful for React Hooks).
+     */
+    readonly useOwner: (use: boolean, owner: SyncOwner) => void;
+    readonly applyChanges: (changes: NonEmptyReadonlyArray<MutationChange>) => Result<void, SqliteError | TimestampCounterOverflowError | TimestampDriftError | TimestampTimeOutOfRangeError>;
 }
 export interface SyncDep {
     readonly sync: Sync;
 }
-export type CreateSync = (deps: ConsoleDep) => (config: SyncConfig) => Sync;
-export interface CreateSyncDep {
-    readonly createSync: CreateSync;
+/**
+ * Represents an owner for sync operations. This is a unified interface that
+ * abstracts over the specific owner types ({@link ShardOwner},
+ * {@link SharedOwner}, {@link SharedReadonlyOwner}) for the sync layer.
+ *
+ * The sync layer only needs the essential data for synchronization and doesn't
+ * need to distinguish between different owner types.
+ */
+export interface SyncOwner {
+    readonly id: OwnerId;
+    readonly encryptionKey: OwnerEncryptionKey;
+    /** Optional for read-only owners like {@link SharedReadonlyOwner}. */
+    readonly writeKey?: OwnerWriteKey;
+    readonly transports?: ReadonlyArray<OwnerTransport>;
+}
+export interface SyncConfig {
+    readonly appOwner: AppOwner;
+    readonly transports: ReadonlyArray<OwnerTransport>;
+    /**
+     * Delay in milliseconds before disposing unused WebSocket connections.
+     * Defaults to 100ms.
+     */
+    readonly disposalDelayMs?: number;
+    readonly onError: (error: ProtocolError | ProtocolInvalidDataError | ProtocolTimestampMismatchError | SqliteError | SymmetricCryptoDecryptError | TimestampCounterOverflowError | TimestampDriftError | TimestampTimeOutOfRangeError | TransferableError) => void;
+    readonly onReceive: () => void;
 }
-export interface SyncConfig extends ConsoleConfig {
-    readonly syncUrl: string;
-    readonly onOpen: (send: Sync["send"]) => void;
-    readonly onMessage: (message: Uint8Array, send: Sync["send"]) => void;
+export declare const createSync: (deps: ClockDep & ConsoleDep & CreateWebSocketDep & PostMessageDep & RandomBytesDep & RandomDep & SqliteDep & SymmetricCryptoDep & TimeDep & TimestampConfigDep) => (config: SyncConfig) => Result<Sync, SqliteError>;
+export interface ClockDep {
+    readonly clock: Clock;
 }
-export declare const createWebSocketSync: CreateSync;
+export interface Clock {
+    readonly get: () => Timestamp;
+    readonly save: (timestamp: Timestamp) => Result<void, SqliteError>;
+}
+export declare const createClock: (deps: RandomBytesDep & SqliteDep) => (initialTimestamp?: Timestamp) => Clock;
+export interface ClientStorage extends Storage, BaseSqliteStorage {
+}
+export interface ClientStorageDep {
+    readonly storage: ClientStorage;
+}
+export declare const applyLocalOnlyChange: (deps: SqliteDep & TimeDep) => (change: MutationChange) => Result<void, SqliteError>;
+export declare const applyMessageToTimestampAndHistoryTables: (deps: ClientStorageDep & SqliteDep) => (ownerId: OwnerIdBytes, message: CrdtMessage, strategy: StorageInsertTimestampStrategy) => Result<void, SqliteError>;
 /**
+ * TODO: Rework for the new owners API.
+ *
  * The possible states of a synchronization process. The `SyncState` can be one
  * of the following:
  *

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

@@ -1 +1 @@
-{"version":3,"file":"Sync.d.ts","sourceRoot":"","sources":["../../../src/Evolu/Sync.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE1D,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAExC,MAAM,WAAW,IAAI;IACnB,QAAQ,CAAC,IAAI,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,IAAI,CAAC;CACnD;AAED,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;CACrB;AAED,MAAM,MAAM,UAAU,GAAG,CAAC,IAAI,EAAE,UAAU,KAAK,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,CAAC;AAE5E,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;CACjC;AAED,MAAM,WAAW,UAAW,SAAQ,aAAa;IAC/C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC;IAC9C,QAAQ,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC;CACvE;AAED,eAAO,MAAM,mBAAmB,EAAE,UA2BjC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,SAAS,GACjB,gBAAgB,GAChB,kBAAkB,GAClB,iBAAiB,GACjB,oBAAoB,CAAC;AAEzB;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;CACnC;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;CACrC;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,YAAY,GAAG,WAAW,GAAG,oBAAoB,CAAC;CACnE;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;CAC/B;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAC;CACvC;AAED,eAAO,MAAM,gBAAgB,EAAE,gBAA+C,CAAC"}
+{"version":3,"file":"Sync.d.ts","sourceRoot":"","sources":["../../../src/Evolu/Sync.ts"],"names":[],"mappings":"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"}