okengine 0.11.2 → 0.12.0

package/src/console/ui-next/src/features/units/lib/fk-lookup.test.ts

@@ -0,0 +1,103 @@
+/**
+ * FK field → Store table lookup.
+ */
+
+import { describe, expect, test } from "bun:test";
+import type { Manifest } from "../../../../../../manifest/types.ts";
+import { fieldsFromSchema } from "./fields-from-schema.ts";
+import { fkOptionsFromRows, resolveFkLookup } from "./fk-lookup.ts";
+
+const MANIFEST = {
+  oke: "1.0",
+  app: "keel",
+  stores: {
+    db: {
+      facet: "sql",
+      tables: {
+        teams: {
+          columns: {
+            id: { type: "text", primaryKey: true },
+            key: { type: "text" },
+            name: { type: "text" },
+          },
+        },
+        users: {
+          columns: {
+            id: { type: "text", primaryKey: true },
+            name: { type: "text" },
+          },
+        },
+      },
+    },
+  },
+} as Manifest;
+
+describe("resolveFkLookup", () => {
+  test("maps teamKey onto teams.key", () => {
+    const field = fieldsFromSchema({
+      type: "object",
+      properties: { teamKey: { type: "string" } },
+    })[0];
+    expect(field).toBeDefined();
+    expect(resolveFkLookup(field!, MANIFEST)).toEqual({
+      ref: "sql:db",
+      child: "teams",
+      column: "key",
+      labelColumn: "name",
+    });
+  });
+
+  test("maps userId onto users.id", () => {
+    const field = fieldsFromSchema({
+      type: "object",
+      properties: { userId: { type: "string" } },
+    })[0];
+    expect(resolveFkLookup(field!, MANIFEST)).toEqual({
+      ref: "sql:db",
+      child: "users",
+      column: "id",
+      labelColumn: "name",
+    });
+  });
+
+  test("honors declared references", () => {
+    const field = fieldsFromSchema({
+      type: "object",
+      properties: {
+        airportId: { type: "string", references: { table: "users", column: "id" } },
+      },
+    })[0];
+    expect(resolveFkLookup(field!, MANIFEST)).toEqual({
+      ref: "sql:db",
+      child: "users",
+      column: "id",
+      labelColumn: "name",
+    });
+  });
+
+  test("returns null when the table is missing", () => {
+    const field = fieldsFromSchema({
+      type: "object",
+      properties: { projectId: { type: "string" } },
+    })[0];
+    expect(resolveFkLookup(field!, MANIFEST)).toBeNull();
+  });
+});
+
+describe("fkOptionsFromRows", () => {
+  test("uses key + name and skips duplicates", () => {
+    expect(
+      fkOptionsFromRows(
+        [
+          { key: "ENG", name: "Engineering" },
+          { key: "ENG", name: "Engineering" },
+          { key: "DES", name: "Design" },
+        ],
+        { ref: "sql:db", child: "teams", column: "key", labelColumn: "name" },
+      ),
+    ).toEqual([
+      { value: "ENG", label: "ENG · Engineering" },
+      { value: "DES", label: "DES · Design" },
+    ]);
+  });
+});

package/src/console/ui-next/src/features/units/lib/fk-lookup.ts

