npm - @x12i/memorix-client-api - Versions diffs - 0.0.0-stage → 0.16.0 - Mend

@x12i/memorix-client-api 0.0.0-stage → 0.16.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (108) hide show

package/HANDOVER.md +97 -0
package/dist/app.d.ts +64 -0
package/dist/app.d.ts.map +1 -0
package/dist/app.js +412 -0
package/dist/app.js.map +1 -0
package/dist/authix.d.ts +9 -0
package/dist/authix.d.ts.map +1 -0
package/dist/authix.js +26 -0
package/dist/authix.js.map +1 -0
package/dist/catalog.d.ts +160 -0
package/dist/catalog.d.ts.map +1 -0
package/dist/catalog.js +371 -0
package/dist/catalog.js.map +1 -0
package/dist/cli.d.ts +2 -0
package/dist/cli.d.ts.map +1 -0
package/dist/cli.js +102 -0
package/dist/cli.js.map +1 -0
package/dist/config.d.ts +33 -0
package/dist/config.d.ts.map +1 -0
package/dist/config.js +109 -0
package/dist/config.js.map +1 -0
package/dist/derived.d.ts +2 -0
package/dist/derived.d.ts.map +1 -0
package/dist/derived.js +35 -0
package/dist/derived.js.map +1 -0
package/dist/errors.d.ts +11 -0
package/dist/errors.d.ts.map +1 -0
package/dist/errors.js +21 -0
package/dist/errors.js.map +1 -0
package/dist/fetch.d.ts +17 -0
package/dist/fetch.d.ts.map +1 -0
package/dist/fetch.js +741 -0
package/dist/fetch.js.map +1 -0
package/dist/index.d.ts +4 -0
package/dist/index.d.ts.map +1 -0
package/dist/index.js +4 -0
package/dist/index.js.map +1 -0
package/dist/live-ops-nav.d.ts +2 -0
package/dist/live-ops-nav.d.ts.map +1 -0
package/dist/live-ops-nav.js +42 -0
package/dist/live-ops-nav.js.map +1 -0
package/dist/live.d.ts +20 -0
package/dist/live.d.ts.map +1 -0
package/dist/live.js +8 -0
package/dist/live.js.map +1 -0
package/dist/markdown.d.ts +19 -0
package/dist/markdown.d.ts.map +1 -0
package/dist/markdown.js +102 -0
package/dist/markdown.js.map +1 -0
package/dist/peers.d.ts +51 -0
package/dist/peers.d.ts.map +1 -0
package/dist/peers.js +127 -0
package/dist/peers.js.map +1 -0
package/dist/processed.d.ts +22 -0
package/dist/processed.d.ts.map +1 -0
package/dist/processed.js +397 -0
package/dist/processed.js.map +1 -0
package/dist/project.d.ts +25 -0
package/dist/project.d.ts.map +1 -0
package/dist/project.js +76 -0
package/dist/project.js.map +1 -0
package/dist/reads-live-routes.d.ts +4 -0
package/dist/reads-live-routes.d.ts.map +1 -0
package/dist/reads-live-routes.js +56 -0
package/dist/reads-live-routes.js.map +1 -0
package/dist/reads-live-ui.d.ts +3 -0
package/dist/reads-live-ui.d.ts.map +1 -0
package/dist/reads-live-ui.js +204 -0
package/dist/reads-live-ui.js.map +1 -0
package/dist/reads-ring.d.ts +29 -0
package/dist/reads-ring.d.ts.map +1 -0
package/dist/reads-ring.js +44 -0
package/dist/reads-ring.js.map +1 -0
package/dist/refs.d.ts +24 -0
package/dist/refs.d.ts.map +1 -0
package/dist/refs.js +354 -0
package/dist/refs.js.map +1 -0
package/dist/request-countex.d.ts +53 -0
package/dist/request-countex.d.ts.map +1 -0
package/dist/request-countex.js +171 -0
package/dist/request-countex.js.map +1 -0
package/dist/scope.d.ts +13 -0
package/dist/scope.d.ts.map +1 -0
package/dist/scope.js +46 -0
package/dist/scope.js.map +1 -0
package/dist/scoper.d.ts +75 -0
package/dist/scoper.d.ts.map +1 -0
package/dist/scoper.js +475 -0
package/dist/scoper.js.map +1 -0
package/dist/shaped-refs.d.ts +23 -0
package/dist/shaped-refs.d.ts.map +1 -0
package/dist/shaped-refs.js +395 -0
package/dist/shaped-refs.js.map +1 -0
package/dist/skills.d.ts +102 -0
package/dist/skills.d.ts.map +1 -0
package/dist/skills.js +609 -0
package/dist/skills.js.map +1 -0
package/dist/story.d.ts +43 -0
package/dist/story.d.ts.map +1 -0
package/dist/story.js +121 -0
package/dist/story.js.map +1 -0
package/dist/upstream.d.ts +13 -0
package/dist/upstream.d.ts.map +1 -0
package/dist/upstream.js +58 -0
package/dist/upstream.js.map +1 -0
package/openapi/openapi.json +480 -0
package/package.json +60 -6
package/README.md +0 -3

