@evolu/nodejs 2.3.0 → 3.0.0-next.0

package/dist/local-first/Relay.js

@@ -1,165 +0,0 @@
-import { createRelation, createRandom, createSqlite, isAsync, ok, SimpleName, Uint8Array, } from "@evolu/common";
-import { applyProtocolMessageAsRelay, createBaseSqliteStorageTables, createRelayLogger, createRelaySqliteStorage, createRelayStorageTables, defaultProtocolMessageMaxSize, parseOwnerIdFromOwnerWebSocketTransportUrl, } from "@evolu/common/local-first";
-import { existsSync } from "fs";
-import { createServer } from "http";
-import { WebSocket, WebSocketServer } from "ws";
-import { createBetterSqliteDriver } from "../BetterSqliteDriver.js";
-import { createTimingSafeEqual } from "../Crypto.js";
-/**
- * Creates an Evolu relay server.
- *
- * This implementation uses Node.js and better-sqlite3. Additional relay
- * implementations will be provided for other platforms (Bun, Deno, Cloudflare
- * Workers, Vercel Edge, etc.).
- */
-export const createNodeJsRelay = (deps) => (config) => createNodeJsRelayWithSqliteDriver({
-    ...deps,
-    createSqliteDriver: createBetterSqliteDriver,
-})(config);
-/**
- * Creates an Evolu relay server with a custom SQLite driver.
- *
- * Use this when you need to provide a different SQLite driver implementation
- * (e.g., using alternative SQLite libraries).
- */
-export const createNodeJsRelayWithSqliteDriver = (deps) => (config) => createNodeJsRelayWithDeps({
-    ...deps,
-    random: createRandom(),
-    timingSafeEqual: createTimingSafeEqual(),
-})(config);
-const createNodeJsRelayWithDeps = (deps) => async ({ port = 443, name = SimpleName.orThrow("evolu-relay"), enableLogging = false, isOwnerAllowed, isOwnerWithinQuota, }) => {
-    const log = createRelayLogger(deps);
-    log.started(enableLogging, port);
-    const dbFileExists = existsSync(`${name}.db`);
-    const sqlite = await createSqlite(deps)(name);
-    if (!sqlite.ok)
-        return sqlite;
-    const depsWithSqlite = { ...deps, sqlite: sqlite.value };
-    if (!dbFileExists) {
-        {
-            const result = createBaseSqliteStorageTables(depsWithSqlite);
-            if (!result.ok)
-                return result;
-        }
-        {
-            const result = createRelayStorageTables(depsWithSqlite);
-            if (!result.ok)
-                return result;
-        }
-    }
-    const storage = createRelaySqliteStorage(depsWithSqlite)({
-        onStorageError: log.storageError,
-        isOwnerWithinQuota,
-    });
-    const server = createServer();
-    const wss = new WebSocketServer({
-        maxPayload: defaultProtocolMessageMaxSize,
-        noServer: true,
-    });
-    const ownerSocketRelation = createRelation();
-    server.on("upgrade", (request, socket, head) => {
-        socket.on("error", log.upgradeSocketError);
-        const completeUpgrade = () => {
-            socket.removeListener("error", log.upgradeSocketError);
-            wss.handleUpgrade(request, socket, head, (ws) => {
-                wss.emit("connection", ws, request);
-            });
-        };
-        if (!isOwnerAllowed) {
-            completeUpgrade();
-            return;
-        }
-        const ownerId = parseOwnerIdFromOwnerWebSocketTransportUrl(request.url ?? "");
-        if (!ownerId) {
-            log.invalidOrMissingOwnerIdInUrl(request.url);
-            socket.write("HTTP/1.1 400 Bad Request\r\n\r\n");
-            socket.destroy();
-            return;
-        }
-        void (async () => {
-            const result = isOwnerAllowed(ownerId);
-            const isAllowed = isAsync(result) ? await result : result;
-            if (!isAllowed) {
-                log.unauthorizedOwner(ownerId);
-                socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
-                socket.destroy();
-                return;
-            }
-            completeUpgrade();
-        })();
-    });
-    wss.on("connection", (ws) => {
-        log.connectionEstablished(wss.clients.size);
-        ws.on("error", (error) => {
-            log.connectionWebSocketError(error);
-        });
-        const options = {
-            subscribe: (ownerId) => {
-                ownerSocketRelation.add(ownerId, ws);
-                log.relayOptionSubscribe(ownerId, () => ownerSocketRelation.getB(ownerId)?.size ?? 0);
-            },
-            unsubscribe: (ownerId) => {
-                ownerSocketRelation.remove(ownerId, ws);
-                log.relayOptionUnsubscribe(ownerId, () => ownerSocketRelation.getB(ownerId)?.size ?? 0);
-            },
-            broadcast: (ownerId, message) => {
-                const sockets = ownerSocketRelation.getB(ownerId);
-                if (!sockets)
-                    return;
-                let broadcastCount = 0;
-                for (const socket of sockets) {
-                    if (socket !== ws && socket.readyState === WebSocket.OPEN) {
-                        socket.send(message, { binary: true });
-                        broadcastCount++;
-                    }
-                }
-                log.relayOptionBroadcast(ownerId, broadcastCount, sockets.size);
-            },
-        };
-        ws.on("message", (message) => {
-            if (!Uint8Array.is(message))
-                return;
-            log.messageLength(message.length);
-            applyProtocolMessageAsRelay({ storage })(message, options)
-                .then((response) => {
-                if (!response.ok) {
-                    log.applyProtocolMessageAsRelayError(response.error);
-                    return;
-                }
-                ws.send(response.value.message, { binary: true });
-                log.responseLength(response.value.message.length);
-            })
-                .catch(log.applyProtocolMessageAsRelayUnknownError);
-        });
-        ws.on("close", () => {
-            ownerSocketRelation.deleteB(ws);
-            log.connectionClosed(wss.clients.size);
-        });
-    });
-    server.listen(port);
-    const dispose = () => {
-        log.shuttingDown();
-        wss.clients.forEach((client) => {
-            if (client.readyState === WebSocket.OPEN) {
-                client.close(1000, "Evolu Relay shutting down");
-            }
-        });
-        wss.close(() => {
-            log.webSocketServerDisposed();
-        });
-        server.close(() => {
-            log.httpServerDisposed();
-        });
-    };
-    let isDisposed = false;
-    const relay = {
-        [Symbol.dispose]: () => {
-            if (isDisposed)
-                return;
-            isDisposed = true;
-            sqlite.value[Symbol.dispose]();
-            dispose();
-        },
-    };
-    return ok(relay);
-};

