midql-cli 0.1.0

package/dist/chunk-3CIK5I4M.js

@@ -0,0 +1,396 @@
+#!/usr/bin/env node
+import {
+  getProfile,
+  resolvePassword
+} from "./chunk-3QAR6XBK.js";
+import {
+  trackTransactionState
+} from "./chunk-PXDMSYWH.js";
+import {
+  ConnectionError,
+  ExecutionError
+} from "./chunk-VFC3HWTF.js";
+
+// src/adapters/introspect/postgres.ts
+var columnsQuery = `
+SELECT c.table_name, c.column_name, c.data_type, c.is_nullable, c.column_default
+FROM information_schema.columns c
+JOIN information_schema.tables t
+  ON t.table_schema = c.table_schema AND t.table_name = c.table_name
+WHERE c.table_schema = 'public' AND t.table_type = 'BASE TABLE'
+ORDER BY c.table_name, c.ordinal_position`;
+var primaryKeysQuery = `
+SELECT rel.relname AS table_name, att.attname AS column_name
+FROM pg_constraint con
+JOIN pg_class rel ON rel.oid = con.conrelid
+JOIN pg_namespace nsp ON nsp.oid = rel.relnamespace
+JOIN unnest(con.conkey) WITH ORDINALITY AS cols(attnum, ord) ON true
+JOIN pg_attribute att ON att.attrelid = rel.oid AND att.attnum = cols.attnum
+WHERE con.contype = 'p' AND nsp.nspname = 'public'
+ORDER BY rel.relname, cols.ord`;
+var foreignKeysQuery = `
+SELECT
+  con.conname AS constraint_name,
+  rel.relname AS table_name,
+  att.attname AS column_name,
+  frel.relname AS referenced_table,
+  fatt.attname AS referenced_column,
+  cols.ord
+FROM pg_constraint con
+JOIN pg_class rel ON rel.oid = con.conrelid
+JOIN pg_class frel ON frel.oid = con.confrelid
+JOIN pg_namespace nsp ON nsp.oid = rel.relnamespace
+JOIN unnest(con.conkey) WITH ORDINALITY AS cols(attnum, ord) ON true
+JOIN unnest(con.confkey) WITH ORDINALITY AS fcols(attnum, ord) ON fcols.ord = cols.ord
+JOIN pg_attribute att ON att.attrelid = rel.oid AND att.attnum = cols.attnum
+JOIN pg_attribute fatt ON fatt.attrelid = frel.oid AND fatt.attnum = fcols.attnum
+WHERE con.contype = 'f' AND nsp.nspname = 'public'
+ORDER BY rel.relname, con.conname, cols.ord`;
+var rowCountsQuery = `
+SELECT relname AS table_name, GREATEST(reltuples, 0)::bigint AS approx_rows
+FROM pg_class rel
+JOIN pg_namespace nsp ON nsp.oid = rel.relnamespace
+WHERE nsp.nspname = 'public' AND rel.relkind = 'r'`;
+function classifyPostgresType(dataType) {
+  const type = dataType.toLowerCase();
+  if (type.includes("int") || type.includes("numeric") || type.includes("decimal")) {
+    return "number";
+  }
+  if (type.includes("double") || type.includes("real") || type.includes("money") || type.includes("serial")) {
+    return "number";
+  }
+  if (type.includes("bool")) {
+    return "boolean";
+  }
+  if (type.includes("timestamp") || type.includes("date") || type.includes("time")) {
+    return "date";
+  }
+  if (type.includes("json")) {
+    return "json";
+  }
+  if (type.includes("uuid")) {
+    return "uuid";
+  }
+  if (type.includes("char") || type.includes("text") || type.includes("citext")) {
+    return "text";
+  }
+  return "other";
+}
+function assembleSchema(columnRows, primaryKeyRows, foreignKeyRows, rowCountRows) {
+  const primaryKeys = /* @__PURE__ */ new Map();
+  for (const row of primaryKeyRows) {
+    const existing = primaryKeys.get(row.table_name) ?? [];
+    existing.push(row.column_name);
+    primaryKeys.set(row.table_name, existing);
+  }
+  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 pk = primaryKeys.get(row.table_name) ?? [];
+    const table = tables.get(row.table_name) ?? {
+      name: row.table_name,
+      columns: [],
+      primaryKey: pk,
+      foreignKeys: [...foreignKeys.get(row.table_name)?.values() ?? []],
+      approxRowCount: rowCounts.get(row.table_name) ?? 0
+    };
+    const column = {
+      name: row.column_name,
+      dataType: row.data_type,
+      kind: classifyPostgresType(row.data_type),
+      nullable: row.is_nullable === "YES",
+      isPrimaryKey: pk.includes(row.column_name),
+      hasDefault: row.column_default !== null
+    };
+    table.columns.push(column);
+    tables.set(row.table_name, table);
+  }
+  return { tables: [...tables.values()] };
+}
+
+// src/adapters/postgres.ts
+var PostgresAdapter = class {
+  dialect = "postgres";
+  database;
+  options;
+  pool = null;
+  sessionClient = null;
+  transactionOpen = false;
+  constructor(options) {
+    this.options = options;
+    this.database = options.database;
+  }
+  async connect() {
+    const { Pool, Client } = (await import("pg")).default ?? await import("pg");
+    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,
+      max: 3
+    };
+    try {
+      this.pool = new Pool(config);
+      this.sessionClient = new Client(config);
+      await this.sessionClient.connect();
+      await this.pool.query("SELECT 1");
+    } catch (error) {
+      await this.close();
+      throw new ConnectionError(
+        `Could not connect to postgres://${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.sessionClient) {
+      throw new ConnectionError("Not connected");
+    }
+    const result = await this.run(
+      () => this.sessionClient.query(sql, params),
+      sql
+    );
+    this.transactionOpen = trackTransactionState(sql, this.transactionOpen);
+    return result;
+  }
+  async run(execute, sql) {
+    const started = performance.now();
+    let result;
+    try {
+      result = await execute();
+    } catch (error) {
+      throw new ExecutionError(error.message);
+    }
+    return {
+      columns: result.fields?.map((field) => field.name) ?? [],
+      rows: result.rows ?? [],
+      rowCount: result.rowCount ?? result.rows?.length ?? 0,
+      durationMs: Math.round(performance.now() - started),
+      command: result.command ?? sql.trim().split(/\s+/)[0]?.toUpperCase() ?? ""
+    };
+  }
+  async introspect() {
+    const [columns, primaryKeys, foreignKeys, rowCounts] = await Promise.all([
+      this.query(columnsQuery),
+      this.query(primaryKeysQuery),
+      this.query(foreignKeysQuery),
+      this.query(rowCountsQuery)
+    ]);
+    return assembleSchema(
+      columns.rows,
+      primaryKeys.rows,
+      foreignKeys.rows,
+      rowCounts.rows
+    );
+  }
+  inTransaction() {
+    return this.transactionOpen;
+  }
+  async close() {
+    if (this.sessionClient) {
+      try {
+        await this.sessionClient.end();
+      } catch {
+      }
+      this.sessionClient = null;
+    }
+    if (this.pool) {
+      try {
+        await this.pool.end();
+      } catch {
+      }
+      this.pool = null;
+    }
+    this.transactionOpen = false;
+  }
+};
+
+// src/connections/manager.ts
+function parseConnectionUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new ConnectionError(`Invalid connection URL: ${url}`);
+  }
+  const protocol = parsed.protocol.replace(":", "");
+  let dialect;
+  if (protocol === "postgres" || protocol === "postgresql") {
+    dialect = "postgres";
+  } else if (protocol === "mysql") {
+    dialect = "mysql";
+  } else {
+    throw new ConnectionError(`Unsupported protocol "${protocol}"; use postgres:// or mysql://`);
+  }
+  const database = parsed.pathname.replace(/^\//, "");
+  if (!database) {
+    throw new ConnectionError("Connection URL must include a database name");
+  }
+  return {
+    dialect,
+    options: {
+      host: parsed.hostname || "localhost",
+      port: parsed.port ? Number(parsed.port) : dialect === "postgres" ? 5432 : 3306,
+      database,
+      user: decodeURIComponent(parsed.username || "postgres"),
+      password: parsed.password ? decodeURIComponent(parsed.password) : null,
+      ssl: parsed.searchParams.get("ssl") === "true" || parsed.searchParams.get("sslmode") === "require"
+    },
+    env: "dev",
+    readonly: false
+  };
+}
+function targetFromProfile(profile) {
+  return {
+    dialect: profile.dialect,
+    options: {
+      host: profile.host,
+      port: profile.port,
+      database: profile.database,
+      user: profile.user,
+      password: resolvePassword(profile),
+      ssl: profile.ssl
+    },
+    env: profile.env,
+    readonly: profile.readonly
+  };
+}
+function resolveTarget(profileNameOrUrl) {
+  if (profileNameOrUrl.includes("://")) {
+    return parseConnectionUrl(profileNameOrUrl);
+  }
+  const profile = getProfile(profileNameOrUrl);
+  if (!profile) {
+    throw new ConnectionError(
+      `No saved profile named "${profileNameOrUrl}". Use a connection URL or save a profile first.`
+    );
+  }
+  return targetFromProfile(profile);
+}
+async function createAdapter(target) {
+  if (target.dialect === "postgres") {
+    return new PostgresAdapter(target.options);
+  }
+  const { MysqlAdapter } = await import("./mysql-GQSXUUEK.js");
+  return new MysqlAdapter(target.options);
+}
+var ConnectionManager = class {
+  connections = /* @__PURE__ */ new Map();
+  activeAlias = null;
+  async connect(profileNameOrUrl, alias) {
+    const target = resolveTarget(profileNameOrUrl);
+    const resolvedAlias = alias ?? this.defaultAlias(profileNameOrUrl, target);
+    if (this.connections.has(resolvedAlias)) {
+      throw new ConnectionError(
+        `Alias "${resolvedAlias}" is already connected; use \\use ${resolvedAlias} or pick another alias`
+      );
+    }
+    const adapter = await createAdapter(target);
+    await adapter.connect();
+    const schema = await adapter.introspect();
+    const connection = {
+      alias: resolvedAlias,
+      adapter,
+      dialect: target.dialect,
+      database: target.options.database,
+      env: target.env,
+      readonly: target.readonly,
+      schema,
+      schemaLoadedAt: Date.now(),
+      options: target.options
+    };
+    this.connections.set(resolvedAlias, connection);
+    this.activeAlias = resolvedAlias;
+    return connection;
+  }
+  defaultAlias(profileNameOrUrl, target) {
+    const base = profileNameOrUrl.includes("://") ? target.options.database : profileNameOrUrl;
+    if (!this.connections.has(base)) {
+      return base;
+    }
+    let suffix = 2;
+    while (this.connections.has(`${base}${suffix}`)) {
+      suffix += 1;
+    }
+    return `${base}${suffix}`;
+  }
+  use(alias) {
+    const connection = this.connections.get(alias);
+    if (!connection) {
+      throw new ConnectionError(`No connection with alias "${alias}"`);
+    }
+    this.activeAlias = alias;
+    return connection;
+  }
+  async disconnect(alias) {
+    const connection = this.connections.get(alias);
+    if (!connection) {
+      throw new ConnectionError(`No connection with alias "${alias}"`);
+    }
+    await connection.adapter.close();
+    this.connections.delete(alias);
+    if (this.activeAlias === alias) {
+      this.activeAlias = this.connections.keys().next().value ?? null;
+    }
+  }
+  list() {
+    return [...this.connections.values()];
+  }
+  active() {
+    if (!this.activeAlias) {
+      return null;
+    }
+    return this.connections.get(this.activeAlias) ?? null;
+  }
+  async refreshSchema(alias) {
+    const connection = alias ? this.connections.get(alias) : this.active();
+    if (!connection) {
+      throw new ConnectionError("No active connection");
+    }
+    connection.schema = await connection.adapter.introspect();
+    connection.schemaLoadedAt = Date.now();
+    return connection;
+  }
+  setReadonly(readonly) {
+    const connection = this.active();
+    if (!connection) {
+      throw new ConnectionError("No active connection");
+    }
+    connection.readonly = readonly;
+    return connection;
+  }
+  async closeAll() {
+    await Promise.all(this.list().map((connection) => connection.adapter.close()));
+    this.connections.clear();
+    this.activeAlias = null;
+  }
+};
+
+export {
+  PostgresAdapter,
+  resolveTarget,
+  ConnectionManager
+};

package/dist/chunk-3FPZQHHV.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+import {
+  findTool,
+  runTool
+} from "./chunk-NCN3ZBOJ.js";
+import {
+  ExecutionError
+} from "./chunk-VFC3HWTF.js";
+
+// src/backup/restore.ts
+import { existsSync } from "fs";
+async function restoreDatabase(dialect, options, file, tools) {
+  if (!existsSync(file)) {
+    throw new ExecutionError(`Backup file not found: ${file}`);
+  }
+  if (dialect === "postgres") {
+    await restorePostgres(options, file, tools);
+  } else {
+    await restoreMysql(options, file, tools);
+  }
+}
+async function restorePostgres(options, file, tools) {
+  const env = { PGPASSWORD: options.password ?? void 0 };
+  const connectionArgs = [
+    "--no-password",
+    "-h",
+    options.host,
+    "-p",
+    String(options.port),
+    "-U",
+    options.user,
+    "-d",
+    options.database
+  ];
+  if (file.endsWith(".sql")) {
+    const binary2 = await findTool("psql", tools.psqlPath);
+    const run2 = await runTool(binary2, [...connectionArgs, "-f", file], env, {});
+    if (run2.code !== 0) {
+      throw new ExecutionError(
+        `psql restore failed: ${run2.stderr.trim() || `exit code ${run2.code}`}`
+      );
+    }
+    return;
+  }
+  const binary = await findTool("pg_restore", tools.pgRestorePath);
+  const run = await runTool(binary, [...connectionArgs, "--clean", "--if-exists", file], env, {});
+  if (run.code !== 0) {
+    throw new ExecutionError(`pg_restore failed: ${run.stderr.trim() || `exit code ${run.code}`}`);
+  }
+}
+async function restoreMysql(options, file, tools) {
+  const binary = await findTool("mysql", tools.mysqlPath);
+  const args = [
+    "-h",
+    options.host,
+    "-P",
+    String(options.port),
+    "-u",
+    options.user,
+    options.database
+  ];
+  const run = await runTool(
+    binary,
+    args,
+    { MYSQL_PWD: options.password ?? void 0 },
+    { fromFile: file }
+  );
+  if (run.code !== 0) {
+    throw new ExecutionError(
+      `mysql restore failed: ${run.stderr.trim() || `exit code ${run.code}`}`
+    );
+  }
+}
+
+export {
+  restoreDatabase
+};

package/dist/chunk-3QAR6XBK.js

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+import {
+  ConfigError
+} from "./chunk-VFC3HWTF.js";
+
+// src/config/config.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+
+// src/config/paths.ts
+import { mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function configDir() {
+  return process.env.MIDQL_HOME ?? join(homedir(), ".midql");
+}
+function configFilePath() {
+  return join(configDir(), "config.json");
+}
+function keyFilePath() {
+  return join(configDir(), ".key");
+}
+function historyFilePath() {
+  return join(configDir(), "history.jsonl");
+}
+function ensureConfigDir() {
+  const dir = configDir();
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+// src/config/config.ts
+var defaultTools = {
+  pgDumpPath: null,
+  pgRestorePath: null,
+  psqlPath: null,
+  mysqldumpPath: null,
+  mysqlPath: null
+};
+function defaultConfig() {
+  return {
+    profiles: [],
+    safety: "on",
+    maxJoinDepth: 3,
+    tools: { ...defaultTools }
+  };
+}
+var environmentTags = ["dev", "staging", "prod"];
+function validateProfile(raw, index) {
+  if (typeof raw !== "object" || raw === null) {
+    throw new ConfigError(`Profile at index ${index} is not an object`);
+  }
+  const p = raw;
+  if (typeof p.name !== "string" || p.name.length === 0) {
+    throw new ConfigError(`Profile at index ${index} is missing a name`);
+  }
+  if (p.dialect !== "postgres" && p.dialect !== "mysql") {
+    throw new ConfigError(`Profile "${p.name}" has invalid dialect "${String(p.dialect)}"`);
+  }
+  if (typeof p.host !== "string" || typeof p.database !== "string" || typeof p.user !== "string") {
+    throw new ConfigError(`Profile "${p.name}" is missing host, database, or user`);
+  }
+  const env = environmentTags.includes(p.env) ? p.env : "dev";
+  return {
+    name: p.name,
+    dialect: p.dialect,
+    host: p.host,
+    port: typeof p.port === "number" ? p.port : p.dialect === "postgres" ? 5432 : 3306,
+    database: p.database,
+    user: p.user,
+    encryptedPassword: typeof p.encryptedPassword === "string" ? p.encryptedPassword : null,
+    passwordEnv: typeof p.passwordEnv === "string" ? p.passwordEnv : null,
+    env,
+    readonly: p.readonly === true,
+    ssl: p.ssl === true
+  };
+}
+function loadConfig() {
+  const path = configFilePath();
+  if (!existsSync(path)) {
+    return defaultConfig();
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    throw new ConfigError(`Failed to parse ${path}: ${error.message}`);
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new ConfigError(`${path} must contain a JSON object`);
+  }
+  const raw = parsed;
+  const profiles = Array.isArray(raw.profiles) ? raw.profiles.map((entry, index) => validateProfile(entry, index)) : [];
+  const tools = typeof raw.tools === "object" && raw.tools !== null ? { ...defaultTools, ...raw.tools } : { ...defaultTools };
+  return {
+    profiles,
+    safety: raw.safety === "off" ? "off" : "on",
+    maxJoinDepth: typeof raw.maxJoinDepth === "number" ? raw.maxJoinDepth : 3,
+    tools
+  };
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  writeFileSync(configFilePath(), `${JSON.stringify(config, null, 2)}
+`, "utf8");
+}
+
+// src/connections/secrets.ts
+import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
+import { chmodSync, existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+var KEY_LENGTH = 32;
+var IV_LENGTH = 12;
+function loadOrCreateKey() {
+  const path = keyFilePath();
+  if (existsSync2(path)) {
+    const key2 = Buffer.from(readFileSync2(path, "utf8").trim(), "base64");
+    if (key2.length !== KEY_LENGTH) {
+      throw new ConfigError(`Key file ${path} is corrupted; delete it to generate a new key`);
+    }
+    return key2;
+  }
+  ensureConfigDir();
+  const key = randomBytes(KEY_LENGTH);
+  writeFileSync2(path, key.toString("base64"), { mode: 384 });
+  try {
+    chmodSync(path, 384);
+  } catch {
+  }
+  return key;
+}
+function encryptSecret(plaintext) {
+  const key = loadOrCreateKey();
+  const iv = randomBytes(IV_LENGTH);
+  const cipher = createCipheriv("aes-256-gcm", key, iv);
+  const encrypted = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return Buffer.concat([iv, tag, encrypted]).toString("base64");
+}
+function decryptSecret(payload) {
+  const key = loadOrCreateKey();
+  const raw = Buffer.from(payload, "base64");
+  const iv = raw.subarray(0, IV_LENGTH);
+  const tag = raw.subarray(IV_LENGTH, IV_LENGTH + 16);
+  const encrypted = raw.subarray(IV_LENGTH + 16);
+  const decipher = createDecipheriv("aes-256-gcm", key, iv);
+  decipher.setAuthTag(tag);
+  return Buffer.concat([decipher.update(encrypted), decipher.final()]).toString("utf8");
+}
+
+// src/connections/profiles.ts
+function listProfiles() {
+  return loadConfig().profiles;
+}
+function getProfile(name) {
+  return loadConfig().profiles.find((profile) => profile.name === name) ?? null;
+}
+function saveProfile(profile, password) {
+  const config = loadConfig();
+  const stored = {
+    ...profile,
+    encryptedPassword: password ? encryptSecret(password) : profile.encryptedPassword
+  };
+  const index = config.profiles.findIndex((existing) => existing.name === profile.name);
+  if (index >= 0) {
+    config.profiles[index] = stored;
+  } else {
+    config.profiles.push(stored);
+  }
+  saveConfig(config);
+}
+function deleteProfile(name) {
+  const config = loadConfig();
+  const index = config.profiles.findIndex((profile) => profile.name === name);
+  if (index < 0) {
+    throw new ConfigError(`Profile "${name}" not found`);
+  }
+  config.profiles.splice(index, 1);
+  saveConfig(config);
+}
+function resolvePassword(profile) {
+  if (profile.passwordEnv) {
+    const value = process.env[profile.passwordEnv];
+    if (value) {
+      return value;
+    }
+  }
+  if (profile.encryptedPassword) {
+    return decryptSecret(profile.encryptedPassword);
+  }
+  return null;
+}
+
+export {
+  historyFilePath,
+  loadConfig,
+  listProfiles,
+  getProfile,
+  saveProfile,
+  deleteProfile,
+  resolvePassword
+};