@@ -0,0 +1,175 @@
+/**
+ * Resolve a Call API foreign-key field onto a Store SQL table + column.
+ */
+
+import type { DeclaredColumn, Manifest, Table } from "../../../../../../manifest/types.ts";
+import type { FormField } from "./fields-from-schema.ts";
+
+/** Browse target for FK options. */
+export type FkLookup = {
+  readonly ref: string;
+  readonly child: string;
+  readonly column: string;
+  readonly labelColumn?: string;
+};
+
+/** One selectable FK value. */
+export type FkOption = {
+  readonly value: string;
+  readonly label: string;
+};
+
+/**
+ * Map a FK field onto `sql:<store>` + table + value column.
+ *
+ * Uses `references` when declared; otherwise `teamKey` → `teams.key`,
+ * `userId` → `users.id` (or the table PK).
+ *
+ * @param field - Contract field
+ * @param manifest - Live Manifest
+ */
+export function resolveFkLookup(field: FormField, manifest: Manifest | null): FkLookup | null {
+  if (!field.foreignKey || !manifest) return null;
+  const stores = sqlStores(manifest);
+  if (stores.length === 0) return null;
+
+  if (field.references?.table) {
+    const hit = findTable(stores, field.references.table);
+    if (!hit) return null;
+    const column = field.references.column ?? pkColumn(hit.table) ?? "id";
+    return lookupOf(hit, column);
+  }
+
+  const parsed = parseFkName(field.name);
+  if (!parsed) return null;
+  const hit = findTableByStem(stores, parsed.stem);
+  if (!hit) return null;
+  const column =
+    parsed.kind === "key"
+      ? (columnIfExists(hit.table, "key") ?? pkColumn(hit.table) ?? "id")
+      : (pkColumn(hit.table) ?? "id");
+  return lookupOf(hit, column);
+}
+
+/**
+ * Distinct options from browse rows.
+ *
+ * @param rows - Store query rows
+ * @param lookup - Resolved target
+ */
+export function fkOptionsFromRows(
+  rows: readonly Readonly<Record<string, unknown>>[],
+  lookup: FkLookup | null,
+): readonly FkOption[] {
+  if (!lookup) return [];
+  const seen = new Set<string>();
+  const out: FkOption[] = [];
+  for (const row of rows) {
+    const raw = row[lookup.column];
+    if (raw == null) continue;
+    const value = String(raw);
+    if (seen.has(value)) continue;
+    seen.add(value);
+    const labelRaw = lookup.labelColumn ? row[lookup.labelColumn] : undefined;
+    const extra = labelRaw != null && String(labelRaw) !== value ? String(labelRaw) : null;
+    out.push({ value, label: extra ? `${value} · ${extra}` : value });
+  }
+  return out;
+}
+
+function lookupOf(
+  hit: { readonly ref: string; readonly name: string; readonly table: Table },
+  column: string,
+): FkLookup {
+  const label = labelColumn(hit.table, column);
+  return {
+    ref: hit.ref,
+    child: hit.name,
+    column,
+    ...(label !== undefined ? { labelColumn: label } : {}),
+  };
+}
+
+function parseFkName(name: string): { readonly stem: string; readonly kind: "id" | "key" } | null {
+  if (name === "id") return null;
+  if (name.endsWith("Id")) return { stem: name.slice(0, -2), kind: "id" };
+  if (name.endsWith("_id")) return { stem: name.slice(0, -3), kind: "id" };
+  if (name.endsWith("Key")) return { stem: name.slice(0, -3), kind: "key" };
+  if (name.endsWith("_key")) return { stem: name.slice(0, -4), kind: "key" };
+  return null;
+}
+
+function sqlStores(manifest: Manifest): readonly {
+  readonly ref: string;
+  readonly tables: Readonly<Record<string, Table>>;
+}[] {
+  const out: { ref: string; tables: Readonly<Record<string, Table>> }[] = [];
+  for (const [name, store] of Object.entries(manifest.stores ?? {})) {
+    if (store.facet !== "sql" || !store.tables) continue;
+    out.push({ ref: `sql:${name}`, tables: store.tables });
+  }
+  return out;
+}
+
+function findTable(
+  stores: readonly { readonly ref: string; readonly tables: Readonly<Record<string, Table>> }[],
+  tableName: string,
+): { readonly ref: string; readonly name: string; readonly table: Table } | null {
+  const needle = tableName.toLowerCase();
+  for (const store of stores) {
+    for (const [name, table] of Object.entries(store.tables)) {
+      if (name.toLowerCase() === needle) return { ref: store.ref, name, table };
+    }
+  }
+  return null;
+}
+
+function findTableByStem(
+  stores: readonly { readonly ref: string; readonly tables: Readonly<Record<string, Table>> }[],
+  stem: string,
+): { readonly ref: string; readonly name: string; readonly table: Table } | null {
+  const snake = camelToSnake(stem);
+  const candidates = [stem, snake, pluralizeSqlName(stem), pluralizeSqlName(snake)].map((n) =>
+    n.toLowerCase(),
+  );
+  for (const store of stores) {
+    for (const [name, table] of Object.entries(store.tables)) {
+      if (candidates.includes(name.toLowerCase())) return { ref: store.ref, name, table };
+    }
+  }
+  return null;
+}
+
+function pkColumn(table: Table): string | undefined {
+  for (const [name, col] of Object.entries(table.columns ?? {})) {
+    if (isDeclared(col) && col.primaryKey === true) return name;
+  }
+  if (table.columns && "id" in table.columns) return "id";
+  return undefined;
+}
+
+function columnIfExists(table: Table, name: string): string | undefined {
+  return table.columns && name in table.columns ? name : undefined;
+}
+
+function labelColumn(table: Table, valueColumn: string): string | undefined {
+  if (valueColumn !== "name" && table.columns && "name" in table.columns) return "name";
+  return undefined;
+}
+
+function isDeclared(col: DeclaredColumn | { pii?: boolean }): col is DeclaredColumn {
+  return "type" in col || "primaryKey" in col || "references" in col;
+}
+
+function pluralizeSqlName(stem: string): string {
+  if (stem.endsWith("y") && !/[aeiou]y$/i.test(stem)) return `${stem.slice(0, -1)}ies`;
+  if (/(?:s|x|z|ch|sh)$/i.test(stem)) return `${stem}es`;
+  return `${stem}s`;
+}
+
+function camelToSnake(value: string): string {
+  return value
+    .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+    .replace(/([A-Z])([A-Z][a-z])/g, "$1_$2")
+    .toLowerCase();
+}

