@loradb/lora-graphql 0.16.2

package/dist/cli.js

@@ -0,0 +1,631 @@
+#!/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 = {
+  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",
+  external: "federation (@external) is not supported",
+  requires: "federation (@requires) is not supported",
+  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 = [
+  ["_NOT_IN", "IN"],
+  ["_STARTS_WITH", "STARTS_WITH"],
+  ["_ENDS_WITH", "ENDS_WITH"],
+  ["_CONTAINS", "CONTAINS"],
+  ["_INCLUDES", "INCLUDES"],
+  ["_GTE", "GTE"],
+  ["_LTE", "LTE"],
+  ["_GT", "GT"],
+  ["_LT", "LT"],
+  ["_IN", "IN"],
+  ["_EQ", "EQ"]
+], Ee = {
+  eq: "EQ",
+  in: "IN",
+  lt: "LT",
+  lte: "LTE",
+  gt: "GT",
+  gte: "GTE",
+  contains: "CONTAINS",
+  startsWith: "STARTS_WITH",
+  endsWith: "ENDS_WITH",
+  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, {
+    ObjectTypeDefinition(i) {
+      if (!c.has(i.name.value)) return;
+      const r = i.name.value;
+      let l = Y(
+        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 = [
+        ...l,
+        I("mutation", {
+          operations: R([...f].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"));
+      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)
+      );
+      return { ...i, directives: l, fields: h };
+    }
+  });
+  return { typeDefs: z(u), todos: s };
+}
+function Ne(t, n, o, s) {
+  let e = Y(
+    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) })));
+  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 };
+}
+function Y(t, n, o, s) {
+  const e = o ? `${n}.${o}` : n, c = [];
+  for (const a of t) {
+    const u = a.name.value;
+    if (u in x) {
+      s.push(`${e}: ${x[u]}`);
+      continue;
+    }
+    if (u === "key" && !o) {
+      s.push(`${e}: federation @key(fields:) is not supported`);
+      continue;
+    }
+    if (u === "unique") {
+      c.push(I("unique"));
+      continue;
+    }
+    if (u === "relationship") {
+      c.push(Se(a, e, s));
+      continue;
+    }
+    if (u === "fulltext") {
+      c.push(ke(a, "indexes", "indexName", "name"));
+      continue;
+    }
+    if (u === "subscription") {
+      c.push(Ie(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);
+  }
+  return c;
+}
+function Se(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")));
+      continue;
+    }
+    if (c === "nestedOperations" && e.value.kind === p.LIST) {
+      const a = e.value.values.filter(
+        (u) => u.kind === p.ENUM && u.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 }));
+      continue;
+    }
+    s.push(e);
+  }
+  return { ...t, arguments: s };
+}
+function Ie(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;
+  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));
+  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) } : {}
+  });
+}
+function ye(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) => {
+    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);
+  }, a = (r, l) => {
+    if (l.kind === p.OBJECT)
+      for (const f of l.fields) {
+        const m = f.name.value;
+        if (m === "AND" || m === "OR") {
+          if (f.value.kind === p.LIST)
+            for (const w of f.value.values) a(r, w);
+          continue;
+        }
+        if (m === "NOT") {
+          a(r, f.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));
+          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);
+          }
+          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);
+          }
+        else c(r.name.value, g, "EQ");
+      }
+  }, 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)$/, ""), 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);
+        }
+        if (g)
+          for (const T of f.arguments ?? []) i(g, T);
+      }
+      u(f.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) => {
+        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);
+      };
+      m(l.value), o.sorts.set(r.name.value, f);
+    }
+  };
+  for (const r of t)
+    for (const l of r.definitions)
+      l.kind === p.OPERATION_DEFINITION && u(l.selectionSet, !0);
+  return o;
+}
+function J(t) {
+  let n = t.type;
+  for (; n.kind !== p.NAMED_TYPE; ) n = n.type;
+  return n.name.value;
+}
+function y(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))
+  };
+}
+function L(t, n) {
+  return { kind: p.ARGUMENT, name: { kind: p.NAME, value: t }, value: n };
+}
+const Z = (t) => ({
+  kind: p.ENUM,
+  value: t
+}), K = (t) => ({
+  kind: p.BOOLEAN,
+  value: t
+}), R = (t) => ({
+  kind: p.LIST,
+  values: t.map(Z)
+});
+function ke(t, n, o, s) {
+  return {
+    ...t,
+    arguments: (t.arguments ?? []).map(
+      (e) => e.name.value === n && e.value.kind === p.LIST ? L(n, {
+        kind: p.LIST,
+        values: e.value.values.map(
+          (c) => c.kind === p.OBJECT ? {
+            ...c,
+            fields: c.fields.map(
+              (a) => a.name.value === o ? { ...a, name: { kind: p.NAME, value: s } } : a
+            )
+          } : c
+        )
+      }) : e
+    )
+  };
+}
+const Oe = {
+  person: "people",
+  man: "men",
+  woman: "women",
+  child: "children",
+  mouse: "mice",
+  goose: "geese",
+  foot: "feet",
+  tooth: "teeth"
+};
+function De(t) {
+  const n = X(t), o = n.toLowerCase();
+  for (const [s, e] of Object.entries(Oe))
+    if (o.endsWith(s))
+      return n.slice(0, n.length - s.length) + e;
+  return H(t);
+}
+function X(t) {
+  return t.charAt(0).toLowerCase() + t.slice(1);
+}
+const W = `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]]
+        [--row-budget <n>] [--database <dir> [--name <db>]]
+                                            CI gate: model, lint, @cypher statements and
+                                            the plans of your operations, on an in-memory
+                                            LoraDB (or an existing one with --database)
+  compile <schema.graphql> --operations <file|dir>... [--out <dir>]
+                                            persisted-operation manifest.json and
+                                            operations.d.ts types
+  analyze <schema.graphql> --database <dir> [--name <db>] [--sample <n>]
+                                            statistics JSON for useStatistics()
+  migrate neo4j <schema.graphql> [--operations <file|dir>]...
+                                            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 $e(t, n = Fe) {
+  const [o, ...s] = t, e = /* @__PURE__ */ new Set(), c = /* @__PURE__ */ new Map(), a = [], u = [];
+  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);
+  }
+  try {
+    switch (o) {
+      case "print":
+        return await Ae(k(a, 1), n);
+      case "directives":
+        return n.out(de.trim()), 0;
+      case "requirements":
+        return await qe(k(a, 1), e.has("--ddl"), n);
+      case "check":
+        return await Ce(k(a, 1), u, e, c, n);
+      case "compile":
+        return await je(k(a, 1), u, c, n);
+      case "analyze":
+        return await Me(k(a, 1), c, n);
+      case "migrate": {
+        const [i, r] = k(a, 2);
+        if (i !== "neo4j") throw new $("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;
+      }
+      case "diff": {
+        const [i, r] = k(a, 2);
+        return await Ue(i, r, e, n);
+      }
+      default:
+        return n.err(W), 2;
+    }
+  } catch (i) {
+    return i instanceof $ ? (n.err(`${i.message}
+
+${W}`), 2) : i instanceof pe ? (n.err(i.message), 1) : (n.err(i instanceof Error ? i.message : String(i)), 1);
+  }
+}
+class $ extends Error {
+}
+const Le = /* @__PURE__ */ new Set([
+  "--out",
+  "--variables",
+  "--baseline",
+  "--row-budget",
+  "--database",
+  "--name",
+  "--sample"
+]);
+function k(t, n) {
+  if (t.length < n)
+    throw new $(`expected ${n} file argument(s)`);
+  return t;
+}
+const E = (t) => se(t, "utf8");
+function ee(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 qe([t], n, o) {
+  const s = me(await E(t));
+  for (const e of he(s))
+    o.out(
+      n ? `${ge(e)};` : `${V(e)}, because ${e.reason}`
+    );
+  return 0;
+}
+async function te(t, n) {
+  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`
+    );
+    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(
+    i ? s.get("--name") ?? "app" : void 0,
+    i ? { databaseDir: i } : {}
+  ), l = new M({
+    typeDefs: a,
+    driver: Q(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 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;
+    try {
+      d = JSON.parse(await E(T));
+    } catch {
+      d = void 0;
+    }
+    if (o.has("--update-baseline") || !d)
+      await _(T, JSON.stringify(b, null, 2) + `
+`);
+    else
+      for (const S of /* @__PURE__ */ new Set([
+        ...Object.keys(d),
+        ...Object.keys(b)
+      ]))
+        JSON.stringify(d[S]) !== JSON.stringify(b[S]) && w.push(S);
+  }
+  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)
+    e.out(
+      `unused   ${d.type} index ${d.name} on :${d.labels.join(":")}(${d.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)
+    e.out(
+      `error    ${d}: the plan differs from the baseline (--update-baseline to accept)`
+    );
+  const C = g.plans.length;
+  return e.out(
+    N ? `ok       ${C} root field(s) in ${h.length} operation(s) seek as expected` : "failed"
+  ), N ? 0 : 1;
+}
+async function _e(t) {
+  const n = {};
+  for (const o of t) {
+    if ((await B(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(
+          (i) => i.kind === p.FRAGMENT_DEFINITION
+        ).map((i) => [i.name.value, i])
+      ), u = oe(process.cwd(), e.path);
+      c.definitions.filter(
+        (i) => i.kind === p.OPERATION_DEFINITION
+      ).forEach((i, r) => {
+        const l = `${u}#${i.name?.value ?? r + 1}`;
+        n[l] = z({
+          kind: p.DOCUMENT,
+          definitions: [i, ...ve(i, a)]
+        });
+      });
+    }
+  }
+  return n;
+}
+async function je([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)
+  ), a = o.get("--out") ?? "lora-graphql";
+  return await ae(a, { recursive: !0 }), await _(
+    D(a, "manifest.json"),
+    JSON.stringify(c) + `
+`
+  ), await _(
+    D(a, "operations.d.ts"),
+    e.generateTypes(c)
+  ), s.out(
+    `wrote ${Object.keys(c.operations).length} operation(s) to ${D(a, "manifest.json")} and ${D(a, "operations.d.ts")}`
+  ), 0;
+}
+async function Me([t], n, o) {
+  const s = n.get("--database");
+  if (!s) throw new $("analyze needs --database <dir>");
+  const e = await te(o, "analyze");
+  if (!e) return 1;
+  const c = 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;
+}
+async function q(t) {
+  if ((await B(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) });
+  }
+  return o;
+}
+function Re(t, n, o) {
+  const s = A(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, {
+      FragmentSpread(l) {
+        const f = e.get(l.name.value);
+        f && !u.has(f.name.value) && (u.set(f.name.value, f), i(f));
+      }
+    });
+    return i(a), [...u.values()];
+  };
+  return s.definitions.filter(
+    (a) => a.kind === p.OPERATION_DEFINITION && a.operation === "query"
+  ).map((a, u) => {
+    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);
+      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)] },
+      variables: i
+    };
+  });
+}
+const Pe = {
+  String: "x",
+  ID: "x",
+  Int: 1,
+  Float: 1,
+  Boolean: !0,
+  BigInt: "1",
+  Date: "2026-01-01",
+  Time: "12:00:00Z",
+  LocalTime: "12:00:00",
+  DateTime: "2026-01-01T12:00:00Z",
+  LocalDateTime: "2026-01-01T12:00:00",
+  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 s = {};
+    for (const e of Object.values(o.getFields()))
+      U(e.type) && e.defaultValue === void 0 && (s[e.name] = j(e.type));
+    return s;
+  }
+  return Pe[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;
+  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};`);
+  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}`);
+  return a;
+}
+const Fe = {
+  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));
+export {
+  $e as main
+};
+//# sourceMappingURL=cli.js.map