@evolu/common 4.1.1 → 5.0.1

package/src/Db.ts

@@ -1,206 +1,160 @@
-import * as AST from "@effect/schema/AST";
 import * as S from "@effect/schema/Schema";
-import { make } from "@effect/schema/Schema";
+import * as Arr from "effect/Array";
 import * as Brand from "effect/Brand";
+import * as Console from "effect/Console";
 import * as Context from "effect/Context";
+import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import { pipe } from "effect/Function";
-import * as Layer from "effect/Layer";
+import { Equivalence } from "effect/Equivalence";
+import { constVoid, pipe } from "effect/Function";
 import * as Option from "effect/Option";
 import * as Predicate from "effect/Predicate";
-import * as ReadonlyArray from "effect/ReadonlyArray";
-import * as ReadonlyRecord from "effect/ReadonlyRecord";
+import * as Record from "effect/Record";
+import * as Ref from "effect/Ref";
+import * as Schedule from "effect/Schedule";
 import * as String from "effect/String";
-import * as Types from "effect/Types";
+import * as SynchronizedRef from "effect/SynchronizedRef";
 import * as Kysely from "kysely";
+import { Config } from "./Config.js";
 import {
+  MerkleTree,
+  Millis,
+  Time,
+  Timestamp,
+  TimestampCounterOverflowError,
+  TimestampDriftError,
+  TimestampString,
+  TimestampTimeOutOfRangeError,
+  diffMerkleTrees,
   initialMerkleTree,
+  insertIntoMerkleTree,
   makeInitialTimestamp,
+  makeSyncTimestamp,
   merkleTreeToString,
+  receiveTimestamp,
+  sendTimestamp,
   timestampToString,
+  unsafeTimestampFromString,
 } from "./Crdt.js";
 import { Bip39, Mnemonic, NanoIdGenerator } from "./Crypto.js";
-import { EvoluTypeError } from "./ErrorStore.js";
-import { Id, SqliteBoolean, SqliteDate } from "./Model.js";
-import { Owner, makeOwner } from "./Owner.js";
+import { QueryPatches, makePatches } from "./Diff.js";
 import {
-  createMessageTable,
-  createMessageTableIndex,
-  createOwnerTable,
-  insertOwner,
-} from "./Sql.js";
+  EvoluError,
+  ensureTransferableError,
+  makeUnexpectedError,
+} from "./Error.js";
+import { Id, cast } from "./Model.js";
+import { Owner, OwnerId, makeOwner } from "./Owner.js";
+import { SyncLock } from "./Platform.js";
+import * as Sql from "./Sql.js";
 import {
-  Index,
-  indexEquivalence,
   JsonObjectOrArray,
   Sqlite,
+  SqliteExecResult,
+  SqliteFactory,
   SqliteQuery,
   SqliteQueryOptions,
-  SqliteSchema,
-  Table,
+  SqliteQueryPlanRow,
+  SqliteTransactionMode,
   Value,
+  drawSqliteQueryPlan,
   isJsonObjectOrArray,
 } from "./Sqlite.js";
-import { Store, makeStore } from "./Store.js";
+import {
+  Message,
+  NewMessage,
+  Sync,
+  SyncData,
+  SyncFactory,
+  SyncResult,
+  SyncState,
+} from "./Sync.js";
+
+export interface Db {
+  readonly init: (
+    schema: DbSchema,
+    initialData: ReadonlyArray<Mutation>,
+    onError: Callbacks["onError"],
+    onSyncStateChange: Callbacks["onSyncStateChange"],
+    onReceive: Callbacks["onReceive"],
+  ) => Effect.Effect<
+    Owner,
+    | NotSupportedPlatformError
+    | TimestampTimeOutOfRangeError
+    | TimestampDriftError
+    | TimestampCounterOverflowError,
+    Config
+  >;
+
+  readonly loadQueries: (
+    queries: ReadonlyArray<Query>,
+  ) => Effect.Effect<ReadonlyArray<QueryPatches>>;
+
+  readonly mutate: (
+    mutations: ReadonlyArray<Mutation>,
+    queriesToRefresh: ReadonlyArray<Query>,
+  ) => Effect.Effect<
+    ReadonlyArray<QueryPatches>,
+    | TimestampTimeOutOfRangeError
+    | TimestampDriftError
+    | TimestampCounterOverflowError,
+    Config
+  >;
+
+  readonly resetOwner: () => Effect.Effect<void>;
+
+  readonly restoreOwner: (
+    schema: DbSchema,
+    mnemonic: Mnemonic,
+  ) => Effect.Effect<void>;
+
+  readonly ensureSchema: (schema: DbSchema) => Effect.Effect<void>;
+
+  readonly sync: (
+    queriesToRefresh: ReadonlyArray<Query>,
+  ) => Effect.Effect<ReadonlyArray<QueryPatches>, never, Config>;
+}
 
-export type DatabaseSchema = ReadonlyRecord.ReadonlyRecord<string, TableSchema>;
+export interface DbSchema {
+  readonly tables: ReadonlyArray<Table>;
+  readonly indexes: ReadonlyArray<Index>;
+}
 
-type TableSchema = ReadonlyRecord.ReadonlyRecord<string, Value> & {
-  readonly id: Id;
-};
+export interface Table {
+  readonly name: string;
+  readonly columns: ReadonlyArray<string>;
+}
 
