okengine 0.11.2 → 0.12.0

package/src/console/ui-next/src/features/store/lib/query-schema.test.ts

@@ -0,0 +1,139 @@
+import { describe, expect, test } from "bun:test";
+import type { Manifest } from "../../../../../../manifest/types.ts";
+import type { StoreListStore } from "@/client.ts";
+import { fieldsFromKvValues, querySchemaTables } from "./query-schema.ts";
+
+const emptyWillNot = { writerFlowIds: [], signals: [], channels: [] };
+const emptyCache = {
+  producedByRead: "cache:sql:db",
+  invalidatedByWrites: [] as string[],
+  invalidatingFlowIds: [] as string[],
+};
+
+const STORE: StoreListStore = {
+  ref: "sql:db",
+  facet: "sql",
+  name: "db",
+  children: [
+    {
+      name: "comments",
+      effectRef: "sql:comments",
+      writers: [],
+      readers: [],
+      cache: emptyCache,
+      willNotFire: emptyWillNot,
+      piiColumns: ["author_email"],
+      columnDescriptions: { body: "Markdown" },
+    },
+    {
+      name: "indexes",
+      effectRef: "sql:db/indexes",
+      kind: "index",
+      writers: [],
+      readers: [],
+      cache: emptyCache,
+      willNotFire: emptyWillNot,
+      piiColumns: [],
+      columnDescriptions: {},
+    },
+  ],
+  replicaLagMs: null,
+  migrationDrift: null,
+  contentAddressed: false,
+  warnings: [],
+};
+
+const MANIFEST = {
+  oke: "1.0",
+  app: "t",
+  stores: {
+    db: {
+      facet: "sql",
+      tables: {
+        comments: {
+          columns: {
+            id: { type: "text", primaryKey: true },
+            author_email: { type: "text", pii: true },
+            body: { type: "text" },
+          },
+        },
+      },
+    },
+  },
+} as Manifest;
+
+describe("querySchemaTables", () => {
+  test("prefers Manifest columns and keeps PII / PK", () => {
+    const tables = querySchemaTables(STORE, MANIFEST);
+    expect(tables).toHaveLength(1);
+    expect(tables[0]?.name).toBe("comments");
+    expect(tables[0]?.columns.map((c) => c.name)).toEqual(["id", "author_email", "body"]);
+    expect(tables[0]?.columns.find((c) => c.name === "id")?.primaryKey).toBe(true);
+    expect(tables[0]?.columns.find((c) => c.name === "author_email")?.pii).toBe(true);
+  });
+
+  test("overlays inferred FK from schema graph", () => {
+    const store: StoreListStore = {
+      ...STORE,
+      children: [
+        ...STORE.children,
+        {
+          name: "issues",
+          effectRef: "sql:issues",
+          writers: [],
+          readers: [],
+          cache: emptyCache,
+          willNotFire: emptyWillNot,
+          piiColumns: [],
+          columnDescriptions: {},
+        },
+      ],
+    };
+    const manifest = {
+      ...MANIFEST,
+      stores: {
+        db: {
+          facet: "sql",
+          tables: {
+            issues: { columns: { id: { type: "text", primaryKey: true } } },
+            comments: {
+              columns: {
+                id: { type: "text", primaryKey: true },
+                issue_id: { type: "text" },
+                author_email: { type: "text", pii: true },
+                body: { type: "text" },
+              },
+            },
+          },
+        },
+      },
+    } as Manifest;
+    const comments = querySchemaTables(store, manifest).find((t) => t.name === "comments");
+    expect(comments?.columns.find((c) => c.name === "issue_id")?.references).toEqual({
+      table: "issues",
+      column: "id",
+    });
+    expect(comments?.columns.find((c) => c.name === "issue_id")?.inferredRef).toBe(true);
+  });
+
+  test("fieldsFromKvValues unions object keys and types", () => {
+    expect(
+      fieldsFromKvValues([
+        { identifier: "ENG-184", title: "Pulse", expiresAt: "2026-08-14T01:00:00Z" },
+        { identifier: "SUP-12", until: "2026-08-15T12:00:00Z", reason: "waiting" },
+        "skip",
+      ]),
+    ).toEqual([
+      { name: "identifier", type: "string" },
+      { name: "title", type: "string" },
+      { name: "expiresAt", type: "string" },
+      { name: "until", type: "string" },
+      { name: "reason", type: "string" },
+    ]);
+  });
+
+  test("falls back to list projection when Manifest has no table", () => {
+    const tables = querySchemaTables(STORE, { oke: "1.0", app: "t" } as Manifest);
+    expect(tables[0]?.columns.map((c) => c.name).sort()).toEqual(["author_email", "body"]);
+  });
+});

