@evolu/common 8.0.0-next.4 → 8.0.0

package/dist/src/local-first/Db.js

@@ -56,39 +56,35 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 import { appendToArray, firstInArray, } from "../Array.js";
-import { assert, assertNonEmptyReadonlyArray, assertType } from "../Assert.js";
+import { assert, assertNonEmptyReadonlyArray, assertNonNullable, } from "../Assert.js";
 import { EncryptionKey, } from "../Crypto.js";
-import { exhaustiveCheck, lazyFalse, lazyVoid } from "../Function.js";
+import { constFalse, constVoid } from "../Function.js";
 import { acquireLeaderLock } from "../LockManager.js";
-import { createRecord, getProperty, objectToEntries } from "../Object.js";
+import { createMutableRecord, getOwnProp, objectToEntries } from "../Object.js";
 import { ok } from "../Result.js";
 import { booleanToSqliteBoolean, createSqlite, sql, SqliteBoolean, sqliteBooleanToBoolean, sqliteQueryStringToSqliteQuery, SqliteValue, } from "../Sqlite.js";
 import { callback } from "../Task.js";
 import { Millis, millisToDateIso } from "../Time.js";
-import { Id, IdBytes, idBytesToId, idToIdBytes, onePositiveInt, } from "../Type.js";
+import { assertType, Id, IdBytes, idBytesToId, idToIdBytes, onePositiveInt, } from "../Type.js";
 import { ownerIdBytesToOwnerId, ownerIdToOwnerIdBytes } from "./Owner.js";
 import { applyProtocolMessageAsClient, createProtocolMessageForSync, decryptAndDecodeDbChange, encodeAndEncryptDbChange, protocolVersion, SubscriptionFlags, } from "./Protocol.js";
 import { ensureSqliteSchema, getEvoluSqliteSchema, systemColumns, } from "./Schema.js";
 import { consoleEntryOrErrorBroadcastChannelName } from "./Shared.js";
 import { createBaseSqliteStorage, createBaseSqliteStorageTables, DbChange, getTimestampInsertStrategy, readOwnerUsageOrDefault, updateOwnerUsage, } from "./Storage.js";
 import { createInitialTimestamp, defaultTimestampMaxDrift, receiveTimestamp, sendTimestamp, TimestampBytes, timestampBytesToTimestamp, timestampToTimestampBytes, } from "./Timestamp.js";
