@evolu/common 8.0.0-next.2 → 8.0.0-next.4

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> =>