@evolu/nodejs 1.0.1-preview.8 → 2.0.0

package/dist/Evolu/Relay.d.ts

@@ -1,7 +1,22 @@
-import { ConsoleDep } from "@evolu/common";
+import { ConsoleDep, CreateSqliteDriverDep, Result, SqliteError } from "@evolu/common";
 import { Relay, RelayConfig } from "@evolu/common/evolu";
 export interface NodeJsRelayConfig extends RelayConfig {
+    /** The port number for the HTTP server. */
     readonly port?: number;
 }
-export declare const createNodeJsRelay: (deps: ConsoleDep) => (config: NodeJsRelayConfig) => Promise<Relay>;
+/**
+ * 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 declare const createNodeJsRelay: (deps: ConsoleDep) => (config: NodeJsRelayConfig) => Promise<Result<Relay, SqliteError>>;
+/**
+ * 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 declare const createNodeJsRelayWithSqliteDriver: (deps: ConsoleDep & CreateSqliteDriverDep) => (config: NodeJsRelayConfig) => Promise<Result<Relay, SqliteError>>;
 //# sourceMappingURL=Relay.d.ts.map

package/dist/Evolu/Relay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Relay.d.ts","sourceRoot":"","sources":["../../src/Evolu/Relay.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EAQX,MAAM,eAAe,CAAC;AACvB,OAAO,EAKL,KAAK,EACL,WAAW,EAEZ,MAAM,qBAAqB,CAAC;AAK7B,MAAM,WAAW,iBAAkB,SAAQ,WAAW;IACpD,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,eAAO,MAAM,iBAAiB,GAC3B,MAAM,UAAU,MACV,QAAQ,iBAAiB,KAAG,OAAO,CAAC,KAAK,CA+I/C,CAAC"}
+{"version":3,"file":"Relay.d.ts","sourceRoot":"","sources":["../../src/Evolu/Relay.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EAIV,qBAAqB,EAKrB,MAAM,EAEN,WAAW,EAGZ,MAAM,eAAe,CAAC;AACvB,OAAO,EASL,KAAK,EACL,WAAW,EACZ,MAAM,qBAAqB,CAAC;AAO7B,MAAM,WAAW,iBAAkB,SAAQ,WAAW;IACpD,2CAA2C;IAC3C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAC3B,MAAM,UAAU,MAChB,QAAQ,iBAAiB,KAAG,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,WAAW,CAAC,CAInD,CAAC;AAEf;;;;;GAKG;AACH,eAAO,MAAM,iCAAiC,GAC3C,MAAM,UAAU,GAAG,qBAAqB,MACxC,QAAQ,iBAAiB,KAAG,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,WAAW,CAAC,CAKnD,CAAC"}

package/dist/Evolu/Relay.js

@@ -1,57 +1,105 @@
-import { createManyToManyMap, createRandom, createSqlite, getOrThrow, SimpleName, Uint8Array, } from "@evolu/common";
-import { applyProtocolMessageAsRelay, createRelayStorage, maxProtocolMessageSize, } from "@evolu/common/evolu";
+import { createRelation, createRandom, createSqlite, isAsync, ok, SimpleName, Uint8Array, } from "@evolu/common";
+import { applyProtocolMessageAsRelay, createBaseSqliteStorageTables, createRelayLogger, createRelaySqliteStorage, createRelayStorageTables, defaultProtocolMessageMaxSize, parseOwnerIdFromOwnerWebSocketTransportUrl, } from "@evolu/common/evolu";
+import { existsSync } from "fs";
+import { createServer } from "http";
 import { WebSocket, WebSocketServer } from "ws";
 import { createBetterSqliteDriver } from "../BetterSqliteDriver.js";
 import { createTimingSafeEqual } from "../Crypto.js";
-export const createNodeJsRelay = (deps) => async (config) => {
-    const { port = 443, name = SimpleName.orThrow("evolu-relay"), enableLogging = false, } = config;
-    deps.console.enabled = true;
-    deps.console.log(`Evolu Relay started on port ${port}`);
-    deps.console.enabled = enableLogging;
-    const sqlite = getOrThrow(await createSqlite({
-        ...deps,
-        createSqliteDriver: createBetterSqliteDriver,
-    })(name));
-    const relaySqliteStorageDeps = {
-        sqlite,
-        random: createRandom(),
-        timingSafeEqual: createTimingSafeEqual(),
-    };
-    const storage = getOrThrow(createRelayStorage(relaySqliteStorageDeps)({
-        onStorageError: (error) => {
-            deps.console.error("[relay]", "storage", error);
-        },
-    }));
+/**
+ * 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 baseTables = createBaseSqliteStorageTables(depsWithSqlite);
+        if (!baseTables.ok)
+            return baseTables;
+        const relayTables = createRelayStorageTables(depsWithSqlite);
+        if (!relayTables.ok)
+            return relayTables;
+    }
+    const storage = createRelaySqliteStorage(depsWithSqlite)({
+        onStorageError: log.storageError,
+        isOwnerWithinQuota,
+    });
+    const server = createServer();
     const wss = new WebSocketServer({
-        maxPayload: maxProtocolMessageSize,
-        port,
+        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();
+        })();
     });
-    const ownerSocketsMap = createManyToManyMap();
     wss.on("connection", (ws) => {
-        deps.console.log("[relay]", "connection", {
-            clientCount: wss.clients.size,
-        });
+        log.connectionEstablished(wss.clients.size);
         ws.on("error", (error) => {
-            deps.console.warn("[relay]", "error", { error });
-            deps.console.error(error);
+            log.connectionWebSocketError(error);
         });
         const options = {
             subscribe: (ownerId) => {
-                ownerSocketsMap.add(ownerId, ws);
-                deps.console.log("[relay]", "subscribe", {
-                    ownerId,
-                    subscriberCount: ownerSocketsMap.getValues(ownerId)?.size ?? 0,
-                });
+                ownerSocketRelation.add(ownerId, ws);
+                log.relayOptionSubscribe(ownerId, () => ownerSocketRelation.getB(ownerId)?.size ?? 0);
             },
             unsubscribe: (ownerId) => {
-                ownerSocketsMap.remove(ownerId, ws);
-                deps.console.log("[relay]", "unsubscribe", {
-                    ownerId,
-                    subscriberCount: ownerSocketsMap.getValues(ownerId)?.size ?? 0,
-                });
+                ownerSocketRelation.remove(ownerId, ws);
+                log.relayOptionUnsubscribe(ownerId, () => ownerSocketRelation.getB(ownerId)?.size ?? 0);
             },
             broadcast: (ownerId, message) => {
-                const sockets = ownerSocketsMap.getValues(ownerId);
+                const sockets = ownerSocketRelation.getB(ownerId);
                 if (!sockets)
                     return;
                 let broadcastCount = 0;
@@ -61,61 +109,53 @@ export const createNodeJsRelay = (deps) => async (config) => {
                         broadcastCount++;
                     }
                 }
-                deps.console.log("[relay]", "broadcast", {
-                    ownerId,
-                    broadcastCount,
-                    totalSubscribers: sockets.size,
-                });
+                log.relayOptionBroadcast(ownerId, broadcastCount, sockets.size);
             },
         };
         ws.on("message", (message) => {
             if (!Uint8Array.is(message))
                 return;
-            deps.console.log("[relay]", "on message", {
-                messageSize: message.length,
-            });
+            log.messageLength(message.length);
             applyProtocolMessageAsRelay({ storage })(message, options)
                 .then((response) => {
                 if (!response.ok) {
-                    deps.console.error("[relay]", "protocol", response.error);
-                    deps.console.error(response.error);
+                    log.applyProtocolMessageAsRelayError(response.error);
                     return;
                 }
                 ws.send(response.value.message, { binary: true });
-                deps.console.log("[relay]", "response", {
-                    responseSize: response.value.message.length,
-                });
+                log.responseLength(response.value.message.length);
             })
-                .catch((error) => {
-                deps.console.error("[relay]", "applyProtocolMessageAsRelay", error);
-            });
+                .catch(log.applyProtocolMessageAsRelayUnknownError);
         });
         ws.on("close", () => {
-            ownerSocketsMap.deleteValue(ws);
-            deps.console.log("[relay]", "close", {
-                clientCount: wss.clients.size,
-            });
+            ownerSocketRelation.deleteB(ws);
+            log.connectionClosed(wss.clients.size);
         });
     });
-    const disposeWss = () => {
-        deps.console.log("Shutting down Evolu Relay...");
+    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(() => {
-            deps.console.log("Evolu Relay disposed");
+            log.webSocketServerDisposed();
+        });
+        server.close(() => {
+            log.httpServerDisposed();
         });
     };
     let isDisposed = false;
-    return {
+    const relay = {
         [Symbol.dispose]: () => {
             if (isDisposed)
                 return;
             isDisposed = true;
-            sqlite[Symbol.dispose]();
-            disposeWss();
+            sqlite.value[Symbol.dispose]();
+            dispose();
         },
     };
+    return ok(relay);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evolu/nodejs",
-  "version": "1.0.1-preview.8",
+  "version": "2.0.0",
   "description": "Evolu for Node.js",
   "author": "Daniel Steigerwald <daniel@steigerwald.cz>",
   "license": "MIT",
@@ -30,11 +30,11 @@
     "shx": "^0.4.0",
     "typescript": "^5.9.2",
     "vitest": "^4.0.4",
-    "@evolu/common": "6.0.1-preview.20",
+    "@evolu/common": "7.0.0",
     "@evolu/tsconfig": "0.0.2"
   },
   "peerDependencies": {
-    "@evolu/common": "^6.0.1-preview.20"
+    "@evolu/common": "^7.0.0"
   },
   "engines": {
     "node": ">=22.0.0"

package/src/Evolu/Relay.ts

@@ -1,100 +1,177 @@
 import {
   ConsoleDep,
-  createManyToManyMap,
+  createRelation,
   createRandom,
   createSqlite,
-  getOrThrow,
+  CreateSqliteDriverDep,
+  isAsync,
+  ok,
   OwnerId,
+  RandomDep,
+  Result,
   SimpleName,
+  SqliteError,
+  TimingSafeEqualDep,
   Uint8Array,
 } from "@evolu/common";
 import {
   applyProtocolMessageAsRelay,
   ApplyProtocolMessageAsRelayOptions,
-  createRelayStorage,
-  maxProtocolMessageSize,
+  createBaseSqliteStorageTables,
+  createRelayLogger,
+  createRelaySqliteStorage,
+  createRelayStorageTables,
+  defaultProtocolMessageMaxSize,
+  parseOwnerIdFromOwnerWebSocketTransportUrl,
   Relay,
   RelayConfig,
-  RelaySqliteStorageDeps,
 } from "@evolu/common/evolu";
+import { existsSync } from "fs";
+import { createServer } from "http";
 import { WebSocket, WebSocketServer } from "ws";
 import { createBetterSqliteDriver } from "../BetterSqliteDriver.js";
 import { createTimingSafeEqual } from "../Crypto.js";
 
 export interface NodeJsRelayConfig extends RelayConfig {
+  /** The port number for the HTTP server. */
   readonly port?: number;
 }
 
