@evolu/common 8.0.0-next.4 → 8.0.0

package/src/local-first/Db.ts

@@ -9,25 +9,29 @@ import {
   firstInArray,
   type NonEmptyArray,
   type NonEmptyReadonlyArray,
-} from "../Array.js";
-import { assert, assertNonEmptyReadonlyArray, assertType } from "../Assert.js";
-import type { ConsoleLevel } from "../Console.js";
+} from "../Array.ts";
+import {
+  assert,
+  assertNonEmptyReadonlyArray,
+  assertNonNullable,
+} from "../Assert.ts";
+import type { ConsoleLevel } from "../Console.ts";
 import {
   EncryptionKey,
   type DecryptWithXChaCha20Poly1305Error,
   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";
+} from "../Crypto.ts";
+import { constFalse, constVoid } from "../Function.ts";
+import type { LockManagerDep } from "../LockManager.ts";
+import { acquireLeaderLock } from "../LockManager.ts";
+import { createMutableRecord, getOwnProp, objectToEntries } from "../Object.ts";
+import { ok, type Result } from "../Result.ts";
 import type {
   CreateSqliteDriverDep,
   SqliteDep,
   SqliteRow,
   SqliteSchema,
-} from "../Sqlite.js";
+} from "../Sqlite.ts";
 import {
   booleanToSqliteBoolean,
   createSqlite,
@@ -36,27 +40,28 @@ import {
   sqliteBooleanToBoolean,
   sqliteQueryStringToSqliteQuery,
   SqliteValue,
-} from "../Sqlite.js";
-import { callback, type Task } from "../Task.js";
-import { Millis, millisToDateIso, type TimeDep } from "../Time.js";
-import type { Name } from "../Type.js";
+} from "../Sqlite.ts";
+import { callback, type Run, type Task } from "../Task.ts";
+import { Millis, millisToDateIso, type TimeDep } from "../Time.ts";
 import {
+  assertType,
+  type ExtractTyped,
   Id,
   IdBytes,
   idBytesToId,
   idToIdBytes,
+  type Name,
   onePositiveInt,
-} from "../Type.js";
-import type { ExtractType } from "../Types.js";
+} from "../Type.ts";
 import type {
   CreateBroadcastChannelDep,
   NativeMessagePort,
   Worker,
   WorkerDeps,
   WorkerSelf,
-} from "../Worker.js";
-import type { OwnerId, OwnerIdBytes } from "./Owner.js";
-import { ownerIdBytesToOwnerId, ownerIdToOwnerIdBytes } from "./Owner.js";
+} from "../Worker.ts";
+import type { OwnerId, OwnerIdBytes } from "./Owner.ts";
+import { ownerIdBytesToOwnerId, ownerIdToOwnerIdBytes } from "./Owner.ts";
 import {
   applyProtocolMessageAsClient,
   createProtocolMessageForSync,
@@ -67,22 +72,22 @@ import {
   type ProtocolInvalidDataError,
   type ProtocolMessage,
   type ProtocolTimestampMismatchError,
-} from "./Protocol.js";
-import type { Query, RowsByQueryMap } from "./Query.js";
-import type { MutationChange, SqliteSchemaDep } from "./Schema.js";
+} from "./Protocol.ts";
+import type { Query, RowsByQueryMap } from "./Query.ts";
+import type { MutationChange, SqliteSchemaDep } from "./Schema.ts";
 import {
   ensureSqliteSchema,
   getEvoluSqliteSchema,
   systemColumns,
-} from "./Schema.js";
+} from "./Schema.ts";
 import type {
   ConsoleEntryOrError,
   DbWorkerInput,
   DbWorkerOutput,
   DbWorkerQueuedResponse,
   DbWorkerRequest,
-} from "./Shared.js";
-import { consoleEntryOrErrorBroadcastChannelName } from "./Shared.js";
+} from "./Shared.ts";
+import { consoleEntryOrErrorBroadcastChannelName } from "./Shared.ts";
 import {
   createBaseSqliteStorage,
   createBaseSqliteStorageTables,
@@ -94,13 +99,13 @@ import {
   type BaseSqliteStorageDep,
   type CrdtMessage,
   type Storage,
-} from "./Storage.js";
+} from "./Storage.ts";
 import type {
   Timestamp,
   TimestampCounterOverflowError,
   TimestampDriftError,
   TimestampTimeOutOfRangeError,
-} from "./Timestamp.js";
+} from "./Timestamp.ts";
 import {
   createInitialTimestamp,
   defaultTimestampMaxDrift,
@@ -110,7 +115,7 @@ import {
   timestampBytesToTimestamp,
   timestampToTimestampBytes,
   type TimestampConfigDep,
-} from "./Timestamp.js";
+} from "./Timestamp.ts";
 
 export type DbWorker = Worker<DbWorkerInit>;
 
