midql-cli 0.1.0

package/dist/maintenance-QHIUTVV3.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+import {
+  backupDatabase,
+  defaultBackupFile
+} from "./chunk-BAAEZXFH.js";
+import {
+  restoreDatabase
+} from "./chunk-3FPZQHHV.js";
+import "./chunk-NCN3ZBOJ.js";
+import {
+  resolveTarget
+} from "./chunk-3CIK5I4M.js";
+import {
+  loadConfig
+} from "./chunk-3QAR6XBK.js";
+import "./chunk-PXDMSYWH.js";
+import "./chunk-VFC3HWTF.js";
+
+// src/commands/maintenance.ts
+import pc from "picocolors";
+async function runBackupCommand(file, options) {
+  const config = loadConfig();
+  const target = resolveTarget(options.db);
+  const format = options.sql || target.dialect === "mysql" ? "sql" : "custom";
+  const output = file ?? defaultBackupFile(target.options.database, target.dialect, format);
+  const result = await backupDatabase(target.dialect, target.options, output, format, config.tools);
+  const size = result.sizeBytes > 1024 * 1024 ? `${(result.sizeBytes / 1024 / 1024).toFixed(1)} MB` : `${Math.max(1, Math.round(result.sizeBytes / 1024))} KB`;
+  console.log(pc.green(`Backup written to ${result.file} (${size}).`));
+  return 0;
+}
+async function runRestoreCommand(file, options) {
+  const config = loadConfig();
+  const target = resolveTarget(options.db);
+  if (!options.yes) {
+    console.error(
+      pc.yellow(
+        `Restoring will overwrite objects in "${target.options.database}". Re-run with --yes to proceed.`
+      )
+    );
+    return 1;
+  }
+  await restoreDatabase(target.dialect, target.options, file, config.tools);
+  console.log(pc.green(`Restored ${target.options.database} from ${file}.`));
+  return 0;
+}
+export {
+  runBackupCommand,
+  runRestoreCommand
+};

package/dist/meta-NZ5Z6NYN.js