+/**
+ * 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: ConsoleDep) =>
-  async (config: NodeJsRelayConfig): Promise<Relay> => {
-    const {
-      port = 443,
-      name = SimpleName.orThrow("evolu-relay"),
-      enableLogging = false,
-    } = config;
-
-    deps.console.enabled = true;
-    deps.console.log(`Evolu Relay started on port ${port}`);
-    deps.console.enabled = enableLogging;
-
-    const sqlite = getOrThrow(
-      await createSqlite({
-        ...deps,
-        createSqliteDriver: createBetterSqliteDriver,
-      })(name),
-    );
-
-    const relaySqliteStorageDeps: RelaySqliteStorageDeps = {
-      sqlite,
+  (config: NodeJsRelayConfig): Promise<Result<Relay, SqliteError>> =>
+    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: ConsoleDep & CreateSqliteDriverDep) =>
+  (config: NodeJsRelayConfig): Promise<Result<Relay, SqliteError>> =>
+    createNodeJsRelayWithDeps({
+      ...deps,
       random: createRandom(),
       timingSafeEqual: createTimingSafeEqual(),
-    };
-
-    const storage = getOrThrow(
-      createRelayStorage(relaySqliteStorageDeps)({
-        onStorageError: (error) => {
-          deps.console.error("[relay]", "storage", error);
-        },
-      }),
-    );
+    })(config);
+
+const createNodeJsRelayWithDeps =
+  (deps: ConsoleDep & CreateSqliteDriverDep & RandomDep & TimingSafeEqualDep) =>
+  async ({
+    port = 443,
+    name = SimpleName.orThrow("evolu-relay"),
+    enableLogging = false,
+    isOwnerAllowed,
+    isOwnerWithinQuota,
+  }: NodeJsRelayConfig): Promise<Result<Relay, SqliteError>> => {
+    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 baseTables = createBaseSqliteStorageTables(depsWithSqlite);
+      if (!baseTables.ok) return baseTables;
+
+      const relayTables = createRelayStorageTables(depsWithSqlite);
+      if (!relayTables.ok) return relayTables;
+    }
+
+    const storage = createRelaySqliteStorage(depsWithSqlite)({
+      onStorageError: log.storageError,
+      isOwnerWithinQuota,
+    });
 
+    const server = createServer();
     const wss = new WebSocketServer({
-      maxPayload: maxProtocolMessageSize,
-      port,
+      maxPayload: defaultProtocolMessageMaxSize,
+      noServer: true,
     });
 
-    const ownerSocketsMap = createManyToManyMap<OwnerId, WebSocket>();
+    const ownerSocketRelation = createRelation<OwnerId, WebSocket>();
+
+    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) => {
-      deps.console.log("[relay]", "connection", {
-        clientCount: wss.clients.size,
-      });
+      log.connectionEstablished(wss.clients.size);
 
       ws.on("error", (error) => {
-        deps.console.warn("[relay]", "error", { error });
-        deps.console.error(error);
+        log.connectionWebSocketError(error);
       });
 
       const options: ApplyProtocolMessageAsRelayOptions = {
         subscribe: (ownerId) => {
-          ownerSocketsMap.add(ownerId, ws);
-          deps.console.log("[relay]", "subscribe", {
+          ownerSocketRelation.add(ownerId, ws);
+          log.relayOptionSubscribe(
             ownerId,
-            subscriberCount: ownerSocketsMap.getValues(ownerId)?.size ?? 0,
-          });
+            () => ownerSocketRelation.getB(ownerId)?.size ?? 0,
+          );
         },
 
         unsubscribe: (ownerId) => {
-          ownerSocketsMap.remove(ownerId, ws);
-          deps.console.log("[relay]", "unsubscribe", {
+          ownerSocketRelation.remove(ownerId, ws);
+          log.relayOptionUnsubscribe(
             ownerId,
-            subscriberCount: ownerSocketsMap.getValues(ownerId)?.size ?? 0,
-          });
+            () => ownerSocketRelation.getB(ownerId)?.size ?? 0,
+          );
         },
 
         broadcast: (ownerId, message) => {
-          const sockets = ownerSocketsMap.getValues(ownerId);
+          const sockets = ownerSocketRelation.getB(ownerId);
           if (!sockets) return;
 
           let broadcastCount = 0;
@@ -105,49 +182,36 @@ export const createNodeJsRelay =
             }
           }
 
-          deps.console.log("[relay]", "broadcast", {
-            ownerId,
-            broadcastCount,
-            totalSubscribers: sockets.size,
-          });
+          log.relayOptionBroadcast(ownerId, broadcastCount, sockets.size);
         },
       };
 
       ws.on("message", (message) => {
         if (!Uint8Array.is(message)) return;
-
-        deps.console.log("[relay]", "on message", {
-          messageSize: message.length,
-        });
+        log.messageLength(message.length);
 
         applyProtocolMessageAsRelay({ storage })(message, options)
           .then((response) => {
             if (!response.ok) {
-              deps.console.error("[relay]", "protocol", response.error);
-              deps.console.error(response.error);
+              log.applyProtocolMessageAsRelayError(response.error);
               return;
             }
-
             ws.send(response.value.message, { binary: true });
-            deps.console.log("[relay]", "response", {
-              responseSize: response.value.message.length,
-            });
+            log.responseLength(response.value.message.length);
           })
-          .catch((error: unknown) => {
-            deps.console.error("[relay]", "applyProtocolMessageAsRelay", error);
-          });
+          .catch(log.applyProtocolMessageAsRelayUnknownError);
       });
 
       ws.on("close", () => {
-        ownerSocketsMap.deleteValue(ws);
-        deps.console.log("[relay]", "close", {
-          clientCount: wss.clients.size,
-        });
+        ownerSocketRelation.deleteB(ws);
+        log.connectionClosed(wss.clients.size);
       });
     });
 
-    const disposeWss = () => {
-      deps.console.log("Shutting down Evolu Relay...");
+    server.listen(port);
+
+    const dispose = () => {
+      log.shuttingDown();
 
       wss.clients.forEach((client) => {
         if (client.readyState === WebSocket.OPEN) {
@@ -156,18 +220,24 @@ export const createNodeJsRelay =
       });
 
       wss.close(() => {
-        deps.console.log("Evolu Relay disposed");
+        log.webSocketServerDisposed();
+      });
+
+      server.close(() => {
+        log.httpServerDisposed();
       });
     };
 
     let isDisposed = false;
 
-    return {
+    const relay: Relay = {
       [Symbol.dispose]: () => {
         if (isDisposed) return;
         isDisposed = true;
-        sqlite[Symbol.dispose]();
-        disposeWss();
+        sqlite.value[Symbol.dispose]();
+        dispose();
       },
     };
+
+    return ok(relay);
   };