@evolu/common 8.15.0 → 8.16.0

package/src/Worker.ts

@@ -656,6 +656,9 @@ export const testCreateMessagePort: CreateMessagePort = <Input, Output = never>(
 /**
  * Creates an in-memory {@link BroadcastChannel} for testing.
  *
+ * Like a native channel, it structured-clones each message, so posting a value
+ * that cannot be cloned throws.
+ *
  * @group Testing
  */
 export const testCreateBroadcastChannel = <Input, Output = Input>(
@@ -667,7 +670,9 @@ export const testCreateBroadcastChannel = <Input, Output = Input>(
   const disposables = disposer.move();
 
   return {
-    postMessage: channel.postMessage,
+    postMessage: (message) => {
+      channel.postMessage(structuredClone(message));
+    },
     get onMessage() {
       return channel.onMessage;
     },

package/src/local-first/Db.ts

@@ -137,7 +137,10 @@ import type {
   EvoluInput,
   SharedWorkerId,
 } from "./Shared.ts";
-import { consoleEntryOrErrorBroadcastChannelName } from "./Shared.ts";
+import {
+  consoleEntryOrErrorBroadcastChannelName,
+  postConsoleEntry,
+} from "./Shared.ts";
 import {
   createBaseSqliteStorage,
   createBaseSqliteStorageTables,
@@ -229,6 +232,13 @@ export const startDbWorker =
         self.onMessage = (message) => resolve(ok(message));
       }),
     );
+    // Tabs report the errors this worker logs as an UnknownError, so it
+    // forwards them even for a silent app, whose tabs do not print them.
+    deps.console.setLevel(
+      initMessage.consoleLevel === "silent"
+        ? "error"
+        : initMessage.consoleLevel,
+    );
 
     const port = disposer.use(
       deps.createMessagePort<DbWorkerOutput, DbWorkerInput>(initMessage.port),
@@ -242,11 +252,7 @@ export const startDbWorker =
     disposer.defer(
       deps.consoleStoreOutputEntry.subscribe(() => {
         const entry = deps.consoleStoreOutputEntry.get();
-        if (entry)
-          consoleEntryOrErrorBroadcastChannel.postMessage({
-            type: "ConsoleEntry",
-            entry,
-          });
+        if (entry) postConsoleEntry(consoleEntryOrErrorBroadcastChannel, entry);
       }),
     );
 
@@ -310,7 +316,6 @@ export const startDbWorker =
       // waits on. The tab leader lock is unaffected.
       port.postMessage({
         type: "LeaderRefused",
-        name: initMessage.name,
         error: startup.error,
       });
       return ok();
@@ -322,7 +327,6 @@ export const startDbWorker =
 
     port.postMessage({
       type: "LeaderAcquired",
-      name: initMessage.name,
       clock: initialClock,
     });
 

package/src/local-first/Evolu.ts

@@ -195,6 +195,10 @@ export interface EvoluConfig {
   /**
    * Use the `indexes` option to define SQLite indexes.
    *
+   * Unique indexes are rejected with an assertion because concurrent offline
+   * writes can violate uniqueness during synchronization. See
+   * [Uniqueness](https://www.evolu.dev/docs/schema#uniqueness).
+   *
    * Table and column names are not typed because Kysely doesn't support it.
    *
    * https://medium.com/@JasonWyatt/squeezing-performance-from-sqlite-indexes-indexes-c4e175f3c346

package/src/local-first/Schema.test.ts

@@ -4,6 +4,7 @@ import {
   assertErr,
   assertOk,
   assertSame,
+  assertThrowsInstanceOf,
   assertType,
   createEvolu,
   createQueryBuilder,
@@ -27,7 +28,7 @@ import {
   type TimestampBytes,
 } from "../index.ts";
 import type { EvoluPlatformDeps } from "./Evolu.ts";
-import type { ValidateSchema } from "./Schema.ts";
+import { evoluSchemaToSqliteSchema, type ValidateSchema } from "./Schema.ts";
 
 test("history queries select and filter by ownerId bytes", () => {
   const createQuery = createQueryBuilder(testEvoluSchema);
@@ -44,6 +45,84 @@ test("history queries select and filter by ownerId bytes", () => {
   >();
 });
 
+test("evoluSchemaToSqliteSchema compiles ordinary indexes", () => {
+  const sqliteSchema = evoluSchemaToSqliteSchema(testEvoluSchema, (create) => [
+    create("todoTitle").on("todo").column("title"),
+    create("todoProjectIdTitle").on("todo").columns(["projectId", "title"]),
+    create("todoTitleNotNull")
+      .on("todo")
+      .column("title")
+      .where("title", "is not", null),
+  ]);
+
+  assertEqual(sqliteSchema.indexes, [
+    {
+      name: "todoTitle",
+      sql: 'create index "todoTitle" on "todo" ("title")',
+    },
+    {
+      name: "todoProjectIdTitle",
+      sql: 'create index "todoProjectIdTitle" on "todo" ("projectId", "title")',
+    },
+    {
+      name: "todoTitleNotNull",
+      sql: 'create index "todoTitleNotNull" on "todo" ("title") where "title" is not null',
+    },
+  ]);
+});
+
+test("evoluSchemaToSqliteSchema rejects unique indexes", () => {
+  const error = assertThrowsInstanceOf(
+    () =>
+      evoluSchemaToSqliteSchema(testEvoluSchema, (create) => [
+        create("todoUniqueTitle").on("todo").column("title").unique(),
+      ]),
+    Error,
+  );
+
+  assertEqual(
+    error.message,
+    "Unique indexes are not supported because they can prevent synchronization.",
+  );
+});
+
+test("evoluSchemaToSqliteSchema rejects composite unique indexes", () => {
+  const error = assertThrowsInstanceOf(
+    () =>
+      evoluSchemaToSqliteSchema(testEvoluSchema, (create) => [
+        create("todoUniqueProjectIdTitle")
+          .on("todo")
+          .columns(["projectId", "title"])
+          .unique(),
+      ]),
+    Error,
+  );
+
+  assertEqual(
+    error.message,
+    "Unique indexes are not supported because they can prevent synchronization.",
+  );
+});
+
+test("evoluSchemaToSqliteSchema rejects partial unique indexes", () => {
+  const error = assertThrowsInstanceOf(
+    () =>
+      evoluSchemaToSqliteSchema(testEvoluSchema, (create) => [
+        create("todoUniqueTitleNotNull")
+          .on("todo")
+          .column("title")
+          .where("title", "is not", null)
+          .unique(),
+      ]),
+    Error,
+  );
+
+  assertEqual(
+    error.message,
+    "Unique indexes are not supported because they can prevent synchronization.",
+  );
+});
+
 test("testEvoluSchema supports project-linked and independent todos", () => {
   assertType<TestEvoluSchema, typeof testEvoluSchema>();
   assertType<ValidateSchema<TestEvoluSchema>, TestEvoluSchema>();

package/src/local-first/Schema.ts

@@ -6,7 +6,7 @@
 
 import * as Kysely from "kysely";
 import type { StandardSchemaV1 } from "@standard-schema/spec";
-import { assertNonNullable } from "../Assert.ts";
+import { assert, assertNonNullable } from "../Assert.ts";
 import { getOwnProp, mapObject, type ReadonlyRecord } from "../Object.ts";
 import {
   eqSqliteIndex,
@@ -299,6 +299,9 @@ export type ValidateSchema<S extends EvoluSchema> =
 /**
  * Defines SQLite indexes with Kysely's index builder.
  *
+ * Unique indexes are not supported because concurrent offline writes can
+ * violate uniqueness during synchronization.
+ *
  * @group SQLite
  */
 export type IndexesConfig = (
@@ -800,10 +803,17 @@ export const evoluSchemaToSqliteSchema = <S extends EvoluSchema>(
   );
 
   const indexes = indexesConfig
-    ? indexesConfig(createIndex).map((index): SqliteIndex => ({
-        name: index.toOperationNode().name.name,
-        sql: index.compile().sql,
-      }))
+    ? indexesConfig(createIndex).map((index): SqliteIndex => {
+        const node = index.toOperationNode();
+        assert(
+          !node.unique,
+          "Unique indexes are not supported because they can prevent synchronization.",
+        );
+        return {
+          name: node.name.name,
+          sql: index.compile().sql,
+        };
+      })
     : [];
 
   return { tables, indexes };