package/src/console/ui-next/src/features/units/lib/flow-activity.test.ts

@@ -0,0 +1,76 @@
+/**
+ * Flow activity summary — honest empty when buffer has nothing in-window.
+ */
+
+import { describe, expect, test } from "bun:test";
+import type { RunRow } from "@/client.ts";
+import { flowActivitySummary } from "./flow-activity.ts";
+
+function run(partial: Partial<RunRow> & Pick<RunRow, "id" | "flow" | "startedAt">): RunRow {
+  return {
+    parentId: null,
+    unit: null,
+    trigger: "http",
+    plane: "user",
+    tenant: null,
+    principal: null,
+    gates: [],
+    cache: "none",
+    replica: null,
+    replicaLagMs: null,
+    cost: null,
+    inputTokens: null,
+    outputTokens: null,
+    promptVersion: null,
+    buildVersion: null,
+    endedAt: partial.startedAt + 1,
+    durationMs: 1,
+    error: null,
+    errorMessage: null,
+    sampled: "sample",
+    effects: [],
+    logs: [],
+    dimensions: {},
+    input: null,
+    output: null,
+    ...partial,
+  };
+}
+
+describe("flowActivitySummary", () => {
+  test("empty buffer → honest empty (not zero-as-fake-data)", () => {
+    expect(flowActivitySummary([], "bookings.create", 1_000_000)).toEqual({ kind: "empty" });
+  });
+
+  test("other flows only → honest empty for this flow", () => {
+    const runs = [run({ id: "a", flow: "other.flow", startedAt: 999_000 })];
+    expect(flowActivitySummary(runs, "bookings.create", 1_000_000)).toEqual({ kind: "empty" });
+  });
+
+  test("in-window runs → real call count + error rate", () => {
+    const now = 1_000_000;
+    const windowMs = 60_000;
+    const runs = [
+      run({ id: "new", flow: "bookings.create", startedAt: now - 1_000, error: "FlightFull" }),
+      run({ id: "ok", flow: "bookings.create", startedAt: now - 2_000 }),
+      run({ id: "old", flow: "bookings.create", startedAt: now - 120_000 }),
+      run({ id: "noise", flow: "other.flow", startedAt: now - 500 }),
+    ];
+    const summary = flowActivitySummary(runs, "bookings.create", now, windowMs);
+    expect(summary).toEqual({
+      kind: "summary",
+      calls: 2,
+      errors: 1,
+      errorRate: 0.5,
+      lastStartedAt: now - 1_000,
+      latestRunId: "new",
+      windowMs,
+    });
+  });
+
+  test("all matching runs outside window → honest empty", () => {
+    const now = 1_000_000;
+    const runs = [run({ id: "stale", flow: "bookings.create", startedAt: now - 3_600_000 })];
+    expect(flowActivitySummary(runs, "bookings.create", now, 60_000)).toEqual({ kind: "empty" });
+  });
+});