-/**
- * Create table schema.
- *
- * Supported types are null, string, number, Uint8Array, JSON Object, and JSON
- * Array. Use SqliteDate for dates and SqliteBoolean for booleans.
- *
- * Reserved columns are createdAt, updatedAt, isDeleted. Those columns are added
- * by default.
- *
- * @example
- *   const TodoId = id("Todo");
- *   type TodoId = S.Schema.Type<typeof TodoId>;
- *
- *   const TodoTable = table({
- *     id: TodoId,
- *     title: NonEmptyString1000,
- *     isCompleted: S.nullable(SqliteBoolean),
- *   });
- *   type TodoTable = S.Schema.Type<typeof TodoTable>;
- */
-export const table = <Fields extends TableFields>(
-  fields: Fields,
-  // Because Schema is invariant, we have to do validation like this.
-): ValidateFieldsTypes<Fields> extends true
-  ? ValidateFieldsNames<Fields> extends true
-    ? ValidateFieldsHasId<Fields> extends true
-      ? S.Schema<
-          Types.Simplify<
-            S.Struct.Type<Fields> & S.Schema.Type<typeof ReservedColumns>
-          >,
-          Types.Simplify<
-            S.Struct.Encoded<Fields> & S.Schema.Encoded<typeof ReservedColumns>
-          >
-        >
-      : EvoluTypeError<"table() called without id column.">
-    : EvoluTypeError<"table() called with a reserved column. Reserved columns are createdAt, updatedAt, isDeleted. Those columns are added by default.">
-  : EvoluTypeError<"table() called with unsupported type. Supported types are null, string, number, Uint8Array, JSON Object, and JSON Array. Use SqliteDate for dates and SqliteBoolean for booleans."> =>
-  S.struct(fields).pipe(S.extend(ReservedColumns)) as never;
-
-const ReservedColumns = S.struct({
-  createdAt: SqliteDate,
-  updatedAt: SqliteDate,
-  isDeleted: SqliteBoolean,
+export const Index = S.Struct({
+  name: S.String,
+  sql: S.String,
 });
+export type Index = S.Schema.Type<typeof Index>;
 
-type TableFields = Record<string, S.Schema<any>>;
-
-type ValidateFieldsTypes<Fields extends TableFields> =
-  keyof Fields extends infer K
-    ? K extends keyof Fields
-      ? Fields[K] extends TableFields
-        ? ValidateFieldsTypes<Fields[K]>
-        : // eslint-disable-next-line @typescript-eslint/no-unused-vars
-          Fields[K] extends S.Schema<infer A, infer _I>
-          ? A extends Value
-            ? true
-            : false
-          : never
-      : never
-    : never;
-
-type ValidateFieldsNames<Fields extends TableFields> =
-  keyof Fields extends infer K
-    ? K extends keyof Fields
-      ? K extends "createdAt" | "updatedAt" | "isDeleted"
-        ? false
-        : true
-      : never
-    : never;
-
-type ValidateFieldsHasId<Fields extends TableFields> = "id" extends keyof Fields
-  ? true
-  : false;
+export interface Mutation {
+  readonly table: string;
+  readonly id: Id;
+  readonly values: Record.ReadonlyRecord<
+    string,
+    Value | Date | boolean | undefined
+  >;
+  readonly isInsert: boolean;
+}
 
-/**
- * Create database schema.
- *
- * Tables with a name prefixed with _ are local-only, which means they are not
- * synced. Local-only tables are useful for device-specific or temporal data.
- *
- * @example
- *   const Database = database({
- *     // A local-only table.
- *     _todo: TodoTable,
- *     todo: TodoTable,
- *     todoCategory: TodoCategoryTable,
- *   });
- *   type Database = S.Schema.Type<typeof Database>;
- */
-export const database = S.struct;
+export interface NotSupportedPlatformError {
+  readonly _tag: "NotSupportedPlatformError";
+}
 
 // https://blog.beraliv.dev/2021-05-07-opaque-type-in-typescript
 declare const __queryBrand: unique symbol;
 
 /**
- * The query is an SQL query serialized as a string with a branded type
- * representing a row it returns.
+ * Query is SQL query serialized as a string with a branded type representing a
+ * row it returns.
  */
 export type Query<R extends Row = Row> = string &
   Brand.Brand<"Query"> & { readonly [__queryBrand]: R };
 
-export type Queries<R extends Row = Row> = ReadonlyArray<Query<R>>;
-
-interface SerializedSqliteQuery {
-  readonly sql: string;
-  readonly parameters: (
-    | null
-    | string
-    | number
-    | Array<number>
-    | { json: JsonObjectOrArray }
-  )[];
-  readonly options?: SqliteQueryOptions;
-}
-
-// We use queries as keys, hence JSON.stringify.
-export const serializeQuery = <R extends Row>({
-  sql,
-  parameters = [],
-  options,
-}: SqliteQuery): Query<R> => {
-  const query: SerializedSqliteQuery = {
-    sql,
-    parameters: parameters.map((p) =>
-      Predicate.isUint8Array(p)
-        ? Array.from(p)
-        : isJsonObjectOrArray(p)
-          ? { json: p }
-          : p,
-    ),
-    ...(options && { options }),
-  };
-  return JSON.stringify(query) as Query<R>;
-};
-
-export const deserializeQuery = <R extends Row>(
-  query: Query<R>,
-): SqliteQuery => {
-  const serializedSqliteQuery = JSON.parse(query) as SerializedSqliteQuery;
-  return {
-    ...serializedSqliteQuery,
-    parameters: serializedSqliteQuery.parameters.map((p) =>
-      Array.isArray(p)
-        ? new Uint8Array(p)
-        : typeof p === "object" && p != null
-          ? p.json
-          : p,
-    ),
-  };
-};
-
 export type Row = {
   [key: string]:
     | Value
@@ -208,158 +162,227 @@ export type Row = {
     | ReadonlyArray<Row>; // for jsonArrayFrom from kysely/helpers/sqlite
 };
 
-/**
- * Extract {@link Row} from {@link Query} instance.
- *
- * @example
- *   const allTodos = evolu.createQuery((db) =>
- *     db.selectFrom("todo").selectAll(),
- *   );
- *   type AllTodosRow = ExtractRow<typeof allTodos>;
- */
-export type ExtractRow<T extends Query> = T extends Query<infer R> ? R : never;
+export class DbFactory extends Context.Tag("DbFactory")<
+  DbFactory,
+  {
+    readonly createDb: Effect.Effect<Db>;
+  }
+>() {}
+
+export const createDb: Effect.Effect<
+  Db,
+  never,
+  SqliteFactory | Bip39 | NanoIdGenerator | Time | SyncFactory | SyncLock
+> = Effect.gen(function* () {
+  const { createSqlite } = yield* SqliteFactory;
+  const { createSync } = yield* SyncFactory;
+
+  const initContext = Context.empty().pipe(
+    Context.add(Bip39, yield* Bip39),
+    Context.add(NanoIdGenerator, yield* NanoIdGenerator),
+    Context.add(Time, yield* Time),
+    Context.add(SyncLock, yield* SyncLock),
+  );
 
-const _emptyRows: ReadonlyArray<Row> = [];
+  const afterInitContext =
+    yield* Deferred.make<
+      Context.Context<
+        | Bip39
+        | NanoIdGenerator
+        | Time
+        | SyncLock
+        | Sqlite
+        | Owner
+        | Sync
+        | Callbacks
+      >
+    >();
+
+  const afterInit =
+    (options: { readonly transaction: SqliteTransactionMode }) =>
+    <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+      Effect.flatMap(Deferred.await(afterInitContext), (context) =>
+        Effect.flatMap(Sqlite, (sqlite) =>
+          sqlite.transaction(options.transaction)(effect),
+        ).pipe(Effect.provide(context)),
+      );
 
-export const emptyRows = <R extends Row>(): ReadonlyArray<R> =>
-  _emptyRows as ReadonlyArray<R>;
+  const queryRowsRef = yield* SynchronizedRef.make<QueryRowsMap>(new Map());
+
+  const db: Db = {
+    init: (schema, initialData, onError, onSyncStateChange, onReceive) =>
+      Effect.gen(function* () {
+        yield* Effect.logDebug(["Db init", { schema }]);
+        const sqlite = yield* createSqlite;
+        const contextWithSqlite = Context.add(initContext, Sqlite, sqlite);
+        const owner = yield* getSchema.pipe(
+          Effect.tap(ensureSchema(schema)),
+          Effect.flatMap((currentSchema) => {
+            if (currentSchema.tables.map((t) => t.name).includes("evolu_owner"))
+              return readOwner;
+            return createOwner().pipe(Effect.tap(applyMutations(initialData)));
+          }),
+          sqlite.transaction("exclusive"),
+          Effect.provide(contextWithSqlite),
+        );
+        const sync = yield* createSync.pipe(Effect.provide(initContext));
+        yield* sync.init(owner);
+        Deferred.unsafeDone(
+          afterInitContext,
+          Effect.succeed(
+            contextWithSqlite.pipe(
+              Context.add(Owner, owner),
+              Context.add(Sync, sync),
+              Context.add(Callbacks, { onError, onSyncStateChange, onReceive }),
+            ),
+          ),
+        );
+        return owner;
+      }),
 
-/** An object with rows and row properties. */
-export interface QueryResult<R extends Row = Row> {
-  /** An array containing all the rows returned by the query. */
-  readonly rows: ReadonlyArray<Readonly<Kysely.Simplify<R>>>;
+    loadQueries: (queries) =>
+      Effect.logDebug(["Db loadQueries", { queries }]).pipe(
+        Effect.zipRight(loadQueries(queries, queryRowsRef)),
+        afterInit({ transaction: "shared" }),
+      ),
 
-  /**
-   * The first row returned by the query, or null if no rows were returned. This
-   * property is useful for queries that are expected to return a single row.
-   */
-  readonly row: Readonly<Kysely.Simplify<R>> | null;
-}
+    mutate: (mutations, queriesToRefresh) =>
+      Effect.gen(function* () {
+        yield* Effect.logDebug(["Db mutate", { mutations, queriesToRefresh }]);
+        const time = yield* Time;
+        const sqlite = yield* Sqlite;
 
-export type QueryResultsFromQueries<Q extends Queries> = {
-  [P in keyof Q]: Q[P] extends Query<infer R> ? QueryResult<R> : never;
-};
+        const [toSyncMutations, localOnlyMutations] = Arr.partition(
+          mutations,
+          /** Table name starting with '_' is local only (not synced). */
+          (mutation) => mutation.table.startsWith("_"),
+        );
 
-export type QueryResultsPromisesFromQueries<Q extends Queries> = {
-  [P in keyof Q]: Q[P] extends Query<infer R> ? Promise<QueryResult<R>> : never;
-};
+        for (const mutation of localOnlyMutations) {
+          const isDeleteMutation = mutationToNewMessages(mutation).some(
+            ({ column, value }) => column === "isDeleted" && value === 1,
+          );
+          if (isDeleteMutation) {
+            yield* sqlite.exec({
+              sql: `delete from "${mutation.table}" where "id" = ?;`,
+              parameters: [mutation.id],
+            });
+          } else {
+            const messages = mutationToNewMessages(mutation);
+            for (const message of messages) {
+              const now = yield* time.now;
+              yield* upsertValueIntoTableRowColumn(message, messages, now);
+            }
+          }
+        }
+        if (toSyncMutations.length > 0) {
+          yield* Effect.tap(applyMutations(toSyncMutations), forkSync);
+        }
+        return yield* loadQueries(queriesToRefresh, queryRowsRef);
+      }).pipe(afterInit({ transaction: "exclusive" })),
+
+    resetOwner: () =>
+      Effect.logTrace("Db resetOwner").pipe(
+        Effect.tap(dropAllTables),
+        afterInit({ transaction: "last" }),
+      ),
 
-const queryResultCache = new WeakMap<ReadonlyArray<Row>, QueryResult<Row>>();
+    restoreOwner: (schema, mnemonic) =>
+      Effect.logTrace("Db restoreOwner").pipe(
+        Effect.tap(dropAllTables),
+        Effect.tap(Effect.flatMap(getSchema, ensureSchema(schema))),
+        Effect.tap(createOwner(mnemonic)),
+        afterInit({ transaction: "last" }),
+      ),
 
-export const queryResultFromRows = <R extends Row>(
-  rows: ReadonlyArray<R>,
-): QueryResult<R> => {
-  let queryResult = queryResultCache.get(rows);
-  if (queryResult == null) {
-    queryResult = { rows, row: rows[0] };
-    queryResultCache.set(rows, queryResult);
-  }
-  return queryResult as QueryResult<R>;
-};
+    ensureSchema: (schema) =>
+      getSchema.pipe(
+        Effect.flatMap(ensureSchema(schema)),
+        afterInit({ transaction: "exclusive" }),
+      ),
 
-// TODO: https://discord.com/channels/795981131316985866/1218626687546294386/1218796529725476935
-// https://github.com/Effect-TS/schema/releases/tag/v0.18.0
-const getPropertySignatures = <I extends { [K in keyof A]: any }, A>(
-  schema: S.Schema<A, I>,
-): { [K in keyof A]: S.Schema<A[K], I[K]> } => {
-  const out: Record<PropertyKey, S.Schema<any>> = {};
-  const propertySignatures = AST.getPropertySignatures(schema.ast);
-  for (let i = 0; i < propertySignatures.length; i++) {
-    const propertySignature = propertySignatures[i];
-    out[propertySignature.name] = make(propertySignature.type);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-  return out as any;
-};
+    sync: (queriesToRefresh) =>
+      Effect.logDebug(["Db sync", { queriesToRefresh }]).pipe(
+        Effect.zipRight(forkSync()),
+        Effect.zipRight(loadQueries(queriesToRefresh, queryRowsRef)),
+        afterInit({ transaction: "shared" }),
+      ),
 
-export const schemaToTables = (schema: S.Schema<any>): ReadonlyArray<Table> =>
-  pipe(
-    getPropertySignatures(schema),
-    ReadonlyRecord.toEntries,
-    ReadonlyArray.map(
-      ([name, schema]): Table => ({
-        name,
-        columns: Object.keys(getPropertySignatures(schema)),
-      }),
-    ),
-  );
+    // TODO:
+    // dispose: () =>
+    //   Effect.logTrace("Db dispose").pipe(
+    //     Effect.tap(Scope.close(scope, Exit.succeed("Db disposed"))),
+    //     afterInit({ transaction: "last" }),
+    //   ),
+  };
 
-export const transaction = <R, E, A>(
-  effect: Effect.Effect<A, E, R>,
-): Effect.Effect<A, E, Sqlite | R> =>
-  Effect.flatMap(Sqlite, (sqlite) =>
-    Effect.acquireUseRelease(
-      sqlite.exec({ sql: "begin" }),
-      () => effect,
-      (_, exit) =>
-        Exit.isFailure(exit)
-          ? sqlite.exec({ sql: "rollback" })
-          : sqlite.exec({ sql: "end" }),
-    ),
-  );
+  return db;
+});
 
-export interface NoSuchTableOrColumnError {
-  readonly _tag: "NoSuchTableOrColumnError";
+export interface Callbacks {
+  readonly onError: (error: EvoluError) => void;
+  readonly onSyncStateChange: (state: SyncState) => void;
+  readonly onReceive: () => void;
 }
 
-export const SqliteNoSuchTableOrColumnError = S.struct({
-  message: S.union(
-    S.string.pipe(S.includes("no such table")),
-    S.string.pipe(S.includes("no such column")),
-    S.string.pipe(S.includes("has no column")),
-  ),
-});
-export type SqliteNoSuchTableOrColumnError = S.Schema.Type<
-  typeof SqliteNoSuchTableOrColumnError
->;
-
-export const someDefectToNoSuchTableOrColumnError = Effect.catchSomeDefect(
-  (error) =>
-    S.is(SqliteNoSuchTableOrColumnError)(error)
-      ? Option.some(
-          Effect.fail<NoSuchTableOrColumnError>({
-            _tag: "NoSuchTableOrColumnError",
+export const Callbacks = Context.GenericTag<Callbacks>("Callbacks");
+
+export type QueryRowsMap = ReadonlyMap<Query, ReadonlyArray<Row>>;
+
+const loadQueries = (
+  queries: ReadonlyArray<Query>,
+  queryRowsRef: SynchronizedRef.SynchronizedRef<QueryRowsMap>,
+) =>
+  Effect.gen(function* () {
+    const sqlite = yield* Sqlite;
+    const previousState = yield* SynchronizedRef.getAndUpdateEffect(
+      queryRowsRef,
+      (previousState) =>
+        Effect.map(
+          Effect.forEach(queries, (query) => {
+            const sqliteQuery = deserializeQuery(query);
+            return sqlite.exec(sqliteQuery).pipe(
+              Effect.tap(maybeExplainQueryPlan(sqliteQuery)),
+              Effect.map(({ rows }) => [query, rows] as const),
+            );
           }),
-        )
-      : Option.none(),
-);
-
-export const lazyInit = (
-  mnemonic?: Mnemonic,
-): Effect.Effect<Owner, never, Sqlite | Bip39 | NanoIdGenerator> =>
-  Effect.gen(function* (_) {
-    const [owner, sqlite, initialTimestampString] = yield* _(
-      Effect.all([makeOwner(mnemonic), Sqlite, makeInitialTimestamp], {
-        concurrency: "unbounded",
-      }),
+          (queriesRows) => new Map([...previousState, ...queriesRows]),
+        ),
     );
-
-    yield* _(
-      Effect.all([
-        sqlite.exec(createMessageTable),
-        sqlite.exec(createMessageTableIndex),
-        sqlite.exec(createOwnerTable),
-        sqlite.exec({
-          ...insertOwner,
-          parameters: [
-            owner.id,
-            owner.mnemonic,
-            owner.encryptionKey,
-            timestampToString(initialTimestampString),
-            merkleTreeToString(initialMerkleTree),
-          ],
-        }),
-      ]),
+    const currentState = yield* SynchronizedRef.get(queryRowsRef);
+    return queries.map(
+      (query): QueryPatches => ({
+        query,
+        patches: makePatches(
+          previousState.get(query),
+          currentState.get(query) || [],
+        ),
+      }),
     );
-
-    return owner;
   });
 
-const getSchema: Effect.Effect<SqliteSchema, never, Sqlite> = Effect.gen(
-  function* (_) {
-    const sqlite = yield* _(Sqlite);
+const maybeExplainQueryPlan = (sqliteQuery: SqliteQuery) => {
+  if (!sqliteQuery.options?.logExplainQueryPlan) return Effect.void;
+  return Sqlite.pipe(
+    Effect.flatMap((sqlite) =>
+      sqlite.exec({
+        ...sqliteQuery,
+        sql: `EXPLAIN QUERY PLAN ${sqliteQuery.sql}`,
+      }),
+    ),
+    Effect.tap(Console.log("ExplainQueryPlan", sqliteQuery)),
+    Effect.tap(({ rows }) =>
+      Console.log(drawSqliteQueryPlan(rows as SqliteQueryPlanRow[])),
+    ),
+    Effect.map(constVoid),
+  );
+};
 
-    const tables = yield* _(
+const getSchema: Effect.Effect<DbSchema, never, Sqlite> = Effect.gen(
+  function* (_) {
+    yield* Effect.logTrace("Db getSchema");
+    const sqlite = yield* Sqlite;
+    const tables = yield* Effect.map(
       sqlite.exec({
         // https://til.simonwillison.net/sqlite/list-all-columns-in-a-database
         sql: `
@@ -369,9 +392,9 @@ select
 from
   sqlite_master
   join pragma_table_info(sqlite_master.name) as table_info
-`.trim(),
+    `.trim(),
       }),
-      Effect.map(({ rows }) => {
+      ({ rows }) => {
         const map = new Map<string, string[]>();
         rows.forEach((row) => {
           const { tableName, columnName } = row as {
@@ -381,14 +404,14 @@ from
           if (!map.has(tableName)) map.set(tableName, []);
           map.get(tableName)?.push(columnName);
         });
-        return Array.from(map, ([name, columns]) => ({
+        return globalThis.Array.from(map, ([name, columns]) => ({
           name,
           columns,
         }));
-      }),
+      },
     );
 
-    const indexes = yield* _(
+    const indexes = yield* Effect.map(
       sqlite.exec({
         sql: `
 select
@@ -401,8 +424,8 @@ where
   name not like 'index_evolu_%'
 `.trim(),
       }),
-      Effect.map((result) =>
-        ReadonlyArray.map(
+      (result) =>
+        Arr.map(
           result.rows,
           (row): Index => ({
             name: row.name as string,
@@ -414,42 +437,37 @@ where
             sql: (row.sql as string).replace("CREATE INDEX", "create index"),
           }),
         ),
-      ),
     );
 
     return { tables, indexes };
   },
 );
 
-export const ensureSchema = (
-  schema: SqliteSchema,
-): Effect.Effect<void, never, Sqlite> =>
-  Effect.gen(function* (_) {
-    const sqlite = yield* _(Sqlite);
-    const currentSchema = yield* _(getSchema);
-
+const ensureSchema = (newSchema: DbSchema) => (currentSchema: DbSchema) =>
+  Effect.gen(function* () {
+    yield* Effect.logTrace("Db ensureSchema");
     const sql: string[] = [];
 
-    schema.tables.forEach((table) => {
+    newSchema.tables.forEach((table) => {
       const currentTable = currentSchema.tables.find(
         (t) => t.name === table.name,
       );
       if (!currentTable) {
         sql.push(
           `
-create table ${table.name} (
-  "id" text primary key,
-  ${table.columns
-    .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) => `"${name}" blob`)
-    .join(", ")}
-);`.trim(),
+  create table ${table.name} (
+    "id" text primary key,
+    ${table.columns
+      .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) => `"${name}" blob`)
+      .join(", ")}
+  );`.trim(),
         );
       } else {
-        ReadonlyArray.differenceWith(String.Equivalence)(
+        Arr.differenceWith(String.Equivalence)(
           table.columns,
           currentTable.columns,
         ).forEach((newColumn) => {
@@ -461,53 +479,465 @@ create table ${table.name} (
     });
 
     // Remove old indexes.
-    ReadonlyArray.differenceWith(indexEquivalence)(
+    Arr.differenceWith(indexEquivalence)(
       currentSchema.indexes,
-      ReadonlyArray.intersectionWith(indexEquivalence)(
+      Arr.intersectionWith(indexEquivalence)(
         currentSchema.indexes,
-        schema.indexes,
+        newSchema.indexes,
       ),
     ).forEach((indexToDrop) => {
       sql.push(`drop index "${indexToDrop.name}";`);
     });
 
     // Add new indexes.
-    ReadonlyArray.differenceWith(indexEquivalence)(
-      schema.indexes,
+    Arr.differenceWith(indexEquivalence)(
+      newSchema.indexes,
       currentSchema.indexes,
     ).forEach((newIndex) => {
       sql.push(`${newIndex.sql};`);
     });
+    if (sql.length > 0) {
+      const sqlite = yield* Sqlite;
+      yield* sqlite.exec({ sql: sql.join("\n") });
+    }
+  });
 
-    if (sql.length > 0)
-      yield* _(
+const indexEquivalence: Equivalence<Index> = (self, that) =>
+  self.name === that.name && self.sql === that.sql;
+
+const readOwner = Effect.logTrace("Db readOwner").pipe(
+  Effect.zipRight(Sqlite),
+  Effect.flatMap((sqlite) => sqlite.exec(Sql.selectOwner)),
+  Effect.map(
+    ({ rows: [row] }): Owner => ({
+      id: row.id as OwnerId,
+      mnemonic: row.mnemonic as Mnemonic,
+      encryptionKey: row.encryptionKey as Uint8Array,
+    }),
+  ),
+);
+
+const createOwner = (mnemonic?: Mnemonic) =>
+  Effect.logTrace("Db createOwner").pipe(
+    Effect.zipRight(
+      Effect.all([makeOwner(mnemonic), Sqlite, makeInitialTimestamp]),
+    ),
+    Effect.tap(([owner, sqlite, initialTimestampString]) =>
+      Effect.all([
+        sqlite.exec(Sql.createMessageTable),
+        sqlite.exec(Sql.createMessageTableIndex),
+        sqlite.exec(Sql.createOwnerTable),
         sqlite.exec({
-          sql: sql.join("\n"),
+          ...Sql.insertOwner,
+          parameters: [
+            owner.id,
+            owner.mnemonic,
+            owner.encryptionKey,
+            timestampToString(initialTimestampString),
+            merkleTreeToString(initialMerkleTree),
+          ],
         }),
-      );
+      ]),
+    ),
+    Effect.map(([owner]) => owner),
+  );
+
+const applyMutations = (mutations: ReadonlyArray<Mutation>) =>
+  Effect.gen(function* (_) {
+    const { timestamp, merkleTree } = yield* readTimestampAndMerkleTree;
+    const [nextTimestamp, messages] = yield* Effect.mapAccum(
+      mutations.flatMap(mutationToNewMessages),
+      timestamp,
+      (currentTimestamp, newMessage) =>
+        Effect.map(sendTimestamp(currentTimestamp), (nextTimestamp) => {
+          const message: Message = {
+            ...newMessage,
+            timestamp: timestampToString(nextTimestamp),
+          };
+          return [nextTimestamp, message];
+        }),
+    );
+    const nextMerkleTree = yield* applyMessages(merkleTree, messages);
+    yield* writeTimestampAndMerkleTree(nextTimestamp, nextMerkleTree);
+    return messages;
   });
 
-export const dropAllTables: Effect.Effect<void, never, Sqlite> = Effect.gen(
-  function* (_) {
-    const sqlite = yield* _(Sqlite);
-    const schema = yield* _(getSchema);
-    const sql = schema.tables
-      // The dropped table is completely removed from the database schema and
-      // the disk file. The table can not be recovered.
-      // All indices and triggers associated with the table are also deleted.
-      // https://sqlite.org/lang_droptable.html
-      .map((table) => `drop table "${table.name}";`)
-      .join("");
-    yield* _(sqlite.exec({ sql }));
-  },
+const readTimestampAndMerkleTree = Sqlite.pipe(
+  Effect.flatMap((sqlite) =>
+    sqlite.exec(Sql.selectOwnerTimestampAndMerkleTree),
+  ),
+  Effect.map(({ rows: [{ timestamp, merkleTree }] }) => ({
+    timestamp: unsafeTimestampFromString(timestamp as TimestampString),
+    merkleTree: merkleTree as MerkleTree,
+  })),
 );
 
-export type RowsStore = Store<RowsStoreValue>;
-export const RowsStore = Context.GenericTag<RowsStore>("@services/RowsStore");
+const mutationToNewMessages = (mutation: Mutation) =>
+  pipe(
+    Object.entries(mutation.values),
+    Arr.filterMap(([column, value]) =>
+      // The value can be undefined if exactOptionalPropertyTypes isn't true.
+      // Don't insert nulls because null is the default value.
+      value === undefined || (mutation.isInsert && value == null)
+        ? Option.none()
+        : Option.some([column, value] as const),
+    ),
+    Arr.map(
+      ([column, value]): NewMessage => ({
+        table: mutation.table,
+        row: mutation.id,
+        column,
+        value:
+          typeof value === "boolean"
+            ? cast(value)
+            : value instanceof Date
+              ? cast(value)
+              : value,
+      }),
+    ),
+  );
+
+const applyMessages = (
+  merkleTree: MerkleTree,
+  messages: ReadonlyArray<Message>,
+): Effect.Effect<MerkleTree, never, Sqlite> =>
+  Effect.gen(function* () {
+    const sqlite = yield* Sqlite;
+    for (const message of messages) {
+      const messageTimestamp = unsafeTimestampFromString(message.timestamp);
+      const lastTimestamp = yield* Effect.map(
+        sqlite.exec({
+          ...Sql.selectLastTimestampForTableRowColumn,
+          parameters: [message.table, message.row, message.column, 1],
+        }),
+        ({ rows }) =>
+          rows.length > 0 ? (rows[0].timestamp as TimestampString) : null,
+      );
+      if (lastTimestamp == null || lastTimestamp < message.timestamp) {
+        yield* upsertValueIntoTableRowColumn(
+          message,
+          messages,
+          messageTimestamp.millis,
+        );
+      }
+      if (lastTimestamp == null || lastTimestamp !== message.timestamp) {
+        const { changes } = yield* sqlite.exec({
+          ...Sql.insertIntoMessagesIfNew,
+          parameters: [
+            message.timestamp,
+            message.table,
+            message.row,
+            message.column,
+            message.value,
+          ],
+        });
+        if (changes === 1)
+          merkleTree = insertIntoMerkleTree(merkleTree, messageTimestamp);
+      }
+    }
+    return merkleTree;
+  });
+
+export const upsertValueIntoTableRowColumn = (
+  message: NewMessage,
+  messages: ReadonlyArray<NewMessage>,
+  millis: Millis,
+): Effect.Effect<SqliteExecResult, never, Sqlite> =>
+  Sqlite.pipe(
+    Effect.map((sqlite) => {
+      const now = cast(new Date(millis));
+      return sqlite.exec({
+        sql: `
+    insert into
+      "${message.table}" ("id", "${message.column}", "createdAt", "updatedAt")
+    values
+      (?, ?, ?, ?)
+    on conflict do update set
+      "${message.column}" = ?,
+      "updatedAt" = ?
+        `.trim(),
+        parameters: [message.row, message.value, now, now, message.value, now],
+      });
+    }),
+    Effect.flatMap((insert) =>
+      Effect.catchSomeDefect(insert, (error) =>
+        S.is(SqliteNoSuchTableOrColumnError)(error)
+          ? Option.some(
+              // If one message fails, we ensure schema for all messages.
+              ensureSchemaByNewMessages(messages).pipe(Effect.zipRight(insert)),
+            )
+          : Option.none(),
+      ),
+    ),
+  );
 
-type RowsStoreValue = ReadonlyMap<Query, ReadonlyArray<Row>>;
+const SqliteNoSuchTableOrColumnError = S.Struct({
+  message: S.Union(
+    S.String.pipe(S.includes("no such table")),
+    S.String.pipe(S.includes("no such column")),
+    S.String.pipe(S.includes("has no column")),
+  ),
+});
 
-export const RowsStoreLive = Layer.effect(
-  RowsStore,
-  makeStore<RowsStoreValue>(new Map()),
-);
+const ensureSchemaByNewMessages = (messages: ReadonlyArray<NewMessage>) =>
+  Effect.gen(function* () {
+    const tablesMap = new Map<string, Table>();
+    messages.forEach((message) => {
+      const table = tablesMap.get(message.table);
+      if (table == null) {
+        tablesMap.set(message.table, {
+          name: message.table,
+          columns: [message.column, "createdAt", "updatedAt"],
+        });
+        return;
+      }
+      if (table.columns.includes(message.column)) return;
+      tablesMap.set(message.table, {
+        name: message.table,
+        columns: table.columns.concat(message.column),
+      });
+    });
+    const tables = Arr.fromIterable(tablesMap.values());
+    yield* Effect.flatMap(getSchema, ensureSchema({ tables, indexes: [] }));
+  });
+
+const writeTimestampAndMerkleTree = (
+  timestamp: Timestamp,
+  merkleTree: MerkleTree,
+) =>
+  Effect.flatMap(Sqlite, (sqlite) =>
+    sqlite.exec({
+      ...Sql.updateOwnerTimestampAndMerkleTree,
+      parameters: [
+        merkleTreeToString(merkleTree),
+        timestampToString(timestamp),
+      ],
+    }),
+  );
+
+const dropAllTables = Effect.gen(function* () {
+  yield* Effect.logTrace("Db dropAllTables");
+  const sqlite = yield* Sqlite;
+  const schema = yield* getSchema;
+  yield* Effect.forEach(schema.tables, (table) =>
+    // The dropped table is completely removed from the database schema and
+    // the disk file. The table can not be recovered.
+    // All indices and triggers associated with the table are also deleted.
+    // https://sqlite.org/lang_droptable.html
+    sqlite.exec({ sql: `drop table "${table.name}"` }),
+  );
+});
+
+const forkSync = (messages: ReadonlyArray<Message> = []) =>
+  SyncLock.pipe(
+    Effect.flatMap((syncLock) => syncLock.tryAcquire),
+    Effect.matchEffect({
+      onFailure: () => Effect.void,
+      onSuccess: () => syncLoop(messages),
+    }),
+    Effect.scoped,
+    Effect.forkDaemon,
+  );
+
+const syncLoop = (
+  messages: ReadonlyArray<Message> = [],
+): Effect.Effect<void, never, Sync | Callbacks | Time | Sqlite | Config> =>
+  Effect.gen(function* (_) {
+    const sqlite = yield* Sqlite;
+    const sync = yield* Sync;
+    const callbacks = yield* Callbacks;
+    const time = yield* Time;
+
+    const syncDataRef = yield* readTimestampAndMerkleTree.pipe(
+      sqlite.transaction("shared"),
+      Effect.map((a): SyncData => ({ ...a, messages })),
+      Effect.flatMap(Ref.make),
+    );
+
+    callbacks.onSyncStateChange({ _tag: "SyncStateIsSyncing" });
+
+    yield* Ref.get(syncDataRef).pipe(
+      Effect.flatMap(sync.sync),
+      Effect.flatMap(handleSyncResult),
+      Effect.repeat({
+        // TODO: Schedule.jittered(Schedule.exponential("10 millis"))
+        schedule: Schedule.recurs(50),
+        until: Option.match({
+          onNone: () =>
+            Effect.gen(function* () {
+              callbacks.onSyncStateChange({
+                _tag: "SyncStateIsSynced",
+                time: yield* time.now,
+              });
+              return true;
+            }),
+          onSome: (syncData) =>
+            Effect.gen(function* () {
+              yield* Ref.set(syncDataRef, syncData);
+              return false;
+            }),
+        }),
+      }),
+      Effect.catchAllDefect((error) =>
+        // Db can run in a Web Worker, so we must ensure transferable error.
+        Effect.fail(makeUnexpectedError(ensureTransferableError(error))),
+      ),
+      Effect.catchTag("SyncStateIsNotSynced", (state) =>
+        Effect.succeed(callbacks.onSyncStateChange(state)),
+      ),
+      Effect.catchAll((error) => Effect.succeed(callbacks.onError(error))),
+    );
+  });
+
+const handleSyncResult = (result: SyncResult) =>
+  Effect.flatMap(Sqlite, (sqlite) =>
+    Effect.gen(function* (_) {
+      const { onReceive } = yield* Callbacks;
+      const current = yield* readTimestampAndMerkleTree;
+      const nextTimestamp = yield* Effect.reduce(
+        result.messages,
+        current.timestamp,
+        (local, message) =>
+          receiveTimestamp({
+            local,
+            remote: unsafeTimestampFromString(message.timestamp),
+          }),
+      );
+      const nextMerkleTree = yield* applyMessages(
+        current.merkleTree,
+        result.messages,
+      );
+      if (result.messages.length > 0) {
+        yield* writeTimestampAndMerkleTree(nextTimestamp, nextMerkleTree);
+        onReceive();
+      }
+      return yield* diffMerkleTrees(result.merkleTree, nextMerkleTree).pipe(
+        Effect.flatMap((diff) =>
+          sqlite.exec({
+            ...Sql.selectMessagesToSync,
+            parameters: [timestampToString(makeSyncTimestamp(diff))],
+          }),
+        ),
+        Effect.map(
+          ({ rows }): SyncData => ({
+            messages: rows as unknown as ReadonlyArray<Message>,
+            merkleTree: nextMerkleTree,
+            timestamp: nextTimestamp,
+          }),
+        ),
+        Effect.option,
+      );
+    }).pipe(sqlite.transaction("exclusive")),
+  );
+
+interface SerializedSqliteQuery {
+  readonly sql: string;
+  readonly parameters: (
+    | null
+    | string
+    | number
+    | Array<number>
+    | { json: JsonObjectOrArray }
+  )[];
+  readonly options?: SqliteQueryOptions;
+}
+
+// We use queries as keys, hence JSON.stringify.
+export const serializeQuery = <R extends Row>({
+  sql,
+  parameters = [],
+  options,
+}: SqliteQuery): Query<R> => {
+  const query: SerializedSqliteQuery = {
+    sql,
+    parameters: parameters.map((p) =>
+      Predicate.isUint8Array(p)
+        ? Arr.fromIterable(p)
+        : isJsonObjectOrArray(p)
+          ? { json: p }
+          : p,
+    ),
+    ...(options && { options }),
+  };
+  return JSON.stringify(query) as Query<R>;
+};
+
+export const deserializeQuery = <R extends Row>(
+  query: Query<R>,
+): SqliteQuery => {
+  const serializedSqliteQuery = JSON.parse(query) as SerializedSqliteQuery;
+  return {
+    ...serializedSqliteQuery,
+    parameters: serializedSqliteQuery.parameters.map((p) =>
+      Arr.isArray(p)
+        ? new Uint8Array(p)
+        : typeof p === "object" && p != null
+          ? p.json
+          : p,
+    ),
+  };
+};
+
+/**
+ * Extract {@link Row} from {@link Query} instance.
+ *
+ * @example
+ *   const allTodos = evolu.createQuery((db) =>
+ *     db.selectFrom("todo").selectAll(),
+ *   );
+ *   type AllTodosRow = ExtractRow<typeof allTodos>;
+ */
+export type ExtractRow<T extends Query> = T extends Query<infer R> ? R : never;
+
+// To preserve identity.
+const _emptyRows: ReadonlyArray<Row> = [];
+export const emptyRows = <R extends Row>(): ReadonlyArray<R> =>
+  _emptyRows as ReadonlyArray<R>;
+
+/** An object with rows and row properties. */
+export interface QueryResult<R extends Row = Row> {
+  /** An array containing all the rows returned by the query. */
+  readonly rows: ReadonlyArray<Readonly<Kysely.Simplify<R>>>;
+
+  /**
+   * The first row returned by the query, or null if no rows were returned. This
+   * property is useful for queries that are expected to return a single row.
+   */
+  readonly row: Readonly<Kysely.Simplify<R>> | null;
+}
+
+export type Queries<R extends Row = Row> = ReadonlyArray<Query<R>>;
+
+export type QueryResultsFromQueries<Q extends Queries> = {
+  [P in keyof Q]: Q[P] extends Query<infer R> ? QueryResult<R> : never;
+};
+
+export type QueryResultsPromisesFromQueries<Q extends Queries> = {
+  [P in keyof Q]: Q[P] extends Query<infer R> ? Promise<QueryResult<R>> : never;
+};
+
+// To preserve identity.
+const queryResultCache = new WeakMap<ReadonlyArray<Row>, QueryResult<Row>>();
+export const queryResultFromRows = <R extends Row>(
+  rows: ReadonlyArray<R>,
+): QueryResult<R> => {
+  let queryResult = queryResultCache.get(rows);
+  if (queryResult == null) {
+    queryResult = { rows, row: rows[0] };
+    queryResultCache.set(rows, queryResult);
+  }
+  return queryResult as QueryResult<R>;
+};
+
+export const notSupportedPlatformWorker: Db = {
+  init: () =>
+    Effect.fail<NotSupportedPlatformError>({
+      _tag: "NotSupportedPlatformError",
+    }),
+  loadQueries: () => Effect.succeed([]),
+  mutate: () => Effect.succeed([]),
+  resetOwner: () => Effect.void,
+  restoreOwner: () => Effect.void,
+  ensureSchema: () => Effect.void,
+  sync: () => Effect.succeed([]),
+};