package/src/console/ui-next/src/features/store/lib/query-schema.ts

@@ -0,0 +1,128 @@
+/**
+ * Manifest + store-list schema catalog for the query console (rail + complete).
+ */
+
+import type { Manifest } from "../../../../../../manifest/types.ts";
+import { expandPiiNames } from "../../../../../../elements/store/classify.ts";
+import type { StoreListChild, StoreListStore } from "@/client.ts";
+import type { FormField } from "@/features/units/lib/fields-from-schema.ts";
+import { fieldsFromTable } from "./fields-from-table.ts";
+import { schemaGraphTables } from "./schema-graph.ts";
+import { isSqlCatalogChild } from "./sql-catalog.ts";
+
+/** One column in the query-console schema catalog. */
+export type QuerySchemaColumn = {
+  readonly name: string;
+  readonly type: string;
+  readonly pii?: boolean;
+  readonly primaryKey?: boolean;
+  readonly unique?: boolean;
+  readonly references?: { readonly table: string; readonly column?: string };
+  readonly inferredRef?: boolean;
+};
+
+/** One table / namespace in the query-console schema catalog. */
+export type QuerySchemaTable = {
+  readonly name: string;
+  readonly columns: readonly QuerySchemaColumn[];
+};
+
+/**
+ * Columns for a store child — Manifest table first, then list projection.
+ *
+ * @param store - Projected store
+ * @param child - Table / namespace
+ * @param manifest - Current Manifest
+ */
+export function schemaColumnsForChild(
+  store: StoreListStore | null | undefined,
+  child: StoreListChild,
+  manifest: Manifest | null,
+): FormField[] {
+  if (store) {
+    const fromManifest = fieldsFromTable(
+      manifest,
+      store.name,
+      child.name,
+      child.columnDescriptions,
+    );
+    if (fromManifest.length > 0) return fromManifest;
+  }
+  const pii = expandPiiNames(child.piiColumns);
+  const names = [...new Set([...Object.keys(child.columnDescriptions), ...child.piiColumns])];
+  return names.map((name) => ({
+    path: `/${name}`,
+    name,
+    type: "unknown" as const,
+    required: false,
+    ...(child.columnDescriptions[name] !== undefined
+      ? { description: child.columnDescriptions[name] }
+      : {}),
+    ...(pii.has(name) ? { pii: true } : {}),
+  }));
+}
+
+/**
+ * Infer value fields from KV samples (union of object keys).
+ *
+ * @param values - Stored values
+ */
+export function fieldsFromKvValues(values: readonly unknown[]): readonly QuerySchemaColumn[] {
+  const types = new Map<string, string>();
+  for (const value of values) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+    for (const [key, cell] of Object.entries(value)) {
+      if (!types.has(key)) types.set(key, kvFieldType(cell));
+    }
+  }
+  return [...types.entries()].map(([name, type]) => ({ name, type }));
+}
+
+function kvFieldType(value: unknown): string {
+  if (value === null || value === undefined) return "unknown";
+  if (Array.isArray(value)) return "array";
+  if (typeof value === "object") return "object";
+  if (typeof value === "number") return Number.isInteger(value) ? "integer" : "number";
+  if (typeof value === "boolean") return "boolean";
+  if (typeof value === "string") return "string";
+  return "unknown";
+}
+
+/**
+ * Tables (or KV namespaces) the editor can complete against.
+ *
+ * @param store - Selected store
+ * @param manifest - Current Manifest
+ */
+export function querySchemaTables(
+  store: StoreListStore | null | undefined,
+  manifest: Manifest | null,
+): readonly QuerySchemaTable[] {
+  if (!store) return [];
+  const graphByName = new Map(
+    store.facet === "sql"
+      ? schemaGraphTables([store], manifest).map((table) => [table.name, table] as const)
+      : [],
+  );
+  return store.children
+    .filter((child) => !isSqlCatalogChild(child))
+    .map((child) => ({
+      name: child.name,
+      columns: schemaColumnsForChild(store, child, manifest).map((col) => {
+        const graphCol = graphByName.get(child.name)?.columns.find((c) => c.name === col.name);
+        return {
+          name: col.name,
+          type: col.type,
+          ...(col.pii === true ? { pii: true } : {}),
+          ...(col.primaryKey === true || graphCol?.primaryKey === true ? { primaryKey: true } : {}),
+          ...(graphCol?.unique === true ? { unique: true } : {}),
+          ...(graphCol?.references
+            ? {
+                references: graphCol.references,
+                ...(graphCol.inferredRef === true ? { inferredRef: true } : {}),
+              }
+            : {}),
+        };
+      }),
+    }));
+}

