@evolu/common 7.2.2 → 7.3.0

package/src/local-first/Db.ts

@@ -1,4 +1,9 @@
-import { isNonEmptyArray, NonEmptyReadonlyArray } from "../Array.js";
+import {
+  firstInArray,
+  isNonEmptyArray,
+  NonEmptyReadonlyArray,
+} from "../Array.js";
+import { assertNonEmptyReadonlyArray } from "../Assert.js";
 import { CallbackId } from "../Callbacks.js";
 import { ConsoleConfig, ConsoleDep } from "../Console.js";
 import {
@@ -13,7 +18,6 @@ import { ok, Result } from "../Result.js";
 import {
   createSqlite,
   CreateSqliteDriverDep,
-  explainSqliteQueryPlan,
   sql,
   SqliteDep,
   SqliteError,
@@ -26,9 +30,9 @@ import {
   MessageHandlers,
   Worker,
 } from "../Worker.js";
-import { makePatches, QueryPatches } from "./Diff.js";
 import {
   AppOwner,
+  AppOwnerDep,
   createAppOwner,
   createOwnerSecret,
   createOwnerWebSocketTransport,
@@ -40,11 +44,11 @@ import {
 } from "./Owner.js";
 import { ProtocolError, protocolVersion } from "./Protocol.js";
 import {
-  createQueryRowsCache,
-  deserializeQuery,
-  emptyRows,
+  createGetQueryRowsCache,
+  GetQueryRowsCacheDep,
+  loadQueries,
   Query,
-  QueryRowsCache,
+  QueryPatches,
 } from "./Query.js";
 import {
   DbSchema,
@@ -60,6 +64,7 @@ import {
   createSync,
   SyncDep,
   SyncOwner,
+  tryApplyQuarantinedMessages,
 } from "./Sync.js";
 import {
   Timestamp,
@@ -311,24 +316,16 @@ type DbWorkerDeps = Omit<
   DbWorkerPlatformDeps,
   keyof CreateSqliteDriverDep | keyof CreateWebSocketDep
 > &
+  AppOwnerDep &
   GetQueryRowsCacheDep &
   PostMessageDep &
   SqliteDep &
-  SyncDep &
-  AppOwnerDep;
-
-interface GetQueryRowsCacheDep {
-  readonly getQueryRowsCache: (tabId: Id) => QueryRowsCache;
-}
+  SyncDep;
 
 export interface PostMessageDep {
   readonly postMessage: (message: DbWorkerOutput) => void;
 }
 
-export interface AppOwnerDep {
-  readonly appOwner: AppOwner;
-}
-
 export const createDbWorkerForPlatform = (
   platformDeps: DbWorkerPlatformDeps,
 ): DbWorker =>
@@ -336,154 +333,142 @@ export const createDbWorkerForPlatform = (
     DbWorkerInput,
     DbWorkerOutput,
     DbWorkerDeps
-  >({ init: createDbWorkerDeps(platformDeps), handlers });
-
-const createDbWorkerDeps =
-  (platformDeps: DbWorkerPlatformDeps) =>
-  async (
-    initMessage: Extract<DbWorkerInput, { type: "init" }>,
-    postMessage: (msg: DbWorkerOutput) => void,
-  ): Promise<DbWorkerDeps | null> => {
-    platformDeps.console.enabled = initMessage.config.enableLogging ?? false;
-
-    const sqliteResult = await createSqlite(platformDeps)(
-      initMessage.config.name,
-      {
-        memory: initMessage.config.inMemory ?? false,
-        encryptionKey: initMessage.config.encryptionKey ?? undefined,
-      },
-    );
-    if (!sqliteResult.ok) {
-      postMessage({ type: "onError", error: sqliteResult.error });
-      return null;
-    }
-    const sqlite = sqliteResult.value;
-
-    const deps = sqlite.transaction(() => {
-      const currentDbSchema = getDbSchema({ sqlite })();
-      if (!currentDbSchema.ok) return currentDbSchema;
+  >({
+    init: async (initMessage, postMessage) => {
+      platformDeps.console.enabled = initMessage.config.enableLogging ?? false;
 
-      let appOwner: AppOwner;
-      let clock: Clock;
-
-      const dbIsInitialized = currentDbSchema.value.tables.some(
-        (table) => table.name === "evolu_version",
+      const deps = await createDbWorkerDeps(
+        platformDeps,
+        initMessage,
+        postMessage,
       );
 
-      if (dbIsInitialized) {
-        const currentVersion = sqlite.exec<{
-          protocolVersion: number;
-        }>(sql`select protocolVersion from evolu_version limit 1;`);
-        if (!currentVersion.ok) return currentVersion;
-
-        // TODO: Handle version migrations here if needed
-        // const [{ protocolVersion }] = protocolVersionResult.value.rows;
-        // if (protocolVersion < currentProtocolVersion) {
-        //   const migrateResult = migrateDatabase({ sqlite })(
-        //     protocolVersion,
-        //     currentProtocolVersion
-        //   );
-        //   if (!migrateResult.ok) return migrateResult;
-        // }
-
-        const configResult = sqlite.exec<{
-          clock: TimestampBytes;
-          appOwnerId: OwnerId;
-          appOwnerEncryptionKey: OwnerEncryptionKey;
-          appOwnerWriteKey: OwnerWriteKey;
-          appOwnerMnemonic: Mnemonic | null;
-        }>(sql`
-          select
-            clock,
-            appOwnerId,
-            appOwnerEncryptionKey,
-            appOwnerWriteKey,
-            appOwnerMnemonic
-          from evolu_config
-          limit 1;
-        `);
-        if (!configResult.ok) return configResult;
+      if (!deps.ok) {
+        postMessage({ type: "onError", error: deps.error });
+        return null;
+      }
 
-        const [config] = configResult.value.rows;
+      return deps.value;
+    },
+    handlers,
+  });
 
-        appOwner = {
-          type: "AppOwner",
-          id: config.appOwnerId,
-          encryptionKey: config.appOwnerEncryptionKey,
-          writeKey: config.appOwnerWriteKey,
-          mnemonic: config.appOwnerMnemonic,
-        };
+const createDbWorkerDeps = async (
+  platformDeps: DbWorkerPlatformDeps,
+  initMessage: Extract<DbWorkerInput, { type: "init" }>,
+  postMessage: (msg: DbWorkerOutput) => void,
+) => {
+  const sqlite = await createSqlite(platformDeps)(initMessage.config.name, {
+    memory: initMessage.config.inMemory ?? false,
+    encryptionKey: initMessage.config.encryptionKey ?? undefined,
+  });
+  if (!sqlite.ok) return sqlite;
+
+  const deps = { ...platformDeps, sqlite: sqlite.value };
+
+  return deps.sqlite.transaction(() => {
+    const dbSchema = getDbSchema(deps)();
+    if (!dbSchema.ok) return dbSchema;
+
+    const dbIsInitialized = "evolu_version" in dbSchema.value.tables;
+
+    let appOwner: AppOwner;
+    let clock: Clock;
+
+    if (dbIsInitialized) {
+      const currentVersion = deps.sqlite.exec<{
+        protocolVersion: number;
+      }>(sql`select protocolVersion from evolu_version limit 1;`);
+      if (!currentVersion.ok) return currentVersion;
+
+      const configResult = deps.sqlite.exec<{
+        clock: TimestampBytes;
+        appOwnerId: OwnerId;
+        appOwnerEncryptionKey: OwnerEncryptionKey;
+        appOwnerWriteKey: OwnerWriteKey;
+        appOwnerMnemonic: Mnemonic | null;
+      }>(sql`
+        select
+          clock,
+          appOwnerId,
+          appOwnerEncryptionKey,
+          appOwnerWriteKey,
+          appOwnerMnemonic
+        from evolu_config
+        limit 1;
+      `);
+      if (!configResult.ok) return configResult;
+
+      assertNonEmptyReadonlyArray(configResult.value.rows);
+      const config = firstInArray(configResult.value.rows);
+
+      appOwner = {
+        type: "AppOwner",
+        id: config.appOwnerId,
+        encryptionKey: config.appOwnerEncryptionKey,
+        writeKey: config.appOwnerWriteKey,
+        mnemonic: config.appOwnerMnemonic,
+      };
 
-        clock = createClock({ ...platformDeps, sqlite })(
-          timestampBytesToTimestamp(config.clock),
-        );
-      } else {
-        appOwner =
-          initMessage.config.externalAppOwner ??
-          createAppOwner(createOwnerSecret(platformDeps));
+      clock = createClock(deps)(timestampBytesToTimestamp(config.clock));
+    } else {
+      appOwner =
+        initMessage.config.externalAppOwner ??
+        createAppOwner(createOwnerSecret(platformDeps));
 
-        clock = createClock({ ...platformDeps, sqlite })();
+      clock = createClock(deps)();
 
-        const result = initializeDb({ sqlite })(appOwner, clock.get());
-        if (!result.ok) return result;
-      }
-
-      const result = ensureDbSchema({ sqlite })(
-        initMessage.dbSchema,
-        currentDbSchema.value,
-      );
+      const result = initializeDb(deps)(appOwner, clock.get());
       if (!result.ok) return result;
+    }
 
-      const sync = createSync({
-        ...platformDeps,
-        clock,
-        sqlite,
-        symmetricCrypto: createSymmetricCrypto(platformDeps),
-        timestampConfig: initMessage.config,
-        postMessage,
-      })({
-        appOwner,
-        transports: initMessage.config.transports,
-        onError: (error) => {
-          postMessage({ type: "onError", error });
-        },
-        onReceive: () => {
-          postMessage({ type: "refreshQueries" });
-        },
-      });
-      if (!sync.ok) return sync;
-
-      sync.value.useOwner(true, appOwner);
-
-      const tabQueryRowsCacheMap = new Map<Id, QueryRowsCache>();
-      const getQueryRowsCache = (tabId: Id) => {
-        let cache = tabQueryRowsCacheMap.get(tabId);
-        if (!cache) {
-          cache = createQueryRowsCache();
-          tabQueryRowsCacheMap.set(tabId, cache);
-        }
-        return cache;
-      };
+    {
+      const result = ensureDbSchema(deps)(initMessage.dbSchema, dbSchema.value);
+      if (!result.ok) return result;
+    }
 
-      const deps: DbWorkerDeps = {
-        ...platformDeps,
-        getQueryRowsCache,
-        postMessage,
-        sqlite,
-        sync: sync.value,
-        appOwner,
-      };
+    {
+      const result = ensureMessageQuarantineTable(deps);
+      if (!result.ok) return result;
+    }
 
-      return ok(deps);
+    const sync = createSync({
+      ...deps,
+      clock,
+      symmetricCrypto: createSymmetricCrypto(platformDeps),
+      timestampConfig: initMessage.config,
+      dbSchema: initMessage.dbSchema,
+    })({
+      appOwner,
+      transports: initMessage.config.transports,
+      onError: (error) => {
+        postMessage({ type: "onError", error });
+      },
+      onReceive: () => {
+        postMessage({ type: "refreshQueries" });
+      },
     });
+    if (!sync.ok) return sync;
 
-    if (!deps.ok) {
-      postMessage({ type: "onError", error: deps.error });
-      return null;
+    {
+      const result = tryApplyQuarantinedMessages({
+        ...deps,
+        dbSchema: initMessage.dbSchema,
+      })();
+      if (!result.ok) return result;
     }
 
-    return deps.value;
-  };
+    sync.value.useOwner(true, appOwner);
+
+    return ok({
+      ...deps,
+      getQueryRowsCache: createGetQueryRowsCache(),
+      postMessage,
+      sync: sync.value,
+      appOwner,
+    });
+  });
+};
 
 const initializeDb =
   (deps: SqliteDep) =>
@@ -555,7 +540,6 @@ const initializeDb =
       `,
 
       // Index for reading database changes by owner and timestamp.
-      // Timestamp always corresponds to a DbChange.
       sql`
         create index evolu_history_ownerId_timestamp on evolu_history (
           "ownerId",
@@ -583,6 +567,41 @@ const initializeDb =
     return ok();
   };
 
+/**
+ * Ensures the quarantine table exists for storing messages with unknown schema.
+ *
+ * When a device receives sync messages containing tables or columns that don't
+ * exist in its current schema (e.g., from a newer app version), those messages
+ * are stored here instead of being discarded. This enables forward
+ * compatibility:
+ *
+ * 1. Unknown data is preserved and can be applied when the app is updated
+ * 2. Messages are still propagated to other devices that may understand them
+ * 3. Partial messages work - known columns go to app tables, unknown to quarantine
+ *
+ * The `union all` query in `readDbChange` combines `evolu_history` and this
+ * table, ensuring all data (known and unknown) is included when syncing to
+ * other devices.
+ */
+const ensureMessageQuarantineTable = (
+  deps: SqliteDep,
+): Result<void, SqliteError> => {
+  const result = deps.sqlite.exec(sql`
+    create table if not exists evolu_message_quarantine (
+      "ownerId" blob not null,
+      "timestamp" blob not null,
+      "table" text not null,
+      "id" blob not null,
+      "column" text not null,
+      "value" any,
+      primary key ("ownerId", "timestamp", "table", "id", "column")
+    )
+    strict;
+  `);
+  if (!result.ok) return result;
+  return ok();
+};
+
 const handlers: Omit<MessageHandlers<DbWorkerInput, DbWorkerDeps>, "init"> = {
   getAppOwner: (deps) => () => {
     deps.postMessage({
@@ -654,11 +673,11 @@ const handlers: Omit<MessageHandlers<DbWorkerInput, DbWorkerDeps>, "init"> = {
   },
 
   reset: (deps) => (message) => {
-    const resetResult = deps.sqlite.transaction(() => {
+    const result = deps.sqlite.transaction(() => {
       const dbSchema = getDbSchema(deps)();
       if (!dbSchema.ok) return dbSchema;
 
-      for (const table of dbSchema.value.tables) {
+      for (const tableName in dbSchema.value.tables) {
         /**
          * The dropped table is completely removed from the database schema and
          * the disk file. The table can not be recovered. All indices and
@@ -666,34 +685,27 @@ const handlers: Omit<MessageHandlers<DbWorkerInput, DbWorkerDeps>, "init"> = {
          * https://sqlite.org/lang_droptable.html
          */
         const result = deps.sqlite.exec(sql`
-          drop table ${sql.identifier(table.name)};
+          drop table ${sql.identifier(tableName)};
         `);
         if (!result.ok) return result;
       }
 
       if (message.restore) {
-        const dbSchema = getDbSchema(deps)();
-        if (!dbSchema.ok) return dbSchema;
-
-        const ensureDbSchemaResult = ensureDbSchema(deps)(
-          message.restore.dbSchema,
-          dbSchema.value,
-        );
-        if (!ensureDbSchemaResult.ok) return ensureDbSchemaResult;
+        const result = ensureDbSchema(deps)(message.restore.dbSchema);
+        if (!result.ok) return result;
 
         const secret = mnemonicToOwnerSecret(message.restore.mnemonic);
         const appOwner = createAppOwner(secret);
         const clock = createClock(deps)();
 
-        const initializeDbResult = initializeDb(deps)(appOwner, clock.get());
-        if (!initializeDbResult.ok) return initializeDbResult;
+        return initializeDb(deps)(appOwner, clock.get());
       }
 
       return ok();
     });
 
-    if (!resetResult.ok) {
-      deps.postMessage({ type: "onError", error: resetResult.error });
+    if (!result.ok) {
+      deps.postMessage({ type: "onError", error: result.error });
       return;
     }
 
@@ -705,21 +717,12 @@ const handlers: Omit<MessageHandlers<DbWorkerInput, DbWorkerDeps>, "init"> = {
   },
 
   ensureDbSchema: (deps) => (message) => {
-    const ensureSchema = deps.sqlite.transaction(() => {
-      const dbSchema = getDbSchema(deps)();
-      if (!dbSchema.ok) return dbSchema;
-
-      const ensureDbSchemaResult = ensureDbSchema(deps)(
-        message.dbSchema,
-        dbSchema.value,
-      );
-      if (!ensureDbSchemaResult.ok) return ensureDbSchemaResult;
-
-      return ok();
-    });
+    const result = deps.sqlite.transaction(() =>
+      ensureDbSchema(deps)(message.dbSchema),
+    );
 
-    if (!ensureSchema.ok) {
-      deps.postMessage({ type: "onError", error: ensureSchema.error });
+    if (!result.ok) {
+      deps.postMessage({ type: "onError", error: result.error });
       return;
     }
   },
@@ -743,41 +746,3 @@ const handlers: Omit<MessageHandlers<DbWorkerInput, DbWorkerDeps>, "init"> = {
     deps.sync.useOwner(message.use, message.owner);
   },
 };
-
-const loadQueries =
-  (deps: GetQueryRowsCacheDep & SqliteDep) =>
-  (
-    tabId: Id,
-    queries: ReadonlyArray<Query>,
-  ): Result<ReadonlyArray<QueryPatches>, SqliteError> => {
-    const queriesRows = [];
-
-    for (const query of queries) {
-      const sqlQuery = deserializeQuery(query);
-      const result = deps.sqlite.exec(sqlQuery);
-      if (!result.ok) return result;
-
-      queriesRows.push([query, result.value.rows] as const);
-      if (sqlQuery.options?.logExplainQueryPlan) {
-        explainSqliteQueryPlan(deps)(sqlQuery);
-      }
-    }
-
-    const queryRowsCache = deps.getQueryRowsCache(tabId);
-
-    const previousState = queryRowsCache.get();
-    queryRowsCache.set(queriesRows);
-
-    const currentState = queryRowsCache.get();
-
-    const queryPatchesArray = queries.map(
-      (query): QueryPatches => ({
-        query,
-        patches: makePatches(
-          previousState.get(query),
-          currentState.get(query) ?? emptyRows,
-        ),
-      }),
-    );
-    return ok(queryPatchesArray);
-  };

package/src/local-first/Evolu.ts

@@ -4,7 +4,7 @@ import {
   isNonEmptyArray,
   isNonEmptyReadonlyArray,
 } from "../Array.js";
-import { assertNonEmptyReadonlyArray } from "../Assert.js";
+import { assert, assertNonEmptyReadonlyArray } from "../Assert.js";
 import { createCallbacks } from "../Callbacks.js";
 import { ConsoleDep } from "../Console.js";
 import { RandomBytesDep, SymmetricCryptoDecryptError } from "../Crypto.js";
@@ -17,6 +17,7 @@ import {
   isSqlMutation,
   SafeSql,
   SqliteBoolean,
+  sqliteBooleanToBoolean,
   SqliteError,
   SqliteQuery,
 } from "../Sqlite.js";
@@ -36,11 +37,11 @@ import {
 } from "../Type.js";
 import { IntentionalNever } from "../Types.js";
 import { CreateDbWorkerDep, DbConfig, defaultDbConfig } from "./Db.js";
-import { applyPatches } from "./Diff.js";
 import { AppOwner } from "./Owner.js";
 import { FlushSyncDep, ReloadAppDep } from "./Platform.js";
 import { ProtocolError } from "./Protocol.js";
 import {
+  applyPatches,
   createSubscribedQueries,
   emptyRows,
   Queries,
@@ -100,6 +101,9 @@ export interface EvoluConfig extends Partial<DbConfig> {
    * URL to reload browser tabs after reset or restore.
    *
    * The default value is `/`.
+   *
+   * Note: This option will be moved to web platform deps in the next major
+   * version.
    */
   readonly reloadUrl?: string;
 }
@@ -730,13 +734,20 @@ const createEvoluInstance =
           } else {
             const { id: _, isDeleted, ...values } = result.value;
 
-            const dbChange = DbChange.orThrow({
+            const dbChange = {
               table,
               id,
               values,
               isInsert: kind === "insert" || kind === "upsert",
-              isDelete: SqliteBoolean.is(isDeleted) ? Boolean(isDeleted) : null,
-            });
+              isDelete: SqliteBoolean.is(isDeleted)
+                ? sqliteBooleanToBoolean(isDeleted)
+                : null,
+            };
+
+            assert(
+              DbChange.is(dbChange),
+              `Invalid DbChange for table '${table}': Please check schema type errors.`,
+            );
 
             mutateMicrotaskQueue.push([
               { ...dbChange, ownerId: options?.ownerId },
@@ -828,15 +839,15 @@ const createEvoluInstance =
 
       subscribeQuery: (query) => (listener) => {
         // Call the listener only if the result has been changed.
-        let previousResult: unknown = null;
+        let previousRows: unknown = null;
         const unsubscribe = subscribedQueries.subscribe(query)(() => {
-          const result = evolu.getQueryRows(query);
-          if (previousResult === result) return;
-          previousResult = result;
+          const rows = evolu.getQueryRows(query);
+          if (previousRows === rows) return;
+          previousRows = rows;
           listener();
         });
         return () => {
-          previousResult = null;
+          previousRows = null;
           unsubscribe();
         };
       },

package/src/local-first/LocalAuth.ts

@@ -47,9 +47,9 @@ export interface LocalAuthDep {
 }
 
 /**
- * - **⚠️
- *
  * Secure storage interface that must be implemented by each platform.
+ *
+ * @experimental
  */
 export interface SecureStorage {
   setItem: (

package/src/local-first/Owner.ts

@@ -188,6 +188,10 @@ export interface AppOwner extends Owner {
   readonly mnemonic?: Mnemonic | null;
 }
 
+export interface AppOwnerDep {
+  readonly appOwner: AppOwner;
+}
+
 /** Creates an {@link AppOwner} from an {@link OwnerSecret}. */
 export const createAppOwner = (secret: OwnerSecret): AppOwner => ({
   ...createOwner(secret),