package/src/console/ui-next/src/features/units/lib/flow-activity.ts

@@ -0,0 +1,68 @@
+/**
+ * Recent activity summary for one flow — scoped from the real runs buffer.
+ *
+ * Empty buffer / no in-window rows → honest empty (never "0 calls" as fake data).
+ */
+
+import type { RunRow } from "@/client.ts";
+import { scopeRunsToFlows } from "@/features/flows/traces/scope-runs.ts";
+
+/** Default lookback window for the Units activity strip (1 hour). */
+export const FLOW_ACTIVITY_WINDOW_MS = 60 * 60 * 1000;
+
+/** Honest empty — no buffered runs for this flow in the window. */
+export type FlowActivityEmpty = {
+  readonly kind: "empty";
+};
+
+/** Real counts derived from buffered runs. */
+export type FlowActivityStats = {
+  readonly kind: "summary";
+  readonly calls: number;
+  readonly errors: number;
+  /** `errors / calls` in `[0, 1]`. */
+  readonly errorRate: number;
+  readonly lastStartedAt: number;
+  readonly latestRunId: string;
+  readonly windowMs: number;
+};
+
+/** Activity strip projection. */
+export type FlowActivitySummary = FlowActivityEmpty | FlowActivityStats;
+
+/**
+ * Summarize recent runs for one flow from the Console runs buffer.
+ *
+ * Uses {@link scopeRunsToFlows} then a time window. When nothing matches,
+ * returns `{ kind: "empty" }` — callers must not invent zeros.
+ *
+ * @param runs - Full runs buffer (may include other flows)
+ * @param flowId - Selected flow id
+ * @param nowMs - Clock (injectable for tests)
+ * @param windowMs - Lookback window
+ */
+export function flowActivitySummary(
+  runs: readonly RunRow[],
+  flowId: string,
+  nowMs: number,
+  windowMs: number = FLOW_ACTIVITY_WINDOW_MS,
+): FlowActivitySummary {
+  const scoped = scopeRunsToFlows(runs, new Set([flowId]));
+  const cutoff = nowMs - windowMs;
+  const inWindow = scoped.filter((r) => r.startedAt >= cutoff);
+  if (inWindow.length === 0) {
+    return { kind: "empty" };
+  }
+
+  const errors = inWindow.filter((r) => r.error != null && r.error.length > 0).length;
+  const latest = inWindow[0]!;
+  return {
+    kind: "summary",
+    calls: inWindow.length,
+    errors,
+    errorRate: errors / inWindow.length,
+    lastStartedAt: latest.startedAt,
+    latestRunId: latest.id,
+    windowMs,
+  };
+}

package/src/console/ui-next/src/features/units/lib/flow-trigger.test.ts