@@ -135,29 +140,23 @@ export type DbWorkerDeps = WorkerDeps &
   LockManagerDep &
   CreateSqliteDriverDep;
 
+/**
+ * Starts the platform-agnostic Evolu DbWorker and owns its resources until the
+ * worker receives a dispose message or its {@link Run} is aborted.
+ */
 export const startDbWorker =
   (self: WorkerSelf<DbWorkerInit>): Task<void, never, DbWorkerDeps> =>
   async (run) => {
     await using disposer = new AsyncDisposableStack();
     disposer.use(self);
-    const dbWorkerRun = disposer.use(run.create());
-    const { deps } = dbWorkerRun;
-
-    let initialized = false;
+    const { deps } = run;
 
-    const initMessage = await dbWorkerRun.orThrow(
-      callback<DbWorkerInit>(({ ok }) => {
-        self.onMessage = (message) => {
-          assert(!initialized, "DbWorker must be initialized only once");
-          initialized = true;
-          ok(message);
-        };
+    const initMessage = await run.ok(
+      callback<DbWorkerInit>(({ resolve }) => {
+        self.onMessage = (message) => resolve(ok(message));
       }),
     );
 
-    const console = deps.console.child(initMessage.name).child("DbWorker");
-    console.setLevel(initMessage.consoleLevel);
-
     const port = disposer.use(
       deps.createMessagePort<DbWorkerOutput, DbWorkerInput>(initMessage.port),
     );
@@ -177,16 +176,11 @@ export const startDbWorker =
           });
       }),
     );
-    console.debug("createDbWorker");
-
-    disposer.use(
-      await dbWorkerRun.orThrow(acquireLeaderLock(initMessage.name)),
-    );
 
-    port.postMessage({ type: "LeaderAcquired", name: initMessage.name });
+    disposer.use(await run.ok(acquireLeaderLock(initMessage.name)));
 
     const sqlite = disposer.use(
-      await dbWorkerRun.orThrow(
+      await run.ok(
         createSqlite(
           initMessage.name,
           initMessage.memoryOnly
@@ -195,21 +189,15 @@ export const startDbWorker =
         ),
       ),
     );
-    console.debug("SQLite created");
-
-    const baseSqliteStorage = createBaseSqliteStorage({
-      sqlite,
-      ...dbWorkerRun.deps,
-    });
 
+    const baseSqliteStorage = createBaseSqliteStorage({ sqlite, ...deps });
     const dbDeps = {
-      ...dbWorkerRun.deps,
+      ...deps,
       sqlite,
       sqliteSchema: initMessage.sqliteSchema,
       baseSqliteStorage,
       timestampConfig: { maxDrift: defaultTimestampMaxDrift },
     };
-
     const currentSchema = getEvoluSqliteSchema(dbDeps)();
     const dbIsInitialized = "evolu_version" in currentSchema.tables;
     const clock = createClock(dbDeps)(dbIsInitialized);
@@ -228,152 +216,135 @@ export const startDbWorker =
         });
       },
     });
+    const dbWorkerRun = disposer.use(run.create({ storage }));
 
