@loradb/lora-graphql 0.16.2 → 0.17.0

package/dist/cli.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { stat as B, readdir as ne, readFile as se, mkdir as ae, writeFile as _ } from "node:fs/promises";
-import { join as D, relative as oe } from "node:path";
-import { parse as A, Kind as p, visit as G, print as z, typeFromAST as ie, isNonNullType as U, isListType as re, getNamedType as ue, isEnumType as ce, isInputObjectType as le } from "graphql";
-import { d as fe } from "./diff-BVP1Jzh3.js";
-import { m as H, d as de, M as pe, L as M, l as Q, f as F, o as V, b as me, i as he, r as ge, u as ve } from "./driver-C8vA5fV-.js";
-const we = /* @__PURE__ */ new Set(["Query", "Mutation", "Subscription"]), x = {
+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-8nsBSSNP.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-BmnRtkpd.js";
+const be = /* @__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 +13,7 @@ const we = /* @__PURE__ */ new Set(["Query", "Mutation", "Subscription"]), x = {
   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"
-}, Te = [
+}, Ne = [
   ["_NOT_IN", "IN"],
   ["_STARTS_WITH", "STARTS_WITH"],
   ["_ENDS_WITH", "ENDS_WITH"],
@@ -25,7 +25,7 @@ const we = /* @__PURE__ */ new Set(["Query", "Mutation", "Subscription"]), x = {
   ["_LT", "LT"],
   ["_IN", "IN"],
   ["_EQ", "EQ"]
-], Ee = {
+], Se = {
   eq: "EQ",
   in: "IN",
   lt: "LT",
@@ -38,249 +38,249 @@ const we = /* @__PURE__ */ new Set(["Query", "Mutation", "Subscription"]), x = {
   includes: "INCLUDES",
   caseInsensitive: "CASE_INSENSITIVE"
 };
-function be(t, n = []) {
-  const o = A(t, { noLocation: !0 }), s = [], e = o.definitions.filter(
-    (i) => i.kind === p.OBJECT_TYPE_DEFINITION && !we.has(i.name.value) && !y(i.directives, "relationshipProperties") && !y(i.directives, "jwt")
-  ), c = new Set(e.map((i) => i.name.value)), a = n.length > 0 ? ye(n, e) : void 0, u = G(o, {
+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, {
     ObjectTypeDefinition(i) {
-      if (!c.has(i.name.value)) return;
+      if (!u.has(i.name.value)) return;
       const r = i.name.value;
-      let l = Y(
+      let l = K(
         i.directives ?? [],
         r,
         void 0,
         s
       );
-      y(l, "node") || (l = [...l, I("node")]);
-      const f = a?.mutations.get(r);
-      y(l, "mutation") || (a ? f && f.size > 0 && (l = [
+      O(l, "node") || (l = [...l, I("node")]);
+      const d = a?.mutations.get(r);
+      O(l, "mutation") || (a ? d && d.size > 0 && (l = [
         ...l,
         I("mutation", {
-          operations: R([...f].sort())
+          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`
       )));
-      const m = (i.fields ?? []).filter((v) => y(v.directives, "id"));
+      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 h = (i.fields ?? []).map(
-        (v) => Ne(v, r, a, s)
+        (v) => ye(v, r, a, s)
       );
       return { ...i, directives: l, fields: h };
     }
   });
-  return { typeDefs: z(u), todos: s };
+  return { typeDefs: Q(c), todos: s };
 }
-function Ne(t, n, o, s) {
-  let e = Y(
+function ye(t, n, o, s) {
+  let e = K(
     t.directives ?? [],
     n,
     t.name.value,
     s
   );
-  e.find((u) => u.name.value === "id") && (e = e.filter(
-    (u) => u.name.value !== "id" && u.name.value !== "unique"
-  ), e.push(I("key", { generate: K(!0) })));
+  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 && !y(e, "filterable") && e.push(
-    y(e, "relationship") ? I("filterable") : I("filterable", { byValue: R([...a].sort()) })
-  ), o?.sorts.get(n)?.has(t.name.value) && !y(e, "sortable") && e.push(I("sortable")), { ...t, directives: e };
+  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 };
 }
-function Y(t, n, o, s) {
-  const e = o ? `${n}.${o}` : n, c = [];
+function K(t, n, o, s) {
+  const e = o ? `${n}.${o}` : n, u = [];
   for (const a of t) {
-    const u = a.name.value;
-    if (u in x) {
-      s.push(`${e}: ${x[u]}`);
+    const c = a.name.value;
+    if (c in W) {
+      s.push(`${e}: ${W[c]}`);
       continue;
     }
-    if (u === "key" && !o) {
+    if (c === "key" && !o) {
       s.push(`${e}: federation @key(fields:) is not supported`);
       continue;
     }
-    if (u === "unique") {
-      c.push(I("unique"));
+    if (c === "unique") {
+      u.push(I("unique"));
       continue;
     }
-    if (u === "relationship") {
-      c.push(Se(a, e, s));
+    if (c === "relationship") {
+      u.push(Oe(a, e, s));
       continue;
     }
-    if (u === "fulltext") {
-      c.push(ke(a, "indexes", "indexName", "name"));
+    if (c === "fulltext") {
+      u.push($e(a, "indexes", "indexName", "name"));
       continue;
     }
-    if (u === "subscription") {
-      c.push(Ie(a, e, s));
+    if (c === "subscription") {
+      u.push(ke(a, e, s));
       continue;
     }
-    (u === "authorization" || u === "authentication") && s.push(
-      `${e}: check the @${u} rule's filters: operators are written { field: { eq: ... } } here`
-    ), c.push(a);
+    (c === "authorization" || c === "authentication") && s.push(
+      `${e}: check the @${c} rule's filters: operators are written { field: { eq: ... } } here`
+    ), u.push(a);
   }
-  return c;
+  return u;
 }
-function Se(t, n, o) {
+function Oe(t, n, o) {
   const s = [];
   for (const e of t.arguments ?? []) {
-    const c = e.name.value;
-    if (c === "queryDirection" && e.value.kind === p.ENUM) {
-      e.value.value.includes("UNDIRECTED") && s.push(L("queryDirection", Z("UNDIRECTED")));
+    const u = e.name.value;
+    if (u === "queryDirection" && e.value.kind === p.ENUM) {
+      e.value.value.includes("UNDIRECTED") && s.push(A("queryDirection", X("UNDIRECTED")));
       continue;
     }
-    if (c === "nestedOperations" && e.value.kind === p.LIST) {
+    if (u === "nestedOperations" && e.value.kind === p.LIST) {
       const a = e.value.values.filter(
-        (u) => u.kind === p.ENUM && u.value !== "CONNECT_OR_CREATE"
+        (c) => c.kind === p.ENUM && c.value !== "CONNECT_OR_CREATE"
       );
-      a.length < e.value.values.length && o.push(`${n}: connectOrCreate is not supported; use upsert`), s.push(L("nestedOperations", { kind: p.LIST, values: a }));
+      a.length < e.value.values.length && o.push(`${n}: connectOrCreate is not supported; use upsert`), s.push(A("nestedOperations", { kind: p.LIST, values: a }));
       continue;
     }
     s.push(e);
   }
   return { ...t, arguments: s };
 }
-function Ie(t, n, o) {
+function ke(t, n, o) {
   const s = t.arguments?.find((a) => a.name.value === "events")?.value;
   if (!s || s.kind !== p.LIST) return t;
   const e = /* @__PURE__ */ new Set();
-  let c = !1;
+  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") && (c = !0));
+    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));
   return o.push(
     `${n}: subscriptions see writes made through this library (or the engine change feed), not CDC`
   ), I("subscription", {
     operations: R([...e].sort()),
-    ...c ? { relationships: K(!0) } : {}
+    ...u ? { relationships: ee(!0) } : {}
   });
 }
-function ye(t, n) {
+function De(t, n) {
   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(H(r.name.value), r), s.set(De(r.name.value), r);
-  const e = new Map(n.map((r) => [r.name.value, r])), c = (r, l, f) => {
+    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(f), m.set(l, h), o.filters.set(r, m);
+    h.add(d), m.set(l, h), o.filters.set(r, m);
   }, a = (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) a(r, w);
+          if (d.value.kind === p.LIST)
+            for (const w of d.value.values) a(r, w);
           continue;
         }
         if (m === "NOT") {
-          a(r, f.value);
+          a(r, d.value);
           continue;
         }
         const h = /^(.+)_(SOME|ALL|NONE|SINGLE)$/.exec(m);
         if (h) {
-          const w = r.fields?.find((C) => C.name.value === h[1]), N = w && e.get(J(w));
-          w && N && (c(r.name.value, h[1], "EQ"), a(N, f.value));
+          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));
           continue;
         }
-        const v = Te.find(([w]) => m.endsWith(w)), g = v ? m.slice(0, -v[0].length) : m, T = r.fields?.find((w) => w.name.value === g);
-        if (!T) continue;
-        const b = e.get(J(T));
-        if (b) {
-          if (c(r.name.value, g, "EQ"), f.value.kind === p.OBJECT) {
-            for (const w of f.value.fields) a(b, w.value);
-            a(b, f.value);
+        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);
+        if (!g) continue;
+        const N = e.get(B(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);
           }
           continue;
         }
-        if (v) c(r.name.value, g, v[1]);
-        else if (f.value.kind === p.OBJECT)
-          for (const w of f.value.fields) {
-            const N = Ee[w.name.value];
-            N && c(r.name.value, g, N);
+        if (v) u(r.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);
           }
-        else c(r.name.value, g, "EQ");
+        else u(r.name.value, T, "EQ");
       }
-  }, u = (r, l) => {
-    for (const f of r?.selections ?? []) {
-      if (f.kind !== p.FIELD) continue;
-      const m = f.name.value;
+  }, c = (r, l) => {
+    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)$/, ""), g = s.get(v) ?? (h ? s.get(X(h[2])) : void 0);
-        if (g && h) {
-          const T = o.mutations.get(g.name.value) ?? /* @__PURE__ */ new Set(), b = h[1].toUpperCase();
-          b === "UPSERT" ? (T.add("CREATE"), T.add("UPDATE")) : T.add(b), o.mutations.set(g.name.value, T);
+        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);
+        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);
         }
-        if (g)
-          for (const T of f.arguments ?? []) i(g, T);
+        if (T)
+          for (const g of d.arguments ?? []) i(T, g);
       }
-      u(f.selectionSet, !1);
+      c(d.selectionSet, !1);
     }
   }, i = (r, l) => {
     if (l.name.value === "where" && a(r, l.value), l.name.value === "sort" || l.name.value === "options") {
-      const f = o.sorts.get(r.name.value) ?? /* @__PURE__ */ new Set(), m = (h) => {
+      const d = o.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), o.sorts.set(r.name.value, f);
+      m(l.value), o.sorts.set(r.name.value, d);
     }
   };
   for (const r of t)
     for (const l of r.definitions)
-      l.kind === p.OPERATION_DEFINITION && u(l.selectionSet, !0);
+      l.kind === p.OPERATION_DEFINITION && c(l.selectionSet, !0);
   return o;
 }
-function J(t) {
+function B(t) {
   let n = t.type;
   for (; n.kind !== p.NAMED_TYPE; ) n = n.type;
   return n.name.value;
 }
-function y(t, n) {
+function O(t, n) {
   return (t ?? []).some((o) => o.name.value === n);
 }
 function I(t, n = {}) {
   return {
     kind: p.DIRECTIVE,
     name: { kind: p.NAME, value: t },
-    arguments: Object.entries(n).map(([o, s]) => L(o, s))
+    arguments: Object.entries(n).map(([o, s]) => A(o, s))
   };
 }
-function L(t, n) {
+function A(t, n) {
   return { kind: p.ARGUMENT, name: { kind: p.NAME, value: t }, value: n };
 }
-const Z = (t) => ({
+const X = (t) => ({
   kind: p.ENUM,
   value: t
-}), K = (t) => ({
+}), ee = (t) => ({
   kind: p.BOOLEAN,
   value: t
 }), R = (t) => ({
   kind: p.LIST,
-  values: t.map(Z)
+  values: t.map(X)
 });
-function ke(t, n, o, s) {
+function $e(t, n, o, s) {
   return {
     ...t,
     arguments: (t.arguments ?? []).map(
-      (e) => e.name.value === n && e.value.kind === p.LIST ? L(n, {
+      (e) => e.name.value === n && e.value.kind === p.LIST ? A(n, {
         kind: p.LIST,
         values: e.value.values.map(
-          (c) => c.kind === p.OBJECT ? {
-            ...c,
-            fields: c.fields.map(
+          (u) => u.kind === p.OBJECT ? {
+            ...u,
+            fields: u.fields.map(
               (a) => a.name.value === o ? { ...a, name: { kind: p.NAME, value: s } } : a
             )
-          } : c
+          } : u
         )
       }) : e
     )
   };
 }
-const Oe = {
+const Le = {
   person: "people",
   man: "men",
   woman: "women",
@@ -290,23 +290,24 @@ const Oe = {
   foot: "feet",
   tooth: "teeth"
 };
-function De(t) {
-  const n = X(t), o = n.toLowerCase();
-  for (const [s, e] of Object.entries(Oe))
+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 H(t);
+  return V(t);
 }
-function X(t) {
+function te(t) {
   return t.charAt(0).toLowerCase() + t.slice(1);
 }
-const W = `lora-graphql <command>
+const G = `lora-graphql <command>
 
   print <schema.graphql>                    the public SDL clients see
   directives                                the directive definitions, for editors
   requirements <schema.graphql> [--ddl]     constraints and indexes the API needs
   check <schema.graphql> [--operations <file|dir>]... [--json]
-        [--variables <file>] [--baseline <file> [--update-baseline]]
+        [--variables <file>] [--context <file>]
+        [--baseline <file> [--update-baseline]]
         [--row-budget <n>] [--database <dir> [--name <db>]]
                                             CI gate: model, lint, @cypher statements and
                                             the plans of your operations, on an in-memory
@@ -321,54 +322,55 @@ const W = `lora-graphql <command>
                                             what has no equivalent
   diff <old.graphql> <new.graphql> [--allow-breaking] [--json]
                                             database statements and API changes`;
-async function $e(t, n = Fe) {
-  const [o, ...s] = t, e = /* @__PURE__ */ new Set(), c = /* @__PURE__ */ new Map(), a = [], u = [];
+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" ? u.push(s[++i] ?? "") : Le.has(r) ? c.set(r, s[++i] ?? "") : r.startsWith("--") ? e.add(r) : a.push(r);
+    r === "--operations" ? c.push(s[++i] ?? "") : Ce.has(r) ? u.set(r, s[++i] ?? "") : r.startsWith("--") ? e.add(r) : a.push(r);
   }
   try {
     switch (o) {
       case "print":
-        return await Ae(k(a, 1), n);
+        return await _e(k(a, 1), n);
       case "directives":
-        return n.out(de.trim()), 0;
+        return n.out(he.trim()), 0;
       case "requirements":
-        return await qe(k(a, 1), e.has("--ddl"), n);
+        return await je(k(a, 1), e.has("--ddl"), n);
       case "check":
-        return await Ce(k(a, 1), u, e, c, n);
+        return await Me(k(a, 1), c, e, u, n);
       case "compile":
-        return await je(k(a, 1), u, c, n);
+        return await xe(k(a, 1), c, u, n);
       case "analyze":
-        return await Me(k(a, 1), c, n);
+        return await Pe(k(a, 1), u, n);
       case "migrate": {
         const [i, r] = k(a, 2);
-        if (i !== "neo4j") throw new $("migrate supports neo4j");
+        if (i !== "neo4j") throw new L("migrate supports neo4j");
         const l = [];
-        for (const m of u)
-          for (const h of await q(m)) l.push(A(h.source));
-        const f = be(await E(r), l);
-        for (const m of f.todos) n.out(`# TODO(migrate): ${m}`);
-        return f.todos.length > 0 && n.out(""), n.out(f.typeDefs), 0;
+        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;
       }
       case "diff": {
         const [i, r] = k(a, 2);
-        return await Ue(i, r, e, n);
+        return await Je(i, r, e, n);
       }
       default:
-        return n.err(W), 2;
+        return n.err(G), 2;
     }
   } catch (i) {
-    return i instanceof $ ? (n.err(`${i.message}
+    return i instanceof L ? (n.err(`${i.message}
 
-${W}`), 2) : i instanceof pe ? (n.err(i.message), 1) : (n.err(i instanceof Error ? i.message : String(i)), 1);
+${G}`), 2) : i instanceof ge ? (n.err(i.message), 1) : (n.err(i instanceof Error ? i.message : String(i)), 1);
   }
 }
-class $ extends Error {
+class L extends Error {
 }
-const Le = /* @__PURE__ */ new Set([
+const Ce = /* @__PURE__ */ new Set([
   "--out",
   "--variables",
+  "--context",
   "--baseline",
   "--row-budget",
   "--database",
@@ -377,28 +379,28 @@ const Le = /* @__PURE__ */ new Set([
 ]);
 function k(t, n) {
   if (t.length < n)
-    throw new $(`expected ${n} file argument(s)`);
+    throw new L(`expected ${n} file argument(s)`);
   return t;
 }
-const E = (t) => se(t, "utf8");
-function ee(t) {
+const E = (t) => ie(t, "utf8");
+function ne(t) {
   const n = {
     run: () => Promise.reject(new Error("no database"))
   };
   return new M({ typeDefs: t, driver: n });
 }
-async function Ae([t], n) {
-  return n.out(ee(await E(t)).printPublicSchema()), 0;
+async function _e([t], n) {
+  return n.out(ne(await E(t)).printPublicSchema()), 0;
 }
-async function qe([t], n, o) {
-  const s = me(await E(t));
-  for (const e of he(s))
+async function je([t], n, o) {
+  const s = ve(await E(t));
+  for (const e of we(s))
     o.out(
-      n ? `${ge(e)};` : `${V(e)}, because ${e.reason}`
+      n ? `${Te(e)};` : `${Z(e)}, because ${e.reason}`
     );
   return 0;
 }
-async function te(t, n) {
+async function se(t, n) {
   try {
     const { createDatabase: o } = await import("@loradb/lora-node");
     return o;
@@ -409,175 +411,182 @@ async function te(t, n) {
     return;
   }
 }
-async function Ce([t], n, o, s, e) {
-  const c = o.has("--json"), a = await E(t), u = await te(e, "check");
-  if (!u) return 1;
-  const i = s.get("--database"), r = await u(
+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,
     i ? { databaseDir: i } : {}
   ), l = new M({
     typeDefs: a,
-    driver: Q(r)
+    driver: Y(r)
   });
   i || await l.assertSchema({ create: !0 });
-  const f = l.getSchema(), m = s.has("--variables") ? JSON.parse(await E(s.get("--variables"))) : {}, h = [];
-  for (const d of n)
-    for (const S of await q(d))
-      for (const O of Re(f, S.path, S.source)) {
-        const P = m[O.name] ?? m[O.name.split("#")[1] ?? ""];
-        h.push(P ? { ...O, variables: P } : O);
+  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["*"];
+        v.push({
+          ...y,
+          ...P ? { variables: P } : {},
+          ...U !== void 0 ? { context: U } : {}
+        });
       }
-  const v = s.has("--row-budget") ? Number(s.get("--row-budget")) : void 0, g = await l.check({
-    operations: h,
-    ...v !== void 0 ? { rowBudget: v } : {}
-  }), T = s.get("--baseline"), b = {};
-  for (const d of g.plans)
-    b[`${d.operation} › ${d.field}`] = d.reports.map((S) => S.operators);
-  const w = [];
-  if (T) {
-    let d;
+  const T = s.has("--row-budget") ? Number(s.get("--row-budget")) : void 0, g = await l.check({
+    operations: v,
+    ...T !== void 0 ? { rowBudget: T } : {}
+  }), N = s.get("--baseline"), w = {};
+  for (const f of g.plans)
+    w[`${f.operation} › ${f.field}`] = f.reports.map((b) => b.operators);
+  const S = [];
+  if (N) {
+    let f;
     try {
-      d = JSON.parse(await E(T));
+      f = JSON.parse(await E(N));
     } catch {
-      d = void 0;
+      f = void 0;
     }
-    if (o.has("--update-baseline") || !d)
-      await _(T, JSON.stringify(b, null, 2) + `
+    if (o.has("--update-baseline") || !f)
+      await _(N, JSON.stringify(w, null, 2) + `
 `);
     else
-      for (const S of /* @__PURE__ */ new Set([
-        ...Object.keys(d),
-        ...Object.keys(b)
+      for (const b of /* @__PURE__ */ new Set([
+        ...Object.keys(f),
+        ...Object.keys(w)
       ]))
-        JSON.stringify(d[S]) !== JSON.stringify(b[S]) && w.push(S);
+        JSON.stringify(f[b]) !== JSON.stringify(w[b]) && S.push(b);
   }
-  const N = g.ok && w.length === 0;
-  if (c)
-    return e.out(JSON.stringify({ ...g, ok: N, planChanges: w }, null, 2)), N ? 0 : 1;
-  for (const d of g.warnings) e.out(`warning  ${F(d)}`);
-  for (const d of g.lint) e.out(`lint     ${F(d)}`);
-  for (const d of g.unused)
+  const D = 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)}`);
+  for (const f of g.unused)
     e.out(
-      `unused   ${d.type} index ${d.name} on :${d.labels.join(":")}(${d.properties.join(", ")})`
+      `unused   ${f.type} index ${f.name} on :${f.labels.join(":")}(${f.properties.join(", ")})`
     );
-  for (const d of g.missing)
-    e.out(`error    missing ${V(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 S of d.reports)
-      for (const O of S.findings)
-        e.out(`error    ${d.operation} › ${d.field}: ${O.message}`);
-  for (const d of w)
+  for (const f of g.missing)
+    e.out(`error    missing ${Z(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 f of S)
     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 C = g.plans.length;
+  const ae = g.plans.length;
   return e.out(
-    N ? `ok       ${C} root field(s) in ${h.length} operation(s) seek as expected` : "failed"
-  ), N ? 0 : 1;
+    D ? `ok       ${ae} root field(s) in ${v.length} operation(s) seek as expected` : "failed"
+  ), D ? 0 : 1;
 }
-async function _e(t) {
+async function Re(t) {
   const n = {};
   for (const o of t) {
-    if ((await B(o)).isFile() && o.endsWith(".json")) {
+    if ((await z(o)).isFile() && o.endsWith(".json")) {
       Object.assign(
         n,
         JSON.parse(await E(o))
       );
       continue;
     }
-    for (const e of await q(o)) {
-      const c = A(e.source), a = new Map(
-        c.definitions.filter(
+    for (const e of await C(o)) {
+      const u = q(e.source), a = new Map(
+        u.definitions.filter(
           (i) => i.kind === p.FRAGMENT_DEFINITION
         ).map((i) => [i.name.value, i])
-      ), u = oe(process.cwd(), e.path);
-      c.definitions.filter(
+      ), c = ce(process.cwd(), e.path);
+      u.definitions.filter(
         (i) => i.kind === p.OPERATION_DEFINITION
       ).forEach((i, r) => {
-        const l = `${u}#${i.name?.value ?? r + 1}`;
-        n[l] = z({
+        const l = `${c}#${i.name?.value ?? r + 1}`;
+        n[l] = Q({
           kind: p.DOCUMENT,
-          definitions: [i, ...ve(i, a)]
+          definitions: [i, ...Ee(i, a)]
         });
       });
     }
   }
   return n;
 }
-async function je([t], n, o, s) {
+async function xe([t], n, o, s) {
   if (n.length === 0)
-    throw new $("compile needs --operations <file|dir>");
-  const e = ee(await E(t)), c = e.buildManifest(
-    await _e(n)
+    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 ae(a, { recursive: !0 }), await _(
-    D(a, "manifest.json"),
-    JSON.stringify(c) + `
+  return await re(a, { recursive: !0 }), await _(
+    $(a, "manifest.json"),
+    JSON.stringify(u) + `
 `
   ), await _(
-    D(a, "operations.d.ts"),
-    e.generateTypes(c)
+    $(a, "operations.d.ts"),
+    e.generateTypes(u)
   ), s.out(
-    `wrote ${Object.keys(c.operations).length} operation(s) to ${D(a, "manifest.json")} and ${D(a, "operations.d.ts")}`
+    `wrote ${Object.keys(u.operations).length} operation(s) to ${$(a, "manifest.json")} and ${$(a, "operations.d.ts")}`
   ), 0;
 }
-async function Me([t], n, o) {
+async function Pe([t], n, o) {
   const s = n.get("--database");
-  if (!s) throw new $("analyze needs --database <dir>");
-  const e = await te(o, "analyze");
+  if (!s) throw new L("analyze needs --database <dir>");
+  const e = await se(o, "analyze");
   if (!e) return 1;
-  const c = await e(n.get("--name") ?? "app", {
+  const u = await e(n.get("--name") ?? "app", {
     databaseDir: s
   }), a = new M({
     typeDefs: await E(t),
-    driver: Q(c)
-  }), u = n.has("--sample") ? Number(n.get("--sample")) : void 0, i = await a.analyze(u !== void 0 ? { sample: u } : {});
-  return o.out(JSON.stringify(i, null, 2)), c.dispose?.(), 0;
+    driver: Y(u)
+  }), c = n.has("--sample") ? Number(n.get("--sample")) : void 0, i = await a.analyze(c !== void 0 ? { sample: c } : {});
+  return o.out(JSON.stringify(i, null, 2)), u.dispose?.(), 0;
 }
-async function q(t) {
-  if ((await B(t)).isFile()) return [{ path: t, source: await E(t) }];
+async function C(t) {
+  if ((await z(t)).isFile()) return [{ path: t, source: await E(t) }];
   const o = [];
-  for (const s of await ne(t, { withFileTypes: !0 })) {
-    const e = D(t, s.name);
-    s.isDirectory() ? o.push(...await q(e)) : /\.(graphql|gql)$/.test(s.name) && o.push({ path: e, source: await E(e) });
+  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) });
   }
   return o;
 }
-function Re(t, n, o) {
-  const s = A(o), e = new Map(
+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])
-  ), c = (a) => {
-    const u = /* @__PURE__ */ new Map(), i = (r) => G(r, {
+  ), u = (a) => {
+    const c = /* @__PURE__ */ new Map(), i = (r) => H(r, {
       FragmentSpread(l) {
-        const f = e.get(l.name.value);
-        f && !u.has(f.name.value) && (u.set(f.name.value, f), i(f));
+        const d = e.get(l.name.value);
+        d && !c.has(d.name.value) && (c.set(d.name.value, d), i(d));
       }
     });
-    return i(a), [...u.values()];
+    return i(a), [...c.values()];
   };
   return s.definitions.filter(
     (a) => a.kind === p.OPERATION_DEFINITION && a.operation === "query"
-  ).map((a, u) => {
+  ).map((a, c) => {
     const i = {};
     for (const r of a.variableDefinitions ?? []) {
       if (r.defaultValue || r.type.kind !== p.NON_NULL_TYPE) continue;
-      const l = ie(t, r.type);
+      const l = ue(t, r.type);
       l && (i[r.variable.name.value] = j(l));
     }
     return {
-      name: `${n}${a.name ? `#${a.name.value}` : `#${u + 1}`}`,
-      document: { kind: p.DOCUMENT, definitions: [a, ...c(a)] },
+      name: `${n}${a.name ? `#${a.name.value}` : `#${c + 1}`}`,
+      document: { kind: p.DOCUMENT, definitions: [a, ...u(a)] },
       variables: i
     };
   });
 }
-const Pe = {
+const Fe = {
   String: "x",
   ID: "x",
   Int: 1,
@@ -592,40 +601,40 @@ const Pe = {
   Duration: "P1D"
 };
 function j(t) {
-  const n = U(t) ? t.ofType : t;
-  if (re(n)) return [j(n.ofType)];
-  const o = ue(n);
-  if (ce(o)) return o.getValues()[0]?.value;
-  if (le(o)) {
+  const n = F(t) ? t.ofType : t;
+  if (le(n)) return [j(n.ofType)];
+  const o = fe(n);
+  if (de(o)) return o.getValues()[0]?.value;
+  if (pe(o)) {
     const s = {};
     for (const e of Object.values(o.getFields()))
-      U(e.type) && e.defaultValue === void 0 && (s[e.name] = j(e.type));
+      F(e.type) && e.defaultValue === void 0 && (s[e.name] = j(e.type));
     return s;
   }
-  return Pe[o.name] ?? "x";
+  return Fe[o.name] ?? "x";
 }
-async function Ue(t, n, o, s) {
-  const e = fe(await E(t), await E(n)), c = e.api.breaking.length > 0, a = c && !o.has("--allow-breaking") ? 1 : 0;
+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;
   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 u of e.database.statements)
-    s.out(`${u.destructive ? "// destructive: " : "// "}${u.reason}`), s.out(`${u.text};`);
+  for (const c of e.database.statements)
+    s.out(`${c.destructive ? "// destructive: " : "// "}${c.reason}`), s.out(`${c.text};`);
   s.out(`
-# API`), !c && e.api.dangerous.length === 0 && s.out("no changes");
-  for (const u of e.api.breaking) s.out(`breaking   ${u.description}`);
-  for (const u of e.api.dangerous) s.out(`dangerous  ${u.description}`);
-  for (const u of e.notes) s.out(`note       ${u}`);
+# 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;
 }
-const Fe = {
+const We = {
   out: (t) => process.stdout.write(t + `
 `),
   err: (t) => process.stderr.write(t + `
 `)
-}, xe = typeof process < "u" && process.argv[1] !== void 0 && /lora-graphql(\.js)?$|cli\.js$/.test(process.argv[1]);
-xe && $e(process.argv.slice(2)).then((t) => process.exit(t));
+}, 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));
 export {
-  $e as main
+  qe as main
 };
 //# sourceMappingURL=cli.js.map