package/src/console/ui-next/src/features/store/lib/query-session.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, test } from "bun:test";
+import {
+  addQueryTab,
+  closeQueryTab,
+  historyPreview,
+  isDefaultQueryTitle,
+  nextQueryTitle,
+  pushQueryHistory,
+  renameQueryTab,
+  upsertSavedQuery,
+  writeQueryTab,
+} from "./query-session.ts";
+
+const seed = [{ id: "a", title: "Query 1", text: "SELECT 1" }];
+
+describe("query tabs", () => {
+  test("names the next unused Query N", () => {
+    expect(nextQueryTitle(seed)).toBe("Query 2");
+    expect(nextQueryTitle([...seed, { id: "b", title: "Query 3", text: "" }])).toBe("Query 2");
+  });
+
+  test("adds and writes a tab", () => {
+    const added = addQueryTab(seed, "SELECT 2");
+    expect(added).toHaveLength(2);
+    expect(added[1]?.title).toBe("Query 2");
+    expect(writeQueryTab(added, added[1]!.id, "SELECT 3")[1]?.text).toBe("SELECT 3");
+  });
+
+  test("caps at 8 tabs", () => {
+    let tabs = seed;
+    for (let i = 0; i < 10; i += 1) tabs = [...addQueryTab(tabs, "x")];
+    expect(tabs).toHaveLength(8);
+  });
+
+  test("detects placeholder Query N titles", () => {
+    expect(isDefaultQueryTitle("Query 1")).toBe(true);
+    expect(isDefaultQueryTitle("comments by issue")).toBe(false);
+  });
+
+  test("renames a tab and falls back when empty", () => {
+    expect(renameQueryTab(seed, "a", "  comments by issue  ")[0]?.title).toBe("comments by issue");
+    expect(renameQueryTab(seed, "a", "   ")[0]?.title).toBe("Query 1");
+  });
+
+  test("upserts saved queries by id", () => {
+    const first = upsertSavedQuery([], { id: "a", title: "Q", text: "SELECT 1" });
+    expect(first).toHaveLength(1);
+    const second = upsertSavedQuery(first, { id: "a", title: "Q2", text: "SELECT 2" });
+    expect(second).toHaveLength(1);
+    expect(second[0]?.title).toBe("Q2");
+    expect(second[0]?.text).toBe("SELECT 2");
+  });
+
+  test("closing the last tab reseeds", () => {
+    const next = closeQueryTab(seed, "a", "SELECT 1;");
+    expect(next).toHaveLength(1);
+    expect(next[0]?.id).not.toBe("a");
+    expect(next[0]?.text).toBe("SELECT 1;");
+  });
+});
+
+describe("query history", () => {
+  test("previews the first executable line", () => {
+    expect(historyPreview("-- note\nSELECT * FROM t")).toBe("SELECT * FROM t");
+    expect(historyPreview("")).toBe("(empty)");
+  });
+
+  test("prepends and caps history", () => {
+    let entries = pushQueryHistory([], {
+      at: 1,
+      storeRef: "sql:db",
+      text: "SELECT 1",
+      ok: true,
+      rowCount: 1,
+      durationMs: 4,
+    });
+    expect(entries).toHaveLength(1);
+    for (let i = 0; i < 30; i += 1) {
+      entries = pushQueryHistory(entries, {
+        at: i,
+        storeRef: "sql:db",
+        text: `SELECT ${i}`,
+        ok: true,
+        rowCount: 0,
+        durationMs: 1,
+      });
+    }
+    expect(entries).toHaveLength(24);
+    expect(entries[0]?.text).toBe("SELECT 29");
+  });
+});

package/src/console/ui-next/src/features/store/lib/query-session.ts

