midql-cli 0.1.0

package/dist/chunk-7WNCISNV.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+
+// src/repl/format.ts
+import Table from "cli-table3";
+import pc from "picocolors";
+var MAX_ROWS_SHOWN = 50;
+var ROW_LIMIT_BEFORE_TRUNCATION = 200;
+var MAX_CELL_WIDTH = 40;
+function formatCell(value) {
+  if (value === null || value === void 0) {
+    return pc.dim("\u2205");
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  const text = String(value);
+  if (text.length > MAX_CELL_WIDTH) {
+    return `${text.slice(0, MAX_CELL_WIDTH - 1)}\u2026`;
+  }
+  return text;
+}
+function plainTable(head, rows) {
+  const table = new Table({
+    head: head.map((column) => pc.cyan(column)),
+    style: { head: [], border: [] }
+  });
+  for (const row of rows) {
+    table.push(row);
+  }
+  return table.toString();
+}
+function describeTable(table) {
+  const rows = table.columns.map((column) => {
+    const flags = [];
+    if (column.isPrimaryKey) {
+      flags.push("PK");
+    }
+    for (const fk of table.foreignKeys) {
+      const index = fk.columns.indexOf(column.name);
+      if (index >= 0) {
+        flags.push(`FK \u2192 ${fk.referencedTable}.${fk.referencedColumns[index]}`);
+      }
+    }
+    return [
+      column.name,
+      column.dataType,
+      column.nullable ? "yes" : "no",
+      column.hasDefault ? "yes" : "no",
+      flags.join(", ")
+    ];
+  });
+  return plainTable(["column", "type", "nullable", "default", "keys"], rows);
+}
+function formatTableList(schema) {
+  const rows = schema.tables.map((table) => [
+    table.name,
+    String(table.columns.length),
+    `~${table.approxRowCount}`
+  ]);
+  return plainTable(["table", "columns", "rows"], rows);
+}
+function formatResultSet(result) {
+  if (result.columns.length === 0) {
+    const verb = result.command || "OK";
+    return pc.green(
+      `${verb} \xB7 ${result.rowCount} row${result.rowCount === 1 ? "" : "s"} affected \xB7 ${result.durationMs}ms`
+    );
+  }
+  if (result.rows.length === 0) {
+    return pc.dim(`(no rows) \xB7 ${result.durationMs}ms`);
+  }
+  const truncate = result.rows.length > ROW_LIMIT_BEFORE_TRUNCATION;
+  const shown = truncate ? result.rows.slice(0, MAX_ROWS_SHOWN) : result.rows;
+  const table = new Table({
+    head: result.columns.map((column) => pc.cyan(column)),
+    style: { head: [], border: [] },
+    wordWrap: true
+  });
+  for (const row of shown) {
+    table.push(result.columns.map((column) => formatCell(row[column])));
+  }
+  const lines = [table.toString()];
+  if (truncate) {
+    lines.push(
+      pc.yellow(
+        `\u2026 showing first ${MAX_ROWS_SHOWN} of ${result.rows.length} rows (add 'first N' or use \\export)`
+      )
+    );
+  }
+  lines.push(
+    pc.dim(
+      `${result.rows.length} row${result.rows.length === 1 ? "" : "s"} \xB7 ${result.durationMs}ms`
+    )
+  );
+  return lines.join("\n");
+}
+
+export {
+  plainTable,
+  describeTable,
+  formatTableList,
+  formatResultSet
+};

package/dist/chunk-ATZPL4EX.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+// src/safety/preview.ts
+var SAMPLE_SIZE = 10;
+function previewSelect(ast) {
+  return {
+    kind: "select",
+    table: ast.table,
+    columns: "*",
+    aggregate: null,
+    joins: ast.joins,
+    where: ast.where,
+    orderBy: [],
+    limit: SAMPLE_SIZE,
+    offset: null
+  };
+}
+function countSelect(ast) {
+  return {
+    kind: "select",
+    table: ast.table,
+    columns: "*",
+    aggregate: { fn: "count", column: null },
+    joins: ast.joins,
+    where: ast.where,
+    orderBy: [],
+    limit: null,
+    offset: null
+  };
+}
+
+export {
+  previewSelect,
+  countSelect
+};

package/dist/chunk-BAAEZXFH.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+import {
+  findTool,
+  runTool
+} from "./chunk-NCN3ZBOJ.js";
+import {
+  ExecutionError
+} from "./chunk-VFC3HWTF.js";
+
+// src/backup/dump.ts
+import { statSync } from "fs";
+function defaultBackupFile(database, dialect, format) {
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:T]/g, "-").slice(0, 19);
+  const extension = dialect === "postgres" && format === "custom" ? "dump" : "sql";
+  return `midql-${database}-${stamp}.${extension}`;
+}
+async function backupDatabase(dialect, options, file, format, tools) {
+  if (dialect === "postgres") {
+    await backupPostgres(options, file, format, tools);
+  } else {
+    await backupMysql(options, file, tools);
+  }
+  return { file, sizeBytes: statSync(file).size };
+}
+async function backupPostgres(options, file, format, tools) {
+  const binary = await findTool("pg_dump", tools.pgDumpPath);
+  const args = [
+    format === "custom" ? "-Fc" : "-Fp",
+    "--no-password",
+    "-h",
+    options.host,
+    "-p",
+    String(options.port),
+    "-U",
+    options.user,
+    "-d",
+    options.database,
+    "-f",
+    file
+  ];
+  const run = await runTool(binary, args, { PGPASSWORD: options.password ?? void 0 }, {});
+  if (run.code !== 0) {
+    throw new ExecutionError(`pg_dump failed: ${run.stderr.trim() || `exit code ${run.code}`}`);
+  }
+}
+async function backupMysql(options, file, tools) {
+  const binary = await findTool("mysqldump", tools.mysqldumpPath);
+  const args = [
+    "--single-transaction",
+    "--routines",
+    "-h",
+    options.host,
+    "-P",
+    String(options.port),
+    "-u",
+    options.user,
+    options.database
+  ];
+  const run = await runTool(
+    binary,
+    args,
+    { MYSQL_PWD: options.password ?? void 0 },
+    { toFile: file }
+  );
+  if (run.code !== 0) {
+    throw new ExecutionError(`mysqldump failed: ${run.stderr.trim() || `exit code ${run.code}`}`);
+  }
+}
+
+export {
+  defaultBackupFile,
+  backupDatabase
+};