@@ -0,0 +1,369 @@
+#!/usr/bin/env node
+import {
+  block,
+  loadHistory,
+  searchHistory
+} from "./chunk-WN6T44OZ.js";
+import "./chunk-3CIK5I4M.js";
+import {
+  describeTable,
+  formatTableList,
+  plainTable
+} from "./chunk-7WNCISNV.js";
+import "./chunk-3QAR6XBK.js";
+import "./chunk-PXDMSYWH.js";
+import "./chunk-VFC3HWTF.js";
+
+// src/repl/meta.ts
+var commands = {
+  help: {
+    usage: "\\help",
+    description: "Show available commands",
+    run() {
+      const rows = Object.entries(commands).map(([, command]) => [
+        command.usage,
+        command.description
+      ]);
+      return { blocks: [block("table", plainTable(["command", "description"], rows))] };
+    }
+  },
+  c: {
+    usage: "\\c <profile|url> [alias]",
+    description: "Connect to a database (saved profile name or postgres://... / mysql://... URL)",
+    async run(controller, args) {
+      const target = args[0];
+      if (!target) {
+        return { blocks: [block("error", "Usage: \\c <profile|url> [alias]")] };
+      }
+      const connection = await controller.manager.connect(target, args[1]);
+      const envNote = connection.env === "prod" ? " [PRODUCTION]" : "";
+      return {
+        blocks: [
+          block(
+            "success",
+            `Connected to ${connection.dialect}://${connection.database} as "${connection.alias}"${envNote} \xB7 ${connection.schema.tables.length} tables`
+          )
+        ]
+      };
+    }
+  },
+  use: {
+    usage: "\\use <alias>",
+    description: "Switch the active connection",
+    run(controller, args) {
+      const alias = args[0];
+      if (!alias) {
+        return { blocks: [block("error", "Usage: \\use <alias>")] };
+      }
+      const connection = controller.manager.use(alias);
+      return {
+        blocks: [block("success", `Switched to "${connection.alias}" (${connection.database})`)]
+      };
+    }
+  },
+  connections: {
+    usage: "\\connections",
+    description: "List open connections",
+    run(controller) {
+      const list = controller.manager.list();
+      if (list.length === 0) {
+        return { blocks: [block("info", "No open connections.")] };
+      }
+      const activeAlias = controller.manager.active()?.alias;
+      const rows = list.map((connection) => [
+        connection.alias === activeAlias ? `* ${connection.alias}` : `  ${connection.alias}`,
+        connection.dialect,
+        connection.database,
+        connection.env,
+        connection.readonly ? "read-only" : "read-write",
+        connection.adapter.inTransaction() ? "open tx" : ""
+      ]);
+      return {
+        blocks: [
+          block("table", plainTable(["alias", "dialect", "database", "env", "mode", "tx"], rows))
+        ]
+      };
+    }
+  },
+  disconnect: {
+    usage: "\\disconnect <alias>",
+    description: "Close a connection",
+    async run(controller, args) {
+      const alias = args[0];
+      if (!alias) {
+        return { blocks: [block("error", "Usage: \\disconnect <alias>")] };
+      }
+      await controller.manager.disconnect(alias);
+      return { blocks: [block("success", `Disconnected "${alias}"`)] };
+    }
+  },
+  tables: {
+    usage: "\\tables",
+    description: "List tables in the active database",
+    run(controller) {
+      const connection = controller.manager.active();
+      if (!connection) {
+        return { blocks: [block("error", "Not connected.")] };
+      }
+      if (connection.schema.tables.length === 0) {
+        return { blocks: [block("info", "No tables found in the public schema.")] };
+      }
+      return { blocks: [block("table", formatTableList(connection.schema))] };
+    }
+  },
+  d: {
+    usage: "\\d <table>",
+    description: "Describe a table",
+    run(controller, args) {
+      const connection = controller.manager.active();
+      if (!connection) {
+        return { blocks: [block("error", "Not connected.")] };
+      }
+      const name = args[0];
+      if (!name) {
+        return { blocks: [block("error", "Usage: \\d <table>")] };
+      }
+      const table = connection.schema.tables.find((entry) => entry.name === name);
+      if (!table) {
+        return { blocks: [block("error", `Table "${name}" not found.`)] };
+      }
+      return { blocks: [block("table", describeTable(table))] };
+    }
+  },
+  refresh: {
+    usage: "\\refresh",
+    description: "Reload the schema cache for the active connection",
+    async run(controller) {
+      const connection = await controller.manager.refreshSchema();
+      return {
+        blocks: [block("success", `Schema refreshed \xB7 ${connection.schema.tables.length} tables`)]
+      };
+    }
+  },
+  sql: {
+    usage: "\\sql",
+    description: "Toggle raw SQL mode (skip natural language parsing)",
+    run(controller) {
+      controller.sqlLock = !controller.sqlLock;
+      return {
+        blocks: [
+          block(
+            "info",
+            controller.sqlLock ? "Raw SQL mode ON \u2014 input runs directly against the database." : "Raw SQL mode OFF \u2014 natural language parsing enabled."
+          )
+        ]
+      };
+    }
+  },
+  safe: {
+    usage: "\\safe on|off",
+    description: "Toggle destructive-operation previews and confirmations",
+    run(controller, args) {
+      const mode = args[0]?.toLowerCase();
+      if (mode !== "on" && mode !== "off") {
+        return { blocks: [block("error", "Usage: \\safe on|off")] };
+      }
+      controller.safety = mode;
+      const blocks = [block("info", `Safety checks ${mode.toUpperCase()}.`)];
+      if (mode === "off" && controller.manager.active()?.env === "prod") {
+        blocks.push(
+          block("warn", "Active connection is tagged prod \u2014 safety stays enforced there.")
+        );
+      }
+      return { blocks };
+    }
+  },
+  readonly: {
+    usage: "\\readonly on|off",
+    description: "Toggle read-only mode for the active connection",
+    run(controller, args) {
+      const mode = args[0]?.toLowerCase();
+      if (mode !== "on" && mode !== "off") {
+        return { blocks: [block("error", "Usage: \\readonly on|off")] };
+      }
+      const connection = controller.manager.setReadonly(mode === "on");
+      return {
+        blocks: [
+          block(
+            "info",
+            `"${connection.alias}" is now ${connection.readonly ? "read-only" : "read-write"}.`
+          )
+        ]
+      };
+    }
+  },
+  history: {
+    usage: "\\history [search]",
+    description: "Show recent inputs, optionally filtered",
+    run(_controller, args) {
+      const entries = loadHistory();
+      const filtered = args.length > 0 ? searchHistory(entries, args.join(" ")) : entries;
+      const recent = filtered.slice(-20);
+      if (recent.length === 0) {
+        return { blocks: [block("info", "No history yet.")] };
+      }
+      const rows = recent.map((entry) => [
+        entry.ts.replace("T", " ").slice(0, 19),
+        entry.connection,
+        entry.input.length > 60 ? `${entry.input.slice(0, 59)}\u2026` : entry.input,
+        entry.ok ? "ok" : "error"
+      ]);
+      return {
+        blocks: [block("table", plainTable(["time", "connection", "input", "status"], rows))]
+      };
+    }
+  },
+  export: {
+    usage: "\\export csv|json <file>",
+    description: "Export the last result set to a file",
+    async run(controller, args) {
+      const format = args[0]?.toLowerCase();
+      const file = args[1];
+      if (format !== "csv" && format !== "json" || !file) {
+        return { blocks: [block("error", "Usage: \\export csv|json <file>")] };
+      }
+      if (!controller.lastResult || controller.lastResult.columns.length === 0) {
+        return { blocks: [block("error", "No result set to export yet \u2014 run a query first.")] };
+      }
+      const { writeFileSync } = await import("fs");
+      const { toCsv } = await import("./csv-F2MFR3XB.js");
+      const { toJson } = await import("./json-Z56V7OEB.js");
+      const content = format === "csv" ? toCsv(controller.lastResult) : toJson(controller.lastResult);
+      writeFileSync(file, content, "utf8");
+      return {
+        blocks: [
+          block(
+            "success",
+            `Exported ${controller.lastResult.rows.length} rows to ${file} (${format}).`
+          )
+        ]
+      };
+    }
+  },
+  backup: {
+    usage: "\\backup [file] [sql]",
+    description: "Back up the active database via pg_dump / mysqldump",
+    async run(controller, args) {
+      const connection = controller.manager.active();
+      if (!connection) {
+        return { blocks: [block("error", "Not connected.")] };
+      }
+      const { backupDatabase, defaultBackupFile } = await import("./dump-LQ7ULAAL.js");
+      const format = args.includes("sql") || connection.dialect === "mysql" ? "sql" : "custom";
+      const file = args.find((arg) => arg !== "sql") ?? defaultBackupFile(connection.database, connection.dialect, format);
+      const result = await backupDatabase(
+        connection.dialect,
+        connection.options,
+        file,
+        format,
+        controller.config.tools
+      );
+      const size = result.sizeBytes > 1024 * 1024 ? `${(result.sizeBytes / 1024 / 1024).toFixed(1)} MB` : `${Math.max(1, Math.round(result.sizeBytes / 1024))} KB`;
+      return {
+        blocks: [block("success", `Backup written to ${result.file} (${size}).`)]
+      };
+    }
+  },
+  restore: {
+    usage: "\\restore <file>",
+    description: "Restore the active database from a backup file",
+    async run(controller, args) {
+      const connection = controller.manager.active();
+      if (!connection) {
+        return { blocks: [block("error", "Not connected.")] };
+      }
+      const file = args[0];
+      if (!file) {
+        return { blocks: [block("error", "Usage: \\restore <file>")] };
+      }
+      const prodBanner = connection.env === "prod" ? " (PRODUCTION)" : "";
+      controller.setPending({
+        prompt: `type '${connection.database}' to confirm`,
+        expectedText: connection.database,
+        async execute() {
+          const { restoreDatabase } = await import("./restore-4QXG2WRR.js");
+          await restoreDatabase(
+            connection.dialect,
+            connection.options,
+            file,
+            controller.config.tools
+          );
+          await controller.manager.refreshSchema(connection.alias).catch(() => connection);
+          return [block("success", `Restored ${connection.database} from ${file}.`)];
+        }
+      });
+      return {
+        blocks: [
+          block(
+            "error",
+            `\u26A0${prodBanner} Restoring will overwrite objects in "${connection.database}".`
+          ),
+          block("warn", `Type '${connection.database}' to confirm:`)
+        ]
+      };
+    }
+  },
+  explain: {
+    usage: "\\explain",
+    description: "Re-run the last query with EXPLAIN and summarize the plan in plain English",
+    async run(controller) {
+      const connection = controller.manager.active();
+      if (!connection) {
+        return { blocks: [block("error", "Not connected.")] };
+      }
+      if (!controller.lastSql || !/^\s*select\b/i.test(controller.lastSql)) {
+        return { blocks: [block("error", "No SELECT to explain yet \u2014 run a query first.")] };
+      }
+      const { humanizePostgresPlan, humanizeMysqlExplain } = await import("./humanize-UG6KBAFO.js");
+      if (connection.dialect === "postgres") {
+        const result2 = await connection.adapter.query(
+          `EXPLAIN (FORMAT JSON) ${controller.lastSql}`,
+          controller.lastParams
+        );
+        const planCell = Object.values(result2.rows[0] ?? {})[0];
+        const plan = typeof planCell === "string" ? JSON.parse(planCell) : planCell;
+        return { blocks: [block("info", humanizePostgresPlan(plan).join("\n"))] };
+      }
+      const result = await connection.adapter.query(
+        `EXPLAIN ${controller.lastSql}`,
+        controller.lastParams
+      );
+      return { blocks: [block("info", humanizeMysqlExplain(result.rows).join("\n"))] };
+    }
+  },
+  q: {
+    usage: "\\q",
+    description: "Quit midql",
+    async run(controller) {
+      const blocks = await controller.shutdown();
+      return { blocks, exit: true };
+    }
+  }
+};
+var aliases = {
+  connect: "c",
+  quit: "q",
+  exit: "q",
+  describe: "d",
+  ls: "tables",
+  h: "help"
+};
+async function dispatchMeta(controller, input) {
+  const parts = input.slice(1).trim().split(/\s+/);
+  const name = (parts[0] ?? "").toLowerCase();
+  const args = parts.slice(1);
+  const command = commands[name] ?? commands[aliases[name] ?? ""];
+  if (!command) {
+    return {
+      blocks: [block("error", `Unknown command \\${name}. Type \\help for the list.`)]
+    };
+  }
+  return command.run(controller, args);
+}
+function registerMetaCommand(name, command) {
+  commands[name] = command;
+}
+export {
+  dispatchMeta,
+  registerMetaCommand
+};

