@evolu/common 8.0.0-next.5 → 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,6 +140,10 @@ 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) => {
@@ -142,21 +151,12 @@ export const startDbWorker =
     disposer.use(self);
     const { deps } = run;
 
-    let initialized = false;
-
-    const initMessage = await run.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),
     );
@@ -176,14 +176,11 @@ export const startDbWorker =
           });
       }),
     );
-    console.debug("createDbWorker");
 
-    disposer.use(await run.orThrow(acquireLeaderLock(initMessage.name)));
-
-    port.postMessage({ type: "LeaderAcquired", name: initMessage.name });
+    disposer.use(await run.ok(acquireLeaderLock(initMessage.name)));
 
     const sqlite = disposer.use(
-      await run.orThrow(
+      await run.ok(
         createSqlite(
           initMessage.name,
           initMessage.memoryOnly
@@ -192,13 +189,8 @@ export const startDbWorker =
         ),
       ),
     );
-    console.debug("SQLite created");
-
-    const baseSqliteStorage = createBaseSqliteStorage({
-      sqlite,
-      ...deps,
-    });
 
+    const baseSqliteStorage = createBaseSqliteStorage({ sqlite, ...deps });
     const dbDeps = {
       ...deps,
       sqlite,
@@ -206,8 +198,6 @@ export const startDbWorker =
       baseSqliteStorage,
       timestampConfig: { maxDrift: defaultTimestampMaxDrift },
     };
-    const dbWorkerRun = disposer.use(run.create());
-
     const currentSchema = getEvoluSqliteSchema(dbDeps)();
     const dbIsInitialized = "evolu_version" in currentSchema.tables;
     const clock = createClock(dbDeps)(dbIsInitialized);
@@ -226,156 +216,135 @@ export const startDbWorker =
         });
       },
     });
+    const dbWorkerRun = disposer.use(run.create({ storage }));
 
-    const disposables = disposer.move();
+    port.postMessage({ type: "LeaderAcquired", name: initMessage.name });
 
-    port.onMessage = (input) => {
-      if (input.type === "Dispose") {
-        if (!disposables.disposed) console.debug("disposeDbWorker");
-        void disposables.disposeAsync();
-        return;
-      }
+    await run.ok(
+      callback<void>(({ resolve }) => {
+        port.onMessage = (input) => {
+          if (input.type === "Dispose") {
+            resolve(ok());
+            return;
+          }
 
-      const { callbackId, request } = input;
+          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;
+
+              void dbWorkerRun(async (run) => {
+                storage.setRequestContext(owner.encryptionKey);
+
+                const result = await run.abortable(
+                  applyProtocolMessageAsClient(inputMessage, {
+                    writeKey: owner.writeKey,
+                  }),
+                );
 
-      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,
+                  type: "ForSharedWorker",
+                  message: {
+                    type: "ApplySyncMessage",
+                    ownerId: owner.id,
+                    didWriteMessages: storage.didWriteMessages(),
+                    result,
+                  },
                 });
-              }
-              break;
-            }
 
-            case "Query":
-              postQueuedResponse({
-                type: "ForEvolu",
-                id: request.id,
-                message: {
-                  type: "Query",
-                  rowsByQuery: loadQueries(dbDeps)(request.message.queries),
-                },
+                return ok();
               });
-              break;
-
-            case "Export":
-              postQueuedResponse({
-                type: "ForEvolu",
-                id: request.id,
-                message: {
-                  type: "Export",
-                  file: dbDeps.sqlite.export(),
-                },
-              });
-              break;
-
-            default:
-              exhaustiveCheck(request.message);
-          }
-          break;
-        }
+              return;
+            }
 
-        case "ForSharedWorker": {
-          switch (request.message.type) {
-            case "CreateSyncMessages": {
-              const protocolMessagesByOwnerId = new Map<
-                OwnerId,
-                ProtocolMessage
-              >();
+            const protocolMessagesByOwnerId = new Map<
+              OwnerId,
+              ProtocolMessage
+            >();
 
-              for (const owner of request.message.owners) {
-                storage.setRequestContext(owner.encryptionKey);
-                const protocolMessage = createProtocolMessageForSync({
+            for (const owner of request.message.owners) {
+              storage.setRequestContext(owner.encryptionKey);
+              protocolMessagesByOwnerId.set(
+                owner.id,
+                createProtocolMessageForSync({
                   storage,
-                  console,
-                })(owner.id, SubscriptionFlags.Subscribe);
-                protocolMessagesByOwnerId.set(owner.id, protocolMessage);
-              }
-
-              postQueuedResponse({
-                type: "ForSharedWorker",
-                message: {
-                  type: "CreateSyncMessages",
-                  protocolMessagesByOwnerId,
-                },
-              });
-              break;
+                  console: deps.console,
+                })(owner.id, SubscriptionFlags.Subscribe),
+              );
             }
 
-            case "ApplySyncMessage": {
-              const { owner, inputMessage } = request.message;
+            postQueuedResponse({
+              type: "ForSharedWorker",
+              message: {
+                type: "CreateSyncMessages",
+                protocolMessagesByOwnerId,
+              },
+            });
+            return;
+          }
 
-              dbWorkerRun<void, never, { readonly storage: ClientStorage }>(
-                async (run) => {
-                  const { storage } = run.deps;
-
-                  storage.setRequestContext(owner.encryptionKey);
-
-                  const result = await run(
-                    applyProtocolMessageAsClient(inputMessage, {
-                      writeKey: owner.writeKey,
-                    }),
-                  );
-
-                  const didWriteMessages = storage.didWriteMessages();
-
-                  postQueuedResponse({
-                    type: "ForSharedWorker",
-                    message: {
-                      type: "ApplySyncMessage",
-                      ownerId: owner.id,
-                      didWriteMessages,
-                      result,
-                    },
-                  });
-
-                  return ok();
-                },
-                { storage },
-              );
-              break;
-            }
+          if (request.message.type === "Query") {
+            postQueuedResponse({
+              type: "ForEvolu",
+              id: request.id,
+              message: {
+                type: "Query",
+                rowsByQuery: loadQueries(dbDeps)(request.message.queries),
+              },
+            });
+            return;
+          }
 
-            default:
-              exhaustiveCheck(request.message);
+          if (request.message.type === "Export") {
+            postQueuedResponse({
+              type: "ForEvolu",
+              id: request.id,
+              message: {
+                type: "Export",
+                file: sqlite.export(),
+              },
+            });
+            return;
           }
-          break;
-        }
 
-        default:
-          exhaustiveCheck(request);
-      }
-    };
+          const result = handleMutation({ ...dbDeps, clock })(request.message);
+          if (!result.ok) {
+            consoleEntryOrErrorBroadcastChannel.postMessage({
+              type: "Error",
+              error: result.error,
+            });
+            return;
+          }
 
-    return ok();
+          postQueuedResponse({
+            type: "ForEvolu",
+            id: request.id,
+            message: result.value,
+          });
+        };
 
-    // 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.
+        return () => {
+          port.onMessage = null;
+        };
+      }),
+    );
+
+    return ok();
   };
 
 /**
@@ -567,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))
@@ -684,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.
@@ -753,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;
 
@@ -801,8 +770,8 @@ const handleMutation =
       TimestampConfigDep,
   ) =>
   (
-    message: ExtractType<
-      ExtractType<DbWorkerRequest, "ForEvolu">["message"],
+    message: ExtractTyped<
+      ExtractTyped<DbWorkerRequest, "ForEvolu">["message"],
       "Mutate"
     >,
   ): Result<
@@ -872,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)})
@@ -901,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 =