@loradb/lora-graphql 0.18.0 → 0.20.0

package/dist/cli.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { stat as z, readdir as oe, readFile as ie, mkdir as re, writeFile as _ } from "node:fs/promises";
-import { join as $, relative as ce } from "node:path";
-import { parse as q, Kind as p, visit as H, print as Q, typeFromAST as ue, isNonNullType as F, isListType as le, getNamedType as fe, isEnumType as de, isInputObjectType as pe } from "graphql";
-import { d as me } from "./diff-fpWH5KUa.js";
-import { m as V, d as he, M as ge, L as M, l as Y, f as J, o as Z, b as ve, i as we, r as Te, u as Ee } from "./driver-CQj9gkvl.js";
-const be = /* @__PURE__ */ new Set(["Query", "Mutation", "Subscription"]), W = {
+import { stat as H, readdir as oe, readFile as ie, mkdir as re, writeFile as _ } from "node:fs/promises";
+import { join as D, relative as ce } from "node:path";
+import { parse as q, Kind as p, visit as Q, print as V, typeFromAST as ue, isNonNullType as W, isListType as le, getNamedType as fe, isEnumType as de, isInputObjectType as pe } from "graphql";
+import { d as me } from "./diff-DUOLUgrI.js";
+import { m as Y, d as he, M as ge, L as M, l as Z, f as C, o as K, b as ve, i as we, r as Ee, u as Te } from "./driver-C7a5NkfH.js";
+const be = /* @__PURE__ */ new Set(["Query", "Mutation", "Subscription"]), B = {
   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",
@@ -38,177 +38,177 @@ const be = /* @__PURE__ */ new Set(["Query", "Mutation", "Subscription"]), W = {
   includes: "INCLUDES",
   caseInsensitive: "CASE_INSENSITIVE"
 };
-function Ie(t, n = []) {
-  const o = q(t, { noLocation: !0 }), s = [], e = o.definitions.filter(
-    (i) => i.kind === p.OBJECT_TYPE_DEFINITION && !be.has(i.name.value) && !O(i.directives, "relationshipProperties") && !O(i.directives, "jwt")
-  ), u = new Set(e.map((i) => i.name.value)), a = n.length > 0 ? De(n, e) : void 0, c = H(o, {
+function ye(n, s = []) {
+  const o = q(n, { noLocation: !0 }), a = [], e = o.definitions.filter(
+    (i) => i.kind === p.OBJECT_TYPE_DEFINITION && !be.has(i.name.value) && !k(i.directives, "relationshipProperties") && !k(i.directives, "jwt")
+  ), u = new Set(e.map((i) => i.name.value)), t = s.length > 0 ? $e(s, e) : void 0, r = Q(o, {
     ObjectTypeDefinition(i) {
       if (!u.has(i.name.value)) return;
-      const r = i.name.value;
-      let l = K(
+      const c = i.name.value;
+      let l = X(
         i.directives ?? [],
-        r,
+        c,
         void 0,
-        s
+        a
       );
-      O(l, "node") || (l = [...l, I("node")]);
-      const d = a?.mutations.get(r);
-      O(l, "mutation") || (a ? d && d.size > 0 && (l = [
+      k(l, "node") || (l = [...l, y("node")]);
+      const d = t?.mutations.get(c);
+      k(l, "mutation") || (t ? d && d.size > 0 && (l = [
         ...l,
-        I("mutation", {
+        y("mutation", {
           operations: R([...d].sort())
         })
-      ]) : (l = [...l, I("mutation")], s.push(
-        `${r}: @mutation added (@neo4j/graphql generates mutations for every type); remove it or narrow its operations`
+      ]) : (l = [...l, y("mutation")], a.push(
+        `${c}: @mutation added (@neo4j/graphql generates mutations for every type); remove it or narrow its operations`
       )));
-      const m = (i.fields ?? []).filter((v) => O(v.directives, "id"));
-      m.length === 0 ? s.push(
-        `${r}: no @id field; add a required @key field (the sort tie-breaker and mutation address)`
-      ) : m.length > 1 && s.push(`${r}: several @id fields; keep one as the @key`);
+      const m = (i.fields ?? []).filter((v) => k(v.directives, "id"));
+      m.length === 0 ? a.push(
+        `${c}: no @id field; add a required @key field (the sort tie-breaker and mutation address)`
+      ) : m.length > 1 && a.push(`${c}: several @id fields; keep one as the @key`);
       const h = (i.fields ?? []).map(
-        (v) => ye(v, r, a, s)
+        (v) => Ie(v, c, t, a)
       );
       return { ...i, directives: l, fields: h };
     }
   });
-  return { typeDefs: Q(c), todos: s };
+  return { typeDefs: V(r), todos: a };
 }
-function ye(t, n, o, s) {
-  let e = K(
-    t.directives ?? [],
-    n,
-    t.name.value,
-    s
+function Ie(n, s, o, a) {
+  let e = X(
+    n.directives ?? [],
+    s,
+    n.name.value,
+    a
   );
-  e.find((c) => c.name.value === "id") && (e = e.filter(
-    (c) => c.name.value !== "id" && c.name.value !== "unique"
-  ), e.push(I("key", { generate: ee(!0) })));
-  const a = o?.filters.get(n)?.get(t.name.value);
-  return a && a.size > 0 && !O(e, "filterable") && e.push(
-    O(e, "relationship") ? I("filterable") : I("filterable", { byValue: R([...a].sort()) })
-  ), o?.sorts.get(n)?.has(t.name.value) && !O(e, "sortable") && e.push(I("sortable")), { ...t, directives: e };
+  e.find((r) => r.name.value === "id") && (e = e.filter(
+    (r) => r.name.value !== "id" && r.name.value !== "unique"
+  ), e.push(y("key", { generate: te(!0) })));
+  const t = o?.filters.get(s)?.get(n.name.value);
+  return t && t.size > 0 && !k(e, "filterable") && e.push(
+    k(e, "relationship") ? y("filterable") : y("filterable", { byValue: R([...t].sort()) })
+  ), o?.sorts.get(s)?.has(n.name.value) && !k(e, "sortable") && e.push(y("sortable")), { ...n, directives: e };
 }
-function K(t, n, o, s) {
-  const e = o ? `${n}.${o}` : n, u = [];
-  for (const a of t) {
-    const c = a.name.value;
-    if (c in W) {
-      s.push(`${e}: ${W[c]}`);
+function X(n, s, o, a) {
+  const e = o ? `${s}.${o}` : s, u = [];
+  for (const t of n) {
+    const r = t.name.value;
+    if (r in B) {
+      a.push(`${e}: ${B[r]}`);
       continue;
     }
-    if (c === "key" && !o) {
-      s.push(`${e}: federation @key(fields:) is not supported`);
+    if (r === "key" && !o) {
+      a.push(`${e}: federation @key(fields:) is not supported`);
       continue;
     }
-    if (c === "unique") {
-      u.push(I("unique"));
+    if (r === "unique") {
+      u.push(y("unique"));
       continue;
     }
-    if (c === "relationship") {
-      u.push(Oe(a, e, s));
+    if (r === "relationship") {
+      u.push(Oe(t, e, a));
       continue;
     }
-    if (c === "fulltext") {
-      u.push($e(a, "indexes", "indexName", "name"));
+    if (r === "fulltext") {
+      u.push(De(t, "indexes", "indexName", "name"));
       continue;
     }
-    if (c === "subscription") {
-      u.push(ke(a, e, s));
+    if (r === "subscription") {
+      u.push(ke(t, e, a));
       continue;
     }
-    (c === "authorization" || c === "authentication") && s.push(
-      `${e}: check the @${c} rule's filters: operators are written { field: { eq: ... } } here`
-    ), u.push(a);
+    (r === "authorization" || r === "authentication") && a.push(
+      `${e}: check the @${r} rule's filters: operators are written { field: { eq: ... } } here`
+    ), u.push(t);
   }
   return u;
 }
-function Oe(t, n, o) {
-  const s = [];
-  for (const e of t.arguments ?? []) {
+function Oe(n, s, o) {
+  const a = [];
+  for (const e of n.arguments ?? []) {
     const u = e.name.value;
     if (u === "queryDirection" && e.value.kind === p.ENUM) {
-      e.value.value.includes("UNDIRECTED") && s.push(A("queryDirection", X("UNDIRECTED")));
+      e.value.value.includes("UNDIRECTED") && a.push(A("queryDirection", ee("UNDIRECTED")));
       continue;
     }
     if (u === "nestedOperations" && e.value.kind === p.LIST) {
-      const a = e.value.values.filter(
-        (c) => c.kind === p.ENUM && c.value !== "CONNECT_OR_CREATE"
+      const t = e.value.values.filter(
+        (r) => r.kind === p.ENUM && r.value !== "CONNECT_OR_CREATE"
       );
-      a.length < e.value.values.length && o.push(`${n}: connectOrCreate is not supported; use upsert`), s.push(A("nestedOperations", { kind: p.LIST, values: a }));
+      t.length < e.value.values.length && o.push(`${s}: connectOrCreate is not supported; use upsert`), a.push(A("nestedOperations", { kind: p.LIST, values: t }));
       continue;
     }
-    s.push(e);
+    a.push(e);
   }
-  return { ...t, arguments: s };
+  return { ...n, arguments: a };
 }
-function ke(t, n, o) {
-  const s = t.arguments?.find((a) => a.name.value === "events")?.value;
-  if (!s || s.kind !== p.LIST) return t;
+function ke(n, s, o) {
+  const a = n.arguments?.find((t) => t.name.value === "events")?.value;
+  if (!a || a.kind !== p.LIST) return n;
   const e = /* @__PURE__ */ new Set();
   let u = !1;
-  for (const a of s.values)
-    a.kind === p.ENUM && (a.value.startsWith("CREATED") && !a.value.includes("RELATIONSHIP") ? e.add("CREATE") : a.value.startsWith("UPDATED") ? e.add("UPDATE") : a.value.startsWith("DELETED") && !a.value.includes("RELATIONSHIP") ? e.add("DELETE") : a.value.includes("RELATIONSHIP") && (u = !0));
+  for (const t of a.values)
+    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") && (u = !0));
   return o.push(
-    `${n}: subscriptions see writes made through this library (or the engine change feed), not CDC`
-  ), I("subscription", {
+    `${s}: subscriptions see writes made through this library (or the engine change feed), not CDC`
+  ), y("subscription", {
     operations: R([...e].sort()),
-    ...u ? { relationships: ee(!0) } : {}
+    ...u ? { relationships: te(!0) } : {}
   });
 }
-function De(t, n) {
+function $e(n, s) {
   const o = {
     filters: /* @__PURE__ */ new Map(),
     sorts: /* @__PURE__ */ new Map(),
     mutations: /* @__PURE__ */ new Map()
-  }, s = /* @__PURE__ */ new Map();
-  for (const r of n)
-    s.set(V(r.name.value), r), s.set(Ae(r.name.value), r);
-  const e = new Map(n.map((r) => [r.name.value, r])), u = (r, l, d) => {
-    const m = o.filters.get(r) ?? /* @__PURE__ */ new Map(), h = m.get(l) ?? /* @__PURE__ */ new Set();
-    h.add(d), m.set(l, h), o.filters.set(r, m);
-  }, a = (r, l) => {
+  }, a = /* @__PURE__ */ new Map();
+  for (const c of s)
+    a.set(Y(c.name.value), c), a.set(Ae(c.name.value), c);
+  const e = new Map(s.map((c) => [c.name.value, c])), u = (c, l, d) => {
+    const m = o.filters.get(c) ?? /* @__PURE__ */ new Map(), h = m.get(l) ?? /* @__PURE__ */ new Set();
+    h.add(d), m.set(l, h), o.filters.set(c, m);
+  }, t = (c, l) => {
     if (l.kind === p.OBJECT)
       for (const d of l.fields) {
         const m = d.name.value;
         if (m === "AND" || m === "OR") {
           if (d.value.kind === p.LIST)
-            for (const w of d.value.values) a(r, w);
+            for (const w of d.value.values) t(c, w);
           continue;
         }
         if (m === "NOT") {
-          a(r, d.value);
+          t(c, d.value);
           continue;
         }
         const h = /^(.+)_(SOME|ALL|NONE|SINGLE)$/.exec(m);
         if (h) {
-          const w = r.fields?.find((D) => D.name.value === h[1]), S = w && e.get(B(w));
-          w && S && (u(r.name.value, h[1], "EQ"), a(S, d.value));
+          const w = c.fields?.find(($) => $.name.value === h[1]), S = w && e.get(G(w));
+          w && S && (u(c.name.value, h[1], "EQ"), t(S, d.value));
           continue;
         }
-        const v = Ne.find(([w]) => m.endsWith(w)), T = v ? m.slice(0, -v[0].length) : m, g = r.fields?.find((w) => w.name.value === T);
+        const v = Ne.find(([w]) => m.endsWith(w)), T = v ? m.slice(0, -v[0].length) : m, g = c.fields?.find((w) => w.name.value === T);
         if (!g) continue;
-        const N = e.get(B(g));
+        const N = e.get(G(g));
         if (N) {
-          if (u(r.name.value, T, "EQ"), d.value.kind === p.OBJECT) {
-            for (const w of d.value.fields) a(N, w.value);
-            a(N, d.value);
+          if (u(c.name.value, T, "EQ"), d.value.kind === p.OBJECT) {
+            for (const w of d.value.fields) t(N, w.value);
+            t(N, d.value);
           }
           continue;
         }
-        if (v) u(r.name.value, T, v[1]);
+        if (v) u(c.name.value, T, v[1]);
         else if (d.value.kind === p.OBJECT)
           for (const w of d.value.fields) {
             const S = Se[w.name.value];
-            S && u(r.name.value, T, S);
+            S && u(c.name.value, T, S);
           }
-        else u(r.name.value, T, "EQ");
+        else u(c.name.value, T, "EQ");
       }
-  }, c = (r, l) => {
-    for (const d of r?.selections ?? []) {
+  }, r = (c, l) => {
+    for (const d of c?.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)$/, ""), T = s.get(v) ?? (h ? s.get(te(h[2])) : void 0);
+        const h = /^(create|update|delete|upsert)(.+)$/.exec(m), v = m.replace(/(Connection|Aggregate)$/, ""), T = a.get(v) ?? (h ? a.get(ne(h[2])) : void 0);
         if (T && h) {
           const g = o.mutations.get(T.name.value) ?? /* @__PURE__ */ new Set(), N = h[1].toUpperCase();
           N === "UPSERT" ? (g.add("CREATE"), g.add("UPDATE")) : g.add(N), o.mutations.set(T.name.value, g);
@@ -216,63 +216,63 @@ function De(t, n) {
         if (T)
           for (const g of d.arguments ?? []) i(T, g);
       }
-      c(d.selectionSet, !1);
+      r(d.selectionSet, !1);
     }
-  }, i = (r, l) => {
-    if (l.name.value === "where" && a(r, l.value), l.name.value === "sort" || l.name.value === "options") {
-      const d = o.sorts.get(r.name.value) ?? /* @__PURE__ */ new Set(), m = (h) => {
+  }, i = (c, l) => {
+    if (l.name.value === "where" && t(c, l.value), l.name.value === "sort" || l.name.value === "options") {
+      const d = o.sorts.get(c.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 && d.add(v.name.value);
       };
-      m(l.value), o.sorts.set(r.name.value, d);
+      m(l.value), o.sorts.set(c.name.value, d);
     }
   };
-  for (const r of t)
-    for (const l of r.definitions)
-      l.kind === p.OPERATION_DEFINITION && c(l.selectionSet, !0);
+  for (const c of n)
+    for (const l of c.definitions)
+      l.kind === p.OPERATION_DEFINITION && r(l.selectionSet, !0);
   return o;
 }
-function B(t) {
-  let n = t.type;
-  for (; n.kind !== p.NAMED_TYPE; ) n = n.type;
-  return n.name.value;
+function G(n) {
+  let s = n.type;
+  for (; s.kind !== p.NAMED_TYPE; ) s = s.type;
+  return s.name.value;
 }
-function O(t, n) {
-  return (t ?? []).some((o) => o.name.value === n);
+function k(n, s) {
+  return (n ?? []).some((o) => o.name.value === s);
 }
-function I(t, n = {}) {
+function y(n, s = {}) {
   return {
     kind: p.DIRECTIVE,
-    name: { kind: p.NAME, value: t },
-    arguments: Object.entries(n).map(([o, s]) => A(o, s))
+    name: { kind: p.NAME, value: n },
+    arguments: Object.entries(s).map(([o, a]) => A(o, a))
   };
 }
-function A(t, n) {
-  return { kind: p.ARGUMENT, name: { kind: p.NAME, value: t }, value: n };
+function A(n, s) {
+  return { kind: p.ARGUMENT, name: { kind: p.NAME, value: n }, value: s };
 }
-const X = (t) => ({
+const ee = (n) => ({
   kind: p.ENUM,
-  value: t
-}), ee = (t) => ({
+  value: n
+}), te = (n) => ({
   kind: p.BOOLEAN,
-  value: t
-}), R = (t) => ({
+  value: n
+}), R = (n) => ({
   kind: p.LIST,
-  values: t.map(X)
+  values: n.map(ee)
 });
-function $e(t, n, o, s) {
+function De(n, s, o, a) {
   return {
-    ...t,
-    arguments: (t.arguments ?? []).map(
-      (e) => e.name.value === n && e.value.kind === p.LIST ? A(n, {
+    ...n,
+    arguments: (n.arguments ?? []).map(
+      (e) => e.name.value === s && e.value.kind === p.LIST ? A(s, {
         kind: p.LIST,
         values: e.value.values.map(
           (u) => u.kind === p.OBJECT ? {
             ...u,
             fields: u.fields.map(
-              (a) => a.name.value === o ? { ...a, name: { kind: p.NAME, value: s } } : a
+              (t) => t.name.value === o ? { ...t, name: { kind: p.NAME, value: a } } : t
             )
           } : u
         )
@@ -290,20 +290,22 @@ const Le = {
   foot: "feet",
   tooth: "teeth"
 };
-function Ae(t) {
-  const n = te(t), o = n.toLowerCase();
-  for (const [s, e] of Object.entries(Le))
-    if (o.endsWith(s))
-      return n.slice(0, n.length - s.length) + e;
-  return V(t);
+function Ae(n) {
+  const s = ne(n), o = s.toLowerCase();
+  for (const [a, e] of Object.entries(Le))
+    if (o.endsWith(a))
+      return s.slice(0, s.length - a.length) + e;
+  return Y(n);
 }
-function te(t) {
-  return t.charAt(0).toLowerCase() + t.slice(1);
+function ne(n) {
+  return n.charAt(0).toLowerCase() + n.slice(1);
 }
-const G = `lora-graphql <command>
+const z = `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
   check <schema.graphql> [--operations <file|dir>]... [--json]
         [--variables <file>] [--context <file>]
@@ -322,52 +324,54 @@ const G = `lora-graphql <command>
                                             what has no equivalent
   diff <old.graphql> <new.graphql> [--allow-breaking] [--json]
                                             database statements and API changes`;
-async function qe(t, n = We) {
-  const [o, ...s] = t, e = /* @__PURE__ */ new Set(), u = /* @__PURE__ */ new Map(), a = [], c = [];
-  for (let i = 0; i < s.length; i++) {
-    const r = s[i];
-    r === "--operations" ? c.push(s[++i] ?? "") : Ce.has(r) ? u.set(r, s[++i] ?? "") : r.startsWith("--") ? e.add(r) : a.push(r);
+async function qe(n, s = Be) {
+  const [o, ...a] = n, e = /* @__PURE__ */ new Set(), u = /* @__PURE__ */ new Map(), t = [], r = [];
+  for (let i = 0; i < a.length; i++) {
+    const c = a[i];
+    c === "--operations" ? r.push(a[++i] ?? "") : je.has(c) ? u.set(c, a[++i] ?? "") : c.startsWith("--") ? e.add(c) : t.push(c);
   }
   try {
     switch (o) {
       case "print":
-        return await _e(k(a, 1), n);
+        return await _e(O(t, 1), s);
       case "directives":
-        return n.out(he.trim()), 0;
+        return s.out(he.trim()), 0;
+      case "access":
+        return await Ce(O(t, 1), e.has("--json"), s);
       case "requirements":
-        return await je(k(a, 1), e.has("--ddl"), n);
+        return await xe(O(t, 1), e.has("--ddl"), s);
       case "check":
-        return await Me(k(a, 1), c, e, u, n);
+        return await Me(O(t, 1), r, e, u, s);
       case "compile":
-        return await xe(k(a, 1), c, u, n);
+        return await Pe(O(t, 1), r, u, s);
       case "analyze":
-        return await Pe(k(a, 1), u, n);
+        return await Ue(O(t, 1), u, s);
       case "migrate": {
-        const [i, r] = k(a, 2);
+        const [i, c] = O(t, 2);
         if (i !== "neo4j") throw new L("migrate supports neo4j");
         const l = [];
-        for (const m of c)
-          for (const h of await C(m)) l.push(q(h.source));
-        const d = Ie(await E(r), l);
-        for (const m of d.todos) n.out(`# TODO(migrate): ${m}`);
-        return d.todos.length > 0 && n.out(""), n.out(d.typeDefs), 0;
+        for (const m of r)
+          for (const h of await j(m)) l.push(q(h.source));
+        const d = ye(await E(c), 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 [i, r] = k(a, 2);
-        return await Je(i, r, e, n);
+        const [i, c] = O(t, 2);
+        return await We(i, c, e, s);
       }
       default:
-        return n.err(G), 2;
+        return s.err(z), 2;
     }
   } catch (i) {
-    return i instanceof L ? (n.err(`${i.message}
+    return i instanceof L ? (s.err(`${i.message}
 
-${G}`), 2) : i instanceof ge ? (n.err(i.message), 1) : (n.err(i instanceof Error ? i.message : String(i)), 1);
+${z}`), 2) : i instanceof ge ? (s.err(i.message), 1) : (s.err(i instanceof Error ? i.message : String(i)), 1);
   }
 }
 class L extends Error {
 }
-const Ce = /* @__PURE__ */ new Set([
+const je = /* @__PURE__ */ new Set([
   "--out",
   "--variables",
   "--context",
@@ -377,66 +381,85 @@ const Ce = /* @__PURE__ */ new Set([
   "--name",
   "--sample"
 ]);
-function k(t, n) {
-  if (t.length < n)
-    throw new L(`expected ${n} file argument(s)`);
-  return t;
+function O(n, s) {
+  if (n.length < s)
+    throw new L(`expected ${s} file argument(s)`);
+  return n;
 }
-const E = (t) => ie(t, "utf8");
-function ne(t) {
-  const n = {
+const E = (n) => ie(n, "utf8");
+function P(n) {
+  const s = {
     run: () => Promise.reject(new Error("no database"))
   };
-  return new M({ typeDefs: t, driver: n });
+  return new M({ typeDefs: n, driver: s });
 }
-async function _e([t], n) {
-  return n.out(ne(await E(t)).printPublicSchema()), 0;
+async function Ce([n], s, o) {
+  const a = P(await E(n)).accessMatrix();
+  if (s)
+    return o.out(JSON.stringify(a, null, 2)), 0;
+  const e = a.map((t) => [
+    t.field ? `${t.type}.${t.field}` : t.type,
+    t.operation,
+    t.principal,
+    t.verdict,
+    t.by.join(", ")
+  ]), u = [0, 1, 2, 3].map(
+    (t) => Math.max(...e.map((r) => r[t].length), 0)
+  );
+  for (const t of e)
+    o.out(
+      t.map((r, i) => i < 4 ? r.padEnd(u[i]) : r).join("  ").trimEnd()
+    );
+  return 0;
+}
+async function _e([n], s) {
+  return s.out(P(await E(n)).printPublicSchema()), 0;
 }
-async function je([t], n, o) {
-  const s = ve(await E(t));
-  for (const e of we(s))
+async function xe([n], s, o) {
+  const a = ve(await E(n));
+  for (const e of we(a))
     o.out(
-      n ? `${Te(e)};` : `${Z(e)}, because ${e.reason}`
+      s ? `${Ee(e)};` : `${K(e)}, because ${e.reason}`
     );
   return 0;
 }
-async function se(t, n) {
+async function se(n, s) {
   try {
     const { createDatabase: o } = await import("@loradb/lora-node");
     return o;
   } catch {
-    t.err(
-      `${n} needs @loradb/lora-node: npm install --save-dev @loradb/lora-node`
+    n.err(
+      `${s} needs @loradb/lora-node: npm install --save-dev @loradb/lora-node`
     );
     return;
   }
 }
-async function Me([t], n, o, s, e) {
-  const u = o.has("--json"), a = await E(t), c = await se(e, "check");
-  if (!c) return 1;
-  const i = s.get("--database"), r = await c(
-    i ? s.get("--name") ?? "app" : void 0,
+async function Me([n], s, o, a, e) {
+  const u = o.has("--json"), t = await E(n), r = await se(e, "check");
+  if (!r) return 1;
+  const i = a.get("--database"), c = await r(
+    i ? a.get("--name") ?? "app" : void 0,
     i ? { databaseDir: i } : {}
   ), l = new M({
-    typeDefs: a,
-    driver: Y(r)
+    typeDefs: t,
+    driver: Z(c)
   });
   i || await l.assertSchema({ create: !0 });
-  const d = l.getSchema(), m = s.has("--variables") ? JSON.parse(await E(s.get("--variables"))) : {}, h = s.has("--context") ? JSON.parse(await E(s.get("--context"))) : {}, v = [];
-  for (const f of n)
-    for (const b of await C(f))
-      for (const y of Ue(d, b.path, b.source)) {
-        const x = y.name.split("#")[1] ?? "", P = m[y.name] ?? m[x], U = h[y.name] ?? h[x] ?? h["*"];
+  const d = 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 f of s)
+    for (const b of await j(f))
+      for (const I of Fe(d, b.path, b.source)) {
+        const U = I.name.split("#")[1] ?? "", F = m[I.name] ?? m[U], J = h[I.name] ?? h[U] ?? h["*"];
         v.push({
-          ...y,
-          ...P ? { variables: P } : {},
-          ...U !== void 0 ? { context: U } : {}
+          ...I,
+          ...F ? { variables: F } : {},
+          ...J !== void 0 ? { context: J } : {}
         });
       }
-  const T = s.has("--row-budget") ? Number(s.get("--row-budget")) : void 0, g = await l.check({
+  const T = a.has("--row-budget") ? Number(a.get("--row-budget")) : void 0, g = await l.check({
     operations: v,
     ...T !== void 0 ? { rowBudget: T } : {}
-  }), N = s.get("--baseline"), w = {};
+  }), N = a.get("--baseline"), w = {};
   for (const f of g.plans)
     w[`${f.operation} › ${f.field}`] = f.reports.map((b) => b.operators);
   const S = [];
@@ -457,27 +480,28 @@ async function Me([t], n, o, s, e) {
       ]))
         JSON.stringify(f[b]) !== JSON.stringify(w[b]) && S.push(b);
   }
-  const D = g.ok && S.length === 0;
+  const $ = g.ok && S.length === 0;
   if (u)
-    return e.out(JSON.stringify({ ...g, ok: D, planChanges: S }, null, 2)), D ? 0 : 1;
-  for (const f of g.warnings) e.out(`warning  ${J(f)}`);
-  for (const f of g.lint) e.out(`lint     ${J(f)}`);
+    return e.out(JSON.stringify({ ...g, ok: $, planChanges: S }, null, 2)), $ ? 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.security) e.out(`error    ${C(f)}`);
   for (const f of g.missing)
-    e.out(`error    missing ${Z(f)}`);
+    e.out(`error    missing ${K(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 b of f.reports) {
-      for (const y of b.findings)
-        e.out(`error    ${f.operation} › ${f.field}: ${y.message}`);
-      for (const y of b.notes)
-        e.out(`lint     ${f.operation} › ${f.field}: ${y.message}`);
+      for (const I of b.findings)
+        e.out(`error    ${f.operation} › ${f.field}: ${I.message}`);
+      for (const I of b.notes)
+        e.out(`lint     ${f.operation} › ${f.field}: ${I.message}`);
     }
   for (const f of S)
     e.out(
@@ -485,108 +509,108 @@ async function Me([t], n, o, s, e) {
     );
   const ae = g.plans.length;
   return e.out(
-    D ? `ok       ${ae} root field(s) in ${v.length} operation(s) seek as expected` : "failed"
-  ), D ? 0 : 1;
+    $ ? `ok       ${ae} root field(s) in ${v.length} operation(s) seek as expected` : "failed"
+  ), $ ? 0 : 1;
 }
-async function Re(t) {
-  const n = {};
-  for (const o of t) {
-    if ((await z(o)).isFile() && o.endsWith(".json")) {
+async function Re(n) {
+  const s = {};
+  for (const o of n) {
+    if ((await H(o)).isFile() && o.endsWith(".json")) {
       Object.assign(
-        n,
+        s,
         JSON.parse(await E(o))
       );
       continue;
     }
-    for (const e of await C(o)) {
-      const u = q(e.source), a = new Map(
+    for (const e of await j(o)) {
+      const u = q(e.source), t = new Map(
         u.definitions.filter(
           (i) => i.kind === p.FRAGMENT_DEFINITION
         ).map((i) => [i.name.value, i])
-      ), c = ce(process.cwd(), e.path);
+      ), r = ce(process.cwd(), e.path);
       u.definitions.filter(
         (i) => i.kind === p.OPERATION_DEFINITION
-      ).forEach((i, r) => {
-        const l = `${c}#${i.name?.value ?? r + 1}`;
-        n[l] = Q({
+      ).forEach((i, c) => {
+        const l = `${r}#${i.name?.value ?? c + 1}`;
+        s[l] = V({
           kind: p.DOCUMENT,
-          definitions: [i, ...Ee(i, a)]
+          definitions: [i, ...Te(i, t)]
         });
       });
     }
   }
-  return n;
+  return s;
 }
-async function xe([t], n, o, s) {
-  if (n.length === 0)
+async function Pe([n], s, o, a) {
+  if (s.length === 0)
     throw new L("compile needs --operations <file|dir>");
-  const e = ne(await E(t)), u = e.buildManifest(
-    await Re(n)
-  ), a = o.get("--out") ?? "lora-graphql";
-  return await re(a, { recursive: !0 }), await _(
-    $(a, "manifest.json"),
+  const e = P(await E(n)), u = e.buildManifest(
+    await Re(s)
+  ), t = o.get("--out") ?? "lora-graphql";
+  return await re(t, { recursive: !0 }), await _(
+    D(t, "manifest.json"),
     JSON.stringify(u) + `
 `
   ), await _(
-    $(a, "operations.d.ts"),
+    D(t, "operations.d.ts"),
     e.generateTypes(u)
-  ), s.out(
-    `wrote ${Object.keys(u.operations).length} operation(s) to ${$(a, "manifest.json")} and ${$(a, "operations.d.ts")}`
+  ), a.out(
+    `wrote ${Object.keys(u.operations).length} operation(s) to ${D(t, "manifest.json")} and ${D(t, "operations.d.ts")}`
   ), 0;
 }
-async function Pe([t], n, o) {
-  const s = n.get("--database");
-  if (!s) throw new L("analyze needs --database <dir>");
+async function Ue([n], s, o) {
+  const a = s.get("--database");
+  if (!a) throw new L("analyze needs --database <dir>");
   const e = await se(o, "analyze");
   if (!e) return 1;
-  const u = await e(n.get("--name") ?? "app", {
-    databaseDir: s
-  }), a = new M({
-    typeDefs: await E(t),
-    driver: Y(u)
-  }), c = n.has("--sample") ? Number(n.get("--sample")) : void 0, i = await a.analyze(c !== void 0 ? { sample: c } : {});
+  const u = await e(s.get("--name") ?? "app", {
+    databaseDir: a
+  }), t = new M({
+    typeDefs: await E(n),
+    driver: Z(u)
+  }), r = s.has("--sample") ? Number(s.get("--sample")) : void 0, i = await t.analyze(r !== void 0 ? { sample: r } : {});
   return o.out(JSON.stringify(i, null, 2)), u.dispose?.(), 0;
 }
-async function C(t) {
-  if ((await z(t)).isFile()) return [{ path: t, source: await E(t) }];
+async function j(n) {
+  if ((await H(n)).isFile()) return [{ path: n, source: await E(n) }];
   const o = [];
-  for (const s of await oe(t, { withFileTypes: !0 })) {
-    const e = $(t, s.name);
-    s.isDirectory() ? o.push(...await C(e)) : /\.(graphql|gql)$/.test(s.name) && o.push({ path: e, source: await E(e) });
+  for (const a of await oe(n, { withFileTypes: !0 })) {
+    const e = D(n, a.name);
+    a.isDirectory() ? o.push(...await j(e)) : /\.(graphql|gql)$/.test(a.name) && o.push({ path: e, source: await E(e) });
   }
   return o;
 }
-function Ue(t, n, o) {
-  const s = q(o), e = new Map(
-    s.definitions.filter(
-      (a) => a.kind === p.FRAGMENT_DEFINITION
-    ).map((a) => [a.name.value, a])
-  ), u = (a) => {
-    const c = /* @__PURE__ */ new Map(), i = (r) => H(r, {
+function Fe(n, s, o) {
+  const a = q(o), e = new Map(
+    a.definitions.filter(
+      (t) => t.kind === p.FRAGMENT_DEFINITION
+    ).map((t) => [t.name.value, t])
+  ), u = (t) => {
+    const r = /* @__PURE__ */ new Map(), i = (c) => Q(c, {
       FragmentSpread(l) {
         const d = e.get(l.name.value);
-        d && !c.has(d.name.value) && (c.set(d.name.value, d), i(d));
+        d && !r.has(d.name.value) && (r.set(d.name.value, d), i(d));
       }
     });
-    return i(a), [...c.values()];
+    return i(t), [...r.values()];
   };
-  return s.definitions.filter(
-    (a) => a.kind === p.OPERATION_DEFINITION && a.operation === "query"
-  ).map((a, c) => {
+  return a.definitions.filter(
+    (t) => t.kind === p.OPERATION_DEFINITION && t.operation === "query"
+  ).map((t, r) => {
     const i = {};
-    for (const r of a.variableDefinitions ?? []) {
-      if (r.defaultValue || r.type.kind !== p.NON_NULL_TYPE) continue;
-      const l = ue(t, r.type);
-      l && (i[r.variable.name.value] = j(l));
+    for (const c of t.variableDefinitions ?? []) {
+      if (c.defaultValue || c.type.kind !== p.NON_NULL_TYPE) continue;
+      const l = ue(n, c.type);
+      l && (i[c.variable.name.value] = x(l));
     }
     return {
-      name: `${n}${a.name ? `#${a.name.value}` : `#${c + 1}`}`,
-      document: { kind: p.DOCUMENT, definitions: [a, ...u(a)] },
+      name: `${s}${t.name ? `#${t.name.value}` : `#${r + 1}`}`,
+      document: { kind: p.DOCUMENT, definitions: [t, ...u(t)] },
       variables: i
     };
   });
 }
-const Fe = {
+const Je = {
   String: "x",
   ID: "x",
   Int: 1,
@@ -600,40 +624,40 @@ const Fe = {
   LocalDateTime: "2026-01-01T12:00:00",
   Duration: "P1D"
 };
-function j(t) {
-  const n = F(t) ? t.ofType : t;
-  if (le(n)) return [j(n.ofType)];
-  const o = fe(n);
+function x(n) {
+  const s = W(n) ? n.ofType : n;
+  if (le(s)) return [x(s.ofType)];
+  const o = fe(s);
   if (de(o)) return o.getValues()[0]?.value;
   if (pe(o)) {
-    const s = {};
+    const a = {};
     for (const e of Object.values(o.getFields()))
-      F(e.type) && e.defaultValue === void 0 && (s[e.name] = j(e.type));
-    return s;
+      W(e.type) && e.defaultValue === void 0 && (a[e.name] = x(e.type));
+    return a;
   }
-  return Fe[o.name] ?? "x";
+  return Je[o.name] ?? "x";
 }
-async function Je(t, n, o, s) {
-  const e = me(await E(t), await E(n)), u = e.api.breaking.length > 0, a = u && !o.has("--allow-breaking") ? 1 : 0;
+async function We(n, s, o, a) {
+  const e = me(await E(n), await E(s)), u = e.api.breaking.length > 0, t = u && !o.has("--allow-breaking") ? 1 : 0;
   if (o.has("--json"))
-    return s.out(JSON.stringify(e, null, 2)), a;
-  s.out("# Database"), e.database.statements.length === 0 && s.out("no changes");
-  for (const c of e.database.statements)
-    s.out(`${c.destructive ? "// destructive: " : "// "}${c.reason}`), s.out(`${c.text};`);
-  s.out(`
-# API`), !u && e.api.dangerous.length === 0 && s.out("no changes");
-  for (const c of e.api.breaking) s.out(`breaking   ${c.description}`);
-  for (const c of e.api.dangerous) s.out(`dangerous  ${c.description}`);
-  for (const c of e.notes) s.out(`note       ${c}`);
-  return a;
+    return a.out(JSON.stringify(e, null, 2)), t;
+  a.out("# Database"), e.database.statements.length === 0 && a.out("no changes");
+  for (const r of e.database.statements)
+    a.out(`${r.destructive ? "// destructive: " : "// "}${r.reason}`), a.out(`${r.text};`);
+  a.out(`
+# API`), !u && e.api.dangerous.length === 0 && a.out("no changes");
+  for (const r of e.api.breaking) a.out(`breaking   ${r.description}`);
+  for (const r of e.api.dangerous) a.out(`dangerous  ${r.description}`);
+  for (const r of e.notes) a.out(`note       ${r}`);
+  return t;
 }
-const We = {
-  out: (t) => process.stdout.write(t + `
+const Be = {
+  out: (n) => process.stdout.write(n + `
 `),
-  err: (t) => process.stderr.write(t + `
+  err: (n) => process.stderr.write(n + `
 `)
-}, Be = typeof process < "u" && process.argv[1] !== void 0 && /lora-graphql(\.js)?$|cli\.js$/.test(process.argv[1]);
-Be && qe(process.argv.slice(2)).then((t) => process.exit(t));
+}, Ge = typeof process < "u" && process.argv[1] !== void 0 && /lora-graphql(\.js)?$|cli\.js$/.test(process.argv[1]);
+Ge && qe(process.argv.slice(2)).then((n) => process.exit(n));
 export {
   qe as main
 };