@loradb/lora-graphql 0.20.2 → 0.22.0

package/dist/cli.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
-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-BO2igqdY.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-XeJM24iP.js";
-const be = /* @__PURE__ */ new Set(["Query", "Mutation", "Subscription"]), B = {
+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-B9iDdELF.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-C5dSoSD8.js";
+const $e = /* @__PURE__ */ new Set(["Query", "Mutation", "Subscription"]), W = {
   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",
@@ -13,7 +14,7 @@ const be = /* @__PURE__ */ new Set(["Query", "Mutation", "Subscription"]), B = {
   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"
-}, Ne = [
+}, ke = [
   ["_NOT_IN", "IN"],
   ["_STARTS_WITH", "STARTS_WITH"],
   ["_ENDS_WITH", "ENDS_WITH"],
@@ -25,7 +26,7 @@ const be = /* @__PURE__ */ new Set(["Query", "Mutation", "Subscription"]), B = {
   ["_LT", "LT"],
   ["_IN", "IN"],
   ["_EQ", "EQ"]
-], Se = {
+], Oe = {
   eq: "EQ",
   in: "IN",
   lt: "LT",
@@ -38,249 +39,249 @@ const be = /* @__PURE__ */ new Set(["Query", "Mutation", "Subscription"]), B = {
   includes: "INCLUDES",
   caseInsensitive: "CASE_INSENSITIVE"
 };
-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 c = i.name.value;
-      let l = X(
-        i.directives ?? [],
-        c,
+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, {
+    ObjectTypeDefinition(o) {
+      if (!c.has(o.name.value)) return;
+      const r = o.name.value;
+      let l = te(
+        o.directives ?? [],
+        r,
         void 0,
         a
       );
-      k(l, "node") || (l = [...l, y("node")]);
-      const d = t?.mutations.get(c);
-      k(l, "mutation") || (t ? d && d.size > 0 && (l = [
+      k(l, "node") || (l = [...l, I("node")]);
+      const f = t?.mutations.get(r);
+      k(l, "mutation") || (t ? f && f.size > 0 && (l = [
         ...l,
-        y("mutation", {
-          operations: R([...d].sort())
+        I("mutation", {
+          operations: F([...f].sort())
         })
-      ]) : (l = [...l, y("mutation")], a.push(
-        `${c}: @mutation added (@neo4j/graphql generates mutations for every type); remove it or narrow its operations`
+      ]) : (l = [...l, I("mutation")], a.push(
+        `${r}: @mutation added (@neo4j/graphql generates mutations for every type); remove it or narrow its operations`
       )));
-      const m = (i.fields ?? []).filter((v) => k(v.directives, "id"));
+      const m = (o.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) => Ie(v, c, t, a)
+        `${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)
       );
-      return { ...i, directives: l, fields: h };
+      return { ...o, directives: l, fields: h };
     }
   });
-  return { typeDefs: V(r), todos: a };
+  return { typeDefs: Z(u), todos: a };
 }
-function Ie(n, s, o, a) {
-  let e = X(
+function Le(n, s, i, a) {
+  let e = te(
     n.directives ?? [],
     s,
     n.name.value,
     a
   );
-  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);
+  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) })));
+  const t = i?.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 };
+    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 };
 }
-function X(n, s, o, a) {
-  const e = o ? `${s}.${o}` : s, u = [];
+function te(n, s, i, a) {
+  const e = i ? `${s}.${i}` : s, c = [];
   for (const t of n) {
-    const r = t.name.value;
-    if (r in B) {
-      a.push(`${e}: ${B[r]}`);
+    const u = t.name.value;
+    if (u in W) {
+      a.push(`${e}: ${W[u]}`);
       continue;
     }
-    if (r === "key" && !o) {
+    if (u === "key" && !i) {
       a.push(`${e}: federation @key(fields:) is not supported`);
       continue;
     }
-    if (r === "unique") {
-      u.push(y("unique"));
+    if (u === "unique") {
+      c.push(I("unique"));
       continue;
     }
-    if (r === "relationship") {
-      u.push(Oe(t, e, a));
+    if (u === "relationship") {
+      c.push(Ae(t, e, a));
       continue;
     }
-    if (r === "fulltext") {
-      u.push(De(t, "indexes", "indexName", "name"));
+    if (u === "fulltext") {
+      c.push(xe(t, "indexes", "indexName", "name"));
       continue;
     }
-    if (r === "subscription") {
-      u.push(ke(t, e, a));
+    if (u === "subscription") {
+      c.push(qe(t, e, a));
       continue;
     }
-    (r === "authorization" || r === "authentication") && a.push(
-      `${e}: check the @${r} rule's filters: operators are written { field: { eq: ... } } here`
-    ), u.push(t);
+    (u === "authorization" || u === "authentication") && a.push(
+      `${e}: check the @${u} rule's filters: operators are written { field: { eq: ... } } here`
+    ), c.push(t);
   }
-  return u;
+  return c;
 }
-function Oe(n, s, o) {
+function Ae(n, s, i) {
   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") && a.push(A("queryDirection", ee("UNDIRECTED")));
+    const c = e.name.value;
+    if (c === "queryDirection" && e.value.kind === p.ENUM) {
+      e.value.value.includes("UNDIRECTED") && a.push(q("queryDirection", ne("UNDIRECTED")));
       continue;
     }
-    if (u === "nestedOperations" && e.value.kind === p.LIST) {
+    if (c === "nestedOperations" && e.value.kind === p.LIST) {
       const t = e.value.values.filter(
-        (r) => r.kind === p.ENUM && r.value !== "CONNECT_OR_CREATE"
+        (u) => u.kind === p.ENUM && u.value !== "CONNECT_OR_CREATE"
       );
-      t.length < e.value.values.length && o.push(`${s}: connectOrCreate is not supported; use upsert`), a.push(A("nestedOperations", { kind: p.LIST, values: t }));
+      t.length < e.value.values.length && i.push(`${s}: connectOrCreate is not supported; use upsert`), a.push(q("nestedOperations", { kind: p.LIST, values: t }));
       continue;
     }
     a.push(e);
   }
   return { ...n, arguments: a };
 }
-function ke(n, s, o) {
+function qe(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();
-  let u = !1;
+  let c = !1;
   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(
+    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`
-  ), y("subscription", {
-    operations: R([...e].sort()),
-    ...u ? { relationships: te(!0) } : {}
+  ), I("subscription", {
+    operations: F([...e].sort()),
+    ...c ? { relationships: se(!0) } : {}
   });
 }
-function $e(n, s) {
-  const o = {
+function je(n, s) {
+  const i = {
     filters: /* @__PURE__ */ new Map(),
     sorts: /* @__PURE__ */ new Map(),
     mutations: /* @__PURE__ */ new Map()
   }, 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) => {
+  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) => {
+    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);
+  }, t = (r, l) => {
     if (l.kind === p.OBJECT)
-      for (const d of l.fields) {
-        const m = d.name.value;
+      for (const f of l.fields) {
+        const m = f.name.value;
         if (m === "AND" || m === "OR") {
-          if (d.value.kind === p.LIST)
-            for (const w of d.value.values) t(c, w);
+          if (f.value.kind === p.LIST)
+            for (const w of f.value.values) t(r, w);
           continue;
         }
         if (m === "NOT") {
-          t(c, d.value);
+          t(r, f.value);
           continue;
         }
         const h = /^(.+)_(SOME|ALL|NONE|SINGLE)$/.exec(m);
         if (h) {
-          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));
+          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));
           continue;
         }
-        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);
+        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);
         if (!g) continue;
-        const N = e.get(G(g));
+        const N = e.get(z(g));
         if (N) {
-          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);
+          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);
           }
           continue;
         }
-        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(c.name.value, T, S);
+        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);
           }
-        else u(c.name.value, T, "EQ");
+        else c(r.name.value, b, "EQ");
       }
-  }, r = (c, l) => {
-    for (const d of c?.selections ?? []) {
-      if (d.kind !== p.FIELD) continue;
-      const m = d.name.value;
+  }, u = (r, l) => {
+    for (const f of r?.selections ?? []) {
+      if (f.kind !== p.FIELD) continue;
+      const m = f.name.value;
       if (l) {
-        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);
+        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);
         }
-        if (T)
-          for (const g of d.arguments ?? []) i(T, g);
+        if (b)
+          for (const g of f.arguments ?? []) o(b, g);
       }
-      r(d.selectionSet, !1);
+      u(f.selectionSet, !1);
     }
-  }, 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) => {
+  }, 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) => {
         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);
+            v.name.value === "sort" ? m(v.value) : v.value.kind === p.ENUM && f.add(v.name.value);
       };
-      m(l.value), o.sorts.set(c.name.value, d);
+      m(l.value), i.sorts.set(r.name.value, f);
     }
   };
-  for (const c of n)
-    for (const l of c.definitions)
-      l.kind === p.OPERATION_DEFINITION && r(l.selectionSet, !0);
-  return o;
+  for (const r of n)
+    for (const l of r.definitions)
+      l.kind === p.OPERATION_DEFINITION && u(l.selectionSet, !0);
+  return i;
 }
-function G(n) {
+function z(n) {
   let s = n.type;
   for (; s.kind !== p.NAMED_TYPE; ) s = s.type;
   return s.name.value;
 }
 function k(n, s) {
-  return (n ?? []).some((o) => o.name.value === s);
+  return (n ?? []).some((i) => i.name.value === s);
 }
-function y(n, s = {}) {
+function I(n, s = {}) {
   return {
     kind: p.DIRECTIVE,
     name: { kind: p.NAME, value: n },
-    arguments: Object.entries(s).map(([o, a]) => A(o, a))
+    arguments: Object.entries(s).map(([i, a]) => q(i, a))
   };
 }
-function A(n, s) {
+function q(n, s) {
   return { kind: p.ARGUMENT, name: { kind: p.NAME, value: n }, value: s };
 }
-const ee = (n) => ({
+const ne = (n) => ({
   kind: p.ENUM,
   value: n
-}), te = (n) => ({
+}), se = (n) => ({
   kind: p.BOOLEAN,
   value: n
-}), R = (n) => ({
+}), F = (n) => ({
   kind: p.LIST,
-  values: n.map(ee)
+  values: n.map(ne)
 });
-function De(n, s, o, a) {
+function xe(n, s, i, a) {
   return {
     ...n,
     arguments: (n.arguments ?? []).map(
-      (e) => e.name.value === s && e.value.kind === p.LIST ? A(s, {
+      (e) => e.name.value === s && e.value.kind === p.LIST ? q(s, {
         kind: p.LIST,
         values: e.value.values.map(
-          (u) => u.kind === p.OBJECT ? {
-            ...u,
-            fields: u.fields.map(
-              (t) => t.name.value === o ? { ...t, name: { kind: p.NAME, value: a } } : t
+          (c) => c.kind === p.OBJECT ? {
+            ...c,
+            fields: c.fields.map(
+              (t) => t.name.value === i ? { ...t, name: { kind: p.NAME, value: a } } : t
             )
-          } : u
+          } : c
         )
       }) : e
     )
   };
 }
-const Le = {
+const _e = {
   person: "people",
   man: "men",
   woman: "women",
@@ -290,17 +291,17 @@ const Le = {
   foot: "feet",
   tooth: "teeth"
 };
-function Ae(n) {
-  const s = ne(n), o = s.toLowerCase();
-  for (const [a, e] of Object.entries(Le))
-    if (o.endsWith(a))
+function Ce(n) {
+  const s = ae(n), i = s.toLowerCase();
+  for (const [a, e] of Object.entries(_e))
+    if (i.endsWith(a))
       return s.slice(0, s.length - a.length) + e;
-  return Y(n);
+  return K(n);
 }
-function ne(n) {
+function ae(n) {
   return n.charAt(0).toLowerCase() + n.slice(1);
 }
-const z = `lora-graphql <command>
+const H = `lora-graphql <command>
 
   print <schema.graphql>                    the public SDL clients see
   directives                                the directive definitions, for editors
@@ -323,55 +324,68 @@ const z = `lora-graphql <command>
                                             rewrite an @neo4j/graphql SDL; TODOs for
                                             what has no equivalent
   diff <old.graphql> <new.graphql> [--allow-breaking] [--json]
-                                            database statements and API changes`;
-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);
+  diff --base <git-ref> <file|dir>... [--allow-breaking] [--json]
+                                            database statements and API changes; exit 1
+                                            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) {
+  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);
   }
   try {
-    switch (o) {
+    switch (i) {
       case "print":
-        return await _e(O(t, 1), s);
+        return await Pe(S(t, 1), s);
       case "directives":
-        return s.out(he.trim()), 0;
+        return s.out(be.trim()), 0;
       case "access":
-        return await Ce(O(t, 1), e.has("--json"), s);
+        return await Fe(S(t, 1), e.has("--json"), s);
       case "requirements":
-        return await xe(O(t, 1), e.has("--ddl"), s);
+        return await Ue(S(t, 1), e.has("--ddl"), s);
       case "check":
-        return await Me(O(t, 1), r, e, u, s);
+        return await Je(S(t, 1), u, e, c, s);
       case "compile":
-        return await Pe(O(t, 1), r, u, s);
+        return await Ge(S(t, 1), u, c, s);
       case "analyze":
-        return await Ue(O(t, 1), u, s);
+        return await We(S(t, 1), c, s);
       case "migrate": {
-        const [i, c] = O(t, 2);
-        if (i !== "neo4j") throw new L("migrate supports neo4j");
+        const [o, r] = S(t, 2);
+        if (o !== "neo4j") throw new L("migrate supports neo4j");
         const l = [];
-        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;
+        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;
       }
       case "diff": {
-        const [i, c] = O(t, 2);
-        return await We(i, c, e, s);
+        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);
+          return m === void 0 ? (s.out(
+            `${o} has none of ${f.join(", ")}; nothing to compare`
+          ), 0) : V(m, await Qe(f), e, s);
+        }
+        const [r, l] = S(t, 2);
+        return V(await E(r), await E(l), e, s);
       }
       default:
-        return s.err(z), 2;
+        return s.err(H), 2;
     }
-  } catch (i) {
-    return i instanceof L ? (s.err(`${i.message}
+  } catch (o) {
+    return o instanceof L ? (s.err(`${o.message}
 
-${z}`), 2) : i instanceof ge ? (s.err(i.message), 1) : (s.err(i instanceof Error ? i.message : String(i)), 1);
+${H}`), 2) : o instanceof Te ? (s.err(o.message), 1) : (s.err(o instanceof Error ? o.message : String(o)), 1);
   }
 }
 class L extends Error {
 }
-const je = /* @__PURE__ */ new Set([
+const Re = /* @__PURE__ */ new Set([
+  "--base",
   "--out",
   "--variables",
   "--context",
@@ -381,52 +395,52 @@ const je = /* @__PURE__ */ new Set([
   "--name",
   "--sample"
 ]);
-function O(n, s) {
+function S(n, s) {
   if (n.length < s)
     throw new L(`expected ${s} file argument(s)`);
   return n;
 }
-const E = (n) => ie(n, "utf8");
+const E = (n) => ce(n, "utf8");
 function P(n) {
   const s = {
     run: () => Promise.reject(new Error("no database"))
   };
-  return new M({ typeDefs: n, driver: s });
+  return new R({ typeDefs: n, driver: s });
 }
-async function Ce([n], s, o) {
+async function Fe([n], s, i) {
   const a = P(await E(n)).accessMatrix();
   if (s)
-    return o.out(JSON.stringify(a, null, 2)), 0;
+    return i.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)
+  ]), c = [0, 1, 2, 3].map(
+    (t) => Math.max(...e.map((u) => u[t].length), 0)
   );
   for (const t of e)
-    o.out(
-      t.map((r, i) => i < 4 ? r.padEnd(u[i]) : r).join("  ").trimEnd()
+    i.out(
+      t.map((u, o) => o < 4 ? u.padEnd(c[o]) : u).join("  ").trimEnd()
     );
   return 0;
 }
-async function _e([n], s) {
+async function Pe([n], s) {
   return s.out(P(await E(n)).printPublicSchema()), 0;
 }
-async function xe([n], s, o) {
-  const a = ve(await E(n));
-  for (const e of we(a))
-    o.out(
-      s ? `${Ee(e)};` : `${K(e)}, because ${e.reason}`
+async function Ue([n], s, i) {
+  const a = Ne(await E(n));
+  for (const e of ye(a))
+    i.out(
+      s ? `${Se(e)};` : `${ee(e)}, because ${e.reason}`
     );
   return 0;
 }
-async function se(n, s) {
+async function oe(n, s) {
   try {
-    const { createDatabase: o } = await import("@loradb/lora-node");
-    return o;
+    const { createDatabase: i } = await import("@loradb/lora-node");
+    return i;
   } catch {
     n.err(
       `${s} needs @loradb/lora-node: npm install --save-dev @loradb/lora-node`
@@ -434,183 +448,183 @@ async function se(n, s) {
     return;
   }
 }
-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({
+async function Je([n], s, i, a, e) {
+  const c = i.has("--json"), t = await E(n), u = await oe(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({
     typeDefs: t,
-    driver: Z(c)
+    driver: X(r)
   });
-  i || await l.assertSchema({ create: !0 });
-  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["*"];
+  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["*"];
         v.push({
-          ...I,
-          ...F ? { variables: F } : {},
-          ...J !== void 0 ? { context: J } : {}
+          ...$,
+          ...J ? { variables: J } : {},
+          ...B !== void 0 ? { context: B } : {}
         });
       }
-  const T = a.has("--row-budget") ? Number(a.get("--row-budget")) : void 0, g = await l.check({
+  const b = a.has("--row-budget") ? Number(a.get("--row-budget")) : void 0, g = await l.check({
     operations: v,
-    ...T !== void 0 ? { rowBudget: T } : {}
+    ...b !== void 0 ? { rowBudget: b } : {}
   }), N = a.get("--baseline"), w = {};
-  for (const f of g.plans)
-    w[`${f.operation} › ${f.field}`] = f.reports.map((b) => b.operators);
-  const S = [];
+  for (const d of g.plans)
+    w[`${d.operation} › ${d.field}`] = d.reports.map((T) => T.operators);
+  const y = [];
   if (N) {
-    let f;
+    let d;
     try {
-      f = JSON.parse(await E(N));
+      d = JSON.parse(await E(N));
     } catch {
-      f = void 0;
+      d = void 0;
     }
-    if (o.has("--update-baseline") || !f)
+    if (i.has("--update-baseline") || !d)
       await _(N, JSON.stringify(w, null, 2) + `
 `);
     else
-      for (const b of /* @__PURE__ */ new Set([
-        ...Object.keys(f),
+      for (const T of /* @__PURE__ */ new Set([
+        ...Object.keys(d),
         ...Object.keys(w)
       ]))
-        JSON.stringify(f[b]) !== JSON.stringify(w[b]) && S.push(b);
+        JSON.stringify(d[T]) !== JSON.stringify(w[T]) && y.push(T);
   }
-  const $ = g.ok && S.length === 0;
-  if (u)
-    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)
+  const D = g.ok && y.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)
     e.out(
-      `unused   ${f.type} index ${f.name} on :${f.labels.join(":")}(${f.properties.join(", ")})`
+      `unused   ${d.type} index ${d.name} on :${d.labels.join(":")}(${d.properties.join(", ")})`
     );
-  for (const f of g.security) e.out(`error    ${C(f)}`);
-  for (const f of g.missing)
-    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 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 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 S)
+  for (const d of y)
     e.out(
-      `error    ${f}: the plan differs from the baseline (--update-baseline to accept)`
+      `error    ${d}: the plan differs from the baseline (--update-baseline to accept)`
     );
-  const ae = g.plans.length;
+  const ie = g.plans.length;
   return e.out(
-    $ ? `ok       ${ae} root field(s) in ${v.length} operation(s) seek as expected` : "failed"
-  ), $ ? 0 : 1;
+    D ? `ok       ${ie} root field(s) in ${v.length} operation(s) seek as expected` : "failed"
+  ), D ? 0 : 1;
 }
-async function Re(n) {
+async function Be(n) {
   const s = {};
-  for (const o of n) {
-    if ((await H(o)).isFile() && o.endsWith(".json")) {
+  for (const i of n) {
+    if ((await M(i)).isFile() && i.endsWith(".json")) {
       Object.assign(
         s,
-        JSON.parse(await E(o))
+        JSON.parse(await E(i))
       );
       continue;
     }
-    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])
-      ), r = ce(process.cwd(), e.path);
-      u.definitions.filter(
-        (i) => i.kind === p.OPERATION_DEFINITION
-      ).forEach((i, c) => {
-        const l = `${r}#${i.name?.value ?? c + 1}`;
-        s[l] = V({
+    for (const e of await A(i)) {
+      const c = j(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);
+      c.definitions.filter(
+        (o) => o.kind === p.OPERATION_DEFINITION
+      ).forEach((o, r) => {
+        const l = `${u}#${o.name?.value ?? r + 1}`;
+        s[l] = Z({
           kind: p.DOCUMENT,
-          definitions: [i, ...Te(i, t)]
+          definitions: [o, ...Ie(o, t)]
         });
       });
     }
   }
   return s;
 }
-async function Pe([n], s, o, a) {
+async function Ge([n], s, i, a) {
   if (s.length === 0)
     throw new L("compile needs --operations <file|dir>");
-  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) + `
+  const e = P(await E(n)), c = e.buildManifest(
+    await Be(s)
+  ), t = i.get("--out") ?? "lora-graphql";
+  return await le(t, { recursive: !0 }), await _(
+    O(t, "manifest.json"),
+    JSON.stringify(c) + `
 `
   ), await _(
-    D(t, "operations.d.ts"),
-    e.generateTypes(u)
+    O(t, "operations.d.ts"),
+    e.generateTypes(c)
   ), a.out(
-    `wrote ${Object.keys(u.operations).length} operation(s) to ${D(t, "manifest.json")} and ${D(t, "operations.d.ts")}`
+    `wrote ${Object.keys(c.operations).length} operation(s) to ${O(t, "manifest.json")} and ${O(t, "operations.d.ts")}`
   ), 0;
 }
-async function Ue([n], s, o) {
+async function We([n], s, i) {
   const a = s.get("--database");
   if (!a) throw new L("analyze needs --database <dir>");
-  const e = await se(o, "analyze");
+  const e = await oe(i, "analyze");
   if (!e) return 1;
-  const u = await e(s.get("--name") ?? "app", {
+  const c = await e(s.get("--name") ?? "app", {
     databaseDir: a
-  }), t = new M({
+  }), t = new R({
     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;
+    driver: X(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 j(n) {
-  if ((await H(n)).isFile()) return [{ path: n, source: await E(n) }];
-  const o = [];
-  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) });
+async function A(n) {
+  if ((await M(n)).isFile()) return [{ path: n, source: await E(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) });
   }
-  return o;
+  return i;
 }
-function Fe(n, s, o) {
-  const a = q(o), e = new Map(
+function ze(n, s, i) {
+  const a = j(i), 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, {
+  ), c = (t) => {
+    const u = /* @__PURE__ */ new Map(), o = (r) => Y(r, {
       FragmentSpread(l) {
-        const d = e.get(l.name.value);
-        d && !r.has(d.name.value) && (r.set(d.name.value, d), i(d));
+        const f = e.get(l.name.value);
+        f && !u.has(f.name.value) && (u.set(f.name.value, f), o(f));
       }
     });
-    return i(t), [...r.values()];
+    return o(t), [...u.values()];
   };
   return a.definitions.filter(
     (t) => t.kind === p.OPERATION_DEFINITION && t.operation === "query"
-  ).map((t, r) => {
-    const i = {};
-    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));
+  ).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));
     }
     return {
-      name: `${s}${t.name ? `#${t.name.value}` : `#${r + 1}`}`,
-      document: { kind: p.DOCUMENT, definitions: [t, ...u(t)] },
-      variables: i
+      name: `${s}${t.name ? `#${t.name.value}` : `#${u + 1}`}`,
+      document: { kind: p.DOCUMENT, definitions: [t, ...c(t)] },
+      variables: o
     };
   });
 }
-const Je = {
+const He = {
   String: "x",
   ID: "x",
   Int: 1,
@@ -624,41 +638,90 @@ const Je = {
   LocalDateTime: "2026-01-01T12:00:00",
   Duration: "P1D"
 };
-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)) {
+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)) {
     const a = {};
-    for (const e of Object.values(o.getFields()))
-      W(e.type) && e.defaultValue === void 0 && (a[e.name] = x(e.type));
+    for (const e of Object.values(i.getFields()))
+      G(e.type) && e.defaultValue === void 0 && (a[e.name] = C(e.type));
     return a;
   }
-  return Je[o.name] ?? "x";
+  return He[i.name] ?? "x";
+}
+const Q = /\.(graphql|gql)$/;
+async function Qe(n) {
+  const s = [];
+  for (const i of n) {
+    const a = await A(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, {
+    cwd: c,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    maxBuffer: 67108864
+  }), a = [];
+  let e = !1;
+  for (const c of s) {
+    const t = await M(c).then(
+      (r) => r.isDirectory(),
+      () => !Q.test(c)
+    ), u = t ? c : fe(c);
+    try {
+      i(u, "rev-parse", "--verify", "--quiet", `${n}^{commit}`);
+    } catch {
+      throw new Error(
+        `diff: ${n} is not a commit (fetch it, or pass another ref)`
+      );
+    }
+    if (!t) {
+      try {
+        a.push(i(u, "show", `${n}:./${de(c)}`)), e = !0;
+      } catch {
+      }
+      continue;
+    }
+    const o = i(u, "ls-tree", "-r", "--name-only", n, "--", ".").split(`
+`).filter((r) => Q.test(r));
+    o.sort((r, l) => {
+      const f = O(c, r), m = O(c, l);
+      return f < m ? -1 : f > m ? 1 : 0;
+    });
+    for (const r of o)
+      a.push(i(u, "show", `${n}:./${r}`)), e = !0;
+  }
+  return e ? a.join(`
+`) : void 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 a.out(JSON.stringify(e, null, 2)), t;
+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;
+  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");
-  for (const r of e.database.statements)
-    a.out(`${r.destructive ? "// destructive: " : "// "}${r.reason}`), a.out(`${r.text};`);
+  for (const o of e.database.statements)
+    a.out(`${o.destructive ? "// destructive: " : "// "}${o.reason}`), a.out(`${o.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;
+# API`), !c && e.api.dangerous.length === 0 && a.out("no changes");
+  for (const o of e.api.breaking) a.out(`breaking   ${o.description}`);
+  for (const o of e.api.dangerous) a.out(`dangerous  ${o.description}`);
+  for (const o of e.notes) a.out(`note       ${o}`);
+  return u;
 }
-const Be = {
+const Ye = {
   out: (n) => process.stdout.write(n + `
 `),
   err: (n) => process.stderr.write(n + `
 `)
-}, 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));
+}, 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));
 export {
-  qe as main
+  Me as main
 };
 //# sourceMappingURL=cli.js.map