@evolu/common 6.0.1-preview.2 → 6.0.1-preview.20

package/dist/src/Evolu/Schema.js

@@ -1,97 +1,38 @@
-import { pack } from "msgpackr";
+import * as Kysely from "kysely";
 import { mapObject, objectToEntries } from "../Object.js";
-import { err, ok } from "../Result.js";
-import { SqliteBoolean } from "../Sqlite.js";
-import { brand, createTypeErrorFormatter, DateIsoString, EvoluType, nullableToOptional, nullOr, object, omit, optional, record, Unknown, } from "../Type.js";
-import { createIndexes } from "./Kysely.js";
-import { Base64Url256, } from "./Protocol.js";
-export const DefaultColumns = object({
-    createdAt: DateIsoString,
-    updatedAt: DateIsoString,
-    isDeleted: nullOr(SqliteBoolean),
-});
-const isDefaultColumnName = (value) => value === "createdAt" || value === "updatedAt" || value === "isDeleted";
-/**
- * Valid {@link EvoluSchema}.
- *
- * - Table and column names must be Base64Url strings.
- * - Each table must include an `id` column of type {@link Id}.
- * - Default column names (`createdAt`, `updatedAt`, `isDeleted`) are not allowed.
- */
-export const ValidEvoluSchema = brand("ValidEvoluSchema", record(Base64Url256, object({ id: EvoluType }, record(Base64Url256, Unknown))), (value) => {
-    for (const tableName in value) {
-        for (const columnName in value[tableName]) {
-            if (isDefaultColumnName(columnName)) {
-                return err({
-                    type: "ValidEvoluSchema",
-                    value,
-                    reason: {
-                        kind: "DefaultColumnError",
-                        tableName,
-                        columnName,
-                    },
-                });
-            }
-        }
-    }
-    return ok(value);
-});
-/**
- * Asserts that the given value is {@link ValidEvoluSchema}.
- *
- * Throws an error if the value is not a valid Evolu schema.
- */
-export const assertValidEvoluSchema = (value) => {
-    const validEvoluSchema = ValidEvoluSchema.fromUnknown(value);
-    if (!validEvoluSchema.ok) {
-        const message = formatValidEvoluSchemaError(validEvoluSchema.error);
-        throw new Error(`Invalid Evolu schema: ${message}`);
-    }
-    return validEvoluSchema.value;
-};
-const formatValidEvoluSchemaError = (error) => {
-    if (error.type === "Record") {
-        if (error.reason.kind === "Key") {
-            return `The table "${error.reason.key}" has invalid name. A table name must be Base64Url256 string (A-Z, a-z, 0-9, -, _).`;
-        }
-        if (error.reason.kind === "Value" &&
-            error.reason.error.reason.kind === "Props" &&
-            error.reason.error.reason.errors.id?.type === "EvoluType") {
-            return `The table "${error.reason.key}" has invalid ID column. Check examples.`;
-        }
-        if (error.reason.kind === "Value" &&
-            error.reason.error.reason.kind === "IndexKey") {
-            return `The table "${error.reason.key}" has invalid column name "${error.reason.error.reason.key}". A column name must be Base64Url256 string (A-Z, a-z, 0-9, -, _).`;
-        }
-    }
-    if (error.type === "ValidEvoluSchema") {
-        return `The table "${error.reason.tableName}" uses reserved column name "${error.reason.columnName}". Reserved column names are: createdAt, updatedAt, isDeleted.`;
-    }
-    return JSON.stringify(error, null, 2);
-};
-export const validEvoluSchemaToDbSchema = (validEvoluSchema, indexes) => {
-    const tables = objectToEntries(validEvoluSchema).map(([tableName, table]) => ({
+import { ok } from "../Result.js";
+import { sql, SqliteBoolean, } from "../Sqlite.js";
+import { array, DateIso, nullableToOptional, nullOr, object, omit, optional, String, validMutationSize, } from "../Type.js";
+export const evoluSchemaToDbSchema = (schema, indexesConfig) => {
+    const tables = objectToEntries(schema).map(([tableName, table]) => ({
         name: tableName,
         columns: objectToEntries(table)
             .filter(([k]) => k !== "id")
             .map(([k]) => k),
     }));
-    return {
-        tables,
-        indexes: createIndexes(indexes),
-    };
+    const indexes = indexesConfig
+        ? indexesConfig(createIndex).map((index) => ({
+            name: index.toOperationNode().name.name,
+            sql: index.compile().sql,
+        }))
+        : [];
+    return { tables, indexes };
 };
 /**
- * Evolu has to limit the maximum mutation size. Otherwise, sync couldn't use
- * the {@link maxProtocolMessageRangesSize}. The max size is 640KB in bytes,
- * measured via MessagePack. Evolu Protocol DbChange will be smaller thanks to
- * various optimizations.
+ * Default columns automatically added to all tables.
+ *
+ * - `createdAt`: Set by Evolu when `insert` is called, or can be custom with
+ *   `upsert`.
+ * - `updatedAt`: Always set by Evolu, derived from {@link CrdtMessage} timestamp.
+ *   If you defer sync to avoid leaking time activity, use a custom column to
+ *   preserve real update time.
+ * - `isDeleted`: Soft delete flag.
  */
-export const maxMutationSize = 655360;
-const validMutationSize = (type) => brand("ValidMutationSize", type, (value) => pack(value).byteLength <= maxMutationSize
-    ? ok(value)
-    : err({ type: "ValidMutationSize", value }));
-export const formatValidMutationSizeError = createTypeErrorFormatter((error) => `The mutation size exceeds the maximum limit of ${maxMutationSize} bytes. The provided mutation has a size of ${pack(error.value).byteLength} bytes.`);
+export const DefaultColumns = object({
+    createdAt: DateIso,
+    updatedAt: DateIso,
+    isDeleted: nullOr(SqliteBoolean),
+});
 /**
  * Type Factory to create insertable {@link Type}. It makes nullable Types
  * optional, omits Id, and ensures the {@link maxMutationSize}.
@@ -135,16 +76,155 @@ export const updateable = (props) => {
     return validMutationSize(object(updateableProps));
 };
 /**
- * Type Factory to create upsertable Type. It makes nullable Types optional and
- * ensures the {@link maxMutationSize}.
+ * Type Factory to create upsertable Type. It makes nullable Types optional,
+ * includes optional default columns (createdAt, isDeleted), and ensures the
+ * {@link maxMutationSize}.
  *
  * ### Example
  *
  * ```ts
  * const UpsertableTodo = upsertable(Schema.todo);
  * type UpsertableTodo = typeof UpsertableTodo.Type;
- * const todo = UpsertableTodo.from({ id, title });
+ * const todo = UpsertableTodo.from({
+ *   id,
+ *   title,
+ *   createdAt: "2023-01-01T00:00:00.000Z",
+ * });
  * if (!todo.ok) return; // handle errors
  * ```
  */
-export const upsertable = (props) => validMutationSize(nullableToOptional(props));
+export const upsertable = (props) => {
+    const propsWithDefaults = {
+        ...props,
+        createdAt: optional(DateIso),
+        isDeleted: optional(SqliteBoolean),
+    };
+    return validMutationSize(nullableToOptional(propsWithDefaults));
+};
+export const DbTable = object({
+    name: String,
+    columns: array(String),
+});
+export const DbIndex = object({ name: String, sql: String });
+export const DbSchema = object({
+    tables: array(DbTable),
+    indexes: array(DbIndex),
+});
+/** Get the current database schema by reading SQLite metadata. */
+export const getDbSchema = (deps) => ({ allIndexes = false } = {}) => {
+    const map = new Map();
+    const tableAndColumnInfoRows = deps.sqlite.exec(sql `
+      select
+        sqlite_master.name as tableName,
+        table_info.name as columnName
+      from
+        sqlite_master
+        join pragma_table_info(sqlite_master.name) as table_info;
+    `);
+    if (!tableAndColumnInfoRows.ok)
+        return tableAndColumnInfoRows;
+    tableAndColumnInfoRows.value.rows.forEach((row) => {
+        const { tableName, columnName } = row;
+        if (!map.has(tableName))
+            map.set(tableName, []);
+        map.get(tableName)?.push(columnName);
+    });
+    const tables = Array.from(map, ([name, columns]) => ({ name, columns }));
+    const indexesRows = deps.sqlite.exec(allIndexes
+        ? sql `
+            select name, sql
+            from sqlite_master
+            where type = 'index' and name not like 'sqlite_%';
+          `
+        : sql `
+            select name, sql
+            from sqlite_master
+            where
+              type = 'index'
+              and name not like 'sqlite_%'
+              and name not like 'evolu_%';
+          `);
+    if (!indexesRows.ok)
+        return indexesRows;
+    const indexes = indexesRows.value.rows.map((row) => ({
+        name: row.name,
+        /**
+         * SQLite returns "CREATE INDEX" for "create index" for some reason.
+         * Other keywords remain unchanged. We have to normalize the casing for
+         * {@link indexesAreEqual} manually.
+         */
+        sql: row.sql
+            .replace("CREATE INDEX", "create index")
+            .replace("CREATE UNIQUE INDEX", "create unique index"),
+    }));
+    return ok({ tables, indexes });
+};
+const indexesAreEqual = (self, that) => self.name === that.name && self.sql === that.sql;
+export const ensureDbSchema = (deps) => (newSchema, currentSchema, options) => {
+    const queries = [];
+    newSchema.tables.forEach((newTable) => {
+        const currentTable = currentSchema.tables.find((t) => t.name === newTable.name);
+        if (!currentTable) {
+            queries.push({
+                sql: createTableWithDefaultColumns(newTable.name, newTable.columns),
+                parameters: [],
+            });
+        }
+        else {
+            newTable.columns
+                .filter((newColumn) => !currentTable.columns.includes(newColumn))
+                .forEach((newColumn) => {
+                queries.push(sql `
+              alter table ${sql.identifier(newTable.name)}
+              add column ${sql.identifier(newColumn)} blob;
+            `);
+            });
+        }
+    });
+    if (options?.ignoreIndexes !== true) {
+        // Remove current indexes that are not in the newSchema.
+        currentSchema.indexes
+            .filter((currentIndex) => !newSchema.indexes.some((newIndex) => indexesAreEqual(newIndex, currentIndex)))
+            .forEach((index) => {
+            queries.push(sql `drop index ${sql.identifier(index.name)};`);
+        });
+        // Add new indexes that are not in the currentSchema.
+        newSchema.indexes
+            .filter((newIndex) => !currentSchema.indexes.some((currentIndex) => indexesAreEqual(newIndex, currentIndex)))
+            .forEach((newIndex) => {
+            queries.push({ sql: `${newIndex.sql};`, parameters: [] });
+        });
+    }
+    for (const query of queries) {
+        const result = deps.sqlite.exec(query);
+        if (!result.ok)
+            return result;
+    }
+    return ok();
+};
+const createTableWithDefaultColumns = (tableName, columns) => `
+    create table ${sql.identifier(tableName).sql} (
+      "id" text primary key,
+      ${columns
+    // Add default columns.
+    .concat(["createdAt", "updatedAt", "isDeleted"])
+    .filter((c) => c !== "id")
+    // "A column with affinity BLOB does not prefer one storage class over another
+    // and no attempt is made to coerce data from one storage class into another."
+    // https://www.sqlite.org/datatype3.html
+    .map((name) => `${sql.identifier(name).sql} blob`)
+    .join(", ")}
+    );
+  `;
+// https://kysely.dev/docs/recipes/splitting-query-building-and-execution
+export const kysely = new Kysely.Kysely({
+    dialect: {
+        createAdapter: () => new Kysely.SqliteAdapter(),
+        createDriver: () => new Kysely.DummyDriver(),
+        createIntrospector() {
+            throw new Error("Not implemeneted");
+        },
+        createQueryCompiler: () => new Kysely.SqliteQueryCompiler(),
+    },
+});
+const createIndex = kysely.schema.createIndex.bind(kysely.schema);

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

@@ -1,10 +1,155 @@
+import { NonEmptyReadonlyArray } from "../Array.js";
+import { Brand } from "../Brand.js";
+import { RandomDep } from "../Random.js";
+import { Result } from "../Result.js";
+import { SqliteDep, SqliteError } from "../Sqlite.js";
+import { NonNegativeInt } from "../Type.js";
+import { OwnerIdBytes, OwnerWriteKey } from "./Owner.js";
+import { Timestamp, TimestampBytes } from "./Timestamp.js";
+/**
+ * Evolu Storage
+ *
+ * The protocol using Storage is agnostic to storage implementation details—any
+ * storage can be plugged in, as long as it implements this interface.
+ * Implementations must handle their own errors; return values only indicate
+ * overall success or failure.
+ *
+ * The Storage API is synchronous because SQLite's synchronous API is the
+ * fastest way to use SQLite. Synchronous bindings (like better-sqlite3) call
+ * SQLite's C API directly with no context switching between the event loop and
+ * native code, and no promise microtasks or await overhead.
+ *
+ * The only exception is {@link Storage#writeMessages}, which is async to allow
+ * for async validation logic before writing to storage. The write operation
+ * itself remains synchronous.
+ */
+export interface Storage {
+    readonly getSize: (ownerId: OwnerIdBytes) => NonNegativeInt | null;
+    readonly fingerprint: (ownerId: OwnerIdBytes, begin: NonNegativeInt, end: NonNegativeInt) => Fingerprint | null;
+    /**
+     * Computes fingerprints with their upper bounds in one call.
+     *
+     * This function can be replaced with many fingerprint/findLowerBound calls,
+     * but implementations can leverage it for batching and more efficient
+     * fingerprint computation.
+     */
+    readonly fingerprintRanges: (ownerId: OwnerIdBytes, buckets: ReadonlyArray<NonNegativeInt>, upperBound?: RangeUpperBound) => ReadonlyArray<FingerprintRange> | null;
+    readonly findLowerBound: (ownerId: OwnerIdBytes, begin: NonNegativeInt, end: NonNegativeInt, upperBound: RangeUpperBound) => NonNegativeInt | null;
+    readonly iterate: (ownerId: OwnerIdBytes, begin: NonNegativeInt, end: NonNegativeInt, callback: (timestamp: TimestampBytes, index: NonNegativeInt) => boolean) => void;
+    /**
+     * Validates the {@link OwnerWriteKey} for the given {@link Owner}.
+     *
+     * Returns `true` if the write key is valid, `false` otherwise.
+     */
+    readonly validateWriteKey: (ownerId: OwnerIdBytes, writeKey: OwnerWriteKey) => boolean;
+    /** Sets the {@link OwnerWriteKey} for the given {@link Owner}. */
+    readonly setWriteKey: (ownerId: OwnerIdBytes, writeKey: OwnerWriteKey) => boolean;
+    /**
+     * Write encrypted {@link CrdtMessage}s to storage.
+     *
+     * Must use a mutex (per ownerId on Relay) to ensure sequential processing and
+     * proper protocol logic handling during sync operations.
+     *
+     * Returns `true` on success, `false` on failure.
+     */
+    readonly writeMessages: (ownerId: OwnerIdBytes, messages: NonEmptyReadonlyArray<EncryptedCrdtMessage>) => Promise<boolean>;
+    /** Read encrypted {@link DbChange}s from storage. */
+    readonly readDbChange: (ownerId: OwnerIdBytes, timestamp: TimestampBytes) => EncryptedDbChange | null;
+    /**
+     * Delete all data for the given {@link Owner}.
+     *
+     * Returns `true` on success, `false` on failure.
+     */
+    readonly deleteOwner: (ownerId: OwnerIdBytes) => boolean;
+}
+export interface StorageDep {
+    readonly storage: Storage;
+}
+/**
+ * A cryptographic hash used for efficiently comparing collections of
+ * {@link TimestampBytes}s.
+ *
+ * It consists of the first {@link fingerprintSize} bytes of the SHA-256 hash of
+ * one or more timestamps.
+ */
+export type Fingerprint = Uint8Array & Brand<"Fingerprint">;
+export declare const fingerprintSize: NonNegativeInt;
+/** A fingerprint of an empty range. */
+export declare const zeroFingerprint: Fingerprint;
+export interface BaseRange {
+    readonly upperBound: RangeUpperBound;
+}
+/**
+ * Union type for Range's upperBound: either a {@link TimestampBytes} or
+ * {@link InfiniteUpperBound}.
+ */
+export type RangeUpperBound = TimestampBytes | InfiniteUpperBound;
+export declare const InfiniteUpperBound: unique symbol;
+export type InfiniteUpperBound = typeof InfiniteUpperBound;
+export declare const RangeType: {
+    readonly Fingerprint: 1;
+    readonly Skip: 0;
+    readonly Timestamps: 2;
+};
+export type RangeType = (typeof RangeType)[keyof typeof RangeType];
+export interface SkipRange extends BaseRange {
+    readonly type: typeof RangeType.Skip;
+}
+export interface FingerprintRange extends BaseRange {
+    readonly type: typeof RangeType.Fingerprint;
+    readonly fingerprint: Fingerprint;
+}
+export interface TimestampsRange extends BaseRange {
+    readonly type: typeof RangeType.Timestamps;
+    readonly timestamps: ReadonlyArray<TimestampBytes>;
+}
+export type Range = SkipRange | FingerprintRange | TimestampsRange;
+/** An encrypted {@link CrdtMessage}. */
+export interface EncryptedCrdtMessage {
+    readonly timestamp: Timestamp;
+    readonly change: EncryptedDbChange;
+}
+/** Encrypted DbChange */
+export type EncryptedDbChange = Uint8Array & Brand<"EncryptedDbChange">;
 /**
- * Evolu Storage for SQLite
+ * A CRDT message combining a unique {@link Timestamp} with a {@link DbChange}.
+ *
+ * Used in Evolu's sync protocol to replicate data changes across devices. Evolu
+ * operates as a durable queue, providing exactly-once delivery guarantees for
+ * reliable synchronization across application restarts and network failures.
+ */
+export interface CrdtMessage {
+    readonly timestamp: Timestamp;
+    readonly change: DbChange;
+}
+/**
+ * A DbChange is a change to a table row. Together with a unique
+ * {@link Timestamp}, it forms a {@link CrdtMessage}.
+ */
+export declare const DbChange: import("../Type.js").ObjectType<{
+    table: import("../Type.js").Type<"String", string, string, import("../Type.js").StringError, string, import("../Type.js").StringError>;
+    id: import("../Type.js").BrandType<import("../Type.js").Type<"String", string, string, import("../Type.js").StringError, string, import("../Type.js").StringError>, "Id", import("../Type.js").IdError, import("../Type.js").StringError>;
+    values: import("../Type.js").RecordType<"String", string, string, import("../Type.js").StringError, string, import("../Type.js").StringError, import("../Type.js").UnionType<[import("../Type.js").Type<"Null", null, null, import("../Type.js").NullError, null, import("../Type.js").NullError>, import("../Type.js").Type<"String", string, string, import("../Type.js").StringError, string, import("../Type.js").StringError>, import("../Type.js").Type<"Number", number, number, import("../Type.js").NumberError, number, import("../Type.js").NumberError>, import("../Type.js").Type<"Uint8Array", Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>, import("../Type.js").Uint8ArrayError, Uint8Array<ArrayBufferLike>, import("../Type.js").Uint8ArrayError>]>>;
+}>;
+export type DbChange = typeof DbChange.Type;
+/**
+ * Common interface for both client and relay SQLite storages.
  *
  * 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
+ * While the SQL implementation may look sophisticated, it's conceptually simple
+ * and LLMs can explain how it works. The Skiplist data structure is well
+ * explained in [this Stack Overflow
+ * answer](https://stackoverflow.com/questions/61944198/what-is-a-zip-tree-and-how-does-it-work).
+ * The logic resembles [Negentropy's C++
+ * storage](https://github.com/hoytech/negentropy), except we use a Skiplist to
+ * leverage SQLite indexes, which makes the code simpler.
+ *
+ * Note: A paid review by the SQLite team is planned, as they use the same
+ * algorithm for their rsync tool.
+ *
+ * The ideal storage for a Relay should use an architecture like
  * [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.)
@@ -19,31 +164,31 @@
  * 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.
- *
- * @module
  */
-import { RandomDep } from "../Random.js";
-import { Result } from "../Result.js";
-import { SqliteDep, SqliteError } from "../Sqlite.js";
-import { NonNegativeInt } from "../Type.js";
-import { BinaryOwnerId, Storage } from "./Protocol.js";
-import { BinaryTimestamp } from "./Timestamp.js";
-/** Common interface for both client and relay SQLite storages. */
 export interface SqliteStorageBase {
-    readonly insertTimestamp: (ownerId: BinaryOwnerId, timestamp: BinaryTimestamp) => Result<void, SqliteError>;
+    /**
+     * 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.
+     */
+    readonly insertTimestamp: (ownerId: OwnerIdBytes, timestamp: TimestampBytes) => Result<void, SqliteError>;
     readonly getSize: Storage["getSize"];
     readonly fingerprint: Storage["fingerprint"];
     readonly fingerprintRanges: Storage["fingerprintRanges"];
     readonly findLowerBound: Storage["findLowerBound"];
     readonly iterate: Storage["iterate"];
+    readonly deleteOwner: Storage["deleteOwner"];
 }
 export interface SqliteStorageBaseDep {
     readonly storage: SqliteStorageBase;
 }
-export type SqliteStorageDeps = SqliteDep & RandomDep;
+export type SqliteStorageDeps = RandomDep & SqliteDep;
 export interface CreateSqliteStorageBaseOptions {
     onStorageError: (error: SqliteError) => void;
 }
 export declare const createSqliteStorageBase: (deps: SqliteStorageDeps) => (options: CreateSqliteStorageBaseOptions) => Result<SqliteStorageBase, SqliteError>;
-export declare const getTimestampByIndex: (deps: SqliteDep) => (ownerId: BinaryOwnerId, index: NonNegativeInt) => Result<BinaryTimestamp, SqliteError>;
+export declare const timestampBytesToFingerprint: (timestamp: TimestampBytes) => Fingerprint;
+export declare const getTimestampByIndex: (deps: SqliteDep) => (ownerId: OwnerIdBytes, index: NonNegativeInt) => Result<TimestampBytes, SqliteError>;
 //# sourceMappingURL=Storage.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Storage.d.ts","sourceRoot":"","sources":["../../../src/Evolu/Storage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAM,MAAM,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAO,SAAS,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,EAAe,cAAc,EAAe,MAAM,YAAY,CAAC;AAGtE,OAAO,EACL,aAAa,EAQb,OAAO,EAER,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,eAAe,EAAwB,MAAM,gBAAgB,CAAC;AAEvE,kEAAkE;AAClE,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,eAAe,EAAE,CACxB,OAAO,EAAE,aAAa,EACtB,SAAS,EAAE,eAAe,KACvB,MAAM,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;IAE/B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IACrC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;IAC7C,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC,mBAAmB,CAAC,CAAC;IACzD,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACnD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;CACtC;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC;CACrC;AAED,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,SAAS,CAAC;AAEtD,MAAM,WAAW,8BAA8B;IAC7C,cAAc,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;CAC9C;AAED,eAAO,MAAM,uBAAuB,GACjC,MAAM,iBAAiB,MAEtB,SAAS,8BAA8B,KACtC,MAAM,CAAC,iBAAiB,EAAE,WAAW,CAyIvC,CAAC;AA09BJ,eAAO,MAAM,mBAAmB,GAC7B,MAAM,SAAS,MAEd,SAAS,aAAa,EACtB,OAAO,cAAc,KACpB,MAAM,CAAC,eAAe,EAAE,WAAW,CA6ErC,CAAC"}
+{"version":3,"file":"Storage.d.ts","sourceRoot":"","sources":["../../../src/Evolu/Storage.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAEpD,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAM,MAAM,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAO,SAAS,EAAE,WAAW,EAAe,MAAM,cAAc,CAAC;AACxE,OAAO,EAGL,cAAc,EAKf,MAAM,YAAY,CAAC;AACpB,OAAO,EAGL,YAAY,EAEZ,aAAa,EACd,MAAM,YAAY,CAAC;AACpB,OAAO,EAAuB,SAAS,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAEhF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,cAAc,GAAG,IAAI,CAAC;IAEnE,QAAQ,CAAC,WAAW,EAAE,CACpB,OAAO,EAAE,YAAY,EACrB,KAAK,EAAE,cAAc,EACrB,GAAG,EAAE,cAAc,KAChB,WAAW,GAAG,IAAI,CAAC;IAExB;;;;;;OAMG;IACH,QAAQ,CAAC,iBAAiB,EAAE,CAC1B,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,aAAa,CAAC,cAAc,CAAC,EACtC,UAAU,CAAC,EAAE,eAAe,KACzB,aAAa,CAAC,gBAAgB,CAAC,GAAG,IAAI,CAAC;IAE5C,QAAQ,CAAC,cAAc,EAAE,CACvB,OAAO,EAAE,YAAY,EACrB,KAAK,EAAE,cAAc,EACrB,GAAG,EAAE,cAAc,EACnB,UAAU,EAAE,eAAe,KACxB,cAAc,GAAG,IAAI,CAAC;IAE3B,QAAQ,CAAC,OAAO,EAAE,CAChB,OAAO,EAAE,YAAY,EACrB,KAAK,EAAE,cAAc,EACrB,GAAG,EAAE,cAAc,EACnB,QAAQ,EAAE,CAAC,SAAS,EAAE,cAAc,EAAE,KAAK,EAAE,cAAc,KAAK,OAAO,KACpE,IAAI,CAAC;IAEV;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,EAAE,CACzB,OAAO,EAAE,YAAY,EACrB,QAAQ,EAAE,aAAa,KACpB,OAAO,CAAC;IAEb,kEAAkE;IAClE,QAAQ,CAAC,WAAW,EAAE,CACpB,OAAO,EAAE,YAAY,EACrB,QAAQ,EAAE,aAAa,KACpB,OAAO,CAAC;IAEb;;;;;;;OAOG;IACH,QAAQ,CAAC,aAAa,EAAE,CACtB,OAAO,EAAE,YAAY,EACrB,QAAQ,EAAE,qBAAqB,CAAC,oBAAoB,CAAC,KAClD,OAAO,CAAC,OAAO,CAAC,CAAC;IAEtB,qDAAqD;IACrD,QAAQ,CAAC,YAAY,EAAE,CACrB,OAAO,EAAE,YAAY,EACrB,SAAS,EAAE,cAAc,KACtB,iBAAiB,GAAG,IAAI,CAAC;IAE9B;;;;OAIG;IACH,QAAQ,CAAC,WAAW,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,OAAO,CAAC;CAC1D;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,KAAK,CAAC,aAAa,CAAC,CAAC;AAE5D,eAAO,MAAM,eAAe,EAAS,cAAc,CAAC;AAEpD,uCAAuC;AACvC,eAAO,MAAM,eAAe,EAAsC,WAAW,CAAC;AAE9E,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAC;CACtC;AAED;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,cAAc,GAAG,kBAAkB,CAAC;AAElE,eAAO,MAAM,kBAAkB,eAA+B,CAAC;AAC/D,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAC;AAE3D,eAAO,MAAM,SAAS;;;;CAIZ,CAAC;AAEX,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;AAEnE,MAAM,WAAW,SAAU,SAAQ,SAAS;IAC1C,QAAQ,CAAC,IAAI,EAAE,OAAO,SAAS,CAAC,IAAI,CAAC;CACtC;AAED,MAAM,WAAW,gBAAiB,SAAQ,SAAS;IACjD,QAAQ,CAAC,IAAI,EAAE,OAAO,SAAS,CAAC,WAAW,CAAC;IAC5C,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;CACnC;AAED,MAAM,WAAW,eAAgB,SAAQ,SAAS;IAChD,QAAQ,CAAC,IAAI,EAAE,OAAO,SAAS,CAAC,UAAU,CAAC;IAC3C,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC;CACpD;AAED,MAAM,MAAM,KAAK,GAAG,SAAS,GAAG,gBAAgB,GAAG,eAAe,CAAC;AAEnE,wCAAwC;AACxC,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC;CACpC;AAED,yBAAyB;AACzB,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG,KAAK,CAAC,mBAAmB,CAAC,CAAC;AAExE;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;CAC3B;AAED;;;GAGG;AACH,eAAO,MAAM,QAAQ;;;;EAInB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;;;OAMG;IACH,QAAQ,CAAC,eAAe,EAAE,CACxB,OAAO,EAAE,YAAY,EACrB,SAAS,EAAE,cAAc,KACtB,MAAM,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;IAE/B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IACrC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;IAC7C,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC,mBAAmB,CAAC,CAAC;IACzD,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACnD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IACrC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;CAC9C;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC;CACrC;AAED,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,SAAS,CAAC;AAEtD,MAAM,WAAW,8BAA8B;IAC7C,cAAc,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;CAC9C;AAED,eAAO,MAAM,uBAAuB,GACjC,MAAM,iBAAiB,MAEtB,SAAS,8BAA8B,KACtC,MAAM,CAAC,iBAAiB,EAAE,WAAW,CAoJvC,CAAC;AAqlBJ,eAAO,MAAM,2BAA2B,GACtC,WAAW,cAAc,KACxB,WAGF,CAAC;AAuYF,eAAO,MAAM,mBAAmB,GAC7B,MAAM,SAAS,MAEd,SAAS,YAAY,EACrB,OAAO,cAAc,KACpB,MAAM,CAAC,cAAc,EAAE,WAAW,CA6EpC,CAAC"}

package/dist/src/Evolu/Storage.js

@@ -1,33 +1,29 @@
-/**
- * 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
- *
- * 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.
- *
- * @module
- */
+import { sha256 } from "@noble/hashes/sha2.js";
 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";
+import { sql, SqliteValue } from "../Sqlite.js";
+import { Id, object, record, String, } from "../Type.js";
+import { ownerIdBytesToOwnerId, } from "./Owner.js";
+import { orderTimestampBytes } from "./Timestamp.js";
+export const fingerprintSize = 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,
+};
+/**
+ * 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),
+});
 export const createSqliteStorageBase = (deps) => (options) => {
     const createTablesResult = createTables(deps);
     if (!createTablesResult.ok)
@@ -35,7 +31,7 @@ export const createSqliteStorageBase = (deps) => (options) => {
     const ownerStats = new Map();
     return ok({
         insertTimestamp: (ownerId, timestamp) => {
-            const ownerIdString = binaryOwnerIdToOwnerId(ownerId);
+            const ownerIdString = ownerIdBytesToOwnerId(ownerId);
             const level = randomSkiplistLevel(deps);
             let stats = ownerStats.get(ownerIdString);
             if (!stats) {
@@ -53,11 +49,11 @@ export const createSqliteStorageBase = (deps) => (options) => {
                 ownerStats.set(ownerIdString, stats);
             }
             let strategy;
-            if (orderBinaryTimestamp(timestamp, stats.maxT) === 1) {
+            if (orderTimestampBytes(timestamp, stats.maxT) === 1) {
                 strategy = "append";
                 stats.maxT = timestamp;
             }
-            else if (orderBinaryTimestamp(timestamp, stats.minT) === -1) {
+            else if (orderTimestampBytes(timestamp, stats.minT) === -1) {
                 strategy = "prepend";
                 stats.minT = timestamp;
             }
@@ -141,6 +137,16 @@ export const createSqliteStorageBase = (deps) => (options) => {
                     return;
             }
         },
+        deleteOwner: (ownerId) => {
+            const result = deps.sqlite.exec(sql `
+          delete from evolu_timestamp where ownerId = ${ownerId};
+        `);
+            if (!result.ok) {
+                options.onStorageError(result.error);
+                return false;
+            }
+            return true;
+        },
     });
 };
 const assertBeginEnd = (begin, end) => {
@@ -159,7 +165,7 @@ 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)
@@ -208,7 +214,7 @@ const createTables = (deps) => {
 // they will prepend. They are always sorted in ascending order by the
 // Protocol.
 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 +723,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.