@evolu/common 8.0.0-next.5 → 8.0.0

package/src/local-first/Shared.ts

@@ -8,37 +8,43 @@ import {
   emptyArray,
   firstInArray,
   isNonEmptyArray,
-  shiftFromArray,
   type NonEmptyReadonlyArray,
-} from "../Array.js";
-import { assert, assertNotAborted, assertNotDisposed } from "../Assert.js";
-import type { Brand } from "../Brand.js";
-import { createCallbacks } from "../Callbacks.js";
-import type { ConsoleEntry, ConsoleLevel } from "../Console.js";
-import type { EncryptionKey } from "../Crypto.js";
-import { acquireLeaderLock, type LockManagerDep } from "../LockManager.js";
-import { structuralLookup, type StructuralLookupKey } from "../Lookup.js";
-import { createRefCountByKey, type RefCountByKey } from "../RefCount.js";
+} from "../Array.ts";
+import { assert } from "../Assert.ts";
+import type { Brand } from "../Brand.ts";
+import { createCallbacks } from "../Callbacks.ts";
+import type { ConsoleEntry, ConsoleLevel } from "../Console.ts";
+import type { EncryptionKey } from "../Crypto.ts";
+import { disposable } from "../Function.ts";
+import { acquireLeaderLock, type LockManagerDep } from "../LockManager.ts";
+import {
+  createLookupMap,
+  structuralLookup,
+  type LookupMap,
+  type StructuralLookupKey,
+} from "../Lookup.ts";
+import { createRefCountByKey, type RefCountByKey } from "../RefCount.ts";
 import {
   createSharedResourceByKey,
   createSharedResourceByKeyWithClaims,
   type BorrowedResource,
+  type ClaimLease,
   type SharedResourceByKeyWithClaims,
-} from "../Resource.js";
-import { ok, type Result } from "../Result.js";
-import type { NonEmptyReadonlySet } from "../Set.js";
-import type { SqliteSchema } from "../Sqlite.js";
-import { createStore, type Store } from "../Store.js";
+} from "../Resource.ts";
+import { ok, type Result } from "../Result.ts";
+import type { NonEmptyReadonlySet } from "../Set.ts";
+import type { SqliteSchema } from "../Sqlite.ts";
+import { createStore, type Store } from "../Store.ts";
 import {
   AbortError,
   createMutex,
   unabortable,
   type Mutex,
   type Task,
-} from "../Task.js";
-import { type Id, type Name, type Typed } from "../Type.js";
-import type { Callback, ExtractType } from "../Types.js";
-import type { CreateWebSocketDep, WebSocket } from "../WebSocket.js";
+} from "../Task.ts";
+import type { ExtractTyped, Id, Name, Typed } from "../Type.ts";
+import type { Callback } from "../Types.ts";
+import type { CreateWebSocketDep, WebSocket } from "../WebSocket.ts";
 import type {
   SharedWorker as CommonSharedWorker,
   CreateBroadcastChannelDep,
@@ -47,10 +53,10 @@ import type {
   NativeMessagePort,
   SharedWorkerSelf,
   WorkerDeps,
-} from "../Worker.js";
-import type { DbWorkerInit } from "./Db.js";
-import type { EvoluError } from "./Error.js";
-import type { Owner, OwnerId, OwnerTransport, SyncOwner } from "./Owner.js";
+} from "../Worker.ts";
+import type { DbWorkerInit } from "./Db.ts";
+import type { EvoluError } from "./Error.ts";
+import type { Owner, OwnerId, OwnerTransport, SyncOwner } from "./Owner.ts";
 import {
   createProtocolMessageForUnsubscribe,
   createProtocolMessageFromCrdtMessages,
@@ -58,16 +64,16 @@ import {
   type ApplyProtocolMessageAsClientResult,
   type ProtocolError,
   type ProtocolMessage,
-} from "./Protocol.js";
+} from "./Protocol.ts";
 import {
   makePatches,
   type Patch,
   type Query,
   type Row,
   type RowsByQueryMap,
-} from "./Query.js";
-import type { MutationChange } from "./Schema.js";
-import type { CrdtMessage } from "./Storage.js";
+} from "./Query.ts";
+import type { MutationChange } from "./Schema.ts";
+import type { CrdtMessage } from "./Storage.ts";
 
 export type SharedWorker = CommonSharedWorker<
   SharedWorkerInput,
