@evolu/common 7.4.0 → 8.0.0-next.0

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

@@ -0,0 +1,569 @@
+/**
+ * Platform-agnostic Evolu SharedWorker.
+ *
+ * @module
+ */
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { emptyArray, firstInArray, isNonEmptyArray, shiftFromArray, } from "../Array.js";
+import { assert, assertNotDisposed } from "../Assert.js";
+import { createCallbacks } from "../Callbacks.js";
+import { exhaustiveCheck } from "../Function.js";
+import { structuralLookup } from "../Lookup.js";
+import { createRefCountByKey } from "../RefCount.js";
+import { createSharedResourceByKey, createSharedResourceByKeyWithClaims, } from "../Resource.js";
+import { ok } from "../Result.js";
+import { spaced } from "../Schedule.js";
+import { repeat, unabortable, } from "../Task.js";
+import { createId } from "../Type.js";
+import { createProtocolMessageForUnsubscribe, createProtocolMessageFromCrdtMessages, parseProtocolHeader, } from "./Protocol.js";
+import { makePatches, } from "./Query.js";
+export const initSharedWorker = (self) => async (run) => {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const { createMessagePort, consoleStoreOutputEntry, createWebSocket } = run.deps;
+        const console = run.deps.console.child("SharedWorker");
+        const stack = __addDisposableResource(env_1, new AsyncDisposableStack(), true);
+        const sharedWorkerReady = Promise.withResolvers();
+        // TODO: Use heartbeat to detect and prune dead ports.
+        const tabPorts = new Set();
+        // Buffer console/error outputs until the first tab connects its port.
+        const queuedTabOutputs = [];
+        const postTabOutput = (output) => {
+            if (tabPorts.size === 0)
+                queuedTabOutputs.push(output);
+            else
+                for (const port of tabPorts)
+                    port.postMessage(output);
+        };
+        stack.defer(consoleStoreOutputEntry.subscribe(() => {
+            const entry = consoleStoreOutputEntry.get();
+            if (entry)
+                postTabOutput({ type: "OnConsoleEntry", entry });
+        }));
+        // Register ASAP so the worker does not miss connections.
+        self.onConnect = (port) => {
+            void sharedWorkerReady.promise.then(() => {
+                // The underlying port buffers messages until onMessage is assigned.
+                port.onMessage = (message) => {
+                    switch (message.type) {
+                        case "InitTab": {
+                            /**
+                             * One SharedWorker serves multiple tabs. The most recently
+                             * initialized tab's level wins.
+                             */
+                            console.setLevel(message.consoleLevel);
+                            const tabPort = createMessagePort(message.port);
+                            tabPorts.add(tabPort);
+                            if (queuedTabOutputs.length > 0) {
+                                queuedTabOutputs.forEach(postTabOutput);
+                                queuedTabOutputs.length = 0;
+                            }
+                            break;
+                        }
+                        case "CreateEvolu": {
+                            void sharedWorkerRunWithSharedEvoluDeps(async (run) => {
+                                const sharedEvoluResult = await run(sharedEvolusByName.acquire(message.name));
+                                if (!sharedEvoluResult.ok)
+                                    return sharedEvoluResult;
+                                sharedEvoluResult.value.createInstance(message.evoluPort, message.dbWorkerPort, () => void sharedWorkerRunWithSharedEvoluDeps(sharedEvolusByName.release(message.name)));
+                                return ok();
+                            });
+                            break;
+                        }
+                        default:
+                            console.error("Unknown shared worker input", message);
+                    }
+                };
+            });
+        };
+        const initSharedWorkerRun = run.create();
+        const transports = stack.use(await initSharedWorkerRun.orThrow(createSharedResourceByKeyWithClaims((transport) => createWebSocket(transport.url, {
+            binaryType: "arraybuffer",
+            onOpen: () => {
+                const ownerIds = transports.getClaimsForResource(transport);
+                console.debug("transportOpen", {
+                    url: transport.url,
+                    ownerIds: [...ownerIds],
+                });
+                forEachSharedEvolu((sharedEvolu) => {
+                    sharedEvolu.requestCreateSyncMessages(ownerIds);
+                });
+            },
+            onMessage(data) {
+                if (!(data instanceof ArrayBuffer))
+                    return;
+                const inputMessage = new globalThis.Uint8Array(data);
+                const headerResult = parseProtocolHeader(new globalThis.Uint8Array(data));
+                if (!headerResult.ok) {
+                    console.debug("transportInvalidProtocolMessage", {
+                        url: transport.url,
+                        byteLength: inputMessage.byteLength,
+                    });
+                    // TODO: Propagate invalid protocol messages to sync state.
+                    return;
+                }
+                console.debug("transportProtocolMessage", {
+                    url: transport.url,
+                    ownerId: headerResult.value.ownerId,
+                    byteLength: inputMessage.byteLength,
+                });
+                forEachSharedEvolu((sharedEvolu) => {
+                    sharedEvolu.requestApplySyncMessage(headerResult.value.ownerId, inputMessage);
+                });
+            },
+        }), {
+            onFirstClaimAdded: (ownerId, webSocket) => {
+                if (!webSocket.isOpen())
+                    return;
+                forEachSharedEvolu((sharedEvolu) => {
+                    sharedEvolu.requestCreateSyncMessages(new Set([ownerId]));
+                });
+            },
+            onLastClaimRemoved: (ownerId, webSocket) => {
+                webSocket.send(createProtocolMessageForUnsubscribe(ownerId));
+            },
+            // Keep sockets alive briefly across short owner churn.
+            idleDisposeAfter: "3s",
+            resourceLookup: structuralLookup,
+        })));
+        const sharedWorkerRunWithSharedEvoluDeps = initSharedWorkerRun.addDeps({
+            transports,
+            postTabOutput,
+        });
+        const sharedEvolusByName = stack.use(await sharedWorkerRunWithSharedEvoluDeps.orThrow(createSharedResourceByKey(createSharedEvolu, {
+            lookup: structuralLookup,
+        })));
+        const forEachSharedEvolu = (callback) => {
+            for (const sharedEvolu of sharedEvolusByName
+                .snapshot()
+                .resourcesByKey.values()) {
+                callback(sharedEvolu);
+            }
+        };
+        sharedWorkerReady.resolve();
+        console.info("initSharedWorker");
+        return ok(stack.move());
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        const result_1 = __disposeResources(env_1);
+        if (result_1)
+            await result_1;
+    }
+};
+const createSharedEvolu = (name) => (run) => {
+    const stack = new AsyncDisposableStack();
+    const sharedEvoluRun = run.create();
+    const console = run.deps.console.child(name).child("SharedWorker");
+    const { createMessagePort, postTabOutput, transports } = run.deps;
+    const evoluInstancesByPortId = new Map();
+    const queue = [];
+    const callbacks = stack.use(createCallbacks(run.deps));
+    let leaderDbWorkerPort = null;
+    let queueProcessingFiber = null;
+    stack.use(sharedEvoluRun);
+    const moved = stack.move();
+    const ensureQueueProcessing = () => {
+        if (queueProcessingFiber ||
+            !isNonEmptyArray(queue) ||
+            !leaderDbWorkerPort) {
+            return;
+        }
+        const first = firstInArray(queue);
+        const callbackId = callbacks.register(({ response }) => {
+            queueProcessingFiber?.abort();
+            queueProcessingFiber = null;
+            switch (response.type) {
+                case "ForEvolu": {
+                    handleResponseForEvolu(response, first);
+                    break;
+                }
+                case "ForSharedWorker":
+                    handleResponseForSharedWorker(response);
+                    break;
+                default:
+                    exhaustiveCheck(response);
+            }
+            // Complete the current queue item and continue with the next one.
+            shiftFromArray(queue);
+            ensureQueueProcessing();
+        });
+        /**
+         * The leader DbWorker can disappear at any time when its tab closes, so
+         * keep resending the current request until some leader answers. The
+         * response handler aborts this retry loop and advances the queue.
+         */
+        queueProcessingFiber = sharedEvoluRun.daemon(repeat(() => {
+            assert(leaderDbWorkerPort, "Expected a leader DbWorker");
+            leaderDbWorkerPort.postMessage({ callbackId, request: first });
+            return ok();
+        }, spaced("5s")));
+    };
+    const handleResponseForEvolu = (response, first) => {
+        const instance = evoluInstancesByPortId.get(response.evoluPortId);
+        const port = instance?.evoluPort;
+        if (!port)
+            return;
+        switch (response.message.type) {
+            case "Mutate":
+            case "Query": {
+                const previousRowsByQuery = instance.rowsByQuery;
+                const nextRowsByQuery = new Map(previousRowsByQuery);
+                const patchesByQuery = new Map();
+                for (const [query, rows] of response.message.rowsByQuery) {
+                    nextRowsByQuery.set(query, rows);
+                    patchesByQuery.set(query, makePatches(previousRowsByQuery.get(query), rows));
+                }
+                instance.rowsByQuery = nextRowsByQuery;
+                instance.evoluPort.postMessage({
+                    type: "OnPatchesByQuery",
+                    patchesByQuery,
+                    onCompleteIds: first.message.type === "Mutate"
+                        ? first.message.onCompleteIds
+                        : emptyArray,
+                });
+                if (response.message.type === "Mutate") {
+                    const mutateResponse = response.message;
+                    for (const [otherEvoluPortId, otherEvoluInstance,] of evoluInstancesByPortId) {
+                        if (otherEvoluPortId === response.evoluPortId)
+                            continue;
+                        otherEvoluInstance.evoluPort.postMessage({
+                            type: "RefreshQueries",
+                        });
+                    }
+                    sharedEvoluRun((run) => {
+                        const protocolMessagesByOwnerId = new Map();
+                        for (const syncOwner of instance.usedSyncOwners.keys()) {
+                            const { owner } = syncOwner;
+                            const messages = mutateResponse.messagesByOwnerId.get(owner.id);
+                            // Skip owners this instance does not currently sync for
+                            // writing. Read-only owners cannot produce protocol
+                            // messages because they do not have a write key.
+                            if (!messages || !("writeKey" in owner))
+                                continue;
+                            protocolMessagesByOwnerId.set(owner.id, createProtocolMessageFromCrdtMessages(run.deps)(owner, messages));
+                        }
+                        sendProtocolMessagesByOwnerId(protocolMessagesByOwnerId);
+                        return ok();
+                    });
+                }
+                break;
+            }
+            case "Export":
+                port.postMessage({ type: "OnExport", file: response.message.file }, [
+                    response.message.file.buffer,
+                ]);
+                break;
+            default:
+                exhaustiveCheck(response.message);
+        }
+    };
+    const handleResponseForSharedWorker = (response) => {
+        switch (response.message.type) {
+            case "CreateSyncMessages":
+                sendProtocolMessagesByOwnerId(response.message.protocolMessagesByOwnerId);
+                break;
+            case "ApplySyncMessage":
+                if (response.message.didWriteMessages) {
+                    refreshQueries();
+                }
+                if (!response.message.result.ok) {
+                    if (response.message.result.error.type !== "AbortError") {
+                        postTabOutput({
+                            type: "OnError",
+                            error: response.message.result.error,
+                        });
+                    }
+                }
+                else {
+                    switch (response.message.result.value.type) {
+                        case "Response":
+                            sendProtocolMessagesByOwnerId(new Map([
+                                [
+                                    response.message.ownerId,
+                                    response.message.result.value.message,
+                                ],
+                            ]));
+                            break;
+                        case "Broadcast":
+                        case "NoResponse":
+                            break;
+                        default:
+                            exhaustiveCheck(response.message.result.value);
+                    }
+                }
+                break;
+            default:
+                exhaustiveCheck(response.message);
+        }
+    };
+    const sendProtocolMessagesByOwnerId = (protocolMessagesByOwnerId) => {
+        for (const [ownerId, protocolMessage] of protocolMessagesByOwnerId) {
+            for (const transport of transports.getResourceKeysForClaim(ownerId)) {
+                const webSocket = transports.getResource(transport);
+                if (!webSocket?.isOpen())
+                    continue;
+                console.debug("sendProtocolMessage", {
+                    ownerId,
+                    url: transport.url,
+                    byteLength: protocolMessage.byteLength,
+                });
+                webSocket.send(protocolMessage);
+            }
+        }
+    };
+    const refreshQueries = () => {
+        for (const evoluInstance of evoluInstancesByPortId.values()) {
+            evoluInstance.evoluPort.postMessage({ type: "RefreshQueries" });
+        }
+    };
+    const getUsedOwnersById = (ownerIds) => {
+        const ownersById = new Map();
+        for (const evoluInstance of evoluInstancesByPortId.values()) {
+            for (const { owner } of evoluInstance.usedSyncOwners.keys()) {
+                if (!ownerIds.has(owner.id) || !("writeKey" in owner))
+                    continue;
+                ownersById.set(owner.id, owner);
+            }
+        }
+        return ownersById;
+    };
+    const removeAllUsedSyncOwners = (evoluInstance) => unabortable(async (run) => {
+        for (const syncOwner of evoluInstance.usedSyncOwners.keys()) {
+            while (evoluInstance.usedSyncOwners.has(syncOwner)) {
+                await run(toggleUsedSyncOwner(evoluInstance, syncOwner, "remove"));
+            }
+        }
+        return ok();
+    });
+    const toggleUsedSyncOwner = (evoluInstance, syncOwner, action) => unabortable(async (run) => {
+        if (action === "add") {
+            evoluInstance.usedSyncOwners.increment(syncOwner);
+            await run(transports.addClaim(syncOwner.owner.id, syncOwner.transports));
+        }
+        else {
+            evoluInstance.usedSyncOwners.decrement(syncOwner);
+            await run(transports.removeClaim(syncOwner.owner.id, syncOwner.transports));
+        }
+        return ok();
+    });
+    return ok({
+        createInstance: (nativeEvoluPort, nativeDbWorkerPort, releaseSharedEvolu) => {
+            assertNotDisposed(moved);
+            const evoluPort = createMessagePort(nativeEvoluPort);
+            const dbWorkerPort = createMessagePort(nativeDbWorkerPort);
+            const evoluPortId = createId(run.deps);
+            const evoluInstance = {
+                evoluPort,
+                dbWorkerPort,
+                releaseSharedEvolu,
+                rowsByQuery: new Map(),
+                usedSyncOwners: createRefCountByKey({
+                    lookup: ({ owner: { id } }) => id,
+                }),
+            };
+            evoluInstancesByPortId.set(evoluPortId, evoluInstance);
+            dbWorkerPort.onMessage = (message) => {
+                switch (message.type) {
+                    case "LeaderAcquired": {
+                        leaderDbWorkerPort = evoluInstance.dbWorkerPort;
+                        console.info("leaderAcquired");
+                        ensureQueueProcessing();
+                        break;
+                    }
+                    case "OnQueuedResponse": {
+                        callbacks.execute(message.callbackId, message);
+                        break;
+                    }
+                    case "OnConsoleEntry":
+                    case "OnError": {
+                        postTabOutput(message);
+                        break;
+                    }
+                    default:
+                        exhaustiveCheck(message);
+                }
+            };
+            evoluPort.onMessage = (evoluMessage) => {
+                switch (evoluMessage.type) {
+                    case "Query":
+                    case "Export": {
+                        queue.push({
+                            type: "ForEvolu",
+                            evoluPortId,
+                            message: evoluMessage,
+                        });
+                        ensureQueueProcessing();
+                        break;
+                    }
+                    case "Mutate": {
+                        // TODO: Delegate do vsech evolu instances, co to pouzivaji
+                        queue.push({
+                            type: "ForEvolu",
+                            evoluPortId,
+                            message: evoluMessage,
+                        });
+                        ensureQueueProcessing();
+                        break;
+                    }
+                    case "UseOwner": {
+                        const evoluInstance = evoluInstancesByPortId.get(evoluPortId);
+                        if (!evoluInstance)
+                            break;
+                        for (const { owner, action } of evoluMessage.actions) {
+                            console.debug("useOwner", {
+                                evoluPortId,
+                                action,
+                                ownerId: owner.owner.id,
+                                transportUrls: owner.transports.map(({ url }) => url),
+                            });
+                            void sharedEvoluRun(toggleUsedSyncOwner(evoluInstance, owner, action));
+                        }
+                        break;
+                    }
+                    case "Dispose": {
+                        const evoluInstance = evoluInstancesByPortId.get(evoluPortId);
+                        if (!evoluInstance)
+                            break;
+                        evoluInstancesByPortId.delete(evoluPortId);
+                        const hadLastPort = evoluInstancesByPortId.size === 0;
+                        console.info("evoluDispose", {
+                            name,
+                            evoluPortId,
+                            hadLastPort,
+                        });
+                        // Potential plan: keep DbWorker ports in a SharedResource
+                        // abstraction instead of deleting them eagerly here. DbWorkers use
+                        // leader election because SQLite WASM needs a single active owner.
+                        // When the last Evolu instance is disposed, broadcast shutdown to
+                        // all DbWorkers so the current leader can dispose itself and the
+                        // followers can clean up consistently.
+                        sharedEvoluRun(async (run) => {
+                            await run(removeAllUsedSyncOwners(evoluInstance));
+                            evoluInstance.usedSyncOwners[Symbol.dispose]();
+                            return ok();
+                        });
+                        // if (hadLastPort) evoluInstance.releaseSharedEvolu();
+                        // TODO: Dispose SharedEvolu on the last port.
+                        // TODO: Decided what to do with DbWorker but probably dispose it, but
+                        // https://bugs.webkit.org/show_bug.cgi?id=301520
+                        break;
+                    }
+                    default:
+                        exhaustiveCheck(evoluMessage);
+                }
+            };
+        },
+        requestCreateSyncMessages: (ownerIds) => {
+            const ownersToSync = [...getUsedOwnersById(ownerIds).values()];
+            if (!isNonEmptyArray(ownersToSync))
+                return;
+            console.debug("requestCreateSyncMessages", {
+                ownerIds: ownersToSync.map(({ id }) => id),
+            });
+            queue.push({
+                type: "ForSharedWorker",
+                message: {
+                    type: "CreateSyncMessages",
+                    owners: ownersToSync,
+                },
+            });
+            ensureQueueProcessing();
+        },
+        requestApplySyncMessage: (ownerId, inputMessage) => {
+            const owner = getUsedOwnersById(new Set([ownerId])).get(ownerId);
+            if (!owner)
+                return;
+            console.debug("requestApplySyncMessage", {
+                ownerId,
+                byteLength: inputMessage.byteLength,
+            });
+            queue.push({
+                type: "ForSharedWorker",
+                message: {
+                    type: "ApplySyncMessage",
+                    owner,
+                    inputMessage,
+                },
+            });
+            ensureQueueProcessing();
+        },
+        [Symbol.asyncDispose]: () => moved.disposeAsync(),
+    });
+};
+//   | (Typed<"reset"> & {
+//       readonly onCompleteId: CallbackId;
+//       readonly reload: boolean;
+//       readonly restore?: {
+//         readonly sqliteSchema: SqliteSchema;
+//         readonly mnemonic: Mnemonic;
+//       };
+//     })
+//   | (Typed<"ensureSqliteSchema"> & {
+//       readonly sqliteSchema: SqliteSchema;
+//     })
+//   | (Typed<"export"> & {
+//       readonly onCompleteId: CallbackId;
+//     })
+//   | (Typed<"useOwner"> & {
+//       readonly use: boolean;
+//       readonly owner: SyncOwner;
+//     });
+//   | (Typed<"onReset"> & {
+//       readonly onCompleteId: CallbackId;
+//       readonly reload: boolean;
+//     })