package/dist/chunk-GWY47EDH.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+// src/export/json.ts
+function toJson(result) {
+  return `${JSON.stringify(result.rows, null, 2)}
+`;
+}
+
+export {
+  toJson
+};

package/dist/chunk-NCN3ZBOJ.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+import {
+  ToolNotFoundError
+} from "./chunk-VFC3HWTF.js";
+
+// src/backup/tools.ts
+import { spawn } from "child_process";
+import { existsSync, readdirSync } from "fs";
+import { join } from "path";
+var installHints = {
+  pg_dump: "Install PostgreSQL client tools (winget install PostgreSQL.PostgreSQL / apt install postgresql-client) or set tools.pgDumpPath in ~/.midql/config.json.",
+  pg_restore: "Install PostgreSQL client tools or set tools.pgRestorePath in ~/.midql/config.json.",
+  psql: "Install PostgreSQL client tools or set tools.psqlPath in ~/.midql/config.json.",
+  mysqldump: "Install MySQL client tools (winget install Oracle.MySQL / apt install mysql-client) or set tools.mysqldumpPath in ~/.midql/config.json.",
+  mysql: "Install MySQL client tools or set tools.mysqlPath in ~/.midql/config.json."
+};
+function windowsCandidates(tool) {
+  const roots = tool.startsWith("pg") || tool === "psql" ? ["C:\\Program Files\\PostgreSQL", "C:\\Program Files (x86)\\PostgreSQL"] : ["C:\\Program Files\\MySQL", "C:\\Program Files (x86)\\MySQL"];
+  const candidates = [];
+  for (const root of roots) {
+    if (!existsSync(root)) {
+      continue;
+    }
+    for (const version of readdirSync(root).sort().reverse()) {
+      const binary = join(root, version, "bin", `${tool}.exe`);
+      if (existsSync(binary)) {
+        candidates.push(binary);
+      }
+    }
+  }
+  return candidates;
+}
+async function isRunnable(command) {
+  return new Promise((resolve) => {
+    const child = spawn(command, ["--version"], { stdio: "ignore", shell: false });
+    child.on("error", () => resolve(false));
+    child.on("exit", (code) => resolve(code === 0));
+  });
+}
+async function findTool(tool, configuredPath) {
+  if (configuredPath) {
+    if (await isRunnable(configuredPath)) {
+      return configuredPath;
+    }
+    throw new ToolNotFoundError(tool, `Configured path "${configuredPath}" is not runnable.`);
+  }
+  if (await isRunnable(tool)) {
+    return tool;
+  }
+  if (process.platform === "win32") {
+    for (const candidate of windowsCandidates(tool)) {
+      if (await isRunnable(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  throw new ToolNotFoundError(
+    tool,
+    installHints[tool] ?? "Install it and make sure it is on PATH."
+  );
+}
+function runTool(command, args, env, stdio) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      env: { ...process.env, ...env },
+      stdio: ["pipe", "pipe", "pipe"],
+      shell: false
+    });
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    if (stdio.toFile) {
+      import("fs").then(({ createWriteStream }) => {
+        child.stdout?.pipe(createWriteStream(stdio.toFile));
+      });
+    }
+    if (stdio.fromFile) {
+      import("fs").then(({ createReadStream }) => {
+        createReadStream(stdio.fromFile).pipe(child.stdin);
+      });
+    } else {
+      child.stdin?.end();
+    }
+    child.on("error", reject);
+    child.on("exit", (code) => resolve({ code: code ?? 1, stderr }));
+  });
+}
+
+export {
+  findTool,
+  runTool
+};

