drizzle-cube 0.4.5 → 0.4.8

package/dist/adapters/fastify/index.js

@@ -1,57 +1,58 @@
-import { S as D, v as H, b as C, a as V, n as z, p as T, w as _, d as B, i as $, M as F, c as U, e as q, s as R } from "../mcp-transport-YHDZWKOi.js";
-import { formatErrorResponse as u, formatCubeResponse as j, handleBatchRequest as G, formatMetaResponse as K, formatSqlResponse as M, handleDryRun as I } from "../utils.js";
-const N = function(n, O, E) {
+import { S as D, v as K, b as x, a as T, n as V, p as z, w as _, d as B, i as j, M as F, c as U, e as E, s as P } from "../mcp-transport-CU5g9bxj.js";
+import { formatErrorResponse as d, formatCubeResponse as A, handleBatchRequest as X, formatMetaResponse as G, formatSqlResponse as I, handleDryRun as M } from "../utils.js";
+const N = function(i, k, R) {
   const {
-    cubes: w,
-    drizzle: k,
-    schema: A,
-    extractSecurityContext: y,
+    cubes: S,
+    drizzle: O,
+    schema: J,
+    extractSecurityContext: p,
     engineType: L,
-    cors: Q,
-    basePath: p = "/cubejs-api/v1",
-    bodyLimit: m = 10485760,
+    cors: q,
+    basePath: m = "/cubejs-api/v1",
+    bodyLimit: g = 10485760,
     // 10MB
-    cache: J,
-    mcp: g = { enabled: !0 }
-  } = O;
-  if (!w || w.length === 0)
-    return E(new Error("At least one cube must be provided in the cubes array"));
-  Q && n.register(import("@fastify/cors"), Q), n.addHook("onRequest", async (r, t) => {
-    r.method === "POST" && (r.body = void 0);
+    cache: H,
+    mcp: b = { enabled: !0 },
+    agent: f
+  } = k;
+  if (!S || S.length === 0)
+    return R(new Error("At least one cube must be provided in the cubes array"));
+  q && i.register(import("@fastify/cors"), q), i.addHook("onRequest", async (t, r) => {
+    t.method === "POST" && (t.body = void 0);
   });
   const c = new D({
-    drizzle: k,
-    schema: A,
+    drizzle: O,
+    schema: J,
     engineType: L,
-    cache: J
+    cache: H
   });
-  if (w.forEach((r) => {
-    c.registerCube(r);
-  }), n.post(`${p}/load`, {
-    bodyLimit: m,
+  if (S.forEach((t) => {
+    c.registerCube(t);
+  }), i.post(`${m}/load`, {
+    bodyLimit: g,
     schema: {
       body: {
         type: "object",
         additionalProperties: !0
       }
     }
-  }, async (r, t) => {
+  }, async (t, r) => {
     try {
-      const e = r.body, a = e.query || e, s = await y(r), o = c.validateQuery(a);
+      const e = t.body, a = e.query || e, n = await p(t), o = c.validateQuery(a);
       if (!o.isValid)
-        return t.status(400).send(u(
+        return r.status(400).send(d(
           `Query validation failed: ${o.errors.join(", ")}`,
           400
         ));
-      const i = r.headers["x-cache-control"] === "no-cache", d = await c.executeMultiCubeQuery(a, s, { skipCache: i });
-      return j(a, d, c);
+      const s = t.headers["x-cache-control"] === "no-cache", l = await c.executeMultiCubeQuery(a, n, { skipCache: s });
+      return A(a, l, c);
     } catch (e) {
-      return r.log.error(e, "Query execution error"), t.status(500).send(u(
+      return t.log.error(e, "Query execution error"), r.status(500).send(d(
         e instanceof Error ? e.message : "Query execution failed",
         500
       ));
     }
-  }), n.get(`${p}/load`, {
+  }), i.get(`${m}/load`, {
     schema: {
       querystring: {
         type: "object",
@@ -61,34 +62,34 @@ const N = function(n, O, E) {
         required: ["query"]
       }
     }
-  }, async (r, t) => {
+  }, async (t, r) => {
     try {
-      const { query: e } = r.query;
+      const { query: e } = t.query;
       let a;
       try {
         a = JSON.parse(e);
       } catch {
-        return t.status(400).send(u(
+        return r.status(400).send(d(
           "Invalid JSON in query parameter",
           400
         ));
       }
-      const s = await y(r), o = c.validateQuery(a);
+      const n = await p(t), o = c.validateQuery(a);
       if (!o.isValid)
-        return t.status(400).send(u(
+        return r.status(400).send(d(
           `Query validation failed: ${o.errors.join(", ")}`,
           400
         ));
-      const i = r.headers["x-cache-control"] === "no-cache", d = await c.executeMultiCubeQuery(a, s, { skipCache: i });
-      return j(a, d, c);
+      const s = t.headers["x-cache-control"] === "no-cache", l = await c.executeMultiCubeQuery(a, n, { skipCache: s });
+      return A(a, l, c);
     } catch (e) {
-      return r.log.error(e, "Query execution error"), t.status(500).send(u(
+      return t.log.error(e, "Query execution error"), r.status(500).send(d(
         e instanceof Error ? e.message : "Query execution failed",
         500
       ));
     }
-  }), n.post(`${p}/batch`, {
-    bodyLimit: m,
+  }), i.post(`${m}/batch`, {
+    bodyLimit: g,
     schema: {
       body: {
         type: "object",
@@ -101,68 +102,68 @@ const N = function(n, O, E) {
         }
       }
     }
-  }, async (r, t) => {
+  }, async (t, r) => {
     try {
-      const { queries: e } = r.body;
+      const { queries: e } = t.body;
       if (!e || !Array.isArray(e))
-        return t.status(400).send(u(
+        return r.status(400).send(d(
           'Request body must contain a "queries" array',
           400
         ));
       if (e.length === 0)
-        return t.status(400).send(u(
+        return r.status(400).send(d(
           "Queries array cannot be empty",
           400
         ));
-      const a = await y(r), s = r.headers["x-cache-control"] === "no-cache";
-      return await G(e, a, c, { skipCache: s });
+      const a = await p(t), n = t.headers["x-cache-control"] === "no-cache";
+      return await X(e, a, c, { skipCache: n });
     } catch (e) {
-      return r.log.error(e, "Batch execution error"), t.status(500).send(u(
+      return t.log.error(e, "Batch execution error"), r.status(500).send(d(
         e instanceof Error ? e.message : "Batch execution failed",
         500
       ));
     }
-  }), n.get(`${p}/meta`, async (r, t) => {
+  }), i.get(`${m}/meta`, async (t, r) => {
     try {
       const e = c.getMetadata();
-      return K(e);
+      return G(e);
     } catch (e) {
-      return r.log.error(e, "Metadata error"), t.status(500).send(u(
+      return t.log.error(e, "Metadata error"), r.status(500).send(d(
         e instanceof Error ? e.message : "Failed to fetch metadata",
         500
       ));
     }
-  }), n.post(`${p}/sql`, {
-    bodyLimit: m,
+  }), i.post(`${m}/sql`, {
+    bodyLimit: g,
     schema: {
       body: {
         type: "object",
         additionalProperties: !0
       }
     }
-  }, async (r, t) => {
+  }, async (t, r) => {
     try {
-      const e = r.body, a = await y(r), s = c.validateQuery(e);
-      if (!s.isValid)
-        return t.status(400).send(u(
-          `Query validation failed: ${s.errors.join(", ")}`,
+      const e = t.body, a = await p(t), n = c.validateQuery(e);
+      if (!n.isValid)
+        return r.status(400).send(d(
+          `Query validation failed: ${n.errors.join(", ")}`,
           400
         ));
       const o = e.measures?.[0] || e.dimensions?.[0];
       if (!o)
-        return t.status(400).send(u(
+        return r.status(400).send(d(
           "No measures or dimensions specified",
           400
         ));
-      const i = o.split(".")[0], d = await c.generateSQL(i, e, a);
-      return M(e, d);
+      const s = o.split(".")[0], l = await c.generateSQL(s, e, a);
+      return I(e, l);
     } catch (e) {
-      return r.log.error(e, "SQL generation error"), t.status(500).send(u(
+      return t.log.error(e, "SQL generation error"), r.status(500).send(d(
         e instanceof Error ? e.message : "SQL generation failed",
         500
       ));
     }
-  }), n.get(`${p}/sql`, {
+  }), i.get(`${m}/sql`, {
     schema: {
       querystring: {
         type: "object",
@@ -172,47 +173,47 @@ const N = function(n, O, E) {
         required: ["query"]
       }
     }
-  }, async (r, t) => {
+  }, async (t, r) => {
     try {
-      const { query: e } = r.query, a = JSON.parse(e), s = await y(r), o = c.validateQuery(a);
+      const { query: e } = t.query, a = JSON.parse(e), n = await p(t), o = c.validateQuery(a);
       if (!o.isValid)
-        return t.status(400).send(u(
+        return r.status(400).send(d(
           `Query validation failed: ${o.errors.join(", ")}`,
           400
         ));
-      const i = a.measures?.[0] || a.dimensions?.[0];
-      if (!i)
-        return t.status(400).send(u(
+      const s = a.measures?.[0] || a.dimensions?.[0];
+      if (!s)
+        return r.status(400).send(d(
           "No measures or dimensions specified",
           400
         ));
-      const d = i.split(".")[0], x = await c.generateSQL(d, a, s);
-      return M(a, x);
+      const l = s.split(".")[0], y = await c.generateSQL(l, a, n);
+      return I(a, y);
     } catch (e) {
-      return r.log.error(e, "SQL generation error"), t.status(500).send(u(
+      return t.log.error(e, "SQL generation error"), r.status(500).send(d(
         e instanceof Error ? e.message : "SQL generation failed",
         500
       ));
     }
-  }), n.post(`${p}/dry-run`, {
-    bodyLimit: m,
+  }), i.post(`${m}/dry-run`, {
+    bodyLimit: g,
     schema: {
       body: {
         type: "object",
         additionalProperties: !0
       }
     }
-  }, async (r, t) => {
+  }, async (t, r) => {
     try {
-      const e = r.body, a = e.query || e, s = await y(r);
-      return await I(a, s, c);
+      const e = t.body, a = e.query || e, n = await p(t);
+      return await M(a, n, c);
     } catch (e) {
-      return r.log.error(e, "Dry-run error"), t.status(400).send({
+      return t.log.error(e, "Dry-run error"), r.status(400).send({
         error: e instanceof Error ? e.message : "Dry-run validation failed",
         valid: !1
       });
     }
-  }), n.get(`${p}/dry-run`, {
+  }), i.get(`${m}/dry-run`, {
     schema: {
       querystring: {
         type: "object",
@@ -222,142 +223,200 @@ const N = function(n, O, E) {
         required: ["query"]
       }
     }
-  }, async (r, t) => {
+  }, async (t, r) => {
     try {
-      const { query: e } = r.query, a = JSON.parse(e), s = await y(r);
-      return await I(a, s, c);
+      const { query: e } = t.query, a = JSON.parse(e), n = await p(t);
+      return await M(a, n, c);
     } catch (e) {
-      return r.log.error(e, "Dry-run error"), t.status(400).send({
+      return t.log.error(e, "Dry-run error"), r.status(400).send({
         error: e instanceof Error ? e.message : "Dry-run validation failed",
         valid: !1
       });
     }
-  }), n.post(`${p}/explain`, {
-    bodyLimit: m,
+  }), i.post(`${m}/explain`, {
+    bodyLimit: g,
     schema: {
       body: {
         type: "object",
         additionalProperties: !0
       }
     }
-  }, async (r, t) => {
+  }, async (t, r) => {
     try {
-      const e = r.body, a = e.query || e, s = e.options || {}, o = await y(r), i = c.validateQuery(a);
-      return i.isValid ? await c.explainQuery(a, o, s) : t.status(400).send({
-        error: `Query validation failed: ${i.errors.join(", ")}`
+      const e = t.body, a = e.query || e, n = e.options || {}, o = await p(t), s = c.validateQuery(a);
+      return s.isValid ? await c.explainQuery(a, o, n) : r.status(400).send({
+        error: `Query validation failed: ${s.errors.join(", ")}`
       });
     } catch (e) {
-      return r.log.error(e, "Explain error"), t.status(500).send({
+      return t.log.error(e, "Explain error"), r.status(500).send({
         error: e instanceof Error ? e.message : "Explain query failed"
       });
     }
-  }), g.enabled !== !1) {
-    const r = g.basePath ?? "/mcp";
-    n.post(`${r}`, {
-      bodyLimit: m,
+  }), f && i.post(`${m}/agent/chat`, {
+    bodyLimit: g,
+    schema: {
+      body: {
+        type: "object",
+        additionalProperties: !0
+      }
+    }
+  }, async (t, r) => {
+    try {
+      const { handleAgentChat: e } = await import("../handler-odjn7MIB.js"), a = t.body, { message: n, sessionId: o } = a;
+      if (!n || typeof n != "string")
+        return r.status(400).send({ error: "message is required and must be a string" });
+      let s = (f.apiKey || "").trim();
+      if (f.allowClientApiKey) {
+        const y = t.headers["x-agent-api-key"];
+        y && (s = y.trim());
+      }
+      if (!s)
+        return r.status(401).send({
+          error: "No API key configured. Set agent.apiKey in server config or send X-Agent-Api-Key header."
+        });
+      const l = await p(t);
+      r.raw.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      });
+      try {
+        const y = e({
+          message: n,
+          sessionId: o,
+          semanticLayer: c,
+          securityContext: l,
+          agentConfig: f,
+          apiKey: s
+        });
+        for await (const u of y)
+          r.raw.write(`data: ${JSON.stringify(u)}
+
+`);
+      } catch (y) {
+        const u = {
+          type: "error",
+          data: { message: y instanceof Error ? y.message : "Stream failed" }
+        };
+        r.raw.write(`data: ${JSON.stringify(u)}
+
+`);
+      } finally {
+        r.raw.end();
+      }
+    } catch (e) {
+      if (t.log.error(e, "Agent chat error"), !r.raw.headersSent)
+        return r.status(500).send({
+          error: e instanceof Error ? e.message : "Agent chat failed"
+        });
+    }
+  }), b.enabled !== !1) {
+    const t = b.basePath ?? "/mcp";
+    i.post(`${t}`, {
+      bodyLimit: g,
       schema: {
         body: {
           type: "object",
           additionalProperties: !0
         }
       }
-    }, async (t, e) => {
-      const a = H(
-        t.headers.origin,
-        g.allowedOrigins ? { allowedOrigins: g.allowedOrigins } : {}
+    }, async (r, e) => {
+      const a = K(
+        r.headers.origin,
+        b.allowedOrigins ? { allowedOrigins: b.allowedOrigins } : {}
       );
       if (!a.valid)
-        return e.status(403).send(C(null, -32600, a.reason));
-      const s = t.headers.accept;
-      if (!V(s))
-        return e.status(400).send(C(null, -32600, "Accept header must include both application/json and text/event-stream"));
-      const o = z(t.headers);
+        return e.status(403).send(x(null, -32600, a.reason));
+      const n = r.headers.accept;
+      if (!T(n))
+        return e.status(400).send(x(null, -32600, "Accept header must include both application/json and text/event-stream"));
+      const o = V(r.headers);
       if (!o.ok)
         return e.status(426).send({
           error: "Unsupported MCP protocol version",
           supported: o.supported
         });
-      const i = T(t.body);
-      if (!i)
-        return e.status(400).send(C(null, -32600, "Invalid JSON-RPC 2.0 request"));
-      const d = _(s), x = i.method === "initialize";
+      const s = z(r.body);
+      if (!s)
+        return e.status(400).send(x(null, -32600, "Invalid JSON-RPC 2.0 request"));
+      const l = _(n), y = s.method === "initialize";
       try {
-        const l = await B(
-          i.method,
-          i.params,
+        const u = await B(
+          s.method,
+          s.params,
           {
             semanticLayer: c,
-            extractSecurityContext: y,
-            rawRequest: t,
+            extractSecurityContext: p,
+            rawRequest: r,
             rawResponse: e,
             negotiatedProtocol: o.negotiated
           }
         );
-        if ($(i))
+        if (j(s))
           return e.status(202).send();
-        const b = x && l && typeof l == "object" && "sessionId" in l ? l.sessionId : void 0;
-        b && e.header(F, b);
-        const v = U(i.id ?? null, l);
-        if (d) {
-          const f = q();
-          e.header("Content-Type", "text/event-stream").header("Cache-Control", "no-cache").header("Connection", "keep-alive").send(`id: ${f}
+        const v = y && u && typeof u == "object" && "sessionId" in u ? u.sessionId : void 0;
+        v && e.header(F, v);
+        const C = U(s.id ?? null, u);
+        if (l) {
+          const w = E();
+          e.header("Content-Type", "text/event-stream").header("Cache-Control", "no-cache").header("Connection", "keep-alive").send(`id: ${w}
 
-${R(v, f)}`);
+${P(C, w)}`);
           return;
         }
-        return e.send(v);
-      } catch (l) {
-        if ($(i))
-          return t.log.error(l, "MCP notification processing error"), e.status(202).send();
-        t.log.error(l, "MCP RPC error");
-        const b = l?.code ?? -32603, v = l?.data, f = l.message || "MCP request failed", S = C(i.id ?? null, b, f, v);
-        if (d) {
-          const P = q();
-          e.header("Content-Type", "text/event-stream").header("Cache-Control", "no-cache").header("Connection", "keep-alive").send(`id: ${P}
+        return e.send(C);
+      } catch (u) {
+        if (j(s))
+          return r.log.error(u, "MCP notification processing error"), e.status(202).send();
+        r.log.error(u, "MCP RPC error");
+        const v = u?.code ?? -32603, C = u?.data, w = u.message || "MCP request failed", Q = x(s.id ?? null, v, w, C);
+        if (l) {
+          const $ = E();
+          e.header("Content-Type", "text/event-stream").header("Cache-Control", "no-cache").header("Connection", "keep-alive").send(`id: ${$}
 
-${R(S, P)}`);
+${P(Q, $)}`);
           return;
         }
-        return e.send(S);
+        return e.send(Q);
       }
-    }), n.get(`${r}`, async (t, e) => {
-      const a = q();
+    }), i.get(`${t}`, async (r, e) => {
+      const a = E();
       e.raw.writeHead(200, {
         "Content-Type": "text/event-stream",
         "Cache-Control": "no-cache",
         Connection: "keep-alive"
-      }), e.raw.write(R({
+      }), e.raw.write(P({
         jsonrpc: "2.0",
         method: "mcp/ready",
         params: { protocol: "streamable-http" }
       }, a, 15e3));
-      const s = setInterval(() => {
+      const n = setInterval(() => {
         e.raw.write(`: keep-alive
 
 `);
       }, 15e3);
-      t.raw.on("close", () => {
-        clearInterval(s);
+      r.raw.on("close", () => {
+        clearInterval(n);
       });
-    }), n.delete(`${r}`, async (t, e) => e.status(405).send({ error: "Session termination not supported" }));
+    }), i.delete(`${t}`, async (r, e) => e.status(405).send({ error: "Session termination not supported" }));
   }
-  n.setErrorHandler(async (r, t, e) => {
-    t.log.error(r, "Fastify cube adapter error"), e.statusCode < 400 && e.status(500);
-    const a = r instanceof Error ? r : String(r);
-    return u(a, e.statusCode);
-  }), E();
+  i.setErrorHandler(async (t, r, e) => {
+    r.log.error(t, "Fastify cube adapter error"), e.statusCode < 400 && e.status(500);
+    const a = t instanceof Error ? t : String(t);
+    return d(a, e.statusCode);
+  }), R();
 };
-async function Y(h, n) {
-  await h.register(N, n);
+async function Z(h, i) {
+  await h.register(N, i);
 }
-function Z(h) {
-  const n = require("fastify")({
+function ee(h) {
+  const i = require("fastify")({
     logger: !0
   });
-  return n.register(N, h), n;
+  return i.register(N, h), i;
 }
 export {
-  Z as createCubeApp,
+  ee as createCubeApp,
   N as cubePlugin,
-  Y as registerCubeRoutes
+  Z as registerCubeRoutes
 };