midql-cli 0.1.0

package/dist/chunk-XJAN6OQ7.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+// src/export/csv.ts
+function escapeField(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  const text = value instanceof Date ? value.toISOString() : typeof value === "object" ? JSON.stringify(value) : String(value);
+  if (/[",\r\n]/.test(text)) {
+    return `"${text.replace(/"/g, '""')}"`;
+  }
+  return text;
+}
+function toCsv(result) {
+  const lines = [result.columns.map(escapeField).join(",")];
+  for (const row of result.rows) {
+    lines.push(result.columns.map((column) => escapeField(row[column])).join(","));
+  }
+  return `${lines.join("\r\n")}\r
+`;
+}
+
+export {
+  toCsv
+};

package/dist/cli.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { createRequire } from "module";
+import { Command } from "commander";
+import pc from "picocolors";
+var pkg = createRequire(import.meta.url)("../package.json");
+async function startRepl(target) {
+  const [{ render }, { createElement }, { App }, { ReplController }] = await Promise.all([
+    import("ink"),
+    import("react"),
+    import("./App-W6AAY42M.js"),
+    import("./controller-HDNDKU6K.js")
+  ]);
+  const controller = new ReplController();
+  const instance = render(
+    createElement(App, { controller, version: pkg.version, initialTarget: target }),
+    { exitOnCtrlC: false }
+  );
+  await instance.waitUntilExit();
+  await controller.manager.closeAll();
+}
+function fail(error) {
+  console.error(pc.red(error.message ?? String(error)));
+  process.exit(1);
+}
+var program = new Command();
+program.name("midql").description(
+  "Fast, safety-first PostgreSQL/MySQL CLI \u2014 schema-aware autocomplete, natural-language shortcuts, destructive-op previews"
+).version(pkg.version);
+program.argument("[connection]", "profile name or connection URL to connect on startup").action(async (connection) => {
+  try {
+    await startRepl(connection ?? null);
+  } catch (error) {
+    fail(error);
+  }
+});
+program.command("query <input>").description("run a single query (plain English or raw SQL) and exit").requiredOption("--db <target>", "profile name or connection URL").option("--yes", "allow destructive statements", false).option("--format <format>", "output format: table, json, csv", "table").action(async (input, options) => {
+  try {
+    const { runQueryCommand } = await import("./query-RCUXCOAF.js");
+    const format = ["table", "json", "csv"].includes(options.format) ? options.format : "table";
+    process.exit(await runQueryCommand(input, { db: options.db, yes: options.yes, format }));
+  } catch (error) {
+    fail(error);
+  }
+});
+program.command("backup [file]").description("back up a database via pg_dump / mysqldump").requiredOption("--db <target>", "profile name or connection URL").option("--sql", "write a plain SQL dump instead of the custom format", false).action(async (file, options) => {
+  try {
+    const { runBackupCommand } = await import("./maintenance-QHIUTVV3.js");
+    process.exit(await runBackupCommand(file, options));
+  } catch (error) {
+    fail(error);
+  }
+});
+program.command("restore <file>").description("restore a database from a backup file").requiredOption("--db <target>", "profile name or connection URL").option("--yes", "confirm overwriting the target database", false).action(async (file, options) => {
+  try {
+    const { runRestoreCommand } = await import("./maintenance-QHIUTVV3.js");
+    process.exit(await runRestoreCommand(file, options));
+  } catch (error) {
+    fail(error);
+  }
+});
+var profiles = program.command("profiles").description("manage saved connection profiles");
+profiles.command("list").description("list saved profiles").action(async () => {
+  try {
+    const { runProfilesList } = await import("./profiles-4QGMCJAO.js");
+    runProfilesList();
+  } catch (error) {
+    fail(error);
+  }
+});
+profiles.command("add <name>").description("save a connection profile").requiredOption("--dialect <dialect>", "postgres or mysql").requiredOption("--host <host>", "database host").requiredOption("--database <database>", "database name").requiredOption("--user <user>", "database user").option("--port <port>", "database port").option("--password <password>", "password to store encrypted").option("--password-env <name>", "environment variable to read the password from").option("--env <env>", "environment tag: dev, staging, prod", "dev").option("--readonly", "open this connection read-only by default", false).option("--ssl", "connect over SSL", false).action(async (name, options) => {
+  try {
+    const { runProfilesAdd } = await import("./profiles-4QGMCJAO.js");
+    process.exit(
+      runProfilesAdd(name, {
+        dialect: String(options.dialect),
+        host: String(options.host),
+        port: options.port ? String(options.port) : void 0,
+        database: String(options.database),
+        user: String(options.user),
+        password: options.password ? String(options.password) : void 0,
+        passwordEnv: options.passwordEnv ? String(options.passwordEnv) : void 0,
+        env: String(options.env),
+        readonly: options.readonly === true,
+        ssl: options.ssl === true
+      })
+    );
+  } catch (error) {
+    fail(error);
+  }
+});
+profiles.command("remove <name>").description("delete a saved profile").action(async (name) => {
+  try {
+    const { runProfilesRemove } = await import("./profiles-4QGMCJAO.js");
+    process.exit(runProfilesRemove(name));
+  } catch (error) {
+    fail(error);
+  }
+});
+program.parseAsync(process.argv);

package/dist/controller-HDNDKU6K.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+import {
+  ReplController,
+  block,
+  hasSqlShape,
+  startsWithSqlKeyword
+} from "./chunk-WN6T44OZ.js";
+import "./chunk-3CIK5I4M.js";
+import "./chunk-7WNCISNV.js";
+import "./chunk-3QAR6XBK.js";
+import "./chunk-PXDMSYWH.js";
+import "./chunk-VFC3HWTF.js";
+export {
+  ReplController,
+  block,
+  hasSqlShape,
+  startsWithSqlKeyword
+};

package/dist/csv-F2MFR3XB.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import {
+  toCsv
+} from "./chunk-XJAN6OQ7.js";
+export {
+  toCsv
+};

package/dist/dump-LQ7ULAAL.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import {
+  backupDatabase,
+  defaultBackupFile
+} from "./chunk-BAAEZXFH.js";
+import "./chunk-NCN3ZBOJ.js";
+import "./chunk-VFC3HWTF.js";
+export {
+  backupDatabase,
+  defaultBackupFile
+};

package/dist/execute-E45HSHNE.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+import {
+  countSelect,
+  previewSelect
+} from "./chunk-ATZPL4EX.js";
+import {
+  buildQuery,
+  dialectFor
+} from "./chunk-TLTYYFT5.js";
+import {
+  astIsWrite,
+  block,
+  classifyAst
+} from "./chunk-WN6T44OZ.js";
+import "./chunk-3CIK5I4M.js";
+import {
+  describeTable,
+  formatResultSet,
+  formatTableList
+} from "./chunk-7WNCISNV.js";
+import "./chunk-3QAR6XBK.js";
+import "./chunk-PXDMSYWH.js";
+import {
+  ParseError
+} from "./chunk-VFC3HWTF.js";
+
+// src/repl/execute.ts
+async function executeAst(controller, connection, input, ast) {
+  if (ast.kind === "showTables") {
+    return { blocks: [block("table", formatTableList(connection.schema))] };
+  }
+  if (ast.kind === "describe") {
+    const table = connection.schema.tables.find((entry) => entry.name === ast.table);
+    if (!table) {
+      throw new ParseError(`Table "${ast.table}" not found`);
+    }
+    return { blocks: [block("table", describeTable(table))] };
+  }
+  const dialect = dialectFor(connection.dialect);
+  const built = buildQuery(ast, dialect);
+  if (connection.readonly && astIsWrite(ast)) {
+    return {
+      blocks: [
+        block("sql", `\u2192 ${built.sql}`),
+        block("error", "Connection is read-only; write statements are blocked."),
+        block("info", "Use \\readonly off to allow writes on this connection.")
+      ]
+    };
+  }
+  const danger = classifyAst(ast);
+  if (danger === "safe" || !controller.safetyEnforced(connection)) {
+    return { blocks: await runBuilt(controller, connection, input, built) };
+  }
+  if (ast.kind === "dropTable") {
+    return confirmDropTable(controller, connection, input, ast.table, built);
+  }
+  return confirmDestructive(
+    controller,
+    connection,
+    input,
+    ast,
+    built,
+    danger
+  );
+}
+async function runBuilt(controller, connection, input, built) {
+  let result;
+  try {
+    result = await connection.adapter.sessionQuery(built.sql, built.params);
+  } catch (error) {
+    controller.record(connection.alias, input, built.sql, null, false);
+    throw error;
+  }
+  controller.lastResult = result;
+  controller.lastSql = built.sql;
+  controller.lastParams = built.params;
+  controller.record(connection.alias, input, built.sql, result.rowCount, true);
+  if (ddlAffectsSchema(built.sql)) {
+    await controller.manager.refreshSchema(connection.alias).catch(() => connection);
+  }
+  return [block("sql", `\u2192 ${built.sql}`), block("table", formatResultSet(result))];
+}
+function ddlAffectsSchema(sql) {
+  return /^\s*(create|drop|alter|truncate)\b/i.test(sql);
+}
+function confirmDropTable(controller, connection, input, table, built) {
+  const meta = connection.schema.tables.find((entry) => entry.name === table);
+  const rowNote = meta ? ` (~${meta.approxRowCount} rows)` : "";
+  const prodBanner = connection.env === "prod" ? " (PRODUCTION)" : "";
+  controller.setPending({
+    prompt: `type '${table}' to confirm`,
+    expectedText: table,
+    execute: () => runBuilt(controller, connection, input, built)
+  });
+  return {
+    blocks: [
+      block("sql", `\u2192 ${built.sql}`),
+      block("error", `\u26A0${prodBanner} This will permanently DROP the table "${table}"${rowNote}.`),
+      block("warn", `Type '${table}' to confirm:`)
+    ]
+  };
+}
+async function confirmDestructive(controller, connection, input, ast, built, danger) {
+  const dialect = dialectFor(connection.dialect);
+  const countQuery = buildQuery(countSelect(ast), dialect);
+  const sampleQuery = buildQuery(previewSelect(ast), dialect);
+  const [countResult, sampleResult] = await Promise.all([
+    connection.adapter.query(countQuery.sql, countQuery.params),
+    connection.adapter.query(sampleQuery.sql, sampleQuery.params)
+  ]);
+  const total = Number(Object.values(countResult.rows[0] ?? {})[0] ?? 0);
+  const verb = ast.kind === "delete" ? "DELETE" : "UPDATE";
+  const prodBanner = connection.env === "prod" ? " (PRODUCTION)" : "";
+  if (total === 0) {
+    return {
+      blocks: [
+        block("sql", `\u2192 ${built.sql}`),
+        block("info", `No rows match \u2014 nothing to ${verb.toLowerCase()}.`)
+      ]
+    };
+  }
+  const blocks = [
+    block("sql", `\u2192 ${built.sql}`),
+    block(
+      "warn",
+      `\u26A0${prodBanner} This will ${verb} ${total.toLocaleString("en-US")} row${total === 1 ? "" : "s"} from "${ast.table}"${danger === "catastrophic" ? " (no WHERE clause \u2014 affects every row)" : ""}.`
+    )
+  ];
+  if (sampleResult.rows.length > 0) {
+    const label = total > sampleResult.rows.length ? `Sample of affected rows (${sampleResult.rows.length} of ${total}):` : "Affected rows:";
+    blocks.push(block("info", label));
+    blocks.push(
+      block("table", formatResultSet({ ...sampleResult, rowCount: sampleResult.rows.length }))
+    );
+  }
+  if (danger === "catastrophic") {
+    blocks.push(block("warn", `Type '${ast.table}' to confirm:`));
+    controller.setPending({
+      prompt: `type '${ast.table}' to confirm`,
+      expectedText: ast.table,
+      execute: () => runBuilt(controller, connection, input, built)
+    });
+  } else {
+    blocks.push(block("warn", "Proceed? [y/N]"));
+    controller.setPending({
+      prompt: "y/N",
+      expectedText: null,
+      execute: () => runBuilt(controller, connection, input, built)
+    });
+  }
+  return { blocks };
+}
+export {
+  executeAst
+};

package/dist/humanize-UG6KBAFO.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+
+// src/explain/humanize.ts
+function describeNode(node, depth) {
+  const indent = "  ".repeat(depth);
+  const rows = node["Plan Rows"] !== void 0 ? ` (~${node["Plan Rows"]} rows)` : "";
+  const lines = [];
+  switch (node["Node Type"]) {
+    case "Seq Scan":
+      lines.push(
+        `${indent}- reads the whole "${node["Relation Name"]}" table row by row${rows}${node.Filter ? `, keeping rows where ${node.Filter}` : ""}`
+      );
+      break;
+    case "Index Scan":
+    case "Index Only Scan":
+      lines.push(
+        `${indent}- uses the index "${node["Index Name"]}" on "${node["Relation Name"]}"${rows}${node["Index Cond"] ? ` matching ${node["Index Cond"]}` : ""}`
+      );
+      break;
+    case "Bitmap Heap Scan":
+      lines.push(`${indent}- fetches matching pages from "${node["Relation Name"]}"${rows}`);
+      break;
+    case "Nested Loop":
+      lines.push(`${indent}- joins by looping over one side for each row of the other${rows}`);
+      break;
+    case "Hash Join":
+      lines.push(
+        `${indent}- joins using an in-memory hash table${node["Hash Cond"] ? ` on ${node["Hash Cond"]}` : ""}${rows}`
+      );
+      break;
+    case "Merge Join":
+      lines.push(`${indent}- joins two pre-sorted inputs${rows}`);
+      break;
+    case "Sort":
+      lines.push(`${indent}- sorts the intermediate result${rows}`);
+      break;
+    case "Aggregate":
+    case "HashAggregate":
+    case "GroupAggregate":
+      lines.push(`${indent}- computes the aggregate${rows}`);
+      break;
+    case "Limit":
+      lines.push(`${indent}- stops early after the LIMIT is reached`);
+      break;
+    default:
+      lines.push(`${indent}- ${node["Node Type"]}${rows}`);
+  }
+  for (const child of node.Plans ?? []) {
+    lines.push(...describeNode(child, depth + 1));
+  }
+  return lines;
+}
+function humanizePostgresPlan(planJson) {
+  const root = Array.isArray(planJson) ? planJson[0] : planJson;
+  if (!root?.Plan) {
+    return ["Could not parse the plan."];
+  }
+  const lines = describeNode(root.Plan, 0);
+  const seqScans = collectSeqScans(root.Plan);
+  if (seqScans.length > 0) {
+    lines.push(
+      `\u26A0 full table scan on ${seqScans.map((name) => `"${name}"`).join(", ")} \u2014 an index could speed this up if the table is large.`
+    );
+  }
+  return lines;
+}
+function collectSeqScans(node) {
+  const names = [];
+  if (node["Node Type"] === "Seq Scan" && node["Relation Name"]) {
+    names.push(node["Relation Name"]);
+  }
+  for (const child of node.Plans ?? []) {
+    names.push(...collectSeqScans(child));
+  }
+  return names;
+}
+function humanizeMysqlExplain(rows) {
+  const lines = [];
+  for (const raw of rows) {
+    if (!raw.table) {
+      continue;
+    }
+    if (raw.type === "ALL") {
+      lines.push(
+        `- reads the whole "${raw.table}" table (~${raw.rows ?? "?"} rows) \u2014 no index used; an index could speed this up.`
+      );
+    } else if (raw.key) {
+      lines.push(`- uses the index "${raw.key}" on "${raw.table}" (~${raw.rows ?? "?"} rows)`);
+    } else {
+      lines.push(
+        `- accesses "${raw.table}" via ${raw.type ?? "unknown"} (~${raw.rows ?? "?"} rows)`
+      );
+    }
+  }
+  return lines.length > 0 ? lines : ["Could not parse the plan."];
+}
+export {
+  humanizeMysqlExplain,
+  humanizePostgresPlan
+};

package/dist/index.d.ts

@@ -0,0 +1,185 @@
+type DialectName = "postgres" | "mysql";
+type ColumnKind = "text" | "number" | "boolean" | "date" | "json" | "uuid" | "other";
+interface Column {
+    name: string;
+    dataType: string;
+    kind: ColumnKind;
+    nullable: boolean;
+    isPrimaryKey: boolean;
+    hasDefault: boolean;
+}
+interface ForeignKey {
+    columns: string[];
+    referencedTable: string;
+    referencedColumns: string[];
+}
+interface Table {
+    name: string;
+    columns: Column[];
+    primaryKey: string[];
+    foreignKeys: ForeignKey[];
+    approxRowCount: number;
+}
+interface Schema {
+    tables: Table[];
+}
+interface ColumnRef {
+    table: string;
+    column: string;
+}
+type ScalarValue = string | number | boolean | null;
+type ComparisonOperator = "=" | "!=" | ">" | "<" | ">=" | "<=" | "like" | "ilike" | "in" | "between" | "isNull" | "isNotNull";
+interface Condition {
+    type: "condition";
+    column: ColumnRef;
+    operator: ComparisonOperator;
+    values: ScalarValue[];
+}
+interface ConditionGroup {
+    type: "group";
+    combinator: "and" | "or";
+    items: ConditionNode[];
+}
+type ConditionNode = Condition | ConditionGroup;
+interface Join {
+    table: string;
+    leftColumn: ColumnRef;
+    rightColumn: ColumnRef;
+}
+type AggregateFunction = "count" | "sum" | "avg" | "min" | "max";
+interface Aggregate {
+    fn: AggregateFunction;
+    column: ColumnRef | null;
+}
+interface OrderBy {
+    column: ColumnRef;
+    direction: "asc" | "desc";
+}
+interface SelectNode {
+    kind: "select";
+    table: string;
+    columns: ColumnRef[] | "*";
+    aggregate: Aggregate | null;
+    joins: Join[];
+    where: ConditionNode | null;
+    orderBy: OrderBy[];
+    limit: number | null;
+    offset: number | null;
+}
+interface InsertNode {
+    kind: "insert";
+    table: string;
+    values: Record<string, ScalarValue>;
+}
+interface UpdateNode {
+    kind: "update";
+    table: string;
+    set: Record<string, ScalarValue>;
+    joins: Join[];
+    where: ConditionNode | null;
+    keyColumn: string | null;
+}
+interface DeleteNode {
+    kind: "delete";
+    table: string;
+    joins: Join[];
+    where: ConditionNode | null;
+    keyColumn: string | null;
+}
+type NlColumnType = "text" | "number" | "decimal" | "boolean" | "date" | "timestamp" | "json" | "uuid" | "serial";
+interface ColumnDefinition {
+    name: string;
+    type: NlColumnType;
+    nullable: boolean;
+    references: {
+        table: string;
+        column: string;
+    } | null;
+}
+interface CreateTableNode {
+    kind: "createTable";
+    table: string;
+    columns: ColumnDefinition[];
+}
+interface DropTableNode {
+    kind: "dropTable";
+    table: string;
+}
+interface DescribeNode {
+    kind: "describe";
+    table: string;
+}
+interface ShowTablesNode {
+    kind: "showTables";
+}
+type QueryAst = SelectNode | InsertNode | UpdateNode | DeleteNode | CreateTableNode | DropTableNode;
+type MetaAst = DescribeNode | ShowTablesNode;
+type Ast = QueryAst | MetaAst;
+interface BuiltQuery {
+    sql: string;
+    params: ScalarValue[];
+}
+interface ResultSet {
+    columns: string[];
+    rows: Record<string, unknown>[];
+    rowCount: number;
+    durationMs: number;
+    command: string;
+}
+interface AmbiguityCandidate {
+    value: string;
+    label: string;
+    detail: string;
+}
+interface Ambiguity {
+    token: string;
+    candidates: AmbiguityCandidate[];
+}
+type DangerLevel = "safe" | "destructive" | "catastrophic";
+type EnvironmentTag = "dev" | "staging" | "prod";
+interface ConnectionProfile {
+    name: string;
+    dialect: DialectName;
+    host: string;
+    port: number;
+    database: string;
+    user: string;
+    encryptedPassword: string | null;
+    passwordEnv: string | null;
+    env: EnvironmentTag;
+    readonly: boolean;
+    ssl: boolean;
+}
+
+declare class MidqlError extends Error {
+    constructor(message: string);
+}
+declare class ParseError extends MidqlError {
+    readonly position: number | null;
+    readonly suggestions: string[];
+    constructor(message: string, options?: {
+        position?: number;
+        suggestions?: string[];
+    });
+}
+declare class AmbiguityError extends MidqlError {
+    readonly token: string;
+    readonly candidates: AmbiguityCandidate[];
+    constructor(token: string, candidates: AmbiguityCandidate[]);
+}
+declare class ConnectionError extends MidqlError {
+}
+declare class ExecutionError extends MidqlError {
+}
+declare class ReadonlyViolationError extends MidqlError {
+    constructor();
+}
+declare class ToolNotFoundError extends MidqlError {
+    readonly tool: string;
+    readonly hint: string;
+    constructor(tool: string, hint: string);
+}
+declare class ConfigError extends MidqlError {
+}
+
+export { type Aggregate, type AggregateFunction, type Ambiguity, type AmbiguityCandidate, AmbiguityError, type Ast, type BuiltQuery, type Column, type ColumnDefinition, type ColumnKind, type ColumnRef, type ComparisonOperator, type Condition, type ConditionGroup, type ConditionNode, ConfigError, ConnectionError, type ConnectionProfile, type CreateTableNode, type DangerLevel, type DeleteNode, type DescribeNode, type DialectName, type DropTableNode, type EnvironmentTag, ExecutionError, type ForeignKey, type InsertNode, type Join, type MetaAst, MidqlError, type NlColumnType, type OrderBy, ParseError, type QueryAst, ReadonlyViolationError, type ResultSet, type ScalarValue, type Schema, type SelectNode, type ShowTablesNode, type Table, ToolNotFoundError, type UpdateNode };

package/dist/index.js

@@ -0,0 +1,55 @@
+// src/core/errors.ts
+var MidqlError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+var ParseError = class extends MidqlError {
+  position;
+  suggestions;
+  constructor(message, options) {
+    super(message);
+    this.position = options?.position ?? null;
+    this.suggestions = options?.suggestions ?? [];
+  }
+};
+var AmbiguityError = class extends MidqlError {
+  token;
+  candidates;
+  constructor(token, candidates) {
+    super(`"${token}" is ambiguous`);
+    this.token = token;
+    this.candidates = candidates;
+  }
+};
+var ConnectionError = class extends MidqlError {
+};
+var ExecutionError = class extends MidqlError {
+};
+var ReadonlyViolationError = class extends MidqlError {
+  constructor() {
+    super("Connection is read-only; write statements are blocked");
+  }
+};
+var ToolNotFoundError = class extends MidqlError {
+  tool;
+  hint;
+  constructor(tool, hint) {
+    super(`${tool} not found. ${hint}`);
+    this.tool = tool;
+    this.hint = hint;
+  }
+};
+var ConfigError = class extends MidqlError {
+};
+export {
+  AmbiguityError,
+  ConfigError,
+  ConnectionError,
+  ExecutionError,
+  MidqlError,
+  ParseError,
+  ReadonlyViolationError,
+  ToolNotFoundError
+};

package/dist/json-Z56V7OEB.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import {
+  toJson
+} from "./chunk-GWY47EDH.js";
+export {
+  toJson
+};