package/dist/chunk-PXDMSYWH.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+// src/adapters/adapter.ts
+var beginPattern = /^\s*(begin|start\s+transaction)\b/i;
+var endPattern = /^\s*(commit|rollback|end)\b/i;
+function trackTransactionState(sql, current) {
+  if (beginPattern.test(sql)) {
+    return true;
+  }
+  if (endPattern.test(sql)) {
+    return false;
+  }
+  return current;
+}
+
+export {
+  trackTransactionState
+};

package/dist/chunk-TLTYYFT5.js

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+import {
+  ParseError
+} from "./chunk-VFC3HWTF.js";
+
+// src/sql/builder.ts
+var ParamCollector = class {
+  constructor(dialect) {
+    this.dialect = dialect;
+  }
+  dialect;
+  params = [];
+  add(value) {
+    this.params.push(value);
+    return this.dialect.placeholder(this.params.length);
+  }
+};
+function ref(column, dialect, qualify) {
+  if (!qualify) {
+    return dialect.quoteIdent(column.column);
+  }
+  return `${dialect.quoteIdent(column.table)}.${dialect.quoteIdent(column.column)}`;
+}
+function buildJoins(joins, dialect) {
+  return joins.map(
+    (join) => ` JOIN ${dialect.quoteIdent(join.table)} ON ${ref(join.leftColumn, dialect, true)} = ${ref(join.rightColumn, dialect, true)}`
+  ).join("");
+}
+function buildCondition(node, dialect, params, qualify) {
+  if (node.type === "group") {
+    const parts = node.items.map((item) => buildCondition(item, dialect, params, qualify));
+    return `(${parts.join(` ${node.combinator.toUpperCase()} `)})`;
+  }
+  const column = ref(node.column, dialect, qualify);
+  switch (node.operator) {
+    case "isNull":
+      return `${column} IS NULL`;
+    case "isNotNull":
+      return `${column} IS NOT NULL`;
+    case "between":
+      return `${column} BETWEEN ${params.add(node.values[0])} AND ${params.add(node.values[1])}`;
+    case "in":
+      return `${column} IN (${node.values.map((value) => params.add(value)).join(", ")})`;
+    case "ilike": {
+      const keyword = dialect.supportsIlike ? "ILIKE" : "LIKE";
+      return `${column} ${keyword} ${params.add(node.values[0])}`;
+    }
+    case "like":
+      return `${column} LIKE ${params.add(node.values[0])}`;
+    default:
+      return `${column} ${node.operator} ${params.add(node.values[0])}`;
+  }
+}
+function buildWhere(where, dialect, params, qualify) {
+  if (!where) {
+    return "";
+  }
+  const clause = buildCondition(where, dialect, params, qualify);
+  const trimmed = clause.startsWith("(") && clause.endsWith(")") ? clause.slice(1, -1) : clause;
+  return ` WHERE ${trimmed}`;
+}
+function buildSelect(ast, dialect) {
+  const params = new ParamCollector(dialect);
+  const qualify = ast.joins.length > 0;
+  let projection;
+  if (ast.aggregate) {
+    const fn = ast.aggregate.fn.toUpperCase();
+    projection = ast.aggregate.column ? `${fn}(${ref(ast.aggregate.column, dialect, qualify)})` : "COUNT(*)";
+  } else if (ast.columns === "*") {
+    projection = qualify ? `${dialect.quoteIdent(ast.table)}.*` : "*";
+  } else {
+    projection = ast.columns.map((column) => ref(column, dialect, qualify)).join(", ");
+  }
+  let sql = `SELECT ${projection} FROM ${dialect.quoteIdent(ast.table)}`;
+  sql += buildJoins(ast.joins, dialect);
+  sql += buildWhere(ast.where, dialect, params, qualify);
+  if (ast.orderBy.length > 0) {
+    const orderParts = ast.orderBy.map(
+      (order) => `${ref(order.column, dialect, qualify)} ${order.direction.toUpperCase()}`
+    );
+    sql += ` ORDER BY ${orderParts.join(", ")}`;
+  }
+  if (ast.limit !== null) {
+    sql += ` LIMIT ${Math.max(0, Math.floor(ast.limit))}`;
+  }
+  if (ast.offset !== null) {
+    sql += ` OFFSET ${Math.max(0, Math.floor(ast.offset))}`;
+  }
+  return { sql, params: params.params };
+}
+function buildInsert(ast, dialect) {
+  const params = new ParamCollector(dialect);
+  const columns = Object.keys(ast.values);
+  const columnList = columns.map((column) => dialect.quoteIdent(column)).join(", ");
+  const valueList = columns.map((column) => params.add(ast.values[column])).join(", ");
+  let sql = `INSERT INTO ${dialect.quoteIdent(ast.table)} (${columnList}) VALUES (${valueList})`;
+  if (dialect.supportsReturning) {
+    sql += " RETURNING *";
+  }
+  return { sql, params: params.params };
+}
+function subqueryFilter(table, keyColumn, joins, where, dialect, params) {
+  if (!keyColumn) {
+    throw new ParseError(
+      `"${table}" needs a primary key for cross-table updates or deletes; write the statement in raw SQL`
+    );
+  }
+  const key = dialect.quoteIdent(keyColumn);
+  const qualifiedKey = `${dialect.quoteIdent(table)}.${key}`;
+  let subquery = `SELECT ${qualifiedKey} FROM ${dialect.quoteIdent(table)}`;
+  subquery += buildJoins(joins, dialect);
+  subquery += buildWhere(where, dialect, params, true);
+  if (dialect.name === "mysql") {
+    return ` WHERE ${key} IN (SELECT ${key} FROM (${subquery}) AS midql_filter)`;
+  }
+  return ` WHERE ${key} IN (${subquery})`;
+}
+function buildUpdate(ast, dialect) {
+  const params = new ParamCollector(dialect);
+  const assignments = Object.entries(ast.set).map(([column, value]) => `${dialect.quoteIdent(column)} = ${params.add(value)}`).join(", ");
+  let sql = `UPDATE ${dialect.quoteIdent(ast.table)} SET ${assignments}`;
+  if (ast.joins.length > 0) {
+    sql += subqueryFilter(ast.table, ast.keyColumn, ast.joins, ast.where, dialect, params);
+  } else {
+    sql += buildWhere(ast.where, dialect, params, false);
+  }
+  return { sql, params: params.params };
+}
+function buildDelete(ast, dialect) {
+  const params = new ParamCollector(dialect);
+  let sql = `DELETE FROM ${dialect.quoteIdent(ast.table)}`;
+  if (ast.joins.length > 0) {
+    sql += subqueryFilter(ast.table, ast.keyColumn, ast.joins, ast.where, dialect, params);
+  } else {
+    sql += buildWhere(ast.where, dialect, params, false);
+  }
+  return { sql, params: params.params };
+}
+function buildCreateTable(ast, dialect) {
+  const definitions = ast.columns.map((column) => {
+    let definition = `${dialect.quoteIdent(column.name)} ${dialect.typeName(column.type)}`;
+    if (!column.nullable && column.type !== "serial") {
+      definition += " NOT NULL";
+    }
+    if (column.references) {
+      definition += ` REFERENCES ${dialect.quoteIdent(column.references.table)}(${dialect.quoteIdent(column.references.column)})`;
+    }
+    return definition;
+  });
+  return {
+    sql: `CREATE TABLE ${dialect.quoteIdent(ast.table)} (${definitions.join(", ")})`,
+    params: []
+  };
+}
+function buildDropTable(ast, dialect) {
+  return { sql: `DROP TABLE ${dialect.quoteIdent(ast.table)}`, params: [] };
+}
+function buildQuery(ast, dialect) {
+  switch (ast.kind) {
+    case "select":
+      return buildSelect(ast, dialect);
+    case "insert":
+      return buildInsert(ast, dialect);
+    case "update":
+      return buildUpdate(ast, dialect);
+    case "delete":
+      return buildDelete(ast, dialect);
+    case "createTable":
+      return buildCreateTable(ast, dialect);
+    case "dropTable":
+      return buildDropTable(ast, dialect);
+  }
+}
+
+// src/sql/dialect-mysql.ts
+var typeNames = {
+  text: "TEXT",
+  number: "INT",
+  decimal: "DECIMAL(12,2)",
+  boolean: "BOOLEAN",
+  date: "DATE",
+  timestamp: "DATETIME",
+  json: "JSON",
+  uuid: "CHAR(36)",
+  serial: "INT AUTO_INCREMENT PRIMARY KEY"
+};
+var mysqlDialect = {
+  name: "mysql",
+  quoteIdent(name) {
+    return `\`${name.replace(/`/g, "``")}\``;
+  },
+  placeholder() {
+    return "?";
+  },
+  supportsIlike: false,
+  supportsReturning: false,
+  typeName(type) {
+    return typeNames[type];
+  }
+};
+
+// src/sql/dialect-postgres.ts
+var typeNames2 = {
+  text: "TEXT",
+  number: "INTEGER",
+  decimal: "NUMERIC",
+  boolean: "BOOLEAN",
+  date: "DATE",
+  timestamp: "TIMESTAMPTZ",
+  json: "JSONB",
+  uuid: "UUID",
+  serial: "SERIAL PRIMARY KEY"
+};
+var postgresDialect = {
+  name: "postgres",
+  quoteIdent(name) {
+    return `"${name.replace(/"/g, '""')}"`;
+  },
+  placeholder(index) {
+    return `$${index}`;
+  },
+  supportsIlike: true,
+  supportsReturning: true,
+  typeName(type) {
+    return typeNames2[type];
+  }
+};
+
+// src/sql/dialects.ts
+function dialectFor(name) {
+  return name === "mysql" ? mysqlDialect : postgresDialect;
+}
+
+export {
+  buildQuery,
+  dialectFor
+};

package/dist/chunk-VFC3HWTF.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+// 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 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 {
+  MidqlError,
+  ParseError,
+  AmbiguityError,
+  ConnectionError,
+  ExecutionError,
+  ToolNotFoundError,
+  ConfigError
+};