mushroomdb-client 0.1.2

package/dist/ws.js

@@ -0,0 +1,139 @@
+/**
+ * WebSocket subscription over `GET /subscribe`.
+ *
+ * # Protocol (matches crates/server/src/subscribe.rs)
+ *
+ * 1. Connect to `ws[s]://<host>/subscribe`.
+ * 2. Server waits for one JSON subscribe message: `{rules?, writes?}`.
+ * 3. Server responds with `{"subscribed":true}`.
+ * 4. Server streams DbEvent JSON frames until the connection closes.
+ *
+ * # Reconnection
+ *
+ * Auto-reconnect is NOT implemented in v1. When the connection drops
+ * (network error, server restart), no further events are delivered. The
+ * caller is responsible for reconnecting if required.
+ *
+ * # Lagged events
+ *
+ * If the server's per-subscriber queue overflows, it emits a
+ * `{"type":"lagged","missed":N}` frame. This is passed to `onEvent` like any
+ * other event. For lossless consumers: on receiving a `lagged` event, re-read
+ * the affected graph state via a query.
+ *
+ * # Node.js usage
+ *
+ * The browser WebSocket global is not present in Node < 21. Pass the `ws`
+ * package's WebSocket class via `opts.wsConstructor`:
+ *
+ * ```ts
+ * import WS from 'ws';
+ * const handle = await subscribe(wsUrl, { writes: true, wsConstructor: WS as WsConstructor }, onEvent);
+ * ```
+ */
+import { MushroomError } from "./types.js";
+/** Coerce an unknown message `data` value to a UTF-8 string. */
+function dataToString(data) {
+    if (typeof data === "string")
+        return data;
+    // Node.js ws package delivers Buffer objects for text frames.
+    if (data != null && typeof data.toString === "function") {
+        return data.toString();
+    }
+    return String(data);
+}
+/** Resolve the WebSocket constructor: explicit option → global. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function resolveWsConstructor(opt) {
+    if (opt)
+        return opt;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const g = globalThis;
+    if (typeof g["WebSocket"] === "function")
+        return g["WebSocket"];
+    throw new Error("No WebSocket implementation available. " +
+        "In Node.js < 21, install the `ws` package and pass " +
+        "`wsConstructor: WS as WsConstructor` in the options.");
+}
+/**
+ * Open a `GET /subscribe` WebSocket and begin streaming {@link DbEvent}s.
+ *
+ * Resolves when the server acknowledges the subscribe message
+ * (`{"subscribed":true}`). Rejects on connection failure or if the server
+ * returns an error (e.g. unknown rule name).
+ *
+ * @param wsUrl   Full WebSocket URL, e.g. `ws://127.0.0.1:8080/subscribe`.
+ * @param opts    Subscribe options — rules, writes flag, optional wsConstructor.
+ * @param onEvent Callback invoked for each {@link DbEvent}, including `lagged`.
+ */
+export async function subscribe(wsUrl, opts, onEvent) {
+    const WS = resolveWsConstructor(opts.wsConstructor);
+    const ws = new WS(wsUrl);
+    return new Promise((resolve, reject) => {
+        let subscribed = false;
+        let closeResolve = null;
+        const closePromise = new Promise((res) => {
+            closeResolve = res;
+        });
+        ws.onopen = () => {
+            const msg = {
+                rules: opts.rules ?? [],
+                writes: opts.writes ?? false,
+            };
+            ws.send(JSON.stringify(msg));
+        };
+        ws.onmessage = (ev) => {
+            let text;
+            try {
+                text = dataToString(ev.data);
+            }
+            catch {
+                return; // unreadable frame — skip
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch {
+                return; // unparseable frame — skip
+            }
+            const frame = parsed;
+            if (!subscribed) {
+                if (frame["subscribed"] === true) {
+                    subscribed = true;
+                    resolve({
+                        close() {
+                            ws.close();
+                            return closePromise;
+                        },
+                    });
+                }
+                else if (typeof frame["error"] === "string") {
+                    reject(new MushroomError(frame["error"]));
+                    ws.close();
+                }
+                else {
+                    reject(new Error("Unexpected subscribe response: " + text));
+                    ws.close();
+                }
+            }
+            else {
+                onEvent(frame);
+            }
+        };
+        ws.onerror = (err) => {
+            if (!subscribed) {
+                reject(err instanceof Error
+                    ? err
+                    : new Error("WebSocket error before subscribe ack"));
+            }
+        };
+        ws.onclose = () => {
+            if (!subscribed) {
+                reject(new Error("WebSocket closed before subscribe ack"));
+            }
+            closeResolve?.();
+        };
+    });
+}
+//# sourceMappingURL=ws.js.map

package/dist/ws.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ws.js","sourceRoot":"","sources":["../src/ws.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "mushroomdb-client",
+  "version": "0.1.2",
+  "description": "TypeScript client for the mushroomdb graph database HTTP + WebSocket API",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MatthewSherlin/mushroomdb"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/ws": "^8.5.12",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10",
+    "ws": "^8.18.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/client.ts

@@ -0,0 +1,364 @@
+/**
+ * HTTP client for the mushroomdb server.
+ *
+ * Uses the browser-standard `fetch` API (built into Node 18+).
+ *
+ * ```ts
+ * import { MushroomClient } from 'mushroomdb-client';
+ *
+ * const client = new MushroomClient('http://127.0.0.1:8080');
+ * const result = await client.query('MATCH (n:Person) RETURN n.name LIMIT 10');
+ * console.log(result.columns, result.rows);
+ * ```
+ */
+
+import {
+  MushroomError,
+  type AlgoReport,
+  type DegreeConfig,
+  type DegreeReport,
+  type Explanation,
+  type IngestReport,
+  type IngestRequest,
+  type Neighborhood,
+  type NodeInfo,
+  type PageRankConfig,
+  type PageRankReport,
+  type QueryResult,
+  type RuleDef,
+  type Stats,
+  type SuggestReport,
+  type WccConfig,
+  type WccReport,
+} from "./types.js";
+import {
+  subscribe as wsSubscribe,
+  type SubscribeHandle,
+  type SubscribeOptions,
+  type WsConstructor,
+} from "./ws.js";
+
+export type {
+  AlgoDir,
+  AlgoReport,
+  CellValue,
+  DegreeConfig,
+  DegreeReport,
+  Explanation,
+  IngestEdge,
+  IngestOptions,
+  IngestReport,
+  IngestRequest,
+  Neighborhood,
+  NodeInfo,
+  PageRankConfig,
+  PageRankReport,
+  PredicateKind,
+  PredicateSummary,
+  QueryResult,
+  RuleDef,
+  RulePredicate,
+  RuleStats,
+  RuleSuggestion,
+  Stats,
+  SuggestReport,
+  WccConfig,
+  WccReport,
+} from "./types.js";
+export { MushroomError };
+
+/** Optional constructor flags for {@link MushroomClient}. */
+export interface ClientOptions {
+  /**
+   * When set, sent as `Authorization: Bearer <token>` on every HTTP fetch.
+   * Cookie auth is a browser/explorer concern and is not implemented here.
+   */
+  token?: string;
+}
+
+/** Parameters for a Cypher query. Values must be JSON scalars. */
+export type QueryParams = Record<string, string | number | boolean>;
+
+/** Options accepted by {@link MushroomClient.query}. */
+export interface QueryOptions {
+  /** Bound parameters. Values must be JSON scalars (string | number | boolean). */
+  params?: QueryParams;
+}
+
+/**
+ * HTTP + WebSocket client for mushroomdb.
+ *
+ * All methods use the browser-standard `fetch` API and are therefore
+ * compatible with both Node.js 18+ and modern browsers.
+ *
+ * **Node-only**: The `subscribe` method requires a WebSocket implementation.
+ * In Node < 21, install the `ws` package and pass `wsConstructor` in the
+ * subscribe options. See {@link SubscribeOptions}.
+ */
+export class MushroomClient {
+  private readonly baseUrl: string;
+  private readonly wsBase: string;
+  private readonly token: string | undefined;
+
+  /**
+   * @param baseUrl  HTTP base URL of the mushroomdb server, e.g.
+   *                 `"http://127.0.0.1:8080"`. Trailing slash is stripped.
+   * @param opts     Optional `{ token }` — sent as `Authorization: Bearer`.
+   */
+  constructor(baseUrl: string, opts?: ClientOptions) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.wsBase = this.baseUrl.replace(/^http/, "ws");
+    this.token = opts?.token;
+  }
+
+  // -------------------------------------------------------------------------
+  // Internal helpers
+  // -------------------------------------------------------------------------
+
+  private url(path: string): string {
+    return `${this.baseUrl}${path}`;
+  }
+
+  private wsUrl(path: string): string {
+    return `${this.wsBase}${path}`;
+  }
+
+  private authHeaders(): Record<string, string> {
+    return this.token ? { Authorization: `Bearer ${this.token}` } : {};
+  }
+
+  /**
+   * Execute a fetch and decode the JSON body.
+   * Throws {@link MushroomError} on non-2xx responses.
+   */
+  private async fetchJson<T>(
+    path: string,
+    init?: RequestInit,
+  ): Promise<T> {
+    const resp = await fetch(this.url(path), {
+      ...init,
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        ...this.authHeaders(),
+        ...(init?.headers ?? {}),
+      },
+    });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const body: any = await resp.json();
+    if (!resp.ok) {
+      const detail: string =
+        typeof body?.error === "string" ? body.error : `HTTP ${resp.status}`;
+      throw new MushroomError(detail);
+    }
+    return body as T;
+  }
+
+  // -------------------------------------------------------------------------
+  // HTTP endpoints
+  // -------------------------------------------------------------------------
+
+  /**
+   * Run a Cypher query (read or write).
+   *
+   * The server auto-detects write statements (`CREATE`, `MERGE`, `SET`,
+   * `DELETE`) and acquires the appropriate lock. Both read and write queries
+   * go to `POST /query?format=json`.
+   *
+   * @param cypher Cypher query string.
+   * @param opts   Optional bound parameters (JSON scalar values only).
+   * @returns      Column names and a 2-D array of {@link CellValue} rows.
+   */
+  async query(cypher: string, opts?: QueryOptions): Promise<QueryResult> {
+    return this.fetchJson<QueryResult>("/query?format=json", {
+      method: "POST",
+      body: JSON.stringify({
+        cypher,
+        ...(opts?.params ? { params: opts.params } : {}),
+      }),
+    });
+  }
+
+  /**
+   * Ingest nodes (and optional edges) into the database.
+   *
+   * Wraps `POST /ingest`. The server acquires the write lock, applies the
+   * rows to the WAL, and runs all rules incrementally.
+   *
+   * @param req  Ingest payload — `label`, `rows`, optional `options` and `edges`.
+   * @returns    Server ingest report (opaque; check for absence of errors).
+   */
+  async ingest(req: IngestRequest): Promise<IngestReport> {
+    return this.fetchJson<IngestReport>("/ingest", {
+      method: "POST",
+      body: JSON.stringify(req),
+    });
+  }
+
+  /**
+   * Get database-wide statistics.
+   *
+   * Wraps `GET /stats`. Returns live node/edge counts and per-rule stats.
+   */
+  async stats(): Promise<Stats> {
+    return this.fetchJson<Stats>("/stats");
+  }
+
+  /**
+   * Profile the database and return rule suggestions.
+   *
+   * Wraps `GET /suggest`. CPU-intensive — runs in the server's blocking
+   * thread-pool with a 5-second global budget. The {@link SuggestReport}
+   * includes a `truncated` flag when the budget fires early.
+   *
+   * Suggestions are not auto-applied; call `POST /rules` to create a rule.
+   */
+  async suggest(): Promise<SuggestReport> {
+    return this.fetchJson<SuggestReport>("/suggest");
+  }
+
+  /**
+   * Run a graph algorithm.
+   *
+   * Wraps `POST /algo/{pagerank|wcc|degree}`.
+   *
+   * @param algo   Algorithm name.
+   * @param config Optional algorithm-specific configuration.
+   * @returns      Algorithm report — see {@link PageRankReport}, {@link WccReport},
+   *               {@link DegreeReport}.
+   *
+   * @example
+   * ```ts
+   * const pr = await client.algo('pagerank') as PageRankReport;
+   * console.log(pr.scores.slice(0, 5));
+   * ```
+   */
+  async algo(algo: "pagerank", config?: PageRankConfig): Promise<PageRankReport>;
+  async algo(algo: "wcc", config?: WccConfig): Promise<WccReport>;
+  async algo(algo: "degree", config?: DegreeConfig): Promise<DegreeReport>;
+  async algo(
+    algo: "pagerank" | "wcc" | "degree",
+    config?: PageRankConfig | WccConfig | DegreeConfig,
+  ): Promise<AlgoReport> {
+    // The server structs carry #[serde(default)], so sending only the fields
+    // the caller explicitly set (or an empty body {}) is valid — the server
+    // fills in its own defaults for any missing fields.
+    return this.fetchJson<AlgoReport>(`/algo/${algo}`, {
+      method: "POST",
+      body: JSON.stringify(config ?? {}),
+    });
+  }
+
+  /**
+   * Explain rule-derived edges between two node keys.
+   *
+   * Wraps `GET /explain?a=&b=`.
+   */
+  async explain(a: string, b: string): Promise<Explanation[]> {
+    const qs = new URLSearchParams({ a, b });
+    return this.fetchJson<Explanation[]>(`/explain?${qs.toString()}`);
+  }
+
+  /**
+   * Create a derivation rule.
+   *
+   * Wraps `POST /rules`. The server acquires the write lock, validates the
+   * {@link RuleDef}, and backfills matching pairs.
+   */
+  async createRule(def: RuleDef): Promise<void> {
+    await this.fetchJson("/rules", {
+      method: "POST",
+      body: JSON.stringify(def),
+    });
+  }
+
+  /**
+   * Fetch a node by key.
+   *
+   * Wraps `GET /node/{key}`. Returns `null` when the server answers 404
+   * (unknown key). Other HTTP errors throw {@link MushroomError}.
+   */
+  async node(key: string): Promise<NodeInfo | null> {
+    const resp = await fetch(this.url(`/node/${encodeURIComponent(key)}`), {
+      headers: {
+        Accept: "application/json",
+        ...this.authHeaders(),
+      },
+    });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const body: any = await resp.json();
+    if (resp.status === 404) {
+      return null;
+    }
+    if (!resp.ok) {
+      const detail: string =
+        typeof body?.error === "string" ? body.error : `HTTP ${resp.status}`;
+      throw new MushroomError(detail);
+    }
+    return body as NodeInfo;
+  }
+
+  /**
+   * Depth-N neighborhood of a node.
+   *
+   * Wraps `GET /node/{key}/neighborhood`. Default depth is the server's
+   * (1). Columns are `key`, `label`, `depth`.
+   */
+  async neighborhood(
+    key: string,
+    opts?: { depth?: number },
+  ): Promise<Neighborhood> {
+    const qs = new URLSearchParams();
+    if (opts?.depth !== undefined) {
+      qs.set("depth", String(opts.depth));
+    }
+    const query = qs.toString();
+    const path = `/node/${encodeURIComponent(key)}/neighborhood${
+      query ? `?${query}` : ""
+    }`;
+    return this.fetchJson<Neighborhood>(path);
+  }
+
+  // -------------------------------------------------------------------------
+  // WebSocket
+  // -------------------------------------------------------------------------
+
+  /**
+   * Subscribe to post-commit events over WebSocket (`GET /subscribe`).
+   *
+   * Returns a promise that resolves when the server acknowledges the
+   * subscription (`{"subscribed":true}`). After that, `onEvent` is called
+   * for each {@link DbEvent}, including {@link DbEvent.lagged} frames.
+   *
+   * **No auto-reconnect in v1.** When the connection drops, no further events
+   * are delivered. Reconnect manually if required.
+   *
+   * **Always await `handle.close()`** when done — an open WebSocket keeps the
+   * Node.js event loop alive and will cause test hangs.
+   *
+   * **Node.js < 21**: pass `wsConstructor` — see {@link SubscribeOptions}.
+   *
+   * @example
+   * ```ts
+   * import WS from 'ws';
+   * const handle = await client.subscribe(
+   *   { writes: true, wsConstructor: WS as WsConstructor },
+   *   (ev) => console.log(ev),
+   * );
+   * // ... do work ...
+   * await handle.close();
+   * ```
+   */
+  subscribe(
+    opts: SubscribeOptions,
+    onEvent: (event: import("./types.js").DbEvent) => void,
+  ): Promise<SubscribeHandle> {
+    let url = this.wsUrl("/subscribe");
+    if (this.token) {
+      url += `?token=${encodeURIComponent(this.token)}`;
+    }
+    return wsSubscribe(url, opts, onEvent);
+  }
+}
+
+export type { SubscribeHandle, SubscribeOptions, WsConstructor };

package/src/index.ts

@@ -0,0 +1,47 @@
+/**
+ * mushroomdb-client — TypeScript client for mushroomdb.
+ *
+ * Entry point re-exports everything callers need.
+ */
+
+export { MushroomClient, MushroomError } from "./client.js";
+export type {
+  AlgoDir,
+  AlgoReport,
+  CellValue,
+  ClientOptions,
+  DegreeConfig,
+  DegreeReport,
+  Explanation,
+  IngestEdge,
+  IngestOptions,
+  IngestReport,
+  IngestRequest,
+  Neighborhood,
+  NodeInfo,
+  PageRankConfig,
+  PageRankReport,
+  PredicateKind,
+  PredicateSummary,
+  QueryOptions,
+  QueryParams,
+  QueryResult,
+  RuleDef,
+  RulePredicate,
+  RuleStats,
+  RuleSuggestion,
+  Stats,
+  SuggestReport,
+  WccConfig,
+  WccReport,
+} from "./client.js";
+export type {
+  DbEvent,
+  SubscribeMessage,
+} from "./types.js";
+export type {
+  SubscribeHandle,
+  SubscribeOptions,
+  WsConstructor,
+  WsLike,
+} from "./ws.js";