-    const disposables = disposer.move();
-    const dbWorkerRunWithStorage = dbWorkerRun.addDeps({ storage });
-
-    port.onMessage = (input) => {
-      if (input.type === "Dispose") {
-        if (!disposables.disposed) console.debug("disposeDbWorker");
-        void disposables.disposeAsync();
-        return;
-      }
-
-      const { callbackId, request } = input;
-
-      const postQueuedResponse = (response: DbWorkerQueuedResponse): void => {
-        port.postMessage(
-          { type: "OnQueuedResponse", callbackId, response },
-          response.type === "ForEvolu" && response.message.type === "Export"
-            ? [response.message.file.buffer]
-            : undefined,
-        );
-      };
-
-      switch (request.type) {
-        case "ForEvolu": {
-          switch (request.message.type) {
-            case "Mutate": {
-              const result = handleMutation({ ...dbDeps, clock })(
-                request.message,
-              );
-              if (!result.ok) {
-                consoleEntryOrErrorBroadcastChannel.postMessage({
-                  type: "Error",
-                  error: result.error,
-                });
-              } else {
-                postQueuedResponse({
-                  type: "ForEvolu",
-                  id: request.id,
-                  message: result.value,
-                });
-              }
-              break;
-            }
-
-            case "Query":
-              postQueuedResponse({
-                type: "ForEvolu",
-                id: request.id,
-                message: {
-                  type: "Query",
-                  rowsByQuery: loadQueries(dbDeps)(request.message.queries),
-                },
-              });
-              break;
-
-            case "Export":
-              postQueuedResponse({
-                type: "ForEvolu",
-                id: request.id,
-                message: {
-                  type: "Export",
-                  file: dbDeps.sqlite.export(),
-                },
-              });
-              break;
+    port.postMessage({ type: "LeaderAcquired", name: initMessage.name });
 
-            default:
-              exhaustiveCheck(request.message);
+    await run.ok(
+      callback<void>(({ resolve }) => {
+        port.onMessage = (input) => {
+          if (input.type === "Dispose") {
+            resolve(ok());
+            return;
           }
-          break;
-        }
-
-        case "ForSharedWorker": {
-          switch (request.message.type) {
-            case "CreateSyncMessages": {
-              const protocolMessagesByOwnerId = new Map<
-                OwnerId,
-                ProtocolMessage
-              >();
-
-              for (const owner of request.message.owners) {
-                storage.setRequestContext(owner.encryptionKey);
-                const protocolMessage = createProtocolMessageForSync({
-                  storage,
-                  console,
-                })(owner.id, SubscriptionFlags.Subscribe);
-                protocolMessagesByOwnerId.set(owner.id, protocolMessage);
-              }
-
-              postQueuedResponse({
-                type: "ForSharedWorker",
-                message: {
-                  type: "CreateSyncMessages",
-                  protocolMessagesByOwnerId,
-                },
-              });
-              break;
-            }
 
-            case "ApplySyncMessage": {
+          const { callbackId, request } = input;
+          const postQueuedResponse = (
+            response: DbWorkerQueuedResponse,
+          ): void => {
+            port.postMessage(
+              {
+                type: "OnQueuedResponse",
+                callbackId,
+                response,
+              },
+              response.type === "ForEvolu" && response.message.type === "Export"
+                ? [response.message.file.buffer]
+                : undefined,
+            );
+          };
+
+          if (request.type === "ForSharedWorker") {
+            if (request.message.type === "ApplySyncMessage") {
               const { owner, inputMessage } = request.message;
 
-              dbWorkerRunWithStorage<void, never>(async (run) => {
+              void dbWorkerRun(async (run) => {
                 storage.setRequestContext(owner.encryptionKey);
 
-                const result = await run(
+                const result = await run.abortable(
                   applyProtocolMessageAsClient(inputMessage, {
                     writeKey: owner.writeKey,
                   }),
                 );
 
-                const didWriteMessages = storage.didWriteMessages();
-
                 postQueuedResponse({
                   type: "ForSharedWorker",
                   message: {
                     type: "ApplySyncMessage",
                     ownerId: owner.id,
-                    didWriteMessages,
+                    didWriteMessages: storage.didWriteMessages(),
                     result,
                   },
                 });
 
                 return ok();
               });
-              break;
+              return;
             }
 
-            default:
-              exhaustiveCheck(request.message);
+            const protocolMessagesByOwnerId = new Map<
+              OwnerId,
+              ProtocolMessage
+            >();
+
+            for (const owner of request.message.owners) {
+              storage.setRequestContext(owner.encryptionKey);
+              protocolMessagesByOwnerId.set(
+                owner.id,
+                createProtocolMessageForSync({
+                  storage,
+                  console: deps.console,
+                })(owner.id, SubscriptionFlags.Subscribe),
+              );
+            }
+
+            postQueuedResponse({
+              type: "ForSharedWorker",
+              message: {
+                type: "CreateSyncMessages",
+                protocolMessagesByOwnerId,
+              },
+            });
+            return;
           }
-          break;
-        }
 
-        default:
-          exhaustiveCheck(request);
-      }
-    };
+          if (request.message.type === "Query") {
+            postQueuedResponse({
+              type: "ForEvolu",
+              id: request.id,
+              message: {
+                type: "Query",
+                rowsByQuery: loadQueries(dbDeps)(request.message.queries),
+              },
+            });
+            return;
+          }
 
-    return ok();
+          if (request.message.type === "Export") {
+            postQueuedResponse({
+              type: "ForEvolu",
+              id: request.id,
+              message: {
+                type: "Export",
+                file: sqlite.export(),
+              },
+            });
+            return;
+          }
+
+          const result = handleMutation({ ...dbDeps, clock })(request.message);
+          if (!result.ok) {
+            consoleEntryOrErrorBroadcastChannel.postMessage({
+              type: "Error",
+              error: result.error,
+            });
+            return;
+          }
 
-    // TODO: Add parallel stale-leader detection.
-    // Heartbeat is emitted by the active DB worker and sent to
-    // SharedWorker. SharedWorker tracks last-seen heartbeat per Evolu
-    // name and if silent for 10 seconds, it waits for another DB worker
-    // to announce itself alive and then routes requests to that worker.
+          postQueuedResponse({
+            type: "ForEvolu",
+            id: request.id,
+            message: result.value,
+          });
+        };
+
+        return () => {
+          port.onMessage = null;
+        };
+      }),
+    );
+
+    return ok();
   };
 
 /**
@@ -565,7 +536,7 @@ const tryApplyQuarantinedMessages = (
 const validateColumnValue =
   (deps: SqliteSchemaDep) =>
   (table: string, column: string, _value: SqliteValue): boolean => {
-    const schemaColumns = getProperty(deps.sqliteSchema.tables, table);
+    const schemaColumns = getOwnProp(deps.sqliteSchema.tables, table);
     return (
       schemaColumns != null &&
       (systemColumnsWithoutOwnerId.has(column) || schemaColumns.has(column))
@@ -682,8 +653,8 @@ const createClientStorage =
       didWriteMessages: () => didWriteMessages,
 
       // Not implemented yet.
-      validateWriteKey: lazyFalse,
-      setWriteKey: lazyVoid,
+      validateWriteKey: constFalse,
+      setWriteKey: constVoid,
 
       writeMessages: (ownerIdBytes, encryptedMessages) => () => {
         // TODO: Add quota checking for collaborative scenarios.
@@ -751,7 +722,7 @@ const createClientStorage =
         assertNonEmptyReadonlyArray(rows, "Every timestamp must have rows");
         const firstRow = firstInArray(rows);
 
-        const values = createRecord<string, SqliteValue>();
+        const values = createMutableRecord<string, SqliteValue>();
         let isInsert: DbChange["isInsert"] = false;
         let isDelete: DbChange["isDelete"] = null;
 
@@ -799,8 +770,8 @@ const handleMutation =
       TimestampConfigDep,
   ) =>
   (
-    message: ExtractType<
-      ExtractType<DbWorkerRequest, "ForEvolu">["message"],
+    message: ExtractTyped<
+      ExtractTyped<DbWorkerRequest, "ForEvolu">["message"],
       "Mutate"
     >,
   ): Result<
@@ -870,6 +841,7 @@ const applyLocalOnlyChange =
       const columns = dbChangeToColumns(change, deps.time.now());
 
       for (const [column, value] of columns) {
+        assertNonNullable(value);
         deps.sqlite.exec(sql.prepared`
           insert into ${sql.identifier(change.table)}
             ("ownerId", "id", ${sql.identifier(column)})
@@ -899,6 +871,7 @@ const applyMessages =
       const timestampBytes = timestampToTimestampBytes(timestamp);
 
       for (const [column, value] of columns) {
+        assertNonNullable(value);
         if (validateColumnValue(deps)(change.table, column, value)) {
           applyColumnChange(deps)(
             ownerIdBytes,

package/src/local-first/Error.ts

@@ -4,10 +4,10 @@
  * @module
  */
 
-import type { DecryptWithXChaCha20Poly1305Error } from "../Crypto.js";
-import type { UnknownError } from "../Error.js";
-import type { ProtocolError } from "./Protocol.js";
-import type { TimestampError } from "./Timestamp.js";
+import type { DecryptWithXChaCha20Poly1305Error } from "../Crypto.ts";
+import type { UnknownError } from "../Error.ts";
+import type { ProtocolError } from "./Protocol.ts";
+import type { TimestampError } from "./Timestamp.ts";
 
 /** Represents errors that can occur in Evolu. */
 export type EvoluError =