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

package/dist/src/Evolu/Schema.js

@@ -1,86 +1,27 @@
 import { pack } from "msgpackr";
+import { assert } from "../Assert.js";
 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 { brand, createTypeErrorFormatter, DateIsoString, nullableToOptional, nullOr, object, omit, optional, } from "../Type.js";
+import { DbSchema } from "./Db.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]) => ({
+export const evoluSchemaToDbSchema = (schema, indexes) => {
+    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 dbSchema = { tables, indexes: createIndexes(indexes) };
+    assert(DbSchema.is(dbSchema), "Invalid EvoluSchema: Table and column names must use only characters A-Za-z0-9_- and be at most 256 characters long.");
+    return dbSchema;
 };
+export const DefaultColumns = object({
+    createdAt: DateIsoString,
+    updatedAt: DateIsoString,
+    isDeleted: nullOr(SqliteBoolean),
+});
 /**
  * Evolu has to limit the maximum mutation size. Otherwise, sync couldn't use
  * the {@link maxProtocolMessageRangesSize}. The max size is 640KB in bytes,

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

@@ -36,6 +36,7 @@ export interface SqliteStorageBase {
     readonly fingerprintRanges: Storage["fingerprintRanges"];
     readonly findLowerBound: Storage["findLowerBound"];
     readonly iterate: Storage["iterate"];
+    readonly deleteOwner: Storage["deleteOwner"];
 }
 export interface SqliteStorageBaseDep {
     readonly storage: SqliteStorageBase;

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":"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;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;AA09BJ,eAAO,MAAM,mBAAmB,GAC7B,MAAM,SAAS,MAEd,SAAS,aAAa,EACtB,OAAO,cAAc,KACpB,MAAM,CAAC,eAAe,EAAE,WAAW,CA6ErC,CAAC"}

package/dist/src/Evolu/Storage.js

@@ -141,6 +141,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) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evolu/common",
-  "version": "6.0.1-preview.1",
+  "version": "6.0.1-preview.10",
   "description": "TypeScript library and local-first framework",
   "keywords": [
     "evolu",
@@ -54,10 +54,10 @@
     "@bokuweb/zstd-wasm": "0.0.27",
     "@types/better-sqlite3": "^7.6.13",
     "@types/ws": "^8.18.1",
-    "better-sqlite3": "^11.10.0",
+    "better-sqlite3": "^12.1.1",
     "shx": "^0.3.4",
     "typescript": "^5.8.3",
-    "vitest": "^3.2.2",
+    "vitest": "^3.2.3",
     "ws": "^8.18.2",
     "@evolu/tsconfig": "0.0.2"
   },

package/src/Assert.ts

@@ -32,9 +32,12 @@ import type { Type } from "./Type.js";
  * assert(true, "true is not true"); // no-op
  * assert(false, "true is not true"); // throws Error
  *
- * const size = fooSize - buffer.getLength();
- * // Ensure required type
- * assert(PositiveInt.is(size), "size is not positive int");
+ * const length = buffer.getLength();
+ * // We know length is logically non-negative, but TypeScript doesn't
+ * assert(
+ *   NonNegativeInt.is(length),
+ *   "buffer length should be non-negative",
+ * );
  * ```
  */
 export const assert: (

package/src/Crypto.ts

@@ -189,3 +189,16 @@ export const padmePaddedLength = (length: NonNegativeInt): NonNegativeInt => {
 export const padmePaddingLength = (length: NonNegativeInt): NonNegativeInt => {
   return (padmePaddedLength(length) - length) as NonNegativeInt;
 };
+
+/**
+ * Performs a timing-safe comparison of two Uint8Arrays. Returns true if they
+ * are equal, false otherwise. Takes constant time regardless of where the
+ * arrays differ.
+ *
+ * @see https://nodejs.org/api/crypto.html#cryptotimingsafeequala-b
+ */
+export type TimingSafeEqual = (a: Uint8Array, b: Uint8Array) => boolean;
+
+export interface TimingSafeEqualDep {
+  readonly timingSafeEqual: TimingSafeEqual;
+}

package/src/Evolu/Config.ts

@@ -5,9 +5,12 @@ import type { DbIndexesBuilder } from "./Kysely.js";
 
 export interface Config extends ConsoleConfig {
   /**
-   * The name of Evolu instances. Evolu is multitenant - it can run more
-   * instances concurrently. Every Evolu instance has to have its own unique
-   * name. Database files are separated and invisible to each other.
+   * The name of the Evolu instance. Evolu is multitenant - it can run multiple
+   * instances concurrently. Each instance must have a unique name.
+   *
+   * The instance name is used as the SQLite database filename for persistent
+   * storage, ensuring that database files are separated and invisible to each
+   * other.
    *
    * The default value is: `Evolu`.
    *
@@ -22,7 +25,7 @@ export interface Config extends ConsoleConfig {
   /**
    * URL for Evolu sync and backup server.
    *
-   * The default value is `https://free.evoluhq.com`.
+   * The default value is `wss://free.evoluhq.com`.
    */
   readonly syncUrl: string;
 
@@ -68,6 +71,17 @@ export interface Config extends ConsoleConfig {
    * until special UX requirements are needed (e.g., multitenancy).
    */
   readonly mnemonic?: Mnemonic;
+
+  /**
+   * Use in-memory SQLite database instead of persistent storage. Useful for
+   * testing or temporary data that doesn't need persistence.
+   *
+   * In-memory databases exist only in RAM and are completely destroyed when
+   * the process ends, making them forensically safe for sensitive data.
+   *
+   * The default value is: `false`.
+   */
+  readonly inMemory?: boolean;
 }
 
 export interface ConfigDep {
@@ -76,7 +90,7 @@ export interface ConfigDep {
 
 export const defaultConfig: Config = {
   name: getOrThrow(SimpleName.fromParent("Evolu")),
-  syncUrl: "https://free.evoluhq.com",
+  syncUrl: "wss://free.evoluhq.com",
   reloadUrl: "/",
   maxDrift: 5 * 60 * 1000,
   enableLogging: false,

package/src/Evolu/Db.ts

@@ -34,7 +34,7 @@ import {
   SqliteValue,
 } from "../Sqlite.js";
 import { TimeDep } from "../Time.js";
-import { Id, Mnemonic, object, SimpleName, String } from "../Type.js";
+import { array, Id, Mnemonic, object, SimpleName, String } from "../Type.js";
 import {
   createInitializedWorker,
   Worker,
@@ -54,6 +54,7 @@ import {
   Base64Url256,
   BinaryId,
   binaryIdToId,
+  BinaryOwnerId,
   CrdtMessage,
   createProtocolMessageForSync,
   createProtocolMessageFromCrdtMessages,
@@ -96,19 +97,21 @@ import {
   timestampToTimestampString,
 } from "./Timestamp.js";
 
-export interface DbSchema {
-  readonly tables: ReadonlyArray<DbTable>;
-  readonly indexes: ReadonlyArray<DbIndex>;
-}
-
-export interface DbTable {
-  readonly name: Base64Url256;
-  readonly columns: ReadonlyArray<Base64Url256>;
-}
+export const DbTable = object({
+  name: Base64Url256,
+  columns: array(Base64Url256),
+});
+export type DbTable = typeof DbTable.Type;
 
 export const DbIndex = object({ name: String, sql: String });
 export type DbIndex = typeof DbIndex.Type;
 
+export const DbSchema = object({
+  tables: array(DbTable),
+  indexes: array(DbIndex),
+});
+export type DbSchema = typeof DbSchema.Type;
+
 export type DbWorker = Worker<DbWorkerInput, DbWorkerOutput>;
 
 export type CreateDbWorker = (name: SimpleName) => DbWorker;
@@ -241,6 +244,7 @@ export const createDbWorkerForPlatform = (
 
       const sqliteResult = await createSqlite(platformDeps)(
         initMessage.config.name,
+        { memory: initMessage.config.inMemory ?? false },
       );
 
       if (!sqliteResult.ok) {
@@ -496,7 +500,6 @@ export const createDbWorkerForPlatform = (
             onCompleteId: message.onCompleteId,
             reload: message.reload,
           });
-          deps.sqlite[Symbol.dispose]();
 
           break;
         }
@@ -621,34 +624,32 @@ const indexesAreEqual = (self: DbIndex, that: DbIndex): boolean =>
 
 export interface DbSnapshot {
   readonly schema: DbSchema;
-  readonly rows: Array<{
-    rows: ReadonlyArray<SqliteRow>;
+  readonly tables: Array<{
     name: string;
+    rows: ReadonlyArray<SqliteRow>;
   }>;
 }
 
-// TODO: Move it to Sqlite.
-export const getDbSnapshot = (
-  deps: SqliteDep,
-): Result<DbSnapshot, SqliteError> => {
+// TODO: Move to test helpers.
+export const getDbSnapshot = (deps: SqliteDep): DbSnapshot => {
   const schema = getDbSchema(deps)({ allIndexes: true });
-  if (!schema.ok) return schema;
+  assert(schema.ok, "bug");
 
-  const rows = [];
+  const tables = [];
 
   for (const table of schema.value.tables) {
     const result = deps.sqlite.exec(sql`
       select * from ${sql.identifier(table.name)};
     `);
-    if (!result.ok) return result;
+    assert(result.ok, "bug");
 
-    rows.push({
-      rows: result.value.rows,
+    tables.push({
       name: table.name,
+      rows: result.value.rows,
     });
   }
 
-  return ok({ schema: schema.value, rows });
+  return { schema: schema.value, tables };
 };
 
 const ensureDbSchema =
@@ -787,41 +788,39 @@ const initializeDb =
       `,
 
       /**
-       * The History table stores all values per timestamp, table, row, and
-       * column. It's required for merging without conflicts. Evolu uses
-       * last-write-win CRDT. In case of last-write-win value isn't what we
-       * want, we can use time travel. The current implementation prefers
-       * performance over storage size. The History table denormalizes Timestamp
-       * and DbChange to leverage a covering index. Hence, every value change
-       * has its timestamp, table, row, and column. In the future, we will
-       * rethink that and store history more efficiently.
-       *
-       * There is no need to use `OwnerId` on the client, because timestamps
-       * (which include a `NodeId`) are globally unique. The relay needs
-       * `OwnerId` because it hosts multiple apps/owners, but client storage
-       * represents one DB, and even when it hosts multiple owners, their
-       * timestamps remain unique.
+       * The History table stores all values per ownerId, timestamp, table, id,
+       * and column for conflict-free merging using last-write-win CRDT.
+       * Denormalizes Timestamp and DbChange for covering index performance.
+       * Time travel is available when last-write-win isn't desired. Future
+       * optimization will store history more efficiently.
        */
       sql`
         create table evolu_history (
-          "timestamp" blob not null,
+          "ownerId" blob not null,
           "table" text not null,
-          "row" blob not null,
+          "id" blob not null,
           "column" text not null,
+          "timestamp" blob not null,
           "value" any
         )
         strict;
       `,
 
+      // Index for reading database changes by owner and timestamp.
+      // Timestamp always corresponds to a DbChange.
       sql`
-        create index evolu_history_timestamp on evolu_history ("timestamp");
+        create index evolu_history_ownerId_timestamp on evolu_history (
+          "ownerId",
+          "timestamp"
+        );
       `,
 
       sql`
-        create unique index evolu_history_row_column_table_timestampDesc on evolu_history (
-          "row",
-          "column",
+        create unique index evolu_history_ownerId_table_id_column_timestampDesc on evolu_history (
+          "ownerId",
           "table",
+          "id",
+          "column",
           "timestamp" desc
         );
       `,
@@ -847,7 +846,14 @@ const initializeDb =
 
     const result = deps.sqlite.exec(sql`
       insert into evolu_owner
-        (mnemonic, id, encryptionKey, createdAt, writeKey, timestamp)
+        (
+          "mnemonic",
+          "id",
+          "encryptionKey",
+          "createdAt",
+          "writeKey",
+          "timestamp"
+        )
       values
         (
           ${ownerRow.mnemonic},
@@ -910,16 +916,18 @@ const applyMessages =
   (
     messages: ReadonlyArray<CrdtMessage>,
     lastTimestamp: Timestamp,
-    options: { isMigrationFromVersion0?: boolean } = {},
   ): Result<void, SqliteError> => {
+    const ownerId = ownerIdToBinaryOwnerId(deps.ownerRowRef.get().id);
+
     for (const message of messages) {
-      if (!options.isMigrationFromVersion0) {
-        const apply1 = applyMessageToAppTable(deps)(message);
-        if (!apply1.ok) return apply1;
-      }
+      const result1 = applyMessageToAppTable(deps)(ownerId, message);
+      if (!result1.ok) return result1;
 
-      const apply2 = applyMessageToTimestampAndHistoryTables(deps)(message);
-      if (!apply2.ok) return apply2;
+      const result2 = applyMessageToTimestampAndHistoryTables(deps)(
+        ownerId,
+        message,
+      );
+      if (!result2.ok) return result2;
     }
 
     const timestamp = timestampToTimestampString(lastTimestamp);
@@ -933,8 +941,8 @@ const applyMessages =
   };
 
 const applyMessageToAppTable =
-  (deps: SqliteDep) =>
-  (message: CrdtMessage): Result<void, SqliteError> => {
+  (deps: SqliteDep & OwnerRowRefDep) =>
+  (ownerId: BinaryOwnerId, message: CrdtMessage): Result<void, SqliteError> => {
     const date = new Date(message.timestamp.millis).toISOString();
     const timestamp = timestampToBinaryTimestamp(message.timestamp);
 
@@ -942,28 +950,29 @@ const applyMessageToAppTable =
       const result = deps.sqlite.exec(sql.prepared`
         with
           lastTimestamp as (
-            select timestamp
+            select "timestamp"
             from evolu_history
             where
-              "row" = ${message.change.id}
-              and "column" = ${column}
+              "ownerId" = ${ownerId}
               and "table" = ${message.change.table}
-            order by timestamp desc
+              and "id" = ${message.change.id}
+              and "column" = ${column}
+            order by "timestamp" desc
             limit 1
           )
         insert into ${sql.identifier(message.change.table)}
           ("id", ${sql.identifier(column)}, createdAt, updatedAt)
         select ${message.change.id}, ${value}, ${date}, ${date}
         where
-          (select timestamp from lastTimestamp) is null
-          or (select timestamp from lastTimestamp) < ${timestamp}
+          (select "timestamp" from lastTimestamp) is null
+          or (select "timestamp" from lastTimestamp) < ${timestamp}
         on conflict ("id") do update
           set
             ${sql.identifier(column)} = ${value},
             updatedAt = ${date}
           where
-            (select timestamp from lastTimestamp) is null
-            or (select timestamp from lastTimestamp) < ${timestamp};
+            (select "timestamp" from lastTimestamp) is null
+            or (select "timestamp" from lastTimestamp) < ${timestamp};
       `);
 
       if (!result.ok) return result;
@@ -973,10 +982,9 @@ const applyMessageToAppTable =
   };
 
 export const applyMessageToTimestampAndHistoryTables =
-  (deps: SqliteDep & RandomDep & OwnerRowRefDep & ClientStorageDep) =>
-  (message: CrdtMessage): Result<void, SqliteError> => {
+  (deps: SqliteDep & ClientStorageDep) =>
+  (ownerId: BinaryOwnerId, message: CrdtMessage): Result<void, SqliteError> => {
     const timestamp = timestampToBinaryTimestamp(message.timestamp);
-    const ownerId = ownerIdToBinaryOwnerId(deps.ownerRowRef.get().id);
     const id = idToBinaryId(message.change.id);
 
     const result = deps.storage.insertTimestamp(ownerId, timestamp);
@@ -985,9 +993,16 @@ export const applyMessageToTimestampAndHistoryTables =
     for (const [column, value] of Object.entries(message.change.values)) {
       const result = deps.sqlite.exec(sql.prepared`
         insert into evolu_history
-          ("timestamp", "table", "row", "column", "value")
+          ("ownerId", "table", "id", "column", "value", "timestamp")
         values
-          (${timestamp}, ${message.change.table}, ${id}, ${column}, ${value})
+          (
+            ${ownerId},
+            ${message.change.table},
+            ${id},
+            ${column},
+            ${value},
+            ${timestamp}
+          )
         on conflict do nothing;
       `);
       if (!result.ok) return result;
@@ -1063,11 +1078,11 @@ export const maybeMigrateToVersion0 =
     const messagesRows = deps.sqlite.exec<{
       timestamp: TimestampString;
       table: Base64Url256;
-      row: Id;
+      id: Id;
       column: Base64Url256;
       value: SqliteValue;
     }>(sql`
-      select "timestamp", "table", "row", "column", "value" from evolu_message;
+      select "timestamp", "table", "id", "column", "value" from evolu_message;
     `);
 
     if (!messagesRows.ok) return messagesRows;
@@ -1083,7 +1098,7 @@ export const maybeMigrateToVersion0 =
     const messages = messagesRows.value.rows.map((message) => ({
       timestamp: timestampStringToTimestamp(message.timestamp),
       change: {
-        id: message.row,
+        id: message.id,
         table: message.table,
         values: { [message.column]: message.value },
       },
@@ -1176,6 +1191,7 @@ const createClientStorage =
       ...sqliteStorageBase.value,
 
       validateWriteKey: constFalse,
+      setWriteKey: constFalse,
 
       writeMessages: (_ownerId, messages) => {
         // TODO: Get owner by _ownerId when we support more.
@@ -1231,16 +1247,16 @@ const createClientStorage =
         return true;
       },
 
-      readDbChange: (_ownerId, timestamp) => {
+      readDbChange: (ownerId, timestamp) => {
         const result = deps.sqlite.exec<{
           table: Base64Url256;
-          row: BinaryId;
+          id: BinaryId;
           column: Base64Url256;
           value: SqliteValue;
         }>(sql`
-          select "table", "row", "column", "value"
+          select "table", "id", "column", "value"
           from evolu_history
-          where "timestamp" = ${timestamp};
+          where "ownerId" = ${ownerId} and "timestamp" = ${timestamp};
         `);
         if (!result.ok) {
           deps.postMessage({ type: "onError", error: result.error });
@@ -1250,18 +1266,18 @@ const createClientStorage =
         const { rows } = result.value;
         assert(rows.length > 0, "Rows must not be empty");
 
-        const { table, row } = rows[0];
+        const { table, id } = rows[0];
         const values: Record<string, SqliteValue> = {};
 
         for (const r of rows) {
           assert(r.table === table, "All rows must have the same table");
-          assert(eqArrayNumber(r.row, row), "All rows must have the same Id");
+          assert(eqArrayNumber(r.id, id), "All rows must have the same Id");
           values[r.column] = r.value;
         }
 
         const change: DbChange = {
           table: rows[0].table,
-          id: binaryIdToId(rows[0].row),
+          id: binaryIdToId(rows[0].id),
           values,
         };