@graffy/server 0.18.1-alpha.2 → 0.19.1-alpha.1

package/{types/httpServer.d.ts → httpServer.d.ts}

@@ -12,8 +12,6 @@
  *   from the client-supplied options before use. Defaults to `[]` (strip all).
  * @returns
  */
-export default function server(store: GraffyStore, { auth, allowedOptions }?: {
-    auth?: (operation: string, payload: any, options: any) => Promise<boolean>;
-    allowedOptions?: string[];
+export default function server(store: any, { auth, allowedOptions }?: {
+    allowedOptions?: any[];
 }): (req: any, res: any) => Promise<void>;
-export type GraffyStore = import("@graffy/core").default;

package/httpServer.js

@@ -0,0 +1,131 @@
+import url from 'node:url';
+import { decodeGraph, decodeQuery, pack, unpack } from '@graffy/common';
+import debug from 'debug';
+const log = debug('graffy:server:http');
+/**
+ * @typedef {import('@graffy/core').default} GraffyStore
+ * @param {GraffyStore} store
+ * @param {object} [options]
+ * @param {(operation: string, payload: any, options: any) => Promise<boolean>} [options.auth]
+ *   Optional callback to authorize each request. Receives the operation name,
+ *   decoded payload, and the filtered options. Return `true` to allow, `false`
+ *   (or a rejected promise) to reject with 401.
+ * @param {string[]} [options.allowedOptions]
+ *   Allowlist of option keys that clients are permitted to pass through to
+ *   `store.call` and the `auth` callback. Any key not in this list is stripped
+ *   from the client-supplied options before use. Defaults to `[]` (strip all).
+ * @returns
+ */
+export default function server(store, { auth, allowedOptions = [] } = {}) {
+    if (!store)
+        throw new Error('server.store_undef');
+    return async (req, res) => {
+        const parsed = url.parse(req.url, true);
+        const optParam = parsed.query.opts && String(parsed.query.opts);
+        const rawOptions = optParam && JSON.parse(decodeURIComponent(optParam));
+        const safeOptions = Object.fromEntries(Object.entries(rawOptions || {}).filter(([k]) => allowedOptions.includes(k)));
+        if (req.method === 'GET') {
+            try {
+                const qParam = parsed.query.q && String(parsed.query.q);
+                const query = qParam && unpack(JSON.parse(decodeURIComponent(qParam)));
+                if (req.headers.accept === 'text/event-stream') {
+                    if (auth && !(await auth('watch', decodeQuery(query), safeOptions))) {
+                        const body = 'unauthorized';
+                        res.writeHead(401, {
+                            'Content-Type': 'text/plain',
+                            'Content-Length': Buffer.byteLength(body),
+                        });
+                        res.end(body);
+                        return;
+                    }
+                    res.setHeader('content-type', 'text/event-stream');
+                    const keepAlive = setInterval(() => {
+                        if (req.aborted || res.finished) {
+                            clearInterval(keepAlive);
+                            return;
+                        }
+                        res.write(': \n\n');
+                    }, 29000);
+                    // TODO: Resumable subscriptions using timestamp ID.
+                    // const lastId = req.headers['last-event-id'];
+                    try {
+                        const stream = store.call('watch', query, {
+                            ...safeOptions,
+                            raw: true,
+                        });
+                        for await (const value of stream) {
+                            if (req.aborted || res.finished)
+                                break;
+                            res.write(`data: ${JSON.stringify(pack(value))}\n\n`);
+                        }
+                    }
+                    catch (e) {
+                        log(e);
+                        res.write(`event: graffyerror\ndata: ${e.message}\n\n`);
+                    }
+                    res.end();
+                }
+                else {
+                    throw Error('httpServer.get_unsupported');
+                }
+            }
+            catch (e) {
+                log(e.message);
+                log(e.stack);
+                const body = `${e.message}`;
+                res.writeHead(400, {
+                    'Content-Type': 'text/plain',
+                    'Content-Length': Buffer.byteLength(body),
+                });
+                res.end(body);
+            }
+        }
+        else if (req.method === 'POST') {
+            try {
+                const op = parsed.query.op;
+                if (op !== 'write' && op !== 'read') {
+                    throw Error('httpServer.unsupported_op');
+                }
+                const chunks = [];
+                for await (const chunk of req)
+                    chunks.push(chunk);
+                const payload = unpack(JSON.parse(Buffer.concat(chunks).toString()));
+                if (auth &&
+                    !(await auth(op, (op === 'write' ? decodeGraph : decodeQuery)(payload), safeOptions))) {
+                    const body = 'unauthorized';
+                    res.writeHead(401, {
+                        'Content-Type': 'text/plain',
+                        'Content-Length': Buffer.byteLength(body),
+                    });
+                    res.end(body);
+                    return;
+                }
+                const value = await store.call(op, payload, safeOptions);
+                const body = JSON.stringify(pack(value));
+                res.writeHead(200, {
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(body),
+                });
+                res.end(body);
+            }
+            catch (e) {
+                log(e.message);
+                log(e.stack);
+                const body = `${e.message}`;
+                res.writeHead(400, {
+                    'Content-Type': 'text/plain',
+                    'Content-Length': Buffer.byteLength(body),
+                });
+                res.end(body);
+            }
+        }
+        else {
+            const body = 'Not implemented';
+            res.writeHead(501, {
+                'Content-Type': 'text/plain',
+                'Content-Length': Buffer.byteLength(body),
+            });
+            res.end(body);
+        }
+    };
+}

package/index.d.ts

@@ -0,0 +1,2 @@
+export { default as httpServer } from './httpServer.js';
+export { default as wsServer } from './wsServer.js';

package/package.json

@@ -2,21 +2,26 @@
   "name": "@graffy/server",
   "description": "Node.js library for building an API for a Graffy store.",
   "author": "aravind (https://github.com/aravindet)",
-  "version": "0.18.1-alpha.2",
-  "main": "./index.cjs",
+  "version": "0.19.1-alpha.1",
+  "main": "./cjs/index.js",
   "exports": {
-    "import": "./index.mjs",
-    "require": "./index.cjs"
+    ".": {
+      "import": "./index.js",
+      "types": "./index.d.ts"
+    },
+    "./*": {
+      "import": "./*.js",
+      "types": "./*.d.ts"
+    }
   },
-  "module": "./index.mjs",
-  "types": "./types/index.d.ts",
+  "types": "./index.d.ts",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/usegraffy/graffy.git"
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@graffy/common": "0.18.1-alpha.2",
+    "@graffy/common": "0.19.1-alpha.1",
     "debug": "^4.4.3",
     "ws": "^8.19.0"
   }

package/{types/wsServer.d.ts → wsServer.d.ts}

@@ -12,8 +12,6 @@
  *   from the client-supplied options before use. Defaults to `[]` (strip all).
  * @returns
  */
-export default function server(store: GraffyStore, { auth, allowedOptions }?: {
-    auth?: (operation: string, payload: any, options: any) => Promise<boolean>;
-    allowedOptions?: string[];
+export default function server(store: any, { auth, allowedOptions }?: {
+    allowedOptions?: any[];
 }): (request: any, socket: any, head: any) => Promise<void>;
-export type GraffyStore = import("@graffy/core").default;

package/wsServer.js

@@ -0,0 +1,105 @@
+import { decodeGraph, decodeQuery, pack, unpack } from '@graffy/common';
+import debug from 'debug';
+import { WebSocketServer } from 'ws';
+const log = debug('graffy:server:ws');
+const PING_INTERVAL = 30000;
+/**
+ * @typedef {import('@graffy/core').default} GraffyStore
+ * @param {GraffyStore} store
+ * @param {object} [options]
+ * @param {(operation: string, payload: any, options: any) => Promise<boolean>} [options.auth]
+ *   Optional callback to authorize each request. Receives the operation name,
+ *   decoded payload, and the filtered options. Return `true` to allow, `false`
+ *   (or a rejected promise) to reject with an error response.
+ * @param {string[]} [options.allowedOptions]
+ *   Allowlist of option keys that clients are permitted to pass through to
+ *   `store.call` and the `auth` callback. Any key not in this list is stripped
+ *   from the client-supplied options before use. Defaults to `[]` (strip all).
+ * @returns
+ */
+export default function server(store, { auth, allowedOptions = [] } = {}) {
+    if (!store)
+        throw new Error('server.store_undef');
+    const wss = new WebSocketServer({ noServer: true });
+    wss.on('connection', function connection(ws) {
+        ws.graffyStreams = {}; // We use this to keep track of streams to close.
+        ws.on('message', async function message(msg) {
+            try {
+                const [id, op, packedPayload, rawOptions] = JSON.parse(msg);
+                const safeOptions = Object.fromEntries(Object.entries(rawOptions || {}).filter(([k]) => allowedOptions.includes(k)));
+                const payload = unpack(packedPayload);
+                if (id === ':pong') {
+                    ws.pingPending = false;
+                    return;
+                }
+                if (auth && op !== 'unwatch') {
+                    const decoded = op === 'write' ? decodeGraph(payload) : decodeQuery(payload);
+                    if (!(await auth(op, decoded, safeOptions))) {
+                        ws.send(JSON.stringify([id, 'unauthorized']));
+                        return;
+                    }
+                }
+                switch (op) {
+                    case 'read':
+                    case 'write':
+                        try {
+                            const result = await store.call(op, payload, safeOptions);
+                            ws.send(JSON.stringify([id, null, pack(result)]));
+                        }
+                        catch (e) {
+                            log(`${op}error:${e.message} ${payload}`);
+                            ws.send(JSON.stringify([id, e.message]));
+                        }
+                        break;
+                    case 'watch':
+                        try {
+                            const stream = store.call('watch', payload, {
+                                ...safeOptions,
+                                raw: true,
+                            });
+                            ws.graffyStreams[id] = stream;
+                            for await (const value of stream) {
+                                ws.send(JSON.stringify([id, null, pack(value)]));
+                            }
+                        }
+                        catch (e) {
+                            log(`${op}error:${e.message} ${payload}`);
+                            ws.send(JSON.stringify([id, e.message]));
+                        }
+                        break;
+                    case 'unwatch':
+                        if (!ws.graffyStreams[id])
+                            break;
+                        ws.graffyStreams[id].return();
+                        delete ws.graffyStreams[id];
+                        break;
+                }
+            }
+            catch (e) {
+                log(`Closing socket due to error: ${e.message}`);
+                ws.close();
+            }
+        });
+        ws.on('close', () => {
+            for (const id in ws.graffyStreams) {
+                ws.graffyStreams[id].return();
+                delete ws.graffyStreams[id];
+            }
+        });
+    });
+    setInterval(function ping() {
+        wss.clients.forEach(function each(ws) {
+            if (ws.pingPending) {
+                ws.terminate();
+                return;
+            }
+            ws.pingPending = true;
+            ws.send(JSON.stringify([':ping', Date.now()]));
+        });
+    }, PING_INTERVAL);
+    return async (request, socket, head) => {
+        wss.handleUpgrade(request, socket, head, function done(ws) {
+            wss.emit('connection', ws, request);
+        });
+    };
+}

package/index.cjs

@@ -1,210 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const url = require("node:url");
-const common = require("@graffy/common");
-const debug = require("debug");
-const ws = require("ws");
-const log$1 = debug("graffy:server:http");
-function server$1(store, { auth, allowedOptions = [] } = {}) {
-  if (!store) throw new Error("server.store_undef");
-  return async (req, res) => {
-    const parsed = url.parse(req.url, true);
-    const optParam = parsed.query.opts && String(parsed.query.opts);
-    const rawOptions = optParam && JSON.parse(decodeURIComponent(optParam));
-    const safeOptions = Object.fromEntries(
-      Object.entries(rawOptions || {}).filter(
-        ([k]) => allowedOptions.includes(k)
-      )
-    );
-    if (req.method === "GET") {
-      try {
-        const qParam = parsed.query.q && String(parsed.query.q);
-        const query = qParam && common.unpack(JSON.parse(decodeURIComponent(qParam)));
-        if (req.headers.accept === "text/event-stream") {
-          if (auth && !await auth("watch", common.decodeQuery(query), safeOptions)) {
-            const body = "unauthorized";
-            res.writeHead(401, {
-              "Content-Type": "text/plain",
-              "Content-Length": Buffer.byteLength(body)
-            });
-            res.end(body);
-            return;
-          }
-          res.setHeader("content-type", "text/event-stream");
-          const keepAlive = setInterval(() => {
-            if (req.aborted || res.finished) {
-              clearInterval(keepAlive);
-              return;
-            }
-            res.write(": \n\n");
-          }, 29e3);
-          try {
-            const stream = store.call("watch", query, {
-              ...safeOptions,
-              raw: true
-            });
-            for await (const value of stream) {
-              if (req.aborted || res.finished) break;
-              res.write(`data: ${JSON.stringify(common.pack(value))}
-
-`);
-            }
-          } catch (e) {
-            log$1(e);
-            res.write(`event: graffyerror
-data: ${e.message}
-
-`);
-          }
-          res.end();
-        } else {
-          throw Error("httpServer.get_unsupported");
-        }
-      } catch (e) {
-        log$1(e.message);
-        log$1(e.stack);
-        const body = `${e.message}`;
-        res.writeHead(400, {
-          "Content-Type": "text/plain",
-          "Content-Length": Buffer.byteLength(body)
-        });
-        res.end(body);
-      }
-    } else if (req.method === "POST") {
-      try {
-        const op = parsed.query.op;
-        if (op !== "write" && op !== "read") {
-          throw Error("httpServer.unsupported_op");
-        }
-        const chunks = [];
-        for await (const chunk of req) chunks.push(chunk);
-        const payload = common.unpack(JSON.parse(Buffer.concat(chunks).toString()));
-        if (auth && !await auth(
-          op,
-          (op === "write" ? common.decodeGraph : common.decodeQuery)(payload),
-          safeOptions
-        )) {
-          const body2 = "unauthorized";
-          res.writeHead(401, {
-            "Content-Type": "text/plain",
-            "Content-Length": Buffer.byteLength(body2)
-          });
-          res.end(body2);
-          return;
-        }
-        const value = await store.call(op, payload, safeOptions);
-        const body = JSON.stringify(common.pack(value));
-        res.writeHead(200, {
-          "Content-Type": "application/json",
-          "Content-Length": Buffer.byteLength(body)
-        });
-        res.end(body);
-      } catch (e) {
-        log$1(e.message);
-        log$1(e.stack);
-        const body = `${e.message}`;
-        res.writeHead(400, {
-          "Content-Type": "text/plain",
-          "Content-Length": Buffer.byteLength(body)
-        });
-        res.end(body);
-      }
-    } else {
-      const body = "Not implemented";
-      res.writeHead(501, {
-        "Content-Type": "text/plain",
-        "Content-Length": Buffer.byteLength(body)
-      });
-      res.end(body);
-    }
-  };
-}
-const log = debug("graffy:server:ws");
-const PING_INTERVAL = 3e4;
-function server(store, { auth, allowedOptions = [] } = {}) {
-  if (!store) throw new Error("server.store_undef");
-  const wss = new ws.WebSocketServer({ noServer: true });
-  wss.on("connection", function connection(ws2) {
-    ws2.graffyStreams = {};
-    ws2.on("message", async function message(msg) {
-      try {
-        const [id, op, packedPayload, rawOptions] = JSON.parse(msg);
-        const safeOptions = Object.fromEntries(
-          Object.entries(rawOptions || {}).filter(
-            ([k]) => allowedOptions.includes(k)
-          )
-        );
-        const payload = common.unpack(packedPayload);
-        if (id === ":pong") {
-          ws2.pingPending = false;
-          return;
-        }
-        if (auth && op !== "unwatch") {
-          const decoded = op === "write" ? common.decodeGraph(payload) : common.decodeQuery(payload);
-          if (!await auth(op, decoded, safeOptions)) {
-            ws2.send(JSON.stringify([id, "unauthorized"]));
-            return;
-          }
-        }
-        switch (op) {
-          case "read":
-          case "write":
-            try {
-              const result = await store.call(op, payload, safeOptions);
-              ws2.send(JSON.stringify([id, null, common.pack(result)]));
-            } catch (e) {
-              log(`${op}error:${e.message} ${payload}`);
-              ws2.send(JSON.stringify([id, e.message]));
-            }
-            break;
-          case "watch":
-            try {
-              const stream = store.call("watch", payload, {
-                ...safeOptions,
-                raw: true
-              });
-              ws2.graffyStreams[id] = stream;
-              for await (const value of stream) {
-                ws2.send(JSON.stringify([id, null, common.pack(value)]));
-              }
-            } catch (e) {
-              log(`${op}error:${e.message} ${payload}`);
-              ws2.send(JSON.stringify([id, e.message]));
-            }
-            break;
-          case "unwatch":
-            if (!ws2.graffyStreams[id]) break;
-            ws2.graffyStreams[id].return();
-            delete ws2.graffyStreams[id];
-            break;
-        }
-      } catch (e) {
-        log(`Closing socket due to error: ${e.message}`);
-        ws2.close();
-      }
-    });
-    ws2.on("close", () => {
-      for (const id in ws2.graffyStreams) {
-        ws2.graffyStreams[id].return();
-        delete ws2.graffyStreams[id];
-      }
-    });
-  });
-  setInterval(function ping() {
-    wss.clients.forEach(function each(ws2) {
-      if (ws2.pingPending) {
-        ws2.terminate();
-        return;
-      }
-      ws2.pingPending = true;
-      ws2.send(JSON.stringify([":ping", Date.now()]));
-    });
-  }, PING_INTERVAL);
-  return async (request, socket, head) => {
-    wss.handleUpgrade(request, socket, head, function done(ws2) {
-      wss.emit("connection", ws2, request);
-    });
-  };
-}
-exports.httpServer = server$1;
-exports.wsServer = server;

package/index.mjs

@@ -1,210 +0,0 @@
-import url from "node:url";
-import { unpack, decodeQuery, pack, decodeGraph } from "@graffy/common";
-import debug from "debug";
-import { WebSocketServer } from "ws";
-const log$1 = debug("graffy:server:http");
-function server$1(store, { auth, allowedOptions = [] } = {}) {
-  if (!store) throw new Error("server.store_undef");
-  return async (req, res) => {
-    const parsed = url.parse(req.url, true);
-    const optParam = parsed.query.opts && String(parsed.query.opts);
-    const rawOptions = optParam && JSON.parse(decodeURIComponent(optParam));
-    const safeOptions = Object.fromEntries(
-      Object.entries(rawOptions || {}).filter(
-        ([k]) => allowedOptions.includes(k)
-      )
-    );
-    if (req.method === "GET") {
-      try {
-        const qParam = parsed.query.q && String(parsed.query.q);
-        const query = qParam && unpack(JSON.parse(decodeURIComponent(qParam)));
-        if (req.headers.accept === "text/event-stream") {
-          if (auth && !await auth("watch", decodeQuery(query), safeOptions)) {
-            const body = "unauthorized";
-            res.writeHead(401, {
-              "Content-Type": "text/plain",
-              "Content-Length": Buffer.byteLength(body)
-            });
-            res.end(body);
-            return;
-          }
-          res.setHeader("content-type", "text/event-stream");
-          const keepAlive = setInterval(() => {
-            if (req.aborted || res.finished) {
-              clearInterval(keepAlive);
-              return;
-            }
-            res.write(": \n\n");
-          }, 29e3);
-          try {
-            const stream = store.call("watch", query, {
-              ...safeOptions,
-              raw: true
-            });
-            for await (const value of stream) {
-              if (req.aborted || res.finished) break;
-              res.write(`data: ${JSON.stringify(pack(value))}
-
-`);
-            }
-          } catch (e) {
-            log$1(e);
-            res.write(`event: graffyerror
-data: ${e.message}
-
-`);
-          }
-          res.end();
-        } else {
-          throw Error("httpServer.get_unsupported");
-        }
-      } catch (e) {
-        log$1(e.message);
-        log$1(e.stack);
-        const body = `${e.message}`;
-        res.writeHead(400, {
-          "Content-Type": "text/plain",
-          "Content-Length": Buffer.byteLength(body)
-        });
-        res.end(body);
-      }
-    } else if (req.method === "POST") {
-      try {
-        const op = parsed.query.op;
-        if (op !== "write" && op !== "read") {
-          throw Error("httpServer.unsupported_op");
-        }
-        const chunks = [];
-        for await (const chunk of req) chunks.push(chunk);
-        const payload = unpack(JSON.parse(Buffer.concat(chunks).toString()));
-        if (auth && !await auth(
-          op,
-          (op === "write" ? decodeGraph : decodeQuery)(payload),
-          safeOptions
-        )) {
-          const body2 = "unauthorized";
-          res.writeHead(401, {
-            "Content-Type": "text/plain",
-            "Content-Length": Buffer.byteLength(body2)
-          });
-          res.end(body2);
-          return;
-        }
-        const value = await store.call(op, payload, safeOptions);
-        const body = JSON.stringify(pack(value));
-        res.writeHead(200, {
-          "Content-Type": "application/json",
-          "Content-Length": Buffer.byteLength(body)
-        });
-        res.end(body);
-      } catch (e) {
-        log$1(e.message);
-        log$1(e.stack);
-        const body = `${e.message}`;
-        res.writeHead(400, {
-          "Content-Type": "text/plain",
-          "Content-Length": Buffer.byteLength(body)
-        });
-        res.end(body);
-      }
-    } else {
-      const body = "Not implemented";
-      res.writeHead(501, {
-        "Content-Type": "text/plain",
-        "Content-Length": Buffer.byteLength(body)
-      });
-      res.end(body);
-    }
-  };
-}
-const log = debug("graffy:server:ws");
-const PING_INTERVAL = 3e4;
-function server(store, { auth, allowedOptions = [] } = {}) {
-  if (!store) throw new Error("server.store_undef");
-  const wss = new WebSocketServer({ noServer: true });
-  wss.on("connection", function connection(ws) {
-    ws.graffyStreams = {};
-    ws.on("message", async function message(msg) {
-      try {
-        const [id, op, packedPayload, rawOptions] = JSON.parse(msg);
-        const safeOptions = Object.fromEntries(
-          Object.entries(rawOptions || {}).filter(
-            ([k]) => allowedOptions.includes(k)
-          )
-        );
-        const payload = unpack(packedPayload);
-        if (id === ":pong") {
-          ws.pingPending = false;
-          return;
-        }
-        if (auth && op !== "unwatch") {
-          const decoded = op === "write" ? decodeGraph(payload) : decodeQuery(payload);
-          if (!await auth(op, decoded, safeOptions)) {
-            ws.send(JSON.stringify([id, "unauthorized"]));
-            return;
-          }
-        }
-        switch (op) {
-          case "read":
-          case "write":
-            try {
-              const result = await store.call(op, payload, safeOptions);
-              ws.send(JSON.stringify([id, null, pack(result)]));
-            } catch (e) {
-              log(`${op}error:${e.message} ${payload}`);
-              ws.send(JSON.stringify([id, e.message]));
-            }
-            break;
-          case "watch":
-            try {
-              const stream = store.call("watch", payload, {
-                ...safeOptions,
-                raw: true
-              });
-              ws.graffyStreams[id] = stream;
-              for await (const value of stream) {
-                ws.send(JSON.stringify([id, null, pack(value)]));
-              }
-            } catch (e) {
-              log(`${op}error:${e.message} ${payload}`);
-              ws.send(JSON.stringify([id, e.message]));
-            }
-            break;
-          case "unwatch":
-            if (!ws.graffyStreams[id]) break;
-            ws.graffyStreams[id].return();
-            delete ws.graffyStreams[id];
-            break;
-        }
-      } catch (e) {
-        log(`Closing socket due to error: ${e.message}`);
-        ws.close();
-      }
-    });
-    ws.on("close", () => {
-      for (const id in ws.graffyStreams) {
-        ws.graffyStreams[id].return();
-        delete ws.graffyStreams[id];
-      }
-    });
-  });
-  setInterval(function ping() {
-    wss.clients.forEach(function each(ws) {
-      if (ws.pingPending) {
-        ws.terminate();
-        return;
-      }
-      ws.pingPending = true;
-      ws.send(JSON.stringify([":ping", Date.now()]));
-    });
-  }, PING_INTERVAL);
-  return async (request, socket, head) => {
-    wss.handleUpgrade(request, socket, head, function done(ws) {
-      wss.emit("connection", ws, request);
-    });
-  };
-}
-export {
-  server$1 as httpServer,
-  server as wsServer
-};