@loradb/lora-graphql 0.24.1 → 0.25.1

package/dist/cli.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { execFileSync as re } from "node:child_process";
-import { stat as M, readFile as ce, readdir as ue, mkdir as le, writeFile as _ } from "node:fs/promises";
-import { dirname as fe, basename as de, join as O, relative as pe } from "node:path";
-import { parse as j, Kind as p, visit as Y, print as Z, typeFromAST as me, isNonNullType as G, isListType as he, getNamedType as ge, isEnumType as ve, isInputObjectType as we } from "graphql";
-import { d as Ee } from "./diff-K8-GSeKH.js";
-import { q as K, e as be, M as Te, a as R, l as X, g as x, u as ee, c as Ne, i as ye, r as Se, w as Ie } from "./driver-CXKPLfkz.js";
-const $e = /* @__PURE__ */ new Set(["Query", "Mutation", "Subscription"]), W = {
+import { execFileSync as ue } from "node:child_process";
+import { stat as F, readFile as le, readdir as fe, mkdir as de, writeFile as M } from "node:fs/promises";
+import { dirname as pe, basename as me, join as k, relative as he } from "node:path";
+import { parse as x, Kind as p, visit as Z, print as K, typeFromAST as ge, isNonNullType as W, isListType as ve, getNamedType as we, isEnumType as be, isInputObjectType as Ee } from "graphql";
+import { d as Te } from "./diff-BZZNZs76.js";
+import { w as X, j as ye, c as ee, e as Ne, M as Se, a as P, l as te, g as C, x as ne, i as $e, r as Ie, y as ke } from "./lora-graphql-RvZQdHNA.js";
+const Oe = /* @__PURE__ */ new Set(["Query", "Mutation", "Subscription"]), z = {
   coalesce: "@coalesce is not supported: it hides predicates from indexes; store a value instead",
   subscriptionsAuthorization: "@subscriptionsAuthorization is not supported: SUBSCRIBE rules go in @authorization",
   shareable: "federation (@shareable) is not supported",
@@ -14,7 +14,7 @@ const $e = /* @__PURE__ */ new Set(["Query", "Mutation", "Subscription"]), W = {
   provides: "federation (@provides) is not supported",
   exclude: "@exclude: use @query / @mutation to choose operations",
   vector: "@vector on types (with a provider) is not supported: put @vector(dimensions:, similarity:) on a [Float!] field"
-}, ke = [
+}, De = [
   ["_NOT_IN", "IN"],
   ["_STARTS_WITH", "STARTS_WITH"],
   ["_ENDS_WITH", "ENDS_WITH"],
@@ -26,7 +26,7 @@ const $e = /* @__PURE__ */ new Set(["Query", "Mutation", "Subscription"]), W = {
   ["_LT", "LT"],
   ["_IN", "IN"],
   ["_EQ", "EQ"]
-], Oe = {
+], Le = {
   eq: "EQ",
   in: "IN",
   lt: "LT",
@@ -39,43 +39,43 @@ const $e = /* @__PURE__ */ new Set(["Query", "Mutation", "Subscription"]), W = {
   includes: "INCLUDES",
   caseInsensitive: "CASE_INSENSITIVE"
 };
-function De(n, s = []) {
-  const i = j(n, { noLocation: !0 }), a = [], e = i.definitions.filter(
-    (o) => o.kind === p.OBJECT_TYPE_DEFINITION && !$e.has(o.name.value) && !k(o.directives, "relationshipProperties") && !k(o.directives, "jwt")
-  ), c = new Set(e.map((o) => o.name.value)), t = s.length > 0 ? je(s, e) : void 0, u = Y(i, {
+function je(n, s = []) {
+  const i = x(n, { noLocation: !0 }), a = [], e = i.definitions.filter(
+    (o) => o.kind === p.OBJECT_TYPE_DEFINITION && !Oe.has(o.name.value) && !I(o.directives, "relationshipProperties") && !I(o.directives, "jwt")
+  ), c = new Set(e.map((o) => o.name.value)), t = s.length > 0 ? _e(s, e) : void 0, u = Z(i, {
     ObjectTypeDefinition(o) {
       if (!c.has(o.name.value)) return;
       const r = o.name.value;
-      let l = te(
+      let l = se(
         o.directives ?? [],
         r,
         void 0,
         a
       );
-      k(l, "node") || (l = [...l, I("node")]);
-      const f = t?.mutations.get(r);
-      k(l, "mutation") || (t ? f && f.size > 0 && (l = [
+      I(l, "node") || (l = [...l, $("node")]);
+      const d = t?.mutations.get(r);
+      I(l, "mutation") || (t ? d && d.size > 0 && (l = [
         ...l,
-        I("mutation", {
-          operations: F([...f].sort())
+        $("mutation", {
+          operations: U([...d].sort())
         })
-      ]) : (l = [...l, I("mutation")], a.push(
+      ]) : (l = [...l, $("mutation")], a.push(
         `${r}: @mutation added (@neo4j/graphql generates mutations for every type); remove it or narrow its operations`
       )));
-      const m = (o.fields ?? []).filter((v) => k(v.directives, "id"));
+      const m = (o.fields ?? []).filter((v) => I(v.directives, "id"));
       m.length === 0 ? a.push(
         `${r}: no @id field; add a required @key field (the sort tie-breaker and mutation address)`
       ) : m.length > 1 && a.push(`${r}: several @id fields; keep one as the @key`);
       const h = (o.fields ?? []).map(
-        (v) => Le(v, r, t, a)
+        (v) => Ae(v, r, t, a)
       );
       return { ...o, directives: l, fields: h };
     }
   });
-  return { typeDefs: Z(u), todos: a };
+  return { typeDefs: K(u), todos: a };
 }
-function Le(n, s, i, a) {
-  let e = te(
+function Ae(n, s, i, a) {
+  let e = se(
     n.directives ?? [],
     s,
     n.name.value,
@@ -83,18 +83,18 @@ function Le(n, s, i, a) {
   );
   e.find((u) => u.name.value === "id") && (e = e.filter(
     (u) => u.name.value !== "id" && u.name.value !== "unique"
-  ), e.push(I("key", { generate: se(!0) })));
+  ), e.push($("key", { generate: oe(!0) })));
   const t = i?.filters.get(s)?.get(n.name.value);
-  return t && t.size > 0 && !k(e, "filterable") && e.push(
-    k(e, "relationship") ? I("filterable") : I("filterable", { byValue: F([...t].sort()) })
-  ), i?.sorts.get(s)?.has(n.name.value) && !k(e, "sortable") && e.push(I("sortable")), { ...n, directives: e };
+  return t && t.size > 0 && !I(e, "filterable") && e.push(
+    I(e, "relationship") ? $("filterable") : $("filterable", { byValue: U([...t].sort()) })
+  ), i?.sorts.get(s)?.has(n.name.value) && !I(e, "sortable") && e.push($("sortable")), { ...n, directives: e };
 }
-function te(n, s, i, a) {
+function se(n, s, i, a) {
   const e = i ? `${s}.${i}` : s, c = [];
   for (const t of n) {
     const u = t.name.value;
-    if (u in W) {
-      a.push(`${e}: ${W[u]}`);
+    if (u in z) {
+      a.push(`${e}: ${z[u]}`);
       continue;
     }
     if (u === "key" && !i) {
@@ -102,19 +102,19 @@ function te(n, s, i, a) {
       continue;
     }
     if (u === "unique") {
-      c.push(I("unique"));
+      c.push($("unique"));
       continue;
     }
     if (u === "relationship") {
-      c.push(Ae(t, e, a));
+      c.push(qe(t, e, a));
       continue;
     }
     if (u === "fulltext") {
-      c.push(xe(t, "indexes", "indexName", "name"));
+      c.push(Ce(t, "indexes", "indexName", "name"));
       continue;
     }
     if (u === "subscription") {
-      c.push(qe(t, e, a));
+      c.push(xe(t, e, a));
       continue;
     }
     (u === "authorization" || u === "authentication") && a.push(
@@ -123,12 +123,12 @@ function te(n, s, i, a) {
   }
   return c;
 }
-function Ae(n, s, i) {
+function qe(n, s, i) {
   const a = [];
   for (const e of n.arguments ?? []) {
     const c = e.name.value;
     if (c === "queryDirection" && e.value.kind === p.ENUM) {
-      e.value.value.includes("UNDIRECTED") && a.push(q("queryDirection", ne("UNDIRECTED")));
+      e.value.value.includes("UNDIRECTED") && a.push(q("queryDirection", ae("UNDIRECTED")));
       continue;
     }
     if (c === "nestedOperations" && e.value.kind === p.LIST) {
@@ -142,7 +142,7 @@ function Ae(n, s, i) {
   }
   return { ...n, arguments: a };
 }
-function qe(n, s, i) {
+function xe(n, s, i) {
   const a = n.arguments?.find((t) => t.name.value === "events")?.value;
   if (!a || a.kind !== p.LIST) return n;
   const e = /* @__PURE__ */ new Set();
@@ -151,83 +151,83 @@ function qe(n, s, i) {
     t.kind === p.ENUM && (t.value.startsWith("CREATED") && !t.value.includes("RELATIONSHIP") ? e.add("CREATE") : t.value.startsWith("UPDATED") ? e.add("UPDATE") : t.value.startsWith("DELETED") && !t.value.includes("RELATIONSHIP") ? e.add("DELETE") : t.value.includes("RELATIONSHIP") && (c = !0));
   return i.push(
     `${s}: subscriptions see writes made through this library (or the engine change feed), not CDC`
-  ), I("subscription", {
-    operations: F([...e].sort()),
-    ...c ? { relationships: se(!0) } : {}
+  ), $("subscription", {
+    operations: U([...e].sort()),
+    ...c ? { relationships: oe(!0) } : {}
   });
 }
-function je(n, s) {
+function _e(n, s) {
   const i = {
     filters: /* @__PURE__ */ new Map(),
     sorts: /* @__PURE__ */ new Map(),
     mutations: /* @__PURE__ */ new Map()
   }, a = /* @__PURE__ */ new Map();
   for (const r of s)
-    a.set(K(r.name.value), r), a.set(Ce(r.name.value), r);
-  const e = new Map(s.map((r) => [r.name.value, r])), c = (r, l, f) => {
+    a.set(X(r.name.value), r), a.set(Re(r.name.value), r);
+  const e = new Map(s.map((r) => [r.name.value, r])), c = (r, l, d) => {
     const m = i.filters.get(r) ?? /* @__PURE__ */ new Map(), h = m.get(l) ?? /* @__PURE__ */ new Set();
-    h.add(f), m.set(l, h), i.filters.set(r, m);
+    h.add(d), m.set(l, h), i.filters.set(r, m);
   }, t = (r, l) => {
     if (l.kind === p.OBJECT)
-      for (const f of l.fields) {
-        const m = f.name.value;
+      for (const d of l.fields) {
+        const m = d.name.value;
         if (m === "AND" || m === "OR") {
-          if (f.value.kind === p.LIST)
-            for (const w of f.value.values) t(r, w);
+          if (d.value.kind === p.LIST)
+            for (const w of d.value.values) t(r, w);
           continue;
         }
         if (m === "NOT") {
-          t(r, f.value);
+          t(r, d.value);
           continue;
         }
         const h = /^(.+)_(SOME|ALL|NONE|SINGLE)$/.exec(m);
         if (h) {
-          const w = r.fields?.find((D) => D.name.value === h[1]), y = w && e.get(z(w));
-          w && y && (c(r.name.value, h[1], "EQ"), t(y, f.value));
+          const w = r.fields?.find((O) => O.name.value === h[1]), N = w && e.get(H(w));
+          w && N && (c(r.name.value, h[1], "EQ"), t(N, d.value));
           continue;
         }
-        const v = ke.find(([w]) => m.endsWith(w)), b = v ? m.slice(0, -v[0].length) : m, g = r.fields?.find((w) => w.name.value === b);
+        const v = De.find(([w]) => m.endsWith(w)), E = v ? m.slice(0, -v[0].length) : m, g = r.fields?.find((w) => w.name.value === E);
         if (!g) continue;
-        const N = e.get(z(g));
-        if (N) {
-          if (c(r.name.value, b, "EQ"), f.value.kind === p.OBJECT) {
-            for (const w of f.value.fields) t(N, w.value);
-            t(N, f.value);
+        const y = e.get(H(g));
+        if (y) {
+          if (c(r.name.value, E, "EQ"), d.value.kind === p.OBJECT) {
+            for (const w of d.value.fields) t(y, w.value);
+            t(y, d.value);
           }
           continue;
         }
-        if (v) c(r.name.value, b, v[1]);
-        else if (f.value.kind === p.OBJECT)
-          for (const w of f.value.fields) {
-            const y = Oe[w.name.value];
-            y && c(r.name.value, b, y);
+        if (v) c(r.name.value, E, v[1]);
+        else if (d.value.kind === p.OBJECT)
+          for (const w of d.value.fields) {
+            const N = Le[w.name.value];
+            N && c(r.name.value, E, N);
           }
-        else c(r.name.value, b, "EQ");
+        else c(r.name.value, E, "EQ");
       }
   }, u = (r, l) => {
-    for (const f of r?.selections ?? []) {
-      if (f.kind !== p.FIELD) continue;
-      const m = f.name.value;
+    for (const d of r?.selections ?? []) {
+      if (d.kind !== p.FIELD) continue;
+      const m = d.name.value;
       if (l) {
-        const h = /^(create|update|delete|upsert)(.+)$/.exec(m), v = m.replace(/(Connection|Aggregate)$/, ""), b = a.get(v) ?? (h ? a.get(ae(h[2])) : void 0);
-        if (b && h) {
-          const g = i.mutations.get(b.name.value) ?? /* @__PURE__ */ new Set(), N = h[1].toUpperCase();
-          N === "UPSERT" ? (g.add("CREATE"), g.add("UPDATE")) : g.add(N), i.mutations.set(b.name.value, g);
+        const h = /^(create|update|delete|upsert)(.+)$/.exec(m), v = m.replace(/(Connection|Aggregate)$/, ""), E = a.get(v) ?? (h ? a.get(ie(h[2])) : void 0);
+        if (E && h) {
+          const g = i.mutations.get(E.name.value) ?? /* @__PURE__ */ new Set(), y = h[1].toUpperCase();
+          y === "UPSERT" ? (g.add("CREATE"), g.add("UPDATE")) : g.add(y), i.mutations.set(E.name.value, g);
         }
-        if (b)
-          for (const g of f.arguments ?? []) o(b, g);
+        if (E)
+          for (const g of d.arguments ?? []) o(E, g);
       }
-      u(f.selectionSet, !1);
+      u(d.selectionSet, !1);
     }
   }, o = (r, l) => {
     if (l.name.value === "where" && t(r, l.value), l.name.value === "sort" || l.name.value === "options") {
-      const f = i.sorts.get(r.name.value) ?? /* @__PURE__ */ new Set(), m = (h) => {
+      const d = i.sorts.get(r.name.value) ?? /* @__PURE__ */ new Set(), m = (h) => {
         if (h.kind === p.LIST) h.values.forEach(m);
         else if (h.kind === p.OBJECT)
           for (const v of h.fields)
-            v.name.value === "sort" ? m(v.value) : v.value.kind === p.ENUM && f.add(v.name.value);
+            v.name.value === "sort" ? m(v.value) : v.value.kind === p.ENUM && d.add(v.name.value);
       };
-      m(l.value), i.sorts.set(r.name.value, f);
+      m(l.value), i.sorts.set(r.name.value, d);
     }
   };
   for (const r of n)
@@ -235,15 +235,15 @@ function je(n, s) {
       l.kind === p.OPERATION_DEFINITION && u(l.selectionSet, !0);
   return i;
 }
-function z(n) {
+function H(n) {
   let s = n.type;
   for (; s.kind !== p.NAMED_TYPE; ) s = s.type;
   return s.name.value;
 }
-function k(n, s) {
+function I(n, s) {
   return (n ?? []).some((i) => i.name.value === s);
 }
-function I(n, s = {}) {
+function $(n, s = {}) {
   return {
     kind: p.DIRECTIVE,
     name: { kind: p.NAME, value: n },
@@ -253,17 +253,17 @@ function I(n, s = {}) {
 function q(n, s) {
   return { kind: p.ARGUMENT, name: { kind: p.NAME, value: n }, value: s };
 }
-const ne = (n) => ({
+const ae = (n) => ({
   kind: p.ENUM,
   value: n
-}), se = (n) => ({
+}), oe = (n) => ({
   kind: p.BOOLEAN,
   value: n
-}), F = (n) => ({
+}), U = (n) => ({
   kind: p.LIST,
-  values: n.map(ne)
+  values: n.map(ae)
 });
-function xe(n, s, i, a) {
+function Ce(n, s, i, a) {
   return {
     ...n,
     arguments: (n.arguments ?? []).map(
@@ -281,7 +281,7 @@ function xe(n, s, i, a) {
     )
   };
 }
-const _e = {
+const Me = {
   person: "people",
   man: "men",
   woman: "women",
@@ -291,23 +291,25 @@ const _e = {
   foot: "feet",
   tooth: "teeth"
 };
-function Ce(n) {
-  const s = ae(n), i = s.toLowerCase();
-  for (const [a, e] of Object.entries(_e))
+function Re(n) {
+  const s = ie(n), i = s.toLowerCase();
+  for (const [a, e] of Object.entries(Me))
     if (i.endsWith(a))
       return s.slice(0, s.length - a.length) + e;
-  return K(n);
+  return X(n);
 }
-function ae(n) {
+function ie(n) {
   return n.charAt(0).toLowerCase() + n.slice(1);
 }
-const H = `lora-graphql <command>
+const Q = `lora-graphql <command>
 
   print <schema.graphql>                    the public SDL clients see
   directives                                the directive definitions, for editors
   access <schema.graphql> [--json]          who may do what: each type and guarded field,
                                             operation and kind of caller
   requirements <schema.graphql> [--ddl]     constraints and indexes the API needs
+  json-schema <schema.graphql>              the validation rules of every create and
+                                            update input, as JSON Schema, for clients
   check <schema.graphql> [--operations <file|dir>]... [--json]
         [--variables <file>] [--context <file>]
         [--baseline <file> [--update-baseline]]
@@ -329,62 +331,68 @@ const H = `lora-graphql <command>
                                             on a breaking change or a destructive statement
                                             (--base: the SDL files at a git ref against the
                                             working tree, each side concatenated)`;
-async function Me(n, s = Ye) {
+async function Fe(n, s = Ke) {
   const [i, ...a] = n, e = /* @__PURE__ */ new Set(), c = /* @__PURE__ */ new Map(), t = [], u = [];
   for (let o = 0; o < a.length; o++) {
     const r = a[o];
-    r === "--operations" ? u.push(a[++o] ?? "") : Re.has(r) ? c.set(r, a[++o] ?? "") : r.startsWith("--") ? e.add(r) : t.push(r);
+    r === "--operations" ? u.push(a[++o] ?? "") : Pe.has(r) ? c.set(r, a[++o] ?? "") : r.startsWith("--") ? e.add(r) : t.push(r);
   }
   try {
     switch (i) {
       case "print":
-        return await Pe(S(t, 1), s);
+        return await Je(S(t, 1), s);
       case "directives":
-        return s.out(be.trim()), 0;
+        return s.out(Ne.trim()), 0;
       case "access":
-        return await Fe(S(t, 1), e.has("--json"), s);
+        return await Ue(S(t, 1), e.has("--json"), s);
       case "requirements":
-        return await Ue(S(t, 1), e.has("--ddl"), s);
+        return await Be(S(t, 1), e.has("--ddl"), s);
+      case "json-schema": {
+        const [o] = S(t, 1);
+        return s.out(
+          JSON.stringify(ye(ee(await b(o))), null, 2)
+        ), 0;
+      }
       case "check":
-        return await Je(S(t, 1), u, e, c, s);
+        return await Ge(S(t, 1), u, e, c, s);
       case "compile":
-        return await Ge(S(t, 1), u, c, s);
+        return await ze(S(t, 1), u, c, s);
       case "analyze":
-        return await We(S(t, 1), c, s);
+        return await He(S(t, 1), c, s);
       case "migrate": {
         const [o, r] = S(t, 2);
-        if (o !== "neo4j") throw new L("migrate supports neo4j");
+        if (o !== "neo4j") throw new D("migrate supports neo4j");
         const l = [];
         for (const m of u)
-          for (const h of await A(m)) l.push(j(h.source));
-        const f = De(await E(r), l);
-        for (const m of f.todos) s.out(`# TODO(migrate): ${m}`);
-        return f.todos.length > 0 && s.out(""), s.out(f.typeDefs), 0;
+          for (const h of await j(m)) l.push(x(h.source));
+        const d = je(await b(r), l);
+        for (const m of d.todos) s.out(`# TODO(migrate): ${m}`);
+        return d.todos.length > 0 && s.out(""), s.out(d.typeDefs), 0;
       }
       case "diff": {
         const o = c.get("--base");
         if (o !== void 0) {
-          if (!o) throw new L("--base takes a git ref");
-          const f = S(t, 1), m = await Ve(o, f);
+          if (!o) throw new D("--base takes a git ref");
+          const d = S(t, 1), m = await Ze(o, d);
           return m === void 0 ? (s.out(
-            `${o} has none of ${f.join(", ")}; nothing to compare`
-          ), 0) : V(m, await Qe(f), e, s);
+            `${o} has none of ${d.join(", ")}; nothing to compare`
+          ), 0) : Y(m, await Ye(d), e, s);
         }
         const [r, l] = S(t, 2);
-        return V(await E(r), await E(l), e, s);
+        return Y(await b(r), await b(l), e, s);
       }
       default:
-        return s.err(H), 2;
+        return s.err(Q), 2;
     }
   } catch (o) {
-    return o instanceof L ? (s.err(`${o.message}
+    return o instanceof D ? (s.err(`${o.message}
 
-${H}`), 2) : o instanceof Te ? (s.err(o.message), 1) : (s.err(o instanceof Error ? o.message : String(o)), 1);
+${Q}`), 2) : o instanceof Se ? (s.err(o.message), 1) : (s.err(o instanceof Error ? o.message : String(o)), 1);
   }
 }
-class L extends Error {
+class D extends Error {
 }
-const Re = /* @__PURE__ */ new Set([
+const Pe = /* @__PURE__ */ new Set([
   "--base",
   "--out",
   "--variables",
@@ -397,18 +405,18 @@ const Re = /* @__PURE__ */ new Set([
 ]);
 function S(n, s) {
   if (n.length < s)
-    throw new L(`expected ${s} file argument(s)`);
+    throw new D(`expected ${s} file argument(s)`);
   return n;
 }
-const E = (n) => ce(n, "utf8");
-function P(n) {
+const b = (n) => le(n, "utf8");
+function J(n) {
   const s = {
     run: () => Promise.reject(new Error("no database"))
   };
-  return new R({ typeDefs: n, driver: s });
+  return new P({ typeDefs: n, driver: s });
 }
-async function Fe([n], s, i) {
-  const a = P(await E(n)).accessMatrix();
+async function Ue([n], s, i) {
+  const a = J(await b(n)).accessMatrix();
   if (s)
     return i.out(JSON.stringify(a, null, 2)), 0;
   const e = a.map((t) => [
@@ -426,18 +434,18 @@ async function Fe([n], s, i) {
     );
   return 0;
 }
-async function Pe([n], s) {
-  return s.out(P(await E(n)).printPublicSchema()), 0;
+async function Je([n], s) {
+  return s.out(J(await b(n)).printPublicSchema()), 0;
 }
-async function Ue([n], s, i) {
-  const a = Ne(await E(n));
-  for (const e of ye(a))
+async function Be([n], s, i) {
+  const a = ee(await b(n));
+  for (const e of $e(a))
     i.out(
-      s ? `${Se(e)};` : `${ee(e)}, because ${e.reason}`
+      s ? `${Ie(e)};` : `${ne(e)}, because ${e.reason}`
     );
   return 0;
 }
-async function oe(n, s) {
+async function re(n, s) {
   try {
     const { createDatabase: i } = await import("@loradb/lora-node");
     return i;
@@ -448,183 +456,194 @@ async function oe(n, s) {
     return;
   }
 }
-async function Je([n], s, i, a, e) {
-  const c = i.has("--json"), t = await E(n), u = await oe(e, "check");
+async function Ge([n], s, i, a, e) {
+  const c = i.has("--json"), t = await b(n), u = await re(e, "check");
   if (!u) return 1;
   const o = a.get("--database"), r = await u(
     o ? a.get("--name") ?? "app" : void 0,
     o ? { databaseDir: o } : {}
-  ), l = new R({
+  ), l = new P({
     typeDefs: t,
-    driver: X(r)
+    driver: te(r)
   });
   o || await l.assertSchema({ create: !0 });
-  const f = l.getSchema(), m = a.has("--variables") ? JSON.parse(await E(a.get("--variables"))) : {}, h = a.has("--context") ? JSON.parse(await E(a.get("--context"))) : {}, v = [];
-  for (const d of s)
-    for (const T of await A(d))
-      for (const $ of ze(f, T.path, T.source)) {
-        const U = $.name.split("#")[1] ?? "", J = m[$.name] ?? m[U], B = h[$.name] ?? h[U] ?? h["*"];
+  const d = l.getSchema(), m = a.has("--variables") ? JSON.parse(await b(a.get("--variables"))) : {}, h = a.has("--context") ? JSON.parse(await b(a.get("--context"))) : {}, v = [];
+  for (const f of s)
+    for (const T of await j(f))
+      for (const { mutation: L, ...A } of Qe(
+        d,
+        T.path,
+        T.source
+      )) {
+        const B = A.name.split("#")[1] ?? "", _ = m[A.name] ?? m[B];
+        if (L && !_) continue;
+        const G = h[A.name] ?? h[B] ?? h["*"];
         v.push({
-          ...$,
-          ...J ? { variables: J } : {},
-          ...B !== void 0 ? { context: B } : {}
+          ...A,
+          ..._ ? { variables: _ } : {},
+          ...G !== void 0 ? { context: G } : {}
         });
       }
-  const b = a.has("--row-budget") ? Number(a.get("--row-budget")) : void 0, g = await l.check({
+  const E = a.has("--row-budget") ? Number(a.get("--row-budget")) : void 0, g = await l.check({
     operations: v,
-    ...b !== void 0 ? { rowBudget: b } : {}
-  }), N = a.get("--baseline"), w = {};
-  for (const d of g.plans)
-    w[`${d.operation} › ${d.field}`] = d.reports.map((T) => T.operators);
-  const y = [];
-  if (N) {
-    let d;
+    ...E !== void 0 ? { rowBudget: E } : {}
+  }), y = a.get("--baseline"), w = {};
+  for (const f of g.plans)
+    w[`${f.operation} › ${f.field}`] = f.reports.map((T) => T.operators);
+  const N = [];
+  if (y) {
+    let f;
     try {
-      d = JSON.parse(await E(N));
+      f = JSON.parse(await b(y));
     } catch {
-      d = void 0;
+      f = void 0;
     }
-    if (i.has("--update-baseline") || !d)
-      await _(N, JSON.stringify(w, null, 2) + `
+    if (i.has("--update-baseline") || !f)
+      await M(y, JSON.stringify(w, null, 2) + `
 `);
     else
       for (const T of /* @__PURE__ */ new Set([
-        ...Object.keys(d),
+        ...Object.keys(f),
         ...Object.keys(w)
       ]))
-        JSON.stringify(d[T]) !== JSON.stringify(w[T]) && y.push(T);
+        JSON.stringify(f[T]) !== JSON.stringify(w[T]) && N.push(T);
   }
-  const D = g.ok && y.length === 0;
+  const O = g.ok && N.length === 0;
   if (c)
-    return e.out(JSON.stringify({ ...g, ok: D, planChanges: y }, null, 2)), D ? 0 : 1;
-  for (const d of g.warnings) e.out(`warning  ${x(d)}`);
-  for (const d of g.lint) e.out(`lint     ${x(d)}`);
-  for (const d of g.unused)
+    return e.out(JSON.stringify({ ...g, ok: O, planChanges: N }, null, 2)), O ? 0 : 1;
+  for (const f of g.warnings) e.out(`warning  ${C(f)}`);
+  for (const f of g.lint) e.out(`lint     ${C(f)}`);
+  for (const f of g.unused)
+    e.out(
+      `unused   ${f.type} index ${f.name} on :${f.labels.join(":")}(${f.properties.join(", ")})`
+    );
+  for (const f of g.stored)
     e.out(
-      `unused   ${d.type} index ${d.name} on :${d.labels.join(":")}(${d.properties.join(", ")})`
+      `stored   ${f.type} ${JSON.stringify(f.key)}.${f.field} ${f.message}`
     );
-  for (const d of g.security) e.out(`error    ${x(d)}`);
-  for (const d of g.missing)
-    e.out(`error    missing ${ee(d)}`);
-  for (const d of g.cypher)
-    e.out(`error    ${d.type}.${d.field}: ${d.message}`);
-  for (const d of g.errors)
-    e.out(`error    ${d.operation}: ${d.message}`);
-  for (const d of g.plans)
-    for (const T of d.reports) {
-      for (const $ of T.findings)
-        e.out(`error    ${d.operation} › ${d.field}: ${$.message}`);
-      for (const $ of T.notes)
-        e.out(`lint     ${d.operation} › ${d.field}: ${$.message}`);
+  for (const f of g.security) e.out(`error    ${C(f)}`);
+  for (const f of g.missing)
+    e.out(`error    missing ${ne(f)}`);
+  for (const f of g.cypher)
+    e.out(`error    ${f.type}.${f.field}: ${f.message}`);
+  for (const f of g.errors)
+    e.out(`error    ${f.operation}: ${f.message}`);
+  for (const f of g.plans)
+    for (const T of f.reports) {
+      for (const L of T.findings)
+        e.out(`error    ${f.operation} › ${f.field}: ${L.message}`);
+      for (const L of T.notes)
+        e.out(`lint     ${f.operation} › ${f.field}: ${L.message}`);
     }
-  for (const d of y)
+  for (const f of N)
     e.out(
-      `error    ${d}: the plan differs from the baseline (--update-baseline to accept)`
+      `error    ${f}: the plan differs from the baseline (--update-baseline to accept)`
     );
-  const ie = g.plans.length;
+  const ce = g.plans.length;
   return e.out(
-    D ? `ok       ${ie} root field(s) in ${v.length} operation(s) seek as expected` : "failed"
-  ), D ? 0 : 1;
+    O ? `ok       ${ce} root field(s) in ${v.length} operation(s) seek as expected` : "failed"
+  ), O ? 0 : 1;
 }
-async function Be(n) {
+async function We(n) {
   const s = {};
   for (const i of n) {
-    if ((await M(i)).isFile() && i.endsWith(".json")) {
+    if ((await F(i)).isFile() && i.endsWith(".json")) {
       Object.assign(
         s,
-        JSON.parse(await E(i))
+        JSON.parse(await b(i))
       );
       continue;
     }
-    for (const e of await A(i)) {
-      const c = j(e.source), t = new Map(
+    for (const e of await j(i)) {
+      const c = x(e.source), t = new Map(
         c.definitions.filter(
           (o) => o.kind === p.FRAGMENT_DEFINITION
         ).map((o) => [o.name.value, o])
-      ), u = pe(process.cwd(), e.path);
+      ), u = he(process.cwd(), e.path);
       c.definitions.filter(
         (o) => o.kind === p.OPERATION_DEFINITION
       ).forEach((o, r) => {
         const l = `${u}#${o.name?.value ?? r + 1}`;
-        s[l] = Z({
+        s[l] = K({
           kind: p.DOCUMENT,
-          definitions: [o, ...Ie(o, t)]
+          definitions: [o, ...ke(o, t)]
         });
       });
     }
   }
   return s;
 }
-async function Ge([n], s, i, a) {
+async function ze([n], s, i, a) {
   if (s.length === 0)
-    throw new L("compile needs --operations <file|dir>");
-  const e = P(await E(n)), c = e.buildManifest(
-    await Be(s)
+    throw new D("compile needs --operations <file|dir>");
+  const e = J(await b(n)), c = e.buildManifest(
+    await We(s)
   ), t = i.get("--out") ?? "lora-graphql";
-  return await le(t, { recursive: !0 }), await _(
-    O(t, "manifest.json"),
+  return await de(t, { recursive: !0 }), await M(
+    k(t, "manifest.json"),
     JSON.stringify(c) + `
 `
-  ), await _(
-    O(t, "operations.d.ts"),
+  ), await M(
+    k(t, "operations.d.ts"),
     e.generateTypes(c)
   ), a.out(
-    `wrote ${Object.keys(c.operations).length} operation(s) to ${O(t, "manifest.json")} and ${O(t, "operations.d.ts")}`
+    `wrote ${Object.keys(c.operations).length} operation(s) to ${k(t, "manifest.json")} and ${k(t, "operations.d.ts")}`
   ), 0;
 }
-async function We([n], s, i) {
+async function He([n], s, i) {
   const a = s.get("--database");
-  if (!a) throw new L("analyze needs --database <dir>");
-  const e = await oe(i, "analyze");
+  if (!a) throw new D("analyze needs --database <dir>");
+  const e = await re(i, "analyze");
   if (!e) return 1;
   const c = await e(s.get("--name") ?? "app", {
     databaseDir: a
-  }), t = new R({
-    typeDefs: await E(n),
-    driver: X(c)
+  }), t = new P({
+    typeDefs: await b(n),
+    driver: te(c)
   }), u = s.has("--sample") ? Number(s.get("--sample")) : void 0, o = await t.analyze(u !== void 0 ? { sample: u } : {});
   return i.out(JSON.stringify(o, null, 2)), c.dispose?.(), 0;
 }
-async function A(n) {
-  if ((await M(n)).isFile()) return [{ path: n, source: await E(n) }];
+async function j(n) {
+  if ((await F(n)).isFile()) return [{ path: n, source: await b(n) }];
   const i = [];
-  for (const a of await ue(n, { withFileTypes: !0 })) {
-    const e = O(n, a.name);
-    a.isDirectory() ? i.push(...await A(e)) : /\.(graphql|gql)$/.test(a.name) && i.push({ path: e, source: await E(e) });
+  for (const a of await fe(n, { withFileTypes: !0 })) {
+    const e = k(n, a.name);
+    a.isDirectory() ? i.push(...await j(e)) : /\.(graphql|gql)$/.test(a.name) && i.push({ path: e, source: await b(e) });
   }
   return i;
 }
-function ze(n, s, i) {
-  const a = j(i), e = new Map(
+function Qe(n, s, i) {
+  const a = x(i), e = new Map(
     a.definitions.filter(
       (t) => t.kind === p.FRAGMENT_DEFINITION
     ).map((t) => [t.name.value, t])
   ), c = (t) => {
-    const u = /* @__PURE__ */ new Map(), o = (r) => Y(r, {
+    const u = /* @__PURE__ */ new Map(), o = (r) => Z(r, {
       FragmentSpread(l) {
-        const f = e.get(l.name.value);
-        f && !u.has(f.name.value) && (u.set(f.name.value, f), o(f));
+        const d = e.get(l.name.value);
+        d && !u.has(d.name.value) && (u.set(d.name.value, d), o(d));
       }
     });
     return o(t), [...u.values()];
   };
   return a.definitions.filter(
-    (t) => t.kind === p.OPERATION_DEFINITION && t.operation === "query"
+    (t) => t.kind === p.OPERATION_DEFINITION && t.operation !== "subscription"
   ).map((t, u) => {
     const o = {};
     for (const r of t.variableDefinitions ?? []) {
       if (r.defaultValue || r.type.kind !== p.NON_NULL_TYPE) continue;
-      const l = me(n, r.type);
-      l && (o[r.variable.name.value] = C(l));
+      const l = ge(n, r.type);
+      l && (o[r.variable.name.value] = R(l));
     }
     return {
       name: `${s}${t.name ? `#${t.name.value}` : `#${u + 1}`}`,
       document: { kind: p.DOCUMENT, definitions: [t, ...c(t)] },
-      variables: o
+      variables: o,
+      mutation: t.operation === "mutation"
     };
   });
 }
-const He = {
+const Ve = {
   String: "x",
   ID: "x",
   Int: 1,
@@ -638,31 +657,31 @@ const He = {
   LocalDateTime: "2026-01-01T12:00:00",
   Duration: "P1D"
 };
-function C(n) {
-  const s = G(n) ? n.ofType : n;
-  if (he(s)) return [C(s.ofType)];
-  const i = ge(s);
-  if (ve(i)) return i.getValues()[0]?.value;
-  if (we(i)) {
+function R(n) {
+  const s = W(n) ? n.ofType : n;
+  if (ve(s)) return [R(s.ofType)];
+  const i = we(s);
+  if (be(i)) return i.getValues()[0]?.value;
+  if (Ee(i)) {
     const a = {};
     for (const e of Object.values(i.getFields()))
-      G(e.type) && e.defaultValue === void 0 && (a[e.name] = C(e.type));
+      W(e.type) && e.defaultValue === void 0 && (a[e.name] = R(e.type));
     return a;
   }
-  return He[i.name] ?? "x";
+  return Ve[i.name] ?? "x";
 }
-const Q = /\.(graphql|gql)$/;
-async function Qe(n) {
+const V = /\.(graphql|gql)$/;
+async function Ye(n) {
   const s = [];
   for (const i of n) {
-    const a = await A(i);
+    const a = await j(i);
     a.sort((e, c) => e.path < c.path ? -1 : e.path > c.path ? 1 : 0), s.push(...a.map((e) => e.source));
   }
   return s.join(`
 `);
 }
-async function Ve(n, s) {
-  const i = (c, ...t) => re("git", t, {
+async function Ze(n, s) {
+  const i = (c, ...t) => ue("git", t, {
     cwd: c,
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"],
@@ -670,10 +689,10 @@ async function Ve(n, s) {
   }), a = [];
   let e = !1;
   for (const c of s) {
-    const t = await M(c).then(
+    const t = await F(c).then(
       (r) => r.isDirectory(),
-      () => !Q.test(c)
-    ), u = t ? c : fe(c);
+      () => !V.test(c)
+    ), u = t ? c : pe(c);
     try {
       i(u, "rev-parse", "--verify", "--quiet", `${n}^{commit}`);
     } catch {
@@ -683,16 +702,16 @@ async function Ve(n, s) {
     }
     if (!t) {
       try {
-        a.push(i(u, "show", `${n}:./${de(c)}`)), e = !0;
+        a.push(i(u, "show", `${n}:./${me(c)}`)), e = !0;
       } catch {
       }
       continue;
     }
     const o = i(u, "ls-tree", "-r", "--name-only", n, "--", ".").split(`
-`).filter((r) => Q.test(r));
+`).filter((r) => V.test(r));
     o.sort((r, l) => {
-      const f = O(c, r), m = O(c, l);
-      return f < m ? -1 : f > m ? 1 : 0;
+      const d = k(c, r), m = k(c, l);
+      return d < m ? -1 : d > m ? 1 : 0;
     });
     for (const r of o)
       a.push(i(u, "show", `${n}:./${r}`)), e = !0;
@@ -700,8 +719,8 @@ async function Ve(n, s) {
   return e ? a.join(`
 `) : void 0;
 }
-function V(n, s, i, a) {
-  const e = Ee(n, s), c = e.api.breaking.length > 0, t = e.database.statements.some((o) => o.destructive), u = (c || t) && !i.has("--allow-breaking") ? 1 : 0;
+function Y(n, s, i, a) {
+  const e = Te(n, s), c = e.api.breaking.length > 0, t = e.database.statements.some((o) => o.destructive), u = (c || t) && !i.has("--allow-breaking") ? 1 : 0;
   if (i.has("--json"))
     return a.out(JSON.stringify(e, null, 2)), u;
   a.out("# Database"), e.database.statements.length === 0 && a.out("no changes");
@@ -714,14 +733,14 @@ function V(n, s, i, a) {
   for (const o of e.notes) a.out(`note       ${o}`);
   return u;
 }
-const Ye = {
+const Ke = {
   out: (n) => process.stdout.write(n + `
 `),
   err: (n) => process.stderr.write(n + `
 `)
-}, Ze = typeof process < "u" && process.argv[1] !== void 0 && /lora-graphql(\.js)?$|cli\.js$/.test(process.argv[1]);
-Ze && Me(process.argv.slice(2)).then((n) => process.exit(n));
+}, Xe = typeof process < "u" && process.argv[1] !== void 0 && /lora-graphql(\.js)?$|cli\.js$/.test(process.argv[1]);
+Xe && Fe(process.argv.slice(2)).then((n) => process.exit(n));
 export {
-  Me as main
+  Fe as main
 };
 //# sourceMappingURL=cli.js.map