@warmdrift/kgauto-compiler 2.0.0-alpha.7 → 2.0.0-alpha.71

package/dist/brain-proxy.js

@@ -0,0 +1,193 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/brain-proxy.ts
+var brain_proxy_exports = {};
+__export(brain_proxy_exports, {
+  createBrainForwardRoutes: () => createBrainForwardRoutes
+});
+module.exports = __toCommonJS(brain_proxy_exports);
+var SEGMENT_TO_TABLE = {
+  outcomes: "compile_outcomes",
+  compile_outcome_advisories: "compile_outcome_advisories",
+  compile_outcome_quality: "compile_outcome_quality",
+  probe_outcomes: "probe_outcomes",
+  // alpha.62 (eval spine): golden-set capture. Only receives rows when the
+  // consumer has explicitly opted in via KGAUTO_GOLDEN_CAPTURE — the segment
+  // existing here does not by itself store anything.
+  golden_irs: "kgauto_golden_irs"
+};
+var KNOWN_SEGMENTS = Object.keys(SEGMENT_TO_TABLE);
+var JSON_HEADERS = { "Content-Type": "application/json" };
+function jsonResponse(status, body) {
+  return new Response(JSON.stringify(body), { status, headers: JSON_HEADERS });
+}
+function bearerOf(req) {
+  const header = req.headers.get("Authorization") ?? "";
+  const match = /^Bearer\s+(.+)$/i.exec(header);
+  return match?.[1]?.trim() ?? "";
+}
+function requireString(name, value) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`createBrainForwardRoutes: ${name} is required`);
+  }
+  return value;
+}
+function isNumericOutcomeId(value) {
+  return typeof value === "number" || typeof value === "string" && /^\d+$/.test(value);
+}
+function createBrainForwardRoutes(config) {
+  const ingestSecret = requireString("ingestSecret", config.ingestSecret);
+  const brainUrl = requireString("brainUrl", config.brainUrl).replace(/\/+$/, "");
+  const serviceKey = requireString("serviceKey", config.serviceKey);
+  const fetchFn = config.fetchImpl ?? fetch;
+  async function resolveQualityOutcomeIds(body) {
+    const rows = Array.isArray(body) ? body : [body];
+    const handles = [
+      ...new Set(
+        rows.map((r) => r?.outcome_id).filter(
+          (v) => typeof v === "string" && !isNumericOutcomeId(v)
+        )
+      )
+    ];
+    if (handles.length === 0) return body;
+    const list = handles.map((h) => `"${h.replace(/"/g, "")}"`).join(",");
+    const url = `${brainUrl}/rest/v1/compile_outcomes?select=id,handle&handle=in.(${encodeURIComponent(list)})&order=id.desc`;
+    let idByHandle;
+    try {
+      const res = await fetchFn(url, {
+        headers: { apikey: serviceKey, Authorization: `Bearer ${serviceKey}` }
+      });
+      if (!res.ok) {
+        const text = await res.text().catch(() => "<no body>");
+        return jsonResponse(502, {
+          error: "handle-resolution-failed",
+          table: "compile_outcome_quality",
+          status: res.status,
+          detail: text
+        });
+      }
+      const found = await res.json();
+      idByHandle = /* @__PURE__ */ new Map();
+      for (const r of found) {
+        if (!idByHandle.has(r.handle)) idByHandle.set(r.handle, r.id);
+      }
+    } catch (err) {
+      return jsonResponse(502, {
+        error: "handle-resolution-failed",
+        table: "compile_outcome_quality",
+        detail: err instanceof Error ? err.message : String(err)
+      });
+    }
+    const unresolved = handles.filter((h) => !idByHandle.has(h));
+    if (unresolved.length > 0) {
+      return jsonResponse(404, {
+        error: "handle_not_found",
+        table: "compile_outcome_quality",
+        unresolved
+      });
+    }
+    const rewritten = rows.map(
+      (r) => typeof r?.outcome_id === "string" && idByHandle.has(r.outcome_id) ? { ...r, outcome_id: idByHandle.get(r.outcome_id) } : r
+    );
+    return Array.isArray(body) ? rewritten : rewritten[0];
+  }
+  async function handle(req, segment) {
+    try {
+      if (req.method !== "POST") {
+        return jsonResponse(405, {
+          error: "method-not-allowed",
+          method: req.method,
+          allowed: ["POST"]
+        });
+      }
+      const table = SEGMENT_TO_TABLE[segment];
+      if (!table) {
+        return jsonResponse(404, {
+          error: "unknown-brain-forward-segment",
+          segment,
+          known: KNOWN_SEGMENTS
+        });
+      }
+      if (bearerOf(req) !== ingestSecret) {
+        return jsonResponse(401, { error: "unauthorized" });
+      }
+      let body;
+      try {
+        body = await req.json();
+      } catch {
+        return jsonResponse(400, { error: "invalid-json" });
+      }
+      let row = Array.isArray(body) ? body : { ...body };
+      if (table === "compile_outcome_quality") {
+        const outcome = await resolveQualityOutcomeIds(row);
+        if (outcome instanceof Response) return outcome;
+        row = outcome;
+      }
+      const wantsRepresentation = /return=representation/i.test(
+        req.headers.get("Prefer") ?? ""
+      );
+      let brainRes;
+      try {
+        brainRes = await fetchFn(`${brainUrl}/rest/v1/${table}`, {
+          method: "POST",
+          headers: {
+            apikey: serviceKey,
+            Authorization: `Bearer ${serviceKey}`,
+            "Content-Type": "application/json",
+            Prefer: wantsRepresentation ? "return=representation" : "return=minimal"
+          },
+          body: JSON.stringify(row)
+        });
+      } catch (err) {
+        return jsonResponse(502, {
+          error: "brain-unreachable",
+          table,
+          detail: err instanceof Error ? err.message : String(err)
+        });
+      }
+      if (brainRes.ok) {
+        if (wantsRepresentation) {
+          const text2 = await brainRes.text().catch(() => "");
+          if (text2.length > 0) {
+            return new Response(text2, { status: 201, headers: JSON_HEADERS });
+          }
+        }
+        return jsonResponse(201, { ok: true });
+      }
+      const text = await brainRes.text().catch(() => "<no body>");
+      return jsonResponse(brainRes.status, {
+        error: "brain-write-failed",
+        table,
+        status: brainRes.status,
+        detail: text
+      });
+    } catch (err) {
+      return jsonResponse(500, {
+        error: "brain-forward-internal-error",
+        detail: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return { handle, segments: KNOWN_SEGMENTS };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createBrainForwardRoutes
+});

package/dist/brain-proxy.mjs

@@ -0,0 +1,6 @@
+import {
+  createBrainForwardRoutes
+} from "./chunk-65ZMX5OT.mjs";
+export {
+  createBrainForwardRoutes
+};