@@ -0,0 +1,330 @@
+/**
+ * Query console tabs + saved queries (localStorage) and run history (sessionStorage).
+ */
+
+import type { StoreQueryFacet } from "../state/store-selection.ts";
+
+/** One editor tab. */
+export type QueryTab = {
+  readonly id: string;
+  readonly title: string;
+  readonly text: string;
+};
+
+/** One recorded run. */
+export type QueryHistoryEntry = {
+  readonly id: string;
+  readonly at: number;
+  readonly storeRef: string;
+  readonly text: string;
+  readonly ok: boolean;
+  readonly rowCount: number | null;
+  readonly durationMs: number;
+  readonly error?: string;
+};
+
+const TAB_CAP = 8;
+const HISTORY_CAP = 24;
+const SAVED_CAP = 24;
+
+/**
+ * True when the title is still the auto `Query N` placeholder.
+ *
+ * @param title - Tab title
+ */
+export function isDefaultQueryTitle(title: string): boolean {
+  return /^Query \d+$/.test(title);
+}
+
+/**
+ * Next `Query N` title that is not already used.
+ *
+ * @param tabs - Existing tabs
+ */
+export function nextQueryTitle(tabs: readonly QueryTab[]): string {
+  const used = new Set(tabs.map((t) => t.title));
+  let n = 1;
+  while (used.has(`Query ${n}`)) n += 1;
+  return `Query ${n}`;
+}
+
+/**
+ * Append a tab. Caps at {@link TAB_CAP}.
+ *
+ * @param tabs - Existing tabs
+ * @param text - Seed buffer
+ */
+export function addQueryTab(tabs: readonly QueryTab[], text: string): readonly QueryTab[] {
+  if (tabs.length >= TAB_CAP) return tabs;
+  return [
+    ...tabs,
+    {
+      id: newTabId(),
+      title: nextQueryTitle(tabs),
+      text,
+    },
+  ];
+}
+
+/**
+ * Remove a tab. Always leaves at least one (re-seeds when emptying).
+ *
+ * @param tabs - Existing tabs
+ * @param id - Tab to close
+ * @param fallbackText - Buffer when the last tab is closed
+ */
+export function closeQueryTab(
+  tabs: readonly QueryTab[],
+  id: string,
+  fallbackText: string,
+): readonly QueryTab[] {
+  const next = tabs.filter((t) => t.id !== id);
+  if (next.length > 0) return next;
+  return [{ id: newTabId(), title: "Query 1", text: fallbackText }];
+}
+
+/**
+ * Replace one tab's buffer.
+ *
+ * @param tabs - Existing tabs
+ * @param id - Tab id
+ * @param text - Next buffer
+ */
+export function writeQueryTab(
+  tabs: readonly QueryTab[],
+  id: string,
+  text: string,
+): readonly QueryTab[] {
+  return tabs.map((t) => (t.id === id ? { ...t, text } : t));
+}
+
+/**
+ * Rename one tab. Empty titles fall back to the next unused `Query N`.
+ *
+ * @param tabs - Existing tabs
+ * @param id - Tab id
+ * @param title - Next title
+ */
+export function renameQueryTab(
+  tabs: readonly QueryTab[],
+  id: string,
+  title: string,
+): readonly QueryTab[] {
+  const trimmed = title.trim().replace(/\s+/g, " ");
+  const nextTitle =
+    trimmed.length > 0 ? trimmed.slice(0, 48) : nextQueryTitle(tabs.filter((t) => t.id !== id));
+  return tabs.map((t) => (t.id === id ? { ...t, title: nextTitle } : t));
+}
+
+/** One named query kept across sessions. */
+export type SavedQuery = {
+  readonly id: string;
+  readonly title: string;
+  readonly text: string;
+  readonly at: number;
+};
+
+/**
+ * Upsert a saved query (same id replaces) and cap the list.
+ *
+ * @param entries - Existing saved
+ * @param entry - Tab snapshot
+ */
+export function upsertSavedQuery(
+  entries: readonly SavedQuery[],
+  entry: Omit<SavedQuery, "at"> & { readonly at?: number },
+): readonly SavedQuery[] {
+  const next: SavedQuery = {
+    id: entry.id,
+    title: entry.title,
+    text: entry.text,
+    at: entry.at ?? Date.now(),
+  };
+  return [next, ...entries.filter((row) => row.id !== next.id)].slice(0, SAVED_CAP);
+}
+
+/**
+ * Prepend a history row and cap the list.
+ *
+ * @param entries - Existing history
+ * @param entry - New run (id assigned here)
+ */
+export function pushQueryHistory(
+  entries: readonly QueryHistoryEntry[],
+  entry: Omit<QueryHistoryEntry, "id">,
+): readonly QueryHistoryEntry[] {
+  return [{ ...entry, id: newTabId() }, ...entries].slice(0, HISTORY_CAP);
+}
+
+/**
+ * First line of a history preview (comments skipped for KV).
+ *
+ * @param text - Buffer
+ */
+export function historyPreview(text: string): string {
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0 || trimmed.startsWith("//") || trimmed.startsWith("--")) continue;
+    return trimmed.length > 72 ? `${trimmed.slice(0, 71)}…` : trimmed;
+  }
+  return text.trim().slice(0, 72) || "(empty)";
+}
+
+/**
+ * Load tabs for a facet. Missing / corrupt storage returns null.
+ *
+ * @param facet - SQL or KV
+ */
+export function loadQueryTabs(facet: StoreQueryFacet): readonly QueryTab[] | null {
+  const key = tabKey(facet);
+  const local = readJson(localStore(), key, isTabList);
+  if (local) return local;
+  const session = readJson(sessionStore(), key, isTabList);
+  if (session) writeJson(localStore(), key, session);
+  return session;
+}
+
+/**
+ * Persist tabs for a facet.
+ *
+ * @param facet - SQL or KV
+ * @param tabs - Tabs
+ */
+export function saveQueryTabs(facet: StoreQueryFacet, tabs: readonly QueryTab[]): void {
+  writeJson(localStore(), tabKey(facet), tabs);
+}
+
+/**
+ * Load run history for a facet.
+ *
+ * @param facet - SQL or KV
+ */
+export function loadQueryHistory(facet: StoreQueryFacet): readonly QueryHistoryEntry[] {
+  return readJson(sessionStore(), historyKey(facet), isHistoryList) ?? [];
+}
+
+/**
+ * Persist run history for a facet.
+ *
+ * @param facet - SQL or KV
+ * @param entries - History
+ */
+export function saveQueryHistory(
+  facet: StoreQueryFacet,
+  entries: readonly QueryHistoryEntry[],
+): void {
+  writeJson(sessionStore(), historyKey(facet), entries);
+}
+
+/**
+ * Load named saved queries for a facet.
+ *
+ * @param facet - SQL or KV
+ */
+export function loadSavedQueries(facet: StoreQueryFacet): readonly SavedQuery[] {
+  return readJson(localStore(), savedKey(facet), isSavedList) ?? [];
+}
+
+/**
+ * Persist named saved queries.
+ *
+ * @param facet - SQL or KV
+ * @param entries - Saved
+ */
+export function saveSavedQueries(facet: StoreQueryFacet, entries: readonly SavedQuery[]): void {
+  writeJson(localStore(), savedKey(facet), entries);
+}
+
+function tabKey(facet: StoreQueryFacet): string {
+  return `oke_store_query_tabs_${facet}`;
+}
+
+function historyKey(facet: StoreQueryFacet): string {
+  return `oke_store_query_history_${facet}`;
+}
+
+function savedKey(facet: StoreQueryFacet): string {
+  return `oke_store_query_saved_${facet}`;
+}
+
+function newTabId(): string {
+  return `q_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+function isTabList(value: unknown): value is QueryTab[] {
+  if (!Array.isArray(value) || value.length === 0) return false;
+  return value.every(
+    (row) =>
+      row !== null &&
+      typeof row === "object" &&
+      typeof (row as QueryTab).id === "string" &&
+      typeof (row as QueryTab).title === "string" &&
+      typeof (row as QueryTab).text === "string",
+  );
+}
+
+function isHistoryList(value: unknown): value is QueryHistoryEntry[] {
+  if (!Array.isArray(value)) return false;
+  return value.every(
+    (row) =>
+      row !== null &&
+      typeof row === "object" &&
+      typeof (row as QueryHistoryEntry).id === "string" &&
+      typeof (row as QueryHistoryEntry).at === "number" &&
+      typeof (row as QueryHistoryEntry).text === "string",
+  );
+}
+
+function isSavedList(value: unknown): value is SavedQuery[] {
+  if (!Array.isArray(value)) return false;
+  return value.every(
+    (row) =>
+      row !== null &&
+      typeof row === "object" &&
+      typeof (row as SavedQuery).id === "string" &&
+      typeof (row as SavedQuery).title === "string" &&
+      typeof (row as SavedQuery).text === "string" &&
+      typeof (row as SavedQuery).at === "number",
+  );
+}
+
+function localStore(): Storage | null {
+  try {
+    return typeof localStorage === "undefined" ? null : localStorage;
+  } catch {
+    return null;
+  }
+}
+
+function sessionStore(): Storage | null {
+  try {
+    return typeof sessionStorage === "undefined" ? null : sessionStorage;
+  } catch {
+    return null;
+  }
+}
+
+function readJson<T>(
+  store: Storage | null,
+  key: string,
+  guard: (value: unknown) => value is T,
+): T | null {
+  if (!store) return null;
+  try {
+    const raw = store.getItem(key);
+    if (!raw) return null;
+    const parsed: unknown = JSON.parse(raw);
+    return guard(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function writeJson(store: Storage | null, key: string, value: unknown): void {
+  if (!store) return;
+  try {
+    store.setItem(key, JSON.stringify(value));
+  } catch {
+    // quota / private mode
+  }
+}