@evolu/common 8.0.0-next.3 → 8.0.0-next.5

package/src/local-first/Db.ts

@@ -18,6 +18,8 @@ import {
   type RandomBytesDep,
 } from "../Crypto.js";
 import { exhaustiveCheck, lazyFalse, lazyVoid } from "../Function.js";
+import type { LockManagerDep } from "../LockManager.js";
+import { acquireLeaderLock } from "../LockManager.js";
 import { createRecord, getProperty, objectToEntries } from "../Object.js";
 import { ok, type Result } from "../Result.js";
 import type {
@@ -35,7 +37,7 @@ import {
   sqliteQueryStringToSqliteQuery,
   SqliteValue,
 } from "../Sqlite.js";
-import { callback, type LeaderLockDep, type Task } from "../Task.js";
+import { callback, type Task } from "../Task.js";
 import { Millis, millisToDateIso, type TimeDep } from "../Time.js";
 import type { Name } from "../Type.js";
 import {
@@ -47,6 +49,7 @@ import {
 } from "../Type.js";
 import type { ExtractType } from "../Types.js";
 import type {
+  CreateBroadcastChannelDep,
   NativeMessagePort,
   Worker,
   WorkerDeps,
@@ -72,7 +75,14 @@ import {
   getEvoluSqliteSchema,
   systemColumns,
 } from "./Schema.js";
-import type { DbWorkerInput, DbWorkerOutput } from "./Shared.js";
+import type {
+  ConsoleEntryOrError,
+  DbWorkerInput,
+  DbWorkerOutput,
+  DbWorkerQueuedResponse,
+  DbWorkerRequest,
+} from "./Shared.js";
+import { consoleEntryOrErrorBroadcastChannelName } from "./Shared.js";
 import {
   createBaseSqliteStorage,
   createBaseSqliteStorageTables,
@@ -105,7 +115,7 @@ import {
 export type DbWorker = Worker<DbWorkerInit>;
 
 export interface DbWorkerInit {
-  readonly type: "Init";
+  readonly type: "DbWorkerInit";
   readonly name: Name;
   readonly consoleLevel: ConsoleLevel;
   readonly sqliteSchema: SqliteSchema;
@@ -120,13 +130,16 @@ export interface CreateDbWorkerDep {
   readonly createDbWorker: CreateDbWorker;
 }
 
-export type DbWorkerDeps = WorkerDeps & LeaderLockDep & CreateSqliteDriverDep;
+export type DbWorkerDeps = WorkerDeps &
+  CreateBroadcastChannelDep &
+  LockManagerDep &
+  CreateSqliteDriverDep;
 
 export const startDbWorker =
   (self: WorkerSelf<DbWorkerInit>): Task<void, never, DbWorkerDeps> =>
-  async (_run) => {
-    await using stack = new AsyncDisposableStack();
-    const run = stack.use(_run.create());
+  async (run) => {
+    await using disposer = new AsyncDisposableStack();
+    disposer.use(self);
     const { deps } = run;
 
     let initialized = false;
@@ -143,25 +156,33 @@ export const startDbWorker =
 
     const console = deps.console.child(initMessage.name).child("DbWorker");
     console.setLevel(initMessage.consoleLevel);
-    console.info("start DbWorker");
 
-    const port = stack.use(
+    const port = disposer.use(
       deps.createMessagePort<DbWorkerOutput, DbWorkerInput>(initMessage.port),
     );
+    const consoleEntryOrErrorBroadcastChannel = disposer.use(
+      deps.createBroadcastChannel<ConsoleEntryOrError>(
+        consoleEntryOrErrorBroadcastChannelName,
+      ),
+    );
 
-    stack.defer(
+    disposer.defer(
       deps.consoleStoreOutputEntry.subscribe(() => {
         const entry = deps.consoleStoreOutputEntry.get();
-        if (entry) port.postMessage({ type: "OnConsoleEntry", entry });
+        if (entry)
+          consoleEntryOrErrorBroadcastChannel.postMessage({
+            type: "ConsoleEntry",
+            entry,
+          });
       }),
     );
+    console.debug("createDbWorker");
 
-    stack.use(await run.orThrow(deps.leaderLock.lock(initMessage.name)));
-    if (stack.disposed) return ok();
+    disposer.use(await run.orThrow(acquireLeaderLock(initMessage.name)));
 
     port.postMessage({ type: "LeaderAcquired", name: initMessage.name });
 
-    const sqlite = stack.use(
+    const sqlite = disposer.use(
       await run.orThrow(
         createSqlite(
           initMessage.name,
@@ -173,15 +194,19 @@ export const startDbWorker =
     );
     console.debug("SQLite created");
 
-    const baseSqliteStorage = createBaseSqliteStorage({ sqlite, ...run.deps });
+    const baseSqliteStorage = createBaseSqliteStorage({
+      sqlite,
+      ...deps,
+    });
 
     const dbDeps = {
-      ...run.deps,
+      ...deps,
       sqlite,
       sqliteSchema: initMessage.sqliteSchema,
       baseSqliteStorage,
       timestampConfig: { maxDrift: defaultTimestampMaxDrift },
     };
+    const dbWorkerRun = disposer.use(run.create());
 
     const currentSchema = getEvoluSqliteSchema(dbDeps)();
     const dbIsInitialized = "evolu_version" in currentSchema.tables;
@@ -195,33 +220,25 @@ export const startDbWorker =
 
     const storage = createClientStorage({ ...dbDeps, clock })({
       onError: (error) => {
-        port.postMessage({ type: "OnError", error });
+        consoleEntryOrErrorBroadcastChannel.postMessage({
+          type: "Error",
+          error,
+        });
       },
     });
 
-    // TODO: Call on dispose message.
-    const _moved = stack.move();
-    const runWithStorage = run.addDeps({ storage });
+    const disposables = disposer.move();
 
-    /**
-     * SharedWorker retries until some leader replies, so this worker must
-     * ignore callback IDs it already completed.
-     *
-     * The Set intentionally lives for one leader's lifetime. If that leader tab
-     * closes, retries go to a new leader with a fresh Set. Revisit this only if
-     * memory pressure shows up; even millions of short callback IDs are
-     * acceptable here, and naive eviction could let a still-retried request run
-     * again.
-     */
-    const processedRequestIds = new Set<Id>();
+    port.onMessage = (input) => {
+      if (input.type === "Dispose") {
+        if (!disposables.disposed) console.debug("disposeDbWorker");
+        void disposables.disposeAsync();
+        return;
+      }
 
-    port.onMessage = ({ callbackId, request }) => {
-      if (processedRequestIds.has(callbackId)) return;
-      processedRequestIds.add(callbackId);
+      const { callbackId, request } = input;
 
-      const postQueuedResponse = (
-        response: ExtractType<DbWorkerOutput, "OnQueuedResponse">["response"],
-      ): void => {
+      const postQueuedResponse = (response: DbWorkerQueuedResponse): void => {
         port.postMessage(
           { type: "OnQueuedResponse", callbackId, response },
           response.type === "ForEvolu" && response.message.type === "Export"
@@ -238,11 +255,14 @@ export const startDbWorker =
                 request.message,
               );
               if (!result.ok) {
-                port.postMessage({ type: "OnError", error: result.error });
+                consoleEntryOrErrorBroadcastChannel.postMessage({
+                  type: "Error",
+                  error: result.error,
+                });
               } else {
                 postQueuedResponse({
                   type: "ForEvolu",
-                  evoluPortId: request.evoluPortId,
+                  id: request.id,
                   message: result.value,
                 });
               }
@@ -252,7 +272,7 @@ export const startDbWorker =
             case "Query":
               postQueuedResponse({
                 type: "ForEvolu",
-                evoluPortId: request.evoluPortId,
+                id: request.id,
                 message: {
                   type: "Query",
                   rowsByQuery: loadQueries(dbDeps)(request.message.queries),
@@ -263,7 +283,7 @@ export const startDbWorker =
             case "Export":
               postQueuedResponse({
                 type: "ForEvolu",
-                evoluPortId: request.evoluPortId,
+                id: request.id,
                 message: {
                   type: "Export",
                   file: dbDeps.sqlite.export(),
@@ -307,29 +327,34 @@ export const startDbWorker =
             case "ApplySyncMessage": {
               const { owner, inputMessage } = request.message;
 
-              runWithStorage<void, never>(async (run) => {
-                storage.setRequestContext(owner.encryptionKey);
+              dbWorkerRun<void, never, { readonly storage: ClientStorage }>(
+                async (run) => {
+                  const { storage } = run.deps;
 
-                const result = await run(
-                  applyProtocolMessageAsClient(inputMessage, {
-                    writeKey: owner.writeKey,
-                  }),
-                );
+                  storage.setRequestContext(owner.encryptionKey);
 
-                const didWriteMessages = storage.didWriteMessages();
+                  const result = await run(
+                    applyProtocolMessageAsClient(inputMessage, {
+                      writeKey: owner.writeKey,
+                    }),
+                  );
 
-                postQueuedResponse({
-                  type: "ForSharedWorker",
-                  message: {
-                    type: "ApplySyncMessage",
-                    ownerId: owner.id,
-                    didWriteMessages,
-                    result,
-                  },
-                });
+                  const didWriteMessages = storage.didWriteMessages();
 
-                return ok();
-              });
+                  postQueuedResponse({
+                    type: "ForSharedWorker",
+                    message: {
+                      type: "ApplySyncMessage",
+                      ownerId: owner.id,
+                      didWriteMessages,
+                      result,
+                    },
+                  });
+
+                  return ok();
+                },
+                { storage },
+              );
               break;
             }
 
@@ -777,7 +802,7 @@ const handleMutation =
   ) =>
   (
     message: ExtractType<
-      ExtractType<DbWorkerInput["request"], "ForEvolu">["message"],
+      ExtractType<DbWorkerRequest, "ForEvolu">["message"],
       "Mutate"
     >,
   ): Result<

package/src/local-first/Evolu.ts

@@ -20,6 +20,11 @@ import type { ConsoleDep } from "../Console.js";
 import { createConsole } from "../Console.js";
 import { createUnknownError } from "../Error.js";
 import { exhaustiveCheck, todo } from "../Function.js";
+import {
+  acquireLeaderLock,
+  acquireLeaderLockCallback,
+  type LockManagerDep,
+} from "../LockManager.js";
 import { createMicrotaskBatch } from "../Microtask.js";
 import type { FlushSyncDep, ReloadAppDep } from "../Platform.js";
 import { createRefCountByKey } from "../RefCount.js";
@@ -38,7 +43,10 @@ import {
   UrlSafeString,
 } from "../Type.js";
 import type { ExtractType } from "../Types.js";
-import type { CreateMessageChannelDep } from "../Worker.js";
+import type {
+  CreateBroadcastChannelDep,
+  CreateMessageChannelDep,
+} from "../Worker.js";
 import type { CreateDbWorkerDep } from "./Db.js";
 import type { EvoluError } from "./Error.js";
 import type {
@@ -68,13 +76,12 @@ import type {
 } from "./Schema.js";
 import { evoluSchemaToSqliteSchema } from "./Schema.js";
 import type {
-  DbWorkerInput,
-  DbWorkerOutput,
+  ConsoleEntryOrError,
   EvoluInput,
   EvoluOutput,
-  EvoluTabOutput,
   SharedWorkerDep,
 } from "./Shared.js";
+import { consoleEntryOrErrorBroadcastChannelName } from "./Shared.js";
 import { DbChange } from "./Storage.js";
 import type { Timestamp } from "./Timestamp.js";
 
@@ -547,7 +554,9 @@ export type EvoluDeps = EvoluPlatformDeps & EvoluErrorDep & Disposable;
  * logging and synchronous UI flush.
  */
 export type EvoluPlatformDeps = CreateDbWorkerDep &
+  CreateBroadcastChannelDep &
   CreateMessageChannelDep &
+  LockManagerDep &
   ReloadAppDep &
   SharedWorkerDep &
   Partial<ConsoleDep> &
@@ -565,17 +574,21 @@ export type EvoluPlatformDeps = CreateDbWorkerDep &
  * Dispose it only during app shutdown.
  */
 export const createEvoluDeps = (deps: EvoluPlatformDeps): EvoluDeps => {
-  const { createMessageChannel, sharedWorker } = deps;
+  const { createBroadcastChannel, sharedWorker } = deps;
   const console = deps.console ?? createConsole();
 
-  const stack = new DisposableStack();
-  stack.use(sharedWorker);
-  const evoluError = stack.use(createStore<EvoluError | null>(null));
+  using disposer = new DisposableStack();
+  disposer.use(sharedWorker);
+  const evoluError = disposer.use(createStore<EvoluError | null>(null));
 
-  const tabChannel = stack.use(createMessageChannel<EvoluTabOutput>());
-  tabChannel.port2.onMessage = (message) => {
+  const consoleEntryOrErrorBroadcastChannel = disposer.use(
+    createBroadcastChannel<ConsoleEntryOrError>(
+      consoleEntryOrErrorBroadcastChannelName,
+    ),
+  );
+  consoleEntryOrErrorBroadcastChannel.onMessage = (message) => {
     switch (message.type) {
-      case "OnConsoleEntry":
+      case "ConsoleEntry":
         console.write(message.entry);
         // Fallback channel for unexpected errors without EvoluError typing.
         if (message.entry.method === "error") {
@@ -583,7 +596,7 @@ export const createEvoluDeps = (deps: EvoluPlatformDeps): EvoluDeps => {
         }
         break;
 
-      case "OnError":
+      case "Error":
         evoluError.set(message.error);
         // Keep typed errors visible in logs as operational failures.
         console.error(message.error);
@@ -594,21 +607,25 @@ export const createEvoluDeps = (deps: EvoluPlatformDeps): EvoluDeps => {
     }
   };
 
-  sharedWorker.port.postMessage(
-    {
-      type: "InitTab",
-      consoleLevel: console.getLevel(),
-      port: tabChannel.port1.native,
-    },
-    [tabChannel.port1.native],
+  sharedWorker.port.onMessage = (message) => {
+    deps.createDbWorker().postMessage(message, [message.port]);
+  };
+
+  disposer.use(
+    acquireLeaderLockCallback(deps)("tab", () => {
+      sharedWorker.port.postMessage({
+        type: "AnnounceTabLeader",
+        consoleLevel: console.getLevel(),
+      });
+    }),
   );
 
-  const moved = stack.move();
+  const disposables = disposer.move();
 
   return {
     ...deps,
     evoluError,
-    [Symbol.dispose]: () => moved.dispose(),
+    [Symbol.dispose]: () => disposables.dispose(),
   };
 };
 
@@ -633,12 +650,14 @@ export const createEvolu =
     const console = run.deps.console.child(name).child("Evolu");
     console.info("createEvolu");
 
-    await using stack = new AsyncDisposableStack();
+    await using disposer = new AsyncDisposableStack();
 
-    const rowsByQueryMapStore = stack.use(
+    const rowsByQueryMapStore = disposer.use(
       createStore<RowsByQueryMap>(new Map()),
     );
-    const subscribedQueriesRefCount = stack.use(createRefCountByKey<Query>());
+    const subscribedQueriesRefCount = disposer.use(
+      createRefCountByKey<Query>(),
+    );
 
     interface LoadingPromise {
       /**
@@ -662,7 +681,7 @@ export const createEvolu =
      * Settle pending query loads during disposal so awaiting callers and React
      * `use` thenables do not hang forever during teardown.
      */
-    const loadingPromisesByQuery = stack.adopt(
+    const loadingPromisesByQuery = disposer.adopt(
       new Map<Query, LoadingPromise>(),
       (loadingPromisesByQuery) => {
         for (const loadingPromise of loadingPromisesByQuery.values()) {
@@ -715,18 +734,18 @@ export const createEvolu =
       }
     };
 
-    const onMutateCompleteCallbacks = stack.use(createCallbacks(run.deps));
+    const onMutateCompleteCallbacks = disposer.use(createCallbacks(run.deps));
 
     let exportDatabasePending = null as PromiseWithResolvers<
       Uint8Array<ArrayBuffer>
     > | null;
 
-    stack.defer(() => {
+    disposer.defer(() => {
       exportDatabasePending?.reject({ type: "EvoluDisposedError" });
       exportDatabasePending = null;
     });
 
-    const mutateBatch = stack.use(
+    const mutateBatch = disposer.use(
       createMicrotaskBatch<{
         readonly change: MutationChange;
         readonly onComplete: (() => void) | undefined;
@@ -747,7 +766,7 @@ export const createEvolu =
       }),
     );
 
-    const queryBatch = stack.use(
+    const queryBatch = disposer.use(
       createMicrotaskBatch<Query>((queries) => {
         const dedupedQueries = new Set(queries);
         assert(
@@ -759,7 +778,7 @@ export const createEvolu =
       }),
     );
 
-    const useOwnerBatch = stack.use(
+    const useOwnerBatch = disposer.use(
       createMicrotaskBatch<
         ExtractType<EvoluInput, "UseOwner">["actions"][number]
       >((actions) => postMessage({ type: "UseOwner", actions })),
@@ -769,11 +788,11 @@ export const createEvolu =
 
     // Scope worker/channel wiring and keep only postMessage outside.
     {
-      const { createDbWorker, createMessageChannel, sharedWorker } = run.deps;
-      const dbWorkerChannel = stack.use(
-        createMessageChannel<DbWorkerOutput, DbWorkerInput>(),
-      );
-      const evoluChannel = stack.use(
+      const id = createId<"EvoluInstance">(run.deps);
+      const { createMessageChannel, sharedWorker } = run.deps;
+      disposer.use(await run.orThrow(acquireLeaderLock(id)));
+
+      const evoluChannel = disposer.use(
         createMessageChannel<EvoluInput, EvoluOutput>(),
       );
 
@@ -858,35 +877,17 @@ export const createEvolu =
         {
           type: "CreateEvolu",
           name,
-          evoluPort: evoluChannel.port2.native,
-          dbWorkerPort: dbWorkerChannel.port2.native,
-        },
-        [evoluChannel.port2.native, dbWorkerChannel.port2.native],
-      );
-
-      /**
-       * No stack.use because Evolu instances don't dispose DbWorker because
-       * it's SharedWorder responsibility. DbWorker can be used by another tab.
-       * That's required because SQLite WASM needs a single web worker.
-       */
-      createDbWorker().postMessage(
-        {
-          type: "Init",
-          name,
+          id,
           consoleLevel: console.getLevel(),
           sqliteSchema: evoluSchemaToSqliteSchema(schema, config.indexes),
           encryptionKey: appOwner.encryptionKey,
           memoryOnly,
-          port: dbWorkerChannel.port1.native,
+          evoluPort: evoluChannel.port2.native,
         },
-        [dbWorkerChannel.port1.native],
+        [evoluChannel.port2.native],
       );
 
       postMessage = evoluChannel.port1.postMessage;
-
-      stack.defer(() => {
-        postMessage({ type: "Dispose" });
-      });
     }
 
     const createMutation =
@@ -894,7 +895,7 @@ export const createEvolu =
         kind: Kind,
       ): Mutation<S, Kind> =>
       (table, values, options) => {
-        assertNotDisposed(moved);
+        assertNotDisposed(disposables);
 
         const {
           id = createId(run.deps),
@@ -928,7 +929,7 @@ export const createEvolu =
     const loadQuery = <R extends Row>(
       query: Query<S, R>,
     ): Promise<QueryRows<R>> => {
-      assertNotDisposed(moved);
+      assertNotDisposed(disposables);
 
       const loadingPromise = loadingPromisesByQuery.get(query);
       if (loadingPromise) {
@@ -951,7 +952,7 @@ export const createEvolu =
     };
 
     const getQueryRows = <R extends Row>(query: Query<S, R>): QueryRows<R> => {
-      assertNotDisposed(moved);
+      assertNotDisposed(disposables);
 
       return (rowsByQueryMapStore.get().get(query) ??
         emptyArray) as QueryRows<R>;
@@ -961,7 +962,7 @@ export const createEvolu =
       owner: ReadonlyOwner | Owner,
       ownerTransports?: NonEmptyReadonlyArray<OwnerTransport>,
     ): UnuseOwner => {
-      assertNotDisposed(moved);
+      assertNotDisposed(disposables);
 
       const effectiveTransports = ownerTransports ?? transports;
       assertNonEmptyReadonlyArray(
@@ -982,6 +983,7 @@ export const createEvolu =
       let isUsed = true;
 
       return () => {
+        if (disposables.disposed) return;
         assert(isUsed, "UnuseOwner can be called only once.");
         isUsed = false;
         useOwnerBatch.push({
@@ -991,10 +993,14 @@ export const createEvolu =
       };
     };
 
-    const moved = stack.move();
+    const disposables = disposer.move();
 
     if (isNonEmptyArray(transports)) useOwner(appOwner);
 
+    if (run.signal.aborted) {
+      await disposables.disposeAsync();
+    }
+
     return ok({
       name,
       appOwner,
@@ -1012,7 +1018,7 @@ export const createEvolu =
         ],
 
       subscribeQuery: (query) => (listener) => {
-        assertNotDisposed(moved);
+        assertNotDisposed(disposables);
 
         subscribedQueriesRefCount.increment(query);
         let isSubscribed = true;
@@ -1036,7 +1042,7 @@ export const createEvolu =
           previousRows = null;
           unsubscribe();
 
-          if (moved.disposed) return;
+          if (disposables.disposed) return;
 
           subscribedQueriesRefCount.decrement(query);
         };
@@ -1044,7 +1050,7 @@ export const createEvolu =
       getQueryRows,
 
       exportDatabase: () => {
-        assertNotDisposed(moved);
+        assertNotDisposed(disposables);
 
         if (!exportDatabasePending) {
           exportDatabasePending =
@@ -1055,12 +1061,12 @@ export const createEvolu =
       },
 
       deleteDatabase: () => {
-        assertNotDisposed(moved);
+        assertNotDisposed(disposables);
         todo();
       },
 
       deleteOwner: (owner) => {
-        assertNotDisposed(moved);
+        assertNotDisposed(disposables);
         void owner;
         todo();
       },
@@ -1068,8 +1074,8 @@ export const createEvolu =
       useOwner,
 
       [Symbol.asyncDispose]: () => {
-        console.info("dispose");
-        return moved.disposeAsync();
+        if (!disposables.disposed) console.info("disposeEvolu");
+        return disposables.disposeAsync();
       },
     } as Evolu<S>);
   };

package/src/local-first/Owner.ts

@@ -100,7 +100,7 @@ export const ownerIdToOwnerIdBytes = (ownerId: OwnerId): OwnerIdBytes =>
 
 /** Converts {@link OwnerIdBytes} to {@link OwnerId}. */
 export const ownerIdBytesToOwnerId = (ownerIdBytes: OwnerIdBytes): OwnerId =>
-  idBytesToId(ownerIdBytes as IdBytes) as OwnerId;
+  idBytesToId(ownerIdBytes) as OwnerId;
 
 export const ownerWriteKeyLength = /*#__PURE__*/ NonNegativeInt.orThrow(16);
 

package/src/local-first/Query.ts

@@ -400,7 +400,7 @@ const parseObject = (
   for (const key in obj) {
     result[key] = parse(obj[key]);
   }
-  return result as ReadonlyRecord<string, unknown>;
+  return result;
 };
 
 const colName = (col: string): Expression<unknown> =>