@@ -0,0 +1,63 @@
+/**
+ * Unit tests for Manifest flow trigger → icon mapping.
+ */
+
+import { describe, expect, test } from "bun:test";
+import {
+  ApiIcon,
+  Calendar03Icon,
+  FunctionCircleIcon,
+  Timer01Icon,
+} from "@hugeicons/core-free-icons";
+import { ELEMENT_ICONS } from "@/lib/element-icons.ts";
+import { flowTriggerSpec } from "./flow-trigger.ts";
+
+describe("flowTriggerSpec", () => {
+  test("maps each trigger kind to a distinct glyph", () => {
+    expect(flowTriggerSpec({ http: { method: "POST", path: "/x" } })).toMatchObject({
+      kind: "http",
+      icon: ApiIcon,
+      label: "HTTP",
+      detail: "POST /x",
+    });
+    expect(flowTriggerSpec({ signal: "order-placed" })).toMatchObject({
+      kind: "signal",
+      icon: ELEMENT_ICONS.signal.icon,
+      label: "Signal",
+      detail: "order-placed",
+    });
+    expect(flowTriggerSpec({ cron: "0 0 * * *" })).toMatchObject({
+      kind: "cron",
+      icon: Calendar03Icon,
+      label: "Cron",
+      detail: "0 0 * * *",
+    });
+    expect(flowTriggerSpec({ every: "5m" })).toMatchObject({
+      kind: "every",
+      icon: Timer01Icon,
+      label: "Every",
+      detail: "5m",
+    });
+    expect(flowTriggerSpec({ cdc: { table: "orders" } })).toMatchObject({
+      kind: "cdc",
+      icon: ELEMENT_ICONS.store.icon,
+      label: "CDC",
+      detail: "orders",
+    });
+  });
+
+  test("call-only flows use the function glyph (not HTTP)", () => {
+    expect(flowTriggerSpec(undefined)).toMatchObject({
+      kind: "internal",
+      icon: FunctionCircleIcon,
+      label: "Call-only",
+      detail: null,
+    });
+    expect(flowTriggerSpec({})).toMatchObject({ kind: "internal", detail: null });
+  });
+
+  test("prefers http when multiple triggers are declared", () => {
+    const spec = flowTriggerSpec({ http: { method: "GET", path: "/a" }, signal: "s" });
+    expect(spec.kind).toBe("http");
+  });
+});

package/src/console/ui-next/src/features/units/lib/flow-trigger.ts

@@ -0,0 +1,120 @@
+/**
+ * Trigger-kind resolution for Manifest flows (Units tree + contract header).
+ *
+ * Icons stay in the eight-element family used by Traces ({@link triggerIconSpec}),
+ * with sibling glyphs where two kinds share an element so the Units tree can
+ * tell them apart at a glance: HTTP vs call-only (Flow), cron vs every (Clock).
+ */
+
+import {
+  ApiIcon,
+  Calendar03Icon,
+  FunctionCircleIcon,
+  Timer01Icon,
+} from "@hugeicons/core-free-icons";
+import type { Trigger } from "../../../../../../manifest/types.ts";
+import { ELEMENT_ICONS, type ElementHugeIcon } from "@/lib/element-icons.ts";
+
+/** Manifest trigger kinds in priority order when several are declared. */
+export type FlowTriggerKind = "http" | "signal" | "cron" | "every" | "cdc" | "internal";
+
+/** All trigger kinds in canonical display order (facet chips, legends). */
+export const FLOW_TRIGGER_KINDS: readonly FlowTriggerKind[] = [
+  "http",
+  "signal",
+  "cron",
+  "every",
+  "cdc",
+  "internal",
+];
+
+/** Static icon + label + icon-well tint per trigger kind. */
+export const FLOW_TRIGGER_KIND_SPECS: Record<
+  FlowTriggerKind,
+  {
+    readonly icon: ElementHugeIcon;
+    readonly label: string;
+    /** Border / fill / text classes for a size-5 icon well. */
+    readonly wellClass: string;
+  }
+> = {
+  http: {
+    icon: ApiIcon,
+    label: "HTTP",
+    wellClass: "border-sky-500/35 bg-sky-500/10 text-sky-600 dark:text-sky-400",
+  },
+  signal: {
+    icon: ELEMENT_ICONS.signal.icon,
+    label: "Signal",
+    wellClass: "border-amber-500/35 bg-amber-500/10 text-amber-700 dark:text-amber-400",
+  },
+  cron: {
+    icon: Calendar03Icon,
+    label: "Cron",
+    wellClass: "border-violet-500/35 bg-violet-500/10 text-violet-700 dark:text-violet-400",
+  },
+  every: {
+    icon: Timer01Icon,
+    label: "Every",
+    wellClass: "border-teal-500/35 bg-teal-500/10 text-teal-700 dark:text-teal-400",
+  },
+  cdc: {
+    icon: ELEMENT_ICONS.store.icon,
+    label: "CDC",
+    wellClass: "border-emerald-500/35 bg-emerald-500/10 text-emerald-700 dark:text-emerald-400",
+  },
+  internal: {
+    icon: FunctionCircleIcon,
+    label: "Call-only",
+    wellClass: "border-zinc-500/35 bg-zinc-500/10 text-zinc-600 dark:text-zinc-400",
+  },
+};
+
+/** Visual + accessible descriptor for one trigger kind. */
+export type FlowTriggerSpec = {
+  readonly kind: FlowTriggerKind;
+  readonly icon: ElementHugeIcon;
+  /** Short noun ("HTTP", "Signal") for tooltips / a11y. */
+  readonly label: string;
+  /** Kind detail — cron expression, signal name, cdc table. */
+  readonly detail: string | null;
+  /** Icon-well tint shared with the Units band header. */
+  readonly wellClass: string;
+};
+
+/**
+ * Resolve the trigger kind for a Manifest flow (priority order).
+ *
+ * @param trigger - Manifest `flow.trigger` (undefined → call-only internal)
+ */
+export function flowTriggerKind(trigger: Trigger | undefined): FlowTriggerKind {
+  if (trigger?.http) return "http";
+  if (trigger?.signal) return "signal";
+  if (trigger?.cron) return "cron";
+  if (trigger?.every) return "every";
+  if (trigger?.cdc) return "cdc";
+  return "internal";
+}
+
+/**
+ * Resolve the trigger kind + icon for a Manifest flow.
+ *
+ * @param trigger - Manifest `flow.trigger` (undefined → call-only internal)
+ */
+export function flowTriggerSpec(trigger: Trigger | undefined): FlowTriggerSpec {
+  const kind = flowTriggerKind(trigger);
+  const base = FLOW_TRIGGER_KIND_SPECS[kind];
+  let detail: string | null = null;
+  if (kind === "http" && trigger?.http) detail = `${trigger.http.method} ${trigger.http.path}`;
+  else if (kind === "signal" && trigger?.signal) detail = trigger.signal;
+  else if (kind === "cron" && trigger?.cron) detail = trigger.cron;
+  else if (kind === "every" && trigger?.every) detail = trigger.every;
+  else if (kind === "cdc" && trigger?.cdc) detail = trigger.cdc.table;
+  return {
+    kind,
+    icon: base.icon,
+    label: base.label,
+    detail,
+    wellClass: base.wellClass,
+  };
+}