package/src/BetterSqliteDriver.ts

@@ -1,47 +0,0 @@
-import {
-  constVoid,
-  createPreparedStatementsCache,
-  CreateSqliteDriver,
-  SqliteDriver,
-  SqliteRow,
-} from "@evolu/common";
-import BetterSQLite, { Statement } from "better-sqlite3";
-
-export const createBetterSqliteDriver: CreateSqliteDriver = (name, options) => {
-  const filename = options?.memory ? ":memory:" : `${name}.db`;
-  const db = new BetterSQLite(filename);
-  let isDisposed = false;
-
-  const cache = createPreparedStatementsCache<Statement>(
-    (sql) => db.prepare(sql),
-    // Not needed.
-    // https://github.com/WiseLibs/better-sqlite3/blob/master/docs/api.md#class-statement
-    constVoid,
-  );
-
-  const driver: SqliteDriver = {
-    exec: (query, isMutation) => {
-      // Always prepare is recommended for better-sqlite3
-      const prepared = cache.get(query, true);
-
-      const rows = isMutation
-        ? []
-        : (prepared.all(query.parameters) as Array<SqliteRow>);
-
-      const changes = isMutation ? prepared.run(query.parameters).changes : 0;
-
-      return { rows, changes };
-    },
-
-    export: () => db.serialize(),
-
-    [Symbol.dispose]: () => {
-      if (isDisposed) return;
-      isDisposed = true;
-      cache[Symbol.dispose]();
-      db.close();
-    },
-  };
-
-  return Promise.resolve(driver);
-};