@reddb-io/ui 0.3.0 → 0.3.2

package/src/lib/reddb/client.ts

@@ -7,6 +7,15 @@ import {
   type RawCapabilities,
   type ServerCapabilities,
 } from "./server-capabilities";
+import type {
+  PermissionCheck,
+  PermissionDecision,
+  PermissionResource,
+} from "../permission-gate";
+import type { ClusterStatus, ReplicationStatus } from "./cluster-status";
+import type { MetricDescriptor, PromResponse } from "./analytics";
+import type { AskResponse, AskOptions } from "./ask";
+import { devConsole, sanitizePayload } from "./dev-console";
 
 export interface QueryRow {
   values: Record<string, unknown>;
@@ -104,59 +113,6 @@ export interface Stats {
   read_only_reason?: string;
 }
 
-export interface ClusterStatus {
-  ok?: boolean;
-  deployment?: {
-    mode?: "embedded" | "server" | "docker" | "replicated" | string;
-    file_path?: string;
-    process_kind?: string;
-    container_id?: string;
-    image?: string;
-    configured_by?: string;
-  };
-  storage?: {
-    capacity_bytes?: number;
-    used_bytes?: number;
-    free_bytes?: number;
-  };
-  wal?: {
-    size_bytes?: number;
-    lsn?: number;
-    oldest_lsn?: number;
-  };
-  throughput?: {
-    requests_per_second?: number;
-    reads_per_second?: number;
-    writes_per_second?: number;
-    avg_response_ms?: number;
-  };
-  system?: {
-    cpu_usage_percent?: number;
-    memory_used_bytes?: number;
-    memory_total_bytes?: number;
-  };
-  replication?: {
-    replica_count?: number;
-    lag_ms?: number;
-    lag_lsn?: number;
-  };
-}
-
-export interface ReplicationStatus {
-  ok: boolean;
-  role: "primary" | "replica" | "standalone";
-  state?: "healthy" | "lagging" | "disconnected";
-  primary_addr?: string;
-  /** primary perspective */
-  wal_lsn?: number;
-  oldest_lsn?: number;
-  replica_count?: number;
-  /** replica perspective */
-  last_applied_lsn?: number;
-  last_seen_primary_lsn?: number;
-  last_seen_oldest_lsn?: number;
-}
-
 export interface Whoami {
   ok: boolean;
   authenticated: boolean;
@@ -199,6 +155,12 @@ export interface AuthPolicy {
   created_at?: number;
 }
 
+interface AuthCanResponse {
+  ok?: boolean;
+  results?: Array<Partial<PermissionDecision>>;
+  error?: string;
+}
+
 export interface ChangeEvent {
   lsn: number;
   timestamp: number;
@@ -280,6 +242,18 @@ function unsupportedCollectionMetadataError(baseUrl: string): Error {
   );
 }
 
+function isPermissionResource(value: unknown): value is PermissionResource {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value as Partial<PermissionResource>;
+  return (
+    typeof candidate.kind === "string" &&
+    candidate.kind.length > 0 &&
+    typeof candidate.name === "string" &&
+    candidate.name.length > 0 &&
+    (candidate.tenant === undefined || typeof candidate.tenant === "string")
+  );
+}
+
 /** One NDJSON frame from `POST /query/stream`. Discriminated by its single key. */
 type NdjsonFrame =
   | { descriptor: { columns: string[]; schema_fingerprint?: string } }
@@ -320,6 +294,46 @@ async function* parseNdjsonFrames(
 
 const SELECT_RE = /^\s*select\b/i;
 
+/**
+ * Pull a row count out of a parsed response for the developer console (#128).
+ * Recognises the `/query` envelope (`record_count`, else the length of
+ * `result.records`) and a bare array; returns `undefined` when the shape
+ * carries no notion of rows. Purely structural — never throws.
+ */
+export function extractRowCount(data: unknown): number | undefined {
+  if (Array.isArray(data)) return data.length;
+  if (data && typeof data === "object") {
+    const d = data as {
+      record_count?: unknown;
+      result?: { records?: unknown };
+    };
+    if (typeof d.record_count === "number") return d.record_count;
+    if (Array.isArray(d.result?.records)) return d.result.records.length;
+  }
+  return undefined;
+}
+
+/**
+ * Extract a human-readable message from any thrown value. Tauri's `invoke` and
+ * the HTTP plugin reject with plain strings or bare objects (not `Error`), so
+ * `(e as Error).message` is often `undefined` — this never returns that.
+ */
+export function errorText(e: unknown): string {
+  if (e instanceof Error) return e.message || String(e);
+  if (typeof e === "string") return e;
+  if (e && typeof e === "object") {
+    const m = (e as { message?: unknown }).message;
+    if (typeof m === "string" && m) return m;
+    try {
+      const s = JSON.stringify(e);
+      if (s && s !== "{}") return s;
+    } catch {
+      /* circular — fall through */
+    }
+  }
+  return String(e);
+}
+
 /**
  * Run a query, preferring the bounded-memory NDJSON stream for a plain SELECT
  * and falling back to the buffered `POST /query` for everything else — and for
@@ -334,7 +348,9 @@ export async function runQueryPreferStream(
   sql: string,
   opts: { maxRows?: number; signal?: AbortSignal } = {}
 ): Promise<QueryResult> {
-  if (!SELECT_RE.test(sql)) return client.query(sql);
+  const queryOpts = opts.signal ? { signal: opts.signal } : undefined;
+  if (!SELECT_RE.test(sql))
+    return queryOpts ? client.query(sql, queryOpts) : client.query(sql);
   try {
     const s = await client.queryStreamCollect(sql, opts);
     return {
@@ -348,8 +364,14 @@ export async function runQueryPreferStream(
       streamed: true,
       truncated: s.truncated,
     };
-  } catch {
-    return client.query(sql);
+  } catch (e) {
+    if (
+      opts.signal?.aborted ||
+      (e instanceof Error && e.name === "AbortError")
+    ) {
+      throw e;
+    }
+    return queryOpts ? client.query(sql, queryOpts) : client.query(sql);
   }
 }
 
@@ -372,14 +394,66 @@ export class RedClient {
     Object.assign(headers, this.headers as Record<string, string> | undefined);
     Object.assign(headers, init?.headers as Record<string, string> | undefined);
 
-    const res = await this.fetcher(url, { ...init, headers });
+    // Developer console instrumentation (#128). Every HTTP call the client
+    // makes is timed and logged from this single seam, so every Surface is
+    // covered without touching each caller. The request body is sanitized
+    // before it lands in an entry — a copy action can never leak a secret.
+    const verb = init?.method ?? "GET";
+    const startedAt = Date.now();
+    const start = performance.now();
+    const payload = sanitizePayload(init?.body);
+    const elapsed = () => Math.round(performance.now() - start);
+
+    let res: Response;
+    try {
+      res = await this.fetcher(url, { ...init, headers });
+    } catch (e) {
+      devConsole.record({
+        kind: "http",
+        verb,
+        target: path,
+        startedAt,
+        durationMs: elapsed(),
+        ok: false,
+        payload,
+        error: errorText(e),
+      });
+      throw e;
+    }
+
     if (!res.ok) {
       const body = await res.text().catch(() => "");
-      throw new Error(
-        `${init?.method ?? "GET"} ${path} → ${res.status} ${body.slice(0, 200)}`
-      );
+      const message = `${verb} ${path} → ${res.status} ${body.slice(0, 200)}`;
+      devConsole.record({
+        kind: "http",
+        verb,
+        target: path,
+        startedAt,
+        durationMs: elapsed(),
+        ok: false,
+        status: res.status,
+        payload,
+        error: message,
+      });
+      throw new Error(message);
     }
-    return res.json() as Promise<T>;
+
+    const data = (await res.json()) as T;
+    const rowCount = extractRowCount(data);
+    devConsole.record({
+      // A response carrying a row count is a query round-trip; everything else
+      // is a plain HTTP call. This is how `/query` entries mark themselves.
+      kind: rowCount === undefined ? "http" : "query",
+      verb,
+      target: path,
+      startedAt,
+      durationMs: elapsed(),
+      ok: true,
+      status: res.status,
+      ...(rowCount === undefined ? {} : { rowCount }),
+      payload,
+    });
+    return data;
   }
 
   async stats(): Promise<Stats> {
@@ -390,6 +464,60 @@ export class RedClient {
     return this.json<ClusterStatus>("/cluster/status");
   }
 
+  /**
+   * List registered metric descriptors from the typed `red.metrics`
+   * projection (reddb #747). One row per `CREATE METRIC`, carrying the
+   * `kind` (counter|gauge|histogram|ratio|derived) the UI uses to auto-select
+   * a chart. Returns `[]` when the server has no analytics surface.
+   */
+  async metricsCatalog(): Promise<MetricDescriptor[]> {
+    const r = await this.query(
+      "SELECT path, kind, role, unit, supports_prometheus_query, created_at_ms FROM red.metrics"
+    );
+    return r.result.records.map((rec) => {
+      const v = rec.values;
+      return {
+        path: String(v.path ?? ""),
+        kind: v.kind as MetricDescriptor["kind"],
+        role: String(v.role ?? "metric"),
+        unit: (v.unit as string | null) ?? null,
+        supports_prometheus_query: v.supports_prometheus_query !== false,
+        created_at_ms:
+          typeof v.created_at_ms === "number" ? v.created_at_ms : undefined,
+      } satisfies MetricDescriptor;
+    });
+  }
+
+  /**
+   * Prometheus instant query (`GET /api/v1/query`). Returns the raw
+   * Prometheus-shaped envelope; callers normalise with `parsePromVector`.
+   */
+  async promQuery(query: string, time?: number): Promise<PromResponse> {
+    const qs = new URLSearchParams({ query });
+    if (time !== undefined) qs.set("time", String(time));
+    return this.json<PromResponse>(`/api/v1/query?${qs}`);
+  }
+
+  /**
+   * Prometheus range query (`GET /api/v1/query_range`). `start`/`end` are unix
+   * seconds, `step` is the resolution in seconds. Normalise with
+   * `parsePromMatrix`.
+   */
+  async promQueryRange(
+    query: string,
+    start: number,
+    end: number,
+    step: number
+  ): Promise<PromResponse> {
+    const qs = new URLSearchParams({
+      query,
+      start: String(start),
+      end: String(end),
+      step: String(step),
+    });
+    return this.json<PromResponse>(`/api/v1/query_range?${qs}`);
+  }
+
   async ping(): Promise<
     { ok: true; rtt_ms: number } | { ok: false; error: string }
   > {
@@ -398,7 +526,7 @@ export class RedClient {
       await this.json("/stats");
       return { ok: true, rtt_ms: Math.round(performance.now() - start) };
     } catch (e) {
-      return { ok: false, error: (e as Error).message };
+      return { ok: false, error: errorText(e) };
     }
   }
 
@@ -497,10 +625,14 @@ export class RedClient {
     );
   }
 
-  async query(query: string): Promise<QueryResult> {
+  async query(
+    query: string,
+    opts: { signal?: AbortSignal } = {}
+  ): Promise<QueryResult> {
     return this.json<QueryResult>("/query", {
       method: "POST",
       body: JSON.stringify({ query }),
+      signal: opts.signal,
     });
   }
 
@@ -528,17 +660,51 @@ export class RedClient {
     };
     Object.assign(headers, this.headers as Record<string, string> | undefined);
 
-    const res = await this.fetcher(`${this.baseUrl}/query/stream`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({ query }),
-      signal: opts.signal,
-    });
+    // Developer console instrumentation (#128). The streaming endpoint skips
+    // `json()`, so it logs its own query round-trip here (verb `POST`, target
+    // `/query/stream`) with the collected row count.
+    const startedAt = Date.now();
+    const start = performance.now();
+    const body = JSON.stringify({ query });
+    const payload = sanitizePayload(body);
+    const elapsed = () => Math.round(performance.now() - start);
+
+    let res: Response;
+    try {
+      res = await this.fetcher(`${this.baseUrl}/query/stream`, {
+        method: "POST",
+        headers,
+        body,
+        signal: opts.signal,
+      });
+    } catch (e) {
+      devConsole.record({
+        kind: "query",
+        verb: "POST",
+        target: "/query/stream",
+        startedAt,
+        durationMs: elapsed(),
+        ok: false,
+        payload,
+        error: errorText(e),
+      });
+      throw e;
+    }
     if (!res.ok || !res.body) {
-      const body = res.body ? await res.text().catch(() => "") : "";
-      throw new Error(
-        `POST /query/stream → ${res.status} ${body.slice(0, 200)}`
-      );
+      const errBody = res.body ? await res.text().catch(() => "") : "";
+      const message = `POST /query/stream → ${res.status} ${errBody.slice(0, 200)}`;
+      devConsole.record({
+        kind: "query",
+        verb: "POST",
+        target: "/query/stream",
+        startedAt,
+        durationMs: elapsed(),
+        ok: false,
+        status: res.status,
+        payload,
+        error: message,
+      });
+      throw new Error(message);
     }
 
     const out: StreamedQueryResult = {
@@ -566,6 +732,18 @@ export class RedClient {
       }
     }
 
+    devConsole.record({
+      kind: "query",
+      verb: "POST",
+      target: "/query/stream",
+      startedAt,
+      durationMs: elapsed(),
+      ok: true,
+      status: res.status,
+      rowCount: out.rowCount,
+      payload,
+    });
+
     // We stopped early with more rows on the server — release the pinned cursor.
     if (out.truncated && out.cursor) {
       await this.cancelQueryStream(out.cursor).catch(() => {
@@ -654,6 +832,20 @@ export class RedClient {
     return this.json<Whoami>("/auth/whoami");
   }
 
+  /**
+   * Grounded natural-language query (`POST /ai/ask`, ADR 0013). Returns the
+   * synthesised answer plus the `sources_flat` it was grounded on and the
+   * `[^N]` citations linking claims to sources. Requires the server's AI
+   * provider to be configured; an unconfigured server answers with an error
+   * status (surfaced by `json()`).
+   */
+  async ask(question: string, opts: AskOptions = {}): Promise<AskResponse> {
+    return this.json<AskResponse>("/ai/ask", {
+      method: "POST",
+      body: JSON.stringify({ question, ...opts }),
+    });
+  }
+
   async users(): Promise<AuthUser[]> {
     const r = await this.json<{ ok: boolean; users: AuthUser[] }>(
       "/auth/users"
@@ -675,6 +867,33 @@ export class RedClient {
     return r.policies ?? [];
   }
 
+  async authCan(checks: PermissionCheck[]): Promise<PermissionDecision[]> {
+    const r = await this.json<AuthCanResponse>("/auth/can", {
+      method: "POST",
+      body: JSON.stringify({ checks }),
+    });
+    if (!Array.isArray(r.results)) {
+      throw new Error(r.error ?? "POST /auth/can returned no results");
+    }
+    return checks.map((check, index) => {
+      const result = r.results?.[index] ?? {};
+      const resource = isPermissionResource(result.resource)
+        ? result.resource
+        : check.resource;
+      return {
+        action:
+          typeof result.action === "string" ? result.action : check.action,
+        resource,
+        current_tenant:
+          typeof result.current_tenant === "string"
+            ? result.current_tenant
+            : check.current_tenant,
+        allowed: result.allowed === true,
+        reason: typeof result.reason === "string" ? result.reason : undefined,
+      };
+    });
+  }
+
   async changes(
     sinceLsn?: number,
     opts: { collection?: string; limit?: number } = {}