package/dist/reads-live-ui.js ADDED Viewed

@@ -0,0 +1,204 @@
+/** HTML for GET /_live/reads — which org and agents each caller read. */
+export function readsLiveHtml() {
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Memorix client API · Reads</title>
+  <link rel="preconnect" href="https://fonts.googleapis.com" />
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+  <link href="https://fonts.googleapis.com/css2?family=IBM+Plex+Sans:wght@400;500;600;700&family=IBM+Plex+Mono:wght@400;500&display=swap" rel="stylesheet" />
+  <style>
+    :root {
+      --bg: #0a0c10; --bg-elev: #10141b; --bg-row: #141922; --line: #242b38;
+      --text: #e8ebe6; --muted: #8a9288; --dim: #5c645c;
+      --bad: #e25a5a; --accent: #c8f082;
+      --sans: "IBM Plex Sans", system-ui, sans-serif;
+      --mono: "IBM Plex Mono", ui-monospace, monospace;
+    }
+    * { box-sizing: border-box; }
+    html, body { margin: 0; }
+    body {
+      font-family: var(--sans);
+      background:
+        radial-gradient(1200px 600px at 10% -10%, #1a2214 0%, transparent 55%),
+        radial-gradient(900px 500px at 100% 0%, #121820 0%, transparent 50%),
+        var(--bg);
+      color: var(--text); font-size: 14px; line-height: 1.45;
+    }
+    a { color: var(--accent); }
+    .shell { max-width: 1280px; margin: 0 auto; padding: 36px 28px 64px; }
+    header {
+      display: flex; align-items: flex-end; justify-content: space-between; gap: 24px;
+      margin-bottom: 22px; padding-bottom: 18px; border-bottom: 1px solid var(--line);
+    }
+    .brand { font-size: 26px; font-weight: 700; letter-spacing: -0.03em; }
+    .brand span { color: var(--accent); }
+    .sub { margin-top: 8px; color: var(--muted); font-size: 13px; max-width: 72ch; }
+    .meta { text-align: right; font-family: var(--mono); font-size: 11px; color: var(--dim); display: grid; gap: 4px; }
+    .toolbar { display: flex; flex-wrap: wrap; gap: 10px; align-items: center; margin-bottom: 16px; }
+    .btn, input {
+      appearance: none; border: 1px solid var(--line); background: var(--bg-row); color: var(--text);
+      font: 500 12px/1 var(--sans); padding: 10px 14px; border-radius: 2px;
+    }
+    input { min-width: 280px; font-family: var(--mono); }
+    .btn { cursor: pointer; }
+    .btn:hover, input:focus { border-color: var(--accent); outline: none; }
+    .cards { display: grid; grid-template-columns: repeat(auto-fit, minmax(140px, 1fr)); gap: 10px; margin-bottom: 18px; }
+    .card { background: var(--bg-elev); border: 1px solid var(--line); padding: 12px 14px; }
+    .card h3 {
+      margin: 0 0 6px; font-family: var(--mono); font-size: 10px; letter-spacing: 0.08em;
+      text-transform: uppercase; color: var(--dim); font-weight: 500;
+    }
+    .card .val { font-family: var(--mono); font-size: 22px; font-weight: 600; }
+    .card .val.time { font-size: 13px; font-weight: 500; }
+    h2 {
+      margin: 22px 0 10px; font-size: 12px; font-family: var(--mono);
+      letter-spacing: 0.08em; text-transform: uppercase; color: var(--dim); font-weight: 500;
+    }
+    table { width: 100%; border-collapse: collapse; background: var(--bg-elev); border: 1px solid var(--line); margin-bottom: 18px; }
+    th, td { text-align: left; padding: 8px 10px; border-bottom: 1px solid var(--line); vertical-align: top; }
+    th {
+      font-family: var(--mono); font-size: 10px; letter-spacing: 0.08em; text-transform: uppercase;
+      color: var(--dim); font-weight: 500; background: #0d1016;
+    }
+    tr:last-child td { border-bottom: 0; }
+    tr.group-head td {
+      background: #0d1016; color: var(--accent); font-family: var(--mono); font-size: 12px; font-weight: 600;
+    }
+    .mono { font-family: var(--mono); font-size: 12px; }
+    .muted { color: var(--muted); }
+    .bad { color: var(--bad); }
+    .chips { display: flex; flex-wrap: wrap; gap: 4px; }
+    .chip {
+      font-family: var(--mono); font-size: 11px; padding: 2px 6px;
+      border: 1px solid var(--line); color: var(--text); background: #0d1016;
+    }
+    .err { color: var(--bad); margin: 8px 0; }
+    footer { margin-top: 28px; color: var(--dim); font-size: 12px; }
+    .empty { color: var(--muted); padding: 16px; border: 1px solid var(--line); background: var(--bg-elev); }
+  </style>
+</head>
+<body>
+  <div class="shell">
+    <header>
+      <div>
+        <div class="brand">Memorix client API <span>reads</span></div>
+        <p class="sub">Which org and which agents did each caller read?</p>
+      </div>
+      <div class="meta">
+        <div><strong>UI</strong> /_live/reads</div>
+        <div><strong>API</strong> /_live/api/reads</div>
+        <div><a href="/_live">← live view</a></div>
+      </div>
+    </header>
+    <div class="toolbar">
+      <input id="q" type="search" placeholder="caller, org, agent, path" aria-label="Search" />
+      <button class="btn" id="refresh" type="button">Refresh</button>
+      <span class="mono muted" id="asof"></span>
+    </div>
+    <div class="cards" id="cards"></div>
+    <div id="error" class="err" hidden></div>
+    <div id="table"></div>
+    <footer>Refreshes every 20 seconds. The table lists the newest 500 reads held in this process. Record bodies stay on the API.</footer>
+  </div>
+  <script>
+    const q = document.getElementById("q");
+    const cards = document.getElementById("cards");
+    const tableEl = document.getElementById("table");
+    const errorEl = document.getElementById("error");
+    const asof = document.getElementById("asof");
+    let snapshot = null;
+    function esc(s) {
+      return String(s ?? "").replace(/[&<>"']/g, (c) => ({
+        "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;"
+      }[c]));
+    }
+    function when(iso) {
+      if (!iso) return "—";
+      const d = new Date(iso);
+      return Number.isNaN(d.getTime()) ? String(iso) : d.toLocaleString();
+    }
+    function card(label, value, time) {
+      const cls = time ? "val time" : "val";
+      return '<div class="card"><h3>' + esc(label) + '</h3><div class="' + cls + '">' + esc(value) + "</div></div>";
+    }
+    function render() {
+      const summary = (snapshot && snapshot.summary) || {};
+      const needle = q.value.trim().toLowerCase();
+      const reads = ((snapshot && snapshot.reads) || []).filter((row) => {
+        if (!needle) return true;
+        const hay = [row.caller, row.orgId, (row.agentIds || []).join(" "), row.path, row.method, row.statusCode]
+          .join(" ").toLowerCase();
+        return hay.includes(needle);
+      });
+      const cardsHtml =
+        card("Reads", summary.reads ?? 0) +
+        card("Callers", summary.callers ?? 0) +
+        card("Orgs", summary.orgs ?? 0) +
+        card("Agents", summary.agents ?? 0) +
+        card("Errors", summary.errors ?? 0) +
+        card("Last read", summary.lastAt ? when(summary.lastAt) : "—", true);
+      let tableHtml = "";
+      if (!snapshot || !(snapshot.reads || []).length) {
+        tableHtml = '<div class="empty">No reads yet. This process has not completed a /api/v1 call.</div>';
+      } else if (!reads.length) {
+        tableHtml = '<div class="empty">No reads match this search.</div>';
+      } else {
+        const groups = new Map();
+        for (const row of reads) {
+          const key = row.caller || "unknown";
+          const list = groups.get(key) || [];
+          list.push(row);
+          groups.set(key, list);
+        }
+        tableHtml = '<table><thead><tr><th>When</th><th>Org</th><th>Agents</th><th>Path</th><th>Status</th><th>ms</th></tr></thead><tbody>';
+        for (const [caller, rows] of groups) {
+          tableHtml += '<tr class="group-head"><td colspan="6">' + esc(caller) + " · " + rows.length + "</td></tr>";
+          for (const row of rows) {
+            const agents = (row.agentIds || []).length
+              ? '<div class="chips">' + row.agentIds.map((id) => '<span class="chip">' + esc(id) + "</span>").join("") + "</div>"
+              : '<span class="muted">—</span>';
+            const statusCls = row.statusCode >= 400 ? "mono bad" : "mono";
+            tableHtml += "<tr><td class='mono'>" + esc(when(row.at)) + "</td><td class='mono'>" + esc(row.orgId || "—") +
+              "</td><td>" + agents + "</td><td class='mono'>" + esc(row.method) + " " + esc(row.path) +
+              "</td><td class='" + statusCls + "'>" + esc(row.statusCode) + "</td><td class='mono'>" + esc(row.durationMs) + "</td></tr>";
+          }
+        }
+        tableHtml += "</tbody></table>";
+      }
+      const markup = cardsHtml + "\\n" + tableHtml;
+      if (tableEl.dataset.markup === markup) return;
+      tableEl.dataset.markup = markup;
+      cards.innerHTML = cardsHtml;
+      tableEl.innerHTML = tableHtml;
+    }
+    async function load() {
+      try {
+        const res = await fetch("/_live/api/reads");
+        if (!res.ok) throw new Error("reads " + res.status);
+        snapshot = await res.json();
+        errorEl.hidden = true;
+        asof.textContent = snapshot.generatedAt ? new Date(snapshot.generatedAt).toLocaleString() : "";
+        render();
+      } catch (err) {
+        errorEl.hidden = false;
+        errorEl.textContent = err && err.message ? err.message : String(err);
+      }
+    }
+    q.addEventListener("input", render);
+    document.getElementById("refresh").addEventListener("click", load);
+    load();
+    setInterval(load, 20000);
+  </script>
+</body>
+</html>`;
+}
+//# sourceMappingURL=reads-live-ui.js.map

package/dist/reads-live-ui.js.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"reads-live-ui.js","sourceRoot":"","sources":["../src/reads-live-ui.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,MAAM,UAAU,aAAa;IAC3B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAuMD,CAAC;AACT,CAAC"}

package/dist/reads-ring.d.ts ADDED Viewed

@@ -0,0 +1,29 @@
+/** Recent /api/v1 reads for /_live/reads. Ids and status only. No bodies, tokens, or grants. */
+export type ReadEvent = {
+    at: string;
+    caller: string;
+    orgId: string;
+    agentIds: string[];
+    method: string;
+    path: string;
+    statusCode: number;
+    durationMs: number;
+};
+export type ReadsSnapshot = {
+    summary: {
+        reads: number;
+        callers: number;
+        orgs: number;
+        agents: number;
+        errors: number;
+        lastAt: string | null;
+        shown: number;
+    };
+    reads: ReadEvent[];
+};
+export type ReadRing = {
+    record: (event: ReadEvent) => void;
+    snapshot: () => ReadsSnapshot;
+};
+export declare function createReadRing(capacity?: number): ReadRing;
+//# sourceMappingURL=reads-ring.d.ts.map

package/dist/reads-ring.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"reads-ring.d.ts","sourceRoot":"","sources":["../src/reads-ring.ts"],"names":[],"mappings":"AAAA,gGAAgG;AAKhG,MAAM,MAAM,SAAS,GAAG;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE;QACP,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QACtB,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IACF,KAAK,EAAE,SAAS,EAAE,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IACrB,MAAM,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;IACnC,QAAQ,EAAE,MAAM,aAAa,CAAC;CAC/B,CAAC;AAEF,wBAAgB,cAAc,CAAC,QAAQ,SAAmB,GAAG,QAAQ,CAkCpE"}

package/dist/reads-ring.js ADDED Viewed

@@ -0,0 +1,44 @@
+/** Recent /api/v1 reads for /_live/reads. Ids and status only. No bodies, tokens, or grants. */
+const DEFAULT_CAPACITY = 10_000;
+const SHOWN = 500;
+export function createReadRing(capacity = DEFAULT_CAPACITY) {
+    const events = [];
+    return {
+        record(event) {
+            events.push(event);
+            while (events.length > capacity)
+                events.shift();
+        },
+        snapshot() {
+            const callers = new Set();
+            const orgs = new Set();
+            const agents = new Set();
+            let errors = 0;
+            for (const event of events) {
+                if (event.caller)
+                    callers.add(event.caller);
+                if (event.orgId)
+                    orgs.add(event.orgId);
+                for (const agentId of event.agentIds)
+                    agents.add(agentId);
+                if (event.statusCode >= 400)
+                    errors += 1;
+            }
+            const reads = events.slice(-SHOWN).reverse();
+            const last = events[events.length - 1];
+            return {
+                summary: {
+                    reads: events.length,
+                    callers: callers.size,
+                    orgs: orgs.size,
+                    agents: agents.size,
+                    errors,
+                    lastAt: last?.at ?? null,
+                    shown: reads.length,
+                },
+                reads,
+            };
+        },
+    };
+}
+//# sourceMappingURL=reads-ring.js.map

package/dist/reads-ring.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"reads-ring.js","sourceRoot":"","sources":["../src/reads-ring.ts"],"names":[],"mappings":"AAAA,gGAAgG;AAEhG,MAAM,gBAAgB,GAAG,MAAM,CAAC;AAChC,MAAM,KAAK,GAAG,GAAG,CAAC;AA+BlB,MAAM,UAAU,cAAc,CAAC,QAAQ,GAAG,gBAAgB;IACxD,MAAM,MAAM,GAAgB,EAAE,CAAC;IAC/B,OAAO;QACL,MAAM,CAAC,KAAK;YACV,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACnB,OAAO,MAAM,CAAC,MAAM,GAAG,QAAQ;gBAAE,MAAM,CAAC,KAAK,EAAE,CAAC;QAClD,CAAC;QACD,QAAQ;YACN,MAAM,OAAO,GAAG,IAAI,GAAG,EAAU,CAAC;YAClC,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;YAC/B,MAAM,MAAM,GAAG,IAAI,GAAG,EAAU,CAAC;YACjC,IAAI,MAAM,GAAG,CAAC,CAAC;YACf,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;gBAC3B,IAAI,KAAK,CAAC,MAAM;oBAAE,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;gBAC5C,IAAI,KAAK,CAAC,KAAK;oBAAE,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;gBACvC,KAAK,MAAM,OAAO,IAAI,KAAK,CAAC,QAAQ;oBAAE,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;gBAC1D,IAAI,KAAK,CAAC,UAAU,IAAI,GAAG;oBAAE,MAAM,IAAI,CAAC,CAAC;YAC3C,CAAC;YACD,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC;YAC7C,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;YACvC,OAAO;gBACL,OAAO,EAAE;oBACP,KAAK,EAAE,MAAM,CAAC,MAAM;oBACpB,OAAO,EAAE,OAAO,CAAC,IAAI;oBACrB,IAAI,EAAE,IAAI,CAAC,IAAI;oBACf,MAAM,EAAE,MAAM,CAAC,IAAI;oBACnB,MAAM;oBACN,MAAM,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI;oBACxB,KAAK,EAAE,KAAK,CAAC,MAAM;iBACpB;gBACD,KAAK;aACN,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/refs.d.ts ADDED Viewed

@@ -0,0 +1,24 @@
+import { type FieldView, type ObjectTypeView } from "./catalog.js";
+import type { ClientScope } from "./scope.js";
+import { type Upstream } from "./upstream.js";
+/** A referred record inlined in place of a record id. */
+export type ResolvedRecord = {
+    recordId: string;
+    objectType: string;
+    contentType: string;
+    data: unknown;
+};
+export declare function referenceKey(objectType: string, recordId: string): string;
+export declare function isResolvedRecord(value: unknown): value is ResolvedRecord;
+export declare function mergeReferenceTargets(into: Map<string, Set<string>>, extra: ReadonlyMap<string, ReadonlySet<string>>): void;
+/** Record ids named by `refersTo` fields on this response. */
+export declare function collectReferenceTargets(contents: Record<string, unknown> | null, fieldsByType: Map<string, FieldView[]>, shape: "record" | "envelope" | "data"): Map<string, Set<string>>;
+/** Replace record ids with the records already loaded for those ids. */
+export declare function expandReferenceData(data: unknown, fields: FieldView[], resolved?: ReadonlyMap<string, ResolvedRecord>): unknown;
+/**
+ * Load the records named by `refersTo` fields.
+ * Match `recordId` first, then identifier fields declared on the leading content type.
+ * A failed lookup leaves that id unresolved.
+ */
+export declare function loadResolvedReferences(upstream: Upstream, scope: ClientScope, catalog: ObjectTypeView[], targets: ReadonlyMap<string, ReadonlySet<string>>): Promise<Map<string, ResolvedRecord>>;
+//# sourceMappingURL=refs.d.ts.map

package/dist/refs.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"refs.d.ts","sourceRoot":"","sources":["../src/refs.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,SAAS,EACd,KAAK,cAAc,EACpB,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EAAY,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AAExD,yDAAyD;AACzD,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AAaF,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEzE;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc,CAUxE;AA6FD,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,EAC9B,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC,GAC9C,IAAI,CASN;AAED,8DAA8D;AAC9D,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,EACxC,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,EACtC,KAAK,EAAE,QAAQ,GAAG,UAAU,GAAG,MAAM,GACpC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAiB1B;AA+ED,wEAAwE;AACxE,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,SAAS,EAAE,EACnB,QAAQ,GAAE,WAAW,CAAC,MAAM,EAAE,cAAc,CAAe,GAC1D,OAAO,CAaT;AAsFD;;;;GAIG;AACH,wBAAsB,sBAAsB,CAC1C,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,cAAc,EAAE,EACzB,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC,GAChD,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAqBtC"}

package/dist/refs.js ADDED Viewed

@@ -0,0 +1,354 @@
+import { findContentType, findObjectType, } from "./catalog.js";
+import { UpstreamError } from "./errors.js";
+import { asRecord } from "./upstream.js";
+const REF_ID_LIMIT = 200;
+const REF_CHUNK = 25;
+const REF_PAGES = 5;
+const CONTENT_TYPE_LIMIT = 5;
+const IDENTITY_FIELD_LIMIT = 8;
+const NO_RESOLVED = new Map();
+function isPlain(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export function referenceKey(objectType, recordId) {
+    return `${objectType}\u0000${recordId}`;
+}
+export function isResolvedRecord(value) {
+    if (!isPlain(value))
+        return false;
+    const keys = Object.keys(value);
+    if (keys.length !== 4)
+        return false;
+    return (typeof value.recordId === "string" &&
+        typeof value.objectType === "string" &&
+        typeof value.contentType === "string" &&
+        "data" in value);
+}
+function dataSegments(path) {
+    if (!path.startsWith("data."))
+        return null;
+    const segments = path.slice("data.".length).split(".").filter(Boolean);
+    return segments.length > 0 ? segments : null;
+}
+function referenceFields(fields) {
+    return fields.filter((field) => typeof field.refersTo?.objectType === "string" &&
+        field.refersTo.objectType.length > 0 &&
+        !(field.shapes && field.shapes.length > 0));
+}
+/** `displayName` / `title` / `name`, or a camelCase id such as `cveId`. */
+function identityLeaf(leaf) {
+    if (leaf === "displayName" || leaf === "title" || leaf === "name")
+        return true;
+    return leaf === "id" || leaf.endsWith("Id") || leaf.endsWith("_id") || leaf.endsWith("-id");
+}
+function identityFields(fields) {
+    return fields
+        .filter((field) => {
+        if (field.refersTo || field.enum?.length)
+            return false;
+        if (field.valueType !== "string")
+            return false;
+        const segments = dataSegments(field.path);
+        if (!segments || segments.length !== 1)
+            return false;
+        return identityLeaf(segments[0]);
+    })
+        .slice(0, IDENTITY_FIELD_LIMIT);
+}
+function eachId(value, visit) {
+    if (typeof value === "string") {
+        if (value.trim())
+            visit(value);
+        return;
+    }
+    if (!Array.isArray(value))
+        return;
+    for (const item of value) {
+        if (typeof item === "string" && item.trim())
+            visit(item);
+    }
+}
+function addIds(value, objectType, into) {
+    eachId(value, (id) => {
+        let set = into.get(objectType);
+        if (!set) {
+            set = new Set();
+            into.set(objectType, set);
+        }
+        set.add(id);
+    });
+}
+function collectDeepKey(value, key, objectType, into) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            collectDeepKey(item, key, objectType, into);
+        return;
+    }
+    if (!isPlain(value))
+        return;
+    for (const [childKey, child] of Object.entries(value)) {
+        if (childKey === key)
+            addIds(child, objectType, into);
+        else
+            collectDeepKey(child, key, objectType, into);
+    }
+}
+function collectAt(value, segments, objectType, into) {
+    if (segments.length === 0) {
+        addIds(value, objectType, into);
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value)
+            collectAt(item, segments, objectType, into);
+        return;
+    }
+    if (!isPlain(value))
+        return;
+    collectAt(value[segments[0]], segments.slice(1), objectType, into);
+}
+function readInstanceData(value, shape) {
+    if (shape === "data")
+        return value;
+    if (!isPlain(value))
+        return undefined;
+    return value.data;
+}
+export function mergeReferenceTargets(into, extra) {
+    for (const [objectType, ids] of extra) {
+        let set = into.get(objectType);
+        if (!set) {
+            set = new Set();
+            into.set(objectType, set);
+        }
+        for (const id of ids)
+            set.add(id);
+    }
+}
+/** Record ids named by `refersTo` fields on this response. */
+export function collectReferenceTargets(contents, fieldsByType, shape) {
+    const into = new Map();
+    for (const [contentType, list] of Object.entries(contents ?? {})) {
+        const fields = referenceFields(fieldsByType.get(contentType) ?? []);
+        if (fields.length === 0)
+            continue;
+        const values = Array.isArray(list) ? list : [];
+        for (const value of values) {
+            const data = readInstanceData(value, shape);
+            for (const field of fields) {
+                const segments = dataSegments(field.path);
+                if (!segments)
+                    continue;
+                if (segments.length === 1)
+                    collectDeepKey(data, segments[0], field.refersTo.objectType, into);
+                else
+                    collectAt(data, segments, field.refersTo.objectType, into);
+            }
+        }
+    }
+    return into;
+}
+function cloneResolved(hit) {
+    try {
+        return structuredClone(hit);
+    }
+    catch {
+        return { ...hit };
+    }
+}
+function substitute(value, objectType, resolved) {
+    if (typeof value === "string") {
+        const hit = resolved.get(referenceKey(objectType, value));
+        return hit ? cloneResolved(hit) : value;
+    }
+    if (!Array.isArray(value))
+        return value;
+    let changed = false;
+    const next = value.map((item) => {
+        if (typeof item !== "string")
+            return item;
+        const hit = resolved.get(referenceKey(objectType, item));
+        if (!hit)
+            return item;
+        changed = true;
+        return cloneResolved(hit);
+    });
+    return changed ? next : value;
+}
+function expandDeepKey(value, key, objectType, resolved) {
+    if (Array.isArray(value)) {
+        let changed = false;
+        const next = value.map((item) => {
+            const updated = expandDeepKey(item, key, objectType, resolved);
+            if (updated !== item)
+                changed = true;
+            return updated;
+        });
+        return changed ? next : value;
+    }
+    if (!isPlain(value))
+        return value;
+    let changed = false;
+    const next = {};
+    for (const [childKey, child] of Object.entries(value)) {
+        const updated = childKey === key
+            ? substitute(child, objectType, resolved)
+            : expandDeepKey(child, key, objectType, resolved);
+        if (updated !== child)
+            changed = true;
+        next[childKey] = updated;
+    }
+    return changed ? next : value;
+}
+function expandAt(value, segments, objectType, resolved) {
+    if (segments.length === 0)
+        return substitute(value, objectType, resolved);
+    if (Array.isArray(value)) {
+        let changed = false;
+        const next = value.map((item) => {
+            const updated = expandAt(item, segments, objectType, resolved);
+            if (updated !== item)
+                changed = true;
+            return updated;
+        });
+        return changed ? next : value;
+    }
+    if (!isPlain(value) || !Object.prototype.hasOwnProperty.call(value, segments[0]))
+        return value;
+    const key = segments[0];
+    const updated = expandAt(value[key], segments.slice(1), objectType, resolved);
+    if (updated === value[key])
+        return value;
+    return { ...value, [key]: updated };
+}
+/** Replace record ids with the records already loaded for those ids. */
+export function expandReferenceData(data, fields, resolved = NO_RESOLVED) {
+    const refs = referenceFields(fields);
+    if (refs.length === 0 || resolved.size === 0)
+        return data;
+    let current = data;
+    for (const field of refs) {
+        const segments = dataSegments(field.path);
+        if (!segments)
+            continue;
+        current =
+            segments.length === 1
+                ? expandDeepKey(current, segments[0], field.refersTo.objectType, resolved)
+                : expandAt(current, segments, field.refersTo.objectType, resolved);
+    }
+    return current;
+}
+function contentTypesToSearch(view) {
+    const ids = view.contentTypes.map((ct) => ct.id).filter((id) => id !== "relationships");
+    const leading = view.leadingContentType;
+    const ordered = leading && leading !== "relationships" ? [leading, ...ids.filter((id) => id !== leading)] : ids;
+    return ordered.slice(0, CONTENT_TYPE_LIMIT);
+}
+function chunks(items, size) {
+    const out = [];
+    for (let index = 0; index < items.length; index += size)
+        out.push(items.slice(index, index + size));
+    return out;
+}
+function contentPath(objectType, contentType, field, ids, cursor) {
+    const params = new URLSearchParams();
+    params.set("objectType", objectType);
+    params.set("contentType", contentType);
+    params.set("limit", String(Math.min(Math.max(ids.length, 1), 200)));
+    params.set("filter", JSON.stringify([{ field, op: "in", value: ids }]));
+    if (cursor)
+        params.set("cursor", cursor);
+    return `/api/data/content?${params.toString()}`;
+}
+function readDataPath(data, path) {
+    const segments = dataSegments(path);
+    if (!segments)
+        return null;
+    let current = data;
+    for (const segment of segments) {
+        if (!isPlain(current))
+            return null;
+        current = current[segment];
+    }
+    return typeof current === "string" && current.trim() ? current : null;
+}
+async function matchByField(upstream, scope, objectType, contentType, field, pending, resolved) {
+    const ids = [...pending];
+    for (const group of chunks(ids, REF_CHUNK)) {
+        const wanted = group.filter((id) => pending.has(id));
+        if (wanted.length === 0)
+            continue;
+        let cursor;
+        const seen = new Set();
+        for (let page = 0; page < REF_PAGES; page += 1) {
+            let body;
+            try {
+                body = await upstream.get(contentPath(objectType, contentType, field, wanted, cursor), scope);
+            }
+            catch (err) {
+                if (err instanceof UpstreamError)
+                    return;
+                throw err;
+            }
+            const root = asRecord(body);
+            const records = Array.isArray(root?.records) ? root.records : [];
+            for (const item of records) {
+                const row = asRecord(item);
+                if (!row)
+                    continue;
+                const recordId = typeof row.recordId === "string" ? row.recordId : "";
+                const matched = field === "recordId" ? recordId : readDataPath(row.data, field);
+                if (!matched || !pending.has(matched))
+                    continue;
+                pending.delete(matched);
+                const key = referenceKey(objectType, matched);
+                if (resolved.has(key))
+                    continue;
+                resolved.set(key, {
+                    recordId: recordId || matched,
+                    objectType,
+                    contentType,
+                    data: row.data ?? null,
+                });
+            }
+            const next = asRecord(root?.pageInfo)?.nextCursor;
+            if (typeof next !== "string" || !next || seen.has(next))
+                break;
+            seen.add(next);
+            cursor = next;
+        }
+    }
+}
+/**
+ * Load the records named by `refersTo` fields.
+ * Match `recordId` first, then identifier fields declared on the leading content type.
+ * A failed lookup leaves that id unresolved.
+ */
+export async function loadResolvedReferences(upstream, scope, catalog, targets) {
+    const resolved = new Map();
+    for (const [objectType, rawIds] of targets) {
+        const view = findObjectType(catalog, objectType);
+        if (!view)
+            continue;
+        const pending = new Set([...rawIds].filter((id) => id.trim()).slice(0, REF_ID_LIMIT));
+        if (pending.size === 0)
+            continue;
+        const contentTypes = contentTypesToSearch(view);
+        for (const contentType of contentTypes) {
+            if (pending.size === 0)
+                break;
+            await matchByField(upstream, scope, objectType, contentType, "recordId", pending, resolved);
+        }
+        const leading = contentTypes[0];
+        if (!leading || pending.size === 0)
+            continue;
+        const fields = findContentType(view, leading)?.fields ?? [];
+        for (const field of identityFields(fields)) {
+            if (pending.size === 0)
+                break;
+            await matchByField(upstream, scope, objectType, leading, field.path, pending, resolved);
+        }
+    }
+    return resolved;
+}
+//# sourceMappingURL=refs.js.map