+/**
+ * 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) => async (run) => {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
         const disposer = __addDisposableResource(env_1, new AsyncDisposableStack(), true);
         disposer.use(self);
-        const dbWorkerRun = disposer.use(run.create());
-        const { deps } = dbWorkerRun;
-        let initialized = false;
-        const initMessage = await dbWorkerRun.orThrow(callback(({ ok }) => {
-            self.onMessage = (message) => {
-                assert(!initialized, "DbWorker must be initialized only once");
-                initialized = true;
-                ok(message);
-            };
+        const { deps } = run;
+        const initMessage = await run.ok(callback(({ 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(initMessage.port));
         const consoleEntryOrErrorBroadcastChannel = disposer.use(deps.createBroadcastChannel(consoleEntryOrErrorBroadcastChannelName));
         disposer.defer(deps.consoleStoreOutputEntry.subscribe(() => {
@@ -99,19 +95,13 @@ export const startDbWorker = (self) => async (run) => {
                     entry,
                 });
         }));
-        console.debug("createDbWorker");
-        disposer.use(await dbWorkerRun.orThrow(acquireLeaderLock(initMessage.name)));
-        port.postMessage({ type: "LeaderAcquired", name: initMessage.name });
-        const sqlite = disposer.use(await dbWorkerRun.orThrow(createSqlite(initMessage.name, initMessage.memoryOnly
+        disposer.use(await run.ok(acquireLeaderLock(initMessage.name)));
+        const sqlite = disposer.use(await run.ok(createSqlite(initMessage.name, initMessage.memoryOnly
             ? { mode: "memory" }
             : { mode: "encrypted", encryptionKey: initMessage.encryptionKey })));
-        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,
@@ -134,117 +124,102 @@ export const startDbWorker = (self) => async (run) => {
                 });
             },
         });
-        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) => {
-                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;
-                        default:
-                            exhaustiveCheck(request.message);
-                    }
-                    break;
+        const dbWorkerRun = disposer.use(run.create({ storage }));
+        port.postMessage({ type: "LeaderAcquired", name: initMessage.name });
+        await run.ok(callback(({ resolve }) => {
+            port.onMessage = (input) => {
+                if (input.type === "Dispose") {
+                    resolve(ok());
+                    return;
                 }
-                case "ForSharedWorker": {
-                    switch (request.message.type) {
-                        case "CreateSyncMessages": {
-                            const protocolMessagesByOwnerId = new Map();
-                            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);
-                            }
+                const { callbackId, request } = input;
+                const postQueuedResponse = (response) => {
+                    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,
+                            }));
                             postQueuedResponse({
                                 type: "ForSharedWorker",
                                 message: {
-                                    type: "CreateSyncMessages",
-                                    protocolMessagesByOwnerId,
+                                    type: "ApplySyncMessage",
+                                    ownerId: owner.id,
+                                    didWriteMessages: storage.didWriteMessages(),
+                                    result,
                                 },
                             });
-                            break;
-                        }
-                        case "ApplySyncMessage": {
-                            const { owner, inputMessage } = request.message;
-                            dbWorkerRunWithStorage(async (run) => {
-                                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();
-                            });
-                            break;
-                        }
-                        default:
-                            exhaustiveCheck(request.message);
+                            return ok();
+                        });
+                        return;
                     }
-                    break;
+                    const protocolMessagesByOwnerId = new Map();
+                    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;
                 }
-                default:
-                    exhaustiveCheck(request);
-            }
-        };
+                if (request.message.type === "Query") {
+                    postQueuedResponse({
+                        type: "ForEvolu",
+                        id: request.id,
+                        message: {
+                            type: "Query",
+                            rowsByQuery: loadQueries(dbDeps)(request.message.queries),
+                        },
+                    });
+                    return;
+                }
+                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;
+                }
+                postQueuedResponse({
+                    type: "ForEvolu",
+                    id: request.id,
+                    message: result.value,
+                });
+            };
+            return () => {
+                port.onMessage = null;
+            };
+        }));
         return ok();
     }
     catch (e_1) {
@@ -393,7 +368,7 @@ const tryApplyQuarantinedMessages = (deps) => {
     }
 };
 const validateColumnValue = (deps) => (table, column, _value) => {
-    const schemaColumns = getProperty(deps.sqliteSchema.tables, table);
+    const schemaColumns = getOwnProp(deps.sqliteSchema.tables, table);
     return (schemaColumns != null &&
         (systemColumnsWithoutOwnerId.has(column) || schemaColumns.has(column)));
 };
@@ -454,8 +429,8 @@ const createClientStorage = (deps) => ({ onError, }) => {
         },
         didWriteMessages: () => didWriteMessages,
         // Not implemented yet.
-        validateWriteKey: lazyFalse,
-        setWriteKey: lazyVoid,
+        validateWriteKey: constFalse,
+        setWriteKey: constVoid,
         writeMessages: (ownerIdBytes, encryptedMessages) => () => {
             // TODO: Add quota checking for collaborative scenarios.
             // When receiving messages from other owners via relay broadcast,
@@ -502,7 +477,7 @@ const createClientStorage = (deps) => ({ onError, }) => {
             const { rows } = result;
             assertNonEmptyReadonlyArray(rows, "Every timestamp must have rows");
             const firstRow = firstInArray(rows);
-            const values = createRecord();
+            const values = createMutableRecord();
             let isInsert = false;
             let isDelete = null;
             for (const r of rows) {
@@ -582,6 +557,7 @@ const applyLocalOnlyChange = (deps) => (change) => {
         const ownerId = change.ownerId;
         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)})
@@ -601,6 +577,7 @@ const applyMessages = (deps) => (ownerId, messages) => {
         const idBytes = idToIdBytes(change.id);
         const timestampBytes = timestampToTimestampBytes(timestamp);
         for (const [column, value] of columns) {
+            assertNonNullable(value);
             if (validateColumnValue(deps)(change.table, column, value)) {
                 applyColumnChange(deps)(ownerIdBytes, ownerId, change.table, idBytes, change.id, column, value, timestampBytes);
             }

package/dist/src/local-first/Error.d.ts

@@ -3,10 +3,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 = DecryptWithXChaCha20Poly1305Error | ProtocolError | TimestampError | UnknownError;
 //# sourceMappingURL=Error.d.ts.map