package/dist/mysql-GQSXUUEK.js

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+import {
+  trackTransactionState
+} from "./chunk-PXDMSYWH.js";
+import {
+  ConnectionError,
+  ExecutionError
+} from "./chunk-VFC3HWTF.js";
+
+// src/adapters/introspect/mysql.ts
+var mysqlColumnsQuery = `
+SELECT TABLE_NAME AS table_name, COLUMN_NAME AS column_name, DATA_TYPE AS data_type,
+       IS_NULLABLE AS is_nullable, COLUMN_DEFAULT AS column_default, COLUMN_KEY AS column_key,
+       EXTRA AS extra
+FROM information_schema.COLUMNS
+WHERE TABLE_SCHEMA = DATABASE()
+ORDER BY TABLE_NAME, ORDINAL_POSITION`;
+var mysqlForeignKeysQuery = `
+SELECT CONSTRAINT_NAME AS constraint_name, TABLE_NAME AS table_name, COLUMN_NAME AS column_name,
+       REFERENCED_TABLE_NAME AS referenced_table, REFERENCED_COLUMN_NAME AS referenced_column
+FROM information_schema.KEY_COLUMN_USAGE
+WHERE TABLE_SCHEMA = DATABASE() AND REFERENCED_TABLE_NAME IS NOT NULL
+ORDER BY TABLE_NAME, CONSTRAINT_NAME, ORDINAL_POSITION`;
+var mysqlRowCountsQuery = `
+SELECT TABLE_NAME AS table_name, COALESCE(TABLE_ROWS, 0) AS approx_rows
+FROM information_schema.TABLES
+WHERE TABLE_SCHEMA = DATABASE() AND TABLE_TYPE = 'BASE TABLE'`;
+function classifyMysqlType(dataType) {
+  const type = dataType.toLowerCase();
+  if (type.includes("int") || type.includes("decimal") || type.includes("float") || type.includes("double") || type.includes("numeric")) {
+    return "number";
+  }
+  if (type === "bit" || type === "boolean" || type === "bool" || type === "tinyint") {
+    return "boolean";
+  }
+  if (type.includes("date") || type.includes("time") || type === "year") {
+    return "date";
+  }
+  if (type.includes("json")) {
+    return "json";
+  }
+  if (type.includes("char") || type.includes("text") || type.includes("enum")) {
+    return "text";
+  }
+  return "other";
+}
+function assembleMysqlSchema(columnRows, foreignKeyRows, rowCountRows) {
+  const foreignKeys = /* @__PURE__ */ new Map();
+  for (const row of foreignKeyRows) {
+    const tableFks = foreignKeys.get(row.table_name) ?? /* @__PURE__ */ new Map();
+    const fk = tableFks.get(row.constraint_name) ?? {
+      columns: [],
+      referencedTable: row.referenced_table,
+      referencedColumns: []
+    };
+    fk.columns.push(row.column_name);
+    fk.referencedColumns.push(row.referenced_column);
+    tableFks.set(row.constraint_name, fk);
+    foreignKeys.set(row.table_name, tableFks);
+  }
+  const rowCounts = /* @__PURE__ */ new Map();
+  for (const row of rowCountRows) {
+    rowCounts.set(row.table_name, Number(row.approx_rows));
+  }
+  const tables = /* @__PURE__ */ new Map();
+  for (const row of columnRows) {
+    const table = tables.get(row.table_name) ?? {
+      name: row.table_name,
+      columns: [],
+      primaryKey: [],
+      foreignKeys: [...foreignKeys.get(row.table_name)?.values() ?? []],
+      approxRowCount: rowCounts.get(row.table_name) ?? 0
+    };
+    const isPrimaryKey = row.column_key === "PRI";
+    if (isPrimaryKey) {
+      table.primaryKey.push(row.column_name);
+    }
+    const column = {
+      name: row.column_name,
+      dataType: row.data_type,
+      kind: classifyMysqlType(row.data_type),
+      nullable: row.is_nullable === "YES",
+      isPrimaryKey,
+      hasDefault: row.column_default !== null || row.extra.includes("auto_increment")
+    };
+    table.columns.push(column);
+    tables.set(row.table_name, table);
+  }
+  return { tables: [...tables.values()] };
+}
+
+// src/adapters/mysql.ts
+var MysqlAdapter = class {
+  dialect = "mysql";
+  database;
+  options;
+  pool = null;
+  sessionConnection = null;
+  transactionOpen = false;
+  constructor(options) {
+    this.options = options;
+    this.database = options.database;
+  }
+  async connect() {
+    const mysql = await import("mysql2/promise");
+    const config = {
+      host: this.options.host,
+      port: this.options.port,
+      database: this.options.database,
+      user: this.options.user,
+      password: this.options.password ?? void 0,
+      ssl: this.options.ssl ? { rejectUnauthorized: false } : void 0,
+      connectionLimit: 3
+    };
+    try {
+      this.pool = mysql.createPool(config);
+      this.sessionConnection = await mysql.createConnection(config);
+      await this.pool.query("SELECT 1");
+    } catch (error) {
+      await this.close();
+      throw new ConnectionError(
+        `Could not connect to mysql://${this.options.user}@${this.options.host}:${this.options.port}/${this.options.database}: ${error.message}`
+      );
+    }
+  }
+  async query(sql, params = []) {
+    if (!this.pool) {
+      throw new ConnectionError("Not connected");
+    }
+    return this.run(() => this.pool.query(sql, params), sql);
+  }
+  async sessionQuery(sql, params = []) {
+    if (!this.sessionConnection) {
+      throw new ConnectionError("Not connected");
+    }
+    const result = await this.run(() => this.sessionConnection.query(sql, params), sql);
+    this.transactionOpen = trackTransactionState(sql, this.transactionOpen);
+    return result;
+  }
+  async run(execute, sql) {
+    const started = performance.now();
+    let rows;
+    let fields;
+    try {
+      [rows, fields] = await execute();
+    } catch (error) {
+      throw new ExecutionError(error.message);
+    }
+    const durationMs = Math.round(performance.now() - started);
+    const command = sql.trim().split(/\s+/)[0]?.toUpperCase() ?? "";
+    if (Array.isArray(rows)) {
+      const fieldNames = Array.isArray(fields) ? fields.map((field) => field.name) : [];
+      return {
+        columns: fieldNames,
+        rows,
+        rowCount: rows.length,
+        durationMs,
+        command
+      };
+    }
+    return {
+      columns: [],
+      rows: [],
+      rowCount: rows?.affectedRows ?? 0,
+      durationMs,
+      command
+    };
+  }
+  async introspect() {
+    const [columns, foreignKeys, rowCounts] = await Promise.all([
+      this.query(mysqlColumnsQuery),
+      this.query(mysqlForeignKeysQuery),
+      this.query(mysqlRowCountsQuery)
+    ]);
+    return assembleMysqlSchema(
+      columns.rows,
+      foreignKeys.rows,
+      rowCounts.rows
+    );
+  }
+  inTransaction() {
+    return this.transactionOpen;
+  }
+  async close() {
+    if (this.sessionConnection) {
+      try {
+        await this.sessionConnection.end();
+      } catch {
+      }
+      this.sessionConnection = null;
+    }
+    if (this.pool) {
+      try {
+        await this.pool.end();
+      } catch {
+      }
+      this.pool = null;
+    }
+    this.transactionOpen = false;
+  }
+};
+export {
+  MysqlAdapter
+};