@@ -156,7 +162,9 @@ export type DbWorkerRequest =
   | {
       readonly type: "ForEvolu";
       readonly id: EvoluInstanceId;
-      readonly message: ExtractType<EvoluInput, "Mutate" | "Query" | "Export">;
+      readonly message: {
+        readonly [Message in EvoluInput as Message["type"]]: Message;
+      }["Mutate" | "Query" | "Export"];
     }
   | {
       readonly type: "ForSharedWorker";
@@ -234,7 +242,7 @@ export type SharedWorkerDeps = WorkerDeps &
 
 interface EvoluTenant extends AsyncDisposable {
   readonly addInstance: (
-    message: ExtractType<SharedWorkerInput, "CreateEvolu">,
+    message: ExtractTyped<SharedWorkerInput, "CreateEvolu">,
     onDisposed: () => void,
   ) => void;
 
@@ -265,8 +273,7 @@ interface TransportsDep {
   readonly transports: SharedResourceByKeyWithClaims<
     OwnerTransport,
     OwnerId,
-    WebSocket,
-    SharedWorkerDeps
+    WebSocket
   >;
 }
 
@@ -274,6 +281,7 @@ export type EvoluInstanceId = Id & Brand<"EvoluInstance">;
 
 export type SyncState = 123;
 
+/** Initializes the platform-agnostic Evolu SharedWorker. */
 export const initSharedWorker =
   (
     self: SharedWorkerSelf<SharedWorkerInput, SharedWorkerOutput>,
@@ -313,15 +321,10 @@ export const initSharedWorker =
 
             case "CreateEvolu": {
               void sharedWorkerRun(async (run) => {
-                const tenant = await run(
+                const tenantLease = await run.ok(
                   unabortable(tenantsByName.acquire(message)),
                 );
-                if (!tenant.ok) return tenant;
-
-                tenant.value.addInstance(
-                  message,
-                  () => void sharedWorkerRun(tenantsByName.release(message)),
-                );
+                tenantLease.resource.addInstance(message, tenantLease.release);
                 return ok();
               });
               break;
@@ -340,12 +343,13 @@ export const initSharedWorker =
       }),
     );
 
+    const currentTenantsByName = new Map<Name, BorrowedResource<EvoluTenant>>();
     const transports = disposer.use(
-      await run.orThrow(
+      await run.ok(
         createSharedResourceByKeyWithClaims<
-          WebSocket,
           OwnerTransport,
           OwnerId,
+          WebSocket,
           SharedWorkerDeps,
           StructuralLookupKey
         >(
@@ -420,11 +424,15 @@ export const initSharedWorker =
     });
 
     const tenantsByName = disposer.use(
-      await sharedWorkerRun.orThrow(
-        createSharedResourceByKey(createEvoluTenant, {
-          idleDisposeAfter: "3s",
-          lookup: (message) => message.name,
-        }),
+      await sharedWorkerRun.ok(
+        createSharedResourceByKey(
+          (message: ExtractTyped<SharedWorkerInput, "CreateEvolu">) =>
+            createEvoluTenant(message, currentTenantsByName),
+          {
+            idleDisposeAfter: "3s",
+            lookup: (message) => message.name,
+          },
+        ),
       ),
     );
 
@@ -433,26 +441,23 @@ export const initSharedWorker =
     const forEachTenant = (
       callback: Callback<BorrowedResource<EvoluTenant>>,
     ): void => {
-      for (const tenant of tenantsByName.snapshot().resourcesByKey.values()) {
-        callback(tenant);
-      }
+      for (const tenant of currentTenantsByName.values()) callback(tenant);
     };
 
     return ok(disposer.move());
   };
 
 const createEvoluTenant =
-  ({
-    name,
-    consoleLevel,
-    sqliteSchema,
-    encryptionKey,
-    memoryOnly,
-  }: ExtractType<SharedWorkerInput, "CreateEvolu">): Task<
-    EvoluTenant,
-    never,
-    EvoluTenantDeps
-  > =>
+  (
+    {
+      name,
+      consoleLevel,
+      sqliteSchema,
+      encryptionKey,
+      memoryOnly,
+    }: ExtractTyped<SharedWorkerInput, "CreateEvolu">,
+    currentTenantsByName: Map<Name, BorrowedResource<EvoluTenant>>,
+  ): Task<EvoluTenant, never, EvoluTenantDeps> =>
   async (run) => {
     await using disposer = new AsyncDisposableStack();
     const tenantRun = disposer.use(run.create());
@@ -462,6 +467,7 @@ const createEvoluTenant =
 
     interface EvoluInstance extends AsyncDisposable {
       readonly id: EvoluInstanceId;
+      readonly claimLeasesBySyncOwner: LookupMap<SyncOwner, Array<ClaimLease>>;
       readonly onDisposed: () => void;
       readonly port: MessagePort<EvoluOutput, EvoluInput>;
       readonly useOwnerMutex: Mutex;
@@ -533,7 +539,7 @@ const createEvoluTenant =
 
     const queue: Array<DbWorkerRequest> = [];
     const callbacks = disposer.use(
-      createCallbacks<ExtractType<DbWorkerOutput, "OnQueuedResponse">>(
+      createCallbacks<ExtractTyped<DbWorkerOutput, "OnQueuedResponse">>(
         run.deps,
       ),
     );
@@ -559,7 +565,7 @@ const createEvoluTenant =
         }
 
         // Complete the current queue item and continue with the next one.
-        shiftFromArray(queue);
+        queue.shift();
         queueRequestInFlight = false;
         runQueue();
       });
@@ -578,21 +584,16 @@ const createEvoluTenant =
       // DbWorker releases it: either because Dispose was delivered or because
       // the hosting tab closed. The wait is unabortable because tenant disposal
       // must finish even after tenantRun receives an abort request.
-      const lock = await tenantRun(acquireLeaderLock(name));
-      // AbortError here means tenantRun was already disposed before this
-      // cleanup could start, violating the disposal ordering above.
-      assertNotAborted(lock);
-      await using _ = lock.value;
+      await using _ = await tenantRun.ok(acquireLeaderLock(name));
     });
 
     disposer.defer(deps.tabLeaderPortStore.subscribe(initDbWorker));
 
     initDbWorker();
     await dbWorkerInited.promise;
-    const disposables = disposer.move();
 
     const handleResponseForEvolu = (
-      response: ExtractType<DbWorkerQueuedResponse, "ForEvolu">,
+      response: ExtractTyped<DbWorkerQueuedResponse, "ForEvolu">,
       first: DbWorkerRequest,
     ): void => {
       const instance = instancesById.get(response.id);
@@ -669,7 +670,7 @@ const createEvoluTenant =
     };
 
     const handleResponseForSharedWorker = (
-      response: ExtractType<DbWorkerQueuedResponse, "ForSharedWorker">,
+      response: ExtractTyped<DbWorkerQueuedResponse, "ForSharedWorker">,
     ): void => {
       switch (response.message.type) {
         case "CreateSyncMessages":
@@ -718,20 +719,20 @@ const createEvoluTenant =
       protocolMessagesByOwnerId: ReadonlyMap<OwnerId, ProtocolMessage>,
     ): void => {
       for (const [ownerId, protocolMessage] of protocolMessagesByOwnerId) {
-        for (const transport of deps.transports.getResourceKeysForClaim(
+        deps.transports.forEachResourceForClaim(
           ownerId,
-        )) {
-          const webSocket = deps.transports.getResource(transport);
-          if (!webSocket?.isOpen()) continue;
+          (webSocket, transport) => {
+            if (!webSocket.isOpen()) return;
 
-          console.debug("sendProtocolMessage", {
-            ownerId,
-            url: transport.url,
-            byteLength: protocolMessage.byteLength,
-          });
+            console.debug("sendProtocolMessage", {
+              ownerId,
+              url: transport.url,
+              byteLength: protocolMessage.byteLength,
+            });
 
-          webSocket.send(protocolMessage);
-        }
+            webSocket.send(protocolMessage);
+          },
+        );
       }
     };
 
@@ -757,156 +758,187 @@ const createEvoluTenant =
       async (run) => {
         if (action === "add") {
           instance.usedSyncOwners.increment(syncOwner);
-          return await run(
-            deps.transports.addClaim(syncOwner.owner.id, syncOwner.transports),
+          let succeeded = false;
+          using compensation = new DisposableStack();
+          compensation.defer(() => {
+            if (!succeeded) instance.usedSyncOwners.decrement(syncOwner);
+          });
+          const claimLease = await run.ok(
+            deps.transports.claim(syncOwner.owner.id, syncOwner.transports),
           );
+          instance.claimLeasesBySyncOwner
+            .getOrInsertComputed(syncOwner, () => [])
+            .push(claimLease);
+          succeeded = true;
         } else {
           instance.usedSyncOwners.decrement(syncOwner);
-          return await run(
-            deps.transports.removeClaim(
-              syncOwner.owner.id,
-              syncOwner.transports,
-            ),
-          );
+          const claimLeases = instance.claimLeasesBySyncOwner.get(syncOwner);
+          assert(claimLeases, "Expected a ClaimLease for the used owner.");
+          const claimLease = claimLeases.pop();
+          assert(claimLease, "Expected a ClaimLease for the used owner.");
+          claimLease.release();
+          if (claimLeases.length === 0) {
+            instance.claimLeasesBySyncOwner.delete(syncOwner);
+          }
         }
+        return ok();
       };
 
-    return ok({
-      addInstance: (message, onDisposed) => {
-        assertNotDisposed(disposables);
-
-        const instance: EvoluInstance = {
-          id: message.id,
-          port: deps.createMessagePort<EvoluOutput, EvoluInput>(
-            message.evoluPort,
-          ),
-          onDisposed,
-          rowsByQuery: new Map<Query, ReadonlyArray<Row>>(),
-          useOwnerMutex: createMutex(),
-          usedSyncOwners: createRefCountByKey<SyncOwner, OwnerId>({
-            lookup: (syncOwner) => syncOwner.owner.id,
-          }),
-          [Symbol.asyncDispose]: () => disposer.disposeAsync(),
-        };
-
-        instancesById.set(instance.id, instance);
+    disposer.defer(() => {
+      currentTenantsByName.delete(name);
+    });
+    const tenant = disposable<EvoluTenant>(
+      {
+        addInstance: (message, onDisposed) => {
+          const disposer = new AsyncDisposableStack();
+          const instance: EvoluInstance = {
+            id: message.id,
+            claimLeasesBySyncOwner: createLookupMap({
+              lookup: (syncOwner: SyncOwner) =>
+                structuralLookup<{
+                  readonly ownerId: OwnerId;
+                  readonly transports: ReadonlyArray<StructuralLookupKey>;
+                }>({
+                  ownerId: syncOwner.owner.id,
+                  transports: syncOwner.transports
+                    .map(structuralLookup)
+                    .toSorted(),
+                }),
+            }),
+            port: deps.createMessagePort<EvoluOutput, EvoluInput>(
+              message.evoluPort,
+            ),
+            onDisposed,
+            rowsByQuery: new Map<Query, ReadonlyArray<Row>>(),
+            useOwnerMutex: createMutex(),
+            usedSyncOwners: createRefCountByKey<SyncOwner, OwnerId>({
+              lookup: (syncOwner) => syncOwner.owner.id,
+            }),
+            [Symbol.asyncDispose]: () => disposer.disposeAsync(),
+          };
 
-        const disposer = new AsyncDisposableStack();
+          instancesById.set(instance.id, instance);
 
-        disposer.defer(instance.onDisposed);
-        disposer.use(instance.usedSyncOwners);
-        disposer.use(instance.useOwnerMutex);
+          disposer.defer(instance.onDisposed);
+          disposer.use(instance.usedSyncOwners);
 
-        disposer.defer(async () => {
-          await tenantRun(
-            instance.useOwnerMutex.withLock(async (run) => {
-              for (const syncOwner of instance.usedSyncOwners.keys()) {
-                while (instance.usedSyncOwners.has(syncOwner)) {
-                  await run(toggleSyncOwner(instance, syncOwner, "remove"));
+          disposer.defer(async () => {
+            await tenantRun(
+              instance.useOwnerMutex.withLock(async (run) => {
+                for (const syncOwner of instance.usedSyncOwners.keys()) {
+                  while (instance.usedSyncOwners.has(syncOwner)) {
+                    await run(toggleSyncOwner(instance, syncOwner, "remove"));
+                  }
                 }
+                return ok();
+              }),
+            );
+          });
+
+          disposer.defer(() => {
+            instancesById.delete(instance.id);
+            console.info("evoluDispose", { name, id: instance.id });
+          });
+          disposer.use(instance.port);
+          disposer.defer(() => {
+            instance.port.onMessage = null;
+          });
+
+          // The main-thread Evolu instance holds this per-instance leader lock
+          // while it is alive. Acquiring the same lock here means the main
+          // thread instance was disposed or its tab closed, so the tenant-side
+          // instance must dispose itself.
+          void tenantRun
+            .abortable(acquireLeaderLock(message.id))
+            .then((lock) => {
+              if (!lock.ok) return;
+
+              disposer.use(lock.value);
+              return instance[Symbol.asyncDispose]();
+            });
+
+          instance.port.onMessage = (message) => {
+            switch (message.type) {
+              case "Query":
+              case "Export": {
+                queue.push({ type: "ForEvolu", id: instance.id, message });
+                runQueue();
+                break;
+              }
+              case "Mutate": {
+                // TODO: Delegate do vsech evolu instances, co to pouzivaji
+                queue.push({ type: "ForEvolu", id: instance.id, message });
+                runQueue();
+                break;
+              }
+              case "UseOwner": {
+                void tenantRun(
+                  instance.useOwnerMutex.withLock(async (run) => {
+                    for (const { owner, action } of message.actions) {
+                      console.debug("useOwner", {
+                        id: instance.id,
+                        action,
+                        ownerId: owner.owner.id,
+                        transportUrls: owner.transports.map(({ url }) => url),
+                      });
+
+                      await run(toggleSyncOwner(instance, owner, action));
+                    }
+
+                    return ok();
+                  }),
+                );
+                break;
               }
-              return ok();
-            }),
-          );
-        });
-
-        disposer.defer(() => {
-          instancesById.delete(instance.id);
-          console.info("evoluDispose", { name, id: instance.id });
-        });
-        disposer.use(instance.port);
-
-        // The main-thread Evolu instance holds this per-instance leader lock
-        // while it is alive. Acquiring the same lock here means the main
-        // thread instance was disposed or its tab closed, so the tenant-side
-        // instance must dispose itself.
-        void tenantRun(acquireLeaderLock(message.id)).then((lock) => {
-          if (!lock.ok) return;
-
-          disposer.use(lock.value);
-          return disposer.disposeAsync();
-        });
-
-        instance.port.onMessage = (message) => {
-          switch (message.type) {
-            case "Query":
-            case "Export": {
-              queue.push({ type: "ForEvolu", id: instance.id, message });
-              runQueue();
-              break;
-            }
-            case "Mutate": {
-              // TODO: Delegate do vsech evolu instances, co to pouzivaji
-              queue.push({ type: "ForEvolu", id: instance.id, message });
-              runQueue();
-              break;
             }
-            case "UseOwner": {
-              void tenantRun(
-                instance.useOwnerMutex.withLock(async (run) => {
-                  for (const { owner, action } of message.actions) {
-                    console.debug("useOwner", {
-                      id: instance.id,
-                      action,
-                      ownerId: owner.owner.id,
-                      transportUrls: owner.transports.map(({ url }) => url),
-                    });
-
-                    await run(toggleSyncOwner(instance, owner, action));
-                  }
+          };
+        },
 
-                  return ok();
-                }),
-              );
-              break;
-            }
-          }
-        };
-      },
+        requestCreateSyncMessages: (ownerIds): void => {
+          const ownersToSync = [...getUsedOwnersById(ownerIds).values()];
 
-      requestCreateSyncMessages: (ownerIds): void => {
-        const ownersToSync = [...getUsedOwnersById(ownerIds).values()];
+          if (!isNonEmptyArray(ownersToSync)) return;
 
-        if (!isNonEmptyArray(ownersToSync)) return;
+          console.debug("requestCreateSyncMessages", {
+            ownerIds: ownersToSync.map(({ id }) => id),
+          });
 
-        console.debug("requestCreateSyncMessages", {
-          ownerIds: ownersToSync.map(({ id }) => id),
-        });
+          queue.push({
+            type: "ForSharedWorker",
+            message: {
+              type: "CreateSyncMessages",
+              owners: ownersToSync,
+            },
+          });
 
-        queue.push({
-          type: "ForSharedWorker",
-          message: {
-            type: "CreateSyncMessages",
-            owners: ownersToSync,
-          },
-        });
+          runQueue();
+        },
 
-        runQueue();
-      },
+        requestApplySyncMessage: (ownerId, inputMessage): void => {
+          const owner = getUsedOwnersById(new Set([ownerId])).get(ownerId);
+          if (!owner) return;
 
-      requestApplySyncMessage: (ownerId, inputMessage): void => {
-        const owner = getUsedOwnersById(new Set([ownerId])).get(ownerId);
-        if (!owner) return;
+          console.debug("requestApplySyncMessage", {
+            ownerId,
+            byteLength: inputMessage.byteLength,
+          });
 
-        console.debug("requestApplySyncMessage", {
-          ownerId,
-          byteLength: inputMessage.byteLength,
-        });
-
-        queue.push({
-          type: "ForSharedWorker",
-          message: {
-            type: "ApplySyncMessage",
-            owner,
-            inputMessage,
-          },
-        });
+          queue.push({
+            type: "ForSharedWorker",
+            message: {
+              type: "ApplySyncMessage",
+              owner,
+              inputMessage,
+            },
+          });
 
-        runQueue();
+          runQueue();
+        },
       },
-
-      [Symbol.asyncDispose]: () => disposables.disposeAsync(),
-    });
+      disposer,
+    );
+    currentTenantsByName.set(name, tenant);
+    return ok(tenant);
   };
 
 //   | (Typed<"reset"> & {
@@ -932,10 +964,17 @@ const createEvoluTenant =
 //       readonly reload: boolean;
 //     })
 
-// TODO: Remaining SharedWorker lifetime issues.
-// - Investigate heartbeat for ports and where liveness tracking is needed.
-// - Sync state for monitoring.
+// TODO: SharedWorker follow-ups.
+// - Complete the queue head when a DbWorker mutation returns an error.
+// - Make retried DbWorker requests deterministic by materializing clocks and
+//   timestamps in the SharedWorker before enqueueing them.
+// - Replace the callback registry and queueRequestInFlight flag with one
+//   explicit in-flight request state.
+// - Detect DbWorker and port liveness so a worker-only crash resumes the queue.
+// - Consolidate usedSyncOwners and claimLeasesBySyncOwner into one owner-use
+//   state abstraction without changing repeated-use semantics.
+// - Split worker protocol types and the EvoluTenant implementation into focused
+//   modules.
+// - Remove the obsolete commented protocol block above.
+// - Replace the SyncState placeholder with actual sync monitoring state.
 // - Propagate invalid protocol messages to sync state.
-// - Make DbWorker logically stateless by making all requests idempotent.
-// - Investigate WebKit bug 301520 relevance to DbWorker disposal. (again)
-//   https://bugs.webkit.org/show_bug.cgi?id=301520