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

package/src/Test.ts

@@ -17,7 +17,7 @@ import {
   type Random,
   type RandomLibDep,
 } from "./Random.js";
-import { createRun, type Run, type RunDeps } from "./Task.js";
+import { createRun, type Run, type RunDefaultDeps } from "./Task.js";
 import {
   minMillis,
   setTimeout,
@@ -35,14 +35,14 @@ export type TestCreateId = <B extends string = never>() => [B] extends [never]
 /**
  * Cheap deterministic baseline deps for tests.
  *
- * `TestDeps` includes test-friendly replacements for {@link RunDeps}, such as
- * {@link TestConsole} and {@link TestTime}, plus extra helpers commonly useful in
- * tests and fixtures, such as `randomLib` (only that for now).
+ * `TestDeps` includes test-friendly replacements for {@link RunDefaultDeps},
+ * such as {@link TestConsole} and {@link TestTime}, plus extra helpers commonly
+ * useful in tests and fixtures, such as `randomLib` (only that for now).
  *
  * Use it directly for synchronous test setup, fixtures, and helpers. It is also
  * intentionally the base deps used by {@link testCreateRun}.
  */
-export type TestDeps = Omit<RunDeps, "console" | "time"> &
+export type TestDeps = Omit<RunDefaultDeps, "console" | "time"> &
   TestConsoleDep &
   TestTimeDep &
   RandomLibDep;
@@ -103,7 +103,7 @@ export const testCreateDeps = (options?: {
  * ### Example
  *
  * ```ts
- * // Built-in TestTime
+ * // Default TestTime
  * await using run = testCreateRun();
  * const fiber = run(sleep("1s"));
  * run.deps.time.advance("1s");
@@ -112,9 +112,7 @@ export const testCreateDeps = (options?: {
  * // For a single test, create the dependency using the Run.
  * await using run = testCreateRun();
  * await using foo = await run.orThrow(createFoo());
- * const runWithFoo = run.addDeps({ foo });
- *
- * expect(runWithFoo.deps.foo).toBe(foo);
+ * await run.orThrow(taskThatNeedsFoo, { foo });
  *
  * // If multiple tests need the same setup, create a disposable helper.
  * // Then `await using setup` disposes everything the helper owns.
@@ -122,14 +120,15 @@ export const testCreateDeps = (options?: {
  *   await using disposer = new AsyncDisposableStack();
  *   const run = disposer.use(testCreateRun());
  *   const foo = disposer.use(await run.orThrow(createFoo()));
+ *   const runWithFoo = disposer.use(run.create({ ...run.deps, foo }));
  *   const disposables = disposer.move();
  *
  *   // Return whatever the tests need: a Run with the dependency,
  *   // the dependency itself, or both.
  *   return {
- *     run: run.addDeps({ foo }),
+ *     run: runWithFoo,
  *     foo,
- *     [Symbol.asyncDispose]: () => moved.disposeAsync(),
+ *     [Symbol.asyncDispose]: () => disposables.disposeAsync(),
  *   };
  * };
  *

package/src/Types.ts

@@ -359,12 +359,3 @@ export type ExtractType<
   TUnion extends { readonly type: TypeName },
   TType extends TUnion["type"],
 > = Extract<TUnion, { readonly type: TType }>;
-
-/**
- * Constrains `T` to only contain keys not present in `Existing`.
- *
- * Use as a generic constraint to prevent overriding existing properties.
- */
-export type NewKeys<T, Existing> = {
-  [K in keyof T]: K extends keyof Existing ? never : T[K];
-};

package/src/local-first/Db.ts

@@ -140,12 +140,11 @@ export const startDbWorker =
   async (run) => {
     await using disposer = new AsyncDisposableStack();
     disposer.use(self);
-    const dbWorkerRun = disposer.use(run.create());
-    const { deps } = dbWorkerRun;
+    const { deps } = run;
 
     let initialized = false;
 
-    const initMessage = await dbWorkerRun.orThrow(
+    const initMessage = await run.orThrow(
       callback<DbWorkerInit>(({ ok }) => {
         self.onMessage = (message) => {
           assert(!initialized, "DbWorker must be initialized only once");
@@ -179,14 +178,12 @@ export const startDbWorker =
     );
     console.debug("createDbWorker");
 
-    disposer.use(
-      await dbWorkerRun.orThrow(acquireLeaderLock(initMessage.name)),
-    );
+    disposer.use(await run.orThrow(acquireLeaderLock(initMessage.name)));
 
     port.postMessage({ type: "LeaderAcquired", name: initMessage.name });
 
     const sqlite = disposer.use(
-      await dbWorkerRun.orThrow(
+      await run.orThrow(
         createSqlite(
           initMessage.name,
           initMessage.memoryOnly
@@ -199,16 +196,17 @@ export const startDbWorker =
 
     const baseSqliteStorage = createBaseSqliteStorage({
       sqlite,
-      ...dbWorkerRun.deps,
+      ...deps,
     });
 
     const dbDeps = {
-      ...dbWorkerRun.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;
@@ -230,7 +228,6 @@ export const startDbWorker =
     });
 
     const disposables = disposer.move();
-    const dbWorkerRunWithStorage = dbWorkerRun.addDeps({ storage });
 
     port.onMessage = (input) => {
       if (input.type === "Dispose") {
@@ -330,29 +327,34 @@ export const startDbWorker =
             case "ApplySyncMessage": {
               const { owner, inputMessage } = request.message;
 
-              dbWorkerRunWithStorage<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;
             }
 

package/src/local-first/Shared.ts

@@ -11,12 +11,11 @@ import {
   shiftFromArray,
   type NonEmptyReadonlyArray,
 } from "../Array.js";
-import { assert, assertNotDisposed } from "../Assert.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 { exhaustiveCheck } from "../Function.js";
 import { acquireLeaderLock, type LockManagerDep } from "../LockManager.js";
 import { structuralLookup, type StructuralLookupKey } from "../Lookup.js";
 import { createRefCountByKey, type RefCountByKey } from "../RefCount.js";
@@ -30,7 +29,13 @@ 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";
-import { AbortError, createMutex, type Mutex, type Task } from "../Task.js";
+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";
@@ -308,10 +313,12 @@ export const initSharedWorker =
 
             case "CreateEvolu": {
               void sharedWorkerRun(async (run) => {
-                const tenant = await run.orThrow(
-                  tenantsByName.acquire(message),
+                const tenant = await run(
+                  unabortable(tenantsByName.acquire(message)),
                 );
-                tenant.addInstance(
+                if (!tenant.ok) return tenant;
+
+                tenant.value.addInstance(
                   message,
                   () => void sharedWorkerRun(tenantsByName.release(message)),
                 );
@@ -405,7 +412,8 @@ export const initSharedWorker =
       ),
     );
 
-    const sharedWorkerRun = run.create().addDeps({
+    const sharedWorkerRun = run.create({
+      ...deps,
       postConsoleEntryOrError,
       tabLeaderPortStore,
       transports,
@@ -414,6 +422,7 @@ export const initSharedWorker =
     const tenantsByName = disposer.use(
       await sharedWorkerRun.orThrow(
         createSharedResourceByKey(createEvoluTenant, {
+          idleDisposeAfter: "3s",
           lookup: (message) => message.name,
         }),
       ),
@@ -505,8 +514,6 @@ const createEvoluTenant =
             callbacks.execute(message.callbackId, message);
             break;
           }
-          default:
-            exhaustiveCheck(message);
         }
       };
 
@@ -549,9 +556,6 @@ const createEvoluTenant =
           case "ForSharedWorker":
             handleResponseForSharedWorker(response);
             break;
-
-          default:
-            exhaustiveCheck(response);
         }
 
         // Complete the current queue item and continue with the next one.
@@ -569,7 +573,16 @@ const createEvoluTenant =
       dbWorkerPort = null;
       queueRequestInFlight = false;
 
-      await using _ = await tenantRun.orThrow(acquireLeaderLock(name));
+      // The DbWorker holds this tenant leader lock while it is alive. Tenant
+      // disposal sends Dispose, then acquires the same lock to wait until the
+      // 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;
     });
 
     disposer.defer(deps.tabLeaderPortStore.subscribe(initDbWorker));
@@ -652,9 +665,6 @@ const createEvoluTenant =
             [response.message.file.buffer],
           );
           break;
-
-        default:
-          exhaustiveCheck(response.message);
       }
     };
 
@@ -698,15 +708,9 @@ const createEvoluTenant =
               case "Broadcast":
               case "NoResponse":
                 break;
-
-              default:
-                exhaustiveCheck(response.message.result.value);
             }
           }
           break;
-
-        default:
-          exhaustiveCheck(response.message);
       }
     };
 
@@ -812,15 +816,14 @@ const createEvoluTenant =
         });
         disposer.use(instance.port);
 
-        void tenantRun(acquireLeaderLock(message.id)).then((result) => {
-          if (!result.ok) return;
-          const lock = result.value;
-
-          if (disposer.disposed) {
-            return lock[Symbol.asyncDispose]();
-          }
+        // 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);
+          disposer.use(lock.value);
           return disposer.disposeAsync();
         });
 
@@ -857,8 +860,6 @@ const createEvoluTenant =
               );
               break;
             }
-            default:
-              exhaustiveCheck(message);
           }
         };
       },