package/dist/profiles-4QGMCJAO.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import {
+  plainTable
+} from "./chunk-7WNCISNV.js";
+import {
+  deleteProfile,
+  listProfiles,
+  saveProfile
+} from "./chunk-3QAR6XBK.js";
+import "./chunk-VFC3HWTF.js";
+
+// src/commands/profiles.ts
+import pc from "picocolors";
+function runProfilesList() {
+  const profiles = listProfiles();
+  if (profiles.length === 0) {
+    console.log(pc.dim("No saved profiles. Add one with: midql profiles add <name> ..."));
+    return;
+  }
+  const rows = profiles.map((profile) => [
+    profile.name,
+    profile.dialect,
+    `${profile.user}@${profile.host}:${profile.port}/${profile.database}`,
+    profile.env,
+    profile.readonly ? "read-only" : "read-write",
+    profile.encryptedPassword ? "stored (encrypted)" : profile.passwordEnv ? `env:${profile.passwordEnv}` : "none"
+  ]);
+  console.log(plainTable(["name", "dialect", "target", "env", "mode", "password"], rows));
+}
+function runProfilesAdd(name, options) {
+  if (options.dialect !== "postgres" && options.dialect !== "mysql") {
+    console.error(pc.red(`Invalid dialect "${options.dialect}"; use postgres or mysql.`));
+    return 1;
+  }
+  const env = ["dev", "staging", "prod"].includes(options.env) ? options.env : "dev";
+  const profile = {
+    name,
+    dialect: options.dialect,
+    host: options.host,
+    port: options.port ? Number(options.port) : options.dialect === "postgres" ? 5432 : 3306,
+    database: options.database,
+    user: options.user,
+    encryptedPassword: null,
+    passwordEnv: options.passwordEnv ?? null,
+    env,
+    readonly: options.readonly,
+    ssl: options.ssl
+  };
+  saveProfile(profile, options.password);
+  console.log(pc.green(`Profile "${name}" saved.`));
+  if (options.password) {
+    console.log(
+      pc.dim("Password stored encrypted in ~/.midql/config.json (key in ~/.midql/.key).")
+    );
+  }
+  return 0;
+}
+function runProfilesRemove(name) {
+  deleteProfile(name);
+  console.log(pc.green(`Profile "${name}" removed.`));
+  return 0;
+}
+export {
+  runProfilesAdd,
+  runProfilesList,
+  runProfilesRemove
+};