midql-cli 0.1.0

package/dist/App-W6AAY42M.js

@@ -0,0 +1,568 @@
+#!/usr/bin/env node
+import {
+  buildQuery,
+  dialectFor
+} from "./chunk-TLTYYFT5.js";
+import {
+  buildFkGraph,
+  dropFillers,
+  extractClauses,
+  findTable,
+  hasSqlShape,
+  startsWithSqlKeyword,
+  tokenize,
+  translate
+} from "./chunk-WN6T44OZ.js";
+import "./chunk-3CIK5I4M.js";
+import "./chunk-7WNCISNV.js";
+import "./chunk-3QAR6XBK.js";
+import "./chunk-PXDMSYWH.js";
+import {
+  AmbiguityError,
+  MidqlError,
+  ParseError
+} from "./chunk-VFC3HWTF.js";
+
+// src/repl/App.tsx
+import { Box, Static, Text as Text2, useApp } from "ink";
+import { useCallback, useEffect, useMemo, useRef, useState as useState2 } from "react";
+
+// src/repl/LineEditor.tsx
+import { Text, useInput } from "ink";
+import { useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+function LineEditor({
+  promptText,
+  promptColor,
+  disabled,
+  history,
+  onSubmit,
+  onExitRequest,
+  onChange,
+  onTab,
+  onCtrlR,
+  onEscape
+}) {
+  const [buffer, setBuffer] = useState("");
+  const [cursor, setCursor] = useState(0);
+  const [historyIndex, setHistoryIndex] = useState(null);
+  const [draft, setDraft] = useState("");
+  const update = (nextBuffer, nextCursor) => {
+    setBuffer(nextBuffer);
+    setCursor(Math.max(0, Math.min(nextCursor, nextBuffer.length)));
+    onChange?.(nextBuffer);
+  };
+  useInput(
+    (input, key) => {
+      if (key.return) {
+        const value = buffer;
+        update("", 0);
+        setHistoryIndex(null);
+        setDraft("");
+        onSubmit(value);
+        return;
+      }
+      if (key.ctrl && input === "c") {
+        if (buffer.length === 0) {
+          onExitRequest();
+        } else {
+          update("", 0);
+          setHistoryIndex(null);
+        }
+        return;
+      }
+      if (key.ctrl && input === "d") {
+        onExitRequest();
+        return;
+      }
+      if (key.ctrl && input === "u") {
+        update("", 0);
+        return;
+      }
+      if (key.ctrl && input === "r") {
+        onCtrlR?.();
+        return;
+      }
+      if (key.ctrl && input === "a") {
+        setCursor(0);
+        return;
+      }
+      if (key.ctrl && input === "e") {
+        setCursor(buffer.length);
+        return;
+      }
+      if (key.backspace || key.delete) {
+        if (cursor > 0) {
+          update(buffer.slice(0, cursor - 1) + buffer.slice(cursor), cursor - 1);
+        }
+        return;
+      }
+      if (key.leftArrow) {
+        setCursor(Math.max(0, cursor - 1));
+        return;
+      }
+      if (key.rightArrow) {
+        setCursor(Math.min(buffer.length, cursor + 1));
+        return;
+      }
+      if (key.upArrow) {
+        if (history.length === 0) {
+          return;
+        }
+        const nextIndex = historyIndex === null ? history.length - 1 : Math.max(0, historyIndex - 1);
+        if (historyIndex === null) {
+          setDraft(buffer);
+        }
+        setHistoryIndex(nextIndex);
+        const entry = history[nextIndex] ?? "";
+        update(entry, entry.length);
+        return;
+      }
+      if (key.downArrow) {
+        if (historyIndex === null) {
+          return;
+        }
+        if (historyIndex >= history.length - 1) {
+          setHistoryIndex(null);
+          update(draft, draft.length);
+          return;
+        }
+        const nextIndex = historyIndex + 1;
+        setHistoryIndex(nextIndex);
+        const entry = history[nextIndex] ?? "";
+        update(entry, entry.length);
+        return;
+      }
+      if (key.tab) {
+        if (onTab) {
+          const completed = onTab(buffer);
+          if (completed !== null) {
+            update(completed, completed.length);
+          }
+        }
+        return;
+      }
+      if (key.escape) {
+        onEscape?.();
+        return;
+      }
+      if (input && !key.ctrl && !key.meta) {
+        const clean = input.replace(/[\r\n]+/g, " ");
+        update(buffer.slice(0, cursor) + clean + buffer.slice(cursor), cursor + clean.length);
+      }
+    },
+    { isActive: !disabled }
+  );
+  const before = buffer.slice(0, cursor);
+  const at = buffer[cursor] ?? " ";
+  const after = buffer.slice(cursor + 1);
+  return /* @__PURE__ */ jsxs(Text, { children: [
+    /* @__PURE__ */ jsx(Text, { color: promptColor, bold: true, children: promptText }),
+    /* @__PURE__ */ jsx(Text, { children: before }),
+    /* @__PURE__ */ jsx(Text, { inverse: true, children: at }),
+    /* @__PURE__ */ jsx(Text, { children: after })
+  ] });
+}
+
+// src/repl/completion.ts
+var intentVerbs = [
+  { text: "show", detail: "select rows" },
+  { text: "find", detail: "select with a filter" },
+  { text: "count", detail: "count rows" },
+  { text: "average", detail: "aggregate a column" },
+  { text: "sum", detail: "aggregate a column" },
+  { text: "add", detail: "insert a row" },
+  { text: "update", detail: "modify rows" },
+  { text: "delete", detail: "remove rows" },
+  { text: "describe", detail: "table structure" },
+  { text: "create table", detail: "new table" },
+  { text: "drop table", detail: "remove a table" },
+  { text: "show tables", detail: "list tables" }
+];
+var connectorSuggestions = [
+  { text: "which has", detail: "add a filter" },
+  { text: "where", detail: "add a filter" },
+  { text: "sorted by", detail: "order results" },
+  { text: "first 10", detail: "limit results" }
+];
+var operatorsByKind = {
+  number: [
+    { text: ">", detail: "greater than" },
+    { text: "<", detail: "less than" },
+    { text: "between", detail: "range" },
+    { text: "is", detail: "equals" }
+  ],
+  text: [
+    { text: "is", detail: "equals" },
+    { text: "contains", detail: "substring match" },
+    { text: "starts with", detail: "prefix match" },
+    { text: "is null", detail: "missing value" }
+  ],
+  boolean: [
+    { text: "is true", detail: "" },
+    { text: "is false", detail: "" }
+  ],
+  date: [
+    { text: ">", detail: "after" },
+    { text: "<", detail: "before" },
+    { text: "between", detail: "range" }
+  ]
+};
+var sqlKeywords = [
+  "SELECT",
+  "FROM",
+  "WHERE",
+  "JOIN",
+  "LEFT JOIN",
+  "GROUP BY",
+  "ORDER BY",
+  "LIMIT",
+  "INSERT INTO",
+  "VALUES",
+  "UPDATE",
+  "SET",
+  "DELETE FROM",
+  "AND",
+  "OR",
+  "BEGIN",
+  "COMMIT",
+  "ROLLBACK"
+];
+function prefixFilter(suggestions, prefix) {
+  if (!prefix) {
+    return suggestions;
+  }
+  const lower = prefix.toLowerCase();
+  return suggestions.filter((suggestion) => suggestion.text.toLowerCase().startsWith(lower));
+}
+function tableSuggestions(schema) {
+  return [...schema.tables].sort((a, b) => b.approxRowCount - a.approxRowCount).map((table) => ({ text: table.name, detail: `~${table.approxRowCount} rows` }));
+}
+function columnSuggestions(base, schema) {
+  const own = base.columns.map((column) => ({
+    text: column.name,
+    detail: column.dataType
+  }));
+  const graph = buildFkGraph(schema);
+  const reachable = new Set((graph.get(base.name) ?? []).map((edge) => edge.to));
+  const foreign = [];
+  for (const table of schema.tables) {
+    if (table.name === base.name || !reachable.has(table.name)) {
+      continue;
+    }
+    for (const column of table.columns) {
+      if (column.isPrimaryKey || column.name.endsWith("_id")) {
+        continue;
+      }
+      foreign.push({ text: column.name, detail: `${table.name}, joined` });
+    }
+  }
+  return [...own, ...foreign];
+}
+function splitBuffer(buffer) {
+  const match = /^(.*?)([\w.]*)$/s.exec(buffer);
+  return { head: match?.[1] ?? buffer, partial: match?.[2] ?? "" };
+}
+function complete(buffer, schema, sqlLock) {
+  const { head, partial } = splitBuffer(buffer);
+  const apply = (suggestion) => `${head}${suggestion.text} `;
+  if (buffer.startsWith("\\") || !schema) {
+    return { suggestions: [], apply };
+  }
+  const rawSql = sqlLock || startsWithSqlKeyword(buffer) && hasSqlShape(buffer);
+  const suggestions = rawSql ? completeSql(buffer, partial, schema) : completeNl(buffer, partial, schema);
+  return { suggestions: suggestions.slice(0, 6), apply };
+}
+function completeNl(buffer, partial, schema) {
+  const tokens = dropFillers(tokenize(buffer));
+  const complete2 = partial.length === 0;
+  const settled = complete2 ? tokens : tokens.slice(0, -1);
+  if (settled.length === 0) {
+    return prefixFilter(intentVerbs, partial);
+  }
+  const clauses = extractClauses(settled.slice(1));
+  const subjectWords = clauses.subject.filter((token) => token.type === "word");
+  const lastSubject = subjectWords[subjectWords.length - 1];
+  const baseTable = lastSubject ? findTable(lastSubject.value, schema) : null;
+  if (!baseTable) {
+    return prefixFilter(tableSuggestions(schema), partial);
+  }
+  const inConditions = clauses.conditionTokens.length > 0 || /\b(which|where|whose|that|has|have|with|having)\s*$/i.test(
+    buffer.slice(0, buffer.length - partial.length)
+  );
+  const inSort = /\b(sorted|ordered|sort|order)\s+by\s*[\w.]*$/i.test(buffer);
+  if (inSort) {
+    return prefixFilter(columnSuggestions(baseTable, schema), partial);
+  }
+  if (inConditions) {
+    const conditionWords = clauses.conditionTokens.filter((token) => token.type === "word");
+    const last = conditionWords[conditionWords.length - 1];
+    const lastIsColumn = last !== void 0 && (baseTable.columns.some((column) => column.name === last.value) || schema.tables.some((table) => table.columns.some((column) => column.name === last.value)));
+    if (lastIsColumn) {
+      const column = baseTable.columns.find((entry) => entry.name === last.value) ?? schema.tables.flatMap((table) => table.columns).find((entry) => entry.name === last.value);
+      const kind = column?.kind ?? "text";
+      return prefixFilter(operatorsByKind[kind] ?? operatorsByKind.text, partial);
+    }
+    return prefixFilter(columnSuggestions(baseTable, schema), partial);
+  }
+  return prefixFilter(connectorSuggestions, partial);
+}
+function completeSql(buffer, partial, schema) {
+  const before = buffer.slice(0, buffer.length - partial.length);
+  const context = /\b(from|join|into|update|table)\s+$/i.test(before) ? "table" : /\b(select|where|set|by|and|or|on)\s+$/i.test(before) ? "column" : "keyword";
+  if (context === "table") {
+    return prefixFilter(tableSuggestions(schema), partial);
+  }
+  if (context === "column") {
+    const columns = schema.tables.flatMap(
+      (table) => table.columns.map((column) => ({ text: column.name, detail: table.name }))
+    );
+    return prefixFilter(columns, partial);
+  }
+  const keywords = sqlKeywords.map((keyword) => ({ text: keyword, detail: "" }));
+  return prefixFilter([...keywords, ...tableSuggestions(schema)], partial);
+}
+
+// src/repl/livePreview.ts
+function livePreview(buffer, schema, dialect, sqlLock, maxJoinDepth) {
+  const input = buffer.trim();
+  if (!input || input.startsWith("\\") || !schema) {
+    return { kind: "none" };
+  }
+  if (sqlLock || startsWithSqlKeyword(input) && hasSqlShape(input)) {
+    return { kind: "raw" };
+  }
+  try {
+    const ast = translate(input, schema, { maxJoinDepth });
+    if (ast.kind === "showTables") {
+      return { kind: "hint", message: "lists all tables" };
+    }
+    if (ast.kind === "describe") {
+      return { kind: "hint", message: `shows the structure of ${ast.table}` };
+    }
+    const built = buildQuery(ast, dialectFor(dialect));
+    const params = built.params.length > 0 ? built.params.map((value, index) => `$${index + 1}=${JSON.stringify(value)}`).join("  ") : "";
+    return { kind: "sql", sql: built.sql, params };
+  } catch (error) {
+    if (error instanceof AmbiguityError) {
+      return {
+        kind: "ambiguity",
+        token: error.token,
+        options: error.candidates.map((candidate) => candidate.value)
+      };
+    }
+    if (error instanceof ParseError) {
+      const suggestion = error.suggestions[0] ? ` \u2014 try: ${error.suggestions.join(", ")}` : "";
+      return { kind: "hint", message: `${error.message}${suggestion}` };
+    }
+    if (error instanceof MidqlError) {
+      return { kind: "hint", message: error.message };
+    }
+    return { kind: "none" };
+  }
+}
+
+// src/repl/App.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var blockColors = {
+  info: "cyan",
+  warn: "yellow",
+  error: "red",
+  success: "green",
+  sql: "gray",
+  plain: void 0,
+  table: void 0,
+  echo: "gray"
+};
+function dialectColor(dialect, env) {
+  if (env === "prod") {
+    return "red";
+  }
+  if (dialect === "mysql") {
+    return "yellow";
+  }
+  if (dialect === "postgres") {
+    return "blue";
+  }
+  return "gray";
+}
+function App({ controller, version, initialTarget }) {
+  const { exit } = useApp();
+  const [items, setItems] = useState2([]);
+  const [busy, setBusy] = useState2(false);
+  const [buffer, setBuffer] = useState2("");
+  const [searchMode, setSearchMode] = useState2(false);
+  const [, setTick] = useState2(0);
+  const nextId = useRef(0);
+  const append = useCallback((blocks) => {
+    setItems((current) => [
+      ...current,
+      ...blocks.map((entry) => ({
+        id: nextId.current++,
+        kind: entry.kind,
+        text: entry.text
+      }))
+    ]);
+  }, []);
+  const runInput = useCallback(
+    async (value, echoPrefix) => {
+      setBuffer("");
+      setSearchMode(false);
+      if (value.trim().length > 0) {
+        append([{ id: 0, kind: "echo", text: `${echoPrefix}${value}` }]);
+      }
+      setBusy(true);
+      const result = await controller.handleInput(value);
+      append(result.blocks);
+      setBusy(false);
+      setTick((tick) => tick + 1);
+      if (result.exit) {
+        exit();
+      }
+    },
+    [append, controller, exit]
+  );
+  useEffect(() => {
+    append([
+      {
+        id: 0,
+        kind: "plain",
+        text: `midql v${version} \u2014 plain English or raw SQL \xB7 \\help for commands \xB7 \\q to quit`
+      }
+    ]);
+    if (initialTarget) {
+      void runInput(`\\c ${initialTarget}`, "");
+    }
+  }, [append, initialTarget, runInput, version]);
+  const info = controller.promptInfo();
+  const pending = controller.pendingConfirmation();
+  const connection = controller.manager.active();
+  const schema = connection?.schema ?? null;
+  const suggestions = useMemo(() => {
+    if (pending || busy) {
+      return [];
+    }
+    if (searchMode) {
+      const needle = buffer.toLowerCase();
+      return controller.inputHistory.filter((entry, index, all) => all.lastIndexOf(entry) === index).filter((entry) => entry.toLowerCase().includes(needle)).slice(-6).reverse().map((entry) => ({ text: entry, detail: "history" }));
+    }
+    if (!buffer.trim()) {
+      return [];
+    }
+    return complete(buffer, schema, controller.sqlLock).suggestions;
+  }, [buffer, busy, controller, pending, schema, searchMode]);
+  const preview = useMemo(() => {
+    if (pending || busy || searchMode || !connection) {
+      return { kind: "none" };
+    }
+    return livePreview(
+      buffer,
+      schema,
+      connection.dialect,
+      controller.sqlLock,
+      controller.config.maxJoinDepth
+    );
+  }, [buffer, busy, connection, controller, pending, schema, searchMode]);
+  const handleTab = useCallback(
+    (current) => {
+      if (searchMode) {
+        const match = suggestions[0];
+        if (match) {
+          setSearchMode(false);
+          return match.text;
+        }
+        return null;
+      }
+      const result = complete(current, schema, controller.sqlLock);
+      const top = result.suggestions[0];
+      if (!top) {
+        return null;
+      }
+      return result.apply(top);
+    },
+    [controller, schema, searchMode, suggestions]
+  );
+  const handleExitRequest = useCallback(() => {
+    void controller.shutdown().then((blocks) => {
+      append(blocks);
+      exit();
+    });
+  }, [append, controller, exit]);
+  let promptText;
+  let promptColor;
+  if (pending) {
+    promptText = `${pending.prompt}> `;
+    promptColor = "red";
+  } else if (searchMode) {
+    promptText = "(history search)> ";
+    promptColor = "magenta";
+  } else if (!info) {
+    promptText = "midql (not connected)> ";
+    promptColor = "gray";
+  } else {
+    const lock = info.sqlLock ? " sql" : "";
+    const tx = info.inTransaction ? " [tx]" : "";
+    const ro = info.readonly ? " [ro]" : "";
+    const bang = info.env === "prod" ? "!" : "";
+    promptText = `midql${lock} (${info.alias}:${info.database})${tx}${ro}${bang}> `;
+    promptColor = dialectColor(info.dialect, info.env);
+  }
+  const connections = controller.manager.list();
+  const statusParts = connections.map(
+    (entry) => entry.alias === info?.alias ? `[${entry.alias}:${entry.env}]` : `${entry.alias}:${entry.env}`
+  );
+  return /* @__PURE__ */ jsxs2(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx2(Static, { items, children: (item) => /* @__PURE__ */ jsx2(Box, { flexDirection: "column", children: /* @__PURE__ */ jsx2(Text2, { color: blockColors[item.kind], children: item.text }) }, item.id) }),
+    busy ? /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "\u2026 running" }) : /* @__PURE__ */ jsx2(
+      LineEditor,
+      {
+        promptText,
+        promptColor,
+        disabled: busy,
+        history: controller.inputHistory,
+        onSubmit: (value) => void runInput(value, promptText),
+        onExitRequest: handleExitRequest,
+        onChange: setBuffer,
+        onTab: handleTab,
+        onCtrlR: () => setSearchMode((mode) => !mode),
+        onEscape: () => setSearchMode(false)
+      }
+    ),
+    preview.kind === "sql" && /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      "\u2192 ",
+      preview.sql,
+      preview.params ? `   ${preview.params}` : ""
+    ] }),
+    preview.kind === "hint" && /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      "\u2026 ",
+      preview.message
+    ] }),
+    preview.kind === "raw" && /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "\u2192 raw SQL, runs as written" }),
+    preview.kind === "ambiguity" && /* @__PURE__ */ jsxs2(Text2, { color: "yellow", children: [
+      '"',
+      preview.token,
+      '"? ',
+      preview.options.join("  \xB7  ")
+    ] }),
+    suggestions.length > 0 && /* @__PURE__ */ jsx2(Text2, { children: suggestions.map((suggestion, index) => /* @__PURE__ */ jsxs2(
+      Text2,
+      {
+        color: index === 0 ? "cyan" : void 0,
+        dimColor: index !== 0,
+        children: [
+          index > 0 ? "   " : "",
+          suggestion.text,
+          suggestion.detail ? ` (${suggestion.detail})` : ""
+        ]
+      },
+      suggestion.text
+    )) }),
+    /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      connections.length > 0 ? `${statusParts.join("  ")}   ` : "",
+      "Tab completes \xB7 Ctrl+R history \xB7 \\help"
+    ] })
+  ] });
+}
+export {
+  App
+};