package/src/console/ui-next/src/features/units/lib/invoke-cache.test.ts

@@ -0,0 +1,31 @@
+/**
+ * Unit tests for Call API cache glyph gating.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { FlashIcon, FlashOffIcon, UnavailableIcon } from "@hugeicons/core-free-icons";
+import { invokeCacheSpec } from "./invoke-cache.ts";
+
+describe("invokeCacheSpec", () => {
+  test("hit / miss / none match traces", () => {
+    expect(invokeCacheSpec("hit")).toMatchObject({
+      icon: FlashIcon,
+      label: "Cache hit",
+    });
+    expect(invokeCacheSpec("miss")).toMatchObject({
+      icon: FlashOffIcon,
+      label: "Cache miss",
+    });
+    expect(invokeCacheSpec("none")).toMatchObject({
+      icon: UnavailableIcon,
+      label: "Cache not applicable",
+      className: "text-muted-foreground",
+    });
+  });
+
+  test("omitted host cache is none, not a hit", () => {
+    const omitted = invokeCacheSpec(undefined);
+    expect(omitted.icon).toBe(UnavailableIcon);
+    expect(omitted.label).toBe("Cache not applicable");
+  });
+});

package/src/console/ui-next/src/features/units/lib/invoke-cache.ts

@@ -0,0 +1,22 @@
+/**
+ * Call API cache glyph — same traces hit / miss / none marks.
+ */
+
+import {
+  cacheIconSpec,
+  type CacheIconSpec,
+  type RunCache,
+} from "@/features/flows/traces/cache-icon.ts";
+
+/**
+ * Traces cache spec for an invoke envelope.
+ *
+ * Omitted host `cache` is `none` (not applicable) — never invent a hit.
+ *
+ * @param cache - Invoke envelope `cache`, when the host reported one
+ */
+export function invokeCacheSpec(cache: RunCache | undefined): CacheIconSpec {
+  const spec = cacheIconSpec(cache ?? "none");
+  if ((cache ?? "none") !== "none") return spec;
+  return { ...spec, className: "text-muted-foreground" };
+}